tx · Aw2Cx2EUJnM5xy3E7RWtxHDEXMRNm8mMeBLtBARuJxF2

3MsNhK6uve98J6DeqbuwGFBRh9GoHPGUFgp:  -0.02300000 Waves

2023.08.17 16:34 [2714660] smart account 3MsNhK6uve98J6DeqbuwGFBRh9GoHPGUFgp > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Aw2Cx2EUJnM5xy3E7RWtxHDEXMRNm8mMeBLtBARuJxF2",
    "fee": 2300000,
    "feeAssetId": null,
    "timestamp": 1692279248233,
    "version": 2,
    "chainId": 84,
    "sender": "3MsNhK6uve98J6DeqbuwGFBRh9GoHPGUFgp",
    "senderPublicKey": "86RHVxKovtU7yKnepY8wKsd8niDxGAsiwuA1XA1DNqrS",
    "proofs": [
        "2NougJbyAemHZYsu5b43kAjSTnx1mzzJGqEhzrCQ1gbumx8Yvc4yuiKKQY67YjWBsG5xDNkoWsHvHArzY61M6L3T"
    ],
    "script": "base64:BgLpIAgCEgMKAQgSAwoBCBIECgIICBIJCgcBERERGAgYEgcKBRERERgIEgcKBQEBAQgIEgASAwoBCBIECgIIARIECgIIARIECgIIARIDCgEIEgYKBAgBCAESBQoDARgYEgMKARgiBlNDQUxFOCIFTVVMVDgiB1NDQUxFMTgiBk1VTFQxOCIDU0VQIg5QT09MV0VJR0hUTVVMVCIKemVyb0JpZ0ludCIOaWR4UG9vbEFkZHJlc3MiDWlkeFBvb2xTdGF0dXMiEGlkeFBvb2xMUEFzc2V0SWQiDWlkeEFtdEFzc2V0SWQiD2lkeFByaWNlQXNzZXRJZCIOaWR4QW10QXNzZXREY20iEGlkeFByaWNlQXNzZXREY20iDmlkeElBbXRBc3NldElkIhBpZHhJUHJpY2VBc3NldElkIg1pZHhMUEFzc2V0RGNtIg9nZXRTdHJpbmdPckZhaWwiA2tleSIYZ2V0U3RyaW5nQnlBZGRyZXNzT3JGYWlsIgdhZGRyZXNzIgxnZXRJbnRPclplcm8iDGdldEludE9yRmFpbCIJYXNBbnlMaXN0IgN2YWwiByRtYXRjaDAiCnZhbEFueUx5c3QiBWFzSW50IgZ2YWxJbnQiCGFzU3RyaW5nIgZ2YWxTdHIiEWtleUZhY3RvcnlBZGRyZXNzIhhJZHhGYWN0b3J5Q2ZnU3Rha2luZ0RhcHAiGUlkeEZhY3RvcnlDZmdCb29zdGluZ0RhcHAiFElkeEZhY3RvcnlDZmdJZG9EYXBwIhVJZHhGYWN0b3J5Q2ZnVGVhbURhcHAiGUlkeEZhY3RvcnlDZmdFbWlzc2lvbkRhcHAiFUlkeEZhY3RvcnlDZmdSZXN0RGFwcCIZSWR4RmFjdG9yeUNmZ1NsaXBwYWdlRGFwcCIaSWR4RmFjdG9yeUNmZ0d3eFJld2FyZERhcHAiDWtleUZhY3RvcnlDZmciGmtleUZhY3RvcnlMcDJBc3NldHNNYXBwaW5nIgpscEFzc2V0U3RyIhBrZXlGYWN0b3J5THBMaXN0IiZrZXlGYWN0b3J5THBBc3NldFRvUG9vbENvbnRyYWN0QWRkcmVzcyIUa2V5RmFjdG9yeVBvb2xXZWlnaHQiD2NvbnRyYWN0QWRkcmVzcyIWa2V5TWFuYWdlclZhdWx0QWRkcmVzcyITa2V5TWFuYWdlclB1YmxpY0tleSIYcmVhZEZhY3RvcnlBZGRyZXNzT3JGYWlsIgpyZWFkTHBMaXN0IhRyZWFkRmFjdG9yeUNmZ09yRmFpbCIHZmFjdG9yeSIYZ2V0Qm9vc3RpbmdBZGRyZXNzT3JGYWlsIgRmQ2ZnIhhnZXRFbWlzc2lvbkFkZHJlc3NPckZhaWwiF2dldFN0YWtpbmdBZGRyZXNzT3JGYWlsIhlnZXRHd3hSZXdhcmRBZGRyZXNzT3JGYWlsIhxnZXRNYW5hZ2VyVmF1bHRBZGRyZXNzT3JUaGlzIgFzIgtrZXlCb29zdENmZyIfa2V5Qm9vc3RpbmdMb2NrUGFyYW1Ub3RhbEFtb3VudCIoa2V5Qm9vc3RpbmdTdGF0c0xvY2tzRHVyYXRpb25TdW1JbkJsb2NrcyIaa2V5Qm9vc3RpbmdTdGF0c0xvY2tzQ291bnQiGmtleUJvb3N0aW5nU3RhdHNVc2Vyc0NvdW50IhJrZXlVc2VyMk51bU1hcHBpbmciC3VzZXJBZGRyZXNzIhJrZXlOdW0yVXNlck1hcHBpbmciA251bSIWa2V5TG9ja1BhcmFtVXNlckFtb3VudCIHdXNlck51bSIWa2V5TG9ja1BhcmFtU3RhcnRCbG9jayIUa2V5TG9ja1BhcmFtRHVyYXRpb24iDWtleUxvY2tQYXJhbUsiDWtleUxvY2tQYXJhbUIiFWtleUxvY2tQYXJhbUJ5UGVyaW9kSyIGcGVyaW9kIhVrZXlMb2NrUGFyYW1CeVBlcmlvZEIiIGtleVVzZXJCb29zdEVtaXNzaW9uTGFzdElOVEVHUkFMIhdrZXlVc2VyTWF4Qm9vc3RJTlRFR1JBTCIYa2V5VG90YWxNYXhCb29zdElOVEVHUkFMIiFrZXlVc2VyQm9vc3RBdmFsYWlibGVUb0NsYWltVG90YWwiE2tleVVzZXJCb29zdENsYWltZWQiEWtleVRvdGFsQ2FjaGVkR3d4Ig9rZXlTdGFrZWRCeVVzZXIiDnVzZXJBZGRyZXNzU3RyIgxscEFzc2V0SWRTdHIiDmtleVN0YWtlZFRvdGFsIhBrZXlDbGFpbWVkQnlVc2VyIhlrZXlDbGFpbWVkQnlVc2VyTWluUmV3YXJkIhtrZXlDbGFpbWVkQnlVc2VyQm9vc3RSZXdhcmQiCnJlYWRTdGFrZWQiC3N0YWtpbmdEYXBwIh5rZXlFbWlzc2lvblJhdGVQZXJCbG9ja0N1cnJlbnQiIWtleUVtaXNzaW9uUmF0ZVBlckJsb2NrTWF4Q3VycmVudCIVa2V5RW1pc3Npb25TdGFydEJsb2NrIhtrZXlFbWlzc2lvbkR1cmF0aW9uSW5CbG9ja3MiE2tleUVtaXNzaW9uRW5kQmxvY2siC2ZhY3RvcnlEYXBwIgpmYWN0b3J5Q2ZnIgxlbWlzc2lvbkRhcHAiDWd3eFJld2FyZERhcHAiDGJvb3N0aW5nRGFwcCIMZ2V0UG9vbEluRmVlIgtwb29sQWRkcmVzcyIBQCINZ2V0UG9vbE91dEZlZSIZaW50ZXJuYWxDdXJyZW50UmV3YXJkUmF0ZSIJbHBBc3NldElkIg5wb29sQWRkcmVzc1N0ciIOcG9vbFdlaWdodE11bHQiCnBvb2xXZWlnaHQiEnd4RW1pc3Npb25QZXJCbG9jayIVd3hFbWlzc2lvblBlckJsb2NrTWF4Ig1ib29zdE1heENvZWZmIhZwb29sV3hFbWlzc2lvblBlckJsb2NrIhlwb29sV3hFbWlzc2lvblBlckJsb2NrTWF4IgltYXhGYWN0b3IiDXRvdGFsTHBTdGFrZWQiGmNhbGNHd3hBbW91bnRTdGFydFJFQURPTkxZIgpsb2NrQW1vdW50Igxsb2NrRHVyYXRpb24iD21heExvY2tEdXJhdGlvbiIHY29lZmZYOCIOZ1d4QW1vdW50U3RhcnQiBmdldEtleSIEYWRkciIEdHlwZSIWbWFuYWdlclB1YmxpY0tleU9yVW5pdCITbWFuYWdlclZhdWx0QWRkcmVzcyIJaXNNYW5hZ2VyIgFpIgJwayILbXVzdE1hbmFnZXIiDmZhY3RvcnlBZGRyZXNzIgtjaGVja0NhbGxlciIKcmV3YXJkRGF0YSISdm90aW5nUmVzdWx0U3Rha2VkIg5scFN0YWtlZEJ5VXNlciINdXNlckNsYWltSW5mbyINbWluUmV3YXJkUGFydCIPYm9vc3RSZXdhcmRQYXJ0IgVkZWJ1ZyINYm9vc3RpbmdQb3dlciILY3VycmVudEl0ZXIiEWRlbHRhV3hBbW91bnRCdWxrIhtkZWx0YUxvY2tQZXJpb2RJbkJsb2Nrc0J1bGsiEWRlbHRhTHBBbW91bnRCdWxrIhBscEFzc2V0SWRPcHRCdWxrIg51c2VyQWRkcmVzc09wdCIGcmVzQWNjIg1kZWx0YVd4QW1vdW50IhdkZWx0YUxvY2tQZXJpb2RJbkJsb2NrcyINZGVsdGFMcEFtb3VudCIMbHBBc3NldElkT3B0IgRpbmZvIgNyZXMiA2ludiIKYm9vc3RDb2VmZiIIbWF0aERhcHAiCEVNUFRZU1RSIhdtYXhMb2NrRHVyYXRpb25JbkJsb2NrcyIKdXNlck51bVN0ciIKdXNlckFtb3VudCIJbG9ja1N0YXJ0Igdsb2NrRW5kIhFyZW1haW5pbmdEdXJhdGlvbiINdXNlckFtb3VudE5ldyIPbG9ja0R1cmF0aW9uTmV3IhF1c2VyQ3VycmdXeEFtb3VudCIRZ1d4QW1vdW50U3RhcnROZXciDnRvdGFsQ2FjaGVkR3d4IgVNVUxUMyIUd3hFbWlzc2lvblBlckJsb2NrWDMiD3N0YWtlZEJ5VXNlcktFWSIOc3Rha2VkVG90YWxLRVkiDHN0YWtlZEJ5VXNlciILc3Rha2VkVG90YWwiGHBvb2xXeEVtaXNzaW9uUGVyQmxvY2tYMyIJd3hQZXJMcFgzIhB1c2VyV3hQZXJCbG9ja1gzIhdib29zdEVtaXNzaW9uUGVyQmxvY2tYMyIWdG1wVXNlckJvb3N0UGVyQmxvY2tYMyITdXNlckJvb3N0UGVyQmxvY2tYMyIOdXNlckJvb3N0Q29lZmYiB09ORU1VTFQiA09ORSISZW1pc3Npb25TdGFydEJsb2NrIgxwYXNzZWRCbG9ja3MiDnRlYW1FbUR1cmF0aW9uIgl0ZWFtRW1NYXgiBnRlYW1FbSIPdG90YWxXeFJlbGVhc2VkIg10b3RhbFd4TG9ja2VkIhhsb2Nrc0R1cmF0aW9uU3VtSW5CbG9ja3MiCmxvY2tzQ291bnQiB2xwQXNzZXQiBnN0YXR1cyIDdHBsIgNjZmciCmFtdEFzc2V0SWQiDHByaWNlQXNzZXRJZCILaUFtdEFzc2V0SWQiDWlQcmljZUFzc2V0SWQiC2FtdEFzc2V0RGNtIg1wcmljZUFzc2V0RGNtIg1wb29sTFBCYWxhbmNlIhJhY2NBbXRBc3NldEJhbGFuY2UiFGFjY1ByaWNlQXNzZXRCYWxhbmNlIgpwcmljZXNMaXN0IghjdXJQcmljZSIPbHBBbXRBc3NldFNoYXJlIhFscFByaWNlQXNzZXRTaGFyZSIFaW5GZWUiBm91dEZlZSIecG9vbE9uZVRva2VuT3BlcmF0aW9uc0Rpc2FibGVkIh1wb29sT25lVG9rZW5PcGVyYXRpb25zRW5hYmxlZCIMaW5BbUFzc2V0QW10IgxhbUFzc2V0SWRTdHIiCWFtQXNzZXRJZCIMcHJBc3NldElkU3RyIglwckFzc2V0SWQiCnBvb2xTdGF0dXMiDmFtdEFzc2V0QW10WDE4IhBwcmljZUFzc2V0QW10WDE4IgtjdXJQcmljZVgxOCIPaW5BbUFzc2V0QW10WDE4Ig9pblByQXNzZXRBbXRYMTgiDGluUHJBc3NldEFtdCINJHQwMjI2OTEyMzA0NCIJY2FsY0xwQW10IgxjdXJQcmljZUNhbGMiCWFtQmFsYW5jZSIJcHJCYWxhbmNlIgpscEVtaXNzaW9uIgxhbUJhbGFuY2VSYXciDHByQmFsYW5jZVJhdyIPYW1CYWxhbmNlUmF3WDE4Ig9wckJhbGFuY2VSYXdYMTgiDSR0MDI1NjE3MjU5NzAiEHBheW1lbnRMcEFzc2V0SWQiDHBheW1lbnRMcEFtdCINJHQwMjY2NjUyNzA4MiIIb3V0QW1BbXQiCG91dFByQW10Ig9nd3hVc2VySW5mb0xJU1QiCWd3eEFtb3VudCINdW5zdGFrZUFtb3VudCIKb3V0QXNzZXRJZCIMbWluT3V0QW1vdW50IgRrZXlzIgFrIgJ0eCIGdmVyaWZ5Ig90YXJnZXRQdWJsaWNLZXldAAFhAAgAAWIAgMLXLwABYwASAAFkCQC2AgEAgICQu7rWrfANAAFlAgJfXwABZgUBYgABZwkAtgIBAAAAAWgAAQABaQACAAFqAAMAAWsABAABbAAFAAFtAAYAAW4ABwABbwAIAAFwAAkAAXEACgEBcgEBcwkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCiCAEFAXMJAKwCAgkArAICAg9tYW5kYXRvcnkgdGhpcy4FAXMCDyBpcyBub3QgZGVmaW5lZAEBdAIBdQFzCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUBdQUBcwkArAICCQCsAgIJAKwCAgkArAICAgptYW5kYXRvcnkgCQClCAEFAXUCAS4FAXMCDyBpcyBub3QgZGVmaW5lZAEBdgIBdQFzCQELdmFsdWVPckVsc2UCCQCaCAIFAXUFAXMAAAEBdwIBdQFzCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUBdQUBcwkArAICCQCsAgICD21hbmRhdG9yeSB0aGlzLgUBcwIPIGlzIG5vdCBkZWZpbmVkAQF4AQF5BAF6BQF5AwkAAQIFAXoCCUxpc3RbQW55XQQBQQUBegUBQQkAAgECG2ZhaWwgdG8gY2FzdCBpbnRvIExpc3RbQW55XQEBQgEBeQQBegUBeQMJAAECBQF6AgNJbnQEAUMFAXoFAUMJAAIBAhVmYWlsIHRvIGNhc3QgaW50byBJbnQBAUQBAXkEAXoFAXkDCQABAgUBegIGU3RyaW5nBAFFBQF6BQFFCQACAQIYZmFpbCB0byBjYXN0IGludG8gU3RyaW5nAQFGAAIcJXMlc19fY29uZmlnX19mYWN0b3J5QWRkcmVzcwABRwABAAFIAAIAAUkAAwABSgAEAAFLAAUAAUwABgABTQAHAAFOAAgBAU8AAhElc19fZmFjdG9yeUNvbmZpZwEBUAEBUQkAuQkCCQDMCAICBiVzJXMlcwkAzAgCBQFRCQDMCAICHm1hcHBpbmdzX19scEFzc2V0MlBvb2xDb250cmFjdAUDbmlsBQFlAQFSAAIQJXNfX2xwVG9rZW5zTGlzdAEBUwEBUQkAuQkCCQDMCAICBiVzJXMlcwkAzAgCBQFRCQDMCAICHm1hcHBpbmdzX19scEFzc2V0MlBvb2xDb250cmFjdAUDbmlsBQFlAQFUAQFVCQC5CQIJAMwIAgIEJXMlcwkAzAgCAgpwb29sV2VpZ2h0CQDMCAIFAVUFA25pbAUBZQEBVgACFyVzX19tYW5hZ2VyVmF1bHRBZGRyZXNzAQFXAAIUJXNfX21hbmFnZXJQdWJsaWNLZXkBAVgACQERQGV4dHJOYXRpdmUoMTA2MikBCQEBcgEJAQFGAAEBWQAJALUJAgkBC3ZhbHVlT3JFbHNlAgkAnQgCCQEBWAAJAQFSAAIABQFlAQFaAQJhYQkAtQkCCQEBdAIFAmFhCQEBTwAFAWUBAmFiAQJhYwkBEUBleHRyTmF0aXZlKDEwNjIpAQkAkQMCBQJhYwUBSAECYWQBAmFjCQERQGV4dHJOYXRpdmUoMTA2MikBCQCRAwIFAmFjBQFLAQJhZQECYWMJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAJEDAgUCYWMFAUcBAmFmAQJhYwkBEUBleHRyTmF0aXZlKDEwNjIpAQkAkQMCBQJhYwUBTgECYWcABAF6CQCiCAEJAQFWAAMJAAECBQF6AgZTdHJpbmcEAmFoBQF6CQERQGV4dHJOYXRpdmUoMTA2MikBBQJhaAUEdGhpcwECYWkAAgolc19fY29uZmlnAQJhagACHiVzJXNfX3N0YXRzX19hY3RpdmVUb3RhbExvY2tlZAECYWsAAiUlcyVzX19zdGF0c19fbG9ja3NEdXJhdGlvblN1bUluQmxvY2tzAQJhbAACFyVzJXNfX3N0YXRzX19sb2Nrc0NvdW50AQJhbQACHSVzJXNfX3N0YXRzX19hY3RpdmVVc2Vyc0NvdW50AQJhbgECYW8JALkJAgkAzAgCAhklcyVzJXNfX21hcHBpbmdfX3VzZXIybnVtCQDMCAIFAmFvBQNuaWwFAWUBAmFwAQJhcQkAuQkCCQDMCAICGSVzJXMlc19fbWFwcGluZ19fbnVtMnVzZXIJAMwIAgUCYXEFA25pbAUBZQECYXIBAmFzCQC5CQIJAMwIAgIWJXMlZCVzX19wYXJhbUJ5VXNlck51bQkAzAgCBQJhcwkAzAgCAgZhbW91bnQFA25pbAUBZQECYXQBAmFzCQC5CQIJAMwIAgIWJXMlZCVzX19wYXJhbUJ5VXNlck51bQkAzAgCBQJhcwkAzAgCAgVzdGFydAUDbmlsBQFlAQJhdQECYXMJALkJAgkAzAgCAhYlcyVkJXNfX3BhcmFtQnlVc2VyTnVtCQDMCAIFAmFzCQDMCAICCGR1cmF0aW9uBQNuaWwFAWUBAmF2AQJhcwkAuQkCCQDMCAICFiVzJWQlc19fcGFyYW1CeVVzZXJOdW0JAMwIAgUCYXMJAMwIAgIBawUDbmlsBQFlAQJhdwECYXMJALkJAgkAzAgCAhYlcyVkJXNfX3BhcmFtQnlVc2VyTnVtCQDMCAIFAmFzCQDMCAICAWIFA25pbAUBZQECYXgCAmFzAmF5CQC5CQIJAMwIAgIXJXMlZCVzJWRfX3BhcmFtQnlQZXJpb2QJAMwIAgUCYXMJAMwIAgIBawkAzAgCBQJheQUDbmlsBQFlAQJhegICYXMCYXkJALkJAgkAzAgCAhclcyVkJXMlZF9fcGFyYW1CeVBlcmlvZAkAzAgCBQJhcwkAzAgCAgFiCQDMCAIFAmF5BQNuaWwFAWUBAmFBAQJhcwkAuQkCCQDMCAICHiVzJWRfX3VzZXJCb29zdEVtaXNzaW9uTGFzdEludAkAzAgCBQJhcwUDbmlsBQFlAQJhQgECYXMJALkJAgkAzAgCAhElcyVkX19tYXhCb29zdEludAkAzAgCBQJhcwUDbmlsBQFlAQJhQwACGCVzJXNfX21heEJvb3N0SW50X190b3RhbAECYUQBAmFzCQC5CQIJAMwIAgIkJXMlZF9fdXNlckJvb3N0QXZhbGlhYmxlVG9DbGFpbVRvdGFsCQDMCAIFAmFzBQNuaWwFAWUBAmFFAQJhcwkAuQkCCQDMCAICFiVzJWRfX3VzZXJCb29zdENsYWltZWQJAMwIAgUCYXMFA25pbAUBZQECYUYAAhYlcyVzX19nd3hDYWNoZWRfX3RvdGFsAQJhRwICYUgCYUkJALkJAgkAzAgCAg4lcyVzJXNfX3N0YWtlZAkAzAgCBQJhSAkAzAgCBQJhSQUDbmlsBQFlAQJhSgECYUkJAKwCAgIXJXMlcyVzX19zdGFrZWRfX3RvdGFsX18FAmFJAQJhSwICYUkCYUgJALkJAgkAzAgCAg8lcyVzJXNfX2NsYWltZWQJAMwIAgUCYUgJAMwIAgUCYUkFA25pbAUBZQECYUwCAmFJAmFICQC5CQIJAMwIAgIYJXMlcyVzX19jbGFpbWVkTWluUmV3YXJkCQDMCAIFAmFICQDMCAIFAmFJBQNuaWwFAWUBAmFNAgJhSQJhSAkAuQkCCQDMCAICGiVzJXMlc19fY2xhaW1lZEJvb3N0UmV3YXJkCQDMCAIFAmFICQDMCAIFAmFJBQNuaWwFAWUBAmFOAgJhTwFzCQELdmFsdWVPckVsc2UCCQCaCAIFAmFPBQFzAAABAmFQAAIbJXMlc19fcmF0ZVBlckJsb2NrX19jdXJyZW50AQJhUQACHiVzJXNfX3JhdGVQZXJCbG9ja01heF9fY3VycmVudAECYVIAAholcyVzX19lbWlzc2lvbl9fc3RhcnRCbG9jawECYVMAAhglcyVzX19lbWlzc2lvbl9fZHVyYXRpb24BAmFUAAIYJXMlc19fZW1pc3Npb25fX2VuZEJsb2NrAAJhVQkBAVgAAAJhVgkBAVoBBQJhVQACYVcJAQJhZAEFAmFWAAJhTwkBAmFlAQUCYVYAAmFYCQECYWYBBQJhVgACYVkJAQJhYgEFAmFWAQJhWgECYmEKAAJiYgkA/AcEBQJhVQIQZ2V0SW5GZWVSRUFET05MWQkAzAgCCQClCAEFAmJhBQNuaWwFA25pbAMJAAECBQJiYgIDSW50BQJiYgkAAgEJAKwCAgkAAwEFAmJiAhggY291bGRuJ3QgYmUgY2FzdCB0byBJbnQBAmJjAQJiYQoAAmJiCQD8BwQFAmFVAhFnZXRPdXRGZWVSRUFET05MWQkAzAgCCQClCAEFAmJhBQNuaWwFA25pbAMJAAECBQJiYgIDSW50BQJiYgkAAgEJAKwCAgkAAwEFAmJiAhggY291bGRuJ3QgYmUgY2FzdCB0byBJbnQBAmJkAQJiZQQCYmYJAQF0AgUCYVUJAQFTAQUCYmUEAmJnBQFiBAJiaAkBEUBleHRyTmF0aXZlKDEwNTApAgUCYVUJAQFUAQUCYmYEAmJpCQEBdwIFAmFXCQECYVAABAJiagkBAXcCBQJhVwkBAmFRAAQCYmsKAAJiYgkA/AcEBQJhVwIVZ2V0Qm9vc3RDb2VmZlJFQURPTkxZBQNuaWwFA25pbAMJAAECBQJiYgIDSW50BQJiYgkAAgEJAKwCAgkAAwEFAmJiAhggY291bGRuJ3QgYmUgY2FzdCB0byBJbnQEAmJsCQBpAgkAawMFAmJpBQJiaAUCYmcFAmJrBAJibQkAawMFAmJqBQJiaAUCYmcEAmJuCQBoAgUCYmsFAWIEAmJvCQEBdgIFAmFPCQECYUoBBQJiZQkAzAgCBQJibAkAzAgCBQJibgkAzAgCBQJibwUDbmlsAQJicAMCYnECYnICYnMEAmJ0CQBrAwUCYnIFAWIFAmJzBAJidQkAawMFAmJxBQJidAUBYgkAzAgCBQJidQUDbmlsAQJidgMCYncBcwJieAMJAAACBQJieAIGc3RyaW5nCQERQGV4dHJOYXRpdmUoMTA1MykCBQJidwUBcwMJAAACBQJieAIHaW50ZWdlcgkApAMBCQERQGV4dHJOYXRpdmUoMTA1MCkCBQJidwUBcwMJAAACBQJieAIHYm9vbGVhbgkApQMBCQERQGV4dHJOYXRpdmUoMTA1MSkCBQJidwUBcwkAAgECLXVua25vd24gdHlwZS4gZXhwZWN0ZWQgc3RyaW5nL2ludGVnZXIvYm9vbGVhbgECYnkABAJiegkBAmFnAAQBegkAnQgCBQJiegkBAVcAAwkAAQIFAXoCBlN0cmluZwQCYWgFAXoJANkEAQUCYWgDCQABAgUBegIEVW5pdAUEdW5pdAkAAgECC01hdGNoIGVycm9yAQJiQQECYkIEAXoJAQJieQADCQABAgUBegIKQnl0ZVZlY3RvcgQCYkMFAXoJAAACCAUCYkIPY2FsbGVyUHVibGljS2V5BQJiQwMJAAECBQF6AgRVbml0CQAAAggFAmJCBmNhbGxlcgUEdGhpcwkAAgECC01hdGNoIGVycm9yAQJiRAECYkIDCQECYkEBBQJiQgYJAAIBAhFwZXJtaXNzaW9uIGRlbmllZA8CYkIBC2NvbnN0cnVjdG9yAQJiRQQCYkYJAQJiRAEFAmJCAwkAAAIFAmJGBQJiRgkAzAgCCQELU3RyaW5nRW50cnkCCQEBRgAFAmJFBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4CYkIBGWN1cnJlbnRSZXdhcmRSYXRlUkVBRE9OTFkBAmJlBAJiRwkBAmJkAQUCYmUEAmJpCQCRAwIFAmJHAAAEAmJuCQCRAwIFAmJHAAEEAmJvCQCRAwIFAmJHAAIEAmJICgACYmIJAPwHBAUCYVkCHWdldFZvdGluZ1Jlc3VsdFN0YWtlZFJFQURPTkxZCQDMCAIFAmJlBQNuaWwFA25pbAMJAAECBQJiYgIDSW50BQJiYgkAAgEJAKwCAgkAAwEFAmJiAhggY291bGRuJ3QgYmUgY2FzdCB0byBJbnQJAJQKAgUDbmlsCQC5CQIJAMwIAgIIJWQlZCVkJWQJAMwIAgkApAMBBQJiaQkAzAgCCQCkAwEFAmJuCQDMCAIJAKQDAQUCYm8JAMwIAgkApAMBBQJiSAUDbmlsBQFlAmJCAR1jdXJyZW50VXNlclJld2FyZFJhdGVSRUFET05MWQICYmUCYW8EAmJHCQECYmQBBQJiZQQCYmkJAJEDAgUCYkcAAAQCYm4JAJEDAgUCYkcAAQQCYm8JAJEDAgUCYkcAAgQCYkkJAQF2AgUCYU8JAQJhRwIFAmFvBQJiZQQCYkoJALUJAgkBAUQBCQD8BwQFAmFPAg9jbGFpbVd4UkVBRE9OTFkJAMwIAgUCYmUJAMwIAgUCYW8FA25pbAUDbmlsBQFlBAJiSwkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQC2CQEJAJEDAgUCYkoABQIcY291bGRuJ3QgcGFyc2UgbWluUmV3YXJkUGFydAQCYkwJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAtgkBCQCRAwIFAmJKAAYCHmNvdWxkbid0IHBhcnNlIGJvb3N0UmV3YXJkUGFydAQCYk0JAJEDAgUCYkoABwQCYk4DCQAAAgUCYkwAAAkAaAIAAQUBYgkAawMJAGQCBQJiSwUCYkwFAWIFAmJLCQCUCgIFA25pbAkAuQkCCQDMCAICDCVkJWQlZCVkJWQlcwkAzAgCCQCkAwEFAmJpCQDMCAIJAKQDAQUCYm4JAMwIAgkApAMBBQJibwkAzAgCCQCkAwEFAmJJCQDMCAIJAKQDAQUCYk4JAMwIAgUCYk0FA25pbAUBZQJiQgEdY2FsY0Jvb3N0QnVsa0ludGVybmFsUkVBRE9OTFkHAmJPAmJQAmJRAmJSAmJTAmJUAmJVAwkAAAIFAmJPCQCQAwEFAmJQCQCUCgIFA25pbAUCYlUEAmJWCQCRAwIFAmJQBQJiTwQCYlcJAJEDAgUCYlEFAmJPBAJiWAkAkQMCBQJiUgUCYk8EAmJZCQCRAwIFAmJTBQJiTwQCYloKAAJiYgkA/AcEBQR0aGlzAhFjYWxjQm9vc3RSRUFET05MWQkAzAgCBQJiVgkAzAgCBQJiVwkAzAgCBQJiWAkAzAgCBQJiWQkAzAgCBQJiVAUDbmlsBQNuaWwDCQABAgUCYmICBlN0cmluZwUCYmIJAAIBCQCsAgIJAAMBBQJiYgIbIGNvdWxkbid0IGJlIGNhc3QgdG8gU3RyaW5nBAJjYQkAzQgCBQJiVQUCYloEAmNiCgACYmIJAPwHBAUEdGhpcwIdY2FsY0Jvb3N0QnVsa0ludGVybmFsUkVBRE9OTFkJAMwIAgkAZAIFAmJPAAEJAMwIAgUCYlAJAMwIAgUCYlEJAMwIAgUCYlIJAMwIAgUCYlMJAMwIAgUCYlQJAMwIAgUCY2EFA25pbAUDbmlsAwkAAQIFAmJiAglMaXN0W0FueV0FAmJiCQACAQkArAICCQADAQUCYmICHiBjb3VsZG4ndCBiZSBjYXN0IHRvIExpc3RbQW55XQMJAAACBQJjYgUCY2IJAJQKAgUDbmlsBQJjYgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJiQgEVY2FsY0Jvb3N0QnVsa1JFQURPTkxZBQJiVgJiVwJiWAJiWQJiVAQCY2EJAPwHBAUEdGhpcwIdY2FsY0Jvb3N0QnVsa0ludGVybmFsUkVBRE9OTFkJAMwIAgAACQDMCAIFAmJWCQDMCAIFAmJXCQDMCAIFAmJYCQDMCAIFAmJZCQDMCAIFAmJUCQDMCAIFA25pbAUDbmlsBQNuaWwJAJQKAgUDbmlsBQJjYQJiQgERY2FsY0Jvb3N0UkVBRE9OTFkFAmJWAmJXAmJYAmJZAmJUBAJjYwoAAmJiCQD8BwQFAmFXAhVnZXRCb29zdENvZWZmUkVBRE9OTFkFA25pbAUDbmlsAwkAAQIFAmJiAgNJbnQFAmJiCQACAQkArAICCQADAQUCYmICGCBjb3VsZG4ndCBiZSBjYXN0IHRvIEludAQCY2QFAmFYBAJjZQIFZW1wdHkEAmNmCQENcGFyc2VJbnRWYWx1ZQEJAJEDAgkAtQkCCQEBdAIFAmFZCQECYWkABQFlAAQEAmFJAwkAAAIFAmJZAgAFAmNlBQJiWQQCYUgDCQAAAgUCYlQCAAUCY2UFAmJUBAJjZwkBC3ZhbHVlT3JFbHNlAgkAnQgCBQJhWQkBAmFuAQUCYlQFAmNlBAJjaAkBC3ZhbHVlT3JFbHNlAgkAmggCBQJhWQkBAmFyAQUCY2cAAAQCY2kJAQt2YWx1ZU9yRWxzZQIJAJoIAgUCYVkJAQJhdAEFAmNnBQZoZWlnaHQEAmJyCQELdmFsdWVPckVsc2UCCQCaCAIFAmFZCQECYXUBBQJjZwAABAJjagkAZAIFAmNpBQJicgQCY2sJAJYDAQkAzAgCCQBlAgUCY2oFBmhlaWdodAkAzAgCAAAFA25pbAQCY2wJAGQCBQJjaAUCYlYEAmNtCQCXAwEJAMwIAgkAZAIFAmNrBQJiVwkAzAgCBQJjZgUDbmlsBAJjbgkBAUIBCQCRAwIJAQF4AQkA/AcEBQJhWQITZ3d4VXNlckluZm9SRUFET05MWQkAzAgCBQJhSAUDbmlsBQNuaWwAAAQCY28JAJEDAgkBAmJwAwUCY2wFAmNtBQJjZgAABAJjcAoAAmJiCQD8BwQFAmFZAhlnZXRUb3RhbENhY2hlZEd3eFJFQURPTkxZBQNuaWwFA25pbAMJAAECBQJiYgIDSW50BQJiYgkAAgEJAKwCAgkAAwEFAmJiAhggY291bGRuJ3QgYmUgY2FzdCB0byBJbnQEAmNxAOgHBAJjcgkAaAIJAQF3AgUCYVcJAQJhUAAFAmNxBAJjcwkBAmFHAgUCYUgFAmFJBAJjdAkBAmFKAQUCYUkEAmN1CQECYU4CBQJhTwUCY3MEAmN2CQECYU4CBQJhTwUCY3QEAmJoAwkBAiE9AgUCYUkFAmNlBAJiZgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCdCAIFAmFVCQEBUAEFAmFJCQCsAgICFXVuc3VwcG9ydGVkIGxwIGFzc2V0IAUCYUkJARFAZXh0ck5hdGl2ZSgxMDUwKQIFAmFVCQEBVAEFAmJmAAAEAmN3CQBrAwUCY3IFAmJoCQBoAgUBZgUCY2MEAmN4AwkBAiE9AgUCY3YAAAkAawMFAmN3BQFiBQJjdgAABAJjeQkAawMFAmN4BQJjdQUBYgQCY3oJAGgCBQJjdwkAZQIFAmNjAAEEAmNBCQBrAwUCY24FAmN6BQJjcAQCY0IJAJcDAQkAzAgCBQJjQQkAzAgCCQBoAgUCY3kJAGUCBQJjYwABBQNuaWwEAmNDAwkAAAIFAmN5AAAJAGgCAAEFAWIJAGsDCQBkAgUCY0IFAmN5BQFiBQJjeQkAlAoCBQNuaWwJALkJAgkAzAgCAgYlZCVkJXMJAMwIAgkApAMBBQJjbwkAzAgCCQCkAwEFAmNDCQDMCAICAWQFA25pbAUBZQJiQgEXd3hFbWlzc2lvblN0YXRzUkVBRE9OTFkABAJjRAkApAMBBQFiBAJjRQIBMQQCYmkJAQF3AgUCYVcJAQJhUAAEAmNGCQEBdwIFAmFXCQECYVIABAJjRwMJAGYCBQJjRgUGaGVpZ2h0AAAJAGUCBQZoZWlnaHQFAmNGBAJjSAkAaAIAoAsA7QIEAmNJCQBoAgDAiOxfBQFiBAJjSgMJAGYCBQJjRwUCY0gFAmNJCQBrAwUCY0kFAmNHBQJjSAQCY0sJAGQCCQBoAgUCYmkFAmNHBQJjSgQCY0wJAQF2AgUCYVkJAQJhagAEAmNNCQEBdgIFAmFZCQECYWsABAJjTgkBAXYCBQJhWQkBAmFsAAkAlAoCBQNuaWwJALkJAgkAzAgCAgglZCVkJWQlZAkAzAgCCQCkAwEFAmNLCQDMCAIJAKQDAQUCY0wJAMwIAgkApAMBBQJjTQkAzAgCCQCkAwEFAmNOBQNuaWwFAWUCYkIBEXBvb2xTdGF0c1JFQURPTkxZAQJjTwQCYmEJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAQF0AgUCYVUJAQFTAQUCY08EAmNQCgACYmIJAPwHBAUCYVUCFWdldFBvb2xTdGF0dXNSRUFET05MWQkAzAgCCQClCAEFAmJhBQNuaWwFA25pbAMJAAECBQJiYgIDSW50BQJiYgkAAgEJAKwCAgkAAwEFAmJiAhggY291bGRuJ3QgYmUgY2FzdCB0byBJbnQEAmNRAhQlZCVkJWQlZCVkJWQlZCVkJWQlcwMJAAACBQJjUAAECQCUCgIFA25pbAkAuQkCCQDMCAIFAmNRCQDMCAIJAKQDAQAACQDMCAIJAKQDAQAACQDMCAIJAKQDAQAACQDMCAIJAKQDAQAACQDMCAIJAKQDAQAACQDMCAIJAKQDAQAACQDMCAIJAKQDAQAACQDMCAIJAKQDAQAACQDMCAIJAKQDAQAACQDMCAIJAKUDAQcFA25pbAUBZQQCY1IJAQF4AQkA/AcEBQJiYQIcZ2V0UG9vbENvbmZpZ1dyYXBwZXJSRUFET05MWQUDbmlsBQNuaWwEAmJlCQDZBAEJAQFEAQkAkQMCBQJjUgUBagQCY1MJAQFEAQkAkQMCBQJjUgUBawQCY1QJAQFEAQkAkQMCBQJjUgUBbAQCY1UJAQFEAQkAkQMCBQJjUgUBbwQCY1YJAQFEAQkAkQMCBQJjUgUBcAQCY1cJAQ1wYXJzZUludFZhbHVlAQkBAUQBCQCRAwIFAmNSBQFtBAJjWAkBDXBhcnNlSW50VmFsdWUBCQEBRAEJAJEDAgUCY1IFAW4EAmNZCAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEFAmJlCQCsAgIJAKwCAgIGQXNzZXQgCQDYBAEFAmJlAg4gZG9lc24ndCBleGlzdAhxdWFudGl0eQQCY1oJAQFCAQkA/AcEBQJiYQIcZ2V0QWNjQmFsYW5jZVdyYXBwZXJSRUFET05MWQkAzAgCBQJjUwUDbmlsBQNuaWwEAmRhCQEBQgEJAPwHBAUCYmECHGdldEFjY0JhbGFuY2VXcmFwcGVyUkVBRE9OTFkJAMwIAgUCY1QFA25pbAUDbmlsBAJkYgMJAAACBQJjWQAACQDMCAIJAKYDAQUBZwkAzAgCCQCmAwEFAWcJAMwIAgkApgMBBQFnBQNuaWwJAQF4AQkA/AcEBQJiYQIZY2FsY1ByaWNlc1dyYXBwZXJSRUFET05MWQkAzAgCBQJjWgkAzAgCBQJkYQkAzAgCBQJjWQUDbmlsBQNuaWwEAmRjAAAEAmRkCQEBQgEJAPwHBAUCYmECFmZyb21YMThXcmFwcGVyUkVBRE9OTFkJAMwIAgkAkQMCBQJkYgABCQDMCAIFAWIFA25pbAUDbmlsBAJkZQkBAUIBCQD8BwQFAmJhAhZmcm9tWDE4V3JhcHBlclJFQURPTkxZCQDMCAIJAJEDAgUCZGIAAgkAzAgCBQFiBQNuaWwFA25pbAQCYmgJARFAZXh0ck5hdGl2ZSgxMDUwKQIFAmFVCQEBVAEJAKUIAQUCYmEEAmRmCQECYVoBBQJiYQQCZGcJAQJiYwEFAmJhBAJkaAoAAmJiCQD8BwQFAmFVAihpc1Bvb2xPbmVUb2tlbk9wZXJhdGlvbnNEaXNhYmxlZFJFQURPTkxZCQDMCAIJAKUIAQUCYmEFA25pbAUDbmlsAwkAAQIFAmJiAgdCb29sZWFuBQJiYgkAAgEJAKwCAgkAAwEFAmJiAhwgY291bGRuJ3QgYmUgY2FzdCB0byBCb29sZWFuBAJkaQkBASEBBQJkaAkAlAoCBQNuaWwJALkJAgkAzAgCBQJjUQkAzAgCCQCkAwEFAmNaCQDMCAIJAKQDAQUCZGEJAMwIAgkApAMBBQJjWQkAzAgCCQCkAwEFAmRjCQDMCAIJAKQDAQUCZGQJAMwIAgkApAMBBQJkZQkAzAgCCQCkAwEFAmJoCQDMCAIJAKQDAQUCZGYJAMwIAgkApAMBBQJkZwkAzAgCCQClAwEFAmRpBQNuaWwFAWUCYkIBJHBvb2xFdmFsdWF0ZVB1dEJ5QW1vdW50QXNzZXRSRUFET05MWQICY08CZGoEAmJhCQERQGV4dHJOYXRpdmUoMTA2MikBCQEBdAIFAmFVCQEBUwEFAmNPBAJjUgkBAXgBCQD8BwQFAmJhAhxnZXRQb29sQ29uZmlnV3JhcHBlclJFQURPTkxZBQNuaWwFA25pbAQCYmUJANkEAQkBAUQBCQCRAwIFAmNSBQFqBAJkawkBAUQBCQCRAwIFAmNSBQFrBAJkbAkA2QQBBQJkawQCZG0JAQFEAQkAkQMCBQJjUgUBbAQCZG4JANkEAQUCZG0EAmNXCQENcGFyc2VJbnRWYWx1ZQEJAQFEAQkAkQMCBQJjUgUBbQQCY1gJAQ1wYXJzZUludFZhbHVlAQkBAUQBCQCRAwIFAmNSBQFuBAJkbwkBAUQBCQCRAwIFAmNSBQFpBAJjWQgJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkA7AcBBQJiZQkArAICCQCsAgICBkFzc2V0IAkA2AQBBQJiZQIOIGRvZXNuJ3QgZXhpc3QIcXVhbnRpdHkEAmNaCQEBQgEJAPwHBAUCYmECHGdldEFjY0JhbGFuY2VXcmFwcGVyUkVBRE9OTFkJAMwIAgUCZGsFA25pbAUDbmlsBAJkYQkBAUIBCQD8BwQFAmJhAhxnZXRBY2NCYWxhbmNlV3JhcHBlclJFQURPTkxZCQDMCAIFAmRtBQNuaWwFA25pbAQCZHAJAKcDAQkBAUQBCQD8BwQFAmJhAhR0b1gxOFdyYXBwZXJSRUFET05MWQkAzAgCBQJjWgkAzAgCBQJjVwUDbmlsBQNuaWwEAmRxCQCnAwEJAQFEAQkA/AcEBQJiYQIUdG9YMThXcmFwcGVyUkVBRE9OTFkJAMwIAgUCZGEJAMwIAgUCY1gFA25pbAUDbmlsBAJkcgMJAAACBQJjWQAABQFnCQCnAwEJAQFEAQkA/AcEBQJiYQIeY2FsY1ByaWNlQmlnSW50V3JhcHBlclJFQURPTkxZCQDMCAIJAKYDAQUCZHEJAMwIAgkApgMBBQJkcAUDbmlsBQNuaWwEAmRjCQEBQgEJAPwHBAUCYmECFmZyb21YMThXcmFwcGVyUkVBRE9OTFkJAMwIAgkApgMBBQJkcgkAzAgCBQFiBQNuaWwFA25pbAQCZHMJAKcDAQkBAUQBCQD8BwQFAmJhAhR0b1gxOFdyYXBwZXJSRUFET05MWQkAzAgCBQJkagkAzAgCBQJjVwUDbmlsBQNuaWwEAmR0CQC8AgMFAmRzBQJkcgUBZAQCZHUJAQFCAQkA/AcEBQJiYQIWZnJvbVgxOFdyYXBwZXJSRUFET05MWQkAzAgCCQCmAwEFAmR0CQDMCAIFAmNYBQNuaWwFA25pbAQCY2EJAPwHBAUCYmECI2VzdGltYXRlUHV0T3BlcmF0aW9uV3JhcHBlclJFQURPTkxZCQDMCAICAAkAzAgCAKDCHgkAzAgCBQJkagkAzAgCBQJkbAkAzAgCBQJkdQkAzAgCBQJkbgkAzAgCAgAJAMwIAgYJAMwIAgcFA25pbAUDbmlsBAJkdgQBegUCY2EDAwMJAAECCAUBegJfMQIDSW50AwkAAQIIBQF6Al8zAgNJbnQDCQABAggFAXoCXzQCA0ludAMJAAECCAUBegJfNQIDSW50CQABAggFAXoCXzYCA0ludAcHBwcJAAACCQDGCgEFAXoADQcEAmR3CAUBegJfMQQCZHgIBQF6Al8zBAJkeQgFAXoCXzQEAmR6CAUBegJfNQQCZEEIBQF6Al82CQCXCgUFAmR3BQJkeAUCZHkFAmR6BQJkQQkAAgECE0NvdWxkbid0IGNhc3QgdHlwZXMEAmR3CAUCZHYCXzEEAmR4CAUCZHYCXzIEAmR5CAUCZHYCXzMEAmR6CAUCZHYCXzQEAmRBCAUCZHYCXzUJAJQKAgUDbmlsCQC5CQIJAMwIAgIQJWQlZCVkJWQlZCVkJWQlZAkAzAgCCQCkAwEFAmR3CQDMCAIJAKQDAQUCZGMJAMwIAgkApAMBBQJkeQkAzAgCCQCkAwEFAmR6CQDMCAIJAKQDAQUCZEEJAMwIAgUCZG8JAMwIAgkApAMBBQJkagkAzAgCCQCkAwEFAmR1BQNuaWwFAWUCYkIBI3Bvb2xFdmFsdWF0ZVB1dEJ5UHJpY2VBc3NldFJFQURPTkxZAgJjTwJkdQQCYmEJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAQF0AgUCYVUJAQFTAQUCY08EAmNSCQEBeAEJAPwHBAUCYmECHGdldFBvb2xDb25maWdXcmFwcGVyUkVBRE9OTFkFA25pbAUDbmlsBAJiZQkA2QQBCQEBRAEJAJEDAgUCY1IFAWoEAmRrCQEBRAEJAJEDAgUCY1IFAWsEAmRsCQDZBAEFAmRrBAJkbQkBAUQBCQCRAwIFAmNSBQFsBAJkbgkA2QQBBQJkbQQCY1cJAQ1wYXJzZUludFZhbHVlAQkBAUQBCQCRAwIFAmNSBQFtBAJjWAkBDXBhcnNlSW50VmFsdWUBCQEBRAEJAJEDAgUCY1IFAW4EAmRvCQEBRAEJAJEDAgUCY1IFAWkEAmNZCAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEFAmJlCQCsAgIJAKwCAgIGQXNzZXQgCQDYBAEFAmJlAg4gZG9lc24ndCBleGlzdAhxdWFudGl0eQQCZEIJAQFCAQkA/AcEBQJiYQIcZ2V0QWNjQmFsYW5jZVdyYXBwZXJSRUFET05MWQkAzAgCBQJkawUDbmlsBQNuaWwEAmRDCQEBQgEJAPwHBAUCYmECHGdldEFjY0JhbGFuY2VXcmFwcGVyUkVBRE9OTFkJAMwIAgUCZG0FA25pbAUDbmlsBAJkRAkApwMBCQEBRAEJAPwHBAUCYmECFHRvWDE4V3JhcHBlclJFQURPTkxZCQDMCAIFAmRCCQDMCAIFAmNXBQNuaWwFA25pbAQCZEUJAKcDAQkBAUQBCQD8BwQFAmJhAhR0b1gxOFdyYXBwZXJSRUFET05MWQkAzAgCBQJkQwkAzAgCBQJjWAUDbmlsBQNuaWwEAmRyAwkAAAIFAmNZAAAFAWcJAKcDAQkBAUQBCQD8BwQFAmJhAh5jYWxjUHJpY2VCaWdJbnRXcmFwcGVyUkVBRE9OTFkJAMwIAgkApgMBBQJkRQkAzAgCCQCmAwEFAmREBQNuaWwFA25pbAQCZGMJAQFCAQkA/AcEBQJiYQIWZnJvbVgxOFdyYXBwZXJSRUFET05MWQkAzAgCCQCmAwEFAmRyCQDMCAIFAWIFA25pbAUDbmlsBAJkdAkApwMBCQEBRAEJAPwHBAUCYmECFHRvWDE4V3JhcHBlclJFQURPTkxZCQDMCAIFAmR1CQDMCAIFAmNYBQNuaWwFA25pbAQCZHMJALwCAwUCZHQFAWQFAmRyBAJkagkBAUIBCQD8BwQFAmJhAhZmcm9tWDE4V3JhcHBlclJFQURPTkxZCQDMCAIJAKYDAQUCZHMJAMwIAgUCY1cFA25pbAUDbmlsBAJjYQkA/AcEBQJiYQIjZXN0aW1hdGVQdXRPcGVyYXRpb25XcmFwcGVyUkVBRE9OTFkJAMwIAgIACQDMCAIAoMIeCQDMCAIFAmRqCQDMCAIFAmRsCQDMCAIFAmR1CQDMCAIFAmRuCQDMCAICAAkAzAgCBgkAzAgCBwUDbmlsBQNuaWwEAmRGBAF6BQJjYQMDAwkAAQIIBQF6Al8xAgNJbnQDCQABAggFAXoCXzMCA0ludAMJAAECCAUBegJfNAIDSW50AwkAAQIIBQF6Al81AgNJbnQJAAECCAUBegJfNgIDSW50BwcHBwkAAAIJAMYKAQUBegANBwQCZHcIBQF6Al8xBAJkeAgFAXoCXzMEAmR5CAUBegJfNAQCZHoIBQF6Al81BAJkQQgFAXoCXzYJAJcKBQUCZHcFAmR4BQJkeQUCZHoFAmRBCQACAQITQ291bGRuJ3QgY2FzdCB0eXBlcwQCZHcIBQJkRgJfMQQCZHgIBQJkRgJfMgQCZHkIBQJkRgJfMwQCZHoIBQJkRgJfNAQCZEEIBQJkRgJfNQkAlAoCBQNuaWwJALkJAgkAzAgCAhAlZCVkJWQlZCVkJWQlZCVkCQDMCAIJAKQDAQUCZHcJAMwIAgkApAMBBQJkYwkAzAgCCQCkAwEFAmR5CQDMCAIJAKQDAQUCZHoJAMwIAgkApAMBBQJkQQkAzAgCBQJkbwkAzAgCCQCkAwEFAmRqCQDMCAIJAKQDAQUCZHUFA25pbAUBZQJiQgEXcG9vbEV2YWx1YXRlR2V0UkVBRE9OTFkCAmRHAmRIBAJiYQkBEUBleHRyTmF0aXZlKDEwNjIpAQkBAXQCBQJhVQkBAVMBBQJkRwQCY2EJAPwHBAUCYmECI2VzdGltYXRlR2V0T3BlcmF0aW9uV3JhcHBlclJFQURPTkxZCQDMCAICAAkAzAgCBQJkRwkAzAgCBQJkSAkAzAgCCQClCAEFAmJhBQNuaWwFA25pbAQCZEkEAXoFAmNhAwMDCQABAggFAXoCXzECA0ludAMJAAECCAUBegJfMgIDSW50AwkAAQIIBQF6Al81AgNJbnQDCQABAggFAXoCXzYCA0ludAMJAAECCAUBegJfNwIDSW50AwkAAQIIBQF6Al84AgZTdHJpbmcJAAECCAUBegJfOQIGU3RyaW5nBwcHBwcHCQAAAgkAxgoBBQF6AAoHBAJkSggFAXoCXzEEAmRLCAUBegJfMgQCZHkIBQF6Al81BAJkeggFAXoCXzYEAmRBCAUBegJfNwQCZGMIBQF6Al84BAJkbwgFAXoCXzkJAJkKBwUCZEoFAmRLBQJkeQUCZHoFAmRBBQJkYwUCZG8JAAIBAhNDb3VsZG4ndCBjYXN0IHR5cGVzBAJkSggFAmRJAl8xBAJkSwgFAmRJAl8yBAJkeQgFAmRJAl8zBAJkeggFAmRJAl80BAJkQQgFAmRJAl81BAJkYwgFAmRJAl82BAJkbwgFAmRJAl83CQCUCgIFA25pbAkAuQkCCQDMCAICDiVkJWQlZCVkJWQlZCVkCQDMCAIJAKQDAQUCZEoJAMwIAgkApAMBBQJkSwkAzAgCCQCkAwEFAmR5CQDMCAIJAKQDAQUCZHoJAMwIAgkApAMBBQJkQQkAzAgCBQJkYwkAzAgCBQJkbwUDbmlsBQFlAmJCARNnd3hVc2VySW5mb1JFQURPTkxZAQJhbwQCZEwJAQF4AQkA/AcEBQJhWQITZ3d4VXNlckluZm9SRUFET05MWQkAzAgCBQJhbwUDbmlsBQNuaWwEAmRNCQEBQgEJAJEDAgUCZEwAAAkAlAoCBQNuaWwJALkJAgkAzAgCAgIlZAkAzAgCCQCkAwEFAmRNBQNuaWwFAWUCYkIBFXVuc3Rha2VBbmRHZXRPbmVUa25WMgQCYmECZE4CZE8CZFAEAmNiCQD8BwQJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAmJhAhV1bnN0YWtlQW5kR2V0T25lVGtuVjIJAMwIAgUCZE4JAMwIAgUCZE8JAMwIAgUCZFAFA25pbAUDbmlsAwkAAAIFAmNiBQJjYgkAlAoCBQNuaWwFBHVuaXQJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4CYkIBE2dldEtleXNCdWxrSW50ZXJuYWwDAmJPAmRRAmJVAwkAAAIFAmJPCQCQAwEFAmRRCQCUCgIFA25pbAUCYlUEAmRSCQC1CQIJAJEDAgUCZFEFAmJPAgIrKwQCYncJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAJEDAgUCZFIAAAQBcwkAkQMCBQJkUgABBAJieAkAkQMCBQJkUgACBAF5CQECYnYDBQJidwUBcwUCYngEAmNhCQDNCAIFAmJVBQF5BAJjYgkA/AcEBQR0aGlzAhNnZXRLZXlzQnVsa0ludGVybmFsCQDMCAIJAGQCBQJiTwABCQDMCAIFAmRRCQDMCAIFAmNhBQNuaWwFA25pbAMJAAACBQJjYgUCY2IJAJQKAgUDbmlsBQJjYgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJiQgELZ2V0S2V5c0J1bGsBAmRRBAJjYQkA/AcEBQR0aGlzAhNnZXRLZXlzQnVsa0ludGVybmFsCQDMCAIAAAkAzAgCBQJkUQkAzAgCBQNuaWwFA25pbAUDbmlsCQCUCgIFA25pbAUCY2EBAmRTAQJkVAAEAmRVBAF6CQECYnkAAwkAAQIFAXoCCkJ5dGVWZWN0b3IEAmJDBQF6BQJiQwMJAAECBQF6AgRVbml0CAUCZFMPc2VuZGVyUHVibGljS2V5CQACAQILTWF0Y2ggZXJyb3IJAPQDAwgFAmRTCWJvZHlCeXRlcwkAkQMCCAUCZFMGcHJvb2ZzAAAFAmRVKlLymg==",
    "height": 2714660,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 42L6Tm7NcZbaCt25UUHwfcTAmvW37Ms7U5GhsX5KJPLY
