tx · 2bUJSF69oVgVZx6im6Av9mB7ipNMYzy67MnPmhUwpSxg

3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV:  -0.02700000 Waves

2023.01.10 13:46 [2398743] smart account 3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2bUJSF69oVgVZx6im6Av9mB7ipNMYzy67MnPmhUwpSxg",
    "fee": 2700000,
    "feeAssetId": null,
    "timestamp": 1673347611373,
    "version": 1,
    "sender": "3N98Ngyaszw66EakvWRCiZ771ja2RDgNaxV",
    "senderPublicKey": "F4oaTkX67vt2MEsXLJJ8a7gaURGjW7x8fkvGfdEiH5oy",
    "proofs": [
        "2y2Aahm919ciJgSZZcfxAGaY2y1ar6AHJigZ7WtDA3xohZx6XuuxDMHy7Sg7KPqpZvQUGt4TV8F1cg5126XJ1TyZ"
    ],
    "script": "base64:BgInCAISAwoBCBIAEgcKBQgICAgIEgASBAoCCAgSABIECgIICBIDCgEIPQAJc2VwYXJhdG9yAgJfXwASc2hhcmVBc3NldERlY2ltYWxzAAgAC3dhdmVzU3RyaW5nAgVXQVZFUwAHc2NhbGUxOACAgJC7utat8A0ADXNjYWxlMThCaWdJbnQJALYCAQUHc2NhbGUxOAEHd3JhcEVycgEDbXNnCQC5CQIJAMwIAgIWbHBfc3Rha2luZ19wb29scy5yaWRlOgkAzAgCBQNtc2cFA25pbAIBIAEIdGhyb3dFcnIBA21zZwkAAgEJAQd3cmFwRXJyAQUDbXNnARJlcnJLZXlJc05vdERlZmluZWQCB2FkZHJlc3MDa2V5CQEHd3JhcEVycgEJALkJAgkAzAgCAgptYW5kYXRvcnkgCQDMCAIJAKUIAQUHYWRkcmVzcwkAzAgCAgEuCQDMCAIFA2tleQkAzAgCAg8gaXMgbm90IGRlZmluZWQFA25pbAIAAQxnZXRTdHJPckZhaWwCB2FkZHJlc3MDa2V5CQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUHYWRkcmVzcwUDa2V5CQESZXJyS2V5SXNOb3REZWZpbmVkAgUHYWRkcmVzcwUDa2V5AQxnZXRJbnRPckZhaWwCB2FkZHJlc3MDa2V5CQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUHYWRkcmVzcwUDa2V5CQESZXJyS2V5SXNOb3REZWZpbmVkAgUHYWRkcmVzcwUDa2V5AQxwYXJzZUFzc2V0SWQBBWlucHV0AwkAAAIFBWlucHV0BQt3YXZlc1N0cmluZwUEdW5pdAkA2QQBBQVpbnB1dAEPYXNzZXRJZFRvU3RyaW5nAQVpbnB1dAMJAAACBQVpbnB1dAUEdW5pdAULd2F2ZXNTdHJpbmcJANgEAQkBBXZhbHVlAQUFaW5wdXQBDmVuc3VyZVBvc2l0aXZlAQF2AwkAZwIFAXYAAAUBdgkBCHRocm93RXJyAQIYdmFsdWUgc2hvdWxkIGJlIHBvc2l0aXZlARJrZXlGYWN0b3J5Q29udHJhY3QACQC5CQIJAMwIAgICJXMJAMwIAgIPZmFjdG9yeUNvbnRyYWN0BQNuaWwFCXNlcGFyYXRvcgEUa2V5THBTdGFraW5nQ29udHJhY3QACQC5CQIJAMwIAgICJXMJAMwIAgIRbHBTdGFraW5nQ29udHJhY3QFA25pbAUJc2VwYXJhdG9yARJrZXlTdGFraW5nQ29udHJhY3QACQC5CQIJAMwIAgICJXMJAMwIAgIPc3Rha2luZ0NvbnRyYWN0BQNuaWwFCXNlcGFyYXRvcgETa2V5Qm9vc3RpbmdDb250cmFjdAAJALkJAgkAzAgCAgIlcwkAzAgCAhBib29zdGluZ0NvbnRyYWN0BQNuaWwFCXNlcGFyYXRvcgEPa2V5U3dhcENvbnRyYWN0AAkAuQkCCQDMCAICAiVzCQDMCAICDHN3YXBDb250cmFjdAUDbmlsBQlzZXBhcmF0b3IBFmtleUFzc2V0c1N0b3JlQ29udHJhY3QACQC5CQIJAMwIAgICJXMJAMwIAgITYXNzZXRzU3RvcmVDb250cmFjdAUDbmlsBQlzZXBhcmF0b3IBDmtleVVzZG5Bc3NldElkAAkAuQkCCQDMCAICAiVzCQDMCAICC3VzZG5Bc3NldElkBQNuaWwFCXNlcGFyYXRvcgEMa2V5V3hBc3NldElkAAkAuQkCCQDMCAICAiVzCQDMCAICCXd4QXNzZXRJZAUDbmlsBQlzZXBhcmF0b3IBC2tleVNodXRkb3duAAkAuQkCCQDMCAICAiVzCQDMCAICCHNodXRkb3duBQNuaWwFCXNlcGFyYXRvcgELa2V5TWluRGVsYXkACQC5CQIJAMwIAgICJXMJAMwIAgIIbWluRGVsYXkFA25pbAUJc2VwYXJhdG9yAQ9rZXlTaGFyZUFzc2V0SWQBC2Jhc2VBc3NldElkCQC5CQIJAMwIAgIEJXMlcwkAzAgCCQEPYXNzZXRJZFRvU3RyaW5nAQULYmFzZUFzc2V0SWQJAMwIAgIMc2hhcmVBc3NldElkBQNuaWwFCXNlcGFyYXRvcgEOa2V5QmFzZUFzc2V0SWQBDHNoYXJlQXNzZXRJZAkAuQkCCQDMCAICBCVzJXMJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFDHNoYXJlQXNzZXRJZAkAzAgCAgtiYXNlQXNzZXRJZAUDbmlsBQlzZXBhcmF0b3IBCWtleVBlcmlvZAELYmFzZUFzc2V0SWQJALkJAgkAzAgCAgQlcyVzCQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBQtiYXNlQXNzZXRJZAkAzAgCAgZwZXJpb2QFA25pbAUJc2VwYXJhdG9yARRrZXlQZXJpb2RTdGFydEhlaWdodAILYmFzZUFzc2V0SWQGcGVyaW9kCQC5CQIJAMwIAgIGJXMlcyVkCQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBQtiYXNlQXNzZXRJZAkAzAgCAhFwZXJpb2RTdGFydEhlaWdodAkAzAgCCQCkAwEFBnBlcmlvZAUDbmlsBQlzZXBhcmF0b3IBG2tleUJhc2VBc3NldEFtb3VudFRvQ29udmVydAELYmFzZUFzc2V0SWQJALkJAgkAzAgCAgQlcyVzCQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBQtiYXNlQXNzZXRJZAkAzAgCAhhiYXNlQXNzZXRBbW91bnRUb0NvbnZlcnQFA25pbAUJc2VwYXJhdG9yARxrZXlTaGFyZUFzc2V0QW1vdW50VG9Db252ZXJ0AQtiYXNlQXNzZXRJZAkAuQkCCQDMCAICBCVzJXMJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFC2Jhc2VBc3NldElkCQDMCAICGXNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQFA25pbAUJc2VwYXJhdG9yAR9rZXlVc2VyQmFzZUFzc2V0QW1vdW50VG9Db252ZXJ0AgtiYXNlQXNzZXRJZAt1c2VyQWRkcmVzcwkAuQkCCQDMCAICBiVzJXMlcwkAzAgCCQEPYXNzZXRJZFRvU3RyaW5nAQULYmFzZUFzc2V0SWQJAMwIAgkApQgBBQt1c2VyQWRkcmVzcwkAzAgCAhhiYXNlQXNzZXRBbW91bnRUb0NvbnZlcnQFA25pbAUJc2VwYXJhdG9yASVrZXlVc2VyQmFzZUFzc2V0QW1vdW50VG9Db252ZXJ0UGVyaW9kAgtiYXNlQXNzZXRJZAt1c2VyQWRkcmVzcwkAuQkCCQDMCAICCCVzJXMlcyVzCQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBQtiYXNlQXNzZXRJZAkAzAgCCQClCAEFC3VzZXJBZGRyZXNzCQDMCAICGGJhc2VBc3NldEFtb3VudFRvQ29udmVydAkAzAgCAgZwZXJpb2QFA25pbAUJc2VwYXJhdG9yASBrZXlVc2VyU2hhcmVBc3NldEFtb3VudFRvQ29udmVydAILYmFzZUFzc2V0SWQLdXNlckFkZHJlc3MJALkJAgkAzAgCAgYlcyVzJXMJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFC2Jhc2VBc3NldElkCQDMCAIJAKUIAQULdXNlckFkZHJlc3MJAMwIAgIZc2hhcmVBc3NldEFtb3VudFRvQ29udmVydAUDbmlsBQlzZXBhcmF0b3IBJmtleVVzZXJTaGFyZUFzc2V0QW1vdW50VG9Db252ZXJ0UGVyaW9kAgtiYXNlQXNzZXRJZAt1c2VyQWRkcmVzcwkAuQkCCQDMCAICCCVzJXMlcyVzCQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBQtiYXNlQXNzZXRJZAkAzAgCCQClCAEFC3VzZXJBZGRyZXNzCQDMCAICGXNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQJAMwIAgIGcGVyaW9kBQNuaWwFCXNlcGFyYXRvcgEOa2V5UHJpY2VQZXJpb2QCC2Jhc2VBc3NldElkBnBlcmlvZAkAuQkCCQDMCAICBiVzJXMlZAkAzAgCCQEPYXNzZXRJZFRvU3RyaW5nAQULYmFzZUFzc2V0SWQJAMwIAgIFcHJpY2UJAMwIAgkApAMBBQZwZXJpb2QFA25pbAUJc2VwYXJhdG9yAQ9rZXlQcmljZUhpc3RvcnkBC2Jhc2VBc3NldElkCQC5CQIJAMwIAgIKJXMlcyVzJWQlZAkAzAgCCQEPYXNzZXRJZFRvU3RyaW5nAQULYmFzZUFzc2V0SWQJAMwIAgIFcHJpY2UJAMwIAgIHaGlzdG9yeQkAzAgCCQCkAwEIBQlsYXN0QmxvY2sGaGVpZ2h0CQDMCAIJAKQDAQgFCWxhc3RCbG9jawl0aW1lc3RhbXAFA25pbAUJc2VwYXJhdG9yARFrZXlQcmljZVBlcmlvZFB1dAILYmFzZUFzc2V0SWQGcGVyaW9kCQC5CQIJAMwIAgIIJXMlcyVkJXMJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFC2Jhc2VBc3NldElkCQDMCAICBXByaWNlCQDMCAIJAKQDAQUGcGVyaW9kCQDMCAICA3B1dAUDbmlsBQlzZXBhcmF0b3IBEmtleVByaWNlUHV0SGlzdG9yeQELYmFzZUFzc2V0SWQJALkJAgkAzAgCAgwlcyVzJXMlcyVkJWQJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFC2Jhc2VBc3NldElkCQDMCAICBXByaWNlCQDMCAICB2hpc3RvcnkJAMwIAgIDcHV0CQDMCAIJAKQDAQgFCWxhc3RCbG9jawZoZWlnaHQJAMwIAgkApAMBCAUJbGFzdEJsb2NrCXRpbWVzdGFtcAUDbmlsBQlzZXBhcmF0b3IBEWtleVByaWNlUGVyaW9kR2V0AgtiYXNlQXNzZXRJZAZwZXJpb2QJALkJAgkAzAgCAgglcyVzJWQlcwkAzAgCCQEPYXNzZXRJZFRvU3RyaW5nAQULYmFzZUFzc2V0SWQJAMwIAgIFcHJpY2UJAMwIAgkApAMBBQZwZXJpb2QJAMwIAgIDZ2V0BQNuaWwFCXNlcGFyYXRvcgESa2V5UHJpY2VHZXRIaXN0b3J5AQtiYXNlQXNzZXRJZAkAuQkCCQDMCAICDCVzJXMlcyVzJWQlZAkAzAgCCQEPYXNzZXRJZFRvU3RyaW5nAQULYmFzZUFzc2V0SWQJAMwIAgIFcHJpY2UJAMwIAgIHaGlzdG9yeQkAzAgCAgNnZXQJAMwIAgkApAMBCAUJbGFzdEJsb2NrBmhlaWdodAkAzAgCCQCkAwEIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQNuaWwFCXNlcGFyYXRvcgEPa2V5SGlzdG9yeUVudHJ5BQtiYXNlQXNzZXRJZAlvcGVyYXRpb24GcGVyaW9kC3VzZXJBZGRyZXNzBHR4SWQJALkJAgkAzAgCAgglcyVzJXMlcwkAzAgCAgdoaXN0b3J5CQDMCAIFCW9wZXJhdGlvbgkAzAgCCQClCAEFC3VzZXJBZGRyZXNzCQDMCAIJANgEAQUEdHhJZAkAzAgCCQCkAwEFBmhlaWdodAUDbmlsBQlzZXBhcmF0b3IBE2tleU1hbmFnZXJQdWJsaWNLZXkAAhQlc19fbWFuYWdlclB1YmxpY0tleQEaa2V5UGVuZGluZ01hbmFnZXJQdWJsaWNLZXkAAhslc19fcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkBFm1hbmFnZXJQdWJsaWNLZXlPclVuaXQABAckbWF0Y2gwCQCiCAEJARNrZXlNYW5hZ2VyUHVibGljS2V5AAMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAXMFByRtYXRjaDAJANkEAQUBcwMJAAECBQckbWF0Y2gwAgRVbml0BQR1bml0CQACAQILTWF0Y2ggZXJyb3IBHXBlbmRpbmdNYW5hZ2VyUHVibGljS2V5T3JVbml0AAQHJG1hdGNoMAkAoggBCQEaa2V5UGVuZGluZ01hbmFnZXJQdWJsaWNLZXkAAwkAAQIFByRtYXRjaDACBlN0cmluZwQBcwUHJG1hdGNoMAkA2QQBBQFzAwkAAQIFByRtYXRjaDACBFVuaXQFBHVuaXQJAAIBAgtNYXRjaCBlcnJvcgAVcGVybWlzc2lvbkRlbmllZEVycm9yCQACAQIRUGVybWlzc2lvbiBkZW5pZWQBCG11c3RUaGlzAQFpAwkAAAIIBQFpBmNhbGxlcgUEdGhpcwYFFXBlcm1pc3Npb25EZW5pZWRFcnJvcgELbXVzdE1hbmFnZXIBAWkEByRtYXRjaDAJARZtYW5hZ2VyUHVibGljS2V5T3JVbml0AAMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBAJwawUHJG1hdGNoMAMJAAACCAUBaQ9jYWxsZXJQdWJsaWNLZXkFAnBrBgUVcGVybWlzc2lvbkRlbmllZEVycm9yAwkAAQIFByRtYXRjaDACBFVuaXQJAQhtdXN0VGhpcwEFAWkJAAIBAgtNYXRjaCBlcnJvcgAIc2h1dGRvd24JAQt2YWx1ZU9yRWxzZQIJAKAIAQkBC2tleVNodXRkb3duAAcBDXNodXRkb3duQ2hlY2sBAWkDAwkBASEBBQhzaHV0ZG93bgYJAQttdXN0TWFuYWdlcgEFAWkGCQACAQIVb3BlcmF0aW9uIGlzIGRpc2FibGVkAA9mYWN0b3J5Q29udHJhY3QJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAQxnZXRTdHJPckZhaWwCBQR0aGlzCQESa2V5RmFjdG9yeUNvbnRyYWN0AAARbHBTdGFraW5nQ29udHJhY3QJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAQxnZXRTdHJPckZhaWwCBQR0aGlzCQEUa2V5THBTdGFraW5nQ29udHJhY3QAAA9zdGFraW5nQ29udHJhY3QJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAQxnZXRTdHJPckZhaWwCBQR0aGlzCQESa2V5U3Rha2luZ0NvbnRyYWN0AAAQYm9vc3RpbmdDb250cmFjdAkBEUBleHRyTmF0aXZlKDEwNjIpAQkBDGdldFN0ck9yRmFpbAIFBHRoaXMJARNrZXlCb29zdGluZ0NvbnRyYWN0AAAMc3dhcENvbnRyYWN0CQERQGV4dHJOYXRpdmUoMTA2MikBCQEMZ2V0U3RyT3JGYWlsAgUEdGhpcwkBD2tleVN3YXBDb250cmFjdAAAE2Fzc2V0c1N0b3JlQ29udHJhY3QJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAQxnZXRTdHJPckZhaWwCBQR0aGlzCQEWa2V5QXNzZXRzU3RvcmVDb250cmFjdAAAC3VzZG5Bc3NldElkCQEMcGFyc2VBc3NldElkAQkBDGdldFN0ck9yRmFpbAIFBHRoaXMJAQ5rZXlVc2RuQXNzZXRJZAAACXd4QXNzZXRJZAkBDHBhcnNlQXNzZXRJZAEJAQxnZXRTdHJPckZhaWwCBQR0aGlzCQEMa2V5V3hBc3NldElkAAAPbWluRGVsYXlEZWZhdWx0AKALAAhtaW5EZWxheQkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzCQELa2V5TWluRGVsYXkABQ9taW5EZWxheURlZmF1bHQBC2dldFBvb2xJbmZvAQ1hbW91bnRBc3NldElkBBBhbW91bnRBc3NldElkU3RyCQEPYXNzZXRJZFRvU3RyaW5nAQUNYW1vdW50QXNzZXRJZAQPcHJpY2VBc3NldElkU3RyCQEPYXNzZXRJZFRvU3RyaW5nAQULdXNkbkFzc2V0SWQEDnBvb2xJbmZvT3B0aW9uCgABQAkA/AcEBQ9mYWN0b3J5Q29udHJhY3QCEHBvb2xJbmZvUkVBRE9OTFkJAMwIAgUQYW1vdW50QXNzZXRJZFN0cgkAzAgCBQ9wcmljZUFzc2V0SWRTdHIFA25pbAUDbmlsAwkAAQIFAUACFShBZGRyZXNzLCBCeXRlVmVjdG9yKQUBQAUEdW5pdAUOcG9vbEluZm9PcHRpb24BCWNhbGNQcmljZQIJbHBBc3NldElkDHNoYXJlQXNzZXRJZAQOc2hhcmVBc3NldEluZm8JARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkA7AcBBQxzaGFyZUFzc2V0SWQCHmZhaWxlZCB0byBnZXQgc2hhcmUgYXNzZXQgaW5mbwQSc2hhcmVBc3NldEVtaXNzaW9uCAUOc2hhcmVBc3NldEluZm8IcXVhbnRpdHkEDHN0YWtlZEFtb3VudAkBDmVuc3VyZVBvc2l0aXZlAQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCgABQAkA/AcEBQ9zdGFraW5nQ29udHJhY3QCFHN0YWtlZEJ5VXNlclJFQURPTkxZCQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBQlscEFzc2V0SWQJAMwIAgkApQgBBQR0aGlzBQNuaWwFA25pbAMJAAECBQFAAgNJbnQFAUAFBHVuaXQJAQd3cmFwRXJyAQIjaW52YWxpZCBzdGFrZWRCeVVzZXJSRUFET05MWSByZXN1bHQEBXByaWNlAwkAAAIFEnNoYXJlQXNzZXRFbWlzc2lvbgAABQ1zY2FsZTE4QmlnSW50CQC9AgQJALYCAQUMc3Rha2VkQW1vdW50BQ1zY2FsZTE4QmlnSW50CQC2AgEFEnNoYXJlQXNzZXRFbWlzc2lvbgUFRkxPT1IFBXByaWNlCAFpAQpzZXRNYW5hZ2VyARdwZW5kaW5nTWFuYWdlclB1YmxpY0tleQQLY2hlY2tDYWxsZXIJAQttdXN0TWFuYWdlcgEFAWkDCQAAAgULY2hlY2tDYWxsZXIFC2NoZWNrQ2FsbGVyBBVjaGVja01hbmFnZXJQdWJsaWNLZXkJANkEAQUXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkDCQAAAgUVY2hlY2tNYW5hZ2VyUHVibGljS2V5BRVjaGVja01hbmFnZXJQdWJsaWNLZXkJAMwIAgkBC1N0cmluZ0VudHJ5AgkBGmtleVBlbmRpbmdNYW5hZ2VyUHVibGljS2V5AAUXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQ5jb25maXJtTWFuYWdlcgAEAnBtCQEdcGVuZGluZ01hbmFnZXJQdWJsaWNLZXlPclVuaXQABAVoYXNQTQMJAQlpc0RlZmluZWQBBQJwbQYJAQh0aHJvd0VycgECEm5vIHBlbmRpbmcgbWFuYWdlcgMJAAACBQVoYXNQTQUFaGFzUE0EB2NoZWNrUE0DCQAAAggFAWkPY2FsbGVyUHVibGljS2V5CQEFdmFsdWUBBQJwbQYJAQh0aHJvd0VycgECG3lvdSBhcmUgbm90IHBlbmRpbmcgbWFuYWdlcgMJAAACBQdjaGVja1BNBQdjaGVja1BNCQDMCAIJAQtTdHJpbmdFbnRyeQIJARNrZXlNYW5hZ2VyUHVibGljS2V5AAkA2AQBCQEFdmFsdWUBBQJwbQkAzAgCCQELRGVsZXRlRW50cnkBCQEaa2V5UGVuZGluZ01hbmFnZXJQdWJsaWNLZXkABQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEGY3JlYXRlBQ5iYXNlQXNzZXRJZFN0cg9zaGFyZUFzc2V0SWRTdHIOc2hhcmVBc3NldE5hbWUVc2hhcmVBc3NldERlc2NyaXB0aW9uDnNoYXJlQXNzZXRMb2dvBA9zaGFyZUFzc2V0TGFiZWwCEExQX1NUQUtJTkdfUE9PTFMEC2Jhc2VBc3NldElkCQEMcGFyc2VBc3NldElkAQUOYmFzZUFzc2V0SWRTdHIEBmNoZWNrcwkAzAgCCQELbXVzdE1hbmFnZXIBBQFpCQDMCAIDCQEJaXNEZWZpbmVkAQkBC2dldFBvb2xJbmZvAQULYmFzZUFzc2V0SWQGCQEIdGhyb3dFcnIBAhJpbnZhbGlkIGJhc2UgYXNzZXQFA25pbAMJAAACBQZjaGVja3MFBmNoZWNrcwQLY29tbW9uU3RhdGUJAMwIAgkBDEludGVnZXJFbnRyeQIJAQlrZXlQZXJpb2QBBQtiYXNlQXNzZXRJZAAABQNuaWwDCQAAAgUPc2hhcmVBc3NldElkU3RyAgAEFXNoYXJlQXNzZXRJc3N1ZUFtb3VudAABBBVzaGFyZUFzc2V0SXNzdWVBY3Rpb24JAMIIBQUOc2hhcmVBc3NldE5hbWUFFXNoYXJlQXNzZXREZXNjcmlwdGlvbgUVc2hhcmVBc3NldElzc3VlQW1vdW50BRJzaGFyZUFzc2V0RGVjaW1hbHMGBBZjYWxjdWxhdGVkU2hhcmVBc3NldElkCQC4CAEFFXNoYXJlQXNzZXRJc3N1ZUFjdGlvbgQUc2hhcmVBc3NldEJ1cm5BY3Rpb24JAQRCdXJuAgUWY2FsY3VsYXRlZFNoYXJlQXNzZXRJZAUVc2hhcmVBc3NldElzc3VlQW1vdW50BBljYWxjdWxhdGVkU2hhcmVBc3NldElkU3RyCQDYBAEFFmNhbGN1bGF0ZWRTaGFyZUFzc2V0SWQEDmNyZWF0ZU9yVXBkYXRlCQD8BwQFE2Fzc2V0c1N0b3JlQ29udHJhY3QCDmNyZWF0ZU9yVXBkYXRlCQDMCAIFGWNhbGN1bGF0ZWRTaGFyZUFzc2V0SWRTdHIJAMwIAgUOc2hhcmVBc3NldExvZ28JAMwIAgcFA25pbAUDbmlsAwkAAAIFDmNyZWF0ZU9yVXBkYXRlBQ5jcmVhdGVPclVwZGF0ZQQIYWRkTGFiZWwJAPwHBAUTYXNzZXRzU3RvcmVDb250cmFjdAIIYWRkTGFiZWwJAMwIAgUZY2FsY3VsYXRlZFNoYXJlQXNzZXRJZFN0cgkAzAgCBQ9zaGFyZUFzc2V0TGFiZWwFA25pbAUDbmlsAwkAAAIFCGFkZExhYmVsBQhhZGRMYWJlbAkAlAoCCQDOCAIFC2NvbW1vblN0YXRlCQDMCAIFFXNoYXJlQXNzZXRJc3N1ZUFjdGlvbgkAzAgCBRRzaGFyZUFzc2V0QnVybkFjdGlvbgkAzAgCCQELU3RyaW5nRW50cnkCCQEPa2V5U2hhcmVBc3NldElkAQULYmFzZUFzc2V0SWQFGWNhbGN1bGF0ZWRTaGFyZUFzc2V0SWRTdHIJAMwIAgkBC1N0cmluZ0VudHJ5AgkBDmtleUJhc2VBc3NldElkAQUWY2FsY3VsYXRlZFNoYXJlQXNzZXRJZAUOYmFzZUFzc2V0SWRTdHIFA25pbAUZY2FsY3VsYXRlZFNoYXJlQXNzZXRJZFN0cgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgQMc2hhcmVBc3NldElkCQDZBAEFD3NoYXJlQXNzZXRJZFN0cgQOc2hhcmVBc3NldEluZm8JARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkA7AcBBQxzaGFyZUFzc2V0SWQJAQd3cmFwRXJyAQIWaW52YWxpZCBzaGFyZSBhc3NldCBpZAQLY2hlY2tJc3N1ZXIDCQAAAggFDnNoYXJlQXNzZXRJbmZvBmlzc3VlcgURbHBTdGFraW5nQ29udHJhY3QGCQEIdGhyb3dFcnIBAh1pbnZhbGlkIHNoYXJlIGFzc2V0IGlkIGlzc3VlcgMJAAACBQtjaGVja0lzc3VlcgULY2hlY2tJc3N1ZXIJAJQKAgkAzggCBQtjb21tb25TdGF0ZQkAzAgCCQELU3RyaW5nRW50cnkCCQEPa2V5U2hhcmVBc3NldElkAQULYmFzZUFzc2V0SWQFD3NoYXJlQXNzZXRJZFN0cgkAzAgCCQELU3RyaW5nRW50cnkCCQEPa2V5U2hhcmVBc3NldElkAQUMc2hhcmVBc3NldElkBQ5iYXNlQXNzZXRJZFN0cgUDbmlsBQ9zaGFyZUFzc2V0SWRTdHIJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEDcHV0AAQDcG10AwkAAAIJAJADAQgFAWkIcGF5bWVudHMAAQkAkQMCCAUBaQhwYXltZW50cwAACQEIdGhyb3dFcnIBAh1leGFjdGx5IDEgcGF5bWVudCBpcyBleHBlY3RlZAQLYmFzZUFzc2V0SWQIBQNwbXQHYXNzZXRJZAQLdXNlckFkZHJlc3MIBQFpBmNhbGxlcgQGY2hlY2tzCQDMCAIJAQ1zaHV0ZG93bkNoZWNrAQUBaQkAzAgCAwkBCWlzRGVmaW5lZAEJAKIIAQkBD2tleVNoYXJlQXNzZXRJZAEFC2Jhc2VBc3NldElkBgkBCHRocm93RXJyAQINaW52YWxpZCBhc3NldAUDbmlsAwkAAAIFBmNoZWNrcwUGY2hlY2tzBA0kdDAxMTAzMjExMTM1CQETdmFsdWVPckVycm9yTWVzc2FnZQIJAQtnZXRQb29sSW5mbwEFC2Jhc2VBc3NldElkCQEHd3JhcEVycgECDWludmFsaWQgYXNzZXQEC3Bvb2xBZGRyZXNzCAUNJHQwMTEwMzIxMTEzNQJfMQQJbHBBc3NldElkCAUNJHQwMTEwMzIxMTEzNQJfMgQGcGVyaW9kCQEFdmFsdWUBCQCfCAEJAQlrZXlQZXJpb2QBBQtiYXNlQXNzZXRJZAQodXNlckJhc2VBc3NldEFtb3VudFRvQ29udmVydFBlcmlvZE9wdGlvbgkAnwgBCQEla2V5VXNlckJhc2VBc3NldEFtb3VudFRvQ29udmVydFBlcmlvZAIFC2Jhc2VBc3NldElkBQt1c2VyQWRkcmVzcwQZY2xhaW1TaGFyZUFzc2V0SW52b2NhdGlvbgMJAAACBSh1c2VyQmFzZUFzc2V0QW1vdW50VG9Db252ZXJ0UGVyaW9kT3B0aW9uBQR1bml0BQR1bml0BCJ1c2VyQmFzZUFzc2V0QW1vdW50VG9Db252ZXJ0UGVyaW9kCQEFdmFsdWUBBSh1c2VyQmFzZUFzc2V0QW1vdW50VG9Db252ZXJ0UGVyaW9kT3B0aW9uAwkAAAIFInVzZXJCYXNlQXNzZXRBbW91bnRUb0NvbnZlcnRQZXJpb2QFBnBlcmlvZAUEdW5pdAkA/AcEBQR0aGlzAg9jbGFpbVNoYXJlQXNzZXQJAMwIAgkBD2Fzc2V0SWRUb1N0cmluZwEFC2Jhc2VBc3NldElkCQDMCAIJAKUIAQULdXNlckFkZHJlc3MFA25pbAUDbmlsAwkAAAIFGWNsYWltU2hhcmVBc3NldEludm9jYXRpb24FGWNsYWltU2hhcmVBc3NldEludm9jYXRpb24EGGJhc2VBc3NldEFtb3VudFRvQ29udmVydAkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEba2V5QmFzZUFzc2V0QW1vdW50VG9Db252ZXJ0AQULYmFzZUFzc2V0SWQAAAQcdXNlckJhc2VBc3NldEFtb3VudFRvQ29udmVydAkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEfa2V5VXNlckJhc2VBc3NldEFtb3VudFRvQ29udmVydAIFC2Jhc2VBc3NldElkBQt1c2VyQWRkcmVzcwAACQCUCgIJAMwIAgkBDEludGVnZXJFbnRyeQIJARtrZXlCYXNlQXNzZXRBbW91bnRUb0NvbnZlcnQBBQtiYXNlQXNzZXRJZAkAZAIFGGJhc2VBc3NldEFtb3VudFRvQ29udmVydAgFA3BtdAZhbW91bnQJAMwIAgkBDEludGVnZXJFbnRyeQIJAR9rZXlVc2VyQmFzZUFzc2V0QW1vdW50VG9Db252ZXJ0AgULYmFzZUFzc2V0SWQFC3VzZXJBZGRyZXNzCQBkAgUcdXNlckJhc2VBc3NldEFtb3VudFRvQ29udmVydAgFA3BtdAZhbW91bnQJAMwIAgkBDEludGVnZXJFbnRyeQIJASVrZXlVc2VyQmFzZUFzc2V0QW1vdW50VG9Db252ZXJ0UGVyaW9kAgULYmFzZUFzc2V0SWQFC3VzZXJBZGRyZXNzBQZwZXJpb2QJAMwIAgkBDEludGVnZXJFbnRyeQIJAQ9rZXlIaXN0b3J5RW50cnkFBQtiYXNlQXNzZXRJZAIDcHV0BQZwZXJpb2QFC3VzZXJBZGRyZXNzCAUBaQ10cmFuc2FjdGlvbklkCAUDcG10BmFtb3VudAUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBD2NsYWltU2hhcmVBc3NldAIOYmFzZUFzc2V0SWRTdHIOdXNlckFkZHJlc3NTdHIEBmNoZWNrcwkAzAgCCQENc2h1dGRvd25DaGVjawEFAWkFA25pbAMJAAACBQZjaGVja3MFBmNoZWNrcwQLdXNlckFkZHJlc3MDCQAAAgUOdXNlckFkZHJlc3NTdHICAAgFAWkGY2FsbGVyBAtjaGVja0NhbGxlcgkBCG11c3RUaGlzAQUBaQMJAAACBQtjaGVja0NhbGxlcgULY2hlY2tDYWxsZXIJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBBQ51c2VyQWRkcmVzc1N0cgkBB3dyYXBFcnIBAhRpbnZhbGlkIHVzZXIgYWRkcmVzcwkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgMJAAACBQt1c2VyQWRkcmVzcwULdXNlckFkZHJlc3MEC2Jhc2VBc3NldElkCQEMcGFyc2VBc3NldElkAQUOYmFzZUFzc2V0SWRTdHIEDHNoYXJlQXNzZXRJZAkBBXZhbHVlAQkBDHBhcnNlQXNzZXRJZAEJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoggBCQEPa2V5U2hhcmVBc3NldElkAQULYmFzZUFzc2V0SWQJAQd3cmFwRXJyAQIVaW52YWxpZCBiYXNlIGFzc2V0IGlkAwkAAAIFDHNoYXJlQXNzZXRJZAUMc2hhcmVBc3NldElkBAZwZXJpb2QJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnwgBCQEJa2V5UGVyaW9kAQULYmFzZUFzc2V0SWQJAQd3cmFwRXJyAQIOaW52YWxpZCBwZXJpb2QDCQAAAgUGcGVyaW9kBQZwZXJpb2QEHHVzZXJCYXNlQXNzZXRBbW91bnRUb0NvbnZlcnQJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBH2tleVVzZXJCYXNlQXNzZXRBbW91bnRUb0NvbnZlcnQCBQtiYXNlQXNzZXRJZAULdXNlckFkZHJlc3MAAAQUY2hlY2tBbW91bnRUb0NvbnZlcnQDCQBmAgUcdXNlckJhc2VBc3NldEFtb3VudFRvQ29udmVydAAABgkBCHRocm93RXJyAQIQbm90aGluZyB0byBjbGFpbQMJAAACBRRjaGVja0Ftb3VudFRvQ29udmVydAUUY2hlY2tBbW91bnRUb0NvbnZlcnQEInVzZXJCYXNlQXNzZXRBbW91bnRUb0NvbnZlcnRQZXJpb2QJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnwgBCQEla2V5VXNlckJhc2VBc3NldEFtb3VudFRvQ29udmVydFBlcmlvZAIFC2Jhc2VBc3NldElkBQt1c2VyQWRkcmVzcwkBB3dyYXBFcnIBAhRmYWlsZWQgdG8gZ2V0IHBlcmlvZAQLY2hlY2tQZXJpb2QDCQBmAgUGcGVyaW9kBSJ1c2VyQmFzZUFzc2V0QW1vdW50VG9Db252ZXJ0UGVyaW9kBgkBCHRocm93RXJyAQIOaW52YWxpZCBwZXJpb2QDCQAAAgULY2hlY2tQZXJpb2QFC2NoZWNrUGVyaW9kBAVwcmljZQkAngMBCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKEIAQkBEWtleVByaWNlUGVyaW9kUHV0AgULYmFzZUFzc2V0SWQFInVzZXJCYXNlQXNzZXRBbW91bnRUb0NvbnZlcnRQZXJpb2QJAQd3cmFwRXJyAQITZmFpbGVkIHRvIGdldCBwcmljZQQQc2hhcmVBc3NldEFtb3VudAkAoAMBCQC8AgMJALYCAQUcdXNlckJhc2VBc3NldEFtb3VudFRvQ29udmVydAUNc2NhbGUxOEJpZ0ludAUFcHJpY2UJAJQKAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBH2tleVVzZXJCYXNlQXNzZXRBbW91bnRUb0NvbnZlcnQCBQtiYXNlQXNzZXRJZAULdXNlckFkZHJlc3MAAAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDBQt1c2VyQWRkcmVzcwUQc2hhcmVBc3NldEFtb3VudAUMc2hhcmVBc3NldElkCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEPa2V5SGlzdG9yeUVudHJ5BQULYmFzZUFzc2V0SWQCD2NsYWltU2hhcmVBc3NldAUGcGVyaW9kBQt1c2VyQWRkcmVzcwgFAWkNdHJhbnNhY3Rpb25JZAUQc2hhcmVBc3NldEFtb3VudAUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBA2dldAAEBmNoZWNrcwkAzAgCCQENc2h1dGRvd25DaGVjawEFAWkFA25pbAMJAAACBQZjaGVja3MFBmNoZWNrcwQDcG10AwkAAAIJAJADAQgFAWkIcGF5bWVudHMAAQkAkQMCCAUBaQhwYXltZW50cwAACQEIdGhyb3dFcnIBAh1leGFjdGx5IDEgcGF5bWVudCBpcyBleHBlY3RlZAQMc2hhcmVBc3NldElkCAUDcG10B2Fzc2V0SWQEC2Jhc2VBc3NldElkCQEFdmFsdWUBCQEMcGFyc2VBc3NldElkAQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJAQ5rZXlCYXNlQXNzZXRJZAEFDHNoYXJlQXNzZXRJZAkBB3dyYXBFcnIBAhZpbnZhbGlkIHNoYXJlIGFzc2V0IGlkAwkAAAIFC2Jhc2VBc3NldElkBQtiYXNlQXNzZXRJZAQLdXNlckFkZHJlc3MIBQFpBmNhbGxlcgQNJHQwMTQ4MzYxNDkzOQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQELZ2V0UG9vbEluZm8BBQtiYXNlQXNzZXRJZAkBB3dyYXBFcnIBAg1pbnZhbGlkIGFzc2V0BAtwb29sQWRkcmVzcwgFDSR0MDE0ODM2MTQ5MzkCXzEECWxwQXNzZXRJZAgFDSR0MDE0ODM2MTQ5MzkCXzIEBnBlcmlvZAkBBXZhbHVlAQkAnwgBCQEJa2V5UGVyaW9kAQULYmFzZUFzc2V0SWQEKXVzZXJTaGFyZUFzc2V0QW1vdW50VG9Db252ZXJ0UGVyaW9kT3B0aW9uCQCfCAEJASZrZXlVc2VyU2hhcmVBc3NldEFtb3VudFRvQ29udmVydFBlcmlvZAIFC2Jhc2VBc3NldElkBQt1c2VyQWRkcmVzcwQYY2xhaW1CYXNlQXNzZXRJbnZvY2F0aW9uAwkAAAIFKXVzZXJTaGFyZUFzc2V0QW1vdW50VG9Db252ZXJ0UGVyaW9kT3B0aW9uBQR1bml0BQR1bml0BCN1c2VyU2hhcmVBc3NldEFtb3VudFRvQ29udmVydFBlcmlvZAkBBXZhbHVlAQUpdXNlclNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnRQZXJpb2RPcHRpb24DCQAAAgUjdXNlclNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnRQZXJpb2QFBnBlcmlvZAUEdW5pdAkA/AcEBQR0aGlzAg5jbGFpbUJhc2VBc3NldAkAzAgCBQt1c2VyQWRkcmVzcwUDbmlsBQNuaWwDCQAAAgUYY2xhaW1CYXNlQXNzZXRJbnZvY2F0aW9uBRhjbGFpbUJhc2VBc3NldEludm9jYXRpb24EGXNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBHGtleVNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQBBQtiYXNlQXNzZXRJZAAABB11c2VyU2hhcmVBc3NldEFtb3VudFRvQ29udmVydAkBC3ZhbHVlT3JFbHNlAgkAnwgBCQEga2V5VXNlclNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQCBQtiYXNlQXNzZXRJZAULdXNlckFkZHJlc3MAAAkAlAoCCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEca2V5U2hhcmVBc3NldEFtb3VudFRvQ29udmVydAEFC2Jhc2VBc3NldElkCQBkAgUZc2hhcmVBc3NldEFtb3VudFRvQ29udmVydAgFA3BtdAZhbW91bnQJAMwIAgkBDEludGVnZXJFbnRyeQIJASBrZXlVc2VyU2hhcmVBc3NldEFtb3VudFRvQ29udmVydAIFC2Jhc2VBc3NldElkBQt1c2VyQWRkcmVzcwkAZAIFHXVzZXJTaGFyZUFzc2V0QW1vdW50VG9Db252ZXJ0CAUDcG10BmFtb3VudAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBJmtleVVzZXJTaGFyZUFzc2V0QW1vdW50VG9Db252ZXJ0UGVyaW9kAgULYmFzZUFzc2V0SWQFC3VzZXJBZGRyZXNzBQZwZXJpb2QJAMwIAgkBDEludGVnZXJFbnRyeQIJAQ9rZXlIaXN0b3J5RW50cnkFBQtiYXNlQXNzZXRJZAIDZ2V0BQZwZXJpb2QFC3VzZXJBZGRyZXNzCAUBaQ10cmFuc2FjdGlvbklkCAUDcG10BmFtb3VudAUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBDmNsYWltQmFzZUFzc2V0Ag5iYXNlQXNzZXRJZFN0cg51c2VyQWRkcmVzc1N0cgQGY2hlY2tzCQDMCAIJAQ1zaHV0ZG93bkNoZWNrAQUBaQUDbmlsAwkAAAIFBmNoZWNrcwUGY2hlY2tzBAt1c2VyQWRkcmVzcwMJAAACBQ51c2VyQWRkcmVzc1N0cgIACAUBaQZjYWxsZXIEC2NoZWNrQ2FsbGVyCQEIbXVzdFRoaXMBBQFpAwkAAAIFC2NoZWNrQ2FsbGVyBQtjaGVja0NhbGxlcgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEFDnVzZXJBZGRyZXNzU3RyCQEHd3JhcEVycgECFGludmFsaWQgdXNlciBhZGRyZXNzCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAwkAAAIFC3VzZXJBZGRyZXNzBQt1c2VyQWRkcmVzcwQLYmFzZUFzc2V0SWQJAQxwYXJzZUFzc2V0SWQBBQ5iYXNlQXNzZXRJZFN0cgQMc2hhcmVBc3NldElkCQEFdmFsdWUBCQEMcGFyc2VBc3NldElkAQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEJAQ9rZXlTaGFyZUFzc2V0SWQBBQtiYXNlQXNzZXRJZAkBB3dyYXBFcnIBAhVpbnZhbGlkIGJhc2UgYXNzZXQgaWQDCQAAAgUMc2hhcmVBc3NldElkBQxzaGFyZUFzc2V0SWQEBnBlcmlvZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCfCAEJAQlrZXlQZXJpb2QBBQtiYXNlQXNzZXRJZAkBB3dyYXBFcnIBAg5pbnZhbGlkIHBlcmlvZAMJAAACBQZwZXJpb2QFBnBlcmlvZAQddXNlclNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBIGtleVVzZXJTaGFyZUFzc2V0QW1vdW50VG9Db252ZXJ0AgULYmFzZUFzc2V0SWQFC3VzZXJBZGRyZXNzAAAEFGNoZWNrQW1vdW50VG9Db252ZXJ0AwkAZgIFHXVzZXJTaGFyZUFzc2V0QW1vdW50VG9Db252ZXJ0AAAGCQEIdGhyb3dFcnIBAhBub3RoaW5nIHRvIGNsYWltAwkAAAIFFGNoZWNrQW1vdW50VG9Db252ZXJ0BRRjaGVja0Ftb3VudFRvQ29udmVydAQjdXNlclNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnRQZXJpb2QJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnwgBCQEma2V5VXNlclNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnRQZXJpb2QCBQtiYXNlQXNzZXRJZAULdXNlckFkZHJlc3MJAQd3cmFwRXJyAQIUZmFpbGVkIHRvIGdldCBwZXJpb2QEC2NoZWNrUGVyaW9kAwkAZgIFBnBlcmlvZAUjdXNlclNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnRQZXJpb2QGCQEIdGhyb3dFcnIBAg5pbnZhbGlkIHBlcmlvZAMJAAACBQtjaGVja1BlcmlvZAULY2hlY2tQZXJpb2QEBXByaWNlCQCeAwEJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAoQgBCQERa2V5UHJpY2VQZXJpb2RHZXQCBQtiYXNlQXNzZXRJZAUjdXNlclNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnRQZXJpb2QJAQd3cmFwRXJyAQITZmFpbGVkIHRvIGdldCBwcmljZQQPYmFzZUFzc2V0QW1vdW50CQCgAwEJALwCAwkAtgIBBR11c2VyU2hhcmVBc3NldEFtb3VudFRvQ29udmVydAUFcHJpY2UFDXNjYWxlMThCaWdJbnQJAJQKAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBIGtleVVzZXJTaGFyZUFzc2V0QW1vdW50VG9Db252ZXJ0AgULYmFzZUFzc2V0SWQFC3VzZXJBZGRyZXNzAAAJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwULdXNlckFkZHJlc3MFD2Jhc2VBc3NldEFtb3VudAULYmFzZUFzc2V0SWQJAMwIAgkBDEludGVnZXJFbnRyeQIJAQ9rZXlIaXN0b3J5RW50cnkFBQtiYXNlQXNzZXRJZAIOY2xhaW1CYXNlQXNzZXQFBnBlcmlvZAULdXNlckFkZHJlc3MIBQFpDXRyYW5zYWN0aW9uSWQFD2Jhc2VBc3NldEFtb3VudAUDbmlsBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBCGZpbmFsaXplAQ5iYXNlQXNzZXRJZFN0cgQGY2hlY2tzCQDMCAIJAQ1zaHV0ZG93bkNoZWNrAQUBaQUDbmlsAwkAAAIFBmNoZWNrcwUGY2hlY2tzBAtiYXNlQXNzZXRJZAkBDHBhcnNlQXNzZXRJZAEFDmJhc2VBc3NldElkU3RyBAxzaGFyZUFzc2V0SWQJAQV2YWx1ZQEJAQxwYXJzZUFzc2V0SWQBCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKIIAQkBD2tleVNoYXJlQXNzZXRJZAEFC2Jhc2VBc3NldElkCQEHd3JhcEVycgECFWludmFsaWQgYmFzZSBhc3NldCBpZAMJAAACBQxzaGFyZUFzc2V0SWQFDHNoYXJlQXNzZXRJZAQGcGVyaW9kCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ8IAQkBCWtleVBlcmlvZAEFC2Jhc2VBc3NldElkCQEHd3JhcEVycgECDmludmFsaWQgcGVyaW9kAwkAAAIFBnBlcmlvZAUGcGVyaW9kBBdwZXJpb2RTdGFydEhlaWdodE9wdGlvbgkAnwgBCQEUa2V5UGVyaW9kU3RhcnRIZWlnaHQCBQtiYXNlQXNzZXRJZAUGcGVyaW9kBApjaGVja0RlbGF5AwkAAAIFF3BlcmlvZFN0YXJ0SGVpZ2h0T3B0aW9uBQR1bml0BQR1bml0BAVkZWxheQkAZQIFBmhlaWdodAkBBXZhbHVlAQUXcGVyaW9kU3RhcnRIZWlnaHRPcHRpb24EDGJsb2Nrc1RvV2FpdAkAlwMBCQDMCAIAAAkAzAgCCQBlAgUIbWluRGVsYXkFBWRlbGF5BQNuaWwDCQAAAgUMYmxvY2tzVG9XYWl0AAAFBHVuaXQJAQh0aHJvd0VycgEJALkJAgkAzAgCAiFmaW5hbGl6YXRpb24gd2lsbCBiZSBwb3NzaWJsZSBpbiAJAMwIAgkApAMBBQxibG9ja3NUb1dhaXQJAMwIAgIHIGJsb2NrcwUDbmlsAgADCQAAAgUKY2hlY2tEZWxheQUKY2hlY2tEZWxheQQNJHQwMTg4ODExOTA2MQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQELZ2V0UG9vbEluZm8BBQtiYXNlQXNzZXRJZAkBB3dyYXBFcnIBAg1pbnZhbGlkIGFzc2V0BAtwb29sQWRkcmVzcwgFDSR0MDE4ODgxMTkwNjECXzEECWxwQXNzZXRJZAgFDSR0MDE4ODgxMTkwNjECXzIEDXN0YWtpbmdSZXdhcmQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgoAAUAJAPwHBAUPc3Rha2luZ0NvbnRyYWN0AgdjbGFpbVd4CQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBQlscEFzc2V0SWQFA25pbAUDbmlsAwkAAQIFAUACA0ludAUBQAUEdW5pdAkBB3dyYXBFcnIBAhZpbnZhbGlkIGNsYWltV3ggcmVzdWx0AwkAAAIFDXN0YWtpbmdSZXdhcmQFDXN0YWtpbmdSZXdhcmQEEHVzZVN0YWtpbmdSZXdhcmQDCQBmAgUNc3Rha2luZ1Jld2FyZAAABAhsb2NrUGFydAkAaQIFDXN0YWtpbmdSZXdhcmQAAgQLY29udmVydFBhcnQJAGUCBQ1zdGFraW5nUmV3YXJkBQhsb2NrUGFydAQBcgkA/AcEBRBib29zdGluZ0NvbnRyYWN0Ahd1c2VyTWF4RHVyYXRpb25SRUFET05MWQkAzAgCCQClCAEFBHRoaXMFA25pbAUDbmlsBARsb2NrBAckbWF0Y2gwBQFyAwMDCQABAggFByRtYXRjaDACXzECBlN0cmluZwkAAQIIBQckbWF0Y2gwAl8yAgNJbnQHCQABAgUHJG1hdGNoMAINKFN0cmluZywgSW50KQcECGZ1bmN0aW9uCAUHJG1hdGNoMAJfMQQIZHVyYXRpb24IBQckbWF0Y2gwAl8yAwkAZgIFCGxvY2tQYXJ0AAAJAPwHBAUQYm9vc3RpbmdDb250cmFjdAUIZnVuY3Rpb24JAMwIAgUIZHVyYXRpb24FA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUJd3hBc3NldElkBQhsb2NrUGFydAUDbmlsBQR1bml0CQEIdGhyb3dFcnIBAhNpbnZhbGlkIGxvY2sgcGFyYW1zAwkAAAIFBGxvY2sFBGxvY2sED2NvbnZlcnRlZEFtb3VudAQJaW5Bc3NldElkBQl3eEFzc2V0SWQEEG1pbmltdW1Ub1JlY2VpdmUAAAQNb3V0QXNzZXRJZFN0cgkBD2Fzc2V0SWRUb1N0cmluZwEFC3VzZG5Bc3NldElkBA10YXJnZXRBZGRyZXNzAgAJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgoAAUAJAPwHBAUMc3dhcENvbnRyYWN0AgRzd2FwCQDMCAIFEG1pbmltdW1Ub1JlY2VpdmUJAMwIAgUNb3V0QXNzZXRJZFN0cgkAzAgCBQ10YXJnZXRBZGRyZXNzBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFCWluQXNzZXRJZAULY29udmVydFBhcnQFA25pbAMJAAECBQFAAgNJbnQFAUAFBHVuaXQJAQd3cmFwRXJyAQITaW52YWxpZCBzd2FwIHJlc3VsdAMJAAACBQ9jb252ZXJ0ZWRBbW91bnQFD2NvbnZlcnRlZEFtb3VudAQNbHBBc3NldEFtb3VudAQMbWluT3V0QW1vdW50AAAECWF1dG9TdGFrZQYJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgoAAUAJAPwHBAULcG9vbEFkZHJlc3MCC3B1dE9uZVRrblYyCQDMCAIFDG1pbk91dEFtb3VudAkAzAgCBQlhdXRvU3Rha2UFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgULdXNkbkFzc2V0SWQFD2NvbnZlcnRlZEFtb3VudAUDbmlsAwkAAQIFAUACA0ludAUBQAUEdW5pdAkBB3dyYXBFcnIBAhppbnZhbGlkIHB1dE9uZVRrblYyIHJlc3VsdAMJAAACBQ1scEFzc2V0QW1vdW50BQ1scEFzc2V0QW1vdW50BQ1scEFzc2V0QW1vdW50CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBQR1bml0AwkAAAIFEHVzZVN0YWtpbmdSZXdhcmQFEHVzZVN0YWtpbmdSZXdhcmQEGXNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBHGtleVNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQBBQtiYXNlQXNzZXRJZAAABApnZXRBY3Rpb25zAwkAZgIFGXNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQAAAQFcHJpY2UJAQljYWxjUHJpY2UCBQlscEFzc2V0SWQFDHNoYXJlQXNzZXRJZAMJAAACBQVwcmljZQUFcHJpY2UEDXVuc3Rha2VBbW91bnQJAKADAQkAvQIECQC2AgEFGXNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQFBXByaWNlBQ1zY2FsZTE4QmlnSW50BQVGTE9PUgQPYmFzZUFzc2V0QW1vdW50BApvdXRBc3NldElkBQtiYXNlQXNzZXRJZAQMbWluT3V0QW1vdW50AAAJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgoAAUAJAPwHBAULcG9vbEFkZHJlc3MCFXVuc3Rha2VBbmRHZXRPbmVUa25WMgkAzAgCBQ11bnN0YWtlQW1vdW50CQDMCAIJAQ9hc3NldElkVG9TdHJpbmcBBQpvdXRBc3NldElkCQDMCAIFDG1pbk91dEFtb3VudAUDbmlsBQNuaWwDCQABAgUBQAIDSW50BQFABQR1bml0CQEHd3JhcEVycgECJGludmFsaWQgdW5zdGFrZUFuZEdldE9uZVRrblYyIHJlc3VsdAMJAAACBQ9iYXNlQXNzZXRBbW91bnQFD2Jhc2VBc3NldEFtb3VudAQVc2hhcmVBc3NldEJ1cm5BY3Rpb25zCQDMCAIJAQRCdXJuAgUMc2hhcmVBc3NldElkBRlzaGFyZUFzc2V0QW1vdW50VG9Db252ZXJ0BQNuaWwECHByaWNlR2V0CQC9AgQJALYCAQUPYmFzZUFzc2V0QW1vdW50BQ1zY2FsZTE4QmlnSW50CQC2AgEFGXNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQFBUZMT09SBBVwcmljZUdldFVwZGF0ZUFjdGlvbnMJAMwIAgkBC0JpbmFyeUVudHJ5AgkBEWtleVByaWNlUGVyaW9kR2V0AgULYmFzZUFzc2V0SWQFBnBlcmlvZAkAnQMBBQhwcmljZUdldAkAzAgCCQELU3RyaW5nRW50cnkCCQESa2V5UHJpY2VHZXRIaXN0b3J5AQULYmFzZUFzc2V0SWQJAKYDAQUIcHJpY2VHZXQFA25pbAkAzggCBRVzaGFyZUFzc2V0QnVybkFjdGlvbnMFFXByaWNlR2V0VXBkYXRlQWN0aW9ucwkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgUDbmlsBBhiYXNlQXNzZXRBbW91bnRUb0NvbnZlcnQJAQt2YWx1ZU9yRWxzZQIJAJ8IAQkBG2tleUJhc2VBc3NldEFtb3VudFRvQ29udmVydAEFC2Jhc2VBc3NldElkAAAECnB1dEFjdGlvbnMDCQBmAgUYYmFzZUFzc2V0QW1vdW50VG9Db252ZXJ0AAAEDWxwQXNzZXRBbW91bnQEDG1pbk91dEFtb3VudAAABAlhdXRvU3Rha2UGCQETdmFsdWVPckVycm9yTWVzc2FnZQIKAAFACQD8BwQFC3Bvb2xBZGRyZXNzAgtwdXRPbmVUa25WMgkAzAgCBQxtaW5PdXRBbW91bnQJAMwIAgUJYXV0b1N0YWtlBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFC2Jhc2VBc3NldElkBRhiYXNlQXNzZXRBbW91bnRUb0NvbnZlcnQFA25pbAMJAAECBQFAAgNJbnQFAUAFBHVuaXQJAQd3cmFwRXJyAQIaaW52YWxpZCBwdXRPbmVUa25WMiByZXN1bHQDCQAAAgUNbHBBc3NldEFtb3VudAUNbHBBc3NldEFtb3VudAQFcHJpY2UJAQljYWxjUHJpY2UCBQlscEFzc2V0SWQFDHNoYXJlQXNzZXRJZAMJAAACBQVwcmljZQUFcHJpY2UEEHNoYXJlQXNzZXRBbW91bnQJAKADAQkAvQIECQC2AgEFDWxwQXNzZXRBbW91bnQFDXNjYWxlMThCaWdJbnQFBXByaWNlBQVGTE9PUgQMaXNSZWlzc3VhYmxlBgQYc2hhcmVBc3NldFJlaXNzdWVBY3Rpb25zCQDMCAIJAQdSZWlzc3VlAwUMc2hhcmVBc3NldElkBRBzaGFyZUFzc2V0QW1vdW50BQxpc1JlaXNzdWFibGUFA25pbAQIcHJpY2VQdXQJALwCAwkAtgIBBRhiYXNlQXNzZXRBbW91bnRUb0NvbnZlcnQFDXNjYWxlMThCaWdJbnQJALYCAQUQc2hhcmVBc3NldEFtb3VudAQVcHJpY2VQdXRVcGRhdGVBY3Rpb25zCQDMCAIJAQtCaW5hcnlFbnRyeQIJARFrZXlQcmljZVBlcmlvZFB1dAIFC2Jhc2VBc3NldElkBQZwZXJpb2QJAJ0DAQUIcHJpY2VQdXQJAMwIAgkBC1N0cmluZ0VudHJ5AgkBEmtleVByaWNlUHV0SGlzdG9yeQEFC2Jhc2VBc3NldElkCQCmAwEFCHByaWNlUHV0BQNuaWwJAM4IAgUYc2hhcmVBc3NldFJlaXNzdWVBY3Rpb25zBRVwcmljZVB1dFVwZGF0ZUFjdGlvbnMJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4FA25pbAQJbmV3UGVyaW9kCQBkAgUGcGVyaW9kAAEECWxhc3RQcmljZQkBCWNhbGNQcmljZQIFCWxwQXNzZXRJZAUMc2hhcmVBc3NldElkBAdhY3Rpb25zCQDOCAIJAM4IAgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBCWtleVBlcmlvZAEFC2Jhc2VBc3NldElkBQluZXdQZXJpb2QJAMwIAgkBDEludGVnZXJFbnRyeQIJARRrZXlQZXJpb2RTdGFydEhlaWdodAIFC2Jhc2VBc3NldElkBQluZXdQZXJpb2QFBmhlaWdodAkAzAgCCQEMSW50ZWdlckVudHJ5AgkBHGtleVNoYXJlQXNzZXRBbW91bnRUb0NvbnZlcnQBBQtiYXNlQXNzZXRJZAAACQDMCAIJAQxJbnRlZ2VyRW50cnkCCQEba2V5QmFzZUFzc2V0QW1vdW50VG9Db252ZXJ0AQULYmFzZUFzc2V0SWQAAAkAzAgCCQELQmluYXJ5RW50cnkCCQEOa2V5UHJpY2VQZXJpb2QCBQtiYXNlQXNzZXRJZAUGcGVyaW9kCQCdAwEFCWxhc3RQcmljZQkAzAgCCQELU3RyaW5nRW50cnkCCQEPa2V5UHJpY2VIaXN0b3J5AQULYmFzZUFzc2V0SWQJAKYDAQUJbGFzdFByaWNlBQNuaWwFCnB1dEFjdGlvbnMFCmdldEFjdGlvbnMJAJQKAgUHYWN0aW9ucwkAnQMBBQlsYXN0UHJpY2UJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAnR4AQZ2ZXJpZnkABA90YXJnZXRQdWJsaWNLZXkEByRtYXRjaDAJARZtYW5hZ2VyUHVibGljS2V5T3JVbml0AAMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBAJwawUHJG1hdGNoMAUCcGsDCQABAgUHJG1hdGNoMAIEVW5pdAgFAnR4D3NlbmRlclB1YmxpY0tleQkAAgECC01hdGNoIGVycm9yCQD0AwMIBQJ0eAlib2R5Qnl0ZXMJAJEDAggFAnR4BnByb29mcwAABQ90YXJnZXRQdWJsaWNLZXmJzE9+",
    "chainId": 84,
    "height": 2398743,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: DHrPoHw8EmsUpxjcgYLZMFJmYfqEKsWNhUnQwyMJWfJg
