w8 · tx · HdG···DS7

tx · HdGSrLaVXd4RsBzJu68FcZ3WfxNrZFN6Asv2ckz1SDS7

3NCwprtpvXak4t4qM7fonVgmNx2x3VxPPzG:  -0.01000000 Waves

2020.12.23 19:55 [1321611] smart account 3NCwprtpvXak4t4qM7fonVgmNx2x3VxPPzG > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HdGSrLaVXd4RsBzJu68FcZ3WfxNrZFN6Asv2ckz1SDS7",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1608742555692,
    "version": 1,
    "sender": "3NCwprtpvXak4t4qM7fonVgmNx2x3VxPPzG",
    "senderPublicKey": "47CUsP52uLED23eivdFk1dKHJEXhmcg9vfeSZZ8Sct36",
    "proofs": [
        "4EpaXTtvGTf2kuTFA72TJS5Y23Fr7ELJbd4cpfoY3bC3NXoC45c68j1TNQCgJVTcnUEDk9CcbJzRKg9cKG7jHXxw"
    ],
    "script": "base64:AAIEAAAAAAAAACUIAhIHCgUICAgBCBIDCgEBEgASABIFCgMICAgSAwoBCBIDCgEIAAAALAAAAAADU0VQAgAAAAJfXwEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQAAAANrZXkJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABB0AAAACBQAAAAR0aGlzBQAAAANrZXkJAAEsAAAAAgIAAAAVTm8gZGF0YSBmb3IgdGhpcy5rZXk9BQAAAANrZXkBAAAAEGdldEJvb2xlYW5PckZhaWwAAAABAAAAA2tleQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEGwAAAAIFAAAABHRoaXMFAAAAA2tleQkAASwAAAACAgAAABVObyBkYXRhIGZvciB0aGlzLmtleT0FAAAAA2tleQEAAAAOZmFpbEV4ZWN1dGVHZXQAAAAEAAAAA21zZwAAAAxiYXNlQXNzZXRTdHIAAAAOdXNlckFkZHJlc3NTdHIAAAAKZ2V0VHhJZFN0cgkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACBQAAAANtc2cCAAAADzogYmFzZUFzc2V0U3RyPQUAAAAMYmFzZUFzc2V0U3RyAgAAABAgdXNlckFkZHJlc3NTdHI9BQAAAA51c2VyQWRkcmVzc1N0cgIAAAAMIGdldFR4SWRTdHI9BQAAAApnZXRUeElkU3RyAQAAAAtrZXlBc3NldENmZwAAAAEAAAAMYmFzZUFzc2V0U3RyCQABLAAAAAICAAAAFyVzJXMlc19fY29uZmlnX19hc3NldF9fBQAAAAxiYXNlQXNzZXRTdHIBAAAAFmtleU5leHRJbnRlcm5hbEFzc2V0SWQAAAAAAgAAABclc19fbmV4dEludGVybmFsQXNzZXRJZAEAAAAMa2V5UHJpY2VMYXN0AAAAAQAAABVpbnRlcm5hbEJhc2V0QXNzZXRTdHIJAAEsAAAAAgIAAAAVJXMlcyVkX19wcmljZV9fbGFzdF9fBQAAABVpbnRlcm5hbEJhc2V0QXNzZXRTdHIBAAAAD2tleVByaWNlSGlzdG9yeQAAAAMAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyAAAAAWgAAAAJdGltZXN0YW1wCQAEuQAAAAIJAARMAAAAAgIAAAAaJXMlcyVkJWQlZF9fcHJpY2VfX2hpc3RvcnkJAARMAAAAAgUAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyCQAETAAAAAIJAAGkAAAAAQUAAAABaAkABEwAAAACCQABpAAAAAEFAAAACXRpbWVzdGFtcAUAAAADbmlsBQAAAANTRVABAAAADmtleVRvdGFsTG9ja2VkAAAAAQAAABVpbnRlcm5hbEJhc2V0QXNzZXRTdHIJAAEsAAAAAgIAAAAXJXMlcyVkX190b3RhbF9fbG9ja2VkX18FAAAAFWludGVybmFsQmFzZXRBc3NldFN0cgEAAAAUa2V5VG90YWxMb2NrZWRCeVVzZXIAAAACAAAAFGludGVybmFsQmFzZUFzc2V0U3RyAAAADnVzZXJBZGRyZXNzU3RyCQAEuQAAAAIJAARMAAAAAgIAAAAXJXMlcyVkJXNfX3RvdGFsX19sb2NrZWQJAARMAAAAAgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAARMAAAAAgUAAAAOdXNlckFkZHJlc3NTdHIFAAAAA25pbAUAAAADU0VQAQAAAB9rZXlNYXBwaW5nc0ludGVybmFsMmJhc2VBc3NldElkAAAAAQAAABFpbnRlcm5hbEJhc2VBc3NldAkAASwAAAACAgAAACglcyVzJWRfX21hcHBpbmdzX19pbnRlcm5hbDJiYXNlQXNzZXRJZF9fCQABpAAAAAEFAAAAEWludGVybmFsQmFzZUFzc2V0AQAAAB9rZXlNYXBwaW5nc0Jhc2VBc3NldDJpbnRlcm5hbElkAAAAAQAAAAxiYXNlQXNzZXRTdHIJAAEsAAAAAgIAAAAoJXMlcyVzX19tYXBwaW5nc19fYmFzZUFzc2V0MmludGVybmFsSWRfXwUAAAAMYmFzZUFzc2V0U3RyAQAAABxrZXlNYXBwaW5nc1NoYXJlMmJhc2VBc3NldElkAAAAAQAAAA1zaGFyZUFzc2V0U3RyCQABLAAAAAICAAAAJSVzJXMlc19fbWFwcGluZ3NfX3NoYXJlMmJhc2VBc3NldElkX18FAAAADXNoYXJlQXNzZXRTdHIBAAAAHGtleU1hcHBpbmdzQmFzZUFzc2V0MnNoYXJlSWQAAAABAAAADGJhc2VBc3NldFN0cgkAASwAAAACAgAAACUlcyVzJXNfX21hcHBpbmdzX19iYXNlQXNzZXQyc2hhcmVJZF9fBQAAAAxiYXNlQXNzZXRTdHIBAAAAF2tleVNodXRkb3duUHV0T3BlcmF0aW9uAAAAAQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkAASwAAAACAgAAABclcyVzJWRfX3NodXRkb3duX19wdXRfXwUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIBAAAAEmtleVNodXRkb3duTWFuYWdlcgAAAAEAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAAEsAAAAAgIAAAAbJXMlcyVkX19zaHV0ZG93bl9fbWFuYWdlcl9fBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgAAAAASSWR4Q2ZnU2hhcmVBc3NldElkAAAAAAAAAAABAAAAABdJZHhDZmdJbnRlcm5hbEJhc2VBc3NldAAAAAAAAAAAAgAAAAAcSWR4Q2ZnRGVjaW1hbHNNdWx0Qm90aEFzc2V0cwAAAAAAAAAAAwAAAAAXSWR4Q2ZnRGVjaW1hbHNNdWx0UHJpY2UAAAAAAAAAAAQAAAAAFElkeENmZ0dldERlbGF5QmxvY2tzAAAAAAAAAAAFAQAAAAxkYXRhQXNzZXRDZmcAAAAFAAAADXNoYXJlQXNzZXRTdHIAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwAAABFkZWNpbWFsc011bHRQcmljZQAAABBnZXREZWxheUluQmxvY2tzCQAEuQAAAAIJAARMAAAAAgIAAAAKJXMlZCVkJWQlZAkABEwAAAACBQAAAA1zaGFyZUFzc2V0U3RyCQAETAAAAAIFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyCQAETAAAAAIJAAGkAAAAAQUAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwkABEwAAAACCQABpAAAAAEFAAAAEWRlY2ltYWxzTXVsdFByaWNlCQAETAAAAAIJAAGkAAAAAQUAAAAQZ2V0RGVsYXlJbkJsb2NrcwUAAAADbmlsBQAAAANTRVAAAAAAE0lkeFRvdGFsTG9ja2VkU2hhcmUAAAAAAAAAAAEAAAAAEklkeFRvdGFsTG9ja2VkQmFzZQAAAAAAAAAAAgEAAAAPZGF0YVRvdGFsTG9ja2VkAAAAAgAAABBzaGFyZUFzc2V0QW1vdW50AAAAD2Jhc2VBc3NldEFtb3VudAkABLkAAAACCQAETAAAAAICAAAABCVkJWQJAARMAAAAAgkAAaQAAAABBQAAABBzaGFyZUFzc2V0QW1vdW50CQAETAAAAAIJAAGkAAAAAQUAAAAPYmFzZUFzc2V0QW1vdW50BQAAAANuaWwFAAAAA1NFUAEAAAAPcmVhZFRvdGFsTG9ja2VkAAAAAQAAAANrZXkEAAAAEHRvdGFsTG9ja2VkQXJyYXkJAAS1AAAAAgkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABB0AAAACBQAAAAR0aGlzBQAAAANrZXkJAQAAAA9kYXRhVG90YWxMb2NrZWQAAAACAAAAAAAAAAAAAAAAAAAAAAAABQAAAANTRVAJAARMAAAAAgD//////////wkABEwAAAACCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAQdG90YWxMb2NrZWRBcnJheQUAAAATSWR4VG90YWxMb2NrZWRTaGFyZQkABEwAAAACCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAQdG90YWxMb2NrZWRBcnJheQUAAAASSWR4VG90YWxMb2NrZWRCYXNlBQAAAANuaWwBAAAADGtleU9wZXJhdGlvbgAAAAQAAAANb3BlcmF0aW9uVHlwZQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgAAAAt1c2VyQWRkcmVzcwAAAAR0eElkCQAEuQAAAAIJAARMAAAAAgIAAAAIJXMlZCVzJXMJAARMAAAAAgUAAAANb3BlcmF0aW9uVHlwZQkABEwAAAACBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkABEwAAAACBQAAAAt1c2VyQWRkcmVzcwkABEwAAAACBQAAAAR0eElkBQAAAANuaWwFAAAAA1NFUAAAAAANSWR4T3BlclN0YXR1cwAAAAAAAAAAAQAAAAAPSWR4T3BlckluQW1vdW50AAAAAAAAAAACAAAAAAxJZHhPcGVyUHJpY2UAAAAAAAAAAAMAAAAAEElkeE9wZXJPdXRBbW91bnQAAAAAAAAAAAQAAAAAEklkeE9wZXJTdGFydEhlaWdodAAAAAAAAAAABQAAAAAVSWR4T3BlclN0YXJ0VGltZXN0YW1wAAAAAAAAAAAGAAAAABBJZHhPcGVyRW5kSGVpZ2h0AAAAAAAAAAAHAAAAABNJZHhPcGVyRW5kVGltZXN0YW1wAAAAAAAAAAAIAQAAAB5wcml2YXRlRGF0YU9wZXJhdGlvbkFsbFN0cmluZ3MAAAAIAAAABnN0YXR1cwAAAA1pbkFzc2V0QW1vdW50AAAABXByaWNlAAAADm91dEFzc2V0QW1vdW50AAAAC3N0YXJ0SGVpZ2h0AAAADnN0YXJ0VGltZXN0YW1wAAAACWVuZEhlaWdodAAAAAxlbmRUaW1lc3RhbXAJAAS5AAAAAgkABEwAAAACAgAAABAlcyVkJWQlZCVkJWQlZCVkCQAETAAAAAIFAAAABnN0YXR1cwkABEwAAAACBQAAAA1pbkFzc2V0QW1vdW50CQAETAAAAAIFAAAABXByaWNlCQAETAAAAAIFAAAADm91dEFzc2V0QW1vdW50CQAETAAAAAIFAAAAC3N0YXJ0SGVpZ2h0CQAETAAAAAIFAAAADnN0YXJ0VGltZXN0YW1wCQAETAAAAAIFAAAACWVuZEhlaWdodAkABEwAAAACBQAAAAxlbmRUaW1lc3RhbXAFAAAAA25pbAUAAAADU0VQAQAAAA1kYXRhT3BlcmF0aW9uAAAACAAAAAZzdGF0dXMAAAANaW5Bc3NldEFtb3VudAAAAAVwcmljZQAAAA5vdXRBc3NldEFtb3VudAAAAAtzdGFydEhlaWdodAAAAA5zdGFydFRpbWVzdGFtcAAAAAllbmRIZWlnaHQAAAAMZW5kVGltZXN0YW1wCQEAAAAecHJpdmF0ZURhdGFPcGVyYXRpb25BbGxTdHJpbmdzAAAACAUAAAAGc3RhdHVzCQABpAAAAAEFAAAADWluQXNzZXRBbW91bnQJAAGkAAAAAQUAAAAFcHJpY2UJAAGkAAAAAQUAAAAOb3V0QXNzZXRBbW91bnQJAAGkAAAAAQUAAAALc3RhcnRIZWlnaHQJAAGkAAAAAQUAAAAOc3RhcnRUaW1lc3RhbXAJAAGkAAAAAQUAAAAJZW5kSGVpZ2h0CQABpAAAAAEFAAAADGVuZFRpbWVzdGFtcAEAAAAcZGF0YU9wZXJhdGlvbkV4ZWN1dGlvblVwZGF0ZQAAAAMAAAANY3Vyck9wZXJBcnJheQAAAAluZXdTdGF0dXMAAAAPbmV3RW5kVGltZXN0YW1wCQEAAAAecHJpdmF0ZURhdGFPcGVyYXRpb25BbGxTdHJpbmdzAAAACAUAAAAJbmV3U3RhdHVzCQABkQAAAAIFAAAADWN1cnJPcGVyQXJyYXkFAAAAD0lkeE9wZXJJbkFtb3VudAkAAZEAAAACBQAAAA1jdXJyT3BlckFycmF5BQAAAAxJZHhPcGVyUHJpY2UJAAGRAAAAAgUAAAANY3Vyck9wZXJBcnJheQUAAAAQSWR4T3Blck91dEFtb3VudAkAAZEAAAACBQAAAA1jdXJyT3BlckFycmF5BQAAABJJZHhPcGVyU3RhcnRIZWlnaHQJAAGRAAAAAgUAAAANY3Vyck9wZXJBcnJheQUAAAAVSWR4T3BlclN0YXJ0VGltZXN0YW1wCQABkQAAAAIFAAAADWN1cnJPcGVyQXJyYXkFAAAAEElkeE9wZXJFbmRIZWlnaHQJAAGkAAAAAQUAAAAPbmV3RW5kVGltZXN0YW1wAQAAABJyZWFkQXNzZXRDZmdPckZhaWwAAAABAAAADGJhc2VBc3NldFN0cgQAAAADa2V5CQEAAAALa2V5QXNzZXRDZmcAAAABBQAAAAxiYXNlQXNzZXRTdHIJAAS1AAAAAgkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEFAAAAA2tleQUAAAADU0VQAQAAABRpbmNyZW1lbnRUb3RhbExvY2tlZAAAAAMAAAADa2V5AAAAEHNoYXJlQXNzZXRBbW91bnQAAAAPYmFzZUFzc2V0QW1vdW50BAAAAAlkYXRhQXJyYXkJAQAAAA9yZWFkVG90YWxMb2NrZWQAAAABBQAAAANrZXkJAQAAAAtTdHJpbmdFbnRyeQAAAAIFAAAAA2tleQkBAAAAD2RhdGFUb3RhbExvY2tlZAAAAAIJAABkAAAAAgkAAZEAAAACBQAAAAlkYXRhQXJyYXkFAAAAE0lkeFRvdGFsTG9ja2VkU2hhcmUFAAAAEHNoYXJlQXNzZXRBbW91bnQJAABkAAAAAgkAAZEAAAACBQAAAAlkYXRhQXJyYXkFAAAAEklkeFRvdGFsTG9ja2VkQmFzZQUAAAAPYmFzZUFzc2V0QW1vdW50AQAAABRkZWNyZW1lbnRUb3RhbExvY2tlZAAAAAMAAAADa2V5AAAAEHNoYXJlQXNzZXRBbW91bnQAAAAPYmFzZUFzc2V0QW1vdW50BAAAAAlkYXRhQXJyYXkJAQAAAA9yZWFkVG90YWxMb2NrZWQAAAABBQAAAANrZXkJAQAAAAtTdHJpbmdFbnRyeQAAAAIFAAAAA2tleQkBAAAAD2RhdGFUb3RhbExvY2tlZAAAAAIJAABlAAAAAgkAAZEAAAACBQAAAAlkYXRhQXJyYXkFAAAAE0lkeFRvdGFsTG9ja2VkU2hhcmUFAAAAEHNoYXJlQXNzZXRBbW91bnQJAABlAAAAAgkAAZEAAAACBQAAAAlkYXRhQXJyYXkFAAAAEklkeFRvdGFsTG9ja2VkQmFzZQUAAAAPYmFzZUFzc2V0QW1vdW50AQAAABBnZW5lcmljQ2FsY1ByaWNlAAAABgAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgAAAAtiYXNlQXNzZXRJZAAAAA90b3BVcEJhc2VBbW91bnQAAAAMc2hhcmVBc3NldElkAAAAFmRlY2ltYWxzTXVsdEJvdGhBc3NldHMAAAARZGVjaW1hbHNNdWx0UHJpY2UEAAAAEHRvdGFsTG9ja2VkQXJyYXkJAQAAAA9yZWFkVG90YWxMb2NrZWQAAAABCQEAAAAOa2V5VG90YWxMb2NrZWQAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgQAAAAVdG90YWxMb2NrZWRCYXNlQW1vdW50CQABkQAAAAIFAAAAEHRvdGFsTG9ja2VkQXJyYXkFAAAAEklkeFRvdGFsTG9ja2VkQmFzZQQAAAAQYmFzZUFzc2V0QmFsYW5jZQkAA/AAAAACBQAAAAR0aGlzBQAAAAtiYXNlQXNzZXRJZAQAAAAfYmFzZUFzc2V0QmFsYW5jZUNvbnNpZGVyaW5nTG9jawkAAGQAAAACCQAAZQAAAAIFAAAAEGJhc2VBc3NldEJhbGFuY2UFAAAAFXRvdGFsTG9ja2VkQmFzZUFtb3VudAUAAAAPdG9wVXBCYXNlQW1vdW50AwkAAGYAAAACAAAAAAAAAAAABQAAAB9iYXNlQXNzZXRCYWxhbmNlQ29uc2lkZXJpbmdMb2NrCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAANmJhc2VBc3NldEJhbGFuY2VDb25zaWRlcmluZ0xvY2sgPCAwOiBiYXNlQXNzZXRCYWxhbmNlPQkAAaQAAAABBQAAABBiYXNlQXNzZXRCYWxhbmNlAgAAACEgYmFzZUFzc2V0QmFsYW5jZUNvbnNpZGVyaW5nTG9jaz0JAAGkAAAAAQUAAAAfYmFzZUFzc2V0QmFsYW5jZUNvbnNpZGVyaW5nTG9jawQAAAANc2hhcmVFbWlzc2lvbggJAQAAAAV2YWx1ZQAAAAEJAAPsAAAAAQUAAAAMc2hhcmVBc3NldElkAAAACHF1YW50aXR5BAAAAAVwcmljZQMJAAAAAAAAAgUAAAANc2hhcmVFbWlzc2lvbgAAAAAAAAAAAAkAAGgAAAACAAAAAAAAAAABBQAAABFkZWNpbWFsc011bHRQcmljZQkAAGsAAAADBQAAAB9iYXNlQXNzZXRCYWxhbmNlQ29uc2lkZXJpbmdMb2NrBQAAABFkZWNpbWFsc011bHRQcmljZQUAAAANc2hhcmVFbWlzc2lvbgkABRcAAAAFBQAAAAVwcmljZQUAAAAQYmFzZUFzc2V0QmFsYW5jZQUAAAAVdG90YWxMb2NrZWRCYXNlQW1vdW50BQAAAB9iYXNlQXNzZXRCYWxhbmNlQ29uc2lkZXJpbmdMb2NrBQAAAA1zaGFyZUVtaXNzaW9uAQAAAAljYWxjUHJpY2UAAAAFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyAAAAC2Jhc2VBc3NldElkAAAADHNoYXJlQXNzZXRJZAAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzAAAAEWRlY2ltYWxzTXVsdFByaWNlCQEAAAAQZ2VuZXJpY0NhbGNQcmljZQAAAAYFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAAtiYXNlQXNzZXRJZAAAAAAAAAAAAAUAAAAMc2hhcmVBc3NldElkBQAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzBQAAABFkZWNpbWFsc011bHRQcmljZQEAAAAbcHJpdmF0ZUN1cnJlbnRTeXNQYXJhbXNSRVNUAAAAAQAAAAxiYXNlQXNzZXRTdHIEAAAAC2Jhc2VBc3NldElkCQACWQAAAAEFAAAADGJhc2VBc3NldFN0cgQAAAAIY2ZnQXJyYXkJAQAAABJyZWFkQXNzZXRDZmdPckZhaWwAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAADXNoYXJlQXNzZXRTdHIJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAEklkeENmZ1NoYXJlQXNzZXRJZAQAAAAMc2hhcmVBc3NldElkCQACWQAAAAEFAAAADXNoYXJlQXNzZXRTdHIEAAAAFmRlY2ltYWxzTXVsdEJvdGhBc3NldHMJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAAhjZmdBcnJheQUAAAAcSWR4Q2ZnRGVjaW1hbHNNdWx0Qm90aEFzc2V0cwQAAAARZGVjaW1hbHNNdWx0UHJpY2UJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAAhjZmdBcnJheQUAAAAXSWR4Q2ZnRGVjaW1hbHNNdWx0UHJpY2UEAAAAFGludGVybmFsQmFzZUFzc2V0U3RyCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAABdJZHhDZmdJbnRlcm5hbEJhc2VBc3NldAQAAAAIc3lzU3RhdGUJAQAAAAljYWxjUHJpY2UAAAAFBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAALYmFzZUFzc2V0SWQFAAAADHNoYXJlQXNzZXRJZAUAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwUAAAARZGVjaW1hbHNNdWx0UHJpY2UJAAUYAAAABgkBAAAADEludGVnZXJFbnRyeQAAAAICAAAABXByaWNlCAUAAAAIc3lzU3RhdGUAAAACXzEJAQAAAAxJbnRlZ2VyRW50cnkAAAACAgAAABFkZWNpbWFsc011bHRQcmljZQUAAAARZGVjaW1hbHNNdWx0UHJpY2UJAQAAAAxJbnRlZ2VyRW50cnkAAAACAgAAABBiYXNlQXNzZXRCYWxhbmNlCAUAAAAIc3lzU3RhdGUAAAACXzIJAQAAAAxJbnRlZ2VyRW50cnkAAAACAgAAABV0b3RhbExvY2tlZEJhc2VBbW91bnQIBQAAAAhzeXNTdGF0ZQAAAAJfMwkBAAAADEludGVnZXJFbnRyeQAAAAICAAAAH2Jhc2VBc3NldEJhbGFuY2VDb25zaWRlcmluZ0xvY2sIBQAAAAhzeXNTdGF0ZQAAAAJfNAkBAAAADEludGVnZXJFbnRyeQAAAAICAAAADXNoYXJlRW1pc3Npb24IBQAAAAhzeXNTdGF0ZQAAAAJfNQAAAAcAAAABaQEAAAASYWRtaW5SZWdpc3RlckFzc2V0AAAABQAAAAxiYXNlQXNzZXRTdHIAAAAOc2hhcmVBc3NldE5hbWUAAAAPc2hhcmVBc3NldERlc2NyAAAAEGdldERlbGF5aW5CbG9ja3MAAAAWc2h1dGRvd25NYW5hZ2VyQWRkcmVzcwQAAAALYmFzZUFzc2V0SWQJAAJZAAAAAQUAAAAMYmFzZUFzc2V0U3RyBAAAAAhkZWNpbWFscwgJAQAAAAV2YWx1ZQAAAAEJAAPsAAAAAQUAAAALYmFzZUFzc2V0SWQAAAAIZGVjaW1hbHMDCQEAAAACIT0AAAACCAUAAAABaQAAAAZjYWxsZXIFAAAABHRoaXMJAAACAAAAAQIAAAAScGVybWlzc2lvbnMgZGVuaWVkAwkBAAAAAiE9AAAAAgkABCUAAAABCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABBQAAABZzaHV0ZG93bk1hbmFnZXJBZGRyZXNzBQAAABZzaHV0ZG93bk1hbmFnZXJBZGRyZXNzCQAAAgAAAAECAAAAHmludmFsaWQgc2h1dGRvd25NYW5hZ2VyQWRkcmVzcwMJAABmAAAAAgAAAAAAAAAAAAUAAAAQZ2V0RGVsYXlpbkJsb2NrcwkAAAIAAAABCQABLAAAAAICAAAAGWludmFsaWQgZ2V0RGVsYXlpbkJsb2Nrcz0JAAGkAAAAAQUAAAAQZ2V0RGVsYXlpbkJsb2NrcwQAAAAVc2hhcmVBc3NldElzc3VlQWN0aW9uCQAEQgAAAAUFAAAADnNoYXJlQXNzZXROYW1lBQAAAA9zaGFyZUFzc2V0RGVzY3IAAAAAAAAAAAEFAAAACGRlY2ltYWxzBgQAAAAMc2hhcmVBc3NldElkCQAEOAAAAAEFAAAAFXNoYXJlQXNzZXRJc3N1ZUFjdGlvbgQAAAANc2hhcmVBc3NldFN0cgkAAlgAAAABBQAAAAxzaGFyZUFzc2V0SWQEAAAAEWRlY2ltYWxzTXVsdFByaWNlCQAAaAAAAAIJAABoAAAAAgAAAAAAAAAAZAAAAAAAAAAD6AAAAAAAAAAD6AQAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwkAAGwAAAAGAAAAAAAAAAAKAAAAAAAAAAAABQAAAAhkZWNpbWFscwAAAAAAAAAAAAAAAAAAAAAAAAUAAAAERE9XTgQAAAAKc3RhcnRQcmljZQkAAGgAAAACAAAAAAAAAAABBQAAABFkZWNpbWFsc011bHRQcmljZQQAAAAUaW50ZXJuYWxCYXNlQXNzZXR0SWQJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwkBAAAAFmtleU5leHRJbnRlcm5hbEFzc2V0SWQAAAAAAAAAAAAAAAAABAAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkAAaQAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldHRJZAkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAALa2V5QXNzZXRDZmcAAAABBQAAAAxiYXNlQXNzZXRTdHIJAQAAAAxkYXRhQXNzZXRDZmcAAAAFBQAAAA1zaGFyZUFzc2V0U3RyBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwUAAAARZGVjaW1hbHNNdWx0UHJpY2UFAAAAEGdldERlbGF5aW5CbG9ja3MJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAH2tleU1hcHBpbmdzSW50ZXJuYWwyYmFzZUFzc2V0SWQAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldHRJZAUAAAAMYmFzZUFzc2V0U3RyCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAB9rZXlNYXBwaW5nc0Jhc2VBc3NldDJpbnRlcm5hbElkAAAAAQUAAAAMYmFzZUFzc2V0U3RyBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAca2V5TWFwcGluZ3NTaGFyZTJiYXNlQXNzZXRJZAAAAAEFAAAADXNoYXJlQXNzZXRTdHIFAAAADGJhc2VBc3NldFN0cgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAca2V5TWFwcGluZ3NCYXNlQXNzZXQyc2hhcmVJZAAAAAEFAAAADGJhc2VBc3NldFN0cgUAAAANc2hhcmVBc3NldFN0cgkABEwAAAACCQEAAAAMQm9vbGVhbkVudHJ5AAAAAgkBAAAAF2tleVNodXRkb3duUHV0T3BlcmF0aW9uAAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIHCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABJrZXlTaHV0ZG93bk1hbmFnZXIAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAWc2h1dGRvd25NYW5hZ2VyQWRkcmVzcwkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAFmtleU5leHRJbnRlcm5hbEFzc2V0SWQAAAAACQAAZAAAAAIFAAAAFGludGVybmFsQmFzZUFzc2V0dElkAAAAAAAAAAABCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAMa2V5UHJpY2VMYXN0AAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAACnN0YXJ0UHJpY2UJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAA9rZXlQcmljZUhpc3RvcnkAAAADBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAGaGVpZ2h0CAUAAAAJbGFzdEJsb2NrAAAACXRpbWVzdGFtcAUAAAAKc3RhcnRQcmljZQkABEwAAAACBQAAABVzaGFyZUFzc2V0SXNzdWVBY3Rpb24JAARMAAAAAgkBAAAABEJ1cm4AAAACBQAAAAxzaGFyZUFzc2V0SWQAAAAAAAAAAAEFAAAAA25pbAAAAAFpAQAAAAtzaHV0ZG93blB1dAAAAAEAAAATaW50ZXJuYWxCYXNlQXNzZXRJZAQAAAAWaW50ZXJuYWxCYXNlQXNzZXRJZFN0cgkAAaQAAAABBQAAABNpbnRlcm5hbEJhc2VBc3NldElkBAAAAA5iYXNlQXNzZXRJZFN0cgkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEJAQAAAB9rZXlNYXBwaW5nc0ludGVybmFsMmJhc2VBc3NldElkAAAAAQUAAAATaW50ZXJuYWxCYXNlQXNzZXRJZAQAAAAWc2h1dGRvd25NYW5hZ2VyQWRkcmVzcwkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEJAQAAABJrZXlTaHV0ZG93bk1hbmFnZXIAAAABBQAAABZpbnRlcm5hbEJhc2VBc3NldElkU3RyAwkAAGYAAAACAAAAAAAAAAABCQABMQAAAAEFAAAADmJhc2VBc3NldElkU3RyCQAAAgAAAAECAAAAG2ludmFsaWQgaW50ZXJuYWxCYXNlQXNzZXRJZAMJAQAAAAIhPQAAAAIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBQAAABZzaHV0ZG93bk1hbmFnZXJBZGRyZXNzCQAAAgAAAAECAAAADWFjY2VzcyBkZW5pZWQJAARMAAAAAgkBAAAADEJvb2xlYW5FbnRyeQAAAAIJAQAAABdrZXlTaHV0ZG93blB1dE9wZXJhdGlvbgAAAAEJAAGkAAAAAQUAAAATaW50ZXJuYWxCYXNlQXNzZXRJZAYFAAAAA25pbAAAAAFpAQAAAANwdXQAAAAABAAAAANwbXQJAQAAAAV2YWx1ZQAAAAEJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAEAAAAC2Jhc2VBc3NldElkCQEAAAAFdmFsdWUAAAABCAUAAAADcG10AAAAB2Fzc2V0SWQEAAAADGJhc2VBc3NldFN0cgkAAlgAAAABBQAAAAtiYXNlQXNzZXRJZAQAAAAOdXNlckFkZHJlc3NTdHIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAAAhjZmdBcnJheQkBAAAAEnJlYWRBc3NldENmZ09yRmFpbAAAAAEFAAAADGJhc2VBc3NldFN0cgQAAAANc2hhcmVBc3NldFN0cgkAAZEAAAACBQAAAAhjZmdBcnJheQUAAAASSWR4Q2ZnU2hhcmVBc3NldElkBAAAAAxzaGFyZUFzc2V0SWQJAAJZAAAAAQUAAAANc2hhcmVBc3NldFN0cgQAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAABxJZHhDZmdEZWNpbWFsc011bHRCb3RoQXNzZXRzBAAAABFkZWNpbWFsc011bHRQcmljZQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAABdJZHhDZmdEZWNpbWFsc011bHRQcmljZQQAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAF0lkeENmZ0ludGVybmFsQmFzZUFzc2V0BAAAAAxpc1B1dEJsb2NrZWQJAQAAABBnZXRCb29sZWFuT3JGYWlsAAAAAQkBAAAAF2tleVNodXRkb3duUHV0T3BlcmF0aW9uAAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIDBQAAAAxpc1B1dEJsb2NrZWQJAAACAAAAAQIAAAAYcHV0IG9wZXJhdGlvbiBpcyBibG9ja2VkBAAAAAVwcmljZQgJAQAAAAljYWxjUHJpY2UAAAAFBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAALYmFzZUFzc2V0SWQFAAAADHNoYXJlQXNzZXRJZAUAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwUAAAARZGVjaW1hbHNNdWx0UHJpY2UAAAACXzEEAAAAEHNoYXJlQXNzZXRBbW91bnQJAABrAAAAAwgFAAAAA3BtdAAAAAZhbW91bnQFAAAAEWRlY2ltYWxzTXVsdFByaWNlBQAAAAVwcmljZQkABEwAAAACCQEAAAAHUmVpc3N1ZQAAAAMFAAAADHNoYXJlQXNzZXRJZAUAAAAQc2hhcmVBc3NldEFtb3VudAYJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwgFAAAAAWkAAAAGY2FsbGVyBQAAABBzaGFyZUFzc2V0QW1vdW50BQAAAAxzaGFyZUFzc2V0SWQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAADGtleU9wZXJhdGlvbgAAAAQCAAAAAVAFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cgkAAlgAAAABCAUAAAABaQAAAA10cmFuc2FjdGlvbklkCQEAAAANZGF0YU9wZXJhdGlvbgAAAAgCAAAACEZJTklTSEVECAUAAAADcG10AAAABmFtb3VudAUAAAAFcHJpY2UFAAAAEHNoYXJlQXNzZXRBbW91bnQFAAAABmhlaWdodAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAFAAAABmhlaWdodAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAFAAAAA25pbAAAAAFpAQAAABBzdWJtaXRHZXRSZXF1ZXN0AAAAAAQAAAADcG10CQEAAAAFdmFsdWUAAAABCQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAABAAAAAxzaGFyZUFzc2V0SWQJAQAAAAV2YWx1ZQAAAAEIBQAAAANwbXQAAAAHYXNzZXRJZAQAAAANc2hhcmVBc3NldFN0cgkAAlgAAAABBQAAAAxzaGFyZUFzc2V0SWQEAAAADGNhbGxlclB1YlN0cgkAAlgAAAABCAUAAAABaQAAAA9jYWxsZXJQdWJsaWNLZXkEAAAAC3VzZXJBZGRyZXNzCAUAAAABaQAAAAZjYWxsZXIEAAAADnVzZXJBZGRyZXNzU3RyCQAEJQAAAAEFAAAAC3VzZXJBZGRyZXNzBAAAABBzaGFyZUFzc2V0QW1vdW50CAUAAAADcG10AAAABmFtb3VudAQAAAAMYmFzZUFzc2V0U3RyCQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQkBAAAAHGtleU1hcHBpbmdzU2hhcmUyYmFzZUFzc2V0SWQAAAABBQAAAA1zaGFyZUFzc2V0U3RyBAAAAAtiYXNlQXNzZXRJZAkAAlkAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAACGNmZ0FycmF5CQEAAAAScmVhZEFzc2V0Q2ZnT3JGYWlsAAAAAQUAAAAMYmFzZUFzc2V0U3RyBAAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAHElkeENmZ0RlY2ltYWxzTXVsdEJvdGhBc3NldHMEAAAAEWRlY2ltYWxzTXVsdFByaWNlCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAF0lkeENmZ0RlY2ltYWxzTXVsdFByaWNlBAAAAA5nZXREZWxheUJsb2NrcwkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAABRJZHhDZmdHZXREZWxheUJsb2NrcwQAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAF0lkeENmZ0ludGVybmFsQmFzZUFzc2V0BAAAAAVwcmljZQgJAQAAAAljYWxjUHJpY2UAAAAFBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAALYmFzZUFzc2V0SWQFAAAADHNoYXJlQXNzZXRJZAUAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwUAAAARZGVjaW1hbHNNdWx0UHJpY2UAAAACXzEEAAAAD2Jhc2VBc3NldEFtb3VudAkAAGsAAAADBQAAABBzaGFyZUFzc2V0QW1vdW50BQAAAAVwcmljZQUAAAARZGVjaW1hbHNNdWx0UHJpY2UEAAAADG9wZXJhdGlvbktleQkBAAAADGtleU9wZXJhdGlvbgAAAAQCAAAAAUcFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cgkAAlgAAAABCAUAAAABaQAAAA10cmFuc2FjdGlvbklkBAAAAA1vcGVyYXRpb25EYXRhCQEAAAANZGF0YU9wZXJhdGlvbgAAAAgCAAAAB1BFTkRJTkcFAAAAEHNoYXJlQXNzZXRBbW91bnQFAAAABXByaWNlBQAAAA9iYXNlQXNzZXRBbW91bnQFAAAABmhlaWdodAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAJAABkAAAAAgUAAAAGaGVpZ2h0BQAAAA5nZXREZWxheUJsb2NrcwAAAAAAAAAAAAkABEwAAAACCQEAAAAEQnVybgAAAAIFAAAADHNoYXJlQXNzZXRJZAUAAAAQc2hhcmVBc3NldEFtb3VudAkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACBQAAAAxvcGVyYXRpb25LZXkFAAAADW9wZXJhdGlvbkRhdGEJAARMAAAAAgkBAAAAFGluY3JlbWVudFRvdGFsTG9ja2VkAAAAAwkBAAAADmtleVRvdGFsTG9ja2VkAAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAAEHNoYXJlQXNzZXRBbW91bnQFAAAAD2Jhc2VBc3NldEFtb3VudAkABEwAAAACCQEAAAAUaW5jcmVtZW50VG90YWxMb2NrZWQAAAADCQEAAAAUa2V5VG90YWxMb2NrZWRCeVVzZXIAAAACBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAOdXNlckFkZHJlc3NTdHIFAAAAEHNoYXJlQXNzZXRBbW91bnQFAAAAD2Jhc2VBc3NldEFtb3VudAUAAAADbmlsAAAAAWkBAAAAEWV4ZWN1dGVHZXRSZXF1ZXN0AAAAAwAAAAxiYXNlQXNzZXRTdHIAAAAOdXNlckFkZHJlc3NTdHIAAAAKZ2V0VHhJZFN0cgQAAAALdXNlckFkZHJlc3MJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEFAAAADnVzZXJBZGRyZXNzU3RyBAAAAA1hc3NldENmZ0FycmF5CQEAAAAScmVhZEFzc2V0Q2ZnT3JGYWlsAAAAAQUAAAAMYmFzZUFzc2V0U3RyBAAAAAxzaGFyZUFzc2V0SWQJAAJZAAAAAQkAAZEAAAACBQAAAA1hc3NldENmZ0FycmF5BQAAABJJZHhDZmdTaGFyZUFzc2V0SWQEAAAAC2Jhc2VBc3NldElkCQACWQAAAAEFAAAADGJhc2VBc3NldFN0cgQAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAAGRAAAAAgUAAAANYXNzZXRDZmdBcnJheQUAAAAXSWR4Q2ZnSW50ZXJuYWxCYXNlQXNzZXQEAAAADG9wZXJhdGlvbktleQkBAAAADGtleU9wZXJhdGlvbgAAAAQCAAAAAUcFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cgUAAAAKZ2V0VHhJZFN0cgQAAAAOb3BlcmF0aW9uQXJyYXkJAAS1AAAAAgkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEFAAAADG9wZXJhdGlvbktleQUAAAADU0VQBAAAAAZzdGF0dXMJAAGRAAAAAgUAAAAOb3BlcmF0aW9uQXJyYXkFAAAADUlkeE9wZXJTdGF0dXMEAAAACWVuZEhlaWdodAkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAADm9wZXJhdGlvbkFycmF5BQAAABBJZHhPcGVyRW5kSGVpZ2h0BAAAAA1pblNoYXJlQW1vdW50CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAOb3BlcmF0aW9uQXJyYXkFAAAAD0lkeE9wZXJJbkFtb3VudAQAAAANb3V0QmFzZUFtb3VudAkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAADm9wZXJhdGlvbkFycmF5BQAAABBJZHhPcGVyT3V0QW1vdW50AwkBAAAAAiE9AAAAAgUAAAAGc3RhdHVzAgAAAAdQRU5ESU5HCQEAAAAOZmFpbEV4ZWN1dGVHZXQAAAAEAgAAABVTdGF0dXMgaXMgbm90IFBFTkRJTkcFAAAADGJhc2VBc3NldFN0cgUAAAAOdXNlckFkZHJlc3NTdHIFAAAACmdldFR4SWRTdHIDCQAAZgAAAAIFAAAACWVuZEhlaWdodAUAAAAGaGVpZ2h0CQEAAAAOZmFpbEV4ZWN1dGVHZXQAAAAECQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAAApFbmRIZWlnaHRbCQABpAAAAAEFAAAACWVuZEhlaWdodAIAAAAEXSA+IAkAAaQAAAABBQAAAAZoZWlnaHQFAAAADGJhc2VBc3NldFN0cgUAAAAOdXNlckFkZHJlc3NTdHIFAAAACmdldFR4SWRTdHIJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwUAAAALdXNlckFkZHJlc3MFAAAADW91dEJhc2VBbW91bnQFAAAAC2Jhc2VBc3NldElkCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIFAAAADG9wZXJhdGlvbktleQkBAAAAHGRhdGFPcGVyYXRpb25FeGVjdXRpb25VcGRhdGUAAAADBQAAAA5vcGVyYXRpb25BcnJheQIAAAAIRklOSVNIRUQIBQAAAAlsYXN0QmxvY2sAAAAJdGltZXN0YW1wCQAETAAAAAIJAQAAABRkZWNyZW1lbnRUb3RhbExvY2tlZAAAAAMJAQAAAA5rZXlUb3RhbExvY2tlZAAAAAEFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAA1pblNoYXJlQW1vdW50BQAAAA1vdXRCYXNlQW1vdW50CQAETAAAAAIJAQAAABRkZWNyZW1lbnRUb3RhbExvY2tlZAAAAAMJAQAAABRrZXlUb3RhbExvY2tlZEJ5VXNlcgAAAAIFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cgUAAAANaW5TaGFyZUFtb3VudAUAAAANb3V0QmFzZUFtb3VudAUAAAADbmlsAAAAAWkBAAAADHRvcFVwQmFsYW5jZQAAAAEAAAAMYmFzZUFzc2V0U3RyBAAAAA1hc3NldENmZ0FycmF5CQEAAAAScmVhZEFzc2V0Q2ZnT3JGYWlsAAAAAQUAAAAMYmFzZUFzc2V0U3RyBAAAAANwbXQJAQAAAAV2YWx1ZQAAAAEJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAEAAAACnBtdEFzc2V0SWQJAQAAAAV2YWx1ZQAAAAEIBQAAAANwbXQAAAAHYXNzZXRJZAQAAAALcG10QXNzZXRTdHIJAAJYAAAAAQUAAAAKcG10QXNzZXRJZAQAAAAMc2hhcmVBc3NldElkCQACWQAAAAEJAAGRAAAAAgUAAAANYXNzZXRDZmdBcnJheQUAAAASSWR4Q2ZnU2hhcmVBc3NldElkBAAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAANYXNzZXRDZmdBcnJheQUAAAAcSWR4Q2ZnRGVjaW1hbHNNdWx0Qm90aEFzc2V0cwQAAAARZGVjaW1hbHNNdWx0UHJpY2UJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAA1hc3NldENmZ0FycmF5BQAAABdJZHhDZmdEZWNpbWFsc011bHRQcmljZQQAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAAGRAAAAAgUAAAANYXNzZXRDZmdBcnJheQUAAAAXSWR4Q2ZnSW50ZXJuYWxCYXNlQXNzZXQDCQEAAAACIT0AAAACBQAAAAxiYXNlQXNzZXRTdHIFAAAAC3BtdEFzc2V0U3RyCQAAAgAAAAECAAAAPmF0dGFjaGVkIHBheW1lbnQncyBhc3NldCBpZCBpcyBOT1QgbWF0Y2hlZCBwYXNzZWQgYmFzZUFzc2V0U3RyAwkAAGYAAAACCQABkAAAAAEIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAABCQAAAgAAAAECAAAAIG9ubHkgb25lIHBheW1lbnQgY2FuIGJlIGF0dGFjaGVkBAAAAAVwcmljZQgJAQAAABBnZW5lcmljQ2FsY1ByaWNlAAAABgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAACnBtdEFzc2V0SWQIBQAAAANwbXQAAAAGYW1vdW50BQAAAAxzaGFyZUFzc2V0SWQFAAAAFmRlY2ltYWxzTXVsdEJvdGhBc3NldHMFAAAAEWRlY2ltYWxzTXVsdFByaWNlAAAAAl8xCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAMa2V5UHJpY2VMYXN0AAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAABXByaWNlCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAPa2V5UHJpY2VIaXN0b3J5AAAAAwUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAABmhlaWdodAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAFAAAABXByaWNlBQAAAANuaWwAAAABaQEAAAAUY3VycmVudFN5c1BhcmFtc1JFU1QAAAABAAAADGJhc2VBc3NldFN0cgQAAAANc3lzU3RhdGVUdXBsZQkBAAAAG3ByaXZhdGVDdXJyZW50U3lzUGFyYW1zUkVTVAAAAAEFAAAADGJhc2VBc3NldFN0cgQAAAAFcHJpY2UICAUAAAANc3lzU3RhdGVUdXBsZQAAAAJfMQAAAAV2YWx1ZQQAAAARZGVjaW1hbHNNdWx0UHJpY2UICAUAAAANc3lzU3RhdGVUdXBsZQAAAAJfMgAAAAV2YWx1ZQQAAAAQYmFzZUFzc2V0QmFsYW5jZQgIBQAAAA1zeXNTdGF0ZVR1cGxlAAAAAl8zAAAABXZhbHVlBAAAABV0b3RhbExvY2tlZEJhc2VBbW91bnQICAUAAAANc3lzU3RhdGVUdXBsZQAAAAJfNAAAAAV2YWx1ZQQAAAAfYmFzZUFzc2V0QmFsYW5jZUNvbnNpZGVyaW5nTG9jawgIBQAAAA1zeXNTdGF0ZVR1cGxlAAAAAl81AAAABXZhbHVlBAAAAA1zaGFyZUVtaXNzaW9uCAgFAAAADXN5c1N0YXRlVHVwbGUAAAACXzYAAAAFdmFsdWUEAAAACHJlc3REYXRhCQAEuQAAAAIJAARMAAAAAgIAAAAZc3RhcnRDdXJyZW50U3lzUGFyYW1zUkVTVAkABEwAAAACCQABpAAAAAEFAAAABXByaWNlCQAETAAAAAIJAAGkAAAAAQUAAAARZGVjaW1hbHNNdWx0UHJpY2UJAARMAAAAAgkAAaQAAAABBQAAABBiYXNlQXNzZXRCYWxhbmNlCQAETAAAAAIJAAGkAAAAAQUAAAAVdG90YWxMb2NrZWRCYXNlQW1vdW50CQAETAAAAAIJAAGkAAAAAQUAAAAfYmFzZUFzc2V0QmFsYW5jZUNvbnNpZGVyaW5nTG9jawkABEwAAAACCQABpAAAAAEFAAAADXNoYXJlRW1pc3Npb24JAARMAAAAAgIAAAAXZW5kQ3VycmVudFN5c1BhcmFtc1JFU1QFAAAAA25pbAUAAAADU0VQCQAAAgAAAAEFAAAACHJlc3REYXRhAAAAACFkUto=",
    "chainId": 84,
    "height": 1321611,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 