Next: 9Y4qWsaqmDnRcXxdJeSz8TRMwAcVs45ZfvDm2Rh7RwdT

Diff: 
Old
New
Differences
531
531
 
                    else throw(($getType(@) + " couldn't be cast to Boolean"))
532
532
 
                }
533
533
 
            let poolOneTokenOperationsEnabled = !(poolOneTokenOperationsDisabled)
534
-
            let poolSwapEnabled = !({
535
-
                let @ = invoke(factoryDapp, "isPoolSwapDisabledREADONLY", [toString(poolAddress)], nil)
536
-
                if ($isInstanceOf(@, "Boolean"))
537
-
                    then @
538
-
                    else throw(($getType(@) + " couldn't be cast to Boolean"))
539
-
                })
540
-
            $Tuple2(nil, makeString([tpl, toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight), toString(inFee), toString(outFee), toString(poolOneTokenOperationsEnabled), toString(poolSwapEnabled)], SEP))
534
+
            $Tuple2(nil, makeString([tpl, toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight), toString(inFee), toString(outFee), toString(poolOneTokenOperationsEnabled)], SEP))
541
535
 
            }
542
536
 
    }
543
537
 
568
562
 
    let inPrAssetAmtX18 = fraction(inAmAssetAmtX18, curPriceX18, MULT18)
