w8 · tx · Foq···J2Y

tx · Foq63cNApk3swSfz1savBpkrsHpRj28DSy6MgDrq2J2Y

3N1TeiekUQhrqux6LjXWhJjUTrgLPJZxBtT:  -0.01400000 Waves

2021.11.02 14:14 [1773283] smart account 3N1TeiekUQhrqux6LjXWhJjUTrgLPJZxBtT > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Foq63cNApk3swSfz1savBpkrsHpRj28DSy6MgDrq2J2Y",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1635851670816,
    "version": 2,
    "chainId": 84,
    "sender": "3N1TeiekUQhrqux6LjXWhJjUTrgLPJZxBtT",
    "senderPublicKey": "DvHRUamE97xEXsqx1rtLMf6DyHcJkZUs9kwyDVPT4zro",
    "proofs": [
        "45a8FNojaRpZxGYABP4Q4viLzQ3cGo1ijDgDwU9PqYyRJ7mrPhK1C2FjDC5aPtmifNTDYhgPdjoeGWQiDJYRc6o"
    ],
    "script": "base64:AAIFAAAAAAAAAGgIAhIECgIICBIECgIBBBIDCgEBEgASBAoCAQESBAoCCAgSABIDCgEIEgUKAwEBARIECgIBARIECgIIARIECgIICBILCgkIAQECAQIIBAQSBgoECAgBCBIAEgMKAQESAwoBARIECgIIAQAAAD8AAAAACmxQZGVjaW1hbHMAAAAAAAAAAAgAAAAABnNjYWxlOAAAAAAABfXhAAAAAAAMc2NhbGU4QmlnSW50CQABNgAAAAEAAAAAAAX14QAAAAAAB3NjYWxlMTgJAAE2AAAAAQAN4Lazp2QAAAAAAAAKemVyb0JpZ0ludAkAATYAAAABAAAAAAAAAAAAAAAAAANTRVACAAAAAl9fAAAAAAVFTVBUWQIAAAAAAAAAAApQb29sQWN0aXZlAAAAAAAAAAABAAAAAA9Qb29sUHV0RGlzYWJsZWQAAAAAAAAAAAIAAAAAE1Bvb2xNYXRjaGVyRGlzYWJsZWQAAAAAAAAAAAMAAAAADFBvb2xTaHV0ZG93bgAAAAAAAAAABAAAAAAOaWR4UG9vbEFkZHJlc3MAAAAAAAAAAAEAAAAADWlkeFBvb2xTdGF0dXMAAAAAAAAAAAIAAAAAEGlkeFBvb2xMUEFzc2V0SWQAAAAAAAAAAAMAAAAADWlkeEFtdEFzc2V0SWQAAAAAAAAAAAQAAAAAD2lkeFByaWNlQXNzZXRJZAAAAAAAAAAABQAAAAAOaWR4QW10QXNzZXREY20AAAAAAAAAAAYAAAAAEGlkeFByaWNlQXNzZXREY20AAAAAAAAAAAcAAAAADmlkeElBbXRBc3NldElkAAAAAAAAAAAIAAAAABBpZHhJUHJpY2VBc3NldElkAAAAAAAAAAAJAAAAAA1pZHhMUEFzc2V0RGNtAAAAAAAAAAAKAAAAABJpZHhQb29sQW10QXNzZXRBbXQAAAAAAAAAAAEAAAAAFGlkeFBvb2xQcmljZUFzc2V0QW10AAAAAAAAAAACAAAAABFpZHhQb29sTFBBc3NldEFtdAAAAAAAAAAAAwAAAAAZaWR4RmFjdG9yeVN0YWtpbmdDb250cmFjdAAAAAAAAAAAAQAAAAAaaWR4RmFjdG9yeVNsaXBwYWdlQ29udHJhY3QAAAAAAAAAAAcBAAAABXRvWDE4AAAAAgAAAAdvcmlnVmFsAAAADW9yaWdTY2FsZU11bHQJAAE8AAAAAwkAATYAAAABBQAAAAdvcmlnVmFsBQAAAAdzY2FsZTE4CQABNgAAAAEFAAAADW9yaWdTY2FsZU11bHQBAAAAB2Zyb21YMTgAAAACAAAAA3ZhbAAAAA9yZXN1bHRTY2FsZU11bHQJAAGgAAAAAQkAATwAAAADBQAAAAN2YWwJAAE2AAAAAQUAAAAPcmVzdWx0U2NhbGVNdWx0BQAAAAdzY2FsZTE4AQAAAAd0b1NjYWxlAAAAAwAAAANhbXQAAAAIcmVzU2NhbGUAAAAIY3VyU2NhbGUJAABrAAAAAwUAAAADYW10BQAAAAhyZXNTY2FsZQUAAAAIY3VyU2NhbGUBAAAAA2FicwAAAAEAAAADdmFsAwkAAT8AAAACBQAAAAp6ZXJvQmlnSW50BQAAAAN2YWwJAAE+AAAAAQUAAAADdmFsBQAAAAN2YWwBAAAAEmtleUZhY3RvcnlDb250cmFjdAAAAAACAAAAEyVzX19mYWN0b3J5Q29udHJhY3QBAAAAE2tleU1hbmFnZXJQdWJsaWNLZXkAAAAAAgAAABQlc19fbWFuYWdlclB1YmxpY0tleQEAAAAMa2V5UHJpY2VMYXN0AAAAAAIAAAARJXMlc19fcHJpY2VfX2xhc3QBAAAAD2tleVByaWNlSGlzdG9yeQAAAAIAAAABaAAAAAl0aW1lc3RhbXAJAAS5AAAAAgkABEwAAAACAgAAABglcyVzJWQlZF9fcHJpY2VfX2hpc3RvcnkJAARMAAAAAgkAAaQAAAABBQAAAAFoCQAETAAAAAIJAAGkAAAAAQUAAAAJdGltZXN0YW1wBQAAAANuaWwFAAAAA1NFUAEAAAASa2V5UHV0QWN0aW9uQnlVc2VyAAAAAgAAAAt1c2VyQWRkcmVzcwAAAAR0eElkCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAAAslcyVzJXNfX1BfXwUAAAALdXNlckFkZHJlc3MCAAAAAl9fBQAAAAR0eElkAQAAABJrZXlHZXRBY3Rpb25CeVVzZXIAAAACAAAAC3VzZXJBZGRyZXNzAAAABHR4SWQJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAACyVzJXMlc19fR19fBQAAAAt1c2VyQWRkcmVzcwIAAAACX18FAAAABHR4SWQBAAAAC2tleUFtdEFzc2V0AAAAAAIAAAAPJXNfX2Ftb3VudEFzc2V0AQAAAA1rZXlQcmljZUFzc2V0AAAAAAIAAAAOJXNfX3ByaWNlQXNzZXQBAAAADGtleUtIaXN0b3JpYwAAAAIAAAABaAAAAAl0aW1lc3RhbXAJAAS5AAAAAgkABEwAAAACAgAAABMlcyVzJWQlZF9fS19oaXN0b3J5CQAETAAAAAIJAAGkAAAAAQUAAAABaAkABEwAAAACCQABpAAAAAEFAAAACXRpbWVzdGFtcAUAAAADbmlsBQAAAANTRVABAAAAEGtleUZhY3RvcnlDb25maWcAAAAAAgAAABElc19fZmFjdG9yeUNvbmZpZwEAAAApa2V5TWFwcGluZ1Bvb2xDb250cmFjdEFkZHJlc3NUb1Bvb2xBc3NldHMAAAABAAAAE3Bvb2xDb250cmFjdEFkZHJlc3MJAAEsAAAAAgkAASwAAAACAgAAAAglcyVzJXNfXwUAAAATcG9vbENvbnRyYWN0QWRkcmVzcwIAAAAgX19tYXBwaW5nc19fcG9vbENvbnRyYWN0MkxwQXNzZXQBAAAADWtleVBvb2xDb25maWcAAAACAAAACWlBbXRBc3NldAAAAAtpUHJpY2VBc3NldAkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAAAglZCVkJXNfXwUAAAAJaUFtdEFzc2V0AgAAAAJfXwUAAAALaVByaWNlQXNzZXQCAAAACF9fY29uZmlnAQAAAB9rZXlNYXBwaW5nc0Jhc2VBc3NldDJpbnRlcm5hbElkAAAAAQAAAAxiYXNlQXNzZXRTdHIJAAEsAAAAAgIAAAAoJXMlcyVzX19tYXBwaW5nc19fYmFzZUFzc2V0MmludGVybmFsSWRfXwUAAAAMYmFzZUFzc2V0U3RyAQAAABNrZXlBbGxQb29sc1NodXRkb3duAAAAAAIAAAAMJXNfX3NodXRkb3duAQAAAA1rZXlQb29sV2VpZ2h0AAAAAQAAAA9jb250cmFjdEFkZHJlc3MJAAEsAAAAAgIAAAASJXMlc19fcG9vbFdlaWdodF9fBQAAAA9jb250cmFjdEFkZHJlc3MBAAAAD2dldFN0cmluZ09yRmFpbAAAAAIAAAAHYWRkcmVzcwAAAANrZXkJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABB0AAAACBQAAAAdhZGRyZXNzBQAAAANrZXkJAAS5AAAAAgkABEwAAAACAgAAAAptYW5kYXRvcnkgCQAETAAAAAIJAAQlAAAAAQUAAAAHYWRkcmVzcwkABEwAAAACAgAAAAEuCQAETAAAAAIFAAAAA2tleQkABEwAAAACAgAAAA8gaXMgbm90IGRlZmluZWQFAAAAA25pbAIAAAAAAQAAAAxnZXRJbnRPckZhaWwAAAACAAAAB2FkZHJlc3MAAAADa2V5CQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQaAAAAAgUAAAAHYWRkcmVzcwUAAAADa2V5CQAEuQAAAAIJAARMAAAAAgIAAAAKbWFuZGF0b3J5IAkABEwAAAACCQAEJQAAAAEFAAAAB2FkZHJlc3MJAARMAAAAAgIAAAABLgkABEwAAAACBQAAAANrZXkJAARMAAAAAgIAAAAPIGlzIG5vdCBkZWZpbmVkBQAAAANuaWwCAAAAAAAAAAAPZmFjdG9yeUNvbnRyYWN0CQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABCQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAgUAAAAEdGhpcwkBAAAAEmtleUZhY3RvcnlDb250cmFjdAAAAAABAAAAEGlzR2xvYmFsU2h1dGRvd24AAAAACQEAAAALdmFsdWVPckVsc2UAAAACCQAEGwAAAAIFAAAAD2ZhY3RvcnlDb250cmFjdAkBAAAAE2tleUFsbFBvb2xzU2h1dGRvd24AAAAABwEAAAANZ2V0UG9vbENvbmZpZwAAAAAEAAAACGFtdEFzc2V0CQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAgUAAAAEdGhpcwkBAAAAC2tleUFtdEFzc2V0AAAAAAQAAAAKcHJpY2VBc3NldAkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAIFAAAABHRoaXMJAQAAAA1rZXlQcmljZUFzc2V0AAAAAAQAAAALaVByaWNlQXNzZXQJAQAAAAxnZXRJbnRPckZhaWwAAAACBQAAAA9mYWN0b3J5Q29udHJhY3QJAQAAAB9rZXlNYXBwaW5nc0Jhc2VBc3NldDJpbnRlcm5hbElkAAAAAQUAAAAKcHJpY2VBc3NldAQAAAAJaUFtdEFzc2V0CQEAAAAMZ2V0SW50T3JGYWlsAAAAAgUAAAAPZmFjdG9yeUNvbnRyYWN0CQEAAAAfa2V5TWFwcGluZ3NCYXNlQXNzZXQyaW50ZXJuYWxJZAAAAAEFAAAACGFtdEFzc2V0CQAEtQAAAAIJAQAAAA9nZXRTdHJpbmdPckZhaWwAAAACBQAAAA9mYWN0b3J5Q29udHJhY3QJAQAAAA1rZXlQb29sQ29uZmlnAAAAAgkAAaQAAAABBQAAAAlpQW10QXNzZXQJAAGkAAAAAQUAAAALaVByaWNlQXNzZXQFAAAAA1NFUAEAAAAQZ2V0RmFjdG9yeUNvbmZpZwAAAAAJAAS1AAAAAgkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAIFAAAAD2ZhY3RvcnlDb250cmFjdAkBAAAAEGtleUZhY3RvcnlDb25maWcAAAAABQAAAANTRVABAAAAEWRhdGFQdXRBY3Rpb25JbmZvAAAACgAAAA1pbkFtdEFzc2V0QW10AAAAD2luUHJpY2VBc3NldEFtdAAAAAhvdXRMcEFtdAAAAAVwcmljZQAAAB1zbGlwcGFnZVRvbGVyYW5jZVBhc3NlZEJ5VXNlcgAAABVzbGlwcGFnZVRvbGVyYW5jZVJlYWwAAAAIdHhIZWlnaHQAAAALdHhUaW1lc3RhbXAAAAASc2xpcGFnZUFtdEFzc2V0QW10AAAAFHNsaXBhZ2VQcmljZUFzc2V0QW10CQAEuQAAAAIJAARMAAAAAgIAAAAUJWQlZCVkJWQlZCVkJWQlZCVkJWQJAARMAAAAAgkAAaQAAAABBQAAAA1pbkFtdEFzc2V0QW10CQAETAAAAAIJAAGkAAAAAQUAAAAPaW5QcmljZUFzc2V0QW10CQAETAAAAAIJAAGkAAAAAQUAAAAIb3V0THBBbXQJAARMAAAAAgkAAaQAAAABBQAAAAVwcmljZQkABEwAAAACCQABpAAAAAEFAAAAHXNsaXBwYWdlVG9sZXJhbmNlUGFzc2VkQnlVc2VyCQAETAAAAAIJAAGkAAAAAQUAAAAVc2xpcHBhZ2VUb2xlcmFuY2VSZWFsCQAETAAAAAIJAAGkAAAAAQUAAAAIdHhIZWlnaHQJAARMAAAAAgkAAaQAAAABBQAAAAt0eFRpbWVzdGFtcAkABEwAAAACCQABpAAAAAEFAAAAEnNsaXBhZ2VBbXRBc3NldEFtdAkABEwAAAACCQABpAAAAAEFAAAAFHNsaXBhZ2VQcmljZUFzc2V0QW10BQAAAANuaWwFAAAAA1NFUAEAAAARZGF0YUdldEFjdGlvbkluZm8AAAAGAAAADm91dEFtdEFzc2V0QW10AAAAEG91dFByaWNlQXNzZXRBbXQAAAAHaW5McEFtdAAAAAVwcmljZQAAAAh0eEhlaWdodAAAAAt0eFRpbWVzdGFtcAkABLkAAAACCQAETAAAAAICAAAADCVkJWQlZCVkJWQlZAkABEwAAAACCQABpAAAAAEFAAAADm91dEFtdEFzc2V0QW10CQAETAAAAAIJAAGkAAAAAQUAAAAQb3V0UHJpY2VBc3NldEFtdAkABEwAAAACCQABpAAAAAEFAAAAB2luTHBBbXQJAARMAAAAAgkAAaQAAAABBQAAAAVwcmljZQkABEwAAAACCQABpAAAAAEFAAAACHR4SGVpZ2h0CQAETAAAAAIJAAGkAAAAAQUAAAALdHhUaW1lc3RhbXAFAAAAA25pbAUAAAADU0VQAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQAAAAdhc3NldElkAwkAAAAAAAACBQAAAAdhc3NldElkAgAAAAVXQVZFUwgJAAPvAAAAAQUAAAAEdGhpcwAAAAlhdmFpbGFibGUJAAPwAAAAAgUAAAAEdGhpcwkAAlkAAAABBQAAAAdhc3NldElkAQAAAA9jYWxjUHJpY2VCaWdJbnQAAAACAAAACHByQW10WDE4AAAACGFtQW10WDE4CQABPAAAAAMFAAAACHByQW10WDE4BQAAAAdzY2FsZTE4BQAAAAhhbUFtdFgxOAEAAAAQcHJpdmF0ZUNhbGNQcmljZQAAAAQAAAAKYW1Bc3NldERjbQAAAApwckFzc2V0RGNtAAAABWFtQW10AAAABXByQW10BAAAAA5hbXRBc3NldEFtdFgxOAkBAAAABXRvWDE4AAAAAgUAAAAFYW1BbXQFAAAACmFtQXNzZXREY20EAAAAEHByaWNlQXNzZXRBbXRYMTgJAQAAAAV0b1gxOAAAAAIFAAAABXByQW10BQAAAApwckFzc2V0RGNtCQEAAAAPY2FsY1ByaWNlQmlnSW50AAAAAgUAAAAQcHJpY2VBc3NldEFtdFgxOAUAAAAOYW10QXNzZXRBbXRYMTgBAAAACmNhbGNQcmljZXMAAAADAAAABWFtQW10AAAABXByQW10AAAABWxwQW10BAAAAANjZmcJAQAAAA1nZXRQb29sQ29uZmlnAAAAAAQAAAALYW10QXNzZXREY20JAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAANjZmcFAAAADmlkeEFtdEFzc2V0RGNtBAAAAA1wcmljZUFzc2V0RGNtCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAABBpZHhQcmljZUFzc2V0RGNtBAAAAAhwcmljZVgxOAkBAAAAEHByaXZhdGVDYWxjUHJpY2UAAAAEBQAAAAthbXRBc3NldERjbQUAAAANcHJpY2VBc3NldERjbQUAAAAFYW1BbXQFAAAABXByQW10BAAAAAhhbUFtdFgxOAkBAAAABXRvWDE4AAAAAgUAAAAFYW1BbXQFAAAAC2FtdEFzc2V0RGNtBAAAAAhwckFtdFgxOAkBAAAABXRvWDE4AAAAAgUAAAAFcHJBbXQFAAAADXByaWNlQXNzZXREY20EAAAACGxwQW10WDE4CQEAAAAFdG9YMTgAAAACBQAAAAVscEFtdAUAAAAGc2NhbGU4BAAAABNscFByaWNlSW5BbUFzc2V0WDE4CQEAAAAPY2FsY1ByaWNlQmlnSW50AAAAAgUAAAAIYW1BbXRYMTgFAAAACGxwQW10WDE4BAAAABNscFByaWNlSW5QckFzc2V0WDE4CQEAAAAPY2FsY1ByaWNlQmlnSW50AAAAAgUAAAAIcHJBbXRYMTgFAAAACGxwQW10WDE4CQAETAAAAAIFAAAACHByaWNlWDE4CQAETAAAAAIFAAAAE2xwUHJpY2VJbkFtQXNzZXRYMTgJAARMAAAAAgUAAAATbHBQcmljZUluUHJBc3NldFgxOAUAAAADbmlsAQAAAA9jYWxjdWxhdGVQcmljZXMAAAADAAAABWFtQW10AAAABXByQW10AAAABWxwQW10BAAAAAZwcmljZXMJAQAAAApjYWxjUHJpY2VzAAAAAwUAAAAFYW1BbXQFAAAABXByQW10BQAAAAVscEFtdAkABEwAAAACCQEAAAAHZnJvbVgxOAAAAAIJAAGRAAAAAgUAAAAGcHJpY2VzAAAAAAAAAAAABQAAAAZzY2FsZTgJAARMAAAAAgkBAAAAB2Zyb21YMTgAAAACCQABkQAAAAIFAAAABnByaWNlcwAAAAAAAAAAAQUAAAAGc2NhbGU4CQAETAAAAAIJAQAAAAdmcm9tWDE4AAAAAgkAAZEAAAACBQAAAAZwcmljZXMAAAAAAAAAAAIFAAAABnNjYWxlOAUAAAADbmlsAQAAABRlc3RpbWF0ZUdldE9wZXJhdGlvbgAAAAQAAAAGdHhJZDU4AAAACnBtdEFzc2V0SWQAAAAIcG10THBBbXQAAAALdXNlckFkZHJlc3MEAAAAA2NmZwkBAAAADWdldFBvb2xDb25maWcAAAAABAAAAAlscEFzc2V0SWQJAAGRAAAAAgUAAAADY2ZnBQAAABBpZHhQb29sTFBBc3NldElkBAAAAAlhbUFzc2V0SWQJAAGRAAAAAgUAAAADY2ZnBQAAAA1pZHhBbXRBc3NldElkBAAAAAlwckFzc2V0SWQJAAGRAAAAAgUAAAADY2ZnBQAAAA9pZHhQcmljZUFzc2V0SWQEAAAACmFtQXNzZXREY20JAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAANjZmcFAAAADmlkeEFtdEFzc2V0RGNtBAAAAApwckFzc2V0RGNtCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAABBpZHhQcmljZUFzc2V0RGNtBAAAAApwb29sU3RhdHVzCQABkQAAAAIFAAAAA2NmZwUAAAANaWR4UG9vbFN0YXR1cwQAAAAKbHBFbWlzc2lvbggJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkAA+wAAAABCQACWQAAAAEFAAAACWxwQXNzZXRJZAkAASwAAAACCQABLAAAAAICAAAABkFzc2V0IAUAAAAJbHBBc3NldElkAgAAAA4gZG9lc24ndCBleGlzdAAAAAhxdWFudGl0eQMJAQAAAAIhPQAAAAIFAAAACWxwQXNzZXRJZAUAAAAKcG10QXNzZXRJZAkAAAIAAAABAgAAABVJbnZhbGlkIGFzc2V0IHBhc3NlZC4EAAAACWFtQmFsYW5jZQkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAlhbUFzc2V0SWQEAAAADGFtQmFsYW5jZVgxOAkBAAAABXRvWDE4AAAAAgUAAAAJYW1CYWxhbmNlBQAAAAphbUFzc2V0RGNtBAAAAAlwckJhbGFuY2UJAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQUAAAAJcHJBc3NldElkBAAAAAxwckJhbGFuY2VYMTgJAQAAAAV0b1gxOAAAAAIFAAAACXByQmFsYW5jZQUAAAAKcHJBc3NldERjbQQAAAALY3VyUHJpY2VYMTgJAQAAAA9jYWxjUHJpY2VCaWdJbnQAAAACBQAAAAxwckJhbGFuY2VYMTgFAAAADGFtQmFsYW5jZVgxOAQAAAAIY3VyUHJpY2UJAQAAAAdmcm9tWDE4AAAAAgUAAAALY3VyUHJpY2VYMTgFAAAABnNjYWxlOAQAAAALcG10THBBbXRYMTgJAQAAAAV0b1gxOAAAAAIFAAAACHBtdExwQW10BQAAAAZzY2FsZTgEAAAADWxwRW1pc3Npb25YMTgJAQAAAAV0b1gxOAAAAAIFAAAACmxwRW1pc3Npb24FAAAABnNjYWxlOAQAAAALb3V0QW1BbXRYMTgJAAE8AAAAAwUAAAAMYW1CYWxhbmNlWDE4BQAAAAtwbXRMcEFtdFgxOAUAAAANbHBFbWlzc2lvblgxOAQAAAALb3V0UHJBbXRYMTgJAAE8AAAAAwUAAAAMcHJCYWxhbmNlWDE4BQAAAAtwbXRMcEFtdFgxOAUAAAANbHBFbWlzc2lvblgxOAQAAAAIb3V0QW1BbXQJAQAAAAdmcm9tWDE4AAAAAgUAAAALb3V0QW1BbXRYMTgFAAAACmFtQXNzZXREY20EAAAACG91dFByQW10CQEAAAAHZnJvbVgxOAAAAAIFAAAAC291dFByQW10WDE4BQAAAApwckFzc2V0RGNtBAAAAAVzdGF0ZQMJAAAAAAAAAgUAAAAGdHhJZDU4AgAAAAAFAAAAA25pbAkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADBQAAAAt1c2VyQWRkcmVzcwUAAAAIb3V0QW1BbXQDCQAAAAAAAAIFAAAACWFtQXNzZXRJZAIAAAAFV0FWRVMFAAAABHVuaXQJAAJZAAAAAQUAAAAJYW1Bc3NldElkCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMFAAAAC3VzZXJBZGRyZXNzBQAAAAhvdXRQckFtdAMJAAAAAAAAAgUAAAAJcHJBc3NldElkAgAAAAVXQVZFUwUAAAAEdW5pdAkAAlkAAAABBQAAAAlwckFzc2V0SWQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAEmtleUdldEFjdGlvbkJ5VXNlcgAAAAIJAAQlAAAAAQUAAAALdXNlckFkZHJlc3MFAAAABnR4SWQ1OAkBAAAAEWRhdGFHZXRBY3Rpb25JbmZvAAAABgUAAAAIb3V0QW1BbXQFAAAACG91dFByQW10BQAAAAhwbXRMcEFtdAUAAAAIY3VyUHJpY2UFAAAABmhlaWdodAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAAxrZXlQcmljZUxhc3QAAAAABQAAAAhjdXJQcmljZQkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAD2tleVByaWNlSGlzdG9yeQAAAAIFAAAABmhlaWdodAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAFAAAACGN1clByaWNlBQAAAANuaWwJAAUcAAAACgUAAAAIb3V0QW1BbXQFAAAACG91dFByQW10BQAAAAlhbUFzc2V0SWQFAAAACXByQXNzZXRJZAUAAAAJYW1CYWxhbmNlBQAAAAlwckJhbGFuY2UFAAAACmxwRW1pc3Npb24FAAAAC2N1clByaWNlWDE4BQAAAApwb29sU3RhdHVzBQAAAAVzdGF0ZQEAAAAUZXN0aW1hdGVQdXRPcGVyYXRpb24AAAAJAAAABnR4SWQ1OAAAABFzbGlwcGFnZVRvbGVyYW5jZQAAAAxpbkFtQXNzZXRBbXQAAAALaW5BbUFzc2V0SWQAAAAMaW5QckFzc2V0QW10AAAAC2luUHJBc3NldElkAAAAC3VzZXJBZGRyZXNzAAAACmlzRXZhbHVhdGUAAAAGZW1pdExwBAAAAANjZmcJAQAAAA1nZXRQb29sQ29uZmlnAAAAAAQAAAAJbHBBc3NldElkCQACWQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAABBpZHhQb29sTFBBc3NldElkBAAAAAxhbUFzc2V0SWRTdHIJAAGRAAAAAgUAAAADY2ZnBQAAAA1pZHhBbXRBc3NldElkBAAAAAxwckFzc2V0SWRTdHIJAAGRAAAAAgUAAAADY2ZnBQAAAA9pZHhQcmljZUFzc2V0SWQEAAAAC2lBbXRBc3NldElkCQABkQAAAAIFAAAAA2NmZwUAAAAOaWR4SUFtdEFzc2V0SWQEAAAADWlQcmljZUFzc2V0SWQJAAGRAAAAAgUAAAADY2ZnBQAAABBpZHhJUHJpY2VBc3NldElkBAAAAAthbXRBc3NldERjbQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAAA2NmZwUAAAAOaWR4QW10QXNzZXREY20EAAAADXByaWNlQXNzZXREY20JAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAANjZmcFAAAAEGlkeFByaWNlQXNzZXREY20EAAAACnBvb2xTdGF0dXMJAAGRAAAAAgUAAAADY2ZnBQAAAA1pZHhQb29sU3RhdHVzBAAAAApscEVtaXNzaW9uCAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAD7AAAAAEFAAAACWxwQXNzZXRJZAkAASwAAAACCQABLAAAAAICAAAABkFzc2V0IAkAAlgAAAABBQAAAAlscEFzc2V0SWQCAAAADiBkb2Vzbid0IGV4aXN0AAAACHF1YW50aXR5BAAAAA5pbkFtQXNzZXRJZFN0cgkAAlgAAAABCQEAAAALdmFsdWVPckVsc2UAAAACBQAAAAtpbkFtQXNzZXRJZAkAAlkAAAABAgAAAAVXQVZFUwQAAAAOaW5QckFzc2V0SWRTdHIJAAJYAAAAAQkBAAAAC3ZhbHVlT3JFbHNlAAAAAgUAAAALaW5QckFzc2V0SWQJAAJZAAAAAQIAAAAFV0FWRVMDAwkBAAAAAiE9AAAAAgUAAAAMYW1Bc3NldElkU3RyBQAAAA5pbkFtQXNzZXRJZFN0cgYJAQAAAAIhPQAAAAIFAAAADHByQXNzZXRJZFN0cgUAAAAOaW5QckFzc2V0SWRTdHIJAAACAAAAAQIAAAAiSW52YWxpZCBhbXQgb3IgcHJpY2UgYXNzZXQgcGFzc2VkLgQAAAAJYW1CYWxhbmNlAwUAAAAKaXNFdmFsdWF0ZQkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAxhbUFzc2V0SWRTdHIJAABlAAAAAgkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAxhbUFzc2V0SWRTdHIFAAAADGluQW1Bc3NldEFtdAQAAAAJcHJCYWxhbmNlAwUAAAAKaXNFdmFsdWF0ZQkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAxwckFzc2V0SWRTdHIJAABlAAAAAgkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAxwckFzc2V0SWRTdHIFAAAADGluUHJBc3NldEFtdAQAAAAPaW5BbUFzc2V0QW10WDE4CQEAAAAFdG9YMTgAAAACBQAAAAxpbkFtQXNzZXRBbXQFAAAAC2FtdEFzc2V0RGNtBAAAAA9pblByQXNzZXRBbXRYMTgJAQAAAAV0b1gxOAAAAAIFAAAADGluUHJBc3NldEFtdAUAAAANcHJpY2VBc3NldERjbQQAAAAMdXNlclByaWNlWDE4CQEAAAAPY2FsY1ByaWNlQmlnSW50AAAAAgUAAAAPaW5QckFzc2V0QW10WDE4BQAAAA9pbkFtQXNzZXRBbXRYMTgEAAAADGFtQmFsYW5jZVgxOAkBAAAABXRvWDE4AAAAAgUAAAAJYW1CYWxhbmNlBQAAAAthbXRBc3NldERjbQQAAAAMcHJCYWxhbmNlWDE4CQEAAAAFdG9YMTgAAAACBQAAAAlwckJhbGFuY2UFAAAADXByaWNlQXNzZXREY20EAAAAA3JlcwMJAAAAAAAAAgUAAAAKbHBFbWlzc2lvbgAAAAAAAAAAAAQAAAALY3VyUHJpY2VYMTgFAAAACnplcm9CaWdJbnQEAAAAC3NsaXBwYWdlWDE4BQAAAAp6ZXJvQmlnSW50BAAAAAhscEFtdFgxOAkAAHYAAAAGCQABOQAAAAIFAAAAD2luQW1Bc3NldEFtdFgxOAUAAAAPaW5QckFzc2V0QW10WDE4AAAAAAAAAAAACQABNgAAAAEAAAAAAAAAAAUAAAAAAAAAAAEAAAAAAAAAAAAFAAAABERPV04JAAUXAAAABQkBAAAAB2Zyb21YMTgAAAACBQAAAAhscEFtdFgxOAUAAAAGc2NhbGU4CQEAAAAHZnJvbVgxOAAAAAIFAAAAD2luQW1Bc3NldEFtdFgxOAUAAAALYW10QXNzZXREY20JAQAAAAdmcm9tWDE4AAAAAgUAAAAPaW5QckFzc2V0QW10WDE4BQAAAA1wcmljZUFzc2V0RGNtCQEAAAAPY2FsY1ByaWNlQmlnSW50AAAAAgkAATcAAAACBQAAAAxwckJhbGFuY2VYMTgFAAAAD2luUHJBc3NldEFtdFgxOAkAATcAAAACBQAAAAxhbUJhbGFuY2VYMTgFAAAAD2luQW1Bc3NldEFtdFgxOAUAAAALc2xpcHBhZ2VYMTgEAAAAC2N1clByaWNlWDE4CQEAAAAPY2FsY1ByaWNlQmlnSW50AAAAAgUAAAAMcHJCYWxhbmNlWDE4BQAAAAxhbUJhbGFuY2VYMTgEAAAAC3NsaXBwYWdlWDE4CQABPAAAAAMJAQAAAANhYnMAAAABCQABOAAAAAIFAAAAC2N1clByaWNlWDE4BQAAAAx1c2VyUHJpY2VYMTgFAAAAB3NjYWxlMTgFAAAAC2N1clByaWNlWDE4BAAAABRzbGlwcGFnZVRvbGVyYW5jZVgxOAkBAAAABXRvWDE4AAAAAgUAAAARc2xpcHBhZ2VUb2xlcmFuY2UFAAAABnNjYWxlOAMDCQEAAAACIT0AAAACBQAAAAtjdXJQcmljZVgxOAUAAAAKemVyb0JpZ0ludAkAAT8AAAACBQAAAAtzbGlwcGFnZVgxOAUAAAAUc2xpcHBhZ2VUb2xlcmFuY2VYMTgHCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAD1ByaWNlIHNsaXBwYWdlIAkAAaYAAAABBQAAAAtzbGlwcGFnZVgxOAIAAAAeIGV4Y2VlZGVkIHRoZSBwYXNzZWQgbGltaXQgb2YgCQABpgAAAAEFAAAAFHNsaXBwYWdlVG9sZXJhbmNlWDE4BAAAAA1scEVtaXNzaW9uWDE4CQEAAAAFdG9YMTgAAAACBQAAAApscEVtaXNzaW9uBQAAAAZzY2FsZTgEAAAACnByVmlhQW1YMTgJAAE8AAAAAwUAAAAPaW5BbUFzc2V0QW10WDE4BQAAAAtjdXJQcmljZVgxOAUAAAAHc2NhbGUxOAQAAAAKYW1WaWFQclgxOAkAATwAAAADBQAAAA9pblByQXNzZXRBbXRYMTgFAAAAB3NjYWxlMTgFAAAAC2N1clByaWNlWDE4BAAAAAxleHBlY3RlZEFtdHMDCQABPwAAAAIFAAAACnByVmlhQW1YMTgFAAAAD2luUHJBc3NldEFtdFgxOAkABRQAAAACBQAAAAphbVZpYVByWDE4BQAAAA9pblByQXNzZXRBbXRYMTgJAAUUAAAAAgUAAAAPaW5BbUFzc2V0QW10WDE4BQAAAApwclZpYUFtWDE4BAAAABFleHBBbXRBc3NldEFtdFgxOAgFAAAADGV4cGVjdGVkQW10cwAAAAJfMQQAAAATZXhwUHJpY2VBc3NldEFtdFgxOAgFAAAADGV4cGVjdGVkQW10cwAAAAJfMgQAAAAIbHBBbXRYMTgJAAE8AAAAAwUAAAANbHBFbWlzc2lvblgxOAUAAAATZXhwUHJpY2VBc3NldEFtdFgxOAUAAAAMcHJCYWxhbmNlWDE4CQAFFwAAAAUJAQAAAAdmcm9tWDE4AAAAAgUAAAAIbHBBbXRYMTgFAAAABnNjYWxlOAkBAAAAB2Zyb21YMTgAAAACBQAAABFleHBBbXRBc3NldEFtdFgxOAUAAAALYW10QXNzZXREY20JAQAAAAdmcm9tWDE4AAAAAgUAAAATZXhwUHJpY2VBc3NldEFtdFgxOAUAAAANcHJpY2VBc3NldERjbQUAAAALY3VyUHJpY2VYMTgFAAAAC3NsaXBwYWdlWDE4BAAAAAljYWxjTHBBbXQIBQAAAANyZXMAAAACXzEEAAAADmNhbGNBbUFzc2V0UG10CAUAAAADcmVzAAAAAl8yBAAAAA5jYWxjUHJBc3NldFBtdAgFAAAAA3JlcwAAAAJfMwQAAAAIY3VyUHJpY2UJAQAAAAdmcm9tWDE4AAAAAggFAAAAA3JlcwAAAAJfNAUAAAAGc2NhbGU4BAAAAAxzbGlwcGFnZUNhbGMJAQAAAAdmcm9tWDE4AAAAAggFAAAAA3JlcwAAAAJfNQUAAAAGc2NhbGU4AwkAAGcAAAACAAAAAAAAAAAABQAAAAljYWxjTHBBbXQJAAACAAAAAQIAAAA2SW52YWxpZCBjYWxjdWxhdGlvbnMuIExQIGNhbGN1bGF0ZWQgaXMgbGVzcyB0aGFuIHplcm8uBAAAAAllbWl0THBBbXQDCQEAAAABIQAAAAEFAAAABmVtaXRMcAAAAAAAAAAAAAUAAAAJY2FsY0xwQW10BAAAAAZhbURpZmYJAABlAAAAAgUAAAAMaW5BbUFzc2V0QW10BQAAAA5jYWxjQW1Bc3NldFBtdAQAAAAGcHJEaWZmCQAAZQAAAAIFAAAADGluUHJBc3NldEFtdAUAAAAOY2FsY1ByQXNzZXRQbXQEAAAAC2NvbW1vblN0YXRlCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAMa2V5UHJpY2VMYXN0AAAAAAUAAAAIY3VyUHJpY2UJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAA9rZXlQcmljZUhpc3RvcnkAAAACBQAAAAZoZWlnaHQIBQAAAAlsYXN0QmxvY2sAAAAJdGltZXN0YW1wBQAAAAhjdXJQcmljZQkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAASa2V5UHV0QWN0aW9uQnlVc2VyAAAAAgUAAAALdXNlckFkZHJlc3MFAAAABnR4SWQ1OAkBAAAAEWRhdGFQdXRBY3Rpb25JbmZvAAAACgUAAAAOY2FsY0FtQXNzZXRQbXQFAAAADmNhbGNQckFzc2V0UG10BQAAAAllbWl0THBBbXQFAAAACGN1clByaWNlBQAAABFzbGlwcGFnZVRvbGVyYW5jZQUAAAAMc2xpcHBhZ2VDYWxjBQAAAAZoZWlnaHQIBQAAAAlsYXN0QmxvY2sAAAAJdGltZXN0YW1wBQAAAAZhbURpZmYFAAAABnByRGlmZgUAAAADbmlsCQAFHwAAAA0FAAAACWNhbGNMcEFtdAUAAAAJZW1pdExwQW10BQAAAAhjdXJQcmljZQUAAAAJYW1CYWxhbmNlBQAAAAlwckJhbGFuY2UFAAAACmxwRW1pc3Npb24FAAAACWxwQXNzZXRJZAUAAAAKcG9vbFN0YXR1cwUAAAALY29tbW9uU3RhdGUFAAAABmFtRGlmZgUAAAAGcHJEaWZmBQAAAAtpbkFtQXNzZXRJZAUAAAALaW5QckFzc2V0SWQBAAAAG3ZhbGlkYXRlTWF0Y2hlck9yZGVyQWxsb3dlZAAAAAEAAAAFb3JkZXIEAAAAA2NmZwkBAAAADWdldFBvb2xDb25maWcAAAAABAAAAAphbXRBc3NldElkCQABkQAAAAIFAAAAA2NmZwUAAAANaWR4QW10QXNzZXRJZAQAAAAMcHJpY2VBc3NldElkCQABkQAAAAIFAAAAA2NmZwUAAAAPaWR4UHJpY2VBc3NldElkBAAAAApwb29sU3RhdHVzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAAA1pZHhQb29sU3RhdHVzBAAAAAthbXRBc3NldERjbQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAAA2NmZwUAAAAOaWR4QW10QXNzZXREY20EAAAADXByaWNlQXNzZXREY20JAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAANjZmcFAAAAEGlkeFByaWNlQXNzZXREY20EAAAAEmFjY0FtdEFzc2V0QmFsYW5jZQkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAphbXRBc3NldElkBAAAABRhY2NQcmljZUFzc2V0QmFsYW5jZQkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAxwcmljZUFzc2V0SWQEAAAAC2N1clByaWNlWDE4AwkAAAAAAAACCAUAAAAFb3JkZXIAAAAJb3JkZXJUeXBlBQAAAANCdXkJAQAAABBwcml2YXRlQ2FsY1ByaWNlAAAABAUAAAALYW10QXNzZXREY20FAAAADXByaWNlQXNzZXREY20JAABkAAAAAgUAAAASYWNjQW10QXNzZXRCYWxhbmNlCAUAAAAFb3JkZXIAAAAGYW1vdW50BQAAABRhY2NQcmljZUFzc2V0QmFsYW5jZQkBAAAAEHByaXZhdGVDYWxjUHJpY2UAAAAEBQAAAAthbXRBc3NldERjbQUAAAANcHJpY2VBc3NldERjbQkAAGUAAAACBQAAABJhY2NBbXRBc3NldEJhbGFuY2UIBQAAAAVvcmRlcgAAAAZhbW91bnQFAAAAFGFjY1ByaWNlQXNzZXRCYWxhbmNlBAAAAAhjdXJQcmljZQkBAAAAB2Zyb21YMTgAAAACBQAAAAtjdXJQcmljZVgxOAUAAAAGc2NhbGU4AwMDCQEAAAAQaXNHbG9iYWxTaHV0ZG93bgAAAAAGCQAAAAAAAAIFAAAACnBvb2xTdGF0dXMFAAAAE1Bvb2xNYXRjaGVyRGlzYWJsZWQGCQAAAAAAAAIFAAAACnBvb2xTdGF0dXMFAAAADFBvb2xTaHV0ZG93bgkAAAIAAAABAgAAABxFeGNoYW5nZSBvcGVyYXRpb25zIGRpc2FibGVkBAAAAA1vcmRlckFtdEFzc2V0CAgFAAAABW9yZGVyAAAACWFzc2V0UGFpcgAAAAthbW91bnRBc3NldAQAAAAQb3JkZXJBbXRBc3NldFN0cgMJAAAAAAAAAgUAAAANb3JkZXJBbXRBc3NldAUAAAAEdW5pdAIAAAAFV0FWRVMJAAJYAAAAAQkBAAAABXZhbHVlAAAAAQUAAAANb3JkZXJBbXRBc3NldAQAAAAPb3JkZXJQcmljZUFzc2V0CAgFAAAABW9yZGVyAAAACWFzc2V0UGFpcgAAAApwcmljZUFzc2V0BAAAABJvcmRlclByaWNlQXNzZXRTdHIDCQAAAAAAAAIFAAAAD29yZGVyUHJpY2VBc3NldAUAAAAEdW5pdAIAAAAFV0FWRVMJAAJYAAAAAQkBAAAABXZhbHVlAAAAAQUAAAAPb3JkZXJQcmljZUFzc2V0AwMJAQAAAAIhPQAAAAIFAAAAEG9yZGVyQW10QXNzZXRTdHIFAAAACmFtdEFzc2V0SWQGCQEAAAACIT0AAAACBQAAABJvcmRlclByaWNlQXNzZXRTdHIFAAAADHByaWNlQXNzZXRJZAkAAAIAAAABAgAAABNXcm9uZyBvcmRlciBhc3NldHMuBAAAAApvcmRlclByaWNlCAUAAAAFb3JkZXIAAAAFcHJpY2UEAAAACHByaWNlRGNtCQAAawAAAAMFAAAABnNjYWxlOAUAAAANcHJpY2VBc3NldERjbQUAAAALYW10QXNzZXREY20EAAAAEGNhc3RlZE9yZGVyUHJpY2UJAQAAAAd0b1NjYWxlAAAAAwUAAAAKb3JkZXJQcmljZQUAAAAGc2NhbGU4BQAAAAhwcmljZURjbQQAAAARaXNPcmRlclByaWNlVmFsaWQDCQAAAAAAAAIIBQAAAAVvcmRlcgAAAAlvcmRlclR5cGUFAAAAA0J1eQkAAGcAAAACBQAAAAhjdXJQcmljZQUAAAAQY2FzdGVkT3JkZXJQcmljZQkAAGcAAAACBQAAABBjYXN0ZWRPcmRlclByaWNlBQAAAAhjdXJQcmljZQYBAAAACWNvbW1vbkdldAAAAAEAAAABaQMJAQAAAAIhPQAAAAIJAAGQAAAAAQgFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAEJAAACAAAAAQIAAAAdZXhhY3RseSAxIHBheW1lbnQgaXMgZXhwZWN0ZWQEAAAAA3BtdAkBAAAABXZhbHVlAAAAAQkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAQAAAAKcG10QXNzZXRJZAkBAAAABXZhbHVlAAAAAQgFAAAAA3BtdAAAAAdhc3NldElkBAAAAAZwbXRBbXQIBQAAAANwbXQAAAAGYW1vdW50BAAAAANyZXMJAQAAABRlc3RpbWF0ZUdldE9wZXJhdGlvbgAAAAQJAAJYAAAAAQgFAAAAAWkAAAANdHJhbnNhY3Rpb25JZAkAAlgAAAABBQAAAApwbXRBc3NldElkBQAAAAZwbXRBbXQIBQAAAAFpAAAABmNhbGxlcgQAAAAIb3V0QW1BbXQIBQAAAANyZXMAAAACXzEEAAAACG91dFByQW10CAUAAAADcmVzAAAAAl8yBAAAAApwb29sU3RhdHVzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEIBQAAAANyZXMAAAACXzkEAAAABXN0YXRlCAUAAAADcmVzAAAAA18xMAMDCQEAAAAQaXNHbG9iYWxTaHV0ZG93bgAAAAAGCQAAAAAAAAIFAAAACnBvb2xTdGF0dXMFAAAADFBvb2xTaHV0ZG93bgkAAAIAAAABCQABLAAAAAICAAAALEdldCBvcGVyYXRpb24gaXMgYmxvY2tlZCBieSBhZG1pbi4gU3RhdHVzID0gCQABpAAAAAEFAAAACnBvb2xTdGF0dXMJAAUXAAAABQUAAAAIb3V0QW1BbXQFAAAACG91dFByQW10BQAAAAZwbXRBbXQFAAAACnBtdEFzc2V0SWQFAAAABXN0YXRlAQAAAAljb21tb25QdXQAAAADAAAAAWkAAAARc2xpcHBhZ2VUb2xlcmFuY2UAAAAGZW1pdExwAwkBAAAAAiE9AAAAAgkAAZAAAAABCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAgkAAAIAAAABAgAAAB9leGFjdGx5IDIgcGF5bWVudHMgYXJlIGV4cGVjdGVkBAAAAAphbUFzc2V0UG10CQEAAAAFdmFsdWUAAAABCQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAABAAAAApwckFzc2V0UG10CQEAAAAFdmFsdWUAAAABCQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAABBAAAAAZlc3RQdXQJAQAAABRlc3RpbWF0ZVB1dE9wZXJhdGlvbgAAAAkJAAJYAAAAAQgFAAAAAWkAAAANdHJhbnNhY3Rpb25JZAUAAAARc2xpcHBhZ2VUb2xlcmFuY2UIBQAAAAphbUFzc2V0UG10AAAABmFtb3VudAgFAAAACmFtQXNzZXRQbXQAAAAHYXNzZXRJZAgFAAAACnByQXNzZXRQbXQAAAAGYW1vdW50CAUAAAAKcHJBc3NldFBtdAAAAAdhc3NldElkCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgcFAAAABmVtaXRMcAQAAAAKcG9vbFN0YXR1cwkBAAAADXBhcnNlSW50VmFsdWUAAAABCAUAAAAGZXN0UHV0AAAAAl84AwMDCQEAAAAQaXNHbG9iYWxTaHV0ZG93bgAAAAAGCQAAAAAAAAIFAAAACnBvb2xTdGF0dXMFAAAAD1Bvb2xQdXREaXNhYmxlZAYJAAAAAAAAAgUAAAAKcG9vbFN0YXR1cwUAAAAMUG9vbFNodXRkb3duCQAAAgAAAAEJAAEsAAAAAgIAAAAsUHV0IG9wZXJhdGlvbiBpcyBibG9ja2VkIGJ5IGFkbWluLiBTdGF0dXMgPSAJAAGkAAAAAQUAAAAKcG9vbFN0YXR1cwUAAAAGZXN0UHV0AAAAEgAAAAFpAQAAAAtjb25zdHJ1Y3RvcgAAAAIAAAAPZmFjdG9yeUNvbnRyYWN0AAAAEG1hbmFnZXJQdWJsaWNLZXkDCQEAAAACIT0AAAACCAUAAAABaQAAAAZjYWxsZXIFAAAABHRoaXMJAAACAAAAAQIAAAAScGVybWlzc2lvbnMgZGVuaWVkCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABJrZXlGYWN0b3J5Q29udHJhY3QAAAAABQAAAA9mYWN0b3J5Q29udHJhY3QJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAE2tleU1hbmFnZXJQdWJsaWNLZXkAAAAABQAAABBtYW5hZ2VyUHVibGljS2V5BQAAAANuaWwAAAABaQEAAAADcHV0AAAAAgAAABFzbGlwcGFnZVRvbGVyYW5jZQAAAA9zaG91bGRBdXRvU3Rha2UEAAAACmZhY3RvcnlDZmcJAQAAABBnZXRGYWN0b3J5Q29uZmlnAAAAAAQAAAAPc3Rha2luZ0NvbnRyYWN0CQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQmAAAAAQkAAZEAAAACBQAAAApmYWN0b3J5Q2ZnBQAAABlpZHhGYWN0b3J5U3Rha2luZ0NvbnRyYWN0AgAAACFFcnJvci4gSW5jb3JyZWN0IHN0YWtpbmcgYWRkcmVzcy4EAAAAEHNsaXBwYWdlQ29udHJhY3QJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABCYAAAABCQABkQAAAAIFAAAACmZhY3RvcnlDZmcFAAAAGmlkeEZhY3RvcnlTbGlwcGFnZUNvbnRyYWN0AgAAACtFcnJvci4gSW5jb3JyZWN0IHNsaXBwYWdlIGNvbnRyYWN0IGFkZHJlc3MuAwkAAGYAAAACAAAAAAAAAAAABQAAABFzbGlwcGFnZVRvbGVyYW5jZQkAAAIAAAABAgAAACBJbnZhbGlkIHNsaXBwYWdlVG9sZXJhbmNlIHBhc3NlZAQAAAAGZXN0UHV0CQEAAAAJY29tbW9uUHV0AAAAAwUAAAABaQUAAAARc2xpcHBhZ2VUb2xlcmFuY2UGBAAAAAllbWl0THBBbXQIBQAAAAZlc3RQdXQAAAACXzIEAAAACWxwQXNzZXRJZAgFAAAABmVzdFB1dAAAAAJfNwQAAAAFc3RhdGUIBQAAAAZlc3RQdXQAAAACXzkEAAAABmFtRGlmZggFAAAABmVzdFB1dAAAAANfMTAEAAAABnByRGlmZggFAAAABmVzdFB1dAAAAANfMTEEAAAABGFtSWQIBQAAAAZlc3RQdXQAAAADXzEyBAAAAARwcklkCAUAAAAGZXN0UHV0AAAAA18xMwQAAAAHZW1pdEludgkAA/wAAAAEBQAAAA9mYWN0b3J5Q29udHJhY3QCAAAABGVtaXQJAARMAAAAAgUAAAAJZW1pdExwQW10BQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAAHZW1pdEludgUAAAAHZW1pdEludgQAAAAMc2xpcHBhZ2VBSW52AwkAAGYAAAACBQAAAAZhbURpZmYAAAAAAAAAAAAJAAP8AAAABAUAAAAQc2xpcHBhZ2VDb250cmFjdAIAAAADcHV0BQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIFAAAABGFtSWQFAAAABmFtRGlmZgUAAAADbmlsBQAAAANuaWwDCQAAAAAAAAIFAAAADHNsaXBwYWdlQUludgUAAAAMc2xpcHBhZ2VBSW52BAAAAAxzbGlwcGFnZVBJbnYDCQAAZgAAAAIFAAAABnByRGlmZgAAAAAAAAAAAAkAA/wAAAAEBQAAABBzbGlwcGFnZUNvbnRyYWN0AgAAAANwdXQFAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgUAAAAEcHJJZAUAAAAGcHJEaWZmBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAAMc2xpcHBhZ2VQSW52BQAAAAxzbGlwcGFnZVBJbnYEAAAACmxwVHJhbnNmZXIDBQAAAA9zaG91bGRBdXRvU3Rha2UEAAAAC3NscFN0YWtlSW52CQAD/AAAAAQFAAAAD3N0YWtpbmdDb250cmFjdAIAAAAFc3Rha2UFAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgUAAAAJbHBBc3NldElkBQAAAAllbWl0THBBbXQFAAAAA25pbAMJAAAAAAAAAgUAAAALc2xwU3Rha2VJbnYFAAAAC3NscFN0YWtlSW52BQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMIBQAAAAFpAAAABmNhbGxlcgUAAAAJZW1pdExwQW10BQAAAAlscEFzc2V0SWQFAAAAA25pbAkABE4AAAACBQAAAAVzdGF0ZQUAAAAKbHBUcmFuc2ZlcgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAApwdXRGb3JGcmVlAAAAAQAAAAttYXhTbGlwcGFnZQMJAABmAAAAAgAAAAAAAAAAAAUAAAALbWF4U2xpcHBhZ2UJAAACAAAAAQIAAAAUSW52YWxpZCB2YWx1ZSBwYXNzZWQEAAAABmVzdFB1dAkBAAAACWNvbW1vblB1dAAAAAMFAAAAAWkFAAAAC21heFNsaXBwYWdlBwgFAAAABmVzdFB1dAAAAAJfOQAAAAFpAQAAAANnZXQAAAAABAAAAANyZXMJAQAAAAljb21tb25HZXQAAAABBQAAAAFpBAAAAAlvdXRBbXRBbXQIBQAAAANyZXMAAAACXzEEAAAACG91dFByQW10CAUAAAADcmVzAAAAAl8yBAAAAAZwbXRBbXQIBQAAAANyZXMAAAACXzMEAAAACnBtdEFzc2V0SWQIBQAAAANyZXMAAAACXzQEAAAABXN0YXRlCAUAAAADcmVzAAAAAl81BAAAABRidXJuTFBBc3NldE9uRmFjdG9yeQkAA/wAAAAEBQAAAA9mYWN0b3J5Q29udHJhY3QCAAAABGJ1cm4JAARMAAAAAgUAAAAGcG10QW10BQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIFAAAACnBtdEFzc2V0SWQFAAAABnBtdEFtdAUAAAADbmlsAwkAAAAAAAACBQAAABRidXJuTFBBc3NldE9uRmFjdG9yeQUAAAAUYnVybkxQQXNzZXRPbkZhY3RvcnkFAAAABXN0YXRlCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAAlnZXROb0xlc3MAAAACAAAAEm5vTGVzc1RoZW5BbXRBc3NldAAAABRub0xlc3NUaGVuUHJpY2VBc3NldAQAAAADcmVzCQEAAAAJY29tbW9uR2V0AAAAAQUAAAABaQQAAAAIb3V0QW1BbXQIBQAAAANyZXMAAAACXzEEAAAACG91dFByQW10CAUAAAADcmVzAAAAAl8yBAAAAAZwbXRBbXQIBQAAAANyZXMAAAACXzMEAAAACnBtdEFzc2V0SWQIBQAAAANyZXMAAAACXzQEAAAABXN0YXRlCAUAAAADcmVzAAAAAl81AwkAAGYAAAACBQAAABJub0xlc3NUaGVuQW10QXNzZXQFAAAACG91dEFtQW10CQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAHG5vTGVzc1RoZW5BbXRBc3NldCBmYWlsZWQ6ICAJAAGkAAAAAQUAAAAIb3V0QW1BbXQCAAAAAyA8IAkAAaQAAAABBQAAABJub0xlc3NUaGVuQW10QXNzZXQDCQAAZgAAAAIFAAAAFG5vTGVzc1RoZW5QcmljZUFzc2V0BQAAAAhvdXRQckFtdAkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAAB1ub0xlc3NUaGVuUHJpY2VBc3NldCBmYWlsZWQ6IAkAAaQAAAABBQAAAAhvdXRQckFtdAIAAAADIDwgCQABpAAAAAEFAAAAFG5vTGVzc1RoZW5QcmljZUFzc2V0BAAAABRidXJuTFBBc3NldE9uRmFjdG9yeQkAA/wAAAAEBQAAAA9mYWN0b3J5Q29udHJhY3QCAAAABGJ1cm4JAARMAAAAAgUAAAAGcG10QW10BQAAAANuaWwJAARMAAAAAgkBAAAAD0F0dGFjaGVkUGF5bWVudAAAAAIFAAAACnBtdEFzc2V0SWQFAAAABnBtdEFtdAUAAAADbmlsAwkAAAAAAAACBQAAABRidXJuTFBBc3NldE9uRmFjdG9yeQUAAAAUYnVybkxQQXNzZXRPbkZhY3RvcnkFAAAABXN0YXRlCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAAAhhY3RpdmF0ZQAAAAIAAAALYW10QXNzZXRTdHIAAAANcHJpY2VBc3NldFN0cgMJAQAAAAIhPQAAAAIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyCQAEJQAAAAEFAAAAD2ZhY3RvcnlDb250cmFjdAkAAAIAAAABAgAAABJwZXJtaXNzaW9ucyBkZW5pZWQJAAUUAAAAAgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAALa2V5QW10QXNzZXQAAAAABQAAAAthbXRBc3NldFN0cgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAANa2V5UHJpY2VBc3NldAAAAAAFAAAADXByaWNlQXNzZXRTdHIFAAAAA25pbAIAAAAHc3VjY2VzcwAAAAFpAQAAABxnZXRQb29sQ29uZmlnV3JhcHBlclJFQURPTkxZAAAAAAkABRQAAAACBQAAAANuaWwJAQAAAA1nZXRQb29sQ29uZmlnAAAAAAAAAAFpAQAAABxnZXRBY2NCYWxhbmNlV3JhcHBlclJFQURPTkxZAAAAAQAAAAdhc3NldElkCQAFFAAAAAIFAAAAA25pbAkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAdhc3NldElkAAAAAWkBAAAAGWNhbGNQcmljZXNXcmFwcGVyUkVBRE9OTFkAAAADAAAABWFtQW10AAAABXByQW10AAAABWxwQW10BAAAAAZwcmljZXMJAQAAAApjYWxjUHJpY2VzAAAAAwUAAAAFYW1BbXQFAAAABXByQW10BQAAAAVscEFtdAkABRQAAAACBQAAAANuaWwJAARMAAAAAgkAAaYAAAABCQABkQAAAAIFAAAABnByaWNlcwAAAAAAAAAAAAkABEwAAAACCQABpgAAAAEJAAGRAAAAAgUAAAAGcHJpY2VzAAAAAAAAAAABCQAETAAAAAIJAAGmAAAAAQkAAZEAAAACBQAAAAZwcmljZXMAAAAAAAAAAAIFAAAAA25pbAAAAAFpAQAAABR0b1gxOFdyYXBwZXJSRUFET05MWQAAAAIAAAAHb3JpZ1ZhbAAAAA1vcmlnU2NhbGVNdWx0CQAFFAAAAAIFAAAAA25pbAkAAaYAAAABCQEAAAAFdG9YMTgAAAACBQAAAAdvcmlnVmFsBQAAAA1vcmlnU2NhbGVNdWx0AAAAAWkBAAAAFmZyb21YMThXcmFwcGVyUkVBRE9OTFkAAAACAAAAA3ZhbAAAAA9yZXN1bHRTY2FsZU11bHQJAAUUAAAAAgUAAAADbmlsCQEAAAAHZnJvbVgxOAAAAAIJAAGnAAAAAQUAAAADdmFsBQAAAA9yZXN1bHRTY2FsZU11bHQAAAABaQEAAAAeY2FsY1ByaWNlQmlnSW50V3JhcHBlclJFQURPTkxZAAAAAgAAAAhwckFtdFgxOAAAAAhhbUFtdFgxOAkABRQAAAACBQAAAANuaWwJAAGmAAAAAQkBAAAAD2NhbGNQcmljZUJpZ0ludAAAAAIJAAGnAAAAAQUAAAAIcHJBbXRYMTgJAAGnAAAAAQUAAAAIYW1BbXRYMTgAAAABaQEAAAAjZXN0aW1hdGVQdXRPcGVyYXRpb25XcmFwcGVyUkVBRE9OTFkAAAAJAAAABnR4SWQ1OAAAABFzbGlwcGFnZVRvbGVyYW5jZQAAAAxpbkFtQXNzZXRBbXQAAAALaW5BbUFzc2V0SWQAAAAMaW5QckFzc2V0QW10AAAAC2luUHJBc3NldElkAAAAC3VzZXJBZGRyZXNzAAAACmlzRXZhbHVhdGUAAAAGZW1pdExwBAAAAAplc3RpbWF0aW9uCQEAAAAUZXN0aW1hdGVQdXRPcGVyYXRpb24AAAAJBQAAAAZ0eElkNTgFAAAAEXNsaXBwYWdlVG9sZXJhbmNlBQAAAAxpbkFtQXNzZXRBbXQFAAAAC2luQW1Bc3NldElkBQAAAAxpblByQXNzZXRBbXQFAAAAC2luUHJBc3NldElkBQAAAAt1c2VyQWRkcmVzcwUAAAAKaXNFdmFsdWF0ZQUAAAAGZW1pdExwBAAAAA0kdDAyNTM2ODI1NTg5BQAAAAplc3RpbWF0aW9uBAAAAAljYWxjTHBBbXQIBQAAAA0kdDAyNTM2ODI1NTg5AAAAAl8xBAAAAAllbWl0THBBbXQIBQAAAA0kdDAyNTM2ODI1NTg5AAAAAl8yBAAAAAhjdXJQcmljZQgFAAAADSR0MDI1MzY4MjU1ODkAAAACXzMEAAAACWFtQmFsYW5jZQgFAAAADSR0MDI1MzY4MjU1ODkAAAACXzQEAAAACXByQmFsYW5jZQgFAAAADSR0MDI1MzY4MjU1ODkAAAACXzUEAAAACmxwRW1pc3Npb24IBQAAAA0kdDAyNTM2ODI1NTg5AAAAAl82BAAAAAlscEFzc2V0SWQIBQAAAA0kdDAyNTM2ODI1NTg5AAAAAl83BAAAAApwb29sU3RhdHVzCAUAAAANJHQwMjUzNjgyNTU4OQAAAAJfOAQAAAALY29tbW9uU3RhdGUIBQAAAA0kdDAyNTM2ODI1NTg5AAAAAl85BAAAAAZhbURpZmYIBQAAAA0kdDAyNTM2ODI1NTg5AAAAA18xMAQAAAAGcHJEaWZmCAUAAAANJHQwMjUzNjgyNTU4OQAAAANfMTEEAAAADGluQW10QXNzZXRJZAgFAAAADSR0MDI1MzY4MjU1ODkAAAADXzEyBAAAAA5pblByaWNlQXNzZXRJZAgFAAAADSR0MDI1MzY4MjU1ODkAAAADXzEzCQAFFAAAAAIFAAAAA25pbAkABR8AAAANBQAAAAljYWxjTHBBbXQFAAAACWVtaXRMcEFtdAUAAAAIY3VyUHJpY2UFAAAACWFtQmFsYW5jZQUAAAAJcHJCYWxhbmNlBQAAAApscEVtaXNzaW9uBQAAAAlscEFzc2V0SWQFAAAACnBvb2xTdGF0dXMFAAAAC2NvbW1vblN0YXRlBQAAAAZhbURpZmYFAAAABnByRGlmZgUAAAAMaW5BbXRBc3NldElkBQAAAA5pblByaWNlQXNzZXRJZAAAAAFpAQAAACNlc3RpbWF0ZUdldE9wZXJhdGlvbldyYXBwZXJSRUFET05MWQAAAAQAAAAGdHhJZDU4AAAACnBtdEFzc2V0SWQAAAAIcG10THBBbXQAAAALdXNlckFkZHJlc3MEAAAACmVzdGltYXRpb24JAQAAABRlc3RpbWF0ZUdldE9wZXJhdGlvbgAAAAQFAAAABnR4SWQ1OAUAAAAKcG10QXNzZXRJZAUAAAAIcG10THBBbXQJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEFAAAAC3VzZXJBZGRyZXNzBAAAAA0kdDAyNjEwNjI2Mjc1BQAAAAplc3RpbWF0aW9uBAAAAAhvdXRBbUFtdAgFAAAADSR0MDI2MTA2MjYyNzUAAAACXzEEAAAACG91dFByQW10CAUAAAANJHQwMjYxMDYyNjI3NQAAAAJfMgQAAAAJYW1Bc3NldElkCAUAAAANJHQwMjYxMDYyNjI3NQAAAAJfMwQAAAAJcHJBc3NldElkCAUAAAANJHQwMjYxMDYyNjI3NQAAAAJfNAQAAAAJYW1CYWxhbmNlCAUAAAANJHQwMjYxMDYyNjI3NQAAAAJfNQQAAAAJcHJCYWxhbmNlCAUAAAANJHQwMjYxMDYyNjI3NQAAAAJfNgQAAAAKbHBFbWlzc2lvbggFAAAADSR0MDI2MTA2MjYyNzUAAAACXzcEAAAAC2N1clByaWNlWDE4CAUAAAANJHQwMjYxMDYyNjI3NQAAAAJfOAQAAAAKcG9vbFN0YXR1cwgFAAAADSR0MDI2MTA2MjYyNzUAAAACXzkEAAAABXN0YXRlCAUAAAANJHQwMjYxMDYyNjI3NQAAAANfMTAJAAUUAAAAAgUAAAADbmlsCQAFHAAAAAoFAAAACG91dEFtQW10BQAAAAhvdXRQckFtdAUAAAAJYW1Bc3NldElkBQAAAAlwckFzc2V0SWQFAAAACWFtQmFsYW5jZQUAAAAJcHJCYWxhbmNlBQAAAApscEVtaXNzaW9uCQABpgAAAAEFAAAAC2N1clByaWNlWDE4BQAAAApwb29sU3RhdHVzBQAAAAVzdGF0ZQAAAAFpAQAAAA1zdGF0c1JFQURPTkxZAAAAAAQAAAADY2ZnCQEAAAANZ2V0UG9vbENvbmZpZwAAAAAEAAAACWxwQXNzZXRJZAkAAlkAAAABCQABkQAAAAIFAAAAA2NmZwUAAAAQaWR4UG9vbExQQXNzZXRJZAQAAAAKYW10QXNzZXRJZAkAAZEAAAACBQAAAANjZmcFAAAADWlkeEFtdEFzc2V0SWQEAAAADHByaWNlQXNzZXRJZAkAAZEAAAACBQAAAANjZmcFAAAAD2lkeFByaWNlQXNzZXRJZAQAAAALaUFtdEFzc2V0SWQJAAGRAAAAAgUAAAADY2ZnBQAAAA5pZHhJQW10QXNzZXRJZAQAAAANaVByaWNlQXNzZXRJZAkAAZEAAAACBQAAAANjZmcFAAAAEGlkeElQcmljZUFzc2V0SWQEAAAAC2FtdEFzc2V0RGNtCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAAA5pZHhBbXRBc3NldERjbQQAAAANcHJpY2VBc3NldERjbQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAAA2NmZwUAAAAQaWR4UHJpY2VBc3NldERjbQQAAAANcG9vbExQQmFsYW5jZQgJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkAA+wAAAABBQAAAAlscEFzc2V0SWQJAAEsAAAAAgkAASwAAAACAgAAAAZBc3NldCAJAAJYAAAAAQUAAAAJbHBBc3NldElkAgAAAA4gZG9lc24ndCBleGlzdAAAAAhxdWFudGl0eQQAAAASYWNjQW10QXNzZXRCYWxhbmNlCQEAAAANZ2V0QWNjQmFsYW5jZQAAAAEFAAAACmFtdEFzc2V0SWQEAAAAFGFjY1ByaWNlQXNzZXRCYWxhbmNlCQEAAAANZ2V0QWNjQmFsYW5jZQAAAAEFAAAADHByaWNlQXNzZXRJZAQAAAAKcHJpY2VzTGlzdAkBAAAACmNhbGNQcmljZXMAAAADBQAAABJhY2NBbXRBc3NldEJhbGFuY2UFAAAAFGFjY1ByaWNlQXNzZXRCYWxhbmNlBQAAAA1wb29sTFBCYWxhbmNlBAAAAAhjdXJQcmljZQAAAAAAAAAAAAQAAAAPbHBBbXRBc3NldFNoYXJlCQEAAAAHZnJvbVgxOAAAAAIJAAGRAAAAAgUAAAAKcHJpY2VzTGlzdAAAAAAAAAAAAQUAAAAGc2NhbGU4BAAAABFscFByaWNlQXNzZXRTaGFyZQkBAAAAB2Zyb21YMTgAAAACCQABkQAAAAIFAAAACnByaWNlc0xpc3QAAAAAAAAAAAIFAAAABnNjYWxlOAQAAAAKcG9vbFdlaWdodAkBAAAABXZhbHVlAAAAAQkABBoAAAACBQAAAA9mYWN0b3J5Q29udHJhY3QJAQAAAA1rZXlQb29sV2VpZ2h0AAAAAQkABCUAAAABBQAAAAR0aGlzCQAFFAAAAAIFAAAAA25pbAkABLkAAAACCQAETAAAAAICAAAADiVkJWQlZCVkJWQlZCVkCQAETAAAAAIJAAGkAAAAAQUAAAASYWNjQW10QXNzZXRCYWxhbmNlCQAETAAAAAIJAAGkAAAAAQUAAAAUYWNjUHJpY2VBc3NldEJhbGFuY2UJAARMAAAAAgkAAaQAAAABBQAAAA1wb29sTFBCYWxhbmNlCQAETAAAAAIJAAGkAAAAAQUAAAAIY3VyUHJpY2UJAARMAAAAAgkAAaQAAAABBQAAAA9scEFtdEFzc2V0U2hhcmUJAARMAAAAAgkAAaQAAAABBQAAABFscFByaWNlQXNzZXRTaGFyZQkABEwAAAACCQABpAAAAAEFAAAACnBvb2xXZWlnaHQFAAAAA25pbAUAAAADU0VQAAAAAWkBAAAAIGV2YWx1YXRlUHV0QnlBbW91bnRBc3NldFJFQURPTkxZAAAAAQAAAAxpbkFtQXNzZXRBbXQEAAAAA2NmZwkBAAAADWdldFBvb2xDb25maWcAAAAABAAAAAlscEFzc2V0SWQJAAJZAAAAAQkAAZEAAAACBQAAAANjZmcFAAAAEGlkeFBvb2xMUEFzc2V0SWQEAAAADGFtQXNzZXRJZFN0cgkAAZEAAAACBQAAAANjZmcFAAAADWlkeEFtdEFzc2V0SWQEAAAACWFtQXNzZXRJZAkAAlkAAAABBQAAAAxhbUFzc2V0SWRTdHIEAAAADHByQXNzZXRJZFN0cgkAAZEAAAACBQAAAANjZmcFAAAAD2lkeFByaWNlQXNzZXRJZAQAAAAJcHJBc3NldElkCQACWQAAAAEFAAAADHByQXNzZXRJZFN0cgQAAAALYW10QXNzZXREY20JAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAANjZmcFAAAADmlkeEFtdEFzc2V0RGNtBAAAAA1wcmljZUFzc2V0RGNtCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAABBpZHhQcmljZUFzc2V0RGNtBAAAAApwb29sU3RhdHVzCQABkQAAAAIFAAAAA2NmZwUAAAANaWR4UG9vbFN0YXR1cwQAAAANcG9vbExQQmFsYW5jZQgJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkAA+wAAAABBQAAAAlscEFzc2V0SWQJAAEsAAAAAgkAASwAAAACAgAAAAZBc3NldCAJAAJYAAAAAQUAAAAJbHBBc3NldElkAgAAAA4gZG9lc24ndCBleGlzdAAAAAhxdWFudGl0eQQAAAASYWNjQW10QXNzZXRCYWxhbmNlCQEAAAANZ2V0QWNjQmFsYW5jZQAAAAEFAAAADGFtQXNzZXRJZFN0cgQAAAAUYWNjUHJpY2VBc3NldEJhbGFuY2UJAQAAAA1nZXRBY2NCYWxhbmNlAAAAAQUAAAAMcHJBc3NldElkU3RyBAAAAA5hbXRBc3NldEFtdFgxOAkBAAAABXRvWDE4AAAAAgUAAAASYWNjQW10QXNzZXRCYWxhbmNlBQAAAAthbXRBc3NldERjbQQAAAAQcHJpY2VBc3NldEFtdFgxOAkBAAAABXRvWDE4AAAAAgUAAAAUYWNjUHJpY2VBc3NldEJhbGFuY2UFAAAADXByaWNlQXNzZXREY20EAAAAC2N1clByaWNlWDE4AwkAAAAAAAACBQAAAA1wb29sTFBCYWxhbmNlAAAAAAAAAAAABQAAAAp6ZXJvQmlnSW50CQEAAAAPY2FsY1ByaWNlQmlnSW50AAAAAgUAAAAQcHJpY2VBc3NldEFtdFgxOAUAAAAOYW10QXNzZXRBbXRYMTgEAAAAD2luQW1Bc3NldEFtdFgxOAkBAAAABXRvWDE4AAAAAgUAAAAMaW5BbUFzc2V0QW10BQAAAAthbXRBc3NldERjbQQAAAAPaW5QckFzc2V0QW10WDE4CQABPAAAAAMFAAAAD2luQW1Bc3NldEFtdFgxOAUAAAALY3VyUHJpY2VYMTgFAAAAB3NjYWxlMTgEAAAADGluUHJBc3NldEFtdAkBAAAAB2Zyb21YMTgAAAACBQAAAA9pblByQXNzZXRBbXRYMTgFAAAADXByaWNlQXNzZXREY20EAAAABmVzdFB1dAkBAAAAFGVzdGltYXRlUHV0T3BlcmF0aW9uAAAACQIAAAAAAAAAAAAAB6EgBQAAAAxpbkFtQXNzZXRBbXQFAAAACWFtQXNzZXRJZAUAAAAMaW5QckFzc2V0QW10BQAAAAlwckFzc2V0SWQCAAAAAAYHBAAAAAljYWxjTHBBbXQIBQAAAAZlc3RQdXQAAAACXzEEAAAADGN1clByaWNlQ2FsYwgFAAAABmVzdFB1dAAAAAJfMwQAAAAJYW1CYWxhbmNlCAUAAAAGZXN0UHV0AAAAAl80BAAAAAlwckJhbGFuY2UIBQAAAAZlc3RQdXQAAAACXzUEAAAACmxwRW1pc3Npb24IBQAAAAZlc3RQdXQAAAACXzYJAAUUAAAAAgUAAAADbmlsCQAEuQAAAAIJAARMAAAAAgIAAAAQJWQlZCVkJWQlZCVkJWQlZAkABEwAAAACCQABpAAAAAEFAAAACWNhbGNMcEFtdAkABEwAAAACCQABpAAAAAEJAQAAAAdmcm9tWDE4AAAAAgUAAAALY3VyUHJpY2VYMTgFAAAABnNjYWxlOAkABEwAAAACCQABpAAAAAEFAAAACWFtQmFsYW5jZQkABEwAAAACCQABpAAAAAEFAAAACXByQmFsYW5jZQkABEwAAAACCQABpAAAAAEFAAAACmxwRW1pc3Npb24JAARMAAAAAgUAAAAKcG9vbFN0YXR1cwkABEwAAAACCQABpAAAAAEFAAAADGluQW1Bc3NldEFtdAkABEwAAAACCQABpAAAAAEFAAAADGluUHJBc3NldEFtdAUAAAADbmlsBQAAAANTRVAAAAABaQEAAAAfZXZhbHVhdGVQdXRCeVByaWNlQXNzZXRSRUFET05MWQAAAAEAAAAMaW5QckFzc2V0QW10BAAAAANjZmcJAQAAAA1nZXRQb29sQ29uZmlnAAAAAAQAAAAJbHBBc3NldElkCQACWQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAABBpZHhQb29sTFBBc3NldElkBAAAAAxhbUFzc2V0SWRTdHIJAAGRAAAAAgUAAAADY2ZnBQAAAA1pZHhBbXRBc3NldElkBAAAAAlhbUFzc2V0SWQJAAJZAAAAAQUAAAAMYW1Bc3NldElkU3RyBAAAAAxwckFzc2V0SWRTdHIJAAGRAAAAAgUAAAADY2ZnBQAAAA9pZHhQcmljZUFzc2V0SWQEAAAACXByQXNzZXRJZAkAAlkAAAABBQAAAAxwckFzc2V0SWRTdHIEAAAAC2FtdEFzc2V0RGNtCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAADY2ZnBQAAAA5pZHhBbXRBc3NldERjbQQAAAANcHJpY2VBc3NldERjbQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAAA2NmZwUAAAAQaWR4UHJpY2VBc3NldERjbQQAAAAKcG9vbFN0YXR1cwkAAZEAAAACBQAAAANjZmcFAAAADWlkeFBvb2xTdGF0dXMEAAAADXBvb2xMUEJhbGFuY2UICQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAPsAAAAAQUAAAAJbHBBc3NldElkCQABLAAAAAIJAAEsAAAAAgIAAAAGQXNzZXQgCQACWAAAAAEFAAAACWxwQXNzZXRJZAIAAAAOIGRvZXNuJ3QgZXhpc3QAAAAIcXVhbnRpdHkEAAAADGFtQmFsYW5jZVJhdwkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAxhbUFzc2V0SWRTdHIEAAAADHByQmFsYW5jZVJhdwkBAAAADWdldEFjY0JhbGFuY2UAAAABBQAAAAxwckFzc2V0SWRTdHIEAAAAD2FtQmFsYW5jZVJhd1gxOAkBAAAABXRvWDE4AAAAAgUAAAAMYW1CYWxhbmNlUmF3BQAAAAthbXRBc3NldERjbQQAAAAPcHJCYWxhbmNlUmF3WDE4CQEAAAAFdG9YMTgAAAACBQAAAAxwckJhbGFuY2VSYXcFAAAADXByaWNlQXNzZXREY20EAAAAC2N1clByaWNlWDE4AwkAAAAAAAACBQAAAA1wb29sTFBCYWxhbmNlAAAAAAAAAAAABQAAAAp6ZXJvQmlnSW50CQEAAAAPY2FsY1ByaWNlQmlnSW50AAAAAgUAAAAPcHJCYWxhbmNlUmF3WDE4BQAAAA9hbUJhbGFuY2VSYXdYMTgEAAAAD2luUHJBc3NldEFtdFgxOAkBAAAABXRvWDE4AAAAAgUAAAAMaW5QckFzc2V0QW10BQAAAA1wcmljZUFzc2V0RGNtBAAAAA9pbkFtQXNzZXRBbXRYMTgJAAE8AAAAAwUAAAAPaW5QckFzc2V0QW10WDE4BQAAAAdzY2FsZTE4BQAAAAtjdXJQcmljZVgxOAQAAAAMaW5BbUFzc2V0QW10CQEAAAAHZnJvbVgxOAAAAAIFAAAAD2luQW1Bc3NldEFtdFgxOAUAAAALYW10QXNzZXREY20EAAAABmVzdFB1dAkBAAAAFGVzdGltYXRlUHV0T3BlcmF0aW9uAAAACQIAAAAAAAAAAAAAB6EgBQAAAAxpbkFtQXNzZXRBbXQFAAAACWFtQXNzZXRJZAUAAAAMaW5QckFzc2V0QW10BQAAAAlwckFzc2V0SWQCAAAAAAYHBAAAAAljYWxjTHBBbXQIBQAAAAZlc3RQdXQAAAACXzEEAAAADGN1clByaWNlQ2FsYwgFAAAABmVzdFB1dAAAAAJfMwQAAAAJYW1CYWxhbmNlCAUAAAAGZXN0UHV0AAAAAl80BAAAAAlwckJhbGFuY2UIBQAAAAZlc3RQdXQAAAACXzUEAAAACmxwRW1pc3Npb24IBQAAAAZlc3RQdXQAAAACXzYJAAUUAAAAAgUAAAADbmlsCQAEuQAAAAIJAARMAAAAAgIAAAAQJWQlZCVkJWQlZCVkJWQlZAkABEwAAAACCQABpAAAAAEFAAAACWNhbGNMcEFtdAkABEwAAAACCQABpAAAAAEJAQAAAAdmcm9tWDE4AAAAAgUAAAALY3VyUHJpY2VYMTgFAAAABnNjYWxlOAkABEwAAAACCQABpAAAAAEFAAAACWFtQmFsYW5jZQkABEwAAAACCQABpAAAAAEFAAAACXByQmFsYW5jZQkABEwAAAACCQABpAAAAAEFAAAACmxwRW1pc3Npb24JAARMAAAAAgUAAAAKcG9vbFN0YXR1cwkABEwAAAACCQABpAAAAAEFAAAADGluQW1Bc3NldEFtdAkABEwAAAACCQABpAAAAAEFAAAADGluUHJBc3NldEFtdAUAAAADbmlsBQAAAANTRVAAAAABaQEAAAATZXZhbHVhdGVHZXRSRUFET05MWQAAAAIAAAAQcGF5bWVudExwQXNzZXRJZAAAAAxwYXltZW50THBBbXQEAAAAA3JlcwkBAAAAFGVzdGltYXRlR2V0T3BlcmF0aW9uAAAABAIAAAAABQAAABBwYXltZW50THBBc3NldElkBQAAAAxwYXltZW50THBBbXQFAAAABHRoaXMEAAAACG91dEFtQW10CAUAAAADcmVzAAAAAl8xBAAAAAhvdXRQckFtdAgFAAAAA3JlcwAAAAJfMgQAAAAJYW1CYWxhbmNlCAUAAAADcmVzAAAAAl81BAAAAAlwckJhbGFuY2UIBQAAAANyZXMAAAACXzYEAAAACmxwRW1pc3Npb24IBQAAAANyZXMAAAACXzcEAAAACGN1clByaWNlCAUAAAADcmVzAAAAAl84BAAAAApwb29sU3RhdHVzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEIBQAAAANyZXMAAAACXzkJAAUUAAAAAgUAAAADbmlsCQAEuQAAAAIJAARMAAAAAgIAAAAOJWQlZCVkJWQlZCVkJWQJAARMAAAAAgkAAaQAAAABBQAAAAhvdXRBbUFtdAkABEwAAAACCQABpAAAAAEFAAAACG91dFByQW10CQAETAAAAAIJAAGkAAAAAQUAAAAJYW1CYWxhbmNlCQAETAAAAAIJAAGkAAAAAQUAAAAJcHJCYWxhbmNlCQAETAAAAAIJAAGkAAAAAQUAAAAKbHBFbWlzc2lvbgkABEwAAAACCQABpgAAAAEFAAAACGN1clByaWNlCQAETAAAAAIJAAGkAAAAAQUAAAAKcG9vbFN0YXR1cwUAAAADbmlsBQAAAANTRVAAAAABAAAAAnR4AQAAAAZ2ZXJpZnkAAAAABAAAAAckbWF0Y2gwBQAAAAJ0eAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAFT3JkZXIEAAAABW9yZGVyBQAAAAckbWF0Y2gwAwkBAAAAG3ZhbGlkYXRlTWF0Y2hlck9yZGVyQWxsb3dlZAAAAAEFAAAABW9yZGVyCQAB9AAAAAMIBQAAAAVvcmRlcgAAAAlib2R5Qnl0ZXMJAAGRAAAAAggFAAAABW9yZGVyAAAABnByb29mcwAAAAAAAAAAAAgFAAAABW9yZGVyAAAAD3NlbmRlclB1YmxpY0tleQcEAAAADW1hbmFnZXJQdWJsaWMJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQdAAAAAgUAAAAEdGhpcwkBAAAAE2tleU1hbmFnZXJQdWJsaWNLZXkAAAAABQAAAAVFTVBUWQMJAAAAAAAAAgUAAAANbWFuYWdlclB1YmxpYwUAAAAFRU1QVFkJAAH0AAAAAwgFAAAAAnR4AAAACWJvZHlCeXRlcwkAAZEAAAACCAUAAAACdHgAAAAGcHJvb2ZzAAAAAAAAAAAACAUAAAACdHgAAAAPc2VuZGVyUHVibGljS2V5CQAB9AAAAAMIBQAAAAJ0eAAAAAlib2R5Qnl0ZXMJAAGRAAAAAggFAAAAAnR4AAAABnByb29mcwAAAAAAAAAAAAkAAlkAAAABBQAAAA1tYW5hZ2VyUHVibGljSeg+Qw==",
    "height": 1773283,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8jqXcFEV6zmEWiJGpDPZZSPGZkKWQYmdTWR6nHo2adui
