tx · 36WEhWv7xQskRAvrDY3DuqDgrKSFmQQ7WLbhukmxGBik

3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai:  -0.03500000 Waves

2022.12.05 13:06 [2346917] smart account 3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "36WEhWv7xQskRAvrDY3DuqDgrKSFmQQ7WLbhukmxGBik",
    "fee": 3500000,
    "feeAssetId": null,
    "timestamp": 1670234741405,
    "version": 2,
    "chainId": 84,
    "sender": "3MsMP2pb2p8MDd6Rxb7XEXqqwEhE8ATfyai",
    "senderPublicKey": "2JEaBjtjvMoNGKZmL9QxYefa1VkMJM3vMW8rNvTs9R2H",
    "proofs": [
        "66DTc8mpw1LBZTC4Y6U1ji66YAkVqGYsyL6BXrQP956xCcHth1e2SJsQMxjWtTFHaWqLKEaxNYH5zMhZE55Yq32P"
    ],
    "script": "base64:AAIFAAAAAAAAAH4IAhIKCggICAgICAgIARIDCgEIEgYKBAgICAgSBAoCCBgSAwoBCBIECgIIGBIDCgEIEgASAwoBGBIKCggICAgICAEICBIECgIIARIDCgEBEgMKAQESBAoCCAESBgoECAgICBIECgIICBIECgIICBIECgIICBIDCgEIEgMKAQgAAABfAAAAAAZTQ0FMRTgAAAAAAAAAAAgAAAAABU1VTFQ4AAAAAAAF9eEAAAAAAAdTQ0FMRTE4AAAAAAAAAAASAAAAAAZNVUxUMTgJAAE2AAAAAQAN4Lazp2QAAAAAAAAOUE9PTFdFSUdIVE1VTFQFAAAABU1VTFQ4AAAAAA5HV1h2aXJ0dWFsUE9PTAIAAAAOR1dYdmlydHVhbFBPT0wAAAAADGxhYmVsUG9vbHNMcAIAAAAIUE9PTFNfTFAAAAAADWRlZmF1bHRTcHJlYWQAAAAAAAAehIAAAAAAEWRlY2ltYWxzTXVsdFByaWNlCQAAaAAAAAIJAABoAAAAAgAAAAAAAAAAZAAAAAAAAAAD6AAAAAAAAAAD6AAAAAADU0VQAgAAAAJfXwAAAAAFRU1QVFkCAAAAAAAAAAAKUG9vbEFjdGl2ZQAAAAAAAAAAAQAAAAAPUG9vbFB1dERpc2FibGVkAAAAAAAAAAACAAAAABNQb29sTWF0Y2hlckRpc2FibGVkAAAAAAAAAAADAAAAAAxQb29sU2h1dGRvd24AAAAAAAAAAAQAAAAAEmlkeEludGVybmFsQXNzZXRJZAAAAAAAAAAAAQAAAAAPaWR4UmVzdXRBY3Rpb25zAAAAAAAAAAACAAAAACBpZHhJZkFzc2V0SWRDYWxjdWxhdGlvblBlcmZvcm1lZAAAAAAAAAAAAwAAAAAOaWR4UG9vbEFkZHJlc3MAAAAAAAAAAAEAAAAADWlkeFBvb2xTdGF0dXMAAAAAAAAAAAIAAAAAEGlkeFBvb2xMUEFzc2V0SWQAAAAAAAAAAAMAAAAADWlkeEFtdEFzc2V0SWQAAAAAAAAAAAQAAAAAD2lkeFByaWNlQXNzZXRJZAAAAAAAAAAABQAAAAAOaWR4QW10QXNzZXREY20AAAAAAAAAAAYAAAAAEGlkeFByaWNlQXNzZXREY20AAAAAAAAAAAcAAAAADmlkeElBbXRBc3NldElkAAAAAAAAAAAIAAAAABBpZHhJUHJpY2VBc3NldElkAAAAAAAAAAAJAAAAAA1pZHhMUEFzc2V0RGNtAAAAAAAAAAAKAAAAAAtpZHhQb29sVHlwZQAAAAAAAAAACwAAAAATcG9vbExhYmVsV3hFbWlzc2lvbgIAAAALV1hfRU1JU1NJT04AAAAAD3ZhbGlkUG9vbExhYmVscwkABEwAAAACBQAAABNwb29sTGFiZWxXeEVtaXNzaW9uBQAAAANuaWwBAAAAFmtleUFsbG93ZWRMcFNjcmlwdEhhc2gAAAAAAgAAABclc19fYWxsb3dlZExwU2NyaXB0SGFzaAEAAAAca2V5QWxsb3dlZExwU3RhYmxlU2NyaXB0SGFzaAAAAAACAAAAHSVzX19hbGxvd2VkTHBTdGFibGVTY3JpcHRIYXNoAQAAACFrZXlBbGxvd2VkTHBTdGFibGVBZGRvblNjcmlwdEhhc2gAAAAAAgAAACIlc19fYWxsb3dlZExwU3RhYmxlQWRkb25TY3JpcHRIYXNoAQAAABBrZXlGYWN0b3J5Q29uZmlnAAAAAAIAAAARJXNfX2ZhY3RvcnlDb25maWcBAAAAD2tleUxwVG9rZW5zTGlzdAAAAAACAAAAECVzX19scFRva2Vuc0xpc3QBAAAAEWtleVBvb2xTY3JpcHRIYXNoAAAAAAIAAAAWJXMlc19fcG9vbF9fc2NyaXB0SGFzaAEAAAANa2V5TWF0Y2hlclB1YgAAAAACAAAAGCVzJXNfX21hdGNoZXJfX3B1YmxpY0tleQEAAAAYa2V5TGVnYWN5RmFjdG9yeUNvbnRyYWN0AAAAAAIAAAAZJXNfX2xlZ2FjeUZhY3RvcnlDb250cmFjdAEAAAAOa2V5TGVnYWN5UG9vbHMAAAAAAgAAAA8lc19fbGVnYWN5UG9vbHMBAAAAE2tleU1hbmFnZXJQdWJsaWNLZXkAAAAAAgAAABQlc19fbWFuYWdlclB1YmxpY0tleQEAAAAaa2V5UGVuZGluZ01hbmFnZXJQdWJsaWNLZXkAAAAAAgAAABslc19fcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkBAAAAD2tleUFkbWluUHViS2V5cwAAAAACAAAAECVzX19hZG1pblB1YktleXMBAAAAFmtleUFzc2V0c1N0b3JlQ29udHJhY3QAAAAAAgAAABclc19fYXNzZXRzU3RvcmVDb250cmFjdAEAAAAZa2V5Vm90aW5nRW1pc3Npb25Db250cmFjdAAAAAACAAAAGiVzX192b3RpbmdFbWlzc2lvbkNvbnRyYWN0AQAAAA5rZXlQcmljZUFzc2V0cwAAAAAJAAS5AAAAAgkABEwAAAACAgAAAAIlcwkABEwAAAACAgAAAAtwcmljZUFzc2V0cwUAAAADbmlsBQAAAANTRVABAAAAEGtleVByaWNlRGVjaW1hbHMAAAAAAgAAABElc19fcHJpY2VEZWNpbWFscwEAAAATa2V5QWxsUG9vbHNTaHV0ZG93bgAAAAACAAAADCVzX19zaHV0ZG93bgEAAAAWa2V5TmV4dEludGVybmFsQXNzZXRJZAAAAAACAAAAFyVzX19uZXh0SW50ZXJuYWxBc3NldElkAQAAAA9rZXlQb29sVG9XZWlnaHQAAAABAAAAC3Bvb2xBZGRyZXNzCQABLAAAAAICAAAAEiVzJXNfX3Bvb2xXZWlnaHRfXwUAAAALcG9vbEFkZHJlc3MBAAAAFmtleVBvb2xUb1dlaWdodEhpc3RvcnkAAAACAAAAC3Bvb2xBZGRyZXNzAAAAA251bQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAASJXMlc19fcG9vbFdlaWdodF9fBQAAAAtwb29sQWRkcmVzcwIAAAACX18JAAGkAAAAAQUAAAADbnVtAQAAAB9rZXlNYXBwaW5nc0ludGVybmFsMmJhc2VBc3NldElkAAAAAQAAABFpbnRlcm5hbEJhc2VBc3NldAkAASwAAAACAgAAACglcyVzJWRfX21hcHBpbmdzX19pbnRlcm5hbDJiYXNlQXNzZXRJZF9fCQABpAAAAAEFAAAAEWludGVybmFsQmFzZUFzc2V0AQAAAB9rZXlNYXBwaW5nc0Jhc2VBc3NldDJpbnRlcm5hbElkAAAAAQAAAAxiYXNlQXNzZXRTdHIJAAEsAAAAAgIAAAAoJXMlcyVzX19tYXBwaW5nc19fYmFzZUFzc2V0MmludGVybmFsSWRfXwUAAAAMYmFzZUFzc2V0U3RyAQAAAA1rZXlQb29sQ29uZmlnAAAAAgAAABNhbW91bnRBc3NldEludGVybmFsAAAAEnByaWNlQXNzZXRJbnRlcm5hbAkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAAAglZCVkJXNfXwUAAAATYW1vdW50QXNzZXRJbnRlcm5hbAIAAAACX18FAAAAEnByaWNlQXNzZXRJbnRlcm5hbAIAAAAIX19jb25maWcBAAAAIWtleVBvb2xPbmVUb2tlbk9wZXJhdGlvbnNEaXNhYmxlZAAAAAEAAAAOYXNzZXRzSW50ZXJuYWwEAAAACyR0MDM2MzIzNjk0BQAAAA5hc3NldHNJbnRlcm5hbAQAAAATYW1vdW50QXNzZXRJbnRlcm5hbAgFAAAACyR0MDM2MzIzNjk0AAAAAl8xBAAAABJwcmljZUFzc2V0SW50ZXJuYWwIBQAAAAskdDAzNjMyMzY5NAAAAAJfMgkABLkAAAACCQAETAAAAAICAAAABiVkJWQlcwkABEwAAAACCQABpAAAAAEFAAAAE2Ftb3VudEFzc2V0SW50ZXJuYWwJAARMAAAAAgkAAaQAAAABBQAAABJwcmljZUFzc2V0SW50ZXJuYWwJAARMAAAAAgIAAAAab25lVG9rZW5PcGVyYXRpb25zRGlzYWJsZWQFAAAAA25pbAUAAAADU0VQAQAAACVrZXlBbGxQb29sc09uZVRva2VuT3BlcmF0aW9uc0Rpc2FibGVkAAAAAAkABLkAAAACCQAETAAAAAICAAAAAiVzCQAETAAAAAICAAAAGm9uZVRva2VuT3BlcmF0aW9uc0Rpc2FibGVkBQAAAANuaWwFAAAAA1NFUAEAAAAda2V5TWFwcGluZ0xwQXNzZXRUb1Bvb2xBc3NldHMAAAABAAAACmxwQXNzZXRTdHIJAAEsAAAAAgkAASwAAAACAgAAAAglcyVzJXNfXwUAAAAKbHBBc3NldFN0cgIAAAAYX19tYXBwaW5nc19fbHBBc3NldDJQb29sAQAAAB1rZXlNYXBwaW5nUG9vbEFzc2V0c1RvTHBhc3NldAAAAAIAAAAYaW50ZXJuYWxBbW91bnRBc3NldElkU3RyAAAAF2ludGVybmFsUHJpY2VBc3NldElkU3RyCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAACiVkJWQlcyVzX18FAAAAGGludGVybmFsQW1vdW50QXNzZXRJZFN0cgIAAAACX18FAAAAF2ludGVybmFsUHJpY2VBc3NldElkU3RyAgAAAB5fX21hcHBpbmdzX19Qb29sQXNzZXRzMkxwQXNzZXQBAAAADWtleVBvb2xTcHJlYWQAAAABAAAAC3Bvb2xBZGRyZXNzCQABLAAAAAICAAAADiVzJXNfX3NwcmVhZF9fBQAAAAtwb29sQWRkcmVzcwEAAAApa2V5TWFwcGluZ1Bvb2xDb250cmFjdEFkZHJlc3NUb1Bvb2xBc3NldHMAAAABAAAAE3Bvb2xDb250cmFjdEFkZHJlc3MJAAEsAAAAAgkAASwAAAACAgAAAAglcyVzJXNfXwUAAAATcG9vbENvbnRyYWN0QWRkcmVzcwIAAAAjX19tYXBwaW5nc19fcG9vbENvbnRyYWN0MlBvb2xBc3NldHMBAAAAKWtleU1hcHBpbmdQb29sQXNzZXRzVG9Qb29sQ29udHJhY3RBZGRyZXNzAAAAAgAAABhpbnRlcm5hbEFtb3VudEFzc2V0SWRTdHIAAAAXaW50ZXJuYWxQcmljZUFzc2V0SWRTdHIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAKJWQlZCVzJXNfXwkAAaQAAAABBQAAABhpbnRlcm5hbEFtb3VudEFzc2V0SWRTdHICAAAAAl9fCQABpAAAAAEFAAAAF2ludGVybmFsUHJpY2VBc3NldElkU3RyAgAAACNfX21hcHBpbmdzX19wb29sQXNzZXRzMlBvb2xDb250cmFjdAEAAAAfa2V5TWFwcGluZ1Bvb2xDb250cmFjdFRvTFBBc3NldAAAAAEAAAATcG9vbENvbnRyYWN0QWRkcmVzcwkAASwAAAACCQABLAAAAAICAAAACCVzJXMlc19fBQAAABNwb29sQ29udHJhY3RBZGRyZXNzAgAAACBfX21hcHBpbmdzX19wb29sQ29udHJhY3QyTHBBc3NldAEAAAAqa2V5TWFwcGluZ1Bvb2xMUEFzc2V0VG9Qb29sQ29udHJhY3RBZGRyZXNzAAAAAQAAAApscEFzc2V0U3RyCQABLAAAAAIJAAEsAAAAAgIAAAAIJXMlcyVzX18FAAAACmxwQXNzZXRTdHICAAAAIF9fbWFwcGluZ3NfX2xwQXNzZXQyUG9vbENvbnRyYWN0AQAAAA1rZXlXeEVtaXNzaW9uAAAAAgAAAA1hbW91bnRBc3NldElkAAAADHByaWNlQXNzZXRJZAkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAUJXMlcyVzX193eEVtaXNzaW9uX18FAAAADWFtb3VudEFzc2V0SWQCAAAAAl9fBQAAAAxwcmljZUFzc2V0SWQBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEAAAADa2V5CQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQdAAAAAgUAAAAEdGhpcwUAAAADa2V5CQABLAAAAAICAAAAFU5vIGRhdGEgZm9yIHRoaXMua2V5PQUAAAADa2V5AQAAABBnZXRCb29sZWFuT3JGYWlsAAAAAQAAAANrZXkJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABBsAAAACBQAAAAR0aGlzBQAAAANrZXkJAAEsAAAAAgIAAAAVTm8gZGF0YSBmb3IgdGhpcy5rZXk9BQAAAANrZXkBAAAADGdldEludE9yRmFpbAAAAAEAAAADa2V5CQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwUAAAADa2V5CQABLAAAAAICAAAAFU5vIGRhdGEgZm9yIHRoaXMua2V5PQUAAAADa2V5AAAAABhJZHhGYWN0b3J5Q2ZnU3Rha2luZ0RhcHAAAAAAAAAAAAEAAAAAGUlkeEZhY3RvcnlDZmdCb29zdGluZ0RhcHAAAAAAAAAAAAIAAAAAFElkeEZhY3RvcnlDZmdJZG9EYXBwAAAAAAAAAAADAAAAABVJZHhGYWN0b3J5Q2ZnVGVhbURhcHAAAAAAAAAAAAQAAAAAGUlkeEZhY3RvcnlDZmdFbWlzc2lvbkRhcHAAAAAAAAAAAAUAAAAAFUlkeEZhY3RvcnlDZmdSZXN0RGFwcAAAAAAAAAAABgAAAAAZSWR4RmFjdG9yeUNmZ1NsaXBwYWdlRGFwcAAAAAAAAAAABwAAAAAUSWR4RmFjdG9yeUNmZ0Rhb0RhcHAAAAAAAAAAAAgAAAAAGklkeEZhY3RvcnlDZmdNYXJrZXRpbmdEYXBwAAAAAAAAAAAJAAAAABpJZHhGYWN0b3J5Q2ZnR3d4UmV3YXJkRGFwcAAAAAAAAAAACgAAAAAWSWR4RmFjdG9yeUNmZ0JpcmRzRGFwcAAAAAAAAAAACwEAAAAYZ2V0Qm9vc3RpbmdBZGRyZXNzT3JGYWlsAAAAAQAAAApmYWN0b3J5Q2ZnCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABCQABkQAAAAIFAAAACmZhY3RvcnlDZmcFAAAAGUlkeEZhY3RvcnlDZmdCb29zdGluZ0RhcHABAAAAGGdldEVtaXNzaW9uQWRkcmVzc09yRmFpbAAAAAEAAAAKZmFjdG9yeUNmZwkBAAAAEUBleHRyTmF0aXZlKDEwNjIpAAAAAQkAAZEAAAACBQAAAApmYWN0b3J5Q2ZnBQAAABlJZHhGYWN0b3J5Q2ZnRW1pc3Npb25EYXBwAQAAABdnZXRTdGFraW5nQWRkcmVzc09yRmFpbAAAAAEAAAAKZmFjdG9yeUNmZwkBAAAAEUBleHRyTmF0aXZlKDEwNjIpAAAAAQkAAZEAAAACBQAAAApmYWN0b3J5Q2ZnBQAAABhJZHhGYWN0b3J5Q2ZnU3Rha2luZ0RhcHABAAAAGWdldEd3eFJld2FyZEFkZHJlc3NPckZhaWwAAAABAAAACmZhY3RvcnlDZmcJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEJAAGRAAAAAgUAAAAKZmFjdG9yeUNmZwUAAAAaSWR4RmFjdG9yeUNmZ0d3eFJld2FyZERhcHABAAAADmdldFByaWNlQXNzZXRzAAAAAAQAAAAHJG1hdGNoMAkABCIAAAABCQEAAAAOa2V5UHJpY2VBc3NldHMAAAAAAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAZTdHJpbmcEAAAAAXMFAAAAByRtYXRjaDADCQAAAAAAAAIJAAExAAAAAQUAAAABcwAAAAAAAAAAAAUAAAADbmlsCQAEtQAAAAIFAAAAAXMFAAAAA1NFUAUAAAADbmlsAQAAABZtYW5hZ2VyUHVibGljS2V5T3JVbml0AAAAAAQAAAAHJG1hdGNoMAkABCIAAAABCQEAAAATa2V5TWFuYWdlclB1YmxpY0tleQAAAAADCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABlN0cmluZwQAAAABcwUAAAAHJG1hdGNoMAkAAlkAAAABBQAAAAFzAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAARVbml0BQAAAAR1bml0CQAAAgAAAAECAAAAC01hdGNoIGVycm9yAQAAAB1wZW5kaW5nTWFuYWdlclB1YmxpY0tleU9yVW5pdAAAAAAEAAAAByRtYXRjaDAJAAQiAAAAAQkBAAAAGmtleVBlbmRpbmdNYW5hZ2VyUHVibGljS2V5AAAAAAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAGU3RyaW5nBAAAAAFzBQAAAAckbWF0Y2gwCQACWQAAAAEFAAAAAXMDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABFVuaXQFAAAABHVuaXQJAAACAAAAAQIAAAALTWF0Y2ggZXJyb3IAAAAAFXBlcm1pc3Npb25EZW5pZWRFcnJvcgkAAAIAAAABAgAAABFQZXJtaXNzaW9uIGRlbmllZAEAAAAIbXVzdFRoaXMAAAABAAAAAWkDCQAAAAAAAAIIBQAAAAFpAAAABmNhbGxlcgUAAAAEdGhpcwYFAAAAFXBlcm1pc3Npb25EZW5pZWRFcnJvcgEAAAALbXVzdE1hbmFnZXIAAAABAAAAAWkEAAAAByRtYXRjaDAJAQAAABZtYW5hZ2VyUHVibGljS2V5T3JVbml0AAAAAAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAKQnl0ZVZlY3RvcgQAAAACcGsFAAAAByRtYXRjaDADCQAAAAAAAAIIBQAAAAFpAAAAD2NhbGxlclB1YmxpY0tleQUAAAACcGsGBQAAABVwZXJtaXNzaW9uRGVuaWVkRXJyb3IDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABFVuaXQJAQAAAAhtdXN0VGhpcwAAAAEFAAAAAWkJAAACAAAAAQIAAAALTWF0Y2ggZXJyb3IBAAAAEGRhdGFGYWN0b3J5Q2ZnVjMAAAALAAAADnN0YWtpbmdBZGRyZXNzAAAAD2Jvb3N0aW5nQWRkcmVzcwAAAAtpZG9Db250cmFjdAAAAAx0ZWFtQ29udHJhY3QAAAAQZW1pc3Npb25Db250cmFjdAAAAAxyZXN0Q29udHJhY3QAAAAQc2xpcHBhZ2VDb250cmFjdAAAAAtkYW9Db250cmFjdAAAABFtYXJrZXRpbmdDb250cmFjdAAAABJnd3hSZXdhcmRzQ29udHJhY3QAAAANYmlyZHNDb250cmFjdAkABLkAAAACCQAETAAAAAICAAAAFiVzJXMlcyVzJXMlcyVzJXMlcyVzJXMJAARMAAAAAgUAAAAOc3Rha2luZ0FkZHJlc3MJAARMAAAAAgUAAAAPYm9vc3RpbmdBZGRyZXNzCQAETAAAAAIFAAAAC2lkb0NvbnRyYWN0CQAETAAAAAIFAAAADHRlYW1Db250cmFjdAkABEwAAAACBQAAABBlbWlzc2lvbkNvbnRyYWN0CQAETAAAAAIFAAAADHJlc3RDb250cmFjdAkABEwAAAACBQAAABBzbGlwcGFnZUNvbnRyYWN0CQAETAAAAAIFAAAAC2Rhb0NvbnRyYWN0CQAETAAAAAIFAAAAEW1hcmtldGluZ0NvbnRyYWN0CQAETAAAAAIFAAAAEmd3eFJld2FyZHNDb250cmFjdAkABEwAAAACBQAAAA1iaXJkc0NvbnRyYWN0BQAAAANuaWwFAAAAA1NFUAEAAAAOZGF0YUZhY3RvcnlDZmcAAAAHAAAADnN0YWtpbmdBZGRyZXNzAAAAD2Jvb3N0aW5nQWRkcmVzcwAAAAtpZG9Db250cmFjdAAAAAx0ZWFtQ29udHJhY3QAAAAQZW1pc3Npb25Db250cmFjdAAAAAxyZXN0Q29udHJhY3QAAAAQc2xpcHBhZ2VDb250cmFjdAkABLkAAAACCQAETAAAAAICAAAADCVzJXMlcyVzJXMlcwkABEwAAAACBQAAAA5zdGFraW5nQWRkcmVzcwkABEwAAAACBQAAAA9ib29zdGluZ0FkZHJlc3MJAARMAAAAAgUAAAALaWRvQ29udHJhY3QJAARMAAAAAgUAAAAMdGVhbUNvbnRyYWN0CQAETAAAAAIFAAAAEGVtaXNzaW9uQ29udHJhY3QJAARMAAAAAgUAAAAMcmVzdENvbnRyYWN0CQAETAAAAAIFAAAAEHNsaXBwYWdlQ29udHJhY3QFAAAAA25pbAUAAAADU0VQAQAAAAtkYXRhUG9vbENmZwAAAAsAAAALcG9vbEFkZHJlc3MAAAAKcG9vbFN0YXR1cwAAAAlscEFzc2V0SWQAAAAOYW1vdW50QXNzZXRTdHIAAAANcHJpY2VBc3NldFN0cgAAABNhbW91bnRBc3NldERlY2ltYWxzAAAAEnByaWNlQXNzZXREZWNpbWFscwAAABVhbW91bnRBc3NldEludGVybmFsSWQAAAAUcHJpY2VBc3NldEludGVybmFsSWQAAAAPbHBBc3NldERlY2ltYWxzAAAACHBvb2xUeXBlCQAEuQAAAAIJAARMAAAAAgIAAAAWJXMlZCVzJXMlcyVkJWQlZCVkJWQlcwkABEwAAAACBQAAAAtwb29sQWRkcmVzcwkABEwAAAACBQAAAApwb29sU3RhdHVzCQAETAAAAAIFAAAACWxwQXNzZXRJZAkABEwAAAACBQAAAA5hbW91bnRBc3NldFN0cgkABEwAAAACBQAAAA1wcmljZUFzc2V0U3RyCQAETAAAAAIJAAGkAAAAAQUAAAATYW1vdW50QXNzZXREZWNpbWFscwkABEwAAAACCQABpAAAAAEFAAAAEnByaWNlQXNzZXREZWNpbWFscwkABEwAAAACCQABpAAAAAEFAAAAFWFtb3VudEFzc2V0SW50ZXJuYWxJZAkABEwAAAACCQABpAAAAAEFAAAAFHByaWNlQXNzZXRJbnRlcm5hbElkCQAETAAAAAIJAAGkAAAAAQUAAAAPbHBBc3NldERlY2ltYWxzCQAETAAAAAIFAAAACHBvb2xUeXBlBQAAAANuaWwFAAAAA1NFUAEAAAAVZGF0YU1hcHBpbmdQb29sQXNzZXRzAAAAAgAAABZpbnRlcm5hbEFtb3VudEFzc2V0U3RyAAAAFWludGVybmFsUHJpY2VBc3NldFN0cgkABLkAAAACCQAETAAAAAICAAAABCVkJWQJAARMAAAAAgkAAaQAAAABBQAAABZpbnRlcm5hbEFtb3VudEFzc2V0U3RyCQAETAAAAAIJAAGkAAAAAQUAAAAVaW50ZXJuYWxQcmljZUFzc2V0U3RyBQAAAANuaWwFAAAAA1NFUAEAAAANZ2V0UG9vbENvbmZpZwAAAAEAAAALcG9vbEFkZHJlc3MEAAAACnBvb2xBc3NldHMJAAS1AAAAAgkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEJAQAAAClrZXlNYXBwaW5nUG9vbENvbnRyYWN0QWRkcmVzc1RvUG9vbEFzc2V0cwAAAAEFAAAAC3Bvb2xBZGRyZXNzBQAAAANTRVAEAAAAE2Ftb3VudEFzc2V0SW50ZXJuYWwJAAGRAAAAAgUAAAAKcG9vbEFzc2V0cwAAAAAAAAAAAQQAAAAScHJpY2VBc3NldEludGVybmFsCQABkQAAAAIFAAAACnBvb2xBc3NldHMAAAAAAAAAAAIJAAS1AAAAAgkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEJAQAAAA1rZXlQb29sQ29uZmlnAAAAAgUAAAATYW1vdW50QXNzZXRJbnRlcm5hbAUAAAAScHJpY2VBc3NldEludGVybmFsBQAAAANTRVABAAAAGmdldEludGVybmFsQXNzZXRJZE9yQ3JlYXRlAAAAAgAAAAphc3NldElkU3RyAAAAC2luY3JlbWVudG9yBAAAAA9pbnRlcm5hbEFzc2V0SWQJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwkBAAAAH2tleU1hcHBpbmdzQmFzZUFzc2V0MmludGVybmFsSWQAAAABBQAAAAphc3NldElkU3RyAAAAAAAAAAAABAAAABhjdXJyZW50SW5kZXhPZkludGVybmFsSWQJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwkBAAAAFmtleU5leHRJbnRlcm5hbEFzc2V0SWQAAAAAAAAAAAAAAAAABAAAAAZyZXN1bHQDCQAAAAAAAAIFAAAAD2ludGVybmFsQXNzZXRJZAAAAAAAAAAAAAQAAAASbmV3SW50ZXJuYWxBc3NldElkCQAAZAAAAAIFAAAAGGN1cnJlbnRJbmRleE9mSW50ZXJuYWxJZAUAAAALaW5jcmVtZW50b3IJAAUVAAAAAwUAAAASbmV3SW50ZXJuYWxBc3NldElkCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAWa2V5TmV4dEludGVybmFsQXNzZXRJZAAAAAAFAAAAEm5ld0ludGVybmFsQXNzZXRJZAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAH2tleU1hcHBpbmdzQmFzZUFzc2V0MmludGVybmFsSWQAAAABBQAAAAphc3NldElkU3RyBQAAABJuZXdJbnRlcm5hbEFzc2V0SWQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAH2tleU1hcHBpbmdzSW50ZXJuYWwyYmFzZUFzc2V0SWQAAAABBQAAABJuZXdJbnRlcm5hbEFzc2V0SWQFAAAACmFzc2V0SWRTdHIFAAAAA25pbAYJAAUVAAAAAwUAAAAPaW50ZXJuYWxBc3NldElkBQAAAANuaWwHBQAAAAZyZXN1bHQBAAAACW11c3RBZG1pbgAAAAEAAAABaQQAAAAIYWRtaW5QS3MJAAS1AAAAAgkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABCIAAAABCQEAAAAPa2V5QWRtaW5QdWJLZXlzAAAAAAUAAAAFRU1QVFkFAAAAA1NFUAMJAQAAAA9jb250YWluc0VsZW1lbnQAAAACBQAAAAhhZG1pblBLcwkAAlgAAAABCAUAAAABaQAAAA9jYWxsZXJQdWJsaWNLZXkGBAAAAAlpc01hbmFnZXIJAQAAAAttdXN0TWFuYWdlcgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAACWlzTWFuYWdlcgUAAAAJaXNNYW5hZ2VyBgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAAUAAAAAWkBAAAAC2NvbnN0cnVjdG9yAAAACAAAAA9zdGFraW5nQ29udHJhY3QAAAAQYm9vc3RpbmdDb250cmFjdAAAAAtpZG9Db250cmFjdAAAAAx0ZWFtQ29udHJhY3QAAAAQZW1pc3Npb25Db250cmFjdAAAAAxyZXN0Q29udHJhY3QAAAAQc2xwaXBhZ2VDb250cmFjdAAAAA1wcmljZURlY2ltYWxzBAAAAAtjaGVja0NhbGxlcgkBAAAAC211c3RNYW5hZ2VyAAAAAQUAAAABaQMJAAAAAAAAAgUAAAALY2hlY2tDYWxsZXIFAAAAC2NoZWNrQ2FsbGVyCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABBrZXlGYWN0b3J5Q29uZmlnAAAAAAkBAAAADmRhdGFGYWN0b3J5Q2ZnAAAABwUAAAAPc3Rha2luZ0NvbnRyYWN0BQAAABBib29zdGluZ0NvbnRyYWN0BQAAAAtpZG9Db250cmFjdAUAAAAMdGVhbUNvbnRyYWN0BQAAABBlbWlzc2lvbkNvbnRyYWN0BQAAAAxyZXN0Q29udHJhY3QFAAAAEHNscGlwYWdlQ29udHJhY3QJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAABBrZXlQcmljZURlY2ltYWxzAAAAAAUAAAANcHJpY2VEZWNpbWFscwUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAA1jb25zdHJ1Y3RvclYyAAAAAQAAABBtYXRoY2hlclB1YjU4U3RyBAAAAAtjaGVja0NhbGxlcgkBAAAAC211c3RNYW5hZ2VyAAAAAQUAAAABaQMJAAAAAAAAAgUAAAALY2hlY2tDYWxsZXIFAAAAC2NoZWNrQ2FsbGVyBAAAAAptYXRoY2VyUHViCQEAAAAUYWRkcmVzc0Zyb21QdWJsaWNLZXkAAAABCQACWQAAAAEFAAAAEG1hdGhjaGVyUHViNThTdHIDCQAAAAAAAAIFAAAACm1hdGhjZXJQdWIFAAAACm1hdGhjZXJQdWIJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAADWtleU1hdGNoZXJQdWIAAAAABQAAABBtYXRoY2hlclB1YjU4U3RyBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAA1jb25zdHJ1Y3RvclYzAAAABAAAAAtkYW9Db250cmFjdAAAABFtYXJrZXRpbmdDb250cmFjdAAAABJnd3hSZXdhcmRzQ29udHJhY3QAAAANYmlyZHNDb250cmFjdAQAAAALY2hlY2tDYWxsZXIJAQAAAAttdXN0TWFuYWdlcgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgQAAAAKZmFjdG9yeUNmZwkABLUAAAACCQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQkBAAAAEGtleUZhY3RvcnlDb25maWcAAAAABQAAAANTRVAJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAEGtleUZhY3RvcnlDb25maWcAAAAACQEAAAAQZGF0YUZhY3RvcnlDZmdWMwAAAAsJAAGRAAAAAgUAAAAKZmFjdG9yeUNmZwAAAAAAAAAAAQkAAZEAAAACBQAAAApmYWN0b3J5Q2ZnAAAAAAAAAAACCQABkQAAAAIFAAAACmZhY3RvcnlDZmcAAAAAAAAAAAMJAAGRAAAAAgUAAAAKZmFjdG9yeUNmZwAAAAAAAAAABAkAAZEAAAACBQAAAApmYWN0b3J5Q2ZnAAAAAAAAAAAFCQABkQAAAAIFAAAACmZhY3RvcnlDZmcAAAAAAAAAAAYJAAGRAAAAAgUAAAAKZmFjdG9yeUNmZwAAAAAAAAAABwUAAAALZGFvQ29udHJhY3QFAAAAEW1hcmtldGluZ0NvbnRyYWN0BQAAABJnd3hSZXdhcmRzQ29udHJhY3QFAAAADWJpcmRzQ29udHJhY3QFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAANY29uc3RydWN0b3JWNAAAAAIAAAAVbGVnYWN5RmFjdG9yeUNvbnRyYWN0AAAAC2xlZ2FjeVBvb2xzBAAAAAtjaGVja0NhbGxlcgkBAAAAC211c3RNYW5hZ2VyAAAAAQUAAAABaQMJAAAAAAAAAgUAAAALY2hlY2tDYWxsZXIFAAAAC2NoZWNrQ2FsbGVyCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABhrZXlMZWdhY3lGYWN0b3J5Q29udHJhY3QAAAAABQAAABVsZWdhY3lGYWN0b3J5Q29udHJhY3QJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAADmtleUxlZ2FjeVBvb2xzAAAAAAkABLkAAAACBQAAAAtsZWdhY3lQb29scwUAAAADU0VQBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAADWNvbnN0cnVjdG9yVjUAAAABAAAAE2Fzc2V0c1N0b3JlQ29udHJhY3QEAAAAC2NoZWNrQ2FsbGVyCQEAAAALbXVzdE1hbmFnZXIAAAABBQAAAAFpAwkAAAAAAAACBQAAAAtjaGVja0NhbGxlcgUAAAALY2hlY2tDYWxsZXIJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAFmtleUFzc2V0c1N0b3JlQ29udHJhY3QAAAAABQAAABNhc3NldHNTdG9yZUNvbnRyYWN0BQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAADWNvbnN0cnVjdG9yVjYAAAACAAAAFnZvdGluZ0VtaXNzaW9uQ29udHJhY3QAAAALcHJpY2VBc3NldHMEAAAABWNoZWtzCQAETAAAAAIJAQAAAAttdXN0TWFuYWdlcgAAAAEFAAAAAWkJAARMAAAAAgMJAQAAAAIhPQAAAAIJAAQmAAAAAQUAAAAWdm90aW5nRW1pc3Npb25Db250cmFjdAUAAAAEdW5pdAYCAAAAKGludmFsaWQgdm90aW5nIGVtaXNzaW9uIGNvbnRyYWN0IGFkZHJlc3MFAAAAA25pbAMJAAAAAAAAAgUAAAAFY2hla3MFAAAABWNoZWtzCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABlrZXlWb3RpbmdFbWlzc2lvbkNvbnRyYWN0AAAAAAUAAAAWdm90aW5nRW1pc3Npb25Db250cmFjdAkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAOa2V5UHJpY2VBc3NldHMAAAAACQAEuQAAAAIFAAAAC3ByaWNlQXNzZXRzBQAAAANTRVAFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAKc2V0TWFuYWdlcgAAAAEAAAAXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkEAAAAC2NoZWNrQ2FsbGVyCQEAAAALbXVzdE1hbmFnZXIAAAABBQAAAAFpAwkAAAAAAAACBQAAAAtjaGVja0NhbGxlcgUAAAALY2hlY2tDYWxsZXIEAAAAFWNoZWNrTWFuYWdlclB1YmxpY0tleQkAAlkAAAABBQAAABdwZW5kaW5nTWFuYWdlclB1YmxpY0tleQMJAAAAAAAAAgUAAAAVY2hlY2tNYW5hZ2VyUHVibGljS2V5BQAAABVjaGVja01hbmFnZXJQdWJsaWNLZXkJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAGmtleVBlbmRpbmdNYW5hZ2VyUHVibGljS2V5AAAAAAUAAAAXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAADmNvbmZpcm1NYW5hZ2VyAAAAAAQAAAACcG0JAQAAAB1wZW5kaW5nTWFuYWdlclB1YmxpY0tleU9yVW5pdAAAAAAEAAAABWhhc1BNAwkBAAAACWlzRGVmaW5lZAAAAAEFAAAAAnBtBgkAAAIAAAABAgAAABJObyBwZW5kaW5nIG1hbmFnZXIDCQAAAAAAAAIFAAAABWhhc1BNBQAAAAVoYXNQTQQAAAAHY2hlY2tQTQMJAAAAAAAAAggFAAAAAWkAAAAPY2FsbGVyUHVibGljS2V5CQEAAAAFdmFsdWUAAAABBQAAAAJwbQYJAAACAAAAAQIAAAAbWW91IGFyZSBub3QgcGVuZGluZyBtYW5hZ2VyAwkAAAAAAAACBQAAAAdjaGVja1BNBQAAAAdjaGVja1BNCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABNrZXlNYW5hZ2VyUHVibGljS2V5AAAAAAkAAlgAAAABCQEAAAAFdmFsdWUAAAABBQAAAAJwbQkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABCQEAAAAaa2V5UGVuZGluZ01hbmFnZXJQdWJsaWNLZXkAAAAABQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAAlzZXRBZG1pbnMAAAABAAAADGFkbWluUHViS2V5cwQAAAALY2hlY2tDYWxsZXIJAQAAAAttdXN0TWFuYWdlcgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAPa2V5QWRtaW5QdWJLZXlzAAAAAAkABLkAAAACBQAAAAxhZG1pblB1YktleXMFAAAAA1NFUAUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAA9hY3RpdmF0ZU5ld1Bvb2wAAAAIAAAAC3Bvb2xBZGRyZXNzAAAADmFtb3VudEFzc2V0U3RyAAAADXByaWNlQXNzZXRTdHIAAAALbHBBc3NldE5hbWUAAAAMbHBBc3NldERlc2NyAAAACnBvb2xXZWlnaHQAAAAIcG9vbFR5cGUAAAAEbG9nbwQAAAALY2hlY2tDYWxsZXIJAQAAAAltdXN0QWRtaW4AAAABBQAAAAFpAwkAAAAAAAACBQAAAAtjaGVja0NhbGxlcgUAAAALY2hlY2tDYWxsZXIDCQEAAAAJaXNEZWZpbmVkAAAAAQkABCIAAAABCQEAAAApa2V5TWFwcGluZ1Bvb2xDb250cmFjdEFkZHJlc3NUb1Bvb2xBc3NldHMAAAABBQAAAAtwb29sQWRkcmVzcwkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgIAAAANUG9vbCBhZGRyZXNzIAUAAAALcG9vbEFkZHJlc3MCAAAAFCBhbHJlYWR5IHJlZ2lzdGVyZWQuBAAAABdpbnRlcm5hbEFtb3VudEFzc2V0RGF0YQkBAAAAGmdldEludGVybmFsQXNzZXRJZE9yQ3JlYXRlAAAAAgUAAAAOYW1vdW50QXNzZXRTdHIAAAAAAAAAAAEEAAAAFWludGVybmFsQW1vdW50QXNzZXRJZAgFAAAAF2ludGVybmFsQW1vdW50QXNzZXREYXRhAAAAAl8xBAAAABZpbnRlcm5hbFByaWNlQXNzZXREYXRhCQEAAAAaZ2V0SW50ZXJuYWxBc3NldElkT3JDcmVhdGUAAAACBQAAAA1wcmljZUFzc2V0U3RyAwgFAAAAF2ludGVybmFsQW1vdW50QXNzZXREYXRhAAAAAl8zAAAAAAAAAAACAAAAAAAAAAABBAAAABRpbnRlcm5hbFByaWNlQXNzZXRJZAgFAAAAFmludGVybmFsUHJpY2VBc3NldERhdGEAAAACXzEEAAAAFXBvb2xBY2NvdW50U2NyaXB0SGFzaAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAD8QAAAAEJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEFAAAAC3Bvb2xBZGRyZXNzCQABLAAAAAICAAAAKU5vIHNjcmlwdCBoYXMgYmVlbiBmb3VuZCBvbiBwb29sIGFjY291bnQgBQAAAAtwb29sQWRkcmVzcwQAAAAcZXRoYWxvblBvb2xBY2NvdW50U2NyaXB0SGFzaAkBAAAAEUBleHRyTmF0aXZlKDEwNTcpAAAAAQkBAAAAEWtleVBvb2xTY3JpcHRIYXNoAAAAAAQAAAAKcG9vbENvbmZpZwkABB0AAAACBQAAAAR0aGlzCQEAAAANa2V5UG9vbENvbmZpZwAAAAIJAAGkAAAAAQUAAAAVaW50ZXJuYWxBbW91bnRBc3NldElkCQABpAAAAAEFAAAAFGludGVybmFsUHJpY2VBc3NldElkAwkBAAAACWlzRGVmaW5lZAAAAAEFAAAACnBvb2xDb25maWcJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAAAVQb29sIAUAAAAOYW1vdW50QXNzZXRTdHICAAAAAS8FAAAADXByaWNlQXNzZXRTdHICAAAAHCBoYXMgYWxyZWFkeSBiZWVuIGFjdGl2YXRlZC4EAAAAD3Bvb2xDb25maWdWYWx1ZQkBAAAABXZhbHVlAAAAAQkABB0AAAACBQAAAAR0aGlzCQEAAAANa2V5UG9vbENvbmZpZwAAAAIJAAGkAAAAAQUAAAAVaW50ZXJuYWxBbW91bnRBc3NldElkCQABpAAAAAEFAAAAFGludGVybmFsUHJpY2VBc3NldElkBAAAABRhbW91bnRBc3NldHNEZWNpbWFscwMJAAAAAAAAAgUAAAAOYW1vdW50QXNzZXRTdHICAAAABVdBVkVTBQAAABFkZWNpbWFsc011bHRQcmljZQkAAGwAAAAGAAAAAAAAAAAKAAAAAAAAAAAACAkBAAAABXZhbHVlAAAAAQkAA+wAAAABCQACWQAAAAEFAAAADmFtb3VudEFzc2V0U3RyAAAACGRlY2ltYWxzAAAAAAAAAAAAAAAAAAAAAAAABQAAAARET1dOBAAAABNwcmljZUFzc2V0c0RlY2ltYWxzAwkAAAAAAAACBQAAAA1wcmljZUFzc2V0U3RyAgAAAAVXQVZFUwUAAAARZGVjaW1hbHNNdWx0UHJpY2UJAABsAAAABgAAAAAAAAAACgAAAAAAAAAAAAgJAQAAAAV2YWx1ZQAAAAEJAAPsAAAAAQkAAlkAAAABBQAAAA1wcmljZUFzc2V0U3RyAAAACGRlY2ltYWxzAAAAAAAAAAAAAAAAAAAAAAAABQAAAARET1dOBAAAABJscEFzc2V0SXNzdWVBY3Rpb24JAARCAAAABQUAAAALbHBBc3NldE5hbWUFAAAADGxwQXNzZXREZXNjcgAAAAAAAAAAAQAAAAAAAAAACAYEAAAACWxwQXNzZXRJZAkABDgAAAABBQAAABJscEFzc2V0SXNzdWVBY3Rpb24EAAAADGxwQXNzZXRJZFN0cgkAAlgAAAABBQAAAAlscEFzc2V0SWQEAAAAGHBvb2xBY3RpdmF0ZUludm9rZVJlc3VsdAkAA/wAAAAECQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABBQAAAAtwb29sQWRkcmVzcwIAAAAIYWN0aXZhdGUJAARMAAAAAgUAAAAOYW1vdW50QXNzZXRTdHIJAARMAAAAAgUAAAANcHJpY2VBc3NldFN0cgUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAGHBvb2xBY3RpdmF0ZUludm9rZVJlc3VsdAUAAAAYcG9vbEFjdGl2YXRlSW52b2tlUmVzdWx0AwkBAAAAAiE9AAAAAgUAAAAYcG9vbEFjdGl2YXRlSW52b2tlUmVzdWx0AgAAAAdzdWNjZXNzCQAAAgAAAAECAAAAI1Bvb2wgaW5pdGlhbGlzYXRpb24gZXJyb3IgaGFwcGVuZWQuBAAAABNhc3NldHNTdG9yZUNvbnRyYWN0CQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABCQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQkBAAAAFmtleUFzc2V0c1N0b3JlQ29udHJhY3QAAAAABAAAABhjcmVhdGVPclVwZGF0ZUxwQXNzZXRJbnYJAAP8AAAABAUAAAATYXNzZXRzU3RvcmVDb250cmFjdAIAAAAOY3JlYXRlT3JVcGRhdGUJAARMAAAAAgUAAAAMbHBBc3NldElkU3RyCQAETAAAAAIFAAAAC2xwQXNzZXROYW1lCQAETAAAAAIHBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAAYY3JlYXRlT3JVcGRhdGVMcEFzc2V0SW52BQAAABhjcmVhdGVPclVwZGF0ZUxwQXNzZXRJbnYEAAAAEmFkZFBvb2xzTHBMYWJlbEludgkAA/wAAAAEBQAAABNhc3NldHNTdG9yZUNvbnRyYWN0AgAAAAhhZGRMYWJlbAkABEwAAAACBQAAAAxscEFzc2V0SWRTdHIJAARMAAAAAgUAAAAMbGFiZWxQb29sc0xwBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAASYWRkUG9vbHNMcExhYmVsSW52BQAAABJhZGRQb29sc0xwTGFiZWxJbnYEAAAACnNldExvZ29JbnYJAAP8AAAABAUAAAATYXNzZXRzU3RvcmVDb250cmFjdAIAAAAHc2V0TG9nbwkABEwAAAACBQAAAAxscEFzc2V0SWRTdHIJAARMAAAAAgUAAAAEbG9nbwUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAACnNldExvZ29JbnYFAAAACnNldExvZ29JbnYEAAAAEGFkZEFzc2V0c0xpbmtJbnYJAAP8AAAABAUAAAATYXNzZXRzU3RvcmVDb250cmFjdAIAAAANYWRkQXNzZXRzTGluawkABEwAAAACBQAAAA5hbW91bnRBc3NldFN0cgkABEwAAAACBQAAAA1wcmljZUFzc2V0U3RyCQAETAAAAAIFAAAADGxwQXNzZXRJZFN0cgUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAEGFkZEFzc2V0c0xpbmtJbnYFAAAAEGFkZEFzc2V0c0xpbmtJbnYEAAAAG2luY3JlYXNlQXNzZXRQb29sc051bWJlckludgkAA/wAAAAEBQAAABNhc3NldHNTdG9yZUNvbnRyYWN0AgAAABhpbmNyZWFzZUFzc2V0UG9vbHNOdW1iZXIJAARMAAAAAgUAAAAOYW1vdW50QXNzZXRTdHIFAAAAA25pbAUAAAADbmlsAwkAAAAAAAACBQAAABtpbmNyZWFzZUFzc2V0UG9vbHNOdW1iZXJJbnYFAAAAG2luY3JlYXNlQXNzZXRQb29sc051bWJlckludgkABRQAAAACCQAETgAAAAIJAAROAAAAAggFAAAAF2ludGVybmFsQW1vdW50QXNzZXREYXRhAAAAAl8yCAUAAAAWaW50ZXJuYWxQcmljZUFzc2V0RGF0YQAAAAJfMgkABEwAAAACBQAAABJscEFzc2V0SXNzdWVBY3Rpb24JAARMAAAAAgkBAAAABEJ1cm4AAAACBQAAAAlscEFzc2V0SWQAAAAAAAAAAAEJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAADWtleVBvb2xDb25maWcAAAACCQABpAAAAAEFAAAAFWludGVybmFsQW1vdW50QXNzZXRJZAkAAaQAAAABBQAAABRpbnRlcm5hbFByaWNlQXNzZXRJZAkBAAAAC2RhdGFQb29sQ2ZnAAAACwUAAAALcG9vbEFkZHJlc3MJAAGkAAAAAQUAAAAKUG9vbEFjdGl2ZQUAAAAMbHBBc3NldElkU3RyBQAAAA5hbW91bnRBc3NldFN0cgUAAAANcHJpY2VBc3NldFN0cgUAAAAUYW1vdW50QXNzZXRzRGVjaW1hbHMFAAAAE3ByaWNlQXNzZXRzRGVjaW1hbHMFAAAAFWludGVybmFsQW1vdW50QXNzZXRJZAUAAAAUaW50ZXJuYWxQcmljZUFzc2V0SWQFAAAAEWRlY2ltYWxzTXVsdFByaWNlBQAAAAhwb29sVHlwZQkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAda2V5TWFwcGluZ0xwQXNzZXRUb1Bvb2xBc3NldHMAAAABBQAAAAxscEFzc2V0SWRTdHIJAQAAABVkYXRhTWFwcGluZ1Bvb2xBc3NldHMAAAACBQAAABVpbnRlcm5hbEFtb3VudEFzc2V0SWQFAAAAFGludGVybmFsUHJpY2VBc3NldElkCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAB1rZXlNYXBwaW5nUG9vbEFzc2V0c1RvTHBhc3NldAAAAAIJAAGkAAAAAQUAAAAVaW50ZXJuYWxBbW91bnRBc3NldElkCQABpAAAAAEFAAAAFGludGVybmFsUHJpY2VBc3NldElkCQABLAAAAAICAAAABCVzX18FAAAADGxwQXNzZXRJZFN0cgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAApa2V5TWFwcGluZ1Bvb2xDb250cmFjdEFkZHJlc3NUb1Bvb2xBc3NldHMAAAABBQAAAAtwb29sQWRkcmVzcwkBAAAAFWRhdGFNYXBwaW5nUG9vbEFzc2V0cwAAAAIFAAAAFWludGVybmFsQW1vdW50QXNzZXRJZAUAAAAUaW50ZXJuYWxQcmljZUFzc2V0SWQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAKWtleU1hcHBpbmdQb29sQXNzZXRzVG9Qb29sQ29udHJhY3RBZGRyZXNzAAAAAgUAAAAVaW50ZXJuYWxBbW91bnRBc3NldElkBQAAABRpbnRlcm5hbFByaWNlQXNzZXRJZAUAAAALcG9vbEFkZHJlc3MJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAKmtleU1hcHBpbmdQb29sTFBBc3NldFRvUG9vbENvbnRyYWN0QWRkcmVzcwAAAAEFAAAADGxwQXNzZXRJZFN0cgUAAAALcG9vbEFkZHJlc3MJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAH2tleU1hcHBpbmdQb29sQ29udHJhY3RUb0xQQXNzZXQAAAABBQAAAAtwb29sQWRkcmVzcwUAAAAMbHBBc3NldElkU3RyCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAPa2V5UG9vbFRvV2VpZ2h0AAAAAQUAAAALcG9vbEFkZHJlc3MFAAAACnBvb2xXZWlnaHQJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAA1rZXlQb29sU3ByZWFkAAAAAQUAAAALcG9vbEFkZHJlc3MFAAAADWRlZmF1bHRTcHJlYWQFAAAAA25pbAUAAAAMbHBBc3NldElkU3RyCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAAptYW5hZ2VQb29sAAAAAgAAAAtwb29sQWRkcmVzcwAAAAluZXdTdGF0dXMEAAAAC2NoZWNrQ2FsbGVyCQEAAAALbXVzdE1hbmFnZXIAAAABBQAAAAFpAwkAAAAAAAACBQAAAAtjaGVja0NhbGxlcgUAAAALY2hlY2tDYWxsZXIEAAAACnBvb2xDb25maWcJAQAAAA1nZXRQb29sQ29uZmlnAAAAAQUAAAALcG9vbEFkZHJlc3MEAAAACnBvb2xTdGF0dXMJAAGRAAAAAgUAAAAKcG9vbENvbmZpZwUAAAANaWR4UG9vbFN0YXR1cwQAAAAMbHBBc3NldElkU3RyCQABkQAAAAIFAAAACnBvb2xDb25maWcFAAAAEGlkeFBvb2xMUEFzc2V0SWQEAAAADmFtb3VudEFzc2V0U3RyCQABkQAAAAIFAAAACnBvb2xDb25maWcFAAAADWlkeEFtdEFzc2V0SWQEAAAADXByaWNlQXNzZXRTdHIJAAGRAAAAAgUAAAAKcG9vbENvbmZpZwUAAAAPaWR4UHJpY2VBc3NldElkBAAAABRhbW91bnRBc3NldHNEZWNpbWFscwkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAACnBvb2xDb25maWcFAAAADmlkeEFtdEFzc2V0RGNtBAAAABNwcmljZUFzc2V0c0RlY2ltYWxzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAKcG9vbENvbmZpZwUAAAAQaWR4UHJpY2VBc3NldERjbQQAAAAVaW50ZXJuYWxBbW91bnRBc3NldElkCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAKcG9vbENvbmZpZwUAAAAOaWR4SUFtdEFzc2V0SWQEAAAAFGludGVybmFsUHJpY2VBc3NldElkCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAKcG9vbENvbmZpZwUAAAAQaWR4SVByaWNlQXNzZXRJZAQAAAAKbHBBc3NldERjbQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAACnBvb2xDb25maWcFAAAADWlkeExQQXNzZXREY20EAAAACHBvb2xUeXBlCQABkQAAAAIFAAAACnBvb2xDb25maWcFAAAAC2lkeFBvb2xUeXBlCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAA1rZXlQb29sQ29uZmlnAAAAAgkAAaQAAAABBQAAABVpbnRlcm5hbEFtb3VudEFzc2V0SWQJAAGkAAAAAQUAAAAUaW50ZXJuYWxQcmljZUFzc2V0SWQJAQAAAAtkYXRhUG9vbENmZwAAAAsFAAAAC3Bvb2xBZGRyZXNzCQABpAAAAAEFAAAACW5ld1N0YXR1cwUAAAAMbHBBc3NldElkU3RyBQAAAA5hbW91bnRBc3NldFN0cgUAAAANcHJpY2VBc3NldFN0cgUAAAAUYW1vdW50QXNzZXRzRGVjaW1hbHMFAAAAE3ByaWNlQXNzZXRzRGVjaW1hbHMFAAAAFWludGVybmFsQW1vdW50QXNzZXRJZAUAAAAUaW50ZXJuYWxQcmljZUFzc2V0SWQFAAAACmxwQXNzZXREY20FAAAACHBvb2xUeXBlBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAABGVtaXQAAAABAAAADGFtb3VudFRvRW1pdAQAAAAGY2FsbGVyCAUAAAABaQAAAAZjYWxsZXIEAAAADG9yaWdpbkNhbGxlcggFAAAAAWkAAAAMb3JpZ2luQ2FsbGVyBAAAABBscEFzc2V0UmVxdWVzdGVkCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQiAAAAAQkBAAAAH2tleU1hcHBpbmdQb29sQ29udHJhY3RUb0xQQXNzZXQAAAABCQAEJQAAAAEFAAAABmNhbGxlcgIAAAAdSW52YWxpZCBMUCBhZGRyZXNzIGNhbGxlZCBtZS4EAAAAB2xwQXNzZXQJAAJZAAAAAQUAAAAQbHBBc3NldFJlcXVlc3RlZAQAAAALbGVnYWN5UG9vbHMJAAS1AAAAAgkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABCIAAAABCQEAAAAOa2V5TGVnYWN5UG9vbHMAAAAABQAAAAVFTVBUWQUAAAADU0VQBAAAABVsZWdhY3lGYWN0b3J5Q29udHJhY3QJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABCIAAAABCQEAAAAYa2V5TGVnYWN5RmFjdG9yeUNvbnRyYWN0AAAAAAIAAAAoTGVnYWN5IGZhY3RvcnkgY29udHJhY3QgZG9lcyBub3QgZXhpc3RzLgMJAABnAAAAAgAAAAAAAAAAAAUAAAAMYW1vdW50VG9FbWl0BQAAAANuaWwDCQEAAAAPY29udGFpbnNFbGVtZW50AAAAAgUAAAALbGVnYWN5UG9vbHMJAAQlAAAAAQUAAAAGY2FsbGVyCQAFFAAAAAIFAAAAA25pbAUAAAAVbGVnYWN5RmFjdG9yeUNvbnRyYWN0CQAFFAAAAAIJAARMAAAAAgkBAAAAB1JlaXNzdWUAAAADBQAAAAdscEFzc2V0BQAAAAxhbW91bnRUb0VtaXQGCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMIBQAAAAFpAAAABmNhbGxlcgUAAAAMYW1vdW50VG9FbWl0BQAAAAdscEFzc2V0BQAAAANuaWwCAAAAB3N1Y2Nlc3MAAAABaQEAAAAEYnVybgAAAAEAAAAMYW1vdW50VG9CdXJuBAAAAAZjYWxsZXIIBQAAAAFpAAAABmNhbGxlcgQAAAAMb3JpZ2luQ2FsbGVyCAUAAAABaQAAAAxvcmlnaW5DYWxsZXIEAAAAB3BheW1lbnQJAQAAAAV2YWx1ZQAAAAEJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAEAAAADXBheW1lbnRBbW91bnQJAQAAAAV2YWx1ZQAAAAEIBQAAAAdwYXltZW50AAAABmFtb3VudAQAAAAPaW5BbW91bnRBc3NldElkCQACWAAAAAEJAQAAAAV2YWx1ZQAAAAEIBQAAAAdwYXltZW50AAAAB2Fzc2V0SWQEAAAAGmxwQXNzZXRSZXF1ZXN0ZWRGb3JCdXJuaW5nCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQiAAAAAQkBAAAAH2tleU1hcHBpbmdQb29sQ29udHJhY3RUb0xQQXNzZXQAAAABCQAEJQAAAAEFAAAABmNhbGxlcgIAAAAdSW52YWxpZCBMUCBhZGRyZXNzIGNhbGxlZCBtZS4DCQEAAAACIT0AAAACBQAAAA9pbkFtb3VudEFzc2V0SWQFAAAAGmxwQXNzZXRSZXF1ZXN0ZWRGb3JCdXJuaW5nCQAAAgAAAAECAAAAFUludmFsaWQgYXNzZXQgcGFzc2VkLgMJAQAAAAIhPQAAAAIFAAAADGFtb3VudFRvQnVybgUAAAANcGF5bWVudEFtb3VudAkAAAIAAAABAgAAABZJbnZhbGlkIGFtb3VudCBwYXNzZWQuBAAAAAdscEFzc2V0CQACWQAAAAEFAAAAGmxwQXNzZXRSZXF1ZXN0ZWRGb3JCdXJuaW5nCQAFFAAAAAIJAARMAAAAAgkBAAAABEJ1cm4AAAACBQAAAAdscEFzc2V0BQAAAAxhbW91bnRUb0J1cm4FAAAAA25pbAIAAAAHc3VjY2VzcwAAAAFpAQAAAAxtb2RpZnlXZWlnaHQAAAACAAAACWxwQXNzZXRJZAAAAAVzaGFyZQQAAAALY2hlY2tDYWxsZXIDCQAAAAAAAAIJAAJYAAAAAQgIBQAAAAFpAAAABmNhbGxlcgAAAAVieXRlcwkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABB0AAAACBQAAAAR0aGlzCQEAAAAZa2V5Vm90aW5nRW1pc3Npb25Db250cmFjdAAAAAACAAAAAAYJAQAAAAttdXN0TWFuYWdlcgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgQAAAATcG9vbENvbnRyYWN0QWRkcmVzcwkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEJAQAAACprZXlNYXBwaW5nUG9vbExQQXNzZXRUb1Bvb2xDb250cmFjdEFkZHJlc3MAAAABBQAAAAlscEFzc2V0SWQEAAAADXBvb2xXZWlnaHRLZXkJAQAAAA9rZXlQb29sVG9XZWlnaHQAAAABBQAAABNwb29sQ29udHJhY3RBZGRyZXNzBAAAAAxnd3hXZWlnaHRLZXkJAQAAAA9rZXlQb29sVG9XZWlnaHQAAAABBQAAAA5HV1h2aXJ0dWFsUE9PTAQAAAAJZ3d4V2VpZ2h0CQEAAAALdmFsdWVPckVsc2UAAAACCQAEHwAAAAEFAAAADGd3eFdlaWdodEtleQAAAAAAAAAAAAQAAAAKcG9vbFdlaWdodAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABB8AAAABBQAAAA1wb29sV2VpZ2h0S2V5AAAAAAAAAAAABAAAAA1wb29sV2VpZ2h0TmV3BQAAAAVzaGFyZQQAAAAKZmFjdG9yeUNmZwkABLUAAAACCQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQkBAAAAEGtleUZhY3RvcnlDb25maWcAAAAABQAAAANTRVAEAAAAD3N0YWtpbmdDb250cmFjdAkBAAAAF2dldFN0YWtpbmdBZGRyZXNzT3JGYWlsAAAAAQUAAAAKZmFjdG9yeUNmZwQAAAARb25Nb2RpZnlXZWlnaHRJbnYJAAP8AAAABAUAAAAPc3Rha2luZ0NvbnRyYWN0AgAAAA5vbk1vZGlmeVdlaWdodAkABEwAAAACBQAAAAlscEFzc2V0SWQJAARMAAAAAgUAAAATcG9vbENvbnRyYWN0QWRkcmVzcwUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAEW9uTW9kaWZ5V2VpZ2h0SW52BQAAABFvbk1vZGlmeVdlaWdodEludgQAAAAVZ3d4VmlydHVhbFBvb2xBY3Rpb25zAwkAAAAAAAACBQAAAAlnd3hXZWlnaHQAAAAAAAAAAAAFAAAAA25pbAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAMZ3d4V2VpZ2h0S2V5AAAAAAAAAAAABQAAAANuaWwEAAAAFHBvb2xXZWlnaHRIaXN0b3J5S2V5CQEAAAAWa2V5UG9vbFRvV2VpZ2h0SGlzdG9yeQAAAAIFAAAAE3Bvb2xDb250cmFjdEFkZHJlc3MAAAAAAAAAAAAEAAAAF3Bvb2xXZWlnaHRIaXN0b3J5T3JVbml0CQAEHwAAAAEFAAAAFHBvb2xXZWlnaHRIaXN0b3J5S2V5BAAAABhwb29sV2VpZ2h0SGlzdG9yeUFjdGlvbnMDCQAAAAAAAAIFAAAAF3Bvb2xXZWlnaHRIaXN0b3J5T3JVbml0BQAAAAR1bml0BQAAAANuaWwJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQUAAAAUcG9vbFdlaWdodEhpc3RvcnlLZXkFAAAAA25pbAkABE4AAAACCQAETgAAAAIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAADXBvb2xXZWlnaHRLZXkFAAAADXBvb2xXZWlnaHROZXcFAAAAA25pbAUAAAAVZ3d4VmlydHVhbFBvb2xBY3Rpb25zBQAAABhwb29sV2VpZ2h0SGlzdG9yeUFjdGlvbnMJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAA1tb2RpZnlXZWlnaHRzAAAABAAAAA5idGNQb29sQWRkcmVzcwAAAA5ldGhQb29sQWRkcmVzcwAAABFldGhCdGNQb29sQWRkcmVzcwAAABN1c2RjVXNkdFBvb2xBZGRyZXNzBAAAAAtjaGVja0NhbGxlcgkBAAAAC211c3RNYW5hZ2VyAAAAAQUAAAABaQMJAAAAAAAAAgUAAAALY2hlY2tDYWxsZXIFAAAAC2NoZWNrQ2FsbGVyBAAAAA9ldGhCdGNXZWlnaHROZXcJAABpAAAAAgkAAGgAAAACAAAAAAAAAAAFBQAAAA5QT09MV0VJR0hUTVVMVAAAAAAAAAAAZAQAAAARdXNkY1VzZHRXZWlnaHROZXcJAABpAAAAAgkAAGgAAAACAAAAAAAAAAAFBQAAAA5QT09MV0VJR0hUTVVMVAAAAAAAAAAAZAQAAAAPd2VpZ2h0RGVjcmVtZW50CQAAaQAAAAIJAABoAAAAAgAAAAAAAAAABQUAAAAOUE9PTFdFSUdIVE1VTFQAAAAAAAAAAGQEAAAACmZhY3RvcnlDZmcJAAS1AAAAAgkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEJAQAAABBrZXlGYWN0b3J5Q29uZmlnAAAAAAUAAAADU0VQBAAAAAtzdGFraW5nRGFwcAkBAAAAF2dldFN0YWtpbmdBZGRyZXNzT3JGYWlsAAAAAQUAAAAKZmFjdG9yeUNmZwQAAAANZ3d4UmV3YXJkRGFwcAkBAAAAGWdldEd3eFJld2FyZEFkZHJlc3NPckZhaWwAAAABBQAAAApmYWN0b3J5Q2ZnBAAAAAxidGNXZWlnaHRLRVkJAQAAAA9rZXlQb29sVG9XZWlnaHQAAAABBQAAAA5idGNQb29sQWRkcmVzcwQAAAAMZXRoV2VpZ2h0S0VZCQEAAAAPa2V5UG9vbFRvV2VpZ2h0AAAAAQUAAAAOZXRoUG9vbEFkZHJlc3MEAAAAD2V0aEJ0Y1dlaWdodEtFWQkBAAAAD2tleVBvb2xUb1dlaWdodAAAAAEFAAAAEWV0aEJ0Y1Bvb2xBZGRyZXNzBAAAABF1c2RjVXNkdFdlaWdodEtFWQkBAAAAD2tleVBvb2xUb1dlaWdodAAAAAEFAAAAE3VzZGNVc2R0UG9vbEFkZHJlc3MEAAAACWJ0Y1dlaWdodAkBAAAADGdldEludE9yRmFpbAAAAAEFAAAADGJ0Y1dlaWdodEtFWQQAAAAJZXRoV2VpZ2h0CQEAAAAMZ2V0SW50T3JGYWlsAAAAAQUAAAAMZXRoV2VpZ2h0S0VZBAAAAAxidGNXZWlnaHROZXcJAABlAAAAAgUAAAAJYnRjV2VpZ2h0BQAAAA93ZWlnaHREZWNyZW1lbnQEAAAADGV0aFdlaWdodE5ldwkAAGUAAAACBQAAAAlldGhXZWlnaHQFAAAAD3dlaWdodERlY3JlbWVudAMJAABnAAAAAgAAAAAAAAAAAAUAAAAMYnRjV2VpZ2h0TmV3CQAAAgAAAAEJAAEsAAAAAgIAAAAWaW52YWxpZCBidGNXZWlnaHROZXc6IAkAAaQAAAABBQAAAAxidGNXZWlnaHROZXcDCQAAZwAAAAIAAAAAAAAAAAAFAAAADGV0aFdlaWdodE5ldwkAAAIAAAABCQABLAAAAAICAAAAFmludmFsaWQgZXRoV2VpZ2h0TmV3OiAJAAGkAAAAAQUAAAAMZXRoV2VpZ2h0TmV3BAAAAA9idGNMcEFzc2V0SWRTdHIJAQAAAA9nZXRTdHJpbmdPckZhaWwAAAABCQEAAAAfa2V5TWFwcGluZ1Bvb2xDb250cmFjdFRvTFBBc3NldAAAAAEFAAAADmJ0Y1Bvb2xBZGRyZXNzBAAAAA9ldGhMcEFzc2V0SWRTdHIJAQAAAA9nZXRTdHJpbmdPckZhaWwAAAABCQEAAAAfa2V5TWFwcGluZ1Bvb2xDb250cmFjdFRvTFBBc3NldAAAAAEFAAAADmV0aFBvb2xBZGRyZXNzBAAAABJldGhCdGNMcEFzc2V0SWRTdHIJAQAAAA9nZXRTdHJpbmdPckZhaWwAAAABCQEAAAAfa2V5TWFwcGluZ1Bvb2xDb250cmFjdFRvTFBBc3NldAAAAAEFAAAAEWV0aEJ0Y1Bvb2xBZGRyZXNzBAAAABR1c2RjVXNkdExwQXNzZXRJZFN0cgkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEJAQAAAB9rZXlNYXBwaW5nUG9vbENvbnRyYWN0VG9MUEFzc2V0AAAAAQUAAAATdXNkY1VzZHRQb29sQWRkcmVzcwQAAAARb25Nb2RpZnlXZWlnaHRCdGMJAAP8AAAABAUAAAALc3Rha2luZ0RhcHACAAAADm9uTW9kaWZ5V2VpZ2h0CQAETAAAAAIFAAAAD2J0Y0xwQXNzZXRJZFN0cgkABEwAAAACBQAAAA5idGNQb29sQWRkcmVzcwUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAEW9uTW9kaWZ5V2VpZ2h0QnRjBQAAABFvbk1vZGlmeVdlaWdodEJ0YwQAAAARb25Nb2RpZnlXZWlnaHRFdGgJAAP8AAAABAUAAAALc3Rha2luZ0RhcHACAAAADm9uTW9kaWZ5V2VpZ2h0CQAETAAAAAIFAAAAD2V0aExwQXNzZXRJZFN0cgkABEwAAAACBQAAAA5ldGhQb29sQWRkcmVzcwUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAEW9uTW9kaWZ5V2VpZ2h0RXRoBQAAABFvbk1vZGlmeVdlaWdodEV0aAQAAAAUb25Nb2RpZnlXZWlnaHRFdGhCdGMJAAP8AAAABAUAAAALc3Rha2luZ0RhcHACAAAADm9uTW9kaWZ5V2VpZ2h0CQAETAAAAAIFAAAAEmV0aEJ0Y0xwQXNzZXRJZFN0cgkABEwAAAACBQAAABFldGhCdGNQb29sQWRkcmVzcwUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAFG9uTW9kaWZ5V2VpZ2h0RXRoQnRjBQAAABRvbk1vZGlmeVdlaWdodEV0aEJ0YwQAAAAWb25Nb2RpZnlXZWlnaHRVc2RjVXNkdAkAA/wAAAAEBQAAAAtzdGFraW5nRGFwcAIAAAAOb25Nb2RpZnlXZWlnaHQJAARMAAAAAgUAAAAUdXNkY1VzZHRMcEFzc2V0SWRTdHIJAARMAAAAAgUAAAATdXNkY1VzZHRQb29sQWRkcmVzcwUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAAFm9uTW9kaWZ5V2VpZ2h0VXNkY1VzZHQFAAAAFm9uTW9kaWZ5V2VpZ2h0VXNkY1VzZHQJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAADGJ0Y1dlaWdodEtFWQUAAAAMYnRjV2VpZ2h0TmV3CQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAAAxldGhXZWlnaHRLRVkFAAAADGV0aFdlaWdodE5ldwkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAPZXRoQnRjV2VpZ2h0S0VZBQAAAA9ldGhCdGNXZWlnaHROZXcJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAEXVzZGNVc2R0V2VpZ2h0S0VZBQAAABF1c2RjVXNkdFdlaWdodE5ldwkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAFmtleVBvb2xUb1dlaWdodEhpc3RvcnkAAAACBQAAAA5idGNQb29sQWRkcmVzcwAAAAAAAAAAAAUAAAAJYnRjV2VpZ2h0CQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAWa2V5UG9vbFRvV2VpZ2h0SGlzdG9yeQAAAAIFAAAADmV0aFBvb2xBZGRyZXNzAAAAAAAAAAAABQAAAAlldGhXZWlnaHQJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAABZrZXlQb29sVG9XZWlnaHRIaXN0b3J5AAAAAgUAAAARZXRoQnRjUG9vbEFkZHJlc3MAAAAAAAAAAAAFAAAAD2V0aEJ0Y1dlaWdodE5ldwkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAFmtleVBvb2xUb1dlaWdodEhpc3RvcnkAAAACBQAAABN1c2RjVXNkdFBvb2xBZGRyZXNzAAAAAAAAAAAABQAAABF1c2RjVXNkdFdlaWdodE5ldwUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAYY2hlY2tXeEVtaXNzaW9uUG9vbExhYmVsAAAAAgAAAA1hbW91bnRBc3NldElkAAAADHByaWNlQXNzZXRJZAQAAAAJaGF2ZUxhYmVsBAAAAAckbWF0Y2gwCQAEIAAAAAEJAQAAAA1rZXlXeEVtaXNzaW9uAAAAAgUAAAANYW1vdW50QXNzZXRJZAUAAAAMcHJpY2VBc3NldElkAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAdCb29sZWFuBAAAAAFiBQAAAAckbWF0Y2gwBQAAAAFiBwkABRQAAAACBQAAAANuaWwFAAAACWhhdmVMYWJlbAAAAAFpAQAAABZzZXRXeEVtaXNzaW9uUG9vbExhYmVsAAAAAgAAAA1hbW91bnRBc3NldElkAAAADHByaWNlQXNzZXRJZAQAAAALY2hlY2tDYWxsZXIJAQAAAAltdXN0QWRtaW4AAAABBQAAAAFpAwkAAAAAAAACBQAAAAtjaGVja0NhbGxlcgUAAAALY2hlY2tDYWxsZXIJAAUUAAAAAgkABEwAAAACCQEAAAAMQm9vbGVhbkVudHJ5AAAAAgkBAAAADWtleVd4RW1pc3Npb24AAAACBQAAAA1hbW91bnRBc3NldElkBQAAAAxwcmljZUFzc2V0SWQGBQAAAANuaWwFAAAABHVuaXQJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAAGWRlbGV0ZVd4RW1pc3Npb25Qb29sTGFiZWwAAAACAAAADWFtb3VudEFzc2V0SWQAAAAMcHJpY2VBc3NldElkBAAAAAtjaGVja0NhbGxlcgMJAQAAAAhtdXN0VGhpcwAAAAEFAAAAAWkGCQEAAAAJbXVzdEFkbWluAAAAAQUAAAABaQMJAAAAAAAAAgUAAAALY2hlY2tDYWxsZXIFAAAAC2NoZWNrQ2FsbGVyCQAFFAAAAAIJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkBAAAADWtleVd4RW1pc3Npb24AAAACBQAAAA1hbW91bnRBc3NldElkBQAAAAxwcmljZUFzc2V0SWQFAAAAA25pbAUAAAAEdW5pdAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAASb25WZXJpZmljYXRpb25Mb3NzAAAAAQAAAAdhc3NldElkBAAAAAtjaGVja0NhbGxlcgMJAAAAAAAAAgkAAlgAAAABCAgFAAAAAWkAAAAGY2FsbGVyAAAABWJ5dGVzCQEAAAALdmFsdWVPckVsc2UAAAACCQAEHQAAAAIFAAAABHRoaXMJAQAAABZrZXlBc3NldHNTdG9yZUNvbnRyYWN0AAAAAAIAAAAABgkBAAAAC211c3RNYW5hZ2VyAAAAAQUAAAABaQMJAAAAAAAAAgUAAAALY2hlY2tDYWxsZXIFAAAAC2NoZWNrQ2FsbGVyBAAAAAtwcmljZUFzc2V0cwkBAAAADmdldFByaWNlQXNzZXRzAAAAAAQAAAAUY2hlY2tQcmljZUFzc2V0c1NpemUDCQAAZgAAAAIJAAGQAAAAAQUAAAALcHJpY2VBc3NldHMAAAAAAAAAAAAGCQAAAgAAAAECAAAAFGludmFsaWQgcHJpY2UgYXNzZXRzAwkAAAAAAAACBQAAABRjaGVja1ByaWNlQXNzZXRzU2l6ZQUAAAAUY2hlY2tQcmljZUFzc2V0c1NpemUKAQAAAAJjYgAAAAIAAAADYWNjAAAACnByaWNlQXNzZXQEAAAAAXIJAAP8AAAABAUAAAAEdGhpcwIAAAAZZGVsZXRlV3hFbWlzc2lvblBvb2xMYWJlbAkABEwAAAACBQAAAAdhc3NldElkCQAETAAAAAIFAAAACnByaWNlQXNzZXQFAAAAA25pbAUAAAADbmlsAwkAAAAAAAACBQAAAAFyBQAAAAFyBQAAAAR1bml0CQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgQAAAAHYWN0aW9ucwoAAAAAAiRsBQAAAAtwcmljZUFzc2V0cwoAAAAAAiRzCQABkAAAAAEFAAAAAiRsCgAAAAAFJGFjYzAFAAAABHVuaXQKAQAAAAUkZjBfMQAAAAIAAAACJGEAAAACJGkDCQAAZwAAAAIFAAAAAiRpBQAAAAIkcwUAAAACJGEJAQAAAAJjYgAAAAIFAAAAAiRhCQABkQAAAAIFAAAAAiRsBQAAAAIkaQoBAAAABSRmMF8yAAAAAgAAAAIkYQAAAAIkaQMJAABnAAAAAgUAAAACJGkFAAAAAiRzBQAAAAIkYQkAAAIAAAABAgAAABNMaXN0IHNpemUgZXhjZWVkcyAzCQEAAAAFJGYwXzIAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACCQEAAAAFJGYwXzEAAAACBQAAAAUkYWNjMAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAgAAAAAAAAAAAwMJAAAAAAAAAgUAAAAHYWN0aW9ucwUAAAAHYWN0aW9ucwkABRQAAAACBQAAAANuaWwFAAAABHVuaXQJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAoaXNQb29sT25lVG9rZW5PcGVyYXRpb25zRGlzYWJsZWRSRUFET05MWQAAAAEAAAALcG9vbEFkZHJlc3MEAAAACnBvb2xDb25maWcJAQAAAA1nZXRQb29sQ29uZmlnAAAAAQUAAAALcG9vbEFkZHJlc3MEAAAADmFzc2V0c0ludGVybmFsCQAFFAAAAAIJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAApwb29sQ29uZmlnBQAAAA5pZHhJQW10QXNzZXRJZAkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAACnBvb2xDb25maWcFAAAAEGlkeElQcmljZUFzc2V0SWQEAAAAHnBvb2xPbmVUb2tlbk9wZXJhdGlvbnNEaXNhYmxlZAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABCAAAAABCQEAAAAha2V5UG9vbE9uZVRva2VuT3BlcmF0aW9uc0Rpc2FibGVkAAAAAQUAAAAOYXNzZXRzSW50ZXJuYWwHBAAAACJhbGxQb29sc09uZVRva2VuT3BlcmF0aW9uc0Rpc2FibGVkCQEAAAALdmFsdWVPckVsc2UAAAACCQAEIAAAAAEJAQAAACVrZXlBbGxQb29sc09uZVRva2VuT3BlcmF0aW9uc0Rpc2FibGVkAAAAAAcJAAUUAAAAAgUAAAADbmlsAwUAAAAiYWxsUG9vbHNPbmVUb2tlbk9wZXJhdGlvbnNEaXNhYmxlZAYFAAAAHnBvb2xPbmVUb2tlbk9wZXJhdGlvbnNEaXNhYmxlZAAAAAEAAAACdHgBAAAABnZlcmlmeQAAAAAEAAAAD3RhcmdldFB1YmxpY0tleQQAAAAHJG1hdGNoMAkBAAAAFm1hbmFnZXJQdWJsaWNLZXlPclVuaXQAAAAAAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAApCeXRlVmVjdG9yBAAAAAJwawUAAAAHJG1hdGNoMAUAAAACcGsDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABFVuaXQIBQAAAAJ0eAAAAA9zZW5kZXJQdWJsaWNLZXkJAAACAAAAAQIAAAALTWF0Y2ggZXJyb3IJAAH0AAAAAwgFAAAAAnR4AAAACWJvZHlCeXRlcwkAAZEAAAACCAUAAAACdHgAAAAGcHJvb2ZzAAAAAAAAAAAABQAAAA90YXJnZXRQdWJsaWNLZXkU1cpN",
    "height": 2346917,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 96Gx3GQsjJADE4KRw1spA3YBZYLWkk4ujUvY78a64UWW
