tx · Gt7Sie3dagcRf9tbbFmYNCv9MmzKUj8LDY9g8KexMUMo

3N6LcQXeQc62oujobJgJ5x8aBHDeBXfxKGV:  -0.01400000 Waves

2022.11.18 17:04 [2322649] smart account 3N6LcQXeQc62oujobJgJ5x8aBHDeBXfxKGV > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Gt7Sie3dagcRf9tbbFmYNCv9MmzKUj8LDY9g8KexMUMo",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1668780276162,
    "version": 2,
    "chainId": 84,
    "sender": "3N6LcQXeQc62oujobJgJ5x8aBHDeBXfxKGV",
    "senderPublicKey": "GNCUYRw4Zom68MnjWJ3xrimtKrknM8TJuYukq2PCXS2m",
    "proofs": [
        "2DJW8fFqhnEobS36QNpuGGhWXocbMsCU7nMPcCFMfWH9S1zNrDTPHKsdBu5RfDYoToovyAXXXKo4TZuqKrJjaAAK"
    ],
    "script": "base64:BgIZCAISBwoFCAgICAgSABIAEgASBAoCAQESAB8ACVNFUEFSQVRPUgICX18ABVdBVkVTAgVXQVZFUwAMS0VZX01VTFRJU0lHAghNVUxUSVNJRwAKS0VZX1NUQVRVUwIGU1RBVFVTAA5LRVlfQkFTRV9BU1NFVAIKQkFTRV9BU1NFVAAJS0VZX0FTU0VUAgVBU1NFVAATS0VZX1NUQUtJTkdfQURBUFRFUgIPU1RBS0lOR19BREFQVEVSABJLRVlfU1RBS0lOR19BTU9VTlQCDlNUQUtJTkdfQU1PVU5UAA1LRVlfTEFTVF9SQVRFAglMQVNUX1JBVEUAEEtFWV9DVVJSRU5UX1JBVEUCDENVUlJFTlRfUkFURQAPS0VZX0xBU1RfSEVJR0hUAgtMQVNUX0hFSUdIVAARS0VZX1RBUkdFVF9IRUlHSFQCDVRBUkdFVF9IRUlHSFQACkZVTkNfU1RBS0UCBXN0YWtlAAxGVU5DX1VOU1RBS0UCB3Vuc3Rha2UAEUZVTkNfQ0xBSU1fUkVXQVJEAgtjbGFpbVJld2FyZAAOUEVSQ0VOVF9GQUNUT1IJALYCAQCAoJSljR0AC1pFUk9fQklHSU5UCQC2AgEAAAAKT05FX0JJR0lOVAkAtgIBAAEBEF92YWxpZGF0ZUFkZHJlc3MBCGFkZHJlc3NfBAckbWF0Y2gwCQCmCAEFCGFkZHJlc3NfAwkAAQIFByRtYXRjaDACB0FkZHJlc3MEAWEFByRtYXRjaDAGBwEOX3ZhbGlkYXRlQXNzZXQBBmFzc2V0XwMJAAACBQZhc3NldF8FBVdBVkVTBgQHJG1hdGNoMAkA7AcBCQDZBAEFBmFzc2V0XwMJAAECBQckbWF0Y2gwAgVBc3NldAQBYQUHJG1hdGNoMAYHAQ5fdG9Bc3NldFZlY3RvcgEGYXNzZXRfAwkAAAIFBmFzc2V0XwUFV0FWRVMFBHVuaXQJANkEAQUGYXNzZXRfARFfZ2V0QXNzZXREZWNpbWFscwEGYXNzZXRfBAckbWF0Y2gwBQZhc3NldF8DCQABAgUHJG1hdGNoMAIKQnl0ZVZlY3RvcgQBYQUHJG1hdGNoMAQHJG1hdGNoMQkA7AcBBQFhAwkAAQIFByRtYXRjaDECBUFzc2V0BAVhc3NldAUHJG1hdGNoMQgFBWFzc2V0CGRlY2ltYWxzCQACAQIgX2dldEFzc2V0RGVjaW1hbHM6IG5vIHN1Y2ggYXNzZXQACAERX2dldEFzc2V0UXVhbnRpdHkBBmFzc2V0XwQHJG1hdGNoMAkA7AcBBQZhc3NldF8DCQABAgUHJG1hdGNoMAIFQXNzZXQEAWEFByRtYXRjaDAIBQFhCHF1YW50aXR5CQACAQIgX2dldEFzc2V0UXVhbnRpdHk6IG5vIHN1Y2ggYXNzZXQBEF9nZXRBc3NldEJhbGFuY2UCBmFzc2V0XwdhZGRyZXNzBAckbWF0Y2gwBQZhc3NldF8DCQABAgUHJG1hdGNoMAIKQnl0ZVZlY3RvcgQBYQUHJG1hdGNoMAkA8AcCBQdhZGRyZXNzBQFhCAkA7wcBBQdhZGRyZXNzB3JlZ3VsYXIBDl9sb2FkQmFzZUFzc2V0AAQHJG1hdGNoMAkAoggBBQ5LRVlfQkFTRV9BU1NFVAMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAWEFByRtYXRjaDADCQAAAgUBYQUFV0FWRVMFBHVuaXQJANkEAQUBYQkAAgECHV9sb2FkQmFzZUFzc2V0OiBubyBiYXNlIGFzc2V0ARNfbG9hZFN0YWtpbmdBZGFwdGVyAAQHJG1hdGNoMAkAoggBBRNLRVlfU1RBS0lOR19BREFQVEVSAwkAAQIFByRtYXRjaDACBlN0cmluZwQBYQUHJG1hdGNoMAkBEUBleHRyTmF0aXZlKDEwNjIpAQUBYQkAAgECJ19sb2FkU3Rha2luZ0FkYXB0ZXI6IG5vIHN0YWtpbmcgYWRhcHRlcgEIX2xvYWRJbnQCBGtleV8IZGVmYXVsdF8EByRtYXRjaDAJAJ8IAQUEa2V5XwMJAAECBQckbWF0Y2gwAgNJbnQEAWEFByRtYXRjaDAFAWEFCGRlZmF1bHRfAQtfbG9hZEJpZ0ludAIEa2V5XwhkZWZhdWx0XwQHJG1hdGNoMAkAoQgBBQRrZXlfAwkAAQIFByRtYXRjaDACCkJ5dGVWZWN0b3IEAWEFByRtYXRjaDAJAJ4DAQUBYQUIZGVmYXVsdF8BCl9sb2FkQXNzZXQABAckbWF0Y2gwCQCiCAEFCUtFWV9BU1NFVAMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAWEFByRtYXRjaDAJANkEAQUBYQEAAQ5fdXBkYXRlU3Rha2luZwMGYXNzZXRfB2Ftb3VudF8IYWRhcHRlcl8EDXN0YWtpbmdBbW91bnQJAQhfbG9hZEludAIFEktFWV9TVEFLSU5HX0FNT1VOVAAABBBuZXdTdGFraW5nQW1vdW50CQBkAgUNc3Rha2luZ0Ftb3VudAUHYW1vdW50XwQKaW52b2NhdGlvbgMJAGYCBQdhbW91bnRfAAAJAPwHBAUIYWRhcHRlcl8FCkZVTkNfU1RBS0UFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUGYXNzZXRfBQdhbW91bnRfBQNuaWwJAPwHBAUIYWRhcHRlcl8FDEZVTkNfVU5TVEFLRQkAzAgCCQBoAgD///////////8BBQdhbW91bnRfBQNuaWwFA25pbAMJAAACBQppbnZvY2F0aW9uBQppbnZvY2F0aW9uCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRJLRVlfU1RBS0lOR19BTU9VTlQFEG5ld1N0YWtpbmdBbW91bnQFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgELX2NoZWNrcG9pbnQBDGNvbXBlbnNhdGlvbgQKaW52b2NhdGlvbgkA/AcECQETX2xvYWRTdGFraW5nQWRhcHRlcgAFEUZVTkNfQ0xBSU1fUkVXQVJEBQNuaWwFA25pbAMJAAACBQppbnZvY2F0aW9uBQppbnZvY2F0aW9uBAckbWF0Y2gwBQppbnZvY2F0aW9uAwkAAQIFByRtYXRjaDACDyhJbnQsIEludCwgSW50KQQGcmV3YXJkBQckbWF0Y2gwAwUMY29tcGVuc2F0aW9uBAVzdGFrZQkA/AcEBQR0aGlzBQpGVU5DX1NUQUtFCQDMCAIIBQZyZXdhcmQCXzEJAMwIAggFBnJld2FyZAJfMwUDbmlsBQNuaWwDCQAAAgUFc3Rha2UFBXN0YWtlCQCUCgIGCAUGcmV3YXJkAl8yCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBAVzdGFrZQkA/AcEBQR0aGlzBQpGVU5DX1NUQUtFCQDMCAIJAGQCCAUGcmV3YXJkAl8xCAUGcmV3YXJkAl8yCQDMCAIIBQZyZXdhcmQCXzMFA25pbAUDbmlsAwkAAAIFBXN0YWtlBQVzdGFrZQkAlAoCBgAACQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQCUCgIHAAAJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4GAWkBBGluaXQFCW11bHRpc2lnXwp0b2tlbk5hbWVfC3Rva2VuRGVzY3JfCmJhc2VBc3NldF8Pc3Rha2luZ0FkYXB0ZXJfBAVhc3NldAkBCl9sb2FkQXNzZXQABAliYXNlQXNzZXQJAQ5fdG9Bc3NldFZlY3RvcgEFCmJhc2VBc3NldF8EA2VycgMJAQIhPQIFBWFzc2V0AQAJAAIBAhlpbml0OiBhbHJlYWR5IGluaXRpYWxpemVkAwkBASEBCQEQX3ZhbGlkYXRlQWRkcmVzcwEFCW11bHRpc2lnXwkAAgECHmluaXQ6IGludmFsaWQgbXVsdGlzaWcgYWRkcmVzcwMDCQBmAgAECQCxAgEFCnRva2VuTmFtZV8GCQBmAgkAsQIBBQp0b2tlbk5hbWVfABAJAAIBAhhpbml0OiBpbnZhbGlkIHRva2VuIG5hbWUDCQBmAgkAsQIBBQt0b2tlbkRlc2NyXwDoBwkAAgECH2luaXQ6IGludmFsaWQgdG9rZW4gZGVzY3JpcHRpb24DCQEBIQEJAQ5fdmFsaWRhdGVBc3NldAEFCmJhc2VBc3NldF8JAAIBAhhpbml0OiBpbnZhbGlkIGJhc2UgYXNzZXQDCQEBIQEJARBfdmFsaWRhdGVBZGRyZXNzAQUPc3Rha2luZ0FkYXB0ZXJfCQACAQIdaW5pdDogaW52YWxpZCBzdGFraW5nIGFkYXB0ZXIDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAEJAAIBAhxpbml0OiBwYXltZW50IGlzIG5vdCBwcmVzZW50AwkBAiE9AggJAJEDAggFAWkIcGF5bWVudHMAAAdhc3NldElkBQliYXNlQXNzZXQJAAIBAiJpbml0OiBwYXltZW50IGlzIG5vdCBpbiBiYXNlIGFzc2V0AwkAZwIAAAgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQJAAIBAhxpbml0OiBpbnZhbGlkIHBheW1lbnQgYW1vdW50BQR1bml0AwkAAAIFA2VycgUDZXJyBA10b2tlbkRlY2ltYWxzCQERX2dldEFzc2V0RGVjaW1hbHMBBQliYXNlQXNzZXQEBWlzc3VlCQDCCAUFCnRva2VuTmFtZV8FC3Rva2VuRGVzY3JfCAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAUNdG9rZW5EZWNpbWFscwYEB2Fzc2V0SWQJALgIAQUFaXNzdWUEDHN0YWtlQWN0aW9ucwkBDl91cGRhdGVTdGFraW5nAwUJYmFzZUFzc2V0CAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAkBEUBleHRyTmF0aXZlKDEwNjIpAQUPc3Rha2luZ0FkYXB0ZXJfCQCUCgIJAM4IAgkAzAgCCQELU3RyaW5nRW50cnkCBQxLRVlfTVVMVElTSUcFCW11bHRpc2lnXwkAzAgCCQELU3RyaW5nRW50cnkCBQ5LRVlfQkFTRV9BU1NFVAUKYmFzZUFzc2V0XwkAzAgCCQELU3RyaW5nRW50cnkCBRNLRVlfU1RBS0lOR19BREFQVEVSBQ9zdGFraW5nQWRhcHRlcl8JAMwIAgkBC1N0cmluZ0VudHJ5AgUJS0VZX0FTU0VUCQDYBAEFB2Fzc2V0SWQJAMwIAgUFaXNzdWUFA25pbAUMc3Rha2VBY3Rpb25zBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBB2dldFJhdGUABAhsYXN0UmF0ZQkBC19sb2FkQmlnSW50AgUNS0VZX0xBU1RfUkFURQUOUEVSQ0VOVF9GQUNUT1IEC2N1cnJlbnRSYXRlCQELX2xvYWRCaWdJbnQCBRBLRVlfQ1VSUkVOVF9SQVRFBQtaRVJPX0JJR0lOVAQKbGFzdEhlaWdodAkBCF9sb2FkSW50AgUPS0VZX0xBU1RfSEVJR0hUAAAEDHRhcmdldEhlaWdodAkAlwMBCQDMCAIJAQhfbG9hZEludAIFEUtFWV9UQVJHRVRfSEVJR0hUAAAJAMwIAggFCWxhc3RCbG9jawZoZWlnaHQFA25pbAQEcmF0ZQkAtwICBQhsYXN0UmF0ZQkAuQICBQtjdXJyZW50UmF0ZQkAtgIBCQBlAgUMdGFyZ2V0SGVpZ2h0BQpsYXN0SGVpZ2h0CQCUCgIFA25pbAkApgMBBQRyYXRlAWkBCmNoZWNrcG9pbnQABApjaGVja3BvaW50CQELX2NoZWNrcG9pbnQBBgMJAAACBQpjaGVja3BvaW50BQpjaGVja3BvaW50AwkBASEBCAUKY2hlY2twb2ludAJfMQkAAgECFWNoZWNrcG9pbnQ6IG5vIHJld2FyZAMJAGYCCAUKY2hlY2twb2ludAJfMgAACQCUCgIJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwgFAWkMb3JpZ2luQ2FsbGVyCAUKY2hlY2twb2ludAJfMgkBDl9sb2FkQmFzZUFzc2V0AAUDbmlsBQR1bml0CQCUCgIFA25pbAUEdW5pdAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQdkZXBvc2l0AAQGY2FsbGVyCQClCAEIBQFpBmNhbGxlcgQJYmFzZUFzc2V0CQEOX2xvYWRCYXNlQXNzZXQABAVhc3NldAkBCl9sb2FkQXNzZXQABA1hc3NldFF1YW50aXR5CQC2AgEJARFfZ2V0QXNzZXRRdWFudGl0eQEFBWFzc2V0BANlcnIDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAEJAAIBAhRkZXBvc2l0OiBubyBwYXltZW50cwMJAQIhPQIICQCRAwIIBQFpCHBheW1lbnRzAAAHYXNzZXRJZAUJYmFzZUFzc2V0CQACAQIlZGVwb3NpdDogcGF5bWVudCBpcyBub3QgaW4gYmFzZSBhc3NldAMJAGcCAAAICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50CQACAQIfZGVwb3NpdDogaW52YWxpZCBwYXltZW50IGFtb3VudAUEdW5pdAMJAAACBQNlcnIFA2VycgQKY2hlY2twb2ludAkBC19jaGVja3BvaW50AQcDCQAAAgUKY2hlY2twb2ludAUKY2hlY2twb2ludAQIbGFzdFJhdGUJAQtfbG9hZEJpZ0ludAIFDUtFWV9MQVNUX1JBVEUFDlBFUkNFTlRfRkFDVE9SBAtjdXJyZW50UmF0ZQkBC19sb2FkQmlnSW50AgUQS0VZX0NVUlJFTlRfUkFURQULWkVST19CSUdJTlQECmxhc3RIZWlnaHQJAQhfbG9hZEludAIFD0tFWV9MQVNUX0hFSUdIVAAABAx0YXJnZXRIZWlnaHQJAJcDAQkAzAgCCQEIX2xvYWRJbnQCBRFLRVlfVEFSR0VUX0hFSUdIVAAACQDMCAIIBQlsYXN0QmxvY2sGaGVpZ2h0BQNuaWwED2xhc3RSYXRlVXBkYXRlZAkAtwICBQhsYXN0UmF0ZQkAuQICBQtjdXJyZW50UmF0ZQkAtgIBCQBlAgUMdGFyZ2V0SGVpZ2h0BQpsYXN0SGVpZ2h0BAtpc3N1ZUFtb3VudAkAoAMBCQC9AgQJALYCAQgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQFDlBFUkNFTlRfRkFDVE9SBQ9sYXN0UmF0ZVVwZGF0ZWQFBUZMT09SBBJjdXJyZW50UmF0ZVVwZGF0ZWQJAL0CBAULY3VycmVudFJhdGUFDWFzc2V0UXVhbnRpdHkJALcCAgUNYXNzZXRRdWFudGl0eQkAtgIBBQtpc3N1ZUFtb3VudAUFRkxPT1IEEWxhc3RIZWlnaHRVcGRhdGVkBQx0YXJnZXRIZWlnaHQEDHN0YWtlQWN0aW9ucwkBDl91cGRhdGVTdGFraW5nAwUJYmFzZUFzc2V0CAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAkBE19sb2FkU3Rha2luZ0FkYXB0ZXIACQCUCgIJAM4IAgkAzAgCCQEHUmVpc3N1ZQMFBWFzc2V0BQtpc3N1ZUFtb3VudAYJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwgFAWkGY2FsbGVyBQtpc3N1ZUFtb3VudAUFYXNzZXQJAMwIAgkBC0JpbmFyeUVudHJ5AgUNS0VZX0xBU1RfUkFURQkAnQMBBQ9sYXN0UmF0ZVVwZGF0ZWQJAMwIAgkBC0JpbmFyeUVudHJ5AgUQS0VZX0NVUlJFTlRfUkFURQkAnQMBBRJjdXJyZW50UmF0ZVVwZGF0ZWQJAMwIAgkBDEludGVnZXJFbnRyeQIFD0tFWV9MQVNUX0hFSUdIVAURbGFzdEhlaWdodFVwZGF0ZWQFA25pbAUMc3Rha2VBY3Rpb25zBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBBXN0YWtlAgdhbW91bnRfDXNwcmVhZEJsb2Nrc18EBmNhbGxlcgkApQgBCAUBaQZjYWxsZXIECWJhc2VBc3NldAkBDl9sb2FkQmFzZUFzc2V0AAQFYXNzZXQJAQpfbG9hZEFzc2V0AAQNYXNzZXRRdWFudGl0eQkAtgIBCQERX2dldEFzc2V0UXVhbnRpdHkBBQVhc3NldAQDZXJyAwkBAiE9AggFAWkGY2FsbGVyBQR0aGlzCQACAQIZc3Rha2U6IG9ubHkgdGhpcyBjb250cmFjdAMJAGcCAAAFB2Ftb3VudF8JAAIBAhtzdGFrZTogaW52YWxpZCBzdGFrZSBhbW91bnQDCQBmAgUHYW1vdW50XwkBEF9nZXRBc3NldEJhbGFuY2UCBQliYXNlQXNzZXQFBHRoaXMJAAIBAiBzdGFrZTogaW5zdWZmaWNpZW50IHN0YWtlIGFtb3VudAMJAAACBQ1hc3NldFF1YW50aXR5BQtaRVJPX0JJR0lOVAkAAgECH3N0YWtlOiBubyBkZXBvc2l0cyB0byBzdGFrZSBmb3IFBHVuaXQDCQAAAgUDZXJyBQNlcnIECGxhc3RSYXRlCQELX2xvYWRCaWdJbnQCBQ1LRVlfTEFTVF9SQVRFBQ5QRVJDRU5UX0ZBQ1RPUgQLY3VycmVudFJhdGUJAQtfbG9hZEJpZ0ludAIFEEtFWV9DVVJSRU5UX1JBVEUFC1pFUk9fQklHSU5UBApsYXN0SGVpZ2h0CQEIX2xvYWRJbnQCBQ9LRVlfTEFTVF9IRUlHSFQAAAQMdGFyZ2V0SGVpZ2h0CQEIX2xvYWRJbnQCBRFLRVlfVEFSR0VUX0hFSUdIVAAABA9taW5UYXJnZXRIZWlnaHQJAJcDAQkAzAgCBQx0YXJnZXRIZWlnaHQJAMwIAggFCWxhc3RCbG9jawZoZWlnaHQFA25pbAQHYWN0aW9ucwMJAAACBQ9taW5UYXJnZXRIZWlnaHQIBQlsYXN0QmxvY2sGaGVpZ2h0BA9sYXN0UmF0ZVVwZGF0ZWQJALcCAgUIbGFzdFJhdGUJALkCAgkAtgIBCQBlAgUPbWluVGFyZ2V0SGVpZ2h0BQpsYXN0SGVpZ2h0BQtjdXJyZW50UmF0ZQQPcmVtYWluaW5nUmV3YXJkCQC5AgIFC2N1cnJlbnRSYXRlCQC2AgEJAGUCBQx0YXJnZXRIZWlnaHQFD21pblRhcmdldEhlaWdodAQSY3VycmVudFJhdGVVcGRhdGVkCQC8AgMJALcCAgkAuQICCQC2AgEFB2Ftb3VudF8FDlBFUkNFTlRfRkFDVE9SBQ9yZW1haW5pbmdSZXdhcmQFCk9ORV9CSUdJTlQJALkCAgUNYXNzZXRRdWFudGl0eQkAtgIBBQ1zcHJlYWRCbG9ja3NfBBFsYXN0SGVpZ2h0VXBkYXRlZAgFCWxhc3RCbG9jawZoZWlnaHQEE3RhcmdldEhlaWdodFVwZGF0ZWQJAGQCBRFsYXN0SGVpZ2h0VXBkYXRlZAUNc3ByZWFkQmxvY2tzXwkAzAgCCQELQmluYXJ5RW50cnkCBQ1LRVlfTEFTVF9SQVRFCQCdAwEFD2xhc3RSYXRlVXBkYXRlZAkAzAgCCQELQmluYXJ5RW50cnkCBRBLRVlfQ1VSUkVOVF9SQVRFCQCdAwEFEmN1cnJlbnRSYXRlVXBkYXRlZAkAzAgCCQEMSW50ZWdlckVudHJ5AgUPS0VZX0xBU1RfSEVJR0hUBRFsYXN0SGVpZ2h0VXBkYXRlZAkAzAgCCQEMSW50ZWdlckVudHJ5AgURS0VZX1RBUkdFVF9IRUlHSFQFE3RhcmdldEhlaWdodFVwZGF0ZWQFA25pbAMJAGYCBQx0YXJnZXRIZWlnaHQFCmxhc3RIZWlnaHQED2xhc3RSYXRlVXBkYXRlZAkAtwICBQhsYXN0UmF0ZQkAuQICCQC2AgEJAGUCBQx0YXJnZXRIZWlnaHQFCmxhc3RIZWlnaHQFC2N1cnJlbnRSYXRlBBJjdXJyZW50UmF0ZVVwZGF0ZWQJALwCAwkAtgIBBQdhbW91bnRfBQ5QRVJDRU5UX0ZBQ1RPUgkAuQICBQ1hc3NldFF1YW50aXR5CQC2AgEFDXNwcmVhZEJsb2Nrc18EEWxhc3RIZWlnaHRVcGRhdGVkCAUJbGFzdEJsb2NrBmhlaWdodAQTdGFyZ2V0SGVpZ2h0VXBkYXRlZAkAZAIFEWxhc3RIZWlnaHRVcGRhdGVkBQ1zcHJlYWRCbG9ja3NfCQDMCAIJAQtCaW5hcnlFbnRyeQIFDUtFWV9MQVNUX1JBVEUJAJ0DAQUPbGFzdFJhdGVVcGRhdGVkCQDMCAIJAQtCaW5hcnlFbnRyeQIFEEtFWV9DVVJSRU5UX1JBVEUJAJ0DAQUSY3VycmVudFJhdGVVcGRhdGVkCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQ9LRVlfTEFTVF9IRUlHSFQFEWxhc3RIZWlnaHRVcGRhdGVkCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRFLRVlfVEFSR0VUX0hFSUdIVAUTdGFyZ2V0SGVpZ2h0VXBkYXRlZAUDbmlsBBJjdXJyZW50UmF0ZVVwZGF0ZWQJALwCAwkAtgIBBQdhbW91bnRfBQ5QRVJDRU5UX0ZBQ1RPUgkAuQICBQ1hc3NldFF1YW50aXR5CQC2AgEFDXNwcmVhZEJsb2Nrc18EEWxhc3RIZWlnaHRVcGRhdGVkCAUJbGFzdEJsb2NrBmhlaWdodAQTdGFyZ2V0SGVpZ2h0VXBkYXRlZAkAZAIFEWxhc3RIZWlnaHRVcGRhdGVkBQ1zcHJlYWRCbG9ja3NfCQDMCAIJAQtCaW5hcnlFbnRyeQIFEEtFWV9DVVJSRU5UX1JBVEUJAJ0DAQUSY3VycmVudFJhdGVVcGRhdGVkCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQ9LRVlfTEFTVF9IRUlHSFQFEWxhc3RIZWlnaHRVcGRhdGVkCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRFLRVlfVEFSR0VUX0hFSUdIVAUTdGFyZ2V0SGVpZ2h0VXBkYXRlZAUDbmlsBAxzdGFrZUFjdGlvbnMJAQ5fdXBkYXRlU3Rha2luZwMFCWJhc2VBc3NldAUHYW1vdW50XwkBE19sb2FkU3Rha2luZ0FkYXB0ZXIACQCUCgIJAM4IAgUHYWN0aW9ucwUMc3Rha2VBY3Rpb25zBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBCHdpdGhkcmF3AAQGY2FsbGVyCQClCAEIBQFpBmNhbGxlcgQJYmFzZUFzc2V0CQEOX2xvYWRCYXNlQXNzZXQABAVhc3NldAkBCl9sb2FkQXNzZXQABA1hc3NldFF1YW50aXR5CQC2AgEJARFfZ2V0QXNzZXRRdWFudGl0eQEFBWFzc2V0BANlcnIDCQBmAgABCQCQAwEIBQFpCHBheW1lbnRzCQACAQIVd2l0aGRyYXc6IG5vIHBheW1lbnRzAwkBAiE9AggJAJEDAggFAWkIcGF5bWVudHMAAAdhc3NldElkBQVhc3NldAkAAgECKXdpdGhkcmF3OiBwYXltZW50IGlzIG5vdCBpbiBjb3JyZWN0IGFzc2V0AwkAZwIAAAgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQJAAIBAiB3aXRoZHJhdzogaW52YWxpZCBwYXltZW50IGFtb3VudAUEdW5pdAMJAAACBQNlcnIFA2VycgQKY2hlY2twb2ludAkBC19jaGVja3BvaW50AQcDCQAAAgUKY2hlY2twb2ludAUKY2hlY2twb2ludAQIbGFzdFJhdGUJAQtfbG9hZEJpZ0ludAIFDUtFWV9MQVNUX1JBVEUFDlBFUkNFTlRfRkFDVE9SBAtjdXJyZW50UmF0ZQkBC19sb2FkQmlnSW50AgUQS0VZX0NVUlJFTlRfUkFURQULWkVST19CSUdJTlQECmxhc3RIZWlnaHQJAQhfbG9hZEludAIFD0tFWV9MQVNUX0hFSUdIVAAABAx0YXJnZXRIZWlnaHQJAJcDAQkAzAgCCQEIX2xvYWRJbnQCBRFLRVlfVEFSR0VUX0hFSUdIVAAACQDMCAIIBQlsYXN0QmxvY2sGaGVpZ2h0BQNuaWwED2xhc3RSYXRlVXBkYXRlZAkAtwICBQhsYXN0UmF0ZQkAuQICBQtjdXJyZW50UmF0ZQkAtgIBCQBlAgUMdGFyZ2V0SGVpZ2h0BQpsYXN0SGVpZ2h0BApiYXNlQW1vdW50CQCgAwEJAL0CBAkAtgIBCAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAUPbGFzdFJhdGVVcGRhdGVkBQ5QRVJDRU5UX0ZBQ1RPUgUFRkxPT1IEEmN1cnJlbnRSYXRlVXBkYXRlZAkAvQIEBQtjdXJyZW50UmF0ZQUNYXNzZXRRdWFudGl0eQkAuAICBQ1hc3NldFF1YW50aXR5CQC2AgEICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50BQVGTE9PUgQRbGFzdEhlaWdodFVwZGF0ZWQFDHRhcmdldEhlaWdodAQMc3Rha2VBY3Rpb25zCQEOX3VwZGF0ZVN0YWtpbmcDBQliYXNlQXNzZXQJAGgCAP///////////wEFCmJhc2VBbW91bnQJARNfbG9hZFN0YWtpbmdBZGFwdGVyAAkAlAoCCQDOCAIFDHN0YWtlQWN0aW9ucwkAzAgCCQEEQnVybgIFBWFzc2V0CAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUBaQZjYWxsZXIFCmJhc2VBbW91bnQFBHVuaXQJAMwIAgkBC0JpbmFyeUVudHJ5AgUNS0VZX0xBU1RfUkFURQkAnQMBBQ9sYXN0UmF0ZVVwZGF0ZWQJAMwIAgkBC0JpbmFyeUVudHJ5AgUQS0VZX0NVUlJFTlRfUkFURQkAnQMBBRJjdXJyZW50UmF0ZVVwZGF0ZWQJAMwIAgkBDEludGVnZXJFbnRyeQIFD0tFWV9MQVNUX0hFSUdIVAURbGFzdEhlaWdodFVwZGF0ZWQFA25pbAUEdW5pdAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgECdHgBBnZlcmlmeQAEByRtYXRjaDAJAKIIAQUMS0VZX01VTFRJU0lHAwkAAQIFByRtYXRjaDACBlN0cmluZwQIbXVsdGlzaWcFByRtYXRjaDAJAQt2YWx1ZU9yRWxzZQIJAJsIAgkBEUBleHRyTmF0aXZlKDEwNjIpAQUIbXVsdGlzaWcJALkJAgkAzAgCBQpLRVlfU1RBVFVTCQDMCAIJAKUIAQUEdGhpcwkAzAgCCQDYBAEIBQJ0eAJpZAUDbmlsBQlTRVBBUkFUT1IHCQD0AwMIBQJ0eAlib2R5Qnl0ZXMJAJEDAggFAnR4BnByb29mcwAACAUCdHgPc2VuZGVyUHVibGljS2V5G/fxcA==",
    "height": 2322649,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEPARATOR = "__"