Next: 61xgwaHNsNaSMdpaN2KCnfRFfUo7u1mGFFQxc3WWZvnU

Diff: 
Old New Differences
516 516  
517 517  @Callable(i)
518 518  func estimatePutOperationWrapperREADONLY (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = {
519 -     let $t02517425559 = estimatePutOperation(txId58, slippageTolerance, inAmAssetAmt, inAmAssetId, inPrAssetAmt, inPrAssetId, userAddress, isEvaluate, emitLp)
520 -     let calcLpAmt = $t02517425559._1
521 -     let emitLpAmt = $t02517425559._2
522 -     let curPrice = $t02517425559._3
523 -     let amBalance = $t02517425559._4
524 -     let prBalance = $t02517425559._5
525 -     let lpEmission = $t02517425559._6
526 -     let lpAssetId = $t02517425559._7
527 -     let poolStatus = $t02517425559._8
528 -     let commonState = $t02517425559._9
529 -     let amDiff = $t02517425559._10
530 -     let prDiff = $t02517425559._11
531 -     let inAmtAssetId = $t02517425559._12
532 -     let inPriceAssetId = $t02517425559._13
519 +     let estimation = estimatePutOperation(txId58, slippageTolerance, inAmAssetAmt, inAmAssetId, inPrAssetAmt, inPrAssetId, userAddress, isEvaluate, emitLp)
520 +     let $t02536825589 = estimation
521 +     let calcLpAmt = $t02536825589._1
522 +     let emitLpAmt = $t02536825589._2
523 +     let curPrice = $t02536825589._3
524 +     let amBalance = $t02536825589._4
525 +     let prBalance = $t02536825589._5
526 +     let lpEmission = $t02536825589._6
527 +     let lpAssetId = $t02536825589._7
528 +     let poolStatus = $t02536825589._8
529 +     let commonState = $t02536825589._9
530 +     let amDiff = $t02536825589._10
531 +     let prDiff = $t02536825589._11
532 +     let inAmtAssetId = $t02536825589._12
533 +     let inPriceAssetId = $t02536825589._13
533 534      $Tuple2(nil, $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmtAssetId, inPriceAssetId))
534 535      }
535 536  
537 538  
538 539  @Callable(i)
539 540  func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
540 -     let $t02594826215 = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
541 -     let outAmAmt = $t02594826215._1
542 -     let outPrAmt = $t02594826215._2
543 -     let amAssetId = $t02594826215._3
544 -     let prAssetId = $t02594826215._4
545 -     let amBalance = $t02594826215._5
546 -     let prBalance = $t02594826215._6
547 -     let lpEmission = $t02594826215._7
548 -     let curPriceX18 = $t02594826215._8
549 -     let poolStatus = $t02594826215._9
550 -     let state = $t02594826215._10
541 +     let estimation = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
542 +     let $t02610626275 = estimation
543 +     let outAmAmt = $t02610626275._1
544 +     let outPrAmt = $t02610626275._2
545 +     let amAssetId = $t02610626275._3
546 +     let prAssetId = $t02610626275._4
547 +     let amBalance = $t02610626275._5
548 +     let prBalance = $t02610626275._6
549 +     let lpEmission = $t02610626275._7
550 +     let curPriceX18 = $t02610626275._8
551 +     let poolStatus = $t02610626275._9
552 +     let state = $t02610626275._10
551 553      $Tuple2(nil, $Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, toString(curPriceX18), poolStatus, state))
552 554      }
553 555  
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 5 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let lPdecimals = 8
5 5  
6 6  let scale8 = 100000000
7 7  
8 8  let scale8BigInt = toBigInt(100000000)
9 9  
10 10  let scale18 = toBigInt(1000000000000000000)
11 11  
12 12  let zeroBigInt = toBigInt(0)
13 13  
14 14  let SEP = "__"
15 15  
16 16  let EMPTY = ""
17 17  
18 18  let PoolActive = 1
19 19  
20 20  let PoolPutDisabled = 2
21 21  
22 22  let PoolMatcherDisabled = 3
23 23  
24 24  let PoolShutdown = 4
25 25  
26 26  let idxPoolAddress = 1
27 27  
28 28  let idxPoolStatus = 2
29 29  
30 30  let idxPoolLPAssetId = 3
31 31  
32 32  let idxAmtAssetId = 4
33 33  
34 34  let idxPriceAssetId = 5
35 35  
36 36  let idxAmtAssetDcm = 6
37 37  
38 38  let idxPriceAssetDcm = 7
39 39  
40 40  let idxIAmtAssetId = 8
41 41  
42 42  let idxIPriceAssetId = 9
43 43  
44 44  let idxLPAssetDcm = 10
45 45  
46 46  let idxPoolAmtAssetAmt = 1
47 47  
48 48  let idxPoolPriceAssetAmt = 2
49 49  
50 50  let idxPoolLPAssetAmt = 3
51 51  
52 52  let idxFactoryStakingContract = 1
53 53  
54 54  let idxFactorySlippageContract = 7
55 55  
56 56  func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
57 57  
58 58  
59 59  func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
60 60  
61 61  
62 62  func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
63 63  
64 64  
65 65  func abs (val) = if ((zeroBigInt > val))
66 66      then -(val)
67 67      else val
68 68  
69 69  
70 70  func keyFactoryContract () = "%s__factoryContract"
71 71  
72 72  
73 73  func keyManagerPublicKey () = "%s__managerPublicKey"
74 74  
75 75  
76 76  func keyPriceLast () = "%s%s__price__last"
77 77  
78 78  
79 79  func keyPriceHistory (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
80 80  
81 81  
82 82  func keyPutActionByUser (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
83 83  
84 84  
85 85  func keyGetActionByUser (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
86 86  
87 87  
88 88  func keyAmtAsset () = "%s__amountAsset"
89 89  
90 90  
91 91  func keyPriceAsset () = "%s__priceAsset"
92 92  
93 93  
94 94  func keyKHistoric (h,timestamp) = makeString(["%s%s%d%d__K_history", toString(h), toString(timestamp)], SEP)
95 95  
96 96  
97 97  func keyFactoryConfig () = "%s__factoryConfig"
98 98  
99 99  
100 100  func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
101 101  
102 102  
103 103  func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
104 104  
105 105  
106 106  func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
107 107  
108 108  
109 109  func keyAllPoolsShutdown () = "%s__shutdown"
110 110  
111 111  
112 112  func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
113 113  
114 114  
115 115  func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
116 116  
117 117  
118 118  func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
119 119  
120 120  
121 121  let factoryContract = addressFromStringValue(getStringOrFail(this, keyFactoryContract()))
122 122  
123 123  func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
124 124  
125 125  
126 126  func getPoolConfig () = {
127 127      let amtAsset = getStringOrFail(this, keyAmtAsset())
128 128      let priceAsset = getStringOrFail(this, keyPriceAsset())
129 129      let iPriceAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAsset))
130 130      let iAmtAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAsset))
131 131      split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAsset), toString(iPriceAsset))), SEP)
132 132      }
133 133  
134 134  
135 135  func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
136 136  
137 137  
138 138  func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageTolerancePassedByUser,slippageToleranceReal,txHeight,txTimestamp,slipageAmtAssetAmt,slipagePriceAssetAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageTolerancePassedByUser), toString(slippageToleranceReal), toString(txHeight), toString(txTimestamp), toString(slipageAmtAssetAmt), toString(slipagePriceAssetAmt)], SEP)
139 139  
140 140  
141 141  func dataGetActionInfo (outAmtAssetAmt,outPriceAssetAmt,inLpAmt,price,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d", toString(outAmtAssetAmt), toString(outPriceAssetAmt), toString(inLpAmt), toString(price), toString(txHeight), toString(txTimestamp)], SEP)
142 142  
143 143  
144 144  func getAccBalance (assetId) = if ((assetId == "WAVES"))
145 145      then wavesBalance(this).available
146 146      else assetBalance(this, fromBase58String(assetId))
147 147  
148 148  
149 149  func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
150 150  
151 151  
152 152  func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
153 153      let amtAssetAmtX18 = toX18(amAmt, amAssetDcm)
154 154      let priceAssetAmtX18 = toX18(prAmt, prAssetDcm)
155 155      calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
156 156      }
157 157  
158 158  
159 159  func calcPrices (amAmt,prAmt,lpAmt) = {
160 160      let cfg = getPoolConfig()
161 161      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
162 162      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
163 163      let priceX18 = privateCalcPrice(amtAssetDcm, priceAssetDcm, amAmt, prAmt)
164 164      let amAmtX18 = toX18(amAmt, amtAssetDcm)
165 165      let prAmtX18 = toX18(prAmt, priceAssetDcm)
166 166      let lpAmtX18 = toX18(lpAmt, scale8)
167 167      let lpPriceInAmAssetX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
168 168      let lpPriceInPrAssetX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
169 169  [priceX18, lpPriceInAmAssetX18, lpPriceInPrAssetX18]
170 170      }
171 171  
172 172  
173 173  func calculatePrices (amAmt,prAmt,lpAmt) = {
174 174      let prices = calcPrices(amAmt, prAmt, lpAmt)
175 175  [fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
176 176      }
177 177  
178 178  
179 179  func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
180 180      let cfg = getPoolConfig()
181 181      let lpAssetId = cfg[idxPoolLPAssetId]
182 182      let amAssetId = cfg[idxAmtAssetId]
183 183      let prAssetId = cfg[idxPriceAssetId]
184 184      let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
185 185      let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
186 186      let poolStatus = cfg[idxPoolStatus]
187 187      let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpAssetId)), (("Asset " + lpAssetId) + " doesn't exist")).quantity
188 188      if ((lpAssetId != pmtAssetId))
189 189          then throw("Invalid asset passed.")
190 190          else {
191 191              let amBalance = getAccBalance(amAssetId)
192 192              let amBalanceX18 = toX18(amBalance, amAssetDcm)
193 193              let prBalance = getAccBalance(prAssetId)
194 194              let prBalanceX18 = toX18(prBalance, prAssetDcm)
195 195              let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
196 196              let curPrice = fromX18(curPriceX18, scale8)
197 197              let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
198 198              let lpEmissionX18 = toX18(lpEmission, scale8)
199 199              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
200 200              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
201 201              let outAmAmt = fromX18(outAmAmtX18, amAssetDcm)
202 202              let outPrAmt = fromX18(outPrAmtX18, prAssetDcm)
203 203              let state = if ((txId58 == ""))
204 204                  then nil
205 205                  else [ScriptTransfer(userAddress, outAmAmt, if ((amAssetId == "WAVES"))
206 206                      then unit
207 207                      else fromBase58String(amAssetId)), ScriptTransfer(userAddress, outPrAmt, if ((prAssetId == "WAVES"))
208 208                      then unit
209 209                      else fromBase58String(prAssetId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
210 210              $Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
211 211              }
212 212      }
213 213  
214 214  
215 215  func estimatePutOperation (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = {
216 216      let cfg = getPoolConfig()
217 217      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
218 218      let amAssetIdStr = cfg[idxAmtAssetId]
219 219      let prAssetIdStr = cfg[idxPriceAssetId]
220 220      let iAmtAssetId = cfg[idxIAmtAssetId]
221 221      let iPriceAssetId = cfg[idxIPriceAssetId]
222 222      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
223 223      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
224 224      let poolStatus = cfg[idxPoolStatus]
225 225      let lpEmission = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
226 226      let inAmAssetIdStr = toBase58String(valueOrElse(inAmAssetId, fromBase58String("WAVES")))
227 227      let inPrAssetIdStr = toBase58String(valueOrElse(inPrAssetId, fromBase58String("WAVES")))
228 228      if (if ((amAssetIdStr != inAmAssetIdStr))
229 229          then true
230 230          else (prAssetIdStr != inPrAssetIdStr))
231 231          then throw("Invalid amt or price asset passed.")
232 232          else {
233 233              let amBalance = if (isEvaluate)
234 234                  then getAccBalance(amAssetIdStr)
235 235                  else (getAccBalance(amAssetIdStr) - inAmAssetAmt)
236 236              let prBalance = if (isEvaluate)
237 237                  then getAccBalance(prAssetIdStr)
238 238                  else (getAccBalance(prAssetIdStr) - inPrAssetAmt)
239 239              let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
240 240              let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
241 241              let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
242 242              let amBalanceX18 = toX18(amBalance, amtAssetDcm)
243 243              let prBalanceX18 = toX18(prBalance, priceAssetDcm)
244 244              let res = if ((lpEmission == 0))
245 245                  then {
246 246                      let curPriceX18 = zeroBigInt
247 247                      let slippageX18 = zeroBigInt
248 248                      let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
249 249                      $Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtAssetDcm), fromX18(inPrAssetAmtX18, priceAssetDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
250 250                      }
251 251                  else {
252 252                      let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
253 253                      let slippageX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
254 254                      let slippageToleranceX18 = toX18(slippageTolerance, scale8)
255 255                      if (if ((curPriceX18 != zeroBigInt))
256 256                          then (slippageX18 > slippageToleranceX18)
257 257                          else false)
258 258                          then throw(((("Price slippage " + toString(slippageX18)) + " exceeded the passed limit of ") + toString(slippageToleranceX18)))
259 259                          else {
260 260                              let lpEmissionX18 = toX18(lpEmission, scale8)
261 261                              let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
262 262                              let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
263 263                              let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
264 264                                  then $Tuple2(amViaPrX18, inPrAssetAmtX18)
265 265                                  else $Tuple2(inAmAssetAmtX18, prViaAmX18)
266 266                              let expAmtAssetAmtX18 = expectedAmts._1
267 267                              let expPriceAssetAmtX18 = expectedAmts._2
268 268                              let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
269 269                              $Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtAssetDcm), fromX18(expPriceAssetAmtX18, priceAssetDcm), curPriceX18, slippageX18)
270 270                              }
271 271                      }
272 272              let calcLpAmt = res._1
273 273              let calcAmAssetPmt = res._2
274 274              let calcPrAssetPmt = res._3
275 275              let curPrice = fromX18(res._4, scale8)
276 276              let slippageCalc = fromX18(res._5, scale8)
277 277              if ((0 >= calcLpAmt))
278 278                  then throw("Invalid calculations. LP calculated is less than zero.")
279 279                  else {
280 280                      let emitLpAmt = if (!(emitLp))
281 281                          then 0
282 282                          else calcLpAmt
283 283                      let amDiff = (inAmAssetAmt - calcAmAssetPmt)
284 284                      let prDiff = (inPrAssetAmt - calcPrAssetPmt)
285 285                      let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippageTolerance, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
286 286                      $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmAssetId, inPrAssetId)
287 287                      }
288 288              }
289 289      }
290 290  
291 291  
292 292  func validateMatcherOrderAllowed (order) = {
293 293      let cfg = getPoolConfig()
294 294      let amtAssetId = cfg[idxAmtAssetId]
295 295      let priceAssetId = cfg[idxPriceAssetId]
296 296      let poolStatus = parseIntValue(cfg[idxPoolStatus])
297 297      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
298 298      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
299 299      let accAmtAssetBalance = getAccBalance(amtAssetId)
300 300      let accPriceAssetBalance = getAccBalance(priceAssetId)
301 301      let curPriceX18 = if ((order.orderType == Buy))
302 302          then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
303 303          else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance - order.amount), accPriceAssetBalance)
304 304      let curPrice = fromX18(curPriceX18, scale8)
305 305      if (if (if (isGlobalShutdown())
306 306          then true
307 307          else (poolStatus == PoolMatcherDisabled))
308 308          then true
309 309          else (poolStatus == PoolShutdown))
310 310          then throw("Exchange operations disabled")
311 311          else {
312 312              let orderAmtAsset = order.assetPair.amountAsset
313 313              let orderAmtAssetStr = if ((orderAmtAsset == unit))
314 314                  then "WAVES"
315 315                  else toBase58String(value(orderAmtAsset))
316 316              let orderPriceAsset = order.assetPair.priceAsset
317 317              let orderPriceAssetStr = if ((orderPriceAsset == unit))
318 318                  then "WAVES"
319 319                  else toBase58String(value(orderPriceAsset))
320 320              if (if ((orderAmtAssetStr != amtAssetId))
321 321                  then true
322 322                  else (orderPriceAssetStr != priceAssetId))
323 323                  then throw("Wrong order assets.")
324 324                  else {
325 325                      let orderPrice = order.price
326 326                      let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
327 327                      let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
328 328                      let isOrderPriceValid = if ((order.orderType == Buy))
329 329                          then (curPrice >= castedOrderPrice)
330 330                          else (castedOrderPrice >= curPrice)
331 331                      true
332 332                      }
333 333              }
334 334      }
335 335  
336 336  
337 337  func commonGet (i) = if ((size(i.payments) != 1))
338 338      then throw("exactly 1 payment is expected")
339 339      else {
340 340          let pmt = value(i.payments[0])
341 341          let pmtAssetId = value(pmt.assetId)
342 342          let pmtAmt = pmt.amount
343 343          let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
344 344          let outAmAmt = res._1
345 345          let outPrAmt = res._2
346 346          let poolStatus = parseIntValue(res._9)
347 347          let state = res._10
348 348          if (if (isGlobalShutdown())
349 349              then true
350 350              else (poolStatus == PoolShutdown))
351 351              then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
352 352              else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
353 353          }
354 354  
355 355  
356 356  func commonPut (i,slippageTolerance,emitLp) = if ((size(i.payments) != 2))
357 357      then throw("exactly 2 payments are expected")
358 358      else {
359 359          let amAssetPmt = value(i.payments[0])
360 360          let prAssetPmt = value(i.payments[1])
361 361          let estPut = estimatePutOperation(toBase58String(i.transactionId), slippageTolerance, amAssetPmt.amount, amAssetPmt.assetId, prAssetPmt.amount, prAssetPmt.assetId, toString(i.caller), false, emitLp)
362 362          let poolStatus = parseIntValue(estPut._8)
363 363          if (if (if (isGlobalShutdown())
364 364              then true
365 365              else (poolStatus == PoolPutDisabled))
366 366              then true
367 367              else (poolStatus == PoolShutdown))
368 368              then throw(("Put operation is blocked by admin. Status = " + toString(poolStatus)))
369 369              else estPut
370 370          }
371 371  
372 372  
373 373  @Callable(i)
374 374  func constructor (factoryContract,managerPublicKey) = if ((i.caller != this))
375 375      then throw("permissions denied")
376 376      else [StringEntry(keyFactoryContract(), factoryContract), StringEntry(keyManagerPublicKey(), managerPublicKey)]
377 377  
378 378  
379 379  
380 380  @Callable(i)
381 381  func put (slippageTolerance,shouldAutoStake) = {
382 382      let factoryCfg = getFactoryConfig()
383 383      let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
384 384      let slippageContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactorySlippageContract]), "Error. Incorrect slippage contract address.")
385 385      if ((0 > slippageTolerance))
386 386          then throw("Invalid slippageTolerance passed")
387 387          else {
388 388              let estPut = commonPut(i, slippageTolerance, true)
389 389              let emitLpAmt = estPut._2
390 390              let lpAssetId = estPut._7
391 391              let state = estPut._9
392 392              let amDiff = estPut._10
393 393              let prDiff = estPut._11
394 394              let amId = estPut._12
395 395              let prId = estPut._13
396 396              let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
397 397              if ((emitInv == emitInv))
398 398                  then {
399 399                      let slippageAInv = if ((amDiff > 0))
400 400                          then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
401 401                          else nil
402 402                      if ((slippageAInv == slippageAInv))
403 403                          then {
404 404                              let slippagePInv = if ((prDiff > 0))
405 405                                  then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
406 406                                  else nil
407 407                              if ((slippagePInv == slippagePInv))
408 408                                  then {
409 409                                      let lpTransfer = if (shouldAutoStake)
410 410                                          then {
411 411                                              let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
412 412                                              if ((slpStakeInv == slpStakeInv))
413 413                                                  then nil
414 414                                                  else throw("Strict value is not equal to itself.")
415 415                                              }
416 416                                          else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
417 417                                      (state ++ lpTransfer)
418 418                                      }
419 419                                  else throw("Strict value is not equal to itself.")
420 420                              }
421 421                          else throw("Strict value is not equal to itself.")
422 422                      }
423 423                  else throw("Strict value is not equal to itself.")
424 424              }
425 425      }
426 426  
427 427  
428 428  
429 429  @Callable(i)
430 430  func putForFree (maxSlippage) = if ((0 > maxSlippage))
431 431      then throw("Invalid value passed")
432 432      else {
433 433          let estPut = commonPut(i, maxSlippage, false)
434 434          estPut._9
435 435          }
436 436  
437 437  
438 438  
439 439  @Callable(i)
440 440  func get () = {
441 441      let res = commonGet(i)
442 442      let outAmtAmt = res._1
443 443      let outPrAmt = res._2
444 444      let pmtAmt = res._3
445 445      let pmtAssetId = res._4
446 446      let state = res._5
447 447      let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
448 448      if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
449 449          then state
450 450          else throw("Strict value is not equal to itself.")
451 451      }
452 452  
453 453  
454 454  
455 455  @Callable(i)
456 456  func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
457 457      let res = commonGet(i)
458 458      let outAmAmt = res._1
459 459      let outPrAmt = res._2
460 460      let pmtAmt = res._3
461 461      let pmtAssetId = res._4
462 462      let state = res._5
463 463      if ((noLessThenAmtAsset > outAmAmt))
464 464          then throw(((("noLessThenAmtAsset failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
465 465          else if ((noLessThenPriceAsset > outPrAmt))
466 466              then throw(((("noLessThenPriceAsset failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
467 467              else {
468 468                  let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
469 469                  if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
470 470                      then state
471 471                      else throw("Strict value is not equal to itself.")
472 472                  }
473 473      }
474 474  
475 475  
476 476  
477 477  @Callable(i)
478 478  func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
479 479      then throw("permissions denied")
480 480      else $Tuple2([StringEntry(keyAmtAsset(), amtAssetStr), StringEntry(keyPriceAsset(), priceAssetStr)], "success")
481 481  
482 482  
483 483  
484 484  @Callable(i)
485 485  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
486 486  
487 487  
488 488  
489 489  @Callable(i)
490 490  func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
491 491  
492 492  
493 493  
494 494  @Callable(i)
495 495  func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
496 496      let prices = calcPrices(amAmt, prAmt, lpAmt)
497 497      $Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
498 498      }
499 499  
500 500  
501 501  
502 502  @Callable(i)
503 503  func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(toX18(origVal, origScaleMult)))
504 504  
505 505  
506 506  
507 507  @Callable(i)
508 508  func fromX18WrapperREADONLY (val,resultScaleMult) = $Tuple2(nil, fromX18(parseBigIntValue(val), resultScaleMult))
509 509  
510 510  
511 511  
512 512  @Callable(i)
513 513  func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(calcPriceBigInt(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
514 514  
515 515  
516 516  
517 517  @Callable(i)
518 518  func estimatePutOperationWrapperREADONLY (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = {
519 -     let $t02517425559 = estimatePutOperation(txId58, slippageTolerance, inAmAssetAmt, inAmAssetId, inPrAssetAmt, inPrAssetId, userAddress, isEvaluate, emitLp)
520 -     let calcLpAmt = $t02517425559._1
521 -     let emitLpAmt = $t02517425559._2
522 -     let curPrice = $t02517425559._3
523 -     let amBalance = $t02517425559._4
524 -     let prBalance = $t02517425559._5
525 -     let lpEmission = $t02517425559._6
526 -     let lpAssetId = $t02517425559._7
527 -     let poolStatus = $t02517425559._8
528 -     let commonState = $t02517425559._9
529 -     let amDiff = $t02517425559._10
530 -     let prDiff = $t02517425559._11
531 -     let inAmtAssetId = $t02517425559._12
532 -     let inPriceAssetId = $t02517425559._13
519 +     let estimation = estimatePutOperation(txId58, slippageTolerance, inAmAssetAmt, inAmAssetId, inPrAssetAmt, inPrAssetId, userAddress, isEvaluate, emitLp)
520 +     let $t02536825589 = estimation
521 +     let calcLpAmt = $t02536825589._1
522 +     let emitLpAmt = $t02536825589._2
523 +     let curPrice = $t02536825589._3
524 +     let amBalance = $t02536825589._4
525 +     let prBalance = $t02536825589._5
526 +     let lpEmission = $t02536825589._6
527 +     let lpAssetId = $t02536825589._7
528 +     let poolStatus = $t02536825589._8
529 +     let commonState = $t02536825589._9
530 +     let amDiff = $t02536825589._10
531 +     let prDiff = $t02536825589._11
532 +     let inAmtAssetId = $t02536825589._12
533 +     let inPriceAssetId = $t02536825589._13
533 534      $Tuple2(nil, $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmtAssetId, inPriceAssetId))
534 535      }
535 536  
536 537  
537 538  
538 539  @Callable(i)
539 540  func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
540 -     let $t02594826215 = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
541 -     let outAmAmt = $t02594826215._1
542 -     let outPrAmt = $t02594826215._2
543 -     let amAssetId = $t02594826215._3
544 -     let prAssetId = $t02594826215._4
545 -     let amBalance = $t02594826215._5
546 -     let prBalance = $t02594826215._6
547 -     let lpEmission = $t02594826215._7
548 -     let curPriceX18 = $t02594826215._8
549 -     let poolStatus = $t02594826215._9
550 -     let state = $t02594826215._10
541 +     let estimation = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
542 +     let $t02610626275 = estimation
543 +     let outAmAmt = $t02610626275._1
544 +     let outPrAmt = $t02610626275._2
545 +     let amAssetId = $t02610626275._3
546 +     let prAssetId = $t02610626275._4
547 +     let amBalance = $t02610626275._5
548 +     let prBalance = $t02610626275._6
549 +     let lpEmission = $t02610626275._7
550 +     let curPriceX18 = $t02610626275._8
551 +     let poolStatus = $t02610626275._9
552 +     let state = $t02610626275._10
551 553      $Tuple2(nil, $Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, toString(curPriceX18), poolStatus, state))
552 554      }
553 555  
554 556  
555 557  
556 558  @Callable(i)
557 559  func statsREADONLY () = {
558 560      let cfg = getPoolConfig()
559 561      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
560 562      let amtAssetId = cfg[idxAmtAssetId]
561 563      let priceAssetId = cfg[idxPriceAssetId]
562 564      let iAmtAssetId = cfg[idxIAmtAssetId]
563 565      let iPriceAssetId = cfg[idxIPriceAssetId]
564 566      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
565 567      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
566 568      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
567 569      let accAmtAssetBalance = getAccBalance(amtAssetId)
568 570      let accPriceAssetBalance = getAccBalance(priceAssetId)
569 571      let pricesList = calcPrices(accAmtAssetBalance, accPriceAssetBalance, poolLPBalance)
570 572      let curPrice = 0
571 573      let lpAmtAssetShare = fromX18(pricesList[1], scale8)
572 574      let lpPriceAssetShare = fromX18(pricesList[2], scale8)
573 575      let poolWeight = value(getInteger(factoryContract, keyPoolWeight(toString(this))))
574 576      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight)], SEP))
575 577      }
576 578  
577 579  
578 580  
579 581  @Callable(i)
580 582  func evaluatePutByAmountAssetREADONLY (inAmAssetAmt) = {
581 583      let cfg = getPoolConfig()
582 584      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
583 585      let amAssetIdStr = cfg[idxAmtAssetId]
584 586      let amAssetId = fromBase58String(amAssetIdStr)
585 587      let prAssetIdStr = cfg[idxPriceAssetId]
586 588      let prAssetId = fromBase58String(prAssetIdStr)
587 589      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
588 590      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
589 591      let poolStatus = cfg[idxPoolStatus]
590 592      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
591 593      let accAmtAssetBalance = getAccBalance(amAssetIdStr)
592 594      let accPriceAssetBalance = getAccBalance(prAssetIdStr)
593 595      let amtAssetAmtX18 = toX18(accAmtAssetBalance, amtAssetDcm)
594 596      let priceAssetAmtX18 = toX18(accPriceAssetBalance, priceAssetDcm)
595 597      let curPriceX18 = if ((poolLPBalance == 0))
596 598          then zeroBigInt
597 599          else calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
598 600      let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
599 601      let inPrAssetAmtX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
600 602      let inPrAssetAmt = fromX18(inPrAssetAmtX18, priceAssetDcm)
601 603      let estPut = estimatePutOperation("", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false)
602 604      let calcLpAmt = estPut._1
603 605      let curPriceCalc = estPut._3
604 606      let amBalance = estPut._4
605 607      let prBalance = estPut._5
606 608      let lpEmission = estPut._6
607 609      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(fromX18(curPriceX18, scale8)), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
608 610      }
609 611  
610 612  
611 613  
612 614  @Callable(i)
613 615  func evaluatePutByPriceAssetREADONLY (inPrAssetAmt) = {
614 616      let cfg = getPoolConfig()
615 617      let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
616 618      let amAssetIdStr = cfg[idxAmtAssetId]
617 619      let amAssetId = fromBase58String(amAssetIdStr)
618 620      let prAssetIdStr = cfg[idxPriceAssetId]
619 621      let prAssetId = fromBase58String(prAssetIdStr)
620 622      let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
621 623      let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
622 624      let poolStatus = cfg[idxPoolStatus]
623 625      let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
624 626      let amBalanceRaw = getAccBalance(amAssetIdStr)
625 627      let prBalanceRaw = getAccBalance(prAssetIdStr)
626 628      let amBalanceRawX18 = toX18(amBalanceRaw, amtAssetDcm)
627 629      let prBalanceRawX18 = toX18(prBalanceRaw, priceAssetDcm)
628 630      let curPriceX18 = if ((poolLPBalance == 0))
629 631          then zeroBigInt
630 632          else calcPriceBigInt(prBalanceRawX18, amBalanceRawX18)
631 633      let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
632 634      let inAmAssetAmtX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
633 635      let inAmAssetAmt = fromX18(inAmAssetAmtX18, amtAssetDcm)
634 636      let estPut = estimatePutOperation("", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false)
635 637      let calcLpAmt = estPut._1
636 638      let curPriceCalc = estPut._3
637 639      let amBalance = estPut._4
638 640      let prBalance = estPut._5
639 641      let lpEmission = estPut._6
640 642      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(fromX18(curPriceX18, scale8)), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
641 643      }
642 644  
643 645  
644 646  
645 647  @Callable(i)
646 648  func evaluateGetREADONLY (paymentLpAssetId,paymentLpAmt) = {
647 649      let res = estimateGetOperation("", paymentLpAssetId, paymentLpAmt, this)
648 650      let outAmAmt = res._1
649 651      let outPrAmt = res._2
650 652      let amBalance = res._5
651 653      let prBalance = res._6
652 654      let lpEmission = res._7
653 655      let curPrice = res._8
654 656      let poolStatus = parseIntValue(res._9)
655 657      $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmAmt), toString(outPrAmt), toString(amBalance), toString(prBalance), toString(lpEmission), toString(curPrice), toString(poolStatus)], SEP))
656 658      }
657 659  
658 660  
659 661  @Verifier(tx)
660 662  func verify () = match tx {
661 663      case order: Order => 
662 664          if (validateMatcherOrderAllowed(order))
663 665              then sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
664 666              else false
665 667      case _ => 
666 668          let managerPublic = valueOrElse(getString(this, keyManagerPublicKey()), EMPTY)
667 669          if ((managerPublic == EMPTY))
668 670              then sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
669 671              else sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(managerPublic))
670 672  }
671 673

