tx · 8DdYYNN1NFHZnMENXsWG6SSXmQZLanCoKXPMp65CLgkv

3N9wLKKtDBphos7U3xzsPqgvJJ5zPQEU6pV:  -0.01300000 Waves

2023.07.06 11:26 [2653809] smart account 3N9wLKKtDBphos7U3xzsPqgvJJ5zPQEU6pV > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8DdYYNN1NFHZnMENXsWG6SSXmQZLanCoKXPMp65CLgkv",
    "fee": 1300000,
    "feeAssetId": null,
    "timestamp": 1688632023980,
    "version": 1,
    "sender": "3N9wLKKtDBphos7U3xzsPqgvJJ5zPQEU6pV",
    "senderPublicKey": "GKX7DbVJVEtTB6ak3PXWHNPUhC3jym3ozbtZ7a36rGu6",
    "proofs": [
        "3bSWydxWWbRtZqxGBoyfES3NqDDgwtjHMYwrC2gqY8iRfCU2Xgxzzsf8Lz64Hs2rNaimzexP8X1QEEBsUSLEYYwd"
    ],
    "script": "base64:BgIKCAISBgoEAgEBASwAA1NFUAICX18ADUNPTlRSQUNUX05BTUUCD2NhbGN1bGF0b3IucmlkZQAGU0NBTEU4AIDC1y8AB1BFTkRJTkcCB1BFTkRJTkcACEZJTklTSEVEAghGSU5JU0hFRAAFV0FWRVMCBVdBVkVTAQd3cmFwRXJyAQFzCQCsAgIJAKwCAgUNQ09OVFJBQ1RfTkFNRQICOiAFAXMBCHRocm93RXJyAQFzCQACAQkBB3dyYXBFcnIBBQFzAQ9hc3NldElkVG9TdHJpbmcBB2Fzc2V0SWQEByRtYXRjaDAFB2Fzc2V0SWQDCQABAgUHJG1hdGNoMAIKQnl0ZVZlY3RvcgQBYgUHJG1hdGNoMAkA2AQBBQFiAwkAAQIFByRtYXRjaDACBFVuaXQFBVdBVkVTCQACAQILTWF0Y2ggZXJyb3IBA2FicwEBbgMJAGYCAAAFAW4JAQEtAQUBbgUBbgERa2V5RmFjdG9yeUFkZHJlc3MACQC5CQIJAMwIAgICJXMJAMwIAgIHZmFjdG9yeQUDbmlsBQNTRVABE2tleU1hbmFnZXJQdWJsaWNLZXkACQC5CQIJAMwIAgICJXMJAMwIAgIQbWFuYWdlclB1YmxpY0tleQUDbmlsBQNTRVABDGtleUxwQXNzZXRJZAAJALkJAgkAzAgCAgIlcwkAzAgCAglscEFzc2V0SWQFA25pbAUDU0VQARdrZXlQcm94eVRyZWFzdXJ5QWRkcmVzcwAJALkJAgkAzAgCAgIlcwkAzAgCAg1wcm94eVRyZWFzdXJ5BQNuaWwFA1NFUAEWa2V5TWFpblRyZWFzdXJ5QWRkcmVzcwAJALkJAgkAzAgCAgIlcwkAzAgCAgxtYWluVHJlYXN1cnkFA25pbAUDU0VQAQtrZXlJbnZlc3RlZAEHYXNzZXRJZAkAuQkCCQDMCAICBCVzJXMJAMwIAgIIaW52ZXN0ZWQJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFB2Fzc2V0SWQFA25pbAUDU0VQAQprZXlEb25hdGVkAQdhc3NldElkCQC5CQIJAMwIAgIEJXMlcwkAzAgCAgdkb25hdGVkCQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBQdhc3NldElkBQNuaWwFA1NFUAEMa2V5QXZhaWxhYmxlAQt1c2VyQWRkcmVzcwkAuQkCCQDMCAICBCVzJXMJAMwIAgIJYXZhaWxhYmxlCQDMCAIJAKUIAQULdXNlckFkZHJlc3MFA25pbAUDU0VQAQprZXlDbGFpbWVkAQt1c2VyQWRkcmVzcwkAuQkCCQDMCAICBCVzJXMJAMwIAgIHY2xhaW1lZAkAzAgCCQClCAEFC3VzZXJBZGRyZXNzBQNuaWwFA1NFUAEQa2V5Q3VycmVudFBlcmlvZAAJALkJAgkAzAgCAgIlcwkAzAgCAg1jdXJyZW50UGVyaW9kBQNuaWwFA1NFUAERa2V5UHJpY2VGb3JQZXJpb2QBBnBlcmlvZAkAuQkCCQDMCAICBCVzJWQJAMwIAgIFcHJpY2UJAMwIAgkApAMBBQZwZXJpb2QFA25pbAUDU0VQAQ5rZXlTdGFydEhlaWdodAEGcGVyaW9kCQC5CQIJAMwIAgIEJXMlZAkAzAgCAgtzdGFydEhlaWdodAkAzAgCCQCkAwEFBnBlcmlvZAUDbmlsBQNTRVABFGtleVBvd2VyTWFuYWdlckJvbnVzAQZwZXJpb2QJALkJAgkAzAgCAgQlcyVkCQDMCAICEXBvd2VyTWFuYWdlckJvbnVzCQDMCAIJAKQDAQUGcGVyaW9kBQNuaWwFA1NFUAEPa2V5UGVyaW9kTGVuZ3RoAAIQJXNfX3BlcmlvZExlbmd0aAEYa2V5QmxvY2tQcm9jZXNzaW5nUmV3YXJkAAIZJXNfX2Jsb2NrUHJvY2Vzc2luZ1Jld2FyZAEVa2V5TmV4dEJsb2NrVG9Qcm9jZXNzAAIWJXNfX25leHRCbG9ja1RvUHJvY2VzcwERa2V5QmxvY2tQcm9jZXNzZWQBBmhlaWdodAkAuQkCCQDMCAICBCVzJWQJAMwIAgIOYmxvY2tQcm9jZXNzZWQJAMwIAgkApAMBBQZoZWlnaHQFA25pbAUDU0VQAQ1rZXlXaXRoZHJhd2FsAAIOJXNfX3dpdGhkcmF3YWwBFGtleVdpdGhkcmF3YWxSZXF1ZXN0Agt1c2VyQWRkcmVzcwR0eElkCQC5CQIJAMwIAgIGJXMlcyVzCQDMCAICCndpdGhkcmF3YWwJAMwIAgkApQgBBQt1c2VyQWRkcmVzcwkAzAgCCQDYBAEFBHR4SWQFA25pbAUDU0VQARZ2YWx1ZVdpdGhkcmF3YWxSZXF1ZXN0BAZzdGF0dXMNbHBBc3NldEFtb3VudAx0YXJnZXRQZXJpb2QJY2xhaW1UeElkBAxjbGFpbVR4SWRTdHIEByRtYXRjaDAFCWNsYWltVHhJZAMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBAFiBQckbWF0Y2gwCQDYBAEFAWIDCQABAgUHJG1hdGNoMAIEVW5pdAIEU09PTgkAAgECC01hdGNoIGVycm9yCQC5CQIJAMwIAgIIJXMlZCVkJXMJAMwIAgUGc3RhdHVzCQDMCAIJAKQDAQUNbHBBc3NldEFtb3VudAkAzAgCCQCkAwEFDHRhcmdldFBlcmlvZAkAzAgCBQxjbGFpbVR4SWRTdHIFA25pbAUDU0VQASFwYXJzZVdpdGhkcmF3YWxSZXF1ZXN0VmFsdWVPckZhaWwBAXMEBXBhcnRzCQC1CQIFAXMFA1NFUAMJAAACCQCQAwEFBXBhcnRzAAUEBnN0YXR1cwkAkQMCBQVwYXJ0cwABBA1scEFzc2V0QW1vdW50CQETdmFsdWVPckVycm9yTWVzc2FnZQIJALYJAQkAkQMCBQVwYXJ0cwACCQEHd3JhcEVycgECFWludmFsaWQgbHBBc3NldEFtb3VudAQMdGFyZ2V0UGVyaW9kCQETdmFsdWVPckVycm9yTWVzc2FnZQIJALYJAQkAkQMCBQVwYXJ0cwADCQEHd3JhcEVycgECFGludmFsaWQgdGFyZ2V0UGVyaW9kBAljbGFpbVR4SWQJAJEDAgUFcGFydHMABAkAlgoEBQZzdGF0dXMFDWxwQXNzZXRBbW91bnQFDHRhcmdldFBlcmlvZAUJY2xhaW1UeElkCQEIdGhyb3dFcnIBAiBpbnZhbGlkIHdpdGhkcmF3YWwgcmVxdWVzdCB2YWx1ZQAUZmFjdG9yeUFkZHJlc3NPcHRpb24EByRtYXRjaDAJAJ0IAgUEdGhpcwkBEWtleUZhY3RvcnlBZGRyZXNzAAMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAXMFByRtYXRjaDAJAKYIAQUBcwMJAAECBQckbWF0Y2gwAgRVbml0BQR1bml0CQACAQILTWF0Y2ggZXJyb3IAFGZhY3RvcnlBZGRyZXNzT3JGYWlsCQETdmFsdWVPckVycm9yTWVzc2FnZQIFFGZhY3RvcnlBZGRyZXNzT3B0aW9uCQEHd3JhcEVycgECF2ludmFsaWQgZmFjdG9yeSBhZGRyZXNzAA9scEFzc2V0SWRPcHRpb24EByRtYXRjaDAFFGZhY3RvcnlBZGRyZXNzT3B0aW9uAwkAAQIFByRtYXRjaDACB0FkZHJlc3MEAWEFByRtYXRjaDAEByRtYXRjaDEJAJ0IAgUBYQkBDGtleUxwQXNzZXRJZAADCQABAgUHJG1hdGNoMQIGU3RyaW5nBAFzBQckbWF0Y2gxCQDZBAEFAXMDCQABAgUHJG1hdGNoMQIEVW5pdAUEdW5pdAkAAgECC01hdGNoIGVycm9yAwkAAQIFByRtYXRjaDACBFVuaXQFBHVuaXQJAAIBAgtNYXRjaCBlcnJvcgAPbHBBc3NldElkT3JGYWlsCQETdmFsdWVPckVycm9yTWVzc2FnZQIFD2xwQXNzZXRJZE9wdGlvbgkBB3dyYXBFcnIBAhFpbnZhbGlkIGxwQXNzZXRJZAAacHJveHlUcmVhc3VyeUFkZHJlc3NPcHRpb24EByRtYXRjaDAFFGZhY3RvcnlBZGRyZXNzT3B0aW9uAwkAAQIFByRtYXRjaDACB0FkZHJlc3MEAWEFByRtYXRjaDAEByRtYXRjaDEJAJ0IAgUBYQkBF2tleVByb3h5VHJlYXN1cnlBZGRyZXNzAAMJAAECBQckbWF0Y2gxAgZTdHJpbmcEAXMFByRtYXRjaDEJAKYIAQUBcwMJAAECBQckbWF0Y2gxAgRVbml0BQR1bml0CQACAQILTWF0Y2ggZXJyb3IDCQABAgUHJG1hdGNoMAIEVW5pdAUEdW5pdAkAAgECC01hdGNoIGVycm9yABpwcm94eVRyZWFzdXJ5QWRkcmVzc09yRmFpbAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCBRpwcm94eVRyZWFzdXJ5QWRkcmVzc09wdGlvbgkBB3dyYXBFcnIBAh5pbnZhbGlkIHByb3h5IHRyZWFzdXJ5IGFkZHJlc3MAGW1haW5UcmVhc3VyeUFkZHJlc3NPcHRpb24EByRtYXRjaDAFFGZhY3RvcnlBZGRyZXNzT3B0aW9uAwkAAQIFByRtYXRjaDACB0FkZHJlc3MEAWEFByRtYXRjaDAEByRtYXRjaDEJAJ0IAgUBYQkBFmtleU1haW5UcmVhc3VyeUFkZHJlc3MAAwkAAQIFByRtYXRjaDECBlN0cmluZwQBcwUHJG1hdGNoMQkApggBBQFzAwkAAQIFByRtYXRjaDECBFVuaXQFBHVuaXQJAAIBAgtNYXRjaCBlcnJvcgMJAAECBQckbWF0Y2gwAgRVbml0BQR1bml0CQACAQILTWF0Y2ggZXJyb3IAGW1haW5UcmVhc3VyeUFkZHJlc3NPckZhaWwJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgUZbWFpblRyZWFzdXJ5QWRkcmVzc09wdGlvbgkBB3dyYXBFcnIBAh1pbnZhbGlkIG1haW4gdHJlYXN1cnkgYWRkcmVzcwEZZ2V0TWFuYWdlclB1YmxpY0tleU9yVW5pdAAEByRtYXRjaDAFFGZhY3RvcnlBZGRyZXNzT3B0aW9uAwkAAQIFByRtYXRjaDACB0FkZHJlc3MEAmZhBQckbWF0Y2gwBAckbWF0Y2gxCQCdCAIFAmZhCQETa2V5TWFuYWdlclB1YmxpY0tleQADCQABAgUHJG1hdGNoMQIGU3RyaW5nBANwdWIFByRtYXRjaDEJANkEAQUDcHViBQR1bml0BQR1bml0AQtvbmx5QWRkcmVzcwIBaQdhZGRyZXNzAwkAAAIIBQFpBmNhbGxlcgUHYWRkcmVzcwYJAQh0aHJvd0VycgECEXBlcm1pc3Npb24gZGVuaWVkAQtvbmx5RmFjdG9yeQEBaQkBC29ubHlBZGRyZXNzAgUBaQUUZmFjdG9yeUFkZHJlc3NPckZhaWwBD3Jld2FyZEZvck9wdGlvbgIHcmV3YXJkcwZ0YXJnZXQEAXMJAJADAQUHcmV3YXJkcwQLJHQwNDczNTQ3NjAJAJEDAgUHcmV3YXJkcwAABAJhMAgFCyR0MDQ3MzU0NzYwAl8xBAJyMAgFCyR0MDQ3MzU0NzYwAl8yBAskdDA0NzYzNDc4OAkAkQMCBQdyZXdhcmRzAAEEAmExCAULJHQwNDc2MzQ3ODgCXzEEAnIxCAULJHQwNDc2MzQ3ODgCXzIECyR0MDQ3OTE0ODE2CQCRAwIFB3Jld2FyZHMAAgQCYTIIBQskdDA0NzkxNDgxNgJfMQQCcjIIBQskdDA0NzkxNDgxNgJfMgMDCQBmAgUBcwAACQAAAgUCYTAFBnRhcmdldAcFAnIwAwMJAGYCBQFzAAEJAAACBQJhMQUGdGFyZ2V0BwUCcjEDAwkAZgIFAXMAAgkAAAIFAmEyBQZ0YXJnZXQHBQJyMgUEdW5pdAEQZmluYWxpemVJTlRFUk5BTAMYbmV3VHJlYXN1cnlWb2x1bWVJbldhdmVzF3B3ck1hbmFnZXJzQm9udXNJbldhdmVzIHRyZWFzdXJ5Vm9sdW1lRGlmZkFsbG9jYXRpb25Db2VmBBJkb25hdGVkV2F2ZXNBbW91bnQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUUZmFjdG9yeUFkZHJlc3NPckZhaWwJAQprZXlEb25hdGVkAQUEdW5pdAAABBNpbnZlc3RlZFdhdmVzQW1vdW50CQELdmFsdWVPckVsc2UCCQCaCAIFFGZhY3RvcnlBZGRyZXNzT3JGYWlsCQELa2V5SW52ZXN0ZWQBBQR1bml0AAAEHGN1cnJlbnRUcmVhc3VyeVZvbHVtZUluV2F2ZXMJAGQCBRJkb25hdGVkV2F2ZXNBbW91bnQFE2ludmVzdGVkV2F2ZXNBbW91bnQECXByb2ZpdFJhdwkAZQIFGG5ld1RyZWFzdXJ5Vm9sdW1lSW5XYXZlcwUcY3VycmVudFRyZWFzdXJ5Vm9sdW1lSW5XYXZlcwQWcHdyTWFuYWdlcnNCb251c0Ftb3VudAMDCQBmAgUJcHJvZml0UmF3AAAJAGcCBQlwcm9maXRSYXcFF3B3ck1hbmFnZXJzQm9udXNJbldhdmVzBwUXcHdyTWFuYWdlcnNCb251c0luV2F2ZXMJAQh0aHJvd0VycgECH3Bvd2VyIGJvbnVzIGlzIG1vcmUgdGhhbiBwcm9maXQEBnByb2ZpdAkAZQIFCXByb2ZpdFJhdwUWcHdyTWFuYWdlcnNCb251c0Ftb3VudAQMZG9uYXRpb25QYXJ0AwkAZgIFHGN1cnJlbnRUcmVhc3VyeVZvbHVtZUluV2F2ZXMAAAkAawMFEmRvbmF0ZWRXYXZlc0Ftb3VudAUGU0NBTEU4BRxjdXJyZW50VHJlYXN1cnlWb2x1bWVJbldhdmVzAAAEFWRvbmF0aW9uUHJvZml0UGFydFJhdwkAawMFBnByb2ZpdAUMZG9uYXRpb25QYXJ0BQZTQ0FMRTgEF2ludmVzdG1lbnRQcm9maXRQYXJ0UmF3CQBlAgUGcHJvZml0BRVkb25hdGlvblByb2ZpdFBhcnRSYXcEI3RyZWFzdXJ5Vm9sdW1lRGlmZkFsbG9jYXRpb25Db2VmQWJzCQEDYWJzAQUgdHJlYXN1cnlWb2x1bWVEaWZmQWxsb2NhdGlvbkNvZWYEEGFtb3VudFRvRG9uYXRpb24JAGsDBRdpbnZlc3RtZW50UHJvZml0UGFydFJhdwMJAGYCAAAFIHRyZWFzdXJ5Vm9sdW1lRGlmZkFsbG9jYXRpb25Db2VmBSN0cmVhc3VyeVZvbHVtZURpZmZBbGxvY2F0aW9uQ29lZkFicwAABQZTQ0FMRTgEEmFtb3VudFRvSW52ZXN0bWVudAkAawMFFWRvbmF0aW9uUHJvZml0UGFydFJhdwMJAGYCBSB0cmVhc3VyeVZvbHVtZURpZmZBbGxvY2F0aW9uQ29lZgAABSN0cmVhc3VyeVZvbHVtZURpZmZBbGxvY2F0aW9uQ29lZkFicwAABQZTQ0FMRTgEEmRvbmF0aW9uUHJvZml0UGFydAkAZAIJAGUCBRVkb25hdGlvblByb2ZpdFBhcnRSYXcFEmFtb3VudFRvSW52ZXN0bWVudAUQYW1vdW50VG9Eb25hdGlvbgQUaW52ZXN0bWVudFByb2ZpdFBhcnQJAGQCCQBlAgUXaW52ZXN0bWVudFByb2ZpdFBhcnRSYXcFEGFtb3VudFRvRG9uYXRpb24FEmFtb3VudFRvSW52ZXN0bWVudAQYZG9uYXRlZFdhdmVzQW1vdW50TmV3UmF3CQBkAgUSZG9uYXRlZFdhdmVzQW1vdW50BRJkb25hdGlvblByb2ZpdFBhcnQEGWludmVzdGVkV2F2ZXNBbW91bnROZXdSYXcJAGQCBRNpbnZlc3RlZFdhdmVzQW1vdW50BRRpbnZlc3RtZW50UHJvZml0UGFydAQPZG9uYXRlZFBhcnREZWJ0CQCXAwEJAMwIAgAACQDMCAIFGGRvbmF0ZWRXYXZlc0Ftb3VudE5ld1JhdwUDbmlsBBBpbnZlc3RlZFBhcnREZWJ0CQCXAwEJAMwIAgAACQDMCAIFGWludmVzdGVkV2F2ZXNBbW91bnROZXdSYXcFA25pbAQVZG9uYXRlZFdhdmVzQW1vdW50TmV3CQBkAgkAlgMBCQDMCAIAAAkAzAgCBRhkb25hdGVkV2F2ZXNBbW91bnROZXdSYXcFA25pbAUQaW52ZXN0ZWRQYXJ0RGVidAQWaW52ZXN0ZWRXYXZlc0Ftb3VudE5ldwkAZAIJAJYDAQkAzAgCAAAJAMwIAgUZaW52ZXN0ZWRXYXZlc0Ftb3VudE5ld1JhdwUDbmlsBQ9kb25hdGVkUGFydERlYnQED2xwQXNzZXRRdWFudGl0eQgJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkA7AcBBQ9scEFzc2V0SWRPckZhaWwJAQd3cmFwRXJyAQIUaW52YWxpZCBscEFzc2V0IGluZm8IcXVhbnRpdHkECG5ld1ByaWNlCQBrAwUWaW52ZXN0ZWRXYXZlc0Ftb3VudE5ldwUGU0NBTEU4BQ9scEFzc2V0UXVhbnRpdHkEE2NoZWNrSWZQcmljZU5vdFplcm8DCQECIT0CBQhuZXdQcmljZQAABgkBCHRocm93RXJyAQIUTFAgcHJpY2UgY2Fubm90IGJlIDADCQAAAgUTY2hlY2tJZlByaWNlTm90WmVybwUTY2hlY2tJZlByaWNlTm90WmVybwQTbHBBc3NldEFtb3VudFRvQnVybgkBC3ZhbHVlT3JFbHNlAgkAmggCBRRmYWN0b3J5QWRkcmVzc09yRmFpbAkBDWtleVdpdGhkcmF3YWwAAAAEEHBheW1lbnRBbW91bnRNaW4JAJYDAQkAzAgCAAAJAMwIAgkAawMFE2xwQXNzZXRBbW91bnRUb0J1cm4FCG5ld1ByaWNlBQZTQ0FMRTgFA25pbAQYZmluYWxJbnZlc3RlZFdhdmVzQW1vdW50CQBlAgUWaW52ZXN0ZWRXYXZlc0Ftb3VudE5ldwUQcGF5bWVudEFtb3VudE1pbgQUbHBBc3NldEZpbmFsUXVhbnRpdHkJAGUCBQ9scEFzc2V0UXVhbnRpdHkFE2xwQXNzZXRBbW91bnRUb0J1cm4JAJgKBgUQcGF5bWVudEFtb3VudE1pbgUYZmluYWxJbnZlc3RlZFdhdmVzQW1vdW50BRVkb25hdGVkV2F2ZXNBbW91bnROZXcFCG5ld1ByaWNlBRNscEFzc2V0QW1vdW50VG9CdXJuBRRscEFzc2V0RmluYWxRdWFudGl0eQkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgEBaQEIZmluYWxpemUEEHVzZXJBZGRyZXNzQnl0ZXMYbmV3VHJlYXN1cnlWb2x1bWVJbldhdmVzF3B3ck1hbmFnZXJzQm9udXNJbldhdmVzIHRyZWFzdXJ5Vm9sdW1lRGlmZkFsbG9jYXRpb25Db2VmBAtjaGVja0NhbGxlcgkBC29ubHlGYWN0b3J5AQUBaQMJAAACBQtjaGVja0NhbGxlcgULY2hlY2tDYWxsZXIEE2N1cnJlbnRQZXJpb2RPckZhaWwJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAmggCBRRmYWN0b3J5QWRkcmVzc09yRmFpbAkBEGtleUN1cnJlbnRQZXJpb2QACQEHd3JhcEVycgECDmludmFsaWQgcGVyaW9kBAxwZXJpb2RMZW5ndGgJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAmggCBRRmYWN0b3J5QWRkcmVzc09yRmFpbAkBD2tleVBlcmlvZExlbmd0aAAJAQd3cmFwRXJyAQIVaW52YWxpZCBwZXJpb2QgbGVuZ3RoBBJjdXJyZW50U3RhcnRIZWlnaHQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAmggCBRRmYWN0b3J5QWRkcmVzc09yRmFpbAkBDmtleVN0YXJ0SGVpZ2h0AQUTY3VycmVudFBlcmlvZE9yRmFpbAkBB3dyYXBFcnIBAhRpbnZhbGlkIHN0YXJ0IGhlaWdodAQSY3VycmVudFByaWNlT3JGYWlsCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUUZmFjdG9yeUFkZHJlc3NPckZhaWwJARFrZXlQcmljZUZvclBlcmlvZAEFE2N1cnJlbnRQZXJpb2RPckZhaWwJAQd3cmFwRXJyAQINaW52YWxpZCBwcmljZQQSbmV4dEJsb2NrVG9Qcm9jZXNzCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUUZmFjdG9yeUFkZHJlc3NPckZhaWwJARVrZXlOZXh0QmxvY2tUb1Byb2Nlc3MACQEHd3JhcEVycgECHWludmFsaWQgbmV4dCBibG9jayB0byBwcm9jZXNzBA9wZXJpb2RFbmRIZWlnaHQJAGUCCQBkAgUSY3VycmVudFN0YXJ0SGVpZ2h0BQxwZXJpb2RMZW5ndGgAAQQGY2hlY2tzCQDMCAIDCQAAAggFAWkMb3JpZ2luQ2FsbGVyBRltYWluVHJlYXN1cnlBZGRyZXNzT3JGYWlsBgkBCHRocm93RXJyAQIRcGVybWlzc2lvbiBkZW5pZWQJAMwIAgMJAGYCBRJuZXh0QmxvY2tUb1Byb2Nlc3MFD3BlcmlvZEVuZEhlaWdodAYJAQh0aHJvd0VycgECEnVucHJvY2Vzc2VkIGJsb2NrcwkAzAgCAwkAZwIFGG5ld1RyZWFzdXJ5Vm9sdW1lSW5XYXZlcwAABgkBCHRocm93RXJyAQIbaW52YWxpZCBuZXcgdHJlYXN1cnkgdm9sdW1lCQDMCAIDCQBnAgUXcHdyTWFuYWdlcnNCb251c0luV2F2ZXMAAAYJAQh0aHJvd0VycgECGmludmFsaWQgUFdSIG1hbmFnZXJzIGJvbnVzCQDMCAIDAwkAZwIFIHRyZWFzdXJ5Vm9sdW1lRGlmZkFsbG9jYXRpb25Db2VmCQEBLQEFBlNDQUxFOAkAZwIFBlNDQUxFOAUgdHJlYXN1cnlWb2x1bWVEaWZmQWxsb2NhdGlvbkNvZWYHBgkBCHRocm93RXJyAQIzaW52YWxpZCB0cmVhc3VyeSB2b2x1bWUgZGlmZiBhbGxvY2F0aW9uIGNvZWZmaWNpZW50BQNuaWwDCQAAAgUGY2hlY2tzBQZjaGVja3MEEmRvbmF0ZWRXYXZlc0Ftb3VudAkBC3ZhbHVlT3JFbHNlAgkAmggCBRRmYWN0b3J5QWRkcmVzc09yRmFpbAkBCmtleURvbmF0ZWQBBQR1bml0AAAEE2ludmVzdGVkV2F2ZXNBbW91bnQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUUZmFjdG9yeUFkZHJlc3NPckZhaWwJAQtrZXlJbnZlc3RlZAEFBHVuaXQAAAQcY3VycmVudFRyZWFzdXJ5Vm9sdW1lSW5XYXZlcwkAZAIFEmRvbmF0ZWRXYXZlc0Ftb3VudAUTaW52ZXN0ZWRXYXZlc0Ftb3VudAQJcHJvZml0UmF3CQBlAgUYbmV3VHJlYXN1cnlWb2x1bWVJbldhdmVzBRxjdXJyZW50VHJlYXN1cnlWb2x1bWVJbldhdmVzBBZwd3JNYW5hZ2Vyc0JvbnVzQW1vdW50AwMJAGYCBQlwcm9maXRSYXcAAAkAZwIFCXByb2ZpdFJhdwUXcHdyTWFuYWdlcnNCb251c0luV2F2ZXMHBRdwd3JNYW5hZ2Vyc0JvbnVzSW5XYXZlcwkBCHRocm93RXJyAQIfcG93ZXIgYm9udXMgaXMgbW9yZSB0aGFuIHByb2ZpdAQGcHJvZml0CQBlAgUJcHJvZml0UmF3BRZwd3JNYW5hZ2Vyc0JvbnVzQW1vdW50BAxkb25hdGlvblBhcnQDCQBmAgUcY3VycmVudFRyZWFzdXJ5Vm9sdW1lSW5XYXZlcwAACQBrAwUSZG9uYXRlZFdhdmVzQW1vdW50BQZTQ0FMRTgFHGN1cnJlbnRUcmVhc3VyeVZvbHVtZUluV2F2ZXMAAAQVZG9uYXRpb25Qcm9maXRQYXJ0UmF3CQBrAwUGcHJvZml0BQxkb25hdGlvblBhcnQFBlNDQUxFOAQXaW52ZXN0bWVudFByb2ZpdFBhcnRSYXcJAGUCBQZwcm9maXQFFWRvbmF0aW9uUHJvZml0UGFydFJhdwQjdHJlYXN1cnlWb2x1bWVEaWZmQWxsb2NhdGlvbkNvZWZBYnMJAQNhYnMBBSB0cmVhc3VyeVZvbHVtZURpZmZBbGxvY2F0aW9uQ29lZgQQYW1vdW50VG9Eb25hdGlvbgkAawMFF2ludmVzdG1lbnRQcm9maXRQYXJ0UmF3AwkAZgIAAAUgdHJlYXN1cnlWb2x1bWVEaWZmQWxsb2NhdGlvbkNvZWYFI3RyZWFzdXJ5Vm9sdW1lRGlmZkFsbG9jYXRpb25Db2VmQWJzAAAFBlNDQUxFOAQSYW1vdW50VG9JbnZlc3RtZW50CQBrAwUVZG9uYXRpb25Qcm9maXRQYXJ0UmF3AwkAZgIFIHRyZWFzdXJ5Vm9sdW1lRGlmZkFsbG9jYXRpb25Db2VmAAAFI3RyZWFzdXJ5Vm9sdW1lRGlmZkFsbG9jYXRpb25Db2VmQWJzAAAFBlNDQUxFOAQSZG9uYXRpb25Qcm9maXRQYXJ0CQBkAgkAZQIFFWRvbmF0aW9uUHJvZml0UGFydFJhdwUSYW1vdW50VG9JbnZlc3RtZW50BRBhbW91bnRUb0RvbmF0aW9uBBRpbnZlc3RtZW50UHJvZml0UGFydAkAZAIJAGUCBRdpbnZlc3RtZW50UHJvZml0UGFydFJhdwUQYW1vdW50VG9Eb25hdGlvbgUSYW1vdW50VG9JbnZlc3RtZW50BBhkb25hdGVkV2F2ZXNBbW91bnROZXdSYXcJAGQCBRJkb25hdGVkV2F2ZXNBbW91bnQFEmRvbmF0aW9uUHJvZml0UGFydAQZaW52ZXN0ZWRXYXZlc0Ftb3VudE5ld1JhdwkAZAIFE2ludmVzdGVkV2F2ZXNBbW91bnQFFGludmVzdG1lbnRQcm9maXRQYXJ0BA9kb25hdGVkUGFydERlYnQJAJcDAQkAzAgCAAAJAMwIAgUYZG9uYXRlZFdhdmVzQW1vdW50TmV3UmF3BQNuaWwEEGludmVzdGVkUGFydERlYnQJAJcDAQkAzAgCAAAJAMwIAgUZaW52ZXN0ZWRXYXZlc0Ftb3VudE5ld1JhdwUDbmlsBBVkb25hdGVkV2F2ZXNBbW91bnROZXcJAGQCCQCWAwEJAMwIAgAACQDMCAIFGGRvbmF0ZWRXYXZlc0Ftb3VudE5ld1JhdwUDbmlsBRBpbnZlc3RlZFBhcnREZWJ0BBZpbnZlc3RlZFdhdmVzQW1vdW50TmV3CQBkAgkAlgMBCQDMCAIAAAkAzAgCBRlpbnZlc3RlZFdhdmVzQW1vdW50TmV3UmF3BQNuaWwFD2RvbmF0ZWRQYXJ0RGVidAQJbmV3UGVyaW9kCQBkAgUTY3VycmVudFBlcmlvZE9yRmFpbAABBA9scEFzc2V0UXVhbnRpdHkICQETdmFsdWVPckVycm9yTWVzc2FnZQIJAOwHAQUPbHBBc3NldElkT3JGYWlsCQEHd3JhcEVycgECFGludmFsaWQgbHBBc3NldCBpbmZvCHF1YW50aXR5BAhuZXdQcmljZQkAawMFFmludmVzdGVkV2F2ZXNBbW91bnROZXcFBlNDQUxFOAUPbHBBc3NldFF1YW50aXR5BBNjaGVja0lmUHJpY2VOb3RaZXJvAwkBAiE9AgUIbmV3UHJpY2UAAAYJAQh0aHJvd0VycgECFExQIHByaWNlIGNhbm5vdCBiZSAwAwkAAAIFE2NoZWNrSWZQcmljZU5vdFplcm8FE2NoZWNrSWZQcmljZU5vdFplcm8EE2xwQXNzZXRBbW91bnRUb0J1cm4JAQt2YWx1ZU9yRWxzZQIJAJoIAgUUZmFjdG9yeUFkZHJlc3NPckZhaWwJAQ1rZXlXaXRoZHJhd2FsAAAABBBwYXltZW50QW1vdW50TWluCQCWAwEJAMwIAgAACQDMCAIJAGsDBRNscEFzc2V0QW1vdW50VG9CdXJuBQhuZXdQcmljZQUGU0NBTEU4BQNuaWwEDXBheW1lbnRPcHRpb24DCQBmAgkAkAMBCAUBaQhwYXltZW50cwAACQCRAwIIBQFpCHBheW1lbnRzAAAFBHVuaXQEDXBheW1lbnRBbW91bnQICQEFdmFsdWUBBQ1wYXltZW50T3B0aW9uBmFtb3VudAQOcGF5bWVudEFzc2V0SWQICQEFdmFsdWUBBQ1wYXltZW50T3B0aW9uB2Fzc2V0SWQEDGNoZWNrUGF5bWVudAMDCQAAAgUQcGF5bWVudEFtb3VudE1pbgAABgMDCQECIT0CBQ1wYXltZW50T3B0aW9uBQR1bml0CQAAAgUOcGF5bWVudEFzc2V0SWQFBHVuaXQHCQBnAgUNcGF5bWVudEFtb3VudAUQcGF5bWVudEFtb3VudE1pbgcGCQEIdGhyb3dFcnIBCQCsAgICJmludmFsaWQgcGF5bWVudHMsIHBheW1lbnQgYW1vdW50IG1pbjogCQCkAwEFEHBheW1lbnRBbW91bnRNaW4DCQAAAgUMY2hlY2tQYXltZW50BQxjaGVja1BheW1lbnQEB2FjdGlvbnMDCQECIT0CBQ1wYXltZW50T3B0aW9uBQR1bml0CQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFFGZhY3RvcnlBZGRyZXNzT3JGYWlsBQ1wYXltZW50QW1vdW50BQ5wYXltZW50QXNzZXRJZAUDbmlsBQNuaWwEDmZhY3RvcnlBY3Rpb25zCQDMCAIJAPwHBAUUZmFjdG9yeUFkZHJlc3NPckZhaWwCDGludGVnZXJFbnRyeQkAzAgCCQEUa2V5UG93ZXJNYW5hZ2VyQm9udXMBBRNjdXJyZW50UGVyaW9kT3JGYWlsCQDMCAIFFnB3ck1hbmFnZXJzQm9udXNBbW91bnQFA25pbAUDbmlsCQDMCAIJAPwHBAUUZmFjdG9yeUFkZHJlc3NPckZhaWwCDGludGVnZXJFbnRyeQkAzAgCCQEQa2V5Q3VycmVudFBlcmlvZAAJAMwIAgUJbmV3UGVyaW9kBQNuaWwFA25pbAkAzAgCCQD8BwQFFGZhY3RvcnlBZGRyZXNzT3JGYWlsAgxpbnRlZ2VyRW50cnkJAMwIAgkBEWtleVByaWNlRm9yUGVyaW9kAQUJbmV3UGVyaW9kCQDMCAIFCG5ld1ByaWNlBQNuaWwFA25pbAkAzAgCCQD8BwQFFGZhY3RvcnlBZGRyZXNzT3JGYWlsAgxpbnRlZ2VyRW50cnkJAMwIAgkBDmtleVN0YXJ0SGVpZ2h0AQUJbmV3UGVyaW9kCQDMCAIJAGQCBQ9wZXJpb2RFbmRIZWlnaHQAAQUDbmlsBQNuaWwJAMwIAgkA/AcEBRRmYWN0b3J5QWRkcmVzc09yRmFpbAIEYnVybgkAzAgCBRNscEFzc2V0QW1vdW50VG9CdXJuBQNuaWwFA25pbAkAzAgCCQD8BwQFFGZhY3RvcnlBZGRyZXNzT3JGYWlsAgxpbnRlZ2VyRW50cnkJAMwIAgkBDWtleVdpdGhkcmF3YWwACQDMCAIAAAUDbmlsBQNuaWwJAMwIAgkA/AcEBRRmYWN0b3J5QWRkcmVzc09yRmFpbAIMaW50ZWdlckVudHJ5CQDMCAIJAQtrZXlJbnZlc3RlZAEFBHVuaXQJAMwIAgkAZQIFFmludmVzdGVkV2F2ZXNBbW91bnROZXcFEHBheW1lbnRBbW91bnRNaW4FA25pbAUDbmlsCQDMCAIJAPwHBAUUZmFjdG9yeUFkZHJlc3NPckZhaWwCDGludGVnZXJFbnRyeQkAzAgCCQEKa2V5RG9uYXRlZAEFBHVuaXQJAMwIAgUVZG9uYXRlZFdhdmVzQW1vdW50TmV3BQNuaWwFA25pbAUDbmlsCQCUCgIFB2FjdGlvbnMFDmZhY3RvcnlBY3Rpb25zCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAEMrjSI=",
    "chainId": 84,
    "height": 2653809,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: B2K7kQfptcWhnEpbWULCVwZbwkveix5Pb3yeVoQyCgc2
