tx · AHowTNniWHkGsBWb4MpYGKJgGHwxuWG9Lofs7FPBKspU

3N1tK7X3jBePJyadqGWXXikv8GMZTjEaUGg:  -0.02000000 Waves

2023.03.10 09:29 [2483613] smart account 3N1tK7X3jBePJyadqGWXXikv8GMZTjEaUGg > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "AHowTNniWHkGsBWb4MpYGKJgGHwxuWG9Lofs7FPBKspU",
    "fee": 2000000,
    "feeAssetId": null,
    "timestamp": 1678429796987,
    "version": 1,
    "sender": "3N1tK7X3jBePJyadqGWXXikv8GMZTjEaUGg",
    "senderPublicKey": "aYCkPk8ZPFwSuum9w1sS8XGMmrcoAx3rXG4t4rgjuw2",
    "proofs": [
        "kJDsSGomFgGSS6YqLpL99fnwQUcemQoZG6VjREZh5qGJFL7aPgW6iNp7GLr2FN59EiXg1B8oL7kW1kgMk93EJ6S"
    ],
    "script": "base64:AAIFAAAAAAAAAG8IAhIECgIICBIECgIICBIECgIIGBIDCgEIEgUKAwgICBIDCgEIEgMKAQgSAwoBCBIECgIICBIECgIICBIECgIICBIDCgEIEgUKAwgIBBIECgIICBIECgIIBBIDCgEIEgMKARgSAwoBCBIAEgMKAQgAAAArAAAAAANTRVACAAAAAl9fAAAAAAVFTVBUWQIAAAAAAAAAAA5zdGF0dXNWZXJpZmllZAAAAAAAAAAAAgAAAAAQc3RhdHVzVW52ZXJpZmllZAAAAAAAAAAAAAAAAAAWbGFiZWxDb21tdW5pdHlWZXJpZmllZAIAAAASQ09NTVVOSVRZX1ZFUklGSUVEAAAAAAxsYWJlbFBvb2xzTHACAAAACFBPT0xTX0xQAAAAAA1kZWZhdWx0TGFiZWxzCQAETAAAAAIFAAAAFmxhYmVsQ29tbXVuaXR5VmVyaWZpZWQJAARMAAAAAgUAAAAMbGFiZWxQb29sc0xwBQAAAANuaWwBAAAAB3Rocm93UEQAAAAACQAAAgAAAAECAAAAEVBlcm1pc3Npb24gZGVuaWVkAQAAAAx0aHJvd05vQXNzZXQAAAAACQAAAgAAAAECAAAAFEFzc2V0IGRvZXNuJ3QgZXhpc3RzAQAAABNrZXlNYW5hZ2VyUHVibGljS2V5AAAAAAIAAAAUJXNfX21hbmFnZXJQdWJsaWNLZXkBAAAAGmtleVBlbmRpbmdNYW5hZ2VyUHVibGljS2V5AAAAAAIAAAAbJXNfX3BlbmRpbmdNYW5hZ2VyUHVibGljS2V5AQAAAA9rZXlBZG1pblB1YktleXMAAAAAAgAAABAlc19fYWRtaW5QdWJLZXlzAQAAABRrZXlVc2VyUG9vbHNDb250cmFjdAAAAAACAAAAFSVzX191c2VyUG9vbHNDb250cmFjdAEAAAASa2V5RmFjdG9yeUNvbnRyYWN0AAAAAAIAAAATJXNfX2ZhY3RvcnlDb250cmFjdAEAAAAKa2V5Q3JlYXRlZAAAAAEAAAAHYXNzZXRJZAkAASwAAAACCQABLAAAAAICAAAACWNyZWF0ZWRfPAUAAAAHYXNzZXRJZAIAAAABPgEAAAAHa2V5TG9nbwAAAAEAAAAHYXNzZXRJZAkAASwAAAACCQABLAAAAAICAAAABmxvZ29fPAUAAAAHYXNzZXRJZAIAAAABPgEAAAAJa2V5VGlja2VyAAAAAQAAAAdhc3NldElkCQABLAAAAAIJAAEsAAAAAgIAAAAIdGlja2VyXzwFAAAAB2Fzc2V0SWQCAAAAAT4BAAAACWtleVN0YXR1cwAAAAEAAAAHYXNzZXRJZAkAASwAAAACCQABLAAAAAICAAAACHN0YXR1c188BQAAAAdhc3NldElkAgAAAAE+AQAAABNrZXlBc3NldFBvb2xzTnVtYmVyAAAAAQAAAAdhc3NldElkCQAEuQAAAAIJAARMAAAAAgIAAAAEJXMlcwkABEwAAAACAgAAAAVwb29scwkABEwAAAACBQAAAAdhc3NldElkBQAAAANuaWwFAAAAA1NFUAEAAAASa2V5VGlja2VyVG9Bc3NldElkAAAAAQAAAAZ0aWNrZXIJAAS5AAAAAgkABEwAAAACAgAAAAQlcyVzCQAETAAAAAICAAAADnRpY2tlcjJhc3NldElkCQAETAAAAAIFAAAABnRpY2tlcgUAAAADbmlsBQAAAANTRVABAAAAEmtleUFzc2V0SWRUb1RpY2tlcgAAAAEAAAAHYXNzZXRJZAkABLkAAAACCQAETAAAAAICAAAABCVzJXMJAARMAAAAAgIAAAAOYXNzZXRJZDJ0aWNrZXIJAARMAAAAAgUAAAAHYXNzZXRJZAUAAAADbmlsBQAAAANTRVABAAAAIGtleUFtb3VudEFuZFByaWNlQXNzZXRzVG9McEFzc2V0AAAAAgAAAAthbW91bnRBc3NldAAAAApwcmljZUFzc2V0CQAEuQAAAAIJAARMAAAAAgIAAAAGJXMlcyVzCQAETAAAAAICAAAAHWFtb3VudEFuZFByaWNlQXNzZXRzVG9McEFzc2V0CQAETAAAAAIFAAAAC2Ftb3VudEFzc2V0CQAETAAAAAIFAAAACnByaWNlQXNzZXQFAAAAA25pbAUAAAADU0VQAQAAACBrZXlMcEFzc2V0VG9BbW91bnRBbmRQcmljZUFzc2V0cwAAAAEAAAAHbHBBc3NldAkABLkAAAACCQAETAAAAAICAAAABCVzJXMJAARMAAAAAgIAAAAdbHBBc3NldFRvQW1vdW50QW5kUHJpY2VBc3NldHMJAARMAAAAAgUAAAAHbHBBc3NldAUAAAADbmlsBQAAAANTRVABAAAADmtleUFzc2V0TGFiZWxzAAAAAQAAAAdhc3NldElkCQAEuQAAAAIJAARMAAAAAgIAAAAEJXMlcwkABEwAAAACAgAAAAZsYWJlbHMJAARMAAAAAgUAAAAHYXNzZXRJZAUAAAADbmlsBQAAAANTRVABAAAACWtleUxhYmVscwAAAAAJAAS5AAAAAgkABEwAAAACAgAAAAIlcwkABEwAAAACAgAAAAZsYWJlbHMFAAAAA25pbAUAAAADU0VQAQAAAAxrZXlBc3NldE5hbWUAAAABAAAAB2Fzc2V0SWQJAAS5AAAAAgkABEwAAAACAgAAAAQlcyVzCQAETAAAAAICAAAACWFzc2V0TmFtZQkABEwAAAACBQAAAAdhc3NldElkBQAAAANuaWwFAAAAA1NFUAEAAAATa2V5QXNzZXREZXNjcmlwdGlvbgAAAAEAAAAHYXNzZXRJZAkABLkAAAACCQAETAAAAAICAAAABCVzJXMJAARMAAAAAgIAAAAQYXNzZXREZXNjcmlwdGlvbgkABEwAAAACBQAAAAdhc3NldElkBQAAAANuaWwFAAAAA1NFUAEAAAAOZ2V0VmFsdWVPckZhaWwAAAADAAAAB2FkZHJlc3MAAAADa2V5AAAABHR5cGUEAAAABWVycm9yCQAEuQAAAAIJAARMAAAAAgIAAAAKbWFuZGF0b3J5IAkABEwAAAACCQAEJQAAAAEFAAAAB2FkZHJlc3MJAARMAAAAAgIAAAABLgkABEwAAAACBQAAAANrZXkJAARMAAAAAgIAAAAPIGlzIG5vdCBkZWZpbmVkBQAAAANuaWwCAAAAAAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACBAAAAAckbWF0Y2gwBQAAAAR0eXBlAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAZTdHJpbmcEAAAAA3N0cgUAAAAHJG1hdGNoMAkABB0AAAACBQAAAAdhZGRyZXNzBQAAAANrZXkDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAA0ludAQAAAADaW50BQAAAAckbWF0Y2gwCQAEGgAAAAIFAAAAB2FkZHJlc3MFAAAAA2tleQkAAAIAAAABAgAAABJpbnZhbGlkIGVudHJ5IHR5cGUFAAAABWVycm9yAQAAAAxnZXRTdHJPckZhaWwAAAACAAAAB2FkZHJlc3MAAAADa2V5CgAAAAABQAkBAAAADmdldFZhbHVlT3JGYWlsAAAAAwUAAAAHYWRkcmVzcwUAAAADa2V5AgAAAAADCQAAAQAAAAIFAAAAAUACAAAABlN0cmluZwUAAAABQAkAAAIAAAABAgAAACJDb3VsZG4ndCBjYXN0IEludHxTdHJpbmcgdG8gU3RyaW5nAQAAAAxnZXRJbnRPckZhaWwAAAACAAAAB2FkZHJlc3MAAAADa2V5CgAAAAABQAkBAAAADmdldFZhbHVlT3JGYWlsAAAAAwUAAAAHYWRkcmVzcwUAAAADa2V5AAAAAAAAAAAAAwkAAAEAAAACBQAAAAFAAgAAAANJbnQFAAAAAUAJAAACAAAAAQIAAAAfQ291bGRuJ3QgY2FzdCBJbnR8U3RyaW5nIHRvIEludAEAAAAKaXNWZXJpZmllZAAAAAEAAAAHYXNzZXRJZAkAAAAAAAACCQEAAAALdmFsdWVPckVsc2UAAAACCQAEHwAAAAEJAQAAAAlrZXlTdGF0dXMAAAABBQAAAAdhc3NldElkBQAAABBzdGF0dXNVbnZlcmlmaWVkBQAAAA5zdGF0dXNWZXJpZmllZAEAAAAJZ2V0TGFiZWxzAAAAAAQAAAAHJG1hdGNoMAkABCIAAAABCQEAAAAJa2V5TGFiZWxzAAAAAAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAGU3RyaW5nBAAAAAFzBQAAAAckbWF0Y2gwAwkAAAAAAAACCQABMQAAAAEFAAAAAXMAAAAAAAAAAAAFAAAAA25pbAkABLUAAAACBQAAAAFzBQAAAANTRVAFAAAAA25pbAEAAAAOZ2V0QXNzZXRMYWJlbHMAAAABAAAAB2Fzc2V0SWQEAAAAByRtYXRjaDAJAAQiAAAAAQkBAAAADmtleUFzc2V0TGFiZWxzAAAAAQUAAAAHYXNzZXRJZAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAGU3RyaW5nBAAAAAFzBQAAAAckbWF0Y2gwAwkAAAAAAAACCQABMQAAAAEFAAAAAXMAAAAAAAAAAAAFAAAAA25pbAkABLUAAAACBQAAAAFzBQAAAANTRVAFAAAAA25pbAEAAAAWbWFuYWdlclB1YmxpY0tleU9yVW5pdAAAAAAEAAAAByRtYXRjaDAJAAQiAAAAAQkBAAAAE2tleU1hbmFnZXJQdWJsaWNLZXkAAAAAAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAZTdHJpbmcEAAAAAXMFAAAAByRtYXRjaDAJAAJZAAAAAQUAAAABcwMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAEVW5pdAUAAAAEdW5pdAkAAAIAAAABAgAAAAtNYXRjaCBlcnJvcgEAAAAdcGVuZGluZ01hbmFnZXJQdWJsaWNLZXlPclVuaXQAAAAABAAAAAckbWF0Y2gwCQAEIgAAAAEJAQAAABprZXlQZW5kaW5nTWFuYWdlclB1YmxpY0tleQAAAAADCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABlN0cmluZwQAAAABcwUAAAAHJG1hdGNoMAkAAlkAAAABBQAAAAFzAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAARVbml0BQAAAAR1bml0CQAAAgAAAAECAAAAC01hdGNoIGVycm9yAQAAAAttdXN0TWFuYWdlcgAAAAEAAAABaQQAAAAHJG1hdGNoMAkBAAAAFm1hbmFnZXJQdWJsaWNLZXlPclVuaXQAAAAAAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAApCeXRlVmVjdG9yBAAAAAJwawUAAAAHJG1hdGNoMAMJAAAAAAAAAggFAAAAAWkAAAAPY2FsbGVyUHVibGljS2V5BQAAAAJwawYJAQAAAAd0aHJvd1BEAAAAAAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAEVW5pdAMJAAAAAAAAAggFAAAAAWkAAAAGY2FsbGVyBQAAAAR0aGlzBgkBAAAAB3Rocm93UEQAAAAACQAAAgAAAAECAAAAC01hdGNoIGVycm9yAQAAAAltdXN0QWRtaW4AAAABAAAAAWkEAAAACGFkbWluUEtzCQAEtQAAAAIJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQiAAAAAQkBAAAAD2tleUFkbWluUHViS2V5cwAAAAAFAAAABUVNUFRZBQAAAANTRVADCQEAAAAPY29udGFpbnNFbGVtZW50AAAAAgUAAAAIYWRtaW5QS3MJAAJYAAAAAQgFAAAAAWkAAAAPY2FsbGVyUHVibGljS2V5BgQAAAAJaXNNYW5hZ2VyCQEAAAALbXVzdE1hbmFnZXIAAAABBQAAAAFpAwkAAAAAAAACBQAAAAlpc01hbmFnZXIFAAAACWlzTWFuYWdlcgYJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAQAAAAlpc0NyZWF0ZWQAAAABAAAAB2Fzc2V0SWQJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQgAAAAAQkBAAAACmtleUNyZWF0ZWQAAAABBQAAAAdhc3NldElkBwEAAAAQdmVyaWZpZWRUb1N0YXR1cwAAAAEAAAAIdmVyaWZpZWQDBQAAAAh2ZXJpZmllZAUAAAAOc3RhdHVzVmVyaWZpZWQFAAAAEHN0YXR1c1VudmVyaWZpZWQBAAAAD2FkZExhYmVsQWN0aW9ucwAAAAMAAAAHYXNzZXRJZAAAAAVsYWJlbAAAAAx0aHJvd09uRXJyb3IEAAAABmxhYmVscwkBAAAACWdldExhYmVscwAAAAAEAAAAC2Fzc2V0TGFiZWxzCQEAAAAOZ2V0QXNzZXRMYWJlbHMAAAABBQAAAAdhc3NldElkBAAAAApjaGVja0xhYmVsAwkBAAAAD2NvbnRhaW5zRWxlbWVudAAAAAIFAAAABmxhYmVscwUAAAAFbGFiZWwGCQAAAgAAAAECAAAAE0xhYmVsIGRvZXNuJ3QgZXhpc3QDCQAAAAAAAAIFAAAACmNoZWNrTGFiZWwFAAAACmNoZWNrTGFiZWwEAAAADm5ld0Fzc2V0TGFiZWxzAwkBAAAAD2NvbnRhaW5zRWxlbWVudAAAAAIFAAAAC2Fzc2V0TGFiZWxzBQAAAAVsYWJlbAMFAAAADHRocm93T25FcnJvcgkAAAIAAAABAgAAABxMYWJlbCBoYXMgYWxyZWFkeSBiZWVuIGFkZGVkBQAAAAthc3NldExhYmVscwkABE0AAAACBQAAAAthc3NldExhYmVscwUAAAAFbGFiZWwJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAADmtleUFzc2V0TGFiZWxzAAAAAQUAAAAHYXNzZXRJZAkABLkAAAACBQAAAA5uZXdBc3NldExhYmVscwUAAAADU0VQBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAQAAABJkZWxldGVMYWJlbEFjdGlvbnMAAAADAAAAB2Fzc2V0SWQAAAAFbGFiZWwAAAAMdGhyb3dPbkVycm9yBAAAAAthc3NldExhYmVscwkBAAAADmdldEFzc2V0TGFiZWxzAAAAAQUAAAAHYXNzZXRJZAQAAAAObmV3QXNzZXRMYWJlbHMDCQEAAAAPY29udGFpbnNFbGVtZW50AAAAAgUAAAALYXNzZXRMYWJlbHMFAAAABWxhYmVsCQAEUQAAAAIFAAAAC2Fzc2V0TGFiZWxzCQEAAAAFdmFsdWUAAAABCQAETwAAAAIFAAAAC2Fzc2V0TGFiZWxzBQAAAAVsYWJlbAMFAAAADHRocm93T25FcnJvcgkAAAIAAAABAgAAABJMYWJlbCB3YXNuJ3QgYWRkZWQFAAAAC2Fzc2V0TGFiZWxzCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAA5rZXlBc3NldExhYmVscwAAAAEFAAAAB2Fzc2V0SWQJAAS5AAAAAgUAAAAObmV3QXNzZXRMYWJlbHMFAAAAA1NFUAUAAAADbmlsAQAAABJzZXRWZXJpZmllZEFjdGlvbnMAAAACAAAAB2Fzc2V0SWQAAAAIdmVyaWZpZWQEAAAAHWxhYmVsQ29tbXVuaXR5VmVyaWZpZWRBY3Rpb25zAwUAAAAIdmVyaWZpZWQJAQAAAA9hZGRMYWJlbEFjdGlvbnMAAAADBQAAAAdhc3NldElkBQAAABZsYWJlbENvbW11bml0eVZlcmlmaWVkBwkBAAAAEmRlbGV0ZUxhYmVsQWN0aW9ucwAAAAMFAAAAB2Fzc2V0SWQFAAAAFmxhYmVsQ29tbXVuaXR5VmVyaWZpZWQHCQAETgAAAAIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAAlrZXlTdGF0dXMAAAABBQAAAAdhc3NldElkCQEAAAAQdmVyaWZpZWRUb1N0YXR1cwAAAAEFAAAACHZlcmlmaWVkBQAAAANuaWwFAAAAHWxhYmVsQ29tbXVuaXR5VmVyaWZpZWRBY3Rpb25zAQAAABN1cGRhdGVUaWNrZXJBY3Rpb25zAAAAAgAAAAdhc3NldElkAAAABnRpY2tlcgQAAAALY2hlY2tUaWNrZXIEAAAAE2xpbmtlZEFzc2V0SWRPclVuaXQJAAQiAAAAAQkBAAAAEmtleVRpY2tlclRvQXNzZXRJZAAAAAEFAAAABnRpY2tlcgQAAAANdGlja2VySXNWYWxpZAMJAQAAAAIhPQAAAAIFAAAABnRpY2tlcgIAAAAAAwkAAAAAAAACBQAAABNsaW5rZWRBc3NldElkT3JVbml0BQAAAAR1bml0BgkAAAAAAAACCQEAAAAFdmFsdWUAAAABBQAAABNsaW5rZWRBc3NldElkT3JVbml0BQAAAAdhc3NldElkBwMFAAAADXRpY2tlcklzVmFsaWQGCQAAAgAAAAECAAAADkludmFsaWQgdGlja2VyAwkAAAAAAAACBQAAAAtjaGVja1RpY2tlcgUAAAALY2hlY2tUaWNrZXIJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAEmtleUFzc2V0SWRUb1RpY2tlcgAAAAEFAAAAB2Fzc2V0SWQFAAAABnRpY2tlcgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAASa2V5VGlja2VyVG9Bc3NldElkAAAAAQUAAAAGdGlja2VyBQAAAAdhc3NldElkBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAFAAAAAFpAQAAAAxzZXRBc3NldE5hbWUAAAACAAAAB2Fzc2V0SUQAAAAJYXNzZXROYW1lBAAAAAtjaGVja0NhbGxlcgkBAAAACW11c3RBZG1pbgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAMa2V5QXNzZXROYW1lAAAAAQUAAAAHYXNzZXRJRAUAAAAJYXNzZXROYW1lBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAAE3NldEFzc2V0RGVzY3JpcHRpb24AAAACAAAAB2Fzc2V0SUQAAAAQYXNzZXREZXNjcmlwdGlvbgQAAAALY2hlY2tDYWxsZXIJAQAAAAltdXN0QWRtaW4AAAABBQAAAAFpAwkAAAAAAAACBQAAAAtjaGVja0NhbGxlcgUAAAALY2hlY2tDYWxsZXIJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAE2tleUFzc2V0RGVzY3JpcHRpb24AAAABBQAAAAdhc3NldElEBQAAABBhc3NldERlc2NyaXB0aW9uBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAAC2NvbnN0cnVjdG9yAAAAAgAAABF1c2VyUG9vbHNDb250cmFjdAAAAAZsYWJlbHMEAAAAC2NoZWNrQ2FsbGVyCQEAAAALbXVzdE1hbmFnZXIAAAABBQAAAAFpAwkAAAAAAAACBQAAAAtjaGVja0NhbGxlcgUAAAALY2hlY2tDYWxsZXIEAAAADWNoZWNrc0FkZHJlc3MJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABCYAAAABBQAAABF1c2VyUG9vbHNDb250cmFjdAIAAAAPSW52YWxpZCBhZGRyZXNzAwkAAAAAAAACBQAAAA1jaGVja3NBZGRyZXNzBQAAAA1jaGVja3NBZGRyZXNzCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABRrZXlVc2VyUG9vbHNDb250cmFjdAAAAAAFAAAAEXVzZXJQb29sc0NvbnRyYWN0CQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAAlrZXlMYWJlbHMAAAAACQAEuQAAAAIJAAROAAAAAgUAAAANZGVmYXVsdExhYmVscwUAAAAGbGFiZWxzBQAAAANTRVAFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAADWNvbnN0cnVjdG9yVjIAAAABAAAAD2ZhY3RvcnlDb250cmFjdAQAAAALY2hlY2tDYWxsZXIJAQAAAAttdXN0TWFuYWdlcgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgQAAAAMY2hlY2tBZGRyZXNzCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQmAAAAAQUAAAAPZmFjdG9yeUNvbnRyYWN0AgAAACBpbnZhbGlkIGZhY3RvcnkgY29udHJhY3QgYWRkcmVzcwMJAAAAAAAAAgUAAAAMY2hlY2tBZGRyZXNzBQAAAAxjaGVja0FkZHJlc3MJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAEmtleUZhY3RvcnlDb250cmFjdAAAAAAFAAAAD2ZhY3RvcnlDb250cmFjdAUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAANYWRkQXNzZXRzTGluawAAAAMAAAALYW1vdW50QXNzZXQAAAAKcHJpY2VBc3NldAAAAAdscEFzc2V0BAAAAAtjaGVja0NhbGxlcgkBAAAACW11c3RBZG1pbgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAga2V5QW1vdW50QW5kUHJpY2VBc3NldHNUb0xwQXNzZXQAAAACBQAAAAthbW91bnRBc3NldAUAAAAKcHJpY2VBc3NldAUAAAAHbHBBc3NldAkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAga2V5THBBc3NldFRvQW1vdW50QW5kUHJpY2VBc3NldHMAAAABBQAAAAdscEFzc2V0CQAEuQAAAAIJAARMAAAAAgUAAAALYW1vdW50QXNzZXQJAARMAAAAAgUAAAAKcHJpY2VBc3NldAUAAAADbmlsBQAAAANTRVAFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAYaW5jcmVhc2VBc3NldFBvb2xzTnVtYmVyAAAAAQAAAAdhc3NldElkBAAAAAtjaGVja0NhbGxlcgkBAAAACW11c3RBZG1pbgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgQAAAATYXNzZXRQb29sc051bWJlcktleQkBAAAAE2tleUFzc2V0UG9vbHNOdW1iZXIAAAABBQAAAAdhc3NldElkBAAAABBhc3NldFBvb2xzTnVtYmVyCQEAAAALdmFsdWVPckVsc2UAAAACCQAEHwAAAAEFAAAAE2Fzc2V0UG9vbHNOdW1iZXJLZXkAAAAAAAAAAAAJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAE2Fzc2V0UG9vbHNOdW1iZXJLZXkJAABkAAAAAgUAAAAQYXNzZXRQb29sc051bWJlcgAAAAAAAAAAAQUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAAtjcmVhdGVMYWJlbAAAAAEAAAAFbGFiZWwEAAAABmxhYmVscwkBAAAACWdldExhYmVscwAAAAAEAAAAC2NoZWNrQ2FsbGVyCQEAAAAJbXVzdEFkbWluAAAAAQUAAAABaQMJAAAAAAAAAgUAAAALY2hlY2tDYWxsZXIFAAAAC2NoZWNrQ2FsbGVyBAAAAApjaGVja0xhYmVsCQAETAAAAAIDCQEAAAABIQAAAAEJAQAAAAhjb250YWlucwAAAAIFAAAABWxhYmVsBQAAAANTRVAGCQAAAgAAAAECAAAAEkludmFsaWQgbGFiZWwgbmFtZQkABEwAAAACAwkBAAAAASEAAAABCQEAAAAPY29udGFpbnNFbGVtZW50AAAAAgUAAAAGbGFiZWxzBQAAAAVsYWJlbAYJAAACAAAAAQIAAAAMTGFiZWwgZXhpc3RzBQAAAANuaWwDCQAAAAAAAAIFAAAACmNoZWNrTGFiZWwFAAAACmNoZWNrTGFiZWwJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAACWtleUxhYmVscwAAAAAJAAS5AAAAAgkABE0AAAACBQAAAAZsYWJlbHMFAAAABWxhYmVsBQAAAANTRVAFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAACWRyb3BMYWJlbAAAAAEAAAAFbGFiZWwEAAAABmxhYmVscwkBAAAACWdldExhYmVscwAAAAAEAAAAC2NoZWNrQ2FsbGVyCQEAAAALbXVzdE1hbmFnZXIAAAABBQAAAAFpAwkAAAAAAAACBQAAAAtjaGVja0NhbGxlcgUAAAALY2hlY2tDYWxsZXIEAAAACmNoZWNrTGFiZWwDCQEAAAAPY29udGFpbnNFbGVtZW50AAAAAgUAAAAGbGFiZWxzBQAAAAVsYWJlbAYJAAACAAAAAQIAAAATTGFiZWwgZG9lc24ndCBleGlzdAMJAAAAAAAAAgUAAAAKY2hlY2tMYWJlbAUAAAAKY2hlY2tMYWJlbAkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAJa2V5TGFiZWxzAAAAAAkABLkAAAACCQAEUQAAAAIFAAAABmxhYmVscwkBAAAABXZhbHVlAAAAAQkABE8AAAACBQAAAAZsYWJlbHMFAAAABWxhYmVsBQAAAANTRVAFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAACGFkZExhYmVsAAAAAgAAAAdhc3NldElkAAAABWxhYmVsBAAAAAtjaGVja0NhbGxlcgkBAAAACW11c3RBZG1pbgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgkBAAAAD2FkZExhYmVsQWN0aW9ucwAAAAMFAAAAB2Fzc2V0SWQFAAAABWxhYmVsBgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAALZGVsZXRlTGFiZWwAAAACAAAAB2Fzc2V0SWQAAAAFbGFiZWwEAAAAC2NoZWNrQ2FsbGVyCQEAAAAJbXVzdEFkbWluAAAAAQUAAAABaQMJAAAAAAAAAgUAAAALY2hlY2tDYWxsZXIFAAAAC2NoZWNrQ2FsbGVyCQEAAAASZGVsZXRlTGFiZWxBY3Rpb25zAAAAAwUAAAAHYXNzZXRJZAUAAAAFbGFiZWwGCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAAx1cGRhdGVUaWNrZXIAAAACAAAAB2Fzc2V0SWQAAAAGdGlja2VyBAAAAAtjaGVja0NhbGxlcgkBAAAACW11c3RBZG1pbgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgQAAAAKY2hlY2tBc3NldAMJAQAAAAlpc0NyZWF0ZWQAAAABBQAAAAdhc3NldElkBgkBAAAADHRocm93Tm9Bc3NldAAAAAADCQAAAAAAAAIFAAAACmNoZWNrQXNzZXQFAAAACmNoZWNrQXNzZXQJAQAAABN1cGRhdGVUaWNrZXJBY3Rpb25zAAAAAgUAAAAHYXNzZXRJZAUAAAAGdGlja2VyCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAMZGVsZXRlVGlja2VyAAAAAQAAAAdhc3NldElkBAAAAAtjaGVja0NhbGxlcgkBAAAACW11c3RBZG1pbgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgQAAAAGdGlja2VyCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQiAAAAAQkBAAAAEmtleUFzc2V0SWRUb1RpY2tlcgAAAAEFAAAAB2Fzc2V0SWQCAAAADUludmFsaWQgYXNzZXQJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkBAAAAEmtleUFzc2V0SWRUb1RpY2tlcgAAAAEFAAAAB2Fzc2V0SWQJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkBAAAAEmtleVRpY2tlclRvQXNzZXRJZAAAAAEFAAAABnRpY2tlcgUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAA5jcmVhdGVPclVwZGF0ZQAAAAMAAAAHYXNzZXRJZAAAAARsb2dvAAAACHZlcmlmaWVkBAAAAAtjaGVja0NhbGxlcgkBAAAACW11c3RBZG1pbgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgQAAAAMaXNDcmVhdGVkTm93CQEAAAABIQAAAAEJAQAAAAlpc0NyZWF0ZWQAAAABBQAAAAdhc3NldElkAwkAAAAAAAACBQAAAAxpc0NyZWF0ZWROb3cFAAAADGlzQ3JlYXRlZE5vdwQAAAAOc2V0TG9nb0FjdGlvbnMDCQAAAAAAAAIFAAAABGxvZ28CAAAAAAUAAAADbmlsCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAAdrZXlMb2dvAAAAAQUAAAAHYXNzZXRJZAUAAAAEbG9nbwUAAAADbmlsCQAFFAAAAAIJAAROAAAAAgkABE4AAAACCQAETAAAAAIJAQAAAAxCb29sZWFuRW50cnkAAAACCQEAAAAKa2V5Q3JlYXRlZAAAAAEFAAAAB2Fzc2V0SWQGBQAAAANuaWwFAAAADnNldExvZ29BY3Rpb25zCQEAAAASc2V0VmVyaWZpZWRBY3Rpb25zAAAAAgUAAAAHYXNzZXRJZAUAAAAIdmVyaWZpZWQFAAAADGlzQ3JlYXRlZE5vdwkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAAB3NldExvZ28AAAACAAAAB2Fzc2V0SWQAAAAEbG9nbwQAAAAGY2hlY2tzCQAETAAAAAIJAQAAAAltdXN0QWRtaW4AAAABBQAAAAFpCQAETAAAAAIDCQEAAAAJaXNDcmVhdGVkAAAAAQUAAAAHYXNzZXRJZAYJAQAAAAx0aHJvd05vQXNzZXQAAAAABQAAAANuaWwDCQAAAAAAAAIFAAAABmNoZWNrcwUAAAAGY2hlY2tzBAAAAAZhY3Rpb24DCQAAAAAAAAIFAAAABGxvZ28CAAAAAAkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkBAAAAB2tleUxvZ28AAAABBQAAAAdhc3NldElkCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAHa2V5TG9nbwAAAAEFAAAAB2Fzc2V0SWQFAAAABGxvZ28JAARMAAAAAgUAAAAGYWN0aW9uBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAAC3NldFZlcmlmaWVkAAAAAgAAAAdhc3NldElkAAAACHZlcmlmaWVkBAAAAAZjaGVja3MJAARMAAAAAgkBAAAACW11c3RBZG1pbgAAAAEFAAAAAWkJAARMAAAAAgMJAQAAAAlpc0NyZWF0ZWQAAAABBQAAAAdhc3NldElkBgkBAAAADHRocm93Tm9Bc3NldAAAAAAFAAAAA25pbAMJAAAAAAAAAgUAAAAGY2hlY2tzBQAAAAZjaGVja3MEAAAAFW9uVmVyaWZpY2F0aW9uTG9zc0ludgMJAQAAAAEhAAAAAQUAAAAIdmVyaWZpZWQEAAAAD2ZhY3RvcnlDb250cmFjdAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEJgAAAAEJAQAAAAxnZXRTdHJPckZhaWwAAAACBQAAAAR0aGlzCQEAAAASa2V5RmFjdG9yeUNvbnRyYWN0AAAAAAIAAAAgaW52YWxpZCBmYWN0b3J5IGNvbnRyYWN0IGFkZHJlc3MJAAP8AAAABAUAAAAPZmFjdG9yeUNvbnRyYWN0AgAAABJvblZlcmlmaWNhdGlvbkxvc3MJAARMAAAAAgUAAAAHYXNzZXRJZAUAAAADbmlsBQAAAANuaWwFAAAABHVuaXQDCQAAAAAAAAIFAAAAFW9uVmVyaWZpY2F0aW9uTG9zc0ludgUAAAAVb25WZXJpZmljYXRpb25Mb3NzSW52CQAFFAAAAAIJAQAAABJzZXRWZXJpZmllZEFjdGlvbnMAAAACBQAAAAdhc3NldElkBQAAAAh2ZXJpZmllZAUAAAAEdW5pdAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAAC29uRWxpbWluYXRlAAAAAQAAAAdhc3NldElkBAAAAAtwb29sc051bWJlcgkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABB8AAAABCQEAAAATa2V5QXNzZXRQb29sc051bWJlcgAAAAEFAAAAB2Fzc2V0SWQAAAAAAAAAAAAEAAAAB2FjdGlvbnMDCQAAZgAAAAIFAAAAC3Bvb2xzTnVtYmVyAAAAAAAAAAAABQAAAANuaWwJAARMAAAAAgkBAAAAC0RlbGV0ZUVudHJ5AAAAAQkBAAAAB2tleUxvZ28AAAABBQAAAAdhc3NldElkBQAAAANuaWwJAAUUAAAAAgUAAAAHYWN0aW9ucwUAAAAEdW5pdAAAAAFpAQAAAAlzZXRBZG1pbnMAAAABAAAADGFkbWluUHViS2V5cwQAAAALY2hlY2tDYWxsZXIJAQAAAAttdXN0TWFuYWdlcgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAPa2V5QWRtaW5QdWJLZXlzAAAAAAkABLkAAAACBQAAAAxhZG1pblB1YktleXMFAAAAA1NFUAUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAApzZXRNYW5hZ2VyAAAAAQAAABdwZW5kaW5nTWFuYWdlclB1YmxpY0tleQQAAAALY2hlY2tDYWxsZXIJAQAAAAttdXN0TWFuYWdlcgAAAAEFAAAAAWkDCQAAAAAAAAIFAAAAC2NoZWNrQ2FsbGVyBQAAAAtjaGVja0NhbGxlcgQAAAAVY2hlY2tNYW5hZ2VyUHVibGljS2V5CQACWQAAAAEFAAAAF3BlbmRpbmdNYW5hZ2VyUHVibGljS2V5AwkAAAAAAAACBQAAABVjaGVja01hbmFnZXJQdWJsaWNLZXkFAAAAFWNoZWNrTWFuYWdlclB1YmxpY0tleQkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAaa2V5UGVuZGluZ01hbmFnZXJQdWJsaWNLZXkAAAAABQAAABdwZW5kaW5nTWFuYWdlclB1YmxpY0tleQUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAAOY29uZmlybU1hbmFnZXIAAAAABAAAAAJwbQkBAAAAHXBlbmRpbmdNYW5hZ2VyUHVibGljS2V5T3JVbml0AAAAAAQAAAAFaGFzUE0DCQEAAAAJaXNEZWZpbmVkAAAAAQUAAAACcG0GCQAAAgAAAAECAAAAEk5vIHBlbmRpbmcgbWFuYWdlcgMJAAAAAAAAAgUAAAAFaGFzUE0FAAAABWhhc1BNBAAAAAdjaGVja1BNAwkAAAAAAAACCAUAAAABaQAAAA9jYWxsZXJQdWJsaWNLZXkJAQAAAAV2YWx1ZQAAAAEFAAAAAnBtBgkAAAIAAAABAgAAABtZb3UgYXJlIG5vdCBwZW5kaW5nIG1hbmFnZXIDCQAAAAAAAAIFAAAAB2NoZWNrUE0FAAAAB2NoZWNrUE0JAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAE2tleU1hbmFnZXJQdWJsaWNLZXkAAAAACQACWAAAAAEJAQAAAAV2YWx1ZQAAAAEFAAAAAnBtCQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEJAQAAABprZXlQZW5kaW5nTWFuYWdlclB1YmxpY0tleQAAAAAFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAAEmlzVmVyaWZpZWRSRUFET05MWQAAAAEAAAAHYXNzZXRJZAkABRQAAAACBQAAAANuaWwJAQAAAAppc1ZlcmlmaWVkAAAAAQUAAAAHYXNzZXRJZAAAAAEAAAACdHgBAAAABnZlcmlmeQAAAAAEAAAAD3RhcmdldFB1YmxpY0tleQQAAAAHJG1hdGNoMAkBAAAAFm1hbmFnZXJQdWJsaWNLZXlPclVuaXQAAAAAAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAApCeXRlVmVjdG9yBAAAAAJwawUAAAAHJG1hdGNoMAUAAAACcGsDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABFVuaXQIBQAAAAJ0eAAAAA9zZW5kZXJQdWJsaWNLZXkJAAACAAAAAQIAAAALTWF0Y2ggZXJyb3IJAAH0AAAAAwgFAAAAAnR4AAAACWJvZHlCeXRlcwkAAZEAAAACCAUAAAACdHgAAAAGcHJvb2ZzAAAAAAAAAAAABQAAAA90YXJnZXRQdWJsaWNLZXkZCooD",
    "chainId": 84,
    "height": 2483613,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: APW6KpiBLmRiNif4QxTZ8zQqZQpdqDgMNcgfYG88KgWz

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let SEP = "__"
5+
6+let EMPTY = ""
7+
8+let statusVerified = 2
9+
10+let statusUnverified = 0
11+
12+let labelCommunityVerified = "COMMUNITY_VERIFIED"
13+
14+let labelPoolsLp = "POOLS_LP"
15+
16+let defaultLabels = [labelCommunityVerified, labelPoolsLp]
17+
18+func throwPD () = throw("Permission denied")
19+
20+
21+func throwNoAsset () = throw("Asset doesn't exists")
22+
23+
24+func keyManagerPublicKey () = "%s__managerPublicKey"
25+
26+
27+func keyPendingManagerPublicKey () = "%s__pendingManagerPublicKey"
28+
29+
30+func keyAdminPubKeys () = "%s__adminPubKeys"
31+
32+
33+func keyUserPoolsContract () = "%s__userPoolsContract"
34+
35+
36+func keyFactoryContract () = "%s__factoryContract"
37+
38+
39+func keyCreated (assetId) = (("created_<" + assetId) + ">")
40+
41+
42+func keyLogo (assetId) = (("logo_<" + assetId) + ">")
43+
44+
45+func keyTicker (assetId) = (("ticker_<" + assetId) + ">")
46+
47+
48+func keyStatus (assetId) = (("status_<" + assetId) + ">")
49+
50+
51+func keyAssetPoolsNumber (assetId) = makeString(["%s%s", "pools", assetId], SEP)
52+
53+
54+func keyTickerToAssetId (ticker) = makeString(["%s%s", "ticker2assetId", ticker], SEP)
55+
56+
57+func keyAssetIdToTicker (assetId) = makeString(["%s%s", "assetId2ticker", assetId], SEP)
58+
59+
60+func keyAmountAndPriceAssetsToLpAsset (amountAsset,priceAsset) = makeString(["%s%s%s", "amountAndPriceAssetsToLpAsset", amountAsset, priceAsset], SEP)
61+
62+
63+func keyLpAssetToAmountAndPriceAssets (lpAsset) = makeString(["%s%s", "lpAssetToAmountAndPriceAssets", lpAsset], SEP)
64+
65+
66+func keyAssetLabels (assetId) = makeString(["%s%s", "labels", assetId], SEP)
67+
68+
69+func keyLabels () = makeString(["%s", "labels"], SEP)
70+
71+
72+func keyAssetName (assetId) = makeString(["%s%s", "assetName", assetId], SEP)
73+
74+
75+func keyAssetDescription (assetId) = makeString(["%s%s", "assetDescription", assetId], SEP)
76+
77+
78+func getValueOrFail (address,key,type) = {
79+    let error = makeString(["mandatory ", toString(address), ".", key, " is not defined"], "")
80+    valueOrErrorMessage(    match type {
81+        case str: String => 
82+            getString(address, key)
83+        case int: Int => 
84+            getInteger(address, key)
85+        case _ => 
86+            throw("invalid entry type")
87+    }, error)
88+    }
89+
90+
91+func getStrOrFail (address,key) = {
92+    let @ = getValueOrFail(address, key, "")
93+    if ($isInstanceOf(@, "String"))
94+        then @
95+        else throw("Couldn't cast Int|String to String")
96+    }
97+
98+
99+func getIntOrFail (address,key) = {
100+    let @ = getValueOrFail(address, key, 0)
101+    if ($isInstanceOf(@, "Int"))
102+        then @
103+        else throw("Couldn't cast Int|String to Int")
104+    }
105+
106+
107+func isVerified (assetId) = (valueOrElse(getInteger(keyStatus(assetId)), statusUnverified) == statusVerified)
108+
109+
110+func getLabels () = match getString(keyLabels()) {
111+    case s: String => 
112+        if ((size(s) == 0))
113+            then nil
114+            else split(s, SEP)
115+    case _ => 
116+        nil
117+}
118+
119+
120+func getAssetLabels (assetId) = match getString(keyAssetLabels(assetId)) {
121+    case s: String => 
122+        if ((size(s) == 0))
123+            then nil
124+            else split(s, SEP)
125+    case _ => 
126+        nil
127+}
128+
129+
130+func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
131+    case s: String => 
132+        fromBase58String(s)
133+    case _: Unit => 
134+        unit
135+    case _ => 
136+        throw("Match error")
137+}
138+
139+
140+func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
141+    case s: String => 
142+        fromBase58String(s)
143+    case _: Unit => 
144+        unit
145+    case _ => 
146+        throw("Match error")
147+}
148+
149+
150+func mustManager (i) = match managerPublicKeyOrUnit() {
151+    case pk: ByteVector => 
152+        if ((i.callerPublicKey == pk))
153+            then true
154+            else throwPD()
155+    case _: Unit => 
156+        if ((i.caller == this))
157+            then true
158+            else throwPD()
159+    case _ => 
160+        throw("Match error")
161+}
162+
163+
164+func mustAdmin (i) = {
165+    let adminPKs = split(valueOrElse(getString(keyAdminPubKeys()), EMPTY), SEP)
166+    if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
167+        then true
168+        else {
169+            let isManager = mustManager(i)
170+            if ((isManager == isManager))
171+                then true
172+                else throw("Strict value is not equal to itself.")
173+            }
174+    }
175+
176+
177+func isCreated (assetId) = valueOrElse(getBoolean(keyCreated(assetId)), false)
178+
179+
180+func verifiedToStatus (verified) = if (verified)
181+    then statusVerified
182+    else statusUnverified
183+
184+
185+func addLabelActions (assetId,label,throwOnError) = {
186+    let labels = getLabels()
187+    let assetLabels = getAssetLabels(assetId)
188+    let checkLabel = if (containsElement(labels, label))
189+        then true
190+        else throw("Label doesn't exist")
191+    if ((checkLabel == checkLabel))
192+        then {
193+            let newAssetLabels = if (containsElement(assetLabels, label))
194+                then if (throwOnError)
195+                    then throw("Label has already been added")
196+                    else assetLabels
197+                else (assetLabels :+ label)
198+[StringEntry(keyAssetLabels(assetId), makeString(newAssetLabels, SEP))]
199+            }
200+        else throw("Strict value is not equal to itself.")
201+    }
202+
203+
204+func deleteLabelActions (assetId,label,throwOnError) = {
205+    let assetLabels = getAssetLabels(assetId)
206+    let newAssetLabels = if (containsElement(assetLabels, label))
207+        then removeByIndex(assetLabels, value(indexOf(assetLabels, label)))
208+        else if (throwOnError)
209+            then throw("Label wasn't added")
210+            else assetLabels
211+[StringEntry(keyAssetLabels(assetId), makeString(newAssetLabels, SEP))]
212+    }
213+
214+
215+func setVerifiedActions (assetId,verified) = {
216+    let labelCommunityVerifiedActions = if (verified)
217+        then addLabelActions(assetId, labelCommunityVerified, false)
218+        else deleteLabelActions(assetId, labelCommunityVerified, false)
219+    ([IntegerEntry(keyStatus(assetId), verifiedToStatus(verified))] ++ labelCommunityVerifiedActions)
220+    }
221+
222+
223+func updateTickerActions (assetId,ticker) = {
224+    let checkTicker = {
225+        let linkedAssetIdOrUnit = getString(keyTickerToAssetId(ticker))
226+        let tickerIsValid = if ((ticker != ""))
227+            then if ((linkedAssetIdOrUnit == unit))
228+                then true
229+                else (value(linkedAssetIdOrUnit) == assetId)
230+            else false
231+        if (tickerIsValid)
232+            then true
233+            else throw("Invalid ticker")
234+        }
235+    if ((checkTicker == checkTicker))
236+        then [StringEntry(keyAssetIdToTicker(assetId), ticker), StringEntry(keyTickerToAssetId(ticker), assetId)]
237+        else throw("Strict value is not equal to itself.")
238+    }
239+
240+
241+@Callable(i)
242+func setAssetName (assetID,assetName) = {
243+    let checkCaller = mustAdmin(i)
244+    if ((checkCaller == checkCaller))
245+        then [StringEntry(keyAssetName(assetID), assetName)]
246+        else throw("Strict value is not equal to itself.")
247+    }
248+
249+
250+
251+@Callable(i)
252+func setAssetDescription (assetID,assetDescription) = {
253+    let checkCaller = mustAdmin(i)
254+    if ((checkCaller == checkCaller))
255+        then [StringEntry(keyAssetDescription(assetID), assetDescription)]
256+        else throw("Strict value is not equal to itself.")
257+    }
258+
259+
260+
261+@Callable(i)
262+func constructor (userPoolsContract,labels) = {
263+    let checkCaller = mustManager(i)
264+    if ((checkCaller == checkCaller))
265+        then {
266+            let checksAddress = valueOrErrorMessage(addressFromString(userPoolsContract), "Invalid address")
267+            if ((checksAddress == checksAddress))
268+                then [StringEntry(keyUserPoolsContract(), userPoolsContract), StringEntry(keyLabels(), makeString((defaultLabels ++ labels), SEP))]
269+                else throw("Strict value is not equal to itself.")
270+            }
271+        else throw("Strict value is not equal to itself.")
272+    }
273+
274+
275+
276+@Callable(i)
277+func constructorV2 (factoryContract) = {
278+    let checkCaller = mustManager(i)
279+    if ((checkCaller == checkCaller))
280+        then {
281+            let checkAddress = valueOrErrorMessage(addressFromString(factoryContract), "invalid factory contract address")
282+            if ((checkAddress == checkAddress))
283+                then [StringEntry(keyFactoryContract(), factoryContract)]
284+                else throw("Strict value is not equal to itself.")
285+            }
286+        else throw("Strict value is not equal to itself.")
287+    }
288+
289+
290+
291+@Callable(i)
292+func addAssetsLink (amountAsset,priceAsset,lpAsset) = {
293+    let checkCaller = mustAdmin(i)
294+    if ((checkCaller == checkCaller))
295+        then [StringEntry(keyAmountAndPriceAssetsToLpAsset(amountAsset, priceAsset), lpAsset), StringEntry(keyLpAssetToAmountAndPriceAssets(lpAsset), makeString([amountAsset, priceAsset], SEP))]
296+        else throw("Strict value is not equal to itself.")
297+    }
298+
299+
300+
301+@Callable(i)
302+func increaseAssetPoolsNumber (assetId) = {
303+    let checkCaller = mustAdmin(i)
304+    if ((checkCaller == checkCaller))
305+        then {
306+            let assetPoolsNumberKey = keyAssetPoolsNumber(assetId)
307+            let assetPoolsNumber = valueOrElse(getInteger(assetPoolsNumberKey), 0)
308+[IntegerEntry(assetPoolsNumberKey, (assetPoolsNumber + 1))]
309+            }
310+        else throw("Strict value is not equal to itself.")
311+    }
312+
313+
314+
315+@Callable(i)
316+func createLabel (label) = {
317+    let labels = getLabels()
318+    let checkCaller = mustAdmin(i)
319+    if ((checkCaller == checkCaller))
320+        then {
321+            let checkLabel = [if (!(contains(label, SEP)))
322+                then true
323+                else throw("Invalid label name"), if (!(containsElement(labels, label)))
324+                then true
325+                else throw("Label exists")]
326+            if ((checkLabel == checkLabel))
327+                then [StringEntry(keyLabels(), makeString((labels :+ label), SEP))]
328+                else throw("Strict value is not equal to itself.")
329+            }
330+        else throw("Strict value is not equal to itself.")
331+    }
332+
333+
334+
335+@Callable(i)
336+func dropLabel (label) = {
337+    let labels = getLabels()
338+    let checkCaller = mustManager(i)
339+    if ((checkCaller == checkCaller))
340+        then {
341+            let checkLabel = if (containsElement(labels, label))
342+                then true
343+                else throw("Label doesn't exist")
344+            if ((checkLabel == checkLabel))
345+                then [StringEntry(keyLabels(), makeString(removeByIndex(labels, value(indexOf(labels, label))), SEP))]
346+                else throw("Strict value is not equal to itself.")
347+            }
348+        else throw("Strict value is not equal to itself.")
349+    }
350+
351+
352+
353+@Callable(i)
354+func addLabel (assetId,label) = {
355+    let checkCaller = mustAdmin(i)
356+    if ((checkCaller == checkCaller))
357+        then addLabelActions(assetId, label, true)
358+        else throw("Strict value is not equal to itself.")
359+    }
360+
361+
362+
363+@Callable(i)
364+func deleteLabel (assetId,label) = {
365+    let checkCaller = mustAdmin(i)
366+    if ((checkCaller == checkCaller))
367+        then deleteLabelActions(assetId, label, true)
368+        else throw("Strict value is not equal to itself.")
369+    }
370+
371+
372+
373+@Callable(i)
374+func updateTicker (assetId,ticker) = {
375+    let checkCaller = mustAdmin(i)
376+    if ((checkCaller == checkCaller))
377+        then {
378+            let checkAsset = if (isCreated(assetId))
379+                then true
380+                else throwNoAsset()
381+            if ((checkAsset == checkAsset))
382+                then updateTickerActions(assetId, ticker)
383+                else throw("Strict value is not equal to itself.")
384+            }
385+        else throw("Strict value is not equal to itself.")
386+    }
387+
388+
389+
390+@Callable(i)
391+func deleteTicker (assetId) = {
392+    let checkCaller = mustAdmin(i)
393+    if ((checkCaller == checkCaller))
394+        then {
395+            let ticker = valueOrErrorMessage(getString(keyAssetIdToTicker(assetId)), "Invalid asset")
396+[DeleteEntry(keyAssetIdToTicker(assetId)), DeleteEntry(keyTickerToAssetId(ticker))]
397+            }
398+        else throw("Strict value is not equal to itself.")
399+    }
400+
401+
402+
403+@Callable(i)
404+func createOrUpdate (assetId,logo,verified) = {
405+    let checkCaller = mustAdmin(i)
406+    if ((checkCaller == checkCaller))
407+        then {
408+            let isCreatedNow = !(isCreated(assetId))
409+            if ((isCreatedNow == isCreatedNow))
410+                then {
411+                    let setLogoActions = if ((logo == ""))
412+                        then nil
413+                        else [StringEntry(keyLogo(assetId), logo)]
414+                    $Tuple2((([BooleanEntry(keyCreated(assetId), true)] ++ setLogoActions) ++ setVerifiedActions(assetId, verified)), isCreatedNow)
415+                    }
416+                else throw("Strict value is not equal to itself.")
417+            }
418+        else throw("Strict value is not equal to itself.")
419+    }
420+
421+
422+
423+@Callable(i)
424+func setLogo (assetId,logo) = {
425+    let checks = [mustAdmin(i), if (isCreated(assetId))
426+        then true
427+        else throwNoAsset()]
428+    if ((checks == checks))
429+        then {
430+            let action = if ((logo == ""))
431+                then DeleteEntry(keyLogo(assetId))
432+                else StringEntry(keyLogo(assetId), logo)
433+[action]
434+            }
435+        else throw("Strict value is not equal to itself.")
436+    }
437+
438+
439+
440+@Callable(i)
441+func setVerified (assetId,verified) = {
442+    let checks = [mustAdmin(i), if (isCreated(assetId))
443+        then true
444+        else throwNoAsset()]
445+    if ((checks == checks))
446+        then {
447+            let onVerificationLossInv = if (!(verified))
448+                then {
449+                    let factoryContract = valueOrErrorMessage(addressFromString(getStrOrFail(this, keyFactoryContract())), "invalid factory contract address")
450+                    invoke(factoryContract, "onVerificationLoss", [assetId], nil)
451+                    }
452+                else unit
453+            if ((onVerificationLossInv == onVerificationLossInv))
454+                then $Tuple2(setVerifiedActions(assetId, verified), unit)
455+                else throw("Strict value is not equal to itself.")
456+            }
457+        else throw("Strict value is not equal to itself.")
458+    }
459+
460+
461+
462+@Callable(i)
463+func onEliminate (assetId) = {
464+    let poolsNumber = valueOrElse(getInteger(keyAssetPoolsNumber(assetId)), 0)
465+    let actions = if ((poolsNumber > 0))
466+        then nil
467+        else [DeleteEntry(keyLogo(assetId))]
468+    $Tuple2(actions, unit)
469+    }
470+
471+
472+
473+@Callable(i)
474+func setAdmins (adminPubKeys) = {
475+    let checkCaller = mustManager(i)
476+    if ((checkCaller == checkCaller))
477+        then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
478+        else throw("Strict value is not equal to itself.")
479+    }
480+
481+
482+
483+@Callable(i)
484+func setManager (pendingManagerPublicKey) = {
485+    let checkCaller = mustManager(i)
486+    if ((checkCaller == checkCaller))
487+        then {
488+            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
489+            if ((checkManagerPublicKey == checkManagerPublicKey))
490+                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
491+                else throw("Strict value is not equal to itself.")
492+            }
493+        else throw("Strict value is not equal to itself.")
494+    }
495+
496+
497+
498+@Callable(i)
499+func confirmManager () = {
500+    let pm = pendingManagerPublicKeyOrUnit()
501+    let hasPM = if (isDefined(pm))
502+        then true
503+        else throw("No pending manager")
504+    if ((hasPM == hasPM))
505+        then {
506+            let checkPM = if ((i.callerPublicKey == value(pm)))
507+                then true
508+                else throw("You are not pending manager")
509+            if ((checkPM == checkPM))
510+                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
511+                else throw("Strict value is not equal to itself.")
512+            }
513+        else throw("Strict value is not equal to itself.")
514+    }
515+
516+
517+
518+@Callable(i)
519+func isVerifiedREADONLY (assetId) = $Tuple2(nil, isVerified(assetId))
520+
521+
522+@Verifier(tx)
523+func verify () = {
524+    let targetPublicKey =     match managerPublicKeyOrUnit() {
525+        case pk: ByteVector => 
526+            pk
527+        case _: Unit => 
528+            tx.senderPublicKey
529+        case _ => 
530+            throw("Match error")
531+    }
532+    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
533+    }
534+
github/deemru/w8io/026f985 
30.79 ms ◑