569
563
 
    let inPrAssetAmt = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(inPrAssetAmtX18), priceAssetDcm], nil))
570
564
 
    let res = invoke(poolAddress, "estimatePutOperationWrapperREADONLY", ["", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false], nil)
571
-
    let $t02285123204 =     match res {
565
+
    let $t02269123044 =     match res {
572
566
 
        case _ => 
573
567
 
            if (if (if ($isInstanceOf($match0._1, "Int"))
574
568
 
                then if ($isInstanceOf($match0._3, "Int"))
591
585
 
                    }
592
586
 
                else throw("Couldn't cast types")
593
587
 
    }
594
-
    let calcLpAmt = $t02285123204._1
595
-
    let curPriceCalc = $t02285123204._2
596
-
    let amBalance = $t02285123204._3
597
-
    let prBalance = $t02285123204._4
598
-
    let lpEmission = $t02285123204._5
588
+
    let calcLpAmt = $t02269123044._1
589
+
    let curPriceCalc = $t02269123044._2
590
+
    let amBalance = $t02269123044._3
591
+
    let prBalance = $t02269123044._4
592
+
    let lpEmission = $t02269123044._5
599
593
 
    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(curPrice), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
600
594
 
    }
601
595
 
626
620
 
    let inAmAssetAmtX18 = fraction(inPrAssetAmtX18, MULT18, curPriceX18)
627
621
 
    let inAmAssetAmt = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(inAmAssetAmtX18), amtAssetDcm], nil))
