tx · 98g6ysyspvsqMzmxGfteVXitHh5kAscTYcTWWL6mhG6q

3MrtFvvc7QBGaNXke4B8T7brYidircMU8pM:  -0.01400000 Waves

2023.02.22 21:47 [2461242] smart account 3MrtFvvc7QBGaNXke4B8T7brYidircMU8pM > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "98g6ysyspvsqMzmxGfteVXitHh5kAscTYcTWWL6mhG6q",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1677091544212,
    "version": 2,
    "chainId": 84,
    "sender": "3MrtFvvc7QBGaNXke4B8T7brYidircMU8pM",
    "senderPublicKey": "A3DknTXNtQRgyx5yLE3L1YUXipPTqbF3qQrCvp8ZbFPq",
    "proofs": [
        "3YN3rDx317uNRyHTHTBJhBRe93Qabj8B2hXQzCyHs5xyV9bgHeRTUn7dBkXT6WK1zmzUuJVtUGwJ4zGxXgTQwhTg"
    ],
    "script": "base64:BgJDCAISBAoCCAgSCQoHCAgBCAEIARIHCgUBCAEIARIDCgEIEgMKAQgSBAoCAQQSAwoBCBILCgkBCAgBAQEBAQQSAwoBCDwACVNFUEFSQVRPUgICX18ACEtFWV9JTklUAgRJTklUAAxLRVlfTVVMVElTSUcCCE1VTFRJU0lHAApLRVlfU1RBVFVTAgZTVEFUVVMACktFWV9QQVVTRUQCBlBBVVNFRAAKS0VZX1BBVVNFUgIGUEFVU0VSAAxLRVlfRVhFQ1VUT1ICCEVYRUNVVE9SABBLRVlfUk9PVF9BREFQVEVSAgxST09UX0FEQVBURVIAE0tFWV9DQUxMRVJfQ09OVFJBQ1QCD0NBTExFUl9DT05UUkFDVAAJS0VZX0NIQUlOAgVDSEFJTgALS0VZX0JJTkRJTkcCB0JJTkRJTkcAB0tFWV9GRUUCA0ZFRQARS0VZX0ZFRV9SRUNJUElFTlQCDUZFRV9SRUNJUElFTlQAE0ZVTkNfUkVMRUFTRV9UT0tFTlMCDXJlbGVhc2VUb2tlbnMABVdBVkVTAgVXQVZFUwAOV0FWRVNfREVDSU1BTFMACAAIREVDSU1BTFMABgAOUEVSQ0VOVF9GQUNUT1IAwIQ9AAdNQVhfSU5UAP//////////fwEQX3ZhbGlkYXRlQWRkcmVzcwIIYWRkcmVzc18EZXJyXwQHJG1hdGNoMAkApggBBQhhZGRyZXNzXwMJAAECBQckbWF0Y2gwAgdBZGRyZXNzBAFhBQckbWF0Y2gwBgkAAgEFBGVycl8BDl92YWxpZGF0ZUFzc2V0Aghhc3NldElkXwRlcnJfBAckbWF0Y2gwCQDsBwEJANkEAQUIYXNzZXRJZF8DCQABAgUHJG1hdGNoMAIFQXNzZXQEAWEFByRtYXRjaDAGCQACAQUEZXJyXwEMX3ZhbGlkYXRlSW50BAR2YWxfDmxvd2VyQm91bmRhcnlfDnVwcGVyQm91bmRhcnlfBGVycl8DAwkAZgIFDmxvd2VyQm91bmRhcnlfBQR2YWxfBgkAZgIFBHZhbF8FDnVwcGVyQm91bmRhcnlfCQACAQUEZXJyXwYBDV92YWxpZGF0ZUJvb2wDBHZhbF8HdGFyZ2V0XwRlcnJfAwkBAiE9AgUEdmFsXwUHdGFyZ2V0XwkAAgEFBGVycl8GARVfdmFsaWRhdGVQYXltZW50c1NpemUDCXBheW1lbnRzXwd0YXJnZXRfBGVycl8DCQECIT0CCQCQAwEFCXBheW1lbnRzXwUHdGFyZ2V0XwkAAgEFBGVycl8GARVfdmFsaWRhdGVQYXltZW50QXNzZXQDCHBheW1lbnRfBmFzc2V0XwRlcnJfAwkBAiE9AggFCHBheW1lbnRfB2Fzc2V0SWQFBmFzc2V0XwkAAgEFBGVycl8GARJfbm9ybWFsaXplRGVjaW1hbHMDB2Ftb3VudF8Pc291cmNlRGVjaW1hbHNfD3RhcmdldERlY2ltYWxzXwMJAGcCBQ9zb3VyY2VEZWNpbWFsc18FD3RhcmdldERlY2ltYWxzXwkAaQIFB2Ftb3VudF8JAGwGAAoAAAkAZQIFD3NvdXJjZURlY2ltYWxzXwUPdGFyZ2V0RGVjaW1hbHNfAAAAAAUERE9XTgkAaAIFB2Ftb3VudF8JAGwGAAoAAAkAZQIFD3RhcmdldERlY2ltYWxzXwUPc291cmNlRGVjaW1hbHNfAAAAAAUERE9XTgEJX2xvYWRJbml0AAQHJG1hdGNoMAkAoAgBBQhLRVlfSU5JVAMJAAECBQckbWF0Y2gwAgdCb29sZWFuBAFhBQckbWF0Y2gwBQFhBwEJX3NhdmVJbml0AQdpc0luaXRfCQDMCAIJAQxCb29sZWFuRW50cnkCBQhLRVlfSU5JVAUHaXNJbml0XwUDbmlsAQpfbG9hZFBhdXNlAAQHJG1hdGNoMAkAoAgBBQpLRVlfUEFVU0VEAwkAAQIFByRtYXRjaDACB0Jvb2xlYW4EAWEFByRtYXRjaDAFAWEHAQpfc2F2ZVBhdXNlAQlpc1BhdXNlZF8JAMwIAgkBDEJvb2xlYW5FbnRyeQIFCktFWV9QQVVTRUQFCWlzUGF1c2VkXwUDbmlsAQtfbG9hZFBhdXNlcgAEByRtYXRjaDAJAKIIAQUKS0VZX1BBVVNFUgMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAWEFByRtYXRjaDAJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAWEJAQdBZGRyZXNzAQEAAQtfc2F2ZVBhdXNlcgEHcGF1c2VyXwkAzAgCCQELU3RyaW5nRW50cnkCBQpLRVlfUEFVU0VSCQClCAEFB3BhdXNlcl8FA25pbAENX2xvYWRNdWx0aXNpZwAEByRtYXRjaDAJAKIIAQUMS0VZX01VTFRJU0lHAwkAAQIFByRtYXRjaDACBlN0cmluZwQBYQUHJG1hdGNoMAkBEUBleHRyTmF0aXZlKDEwNjIpAQUBYQkBB0FkZHJlc3MBAQABDV9zYXZlTXVsdGlzaWcBCW11bHRpc2lnXwkAzAgCCQELU3RyaW5nRW50cnkCBQxLRVlfTVVMVElTSUcJAKUIAQUJbXVsdGlzaWdfBQNuaWwBDV9sb2FkRXhlY3V0b3IABAckbWF0Y2gwCQCiCAEFDEtFWV9FWEVDVVRPUgMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAWEFByRtYXRjaDAJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAWEJAQdBZGRyZXNzAQEAAQ1fc2F2ZUV4ZWN1dG9yAQlleGVjdXRvcl8JAMwIAgkBC1N0cmluZ0VudHJ5AgUMS0VZX0VYRUNVVE9SCQClCAEFCWV4ZWN1dG9yXwUDbmlsARNfbG9hZENhbGxlckNvbnRyYWN0AAQHJG1hdGNoMAkAoggBBRNLRVlfQ0FMTEVSX0NPTlRSQUNUAwkAAQIFByRtYXRjaDACBlN0cmluZwQBYQUHJG1hdGNoMAUBYQIAARNfc2F2ZUNhbGxlckNvbnRyYWN0AQdjYWxsZXJfCQDMCAIJAQtTdHJpbmdFbnRyeQIFE0tFWV9DQUxMRVJfQ09OVFJBQ1QFB2NhbGxlcl8FA25pbAEKX2xvYWRDaGFpbgEIY2hhaW5JZF8EByRtYXRjaDAJAKAIAQkAuQkCCQDMCAIFCUtFWV9DSEFJTgkAzAgCCQCkAwEFCGNoYWluSWRfBQNuaWwFCVNFUEFSQVRPUgMJAAECBQckbWF0Y2gwAgdCb29sZWFuBAFhBQckbWF0Y2gwBQFhBwEKX3NhdmVDaGFpbgIIY2hhaW5JZF8EdmFsXwkAzAgCCQEMQm9vbGVhbkVudHJ5AgkAuQkCCQDMCAIFCUtFWV9DSEFJTgkAzAgCCQCkAwEFCGNoYWluSWRfBQNuaWwFCVNFUEFSQVRPUgUEdmFsXwUDbmlsAQxfbG9hZEJpbmRpbmcCEWV4ZWN1dGlvbkNoYWluSWRfCGFzc2V0SWRfBAckbWF0Y2gwCQCiCAEJALkJAgkAzAgCBQtLRVlfQklORElORwkAzAgCCQCkAwEFEWV4ZWN1dGlvbkNoYWluSWRfCQDMCAIJANgEAQUIYXNzZXRJZF8FA25pbAUJU0VQQVJBVE9SAwkAAQIFByRtYXRjaDACBlN0cmluZwQBYQUHJG1hdGNoMAQGc3RydWN0CQC1CQIFAWEFCVNFUEFSQVRPUgkAmQoHCQCRAwIFBnN0cnVjdAAACQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUGc3RydWN0AAEJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQZzdHJ1Y3QAAgkBDXBhcnNlSW50VmFsdWUBCQCRAwIFBnN0cnVjdAADCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgUGc3RydWN0AAQJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQZzdHJ1Y3QABQMJAAACCQCRAwIFBnN0cnVjdAAGAgExBgcJAJkKBwIAAAAAAAAAAAAAAAcBDF9zYXZlQmluZGluZwMRZXhlY3V0aW9uQ2hhaW5JZF8IYXNzZXRJZF8IYmluZGluZ18JAMwIAgkBC1N0cmluZ0VudHJ5AgkAuQkCCQDMCAIFC0tFWV9CSU5ESU5HCQDMCAIJAKQDAQURZXhlY3V0aW9uQ2hhaW5JZF8JAMwIAgkA2AQBBQhhc3NldElkXwUDbmlsBQlTRVBBUkFUT1IJALkJAgkAzAgCCAUIYmluZGluZ18CXzEJAMwIAgkApAMBCAUIYmluZGluZ18CXzIJAMwIAgkApAMBCAUIYmluZGluZ18CXzMJAMwIAgkApAMBCAUIYmluZGluZ18CXzQJAMwIAgkApAMBCAUIYmluZGluZ18CXzUJAMwIAgkApAMBCAUIYmluZGluZ18CXzYJAMwIAgMIBQhiaW5kaW5nXwJfNwIBMQIBMAUDbmlsBQlTRVBBUkFUT1IFA25pbAEIX2xvYWRGZWUBCGFzc2V0SWRfBAckbWF0Y2gwCQCfCAEJALkJAgkAzAgCBQdLRVlfRkVFCQDMCAIJANgEAQUIYXNzZXRJZF8FA25pbAUJU0VQQVJBVE9SAwkAAQIFByRtYXRjaDACA0ludAQBYQUHJG1hdGNoMAUBYQAAAQhfc2F2ZUZlZQIIYXNzZXRJZF8EdmFsXwkAzAgCCQEMSW50ZWdlckVudHJ5AgkAuQkCCQDMCAIFB0tFWV9GRUUJAMwIAgkA2AQBBQhhc3NldElkXwUDbmlsBQlTRVBBUkFUT1IFBHZhbF8FA25pbAEQX2xvYWRSb290QWRhcHRlcgAEByRtYXRjaDAJAKIIAQUQS0VZX1JPT1RfQURBUFRFUgMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAWEFByRtYXRjaDAJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAWEJAQdBZGRyZXNzAQEAARBfc2F2ZVJvb3RBZGFwdGVyAQhhZGFwdGVyXwkAzAgCCQELU3RyaW5nRW50cnkCBRBLRVlfUk9PVF9BREFQVEVSCQClCAEFCGFkYXB0ZXJfBQNuaWwBEV9sb2FkRmVlUmVjaXBpZW50AAQHJG1hdGNoMAkAoggBBRFLRVlfRkVFX1JFQ0lQSUVOVAMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAWEFByRtYXRjaDAJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAWEJAQdBZGRyZXNzAQEAARFfc2F2ZUZlZVJlY2lwaWVudAEEdmFsXwkAzAgCCQELU3RyaW5nRW50cnkCBRFLRVlfRkVFX1JFQ0lQSUVOVAkApQgBBQR2YWxfBQNuaWwBEV9vbmx5VGhpc0NvbnRyYWN0AQdjYWxsZXJfAwkBAiE9AgUHY2FsbGVyXwUEdGhpcwkAAgECGV9vbmx5VGhpc0NvbnRyYWN0OiByZXZlcnQGARBfd2hlbk11bHRpc2lnU2V0AAMJAAACCQENX2xvYWRNdWx0aXNpZwAJAQdBZGRyZXNzAQEACQACAQIYX3doZW5NdWx0aXNpZ1NldDogcmV2ZXJ0BgETX3doZW5Ob3RJbml0aWFsaXplZAADCQEJX2xvYWRJbml0AAkAAgECG193aGVuTm90SW5pdGlhbGl6ZWQ6IHJldmVydAYBEF93aGVuSW5pdGlhbGl6ZWQAAwkBASEBCQEJX2xvYWRJbml0AAkAAgECGF93aGVuSW5pdGlhbGl6ZWQ6IHJldmVydAYBDl93aGVuTm90UGF1c2VkAAMJAQpfbG9hZFBhdXNlAAkAAgECFl93aGVuTm90UGF1c2VkOiByZXZlcnQGAQtfd2hlblBhdXNlZAADCQEBIQEJAQpfbG9hZFBhdXNlAAkAAgECE193aGVuUGF1c2VkOiByZXZlcnQGAQtfb25seVBhdXNlcgEHY2FsbGVyXwMJAQIhPQIFB2NhbGxlcl8JAQtfbG9hZFBhdXNlcgAJAAIBAhNfb25seVBhdXNlcjogcmV2ZXJ0BgEGX2FzSW50AQR2YWxfBAckbWF0Y2gwBQR2YWxfAwkAAQIFByRtYXRjaDACA0ludAQBYQUHJG1hdGNoMAUBYQkAAgECDl9hc0ludDogcmV2ZXJ0AQhfYXNCeXRlcwEEdmFsXwQHJG1hdGNoMAUEdmFsXwMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBAFhBQckbWF0Y2gwBQFhCQACAQIQX2FzQnl0ZXM6IHJldmVydAERX3ZhbGlkYXRlRXhlY3V0b3ICBHZhbF8EZXJyXwMJAQIhPQIFBHZhbF8JAQ1fbG9hZEV4ZWN1dG9yAAkAAgEFBGVycl8GAQ9fdmFsaWRhdGVDYWxsZXICBHZhbF8EZXJyXwMJAQIhPQIFBHZhbF8JARNfbG9hZENhbGxlckNvbnRyYWN0AAkAAgEFBGVycl8GAQ5fdmFsaWRhdGVDaGFpbgIRZXhlY3V0aW9uQ2hhaW5JZF8EZXJyXwMJAQEhAQkBCl9sb2FkQ2hhaW4BBRFleGVjdXRpb25DaGFpbklkXwkAAgEFBGVycl8GCQFpAQRpbml0AglleGVjdXRvcl8IYWRhcHRlcl8EA2VycgMDAwMJARFfb25seVRoaXNDb250cmFjdAEIBQFpBmNhbGxlcgkBE193aGVuTm90SW5pdGlhbGl6ZWQABwkBEF93aGVuTXVsdGlzaWdTZXQABwkBEF92YWxpZGF0ZUFkZHJlc3MCBQlleGVjdXRvcl8CFmluaXQ6IGludmFsaWQgZXhlY3V0b3IHCQEQX3ZhbGlkYXRlQWRkcmVzcwIFCGFkYXB0ZXJfAhVpbml0OiBpbnZhbGlkIGFkYXB0ZXIHAwkAAAIFA2VycgUDZXJyCQCUCgIJAM4IAgkAzggCCQEJX3NhdmVJbml0AQYJAQ1fc2F2ZUV4ZWN1dG9yAQkBEUBleHRyTmF0aXZlKDEwNjIpAQUJZXhlY3V0b3JfCQEQX3NhdmVSb290QWRhcHRlcgEJARFAZXh0ck5hdGl2ZSgxMDYyKQEFCGFkYXB0ZXJfBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBCm1pbnRUb2tlbnMHD2NhbGxlckNvbnRyYWN0Xw5hc3NldENvbnRyYWN0XwdhbW91bnRfCnJlY2lwaWVudF8OZ2FzbGVzc1Jld2FyZF8JcmVmZXJyZXJfDHJlZmVycmVyRmVlXwQDZXJyAwMDAwMDAwkBEF93aGVuSW5pdGlhbGl6ZWQACQEOX3doZW5Ob3RQYXVzZWQABwkBEF92YWxpZGF0ZUFkZHJlc3MCBQ5hc3NldENvbnRyYWN0XwIcbWludDogaW52YWxpZCBhc3NldCBjb250cmFjdAcJARFfdmFsaWRhdGVFeGVjdXRvcgIIBQFpBmNhbGxlcgIWbWludDogaW52YWxpZCBleGVjdXRvcgcJAQ9fdmFsaWRhdGVDYWxsZXICBQ9jYWxsZXJDb250cmFjdF8CFG1pbnQ6IGludmFsaWQgY2FsbGVyBwkBEF92YWxpZGF0ZUFkZHJlc3MCBQpyZWNpcGllbnRfAh9taW50OiBpbnZhbGlkIHJlY2lwaWVudCBhZGRyZXNzBwkBDF92YWxpZGF0ZUludAQFB2Ftb3VudF8AAAUHTUFYX0lOVAIUbWludDogaW52YWxpZCBhbW91bnQHCQEMX3ZhbGlkYXRlSW50BAUOZ2FzbGVzc1Jld2FyZF8AAAUHTUFYX0lOVAIbbWludDogaW52YWxpZCBnYXNsZXNzUmV3YXJkBwMJAAACBQNlcnIFA2VycgQHYXNzZXRJZAkBCF9hc0J5dGVzAQkA/AcECQERQGV4dHJOYXRpdmUoMTA2MikBBQ5hc3NldENvbnRyYWN0XwIKZ2V0QXNzZXRJZAUDbmlsBQNuaWwDCQAAAgUHYXNzZXRJZAUHYXNzZXRJZAQNYXNzZXREZWNpbWFscwkBBl9hc0ludAEJAPwHBAkBEUBleHRyTmF0aXZlKDEwNjIpAQUOYXNzZXRDb250cmFjdF8CC2dldERlY2ltYWxzBQNuaWwFA25pbAMJAAACBQ1hc3NldERlY2ltYWxzBQ1hc3NldERlY2ltYWxzBBBub3JtYWxpemVkQW1vdW50CQESX25vcm1hbGl6ZURlY2ltYWxzAwUHYW1vdW50XwUIREVDSU1BTFMFDWFzc2V0RGVjaW1hbHMEEW5vcm1hbGl6ZWRHYXNsZXNzCQESX25vcm1hbGl6ZURlY2ltYWxzAwUOZ2FzbGVzc1Jld2FyZF8FCERFQ0lNQUxTBQ1hc3NldERlY2ltYWxzBAhyZWZlcnJlcgMJAGYCCQCxAgEFCXJlZmVycmVyXwAABARlcnIxAwkBEF92YWxpZGF0ZUFkZHJlc3MCBQlyZWZlcnJlcl8CHm1pbnQ6IGludmFsaWQgcmVmZXJyZXIgYWRkcmVzcwkBDF92YWxpZGF0ZUludAQFDHJlZmVycmVyRmVlXwAABQdNQVhfSU5UAhptaW50OiBpbnZhbGlkIHJlZmVycmVyIGZlZQcDCQAAAgUEZXJyMQUEZXJyMQQVbm9ybWFsaXplZFJlZmVycmVyRmVlCQESX25vcm1hbGl6ZURlY2ltYWxzAwUMcmVmZXJyZXJGZWVfBQhERUNJTUFMUwUNYXNzZXREZWNpbWFscwkAlAoCBRVub3JtYWxpemVkUmVmZXJyZXJGZWUJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwkBEUBleHRyTmF0aXZlKDEwNjIpAQUJcmVmZXJyZXJfBRVub3JtYWxpemVkUmVmZXJyZXJGZWUFB2Fzc2V0SWQFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAlAoCAAAFA25pbAQLcmVmZXJyZXJGZWUIBQhyZWZlcnJlcgJfMQQPcmVmZXJyZXJBY3Rpb25zCAUIcmVmZXJyZXICXzIECmludm9jYXRpb24JAPwHBAkBEUBleHRyTmF0aXZlKDEwNjIpAQUOYXNzZXRDb250cmFjdF8CBG1pbnQJAMwIAgkAZAIFEG5vcm1hbGl6ZWRBbW91bnQFC3JlZmVycmVyRmVlCQDMCAIJAKUIAQUEdGhpcwUDbmlsBQNuaWwDCQAAAgUKaW52b2NhdGlvbgUKaW52b2NhdGlvbgQHYWN0aW9ucwMDCQBmAgURbm9ybWFsaXplZEdhc2xlc3MAAAkBAiE9AgkBEUBleHRyTmF0aXZlKDEwNjIpAQUKcmVjaXBpZW50XwgFAWkMb3JpZ2luQ2FsbGVyBwkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCQERQGV4dHJOYXRpdmUoMTA2MikBBQpyZWNpcGllbnRfCQBlAgUQbm9ybWFsaXplZEFtb3VudAURbm9ybWFsaXplZEdhc2xlc3MFB2Fzc2V0SWQJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwgFAWkMb3JpZ2luQ2FsbGVyBRFub3JtYWxpemVkR2FzbGVzcwUHYXNzZXRJZAUDbmlsCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMJARFAZXh0ck5hdGl2ZSgxMDYyKQEFCnJlY2lwaWVudF8FEG5vcm1hbGl6ZWRBbW91bnQFB2Fzc2V0SWQFA25pbAkAlAoCCQDOCAIFB2FjdGlvbnMFD3JlZmVycmVyQWN0aW9ucwUEdW5pdAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQpidXJuVG9rZW5zBRFleGVjdXRpb25DaGFpbklkXw5hc3NldENvbnRyYWN0XwdhbW91bnRfCnJlY2lwaWVudF8OZ2FzbGVzc1Jld2FyZF8EA2VycgMDAwMDCQEQX3doZW5Jbml0aWFsaXplZAAJAQ5fd2hlbk5vdFBhdXNlZAAHCQEQX3ZhbGlkYXRlQWRkcmVzcwIFDmFzc2V0Q29udHJhY3RfAhxidXJuOiBpbnZhbGlkIGFzc2V0IGNvbnRyYWN0BwkBDl92YWxpZGF0ZUNoYWluAgURZXhlY3V0aW9uQ2hhaW5JZF8CHWJ1cm46IGludmFsaWQgZXhlY3V0aW9uIGNoYWluBwkBFV92YWxpZGF0ZVBheW1lbnRzU2l6ZQMIBQFpCHBheW1lbnRzAAECEGJ1cm46IG5vIHBheW1lbnQHCQEMX3ZhbGlkYXRlSW50BAgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQFB2Ftb3VudF8FB01BWF9JTlQCHGJ1cm46IGludmFsaWQgcGF5bWVudCBhbW91bnQHAwkAAAIFA2VycgUDZXJyBAdhc3NldElkCQEIX2FzQnl0ZXMBCQD8BwQJARFAZXh0ck5hdGl2ZSgxMDYyKQEFDmFzc2V0Q29udHJhY3RfAgpnZXRBc3NldElkBQNuaWwFA25pbAMJAAACBQdhc3NldElkBQdhc3NldElkBA1hc3NldERlY2ltYWxzCQEGX2FzSW50AQkA/AcECQERQGV4dHJOYXRpdmUoMTA2MikBBQ5hc3NldENvbnRyYWN0XwILZ2V0RGVjaW1hbHMFA25pbAUDbmlsAwkAAAIFDWFzc2V0RGVjaW1hbHMFDWFzc2V0RGVjaW1hbHMEB2JpbmRpbmcJAQxfbG9hZEJpbmRpbmcCBRFleGVjdXRpb25DaGFpbklkXwUHYXNzZXRJZAQOZXhlY3V0aW9uQXNzZXQIBQdiaW5kaW5nAl8xBAltaW5BbW91bnQIBQdiaW5kaW5nAl8yBAZtaW5GZWUIBQdiaW5kaW5nAl8zBAx0aHJlc2hvbGRGZWUIBQdiaW5kaW5nAl80BBBiZWZvcmVQZXJjZW50RmVlCAUHYmluZGluZwJfNQQPYWZ0ZXJQZXJjZW50RmVlCAUHYmluZGluZwJfNgQHZW5hYmxlZAgFB2JpbmRpbmcCXzcEBGVycjEDAwkBFV92YWxpZGF0ZVBheW1lbnRBc3NldAMJAJEDAggFAWkIcGF5bWVudHMAAAUHYXNzZXRJZAIbYnVybjogaW52YWxpZCBwYXltZW50IGFzc2V0CQEMX3ZhbGlkYXRlSW50BAUHYW1vdW50XwUJbWluQW1vdW50BQdNQVhfSU5UAhNidXJuOiBsZXNzIHRoYW4gbWluBwkBDV92YWxpZGF0ZUJvb2wDBQdlbmFibGVkBgIXYnVybjogdG9rZW4gaXMgZGlzYWJsZWQHAwkAAAIFBGVycjEFBGVycjEEB3BlcmNlbnQDCQBmAgUHYW1vdW50XwUMdGhyZXNob2xkRmVlBQ9hZnRlclBlcmNlbnRGZWUFEGJlZm9yZVBlcmNlbnRGZWUEA2ZlZQkAZAIFBm1pbkZlZQkAaQIJAGgCBQdhbW91bnRfBQdwZXJjZW50BQ5QRVJDRU5UX0ZBQ1RPUgQEZXJyMgkBDF92YWxpZGF0ZUludAQFB2Ftb3VudF8JAGQCBQNmZWUAAQUHTUFYX0lOVAIaYnVybjogZmVlIG1vcmUgdGhhbiBhbW91bnQDCQAAAgUEZXJyMgUEZXJyMgQMYW1vdW50VG9TZW5kCQBlAgUHYW1vdW50XwUDZmVlBARlcnIzCQEMX3ZhbGlkYXRlSW50BAUMYW1vdW50VG9TZW5kCQBkAgUOZ2FzbGVzc1Jld2FyZF8AAQUHTUFYX0lOVAIdYnVybjogcmV3YXJkIG1vcmUgdGhhbiBhbW91bnQDCQAAAgUEZXJyMwUEZXJyMwQJdXBkYXRlRmVlCQBkAgkBCF9sb2FkRmVlAQUHYXNzZXRJZAUDZmVlBBBub3JtYWxpemVkQW1vdW50CQESX25vcm1hbGl6ZURlY2ltYWxzAwUMYW1vdW50VG9TZW5kBQ1hc3NldERlY2ltYWxzBQhERUNJTUFMUwQRbm9ybWFsaXplZEdhc2xlc3MJARJfbm9ybWFsaXplRGVjaW1hbHMDBQ5nYXNsZXNzUmV3YXJkXwUNYXNzZXREZWNpbWFscwUIREVDSU1BTFMECmludm9jYXRpb24JAPwHBAkBEF9sb2FkUm9vdEFkYXB0ZXIABRNGVU5DX1JFTEVBU0VfVE9LRU5TCQDMCAIFEWV4ZWN1dGlvbkNoYWluSWRfCQDMCAIFDmV4ZWN1dGlvbkFzc2V0CQDMCAIFEG5vcm1hbGl6ZWRBbW91bnQJAMwIAgUKcmVjaXBpZW50XwkAzAgCBRFub3JtYWxpemVkR2FzbGVzcwUDbmlsBQNuaWwDCQAAAgUKaW52b2NhdGlvbgUKaW52b2NhdGlvbgkAlAoCCQDOCAIJAQhfc2F2ZUZlZQIFB2Fzc2V0SWQFCXVwZGF0ZUZlZQkAzAgCCQEEQnVybgIFB2Fzc2V0SWQFDGFtb3VudFRvU2VuZAUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBC3RyYW5zZmVyRmVlAQ5hc3NldENvbnRyYWN0XwQDZXJyAwMJARBfd2hlbkluaXRpYWxpemVkAAkBDl93aGVuTm90UGF1c2VkAAcJARBfdmFsaWRhdGVBZGRyZXNzAgUOYXNzZXRDb250cmFjdF8CH2J1cm5GZWU6IGludmFsaWQgYXNzZXQgY29udHJhY3QHAwkAAAIFA2VycgUDZXJyBAdhc3NldElkCQEIX2FzQnl0ZXMBCQD8BwQJARFAZXh0ck5hdGl2ZSgxMDYyKQEFDmFzc2V0Q29udHJhY3RfAgpnZXRBc3NldElkBQNuaWwFA25pbAMJAAACBQdhc3NldElkBQdhc3NldElkCQCUCgIJAM4IAgkBCF9zYXZlRmVlAgUHYXNzZXRJZAAACQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMJARFfbG9hZEZlZVJlY2lwaWVudAAJAQhfbG9hZEZlZQEFB2Fzc2V0SWQFB2Fzc2V0SWQFA25pbAUEdW5pdAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpARR1cGRhdGVDYWxsZXJDb250cmFjdAEPY2FsbGVyQ29udHJhY3RfBANlcnIDCQERX29ubHlUaGlzQ29udHJhY3QBCAUBaQZjYWxsZXIJARBfd2hlbkluaXRpYWxpemVkAAcDCQAAAgUDZXJyBQNlcnIJAJQKAgkBE19zYXZlQ2FsbGVyQ29udHJhY3QBBQ9jYWxsZXJDb250cmFjdF8FBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEUdXBkYXRlRXhlY3V0aW9uQ2hhaW4CEWV4ZWN1dGlvbkNoYWluSWRfCGVuYWJsZWRfBANlcnIDAwkBEV9vbmx5VGhpc0NvbnRyYWN0AQgFAWkGY2FsbGVyCQEQX3doZW5Jbml0aWFsaXplZAAHCQEMX3ZhbGlkYXRlSW50BAURZXhlY3V0aW9uQ2hhaW5JZF8AAAUHTUFYX0lOVAIudXBkYXRlRXhlY3V0aW9uQ2hhaW46IGludmFsaWQgZXhlY3V0aW9uQ2hhaW5JZAcDCQAAAgUDZXJyBQNlcnIJAJQKAgkBCl9zYXZlQ2hhaW4CBRFleGVjdXRpb25DaGFpbklkXwUIZW5hYmxlZF8FBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQESdXBkYXRlRmVlUmVjaXBpZW50AQ1mZWVSZWNpcGllbnRfBANlcnIDAwkBEV9vbmx5VGhpc0NvbnRyYWN0AQgFAWkGY2FsbGVyCQEQX3doZW5Jbml0aWFsaXplZAAHCQEQX3ZhbGlkYXRlQWRkcmVzcwIFDWZlZVJlY2lwaWVudF8CKHVwZGF0ZUZlZVJlY2lwaWVudDogaW52YWxpZCBmZWVSZWNpcGllbnQHAwkAAAIFA2VycgUDZXJyCQCUCgIJARFfc2F2ZUZlZVJlY2lwaWVudAEJARFAZXh0ck5hdGl2ZSgxMDYyKQEFDWZlZVJlY2lwaWVudF8FBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQERdXBkYXRlQmluZGluZ0luZm8JEWV4ZWN1dGlvbkNoYWluSWRfDmFzc2V0Q29udHJhY3RfD2V4ZWN1dGlvbkFzc2V0XwptaW5BbW91bnRfB21pbkZlZV8NdGhyZXNob2xkRmVlXxFiZWZvcmVQZXJjZW50RmVlXxBhZnRlclBlcmNlbnRGZWVfCGVuYWJsZWRfBANlcnIDAwMDAwMDAwkBEV9vbmx5VGhpc0NvbnRyYWN0AQgFAWkGY2FsbGVyCQEQX3doZW5Jbml0aWFsaXplZAAHCQEQX3ZhbGlkYXRlQWRkcmVzcwIFDmFzc2V0Q29udHJhY3RfAil1cGRhdGVCaW5kaW5nSW5mbzogaW52YWxpZCBhc3NldCBjb250cmFjdAcJAQxfdmFsaWRhdGVJbnQEBRFleGVjdXRpb25DaGFpbklkXwAABQdNQVhfSU5UAit1cGRhdGVCaW5kaW5nSW5mbzogaW52YWxpZCBleGVjdXRpb25DaGFpbklkBwkBDF92YWxpZGF0ZUludAQFCm1pbkFtb3VudF8AAAUHTUFYX0lOVAIkdXBkYXRlQmluZGluZ0luZm86IGludmFsaWQgbWluQW1vdW50BwkBDF92YWxpZGF0ZUludAQFB21pbkZlZV8AAAUHTUFYX0lOVAIhdXBkYXRlQmluZGluZ0luZm86IGludmFsaWQgbWluRmVlBwkBDF92YWxpZGF0ZUludAQFDXRocmVzaG9sZEZlZV8AAAUHTUFYX0lOVAIndXBkYXRlQmluZGluZ0luZm86IGludmFsaWQgdGhyZXNob2xkRmVlBwkBDF92YWxpZGF0ZUludAQFEWJlZm9yZVBlcmNlbnRGZWVfAAAFB01BWF9JTlQCK3VwZGF0ZUJpbmRpbmdJbmZvOiBpbnZhbGlkIGJlZm9yZVBlcmNlbnRGZWUHCQEMX3ZhbGlkYXRlSW50BAUQYWZ0ZXJQZXJjZW50RmVlXwAABQdNQVhfSU5UAip1cGRhdGVCaW5kaW5nSW5mbzogaW52YWxpZCBhZnRlclBlcmNlbnRGZWUHAwkAAAIFA2VycgUDZXJyBAdhc3NldElkCQEIX2FzQnl0ZXMBCQD8BwQJARFAZXh0ck5hdGl2ZSgxMDYyKQEFDmFzc2V0Q29udHJhY3RfAgpnZXRBc3NldElkBQNuaWwFA25pbAMJAAACBQdhc3NldElkBQdhc3NldElkBAdiaW5kaW5nCQCZCgcFD2V4ZWN1dGlvbkFzc2V0XwUKbWluQW1vdW50XwUHbWluRmVlXwUNdGhyZXNob2xkRmVlXwURYmVmb3JlUGVyY2VudEZlZV8FEGFmdGVyUGVyY2VudEZlZV8FCGVuYWJsZWRfCQCUCgIJAQxfc2F2ZUJpbmRpbmcDBRFleGVjdXRpb25DaGFpbklkXwUHYXNzZXRJZAUHYmluZGluZwUEdW5pdAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQtzZXRNdWx0aXNpZwEJbXVsdGlzaWdfBANlcnIDCQERX29ubHlUaGlzQ29udHJhY3QBCAUBaQZjYWxsZXIJARBfdmFsaWRhdGVBZGRyZXNzAgUJbXVsdGlzaWdfAh1zZXRNdWx0aXNpZzogaW52YWxpZCBtdWx0aXNpZwcDCQAAAgUDZXJyBQNlcnIJAJQKAgkBDV9zYXZlTXVsdGlzaWcBCQERQGV4dHJOYXRpdmUoMTA2MikBBQltdWx0aXNpZ18FBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAnR4AQZ2ZXJpZnkABAckbWF0Y2gwCQCiCAEFDEtFWV9NVUxUSVNJRwMJAAECBQckbWF0Y2gwAgZTdHJpbmcECG11bHRpc2lnBQckbWF0Y2gwCQELdmFsdWVPckVsc2UCCQCbCAIJARFAZXh0ck5hdGl2ZSgxMDYyKQEFCG11bHRpc2lnCQC5CQIJAMwIAgUKS0VZX1NUQVRVUwkAzAgCCQClCAEFBHRoaXMJAMwIAgkA2AQBCAUCdHgCaWQFA25pbAUJU0VQQVJBVE9SBwkA9AMDCAUCdHgJYm9keUJ5dGVzCQCRAwIIBQJ0eAZwcm9vZnMAAAgFAnR4D3NlbmRlclB1YmxpY0tleQeokZY=",
    "height": 2461242,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8Cc7s47hmEqPnxKgmbAAdKHLX9P46WXccqyYmJ5qKme9