Old	New		Differences
516	516
517	517		@Callable(i)
518	518		func estimatePutOperationWrapperREADONLY (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = {
519		-	let $t02517425559 = estimatePutOperation(txId58, slippageTolerance, inAmAssetAmt, inAmAssetId, inPrAssetAmt, inPrAssetId, userAddress, isEvaluate, emitLp)
520		-	let calcLpAmt = $t02517425559._1
521		-	let emitLpAmt = $t02517425559._2
522		-	let curPrice = $t02517425559._3
523		-	let amBalance = $t02517425559._4
524		-	let prBalance = $t02517425559._5
525		-	let lpEmission = $t02517425559._6
526		-	let lpAssetId = $t02517425559._7
527		-	let poolStatus = $t02517425559._8
528		-	let commonState = $t02517425559._9
529		-	let amDiff = $t02517425559._10
530		-	let prDiff = $t02517425559._11
531		-	let inAmtAssetId = $t02517425559._12
532		-	let inPriceAssetId = $t02517425559._13
	519	+	let estimation = estimatePutOperation(txId58, slippageTolerance, inAmAssetAmt, inAmAssetId, inPrAssetAmt, inPrAssetId, userAddress, isEvaluate, emitLp)
	520	+	let $t02536825589 = estimation
	521	+	let calcLpAmt = $t02536825589._1
	522	+	let emitLpAmt = $t02536825589._2
	523	+	let curPrice = $t02536825589._3
	524	+	let amBalance = $t02536825589._4
	525	+	let prBalance = $t02536825589._5
	526	+	let lpEmission = $t02536825589._6
	527	+	let lpAssetId = $t02536825589._7
	528	+	let poolStatus = $t02536825589._8
	529	+	let commonState = $t02536825589._9
	530	+	let amDiff = $t02536825589._10
	531	+	let prDiff = $t02536825589._11
	532	+	let inAmtAssetId = $t02536825589._12
	533	+	let inPriceAssetId = $t02536825589._13
533	534		$Tuple2(nil, $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmtAssetId, inPriceAssetId))
534	535		}
535	536