Next: 5Zw1JHvQr7soHtAaHjxUzGsgXK43wpqmjjdvmAo6Yrwt

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+let CONTRACT_NAME = "calculator.ride"
7+
8+let SCALE8 = 100000000
9+
10+let PENDING = "PENDING"
11+
12+let FINISHED = "FINISHED"
13+
14+let WAVES = "WAVES"
15+
16+func wrapErr (s) = ((CONTRACT_NAME + ": ") + s)
17+
18+
19+func throwErr (s) = throw(wrapErr(s))
20+
21+
22+func assetIdToString (assetId) = match assetId {
23+    case b: ByteVector => 
24+        toBase58String(b)
25+    case _: Unit => 
26+        WAVES
27+    case _ => 
28+        throw("Match error")
29+}
30+
31+
32+func abs (n) = if ((0 > n))
33+    then -(n)
34+    else n
35+
36+
37+func keyFactoryAddress () = makeString(["%s", "factory"], SEP)
38+
39+
40+func keyManagerPublicKey () = makeString(["%s", "managerPublicKey"], SEP)
41+
42+
43+func keyLpAssetId () = makeString(["%s", "lpAssetId"], SEP)
44+
45+
46+func keyProxyTreasuryAddress () = makeString(["%s", "proxyTreasury"], SEP)
47+
48+
49+func keyMainTreasuryAddress () = makeString(["%s", "mainTreasury"], SEP)
50+
51+
52+func keyInvested (assetId) = makeString(["%s%s", "invested", assetIdToString(assetId)], SEP)
53+
54+
55+func keyDonated (assetId) = makeString(["%s%s", "donated", assetIdToString(assetId)], SEP)
56+
57+
58+func keyAvailable (userAddress) = makeString(["%s%s", "available", toString(userAddress)], SEP)
59+
60+
61+func keyClaimed (userAddress) = makeString(["%s%s", "claimed", toString(userAddress)], SEP)
62+
63+
64+func keyCurrentPeriod () = makeString(["%s", "currentPeriod"], SEP)
65+
66+
67+func keyPriceForPeriod (period) = makeString(["%s%d", "price", toString(period)], SEP)
68+
69+
70+func keyStartHeight (period) = makeString(["%s%d", "startHeight", toString(period)], SEP)
71+
72+
73+func keyPowerManagerBonus (period) = makeString(["%s%d", "powerManagerBonus", toString(period)], SEP)
74+
75+
76+func keyPeriodLength () = "%s__periodLength"
77+
78+
79+func keyBlockProcessingReward () = "%s__blockProcessingReward"
80+
81+
82+func keyNextBlockToProcess () = "%s__nextBlockToProcess"
83+
84+
85+func keyBlockProcessed (height) = makeString(["%s%d", "blockProcessed", toString(height)], SEP)
86+
87+
88+func keyWithdrawal () = "%s__withdrawal"
89+
90+
91+func keyWithdrawalRequest (userAddress,txId) = makeString(["%s%s%s", "withdrawal", toString(userAddress), toBase58String(txId)], SEP)
92+
93+
94+func valueWithdrawalRequest (status,lpAssetAmount,targetPeriod,claimTxId) = {
95+    let claimTxIdStr =     match claimTxId {
96+        case b: ByteVector => 
97+            toBase58String(b)
98+        case _: Unit => 
99+            "SOON"
100+        case _ => 
101+            throw("Match error")
102+    }
103+    makeString(["%s%d%d%s", status, toString(lpAssetAmount), toString(targetPeriod), claimTxIdStr], SEP)
104+    }
105+
106+
107+func parseWithdrawalRequestValueOrFail (s) = {
108+    let parts = split(s, SEP)
109+    if ((size(parts) == 5))
110+        then {
111+            let status = parts[1]
112+            let lpAssetAmount = valueOrErrorMessage(parseInt(parts[2]), wrapErr("invalid lpAssetAmount"))
113+            let targetPeriod = valueOrErrorMessage(parseInt(parts[3]), wrapErr("invalid targetPeriod"))
114+            let claimTxId = parts[4]
115+            $Tuple4(status, lpAssetAmount, targetPeriod, claimTxId)
116+            }
117+        else throwErr("invalid withdrawal request value")
118+    }
119+
120+
121+let factoryAddressOption = match getString(this, keyFactoryAddress()) {
122+    case s: String => 
123+        addressFromString(s)
124+    case _: Unit => 
125+        unit
126+    case _ => 
127+        throw("Match error")
128+}
129+
130+let factoryAddressOrFail = valueOrErrorMessage(factoryAddressOption, wrapErr("invalid factory address"))
131+
132+let lpAssetIdOption = match factoryAddressOption {
133+    case a: Address => 
134+        match getString(a, keyLpAssetId()) {
135+            case s: String => 
136+                fromBase58String(s)
137+            case _: Unit => 
138+                unit
139+            case _ => 
140+                throw("Match error")
141+        }
142+    case _: Unit => 
143+        unit
144+    case _ => 
145+        throw("Match error")
146+}
147+
148+let lpAssetIdOrFail = valueOrErrorMessage(lpAssetIdOption, wrapErr("invalid lpAssetId"))
149+
150+let proxyTreasuryAddressOption = match factoryAddressOption {
151+    case a: Address => 
152+        match getString(a, keyProxyTreasuryAddress()) {
153+            case s: String => 
154+                addressFromString(s)
155+            case _: Unit => 
156+                unit
157+            case _ => 
158+                throw("Match error")
159+        }
160+    case _: Unit => 
161+        unit
162+    case _ => 
163+        throw("Match error")
164+}
165+
166+let proxyTreasuryAddressOrFail = valueOrErrorMessage(proxyTreasuryAddressOption, wrapErr("invalid proxy treasury address"))
167+
168+let mainTreasuryAddressOption = match factoryAddressOption {
169+    case a: Address => 
170+        match getString(a, keyMainTreasuryAddress()) {
171+            case s: String => 
172+                addressFromString(s)
173+            case _: Unit => 
174+                unit
175+            case _ => 
176+                throw("Match error")
177+        }
178+    case _: Unit => 
179+        unit
180+    case _ => 
181+        throw("Match error")
182+}
183+
184+let mainTreasuryAddressOrFail = valueOrErrorMessage(mainTreasuryAddressOption, wrapErr("invalid main treasury address"))
185+
186+func getManagerPublicKeyOrUnit () = match factoryAddressOption {
187+    case fa: Address => 
188+        match getString(fa, keyManagerPublicKey()) {
189+            case pub: String => 
190+                fromBase58String(pub)
191+            case _ => 
192+                unit
193+        }
194+    case _ => 
195+        unit
196+}
197+
198+
199+func onlyAddress (i,address) = if ((i.caller == address))
200+    then true
201+    else throwErr("permission denied")
202+
203+
204+func onlyFactory (i) = onlyAddress(i, factoryAddressOrFail)
205+
206+
207+func rewardForOption (rewards,target) = {
208+    let s = size(rewards)
209+    let $t047354760 = rewards[0]
210+    let a0 = $t047354760._1
211+    let r0 = $t047354760._2
212+    let $t047634788 = rewards[1]
213+    let a1 = $t047634788._1
214+    let r1 = $t047634788._2
215+    let $t047914816 = rewards[2]
216+    let a2 = $t047914816._1
217+    let r2 = $t047914816._2
218+    if (if ((s > 0))
219+        then (a0 == target)
220+        else false)
221+        then r0
222+        else if (if ((s > 1))
223+            then (a1 == target)
224+            else false)
225+            then r1
226+            else if (if ((s > 2))
227+                then (a2 == target)
228+                else false)
229+                then r2
230+                else unit
231+    }
232+
233+
234+func finalizeINTERNAL (newTreasuryVolumeInWaves,pwrManagersBonusInWaves,treasuryVolumeDiffAllocationCoef) = {
235+    let donatedWavesAmount = valueOrElse(getInteger(factoryAddressOrFail, keyDonated(unit)), 0)
236+    let investedWavesAmount = valueOrElse(getInteger(factoryAddressOrFail, keyInvested(unit)), 0)
237+    let currentTreasuryVolumeInWaves = (donatedWavesAmount + investedWavesAmount)
238+    let profitRaw = (newTreasuryVolumeInWaves - currentTreasuryVolumeInWaves)
239+    let pwrManagersBonusAmount = if (if ((profitRaw > 0))
240+        then (profitRaw >= pwrManagersBonusInWaves)
241+        else false)
242+        then pwrManagersBonusInWaves
243+        else throwErr("power bonus is more than profit")
244+    let profit = (profitRaw - pwrManagersBonusAmount)
245+    let donationPart = if ((currentTreasuryVolumeInWaves > 0))
246+        then fraction(donatedWavesAmount, SCALE8, currentTreasuryVolumeInWaves)
247+        else 0
248+    let donationProfitPartRaw = fraction(profit, donationPart, SCALE8)
249+    let investmentProfitPartRaw = (profit - donationProfitPartRaw)
250+    let treasuryVolumeDiffAllocationCoefAbs = abs(treasuryVolumeDiffAllocationCoef)
251+    let amountToDonation = fraction(investmentProfitPartRaw, if ((0 > treasuryVolumeDiffAllocationCoef))
252+        then treasuryVolumeDiffAllocationCoefAbs
253+        else 0, SCALE8)
254+    let amountToInvestment = fraction(donationProfitPartRaw, if ((treasuryVolumeDiffAllocationCoef > 0))
255+        then treasuryVolumeDiffAllocationCoefAbs
256+        else 0, SCALE8)
257+    let donationProfitPart = ((donationProfitPartRaw - amountToInvestment) + amountToDonation)
258+    let investmentProfitPart = ((investmentProfitPartRaw - amountToDonation) + amountToInvestment)
259+    let donatedWavesAmountNewRaw = (donatedWavesAmount + donationProfitPart)
260+    let investedWavesAmountNewRaw = (investedWavesAmount + investmentProfitPart)
261+    let donatedPartDebt = min([0, donatedWavesAmountNewRaw])
262+    let investedPartDebt = min([0, investedWavesAmountNewRaw])
263+    let donatedWavesAmountNew = (max([0, donatedWavesAmountNewRaw]) + investedPartDebt)
264+    let investedWavesAmountNew = (max([0, investedWavesAmountNewRaw]) + donatedPartDebt)
265+    let lpAssetQuantity = valueOrErrorMessage(assetInfo(lpAssetIdOrFail), wrapErr("invalid lpAsset info")).quantity
266+    let newPrice = fraction(investedWavesAmountNew, SCALE8, lpAssetQuantity)
267+    let checkIfPriceNotZero = if ((newPrice != 0))
268+        then true
269+        else throwErr("LP price cannot be 0")
270+    if ((checkIfPriceNotZero == checkIfPriceNotZero))
271+        then {
272+            let lpAssetAmountToBurn = valueOrElse(getInteger(factoryAddressOrFail, keyWithdrawal()), 0)
273+            let paymentAmountMin = max([0, fraction(lpAssetAmountToBurn, newPrice, SCALE8)])
274+            let finalInvestedWavesAmount = (investedWavesAmountNew - paymentAmountMin)
275+            let lpAssetFinalQuantity = (lpAssetQuantity - lpAssetAmountToBurn)
276+            $Tuple6(paymentAmountMin, finalInvestedWavesAmount, donatedWavesAmountNew, newPrice, lpAssetAmountToBurn, lpAssetFinalQuantity)
277+            }
278+        else throw("Strict value is not equal to itself.")
279+    }
280+
281+
282+@Callable(i)
283+func finalize (userAddressBytes,newTreasuryVolumeInWaves,pwrManagersBonusInWaves,treasuryVolumeDiffAllocationCoef) = {
284+    let checkCaller = onlyFactory(i)
285+    if ((checkCaller == checkCaller))
286+        then {
287+            let currentPeriodOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyCurrentPeriod()), wrapErr("invalid period"))
288+            let periodLength = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPeriodLength()), wrapErr("invalid period length"))
289+            let currentStartHeight = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyStartHeight(currentPeriodOrFail)), wrapErr("invalid start height"))
290+            let currentPriceOrFail = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyPriceForPeriod(currentPeriodOrFail)), wrapErr("invalid price"))
291+            let nextBlockToProcess = valueOrErrorMessage(getInteger(factoryAddressOrFail, keyNextBlockToProcess()), wrapErr("invalid next block to process"))
292+            let periodEndHeight = ((currentStartHeight + periodLength) - 1)
293+            let checks = [if ((i.originCaller == mainTreasuryAddressOrFail))
294+                then true
295+                else throwErr("permission denied"), if ((nextBlockToProcess > periodEndHeight))
296+                then true
297+                else throwErr("unprocessed blocks"), if ((newTreasuryVolumeInWaves >= 0))
298+                then true
299+                else throwErr("invalid new treasury volume"), if ((pwrManagersBonusInWaves >= 0))
300+                then true
301+                else throwErr("invalid PWR managers bonus"), if (if ((treasuryVolumeDiffAllocationCoef >= -(SCALE8)))
302+                then (SCALE8 >= treasuryVolumeDiffAllocationCoef)
303+                else false)
304+                then true
305+                else throwErr("invalid treasury volume diff allocation coefficient")]
306+            if ((checks == checks))
307+                then {
308+                    let donatedWavesAmount = valueOrElse(getInteger(factoryAddressOrFail, keyDonated(unit)), 0)
309+                    let investedWavesAmount = valueOrElse(getInteger(factoryAddressOrFail, keyInvested(unit)), 0)
310+                    let currentTreasuryVolumeInWaves = (donatedWavesAmount + investedWavesAmount)
311+                    let profitRaw = (newTreasuryVolumeInWaves - currentTreasuryVolumeInWaves)
312+                    let pwrManagersBonusAmount = if (if ((profitRaw > 0))
313+                        then (profitRaw >= pwrManagersBonusInWaves)
314+                        else false)
315+                        then pwrManagersBonusInWaves
316+                        else throwErr("power bonus is more than profit")
317+                    let profit = (profitRaw - pwrManagersBonusAmount)
318+                    let donationPart = if ((currentTreasuryVolumeInWaves > 0))
319+                        then fraction(donatedWavesAmount, SCALE8, currentTreasuryVolumeInWaves)
320+                        else 0
321+                    let donationProfitPartRaw = fraction(profit, donationPart, SCALE8)
322+                    let investmentProfitPartRaw = (profit - donationProfitPartRaw)
323+                    let treasuryVolumeDiffAllocationCoefAbs = abs(treasuryVolumeDiffAllocationCoef)
324+                    let amountToDonation = fraction(investmentProfitPartRaw, if ((0 > treasuryVolumeDiffAllocationCoef))
325+                        then treasuryVolumeDiffAllocationCoefAbs
326+                        else 0, SCALE8)
327+                    let amountToInvestment = fraction(donationProfitPartRaw, if ((treasuryVolumeDiffAllocationCoef > 0))
328+                        then treasuryVolumeDiffAllocationCoefAbs
329+                        else 0, SCALE8)
330+                    let donationProfitPart = ((donationProfitPartRaw - amountToInvestment) + amountToDonation)
331+                    let investmentProfitPart = ((investmentProfitPartRaw - amountToDonation) + amountToInvestment)
332+                    let donatedWavesAmountNewRaw = (donatedWavesAmount + donationProfitPart)
333+                    let investedWavesAmountNewRaw = (investedWavesAmount + investmentProfitPart)
334+                    let donatedPartDebt = min([0, donatedWavesAmountNewRaw])
335+                    let investedPartDebt = min([0, investedWavesAmountNewRaw])
336+                    let donatedWavesAmountNew = (max([0, donatedWavesAmountNewRaw]) + investedPartDebt)
337+                    let investedWavesAmountNew = (max([0, investedWavesAmountNewRaw]) + donatedPartDebt)
338+                    let newPeriod = (currentPeriodOrFail + 1)
339+                    let lpAssetQuantity = valueOrErrorMessage(assetInfo(lpAssetIdOrFail), wrapErr("invalid lpAsset info")).quantity
340+                    let newPrice = fraction(investedWavesAmountNew, SCALE8, lpAssetQuantity)
341+                    let checkIfPriceNotZero = if ((newPrice != 0))
342+                        then true
343+                        else throwErr("LP price cannot be 0")
344+                    if ((checkIfPriceNotZero == checkIfPriceNotZero))
345+                        then {
346+                            let lpAssetAmountToBurn = valueOrElse(getInteger(factoryAddressOrFail, keyWithdrawal()), 0)
347+                            let paymentAmountMin = max([0, fraction(lpAssetAmountToBurn, newPrice, SCALE8)])
348+                            let paymentOption = if ((size(i.payments) > 0))
349+                                then i.payments[0]
350+                                else unit
351+                            let paymentAmount = value(paymentOption).amount
352+                            let paymentAssetId = value(paymentOption).assetId
353+                            let checkPayment = if (if ((paymentAmountMin == 0))
354+                                then true
355+                                else if (if ((paymentOption != unit))
356+                                    then (paymentAssetId == unit)
357+                                    else false)
358+                                    then (paymentAmount >= paymentAmountMin)
359+                                    else false)
360+                                then true
361+                                else throwErr(("invalid payments, payment amount min: " + toString(paymentAmountMin)))
362+                            if ((checkPayment == checkPayment))
363+                                then {
364+                                    let actions = if ((paymentOption != unit))
365+                                        then [ScriptTransfer(factoryAddressOrFail, paymentAmount, paymentAssetId)]
366+                                        else nil
367+                                    let factoryActions = [invoke(factoryAddressOrFail, "integerEntry", [keyPowerManagerBonus(currentPeriodOrFail), pwrManagersBonusAmount], nil), invoke(factoryAddressOrFail, "integerEntry", [keyCurrentPeriod(), newPeriod], nil), invoke(factoryAddressOrFail, "integerEntry", [keyPriceForPeriod(newPeriod), newPrice], nil), invoke(factoryAddressOrFail, "integerEntry", [keyStartHeight(newPeriod), (periodEndHeight + 1)], nil), invoke(factoryAddressOrFail, "burn", [lpAssetAmountToBurn], nil), invoke(factoryAddressOrFail, "integerEntry", [keyWithdrawal(), 0], nil), invoke(factoryAddressOrFail, "integerEntry", [keyInvested(unit), (investedWavesAmountNew - paymentAmountMin)], nil), invoke(factoryAddressOrFail, "integerEntry", [keyDonated(unit), donatedWavesAmountNew], nil)]
368+                                    $Tuple2(actions, factoryActions)
369+                                    }
370+                                else throw("Strict value is not equal to itself.")
371+                            }
372+                        else throw("Strict value is not equal to itself.")
373+                    }
374+                else throw("Strict value is not equal to itself.")
375+            }
376+        else throw("Strict value is not equal to itself.")
377+    }
378+
379+
github/deemru/w8io/026f985 
31.26 ms ◑