628
622
 
    let res = invoke(poolAddress, "estimatePutOperationWrapperREADONLY", ["", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false], nil)
629
-
    let $t02577726130 =     match res {
623
+
    let $t02561725970 =     match res {
630
624
 
        case _ => 
631
625
 
            if (if (if ($isInstanceOf($match0._1, "Int"))
632
626
 
                then if ($isInstanceOf($match0._3, "Int"))
649
643
 
                    }
650
644
 
                else throw("Couldn't cast types")
651
645
 
    }
652
-
    let calcLpAmt = $t02577726130._1
653
-
    let curPriceCalc = $t02577726130._2
654
-
    let amBalance = $t02577726130._3
655
-
    let prBalance = $t02577726130._4
656
-
    let lpEmission = $t02577726130._5
646
+
    let calcLpAmt = $t02561725970._1
647
+
    let curPriceCalc = $t02561725970._2
648
+
    let amBalance = $t02561725970._3
649
+
    let prBalance = $t02561725970._4
650
+
    let lpEmission = $t02561725970._5
657
651
 
    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(curPrice), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
658
652
 
    }
659
653
 
663
657
 
func poolEvaluateGetREADONLY (paymentLpAssetId,paymentLpAmt) = {
664
658
 
    let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(paymentLpAssetId)))
