tx · DAe3Ki5q1Lvd6aA7fg1u9Kcpzzf2F8936MpQ5Ckg72zA

3N9Fi37D7EoAveMhpdBFPB8NEUn4bwXEV4G:  -0.03400000 Waves

2023.05.24 17:20 [2592175] smart account 3N9Fi37D7EoAveMhpdBFPB8NEUn4bwXEV4G > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DAe3Ki5q1Lvd6aA7fg1u9Kcpzzf2F8936MpQ5Ckg72zA",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1684938059567,
    "version": 2,
    "chainId": 84,
    "sender": "3N9Fi37D7EoAveMhpdBFPB8NEUn4bwXEV4G",
    "senderPublicKey": "7SdMpYYBFTqnnyr31oEmHeJfFTa3aGnwocRuvfEhpyoh",
    "proofs": [
        "bXUHfJbjvQRgUogLiAikE5K3duhYv2rEQqm8iagxFYuxmX14dTAamY4J7Jj4qAfokQgt4Xo6xmcXGCpzc2a7QXZ"
    ],
    "script": "base64:BgI5CAISABIAEgQKAgEBEgYKBAgICAgSAwoBCBIFCgMIAQESBAoCCAESBAoCCAESBAoCCAESBQoDAQgILwANa19pbml0aWFsaXplZAINa19pbml0aWFsaXplZAAIa19wYXVzZWQCCGtfcGF1c2VkAAVrX2ZlZQIFa19mZWUACGtfcmViYXRlAghrX3JlYmF0ZQAUa19jb29yZGluYXRvckFkZHJlc3MCFGtfY29vcmRpbmF0b3JBZGRyZXNzAA9rX2V4Y2Vzc0JhbGFuY2UCD2tfZXhjZXNzQmFsYW5jZQANa19mcmVlQmFsYW5jZQINa19mcmVlQmFsYW5jZQAUa19tYXhTcG90VXRpbGl6YXRpb24CFGtfbWF4U3BvdFV0aWxpemF0aW9uABBrX21heFByaWNlU3ByZWFkAhBrX21heFByaWNlU3ByZWFkABJrX2Jhc2VBc3NldFJlc2VydmUCCGtfYnNBc3RSABJrX3F1b3RlQXNzZXRXZWlnaHQCCGtfcXRBc3RXABNrX3RvdGFsUG9zaXRpb25TaXplAhNrX3RvdGFsUG9zaXRpb25TaXplAAVrX2FtbQIFa19hbW0AB2tfdmF1bHQCB2tfdmF1bHQACmtfYW1tX2RhdGECCmtfYW1tX2RhdGEADWtfYXNzZXRfdmF1bHQCDWtfYXNzZXRfdmF1bHQAC2tfYXNzZXRfYW1tAgtrX2Fzc2V0X2FtbQAPa19hZG1pbl9hZGRyZXNzAg9rX2FkbWluX2FkZHJlc3MBDnRvQ29tcG9zaXRlS2V5AgRfa2V5CF9hZGRyZXNzCQCsAgIJAKwCAgUEX2tleQIBXwUIX2FkZHJlc3MBC2Nvb3JkaW5hdG9yAAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEJARFAZXh0ck5hdGl2ZSgxMDUzKQIFBHRoaXMFFGtfY29vcmRpbmF0b3JBZGRyZXNzAhNDb29yZGluYXRvciBub3Qgc2V0AQxhZG1pbkFkZHJlc3MACQCmCAEJARFAZXh0ck5hdGl2ZSgxMDUzKQIJAQtjb29yZGluYXRvcgAFD2tfYWRtaW5fYWRkcmVzcwERZ2V0QWRkcmVzc0lmVmFsaWQBB2FkZHJlc3MJAKUIAQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEFB2FkZHJlc3MJAKwCAgkArAICAg1DYW4ndCBwYXJzZSAiBQdhZGRyZXNzAgwiIGFzIGFkZHJlc3MAD0RFQ0lNQUxfTlVNQkVSUwAGAAxERUNJTUFMX1VOSVQJAGgCAAEJAGgCCQBoAgkAaAIJAGgCCQBoAgAKAAoACgAKAAoACgEBcwECX3gJAKwCAgkApAMBBQJfeAIBLAEEZGl2ZAICX3gCX3kJAG4EBQJfeAUMREVDSU1BTF9VTklUBQJfeQUISEFMRkVWRU4BBG11bGQCAl94Al95CQBuBAUCX3gFAl95BQxERUNJTUFMX1VOSVQFCEhBTEZFVkVOAQNhYnMBAl94AwkAZgIFAl94AAAFAl94CQEBLQEFAl94AQR2bWF4AgJfeAJfeQMJAGcCBQJfeAUCX3kFAl94BQJfeQEEdm1pbgICX3gCX3kDCQBnAgUCX3kFAl94BQJfeAUCX3kBA2ludAEBawkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCaCAIFBHRoaXMFAWsJAKwCAgINbm8gdmFsdWUgZm9yIAUBawEDZmVlAAkBA2ludAEFBWtfZmVlAQlmZWVSZWJhdGUACQEDaW50AQUIa19yZWJhdGUBDmdldE1hcmtldE1heWJlAQhfYXNzZXRJZAQKYWRkcmVzc1N0cgkAnQgCBQR0aGlzCQEOdG9Db21wb3NpdGVLZXkCBQtrX2Fzc2V0X2FtbQUIX2Fzc2V0SWQDCQEJaXNEZWZpbmVkAQUKYWRkcmVzc1N0cgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEJAQV2YWx1ZQEFCmFkZHJlc3NTdHIJAKwCAgIbSW52YWxpZCB2YXVsdCBhZGRyZXNzIGZvcjogBQhfYXNzZXRJZAUEdW5pdAENZ2V0VmF1bHRNYXliZQEIX2Fzc2V0SWQECmFkZHJlc3NTdHIJAJ0IAgUEdGhpcwkBDnRvQ29tcG9zaXRlS2V5AgUNa19hc3NldF92YXVsdAUIX2Fzc2V0SWQDCQEJaXNEZWZpbmVkAQUKYWRkcmVzc1N0cgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEJAQV2YWx1ZQEFCmFkZHJlc3NTdHIJAKwCAgIcSW52YWxpZCBtYXJrZXQgYWRkcmVzcyBmb3I6IAUIX2Fzc2V0SWQFBHVuaXQBCWdldE1hcmtldAEIX2Fzc2V0SWQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkBDmdldE1hcmtldE1heWJlAQUIX2Fzc2V0SWQJAKwCAgIPTm8gbWFya2V0IGZvcjogBQhfYXNzZXRJZAEIZ2V0VmF1bHQBCF9hc3NldElkCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAQ1nZXRWYXVsdE1heWJlAQUIX2Fzc2V0SWQJAKwCAgIOTm8gdmF1bHQgZm9yOiAFCF9hc3NldElkARBnZXRFeGNlc3NCYWxhbmNlAQZfdmF1bHQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUGX3ZhdWx0BQ9rX2V4Y2Vzc0JhbGFuY2UAAAEOZ2V0RnJlZUJhbGFuY2UBBl92YXVsdAkBC3ZhbHVlT3JFbHNlAgkAmggCBQZfdmF1bHQFDWtfZnJlZUJhbGFuY2UAAAERZ2V0TWF4VXRpbGl6YXRpb24BBl92YXVsdAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCaCAIFBl92YXVsdAUUa19tYXhTcG90VXRpbGl6YXRpb24JAKwCAgIiTWF4IHNwb3QgdXRpbGl6YXRpb24gbm90IHNldCBmb3I6IAkApQgBBQZfdmF1bHQBEWdldE1heFByaWNlU3ByZWFkAQRfYW1tCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUEX2FtbQUQa19tYXhQcmljZVNwcmVhZAkArAICAh5NYXggcHJpY2Ugc3ByZWFkIG5vdCBzZXQgZm9yOiAJAKUIAQUEX2FtbQEoZ2V0T2xkUHJvamVjdGVkTGlxdWlkaXR5QW5kVGVybWluYWxQcmljZQEEX2FtbQQEc3luYwkA/AcEBQRfYW1tAhlzeW5jVGVybWluYWxQcmljZVRvT3JhY2xlBQNuaWwFA25pbAMJAAACBQRzeW5jBQRzeW5jBAZwcmljZVIJAPwHBAUEX2FtbQIXY29tcHV0ZVRlcm1pbmFsQW1tUHJpY2UFA25pbAUDbmlsAwkAAAIFBnByaWNlUgUGcHJpY2VSBAVwcmljZQQHJG1hdGNoMAUGcHJpY2VSAwkAAQIFByRtYXRjaDACA0ludAQBdAUHJG1hdGNoMAUBdAkAAgEJAKwCAgIrSW52YWxpZCBjb21wdXRlVGVybWluYWxBbW1QcmljZSByZXN1bHQgZm9yIAkApQgBBQRfYW1tBBZjdXJyZW50QmFzZUFzc2V0QW1vdW50CQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUEX2FtbQUSa19iYXNlQXNzZXRSZXNlcnZlCQCsAgIJAKwCAgkArAICAgRLZXkgBRJrX2Jhc2VBc3NldFJlc2VydmUCDSBub3Qgc2V0IGZvciAJAKUIAQUEX2FtbQMJAAACBRZjdXJyZW50QmFzZUFzc2V0QW1vdW50BRZjdXJyZW50QmFzZUFzc2V0QW1vdW50BBRiYXNlQXNzZXRBbW91bnREZWx0YQkBC3ZhbHVlT3JFbHNlAgkAmggCBQRfYW1tBRNrX3RvdGFsUG9zaXRpb25TaXplAAADCQAAAgUUYmFzZUFzc2V0QW1vdW50RGVsdGEFFGJhc2VBc3NldEFtb3VudERlbHRhBBBxdW90ZUFzc2V0V2VpZ2h0CQELdmFsdWVPckVsc2UCCQCaCAIFBF9hbW0FEmtfcXVvdGVBc3NldFdlaWdodAUMREVDSU1BTF9VTklUAwkAAAIFEHF1b3RlQXNzZXRXZWlnaHQFEHF1b3RlQXNzZXRXZWlnaHQJAJUKAwkAZAIFFmN1cnJlbnRCYXNlQXNzZXRBbW91bnQFFGJhc2VBc3NldEFtb3VudERlbHRhBQVwcmljZQUQcXVvdGVBc3NldFdlaWdodAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgETZ2V0SW1iYWxhbmNlQ29zdFVTRAQGX3ZhdWx0BF9hbW0JX2RlY2ltYWxzB19hbW91bnQEBmFtb3VudAMJAAACBQlfZGVjaW1hbHMACAUHX2Ftb3VudAMJAAACBQlfZGVjaW1hbHMABgkAaAIFB19hbW91bnQAZAkAAgECEEludmFsaWQgZGVjaW1hbHMEDG9sZEltYmFsYW5jZQkBEGdldEV4Y2Vzc0JhbGFuY2UBBQZfdmF1bHQEDG5ld0ltYmFsYW5jZQkAZAIFDG9sZEltYmFsYW5jZQUGYW1vdW50BBtpbWJhbGFuY2VEZWx0YUluQW1tRGVjaW1hbHMJAGkCCQBlAgkBA2FicwEFDG5ld0ltYmFsYW5jZQkBA2FicwEFDG9sZEltYmFsYW5jZQBkBAZwcmljZVIJAPwHBAUEX2FtbQIQY29tcHV0ZVNwb3RQcmljZQUDbmlsBQNuaWwDCQAAAgUGcHJpY2VSBQZwcmljZVIEBXByaWNlBAckbWF0Y2gwBQZwcmljZVIDCQABAgUHJG1hdGNoMAIDSW50BAF0BQckbWF0Y2gwBQF0CQACAQkArAICAiRJbnZhbGlkIGNvbXB1dGVTcG90UHJpY2UgcmVzdWx0IGZvciAJAKUIAQUEX2FtbQQTaW1iYWxhbmNlRGVsdGFJblVTRAkBBG11bGQCBRtpbWJhbGFuY2VEZWx0YUluQW1tRGVjaW1hbHMFBXByaWNlBBdmcmVlQmFsYW5jZUluQW1tRGVjaW1hbAkAaQIJAQ5nZXRGcmVlQmFsYW5jZQEFBl92YXVsdABkBBF2YXVsdEJhbGFuY2VJblVTRAkBBG11bGQCBRdmcmVlQmFsYW5jZUluQW1tRGVjaW1hbAUFcHJpY2UJAJQKAgUTaW1iYWxhbmNlRGVsdGFJblVTRAURdmF1bHRCYWxhbmNlSW5VU0QJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BDGVzdGltYXRlU3dhcAMHX2Ftb3VudAhfYXNzZXRJZAxfdGFyZ2V0QXNzZXQEDnNvdXJjZURlY2ltYWxzAwkAAAIFCF9hc3NldElkAgVXQVZFUwAICAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEJANkEAQUIX2Fzc2V0SWQJAKwCAgIPSW52YWxpZCBhc3NldDogBQhfYXNzZXRJZAhkZWNpbWFscwQOdGFyZ2V0RGVjaW1hbHMDCQAAAgUMX3RhcmdldEFzc2V0AgVXQVZFUwAICAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQDsBwEJANkEAQUMX3RhcmdldEFzc2V0CQCsAgICD0ludmFsaWQgYXNzZXQ6IAUMX3RhcmdldEFzc2V0CGRlY2ltYWxzBBlzb3VyY2VBbW91bnRJbkFtbURlY2ltYWxzAwkAAAIFDnNvdXJjZURlY2ltYWxzAAgJAGkCBQdfYW1vdW50AGQDCQAAAgUOc291cmNlRGVjaW1hbHMABgUHX2Ftb3VudAkAAgECGUludmFsaWQgZGVjaW1hbHMgKHNvdXJjZSkECnNlbGxNYXJrZXQJAQlnZXRNYXJrZXQBBQhfYXNzZXRJZAQCczEJAPwHBAUKc2VsbE1hcmtldAILc3dhcFRvUXVvdGUJAMwIAgUZc291cmNlQW1vdW50SW5BbW1EZWNpbWFscwkAzAgCAAAFA25pbAUDbmlsAwkAAAIFAnMxBQJzMQQJdXNkQW1vdW50BAckbWF0Y2gwBQJzMQMJAAECBQckbWF0Y2gwAgNJbnQEAXQFByRtYXRjaDAFAXQJAAIBAhpJbnZhbGlkIHN3YXBUb1F1b3RlIHJlc3VsdAQJYnV5TWFya2V0CQEJZ2V0TWFya2V0AQUMX3RhcmdldEFzc2V0BAJzMgkA/AcEBQlidXlNYXJrZXQCCnN3YXBUb0Jhc2UJAMwIAgUJdXNkQW1vdW50CQDMCAIAAAUDbmlsBQNuaWwDCQAAAgUCczIFAnMyBAx0YXJnZXRBbW91bnQEByRtYXRjaDAFAnMyAwkAAQIFByRtYXRjaDACA0ludAQBdAUHJG1hdGNoMAMJAAACBQ50YXJnZXREZWNpbWFscwAICQBoAgUBdABkAwkAAAIFDnRhcmdldERlY2ltYWxzAAYFAXQJAAIBAhlJbnZhbGlkIGRlY2ltYWxzICh0YXJnZXQpCQACAQIZSW52YWxpZCBzd2FwVG9CYXNlIHJlc3VsdAQKdmF1bHRUb0FkZAkBCGdldFZhdWx0AQUIX2Fzc2V0SWQECyR0MDcwOTY3MjYxCQETZ2V0SW1iYWxhbmNlQ29zdFVTRAQFCnZhdWx0VG9BZGQFCnNlbGxNYXJrZXQFDnNvdXJjZURlY2ltYWxzBQdfYW1vdW50BA9hZGRJbWJhbGFuY2VVU0QIBQskdDA3MDk2NzI2MQJfMQQSYWRkVmF1bHRCYWxhbmNlVVNECAULJHQwNzA5NjcyNjECXzIEDXZhdWx0VG9SZW1vdmUJAQhnZXRWYXVsdAEFDF90YXJnZXRBc3NldAQLJHQwNzMwOTc1NDUJARNnZXRJbWJhbGFuY2VDb3N0VVNEBAUNdmF1bHRUb1JlbW92ZQUJYnV5TWFya2V0BQ50YXJnZXREZWNpbWFscwkBAS0BBQx0YXJnZXRBbW91bnQEEnJlbW92ZUltYmFsYW5jZVVTRAgFCyR0MDczMDk3NTQ1Al8xBBVyZW1vdmVWYXVsdEJhbGFuY2VVU0QIBQskdDA3MzA5NzU0NQJfMgQUcmVzdWx0SW1iYWxhbmNlSW5VU0QJAGQCBQ9hZGRJbWJhbGFuY2VVU0QFEnJlbW92ZUltYmFsYW5jZVVTRAQHYmFzZUZlZQkBA2ZlZQAEC3RvdGFsTGlxdWlkCQBkAgUSYWRkVmF1bHRCYWxhbmNlVVNEBRVyZW1vdmVWYXVsdEJhbGFuY2VVU0QECyR0MDc2OTk4MTgyAwkAZgIAAAUUcmVzdWx0SW1iYWxhbmNlSW5VU0QECnJlYmF0ZVJhdGUJAQRkaXZkAgkBA2FicwEFFHJlc3VsdEltYmFsYW5jZUluVVNEBQt0b3RhbExpcXVpZAQGcmViYXRlCQEEbXVsZAIJAQlmZWVSZWJhdGUABQpyZWJhdGVSYXRlBAlhY3R1YWxGZWUDCQBmAgUGcmViYXRlBQdiYXNlRmVlAAAJAGUCBQdiYXNlRmVlBQZyZWJhdGUJAJUKAwUJYWN0dWFsRmVlBQZyZWJhdGUAAAQHdGF4UmF0ZQkBBGRpdmQCCQEDYWJzAQUUcmVzdWx0SW1iYWxhbmNlSW5VU0QFC3RvdGFsTGlxdWlkBAN0YXgJAQRtdWxkAgkBCWZlZVJlYmF0ZQAFB3RheFJhdGUECWFjdHVhbEZlZQkAZAIFB2Jhc2VGZWUFA3RheAkAlQoDBQlhY3R1YWxGZWUAAAUDdGF4BAlhY3R1YWxGZWUIBQskdDA3Njk5ODE4MgJfMQQGcmViYXRlCAULJHQwNzY5OTgxODICXzIEA3RheAgFCyR0MDc2OTk4MTgyAl8zBBBmZWVJblRhcmdldFRva2VuCQEEbXVsZAIFDHRhcmdldEFtb3VudAUJYWN0dWFsRmVlBBdyZXN1bHRUYXJnZXRBc3NldEFtb3VudAkAZQIFDHRhcmdldEFtb3VudAUQZmVlSW5UYXJnZXRUb2tlbgkAnwoNBQx0YXJnZXRBbW91bnQFEGZlZUluVGFyZ2V0VG9rZW4FF3Jlc3VsdFRhcmdldEFzc2V0QW1vdW50BQdiYXNlRmVlBQlhY3R1YWxGZWUFBnJlYmF0ZQUDdGF4BQ12YXVsdFRvUmVtb3ZlBQp2YXVsdFRvQWRkBQ9hZGRJbWJhbGFuY2VVU0QFEmFkZFZhdWx0QmFsYW5jZVVTRAUScmVtb3ZlSW1iYWxhbmNlVVNEBRVyZW1vdmVWYXVsdEJhbGFuY2VVU0QJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BGmVzdGltYXRlUHJvamVjdGVkTGlxdWlkaXR5AwZfdmF1bHQEX2FtbQdfY2hhbmdlBAx2YXVsdFJlc2VydmUJAGQCCQBpAgkBDmdldEZyZWVCYWxhbmNlAQUGX3ZhdWx0AGQJAGkCBQdfY2hhbmdlAGQEEHZhdWx0VXRpbGl6YXRpb24JAGkCCQERZ2V0TWF4VXRpbGl6YXRpb24BBQZfdmF1bHQAZAQObWF4UHJpY2VTcHJlYWQJARFnZXRNYXhQcmljZVNwcmVhZAEFBF9hbW0EGmFjdHVhbExpcXVpZGl0eUluQmFzZUFzc2V0CQEEbXVsZAIFDHZhdWx0UmVzZXJ2ZQUQdmF1bHRVdGlsaXphdGlvbgQSbmV3QmFzZUFzc2V0QW1vdW50CQEEZGl2ZAIJAGUCBRphY3R1YWxMaXF1aWRpdHlJbkJhc2VBc3NldAkBBG11bGQCBQ5tYXhQcmljZVNwcmVhZAUaYWN0dWFsTGlxdWlkaXR5SW5CYXNlQXNzZXQFDm1heFByaWNlU3ByZWFkBAskdDA5MDY3OTE1MwkBKGdldE9sZFByb2plY3RlZExpcXVpZGl0eUFuZFRlcm1pbmFsUHJpY2UBBQRfYW1tAwkAAAIFCyR0MDkwNjc5MTUzBQskdDA5MDY3OTE1MwQBcQgFCyR0MDkwNjc5MTUzAl8zBAVwcmljZQgFCyR0MDkwNjc5MTUzAl8yBBJvbGRCYXNlQXNzZXRBbW91bnQIBQskdDA5MDY3OTE1MwJfMQQUYmFzZUFzc2V0QW1vdW50RGVsdGEJAGUCBRJuZXdCYXNlQXNzZXRBbW91bnQFEm9sZEJhc2VBc3NldEFtb3VudAQQcXVvdGVBc3NldENoYW5nZQkBBGRpdmQCCQEEbXVsZAIFFGJhc2VBc3NldEFtb3VudERlbHRhBQVwcmljZQUBcQkAlAoCBRRiYXNlQXNzZXRBbW91bnREZWx0YQUQcXVvdGVBc3NldENoYW5nZQkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgELaW5pdGlhbGl6ZWQACQELdmFsdWVPckVsc2UCCQCbCAIFBHRoaXMFDWtfaW5pdGlhbGl6ZWQHAQ51cGRhdGVTZXR0aW5ncwIEX2ZlZQdfcmViYXRlCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQVrX2ZlZQUEX2ZlZQkAzAgCCQEMSW50ZWdlckVudHJ5AgUIa19yZWJhdGUFB19yZWJhdGUFA25pbAoBaQEFcGF1c2UAAwkBAiE9AggFAWkGY2FsbGVyCQEMYWRtaW5BZGRyZXNzAAkAAgECFEludmFsaWQgcGF1c2UgcGFyYW1zCQDMCAIJAQxCb29sZWFuRW50cnkCBQhrX3BhdXNlZAYFA25pbAFpAQd1bnBhdXNlAAMJAQIhPQIIBQFpBmNhbGxlcgkBDGFkbWluQWRkcmVzcwAJAAIBAhZJbnZhbGlkIHVucGF1c2UgcGFyYW1zCQDMCAIJAQxCb29sZWFuRW50cnkCBQhrX3BhdXNlZAcFA25pbAFpAQ5jaGFuZ2VTZXR0aW5ncwIEX2ZlZQdfcmViYXRlAwMDAwkAZwIAAAUEX2ZlZQYJAGcCAAAFB19yZWJhdGUGCQEBIQEJAQtpbml0aWFsaXplZAAGCQECIT0CCAUBaQZjYWxsZXIJAQxhZG1pbkFkZHJlc3MACQACAQIdSW52YWxpZCBjaGFuZ2VTZXR0aW5ncyBwYXJhbXMJAQ51cGRhdGVTZXR0aW5ncwIFBF9mZWUFB19yZWJhdGUBaQEGYWRkQW1tBAtfYW1tQWRkcmVzcw1fdmF1bHRBZGRyZXNzC192YXVsdEFzc2V0BV9kYXRhAwkBAiE9AggFAWkGY2FsbGVyCQEMYWRtaW5BZGRyZXNzAAkAAgECFUludmFsaWQgYWRkQW1tIHBhcmFtcwQKYW1tQWRkcmVzcwkBEWdldEFkZHJlc3NJZlZhbGlkAQULX2FtbUFkZHJlc3MDCQAAAgUKYW1tQWRkcmVzcwUKYW1tQWRkcmVzcwQMdmF1bHRBZGRyZXNzCQERZ2V0QWRkcmVzc0lmVmFsaWQBBQ1fdmF1bHRBZGRyZXNzAwkAAAIFDHZhdWx0QWRkcmVzcwUMdmF1bHRBZGRyZXNzCQDMCAIJAQxCb29sZWFuRW50cnkCCQEOdG9Db21wb3NpdGVLZXkCBQVrX2FtbQULX2FtbUFkZHJlc3MGCQDMCAIJAQxCb29sZWFuRW50cnkCCQEOdG9Db21wb3NpdGVLZXkCBQdrX3ZhdWx0BQ1fdmF1bHRBZGRyZXNzBgkAzAgCCQELU3RyaW5nRW50cnkCCQEOdG9Db21wb3NpdGVLZXkCBQ1rX2Fzc2V0X3ZhdWx0BQtfdmF1bHRBc3NldAUNX3ZhdWx0QWRkcmVzcwkAzAgCCQELU3RyaW5nRW50cnkCCQEOdG9Db21wb3NpdGVLZXkCBQtrX2Fzc2V0X2FtbQULX3ZhdWx0QXNzZXQFC19hbW1BZGRyZXNzCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQ50b0NvbXBvc2l0ZUtleQIFCmtfYW1tX2RhdGEFC19hbW1BZGRyZXNzBQVfZGF0YQUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBCXJlbW92ZUFtbQELX2FtbUFkZHJlc3MDCQECIT0CCAUBaQZjYWxsZXIJAQxhZG1pbkFkZHJlc3MACQACAQIYSW52YWxpZCByZW1vdmVBbW0gcGFyYW1zCQDMCAIJAQtEZWxldGVFbnRyeQEJAQ50b0NvbXBvc2l0ZUtleQIFBWtfYW1tBQtfYW1tQWRkcmVzcwUDbmlsAWkBCmluaXRpYWxpemUDDF9jb29yZGluYXRvcgRfZmVlB19yZWJhdGUDAwMDCQBnAgAABQRfZmVlBgkAZwIAAAUHX3JlYmF0ZQYJAQtpbml0aWFsaXplZAAGCQECIT0CCAUBaQZjYWxsZXIFBHRoaXMJAAIBAh1JbnZhbGlkIGluaXRpYWxpemUgcGFyYW1ldGVycwkAzggCCQEOdXBkYXRlU2V0dGluZ3MCBQRfZmVlBQdfcmViYXRlCQDMCAIJAQxCb29sZWFuRW50cnkCBQ1rX2luaXRpYWxpemVkBgkAzAgCCQELU3RyaW5nRW50cnkCBRRrX2Nvb3JkaW5hdG9yQWRkcmVzcwkApQgBCQERQGV4dHJOYXRpdmUoMTA2MikBBQxfY29vcmRpbmF0b3IFA25pbAFpAQRzd2FwAgxfdGFyZ2V0QXNzZXQQX21pblRhcmdldEFtb3VudAQRY2hlY2tQYXltZW50Q291bnQDCQECIT0CCQCQAwEIBQFpCHBheW1lbnRzAAEJAAIBAiJJbnZhbGlkIHN3YXAgcGFyYW1zOiBwYXltZW50IGNvdW50BgMJAAACBRFjaGVja1BheW1lbnRDb3VudAURY2hlY2tQYXltZW50Q291bnQEB19hbW91bnQICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50BAhfYXNzZXRJZAgJAJEDAggFAWkIcGF5bWVudHMAAAdhc3NldElkBAdhc3NldElkAwkBCWlzRGVmaW5lZAEFCF9hc3NldElkCQDYBAEJAQV2YWx1ZQEFCF9hc3NldElkAgVXQVZFUwQRY2hlY2tOb3RTYW1lQXNzZXQDCQAAAgUMX3RhcmdldEFzc2V0BQdhc3NldElkCQACAQIfSW52YWxpZCBzd2FwIHBhcmFtczogc2FtZSBhc3NldAYDCQAAAgURY2hlY2tOb3RTYW1lQXNzZXQFEWNoZWNrTm90U2FtZUFzc2V0BA0kdDAxMjQ5NDEyODEzCQEMZXN0aW1hdGVTd2FwAwUHX2Ftb3VudAUHYXNzZXRJZAUMX3RhcmdldEFzc2V0AwkAAAIFDSR0MDEyNDk0MTI4MTMFDSR0MDEyNDk0MTI4MTMECnZhdWx0VG9BZGQIBQ0kdDAxMjQ5NDEyODEzAl85BA12YXVsdFRvUmVtb3ZlCAUNJHQwMTI0OTQxMjgxMwJfOAQDdGF4CAUNJHQwMTI0OTQxMjgxMwJfNwQGcmViYXRlCAUNJHQwMTI0OTQxMjgxMwJfNgQJYWN0dWFsRmVlCAUNJHQwMTI0OTQxMjgxMwJfNQQHYmFzZUZlZQgFDSR0MDEyNDk0MTI4MTMCXzQEF3Jlc3VsdFRhcmdldEFzc2V0QW1vdW50CAUNJHQwMTI0OTQxMjgxMwJfMwQQZmVlSW5UYXJnZXRUb2tlbggFDSR0MDEyNDk0MTI4MTMCXzIEDHRhcmdldEFtb3VudAgFDSR0MDEyNDk0MTI4MTMCXzEECWRvRGVwb3NpdAkA/AcEBQp2YXVsdFRvQWRkAgVyZXBheQUDbmlsCQDMCAIJAJEDAggFAWkIcGF5bWVudHMAAAUDbmlsAwkAAAIFCWRvRGVwb3NpdAUJZG9EZXBvc2l0BApkb1dpdGhkcmF3CQD8BwQFDXZhdWx0VG9SZW1vdmUCBmJvcnJvdwkAzAgCBQx0YXJnZXRBbW91bnQFA25pbAUDbmlsAwkAAAIFCmRvV2l0aGRyYXcFCmRvV2l0aGRyYXcEC3RhcmdldEFzc2V0AwkAAAIFDF90YXJnZXRBc3NldAIFV0FWRVMFBHVuaXQJANkEAQUMX3RhcmdldEFzc2V0BAxkb0NvbGxlY3RGZWUJAPwHBAUNdmF1bHRUb1JlbW92ZQIHYWRkRnJlZQUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQt0YXJnZXRBc3NldAUQZmVlSW5UYXJnZXRUb2tlbgUDbmlsAwkAAAIFDGRvQ29sbGVjdEZlZQUMZG9Db2xsZWN0RmVlAwkAZgIFEF9taW5UYXJnZXRBbW91bnQFF3Jlc3VsdFRhcmdldEFzc2V0QW1vdW50CQACAQkArAICCQCsAgIJAKwCAgIeQ2FuIG5vdCBzd2FwIGR1ZSB0byBzbGlwcGFnZTogCQCkAwEFF3Jlc3VsdFRhcmdldEFzc2V0QW1vdW50AgMgPCAJAKQDAQUQX21pblRhcmdldEFtb3VudAkAlAoCCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQFpBmNhbGxlcgUXcmVzdWx0VGFyZ2V0QXNzZXRBbW91bnQFC3RhcmdldEFzc2V0BQNuaWwJAJgKBgUHX2Ftb3VudAUXcmVzdWx0VGFyZ2V0QXNzZXRBbW91bnQFB2Jhc2VGZWUFCWFjdHVhbEZlZQUGcmViYXRlBQN0YXgJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEYbm90aWZ5VmF1bHRCYWxhbmNlQ2hhbmdlAgZfYXNzZXQHX2NoYW5nZQQGbWFya2V0CQEOZ2V0TWFya2V0TWF5YmUBBQZfYXNzZXQEBXZhdWx0CQENZ2V0VmF1bHRNYXliZQEFBl9hc3NldAMDCQEJaXNEZWZpbmVkAQUGbWFya2V0CQEJaXNEZWZpbmVkAQUFdmF1bHQHAwkBAiE9AggFAWkGY2FsbGVyBQV2YXVsdAkAAgECJ0ludmFsaWQgbm90aWZ5VmF1bHRCYWxhbmNlQ2hhbmdlIHBhcmFtcwQNJHQwMTQwMzQxNDE1MAkBGmVzdGltYXRlUHJvamVjdGVkTGlxdWlkaXR5AwkBBXZhbHVlAQUFdmF1bHQJAQV2YWx1ZQEFBm1hcmtldAUHX2NoYW5nZQMJAAACBQ0kdDAxNDAzNDE0MTUwBQ0kdDAxNDAzNDE0MTUwBBBxdW90ZUFzc2V0Q2hhbmdlCAUNJHQwMTQwMzQxNDE1MAJfMgQUYmFzZUFzc2V0QW1vdW50RGVsdGEIBQ0kdDAxNDAzNDE0MTUwAl8xBAZyZXN1bHQJAPwHBAkBBXZhbHVlAQUGbWFya2V0Ag9jaGFuZ2VMaXF1aWRpdHkJAMwIAgUQcXVvdGVBc3NldENoYW5nZQUDbmlsBQNuaWwDCQAAAgUGcmVzdWx0BQZyZXN1bHQFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgUDbmlsAWkBH3ZpZXdfZXN0aW1hdGVQcm9qZWN0ZWRMaXF1aWRpdHkCBl9hc3NldAdfY2hhbmdlBAZtYXJrZXQJAQlnZXRNYXJrZXQBBQZfYXNzZXQEBXZhdWx0CQEIZ2V0VmF1bHQBBQZfYXNzZXQEDSR0MDE0NDM4MTQ1MzgJARplc3RpbWF0ZVByb2plY3RlZExpcXVpZGl0eQMFBXZhdWx0BQZtYXJrZXQFB19jaGFuZ2UDCQAAAgUNJHQwMTQ0MzgxNDUzOAUNJHQwMTQ0MzgxNDUzOAQQcXVvdGVBc3NldENoYW5nZQgFDSR0MDE0NDM4MTQ1MzgCXzIEFGJhc2VBc3NldEFtb3VudERlbHRhCAUNJHQwMTQ0MzgxNDUzOAJfMQQEZGF0YQkAuQkCCQDMCAIJAKQDAQUUYmFzZUFzc2V0QW1vdW50RGVsdGEJAMwIAgkApAMBBRBxdW90ZUFzc2V0Q2hhbmdlBQNuaWwCASwJAAIBBQRkYXRhCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBEXZpZXdfZXN0aW1hdGVTd2FwAw1fc291cmNlQW1vdW50DF9zb3VyY2VBc3NldAxfdGFyZ2V0QXNzZXQEDSR0MDE0NzgxMTUxMDYJAQxlc3RpbWF0ZVN3YXADBQ1fc291cmNlQW1vdW50BQxfc291cmNlQXNzZXQFDF90YXJnZXRBc3NldAMJAAACBQ0kdDAxNDc4MTE1MTA2BQ0kdDAxNDc4MTE1MTA2BBVyZW1vdmVWYXVsdEJhbGFuY2VVU0QIBQ0kdDAxNDc4MTE1MTA2A18xMwQScmVtb3ZlSW1iYWxhbmNlVVNECAUNJHQwMTQ3ODExNTEwNgNfMTIEEmFkZFZhdWx0QmFsYW5jZVVTRAgFDSR0MDE0NzgxMTUxMDYDXzExBA9hZGRJbWJhbGFuY2VVU0QIBQ0kdDAxNDc4MTE1MTA2A18xMAQKdmF1bHRUb0FkZAgFDSR0MDE0NzgxMTUxMDYCXzkEDXZhdWx0VG9SZW1vdmUIBQ0kdDAxNDc4MTE1MTA2Al84BAN0YXgIBQ0kdDAxNDc4MTE1MTA2Al83BAZyZWJhdGUIBQ0kdDAxNDc4MTE1MTA2Al82BAlhY3R1YWxGZWUIBQ0kdDAxNDc4MTE1MTA2Al81BAdiYXNlRmVlCAUNJHQwMTQ3ODExNTEwNgJfNAQXcmVzdWx0VGFyZ2V0QXNzZXRBbW91bnQIBQ0kdDAxNDc4MTE1MTA2Al8zBBBmZWVJblRhcmdldFRva2VuCAUNJHQwMTQ3ODExNTEwNgJfMgQMdGFyZ2V0QW1vdW50CAUNJHQwMTQ3ODExNTEwNgJfMQQEZGF0YQkAuQkCCQDMCAIJAKQDAQUMdGFyZ2V0QW1vdW50CQDMCAIJAKQDAQUQZmVlSW5UYXJnZXRUb2tlbgkAzAgCCQCkAwEFF3Jlc3VsdFRhcmdldEFzc2V0QW1vdW50CQDMCAIJAKQDAQUHYmFzZUZlZQkAzAgCCQCkAwEFCWFjdHVhbEZlZQkAzAgCCQCkAwEFBnJlYmF0ZQkAzAgCCQCkAwEFA3RheAkAzAgCCQCkAwEFD2FkZEltYmFsYW5jZVVTRAkAzAgCCQCkAwEFEmFkZFZhdWx0QmFsYW5jZVVTRAkAzAgCCQCkAwEFEnJlbW92ZUltYmFsYW5jZVVTRAkAzAgCCQCkAwEFFXJlbW92ZVZhdWx0QmFsYW5jZVVTRAUDbmlsAgEsCQACAQUEZGF0YQkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgECdHgBBnZlcmlmeQAEDmNvb3JkaW5hdG9yU3RyCQCdCAIFBHRoaXMFFGtfY29vcmRpbmF0b3JBZGRyZXNzAwkBCWlzRGVmaW5lZAEFDmNvb3JkaW5hdG9yU3RyBAVhZG1pbgkAnQgCCQERQGV4dHJOYXRpdmUoMTA2MikBCQEFdmFsdWUBBQ5jb29yZGluYXRvclN0cgUPa19hZG1pbl9hZGRyZXNzAwkBCWlzRGVmaW5lZAEFBWFkbWluCQELdmFsdWVPckVsc2UCCQCbCAIJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAQV2YWx1ZQEFBWFkbWluCQCsAgIJAKwCAgkArAICAgdzdGF0dXNfCQClCAEFBHRoaXMCAV8JANgEAQgFAnR4AmlkBwkAAgECLnVuYWJsZSB0byB2ZXJpZnk6IGFkbWluIG5vdCBzZXQgaW4gY29vcmRpbmF0b3IJAPQDAwgFAnR4CWJvZHlCeXRlcwkAkQMCCAUCdHgGcHJvb2ZzAAAIBQJ0eA9zZW5kZXJQdWJsaWNLZXkxAETB",
    "height": 2592175,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: CmwuR2kWyenmUFDs9cwBVzwkYLEAT532bZ5Rir33Ro38

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let k_initialized = "k_initialized"
5+
6+let k_paused = "k_paused"
7+
8+let k_fee = "k_fee"
9+
10+let k_rebate = "k_rebate"
11+
12+let k_coordinatorAddress = "k_coordinatorAddress"
13+
14+let k_excessBalance = "k_excessBalance"
15+
16+let k_freeBalance = "k_freeBalance"
17+
18+let k_maxSpotUtilization = "k_maxSpotUtilization"
19+
20+let k_maxPriceSpread = "k_maxPriceSpread"
21+
22+let k_baseAssetReserve = "k_bsAstR"
23+
24+let k_quoteAssetWeight = "k_qtAstW"
25+
26+let k_totalPositionSize = "k_totalPositionSize"
27+
28+let k_amm = "k_amm"
29+
30+let k_vault = "k_vault"
31+
32+let k_amm_data = "k_amm_data"
33+
34+let k_asset_vault = "k_asset_vault"
35+
36+let k_asset_amm = "k_asset_amm"
37+
38+let k_admin_address = "k_admin_address"
39+
40+func toCompositeKey (_key,_address) = ((_key + "_") + _address)
41+
42+
43+func coordinator () = valueOrErrorMessage(addressFromString(getStringValue(this, k_coordinatorAddress)), "Coordinator not set")
44+
45+
46+func adminAddress () = addressFromString(getStringValue(coordinator(), k_admin_address))
47+
48+
49+func getAddressIfValid (address) = toString(valueOrErrorMessage(addressFromString(address), (("Can't parse \"" + address) + "\" as address")))
50+
51+
52+let DECIMAL_NUMBERS = 6
53+
54+let DECIMAL_UNIT = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
55+
56+func s (_x) = (toString(_x) + ",")
57+
58+
59+func divd (_x,_y) = fraction(_x, DECIMAL_UNIT, _y, HALFEVEN)
60+
61+
62+func muld (_x,_y) = fraction(_x, _y, DECIMAL_UNIT, HALFEVEN)
63+
64+
65+func abs (_x) = if ((_x > 0))
66+    then _x
67+    else -(_x)
68+
69+
70+func vmax (_x,_y) = if ((_x >= _y))
71+    then _x
72+    else _y
73+
74+
75+func vmin (_x,_y) = if ((_y >= _x))
76+    then _x
77+    else _y
78+
79+
80+func int (k) = valueOrErrorMessage(getInteger(this, k), ("no value for " + k))
81+
82+
83+func fee () = int(k_fee)
84+
85+
86+func feeRebate () = int(k_rebate)
87+
88+
89+func getMarketMaybe (_assetId) = {
90+    let addressStr = getString(this, toCompositeKey(k_asset_amm, _assetId))
91+    if (isDefined(addressStr))
92+        then valueOrErrorMessage(addressFromString(value(addressStr)), ("Invalid vault address for: " + _assetId))
93+        else unit
94+    }
95+
96+
97+func getVaultMaybe (_assetId) = {
98+    let addressStr = getString(this, toCompositeKey(k_asset_vault, _assetId))
99+    if (isDefined(addressStr))
100+        then valueOrErrorMessage(addressFromString(value(addressStr)), ("Invalid market address for: " + _assetId))
101+        else unit
102+    }
103+
104+
105+func getMarket (_assetId) = valueOrErrorMessage(getMarketMaybe(_assetId), ("No market for: " + _assetId))
106+
107+
108+func getVault (_assetId) = valueOrErrorMessage(getVaultMaybe(_assetId), ("No vault for: " + _assetId))
109+
110+
111+func getExcessBalance (_vault) = valueOrElse(getInteger(_vault, k_excessBalance), 0)
112+
113+
114+func getFreeBalance (_vault) = valueOrElse(getInteger(_vault, k_freeBalance), 0)
115+
116+
117+func getMaxUtilization (_vault) = valueOrErrorMessage(getInteger(_vault, k_maxSpotUtilization), ("Max spot utilization not set for: " + toString(_vault)))
118+
119+
120+func getMaxPriceSpread (_amm) = valueOrErrorMessage(getInteger(_amm, k_maxPriceSpread), ("Max price spread not set for: " + toString(_amm)))
121+
122+
123+func getOldProjectedLiquidityAndTerminalPrice (_amm) = {
124+    let sync = invoke(_amm, "syncTerminalPriceToOracle", nil, nil)
125+    if ((sync == sync))
126+        then {
127+            let priceR = invoke(_amm, "computeTerminalAmmPrice", nil, nil)
128+            if ((priceR == priceR))
129+                then {
130+                    let price =                     match priceR {
131+                        case t: Int => 
132+                            t
133+                        case _ => 
134+                            throw(("Invalid computeTerminalAmmPrice result for " + toString(_amm)))
135+                    }
136+                    let currentBaseAssetAmount = valueOrErrorMessage(getInteger(_amm, k_baseAssetReserve), ((("Key " + k_baseAssetReserve) + " not set for ") + toString(_amm)))
137+                    if ((currentBaseAssetAmount == currentBaseAssetAmount))
138+                        then {
139+                            let baseAssetAmountDelta = valueOrElse(getInteger(_amm, k_totalPositionSize), 0)
140+                            if ((baseAssetAmountDelta == baseAssetAmountDelta))
141+                                then {
142+                                    let quoteAssetWeight = valueOrElse(getInteger(_amm, k_quoteAssetWeight), DECIMAL_UNIT)
143+                                    if ((quoteAssetWeight == quoteAssetWeight))
144+                                        then $Tuple3((currentBaseAssetAmount + baseAssetAmountDelta), price, quoteAssetWeight)
145+                                        else throw("Strict value is not equal to itself.")
146+                                    }
147+                                else throw("Strict value is not equal to itself.")
148+                            }
149+                        else throw("Strict value is not equal to itself.")
150+                    }
151+                else throw("Strict value is not equal to itself.")
152+            }
153+        else throw("Strict value is not equal to itself.")
154+    }
155+
156+
157+func getImbalanceCostUSD (_vault,_amm,_decimals,_amount) = {
158+    let amount = if ((_decimals == 8))
159+        then _amount
160+        else if ((_decimals == 6))
161+            then (_amount * 100)
162+            else throw("Invalid decimals")
163+    let oldImbalance = getExcessBalance(_vault)
164+    let newImbalance = (oldImbalance + amount)
165+    let imbalanceDeltaInAmmDecimals = ((abs(newImbalance) - abs(oldImbalance)) / 100)
166+    let priceR = invoke(_amm, "computeSpotPrice", nil, nil)
167+    if ((priceR == priceR))
168+        then {
169+            let price =             match priceR {
170+                case t: Int => 
171+                    t
172+                case _ => 
173+                    throw(("Invalid computeSpotPrice result for " + toString(_amm)))
174+            }
175+            let imbalanceDeltaInUSD = muld(imbalanceDeltaInAmmDecimals, price)
176+            let freeBalanceInAmmDecimal = (getFreeBalance(_vault) / 100)
177+            let vaultBalanceInUSD = muld(freeBalanceInAmmDecimal, price)
178+            $Tuple2(imbalanceDeltaInUSD, vaultBalanceInUSD)
179+            }
180+        else throw("Strict value is not equal to itself.")
181+    }
182+
183+
184+func estimateSwap (_amount,_assetId,_targetAsset) = {
185+    let sourceDecimals = if ((_assetId == "WAVES"))
186+        then 8
187+        else valueOrErrorMessage(assetInfo(fromBase58String(_assetId)), ("Invalid asset: " + _assetId)).decimals
188+    let targetDecimals = if ((_targetAsset == "WAVES"))
189+        then 8
190+        else valueOrErrorMessage(assetInfo(fromBase58String(_targetAsset)), ("Invalid asset: " + _targetAsset)).decimals
191+    let sourceAmountInAmmDecimals = if ((sourceDecimals == 8))
192+        then (_amount / 100)
193+        else if ((sourceDecimals == 6))
194+            then _amount
195+            else throw("Invalid decimals (source)")
196+    let sellMarket = getMarket(_assetId)
197+    let s1 = invoke(sellMarket, "swapToQuote", [sourceAmountInAmmDecimals, 0], nil)
198+    if ((s1 == s1))
199+        then {
200+            let usdAmount =             match s1 {
201+                case t: Int => 
202+                    t
203+                case _ => 
204+                    throw("Invalid swapToQuote result")
205+            }
206+            let buyMarket = getMarket(_targetAsset)
207+            let s2 = invoke(buyMarket, "swapToBase", [usdAmount, 0], nil)
208+            if ((s2 == s2))
209+                then {
210+                    let targetAmount =                     match s2 {
211+                        case t: Int => 
212+                            if ((targetDecimals == 8))
213+                                then (t * 100)
214+                                else if ((targetDecimals == 6))
215+                                    then t
216+                                    else throw("Invalid decimals (target)")
217+                        case _ => 
218+                            throw("Invalid swapToBase result")
219+                    }
220+                    let vaultToAdd = getVault(_assetId)
221+                    let $t070967261 = getImbalanceCostUSD(vaultToAdd, sellMarket, sourceDecimals, _amount)
222+                    let addImbalanceUSD = $t070967261._1
223+                    let addVaultBalanceUSD = $t070967261._2
224+                    let vaultToRemove = getVault(_targetAsset)
225+                    let $t073097545 = getImbalanceCostUSD(vaultToRemove, buyMarket, targetDecimals, -(targetAmount))
226+                    let removeImbalanceUSD = $t073097545._1
227+                    let removeVaultBalanceUSD = $t073097545._2
228+                    let resultImbalanceInUSD = (addImbalanceUSD + removeImbalanceUSD)
229+                    let baseFee = fee()
230+                    let totalLiquid = (addVaultBalanceUSD + removeVaultBalanceUSD)
231+                    let $t076998182 = if ((0 > resultImbalanceInUSD))
232+                        then {
233+                            let rebateRate = divd(abs(resultImbalanceInUSD), totalLiquid)
234+                            let rebate = muld(feeRebate(), rebateRate)
235+                            let actualFee = if ((rebate > baseFee))
236+                                then 0
237+                                else (baseFee - rebate)
238+                            $Tuple3(actualFee, rebate, 0)
239+                            }
240+                        else {
241+                            let taxRate = divd(abs(resultImbalanceInUSD), totalLiquid)
242+                            let tax = muld(feeRebate(), taxRate)
243+                            let actualFee = (baseFee + tax)
244+                            $Tuple3(actualFee, 0, tax)
245+                            }
246+                    let actualFee = $t076998182._1
247+                    let rebate = $t076998182._2
248+                    let tax = $t076998182._3
249+                    let feeInTargetToken = muld(targetAmount, actualFee)
250+                    let resultTargetAssetAmount = (targetAmount - feeInTargetToken)
251+                    $Tuple13(targetAmount, feeInTargetToken, resultTargetAssetAmount, baseFee, actualFee, rebate, tax, vaultToRemove, vaultToAdd, addImbalanceUSD, addVaultBalanceUSD, removeImbalanceUSD, removeVaultBalanceUSD)
252+                    }
253+                else throw("Strict value is not equal to itself.")
254+            }
255+        else throw("Strict value is not equal to itself.")
256+    }
257+
258+
259+func estimateProjectedLiquidity (_vault,_amm,_change) = {
260+    let vaultReserve = ((getFreeBalance(_vault) / 100) + (_change / 100))
261+    let vaultUtilization = (getMaxUtilization(_vault) / 100)
262+    let maxPriceSpread = getMaxPriceSpread(_amm)
263+    let actualLiquidityInBaseAsset = muld(vaultReserve, vaultUtilization)
264+    let newBaseAssetAmount = divd((actualLiquidityInBaseAsset - muld(maxPriceSpread, actualLiquidityInBaseAsset)), maxPriceSpread)
265+    let $t090679153 = getOldProjectedLiquidityAndTerminalPrice(_amm)
266+    if (($t090679153 == $t090679153))
267+        then {
268+            let q = $t090679153._3
269+            let price = $t090679153._2
270+            let oldBaseAssetAmount = $t090679153._1
271+            let baseAssetAmountDelta = (newBaseAssetAmount - oldBaseAssetAmount)
272+            let quoteAssetChange = divd(muld(baseAssetAmountDelta, price), q)
273+            $Tuple2(baseAssetAmountDelta, quoteAssetChange)
274+            }
275+        else throw("Strict value is not equal to itself.")
276+    }
277+
278+
279+func initialized () = valueOrElse(getBoolean(this, k_initialized), false)
280+
281+
282+func updateSettings (_fee,_rebate) = [IntegerEntry(k_fee, _fee), IntegerEntry(k_rebate, _rebate)]
283+
284+
285+@Callable(i)
286+func pause () = if ((i.caller != adminAddress()))
287+    then throw("Invalid pause params")
288+    else [BooleanEntry(k_paused, true)]
289+
290+
291+
292+@Callable(i)
293+func unpause () = if ((i.caller != adminAddress()))
294+    then throw("Invalid unpause params")
295+    else [BooleanEntry(k_paused, false)]
296+
297+
298+
299+@Callable(i)
300+func changeSettings (_fee,_rebate) = if (if (if (if ((0 >= _fee))
301+    then true
302+    else (0 >= _rebate))
303+    then true
304+    else !(initialized()))
305+    then true
306+    else (i.caller != adminAddress()))
307+    then throw("Invalid changeSettings params")
308+    else updateSettings(_fee, _rebate)
309+
310+
311+
312+@Callable(i)
313+func addAmm (_ammAddress,_vaultAddress,_vaultAsset,_data) = if ((i.caller != adminAddress()))
314+    then throw("Invalid addAmm params")
315+    else {
316+        let ammAddress = getAddressIfValid(_ammAddress)
317+        if ((ammAddress == ammAddress))
318+            then {
319+                let vaultAddress = getAddressIfValid(_vaultAddress)
320+                if ((vaultAddress == vaultAddress))
321+                    then [BooleanEntry(toCompositeKey(k_amm, _ammAddress), true), BooleanEntry(toCompositeKey(k_vault, _vaultAddress), true), StringEntry(toCompositeKey(k_asset_vault, _vaultAsset), _vaultAddress), StringEntry(toCompositeKey(k_asset_amm, _vaultAsset), _ammAddress), StringEntry(toCompositeKey(k_amm_data, _ammAddress), _data)]
322+                    else throw("Strict value is not equal to itself.")
323+                }
324+            else throw("Strict value is not equal to itself.")
325+        }
326+
327+
328+
329+@Callable(i)
330+func removeAmm (_ammAddress) = if ((i.caller != adminAddress()))
331+    then throw("Invalid removeAmm params")
332+    else [DeleteEntry(toCompositeKey(k_amm, _ammAddress))]
333+
334+
335+
336+@Callable(i)
337+func initialize (_coordinator,_fee,_rebate) = if (if (if (if ((0 >= _fee))
338+    then true
339+    else (0 >= _rebate))
340+    then true
341+    else initialized())
342+    then true
343+    else (i.caller != this))
344+    then throw("Invalid initialize parameters")
345+    else (updateSettings(_fee, _rebate) ++ [BooleanEntry(k_initialized, true), StringEntry(k_coordinatorAddress, toString(addressFromStringValue(_coordinator)))])
346+
347+
348+
349+@Callable(i)
350+func swap (_targetAsset,_minTargetAmount) = {
351+    let checkPaymentCount = if ((size(i.payments) != 1))
352+        then throw("Invalid swap params: payment count")
353+        else true
354+    if ((checkPaymentCount == checkPaymentCount))
355+        then {
356+            let _amount = i.payments[0].amount
357+            let _assetId = i.payments[0].assetId
358+            let assetId = if (isDefined(_assetId))
359+                then toBase58String(value(_assetId))
360+                else "WAVES"
361+            let checkNotSameAsset = if ((_targetAsset == assetId))
362+                then throw("Invalid swap params: same asset")
363+                else true
364+            if ((checkNotSameAsset == checkNotSameAsset))
365+                then {
366+                    let $t01249412813 = estimateSwap(_amount, assetId, _targetAsset)
367+                    if (($t01249412813 == $t01249412813))
368+                        then {
369+                            let vaultToAdd = $t01249412813._9
370+                            let vaultToRemove = $t01249412813._8
371+                            let tax = $t01249412813._7
372+                            let rebate = $t01249412813._6
373+                            let actualFee = $t01249412813._5
374+                            let baseFee = $t01249412813._4
375+                            let resultTargetAssetAmount = $t01249412813._3
376+                            let feeInTargetToken = $t01249412813._2
377+                            let targetAmount = $t01249412813._1
378+                            let doDeposit = invoke(vaultToAdd, "repay", nil, [i.payments[0]])
379+                            if ((doDeposit == doDeposit))
380+                                then {
381+                                    let doWithdraw = invoke(vaultToRemove, "borrow", [targetAmount], nil)
382+                                    if ((doWithdraw == doWithdraw))
383+                                        then {
384+                                            let targetAsset = if ((_targetAsset == "WAVES"))
385+                                                then unit
386+                                                else fromBase58String(_targetAsset)
387+                                            let doCollectFee = invoke(vaultToRemove, "addFree", nil, [AttachedPayment(targetAsset, feeInTargetToken)])
388+                                            if ((doCollectFee == doCollectFee))
389+                                                then if ((_minTargetAmount > resultTargetAssetAmount))
390+                                                    then throw(((("Can not swap due to slippage: " + toString(resultTargetAssetAmount)) + " < ") + toString(_minTargetAmount)))
391+                                                    else $Tuple2([ScriptTransfer(i.caller, resultTargetAssetAmount, targetAsset)], $Tuple6(_amount, resultTargetAssetAmount, baseFee, actualFee, rebate, tax))
392+                                                else throw("Strict value is not equal to itself.")
393+                                            }
394+                                        else throw("Strict value is not equal to itself.")
395+                                    }
396+                                else throw("Strict value is not equal to itself.")
397+                            }
398+                        else throw("Strict value is not equal to itself.")
399+                    }
400+                else throw("Strict value is not equal to itself.")
401+            }
402+        else throw("Strict value is not equal to itself.")
403+    }
404+
405+
406+
407+@Callable(i)
408+func notifyVaultBalanceChange (_asset,_change) = {
409+    let market = getMarketMaybe(_asset)
410+    let vault = getVaultMaybe(_asset)
411+    if (if (isDefined(market))
412+        then isDefined(vault)
413+        else false)
414+        then if ((i.caller != vault))
415+            then throw("Invalid notifyVaultBalanceChange params")
416+            else {
417+                let $t01403414150 = estimateProjectedLiquidity(value(vault), value(market), _change)
418+                if (($t01403414150 == $t01403414150))
419+                    then {
420+                        let quoteAssetChange = $t01403414150._2
421+                        let baseAssetAmountDelta = $t01403414150._1
422+                        let result = invoke(value(market), "changeLiquidity", [quoteAssetChange], nil)
423+                        if ((result == result))
424+                            then nil
425+                            else throw("Strict value is not equal to itself.")
426+                        }
427+                    else throw("Strict value is not equal to itself.")
428+                }
429+        else nil
430+    }
431+
432+
433+
434+@Callable(i)
435+func view_estimateProjectedLiquidity (_asset,_change) = {
436+    let market = getMarket(_asset)
437+    let vault = getVault(_asset)
438+    let $t01443814538 = estimateProjectedLiquidity(vault, market, _change)
439+    if (($t01443814538 == $t01443814538))
440+        then {
441+            let quoteAssetChange = $t01443814538._2
442+            let baseAssetAmountDelta = $t01443814538._1
443+            let data = makeString([toString(baseAssetAmountDelta), toString(quoteAssetChange)], ",")
444+            throw(data)
445+            }
446+        else throw("Strict value is not equal to itself.")
447+    }
448+
449+
450+
451+@Callable(i)
452+func view_estimateSwap (_sourceAmount,_sourceAsset,_targetAsset) = {
453+    let $t01478115106 = estimateSwap(_sourceAmount, _sourceAsset, _targetAsset)
454+    if (($t01478115106 == $t01478115106))
455+        then {
456+            let removeVaultBalanceUSD = $t01478115106._13
457+            let removeImbalanceUSD = $t01478115106._12
458+            let addVaultBalanceUSD = $t01478115106._11
459+            let addImbalanceUSD = $t01478115106._10
460+            let vaultToAdd = $t01478115106._9
461+            let vaultToRemove = $t01478115106._8
462+            let tax = $t01478115106._7
463+            let rebate = $t01478115106._6
464+            let actualFee = $t01478115106._5
465+            let baseFee = $t01478115106._4
466+            let resultTargetAssetAmount = $t01478115106._3
467+            let feeInTargetToken = $t01478115106._2
468+            let targetAmount = $t01478115106._1
469+            let data = makeString([toString(targetAmount), toString(feeInTargetToken), toString(resultTargetAssetAmount), toString(baseFee), toString(actualFee), toString(rebate), toString(tax), toString(addImbalanceUSD), toString(addVaultBalanceUSD), toString(removeImbalanceUSD), toString(removeVaultBalanceUSD)], ",")
470+            throw(data)
471+            }
472+        else throw("Strict value is not equal to itself.")
473+    }
474+
475+
476+@Verifier(tx)
477+func verify () = {
478+    let coordinatorStr = getString(this, k_coordinatorAddress)
479+    if (isDefined(coordinatorStr))
480+        then {
481+            let admin = getString(addressFromStringValue(value(coordinatorStr)), k_admin_address)
482+            if (isDefined(admin))
483+                then valueOrElse(getBoolean(addressFromStringValue(value(admin)), ((("status_" + toString(this)) + "_") + toBase58String(tx.id))), false)
484+                else throw("unable to verify: admin not set in coordinator")
485+            }
486+        else sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
487+    }
488+
github/deemru/w8io/873ac7e 
28.90 ms ◑