Old New Differences
1 - # no script
1 + {-# STDLIB_VERSION 4 #-}
2 + {-# SCRIPT_TYPE ACCOUNT #-}
3 + {-# CONTENT_TYPE DAPP #-}
4 + let SEP = "__"
5 + 
6 + func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
7 + 
8 + 
9 + func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
10 + 
11 + 
12 + func failExecuteGet (msg,baseAssetStr,userAddressStr,getTxIdStr) = throw(((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " getTxIdStr=") + getTxIdStr))
13 + 
14 + 
15 + func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
16 + 
17 + 
18 + func keyNextInternalAssetId () = "%s__nextInternalAssetId"
19 + 
20 + 
21 + func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
22 + 
23 + 
24 + func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
25 + 
26 + 
27 + func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
28 + 
29 + 
30 + func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
31 + 
32 + 
33 + func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
34 + 
35 + 
36 + func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
37 + 
38 + 
39 + func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
40 + 
41 + 
42 + func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
43 + 
44 + 
45 + func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
46 + 
47 + 
48 + func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
49 + 
50 + 
51 + let IdxCfgShareAssetId = 1
52 + 
53 + let IdxCfgInternalBaseAsset = 2
54 + 
55 + let IdxCfgDecimalsMultBothAssets = 3
56 + 
57 + let IdxCfgDecimalsMultPrice = 4
58 + 
59 + let IdxCfgGetDelayBlocks = 5
60 + 
61 + func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks) = makeString(["%s%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks)], SEP)
62 + 
63 + 
64 + let IdxTotalLockedShare = 1
65 + 
66 + let IdxTotalLockedBase = 2
67 + 
68 + func dataTotalLocked (shareAssetAmount,baseAssetAmount) = makeString(["%d%d", toString(shareAssetAmount), toString(baseAssetAmount)], SEP)
69 + 
70 + 
71 + func readTotalLocked (key) = {
72 +     let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0)), SEP)
73 + [-1, parseIntValue(totalLockedArray[IdxTotalLockedShare]), parseIntValue(totalLockedArray[IdxTotalLockedBase])]
74 +     }
75 + 
76 + 
77 + func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
78 + 
79 + 
80 + let IdxOperStatus = 1
81 + 
82 + let IdxOperInAmount = 2
83 + 
84 + let IdxOperPrice = 3
85 + 
86 + let IdxOperOutAmount = 4
87 + 
88 + let IdxOperStartHeight = 5
89 + 
90 + let IdxOperStartTimestamp = 6
91 + 
92 + let IdxOperEndHeight = 7
93 + 
94 + let IdxOperEndTimestamp = 8
95 + 
96 + func privateDataOperationAllStrings (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp) = makeString(["%s%d%d%d%d%d%d%d", status, inAssetAmount, price, outAssetAmount, startHeight, startTimestamp, endHeight, endTimestamp], SEP)
97 + 
98 + 
99 + func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp))
100 + 
101 + 
102 + func dataOperationExecutionUpdate (currOperArray,newStatus,newEndTimestamp) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], currOperArray[IdxOperPrice], currOperArray[IdxOperOutAmount], currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], currOperArray[IdxOperEndHeight], toString(newEndTimestamp))
103 + 
104 + 
105 + func readAssetCfgOrFail (baseAssetStr) = {
106 +     let key = keyAssetCfg(baseAssetStr)
107 +     split(getStringOrFail(key), SEP)
108 +     }
109 + 
110 + 
111 + func incrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
112 +     let dataArray = readTotalLocked(key)
113 +     StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] + shareAssetAmount), (dataArray[IdxTotalLockedBase] + baseAssetAmount)))
114 +     }
115 + 
116 + 
117 + func decrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
118 +     let dataArray = readTotalLocked(key)
119 +     StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] - shareAssetAmount), (dataArray[IdxTotalLockedBase] - baseAssetAmount)))
120 +     }
121 + 
122 + 
123 + func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = {
124 +     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
125 +     let totalLockedBaseAmount = totalLockedArray[IdxTotalLockedBase]
126 +     let baseAssetBalance = assetBalance(this, baseAssetId)
127 +     let baseAssetBalanceConsideringLock = ((baseAssetBalance - totalLockedBaseAmount) + topUpBaseAmount)
128 +     if ((0 > baseAssetBalanceConsideringLock))
129 +         then throw(((("baseAssetBalanceConsideringLock < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceConsideringLock=") + toString(baseAssetBalanceConsideringLock)))
130 +         else {
131 +             let shareEmission = value(assetInfo(shareAssetId)).quantity
132 +             let price = if ((shareEmission == 0))
133 +                 then (1 * decimalsMultPrice)
134 +                 else fraction(baseAssetBalanceConsideringLock, decimalsMultPrice, shareEmission)
135 +             $Tuple5(price, baseAssetBalance, totalLockedBaseAmount, baseAssetBalanceConsideringLock, shareEmission)
136 +             }
137 +     }
138 + 
139 + 
140 + func calcPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = genericCalcPrice(internalBaseAssetStr, baseAssetId, 0, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)
141 + 
142 + 
143 + func privateCurrentSysParamsREST (baseAssetStr) = {
144 +     let baseAssetId = fromBase58String(baseAssetStr)
145 +     let cfgArray = readAssetCfgOrFail(baseAssetStr)
146 +     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
147 +     let shareAssetId = fromBase58String(shareAssetStr)
148 +     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
149 +     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
150 +     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
151 +     let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)
152 +     $Tuple6(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5))
153 +     }
154 + 
155 + 
156 + @Callable(i)
157 + func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress) = {
158 +     let baseAssetId = fromBase58String(baseAssetStr)
159 +     let decimals = value(assetInfo(baseAssetId)).decimals
160 +     if ((i.caller != this))
161 +         then throw("permissions denied")
162 +         else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
163 +             then throw("invalid shutdownManagerAddress")
164 +             else if ((0 > getDelayinBlocks))
165 +                 then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
166 +                 else {
167 +                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, 1, decimals, true)
168 +                     let shareAssetId = calculateAssetId(shareAssetIssueAction)
169 +                     let shareAssetStr = toBase58String(shareAssetId)
170 +                     let decimalsMultPrice = ((100 * 1000) * 1000)
171 +                     let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
172 +                     let startPrice = (1 * decimalsMultPrice)
173 +                     let internalBaseAssettId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
174 +                     let internalBaseAssetStr = toString(internalBaseAssettId)
175 + [StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssettId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownPutOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssettId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), shareAssetIssueAction, Burn(shareAssetId, 1)]
176 +                     }
177 +     }
178 + 
179 + 
180 + 
181 + @Callable(i)
182 + func shutdownPut (internalBaseAssetId) = {
183 +     let internalBaseAssetIdStr = toString(internalBaseAssetId)
184 +     let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
185 +     let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
186 +     if ((1 > size(baseAssetIdStr)))
187 +         then throw("invalid internalBaseAssetId")
188 +         else if ((toString(i.caller) != shutdownManagerAddress))
189 +             then throw("access denied")
190 +             else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
191 +     }
192 + 
193 + 
194 + 
195 + @Callable(i)
196 + func put () = {
197 +     let pmt = value(i.payments[0])
198 +     let baseAssetId = value(pmt.assetId)
199 +     let baseAssetStr = toBase58String(baseAssetId)
200 +     let userAddressStr = toString(i.caller)
201 +     let cfgArray = readAssetCfgOrFail(baseAssetStr)
202 +     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
203 +     let shareAssetId = fromBase58String(shareAssetStr)
204 +     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
205 +     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
206 +     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
207 +     let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
208 +     if (isPutBlocked)
209 +         then throw("put operation is blocked")
210 +         else {
211 +             let price = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
212 +             let shareAssetAmount = fraction(pmt.amount, decimalsMultPrice, price)
213 + [Reissue(shareAssetId, shareAssetAmount, true), ScriptTransfer(i.caller, shareAssetAmount, shareAssetId), StringEntry(keyOperation("P", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("FINISHED", pmt.amount, price, shareAssetAmount, height, lastBlock.timestamp, height, lastBlock.timestamp))]
214 +             }
215 +     }
216 + 
217 + 
218 + 
219 + @Callable(i)
220 + func submitGetRequest () = {
221 +     let pmt = value(i.payments[0])
222 +     let shareAssetId = value(pmt.assetId)
223 +     let shareAssetStr = toBase58String(shareAssetId)
224 +     let callerPubStr = toBase58String(i.callerPublicKey)
225 +     let userAddress = i.caller
226 +     let userAddressStr = toString(userAddress)
227 +     let shareAssetAmount = pmt.amount
228 +     let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
229 +     let baseAssetId = fromBase58String(baseAssetStr)
230 +     let cfgArray = readAssetCfgOrFail(baseAssetStr)
231 +     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
232 +     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
233 +     let getDelayBlocks = parseIntValue(cfgArray[IdxCfgGetDelayBlocks])
234 +     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
235 +     let price = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
236 +     let baseAssetAmount = fraction(shareAssetAmount, price, decimalsMultPrice)
237 +     let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId))
238 +     let operationData = dataOperation("PENDING", shareAssetAmount, price, baseAssetAmount, height, lastBlock.timestamp, (height + getDelayBlocks), 0)
239 + [Burn(shareAssetId, shareAssetAmount), StringEntry(operationKey, operationData), incrementTotalLocked(keyTotalLocked(internalBaseAssetStr), shareAssetAmount, baseAssetAmount), incrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), shareAssetAmount, baseAssetAmount)]
240 +     }
241 + 
242 + 
243 + 
244 + @Callable(i)
245 + func executeGetRequest (baseAssetStr,userAddressStr,getTxIdStr) = {
246 +     let userAddress = addressFromStringValue(userAddressStr)
247 +     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
248 +     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
249 +     let baseAssetId = fromBase58String(baseAssetStr)
250 +     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
251 +     let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, getTxIdStr)
252 +     let operationArray = split(getStringOrFail(operationKey), SEP)
253 +     let status = operationArray[IdxOperStatus]
254 +     let endHeight = parseIntValue(operationArray[IdxOperEndHeight])
255 +     let inShareAmount = parseIntValue(operationArray[IdxOperInAmount])
256 +     let outBaseAmount = parseIntValue(operationArray[IdxOperOutAmount])
257 +     if ((status != "PENDING"))
258 +         then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, getTxIdStr)
259 +         else if ((endHeight > height))
260 +             then failExecuteGet(((("EndHeight[" + toString(endHeight)) + "] > ") + toString(height)), baseAssetStr, userAddressStr, getTxIdStr)
261 +             else [ScriptTransfer(userAddress, outBaseAmount, baseAssetId), StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", lastBlock.timestamp)), decrementTotalLocked(keyTotalLocked(internalBaseAssetStr), inShareAmount, outBaseAmount), decrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), inShareAmount, outBaseAmount)]
262 +     }
263 + 
264 + 
265 + 
266 + @Callable(i)
267 + func topUpBalance (baseAssetStr) = {
268 +     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
269 +     let pmt = value(i.payments[0])
270 +     let pmtAssetId = value(pmt.assetId)
271 +     let pmtAssetStr = toBase58String(pmtAssetId)
272 +     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
273 +     let decimalsMultBothAssets = parseIntValue(assetCfgArray[IdxCfgDecimalsMultBothAssets])
274 +     let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
275 +     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
276 +     if ((baseAssetStr != pmtAssetStr))
277 +         then throw("attached payment's asset id is NOT matched passed baseAssetStr")
278 +         else if ((size(i.payments) > 1))
279 +             then throw("only one payment can be attached")
280 +             else {
281 +                 let price = genericCalcPrice(internalBaseAssetStr, pmtAssetId, pmt.amount, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
282 + [IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price)]
283 +                 }
284 +     }
285 + 
286 + 
287 + 
288 + @Callable(i)
289 + func currentSysParamsREST (baseAssetStr) = {
290 +     let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
291 +     let price = sysStateTuple._1.value
292 +     let decimalsMultPrice = sysStateTuple._2.value
293 +     let baseAssetBalance = sysStateTuple._3.value
294 +     let totalLockedBaseAmount = sysStateTuple._4.value
295 +     let baseAssetBalanceConsideringLock = sysStateTuple._5.value
296 +     let shareEmission = sysStateTuple._6.value
297 +     let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
298 +     throw(restData)
299 +     }
300 + 
301 +