665
659
 
    let res = invoke(poolAddress, "estimateGetOperationWrapperREADONLY", ["", paymentLpAssetId, paymentLpAmt, toString(poolAddress)], nil)
666
-
    let $t02682527242 =     match res {
660
+
    let $t02666527082 =     match res {
667
661
 
        case _ => 
668
662
 
            if (if (if ($isInstanceOf($match0._1, "Int"))
669
663
 
                then if ($isInstanceOf($match0._2, "Int"))
692
686
 
                    }
693
687
 
                else throw("Couldn't cast types")
694
688
 
    }
695
-
    let outAmAmt = $t02682527242._1
696
-
    let outPrAmt = $t02682527242._2
697
-
    let amBalance = $t02682527242._3
698
-
    let prBalance = $t02682527242._4
699
-
    let lpEmission = $t02682527242._5
700
-
    let curPrice = $t02682527242._6
701
-
    let poolStatus = $t02682527242._7
689
+
    let outAmAmt = $t02666527082._1
690
+
    let outPrAmt = $t02666527082._2
691
+
    let amBalance = $t02666527082._3
692
+
    let prBalance = $t02666527082._4
693
+
    let lpEmission = $t02666527082._5
694
+
    let curPrice = $t02666527082._6
695
+
    let poolStatus = $t02666527082._7
702
696
 
    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmAmt), toString(outPrAmt), toString(amBalance), toString(prBalance), toString(lpEmission), curPrice, poolStatus], SEP))
703
697
 
    }
704
698
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SCALE8 = 8
5
5
 
6
6
 
let MULT8 = 100000000
7
7
 
8
8
 
let SCALE18 = 18
9
9
 
10
10
 
let MULT18 = toBigInt(1000000000000000000)
11
11
 
12
12
 
let SEP = "__"
13
13
 
14
14
 
let POOLWEIGHTMULT = MULT8
15
15
 
16
16
 
let zeroBigInt = toBigInt(0)
17
17
 
18
18
 
let idxPoolAddress = 1
19
19
 
20
20
 
let idxPoolStatus = 2
21
21
 
22
22
 
let idxPoolLPAssetId = 3
23
23
 
24
24
 
let idxAmtAssetId = 4
25
25
 
26
26
 
let idxPriceAssetId = 5
27
27
 
28
28
 
let idxAmtAssetDcm = 6
29
29
 
30
30
 
let idxPriceAssetDcm = 7
31
31
 
32
32
 
let idxIAmtAssetId = 8
33
33
 
34
34
 
let idxIPriceAssetId = 9
35
35
 
36
36
 
let idxLPAssetDcm = 10
37
37
 
38
38
 
func getStringOrFail (key) = valueOrErrorMessage(getString(key), (("mandatory this." + key) + " is not defined"))
39
39
 
40
40
 
41
41
 
func getStringByAddressOrFail (address,key) = valueOrErrorMessage(getString(address, key), (((("mandatory " + toString(address)) + ".") + key) + " is not defined"))
42
42
 
43
43
 
44
44
 
func getIntOrZero (address,key) = valueOrElse(getInteger(address, key), 0)
45
45
 
46
46
 
47
47
 
func getIntOrFail (address,key) = valueOrErrorMessage(getInteger(address, key), (("mandatory this." + key) + " is not defined"))
48
48
 
49
49
 
50
50
 
func asAnyList (val) = match val {
51
51
 
    case valAnyLyst: List[Any] => 
52
52
 
        valAnyLyst
53
53
 
    case _ => 
54
54
 
        throw("fail to cast into List[Any]")
55
55
 
}
56
56
 
57
57
 
58
58
 
func asInt (val) = match val {
59
59
 
    case valInt: Int => 
60
60
 
        valInt
61
61
 
    case _ => 
62
62
 
        throw("fail to cast into Int")
63
63
 
}
64
64
 
65
65
 
66
66
 
func asString (val) = match val {
67
67
 
    case valStr: String => 
68
68
 
        valStr
69
69
 
    case _ => 
70
70
 
        throw("fail to cast into String")
71
71
 
}
72
72
 
73
73
 
74
74
 
func keyFactoryAddress () = "%s%s__config__factoryAddress"
75
75
 
76
76
 
77
77
 
let IdxFactoryCfgStakingDapp = 1
78
78
 
79
79
 
let IdxFactoryCfgBoostingDapp = 2
80
80
 
81
81
 
let IdxFactoryCfgIdoDapp = 3
82
82
 
83
83
 
let IdxFactoryCfgTeamDapp = 4
84
84
 
85
85
 
let IdxFactoryCfgEmissionDapp = 5
86
86
 
87
87
 
let IdxFactoryCfgRestDapp = 6
88
88
 
89
89
 
let IdxFactoryCfgSlippageDapp = 7
90
90
 
91
91
 
let IdxFactoryCfgGwxRewardDapp = 8
92
92
 
93
93
 
func keyFactoryCfg () = "%s__factoryConfig"
94
94
 
95
95
 
96
96
 
func keyFactoryLp2AssetsMapping (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
97
97
 
98
98
 
99
99
 
func keyFactoryLpList () = "%s__lpTokensList"
100
100
 
101
101
 
102
102
 
func keyFactoryLpAssetToPoolContractAddress (lpAssetStr) = makeString(["%s%s%s", lpAssetStr, "mappings__lpAsset2PoolContract"], SEP)
103
103
 
104
104
 
105
105
 
func keyFactoryPoolWeight (contractAddress) = makeString(["%s%s", "poolWeight", contractAddress], SEP)
106
106
 
107
107
 
108
108
 
func keyManagerVaultAddress () = "%s__managerVaultAddress"
109
109
 
110
110
 
111
111
 
func keyManagerPublicKey () = "%s__managerPublicKey"
112
112
 
113
113
 
114
114
 
func readFactoryAddressOrFail () = addressFromStringValue(getStringOrFail(keyFactoryAddress()))
115
115
 
116
116
 
117
117
 
func readLpList () = split(valueOrElse(getString(readFactoryAddressOrFail(), keyFactoryLpList()), ""), SEP)
118
118
 
119
119
 
120
120
 
func readFactoryCfgOrFail (factory) = split(getStringByAddressOrFail(factory, keyFactoryCfg()), SEP)
121
121
 
122
122
 
123
123
 
func getBoostingAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgBoostingDapp])
124
124
 
125
125
 
126
126
 
func getEmissionAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgEmissionDapp])
127
127
 
128
128
 
129
129
 
func getStakingAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgStakingDapp])
130
130
 
131
131
 
132
132
 
func getGwxRewardAddressOrFail (fCfg) = addressFromStringValue(fCfg[IdxFactoryCfgGwxRewardDapp])
133
133
 
134
134
 
135
135
 
func getManagerVaultAddressOrThis () = match getString(keyManagerVaultAddress()) {
136
136
 
    case s: String => 
137
137
 
        addressFromStringValue(s)
138
138
 
    case _ => 
139
139
 
        this
140
140
 
}
141
141
 
