w8 · tx · HRV···iiw

tx · HRVfuWnYFAayBfwVcU1sZnKDeUZ2AQZav16HjDkexiiw

3PDPzZVLhN1EuzGy4xAxjjTVkawKDLEaHiV:  -0.01400000 Waves

2022.12.26 12:28 [3442564] smart account 3PDPzZVLhN1EuzGy4xAxjjTVkawKDLEaHiV > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HRVfuWnYFAayBfwVcU1sZnKDeUZ2AQZav16HjDkexiiw",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1672046741535,
    "version": 2,
    "chainId": 87,
    "sender": "3PDPzZVLhN1EuzGy4xAxjjTVkawKDLEaHiV",
    "senderPublicKey": "AWbtWgxWu2DDKVdfFLGSrbwR5GjNjaooWJg9h8BwWnvz",
    "proofs": [
        "rj8yVPMJpMpUS7GAqo3M3PhqZ45HxXnVnApmmnozQ9YKePD71fsgc81vMdBHWQBzg5o3Pwk83goPZgVxgg8dGKm"
    ],
    "script": "base64:BgIoCAISBgoECAgICBIAEgASABIECgIBARIAEgMKAQgSAwoBCBIECgIBASIACVNFUEFSQVRPUgICX18ABVdBVkVTAgVXQVZFUwAMS0VZX01VTFRJU0lHAghNVUxUSVNJRwAKS0VZX1NUQVRVUwIGU1RBVFVTAA5LRVlfQkFTRV9BU1NFVAIKQkFTRV9BU1NFVAAJS0VZX0FTU0VUAgVBU1NFVAATS0VZX1NUQUtJTkdfQURBUFRFUgIPU1RBS0lOR19BREFQVEVSABJLRVlfU1RBS0lOR19BTU9VTlQCDlNUQUtJTkdfQU1PVU5UAA1LRVlfTEFTVF9SQVRFAglMQVNUX1JBVEUAEEtFWV9DVVJSRU5UX1JBVEUCDENVUlJFTlRfUkFURQAPS0VZX0xBU1RfSEVJR0hUAgtMQVNUX0hFSUdIVAARS0VZX1RBUkdFVF9IRUlHSFQCDVRBUkdFVF9IRUlHSFQAF0tFWV9TUE9OU09SU0hJUF9NQU5BR0VSAhNTUE9OU09SU0hJUF9NQU5BR0VSAApGVU5DX1NUQUtFAgVzdGFrZQAMRlVOQ19VTlNUQUtFAgd1bnN0YWtlABFGVU5DX0NMQUlNX1JFV0FSRAILY2xhaW1SZXdhcmQADlBFUkNFTlRfRkFDVE9SCQC2AgEAgKCUpY0dAAtaRVJPX0JJR0lOVAkAtgIBAAAACk9ORV9CSUdJTlQJALYCAQABAAtJTklUX0FNT1VOVACAwtcvARBfdmFsaWRhdGVBZGRyZXNzAQhhZGRyZXNzXwQHJG1hdGNoMAkApggBBQhhZGRyZXNzXwMJAAECBQckbWF0Y2gwAgdBZGRyZXNzBAFhBQckbWF0Y2gwBgcBDl92YWxpZGF0ZUFzc2V0AQZhc3NldF8DCQAAAgUGYXNzZXRfBQVXQVZFUwYEByRtYXRjaDAJAOwHAQkA2QQBBQZhc3NldF8DCQABAgUHJG1hdGNoMAIFQXNzZXQEAWEFByRtYXRjaDAGBwEOX3RvQXNzZXRWZWN0b3IBBmFzc2V0XwMJAAACBQZhc3NldF8FBVdBVkVTBQR1bml0CQDZBAEFBmFzc2V0XwERX2dldEFzc2V0RGVjaW1hbHMBBmFzc2V0XwQHJG1hdGNoMAUGYXNzZXRfAwkAAQIFByRtYXRjaDACCkJ5dGVWZWN0b3IEAWEFByRtYXRjaDAEByRtYXRjaDEJAOwHAQUBYQMJAAECBQckbWF0Y2gxAgVBc3NldAQFYXNzZXQFByRtYXRjaDEIBQVhc3NldAhkZWNpbWFscwkAAgECIF9nZXRBc3NldERlY2ltYWxzOiBubyBzdWNoIGFzc2V0AAgBEV9nZXRBc3NldFF1YW50aXR5AQZhc3NldF8EByRtYXRjaDAJAOwHAQUGYXNzZXRfAwkAAQIFByRtYXRjaDACBUFzc2V0BAFhBQckbWF0Y2gwCAUBYQhxdWFudGl0eQkAAgECIF9nZXRBc3NldFF1YW50aXR5OiBubyBzdWNoIGFzc2V0ARBfZ2V0QXNzZXRCYWxhbmNlAgZhc3NldF8HYWRkcmVzcwQHJG1hdGNoMAUGYXNzZXRfAwkAAQIFByRtYXRjaDACCkJ5dGVWZWN0b3IEAWEFByRtYXRjaDAJAPAHAgUHYWRkcmVzcwUBYQgJAO8HAQUHYWRkcmVzcwdyZWd1bGFyAQ5fbG9hZEJhc2VBc3NldAAEByRtYXRjaDAJAKIIAQUOS0VZX0JBU0VfQVNTRVQDCQABAgUHJG1hdGNoMAIGU3RyaW5nBAFhBQckbWF0Y2gwAwkAAAIFAWEFBVdBVkVTBQR1bml0CQDZBAEFAWEJAAIBAh1fbG9hZEJhc2VBc3NldDogbm8gYmFzZSBhc3NldAETX2xvYWRTdGFraW5nQWRhcHRlcgAEByRtYXRjaDAJAKIIAQUTS0VZX1NUQUtJTkdfQURBUFRFUgMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAWEFByRtYXRjaDAJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAWEJAAIBAidfbG9hZFN0YWtpbmdBZGFwdGVyOiBubyBzdGFraW5nIGFkYXB0ZXIBF19sb2FkU3BvbnNvcnNoaXBNYW5hZ2VyAAQHJG1hdGNoMAkAoggBBRdLRVlfU1BPTlNPUlNISVBfTUFOQUdFUgMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAWEFByRtYXRjaDAJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAWEJAAIBAi9fbG9hZFNwb25zb3JzaGlwTWFuYWdlcjogbm8gc3BvbnNvcnNoaXAgbWFuYWdlcgEIX2xvYWRJbnQCBGtleV8IZGVmYXVsdF8EByRtYXRjaDAJAJ8IAQUEa2V5XwMJAAECBQckbWF0Y2gwAgNJbnQEAWEFByRtYXRjaDAFAWEFCGRlZmF1bHRfAQtfbG9hZEJpZ0ludAIEa2V5XwhkZWZhdWx0XwQHJG1hdGNoMAkAoQgBBQRrZXlfAwkAAQIFByRtYXRjaDACCkJ5dGVWZWN0b3IEAWEFByRtYXRjaDAJAJ4DAQUBYQUIZGVmYXVsdF8BCl9sb2FkQXNzZXQABAckbWF0Y2gwCQCiCAEFCUtFWV9BU1NFVAMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAWEFByRtYXRjaDAJANkEAQUBYQEAAQ5fdXBkYXRlU3Rha2luZwMGYXNzZXRfB2Ftb3VudF8IYWRhcHRlcl8EDXN0YWtpbmdBbW91bnQJAQhfbG9hZEludAIFEktFWV9TVEFLSU5HX0FNT1VOVAAABBBuZXdTdGFraW5nQW1vdW50CQBkAgUNc3Rha2luZ0Ftb3VudAUHYW1vdW50XwQKaW52b2NhdGlvbgMJAGYCBQdhbW91bnRfAAAJAPwHBAUIYWRhcHRlcl8FCkZVTkNfU1RBS0UFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUGYXNzZXRfBQdhbW91bnRfBQNuaWwJAPwHBAUIYWRhcHRlcl8FDEZVTkNfVU5TVEFLRQkAzAgCCQBoAgD///////////8BBQdhbW91bnRfBQNuaWwFA25pbAMJAAACBQppbnZvY2F0aW9uBQppbnZvY2F0aW9uCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRJLRVlfU1RBS0lOR19BTU9VTlQFEG5ld1N0YWtpbmdBbW91bnQFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgELX2NoZWNrcG9pbnQBDGNvbXBlbnNhdGlvbgQKaW52b2NhdGlvbgkA/AcECQETX2xvYWRTdGFraW5nQWRhcHRlcgAFEUZVTkNfQ0xBSU1fUkVXQVJEBQNuaWwFA25pbAMJAAACBQppbnZvY2F0aW9uBQppbnZvY2F0aW9uBAckbWF0Y2gwBQppbnZvY2F0aW9uAwkAAQIFByRtYXRjaDACDyhJbnQsIEludCwgSW50KQQGcmV3YXJkBQckbWF0Y2gwAwUMY29tcGVuc2F0aW9uBAVzdGFrZQkA/AcEBQR0aGlzBQpGVU5DX1NUQUtFCQDMCAIIBQZyZXdhcmQCXzEJAMwIAggFBnJld2FyZAJfMwUDbmlsBQNuaWwDCQAAAgUFc3Rha2UFBXN0YWtlCQCUCgIGCAUGcmV3YXJkAl8yCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBAVzdGFrZQkA/AcEBQR0aGlzBQpGVU5DX1NUQUtFCQDMCAIJAGQCCAUGcmV3YXJkAl8xCAUGcmV3YXJkAl8yCQDMCAIIBQZyZXdhcmQCXzMFA25pbAUDbmlsAwkAAAIFBXN0YWtlBQVzdGFrZQkAlAoCBgAACQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQCUCgIHAAAJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAWkBBGluaXQECnRva2VuTmFtZV8LdG9rZW5EZXNjcl8KYmFzZUFzc2V0Xw9zdGFraW5nQWRhcHRlcl8ECG11bHRpc2lnCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQUMS0VZX01VTFRJU0lHAhVpbml0OiBubyBtdWx0aXNpZyBzZXQDCQAAAgUIbXVsdGlzaWcFCG11bHRpc2lnBAVhc3NldAkBCl9sb2FkQXNzZXQABAliYXNlQXNzZXQJAQ5fdG9Bc3NldFZlY3RvcgEFCmJhc2VBc3NldF8EA2VycgMJAQIhPQIIBQFpBmNhbGxlcgUEdGhpcwkAAgECF2luaXQ6IHBlcm1pc3Npb24gZGVuaWVkAwkBAiE9AgUFYXNzZXQBAAkAAgECGWluaXQ6IGFscmVhZHkgaW5pdGlhbGl6ZWQDAwkAZgIABAkAsQIBBQp0b2tlbk5hbWVfBgkAZgIJALECAQUKdG9rZW5OYW1lXwAQCQACAQIYaW5pdDogaW52YWxpZCB0b2tlbiBuYW1lAwkAZgIJALECAQULdG9rZW5EZXNjcl8A6AcJAAIBAh9pbml0OiBpbnZhbGlkIHRva2VuIGRlc2NyaXB0aW9uAwkBASEBCQEOX3ZhbGlkYXRlQXNzZXQBBQpiYXNlQXNzZXRfCQACAQIYaW5pdDogaW52YWxpZCBiYXNlIGFzc2V0AwkBASEBCQEQX3ZhbGlkYXRlQWRkcmVzcwEFD3N0YWtpbmdBZGFwdGVyXwkAAgECHWluaXQ6IGludmFsaWQgc3Rha2luZyBhZGFwdGVyBQR1bml0AwkAAAIFA2VycgUDZXJyBA10b2tlbkRlY2ltYWxzCQERX2dldEFzc2V0RGVjaW1hbHMBBQliYXNlQXNzZXQEBWlzc3VlCQDCCAUFCnRva2VuTmFtZV8FC3Rva2VuRGVzY3JfBQtJTklUX0FNT1VOVAUNdG9rZW5EZWNpbWFscwYEB2Fzc2V0SWQJALgIAQUFaXNzdWUEDHN0YWtlQWN0aW9ucwkBDl91cGRhdGVTdGFraW5nAwUJYmFzZUFzc2V0BQtJTklUX0FNT1VOVAkBEUBleHRyTmF0aXZlKDEwNjIpAQUPc3Rha2luZ0FkYXB0ZXJfCQCUCgIJAM4IAgkAzAgCCQELU3RyaW5nRW50cnkCBQ5LRVlfQkFTRV9BU1NFVAUKYmFzZUFzc2V0XwkAzAgCCQELU3RyaW5nRW50cnkCBRNLRVlfU1RBS0lOR19BREFQVEVSBQ9zdGFraW5nQWRhcHRlcl8JAMwIAgkBC1N0cmluZ0VudHJ5AgUJS0VZX0FTU0VUCQDYBAEFB2Fzc2V0SWQJAMwIAgUFaXNzdWUFA25pbAUMc3Rha2VBY3Rpb25zBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBB2dldFJhdGUABAhsYXN0UmF0ZQkBC19sb2FkQmlnSW50AgUNS0VZX0xBU1RfUkFURQUOUEVSQ0VOVF9GQUNUT1IEC2N1cnJlbnRSYXRlCQELX2xvYWRCaWdJbnQCBRBLRVlfQ1VSUkVOVF9SQVRFBQtaRVJPX0JJR0lOVAQKbGFzdEhlaWdodAkBCF9sb2FkSW50AgUPS0VZX0xBU1RfSEVJR0hUAAAEDHRhcmdldEhlaWdodAkAlwMBCQDMCAIJAQhfbG9hZEludAIFEUtFWV9UQVJHRVRfSEVJR0hUAAAJAMwIAgUGaGVpZ2h0BQNuaWwEBHJhdGUJALcCAgUIbGFzdFJhdGUJALkCAgULY3VycmVudFJhdGUJALYCAQkAZQIFDHRhcmdldEhlaWdodAUKbGFzdEhlaWdodAkAlAoCBQNuaWwJAKYDAQUEcmF0ZQFpAQpjaGVja3BvaW50AAQKY2hlY2twb2ludAkBC19jaGVja3BvaW50AQYDCQAAAgUKY2hlY2twb2ludAUKY2hlY2twb2ludAMJAQEhAQgFCmNoZWNrcG9pbnQCXzEJAAIBAhVjaGVja3BvaW50OiBubyByZXdhcmQDCQBmAggFCmNoZWNrcG9pbnQCXzIAAAkAlAoCCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQFpDG9yaWdpbkNhbGxlcggFCmNoZWNrcG9pbnQCXzIJAQ5fbG9hZEJhc2VBc3NldAAFA25pbAUEdW5pdAkAlAoCBQNuaWwFBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEHZGVwb3NpdAAEBmNhbGxlcgkApQgBCAUBaQZjYWxsZXIECWJhc2VBc3NldAkBDl9sb2FkQmFzZUFzc2V0AAQFYXNzZXQJAQpfbG9hZEFzc2V0AAQNYXNzZXRRdWFudGl0eQkAtgIBCQERX2dldEFzc2V0UXVhbnRpdHkBBQVhc3NldAQDZXJyAwkBAiE9AgkAkAMBCAUBaQhwYXltZW50cwABCQACAQIUZGVwb3NpdDogbm8gcGF5bWVudHMDCQECIT0CCAkAkQMCCAUBaQhwYXltZW50cwAAB2Fzc2V0SWQFCWJhc2VBc3NldAkAAgECJWRlcG9zaXQ6IHBheW1lbnQgaXMgbm90IGluIGJhc2UgYXNzZXQDCQBnAgAACAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAkAAgECH2RlcG9zaXQ6IGludmFsaWQgcGF5bWVudCBhbW91bnQFBHVuaXQDCQAAAgUDZXJyBQNlcnIECmNoZWNrcG9pbnQJAQtfY2hlY2twb2ludAEHAwkAAAIFCmNoZWNrcG9pbnQFCmNoZWNrcG9pbnQECGxhc3RSYXRlCQELX2xvYWRCaWdJbnQCBQ1LRVlfTEFTVF9SQVRFBQ5QRVJDRU5UX0ZBQ1RPUgQLY3VycmVudFJhdGUJAQtfbG9hZEJpZ0ludAIFEEtFWV9DVVJSRU5UX1JBVEUFC1pFUk9fQklHSU5UBApsYXN0SGVpZ2h0CQEIX2xvYWRJbnQCBQ9LRVlfTEFTVF9IRUlHSFQAAAQMdGFyZ2V0SGVpZ2h0CQCXAwEJAMwIAgkBCF9sb2FkSW50AgURS0VZX1RBUkdFVF9IRUlHSFQAAAkAzAgCBQZoZWlnaHQFA25pbAQPbGFzdFJhdGVVcGRhdGVkCQC3AgIFCGxhc3RSYXRlCQC5AgIFC2N1cnJlbnRSYXRlCQC2AgEJAGUCBQx0YXJnZXRIZWlnaHQFCmxhc3RIZWlnaHQEC2lzc3VlQW1vdW50CQCgAwEJAL0CBAkAtgIBCAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAUOUEVSQ0VOVF9GQUNUT1IFD2xhc3RSYXRlVXBkYXRlZAUFRkxPT1IEEmN1cnJlbnRSYXRlVXBkYXRlZAkAvQIEBQtjdXJyZW50UmF0ZQUNYXNzZXRRdWFudGl0eQkAtwICBQ1hc3NldFF1YW50aXR5CQC2AgEFC2lzc3VlQW1vdW50BQVGTE9PUgQRbGFzdEhlaWdodFVwZGF0ZWQFDHRhcmdldEhlaWdodAQMc3Rha2VBY3Rpb25zCQEOX3VwZGF0ZVN0YWtpbmcDBQliYXNlQXNzZXQICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50CQETX2xvYWRTdGFraW5nQWRhcHRlcgAJAJQKAgkAzggCCQDMCAIJAQdSZWlzc3VlAwUFYXNzZXQFC2lzc3VlQW1vdW50BgkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUBaQZjYWxsZXIFC2lzc3VlQW1vdW50BQVhc3NldAkAzAgCCQELQmluYXJ5RW50cnkCBQ1LRVlfTEFTVF9SQVRFCQCdAwEFD2xhc3RSYXRlVXBkYXRlZAkAzAgCCQELQmluYXJ5RW50cnkCBRBLRVlfQ1VSUkVOVF9SQVRFCQCdAwEFEmN1cnJlbnRSYXRlVXBkYXRlZAkAzAgCCQEMSW50ZWdlckVudHJ5AgUPS0VZX0xBU1RfSEVJR0hUBRFsYXN0SGVpZ2h0VXBkYXRlZAUDbmlsBQxzdGFrZUFjdGlvbnMFBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEFc3Rha2UCB2Ftb3VudF8Nc3ByZWFkQmxvY2tzXwQGY2FsbGVyCQClCAEIBQFpBmNhbGxlcgQJYmFzZUFzc2V0CQEOX2xvYWRCYXNlQXNzZXQABAVhc3NldAkBCl9sb2FkQXNzZXQABA1hc3NldFF1YW50aXR5CQC2AgEJARFfZ2V0QXNzZXRRdWFudGl0eQEFBWFzc2V0BANlcnIDCQECIT0CCAUBaQZjYWxsZXIFBHRoaXMJAAIBAhlzdGFrZTogb25seSB0aGlzIGNvbnRyYWN0AwkAZwIAAAUHYW1vdW50XwkAAgECG3N0YWtlOiBpbnZhbGlkIHN0YWtlIGFtb3VudAMJAGYCBQdhbW91bnRfCQEQX2dldEFzc2V0QmFsYW5jZQIFCWJhc2VBc3NldAUEdGhpcwkAAgECIHN0YWtlOiBpbnN1ZmZpY2llbnQgc3Rha2UgYW1vdW50AwkAAAIFDWFzc2V0UXVhbnRpdHkFC1pFUk9fQklHSU5UCQACAQIfc3Rha2U6IG5vIGRlcG9zaXRzIHRvIHN0YWtlIGZvcgUEdW5pdAMJAAACBQNlcnIFA2VycgQIbGFzdFJhdGUJAQtfbG9hZEJpZ0ludAIFDUtFWV9MQVNUX1JBVEUFDlBFUkNFTlRfRkFDVE9SBAtjdXJyZW50UmF0ZQkBC19sb2FkQmlnSW50AgUQS0VZX0NVUlJFTlRfUkFURQULWkVST19CSUdJTlQECmxhc3RIZWlnaHQJAQhfbG9hZEludAIFD0tFWV9MQVNUX0hFSUdIVAAABAx0YXJnZXRIZWlnaHQJAQhfbG9hZEludAIFEUtFWV9UQVJHRVRfSEVJR0hUAAAED21pblRhcmdldEhlaWdodAkAlwMBCQDMCAIFDHRhcmdldEhlaWdodAkAzAgCBQZoZWlnaHQFA25pbAQHYWN0aW9ucwMJAAACBQ9taW5UYXJnZXRIZWlnaHQFBmhlaWdodAQPbGFzdFJhdGVVcGRhdGVkCQC3AgIFCGxhc3RSYXRlCQC5AgIJALYCAQkAZQIFD21pblRhcmdldEhlaWdodAUKbGFzdEhlaWdodAULY3VycmVudFJhdGUED3JlbWFpbmluZ1Jld2FyZAkAuQICBQtjdXJyZW50UmF0ZQkAtgIBCQBlAgUMdGFyZ2V0SGVpZ2h0BQ9taW5UYXJnZXRIZWlnaHQEEmN1cnJlbnRSYXRlVXBkYXRlZAkAvAIDCQC3AgIJALkCAgkAtgIBBQdhbW91bnRfBQ5QRVJDRU5UX0ZBQ1RPUgUPcmVtYWluaW5nUmV3YXJkBQpPTkVfQklHSU5UCQC5AgIFDWFzc2V0UXVhbnRpdHkJALYCAQUNc3ByZWFkQmxvY2tzXwQRbGFzdEhlaWdodFVwZGF0ZWQFBmhlaWdodAQTdGFyZ2V0SGVpZ2h0VXBkYXRlZAkAZAIFEWxhc3RIZWlnaHRVcGRhdGVkBQ1zcHJlYWRCbG9ja3NfCQDMCAIJAQtCaW5hcnlFbnRyeQIFDUtFWV9MQVNUX1JBVEUJAJ0DAQUPbGFzdFJhdGVVcGRhdGVkCQDMCAIJAQtCaW5hcnlFbnRyeQIFEEtFWV9DVVJSRU5UX1JBVEUJAJ0DAQUSY3VycmVudFJhdGVVcGRhdGVkCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQ9LRVlfTEFTVF9IRUlHSFQFEWxhc3RIZWlnaHRVcGRhdGVkCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRFLRVlfVEFSR0VUX0hFSUdIVAUTdGFyZ2V0SGVpZ2h0VXBkYXRlZAUDbmlsAwkAZgIFDHRhcmdldEhlaWdodAUKbGFzdEhlaWdodAQPbGFzdFJhdGVVcGRhdGVkCQC3AgIFCGxhc3RSYXRlCQC5AgIJALYCAQkAZQIFDHRhcmdldEhlaWdodAUKbGFzdEhlaWdodAULY3VycmVudFJhdGUEEmN1cnJlbnRSYXRlVXBkYXRlZAkAvAIDCQC2AgEFB2Ftb3VudF8FDlBFUkNFTlRfRkFDVE9SCQC5AgIFDWFzc2V0UXVhbnRpdHkJALYCAQUNc3ByZWFkQmxvY2tzXwQRbGFzdEhlaWdodFVwZGF0ZWQFBmhlaWdodAQTdGFyZ2V0SGVpZ2h0VXBkYXRlZAkAZAIFEWxhc3RIZWlnaHRVcGRhdGVkBQ1zcHJlYWRCbG9ja3NfCQDMCAIJAQtCaW5hcnlFbnRyeQIFDUtFWV9MQVNUX1JBVEUJAJ0DAQUPbGFzdFJhdGVVcGRhdGVkCQDMCAIJAQtCaW5hcnlFbnRyeQIFEEtFWV9DVVJSRU5UX1JBVEUJAJ0DAQUSY3VycmVudFJhdGVVcGRhdGVkCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQ9LRVlfTEFTVF9IRUlHSFQFEWxhc3RIZWlnaHRVcGRhdGVkCQDMCAIJAQxJbnRlZ2VyRW50cnkCBRFLRVlfVEFSR0VUX0hFSUdIVAUTdGFyZ2V0SGVpZ2h0VXBkYXRlZAUDbmlsBBJjdXJyZW50UmF0ZVVwZGF0ZWQJALwCAwkAtgIBBQdhbW91bnRfBQ5QRVJDRU5UX0ZBQ1RPUgkAuQICBQ1hc3NldFF1YW50aXR5CQC2AgEFDXNwcmVhZEJsb2Nrc18EEWxhc3RIZWlnaHRVcGRhdGVkBQZoZWlnaHQEE3RhcmdldEhlaWdodFVwZGF0ZWQJAGQCBRFsYXN0SGVpZ2h0VXBkYXRlZAUNc3ByZWFkQmxvY2tzXwkAzAgCCQELQmluYXJ5RW50cnkCBRBLRVlfQ1VSUkVOVF9SQVRFCQCdAwEFEmN1cnJlbnRSYXRlVXBkYXRlZAkAzAgCCQEMSW50ZWdlckVudHJ5AgUPS0VZX0xBU1RfSEVJR0hUBRFsYXN0SGVpZ2h0VXBkYXRlZAkAzAgCCQEMSW50ZWdlckVudHJ5AgURS0VZX1RBUkdFVF9IRUlHSFQFE3RhcmdldEhlaWdodFVwZGF0ZWQFA25pbAQMc3Rha2VBY3Rpb25zCQEOX3VwZGF0ZVN0YWtpbmcDBQliYXNlQXNzZXQFB2Ftb3VudF8JARNfbG9hZFN0YWtpbmdBZGFwdGVyAAkAlAoCCQDOCAIFB2FjdGlvbnMFDHN0YWtlQWN0aW9ucwUEdW5pdAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQh3aXRoZHJhdwAEBmNhbGxlcgkApQgBCAUBaQZjYWxsZXIECWJhc2VBc3NldAkBDl9sb2FkQmFzZUFzc2V0AAQFYXNzZXQJAQpfbG9hZEFzc2V0AAQNYXNzZXRRdWFudGl0eQkAtgIBCQERX2dldEFzc2V0UXVhbnRpdHkBBQVhc3NldAQDZXJyAwkAZgIAAQkAkAMBCAUBaQhwYXltZW50cwkAAgECFXdpdGhkcmF3OiBubyBwYXltZW50cwMJAQIhPQIICQCRAwIIBQFpCHBheW1lbnRzAAAHYXNzZXRJZAUFYXNzZXQJAAIBAil3aXRoZHJhdzogcGF5bWVudCBpcyBub3QgaW4gY29ycmVjdCBhc3NldAMJAGcCAAAICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50CQACAQIgd2l0aGRyYXc6IGludmFsaWQgcGF5bWVudCBhbW91bnQFBHVuaXQDCQAAAgUDZXJyBQNlcnIECmNoZWNrcG9pbnQJAQtfY2hlY2twb2ludAEHAwkAAAIFCmNoZWNrcG9pbnQFCmNoZWNrcG9pbnQECGxhc3RSYXRlCQELX2xvYWRCaWdJbnQCBQ1LRVlfTEFTVF9SQVRFBQ5QRVJDRU5UX0ZBQ1RPUgQLY3VycmVudFJhdGUJAQtfbG9hZEJpZ0ludAIFEEtFWV9DVVJSRU5UX1JBVEUFC1pFUk9fQklHSU5UBApsYXN0SGVpZ2h0CQEIX2xvYWRJbnQCBQ9LRVlfTEFTVF9IRUlHSFQAAAQMdGFyZ2V0SGVpZ2h0CQCXAwEJAMwIAgkBCF9sb2FkSW50AgURS0VZX1RBUkdFVF9IRUlHSFQAAAkAzAgCBQZoZWlnaHQFA25pbAQPbGFzdFJhdGVVcGRhdGVkCQC3AgIFCGxhc3RSYXRlCQC5AgIFC2N1cnJlbnRSYXRlCQC2AgEJAGUCBQx0YXJnZXRIZWlnaHQFCmxhc3RIZWlnaHQECmJhc2VBbW91bnQJAKADAQkAvQIECQC2AgEICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50BQ9sYXN0UmF0ZVVwZGF0ZWQFDlBFUkNFTlRfRkFDVE9SBQVGTE9PUgQSY3VycmVudFJhdGVVcGRhdGVkCQC9AgQFC2N1cnJlbnRSYXRlBQ1hc3NldFF1YW50aXR5CQC4AgIFDWFzc2V0UXVhbnRpdHkJALYCAQgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQFBUZMT09SBBFsYXN0SGVpZ2h0VXBkYXRlZAUMdGFyZ2V0SGVpZ2h0BAxzdGFrZUFjdGlvbnMJAQ5fdXBkYXRlU3Rha2luZwMFCWJhc2VBc3NldAkAaAIA////////////AQUKYmFzZUFtb3VudAkBE19sb2FkU3Rha2luZ0FkYXB0ZXIACQCUCgIJAM4IAgUMc3Rha2VBY3Rpb25zCQDMCAIJAQRCdXJuAgUFYXNzZXQICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50CQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQFpBmNhbGxlcgUKYmFzZUFtb3VudAUEdW5pdAkAzAgCCQELQmluYXJ5RW50cnkCBQ1LRVlfTEFTVF9SQVRFCQCdAwEFD2xhc3RSYXRlVXBkYXRlZAkAzAgCCQELQmluYXJ5RW50cnkCBRBLRVlfQ1VSUkVOVF9SQVRFCQCdAwEFEmN1cnJlbnRSYXRlVXBkYXRlZAkAzAgCCQEMSW50ZWdlckVudHJ5AgUPS0VZX0xBU1RfSEVJR0hUBRFsYXN0SGVpZ2h0VXBkYXRlZAUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBC3NldE11bHRpc2lnAQltdWx0aXNpZ18EA2VycgMJAQIhPQIIBQFpBmNhbGxlcgUEdGhpcwkAAgECHnNldE11bHRpc2lnOiBwZXJtaXNzaW9uIGRlbmllZAMJAQEhAQkBEF92YWxpZGF0ZUFkZHJlc3MBBQltdWx0aXNpZ18JAAIBAiVzZXRNdWx0aXNpZzogaW52YWxpZCBtdWx0aXNpZyBhZGRyZXNzBQR1bml0AwkAAAIFA2VycgUDZXJyCQCUCgIJAMwIAgkBC1N0cmluZ0VudHJ5AgUMS0VZX01VTFRJU0lHBQltdWx0aXNpZ18FA25pbAUEdW5pdAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpARVzZXRTcG9uc29yc2hpcE1hbmFnZXIBCG1hbmFnZXJfBANlcnIDCQECIT0CCAUBaQZjYWxsZXIFBHRoaXMJAAIBAihzZXRTcG9uc29yc2hpcE1hbmFnZXI6IHBlcm1pc3Npb24gZGVuaWVkAwkBASEBCQEQX3ZhbGlkYXRlQWRkcmVzcwEFCG1hbmFnZXJfCQACAQIuc2V0U3BvbnNvcnNoaXBNYW5hZ2VyOiBpbnZhbGlkIG1hbmFnZXIgYWRkcmVzcwUEdW5pdAMJAAACBQNlcnIFA2VycgkAlAoCCQDMCAIJAQtTdHJpbmdFbnRyeQIFF0tFWV9TUE9OU09SU0hJUF9NQU5BR0VSBQhtYW5hZ2VyXwUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBEXVwZGF0ZVNwb25zb3JzaGlwAhVtaW5TcG9uc29yZWRBc3NldEZlZV8Ud2F2ZXNSZXF1aXJlZEFtb3VudF8EA2VycgMJAQIhPQIIBQFpBmNhbGxlcgkBF19sb2FkU3BvbnNvcnNoaXBNYW5hZ2VyAAkAAgECJHVwZGF0ZVNwb25zb3JzaGlwOiBwZXJtaXNzaW9uIGRlbmllZAMJAGYCAAAFFW1pblNwb25zb3JlZEFzc2V0RmVlXwkAAgECKnVwZGF0ZVNwb25zb3JzaGlwOiBpbnZhbGlkIHNwb25zb3JzaGlwIGZlZQMJAGYCAAAFFHdhdmVzUmVxdWlyZWRBbW91bnRfCQACAQIwdXBkYXRlU3BvbnNvcnNoaXA6IGludmFsaWQgd2F2ZXMgcmVxdWlyZWQgYW1vdW50BQR1bml0AwkAAAIFA2VycgUDZXJyBAxzcG9uc29yQXNzZXQJAQpfbG9hZEFzc2V0AAQNc3BvbnNvckFtb3VudAkA8AcCBQR0aGlzBQxzcG9uc29yQXNzZXQEFG1pblNwb25zb3JlZEFzc2V0RmVlAwkAAAIFFW1pblNwb25zb3JlZEFzc2V0RmVlXwAABQR1bml0BRVtaW5TcG9uc29yZWRBc3NldEZlZV8EB2FjdGlvbnMDCQBmAggJAO8HAQUEdGhpcwdyZWd1bGFyBRR3YXZlc1JlcXVpcmVkQW1vdW50XwkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUBaQZjYWxsZXIJAGUCCAkA7wcBBQR0aGlzB3JlZ3VsYXIFFHdhdmVzUmVxdWlyZWRBbW91bnRfBQR1bml0BQNuaWwFA25pbAkAlAoCCQDOCAIFB2FjdGlvbnMJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwgFAWkGY2FsbGVyBQ1zcG9uc29yQW1vdW50BQxzcG9uc29yQXNzZXQJAMwIAgkBClNwb25zb3JGZWUCBQxzcG9uc29yQXNzZXQFFG1pblNwb25zb3JlZEFzc2V0RmVlBQNuaWwFDXNwb25zb3JBbW91bnQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAnR4AQZ2ZXJpZnkABAckbWF0Y2gwCQCiCAEFDEtFWV9NVUxUSVNJRwMJAAECBQckbWF0Y2gwAgZTdHJpbmcECG11bHRpc2lnBQckbWF0Y2gwCQELdmFsdWVPckVsc2UCCQCbCAIJARFAZXh0ck5hdGl2ZSgxMDYyKQEFCG11bHRpc2lnCQC5CQIJAMwIAgUKS0VZX1NUQVRVUwkAzAgCCQClCAEFBHRoaXMJAMwIAgkA2AQBCAUCdHgCaWQFA25pbAUJU0VQQVJBVE9SBwkA9AMDCAUCdHgJYm9keUJ5dGVzCQCRAwIIBQJ0eAZwcm9vZnMAAAgFAnR4D3NlbmRlclB1YmxpY0tleTPH3qY=",
    "height": 3442564,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 9NKNLCPpnVfbyo5BQndnfefhJx6daC2oTuqfN5pjMr2z