Next: 5EYwLezaZQU2k2nDHNuW4iFRtNunKMW7br1YgSuzLJfy

Diff: 

OldNewDifferences
1414 let GWXvirtualPOOL = "GWXvirtualPOOL"
1515 
1616 let labelPoolsLp = "POOLS_LP"
17+
18+let defaultSpread = 2000000
1719 
1820 let decimalsMultPrice = ((100 * 1000) * 1000)
1921 
131133 
132134 
133135 func keyPoolOneTokenOperationsDisabled (assetsInternal) = {
134-    let $t035873649 = assetsInternal
135-    let amountAssetInternal = $t035873649._1
136-    let priceAssetInternal = $t035873649._2
136+    let $t036323694 = assetsInternal
137+    let amountAssetInternal = $t036323694._1
138+    let priceAssetInternal = $t036323694._2
137139     makeString(["%d%d%s", toString(amountAssetInternal), toString(priceAssetInternal), "oneTokenOperationsDisabled"], SEP)
138140     }
139141 
145147 
146148 
147149 func keyMappingPoolAssetsToLpasset (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + internalAmountAssetIdStr) + "__") + internalPriceAssetIdStr) + "__mappings__PoolAssets2LpAsset")
150+
151+
152+func keyPoolSpread (poolAddress) = ("%s%s__spread__" + poolAddress)
148153 
149154 
150155 func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2PoolAssets")
464469                                                                 then {
465470                                                                     let increaseAssetPoolsNumberInv = invoke(assetsStoreContract, "increaseAssetPoolsNumber", [amountAssetStr], nil)
466471                                                                     if ((increaseAssetPoolsNumberInv == increaseAssetPoolsNumberInv))
467-                                                                        then $Tuple2(((internalAmountAssetData._2 ++ internalPriceAssetData._2) ++ [lpAssetIssueAction, Burn(lpAssetId, 1), StringEntry(keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)), dataPoolCfg(poolAddress, toString(PoolActive), lpAssetIdStr, amountAssetStr, priceAssetStr, amountAssetsDecimals, priceAssetsDecimals, internalAmountAssetId, internalPriceAssetId, decimalsMultPrice, poolType)), StringEntry(keyMappingLpAssetToPoolAssets(lpAssetIdStr), dataMappingPoolAssets(internalAmountAssetId, internalPriceAssetId)), StringEntry(keyMappingPoolAssetsToLpasset(toString(internalAmountAssetId), toString(internalPriceAssetId)), ("%s__" + lpAssetIdStr)), StringEntry(keyMappingPoolContractAddressToPoolAssets(poolAddress), dataMappingPoolAssets(internalAmountAssetId, internalPriceAssetId)), StringEntry(keyMappingPoolAssetsToPoolContractAddress(internalAmountAssetId, internalPriceAssetId), poolAddress), StringEntry(keyMappingPoolLPAssetToPoolContractAddress(lpAssetIdStr), poolAddress), StringEntry(keyMappingPoolContractToLPAsset(poolAddress), lpAssetIdStr), IntegerEntry(keyPoolToWeight(poolAddress), poolWeight)]), lpAssetIdStr)
472+                                                                        then $Tuple2(((internalAmountAssetData._2 ++ internalPriceAssetData._2) ++ [lpAssetIssueAction, Burn(lpAssetId, 1), StringEntry(keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)), dataPoolCfg(poolAddress, toString(PoolActive), lpAssetIdStr, amountAssetStr, priceAssetStr, amountAssetsDecimals, priceAssetsDecimals, internalAmountAssetId, internalPriceAssetId, decimalsMultPrice, poolType)), StringEntry(keyMappingLpAssetToPoolAssets(lpAssetIdStr), dataMappingPoolAssets(internalAmountAssetId, internalPriceAssetId)), StringEntry(keyMappingPoolAssetsToLpasset(toString(internalAmountAssetId), toString(internalPriceAssetId)), ("%s__" + lpAssetIdStr)), StringEntry(keyMappingPoolContractAddressToPoolAssets(poolAddress), dataMappingPoolAssets(internalAmountAssetId, internalPriceAssetId)), StringEntry(keyMappingPoolAssetsToPoolContractAddress(internalAmountAssetId, internalPriceAssetId), poolAddress), StringEntry(keyMappingPoolLPAssetToPoolContractAddress(lpAssetIdStr), poolAddress), StringEntry(keyMappingPoolContractToLPAsset(poolAddress), lpAssetIdStr), IntegerEntry(keyPoolToWeight(poolAddress), poolWeight), IntegerEntry(keyPoolSpread(poolAddress), defaultSpread)]), lpAssetIdStr)
468473                                                                         else throw("Strict value is not equal to itself.")
469474                                                                     }
470475                                                                 else throw("Strict value is not equal to itself.")

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SCALE8 = 8
55 
66 let MULT8 = 100000000
77 
88 let SCALE18 = 18
99 
1010 let MULT18 = toBigInt(1000000000000000000)
1111 
1212 let POOLWEIGHTMULT = MULT8
1313 
1414 let GWXvirtualPOOL = "GWXvirtualPOOL"
1515 
1616 let labelPoolsLp = "POOLS_LP"
17+
18+let defaultSpread = 2000000
1719 
1820 let decimalsMultPrice = ((100 * 1000) * 1000)
1921 
2022 let SEP = "__"
2123 
2224 let EMPTY = ""
2325 
2426 let PoolActive = 1
2527 
2628 let PoolPutDisabled = 2
2729 
2830 let PoolMatcherDisabled = 3
2931 
3032 let PoolShutdown = 4
3133 
3234 let idxInternalAssetId = 1
3335 
3436 let idxResutActions = 2
3537 
3638 let idxIfAssetIdCalculationPerformed = 3
3739 
3840 let idxPoolAddress = 1
3941 
4042 let idxPoolStatus = 2
4143 
4244 let idxPoolLPAssetId = 3
4345 
4446 let idxAmtAssetId = 4
4547 
4648 let idxPriceAssetId = 5
4749 
4850 let idxAmtAssetDcm = 6
4951 
5052 let idxPriceAssetDcm = 7
5153 
5254 let idxIAmtAssetId = 8
5355 
5456 let idxIPriceAssetId = 9
5557 
5658 let idxLPAssetDcm = 10
5759 
5860 let idxPoolType = 11
5961 
6062 let poolLabelWxEmission = "WX_EMISSION"
6163 
6264 let validPoolLabels = [poolLabelWxEmission]
6365 
6466 func keyAllowedLpScriptHash () = "%s__allowedLpScriptHash"
6567 
6668 
6769 func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
6870 
6971 
7072 func keyAllowedLpStableAddonScriptHash () = "%s__allowedLpStableAddonScriptHash"
7173 
7274 
7375 func keyFactoryConfig () = "%s__factoryConfig"
7476 
7577 
7678 func keyLpTokensList () = "%s__lpTokensList"
7779 
7880 
7981 func keyPoolScriptHash () = "%s%s__pool__scriptHash"
8082 
8183 
8284 func keyMatcherPub () = "%s%s__matcher__publicKey"
8385 
8486 
8587 func keyLegacyFactoryContract () = "%s__legacyFactoryContract"
8688 
8789 
8890 func keyLegacyPools () = "%s__legacyPools"
8991 
9092 
9193 func keyManagerPublicKey () = "%s__managerPublicKey"
9294 
9395 
9496 func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
9597 
9698 
9799 func keyAdminPubKeys () = "%s__adminPubKeys"
98100 
99101 
100102 func keyAssetsStoreContract () = "%s__assetsStoreContract"
101103 
102104 
103105 func keyVotingEmissionContract () = "%s__votingEmissionContract"
104106 
105107 
106108 func keyPriceAssets () = makeString(["%s", "priceAssets"], SEP)
107109 
108110 
109111 func keyPriceDecimals () = "%s__priceDecimals"
110112 
111113 
112114 func keyAllPoolsShutdown () = "%s__shutdown"
113115 
114116 
115117 func keyNextInternalAssetId () = "%s__nextInternalAssetId"
116118 
117119 
118120 func keyPoolToWeight (poolAddress) = ("%s%s__poolWeight__" + poolAddress)
119121 
120122 
121123 func keyPoolToWeightHistory (poolAddress,num) = ((("%s%s__poolWeight__" + poolAddress) + "__") + toString(num))
122124 
123125 
124126 func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
125127 
126128 
127129 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
128130 
129131 
130132 func keyPoolConfig (amountAssetInternal,priceAssetInternal) = (((("%d%d%s__" + amountAssetInternal) + "__") + priceAssetInternal) + "__config")
131133 
132134 
133135 func keyPoolOneTokenOperationsDisabled (assetsInternal) = {
134-    let $t035873649 = assetsInternal
135-    let amountAssetInternal = $t035873649._1
136-    let priceAssetInternal = $t035873649._2
136+    let $t036323694 = assetsInternal
137+    let amountAssetInternal = $t036323694._1
138+    let priceAssetInternal = $t036323694._2
137139     makeString(["%d%d%s", toString(amountAssetInternal), toString(priceAssetInternal), "oneTokenOperationsDisabled"], SEP)
138140     }
139141 
140142 
141143 func keyAllPoolsOneTokenOperationsDisabled () = makeString(["%s", "oneTokenOperationsDisabled"], SEP)
142144 
143145 
144146 func keyMappingLpAssetToPoolAssets (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2Pool")
145147 
146148 
147149 func keyMappingPoolAssetsToLpasset (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + internalAmountAssetIdStr) + "__") + internalPriceAssetIdStr) + "__mappings__PoolAssets2LpAsset")
150+
151+
152+func keyPoolSpread (poolAddress) = ("%s%s__spread__" + poolAddress)
148153 
149154 
150155 func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2PoolAssets")
151156 
152157 
153158 func keyMappingPoolAssetsToPoolContractAddress (internalAmountAssetIdStr,internalPriceAssetIdStr) = (((("%d%d%s%s__" + toString(internalAmountAssetIdStr)) + "__") + toString(internalPriceAssetIdStr)) + "__mappings__poolAssets2PoolContract")
154159 
155160 
156161 func keyMappingPoolContractToLPAsset (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
157162 
158163 
159164 func keyMappingPoolLPAssetToPoolContractAddress (lpAssetStr) = (("%s%s%s__" + lpAssetStr) + "__mappings__lpAsset2PoolContract")
160165 
161166 
162167 func keyWxEmission (amountAssetId,priceAssetId) = ((("%s%s%s__wxEmission__" + amountAssetId) + "__") + priceAssetId)
163168 
164169 
165170 func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
166171 
167172 
168173 func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
169174 
170175 
171176 func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), ("No data for this.key=" + key))
172177 
173178 
174179 let IdxFactoryCfgStakingDapp = 1
175180 
176181 let IdxFactoryCfgBoostingDapp = 2
177182 
178183 let IdxFactoryCfgIdoDapp = 3
179184 
180185 let IdxFactoryCfgTeamDapp = 4
181186 
182187 let IdxFactoryCfgEmissionDapp = 5
183188 
184189 let IdxFactoryCfgRestDapp = 6
185190 
186191 let IdxFactoryCfgSlippageDapp = 7
187192 
188193 let IdxFactoryCfgDaoDapp = 8
189194 
190195 let IdxFactoryCfgMarketingDapp = 9
191196 
192197 let IdxFactoryCfgGwxRewardDapp = 10
193198 
194199 let IdxFactoryCfgBirdsDapp = 11
195200 
196201 func getBoostingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgBoostingDapp])
197202 
198203 
199204 func getEmissionAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgEmissionDapp])
200205 
201206 
202207 func getStakingAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgStakingDapp])
203208 
204209 
205210 func getGwxRewardAddressOrFail (factoryCfg) = addressFromStringValue(factoryCfg[IdxFactoryCfgGwxRewardDapp])
206211 
207212 
208213 func getPriceAssets () = match getString(keyPriceAssets()) {
209214     case s: String => 
210215         if ((size(s) == 0))
211216             then nil
212217             else split(s, SEP)
213218     case _ => 
214219         nil
215220 }
216221 
217222 
218223 func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
219224     case s: String => 
220225         fromBase58String(s)
221226     case _: Unit => 
222227         unit
223228     case _ => 
224229         throw("Match error")
225230 }
226231 
227232 
228233 func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
229234     case s: String => 
230235         fromBase58String(s)
231236     case _: Unit => 
232237         unit
233238     case _ => 
234239         throw("Match error")
235240 }
236241 
237242 
238243 let permissionDeniedError = throw("Permission denied")
239244 
240245 func mustThis (i) = if ((i.caller == this))
241246     then true
242247     else permissionDeniedError
243248 
244249 
245250 func mustManager (i) = match managerPublicKeyOrUnit() {
246251     case pk: ByteVector => 
247252         if ((i.callerPublicKey == pk))
248253             then true
249254             else permissionDeniedError
250255     case _: Unit => 
251256         mustThis(i)
252257     case _ => 
253258         throw("Match error")
254259 }
255260 
256261 
257262 func dataFactoryCfgV3 (stakingAddress,boostingAddress,idoContract,teamContract,emissionContract,restContract,slippageContract,daoContract,marketingContract,gwxRewardsContract,birdsContract) = makeString(["%s%s%s%s%s%s%s%s%s%s%s", stakingAddress, boostingAddress, idoContract, teamContract, emissionContract, restContract, slippageContract, daoContract, marketingContract, gwxRewardsContract, birdsContract], SEP)
258263 
259264 
260265 func dataFactoryCfg (stakingAddress,boostingAddress,idoContract,teamContract,emissionContract,restContract,slippageContract) = makeString(["%s%s%s%s%s%s", stakingAddress, boostingAddress, idoContract, teamContract, emissionContract, restContract, slippageContract], SEP)
261266 
262267 
263268 func dataPoolCfg (poolAddress,poolStatus,lpAssetId,amountAssetStr,priceAssetStr,amountAssetDecimals,priceAssetDecimals,amountAssetInternalId,priceAssetInternalId,lpAssetDecimals,poolType) = makeString(["%s%d%s%s%s%d%d%d%d%d%s", poolAddress, poolStatus, lpAssetId, amountAssetStr, priceAssetStr, toString(amountAssetDecimals), toString(priceAssetDecimals), toString(amountAssetInternalId), toString(priceAssetInternalId), toString(lpAssetDecimals), poolType], SEP)
264269 
265270 
266271 func dataMappingPoolAssets (internalAmountAssetStr,internalPriceAssetStr) = makeString(["%d%d", toString(internalAmountAssetStr), toString(internalPriceAssetStr)], SEP)
267272 
268273 
269274 func getPoolConfig (poolAddress) = {
270275     let poolAssets = split(getStringOrFail(keyMappingPoolContractAddressToPoolAssets(poolAddress)), SEP)
271276     let amountAssetInternal = poolAssets[1]
272277     let priceAssetInternal = poolAssets[2]
273278     split(getStringOrFail(keyPoolConfig(amountAssetInternal, priceAssetInternal)), SEP)
274279     }
275280 
276281 
277282 func getInternalAssetIdOrCreate (assetIdStr,incrementor) = {
278283     let internalAssetId = valueOrElse(getInteger(this, keyMappingsBaseAsset2internalId(assetIdStr)), 0)
279284     let currentIndexOfInternalId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
280285     let result = if ((internalAssetId == 0))
281286         then {
282287             let newInternalAssetId = (currentIndexOfInternalId + incrementor)
283288             $Tuple3(newInternalAssetId, [IntegerEntry(keyNextInternalAssetId(), newInternalAssetId), IntegerEntry(keyMappingsBaseAsset2internalId(assetIdStr), newInternalAssetId), StringEntry(keyMappingsInternal2baseAssetId(newInternalAssetId), assetIdStr)], true)
284289             }
285290         else $Tuple3(internalAssetId, nil, false)
286291     result
287292     }
288293 
289294 
290295 func mustAdmin (i) = {
291296     let adminPKs = split(valueOrElse(getString(keyAdminPubKeys()), EMPTY), SEP)
292297     if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
293298         then true
294299         else {
295300             let isManager = mustManager(i)
296301             if ((isManager == isManager))
297302                 then true
298303                 else throw("Strict value is not equal to itself.")
299304             }
300305     }
301306 
302307 
303308 @Callable(i)
304309 func constructor (stakingContract,boostingContract,idoContract,teamContract,emissionContract,restContract,slpipageContract,priceDecimals) = {
305310     let checkCaller = mustManager(i)
306311     if ((checkCaller == checkCaller))
307312         then [StringEntry(keyFactoryConfig(), dataFactoryCfg(stakingContract, boostingContract, idoContract, teamContract, emissionContract, restContract, slpipageContract)), IntegerEntry(keyPriceDecimals(), priceDecimals)]
308313         else throw("Strict value is not equal to itself.")
309314     }
310315 
311316 
312317 
313318 @Callable(i)
314319 func constructorV2 (mathcherPub58Str) = {
315320     let checkCaller = mustManager(i)
316321     if ((checkCaller == checkCaller))
317322         then {
318323             let mathcerPub = addressFromPublicKey(fromBase58String(mathcherPub58Str))
319324             if ((mathcerPub == mathcerPub))
320325                 then [StringEntry(keyMatcherPub(), mathcherPub58Str)]
321326                 else throw("Strict value is not equal to itself.")
322327             }
323328         else throw("Strict value is not equal to itself.")
324329     }
325330 
326331 
327332 
328333 @Callable(i)
329334 func constructorV3 (daoContract,marketingContract,gwxRewardsContract,birdsContract) = {
330335     let checkCaller = mustManager(i)
331336     if ((checkCaller == checkCaller))
332337         then {
333338             let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
334339 [StringEntry(keyFactoryConfig(), dataFactoryCfgV3(factoryCfg[1], factoryCfg[2], factoryCfg[3], factoryCfg[4], factoryCfg[5], factoryCfg[6], factoryCfg[7], daoContract, marketingContract, gwxRewardsContract, birdsContract))]
335340             }
336341         else throw("Strict value is not equal to itself.")
337342     }
338343 
339344 
340345 
341346 @Callable(i)
342347 func constructorV4 (legacyFactoryContract,legacyPools) = {
343348     let checkCaller = mustManager(i)
344349     if ((checkCaller == checkCaller))
345350         then [StringEntry(keyLegacyFactoryContract(), legacyFactoryContract), StringEntry(keyLegacyPools(), makeString(legacyPools, SEP))]
346351         else throw("Strict value is not equal to itself.")
347352     }
348353 
349354 
350355 
351356 @Callable(i)
352357 func constructorV5 (assetsStoreContract) = {
353358     let checkCaller = mustManager(i)
354359     if ((checkCaller == checkCaller))
355360         then [StringEntry(keyAssetsStoreContract(), assetsStoreContract)]
356361         else throw("Strict value is not equal to itself.")
357362     }
358363 
359364 
360365 
361366 @Callable(i)
362367 func constructorV6 (votingEmissionContract,priceAssets) = {
363368     let cheks = [mustManager(i), if ((addressFromString(votingEmissionContract) != unit))
364369         then true
365370         else "invalid voting emission contract address"]
366371     if ((cheks == cheks))
367372         then [StringEntry(keyVotingEmissionContract(), votingEmissionContract), StringEntry(keyPriceAssets(), makeString(priceAssets, SEP))]
368373         else throw("Strict value is not equal to itself.")
369374     }
370375 
371376 
372377 
373378 @Callable(i)
374379 func setManager (pendingManagerPublicKey) = {
375380     let checkCaller = mustManager(i)
376381     if ((checkCaller == checkCaller))
377382         then {
378383             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
379384             if ((checkManagerPublicKey == checkManagerPublicKey))
380385                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
381386                 else throw("Strict value is not equal to itself.")
382387             }
383388         else throw("Strict value is not equal to itself.")
384389     }
385390 
386391 
387392 
388393 @Callable(i)
389394 func confirmManager () = {
390395     let pm = pendingManagerPublicKeyOrUnit()
391396     let hasPM = if (isDefined(pm))
392397         then true
393398         else throw("No pending manager")
394399     if ((hasPM == hasPM))
395400         then {
396401             let checkPM = if ((i.callerPublicKey == value(pm)))
397402                 then true
398403                 else throw("You are not pending manager")
399404             if ((checkPM == checkPM))
400405                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
401406                 else throw("Strict value is not equal to itself.")
402407             }
403408         else throw("Strict value is not equal to itself.")
404409     }
405410 
406411 
407412 
408413 @Callable(i)
409414 func setAdmins (adminPubKeys) = {
410415     let checkCaller = mustManager(i)
411416     if ((checkCaller == checkCaller))
412417         then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
413418         else throw("Strict value is not equal to itself.")
414419     }
415420 
416421 
417422 
418423 @Callable(i)
419424 func activateNewPool (poolAddress,amountAssetStr,priceAssetStr,lpAssetName,lpAssetDescr,poolWeight,poolType,logo) = {
420425     let checkCaller = mustAdmin(i)
421426     if ((checkCaller == checkCaller))
422427         then if (isDefined(getString(keyMappingPoolContractAddressToPoolAssets(poolAddress))))
423428             then throw((("Pool address " + poolAddress) + " already registered."))
424429             else {
425430                 let internalAmountAssetData = getInternalAssetIdOrCreate(amountAssetStr, 1)
426431                 let internalAmountAssetId = internalAmountAssetData._1
427432                 let internalPriceAssetData = getInternalAssetIdOrCreate(priceAssetStr, if (internalAmountAssetData._3)
428433                     then 2
429434                     else 1)
430435                 let internalPriceAssetId = internalPriceAssetData._1
431436                 let poolAccountScriptHash = valueOrErrorMessage(scriptHash(addressFromStringValue(poolAddress)), ("No script has been found on pool account " + poolAddress))
432437                 let ethalonPoolAccountScriptHash = getBinaryValue(keyPoolScriptHash())
433438                 let poolConfig = getString(this, keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)))
434439                 if (isDefined(poolConfig))
435440                     then throw((((("Pool " + amountAssetStr) + "/") + priceAssetStr) + " has already been activated."))
436441                     else {
437442                         let poolConfigValue = value(getString(this, keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId))))
438443                         let amountAssetsDecimals = if ((amountAssetStr == "WAVES"))
439444                             then decimalsMultPrice
440445                             else pow(10, 0, value(assetInfo(fromBase58String(amountAssetStr))).decimals, 0, 0, DOWN)
441446                         let priceAssetsDecimals = if ((priceAssetStr == "WAVES"))
442447                             then decimalsMultPrice
443448                             else pow(10, 0, value(assetInfo(fromBase58String(priceAssetStr))).decimals, 0, 0, DOWN)
444449                         let lpAssetIssueAction = Issue(lpAssetName, lpAssetDescr, 1, 8, true)
445450                         let lpAssetId = calculateAssetId(lpAssetIssueAction)
446451                         let lpAssetIdStr = toBase58String(lpAssetId)
447452                         let poolActivateInvokeResult = invoke(addressFromStringValue(poolAddress), "activate", [amountAssetStr, priceAssetStr], nil)
448453                         if ((poolActivateInvokeResult == poolActivateInvokeResult))
449454                             then if ((poolActivateInvokeResult != "success"))
450455                                 then throw("Pool initialisation error happened.")
451456                                 else {
452457                                     let assetsStoreContract = addressFromStringValue(getStringOrFail(keyAssetsStoreContract()))
453458                                     let createOrUpdateLpAssetInv = invoke(assetsStoreContract, "createOrUpdate", [lpAssetIdStr, lpAssetName, false], nil)
454459                                     if ((createOrUpdateLpAssetInv == createOrUpdateLpAssetInv))
455460                                         then {
456461                                             let addPoolsLpLabelInv = invoke(assetsStoreContract, "addLabel", [lpAssetIdStr, labelPoolsLp], nil)
457462                                             if ((addPoolsLpLabelInv == addPoolsLpLabelInv))
458463                                                 then {
459464                                                     let setLogoInv = invoke(assetsStoreContract, "setLogo", [lpAssetIdStr, logo], nil)
460465                                                     if ((setLogoInv == setLogoInv))
461466                                                         then {
462467                                                             let addAssetsLinkInv = invoke(assetsStoreContract, "addAssetsLink", [amountAssetStr, priceAssetStr, lpAssetIdStr], nil)
463468                                                             if ((addAssetsLinkInv == addAssetsLinkInv))
464469                                                                 then {
465470                                                                     let increaseAssetPoolsNumberInv = invoke(assetsStoreContract, "increaseAssetPoolsNumber", [amountAssetStr], nil)
466471                                                                     if ((increaseAssetPoolsNumberInv == increaseAssetPoolsNumberInv))
467-                                                                        then $Tuple2(((internalAmountAssetData._2 ++ internalPriceAssetData._2) ++ [lpAssetIssueAction, Burn(lpAssetId, 1), StringEntry(keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)), dataPoolCfg(poolAddress, toString(PoolActive), lpAssetIdStr, amountAssetStr, priceAssetStr, amountAssetsDecimals, priceAssetsDecimals, internalAmountAssetId, internalPriceAssetId, decimalsMultPrice, poolType)), StringEntry(keyMappingLpAssetToPoolAssets(lpAssetIdStr), dataMappingPoolAssets(internalAmountAssetId, internalPriceAssetId)), StringEntry(keyMappingPoolAssetsToLpasset(toString(internalAmountAssetId), toString(internalPriceAssetId)), ("%s__" + lpAssetIdStr)), StringEntry(keyMappingPoolContractAddressToPoolAssets(poolAddress), dataMappingPoolAssets(internalAmountAssetId, internalPriceAssetId)), StringEntry(keyMappingPoolAssetsToPoolContractAddress(internalAmountAssetId, internalPriceAssetId), poolAddress), StringEntry(keyMappingPoolLPAssetToPoolContractAddress(lpAssetIdStr), poolAddress), StringEntry(keyMappingPoolContractToLPAsset(poolAddress), lpAssetIdStr), IntegerEntry(keyPoolToWeight(poolAddress), poolWeight)]), lpAssetIdStr)
472+                                                                        then $Tuple2(((internalAmountAssetData._2 ++ internalPriceAssetData._2) ++ [lpAssetIssueAction, Burn(lpAssetId, 1), StringEntry(keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)), dataPoolCfg(poolAddress, toString(PoolActive), lpAssetIdStr, amountAssetStr, priceAssetStr, amountAssetsDecimals, priceAssetsDecimals, internalAmountAssetId, internalPriceAssetId, decimalsMultPrice, poolType)), StringEntry(keyMappingLpAssetToPoolAssets(lpAssetIdStr), dataMappingPoolAssets(internalAmountAssetId, internalPriceAssetId)), StringEntry(keyMappingPoolAssetsToLpasset(toString(internalAmountAssetId), toString(internalPriceAssetId)), ("%s__" + lpAssetIdStr)), StringEntry(keyMappingPoolContractAddressToPoolAssets(poolAddress), dataMappingPoolAssets(internalAmountAssetId, internalPriceAssetId)), StringEntry(keyMappingPoolAssetsToPoolContractAddress(internalAmountAssetId, internalPriceAssetId), poolAddress), StringEntry(keyMappingPoolLPAssetToPoolContractAddress(lpAssetIdStr), poolAddress), StringEntry(keyMappingPoolContractToLPAsset(poolAddress), lpAssetIdStr), IntegerEntry(keyPoolToWeight(poolAddress), poolWeight), IntegerEntry(keyPoolSpread(poolAddress), defaultSpread)]), lpAssetIdStr)
468473                                                                         else throw("Strict value is not equal to itself.")
469474                                                                     }
470475                                                                 else throw("Strict value is not equal to itself.")
471476                                                             }
472477                                                         else throw("Strict value is not equal to itself.")
473478                                                     }
474479                                                 else throw("Strict value is not equal to itself.")
475480                                             }
476481                                         else throw("Strict value is not equal to itself.")
477482                                     }
478483                             else throw("Strict value is not equal to itself.")
479484                         }
480485                 }
481486         else throw("Strict value is not equal to itself.")
482487     }
483488 
484489 
485490 
486491 @Callable(i)
487492 func managePool (poolAddress,newStatus) = {
488493     let checkCaller = mustManager(i)
489494     if ((checkCaller == checkCaller))
490495         then {
491496             let poolConfig = getPoolConfig(poolAddress)
492497             let poolStatus = poolConfig[idxPoolStatus]
493498             let lpAssetIdStr = poolConfig[idxPoolLPAssetId]
494499             let amountAssetStr = poolConfig[idxAmtAssetId]
495500             let priceAssetStr = poolConfig[idxPriceAssetId]
496501             let amountAssetsDecimals = parseIntValue(poolConfig[idxAmtAssetDcm])
497502             let priceAssetsDecimals = parseIntValue(poolConfig[idxPriceAssetDcm])
498503             let internalAmountAssetId = parseIntValue(poolConfig[idxIAmtAssetId])
499504             let internalPriceAssetId = parseIntValue(poolConfig[idxIPriceAssetId])
500505             let lpAssetDcm = parseIntValue(poolConfig[idxLPAssetDcm])
501506             let poolType = poolConfig[idxPoolType]
502507 [StringEntry(keyPoolConfig(toString(internalAmountAssetId), toString(internalPriceAssetId)), dataPoolCfg(poolAddress, toString(newStatus), lpAssetIdStr, amountAssetStr, priceAssetStr, amountAssetsDecimals, priceAssetsDecimals, internalAmountAssetId, internalPriceAssetId, lpAssetDcm, poolType))]
503508             }
504509         else throw("Strict value is not equal to itself.")
505510     }
506511 
507512 
508513 
509514 @Callable(i)
510515 func emit (amountToEmit) = {
511516     let caller = i.caller
512517     let originCaller = i.originCaller
513518     let lpAssetRequested = valueOrErrorMessage(getString(keyMappingPoolContractToLPAsset(toString(caller))), "Invalid LP address called me.")
514519     let lpAsset = fromBase58String(lpAssetRequested)
515520     let legacyPools = split(valueOrElse(getString(keyLegacyPools()), EMPTY), SEP)
516521     let legacyFactoryContract = addressFromStringValue(valueOrErrorMessage(getString(keyLegacyFactoryContract()), "Legacy factory contract does not exists."))
517522     if ((0 >= amountToEmit))
518523         then nil
519524         else if (containsElement(legacyPools, toString(caller)))
520525             then $Tuple2(nil, legacyFactoryContract)
521526             else $Tuple2([Reissue(lpAsset, amountToEmit, true), ScriptTransfer(i.caller, amountToEmit, lpAsset)], "success")
522527     }
523528 
524529 
525530 
526531 @Callable(i)
527532 func burn (amountToBurn) = {
528533     let caller = i.caller
529534     let originCaller = i.originCaller
530535     let payment = value(i.payments[0])
531536     let paymentAmount = value(payment.amount)
532537     let inAmountAssetId = toBase58String(value(payment.assetId))
533538     let lpAssetRequestedForBurning = valueOrErrorMessage(getString(keyMappingPoolContractToLPAsset(toString(caller))), "Invalid LP address called me.")
534539     if ((inAmountAssetId != lpAssetRequestedForBurning))
535540         then throw("Invalid asset passed.")
536541         else if ((amountToBurn != paymentAmount))
537542             then throw("Invalid amount passed.")
538543             else {
539544                 let lpAsset = fromBase58String(lpAssetRequestedForBurning)
540545                 $Tuple2([Burn(lpAsset, amountToBurn)], "success")
541546                 }
542547     }
543548 
544549 
545550 
546551 @Callable(i)
547552 func modifyWeight (lpAssetId,share) = {
548553     let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyVotingEmissionContract()), "")))
549554         then true
550555         else mustManager(i)
551556     if ((checkCaller == checkCaller))
552557         then {
553558             let poolContractAddress = getStringOrFail(keyMappingPoolLPAssetToPoolContractAddress(lpAssetId))
554559             let poolWeightKey = keyPoolToWeight(poolContractAddress)
555560             let gwxWeightKey = keyPoolToWeight(GWXvirtualPOOL)
556561             let gwxWeight = valueOrElse(getInteger(gwxWeightKey), 0)
557562             let poolWeight = valueOrElse(getInteger(poolWeightKey), 0)
558563             let poolWeightNew = share
559564             let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
560565             let stakingContract = getStakingAddressOrFail(factoryCfg)
561566             let onModifyWeightInv = invoke(stakingContract, "onModifyWeight", [lpAssetId, poolContractAddress], nil)
562567             if ((onModifyWeightInv == onModifyWeightInv))
563568                 then {
564569                     let gwxVirtualPoolActions = if ((gwxWeight == 0))
565570                         then nil
566571                         else [IntegerEntry(gwxWeightKey, 0)]
567572                     let poolWeightHistoryKey = keyPoolToWeightHistory(poolContractAddress, 0)
568573                     let poolWeightHistoryOrUnit = getInteger(poolWeightHistoryKey)
569574                     let poolWeightHistoryActions = if ((poolWeightHistoryOrUnit == unit))
570575                         then nil
571576                         else [DeleteEntry(poolWeightHistoryKey)]
572577                     (([IntegerEntry(poolWeightKey, poolWeightNew)] ++ gwxVirtualPoolActions) ++ poolWeightHistoryActions)
573578                     }
574579                 else throw("Strict value is not equal to itself.")
575580             }
576581         else throw("Strict value is not equal to itself.")
577582     }
578583 
579584 
580585 
581586 @Callable(i)
582587 func modifyWeights (btcPoolAddress,ethPoolAddress,ethBtcPoolAddress,usdcUsdtPoolAddress) = {
583588     let checkCaller = mustManager(i)
584589     if ((checkCaller == checkCaller))
585590         then {
586591             let ethBtcWeightNew = ((5 * POOLWEIGHTMULT) / 100)
587592             let usdcUsdtWeightNew = ((5 * POOLWEIGHTMULT) / 100)
588593             let weightDecrement = ((5 * POOLWEIGHTMULT) / 100)
589594             let factoryCfg = split(getStringOrFail(keyFactoryConfig()), SEP)
590595             let stakingDapp = getStakingAddressOrFail(factoryCfg)
591596             let gwxRewardDapp = getGwxRewardAddressOrFail(factoryCfg)
592597             let btcWeightKEY = keyPoolToWeight(btcPoolAddress)
593598             let ethWeightKEY = keyPoolToWeight(ethPoolAddress)
594599             let ethBtcWeightKEY = keyPoolToWeight(ethBtcPoolAddress)
595600             let usdcUsdtWeightKEY = keyPoolToWeight(usdcUsdtPoolAddress)
596601             let btcWeight = getIntOrFail(btcWeightKEY)
597602             let ethWeight = getIntOrFail(ethWeightKEY)
598603             let btcWeightNew = (btcWeight - weightDecrement)
599604             let ethWeightNew = (ethWeight - weightDecrement)
600605             if ((0 >= btcWeightNew))
601606                 then throw(("invalid btcWeightNew: " + toString(btcWeightNew)))
602607                 else if ((0 >= ethWeightNew))
603608                     then throw(("invalid ethWeightNew: " + toString(ethWeightNew)))
604609                     else {
605610                         let btcLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(btcPoolAddress))
606611                         let ethLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(ethPoolAddress))
607612                         let ethBtcLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(ethBtcPoolAddress))
608613                         let usdcUsdtLpAssetIdStr = getStringOrFail(keyMappingPoolContractToLPAsset(usdcUsdtPoolAddress))
609614                         let onModifyWeightBtc = invoke(stakingDapp, "onModifyWeight", [btcLpAssetIdStr, btcPoolAddress], nil)
610615                         if ((onModifyWeightBtc == onModifyWeightBtc))
611616                             then {
612617                                 let onModifyWeightEth = invoke(stakingDapp, "onModifyWeight", [ethLpAssetIdStr, ethPoolAddress], nil)
613618                                 if ((onModifyWeightEth == onModifyWeightEth))
614619                                     then {
615620                                         let onModifyWeightEthBtc = invoke(stakingDapp, "onModifyWeight", [ethBtcLpAssetIdStr, ethBtcPoolAddress], nil)
616621                                         if ((onModifyWeightEthBtc == onModifyWeightEthBtc))
617622                                             then {
618623                                                 let onModifyWeightUsdcUsdt = invoke(stakingDapp, "onModifyWeight", [usdcUsdtLpAssetIdStr, usdcUsdtPoolAddress], nil)
619624                                                 if ((onModifyWeightUsdcUsdt == onModifyWeightUsdcUsdt))
620625                                                     then [IntegerEntry(btcWeightKEY, btcWeightNew), IntegerEntry(ethWeightKEY, ethWeightNew), IntegerEntry(ethBtcWeightKEY, ethBtcWeightNew), IntegerEntry(usdcUsdtWeightKEY, usdcUsdtWeightNew), IntegerEntry(keyPoolToWeightHistory(btcPoolAddress, 0), btcWeight), IntegerEntry(keyPoolToWeightHistory(ethPoolAddress, 0), ethWeight), IntegerEntry(keyPoolToWeightHistory(ethBtcPoolAddress, 0), ethBtcWeightNew), IntegerEntry(keyPoolToWeightHistory(usdcUsdtPoolAddress, 0), usdcUsdtWeightNew)]
621626                                                     else throw("Strict value is not equal to itself.")
622627                                                 }
623628                                             else throw("Strict value is not equal to itself.")
624629                                         }
625630                                     else throw("Strict value is not equal to itself.")
626631                                 }
627632                             else throw("Strict value is not equal to itself.")
628633                         }
629634             }
630635         else throw("Strict value is not equal to itself.")
631636     }
632637 
633638 
634639 
635640 @Callable(i)
636641 func checkWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
637642     let haveLabel =     match getBoolean(keyWxEmission(amountAssetId, priceAssetId)) {
638643         case b: Boolean => 
639644             b
640645         case _ => 
641646             false
642647     }
643648     $Tuple2(nil, haveLabel)
644649     }
645650 
646651 
647652 
648653 @Callable(i)
649654 func setWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
650655     let checkCaller = mustAdmin(i)
651656     if ((checkCaller == checkCaller))
652657         then $Tuple2([BooleanEntry(keyWxEmission(amountAssetId, priceAssetId), true)], unit)
653658         else throw("Strict value is not equal to itself.")
654659     }
655660 
656661 
657662 
658663 @Callable(i)
659664 func deleteWxEmissionPoolLabel (amountAssetId,priceAssetId) = {
660665     let checkCaller = if (mustThis(i))
661666         then true
662667         else mustAdmin(i)
663668     if ((checkCaller == checkCaller))
664669         then $Tuple2([DeleteEntry(keyWxEmission(amountAssetId, priceAssetId))], unit)
665670         else throw("Strict value is not equal to itself.")
666671     }
667672 
668673 
669674 
670675 @Callable(i)
671676 func onVerificationLoss (assetId) = {
672677     let checkCaller = if ((toBase58String(i.caller.bytes) == valueOrElse(getString(this, keyAssetsStoreContract()), "")))
673678         then true
674679         else mustManager(i)
675680     if ((checkCaller == checkCaller))
676681         then {
677682             let priceAssets = getPriceAssets()
678683             let checkPriceAssetsSize = if ((size(priceAssets) > 0))
679684                 then true
680685                 else throw("invalid price assets")
681686             if ((checkPriceAssetsSize == checkPriceAssetsSize))
682687                 then {
683688                     func cb (acc,priceAsset) =                     {
684689                         let r = invoke(this, "deleteWxEmissionPoolLabel", [assetId, priceAsset], nil)
685690                         if ((r == r))
686691                             then unit
687692                             else throw("Strict value is not equal to itself.")
688693                         }
689694 
690695                     let actions = {
691696                         let $l = priceAssets
692697                         let $s = size($l)
693698                         let $acc0 = unit
694699                         func $f0_1 ($a,$i) =                         if (($i >= $s))
695700                             then $a
696701                             else cb($a, $l[$i])
697702 
698703                         func $f0_2 ($a,$i) =                         if (($i >= $s))
699704                             then $a
700705                             else throw("List size exceeds 3")
701706 
702707                         $f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
703708                         }
704709                     if ((actions == actions))
705710                         then $Tuple2(nil, unit)
706711                         else throw("Strict value is not equal to itself.")
707712                     }
708713                 else throw("Strict value is not equal to itself.")
709714             }
710715         else throw("Strict value is not equal to itself.")
711716     }
712717 
713718 
714719 
715720 @Callable(i)
716721 func isPoolOneTokenOperationsDisabledREADONLY (poolAddress) = {
717722     let poolConfig = getPoolConfig(poolAddress)
718723     let assetsInternal = $Tuple2(parseIntValue(poolConfig[idxIAmtAssetId]), parseIntValue(poolConfig[idxIPriceAssetId]))
719724     let poolOneTokenOperationsDisabled = valueOrElse(getBoolean(keyPoolOneTokenOperationsDisabled(assetsInternal)), false)
720725     let allPoolsOneTokenOperationsDisabled = valueOrElse(getBoolean(keyAllPoolsOneTokenOperationsDisabled()), false)
721726     $Tuple2(nil, if (allPoolsOneTokenOperationsDisabled)
722727         then true
723728         else poolOneTokenOperationsDisabled)
724729     }
725730 
726731 
727732 @Verifier(tx)
728733 func verify () = {
729734     let targetPublicKey =     match managerPublicKeyOrUnit() {
730735         case pk: ByteVector => 
731736             pk
732737         case _: Unit => 
733738             tx.senderPublicKey
734739         case _ => 
735740             throw("Match error")
736741     }
737742     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
738743     }
739744 
github/deemru/w8io/169f3d6 
87.07 ms ◑