142
142
 
143
143
 
func keyBoostCfg () = "%s__config"
144
144
 
145
145
 
146
146
 
func keyBoostingLockParamTotalAmount () = "%s%s__stats__activeTotalLocked"
147
147
 
148
148
 
149
149
 
func keyBoostingStatsLocksDurationSumInBlocks () = "%s%s__stats__locksDurationSumInBlocks"
150
150
 
151
151
 
152
152
 
func keyBoostingStatsLocksCount () = "%s%s__stats__locksCount"
153
153
 
154
154
 
155
155
 
func keyBoostingStatsUsersCount () = "%s%s__stats__activeUsersCount"
156
156
 
157
157
 
158
158
 
func keyUser2NumMapping (userAddress) = makeString(["%s%s%s__mapping__user2num", userAddress], SEP)
159
159
 
160
160
 
161
161
 
func keyNum2UserMapping (num) = makeString(["%s%s%s__mapping__num2user", num], SEP)
162
162
 
163
163
 
164
164
 
func keyLockParamUserAmount (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "amount"], SEP)
165
165
 
166
166
 
167
167
 
func keyLockParamStartBlock (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "start"], SEP)
168
168
 
169
169
 
170
170
 
func keyLockParamDuration (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "duration"], SEP)
171
171
 
172
172
 
173
173
 
func keyLockParamK (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "k"], SEP)
174
174
 
175
175
 
176
176
 
func keyLockParamB (userNum) = makeString(["%s%d%s__paramByUserNum", userNum, "b"], SEP)
177
177
 
178
178
 
179
179
 
func keyLockParamByPeriodK (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "k", period], SEP)
180
180
 
181
181
 
182
182
 
func keyLockParamByPeriodB (userNum,period) = makeString(["%s%d%s%d__paramByPeriod", userNum, "b", period], SEP)
183
183
 
184
184
 
185
185
 
func keyUserBoostEmissionLastINTEGRAL (userNum) = makeString(["%s%d__userBoostEmissionLastInt", userNum], SEP)
186
186
 
187
187
 
188
188
 
func keyUserMaxBoostINTEGRAL (userNum) = makeString(["%s%d__maxBoostInt", userNum], SEP)
189
189
 
190
190
 
191
191
 
func keyTotalMaxBoostINTEGRAL () = "%s%s__maxBoostInt__total"
192
192
 
193
193
 
194
194
 
func keyUserBoostAvalaibleToClaimTotal (userNum) = makeString(["%s%d__userBoostAvaliableToClaimTotal", userNum], SEP)
195
195
 
196
196
 
197
197
 
func keyUserBoostClaimed (userNum) = makeString(["%s%d__userBoostClaimed", userNum], SEP)
198
198
 
199
199
 
200
200
 
func keyTotalCachedGwx () = "%s%s__gwxCached__total"
201
201
 
202
202
 
203
203
 
func keyStakedByUser (userAddressStr,lpAssetIdStr) = makeString(["%s%s%s__staked", userAddressStr, lpAssetIdStr], SEP)
204
204
 
205
205
 
206
206
 
func keyStakedTotal (lpAssetIdStr) = ("%s%s%s__staked__total__" + lpAssetIdStr)
207
207
 
208
208
 
209
209
 
func keyClaimedByUser (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimed", userAddressStr, lpAssetIdStr], SEP)
210
210
 
211
211
 
212
212
 
func keyClaimedByUserMinReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedMinReward", userAddressStr, lpAssetIdStr], SEP)
213
213
 
214
214
 
215
215
 
func keyClaimedByUserBoostReward (lpAssetIdStr,userAddressStr) = makeString(["%s%s%s__claimedBoostReward", userAddressStr, lpAssetIdStr], SEP)
216
216
 
217
217
 
218
218
 
func readStaked (stakingDapp,key) = valueOrElse(getInteger(stakingDapp, key), 0)
219
219
 
220
220
 
221
221
 
func keyEmissionRatePerBlockCurrent () = "%s%s__ratePerBlock__current"
222
222
 
223
223
 
224
224
 
func keyEmissionRatePerBlockMaxCurrent () = "%s%s__ratePerBlockMax__current"
225
225
 
226
226
 
227
227
 
func keyEmissionStartBlock () = "%s%s__emission__startBlock"
228
228
 
229
229
 
230
230
 
func keyEmissionDurationInBlocks () = "%s%s__emission__duration"
231
231
 
232
232
 
233
233
 
func keyEmissionEndBlock () = "%s%s__emission__endBlock"
234
234
 
235
235
 
236
236
 
let factoryDapp = readFactoryAddressOrFail()
237
237
 
238
238
 
let factoryCfg = readFactoryCfgOrFail(factoryDapp)
239
239
 
240
240
 
let emissionDapp = getEmissionAddressOrFail(factoryCfg)
241
241
 
242
242
 
let stakingDapp = getStakingAddressOrFail(factoryCfg)
243
243
 
244
244
 
let gwxRewardDapp = getGwxRewardAddressOrFail(factoryCfg)
245
245
 
246
246
 
let boostingDapp = getBoostingAddressOrFail(factoryCfg)
247
247
 
248
248
 
func getPoolInFee (poolAddress) = {
249
249
 
    let @ = invoke(factoryDapp, "getInFeeREADONLY", [toString(poolAddress)], nil)
250
250
 
    if ($isInstanceOf(@, "Int"))
251
251
 
        then @
252
252
 
        else throw(($getType(@) + " couldn't be cast to Int"))
253
253
 
    }
254
254
 
255
255
 
256
256
 
func getPoolOutFee (poolAddress) = {
257
257
 
    let @ = invoke(factoryDapp, "getOutFeeREADONLY", [toString(poolAddress)], nil)
258
258
 
    if ($isInstanceOf(@, "Int"))
259
259
 
        then @
260
260
 
        else throw(($getType(@) + " couldn't be cast to Int"))
261
261
 
    }
262
262
 
263
263
 
264
264
 
func internalCurrentRewardRate (lpAssetId) = {
265
265
 
    let poolAddressStr = getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(lpAssetId))
266
266
 
    let poolWeightMult = MULT8
267
267
 
    let poolWeight = getIntegerValue(factoryDapp, keyFactoryPoolWeight(poolAddressStr))
268
268
 
    let wxEmissionPerBlock = getIntOrFail(emissionDapp, keyEmissionRatePerBlockCurrent())
269
269
 
    let wxEmissionPerBlockMax = getIntOrFail(emissionDapp, keyEmissionRatePerBlockMaxCurrent())
270
270
 
    let boostMaxCoeff = {
271
271
 
        let @ = invoke(emissionDapp, "getBoostCoeffREADONLY", nil, nil)
272
272
 
        if ($isInstanceOf(@, "Int"))
273
273
 
            then @
274
274
 
            else throw(($getType(@) + " couldn't be cast to Int"))
275
275
 
        }
276
276
 
    let poolWxEmissionPerBlock = (fraction(wxEmissionPerBlock, poolWeight, poolWeightMult) / boostMaxCoeff)
277
277
 
    let poolWxEmissionPerBlockMax = fraction(wxEmissionPerBlockMax, poolWeight, poolWeightMult)
278
278
 
    let maxFactor = (boostMaxCoeff * MULT8)
279
279
 
    let totalLpStaked = getIntOrZero(stakingDapp, keyStakedTotal(lpAssetId))
280
280
 
[poolWxEmissionPerBlock, maxFactor, totalLpStaked]
281
281
 
    }
282
282
 
283
283
 
284
284
 
func calcGwxAmountStartREADONLY (lockAmount,lockDuration,maxLockDuration) = {
285
285
 
    let coeffX8 = fraction(lockDuration, MULT8, maxLockDuration)
286
286
 
    let gWxAmountStart = fraction(lockAmount, coeffX8, MULT8)
287
287
 
[gWxAmountStart]
288
288
 
    }
289
289
 
290
290
 
291
291
 
func getKey (addr,key,type) = if ((type == "string"))
292
292
 
    then getStringValue(addr, key)
293
293
 
    else if ((type == "integer"))
294
294
 
        then toString(getIntegerValue(addr, key))
295
295
 
        else if ((type == "boolean"))
296
296
 
            then toString(getBooleanValue(addr, key))
297
297
 
            else throw("unknown type. expected string/integer/boolean")
298
298
 
299
299
 
300
300
 
func managerPublicKeyOrUnit () = {
301
301
 
    let managerVaultAddress = getManagerVaultAddressOrThis()
302
302
 
    match getString(managerVaultAddress, keyManagerPublicKey()) {
303
303
 
        case s: String => 
304
304
 
            fromBase58String(s)
305
305
 
        case _: Unit => 
306
306
 
            unit
307
307
 
        case _ => 
308
308
 
            throw("Match error")
309
309
 
    }
310
310
 
    }
311
311
 
312
312
 
313
313
 
func isManager (i) = match managerPublicKeyOrUnit() {
314
314
 
    case pk: ByteVector => 
315
315
 
        (i.callerPublicKey == pk)
316
316
 
    case _: Unit => 
317
317
 
        (i.caller == this)
318
318
 
    case _ => 
319
319
 
        throw("Match error")
320
320
 
}
321
321
 
322
322
 
323
323
 
func mustManager (i) = if (isManager(i))
324
324
 
    then true
325
325
 
    else throw("permission denied")
326
326
 
327
327
 
328
328
 
@Callable(i)
329
329
 
func constructor (factoryAddress) = {
330
330
 
    let checkCaller = mustManager(i)
331
331
 
    if ((checkCaller == checkCaller))
332
332
 
        then [StringEntry(keyFactoryAddress(), factoryAddress)]
333
333
 
        else throw("Strict value is not equal to itself.")
334
334
 
    }
335
335
 
336
336
 
337
337
 
338
338
 
@Callable(i)
339
339
 
func currentRewardRateREADONLY (lpAssetId) = {
340
340
 
    let rewardData = internalCurrentRewardRate(lpAssetId)
341
341
 
    let wxEmissionPerBlock = rewardData[0]
342
342
 
    let maxFactor = rewardData[1]
343
343
 
    let totalLpStaked = rewardData[2]
344
344
 
    let votingResultStaked = {
345
345
 
        let @ = invoke(boostingDapp, "getVotingResultStakedREADONLY", [lpAssetId], nil)
346
346
 
        if ($isInstanceOf(@, "Int"))
347
347
 
            then @
348
348
 
            else throw(($getType(@) + " couldn't be cast to Int"))
349
349
 
        }
350
350
 
    $Tuple2(nil, makeString(["%d%d%d%d", toString(wxEmissionPerBlock), toString(maxFactor), toString(totalLpStaked), toString(votingResultStaked)], SEP))
351
351
 
    }
352
352
 
353
353
 
354
354
 
355
355
 
@Callable(i)
356
356
 
func currentUserRewardRateREADONLY (lpAssetId,userAddress) = {
357
357
 
    let rewardData = internalCurrentRewardRate(lpAssetId)
358
358
 
    let wxEmissionPerBlock = rewardData[0]
359
359
 
    let maxFactor = rewardData[1]
360
360
 
    let totalLpStaked = rewardData[2]
361
361
 
    let lpStakedByUser = getIntOrZero(stakingDapp, keyStakedByUser(userAddress, lpAssetId))
362
362
 
    let userClaimInfo = split(asString(invoke(stakingDapp, "claimWxREADONLY", [lpAssetId, userAddress], nil)), SEP)
363
363
 
    let minRewardPart = valueOrErrorMessage(parseInt(userClaimInfo[5]), "couldn't parse minRewardPart")
364
364
 
    let boostRewardPart = valueOrErrorMessage(parseInt(userClaimInfo[6]), "couldn't parse boostRewardPart")
365
365
 
    let debug = userClaimInfo[7]
366
366
 
    let boostingPower = if ((boostRewardPart == 0))
367
367
 
        then (1 * MULT8)
368
368
 
        else fraction((minRewardPart + boostRewardPart), MULT8, minRewardPart)
369
369
 
    $Tuple2(nil, makeString(["%d%d%d%d%d%s", toString(wxEmissionPerBlock), toString(maxFactor), toString(totalLpStaked), toString(lpStakedByUser), toString(boostingPower), debug], SEP))
370
370
 
    }
371
371
 
372
372
 
373
373
 
374
374
 
@Callable(i)
375
375
 
func calcBoostBulkInternalREADONLY (currentIter,deltaWxAmountBulk,deltaLockPeriodInBlocksBulk,deltaLpAmountBulk,lpAssetIdOptBulk,userAddressOpt,resAcc) = if ((currentIter == size(deltaWxAmountBulk)))
376
376
 
    then $Tuple2(nil, resAcc)
377
377
 
    else {
378
378
 
        let deltaWxAmount = deltaWxAmountBulk[currentIter]
379
379
 
        let deltaLockPeriodInBlocks = deltaLockPeriodInBlocksBulk[currentIter]
380
380
 
        let deltaLpAmount = deltaLpAmountBulk[currentIter]
381
381
 
        let lpAssetIdOpt = lpAssetIdOptBulk[currentIter]
382
382
 
        let info = {
383
383
 
            let @ = invoke(this, "calcBoostREADONLY", [deltaWxAmount, deltaLockPeriodInBlocks, deltaLpAmount, lpAssetIdOpt, userAddressOpt], nil)
384
384
 
            if ($isInstanceOf(@, "String"))
385
385
 
                then @
386
386
 
                else throw(($getType(@) + " couldn't be cast to String"))
387
387
 
            }
388
388
 
        let res = (resAcc :+ info)
389
389
 
        let inv = {
390
390
 
            let @ = invoke(this, "calcBoostBulkInternalREADONLY", [(currentIter + 1), deltaWxAmountBulk, deltaLockPeriodInBlocksBulk, deltaLpAmountBulk, lpAssetIdOptBulk, userAddressOpt, res], nil)
391
391
 
            if ($isInstanceOf(@, "List[Any]"))
392
392
 
                then @
393
393
 
                else throw(($getType(@) + " couldn't be cast to List[Any]"))
394
394
 
            }
395
395
 
        if ((inv == inv))
396
396
 
            then $Tuple2(nil, inv)
397
397
 
            else throw("Strict value is not equal to itself.")
398
398
 
        }