Next: none

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

Old	New		Differences
25	25
26	26		let KEY_TARGET_HEIGHT = "TARGET_HEIGHT"
27	27
	28	+	let KEY_SPONSORSHIP_MANAGER = "SPONSORSHIP_MANAGER"
	29	+
28	30		let FUNC_STAKE = "stake"
29	31
30	32		let FUNC_UNSTAKE = "unstake"

37	39
38	40		let ONE_BIGINT = toBigInt(1)
39	41
40		-	let ~~ONE~~_~~WAVES~~ = 100000000
	42	+	let INIT_AMOUNT = 100000000
41	43
42	44		func _validateAddress (address_) = match addressFromString(address_) {
43	45		case a: Address =>

109	111		}
110	112
111	113
	114	+	func _loadSponsorshipManager () = match getString(KEY_SPONSORSHIP_MANAGER) {
	115	+	case a: String =>
	116	+	addressFromStringValue(a)
	117	+	case _ =>
	118	+	throw("_loadSponsorshipManager: no sponsorship manager")
	119	+	}
	120	+
	121	+
112	122		func _loadInt (key_,default_) = match getInteger(key_) {
113	123		case a: Int =>
114	124		a

173	183		@Callable(i)
174	184		func init (tokenName_,tokenDescr_,baseAsset_,stakingAdapter_) = {
175	185		let multisig = valueOrErrorMessage(getString(KEY_MULTISIG), "init: no multisig set")
176		-	let asset = _loadAsset()
177		-	let baseAsset = _toAssetVector(baseAsset_)
178		-	let err = if ((i.caller != this))
179		-	then throw("init: permission denied")
180		-	else if ((asset != base58''))
181		-	then throw("init: already initialized")
182		-	else if (if ((4 > size(tokenName_)))
183		-	then true
184		-	else (size(tokenName_) > 16))
185		-	then throw("init: invalid token name")
186		-	else if ((size(tokenDescr_) > 1000))
187		-	then throw("init: invalid token description")
188		-	else if (!(_validateAsset(baseAsset_)))
189		-	then throw("init: invalid base asset")
190		-	else if (!(_validateAddress(stakingAdapter_)))
191		-	then throw("init: invalid staking adapter")
192		-	else unit
193		-	if ((err == err))
	186	+	if ((multisig == multisig))
194	187		then {
195		-	let tokenDecimals = _getAssetDecimals(baseAsset)
196		-	let issue = Issue(tokenName_, tokenDescr_, ONE_WAVES, tokenDecimals, true)
197		-	let assetId = calculateAssetId(issue)
198		-	let stakeActions = _updateStaking(baseAsset, ONE_WAVES, addressFromStringValue(stakingAdapter_))
199		-	$Tuple2(([StringEntry(KEY_BASE_ASSET, baseAsset_), StringEntry(KEY_STAKING_ADAPTER, stakingAdapter_), StringEntry(KEY_ASSET, toBase58String(assetId)), issue] ++ stakeActions), unit)
	188	+	let asset = _loadAsset()
	189	+	let baseAsset = _toAssetVector(baseAsset_)
	190	+	let err = if ((i.caller != this))
	191	+	then throw("init: permission denied")
	192	+	else if ((asset != base58''))
	193	+	then throw("init: already initialized")
	194	+	else if (if ((4 > size(tokenName_)))
	195	+	then true
	196	+	else (size(tokenName_) > 16))
	197	+	then throw("init: invalid token name")
	198	+	else if ((size(tokenDescr_) > 1000))
	199	+	then throw("init: invalid token description")
	200	+	else if (!(_validateAsset(baseAsset_)))
	201	+	then throw("init: invalid base asset")
	202	+	else if (!(_validateAddress(stakingAdapter_)))
	203	+	then throw("init: invalid staking adapter")
	204	+	else unit
	205	+	if ((err == err))
	206	+	then {
	207	+	let tokenDecimals = _getAssetDecimals(baseAsset)
	208	+	let issue = Issue(tokenName_, tokenDescr_, INIT_AMOUNT, tokenDecimals, true)
	209	+	let assetId = calculateAssetId(issue)
	210	+	let stakeActions = _updateStaking(baseAsset, INIT_AMOUNT, addressFromStringValue(stakingAdapter_))
	211	+	$Tuple2(([StringEntry(KEY_BASE_ASSET, baseAsset_), StringEntry(KEY_STAKING_ADAPTER, stakingAdapter_), StringEntry(KEY_ASSET, toBase58String(assetId)), issue] ++ stakeActions), unit)
	212	+	}
	213	+	else throw("Strict value is not equal to itself.")
200	214		}
201	215		else throw("Strict value is not equal to itself.")
202	216		}

367	381		}
368	382
369	383
	384	+
	385	+	@Callable(i)
	386	+	func setSponsorshipManager (manager_) = {
	387	+	let err = if ((i.caller != this))
	388	+	then throw("setSponsorshipManager: permission denied")
	389	+	else if (!(_validateAddress(manager_)))
	390	+	then throw("setSponsorshipManager: invalid manager address")
	391	+	else unit
	392	+	if ((err == err))
	393	+	then $Tuple2([StringEntry(KEY_SPONSORSHIP_MANAGER, manager_)], unit)
	394	+	else throw("Strict value is not equal to itself.")
	395	+	}
	396	+
	397	+
	398	+
	399	+	@Callable(i)
	400	+	func updateSponsorship (minSponsoredAssetFee_,wavesRequiredAmount_) = {
	401	+	let err = if ((i.caller != _loadSponsorshipManager()))
	402	+	then throw("updateSponsorship: permission denied")
	403	+	else if ((0 > minSponsoredAssetFee_))
	404	+	then throw("updateSponsorship: invalid sponsorship fee")
	405	+	else if ((0 > wavesRequiredAmount_))
	406	+	then throw("updateSponsorship: invalid waves required amount")
	407	+	else unit
	408	+	if ((err == err))
	409	+	then {
	410	+	let sponsorAsset = _loadAsset()
	411	+	let sponsorAmount = assetBalance(this, sponsorAsset)
	412	+	let minSponsoredAssetFee = if ((minSponsoredAssetFee_ == 0))
	413	+	then unit
	414	+	else minSponsoredAssetFee_
	415	+	let actions = if ((wavesBalance(this).regular > wavesRequiredAmount_))
	416	+	then [ScriptTransfer(i.caller, (wavesBalance(this).regular - wavesRequiredAmount_), unit)]
	417	+	else nil
	418	+	$Tuple2((actions ++ [ScriptTransfer(i.caller, sponsorAmount, sponsorAsset), SponsorFee(sponsorAsset, minSponsoredAssetFee)]), sponsorAmount)
	419	+	}
	420	+	else throw("Strict value is not equal to itself.")
	421	+	}
	422	+
	423	+
370	424		@Verifier(tx)
371	425		func verify () = match getString(KEY_MULTISIG) {
372	426		case multisig: String =>

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

github/deemru/w8io/3ef1775 
52.91 ms ◑