Next: 7exsjLKnvz3qfjpTcdYXggQh48K885hb37rmxzTqsySk

Diff: 

OldNewDifferences
6363 
6464 
6565 func keyWxAssetId () = makeString(["%s", "wxAssetId"], separator)
66+
67+
68+func keyShutdown () = makeString(["%s", "shutdown"], separator)
6669 
6770 
6871 func keyMinDelay () = makeString(["%s", "minDelay"], separator)
164167 }
165168 
166169 
170+let shutdown = valueOrElse(getBoolean(keyShutdown()), false)
171+
172+func shutdownCheck (i) = if (if (!(shutdown))
173+    then true
174+    else mustManager(i))
175+    then true
176+    else throw("operation is disabled")
177+
178+
167179 let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract()))
168180 
169181 let lpStakingContract = addressFromStringValue(getStrOrFail(this, keyLpStakingContract()))
194206             else unit
195207         }
196208     poolInfoOption
209+    }
210+
211+
212+func calcPrice (lpAssetId,shareAssetId) = {
213+    let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), "failed to get share asset info")
214+    let shareAssetEmission = shareAssetInfo.quantity
215+    let stakedAmount = ensurePositive(valueOrErrorMessage({
216+        let @ = invoke(stakingContract, "stakedByUserREADONLY", [assetIdToString(lpAssetId), toString(this)], nil)
217+        if ($isInstanceOf(@, "Int"))
218+            then @
219+            else unit
220+        }, wrapErr("invalid stakedByUserREADONLY result")))
221+    let price = if ((shareAssetEmission == 0))
222+        then scale18BigInt
223+        else fraction(toBigInt(stakedAmount), scale18BigInt, toBigInt(shareAssetEmission), FLOOR)
224+    price
197225     }
198226 
199227 
282310         else throwErr("exactly 1 payment is expected")
283311     let baseAssetId = pmt.assetId
284312     let userAddress = i.caller
285-    let checks = [if (isDefined(getString(keyShareAssetId(baseAssetId))))
313+    let checks = [shutdownCheck(i), if (isDefined(getString(keyShareAssetId(baseAssetId))))
286314         then true
287315         else throwErr("invalid asset")]
288316     if ((checks == checks))
289317         then {
290-            let $t01007810181 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
291-            let poolAddress = $t01007810181._1
292-            let lpAssetId = $t01007810181._2
318+            let $t01103211135 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
319+            let poolAddress = $t01103211135._1
320+            let lpAssetId = $t01103211135._2
293321             let period = value(getInteger(keyPeriod(baseAssetId)))
294322             let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
295323             let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
315343 
316344 @Callable(i)
317345 func claimShareAsset (baseAssetIdStr,userAddressStr) = {
318-    let userAddress = if ((userAddressStr == ""))
319-        then i.caller
320-        else {
321-            let checkCaller = mustThis(i)
322-            if ((checkCaller == checkCaller))
323-                then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
324-                else throw("Strict value is not equal to itself.")
325-            }
326-    if ((userAddress == userAddress))
346+    let checks = [shutdownCheck(i)]
347+    if ((checks == checks))
327348         then {
328-            let baseAssetId = parseAssetId(baseAssetIdStr)
329-            let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
330-            if ((shareAssetId == shareAssetId))
349+            let userAddress = if ((userAddressStr == ""))
350+                then i.caller
351+                else {
352+                    let checkCaller = mustThis(i)
353+                    if ((checkCaller == checkCaller))
354+                        then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
355+                        else throw("Strict value is not equal to itself.")
356+                    }
357+            if ((userAddress == userAddress))
331358                 then {
332-                    let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
333-                    if ((period == period))
359+                    let baseAssetId = parseAssetId(baseAssetIdStr)
360+                    let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
361+                    if ((shareAssetId == shareAssetId))
334362                         then {
335-                            let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0)
336-                            let checkAmountToConvert = if ((userBaseAssetAmountToConvert > 0))
337-                                then true
338-                                else throwErr("nothing to claim")
339-                            if ((checkAmountToConvert == checkAmountToConvert))
363+                            let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
364+                            if ((period == period))
340365                                 then {
341-                                    let userBaseAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
342-                                    let checkPeriod = if ((period > userBaseAssetAmountToConvertPeriod))
366+                                    let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0)
367+                                    let checkAmountToConvert = if ((userBaseAssetAmountToConvert > 0))
343368                                         then true
344-                                        else throwErr("invalid period")
345-                                    if ((checkPeriod == checkPeriod))
369+                                        else throwErr("nothing to claim")
370+                                    if ((checkAmountToConvert == checkAmountToConvert))
346371                                         then {
347-                                            let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
348-                                            let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price))
349-                                            $Tuple2([IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), shareAssetAmount)], unit)
372+                                            let userBaseAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
373+                                            let checkPeriod = if ((period > userBaseAssetAmountToConvertPeriod))
374+                                                then true
375+                                                else throwErr("invalid period")
376+                                            if ((checkPeriod == checkPeriod))
377+                                                then {
378+                                                    let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
379+                                                    let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price))
380+                                                    $Tuple2([IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), shareAssetAmount)], unit)
381+                                                    }
382+                                                else throw("Strict value is not equal to itself.")
350383                                             }
351384                                         else throw("Strict value is not equal to itself.")
352385                                     }
363396 
364397 @Callable(i)
365398 func get () = {
366-    let pmt = if ((size(i.payments) == 1))
367-        then i.payments[0]
368-        else throwErr("exactly 1 payment is expected")
369-    let shareAssetId = pmt.assetId
370-    let baseAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyBaseAssetId(shareAssetId)), wrapErr("invalid share asset id"))))
371-    if ((baseAssetId == baseAssetId))
399+    let checks = [shutdownCheck(i)]
400+    if ((checks == checks))
372401         then {
373-            let userAddress = i.caller
374-            let $t01379013893 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
375-            let poolAddress = $t01379013893._1
376-            let lpAssetId = $t01379013893._2
377-            let period = value(getInteger(keyPeriod(baseAssetId)))
378-            let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
379-            let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
380-                then unit
381-                else {
382-                    let userShareAssetAmountToConvertPeriod = value(userShareAssetAmountToConvertPeriodOption)
383-                    if ((userShareAssetAmountToConvertPeriod == period))
402+            let pmt = if ((size(i.payments) == 1))
403+                then i.payments[0]
404+                else throwErr("exactly 1 payment is expected")
405+            let shareAssetId = pmt.assetId
406+            let baseAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyBaseAssetId(shareAssetId)), wrapErr("invalid share asset id"))))
407+            if ((baseAssetId == baseAssetId))
408+                then {
409+                    let userAddress = i.caller
410+                    let $t01483614939 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
411+                    let poolAddress = $t01483614939._1
412+                    let lpAssetId = $t01483614939._2
413+                    let period = value(getInteger(keyPeriod(baseAssetId)))
414+                    let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
415+                    let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
384416                         then unit
385-                        else invoke(this, "claimBaseAsset", [userAddress], nil)
386-                    }
387-            if ((claimBaseAssetInvocation == claimBaseAssetInvocation))
388-                then {
389-                    let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
390-                    let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
391-                    $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), (userShareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), IntegerEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), pmt.amount)], unit)
417+                        else {
418+                            let userShareAssetAmountToConvertPeriod = value(userShareAssetAmountToConvertPeriodOption)
419+                            if ((userShareAssetAmountToConvertPeriod == period))
420+                                then unit
421+                                else invoke(this, "claimBaseAsset", [userAddress], nil)
422+                            }
423+                    if ((claimBaseAssetInvocation == claimBaseAssetInvocation))
424+                        then {
425+                            let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
426+                            let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
427+                            $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), (userShareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), IntegerEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), pmt.amount)], unit)
428+                            }
429+                        else throw("Strict value is not equal to itself.")
392430                     }
393431                 else throw("Strict value is not equal to itself.")
394432             }
399437 
400438 @Callable(i)
401439 func claimBaseAsset (baseAssetIdStr,userAddressStr) = {
402-    let userAddress = if ((userAddressStr == ""))
403-        then i.caller
404-        else {
405-            let checkCaller = mustThis(i)
406-            if ((checkCaller == checkCaller))
407-                then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
408-                else throw("Strict value is not equal to itself.")
409-            }
410-    if ((userAddress == userAddress))
440+    let checks = [shutdownCheck(i)]
441+    if ((checks == checks))
411442         then {
412-            let baseAssetId = parseAssetId(baseAssetIdStr)
413-            let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
414-            if ((shareAssetId == shareAssetId))
443+            let userAddress = if ((userAddressStr == ""))
444+                then i.caller
445+                else {
446+                    let checkCaller = mustThis(i)
447+                    if ((checkCaller == checkCaller))
448+                        then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
449+                        else throw("Strict value is not equal to itself.")
450+                    }
451+            if ((userAddress == userAddress))
415452                 then {
416-                    let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
417-                    if ((period == period))
453+                    let baseAssetId = parseAssetId(baseAssetIdStr)
454+                    let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
455+                    if ((shareAssetId == shareAssetId))
418456                         then {
419-                            let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
420-                            let checkAmountToConvert = if ((userShareAssetAmountToConvert > 0))
421-                                then true
422-                                else throwErr("nothing to claim")
423-                            if ((checkAmountToConvert == checkAmountToConvert))
457+                            let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
458+                            if ((period == period))
424459                                 then {
425-                                    let userShareAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
426-                                    let checkPeriod = if ((period > userShareAssetAmountToConvertPeriod))
460+                                    let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
461+                                    let checkAmountToConvert = if ((userShareAssetAmountToConvert > 0))
427462                                         then true
428-                                        else throwErr("invalid period")
429-                                    if ((checkPeriod == checkPeriod))
463+                                        else throwErr("nothing to claim")
464+                                    if ((checkAmountToConvert == checkAmountToConvert))
430465                                         then {
431-                                            let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
432-                                            let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt))
433-                                            $Tuple2([IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), baseAssetAmount)], unit)
466+                                            let userShareAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
467+                                            let checkPeriod = if ((period > userShareAssetAmountToConvertPeriod))
468+                                                then true
469+                                                else throwErr("invalid period")
470+                                            if ((checkPeriod == checkPeriod))
471+                                                then {
472+                                                    let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
473+                                                    let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt))
474+                                                    $Tuple2([IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), baseAssetAmount)], unit)
475+                                                    }
476+                                                else throw("Strict value is not equal to itself.")
434477                                             }
435478                                         else throw("Strict value is not equal to itself.")
436479                                     }
447490 
448491 @Callable(i)
449492 func finalize (baseAssetIdStr) = {
450-    let baseAssetId = parseAssetId(baseAssetIdStr)
451-    let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
452-    if ((shareAssetId == shareAssetId))
493+    let checks = [shutdownCheck(i)]
494+    if ((checks == checks))
453495         then {
454-            let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
455-            if ((period == period))
496+            let baseAssetId = parseAssetId(baseAssetIdStr)
497+            let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
498+            if ((shareAssetId == shareAssetId))
456499                 then {
457-                    let periodStartHeightOption = getInteger(keyPeriodStartHeight(baseAssetId, period))
458-                    let checkDelay = if ((periodStartHeightOption == unit))
459-                        then unit
460-                        else {
461-                            let delay = (height - value(periodStartHeightOption))
462-                            let blocksToWait = min([0, (minDelay - delay)])
463-                            if ((blocksToWait == 0))
500+                    let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
501+                    if ((period == period))
502+                        then {
503+                            let periodStartHeightOption = getInteger(keyPeriodStartHeight(baseAssetId, period))
504+                            let checkDelay = if ((periodStartHeightOption == unit))
464505                                 then unit
465-                                else throwErr(makeString(["finalization will be possible in ", toString(blocksToWait), " blocks"], ""))
466-                            }
467-                    if ((checkDelay == checkDelay))
468-                        then {
469-                            let $t01774317923 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
470-                            let poolAddress = $t01774317923._1
471-                            let lpAssetId = $t01774317923._2
472-                            let stakingReward = valueOrErrorMessage({
473-                                let @ = invoke(stakingContract, "claimWx", [assetIdToString(lpAssetId)], nil)
474-                                if ($isInstanceOf(@, "Int"))
475-                                    then @
476-                                    else unit
477-                                }, wrapErr("invalid claimWx result"))
478-                            if ((stakingReward == stakingReward))
506+                                else {
507+                                    let delay = (height - value(periodStartHeightOption))
508+                                    let blocksToWait = min([0, (minDelay - delay)])
509+                                    if ((blocksToWait == 0))
510+                                        then unit
511+                                        else throwErr(makeString(["finalization will be possible in ", toString(blocksToWait), " blocks"], ""))
512+                                    }
513+                            if ((checkDelay == checkDelay))
479514                                 then {
480-                                    let useStakingReward = if ((stakingReward > 0))
515+                                    let $t01888119061 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
516+                                    let poolAddress = $t01888119061._1
517+                                    let lpAssetId = $t01888119061._2
518+                                    let stakingReward = valueOrErrorMessage({
519+                                        let @ = invoke(stakingContract, "claimWx", [assetIdToString(lpAssetId)], nil)
520+                                        if ($isInstanceOf(@, "Int"))
521+                                            then @
522+                                            else unit
523+                                        }, wrapErr("invalid claimWx result"))
524+                                    if ((stakingReward == stakingReward))
481525                                         then {
482-                                            let lockPart = (stakingReward / 2)
483-                                            let convertPart = (stakingReward - lockPart)
484-                                            let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil)
485-                                            let lock =                                             match r {
486-                                                case _ => 
487-                                                    if (if (if ($isInstanceOf($match0._1, "String"))
488-                                                        then $isInstanceOf($match0._2, "Int")
489-                                                        else false)
490-                                                        then $isInstanceOf($match0, "(String, Int)")
491-                                                        else false)
526+                                            let useStakingReward = if ((stakingReward > 0))
527+                                                then {
528+                                                    let lockPart = (stakingReward / 2)
529+                                                    let convertPart = (stakingReward - lockPart)
530+                                                    let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil)
531+                                                    let lock =                                                     match r {
532+                                                        case _ => 
533+                                                            if (if (if ($isInstanceOf($match0._1, "String"))
534+                                                                then $isInstanceOf($match0._2, "Int")
535+                                                                else false)
536+                                                                then $isInstanceOf($match0, "(String, Int)")
537+                                                                else false)
538+                                                                then {
539+                                                                    let function = $match0._1
540+                                                                    let duration = $match0._2
541+                                                                    if ((lockPart > 0))
542+                                                                        then invoke(boostingContract, function, [duration], [AttachedPayment(wxAssetId, lockPart)])
543+                                                                        else unit
544+                                                                    }
545+                                                                else throwErr("invalid lock params")
546+                                                    }
547+                                                    if ((lock == lock))
492548                                                         then {
493-                                                            let function = $match0._1
494-                                                            let duration = $match0._2
495-                                                            if ((lockPart > 0))
496-                                                                then invoke(boostingContract, function, [duration], [AttachedPayment(wxAssetId, lockPart)])
497-                                                                else unit
498-                                                            }
499-                                                        else throwErr("invalid lock params")
500-                                            }
501-                                            if ((lock == lock))
502-                                                then {
503-                                                    let convertedAmount = {
504-                                                        let inAssetId = wxAssetId
505-                                                        let minimumToReceive = 0
506-                                                        let outAssetIdStr = assetIdToString(usdnAssetId)
507-                                                        let targetAddress = ""
508-                                                        valueOrErrorMessage({
509-                                                            let @ = invoke(swapContract, "swap", [minimumToReceive, outAssetIdStr, targetAddress], [AttachedPayment(inAssetId, convertPart)])
510-                                                            if ($isInstanceOf(@, "Int"))
511-                                                                then @
512-                                                                else unit
513-                                                            }, wrapErr("invalid swap result"))
514-                                                        }
515-                                                    if ((convertedAmount == convertedAmount))
516-                                                        then {
517-                                                            let lpAssetAmount = {
518-                                                                let minOutAmount = 0
519-                                                                let autoStake = true
549+                                                            let convertedAmount = {
550+                                                                let inAssetId = wxAssetId
551+                                                                let minimumToReceive = 0
552+                                                                let outAssetIdStr = assetIdToString(usdnAssetId)
553+                                                                let targetAddress = ""
520554                                                                 valueOrErrorMessage({
521-                                                                    let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(usdnAssetId, convertedAmount)])
555+                                                                    let @ = invoke(swapContract, "swap", [minimumToReceive, outAssetIdStr, targetAddress], [AttachedPayment(inAssetId, convertPart)])
522556                                                                     if ($isInstanceOf(@, "Int"))
523557                                                                         then @
524558                                                                         else unit
525-                                                                    }, wrapErr("invalid putOneTknV2 result"))
559+                                                                    }, wrapErr("invalid swap result"))
526560                                                                 }
527-                                                            if ((lpAssetAmount == lpAssetAmount))
528-                                                                then lpAssetAmount
561+                                                            if ((convertedAmount == convertedAmount))
562+                                                                then {
563+                                                                    let lpAssetAmount = {
564+                                                                        let minOutAmount = 0
565+                                                                        let autoStake = true
566+                                                                        valueOrErrorMessage({
567+                                                                            let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(usdnAssetId, convertedAmount)])
568+                                                                            if ($isInstanceOf(@, "Int"))
569+                                                                                then @
570+                                                                                else unit
571+                                                                            }, wrapErr("invalid putOneTknV2 result"))
572+                                                                        }
573+                                                                    if ((lpAssetAmount == lpAssetAmount))
574+                                                                        then lpAssetAmount
575+                                                                        else throw("Strict value is not equal to itself.")
576+                                                                    }
529577                                                                 else throw("Strict value is not equal to itself.")
530578                                                             }
531579                                                         else throw("Strict value is not equal to itself.")
532580                                                     }
533-                                                else throw("Strict value is not equal to itself.")
534-                                            }
535-                                        else unit
536-                                    if ((useStakingReward == useStakingReward))
537-                                        then {
538-                                            let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), "failed to get share asset info")
539-                                            let shareAssetEmission = shareAssetInfo.quantity
540-                                            let stakedAmount = ensurePositive(valueOrErrorMessage({
541-                                                let @ = invoke(stakingContract, "stakedByUserREADONLY", [assetIdToString(lpAssetId), toString(this)], nil)
542-                                                if ($isInstanceOf(@, "Int"))
543-                                                    then @
544-                                                    else unit
545-                                                }, wrapErr("invalid stakedByUserREADONLY result")))
546-                                            let price = if ((shareAssetEmission == 0))
547-                                                then scale18BigInt
548-                                                else fraction(toBigInt(stakedAmount), scale18BigInt, toBigInt(shareAssetEmission), FLOOR)
549-                                            if ((price == price))
581+                                                else unit
582+                                            if ((useStakingReward == useStakingReward))
550583                                                 then {
551584                                                     let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
552585                                                     let getActions = if ((shareAssetAmountToConvert > 0))
553586                                                         then {
554-                                                            let unstakeAmount = toInt(fraction(toBigInt(shareAssetAmountToConvert), price, scale18BigInt, FLOOR))
555-                                                            let baseAssetAmount = {
556-                                                                let outAssetId = baseAssetId
557-                                                                let minOutAmount = 0
558-                                                                valueOrErrorMessage({
559-                                                                    let @ = invoke(poolAddress, "unstakeAndGetOneTknV2", [unstakeAmount, assetIdToString(outAssetId), minOutAmount], nil)
560-                                                                    if ($isInstanceOf(@, "Int"))
561-                                                                        then @
562-                                                                        else unit
563-                                                                    }, wrapErr("invalid unstakeAndGetOneTknV2 result"))
564-                                                                }
565-                                                            if ((baseAssetAmount == baseAssetAmount))
587+                                                            let price = calcPrice(lpAssetId, shareAssetId)
588+                                                            if ((price == price))
566589                                                                 then {
567-                                                                    let shareAssetBurnActions = [Burn(shareAssetId, shareAssetAmountToConvert)]
568-                                                                    let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
569-                                                                    let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
570-                                                                    (shareAssetBurnActions ++ priceGetUpdateActions)
590+                                                                    let unstakeAmount = toInt(fraction(toBigInt(shareAssetAmountToConvert), price, scale18BigInt, FLOOR))
591+                                                                    let baseAssetAmount = {
592+                                                                        let outAssetId = baseAssetId
593+                                                                        let minOutAmount = 0
594+                                                                        valueOrErrorMessage({
595+                                                                            let @ = invoke(poolAddress, "unstakeAndGetOneTknV2", [unstakeAmount, assetIdToString(outAssetId), minOutAmount], nil)
596+                                                                            if ($isInstanceOf(@, "Int"))
597+                                                                                then @
598+                                                                                else unit
599+                                                                            }, wrapErr("invalid unstakeAndGetOneTknV2 result"))
600+                                                                        }
601+                                                                    if ((baseAssetAmount == baseAssetAmount))
602+                                                                        then {
603+                                                                            let shareAssetBurnActions = [Burn(shareAssetId, shareAssetAmountToConvert)]
604+                                                                            let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
605+                                                                            let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
606+                                                                            (shareAssetBurnActions ++ priceGetUpdateActions)
607+                                                                            }
608+                                                                        else throw("Strict value is not equal to itself.")
571609                                                                     }
572610                                                                 else throw("Strict value is not equal to itself.")
573611                                                             }
587625                                                                 }
588626                                                             if ((lpAssetAmount == lpAssetAmount))
589627                                                                 then {
590-                                                                    let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
591-                                                                    let isReissuable = true
592-                                                                    let shareAssetReissueActions = [Reissue(shareAssetId, shareAssetAmount, isReissuable)]
593-                                                                    let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
594-                                                                    let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
595-                                                                    (shareAssetReissueActions ++ pricePutUpdateActions)
628+                                                                    let price = calcPrice(lpAssetId, shareAssetId)
629+                                                                    if ((price == price))
630+                                                                        then {
631+                                                                            let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
632+                                                                            let isReissuable = true
633+                                                                            let shareAssetReissueActions = [Reissue(shareAssetId, shareAssetAmount, isReissuable)]
634+                                                                            let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
635+                                                                            let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
636+                                                                            (shareAssetReissueActions ++ pricePutUpdateActions)
637+                                                                            }
638+                                                                        else throw("Strict value is not equal to itself.")
596639                                                                     }
597640                                                                 else throw("Strict value is not equal to itself.")
598641                                                             }
599642                                                         else nil
600643                                                     let newPeriod = (period + 1)
601-                                                    let actions = (([IntegerEntry(keyPeriod(baseAssetId), newPeriod), IntegerEntry(keyPeriodStartHeight(baseAssetId, newPeriod), height), IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), 0), IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), 0), BinaryEntry(keyPricePeriod(baseAssetId, period), toBytes(price)), StringEntry(keyPriceHistory(baseAssetId), toString(price))] ++ putActions) ++ getActions)
602-                                                    $Tuple2(actions, toBytes(price))
644+                                                    let lastPrice = calcPrice(lpAssetId, shareAssetId)
645+                                                    let actions = (([IntegerEntry(keyPeriod(baseAssetId), newPeriod), IntegerEntry(keyPeriodStartHeight(baseAssetId, newPeriod), height), IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), 0), IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), 0), BinaryEntry(keyPricePeriod(baseAssetId, period), toBytes(lastPrice)), StringEntry(keyPriceHistory(baseAssetId), toString(lastPrice))] ++ putActions) ++ getActions)
646+                                                    $Tuple2(actions, toBytes(lastPrice))
603647                                                     }
604648                                                 else throw("Strict value is not equal to itself.")
605649                                             }

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let separator = "__"
55 
66 let shareAssetDecimals = 8
77 
88 let wavesString = "WAVES"
99 
1010 let scale18 = 1000000000000000000
1111 
1212 let scale18BigInt = toBigInt(scale18)
1313 
1414 func wrapErr (msg) = makeString(["lp_staking_pools.ride:", msg], " ")
1515 
1616 
1717 func throwErr (msg) = throw(wrapErr(msg))
1818 
1919 
2020 func errKeyIsNotDefined (address,key) = wrapErr(makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
2121 
2222 
2323 func getStrOrFail (address,key) = valueOrErrorMessage(getString(address, key), errKeyIsNotDefined(address, key))
2424 
2525 
2626 func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), errKeyIsNotDefined(address, key))
2727 
2828 
2929 func parseAssetId (input) = if ((input == wavesString))
3030     then unit
3131     else fromBase58String(input)
3232 
3333 
3434 func assetIdToString (input) = if ((input == unit))
3535     then wavesString
3636     else toBase58String(value(input))
3737 
3838 
3939 func ensurePositive (v) = if ((v >= 0))
4040     then v
4141     else throwErr("value should be positive")
4242 
4343 
4444 func keyFactoryContract () = makeString(["%s", "factoryContract"], separator)
4545 
4646 
4747 func keyLpStakingContract () = makeString(["%s", "lpStakingContract"], separator)
4848 
4949 
5050 func keyStakingContract () = makeString(["%s", "stakingContract"], separator)
5151 
5252 
5353 func keyBoostingContract () = makeString(["%s", "boostingContract"], separator)
5454 
5555 
5656 func keySwapContract () = makeString(["%s", "swapContract"], separator)
5757 
5858 
5959 func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], separator)
6060 
6161 
6262 func keyUsdnAssetId () = makeString(["%s", "usdnAssetId"], separator)
6363 
6464 
6565 func keyWxAssetId () = makeString(["%s", "wxAssetId"], separator)
66+
67+
68+func keyShutdown () = makeString(["%s", "shutdown"], separator)
6669 
6770 
6871 func keyMinDelay () = makeString(["%s", "minDelay"], separator)
6972 
7073 
7174 func keyShareAssetId (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetId"], separator)
7275 
7376 
7477 func keyBaseAssetId (shareAssetId) = makeString(["%s%s", assetIdToString(shareAssetId), "baseAssetId"], separator)
7578 
7679 
7780 func keyPeriod (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "period"], separator)
7881 
7982 
8083 func keyPeriodStartHeight (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "periodStartHeight", toString(period)], separator)
8184 
8285 
8386 func keyBaseAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "baseAssetAmountToConvert"], separator)
8487 
8588 
8689 func keyShareAssetAmountToConvert (baseAssetId) = makeString(["%s%s", assetIdToString(baseAssetId), "shareAssetAmountToConvert"], separator)
8790 
8891 
8992 func keyUserBaseAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert"], separator)
9093 
9194 
9295 func keyUserBaseAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "baseAssetAmountToConvert", "period"], separator)
9396 
9497 
9598 func keyUserShareAssetAmountToConvert (baseAssetId,userAddress) = makeString(["%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert"], separator)
9699 
97100 
98101 func keyUserShareAssetAmountToConvertPeriod (baseAssetId,userAddress) = makeString(["%s%s%s%s", assetIdToString(baseAssetId), toString(userAddress), "shareAssetAmountToConvert", "period"], separator)
99102 
100103 
101104 func keyPricePeriod (baseAssetId,period) = makeString(["%s%s%d", assetIdToString(baseAssetId), "price", toString(period)], separator)
102105 
103106 
104107 func keyPriceHistory (baseAssetId) = makeString(["%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
105108 
106109 
107110 func keyPricePeriodPut (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "put"], separator)
108111 
109112 
110113 func keyPricePutHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "put", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
111114 
112115 
113116 func keyPricePeriodGet (baseAssetId,period) = makeString(["%s%s%d%s", assetIdToString(baseAssetId), "price", toString(period), "get"], separator)
114117 
115118 
116119 func keyPriceGetHistory (baseAssetId) = makeString(["%s%s%s%s%d%d", assetIdToString(baseAssetId), "price", "history", "get", toString(lastBlock.height), toString(lastBlock.timestamp)], separator)
117120 
118121 
119122 func keyHistoryEntry (baseAssetId,operation,period,userAddress,txId) = makeString(["%s%s%s%s", "history", operation, toString(userAddress), toBase58String(txId), toString(height)], separator)
120123 
121124 
122125 func keyManagerPublicKey () = "%s__managerPublicKey"
123126 
124127 
125128 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
126129 
127130 
128131 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
129132     case s: String => 
130133         fromBase58String(s)
131134     case _: Unit => 
132135         unit
133136     case _ => 
134137         throw("Match error")
135138 }
136139 
137140 
138141 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
139142     case s: String => 
140143         fromBase58String(s)
141144     case _: Unit => 
142145         unit
143146     case _ => 
144147         throw("Match error")
145148 }
146149 
147150 
148151 let permissionDeniedError = throw("Permission denied")
149152 
150153 func mustThis (i) = if ((i.caller == this))
151154     then true
152155     else permissionDeniedError
153156 
154157 
155158 func mustManager (i) = match managerPublicKeyOrUnit() {
156159     case pk: ByteVector => 
157160         if ((i.callerPublicKey == pk))
158161             then true
159162             else permissionDeniedError
160163     case _: Unit => 
161164         mustThis(i)
162165     case _ => 
163166         throw("Match error")
164167 }
165168 
166169 
170+let shutdown = valueOrElse(getBoolean(keyShutdown()), false)
171+
172+func shutdownCheck (i) = if (if (!(shutdown))
173+    then true
174+    else mustManager(i))
175+    then true
176+    else throw("operation is disabled")
177+
178+
167179 let factoryContract = addressFromStringValue(getStrOrFail(this, keyFactoryContract()))
168180 
169181 let lpStakingContract = addressFromStringValue(getStrOrFail(this, keyLpStakingContract()))
170182 
171183 let stakingContract = addressFromStringValue(getStrOrFail(this, keyStakingContract()))
172184 
173185 let boostingContract = addressFromStringValue(getStrOrFail(this, keyBoostingContract()))
174186 
175187 let swapContract = addressFromStringValue(getStrOrFail(this, keySwapContract()))
176188 
177189 let assetsStoreContract = addressFromStringValue(getStrOrFail(this, keyAssetsStoreContract()))
178190 
179191 let usdnAssetId = parseAssetId(getStrOrFail(this, keyUsdnAssetId()))
180192 
181193 let wxAssetId = parseAssetId(getStrOrFail(this, keyWxAssetId()))
182194 
183195 let minDelayDefault = 1440
184196 
185197 let minDelay = valueOrElse(getInteger(this, keyMinDelay()), minDelayDefault)
186198 
187199 func getPoolInfo (amountAssetId) = {
188200     let amountAssetIdStr = assetIdToString(amountAssetId)
189201     let priceAssetIdStr = assetIdToString(usdnAssetId)
190202     let poolInfoOption = {
191203         let @ = invoke(factoryContract, "poolInfoREADONLY", [amountAssetIdStr, priceAssetIdStr], nil)
192204         if ($isInstanceOf(@, "(Address, ByteVector)"))
193205             then @
194206             else unit
195207         }
196208     poolInfoOption
209+    }
210+
211+
212+func calcPrice (lpAssetId,shareAssetId) = {
213+    let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), "failed to get share asset info")
214+    let shareAssetEmission = shareAssetInfo.quantity
215+    let stakedAmount = ensurePositive(valueOrErrorMessage({
216+        let @ = invoke(stakingContract, "stakedByUserREADONLY", [assetIdToString(lpAssetId), toString(this)], nil)
217+        if ($isInstanceOf(@, "Int"))
218+            then @
219+            else unit
220+        }, wrapErr("invalid stakedByUserREADONLY result")))
221+    let price = if ((shareAssetEmission == 0))
222+        then scale18BigInt
223+        else fraction(toBigInt(stakedAmount), scale18BigInt, toBigInt(shareAssetEmission), FLOOR)
224+    price
197225     }
198226 
199227 
200228 @Callable(i)
201229 func setManager (pendingManagerPublicKey) = {
202230     let checkCaller = mustManager(i)
203231     if ((checkCaller == checkCaller))
204232         then {
205233             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
206234             if ((checkManagerPublicKey == checkManagerPublicKey))
207235                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
208236                 else throw("Strict value is not equal to itself.")
209237             }
210238         else throw("Strict value is not equal to itself.")
211239     }
212240 
213241 
214242 
215243 @Callable(i)
216244 func confirmManager () = {
217245     let pm = pendingManagerPublicKeyOrUnit()
218246     let hasPM = if (isDefined(pm))
219247         then true
220248         else throwErr("no pending manager")
221249     if ((hasPM == hasPM))
222250         then {
223251             let checkPM = if ((i.callerPublicKey == value(pm)))
224252                 then true
225253                 else throwErr("you are not pending manager")
226254             if ((checkPM == checkPM))
227255                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
228256                 else throw("Strict value is not equal to itself.")
229257             }
230258         else throw("Strict value is not equal to itself.")
231259     }
232260 
233261 
234262 
235263 @Callable(i)
236264 func create (baseAssetIdStr,shareAssetIdStr,shareAssetName,shareAssetDescription,shareAssetLogo) = {
237265     let shareAssetLabel = "LP_STAKING_POOLS"
238266     let baseAssetId = parseAssetId(baseAssetIdStr)
239267     let checks = [mustManager(i), if (isDefined(getPoolInfo(baseAssetId)))
240268         then true
241269         else throwErr("invalid base asset")]
242270     if ((checks == checks))
243271         then {
244272             let commonState = [IntegerEntry(keyPeriod(baseAssetId), 0)]
245273             if ((shareAssetIdStr == ""))
246274                 then {
247275                     let shareAssetIssueAmount = 1
248276                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescription, shareAssetIssueAmount, shareAssetDecimals, true)
249277                     let calculatedShareAssetId = calculateAssetId(shareAssetIssueAction)
250278                     let shareAssetBurnAction = Burn(calculatedShareAssetId, shareAssetIssueAmount)
251279                     let calculatedShareAssetIdStr = toBase58String(calculatedShareAssetId)
252280                     let createOrUpdate = invoke(assetsStoreContract, "createOrUpdate", [calculatedShareAssetIdStr, shareAssetLogo, false], nil)
253281                     if ((createOrUpdate == createOrUpdate))
254282                         then {
255283                             let addLabel = invoke(assetsStoreContract, "addLabel", [calculatedShareAssetIdStr, shareAssetLabel], nil)
256284                             if ((addLabel == addLabel))
257285                                 then $Tuple2((commonState ++ [shareAssetIssueAction, shareAssetBurnAction, StringEntry(keyShareAssetId(baseAssetId), calculatedShareAssetIdStr), StringEntry(keyBaseAssetId(calculatedShareAssetId), baseAssetIdStr)]), calculatedShareAssetIdStr)
258286                                 else throw("Strict value is not equal to itself.")
259287                             }
260288                         else throw("Strict value is not equal to itself.")
261289                     }
262290                 else {
263291                     let shareAssetId = fromBase58String(shareAssetIdStr)
264292                     let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), wrapErr("invalid share asset id"))
265293                     let checkIssuer = if ((shareAssetInfo.issuer == lpStakingContract))
266294                         then true
267295                         else throwErr("invalid share asset id issuer")
268296                     if ((checkIssuer == checkIssuer))
269297                         then $Tuple2((commonState ++ [StringEntry(keyShareAssetId(baseAssetId), shareAssetIdStr), StringEntry(keyShareAssetId(shareAssetId), baseAssetIdStr)]), shareAssetIdStr)
270298                         else throw("Strict value is not equal to itself.")
271299                     }
272300             }
273301         else throw("Strict value is not equal to itself.")
274302     }
275303 
276304 
277305 
278306 @Callable(i)
279307 func put () = {
280308     let pmt = if ((size(i.payments) == 1))
281309         then i.payments[0]
282310         else throwErr("exactly 1 payment is expected")
283311     let baseAssetId = pmt.assetId
284312     let userAddress = i.caller
285-    let checks = [if (isDefined(getString(keyShareAssetId(baseAssetId))))
313+    let checks = [shutdownCheck(i), if (isDefined(getString(keyShareAssetId(baseAssetId))))
286314         then true
287315         else throwErr("invalid asset")]
288316     if ((checks == checks))
289317         then {
290-            let $t01007810181 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
291-            let poolAddress = $t01007810181._1
292-            let lpAssetId = $t01007810181._2
318+            let $t01103211135 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
319+            let poolAddress = $t01103211135._1
320+            let lpAssetId = $t01103211135._2
293321             let period = value(getInteger(keyPeriod(baseAssetId)))
294322             let userBaseAssetAmountToConvertPeriodOption = getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress))
295323             let claimShareAssetInvocation = if ((userBaseAssetAmountToConvertPeriodOption == unit))
296324                 then unit
297325                 else {
298326                     let userBaseAssetAmountToConvertPeriod = value(userBaseAssetAmountToConvertPeriodOption)
299327                     if ((userBaseAssetAmountToConvertPeriod == period))
300328                         then unit
301329                         else invoke(this, "claimShareAsset", [assetIdToString(baseAssetId), toString(userAddress)], nil)
302330                     }
303331             if ((claimShareAssetInvocation == claimShareAssetInvocation))
304332                 then {
305333                     let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
306334                     let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0)
307335                     $Tuple2([IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), (baseAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), (userBaseAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress), period), IntegerEntry(keyHistoryEntry(baseAssetId, "put", period, userAddress, i.transactionId), pmt.amount)], unit)
308336                     }
309337                 else throw("Strict value is not equal to itself.")
310338             }
311339         else throw("Strict value is not equal to itself.")
312340     }
313341 
314342 
315343 
316344 @Callable(i)
317345 func claimShareAsset (baseAssetIdStr,userAddressStr) = {
318-    let userAddress = if ((userAddressStr == ""))
319-        then i.caller
320-        else {
321-            let checkCaller = mustThis(i)
322-            if ((checkCaller == checkCaller))
323-                then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
324-                else throw("Strict value is not equal to itself.")
325-            }
326-    if ((userAddress == userAddress))
346+    let checks = [shutdownCheck(i)]
347+    if ((checks == checks))
327348         then {
328-            let baseAssetId = parseAssetId(baseAssetIdStr)
329-            let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
330-            if ((shareAssetId == shareAssetId))
349+            let userAddress = if ((userAddressStr == ""))
350+                then i.caller
351+                else {
352+                    let checkCaller = mustThis(i)
353+                    if ((checkCaller == checkCaller))
354+                        then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
355+                        else throw("Strict value is not equal to itself.")
356+                    }
357+            if ((userAddress == userAddress))
331358                 then {
332-                    let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
333-                    if ((period == period))
359+                    let baseAssetId = parseAssetId(baseAssetIdStr)
360+                    let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
361+                    if ((shareAssetId == shareAssetId))
334362                         then {
335-                            let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0)
336-                            let checkAmountToConvert = if ((userBaseAssetAmountToConvert > 0))
337-                                then true
338-                                else throwErr("nothing to claim")
339-                            if ((checkAmountToConvert == checkAmountToConvert))
363+                            let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
364+                            if ((period == period))
340365                                 then {
341-                                    let userBaseAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
342-                                    let checkPeriod = if ((period > userBaseAssetAmountToConvertPeriod))
366+                                    let userBaseAssetAmountToConvert = valueOrElse(getInteger(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress)), 0)
367+                                    let checkAmountToConvert = if ((userBaseAssetAmountToConvert > 0))
343368                                         then true
344-                                        else throwErr("invalid period")
345-                                    if ((checkPeriod == checkPeriod))
369+                                        else throwErr("nothing to claim")
370+                                    if ((checkAmountToConvert == checkAmountToConvert))
346371                                         then {
347-                                            let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
348-                                            let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price))
349-                                            $Tuple2([IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), shareAssetAmount)], unit)
372+                                            let userBaseAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserBaseAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
373+                                            let checkPeriod = if ((period > userBaseAssetAmountToConvertPeriod))
374+                                                then true
375+                                                else throwErr("invalid period")
376+                                            if ((checkPeriod == checkPeriod))
377+                                                then {
378+                                                    let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodPut(baseAssetId, userBaseAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
379+                                                    let shareAssetAmount = toInt(fraction(toBigInt(userBaseAssetAmountToConvert), scale18BigInt, price))
380+                                                    $Tuple2([IntegerEntry(keyUserBaseAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, shareAssetAmount, shareAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimShareAsset", period, userAddress, i.transactionId), shareAssetAmount)], unit)
381+                                                    }
382+                                                else throw("Strict value is not equal to itself.")
350383                                             }
351384                                         else throw("Strict value is not equal to itself.")
352385                                     }
353386                                 else throw("Strict value is not equal to itself.")
354387                             }
355388                         else throw("Strict value is not equal to itself.")
356389                     }
357390                 else throw("Strict value is not equal to itself.")
358391             }
359392         else throw("Strict value is not equal to itself.")
360393     }
361394 
362395 
363396 
364397 @Callable(i)
365398 func get () = {
366-    let pmt = if ((size(i.payments) == 1))
367-        then i.payments[0]
368-        else throwErr("exactly 1 payment is expected")
369-    let shareAssetId = pmt.assetId
370-    let baseAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyBaseAssetId(shareAssetId)), wrapErr("invalid share asset id"))))
371-    if ((baseAssetId == baseAssetId))
399+    let checks = [shutdownCheck(i)]
400+    if ((checks == checks))
372401         then {
373-            let userAddress = i.caller
374-            let $t01379013893 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
375-            let poolAddress = $t01379013893._1
376-            let lpAssetId = $t01379013893._2
377-            let period = value(getInteger(keyPeriod(baseAssetId)))
378-            let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
379-            let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
380-                then unit
381-                else {
382-                    let userShareAssetAmountToConvertPeriod = value(userShareAssetAmountToConvertPeriodOption)
383-                    if ((userShareAssetAmountToConvertPeriod == period))
402+            let pmt = if ((size(i.payments) == 1))
403+                then i.payments[0]
404+                else throwErr("exactly 1 payment is expected")
405+            let shareAssetId = pmt.assetId
406+            let baseAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyBaseAssetId(shareAssetId)), wrapErr("invalid share asset id"))))
407+            if ((baseAssetId == baseAssetId))
408+                then {
409+                    let userAddress = i.caller
410+                    let $t01483614939 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
411+                    let poolAddress = $t01483614939._1
412+                    let lpAssetId = $t01483614939._2
413+                    let period = value(getInteger(keyPeriod(baseAssetId)))
414+                    let userShareAssetAmountToConvertPeriodOption = getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress))
415+                    let claimBaseAssetInvocation = if ((userShareAssetAmountToConvertPeriodOption == unit))
384416                         then unit
385-                        else invoke(this, "claimBaseAsset", [userAddress], nil)
386-                    }
387-            if ((claimBaseAssetInvocation == claimBaseAssetInvocation))
388-                then {
389-                    let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
390-                    let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
391-                    $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), (userShareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), IntegerEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), pmt.amount)], unit)
417+                        else {
418+                            let userShareAssetAmountToConvertPeriod = value(userShareAssetAmountToConvertPeriodOption)
419+                            if ((userShareAssetAmountToConvertPeriod == period))
420+                                then unit
421+                                else invoke(this, "claimBaseAsset", [userAddress], nil)
422+                            }
423+                    if ((claimBaseAssetInvocation == claimBaseAssetInvocation))
424+                        then {
425+                            let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
426+                            let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
427+                            $Tuple2([IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), (shareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), (userShareAssetAmountToConvert + pmt.amount)), IntegerEntry(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress), period), IntegerEntry(keyHistoryEntry(baseAssetId, "get", period, userAddress, i.transactionId), pmt.amount)], unit)
428+                            }
429+                        else throw("Strict value is not equal to itself.")
392430                     }
393431                 else throw("Strict value is not equal to itself.")
394432             }
395433         else throw("Strict value is not equal to itself.")
396434     }
397435 
398436 
399437 
400438 @Callable(i)
401439 func claimBaseAsset (baseAssetIdStr,userAddressStr) = {
402-    let userAddress = if ((userAddressStr == ""))
403-        then i.caller
404-        else {
405-            let checkCaller = mustThis(i)
406-            if ((checkCaller == checkCaller))
407-                then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
408-                else throw("Strict value is not equal to itself.")
409-            }
410-    if ((userAddress == userAddress))
440+    let checks = [shutdownCheck(i)]
441+    if ((checks == checks))
411442         then {
412-            let baseAssetId = parseAssetId(baseAssetIdStr)
413-            let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
414-            if ((shareAssetId == shareAssetId))
443+            let userAddress = if ((userAddressStr == ""))
444+                then i.caller
445+                else {
446+                    let checkCaller = mustThis(i)
447+                    if ((checkCaller == checkCaller))
448+                        then valueOrErrorMessage(addressFromString(userAddressStr), wrapErr("invalid user address"))
449+                        else throw("Strict value is not equal to itself.")
450+                    }
451+            if ((userAddress == userAddress))
415452                 then {
416-                    let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
417-                    if ((period == period))
453+                    let baseAssetId = parseAssetId(baseAssetIdStr)
454+                    let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
455+                    if ((shareAssetId == shareAssetId))
418456                         then {
419-                            let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
420-                            let checkAmountToConvert = if ((userShareAssetAmountToConvert > 0))
421-                                then true
422-                                else throwErr("nothing to claim")
423-                            if ((checkAmountToConvert == checkAmountToConvert))
457+                            let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
458+                            if ((period == period))
424459                                 then {
425-                                    let userShareAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
426-                                    let checkPeriod = if ((period > userShareAssetAmountToConvertPeriod))
460+                                    let userShareAssetAmountToConvert = valueOrElse(getInteger(keyUserShareAssetAmountToConvert(baseAssetId, userAddress)), 0)
461+                                    let checkAmountToConvert = if ((userShareAssetAmountToConvert > 0))
427462                                         then true
428-                                        else throwErr("invalid period")
429-                                    if ((checkPeriod == checkPeriod))
463+                                        else throwErr("nothing to claim")
464+                                    if ((checkAmountToConvert == checkAmountToConvert))
430465                                         then {
431-                                            let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
432-                                            let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt))
433-                                            $Tuple2([IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), baseAssetAmount)], unit)
466+                                            let userShareAssetAmountToConvertPeriod = valueOrErrorMessage(getInteger(keyUserShareAssetAmountToConvertPeriod(baseAssetId, userAddress)), wrapErr("failed to get period"))
467+                                            let checkPeriod = if ((period > userShareAssetAmountToConvertPeriod))
468+                                                then true
469+                                                else throwErr("invalid period")
470+                                            if ((checkPeriod == checkPeriod))
471+                                                then {
472+                                                    let price = toBigInt(valueOrErrorMessage(getBinary(keyPricePeriodGet(baseAssetId, userShareAssetAmountToConvertPeriod)), wrapErr("failed to get price")))
473+                                                    let baseAssetAmount = toInt(fraction(toBigInt(userShareAssetAmountToConvert), price, scale18BigInt))
474+                                                    $Tuple2([IntegerEntry(keyUserShareAssetAmountToConvert(baseAssetId, userAddress), 0), ScriptTransfer(userAddress, baseAssetAmount, baseAssetId), IntegerEntry(keyHistoryEntry(baseAssetId, "claimBaseAsset", period, userAddress, i.transactionId), baseAssetAmount)], unit)
475+                                                    }
476+                                                else throw("Strict value is not equal to itself.")
434477                                             }
435478                                         else throw("Strict value is not equal to itself.")
436479                                     }
437480                                 else throw("Strict value is not equal to itself.")
438481                             }
439482                         else throw("Strict value is not equal to itself.")
440483                     }
441484                 else throw("Strict value is not equal to itself.")
442485             }
443486         else throw("Strict value is not equal to itself.")
444487     }
445488 
446489 
447490 
448491 @Callable(i)
449492 func finalize (baseAssetIdStr) = {
450-    let baseAssetId = parseAssetId(baseAssetIdStr)
451-    let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
452-    if ((shareAssetId == shareAssetId))
493+    let checks = [shutdownCheck(i)]
494+    if ((checks == checks))
453495         then {
454-            let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
455-            if ((period == period))
496+            let baseAssetId = parseAssetId(baseAssetIdStr)
497+            let shareAssetId = value(parseAssetId(valueOrErrorMessage(getString(keyShareAssetId(baseAssetId)), wrapErr("invalid base asset id"))))
498+            if ((shareAssetId == shareAssetId))
456499                 then {
457-                    let periodStartHeightOption = getInteger(keyPeriodStartHeight(baseAssetId, period))
458-                    let checkDelay = if ((periodStartHeightOption == unit))
459-                        then unit
460-                        else {
461-                            let delay = (height - value(periodStartHeightOption))
462-                            let blocksToWait = min([0, (minDelay - delay)])
463-                            if ((blocksToWait == 0))
500+                    let period = valueOrErrorMessage(getInteger(keyPeriod(baseAssetId)), wrapErr("invalid period"))
501+                    if ((period == period))
502+                        then {
503+                            let periodStartHeightOption = getInteger(keyPeriodStartHeight(baseAssetId, period))
504+                            let checkDelay = if ((periodStartHeightOption == unit))
464505                                 then unit
465-                                else throwErr(makeString(["finalization will be possible in ", toString(blocksToWait), " blocks"], ""))
466-                            }
467-                    if ((checkDelay == checkDelay))
468-                        then {
469-                            let $t01774317923 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
470-                            let poolAddress = $t01774317923._1
471-                            let lpAssetId = $t01774317923._2
472-                            let stakingReward = valueOrErrorMessage({
473-                                let @ = invoke(stakingContract, "claimWx", [assetIdToString(lpAssetId)], nil)
474-                                if ($isInstanceOf(@, "Int"))
475-                                    then @
476-                                    else unit
477-                                }, wrapErr("invalid claimWx result"))
478-                            if ((stakingReward == stakingReward))
506+                                else {
507+                                    let delay = (height - value(periodStartHeightOption))
508+                                    let blocksToWait = min([0, (minDelay - delay)])
509+                                    if ((blocksToWait == 0))
510+                                        then unit
511+                                        else throwErr(makeString(["finalization will be possible in ", toString(blocksToWait), " blocks"], ""))
512+                                    }
513+                            if ((checkDelay == checkDelay))
479514                                 then {
480-                                    let useStakingReward = if ((stakingReward > 0))
515+                                    let $t01888119061 = valueOrErrorMessage(getPoolInfo(baseAssetId), wrapErr("invalid asset"))
516+                                    let poolAddress = $t01888119061._1
517+                                    let lpAssetId = $t01888119061._2
518+                                    let stakingReward = valueOrErrorMessage({
519+                                        let @ = invoke(stakingContract, "claimWx", [assetIdToString(lpAssetId)], nil)
520+                                        if ($isInstanceOf(@, "Int"))
521+                                            then @
522+                                            else unit
523+                                        }, wrapErr("invalid claimWx result"))
524+                                    if ((stakingReward == stakingReward))
481525                                         then {
482-                                            let lockPart = (stakingReward / 2)
483-                                            let convertPart = (stakingReward - lockPart)
484-                                            let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil)
485-                                            let lock =                                             match r {
486-                                                case _ => 
487-                                                    if (if (if ($isInstanceOf($match0._1, "String"))
488-                                                        then $isInstanceOf($match0._2, "Int")
489-                                                        else false)
490-                                                        then $isInstanceOf($match0, "(String, Int)")
491-                                                        else false)
526+                                            let useStakingReward = if ((stakingReward > 0))
527+                                                then {
528+                                                    let lockPart = (stakingReward / 2)
529+                                                    let convertPart = (stakingReward - lockPart)
530+                                                    let r = invoke(boostingContract, "userMaxDurationREADONLY", [toString(this)], nil)
531+                                                    let lock =                                                     match r {
532+                                                        case _ => 
533+                                                            if (if (if ($isInstanceOf($match0._1, "String"))
534+                                                                then $isInstanceOf($match0._2, "Int")
535+                                                                else false)
536+                                                                then $isInstanceOf($match0, "(String, Int)")
537+                                                                else false)
538+                                                                then {
539+                                                                    let function = $match0._1
540+                                                                    let duration = $match0._2
541+                                                                    if ((lockPart > 0))
542+                                                                        then invoke(boostingContract, function, [duration], [AttachedPayment(wxAssetId, lockPart)])
543+                                                                        else unit
544+                                                                    }
545+                                                                else throwErr("invalid lock params")
546+                                                    }
547+                                                    if ((lock == lock))
492548                                                         then {
493-                                                            let function = $match0._1
494-                                                            let duration = $match0._2
495-                                                            if ((lockPart > 0))
496-                                                                then invoke(boostingContract, function, [duration], [AttachedPayment(wxAssetId, lockPart)])
497-                                                                else unit
498-                                                            }
499-                                                        else throwErr("invalid lock params")
500-                                            }
501-                                            if ((lock == lock))
502-                                                then {
503-                                                    let convertedAmount = {
504-                                                        let inAssetId = wxAssetId
505-                                                        let minimumToReceive = 0
506-                                                        let outAssetIdStr = assetIdToString(usdnAssetId)
507-                                                        let targetAddress = ""
508-                                                        valueOrErrorMessage({
509-                                                            let @ = invoke(swapContract, "swap", [minimumToReceive, outAssetIdStr, targetAddress], [AttachedPayment(inAssetId, convertPart)])
510-                                                            if ($isInstanceOf(@, "Int"))
511-                                                                then @
512-                                                                else unit
513-                                                            }, wrapErr("invalid swap result"))
514-                                                        }
515-                                                    if ((convertedAmount == convertedAmount))
516-                                                        then {
517-                                                            let lpAssetAmount = {
518-                                                                let minOutAmount = 0
519-                                                                let autoStake = true
549+                                                            let convertedAmount = {
550+                                                                let inAssetId = wxAssetId
551+                                                                let minimumToReceive = 0
552+                                                                let outAssetIdStr = assetIdToString(usdnAssetId)
553+                                                                let targetAddress = ""
520554                                                                 valueOrErrorMessage({
521-                                                                    let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(usdnAssetId, convertedAmount)])
555+                                                                    let @ = invoke(swapContract, "swap", [minimumToReceive, outAssetIdStr, targetAddress], [AttachedPayment(inAssetId, convertPart)])
522556                                                                     if ($isInstanceOf(@, "Int"))
523557                                                                         then @
524558                                                                         else unit
525-                                                                    }, wrapErr("invalid putOneTknV2 result"))
559+                                                                    }, wrapErr("invalid swap result"))
526560                                                                 }
527-                                                            if ((lpAssetAmount == lpAssetAmount))
528-                                                                then lpAssetAmount
561+                                                            if ((convertedAmount == convertedAmount))
562+                                                                then {
563+                                                                    let lpAssetAmount = {
564+                                                                        let minOutAmount = 0
565+                                                                        let autoStake = true
566+                                                                        valueOrErrorMessage({
567+                                                                            let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(usdnAssetId, convertedAmount)])
568+                                                                            if ($isInstanceOf(@, "Int"))
569+                                                                                then @
570+                                                                                else unit
571+                                                                            }, wrapErr("invalid putOneTknV2 result"))
572+                                                                        }
573+                                                                    if ((lpAssetAmount == lpAssetAmount))
574+                                                                        then lpAssetAmount
575+                                                                        else throw("Strict value is not equal to itself.")
576+                                                                    }
529577                                                                 else throw("Strict value is not equal to itself.")
530578                                                             }
531579                                                         else throw("Strict value is not equal to itself.")
532580                                                     }
533-                                                else throw("Strict value is not equal to itself.")
534-                                            }
535-                                        else unit
536-                                    if ((useStakingReward == useStakingReward))
537-                                        then {
538-                                            let shareAssetInfo = valueOrErrorMessage(assetInfo(shareAssetId), "failed to get share asset info")
539-                                            let shareAssetEmission = shareAssetInfo.quantity
540-                                            let stakedAmount = ensurePositive(valueOrErrorMessage({
541-                                                let @ = invoke(stakingContract, "stakedByUserREADONLY", [assetIdToString(lpAssetId), toString(this)], nil)
542-                                                if ($isInstanceOf(@, "Int"))
543-                                                    then @
544-                                                    else unit
545-                                                }, wrapErr("invalid stakedByUserREADONLY result")))
546-                                            let price = if ((shareAssetEmission == 0))
547-                                                then scale18BigInt
548-                                                else fraction(toBigInt(stakedAmount), scale18BigInt, toBigInt(shareAssetEmission), FLOOR)
549-                                            if ((price == price))
581+                                                else unit
582+                                            if ((useStakingReward == useStakingReward))
550583                                                 then {
551584                                                     let shareAssetAmountToConvert = valueOrElse(getInteger(keyShareAssetAmountToConvert(baseAssetId)), 0)
552585                                                     let getActions = if ((shareAssetAmountToConvert > 0))
553586                                                         then {
554-                                                            let unstakeAmount = toInt(fraction(toBigInt(shareAssetAmountToConvert), price, scale18BigInt, FLOOR))
555-                                                            let baseAssetAmount = {
556-                                                                let outAssetId = baseAssetId
557-                                                                let minOutAmount = 0
558-                                                                valueOrErrorMessage({
559-                                                                    let @ = invoke(poolAddress, "unstakeAndGetOneTknV2", [unstakeAmount, assetIdToString(outAssetId), minOutAmount], nil)
560-                                                                    if ($isInstanceOf(@, "Int"))
561-                                                                        then @
562-                                                                        else unit
563-                                                                    }, wrapErr("invalid unstakeAndGetOneTknV2 result"))
564-                                                                }
565-                                                            if ((baseAssetAmount == baseAssetAmount))
587+                                                            let price = calcPrice(lpAssetId, shareAssetId)
588+                                                            if ((price == price))
566589                                                                 then {
567-                                                                    let shareAssetBurnActions = [Burn(shareAssetId, shareAssetAmountToConvert)]
568-                                                                    let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
569-                                                                    let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
570-                                                                    (shareAssetBurnActions ++ priceGetUpdateActions)
590+                                                                    let unstakeAmount = toInt(fraction(toBigInt(shareAssetAmountToConvert), price, scale18BigInt, FLOOR))
591+                                                                    let baseAssetAmount = {
592+                                                                        let outAssetId = baseAssetId
593+                                                                        let minOutAmount = 0
594+                                                                        valueOrErrorMessage({
595+                                                                            let @ = invoke(poolAddress, "unstakeAndGetOneTknV2", [unstakeAmount, assetIdToString(outAssetId), minOutAmount], nil)
596+                                                                            if ($isInstanceOf(@, "Int"))
597+                                                                                then @
598+                                                                                else unit
599+                                                                            }, wrapErr("invalid unstakeAndGetOneTknV2 result"))
600+                                                                        }
601+                                                                    if ((baseAssetAmount == baseAssetAmount))
602+                                                                        then {
603+                                                                            let shareAssetBurnActions = [Burn(shareAssetId, shareAssetAmountToConvert)]
604+                                                                            let priceGet = fraction(toBigInt(baseAssetAmount), scale18BigInt, toBigInt(shareAssetAmountToConvert), FLOOR)
605+                                                                            let priceGetUpdateActions = [BinaryEntry(keyPricePeriodGet(baseAssetId, period), toBytes(priceGet)), StringEntry(keyPriceGetHistory(baseAssetId), toString(priceGet))]
606+                                                                            (shareAssetBurnActions ++ priceGetUpdateActions)
607+                                                                            }
608+                                                                        else throw("Strict value is not equal to itself.")
571609                                                                     }
572610                                                                 else throw("Strict value is not equal to itself.")
573611                                                             }
574612                                                         else nil
575613                                                     let baseAssetAmountToConvert = valueOrElse(getInteger(keyBaseAssetAmountToConvert(baseAssetId)), 0)
576614                                                     let putActions = if ((baseAssetAmountToConvert > 0))
577615                                                         then {
578616                                                             let lpAssetAmount = {
579617                                                                 let minOutAmount = 0
580618                                                                 let autoStake = true
581619                                                                 valueOrErrorMessage({
582620                                                                     let @ = invoke(poolAddress, "putOneTknV2", [minOutAmount, autoStake], [AttachedPayment(baseAssetId, baseAssetAmountToConvert)])
583621                                                                     if ($isInstanceOf(@, "Int"))
584622                                                                         then @
585623                                                                         else unit
586624                                                                     }, wrapErr("invalid putOneTknV2 result"))
587625                                                                 }
588626                                                             if ((lpAssetAmount == lpAssetAmount))
589627                                                                 then {
590-                                                                    let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
591-                                                                    let isReissuable = true
592-                                                                    let shareAssetReissueActions = [Reissue(shareAssetId, shareAssetAmount, isReissuable)]
593-                                                                    let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
594-                                                                    let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
595-                                                                    (shareAssetReissueActions ++ pricePutUpdateActions)
628+                                                                    let price = calcPrice(lpAssetId, shareAssetId)
629+                                                                    if ((price == price))
630+                                                                        then {
631+                                                                            let shareAssetAmount = toInt(fraction(toBigInt(lpAssetAmount), scale18BigInt, price, FLOOR))
632+                                                                            let isReissuable = true
633+                                                                            let shareAssetReissueActions = [Reissue(shareAssetId, shareAssetAmount, isReissuable)]
634+                                                                            let pricePut = fraction(toBigInt(baseAssetAmountToConvert), scale18BigInt, toBigInt(shareAssetAmount))
635+                                                                            let pricePutUpdateActions = [BinaryEntry(keyPricePeriodPut(baseAssetId, period), toBytes(pricePut)), StringEntry(keyPricePutHistory(baseAssetId), toString(pricePut))]
636+                                                                            (shareAssetReissueActions ++ pricePutUpdateActions)
637+                                                                            }
638+                                                                        else throw("Strict value is not equal to itself.")
596639                                                                     }
597640                                                                 else throw("Strict value is not equal to itself.")
598641                                                             }
599642                                                         else nil
600643                                                     let newPeriod = (period + 1)
601-                                                    let actions = (([IntegerEntry(keyPeriod(baseAssetId), newPeriod), IntegerEntry(keyPeriodStartHeight(baseAssetId, newPeriod), height), IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), 0), IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), 0), BinaryEntry(keyPricePeriod(baseAssetId, period), toBytes(price)), StringEntry(keyPriceHistory(baseAssetId), toString(price))] ++ putActions) ++ getActions)
602-                                                    $Tuple2(actions, toBytes(price))
644+                                                    let lastPrice = calcPrice(lpAssetId, shareAssetId)
645+                                                    let actions = (([IntegerEntry(keyPeriod(baseAssetId), newPeriod), IntegerEntry(keyPeriodStartHeight(baseAssetId, newPeriod), height), IntegerEntry(keyShareAssetAmountToConvert(baseAssetId), 0), IntegerEntry(keyBaseAssetAmountToConvert(baseAssetId), 0), BinaryEntry(keyPricePeriod(baseAssetId, period), toBytes(lastPrice)), StringEntry(keyPriceHistory(baseAssetId), toString(lastPrice))] ++ putActions) ++ getActions)
646+                                                    $Tuple2(actions, toBytes(lastPrice))
603647                                                     }
604648                                                 else throw("Strict value is not equal to itself.")
605649                                             }
606650                                         else throw("Strict value is not equal to itself.")
607651                                     }
608652                                 else throw("Strict value is not equal to itself.")
609653                             }
610654                         else throw("Strict value is not equal to itself.")
611655                     }
612656                 else throw("Strict value is not equal to itself.")
613657             }
614658         else throw("Strict value is not equal to itself.")
615659     }
616660 
617661 
618662 @Verifier(tx)
619663 func verify () = {
620664     let targetPublicKey =     match managerPublicKeyOrUnit() {
621665         case pk: ByteVector => 
622666             pk
623667         case _: Unit => 
624668             tx.senderPublicKey
625669         case _ => 
626670             throw("Match error")
627671     }
628672     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
629673     }
630674 
github/deemru/w8io/3ef1775 
117.09 ms ◑