399
399
 
400
400
 
401
401
 
402
402
 
@Callable(i)
403
403
 
func calcBoostBulkREADONLY (deltaWxAmount,deltaLockPeriodInBlocks,deltaLpAmount,lpAssetIdOpt,userAddressOpt) = {
404
404
 
    let res = invoke(this, "calcBoostBulkInternalREADONLY", [0, deltaWxAmount, deltaLockPeriodInBlocks, deltaLpAmount, lpAssetIdOpt, userAddressOpt, nil], nil)
405
405
 
    $Tuple2(nil, res)
406
406
 
    }
407
407
 
408
408
 
409
409
 
410
410
 
@Callable(i)
411
411
 
func calcBoostREADONLY (deltaWxAmount,deltaLockPeriodInBlocks,deltaLpAmount,lpAssetIdOpt,userAddressOpt) = {
412
412
 
    let boostCoeff = {
413
413
 
        let @ = invoke(emissionDapp, "getBoostCoeffREADONLY", nil, nil)
414
414
 
        if ($isInstanceOf(@, "Int"))
415
415
 
            then @
416
416
 
            else throw(($getType(@) + " couldn't be cast to Int"))
417
417
 
        }
418
418
 
    let mathDapp = gwxRewardDapp
419
419
 
    let EMPTYSTR = "empty"
420
420
 
    let maxLockDurationInBlocks = parseIntValue(split(getStringByAddressOrFail(boostingDapp, keyBoostCfg()), SEP)[4])
421
421
 
    let lpAssetIdStr = if ((lpAssetIdOpt == ""))
422
422
 
        then EMPTYSTR
423
423
 
        else lpAssetIdOpt
424
424
 
    let userAddressStr = if ((userAddressOpt == ""))
425
425
 
        then EMPTYSTR
426
426
 
        else userAddressOpt
427
427
 
    let userNumStr = valueOrElse(getString(boostingDapp, keyUser2NumMapping(userAddressOpt)), EMPTYSTR)
428
428
 
    let userAmount = valueOrElse(getInteger(boostingDapp, keyLockParamUserAmount(userNumStr)), 0)
429
429
 
    let lockStart = valueOrElse(getInteger(boostingDapp, keyLockParamStartBlock(userNumStr)), height)
430
430
 
    let lockDuration = valueOrElse(getInteger(boostingDapp, keyLockParamDuration(userNumStr)), 0)
431
431
 
    let lockEnd = (lockStart + lockDuration)
432
432
 
    let remainingDuration = max([(lockEnd - height), 0])
433
433
 
    let userAmountNew = (userAmount + deltaWxAmount)
434
434
 
    let lockDurationNew = min([(remainingDuration + deltaLockPeriodInBlocks), maxLockDurationInBlocks])
435
435
 
    let userCurrgWxAmount = asInt(asAnyList(invoke(boostingDapp, "gwxUserInfoREADONLY", [userAddressStr], nil))[0])
436
436
 
    let gWxAmountStartNew = calcGwxAmountStartREADONLY(userAmountNew, lockDurationNew, maxLockDurationInBlocks)[0]
437
437
 
    let totalCachedGwx = {
438
438
 
        let @ = invoke(boostingDapp, "getTotalCachedGwxREADONLY", nil, nil)
439
439
 
        if ($isInstanceOf(@, "Int"))
440
440
 
            then @
441
441
 
            else throw(($getType(@) + " couldn't be cast to Int"))
442
442
 
        }
443
443
 
    let MULT3 = 1000
444
444
 
    let wxEmissionPerBlockX3 = (getIntOrFail(emissionDapp, keyEmissionRatePerBlockCurrent()) * MULT3)
445
445
 
    let stakedByUserKEY = keyStakedByUser(userAddressStr, lpAssetIdStr)
446
446
 
    let stakedTotalKEY = keyStakedTotal(lpAssetIdStr)
447
447
 
    let stakedByUser = readStaked(stakingDapp, stakedByUserKEY)
448
448
 
    let stakedTotal = readStaked(stakingDapp, stakedTotalKEY)
449
449
 
    let poolWeight = if ((lpAssetIdStr != EMPTYSTR))
450
450
 
        then {
451
451
 
            let poolAddressStr = valueOrErrorMessage(getString(factoryDapp, keyFactoryLp2AssetsMapping(lpAssetIdStr)), ("unsupported lp asset " + lpAssetIdStr))
452
452
 
            getIntegerValue(factoryDapp, keyFactoryPoolWeight(poolAddressStr))
453
453
 
            }
454
454
 
        else 0
455
455
 
    let poolWxEmissionPerBlockX3 = fraction(wxEmissionPerBlockX3, poolWeight, (POOLWEIGHTMULT * boostCoeff))
456
456
 
    let wxPerLpX3 = if ((stakedTotal != 0))
457
457
 
        then fraction(poolWxEmissionPerBlockX3, MULT8, stakedTotal)
458
458
 
        else 0
459
459
 
    let userWxPerBlockX3 = fraction(wxPerLpX3, stakedByUser, MULT8)
460
460
 
    let boostEmissionPerBlockX3 = (poolWxEmissionPerBlockX3 * (boostCoeff - 1))
461
461
 
    let tmpUserBoostPerBlockX3 = fraction(userCurrgWxAmount, boostEmissionPerBlockX3, totalCachedGwx)
462
462
 
    let userBoostPerBlockX3 = min([tmpUserBoostPerBlockX3, (userWxPerBlockX3 * (boostCoeff - 1))])
463
463
 
    let userBoostCoeff = if ((userWxPerBlockX3 == 0))
464
464
 
        then (1 * MULT8)
465
465
 
        else fraction((userBoostPerBlockX3 + userWxPerBlockX3), MULT8, userWxPerBlockX3)
466
466
 
    $Tuple2(nil, makeString(["%d%d%s", toString(gWxAmountStartNew), toString(userBoostCoeff), "d"], SEP))
467
467
 
    }
468
468
 
469
469
 
470
470
 
471
471
 
@Callable(i)
472
472
 
func wxEmissionStatsREADONLY () = {
473
473
 
    let ONEMULT = toString(MULT8)
474
474
 
    let ONE = "1"
475
475
 
    let wxEmissionPerBlock = getIntOrFail(emissionDapp, keyEmissionRatePerBlockCurrent())
476
476
 
    let emissionStartBlock = getIntOrFail(emissionDapp, keyEmissionStartBlock())
477
477
 
    let passedBlocks = if ((emissionStartBlock > height))
478
478
 
        then 0
479
479
 
        else (height - emissionStartBlock)
480
480
 
    let teamEmDuration = (1440 * 365)
481
481
 
    let teamEmMax = (201000000 * MULT8)
482
482
 
    let teamEm = if ((passedBlocks > teamEmDuration))
483
483
 
        then teamEmMax
484
484
 
        else fraction(teamEmMax, passedBlocks, teamEmDuration)
485
485
 
    let totalWxReleased = ((wxEmissionPerBlock * passedBlocks) + teamEm)
486
486
 
    let totalWxLocked = getIntOrZero(boostingDapp, keyBoostingLockParamTotalAmount())
487
487
 
    let locksDurationSumInBlocks = getIntOrZero(boostingDapp, keyBoostingStatsLocksDurationSumInBlocks())
488
488
 
    let locksCount = getIntOrZero(boostingDapp, keyBoostingStatsLocksCount())
489
489
 
    $Tuple2(nil, makeString(["%d%d%d%d", toString(totalWxReleased), toString(totalWxLocked), toString(locksDurationSumInBlocks), toString(locksCount)], SEP))
490
490
 
    }
491
491
 
492
492
 
493
493
 
494
494
 
@Callable(i)
495
495
 
func poolStatsREADONLY (lpAsset) = {
496
496
 
    let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(lpAsset)))
497
497
 
    let status = {
498
498
 
        let @ = invoke(factoryDapp, "getPoolStatusREADONLY", [toString(poolAddress)], nil)
499
499
 
        if ($isInstanceOf(@, "Int"))
500
500
 
            then @
501
501
 
            else throw(($getType(@) + " couldn't be cast to Int"))
502
502
 
        }
503
503
 
    let tpl = "%d%d%d%d%d%d%d%d%d%s"
504
504
 
    if ((status == 4))
505
505
 
        then $Tuple2(nil, makeString([tpl, toString(0), toString(0), toString(0), toString(0), toString(0), toString(0), toString(0), toString(0), toString(0), toString(false)], SEP))
506
506
 
        else {
507
507
 
            let cfg = asAnyList(invoke(poolAddress, "getPoolConfigWrapperREADONLY", nil, nil))
508
508
 
            let lpAssetId = fromBase58String(asString(cfg[idxPoolLPAssetId]))
509
509
 
            let amtAssetId = asString(cfg[idxAmtAssetId])
510
510
 
            let priceAssetId = asString(cfg[idxPriceAssetId])
511
511
 
            let iAmtAssetId = asString(cfg[idxIAmtAssetId])
512
512
 
            let iPriceAssetId = asString(cfg[idxIPriceAssetId])
513
513
 
            let amtAssetDcm = parseIntValue(asString(cfg[idxAmtAssetDcm]))
514
514
 
            let priceAssetDcm = parseIntValue(asString(cfg[idxPriceAssetDcm]))
515
515
 
            let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
516
516
 
            let accAmtAssetBalance = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [amtAssetId], nil))
517
517
 
            let accPriceAssetBalance = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [priceAssetId], nil))
518
518
 
            let pricesList = if ((poolLPBalance == 0))
519
519
 
                then [toString(zeroBigInt), toString(zeroBigInt), toString(zeroBigInt)]
520
520
 
                else asAnyList(invoke(poolAddress, "calcPricesWrapperREADONLY", [accAmtAssetBalance, accPriceAssetBalance, poolLPBalance], nil))
521
521
 
            let curPrice = 0
522
522
 
            let lpAmtAssetShare = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [pricesList[1], MULT8], nil))
523
523
 
            let lpPriceAssetShare = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [pricesList[2], MULT8], nil))
524
524
 
            let poolWeight = getIntegerValue(factoryDapp, keyFactoryPoolWeight(toString(poolAddress)))
525
525
 
            let inFee = getPoolInFee(poolAddress)
526
526
 
            let outFee = getPoolOutFee(poolAddress)
527
527
 
            let poolOneTokenOperationsDisabled = {
528
528
 
                let @ = invoke(factoryDapp, "isPoolOneTokenOperationsDisabledREADONLY", [toString(poolAddress)], nil)
529
529
 
                if ($isInstanceOf(@, "Boolean"))
530
530
 
                    then @
531
531
 
                    else throw(($getType(@) + " couldn't be cast to Boolean"))
532
532
 
                }
533
533
 
            let poolOneTokenOperationsEnabled = !(poolOneTokenOperationsDisabled)
534
-
            let poolSwapEnabled = !({
535
-
                let @ = invoke(factoryDapp, "isPoolSwapDisabledREADONLY", [toString(poolAddress)], nil)
536
-
                if ($isInstanceOf(@, "Boolean"))
537
-
                    then @
538
-
                    else throw(($getType(@) + " couldn't be cast to Boolean"))
539
-
                })
540
-
            $Tuple2(nil, makeString([tpl, toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight), toString(inFee), toString(outFee), toString(poolOneTokenOperationsEnabled), toString(poolSwapEnabled)], SEP))
534
+
            $Tuple2(nil, makeString([tpl, toString(accAmtAssetBalance), toString(accPriceAssetBalance), toString(poolLPBalance), toString(curPrice), toString(lpAmtAssetShare), toString(lpPriceAssetShare), toString(poolWeight), toString(inFee), toString(outFee), toString(poolOneTokenOperationsEnabled)], SEP))
541
535
 
            }
542
536
 
    }
543
537
 
544
538
 
545
539
 
546
540
 
@Callable(i)
547
541
 
func poolEvaluatePutByAmountAssetREADONLY (lpAsset,inAmAssetAmt) = {
548
542
 
    let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(lpAsset)))
549
543
 
    let cfg = asAnyList(invoke(poolAddress, "getPoolConfigWrapperREADONLY", nil, nil))
550
544
 
    let lpAssetId = fromBase58String(asString(cfg[idxPoolLPAssetId]))
551
545
 
    let amAssetIdStr = asString(cfg[idxAmtAssetId])
552
546
 
    let amAssetId = fromBase58String(amAssetIdStr)
553
547
 
    let prAssetIdStr = asString(cfg[idxPriceAssetId])
554
548
 
    let prAssetId = fromBase58String(prAssetIdStr)
555
549
 
    let amtAssetDcm = parseIntValue(asString(cfg[idxAmtAssetDcm]))
556
550
 
    let priceAssetDcm = parseIntValue(asString(cfg[idxPriceAssetDcm]))
557
551
 
    let poolStatus = asString(cfg[idxPoolStatus])
558
552
 
    let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
559
553
 
    let accAmtAssetBalance = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [amAssetIdStr], nil))