537	538
538	539		@Callable(i)
539	540		func estimateGetOperationWrapperREADONLY (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
540		-	let $t02594826215 = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
541		-	let outAmAmt = $t02594826215._1
542		-	let outPrAmt = $t02594826215._2
543		-	let amAssetId = $t02594826215._3
544		-	let prAssetId = $t02594826215._4
545		-	let amBalance = $t02594826215._5
546		-	let prBalance = $t02594826215._6
547		-	let lpEmission = $t02594826215._7
548		-	let curPriceX18 = $t02594826215._8
549		-	let poolStatus = $t02594826215._9
550		-	let state = $t02594826215._10
	541	+	let estimation = estimateGetOperation(txId58, pmtAssetId, pmtLpAmt, addressFromStringValue(userAddress))
	542	+	let $t02610626275 = estimation
	543	+	let outAmAmt = $t02610626275._1
	544	+	let outPrAmt = $t02610626275._2
	545	+	let amAssetId = $t02610626275._3
	546	+	let prAssetId = $t02610626275._4
	547	+	let amBalance = $t02610626275._5
	548	+	let prBalance = $t02610626275._6
	549	+	let lpEmission = $t02610626275._7
	550	+	let curPriceX18 = $t02610626275._8
	551	+	let poolStatus = $t02610626275._9
	552	+	let state = $t02610626275._10
551	553		$Tuple2(nil, $Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, toString(curPriceX18), poolStatus, state))
552	554		}
553	555