Next: FsdhTvBcNQP2rmCVB1YZBh73ndKK1yJ3aB5YUg3L9ZLR

Diff: 
Old
New
Differences
25
25
 
26
26
 
let KEY_FEE = "FEE"
27
27
 
28
-
let KEY_FEE_CHAIN_ID = "FEE_CHAIN_ID"
29
-
30
28
 
let KEY_FEE_RECIPIENT = "FEE_RECIPIENT"
31
29
 
32
-
let FUNC_TAKE_TOKENS = "takeTokens"
30
+
let FUNC_RELEASE_TOKENS = "releaseTokens"
33
31
 
34
32
 
let WAVES = "WAVES"
35
33
 
164
162
 
func _loadBinding (executionChainId_,assetId_) = match getString(makeString([KEY_BINDING, toString(executionChainId_), toBase58String(assetId_)], SEPARATOR)) {
165
163
 
    case a: String => 
166
164
 
        let struct = split(a, SEPARATOR)
167
-
        $Tuple6(parseIntValue(struct[0]), parseIntValue(struct[1]), parseIntValue(struct[2]), parseIntValue(struct[3]), parseIntValue(struct[4]), if ((struct[5] == "1"))
165
+
        $Tuple7(struct[0], parseIntValue(struct[1]), parseIntValue(struct[2]), parseIntValue(struct[3]), parseIntValue(struct[4]), parseIntValue(struct[5]), if ((struct[6] == "1"))
168
166
 
            then true
169
167
 
            else false)
170
168
 
    case _ => 
171
-
        $Tuple6(0, 0, 0, 0, 0, false)
169
+
        $Tuple7("", 0, 0, 0, 0, 0, false)
172
170
 
}
173
171
 
174
172
 
175
-
func _saveBinding (executionChainId_,assetId_,binding_) = [StringEntry(makeString([KEY_BINDING, toString(executionChainId_), toBase58String(assetId_)], SEPARATOR), makeString([toString(binding_._1), toString(binding_._2), toString(binding_._3), toString(binding_._4), toString(binding_._5), if (binding_._6)
173
+
func _saveBinding (executionChainId_,assetId_,binding_) = [StringEntry(makeString([KEY_BINDING, toString(executionChainId_), toBase58String(assetId_)], SEPARATOR), makeString([binding_._1, toString(binding_._2), toString(binding_._3), toString(binding_._4), toString(binding_._5), toString(binding_._6), if (binding_._7)
176
174
 
    then "1"
177
175
 
    else "0"], SEPARATOR))]
178
176
 
199
197
 
func _saveRootAdapter (adapter_) = [StringEntry(KEY_ROOT_ADAPTER, toString(adapter_))]
200
198
 
201
199
 
202
-
func _loadFeeChainId () = match getInteger(KEY_FEE_CHAIN_ID) {
203
-
    case a: Int => 
204
-
        a
200
+
func _loadFeeRecipient () = match getString(KEY_FEE_RECIPIENT) {
201
+
    case a: String => 
202
+
        addressFromStringValue(a)
205
203
 
    case _ => 
206
-
        0
204
+
        Address(base58'')
207
205
 
}
208
206
 
209
207
 
210
-
func _saveFeeChainId (val_) = [IntegerEntry(KEY_FEE_CHAIN_ID, val_)]
211
-
212
-
213
-
func _loadFeeRecipient () = match getString(KEY_FEE_RECIPIENT) {
214
-
    case a: String => 
215
-
        a
216
-
    case _ => 
217
-
        ""
218
-
}
219
-
220
-
221
-
func _saveFeeRecipient (val_) = [StringEntry(KEY_FEE_RECIPIENT, val_)]
208
+
func _saveFeeRecipient (val_) = [StringEntry(KEY_FEE_RECIPIENT, toString(val_))]
222
209
 
223
210
 
224
211
 
func _onlyThisContract (caller_) = if ((caller_ != this))
306
293
 
307
294
 
308
295
 
@Callable(i)
309
-
func mintTokens (assetContract_,amount_,recipient_,gaslessReward_,referrer_,referrerFee_,callerContract_) = {
296
+
func mintTokens (callerContract_,assetContract_,amount_,recipient_,gaslessReward_,referrer_,referrerFee_) = {
310
297
 
    let err = if (if (if (if (if (if (if (_whenInitialized())
311
298
 
        then _whenNotPaused()
312
299
 
        else false)
369
356
 
370
357
 
371
358
 
@Callable(i)
372
-
func burnTokens (assetContract_,amount_,executionChainId_,recipient_,gaslessReward_,referrer_) = {
359
+
func burnTokens (executionChainId_,assetContract_,amount_,recipient_,gaslessReward_) = {
373
360
 
    let err = if (if (if (if (if (_whenInitialized())
374
361
 
        then _whenNotPaused()
375
362
 
        else false)
390
377
 
                    if ((assetDecimals == assetDecimals))
391
378
 
                        then {
392
379
 
                            let binding = _loadBinding(executionChainId_, assetId)
393
-
                            let minAmount = binding._1
394
-
                            let minFee = binding._2
395
-
                            let thresholdFee = binding._3
396
-
                            let beforePercentFee = binding._4
397
-
                            let afterPercentFee = binding._5
398
-
                            let enabled = binding._6
380
+
                            let executionAsset = binding._1
381
+
                            let minAmount = binding._2
382
+
                            let minFee = binding._3
383
+
                            let thresholdFee = binding._4
384
+
                            let beforePercentFee = binding._5
385
+
                            let afterPercentFee = binding._6
386
+
                            let enabled = binding._7
399
387
 
                            let err1 = if (if (_validatePaymentAsset(i.payments[0], assetId, "burn: invalid payment asset"))
400
388
 
                                then _validateInt(amount_, minAmount, MAX_INT, "burn: less than min")
401
389
 
                                else false)
417
405
 
                                                    let updateFee = (_loadFee(assetId) + fee)
418
406
 
                                                    let normalizedAmount = _normalizeDecimals(amountToSend, assetDecimals, DECIMALS)
419
407
 
                                                    let normalizedGasless = _normalizeDecimals(gaslessReward_, assetDecimals, DECIMALS)
420
-
                                                    let invocation = invoke(_loadRootAdapter(), FUNC_TAKE_TOKENS, [executionChainId_, assetContract_, normalizedAmount, recipient_, normalizedGasless, referrer_], nil)
408
+
                                                    let invocation = invoke(_loadRootAdapter(), FUNC_RELEASE_TOKENS, [executionChainId_, executionAsset, normalizedAmount, recipient_, normalizedGasless], nil)
421
409
 
                                                    if ((invocation == invocation))
422
-
                                                        then $Tuple2((_saveFee(assetId, updateFee) ++ [Burn(assetId, amount_)]), unit)
410
+
                                                        then $Tuple2((_saveFee(assetId, updateFee) ++ [Burn(assetId, amountToSend)]), unit)
423
411
 
                                                        else throw("Strict value is not equal to itself.")
424
412
 
                                                    }
425
413
 
                                                else throw("Strict value is not equal to itself.")
430
418
 
                            }
431
419
 
                        else throw("Strict value is not equal to itself.")
432
420
 
                    }
421
+
                else throw("Strict value is not equal to itself.")
422
+
            }
423
+
        else throw("Strict value is not equal to itself.")
424
+
    }
425
+
426
+
427
+
428
+
@Callable(i)
429
+
func transferFee (assetContract_) = {
430
+
    let err = if (if (_whenInitialized())
431
+
        then _whenNotPaused()
432
+
        else false)
433
+
        then _validateAddress(assetContract_, "burnFee: invalid asset contract")
434
+
        else false
435
+
    if ((err == err))
436
+
        then {
437
+
            let assetId = _asBytes(invoke(addressFromStringValue(assetContract_), "getAssetId", nil, nil))
438
+
            if ((assetId == assetId))
439
+
                then $Tuple2((_saveFee(assetId, 0) ++ [ScriptTransfer(_loadFeeRecipient(), _loadFee(assetId), assetId)]), unit)
433
440
 
                else throw("Strict value is not equal to itself.")
434
441
 
            }
435
442
 
        else throw("Strict value is not equal to itself.")
464
471
 
465
472
 
466
473
 
@Callable(i)
467
-
func updateFeeChain (feeChainId_) = {
474
+
func updateFeeRecipient (feeRecipient_) = {
468
475
 
    let err = if (if (_onlyThisContract(i.caller))
469
476
 
        then _whenInitialized()
470
477
 
        else false)
471
-
        then _validateInt(feeChainId_, 0, MAX_INT, "updateFeeChain: invalid feeChainId")
478
+
        then _validateAddress(feeRecipient_, "updateFeeRecipient: invalid feeRecipient")
472
479
 
        else false
473
480
 
    if ((err == err))
474
-
        then $Tuple2(_saveFeeChainId(feeChainId_), unit)
481
+
        then $Tuple2(_saveFeeRecipient(addressFromStringValue(feeRecipient_)), unit)
475
482
 
        else throw("Strict value is not equal to itself.")
476
483
 
    }
477
484
 
478
485
 
479
486
 
480
487
 
@Callable(i)
481
-
func updateFeeRecipient (feeRecipient_) = {
482
-
    let err = if (_onlyThisContract(i.caller))
483
-
        then _whenInitialized()
484
-
        else false
485
-
    if ((err == err))
486
-
        then $Tuple2(_saveFeeRecipient(feeRecipient_), unit)
487
-
        else throw("Strict value is not equal to itself.")
488
-
    }
489
-
490
-
491
-
492
-
@Callable(i)
493
-
func updateBindingInfo (assetContract_,executionChainId_,minAmount_,minFee_,thresholdFee_,beforePercentFee_,afterPercentFee_,enabled_) = {
488
+
func updateBindingInfo (executionChainId_,assetContract_,executionAsset_,minAmount_,minFee_,thresholdFee_,beforePercentFee_,afterPercentFee_,enabled_) = {
494
489
 
    let err = if (if (if (if (if (if (if (if (_onlyThisContract(i.caller))
495
490
 
        then _whenInitialized()
496
491
 
        else false)
513
508
 
            let assetId = _asBytes(invoke(addressFromStringValue(assetContract_), "getAssetId", nil, nil))
514
509
 
            if ((assetId == assetId))
515
510
 
                then {
516
-
                    let binding = $Tuple6(minAmount_, minFee_, thresholdFee_, beforePercentFee_, afterPercentFee_, enabled_)
511
+
                    let binding = $Tuple7(executionAsset_, minAmount_, minFee_, thresholdFee_, beforePercentFee_, afterPercentFee_, enabled_)
517
512
 
                    $Tuple2(_saveBinding(executionChainId_, assetId, binding), unit)
518
513
 
                    }
519
514
 
                else throw("Strict value is not equal to itself.")
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 KEY_INIT = "INIT"
7
7
 
8
8
 
let KEY_MULTISIG = "MULTISIG"
9
9
 
10
10
 
let KEY_STATUS = "STATUS"
11
11
 
12
12
 
let KEY_PAUSED = "PAUSED"
13
13
 
14
14
 
let KEY_PAUSER = "PAUSER"
15
15
 
16
16
 
let KEY_EXECUTOR = "EXECUTOR"
17
17
 
18
18
 
let KEY_ROOT_ADAPTER = "ROOT_ADAPTER"
19
19
 
20
20
 
let KEY_CALLER_CONTRACT = "CALLER_CONTRACT"
21
21
 
22
22
 
let KEY_CHAIN = "CHAIN"
23
23
 
24
24
 
let KEY_BINDING = "BINDING"
25
25
 
26
26
 
let KEY_FEE = "FEE"
27
27
 
28
-
let KEY_FEE_CHAIN_ID = "FEE_CHAIN_ID"
29
-
30
28
 
let KEY_FEE_RECIPIENT = "FEE_RECIPIENT"
31
29
 
32
-
let FUNC_TAKE_TOKENS = "takeTokens"
30
+
let FUNC_RELEASE_TOKENS = "releaseTokens"
33
31
 
34
32
 
let WAVES = "WAVES"
35
33
 
36
34
 
let WAVES_DECIMALS = 8
37
35
 
38
36
 
let DECIMALS = 6
39
37
 
40
38
 
let PERCENT_FACTOR = 1000000
41
39
 
42
40
 
let MAX_INT = 9223372036854775807
43
41
 
44
42
 
func _validateAddress (address_,err_) = match addressFromString(address_) {
45
43
 
    case a: Address => 
46
44
 
        true
47
45
 
    case _ => 
48
46
 
        throw(err_)
49
47
 
}
50
48
 
51
49
 
52
50
 
func _validateAsset (assetId_,err_) = match assetInfo(fromBase58String(assetId_)) {
53
51
 
    case a: Asset => 
54
52
 
        true
55
53
 
    case _ => 
56
54
 
        throw(err_)
57
55
 
}
58
56
 
59
57
 
60
58
 
func _validateInt (val_,lowerBoundary_,upperBoundary_,err_) = if (if ((lowerBoundary_ > val_))
61
59
 
    then true
62
60
 
    else (val_ > upperBoundary_))
63
61
 
    then throw(err_)
64
62
 
    else true
65
63
 
66
64
 
67
65
 
func _validateBool (val_,target_,err_) = if ((val_ != target_))
68
66
 
    then throw(err_)
69
67
 
    else true
70
68
 
71
69
 
72
70
 
func _validatePaymentsSize (payments_,target_,err_) = if ((size(payments_) != target_))
73
71
 
    then throw(err_)
74
72
 
    else true
75
73
 
76
74
 
77
75
 
func _validatePaymentAsset (payment_,asset_,err_) = if ((payment_.assetId != asset_))
78
76
 
    then throw(err_)
79
77
 
    else true
80
78
 
81
79
 
82
80
 
func _normalizeDecimals (amount_,sourceDecimals_,targetDecimals_) = if ((sourceDecimals_ >= targetDecimals_))
83
81
 
    then (amount_ / pow(10, 0, (sourceDecimals_ - targetDecimals_), 0, 0, DOWN))
84
82
 
    else (amount_ * pow(10, 0, (targetDecimals_ - sourceDecimals_), 0, 0, DOWN))
85
83
 
86
84
 
87
85
 
func _loadInit () = match getBoolean(KEY_INIT) {
88
86
 
    case a: Boolean => 
89
87
 
        a
90
88
 
    case _ => 
91
89
 
        false
92
90
 
}
93
91
 
94
92
 
95
93
 
func _saveInit (isInit_) = [BooleanEntry(KEY_INIT, isInit_)]
96
94
 
97
95
 
98
96
 
func _loadPause () = match getBoolean(KEY_PAUSED) {
99
97
 
    case a: Boolean => 
100
98
 
        a
101
99
 
    case _ => 
102
100
 
        false
103
101
 
}
104
102
 
105
103
 
106
104
 
func _savePause (isPaused_) = [BooleanEntry(KEY_PAUSED, isPaused_)]
107
105
 
108
106
 
109
107
 
func _loadPauser () = match getString(KEY_PAUSER) {
110
108
 
    case a: String => 
111
109
 
        addressFromStringValue(a)
112
110
 
    case _ => 
113
111
 
        Address(base58'')
114
112
 
}
115
113
 
116
114
 
117
115
 
func _savePauser (pauser_) = [StringEntry(KEY_PAUSER, toString(pauser_))]
118
116
 
119
117
 
120
118
 
func _loadMultisig () = match getString(KEY_MULTISIG) {
121
119
 
    case a: String => 
122
120
 
        addressFromStringValue(a)
123
121
 
    case _ => 
124
122
 
        Address(base58'')
125
123
 
}
126
124
 
127
125
 
128
126
 
func _saveMultisig (multisig_) = [StringEntry(KEY_MULTISIG, toString(multisig_))]
129
127
 
130
128
 
131
129
 
func _loadExecutor () = match getString(KEY_EXECUTOR) {
132
130
 
    case a: String => 
133
131
 
        addressFromStringValue(a)
134
132
 
    case _ => 
135
133
 
        Address(base58'')
136
134
 
}
137
135
 
138
136
 
139
137
 
func _saveExecutor (executor_) = [StringEntry(KEY_EXECUTOR, toString(executor_))]
140
138
 
141
139
 
142
140
 
func _loadCallerContract () = match getString(KEY_CALLER_CONTRACT) {
143
141
 
    case a: String => 
144
142
 
        a
145
143
 
    case _ => 
146
144
 
        ""
147
145
 
}
148
146
 
149
147
 
150
148
 
func _saveCallerContract (caller_) = [StringEntry(KEY_CALLER_CONTRACT, caller_)]
151
149
 
152
150
 
153
151
 
func _loadChain (chainId_) = match getBoolean(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR)) {
154
152
 
    case a: Boolean => 
155
153
 
        a
156
154
 
    case _ => 
157
155
 
        false
158
156
 
}
159
157
 
160
158
 
161
159
 
func _saveChain (chainId_,val_) = [BooleanEntry(makeString([KEY_CHAIN, toString(chainId_)], SEPARATOR), val_)]
162
160
 
163
161
 
164
162
 
func _loadBinding (executionChainId_,assetId_) = match getString(makeString([KEY_BINDING, toString(executionChainId_), toBase58String(assetId_)], SEPARATOR)) {
165
163
 
    case a: String => 
166
164
 
        let struct = split(a, SEPARATOR)
167
-
        $Tuple6(parseIntValue(struct[0]), parseIntValue(struct[1]), parseIntValue(struct[2]), parseIntValue(struct[3]), parseIntValue(struct[4]), if ((struct[5] == "1"))
165
+
        $Tuple7(struct[0], parseIntValue(struct[1]), parseIntValue(struct[2]), parseIntValue(struct[3]), parseIntValue(struct[4]), parseIntValue(struct[5]), if ((struct[6] == "1"))
168
166
 
            then true
169
167
 
            else false)
170
168
 
    case _ => 
171
-
        $Tuple6(0, 0, 0, 0, 0, false)
169
+
        $Tuple7("", 0, 0, 0, 0, 0, false)
172
170
 
}
173
171
 
174
172
 
175
-
func _saveBinding (executionChainId_,assetId_,binding_) = [StringEntry(makeString([KEY_BINDING, toString(executionChainId_), toBase58String(assetId_)], SEPARATOR), makeString([toString(binding_._1), toString(binding_._2), toString(binding_._3), toString(binding_._4), toString(binding_._5), if (binding_._6)
173
+
func _saveBinding (executionChainId_,assetId_,binding_) = [StringEntry(makeString([KEY_BINDING, toString(executionChainId_), toBase58String(assetId_)], SEPARATOR), makeString([binding_._1, toString(binding_._2), toString(binding_._3), toString(binding_._4), toString(binding_._5), toString(binding_._6), if (binding_._7)
176
174
 
    then "1"
177
175
 
    else "0"], SEPARATOR))]
178
176
 
179
177
 
180
178
 
func _loadFee (assetId_) = match getInteger(makeString([KEY_FEE, toBase58String(assetId_)], SEPARATOR)) {
181
179
 
    case a: Int => 
182
180
 
        a
183
181
 
    case _ => 
184
182
 
        0
185
183
 
}
186
184
 
187
185
 
188
186
 
func _saveFee (assetId_,val_) = [IntegerEntry(makeString([KEY_FEE, toBase58String(assetId_)], SEPARATOR), val_)]
189
187
 
190
188
 
191
189
 
func _loadRootAdapter () = match getString(KEY_ROOT_ADAPTER) {
192
190
 
    case a: String => 
193
191
 
        addressFromStringValue(a)
194
192
 
    case _ => 
195
193
 
        Address(base58'')
196
194
 
}
197
195
 
198
196
 
199
197
 
func _saveRootAdapter (adapter_) = [StringEntry(KEY_ROOT_ADAPTER, toString(adapter_))]
200
198
 
201
199
 
202
-
func _loadFeeChainId () = match getInteger(KEY_FEE_CHAIN_ID) {
203
-
    case a: Int => 
204
-
        a
200
+
func _loadFeeRecipient () = match getString(KEY_FEE_RECIPIENT) {
201
+
    case a: String => 
202
+
        addressFromStringValue(a)
205
203
 
    case _ => 
206
-
        0
204
+
        Address(base58'')
207
205
 
}
208
206
 
209
207
 
210
-
func _saveFeeChainId (val_) = [IntegerEntry(KEY_FEE_CHAIN_ID, val_)]
211
-
212
-
213
-
func _loadFeeRecipient () = match getString(KEY_FEE_RECIPIENT) {
214
-
    case a: String => 
215
-
        a
216
-
    case _ => 
217
-
        ""
218
-
}
219
-
220
-
221
-
func _saveFeeRecipient (val_) = [StringEntry(KEY_FEE_RECIPIENT, val_)]
208
+
func _saveFeeRecipient (val_) = [StringEntry(KEY_FEE_RECIPIENT, toString(val_))]
222
209
 
223
210
 
224
211
 
func _onlyThisContract (caller_) = if ((caller_ != this))
225
212
 
    then throw("_onlyThisContract: revert")
226
213
 
    else true
227
214
 
228
215
 
229
216
 
func _whenMultisigSet () = if ((_loadMultisig() == Address(base58'')))
230
217
 
    then throw("_whenMultisigSet: revert")
231
218
 
    else true
232
219
 
233
220
 
234
221
 
func _whenNotInitialized () = if (_loadInit())
235
222
 
    then throw("_whenNotInitialized: revert")
236
223
 
    else true
237
224
 
238
225
 
239
226
 
func _whenInitialized () = if (!(_loadInit()))
240
227
 
    then throw("_whenInitialized: revert")
241
228
 
    else true
242
229
 
243
230
 
244
231
 
func _whenNotPaused () = if (_loadPause())
245
232
 
    then throw("_whenNotPaused: revert")
246
233
 
    else true
247
234
 
248
235
 
249
236
 
func _whenPaused () = if (!(_loadPause()))
250
237
 
    then throw("_whenPaused: revert")
251
238
 
    else true
252
239
 
253
240
 
254
241
 
func _onlyPauser (caller_) = if ((caller_ != _loadPauser()))
255
242
 
    then throw("_onlyPauser: revert")
256
243
 
    else true
257
244
 
258
245
 
259
246
 
func _asInt (val_) = match val_ {
260
247
 
    case a: Int => 
261
248
 
        a
262
249
 
    case _ => 
263
250
 
        throw("_asInt: revert")
264
251
 
}
265
252
 
266
253
 
267
254
 
func _asBytes (val_) = match val_ {
268
255
 
    case a: ByteVector => 
269
256
 
        a
270
257
 
    case _ => 
271
258
 
        throw("_asBytes: revert")
272
259
 
}
273
260
 
274
261
 
275
262
 
func _validateExecutor (val_,err_) = if ((val_ != _loadExecutor()))
276
263
 
    then throw(err_)
277
264
 
    else true
278
265
 
279
266
 
280
267
 
func _validateCaller (val_,err_) = if ((val_ != _loadCallerContract()))
281
268
 
    then throw(err_)
282
269
 
    else true
283
270
 
284
271
 
285
272
 
func _validateChain (executionChainId_,err_) = if (!(_loadChain(executionChainId_)))
286
273
 
    then throw(err_)
287
274
 
    else true
288
275
 
289
276
 
290
277
 
@Callable(i)
291
278
 
func init (executor_,adapter_) = {
292
279
 
    let err = if (if (if (if (_onlyThisContract(i.caller))
293
280
 
        then _whenNotInitialized()
294
281
 
        else false)
295
282
 
        then _whenMultisigSet()
296
283
 
        else false)
297
284
 
        then _validateAddress(executor_, "init: invalid executor")
298
285
 
        else false)
299
286
 
        then _validateAddress(adapter_, "init: invalid adapter")
300
287
 
        else false
301
288
 
    if ((err == err))
302
289
 
        then $Tuple2(((_saveInit(true) ++ _saveExecutor(addressFromStringValue(executor_))) ++ _saveRootAdapter(addressFromStringValue(adapter_))), unit)
303
290
 
        else throw("Strict value is not equal to itself.")
304
291
 
    }
305
292
 
306
293
 
307
294
 
308
295
 
@Callable(i)
309
-
func mintTokens (assetContract_,amount_,recipient_,gaslessReward_,referrer_,referrerFee_,callerContract_) = {
296
+
func mintTokens (callerContract_,assetContract_,amount_,recipient_,gaslessReward_,referrer_,referrerFee_) = {
310
297
 
    let err = if (if (if (if (if (if (if (_whenInitialized())
311
298
 
        then _whenNotPaused()
312
299
 
        else false)
313
300
 
        then _validateAddress(assetContract_, "mint: invalid asset contract")
314
301
 
        else false)
315
302
 
        then _validateExecutor(i.caller, "mint: invalid executor")
316
303
 
        else false)
317
304
 
        then _validateCaller(callerContract_, "mint: invalid caller")
318
305
 
        else false)
319
306
 
        then _validateAddress(recipient_, "mint: invalid recipient address")
320
307
 
        else false)
321
308
 
        then _validateInt(amount_, 0, MAX_INT, "mint: invalid amount")
322
309
 
        else false)
323
310
 
        then _validateInt(gaslessReward_, 0, MAX_INT, "mint: invalid gaslessReward")
324
311
 
        else false
325
312
 
    if ((err == err))
326
313
 
        then {
327
314
 
            let assetId = _asBytes(invoke(addressFromStringValue(assetContract_), "getAssetId", nil, nil))
328
315
 
            if ((assetId == assetId))
329
316
 
                then {
330
317
 
                    let assetDecimals = _asInt(invoke(addressFromStringValue(assetContract_), "getDecimals", nil, nil))
331
318
 
                    if ((assetDecimals == assetDecimals))
332
319
 
                        then {
333
320
 
                            let normalizedAmount = _normalizeDecimals(amount_, DECIMALS, assetDecimals)
334
321
 
                            let normalizedGasless = _normalizeDecimals(gaslessReward_, DECIMALS, assetDecimals)
335
322
 
                            let referrer = if ((size(referrer_) > 0))
336
323
 
                                then {
337
324
 
                                    let err1 = if (_validateAddress(referrer_, "mint: invalid referrer address"))
338
325
 
                                        then _validateInt(referrerFee_, 0, MAX_INT, "mint: invalid referrer fee")
339
326
 
                                        else false
340
327
 
                                    if ((err1 == err1))
341
328
 
                                        then {
342
329
 
                                            let normalizedReferrerFee = _normalizeDecimals(referrerFee_, DECIMALS, assetDecimals)
343
330
 
                                            $Tuple2(normalizedReferrerFee, [ScriptTransfer(addressFromStringValue(referrer_), normalizedReferrerFee, assetId)])
344
331
 
                                            }
345
332
 
                                        else throw("Strict value is not equal to itself.")
346
333
 
                                    }
347
334
 
                                else $Tuple2(0, nil)
348
335
 
                            let referrerFee = referrer._1
349
336
 
                            let referrerActions = referrer._2
350
337
 
                            let invocation = invoke(addressFromStringValue(assetContract_), "mint", [(normalizedAmount + referrerFee), toString(this)], nil)
351
338
 
                            if ((invocation == invocation))
352
339
 
                                then {
353
340
 
                                    let actions = if (if ((normalizedGasless > 0))
354
341
 
                                        then (addressFromStringValue(recipient_) != i.originCaller)
355
342
 
                                        else false)
356
343
 
                                        then [ScriptTransfer(addressFromStringValue(recipient_), (normalizedAmount - normalizedGasless), assetId), ScriptTransfer(i.originCaller, normalizedGasless, assetId)]
357
344
 
                                        else [ScriptTransfer(addressFromStringValue(recipient_), normalizedAmount, assetId)]
358
345
 
                                    $Tuple2((actions ++ referrerActions), unit)
359
346
 
                                    }
360
347
 
                                else throw("Strict value is not equal to itself.")
361
348
 
                            }
362
349
 
                        else throw("Strict value is not equal to itself.")
363
350
 
                    }
364
351
 
                else throw("Strict value is not equal to itself.")
365
352
 
            }
366
353
 
        else throw("Strict value is not equal to itself.")
367
354
 
    }
368
355
 
369
356
 
370
357
 
371
358
 
@Callable(i)
372
-
func burnTokens (assetContract_,amount_,executionChainId_,recipient_,gaslessReward_,referrer_) = {
359
+
func burnTokens (executionChainId_,assetContract_,amount_,recipient_,gaslessReward_) = {
373
360
 
    let err = if (if (if (if (if (_whenInitialized())
374
361
 
        then _whenNotPaused()
375
362
 
        else false)
376
363
 
        then _validateAddress(assetContract_, "burn: invalid asset contract")
377
364
 
        else false)
378
365
 
        then _validateChain(executionChainId_, "burn: invalid execution chain")
379
366
 
        else false)
380
367
 
        then _validatePaymentsSize(i.payments, 1, "burn: no payment")
381
368
 
        else false)
382
369
 
        then _validateInt(i.payments[0].amount, amount_, MAX_INT, "burn: invalid payment amount")
383
370
 
        else false
384
371
 
    if ((err == err))
385
372
 
        then {
386
373
 
            let assetId = _asBytes(invoke(addressFromStringValue(assetContract_), "getAssetId", nil, nil))
387
374
 
            if ((assetId == assetId))
388
375
 
                then {
389
376
 
                    let assetDecimals = _asInt(invoke(addressFromStringValue(assetContract_), "getDecimals", nil, nil))
390
377
 
                    if ((assetDecimals == assetDecimals))
391
378
 
                        then {
392
379
 
                            let binding = _loadBinding(executionChainId_, assetId)
393
-
                            let minAmount = binding._1
394
-
                            let minFee = binding._2
395
-
                            let thresholdFee = binding._3
396
-
                            let beforePercentFee = binding._4
397
-
                            let afterPercentFee = binding._5
398
-
                            let enabled = binding._6
380
+
                            let executionAsset = binding._1
381
+
                            let minAmount = binding._2
382
+
                            let minFee = binding._3
383
+
                            let thresholdFee = binding._4
384
+
                            let beforePercentFee = binding._5
385
+
                            let afterPercentFee = binding._6
386
+
                            let enabled = binding._7
399
387
 
                            let err1 = if (if (_validatePaymentAsset(i.payments[0], assetId, "burn: invalid payment asset"))
400
388
 
                                then _validateInt(amount_, minAmount, MAX_INT, "burn: less than min")
401
389
 
                                else false)
402
390
 
                                then _validateBool(enabled, true, "burn: token is disabled")
403
391
 
                                else false
404
392
 
                            if ((err1 == err1))
405
393
 
                                then {
406
394
 
                                    let percent = if ((amount_ > thresholdFee))
407
395
 
                                        then afterPercentFee
408
396
 
                                        else beforePercentFee
409
397
 
                                    let fee = (minFee + ((amount_ * percent) / PERCENT_FACTOR))
410
398
 
                                    let err2 = _validateInt(amount_, (fee + 1), MAX_INT, "burn: fee more than amount")
411
399
 
                                    if ((err2 == err2))
412
400
 
                                        then {
413
401
 
                                            let amountToSend = (amount_ - fee)
414
402
 
                                            let err3 = _validateInt(amountToSend, (gaslessReward_ + 1), MAX_INT, "burn: reward more than amount")
415
403
 
                                            if ((err3 == err3))
416
404
 
                                                then {
417
405
 
                                                    let updateFee = (_loadFee(assetId) + fee)
418
406
 
                                                    let normalizedAmount = _normalizeDecimals(amountToSend, assetDecimals, DECIMALS)
419
407
 
                                                    let normalizedGasless = _normalizeDecimals(gaslessReward_, assetDecimals, DECIMALS)
420
-
                                                    let invocation = invoke(_loadRootAdapter(), FUNC_TAKE_TOKENS, [executionChainId_, assetContract_, normalizedAmount, recipient_, normalizedGasless, referrer_], nil)
408
+
                                                    let invocation = invoke(_loadRootAdapter(), FUNC_RELEASE_TOKENS, [executionChainId_, executionAsset, normalizedAmount, recipient_, normalizedGasless], nil)
421
409
 
                                                    if ((invocation == invocation))
422
-
                                                        then $Tuple2((_saveFee(assetId, updateFee) ++ [Burn(assetId, amount_)]), unit)
410
+
                                                        then $Tuple2((_saveFee(assetId, updateFee) ++ [Burn(assetId, amountToSend)]), unit)
423
411
 
                                                        else throw("Strict value is not equal to itself.")
424
412
 
                                                    }
425
413
 
                                                else throw("Strict value is not equal to itself.")
426
414
 
                                            }
427
415
 
                                        else throw("Strict value is not equal to itself.")
428
416
 
                                    }
429
417
 
                                else throw("Strict value is not equal to itself.")
430
418
 
                            }
431
419
 
                        else throw("Strict value is not equal to itself.")
432
420
 
                    }
421
+
                else throw("Strict value is not equal to itself.")
422
+
            }
423
+
        else throw("Strict value is not equal to itself.")
424
+
    }
425
+
426
+
427
+
428
+
@Callable(i)
429
+
func transferFee (assetContract_) = {
430
+
    let err = if (if (_whenInitialized())
431
+
        then _whenNotPaused()
432
+
        else false)
433
+
        then _validateAddress(assetContract_, "burnFee: invalid asset contract")
434
+
        else false
435
+
    if ((err == err))
436
+
        then {
437
+
            let assetId = _asBytes(invoke(addressFromStringValue(assetContract_), "getAssetId", nil, nil))
438
+
            if ((assetId == assetId))
439
+
                then $Tuple2((_saveFee(assetId, 0) ++ [ScriptTransfer(_loadFeeRecipient(), _loadFee(assetId), assetId)]), unit)
433
440
 
                else throw("Strict value is not equal to itself.")
434
441
 
            }
435
442
 
        else throw("Strict value is not equal to itself.")
436
443
 
    }
437
444
 
438
445
 
439
446
 
440
447
 
@Callable(i)
441
448
 
func updateCallerContract (callerContract_) = {
442
449
 
    let err = if (_onlyThisContract(i.caller))
443
450
 
        then _whenInitialized()
444
451
 
        else false
445
452
 
    if ((err == err))
446
453
 
        then $Tuple2(_saveCallerContract(callerContract_), unit)
447
454
 
        else throw("Strict value is not equal to itself.")
448
455
 
    }
449
456
 
450
457
 
451
458
 
452
459
 
@Callable(i)
453
460
 
func updateExecutionChain (executionChainId_,enabled_) = {
454
461
 
    let err = if (if (_onlyThisContract(i.caller))
455
462
 
        then _whenInitialized()
456
463
 
        else false)
457
464
 
        then _validateInt(executionChainId_, 0, MAX_INT, "updateExecutionChain: invalid executionChainId")
458
465
 
        else false
459
466
 
    if ((err == err))
460
467
 
        then $Tuple2(_saveChain(executionChainId_, enabled_), unit)
461
468
 
        else throw("Strict value is not equal to itself.")
462
469
 
    }
463
470
 
464
471
 
465
472
 
466
473
 
@Callable(i)
467
-
func updateFeeChain (feeChainId_) = {
474
+
func updateFeeRecipient (feeRecipient_) = {
468
475
 
    let err = if (if (_onlyThisContract(i.caller))
469
476
 
        then _whenInitialized()
470
477
 
        else false)
471
-
        then _validateInt(feeChainId_, 0, MAX_INT, "updateFeeChain: invalid feeChainId")
478
+
        then _validateAddress(feeRecipient_, "updateFeeRecipient: invalid feeRecipient")
472
479
 
        else false
473
480
 
    if ((err == err))
474
-
        then $Tuple2(_saveFeeChainId(feeChainId_), unit)
481
+
        then $Tuple2(_saveFeeRecipient(addressFromStringValue(feeRecipient_)), unit)
475
482
 
        else throw("Strict value is not equal to itself.")
476
483
 
    }
477
484
 
478
485
 
479
486
 
480
487
 
@Callable(i)
481
-
func updateFeeRecipient (feeRecipient_) = {
482
-
    let err = if (_onlyThisContract(i.caller))
483
-
        then _whenInitialized()
484
-
        else false
485
-
    if ((err == err))
486
-
        then $Tuple2(_saveFeeRecipient(feeRecipient_), unit)
487
-
        else throw("Strict value is not equal to itself.")
488
-
    }
489
-
490
-
491
-
492
-
@Callable(i)
493
-
func updateBindingInfo (assetContract_,executionChainId_,minAmount_,minFee_,thresholdFee_,beforePercentFee_,afterPercentFee_,enabled_) = {
488
+
func updateBindingInfo (executionChainId_,assetContract_,executionAsset_,minAmount_,minFee_,thresholdFee_,beforePercentFee_,afterPercentFee_,enabled_) = {
494
489
 
    let err = if (if (if (if (if (if (if (if (_onlyThisContract(i.caller))
495
490
 
        then _whenInitialized()
496
491
 
        else false)
497
492
 
        then _validateAddress(assetContract_, "updateBindingInfo: invalid asset contract")
498
493
 
        else false)
499
494
 
        then _validateInt(executionChainId_, 0, MAX_INT, "updateBindingInfo: invalid executionChainId")
500
495
 
        else false)
501
496
 
        then _validateInt(minAmount_, 0, MAX_INT, "updateBindingInfo: invalid minAmount")
502
497
 
        else false)
503
498
 
        then _validateInt(minFee_, 0, MAX_INT, "updateBindingInfo: invalid minFee")
504
499
 
        else false)
505
500
 
        then _validateInt(thresholdFee_, 0, MAX_INT, "updateBindingInfo: invalid thresholdFee")
506
501
 
        else false)
507
502
 
        then _validateInt(beforePercentFee_, 0, MAX_INT, "updateBindingInfo: invalid beforePercentFee")
508
503
 
        else false)
509
504
 
        then _validateInt(afterPercentFee_, 0, MAX_INT, "updateBindingInfo: invalid afterPercentFee")
510
505
 
        else false
511
506
 
    if ((err == err))
512
507
 
        then {
513
508
 
            let assetId = _asBytes(invoke(addressFromStringValue(assetContract_), "getAssetId", nil, nil))
514
509
 
            if ((assetId == assetId))
515
510
 
                then {
516
-
                    let binding = $Tuple6(minAmount_, minFee_, thresholdFee_, beforePercentFee_, afterPercentFee_, enabled_)
511
+
                    let binding = $Tuple7(executionAsset_, minAmount_, minFee_, thresholdFee_, beforePercentFee_, afterPercentFee_, enabled_)
517
512
 
                    $Tuple2(_saveBinding(executionChainId_, assetId, binding), unit)
518
513
 
                    }
519
514
 
                else throw("Strict value is not equal to itself.")
520
515
 
            }
521
516
 
        else throw("Strict value is not equal to itself.")
522
517
 
    }
523
518
 
524
519
 
525
520
 
526
521
 
@Callable(i)
527
522
 
func setMultisig (multisig_) = {
528
523
 
    let err = if (_onlyThisContract(i.caller))
529
524
 
        then _validateAddress(multisig_, "setMultisig: invalid multisig")
530
525
 
        else false
531
526
 
    if ((err == err))
532
527
 
        then $Tuple2(_saveMultisig(addressFromStringValue(multisig_)), unit)
533
528
 
        else throw("Strict value is not equal to itself.")
534
529
 
    }
535
530
 
536
531
 
537
532
 
@Verifier(tx)
538
533
 
func verify () = match getString(KEY_MULTISIG) {
539
534
 
    case multisig: String => 
540
535
 
        valueOrElse(getBoolean(addressFromStringValue(multisig), makeString([KEY_STATUS, toString(this), toBase58String(tx.id)], SEPARATOR)), false)
541
536
 
    case _ => 
542
537
 
        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
543
538
 
}
544
539
 

github/deemru/w8io/873ac7e 
72.84 ms ◑