560
554
 
    let accPriceAssetBalance = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [prAssetIdStr], nil))
561
555
 
    let amtAssetAmtX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [accAmtAssetBalance, amtAssetDcm], nil)))
562
556
 
    let priceAssetAmtX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [accPriceAssetBalance, priceAssetDcm], nil)))
563
557
 
    let curPriceX18 = if ((poolLPBalance == 0))
564
558
 
        then zeroBigInt
565
559
 
        else parseBigIntValue(asString(invoke(poolAddress, "calcPriceBigIntWrapperREADONLY", [toString(priceAssetAmtX18), toString(amtAssetAmtX18)], nil)))
566
560
 
    let curPrice = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(curPriceX18), MULT8], nil))
567
561
 
    let inAmAssetAmtX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [inAmAssetAmt, amtAssetDcm], nil)))
568
562
 
    let inPrAssetAmtX18 = fraction(inAmAssetAmtX18, curPriceX18, MULT18)
569
563
 
    let inPrAssetAmt = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(inPrAssetAmtX18), priceAssetDcm], nil))
570
564
 
    let res = invoke(poolAddress, "estimatePutOperationWrapperREADONLY", ["", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false], nil)
571
-
    let $t02285123204 =     match res {
565
+
    let $t02269123044 =     match res {
572
566
 
        case _ => 
573
567
 
            if (if (if ($isInstanceOf($match0._1, "Int"))
574
568
 
                then if ($isInstanceOf($match0._3, "Int"))
575
569
 
                    then if ($isInstanceOf($match0._4, "Int"))
576
570
 
                        then if ($isInstanceOf($match0._5, "Int"))
577
571
 
                            then $isInstanceOf($match0._6, "Int")
578
572
 
                            else false
579
573
 
                        else false
580
574
 
                    else false
581
575
 
                else false)
582
576
 
                then (size($match0) == 13)
583
577
 
                else false)
584
578
 
                then {
585
579
 
                    let calcLpAmt = $match0._1
586
580
 
                    let curPriceCalc = $match0._3
587
581
 
                    let amBalance = $match0._4
588
582
 
                    let prBalance = $match0._5
589
583
 
                    let lpEmission = $match0._6
590
584
 
                    $Tuple5(calcLpAmt, curPriceCalc, amBalance, prBalance, lpEmission)
591
585
 
                    }
592
586
 
                else throw("Couldn't cast types")
593
587
 
    }
594
-
    let calcLpAmt = $t02285123204._1
595
-
    let curPriceCalc = $t02285123204._2
596
-
    let amBalance = $t02285123204._3
597
-
    let prBalance = $t02285123204._4
598
-
    let lpEmission = $t02285123204._5
588
+
    let calcLpAmt = $t02269123044._1
589
+
    let curPriceCalc = $t02269123044._2
590
+
    let amBalance = $t02269123044._3
591
+
    let prBalance = $t02269123044._4
592
+
    let lpEmission = $t02269123044._5
599
593
 
    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(curPrice), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
600
594
 
    }
601
595
 
602
596
 
603
597
 
604
598
 
@Callable(i)
605
599
 
func poolEvaluatePutByPriceAssetREADONLY (lpAsset,inPrAssetAmt) = {
606
600
 
    let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(lpAsset)))
607
601
 
    let cfg = asAnyList(invoke(poolAddress, "getPoolConfigWrapperREADONLY", nil, nil))
608
602
 
    let lpAssetId = fromBase58String(asString(cfg[idxPoolLPAssetId]))
609
603
 
    let amAssetIdStr = asString(cfg[idxAmtAssetId])
610
604
 
    let amAssetId = fromBase58String(amAssetIdStr)
611
605
 
    let prAssetIdStr = asString(cfg[idxPriceAssetId])
612
606
 
    let prAssetId = fromBase58String(prAssetIdStr)
613
607
 
    let amtAssetDcm = parseIntValue(asString(cfg[idxAmtAssetDcm]))
614
608
 
    let priceAssetDcm = parseIntValue(asString(cfg[idxPriceAssetDcm]))
615
609
 
    let poolStatus = asString(cfg[idxPoolStatus])
616
610
 
    let poolLPBalance = valueOrErrorMessage(assetInfo(lpAssetId), (("Asset " + toBase58String(lpAssetId)) + " doesn't exist")).quantity
617
611
 
    let amBalanceRaw = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [amAssetIdStr], nil))
618
612
 
    let prBalanceRaw = asInt(invoke(poolAddress, "getAccBalanceWrapperREADONLY", [prAssetIdStr], nil))
619
613
 
    let amBalanceRawX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [amBalanceRaw, amtAssetDcm], nil)))
620
614
 
    let prBalanceRawX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [prBalanceRaw, priceAssetDcm], nil)))
621
615
 
    let curPriceX18 = if ((poolLPBalance == 0))
622
616
 
        then zeroBigInt
623
617
 
        else parseBigIntValue(asString(invoke(poolAddress, "calcPriceBigIntWrapperREADONLY", [toString(prBalanceRawX18), toString(amBalanceRawX18)], nil)))
624
618
 
    let curPrice = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(curPriceX18), MULT8], nil))
625
619
 
    let inPrAssetAmtX18 = parseBigIntValue(asString(invoke(poolAddress, "toX18WrapperREADONLY", [inPrAssetAmt, priceAssetDcm], nil)))
626
620
 
    let inAmAssetAmtX18 = fraction(inPrAssetAmtX18, MULT18, curPriceX18)
627
621
 
    let inAmAssetAmt = asInt(invoke(poolAddress, "fromX18WrapperREADONLY", [toString(inAmAssetAmtX18), amtAssetDcm], nil))
628
622
 
    let res = invoke(poolAddress, "estimatePutOperationWrapperREADONLY", ["", 500000, inAmAssetAmt, amAssetId, inPrAssetAmt, prAssetId, "", true, false], nil)
629
-
    let $t02577726130 =     match res {
623
+
    let $t02561725970 =     match res {
630
624
 
        case _ => 
631
625
 
            if (if (if ($isInstanceOf($match0._1, "Int"))
632
626
 
                then if ($isInstanceOf($match0._3, "Int"))
633
627
 
                    then if ($isInstanceOf($match0._4, "Int"))
634
628
 
                        then if ($isInstanceOf($match0._5, "Int"))
635
629
 
                            then $isInstanceOf($match0._6, "Int")
636
630
 
                            else false
637
631
 
                        else false
638
632
 
                    else false
639
633
 
                else false)
640
634
 
                then (size($match0) == 13)
641
635
 
                else false)
642
636
 
                then {
643
637
 
                    let calcLpAmt = $match0._1
644
638
 
                    let curPriceCalc = $match0._3
645
639
 
                    let amBalance = $match0._4
646
640
 
                    let prBalance = $match0._5
647
641
 
                    let lpEmission = $match0._6
648
642
 
                    $Tuple5(calcLpAmt, curPriceCalc, amBalance, prBalance, lpEmission)
649
643
 
                    }
650
644
 
                else throw("Couldn't cast types")
651
645
 
    }
652
-
    let calcLpAmt = $t02577726130._1
653
-
    let curPriceCalc = $t02577726130._2
654
-
    let amBalance = $t02577726130._3
655
-
    let prBalance = $t02577726130._4
656
-
    let lpEmission = $t02577726130._5
646
+
    let calcLpAmt = $t02561725970._1
647
+
    let curPriceCalc = $t02561725970._2
648
+
    let amBalance = $t02561725970._3
649
+
    let prBalance = $t02561725970._4
650
+
    let lpEmission = $t02561725970._5
657
651
 
    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d%d", toString(calcLpAmt), toString(curPrice), toString(amBalance), toString(prBalance), toString(lpEmission), poolStatus, toString(inAmAssetAmt), toString(inPrAssetAmt)], SEP))
658
652
 
    }
659
653
 
660
654
 
661
655
 
662
656
 
@Callable(i)
663
657
 
func poolEvaluateGetREADONLY (paymentLpAssetId,paymentLpAmt) = {
664
658
 
    let poolAddress = addressFromStringValue(getStringByAddressOrFail(factoryDapp, keyFactoryLpAssetToPoolContractAddress(paymentLpAssetId)))
665
659
 
    let res = invoke(poolAddress, "estimateGetOperationWrapperREADONLY", ["", paymentLpAssetId, paymentLpAmt, toString(poolAddress)], nil)
666
-
    let $t02682527242 =     match res {
660
+
    let $t02666527082 =     match res {
667
661
 
        case _ => 
668
662
 
            if (if (if ($isInstanceOf($match0._1, "Int"))
669
663
 
                then if ($isInstanceOf($match0._2, "Int"))
670
664
 
                    then if ($isInstanceOf($match0._5, "Int"))
671
665
 
                        then if ($isInstanceOf($match0._6, "Int"))
672
666
 
                            then if ($isInstanceOf($match0._7, "Int"))
673
667
 
                                then if ($isInstanceOf($match0._8, "String"))
674
668
 
                                    then $isInstanceOf($match0._9, "String")
675
669
 
                                    else false
676
670
 
                                else false
677
671
 
                            else false
678
672
 
                        else false
679
673
 
                    else false
680
674
 
                else false)
681
675
 
                then (size($match0) == 10)
682
676
 
                else false)
683
677
 
                then {
684
678
 
                    let outAmAmt = $match0._1
685
679
 
                    let outPrAmt = $match0._2
686
680
 
                    let amBalance = $match0._5
687
681
 
                    let prBalance = $match0._6
688
682
 
                    let lpEmission = $match0._7
689
683
 
                    let curPrice = $match0._8
690
684
 
                    let poolStatus = $match0._9
691
685
 
                    $Tuple7(outAmAmt, outPrAmt, amBalance, prBalance, lpEmission, curPrice, poolStatus)
692
686
 
                    }
693
687
 
                else throw("Couldn't cast types")
694
688
 
    }
695
-
    let outAmAmt = $t02682527242._1
696
-
    let outPrAmt = $t02682527242._2
697
-
    let amBalance = $t02682527242._3
698
-
    let prBalance = $t02682527242._4
699
-
    let lpEmission = $t02682527242._5
700
-
    let curPrice = $t02682527242._6
701
-
    let poolStatus = $t02682527242._7
689
+
    let outAmAmt = $t02666527082._1
690
+
    let outPrAmt = $t02666527082._2
691
+
    let amBalance = $t02666527082._3
692
+
    let prBalance = $t02666527082._4
693
+
    let lpEmission = $t02666527082._5
694
+
    let curPrice = $t02666527082._6
695
+
    let poolStatus = $t02666527082._7
702
696
 
    $Tuple2(nil, makeString(["%d%d%d%d%d%d%d", toString(outAmAmt), toString(outPrAmt), toString(amBalance), toString(prBalance), toString(lpEmission), curPrice, poolStatus], SEP))
703
697
 
    }
704
698
 
705
699
 
706
700
 
707
701
 
@Callable(i)
708
702
 
func gwxUserInfoREADONLY (userAddress) = {
709
703
 
    let gwxUserInfoLIST = asAnyList(invoke(boostingDapp, "gwxUserInfoREADONLY", [userAddress], nil))
710
704
 
    let gwxAmount = asInt(gwxUserInfoLIST[0])
711
705
 
    $Tuple2(nil, makeString(["%d", toString(gwxAmount)], SEP))
712
706
 
    }
713
707
 
714
708
 
715
709
 
716
710
 
@Callable(i)
717
711
 
func unstakeAndGetOneTknV2 (poolAddress,unstakeAmount,outAssetId,minOutAmount) = {
718
712
 
    let inv = invoke(addressFromStringValue(poolAddress), "unstakeAndGetOneTknV2", [unstakeAmount, outAssetId, minOutAmount], nil)
719
713
 
    if ((inv == inv))
720
714
 
        then $Tuple2(nil, unit)
721
715
 
        else throw("Strict value is not equal to itself.")
722
716
 
    }
723
717
 
724
718
 
725
719
 
726
720
 
@Callable(i)
727
721
 
func getKeysBulkInternal (currentIter,keys,resAcc) = if ((currentIter == size(keys)))
728
722
 
    then $Tuple2(nil, resAcc)
729
723
 
    else {
730
724
 
        let k = split(keys[currentIter], "++")
731
725
 
        let addr = addressFromStringValue(k[0])
732
726
 
        let key = k[1]
733
727
 
        let type = k[2]
734
728
 
        let val = getKey(addr, key, type)
735
729
 
        let res = (resAcc :+ val)
736
730
 
        let inv = invoke(this, "getKeysBulkInternal", [(currentIter + 1), keys, res], nil)
737
731
 
        if ((inv == inv))
738
732
 
            then $Tuple2(nil, inv)
739
733
 
            else throw("Strict value is not equal to itself.")
740
734
 
        }
741
735
 
742
736
 
743
737
 
744
738
 
@Callable(i)
745
739
 
func getKeysBulk (keys) = {
746
740
 
    let res = invoke(this, "getKeysBulkInternal", [0, keys, nil], nil)
747
741
 
    $Tuple2(nil, res)
748
742
 
    }
749
743
 
750
744
 
751
745
 
@Verifier(tx)
752
746
 
func verify () = {
753
747
 
    let targetPublicKey =     match managerPublicKeyOrUnit() {
754
748
 
        case pk: ByteVector => 
755
749
 
            pk
756
750
 
        case _: Unit => 
757
751
 
            tx.senderPublicKey
758
752
 
        case _ => 
759
753
 
            throw("Match error")
760
754
 
    }
761
755
 
    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
762
756
 
    }
763
757
 

github/deemru/w8io/873ac7e 
93.88 ms ◑