Old	New	Differences
1	1	{-# STDLIB_VERSION 5 #-}
2	2	{-# SCRIPT_TYPE ACCOUNT #-}
3	3	{-# CONTENT_TYPE DAPP #-}
4	4	let lPdecimals = 8
5	5
6	6	let scale8 = 100000000
7	7
8	8	let scale8BigInt = toBigInt(100000000)
9	9
10	10	let scale18 = toBigInt(1000000000000000000)
11	11
12	12	let zeroBigInt = toBigInt(0)
13	13
14	14	let SEP = "__"
15	15
16	16	let EMPTY = ""
17	17
18	18	let PoolActive = 1
19	19
20	20	let PoolPutDisabled = 2
21	21
22	22	let PoolMatcherDisabled = 3
23	23
24	24	let PoolShutdown = 4
25	25
26	26	let idxPoolAddress = 1
27	27
28	28	let idxPoolStatus = 2
29	29
30	30	let idxPoolLPAssetId = 3
31	31
32	32	let idxAmtAssetId = 4
33	33
34	34	let idxPriceAssetId = 5
35	35
36	36	let idxAmtAssetDcm = 6
37	37
38	38	let idxPriceAssetDcm = 7
39	39
40	40	let idxIAmtAssetId = 8
41	41
42	42	let idxIPriceAssetId = 9
43	43
44	44	let idxLPAssetDcm = 10
45	45
46	46	let idxPoolAmtAssetAmt = 1
47	47
48	48	let idxPoolPriceAssetAmt = 2
49	49
50	50	let idxPoolLPAssetAmt = 3
51	51
52	52	let idxFactoryStakingContract = 1
53	53
54	54	let idxFactorySlippageContract = 7
55	55
56	56	func toX18 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
57	57
58	58
59	59	func fromX18 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
60	60
61	61
62	62	func toScale (amt,resScale,curScale) = fraction(amt, resScale, curScale)
63	63
64	64
65	65	func abs (val) = if ((zeroBigInt > val))
66	66	then -(val)
67	67	else val
68	68
69	69
70	70	func keyFactoryContract () = "%s__factoryContract"
71	71
72	72
73	73	func keyManagerPublicKey () = "%s__managerPublicKey"
74	74
75	75
76	76	func keyPriceLast () = "%s%s__price__last"
77	77
78	78
79	79	func keyPriceHistory (h,timestamp) = makeString(["%s%s%d%d__price__history", toString(h), toString(timestamp)], SEP)
80	80
81	81
82	82	func keyPutActionByUser (userAddress,txId) = ((("%s%s%s__P__" + userAddress) + "__") + txId)
83	83
84	84
85	85	func keyGetActionByUser (userAddress,txId) = ((("%s%s%s__G__" + userAddress) + "__") + txId)
86	86
87	87
88	88	func keyAmtAsset () = "%s__amountAsset"
89	89
90	90
91	91	func keyPriceAsset () = "%s__priceAsset"
92	92
93	93
94	94	func keyKHistoric (h,timestamp) = makeString(["%s%s%d%d__K_history", toString(h), toString(timestamp)], SEP)
95	95
96	96
97	97	func keyFactoryConfig () = "%s__factoryConfig"
98	98
99	99
100	100	func keyMappingPoolContractAddressToPoolAssets (poolContractAddress) = (("%s%s%s__" + poolContractAddress) + "__mappings__poolContract2LpAsset")
101	101
102	102
103	103	func keyPoolConfig (iAmtAsset,iPriceAsset) = (((("%d%d%s__" + iAmtAsset) + "__") + iPriceAsset) + "__config")
104	104
105	105
106	106	func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
107	107
108	108
109	109	func keyAllPoolsShutdown () = "%s__shutdown"
110	110
111	111
112	112	func keyPoolWeight (contractAddress) = ("%s%s__poolWeight__" + contractAddress)
113	113
114	114
115	115	func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
116	116
117	117
118	118	func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
119	119
120	120
121	121	let factoryContract = addressFromStringValue(getStringOrFail(this, keyFactoryContract()))
122	122
123	123	func isGlobalShutdown () = valueOrElse(getBoolean(factoryContract, keyAllPoolsShutdown()), false)
124	124
125	125
126	126	func getPoolConfig () = {
127	127	let amtAsset = getStringOrFail(this, keyAmtAsset())
128	128	let priceAsset = getStringOrFail(this, keyPriceAsset())
129	129	let iPriceAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(priceAsset))
130	130	let iAmtAsset = getIntOrFail(factoryContract, keyMappingsBaseAsset2internalId(amtAsset))
131	131	split(getStringOrFail(factoryContract, keyPoolConfig(toString(iAmtAsset), toString(iPriceAsset))), SEP)
132	132	}
133	133
134	134
135	135	func getFactoryConfig () = split(getStringOrFail(factoryContract, keyFactoryConfig()), SEP)
136	136
137	137
138	138	func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slippageTolerancePassedByUser,slippageToleranceReal,txHeight,txTimestamp,slipageAmtAssetAmt,slipagePriceAssetAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slippageTolerancePassedByUser), toString(slippageToleranceReal), toString(txHeight), toString(txTimestamp), toString(slipageAmtAssetAmt), toString(slipagePriceAssetAmt)], SEP)
139	139
140	140
141	141	func dataGetActionInfo (outAmtAssetAmt,outPriceAssetAmt,inLpAmt,price,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d", toString(outAmtAssetAmt), toString(outPriceAssetAmt), toString(inLpAmt), toString(price), toString(txHeight), toString(txTimestamp)], SEP)
142	142
143	143
144	144	func getAccBalance (assetId) = if ((assetId == "WAVES"))
145	145	then wavesBalance(this).available
146	146	else assetBalance(this, fromBase58String(assetId))
147	147
148	148
149	149	func calcPriceBigInt (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
150	150
151	151
152	152	func privateCalcPrice (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
153	153	let amtAssetAmtX18 = toX18(amAmt, amAssetDcm)
154	154	let priceAssetAmtX18 = toX18(prAmt, prAssetDcm)
155	155	calcPriceBigInt(priceAssetAmtX18, amtAssetAmtX18)
156	156	}
157	157
158	158
159	159	func calcPrices (amAmt,prAmt,lpAmt) = {
160	160	let cfg = getPoolConfig()
161	161	let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
162	162	let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
163	163	let priceX18 = privateCalcPrice(amtAssetDcm, priceAssetDcm, amAmt, prAmt)
164	164	let amAmtX18 = toX18(amAmt, amtAssetDcm)
165	165	let prAmtX18 = toX18(prAmt, priceAssetDcm)
166	166	let lpAmtX18 = toX18(lpAmt, scale8)
167	167	let lpPriceInAmAssetX18 = calcPriceBigInt(amAmtX18, lpAmtX18)
168	168	let lpPriceInPrAssetX18 = calcPriceBigInt(prAmtX18, lpAmtX18)
169	169	[priceX18, lpPriceInAmAssetX18, lpPriceInPrAssetX18]
170	170	}
171	171
172	172
173	173	func calculatePrices (amAmt,prAmt,lpAmt) = {
174	174	let prices = calcPrices(amAmt, prAmt, lpAmt)
175	175	[fromX18(prices[0], scale8), fromX18(prices[1], scale8), fromX18(prices[2], scale8)]
176	176	}
177	177
178	178
179	179	func estimateGetOperation (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
180	180	let cfg = getPoolConfig()
181	181	let lpAssetId = cfg[idxPoolLPAssetId]
182	182	let amAssetId = cfg[idxAmtAssetId]
183	183	let prAssetId = cfg[idxPriceAssetId]
184	184	let amAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
185	185	let prAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
186	186	let poolStatus = cfg[idxPoolStatus]
187	187	let lpEmission = valueOrErrorMessage(assetInfo(fromBase58String(lpAssetId)), (("Asset " + lpAssetId) + " doesn't exist")).quantity
188	188	if ((lpAssetId != pmtAssetId))
189	189	then throw("Invalid asset passed.")
190	190	else {
191	191	let amBalance = getAccBalance(amAssetId)
192	192	let amBalanceX18 = toX18(amBalance, amAssetDcm)
193	193	let prBalance = getAccBalance(prAssetId)
194	194	let prBalanceX18 = toX18(prBalance, prAssetDcm)
195	195	let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
196	196	let curPrice = fromX18(curPriceX18, scale8)
197	197	let pmtLpAmtX18 = toX18(pmtLpAmt, scale8)
198	198	let lpEmissionX18 = toX18(lpEmission, scale8)
199	199	let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissionX18)
200	200	let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissionX18)
201	201	let outAmAmt = fromX18(outAmAmtX18, amAssetDcm)
202	202	let outPrAmt = fromX18(outPrAmtX18, prAssetDcm)
203	203	let state = if ((txId58 == ""))
204	204	then nil
205	205	else [ScriptTransfer(userAddress, outAmAmt, if ((amAssetId == "WAVES"))
206	206	then unit
207	207	else fromBase58String(amAssetId)), ScriptTransfer(userAddress, outPrAmt, if ((prAssetId == "WAVES"))
208	208	then unit
209	209	else fromBase58String(prAssetId)), StringEntry(keyGetActionByUser(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice)]
210	210	$Tuple10(outAmAmt, outPrAmt, amAssetId, prAssetId, amBalance, prBalance, lpEmission, curPriceX18, poolStatus, state)
211	211	}
212	212	}
213	213
214	214
215	215	func estimatePutOperation (txId58,slippageTolerance,inAmAssetAmt,inAmAssetId,inPrAssetAmt,inPrAssetId,userAddress,isEvaluate,emitLp) = {
216	216	let cfg = getPoolConfig()
217	217	let lpAssetId = fromBase58String(cfg[idxPoolLPAssetId])
218	218	let amAssetIdStr = cfg[idxAmtAssetId]
219	219	let prAssetIdStr = cfg[idxPriceAssetId]
220	220	let iAmtAssetId = cfg[idxIAmtAssetId]
221	221	let iPriceAssetId = cfg[idxIPriceAssetId]
222	222	let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
223	223	let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
224	224	let poolStatus = cfg[idxPoolStatus]
225	225	let lpEmission = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
226	226	let inAmAssetIdStr = toBase58String(valueOrElse(inAmAssetId, fromBase58String("WAVES")))
227	227	let inPrAssetIdStr = toBase58String(valueOrElse(inPrAssetId, fromBase58String("WAVES")))
228	228	if (if ((amAssetIdStr != inAmAssetIdStr))
229	229	then true
230	230	else (prAssetIdStr != inPrAssetIdStr))
231	231	then throw("Invalid amt or price asset passed.")
232	232	else {
233	233	let amBalance = if (isEvaluate)
234	234	then getAccBalance(amAssetIdStr)
235	235	else (getAccBalance(amAssetIdStr) - inAmAssetAmt)
236	236	let prBalance = if (isEvaluate)
237	237	then getAccBalance(prAssetIdStr)
238	238	else (getAccBalance(prAssetIdStr) - inPrAssetAmt)
239	239	let inAmAssetAmtX18 = toX18(inAmAssetAmt, amtAssetDcm)
240	240	let inPrAssetAmtX18 = toX18(inPrAssetAmt, priceAssetDcm)
241	241	let userPriceX18 = calcPriceBigInt(inPrAssetAmtX18, inAmAssetAmtX18)
242	242	let amBalanceX18 = toX18(amBalance, amtAssetDcm)
243	243	let prBalanceX18 = toX18(prBalance, priceAssetDcm)
244	244	let res = if ((lpEmission == 0))
245	245	then {
246	246	let curPriceX18 = zeroBigInt
247	247	let slippageX18 = zeroBigInt
248	248	let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
249	249	$Tuple5(fromX18(lpAmtX18, scale8), fromX18(inAmAssetAmtX18, amtAssetDcm), fromX18(inPrAssetAmtX18, priceAssetDcm), calcPriceBigInt((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
250	250	}
251	251	else {
252	252	let curPriceX18 = calcPriceBigInt(prBalanceX18, amBalanceX18)
253	253	let slippageX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
254	254	let slippageToleranceX18 = toX18(slippageTolerance, scale8)
255	255	if (if ((curPriceX18 != zeroBigInt))
256	256	then (slippageX18 > slippageToleranceX18)
257	257	else false)
258	258	then throw(((("Price slippage " + toString(slippageX18)) + " exceeded the passed limit of ") + toString(slippageToleranceX18)))
259	259	else {
260	260	let lpEmissionX18 = toX18(lpEmission, scale8)
261	261	let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
262	262	let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
263	263	let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
264	264	then $Tuple2(amViaPrX18, inPrAssetAmtX18)
265	265	else $Tuple2(inAmAssetAmtX18, prViaAmX18)
266	266	let expAmtAssetAmtX18 = expectedAmts._1
267	267	let expPriceAssetAmtX18 = expectedAmts._2
268	268	let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
269	269	$Tuple5(fromX18(lpAmtX18, scale8), fromX18(expAmtAssetAmtX18, amtAssetDcm), fromX18(expPriceAssetAmtX18, priceAssetDcm), curPriceX18, slippageX18)
270	270	}
271	271	}
272	272	let calcLpAmt = res._1
273	273	let calcAmAssetPmt = res._2
274	274	let calcPrAssetPmt = res._3
275	275	let curPrice = fromX18(res._4, scale8)
276	276	let slippageCalc = fromX18(res._5, scale8)
277	277	if ((0 >= calcLpAmt))
278	278	then throw("Invalid calculations. LP calculated is less than zero.")
279	279	else {
280	280	let emitLpAmt = if (!(emitLp))
281	281	then 0
282	282	else calcLpAmt
283	283	let amDiff = (inAmAssetAmt - calcAmAssetPmt)
284	284	let prDiff = (inPrAssetAmt - calcPrAssetPmt)
285	285	let commonState = [IntegerEntry(keyPriceLast(), curPrice), IntegerEntry(keyPriceHistory(height, lastBlock.timestamp), curPrice), StringEntry(keyPutActionByUser(userAddress, txId58), dataPutActionInfo(calcAmAssetPmt, calcPrAssetPmt, emitLpAmt, curPrice, slippageTolerance, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
286	286	$Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEmission, lpAssetId, poolStatus, commonState, amDiff, prDiff, inAmAssetId, inPrAssetId)
287	287	}
288	288	}
289	289	}
290	290
291	291
292	292	func validateMatcherOrderAllowed (order) = {
293	293	let cfg = getPoolConfig()
294	294	let amtAssetId = cfg[idxAmtAssetId]
295	295	let priceAssetId = cfg[idxPriceAssetId]
296	296	let poolStatus = parseIntValue(cfg[idxPoolStatus])
297	297	let amtAssetDcm = parseIntValue(cfg[idxAmtAssetDcm])
298	298	let priceAssetDcm = parseIntValue(cfg[idxPriceAssetDcm])
299	299	let accAmtAssetBalance = getAccBalance(amtAssetId)
300	300	let accPriceAssetBalance = getAccBalance(priceAssetId)
301	301	let curPriceX18 = if ((order.orderType == Buy))
302	302	then privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance + order.amount), accPriceAssetBalance)
303	303	else privateCalcPrice(amtAssetDcm, priceAssetDcm, (accAmtAssetBalance - order.amount), accPriceAssetBalance)
304	304	let curPrice = fromX18(curPriceX18, scale8)
305	305	if (if (if (isGlobalShutdown())
306	306	then true
307	307	else (poolStatus == PoolMatcherDisabled))
308	308	then true
309	309	else (poolStatus == PoolShutdown))
310	310	then throw("Exchange operations disabled")
311	311	else {
312	312	let orderAmtAsset = order.assetPair.amountAsset
313	313	let orderAmtAssetStr = if ((orderAmtAsset == unit))
314	314	then "WAVES"
315	315	else toBase58String(value(orderAmtAsset))
316	316	let orderPriceAsset = order.assetPair.priceAsset
317	317	let orderPriceAssetStr = if ((orderPriceAsset == unit))
318	318	then "WAVES"
319	319	else toBase58String(value(orderPriceAsset))
320	320	if (if ((orderAmtAssetStr != amtAssetId))
321	321	then true
322	322	else (orderPriceAssetStr != priceAssetId))
323	323	then throw("Wrong order assets.")
324	324	else {
325	325	let orderPrice = order.price
326	326	let priceDcm = fraction(scale8, priceAssetDcm, amtAssetDcm)
327	327	let castedOrderPrice = toScale(orderPrice, scale8, priceDcm)
328	328	let isOrderPriceValid = if ((order.orderType == Buy))
329	329	then (curPrice >= castedOrderPrice)
330	330	else (castedOrderPrice >= curPrice)
331	331	true
332	332	}
333	333	}
334	334	}
335	335
336	336
337	337	func commonGet (i) = if ((size(i.payments) != 1))
338	338	then throw("exactly 1 payment is expected")
339	339	else {
340	340	let pmt = value(i.payments[0])
341	341	let pmtAssetId = value(pmt.assetId)
342	342	let pmtAmt = pmt.amount
343	343	let res = estimateGetOperation(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
344	344	let outAmAmt = res._1
345	345	let outPrAmt = res._2
346	346	let poolStatus = parseIntValue(res._9)
347	347	let state = res._10
348	348	if (if (isGlobalShutdown())
349	349	then true
350	350	else (poolStatus == PoolShutdown))
351	351	then throw(("Get operation is blocked by admin. Status = " + toString(poolStatus)))
352	352	else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
353	353	}
354	354
355	355
356	356	func commonPut (i,slippageTolerance,emitLp) = if ((size(i.payments) != 2))
357	357	then throw("exactly 2 payments are expected")
358	358	else {
359	359	let amAssetPmt = value(i.payments[0])
360	360	let prAssetPmt = value(i.payments[1])
361	361	let estPut = estimatePutOperation(toBase58String(i.transactionId), slippageTolerance, amAssetPmt.amount, amAssetPmt.assetId, prAssetPmt.amount, prAssetPmt.assetId, toString(i.caller), false, emitLp)
362	362	let poolStatus = parseIntValue(estPut._8)
363	363	if (if (if (isGlobalShutdown())
364	364	then true
365	365	else (poolStatus == PoolPutDisabled))
366	366	then true
367	367	else (poolStatus == PoolShutdown))
368	368	then throw(("Put operation is blocked by admin. Status = " + toString(poolStatus)))
369	369	else estPut
370	370	}
371	371
372	372
373	373	@Callable(i)
374	374	func constructor (factoryContract,managerPublicKey) = if ((i.caller != this))
375	375	then throw("permissions denied")
376	376	else [StringEntry(keyFactoryContract(), factoryContract), StringEntry(keyManagerPublicKey(), managerPublicKey)]
377	377
378	378
379	379
380	380	@Callable(i)
381	381	func put (slippageTolerance,shouldAutoStake) = {
382	382	let factoryCfg = getFactoryConfig()
383	383	let stakingContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactoryStakingContract]), "Error. Incorrect staking address.")
384	384	let slippageContract = valueOrErrorMessage(addressFromString(factoryCfg[idxFactorySlippageContract]), "Error. Incorrect slippage contract address.")
385	385	if ((0 > slippageTolerance))
386	386	then throw("Invalid slippageTolerance passed")
387	387	else {
388	388	let estPut = commonPut(i, slippageTolerance, true)
389	389	let emitLpAmt = estPut._2
390	390	let lpAssetId = estPut._7
391	391	let state = estPut._9
392	392	let amDiff = estPut._10
393	393	let prDiff = estPut._11
394	394	let amId = estPut._12
395	395	let prId = estPut._13
396	396	let emitInv = invoke(factoryContract, "emit", [emitLpAmt], nil)
397	397	if ((emitInv == emitInv))
398	398	then {
399	399	let slippageAInv = if ((amDiff > 0))
400	400	then invoke(slippageContract, "put", nil, [AttachedPayment(amId, amDiff)])
401	401	else nil
402	402	if ((slippageAInv == slippageAInv))
403	403	then {
404	404	let slippagePInv = if ((prDiff > 0))
405	405	then invoke(slippageContract, "put", nil, [AttachedPayment(prId, prDiff)])
406	406	else nil
407	407	if ((slippagePInv == slippagePInv))
408	408	then {
409	409	let lpTransfer = if (shouldAutoStake)
410	410	then {
411	411	let slpStakeInv = invoke(stakingContract, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
412	412	if ((slpStakeInv == slpStakeInv))
413	413	then nil
414	414	else throw("Strict value is not equal to itself.")
415	415	}
416	416	else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
417	417	(state ++ lpTransfer)
418	418	}
419	419	else throw("Strict value is not equal to itself.")
420	420	}
421	421	else throw("Strict value is not equal to itself.")
422	422	}
423	423	else throw("Strict value is not equal to itself.")
424	424	}
425	425	}
426	426
427	427
428	428
429	429	@Callable(i)
430	430	func putForFree (maxSlippage) = if ((0 > maxSlippage))
431	431	then throw("Invalid value passed")
432	432	else {
433	433	let estPut = commonPut(i, maxSlippage, false)
434	434	estPut._9
435	435	}
436	436
437	437
438	438
439	439	@Callable(i)
440	440	func get () = {
441	441	let res = commonGet(i)
442	442	let outAmtAmt = res._1
443	443	let outPrAmt = res._2
444	444	let pmtAmt = res._3
445	445	let pmtAssetId = res._4
446	446	let state = res._5
447	447	let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
448	448	if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
449	449	then state
450	450	else throw("Strict value is not equal to itself.")
451	451	}
452	452
453	453
454	454
455	455	@Callable(i)
456	456	func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
457	457	let res = commonGet(i)
458	458	let outAmAmt = res._1
459	459	let outPrAmt = res._2
460	460	let pmtAmt = res._3
461	461	let pmtAssetId = res._4
462	462	let state = res._5
463	463	if ((noLessThenAmtAsset > outAmAmt))
464	464	then throw(((("noLessThenAmtAsset failed: " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
465	465	else if ((noLessThenPriceAsset > outPrAmt))
466	466	then throw(((("noLessThenPriceAsset failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
467	467	else {
468	468	let burnLPAssetOnFactory = invoke(factoryContract, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
469	469	if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
470	470	then state
471	471	else throw("Strict value is not equal to itself.")
472	472	}
473	473	}
474	474
475	475
476	476
477	477	@Callable(i)
478	478	func activate (amtAssetStr,priceAssetStr) = if ((toString(i.caller) != toString(factoryContract)))
479	479	then throw("permissions denied")
480	480	else $Tuple2([StringEntry(keyAmtAsset(), amtAssetStr), StringEntry(keyPriceAsset(), priceAssetStr)], "success")
481	481
482	482
483	483
484	484	@Callable(i)
485	485	func getPoolConfigWrapperREADONLY () = $Tuple2(nil, getPoolConfig())
486	486
487	487
488	488
489	489	@Callable(i)
490	490	func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
491	491
492	492
493	493
494	494	@Callable(i)
495	495	func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
496	496	let prices = calcPrices(amAmt, prAmt, lpAmt)
497	497	$Tuple2(nil, [toString(prices[0]), toString(prices[1]), toString(prices[2])])
498	498	}
499	499
500	500

github/deemru/w8io/026f985 
75.09 ms ◑