5+
6+let WAVES = "WAVES"
7+
8+let KEY_MULTISIG = "MULTISIG"
9+
10+let KEY_STATUS = "STATUS"
11+
12+let KEY_BASE_ASSET = "BASE_ASSET"
13+
14+let KEY_ASSET = "ASSET"
15+
16+let KEY_STAKING_ADAPTER = "STAKING_ADAPTER"
17+
18+let KEY_STAKING_AMOUNT = "STAKING_AMOUNT"
19+
20+let KEY_LAST_RATE = "LAST_RATE"
21+
22+let KEY_CURRENT_RATE = "CURRENT_RATE"
23+
24+let KEY_LAST_HEIGHT = "LAST_HEIGHT"
25+
26+let KEY_TARGET_HEIGHT = "TARGET_HEIGHT"
27+
28+let FUNC_STAKE = "stake"
29+
30+let FUNC_UNSTAKE = "unstake"
31+
32+let FUNC_CLAIM_REWARD = "claimReward"
33+
34+let PERCENT_FACTOR = toBigInt(1000000000000)
35+
36+let ZERO_BIGINT = toBigInt(0)
37+
38+let ONE_BIGINT = toBigInt(1)
39+
40+func _validateAddress (address_) = match addressFromString(address_) {
41+    case a: Address => 
42+        true
43+    case _ => 
44+        false
45+}
46+
47+
48+func _validateAsset (asset_) = if ((asset_ == WAVES))
49+    then true
50+    else     match assetInfo(fromBase58String(asset_)) {
51+        case a: Asset => 
52+            true
53+        case _ => 
54+            false
55+    }
56+
57+
58+func _toAssetVector (asset_) = if ((asset_ == WAVES))
59+    then unit
60+    else fromBase58String(asset_)
61+
62+
63+func _getAssetDecimals (asset_) = match asset_ {
64+    case a: ByteVector => 
65+        match assetInfo(a) {
66+            case asset: Asset => 
67+                asset.decimals
68+            case _ => 
69+                throw("_getAssetDecimals: no such asset")
70+        }
71+    case _ => 
72+        8
73+}
74+
75+
76+func _getAssetQuantity (asset_) = match assetInfo(asset_) {
77+    case a: Asset => 
78+        a.quantity
79+    case _ => 
80+        throw("_getAssetQuantity: no such asset")
81+}
82+
83+
84+func _getAssetBalance (asset_,address) = match asset_ {
85+    case a: ByteVector => 
86+        assetBalance(address, a)
87+    case _ => 
88+        wavesBalance(address).regular
89+}
90+
91+
92+func _loadBaseAsset () = match getString(KEY_BASE_ASSET) {
93+    case a: String => 
94+        if ((a == WAVES))
95+            then unit
96+            else fromBase58String(a)
97+    case _ => 
98+        throw("_loadBaseAsset: no base asset")
99+}
100+
101+
102+func _loadStakingAdapter () = match getString(KEY_STAKING_ADAPTER) {
103+    case a: String => 
104+        addressFromStringValue(a)
105+    case _ => 
106+        throw("_loadStakingAdapter: no staking adapter")
107+}
108+
109+
110+func _loadInt (key_,default_) = match getInteger(key_) {
111+    case a: Int => 
112+        a
113+    case _ => 
114+        default_
115+}
116+
117+
118+func _loadBigInt (key_,default_) = match getBinary(key_) {
119+    case a: ByteVector => 
120+        toBigInt(a)
121+    case _ => 
122+        default_
123+}
124+
125+
126+func _loadAsset () = match getString(KEY_ASSET) {
127+    case a: String => 
128+        fromBase58String(a)
129+    case _ => 
130+        base58''
131+}
132+
133+
134+func _updateStaking (asset_,amount_,adapter_) = {
135+    let stakingAmount = _loadInt(KEY_STAKING_AMOUNT, 0)
136+    let newStakingAmount = (stakingAmount + amount_)
137+    let invocation = if ((amount_ > 0))
138+        then invoke(adapter_, FUNC_STAKE, nil, [AttachedPayment(asset_, amount_)])
139+        else invoke(adapter_, FUNC_UNSTAKE, [(-1 * amount_)], nil)
140+    if ((invocation == invocation))
141+        then [IntegerEntry(KEY_STAKING_AMOUNT, newStakingAmount)]
142+        else throw("Strict value is not equal to itself.")
143+    }
144+
145+
146+func _checkpoint (compensation) = {
147+    let invocation = invoke(_loadStakingAdapter(), FUNC_CLAIM_REWARD, nil, nil)
148+    if ((invocation == invocation))
149+        then         match invocation {
150+            case reward: (Int, Int, Int) => 
151+                if (compensation)
152+                    then {
153+                        let stake = invoke(this, FUNC_STAKE, [reward._1, reward._3], nil)
154+                        if ((stake == stake))
155+                            then $Tuple2(true, reward._2)
156+                            else throw("Strict value is not equal to itself.")
157+                        }
158+                    else {
159+                        let stake = invoke(this, FUNC_STAKE, [(reward._1 + reward._2), reward._3], nil)
160+                        if ((stake == stake))
161+                            then $Tuple2(true, 0)
162+                            else throw("Strict value is not equal to itself.")
163+                        }
164+            case _ => 
165+                $Tuple2(false, 0)
166+        }
167+        else throw("Strict value is not equal to itself.")
168+    }
169+
170+
171+@Callable(i)
172+func init (multisig_,tokenName_,tokenDescr_,baseAsset_,stakingAdapter_) = {
173+    let asset = _loadAsset()
174+    let baseAsset = _toAssetVector(baseAsset_)
175+    let err = if ((asset != base58''))
176+        then throw("init: already initialized")
177+        else if (!(_validateAddress(multisig_)))
178+            then throw("init: invalid multisig address")
179+            else if (if ((4 > size(tokenName_)))
180+                then true
181+                else (size(tokenName_) > 16))
182+                then throw("init: invalid token name")
183+                else if ((size(tokenDescr_) > 1000))
184+                    then throw("init: invalid token description")
185+                    else if (!(_validateAsset(baseAsset_)))
186+                        then throw("init: invalid base asset")
187+                        else if (!(_validateAddress(stakingAdapter_)))
188+                            then throw("init: invalid staking adapter")
189+                            else if ((size(i.payments) != 1))
190+                                then throw("init: payment is not present")
191+                                else if ((i.payments[0].assetId != baseAsset))
192+                                    then throw("init: payment is not in base asset")
193+                                    else if ((0 >= i.payments[0].amount))
194+                                        then throw("init: invalid payment amount")
195+                                        else unit
196+    if ((err == err))
197+        then {
198+            let tokenDecimals = _getAssetDecimals(baseAsset)
199+            let issue = Issue(tokenName_, tokenDescr_, i.payments[0].amount, tokenDecimals, true)
200+            let assetId = calculateAssetId(issue)
201+            let stakeActions = _updateStaking(baseAsset, i.payments[0].amount, addressFromStringValue(stakingAdapter_))
202+            $Tuple2(([StringEntry(KEY_MULTISIG, multisig_), StringEntry(KEY_BASE_ASSET, baseAsset_), StringEntry(KEY_STAKING_ADAPTER, stakingAdapter_), StringEntry(KEY_ASSET, toBase58String(assetId)), issue] ++ stakeActions), unit)
203+            }
204+        else throw("Strict value is not equal to itself.")
205+    }
206+
207+
208+
209+@Callable(i)
210+func getRate () = {
211+    let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
212+    let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
213+    let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
214+    let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), lastBlock.height])
215+    let rate = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
216+    $Tuple2(nil, toString(rate))
217+    }
218+
219+
220+
221+@Callable(i)
222+func checkpoint () = {
223+    let checkpoint = _checkpoint(true)
224+    if ((checkpoint == checkpoint))
225+        then if (!(checkpoint._1))
226+            then throw("checkpoint: no reward")
227+            else if ((checkpoint._2 > 0))
228+                then $Tuple2([ScriptTransfer(i.originCaller, checkpoint._2, _loadBaseAsset())], unit)
229+                else $Tuple2(nil, unit)
230+        else throw("Strict value is not equal to itself.")
231+    }
232+
233+
234+
235+@Callable(i)
236+func deposit () = {
237+    let caller = toString(i.caller)
238+    let baseAsset = _loadBaseAsset()
239+    let asset = _loadAsset()
240+    let assetQuantity = toBigInt(_getAssetQuantity(asset))
241+    let err = if ((size(i.payments) != 1))
242+        then throw("deposit: no payments")
243+        else if ((i.payments[0].assetId != baseAsset))
244+            then throw("deposit: payment is not in base asset")
245+            else if ((0 >= i.payments[0].amount))
246+                then throw("deposit: invalid payment amount")
247+                else unit
248+    if ((err == err))
249+        then {
250+            let checkpoint = _checkpoint(false)
251+            if ((checkpoint == checkpoint))
252+                then {
253+                    let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
254+                    let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
255+                    let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
256+                    let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), lastBlock.height])
257+                    let lastRateUpdated = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
258+                    let issueAmount = toInt(fraction(toBigInt(i.payments[0].amount), PERCENT_FACTOR, lastRateUpdated, FLOOR))
259+                    let currentRateUpdated = fraction(currentRate, assetQuantity, (assetQuantity + toBigInt(issueAmount)), FLOOR)
260+                    let lastHeightUpdated = targetHeight
261+                    let stakeActions = _updateStaking(baseAsset, i.payments[0].amount, _loadStakingAdapter())
262+                    $Tuple2(([Reissue(asset, issueAmount, true), ScriptTransfer(i.caller, issueAmount, asset), BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated)] ++ stakeActions), unit)
263+                    }
264+                else throw("Strict value is not equal to itself.")
265+            }
266+        else throw("Strict value is not equal to itself.")
267+    }
268+
269+
270+
271+@Callable(i)
272+func stake (amount_,spreadBlocks_) = {
273+    let caller = toString(i.caller)
274+    let baseAsset = _loadBaseAsset()
275+    let asset = _loadAsset()
276+    let assetQuantity = toBigInt(_getAssetQuantity(asset))
277+    let err = if ((i.caller != this))
278+        then throw("stake: only this contract")
279+        else if ((0 >= amount_))
280+            then throw("stake: invalid stake amount")
281+            else if ((amount_ > _getAssetBalance(baseAsset, this)))
282+                then throw("stake: insufficient stake amount")
283+                else if ((assetQuantity == ZERO_BIGINT))
284+                    then throw("stake: no deposits to stake for")
285+                    else unit
286+    if ((err == err))
287+        then {
288+            let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
289+            let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
290+            let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
291+            let targetHeight = _loadInt(KEY_TARGET_HEIGHT, 0)
292+            let minTargetHeight = min([targetHeight, lastBlock.height])
293+            let actions = if ((minTargetHeight == lastBlock.height))
294+                then {
295+                    let lastRateUpdated = (lastRate + (toBigInt((minTargetHeight - lastHeight)) * currentRate))
296+                    let remainingReward = (currentRate * toBigInt((targetHeight - minTargetHeight)))
297+                    let currentRateUpdated = fraction(((toBigInt(amount_) * PERCENT_FACTOR) + remainingReward), ONE_BIGINT, (assetQuantity * toBigInt(spreadBlocks_)))
298+                    let lastHeightUpdated = lastBlock.height
299+                    let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
300+[BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
301+                    }
302+                else if ((targetHeight > lastHeight))
303+                    then {
304+                        let lastRateUpdated = (lastRate + (toBigInt((targetHeight - lastHeight)) * currentRate))
305+                        let currentRateUpdated = fraction(toBigInt(amount_), PERCENT_FACTOR, (assetQuantity * toBigInt(spreadBlocks_)))
306+                        let lastHeightUpdated = lastBlock.height
307+                        let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
308+[BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
309+                        }
310+                    else {
311+                        let currentRateUpdated = fraction(toBigInt(amount_), PERCENT_FACTOR, (assetQuantity * toBigInt(spreadBlocks_)))
312+                        let lastHeightUpdated = lastBlock.height
313+                        let targetHeightUpdated = (lastHeightUpdated + spreadBlocks_)
314+[BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated), IntegerEntry(KEY_TARGET_HEIGHT, targetHeightUpdated)]
315+                        }
316+            let stakeActions = _updateStaking(baseAsset, amount_, _loadStakingAdapter())
317+            $Tuple2((actions ++ stakeActions), unit)
318+            }
319+        else throw("Strict value is not equal to itself.")
320+    }
321+
322+
323+
324+@Callable(i)
325+func withdraw () = {
326+    let caller = toString(i.caller)
327+    let baseAsset = _loadBaseAsset()
328+    let asset = _loadAsset()
329+    let assetQuantity = toBigInt(_getAssetQuantity(asset))
330+    let err = if ((1 > size(i.payments)))
331+        then throw("withdraw: no payments")
332+        else if ((i.payments[0].assetId != asset))
333+            then throw("withdraw: payment is not in correct asset")
334+            else if ((0 >= i.payments[0].amount))
335+                then throw("withdraw: invalid payment amount")
336+                else unit
337+    if ((err == err))
338+        then {
339+            let checkpoint = _checkpoint(false)
340+            if ((checkpoint == checkpoint))
341+                then {
342+                    let lastRate = _loadBigInt(KEY_LAST_RATE, PERCENT_FACTOR)
343+                    let currentRate = _loadBigInt(KEY_CURRENT_RATE, ZERO_BIGINT)
344+                    let lastHeight = _loadInt(KEY_LAST_HEIGHT, 0)
345+                    let targetHeight = min([_loadInt(KEY_TARGET_HEIGHT, 0), lastBlock.height])
346+                    let lastRateUpdated = (lastRate + (currentRate * toBigInt((targetHeight - lastHeight))))
347+                    let baseAmount = toInt(fraction(toBigInt(i.payments[0].amount), lastRateUpdated, PERCENT_FACTOR, FLOOR))
348+                    let currentRateUpdated = fraction(currentRate, assetQuantity, (assetQuantity - toBigInt(i.payments[0].amount)), FLOOR)
349+                    let lastHeightUpdated = targetHeight
350+                    let stakeActions = _updateStaking(baseAsset, (-1 * baseAmount), _loadStakingAdapter())
351+                    $Tuple2((stakeActions ++ [Burn(asset, i.payments[0].amount), ScriptTransfer(i.caller, baseAmount, unit), BinaryEntry(KEY_LAST_RATE, toBytes(lastRateUpdated)), BinaryEntry(KEY_CURRENT_RATE, toBytes(currentRateUpdated)), IntegerEntry(KEY_LAST_HEIGHT, lastHeightUpdated)]), unit)
352+                    }
353+                else throw("Strict value is not equal to itself.")
354+            }
355+        else throw("Strict value is not equal to itself.")
356+    }
357+
358+
359+@Verifier(tx)
360+func verify () = match getString(KEY_MULTISIG) {
361+    case multisig: String => 
362+        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
363+    case _ => 
364+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
365+}
366+
github/deemru/w8io/873ac7e 
44.74 ms ◑