Old	New		Differences
1		-	# no script
	1	+	{-# STDLIB_VERSION 4 #-}
	2	+	{-# SCRIPT_TYPE ACCOUNT #-}
	3	+	{-# CONTENT_TYPE DAPP #-}
	4	+	let SEP = "__"
	5	+
	6	+	func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
	7	+
	8	+
	9	+	func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
	10	+
	11	+
	12	+	func failExecuteGet (msg,baseAssetStr,userAddressStr,getTxIdStr) = throw(((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " getTxIdStr=") + getTxIdStr))
	13	+
	14	+
	15	+	func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
	16	+
	17	+
	18	+	func keyNextInternalAssetId () = "%s__nextInternalAssetId"
	19	+
	20	+
	21	+	func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
	22	+
	23	+
	24	+	func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
	25	+
	26	+
	27	+	func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
	28	+
	29	+
	30	+	func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
	31	+
	32	+
	33	+	func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
	34	+
	35	+
	36	+	func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
	37	+
	38	+
	39	+	func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
	40	+
	41	+
	42	+	func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
	43	+
	44	+
	45	+	func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
	46	+
	47	+
	48	+	func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
	49	+
	50	+
	51	+	let IdxCfgShareAssetId = 1
	52	+
	53	+	let IdxCfgInternalBaseAsset = 2
	54	+
	55	+	let IdxCfgDecimalsMultBothAssets = 3
	56	+
	57	+	let IdxCfgDecimalsMultPrice = 4
	58	+
	59	+	let IdxCfgGetDelayBlocks = 5
	60	+
	61	+	func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks) = makeString(["%s%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks)], SEP)
	62	+
	63	+
	64	+	let IdxTotalLockedShare = 1
	65	+
	66	+	let IdxTotalLockedBase = 2
	67	+
	68	+	func dataTotalLocked (shareAssetAmount,baseAssetAmount) = makeString(["%d%d", toString(shareAssetAmount), toString(baseAssetAmount)], SEP)
	69	+
	70	+
	71	+	func readTotalLocked (key) = {
	72	+	let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0)), SEP)
	73	+	[-1, parseIntValue(totalLockedArray[IdxTotalLockedShare]), parseIntValue(totalLockedArray[IdxTotalLockedBase])]
	74	+	}
	75	+
	76	+
	77	+	func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
	78	+
	79	+
	80	+	let IdxOperStatus = 1
	81	+
	82	+	let IdxOperInAmount = 2
	83	+
	84	+	let IdxOperPrice = 3
	85	+
	86	+	let IdxOperOutAmount = 4
	87	+
	88	+	let IdxOperStartHeight = 5
	89	+
	90	+	let IdxOperStartTimestamp = 6
	91	+
	92	+	let IdxOperEndHeight = 7
	93	+
	94	+	let IdxOperEndTimestamp = 8
	95	+
	96	+	func privateDataOperationAllStrings (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp) = makeString(["%s%d%d%d%d%d%d%d", status, inAssetAmount, price, outAssetAmount, startHeight, startTimestamp, endHeight, endTimestamp], SEP)
	97	+
	98	+
	99	+	func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp))
	100	+
	101	+
	102	+	func dataOperationExecutionUpdate (currOperArray,newStatus,newEndTimestamp) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], currOperArray[IdxOperPrice], currOperArray[IdxOperOutAmount], currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], currOperArray[IdxOperEndHeight], toString(newEndTimestamp))
	103	+
	104	+
	105	+	func readAssetCfgOrFail (baseAssetStr) = {
	106	+	let key = keyAssetCfg(baseAssetStr)
	107	+	split(getStringOrFail(key), SEP)
	108	+	}
	109	+
	110	+
	111	+	func incrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
	112	+	let dataArray = readTotalLocked(key)
	113	+	StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] + shareAssetAmount), (dataArray[IdxTotalLockedBase] + baseAssetAmount)))
	114	+	}
	115	+
	116	+
	117	+	func decrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
	118	+	let dataArray = readTotalLocked(key)
	119	+	StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] - shareAssetAmount), (dataArray[IdxTotalLockedBase] - baseAssetAmount)))
	120	+	}
	121	+
	122	+
	123	+	func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = {
	124	+	let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
	125	+	let totalLockedBaseAmount = totalLockedArray[IdxTotalLockedBase]
	126	+	let baseAssetBalance = assetBalance(this, baseAssetId)
	127	+	let baseAssetBalanceConsideringLock = ((baseAssetBalance - totalLockedBaseAmount) + topUpBaseAmount)
	128	+	if ((0 > baseAssetBalanceConsideringLock))
	129	+	then throw(((("baseAssetBalanceConsideringLock < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceConsideringLock=") + toString(baseAssetBalanceConsideringLock)))
	130	+	else {
	131	+	let shareEmission = value(assetInfo(shareAssetId)).quantity
	132	+	let price = if ((shareEmission == 0))
	133	+	then (1 * decimalsMultPrice)
	134	+	else fraction(baseAssetBalanceConsideringLock, decimalsMultPrice, shareEmission)
	135	+	$Tuple5(price, baseAssetBalance, totalLockedBaseAmount, baseAssetBalanceConsideringLock, shareEmission)
	136	+	}
	137	+	}
	138	+
	139	+
	140	+	func calcPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = genericCalcPrice(internalBaseAssetStr, baseAssetId, 0, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)
	141	+
	142	+
	143	+	func privateCurrentSysParamsREST (baseAssetStr) = {
	144	+	let baseAssetId = fromBase58String(baseAssetStr)
	145	+	let cfgArray = readAssetCfgOrFail(baseAssetStr)
	146	+	let shareAssetStr = cfgArray[IdxCfgShareAssetId]
	147	+	let shareAssetId = fromBase58String(shareAssetStr)
	148	+	let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
	149	+	let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
	150	+	let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	151	+	let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)
	152	+	$Tuple6(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5))
	153	+	}
	154	+
	155	+
	156	+	@Callable(i)
	157	+	func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress) = {
	158	+	let baseAssetId = fromBase58String(baseAssetStr)
	159	+	let decimals = value(assetInfo(baseAssetId)).decimals
	160	+	if ((i.caller != this))
	161	+	then throw("permissions denied")
	162	+	else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
	163	+	then throw("invalid shutdownManagerAddress")
	164	+	else if ((0 > getDelayinBlocks))
	165	+	then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
	166	+	else {
	167	+	let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, 1, decimals, true)
	168	+	let shareAssetId = calculateAssetId(shareAssetIssueAction)
	169	+	let shareAssetStr = toBase58String(shareAssetId)
	170	+	let decimalsMultPrice = ((100 * 1000) * 1000)
	171	+	let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
	172	+	let startPrice = (1 * decimalsMultPrice)
	173	+	let internalBaseAssettId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
	174	+	let internalBaseAssetStr = toString(internalBaseAssettId)
	175	+	[StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssettId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownPutOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssettId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), shareAssetIssueAction, Burn(shareAssetId, 1)]
	176	+	}
	177	+	}
	178	+
	179	+
	180	+
	181	+	@Callable(i)
	182	+	func shutdownPut (internalBaseAssetId) = {
	183	+	let internalBaseAssetIdStr = toString(internalBaseAssetId)
	184	+	let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
	185	+	let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
	186	+	if ((1 > size(baseAssetIdStr)))
	187	+	then throw("invalid internalBaseAssetId")
	188	+	else if ((toString(i.caller) != shutdownManagerAddress))
	189	+	then throw("access denied")
	190	+	else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
	191	+	}
	192	+
	193	+
	194	+
	195	+	@Callable(i)
	196	+	func put () = {
	197	+	let pmt = value(i.payments[0])
	198	+	let baseAssetId = value(pmt.assetId)
	199	+	let baseAssetStr = toBase58String(baseAssetId)
	200	+	let userAddressStr = toString(i.caller)
	201	+	let cfgArray = readAssetCfgOrFail(baseAssetStr)
	202	+	let shareAssetStr = cfgArray[IdxCfgShareAssetId]
	203	+	let shareAssetId = fromBase58String(shareAssetStr)
	204	+	let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
	205	+	let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
	206	+	let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	207	+	let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
	208	+	if (isPutBlocked)
	209	+	then throw("put operation is blocked")
	210	+	else {
	211	+	let price = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
	212	+	let shareAssetAmount = fraction(pmt.amount, decimalsMultPrice, price)
	213	+	[Reissue(shareAssetId, shareAssetAmount, true), ScriptTransfer(i.caller, shareAssetAmount, shareAssetId), StringEntry(keyOperation("P", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("FINISHED", pmt.amount, price, shareAssetAmount, height, lastBlock.timestamp, height, lastBlock.timestamp))]
	214	+	}
	215	+	}
	216	+
	217	+
	218	+
	219	+	@Callable(i)
	220	+	func submitGetRequest () = {
	221	+	let pmt = value(i.payments[0])
	222	+	let shareAssetId = value(pmt.assetId)
	223	+	let shareAssetStr = toBase58String(shareAssetId)
	224	+	let callerPubStr = toBase58String(i.callerPublicKey)
	225	+	let userAddress = i.caller
	226	+	let userAddressStr = toString(userAddress)
	227	+	let shareAssetAmount = pmt.amount
	228	+	let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
	229	+	let baseAssetId = fromBase58String(baseAssetStr)
	230	+	let cfgArray = readAssetCfgOrFail(baseAssetStr)
	231	+	let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
	232	+	let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
	233	+	let getDelayBlocks = parseIntValue(cfgArray[IdxCfgGetDelayBlocks])
	234	+	let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	235	+	let price = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
	236	+	let baseAssetAmount = fraction(shareAssetAmount, price, decimalsMultPrice)
	237	+	let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId))
	238	+	let operationData = dataOperation("PENDING", shareAssetAmount, price, baseAssetAmount, height, lastBlock.timestamp, (height + getDelayBlocks), 0)
	239	+	[Burn(shareAssetId, shareAssetAmount), StringEntry(operationKey, operationData), incrementTotalLocked(keyTotalLocked(internalBaseAssetStr), shareAssetAmount, baseAssetAmount), incrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), shareAssetAmount, baseAssetAmount)]
	240	+	}
	241	+
	242	+
	243	+
	244	+	@Callable(i)
	245	+	func executeGetRequest (baseAssetStr,userAddressStr,getTxIdStr) = {
	246	+	let userAddress = addressFromStringValue(userAddressStr)
	247	+	let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
	248	+	let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
	249	+	let baseAssetId = fromBase58String(baseAssetStr)
	250	+	let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
	251	+	let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, getTxIdStr)
	252	+	let operationArray = split(getStringOrFail(operationKey), SEP)
	253	+	let status = operationArray[IdxOperStatus]
	254	+	let endHeight = parseIntValue(operationArray[IdxOperEndHeight])
	255	+	let inShareAmount = parseIntValue(operationArray[IdxOperInAmount])
	256	+	let outBaseAmount = parseIntValue(operationArray[IdxOperOutAmount])
	257	+	if ((status != "PENDING"))
	258	+	then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, getTxIdStr)
	259	+	else if ((endHeight > height))
	260	+	then failExecuteGet(((("EndHeight[" + toString(endHeight)) + "] > ") + toString(height)), baseAssetStr, userAddressStr, getTxIdStr)
	261	+	else [ScriptTransfer(userAddress, outBaseAmount, baseAssetId), StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", lastBlock.timestamp)), decrementTotalLocked(keyTotalLocked(internalBaseAssetStr), inShareAmount, outBaseAmount), decrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), inShareAmount, outBaseAmount)]
	262	+	}
	263	+
	264	+
	265	+
	266	+	@Callable(i)
	267	+	func topUpBalance (baseAssetStr) = {
	268	+	let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
	269	+	let pmt = value(i.payments[0])
	270	+	let pmtAssetId = value(pmt.assetId)
	271	+	let pmtAssetStr = toBase58String(pmtAssetId)
	272	+	let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
	273	+	let decimalsMultBothAssets = parseIntValue(assetCfgArray[IdxCfgDecimalsMultBothAssets])
	274	+	let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
	275	+	let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
	276	+	if ((baseAssetStr != pmtAssetStr))
	277	+	then throw("attached payment's asset id is NOT matched passed baseAssetStr")
	278	+	else if ((size(i.payments) > 1))
	279	+	then throw("only one payment can be attached")
	280	+	else {
	281	+	let price = genericCalcPrice(internalBaseAssetStr, pmtAssetId, pmt.amount, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
	282	+	[IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price)]
	283	+	}
	284	+	}
	285	+
	286	+
	287	+
	288	+	@Callable(i)
	289	+	func currentSysParamsREST (baseAssetStr) = {
	290	+	let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
	291	+	let price = sysStateTuple._1.value
	292	+	let decimalsMultPrice = sysStateTuple._2.value
	293	+	let baseAssetBalance = sysStateTuple._3.value
	294	+	let totalLockedBaseAmount = sysStateTuple._4.value
	295	+	let baseAssetBalanceConsideringLock = sysStateTuple._5.value
	296	+	let shareEmission = sysStateTuple._6.value
	297	+	let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
	298	+	throw(restData)
	299	+	}
	300	+
	301	+

github/deemru/w8io/3ef1775 
48.28 ms ◑