tx · 7Z4G6dGZiRSWzKJDxUnVRbZSh6Birgr2pQ4PN65BmMvc

3P41aTUxCrznRjxHFZJoQRtgi2LEKFsE1Aq:  -0.01400000 Waves

2023.04.12 14:20 [3596901] smart account 3P41aTUxCrznRjxHFZJoQRtgi2LEKFsE1Aq > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7Z4G6dGZiRSWzKJDxUnVRbZSh6Birgr2pQ4PN65BmMvc",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1681298429219,
    "version": 1,
    "sender": "3P41aTUxCrznRjxHFZJoQRtgi2LEKFsE1Aq",
    "senderPublicKey": "9BMNhDNwwvEfNYh1LrHm95bgeHz86L5td1CTTt6U3yCX",
    "proofs": [
        "23U4NFAsw4oQW9eojFXKJV9fwHiy5ngshJ4W1qdpbihnLNy19YX2sV8MGmDRMxzGn81pkn1Zzfoug8tNVxhke2AW"
    ],
    "script": "base64:BgIjCAISAwoBCBIGCgQICAgBEgYKBAgICAESBAoCCAgSBAoCCAgkAAtmYWN0b3JzQmFzZQDoBwEDZkNpAwV2YWx1ZQludW1lcmF0b3ILZGVub21pbmF0b3IEBGNhbmQJAGsDBQV2YWx1ZQUJbnVtZXJhdG9yBQtkZW5vbWluYXRvcgQBRACz5pOoCwQFZXhhY3QJAAACCQBqAgkAaAIJAGoCBQRjYW5kBQFECQBqAgULZGVub21pbmF0b3IFAUQFAUQJAGoCCQBoAgkAagIFBXZhbHVlBQFECQBqAgUJbnVtZXJhdG9yBQFEBQFEAwUFZXhhY3QFBGNhbmQJAGQCBQRjYW5kAAEBEHdyaXRlQ29uc3RTdHJpbmcCA2tleQV2YWx1ZQMJAQEhAQkBCWlzRGVmaW5lZAEJAJ0IAgUEdGhpcwUDa2V5CQELU3RyaW5nRW50cnkCBQNrZXkFBXZhbHVlCQACAQkArAICAhVhbHJlYWR5IGluaXRpYWxpemVkOiAFA2tleQEFYXNJbnQBBXZhbHVlBAckbWF0Y2gwBQV2YWx1ZQMJAAECBQckbWF0Y2gwAgNJbnQEA2ludAUHJG1hdGNoMAUDaW50CQACAQIEbTI6MQEGYXNJbnQzAQV2YWx1ZQQHJG1hdGNoMAUFdmFsdWUDCQABAgUHJG1hdGNoMAIPKEludCwgSW50LCBJbnQpBAF4BQckbWF0Y2gwBQF4BAF0BQckbWF0Y2gwCQACAQIBMgERYXNVc2VyQmFsYW5jZURhdGEBBXZhbHVlBAckbWF0Y2gwBQV2YWx1ZQMJAAECBQckbWF0Y2gwAiIoSW50LCBJbnQsIEludCwgSW50LCBJbnQsIEJvb2xlYW4pBAF4BQckbWF0Y2gwBQF4BAF0BQckbWF0Y2gwCQACAQIBMwALY29uZmlnU3RvcmUCBmNvbmZpZwANcmVzZXJ2ZXNTdG9yZQIIcmVzZXJ2ZXMABWFUSWRTAghhVG9rZW5JZAAEYUlkUwIHYXNzZXRJZAANY29uZmlnQWRkcmVzcwkBEUBleHRyTmF0aXZlKDEwNjIpAQkBEUBleHRyTmF0aXZlKDEwNTMpAgUEdGhpcwULY29uZmlnU3RvcmUAC3Jlc2VydmVzU3RyCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUNY29uZmlnQWRkcmVzcwIQcHJpbWFyeV9yZXNlcnZlcwIWbm8gcmVzZXJ2ZXMgcmVnaXN0ZXJlZAAIcmVzZXJ2ZXMJALwJAgULcmVzZXJ2ZXNTdHICAXwAA21WRAQHJG1hdGNoMAkAnQgCBQ1jb25maWdBZGRyZXNzAhF2aXJlc19kaXN0cmlidXRvcgMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAWQFByRtYXRjaDAJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAWQFBHVuaXQBEGFzc2V0SWRPZlJlc2VydmUBA3JzcgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCdCAIFA3JzcgUEYUlkUwIVbm8gYXNzZXRJZCBpbiByZXNlcnZlARBjb2xsYXRlcmFsRmFjdG9yAQNyc3IJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAmggCBQ1jb25maWdBZGRyZXNzCQCsAgIJARBhc3NldElkT2ZSZXNlcnZlAQUDcnNyAhFfQ29sbGF0ZXJhbEZhY3RvcgIEbm8gMQEUbGlxdWlkYXRpb25UaHJlc2hvbGQBA3JzcgkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCaCAIFDWNvbmZpZ0FkZHJlc3MJAKwCAgkBEGFzc2V0SWRPZlJlc2VydmUBBQNyc3ICFV9MaXF1aWRhdGlvblRocmVzaG9sZAIEbm8gMgESbGlxdWlkYXRpb25QZW5hbHR5AQdhc3NldElkCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUNY29uZmlnQWRkcmVzcwkArAICBQdhc3NldElkAhNfTGlxdWlkYXRpb25QZW5hbHR5AgRubyAzABZhY2NvdW50SGVhbHRoVGhyZXNob2xkCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUNY29uZmlnQWRkcmVzcwIYYWNjb3VudF9oZWFsdGhfdGhyZXNob2xkAgRubyA0ABRhY2NvdW50SGVhbHRoT3ZlcmxhcAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCaCAIFDWNvbmZpZ0FkZHJlc3MCFmFjY291bnRfaGVhbHRoX292ZXJsYXACBG5vIDUAD2NvbGxhcHNlUGVuYWx0eQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCaCAIFDWNvbmZpZ0FkZHJlc3MCEGNvbGxhcHNlX3BlbmFsdHkCBG5vIDYAC2xpcXVpZGF0b3JzCQELdmFsdWVPckVsc2UCCQCdCAIFDWNvbmZpZ0FkZHJlc3MCC2xpcXVpZGF0b3JzAgABA3ZsUgEBcgMJAQhjb250YWlucwIFC3Jlc2VydmVzU3RyBQFyCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKYIAQUBcgINbWFpbjogYmFkIHJzcgkAAgEJAKwCAgIMdW5rbm93biByc3I6BQFyAQt1c2VyQmFsYW5jZQIDcnNyBHVzZXIJARFhc1VzZXJCYWxhbmNlRGF0YQEJAPwHBAUDcnNyAgt1c2VyQmFsYW5jZQkAzAgCBQR1c2VyBQNuaWwFA25pbAAObWF5YmVQcm90ZWN0ZWQEByRtYXRjaDAJAJ0IAgUNY29uZmlnQWRkcmVzcwIRcHJvdGVjdGVkX3Jlc2VydmUDCQABAgUHJG1hdGNoMAIGU3RyaW5nBANwZHMFByRtYXRjaDAJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBBQNwZHMCDWJhZCBwcm90ZWN0ZWQFBHVuaXQBCXVzZXJQb3dlcgEEdXNlcgQQcHJvdGVjdGVkRGVwb3NpdAQHJG1hdGNoMAUObWF5YmVQcm90ZWN0ZWQDCQABAgUHJG1hdGNoMAIHQWRkcmVzcwQCcGEFByRtYXRjaDAJAQVhc0ludAEJAPwHBAUCcGECC2JvcnJvd1Bvd2VyCQDMCAIFBHVzZXIFA25pbAUDbmlsAAAKAQRmb2xkAgZ0b3RhbHMBcgQLJHQwMjkzODI5ODQFBnRvdGFscwQGdG90YWxECAULJHQwMjkzODI5ODQCXzEEBnRvdGFsQggFCyR0MDI5MzgyOTg0Al8yBA9udW1iZXJPZkJvcnJvd3MIBQskdDAyOTM4Mjk4NAJfMwQDcnNyCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKYIAQUBcgIPcnNyIGJhZCBhZGRyZXNzBAJjZgkBEGNvbGxhdGVyYWxGYWN0b3IBBQNyc3IEAmx0CQEUbGlxdWlkYXRpb25UaHJlc2hvbGQBBQNyc3IECyR0MDMxMzgzMjIyCQELdXNlckJhbGFuY2UCBQNyc3IFBHVzZXIEBXRva2VuCAULJHQwMzEzODMyMjICXzEEBWFzc2V0CAULJHQwMzEzODMyMjICXzIECmRlcG9zaXRVc2QIBQskdDAzMTM4MzIyMgJfMwQEZGVidAgFCyR0MDMxMzgzMjIyAl80BAdkZWJ0VXNkCAULJHQwMzEzODMyMjICXzUEDGFzQ29sbGF0ZXJhbAgFCyR0MDMxMzgzMjIyAl82BAx0b3RhbEJvcnJvd3MJAGQCBQ9udW1iZXJPZkJvcnJvd3MDCQBmAgUEZGVidAAAAAEAAAQTZWZmZWN0aXZlRGVwb3NpdFVzZAMFDGFzQ29sbGF0ZXJhbAUKZGVwb3NpdFVzZAAABApvdmVybGFwVXNkCQCXAwEJAMwIAgUHZGVidFVzZAkAzAgCBRNlZmZlY3RpdmVEZXBvc2l0VXNkBQNuaWwEDW92ZXJsYXBDaGFyZ2UJAQNmQ2kDBQpvdmVybGFwVXNkBRRhY2NvdW50SGVhbHRoT3ZlcmxhcAULZmFjdG9yc0Jhc2UDCQBmAgUHZGVidFVzZAUTZWZmZWN0aXZlRGVwb3NpdFVzZAkAlQoDBQZ0b3RhbEQJAGQCCQBkAgUGdG90YWxCCQBrAwkAZQIFB2RlYnRVc2QFE2VmZmVjdGl2ZURlcG9zaXRVc2QFC2ZhY3RvcnNCYXNlBQJsdAUNb3ZlcmxhcENoYXJnZQUMdG90YWxCb3Jyb3dzCQCVCgMJAGQCBQZ0b3RhbEQJAGsDCQBlAgUTZWZmZWN0aXZlRGVwb3NpdFVzZAUHZGVidFVzZAUCY2YFC2ZhY3RvcnNCYXNlCQBkAgUGdG90YWxCBQ1vdmVybGFwQ2hhcmdlBQx0b3RhbEJvcnJvd3MEAXIKAAIkbAUIcmVzZXJ2ZXMKAAIkcwkAkAMBBQIkbAoABSRhY2MwCQCVCgMFEHByb3RlY3RlZERlcG9zaXQAAAAACgEFJGYwXzECAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAQRmb2xkAgUCJGEJAJEDAgUCJGwFAiRpCgEFJGYwXzICAiRhAiRpAwkAZwIFAiRpBQIkcwUCJGEJAAIBAhRMaXN0IHNpemUgZXhjZWVkcyAyMAkBBSRmMF8yAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgkBBSRmMF8xAgUFJGFjYzAAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQABEAEgATABQDAwkAZgIFEHByb3RlY3RlZERlcG9zaXQAAAkAZgIIBQFyAl8zAAQHCQACAQIeY2FuJ3QgaGF2ZSBtb3JlIHRoYW4gNCBib3Jyb3dzBQFyAQ1nZXRVc2VySGVhbHRoAQdhY2NvdW50BAskdDAzOTc3NDAyOAkBBmFzSW50MwEJAQl1c2VyUG93ZXIBBQdhY2NvdW50BAJicAgFCyR0MDM5Nzc0MDI4Al8xBANicHUIBQskdDAzOTc3NDAyOAJfMgQGaWdub3JlCAULJHQwMzk3NzQwMjgCXzMJAKwCAgkArAICCQCsAgICA2JwOgkApAMBBQJicAIGLCBicHU6CQCkAwEFA2JwdQENdmFsaWRhdGVBZnRlcgIEdXNlcgJvcAQLJHQwNDEzOTQxNzAJAQl1c2VyUG93ZXIBBQR1c2VyBAJicAgFCyR0MDQxMzk0MTcwAl8xBANicHUIBQskdDA0MTM5NDE3MAJfMgQJYWNjSGVhbHRoCQBpAgkAaAIJAGUCBQJicAUDYnB1BQtmYWN0b3JzQmFzZQUCYnADAwkAAAIFAmJwAAAJAAACBQNicHUAAAcFA25pbAMDCQAAAgUCYnAAAAkAZgIFA2JwdQAABwkAAgEJAKwCAgkArAICBQJvcAIsOiBicmVhY2hpbmcgbGlxdWlkYXRpb24gdGhyZXNob2xkKGJwPTAsIGJwdT0JAKQDAQUDYnB1AwkAZgIFFmFjY291bnRIZWFsdGhUaHJlc2hvbGQFCWFjY0hlYWx0aAkAAgEJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgUCb3ACJTogYnJlYWNoaW5nIGxpcXVpZGF0aW9uIHRocmVzaG9sZChicD0JAKQDAQUCYnACBiwgYnB1PQkApAMBBQNicHUCCSwgaGVhbHRoPQkApAMBBQlhY2NIZWFsdGgCASkFA25pbAEMdXBkYXRlU3RyZWFtBQNyc3IGYWN0aW9uBHVzZXIKdXNlckNoYW5nZQxzdHJlYW1DaGFuZ2UEByRtYXRjaDAFA21WRAMJAAECBQckbWF0Y2gwAgdBZGRyZXNzBAFhBQckbWF0Y2gwCQD8BwQFAWECCG9uQWN0aW9uCQDMCAIFA3JzcgkAzAgCBQZhY3Rpb24JAMwIAgUEdXNlcgkAzAgCBQp1c2VyQ2hhbmdlCQDMCAIFDHN0cmVhbUNoYW5nZQUDbmlsBQNuaWwFBHVuaXQBCm1vdmVTdHJlYW0FA3JzcgZhY3Rpb24EZnJvbQZzdHJpbmcDYW10BAckbWF0Y2gwBQNtVkQDCQABAgUHJG1hdGNoMAIHQWRkcmVzcwQBYQUHJG1hdGNoMAkA/AcEBQFhAgRtb3ZlCQDMCAIFA3JzcgkAzAgCBQZhY3Rpb24JAMwIAgUEZnJvbQkAzAgCBQZzdHJpbmcJAMwIAgUDYW10BQNuaWwFA25pbAUEdW5pdAELc3luY1Jld2FyZHMBA3JzcgQHJG1hdGNoMAUDbVZEAwkAAQIFByRtYXRjaDACB0FkZHJlc3MEAWEFByRtYXRjaDAJAPwHBAUBYQIKc3luY0hlaWdodAkAzAgCBQNyc3IFA25pbAUDbmlsBQR1bml0AQtwdXJlQXNzZXRJZAEHYXNzZXRJZAQBaQkAkQMCCQC1CQIFB2Fzc2V0SWQCAV8AAAMJAAACBQFpAgVXQVZFUwUEdW5pdAkA2QQBBQFpAQlvcEFsbG93ZWQCAm9wB2Fzc2V0SWQEByRtYXRjaDAJAPwHBAUNY29uZmlnQWRkcmVzcwIJb3BBbGxvd2VkCQDMCAIFB2Fzc2V0SWQJAMwIAgUCb3AFA25pbAUDbmlsAwkAAQIFByRtYXRjaDACB0Jvb2xlYW4EAWIFByRtYXRjaDADBQFiBgkAAgEJAKwCAgUCb3ACDCBub3QgYWxsb3dlZAkAAgECIW9wQWxsb3dlZDogdW5leHBlY3RlZCByZXN1bHQgdHlwZQEObW92ZUNvbGxhdGVyYWwEBGFkZHIIYXNzZXRTdHIDcnNyCnJlc2VydmVTdHIEEHByb3RlY3RlZFJlc2VydmUJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgUObWF5YmVQcm90ZWN0ZWQCEG5vIHByb3RlY3RlZCByc3IEA2FtdAkBBWFzSW50AQkA/AcEBRBwcm90ZWN0ZWRSZXNlcnZlAg53aXRoZHJhd1RvTWFpbgkAzAgCBQRhZGRyCQDMCAIFCGFzc2V0U3RyBQNuaWwFA25pbAMJAAACBQNhbXQFA2FtdAQHYXNzZXRJZAMJAAACBQhhc3NldFN0cgIFV0FWRVMFBHVuaXQJANkEAQUIYXNzZXRTdHIEA2RlcAkA/AcEBQNyc3ICCmRlcG9zaXRGb3IJAMwIAgUEYWRkcgkAzAgCBgUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCCQELcHVyZUFzc2V0SWQBBQhhc3NldFN0cgUDYW10BQNuaWwDCQAAAgUDZGVwBQNkZXAEBHByb3AJAQx1cGRhdGVTdHJlYW0FBQpyZXNlcnZlU3RyAgdkZXBvc2l0BQRhZGRyBQNhbXQFA2FtdAMJAAACBQRwcm9wBQRwcm9wBQR1bml0CQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuARR0cmFuc2ZlckRlYnRJbnRlcm5hbAYKbGlxdWlkYXRvcg1ib3Jyb3dSZXNlcnZlEWNvbGxhdGVyYWxSZXNlcnZlCGJvcnJvd2VyE2xpcXVpZGF0ZURlYnRBbW91bnQNZnJvbVByb3RlY3RlZAQDc2gxCQELc3luY1Jld2FyZHMBBQ1ib3Jyb3dSZXNlcnZlAwkAAAIFA3NoMQUDc2gxBANzaDIJAQtzeW5jUmV3YXJkcwEFEWNvbGxhdGVyYWxSZXNlcnZlAwkAAAIFA3NoMgUDc2gyAwkAZwIAAAUTbGlxdWlkYXRlRGVidEFtb3VudAkAAgECE25vbi1wb3NpdGl2ZSBhbW91bnQDCQAAAgURY29sbGF0ZXJhbFJlc2VydmUFDWJvcnJvd1Jlc2VydmUJAAIBAgdjciA9IGJyAwkAAAIFCmxpcXVpZGF0b3IFCGJvcnJvd2VyCQACAQIEc2VsZgQLJHQwNjcwNzY3NDIJAQl1c2VyUG93ZXIBBQhib3Jyb3dlcgQCYnAIBQskdDA2NzA3Njc0MgJfMQQDYnB1CAULJHQwNjcwNzY3NDICXzIDCQBmAgUCYnAFA2JwdQkAAgEJAKwCAgIRIGhlYWx0aHkgdXNlcjogdT0FCGJvcnJvd2VyBAJicgkBA3ZsUgEFDWJvcnJvd1Jlc2VydmUEAmNyCQEDdmxSAQURY29sbGF0ZXJhbFJlc2VydmUEC2JvcnJvd0Fzc2V0CQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUCYnIFBGFJZFMCEG5vIGFzc2V0SWQgaW4gYnIED2NvbGxhdGVyYWxBc3NldAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCdCAIFAmNyBQRhSWRTAhBubyBhc3NldElkIGluIGNyBAZjaGVja3MJAQlvcEFsbG93ZWQCAglsaXF1aWRhdGUFC2JvcnJvd0Fzc2V0AwkAAAIFBmNoZWNrcwUGY2hlY2tzBAxpc0NvbGxhdGVyYWwJAQt2YWx1ZU9yRWxzZQIJAJsIAgUCY3IJAKwCAgUIYm9ycm93ZXICEF91c2VBc0NvbGxhdGVyYWwHAwkAAAIFDGlzQ29sbGF0ZXJhbAUMaXNDb2xsYXRlcmFsAwMJAQEhAQUNZnJvbVByb3RlY3RlZAkBASEBBQxpc0NvbGxhdGVyYWwHCQACAQIeZGVwb3NpdCBub3QgdXNlZCBhcyBjb2xsYXRlcmFsBAskdDA3MjY1NzM1NQkBC3VzZXJCYWxhbmNlAgUCYnIFCGJvcnJvd2VyAwkAAAIFCyR0MDcyNjU3MzU1BQskdDA3MjY1NzM1NQQLdXNlckRlYnRVc2QIBQskdDA3MjY1NzM1NQJfNQQIdXNlckRlYnQIBQskdDA3MjY1NzM1NQJfNAQMdXNlckFzc2V0VXNkCAULJHQwNzI2NTczNTUCXzMECXVzZXJBc3NldAgFCyR0MDcyNjU3MzU1Al8yBAZpZ25vcmUIBQskdDA3MjY1NzM1NQJfMQMJAGcCBQl1c2VyQXNzZXQFCHVzZXJEZWJ0CQACAQIOcG9zaXRpdmUgc2FsZG8DCQBnAgAABRNsaXF1aWRhdGVEZWJ0QW1vdW50CQACAQIFPD0gMD4EBmZhY3RvcgkBC3ZhbHVlT3JFbHNlAgkAmggCBQ1jb25maWdBZGRyZXNzCQCsAgIFD2NvbGxhdGVyYWxBc3NldAIaX0xpcXVpZGF0aW9uRnJhY3Rpb25GYWN0b3IAAgMJAGYCCQBoAgUTbGlxdWlkYXRlRGVidEFtb3VudAUGZmFjdG9yCQBlAgUIdXNlckRlYnQFCXVzZXJBc3NldAkAAgEJAKwCAgkArAICCQCsAgICIm1vcmUgdGhhbiAxL2ZhY3RvciBvZiBzYWxkbzogZGVidD0JAKQDAQUIdXNlckRlYnQCGCwgbGlxdWlkYXRlRGVidEFtb3VudCA9IAkApAMBBRNsaXF1aWRhdGVEZWJ0QW1vdW50BA1jb2xsYXRlcmFsVXNkCQBrAwUTbGlxdWlkYXRlRGVidEFtb3VudAULdXNlckRlYnRVc2QFCHVzZXJEZWJ0BA1wZW5hbHRpemVkVXNkCQBrAwUNY29sbGF0ZXJhbFVzZAkAZAIFC2ZhY3RvcnNCYXNlCQESbGlxdWlkYXRpb25QZW5hbHR5AQULYm9ycm93QXNzZXQFC2ZhY3RvcnNCYXNlBAJtYwMFDWZyb21Qcm90ZWN0ZWQJAQ5tb3ZlQ29sbGF0ZXJhbAQFCGJvcnJvd2VyBQ9jb2xsYXRlcmFsQXNzZXQFAmNyBRFjb2xsYXRlcmFsUmVzZXJ2ZQUEdW5pdAMJAAACBQJtYwUCbWMEFXRyYW5zZmVycmVkQ29sbGF0ZXJhbAkBBWFzSW50AQkA/AcEBQJjcgISdHJhbnNmZXJBVG9rZW5zRm9yCQDMCAIFCGJvcnJvd2VyCQDMCAIFCmxpcXVpZGF0b3IJAMwIAgUNcGVuYWx0aXplZFVzZAUDbmlsBQNuaWwDCQAAAgUVdHJhbnNmZXJyZWRDb2xsYXRlcmFsBRV0cmFuc2ZlcnJlZENvbGxhdGVyYWwEBHBSdzEJAQptb3ZlU3RyZWFtBQURY29sbGF0ZXJhbFJlc2VydmUCB2RlcG9zaXQFCGJvcnJvd2VyBQpsaXF1aWRhdG9yBRV0cmFuc2ZlcnJlZENvbGxhdGVyYWwDCQAAAgUEcFJ3MQUEcFJ3MQQPdHJhbnNmZXJyZWREZWJ0CQEFYXNJbnQBCQD8BwQFAmJyAg90cmFuc2ZlckRlYnRGb3IJAMwIAgUIYm9ycm93ZXIJAMwIAgUKbGlxdWlkYXRvcgkAzAgCBRNsaXF1aWRhdGVEZWJ0QW1vdW50BQNuaWwFA25pbAMJAAACBQ90cmFuc2ZlcnJlZERlYnQFD3RyYW5zZmVycmVkRGVidAQEcFJ3MgkBCm1vdmVTdHJlYW0FBQ1ib3Jyb3dSZXNlcnZlAgZib3Jyb3cFCGJvcnJvd2VyBQpsaXF1aWRhdG9yBQ90cmFuc2ZlcnJlZERlYnQDCQAAAgUEcFJ3MgUEcFJ3MgQVbGlxdWlkYXRvckhlYWx0aENoZWNrAwkBCGNvbnRhaW5zAgULbGlxdWlkYXRvcnMFCmxpcXVpZGF0b3IFA25pbAkBDXZhbGlkYXRlQWZ0ZXICBQpsaXF1aWRhdG9yAhF0cmFuc2ZlcnJpbmcgZGVidAMJAAACBRVsaXF1aWRhdG9ySGVhbHRoQ2hlY2sFFWxpcXVpZGF0b3JIZWFsdGhDaGVjawkAlAoCBRVsaXF1aWRhdG9ySGVhbHRoQ2hlY2sFFXRyYW5zZmVycmVkQ29sbGF0ZXJhbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgEVZm9yY2VDb2xsYXBzZUludGVybmFsBApsaXF1aWRhdG9yA3Jzcghib3Jyb3dlcg1mcm9tUHJvdGVjdGVkBA5yZXNlcnZlQWRkcmVzcwkBA3ZsUgEFA3JzcgMJAAACBQ5yZXNlcnZlQWRkcmVzcwUOcmVzZXJ2ZUFkZHJlc3MEAnNoCQELc3luY1Jld2FyZHMBBQNyc3IDCQAAAgUCc2gFAnNoAwkAAAIFCmxpcXVpZGF0b3IFCGJvcnJvd2VyCQACAQIkY2FuJ3QgY29sbGFwc2Ugc2VsZiBpbiB0aGlzIGZ1bmN0aW9uBAskdDA5MDAzOTAzOAkBCXVzZXJQb3dlcgEFCGJvcnJvd2VyBAJicAgFCyR0MDkwMDM5MDM4Al8xBANicHUIBQskdDA5MDAzOTAzOAJfMgMJAGYCBQJicAUDYnB1CQACAQkArAICAiJjYW4ndCBmb3JjZSBjb2xsYXBzZSBoZWFsdGh5IHVzZXIgBQhib3Jyb3dlcgQFYXNzZXQJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnQgCBQ5yZXNlcnZlQWRkcmVzcwUEYUlkUwkArAICAhhubyBhc3NldElkIGZpZWxkIGluIHJzciAFA3JzcgQCbWMDBQ1mcm9tUHJvdGVjdGVkCQEObW92ZUNvbGxhdGVyYWwEBQhib3Jyb3dlcgUFYXNzZXQFDnJlc2VydmVBZGRyZXNzBQNyc3IFBHVuaXQDCQAAAgUCbWMFAm1jBAskdDA5MzQwOTQ0OAkBC3VzZXJCYWxhbmNlAgUOcmVzZXJ2ZUFkZHJlc3MFCGJvcnJvd2VyAwkAAAIFCyR0MDkzNDA5NDQ4BQskdDA5MzQwOTQ0OAQLdXNlckRlYnRVc2QIBQskdDA5MzQwOTQ0OAJfNQQIdXNlckRlYnQIBQskdDA5MzQwOTQ0OAJfNAQMdXNlckFzc2V0VXNkCAULJHQwOTM0MDk0NDgCXzMED2JvcnJvd2VyRGVwb3NpdAgFCyR0MDkzNDA5NDQ4Al8yBAZpZ25vcmUIBQskdDA5MzQwOTQ0OAJfMQQNcGVuYWx0aXplZFVzZAkAawMJAJcDAQkAzAgCBQx1c2VyQXNzZXRVc2QJAMwIAgULdXNlckRlYnRVc2QFA25pbAUPY29sbGFwc2VQZW5hbHR5BQtmYWN0b3JzQmFzZQQRdHJhbnNmZXJyZWRBc3NldHMJAQVhc0ludAEJAPwHBAUOcmVzZXJ2ZUFkZHJlc3MCEnRyYW5zZmVyQVRva2Vuc0ZvcgkAzAgCBQhib3Jyb3dlcgkAzAgCBQpsaXF1aWRhdG9yCQDMCAIFDXBlbmFsdGl6ZWRVc2QFA25pbAUDbmlsAwkAAAIFEXRyYW5zZmVycmVkQXNzZXRzBRF0cmFuc2ZlcnJlZEFzc2V0cwQEcFJ3MQkBCm1vdmVTdHJlYW0FBQNyc3ICB2RlcG9zaXQFCGJvcnJvd2VyBQpsaXF1aWRhdG9yBRF0cmFuc2ZlcnJlZEFzc2V0cwMJAAACBQRwUncxBQRwUncxBAljb2xsYXBzZWQJAQVhc0ludAEJAPwHBAUOcmVzZXJ2ZUFkZHJlc3MCC2NvbGxhcHNlRm9yCQDMCAIFCGJvcnJvd2VyBQNuaWwFA25pbAMJAAACBQljb2xsYXBzZWQFCWNvbGxhcHNlZAQEcFJ3MgkBDHVwZGF0ZVN0cmVhbQUFA3JzcgIGYm9ycm93BQhib3Jyb3dlcgkBAS0BBQljb2xsYXBzZWQJAQEtAQUJY29sbGFwc2VkAwkAAAIFBHBSdzIFBHBSdzIEBHBSdzMJAQx1cGRhdGVTdHJlYW0FBQNyc3ICB2RlcG9zaXQFCGJvcnJvd2VyCQEBLQEFCWNvbGxhcHNlZAkBAS0BBQljb2xsYXBzZWQDCQAAAgUEcFJ3MwUEcFJ3MwUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBQFpAQppbml0aWFsaXplAQJjYQkAzAgCCQEQd3JpdGVDb25zdFN0cmluZwIFC2NvbmZpZ1N0b3JlBQJjYQUDbmlsAWkBDHRyYW5zZmVyRGVidAQCYnICY3IBYgJsYQkBFHRyYW5zZmVyRGVidEludGVybmFsBgkApQgBCAUBaQZjYWxsZXIFAmJyBQJjcgUBYgUCbGEHAWkBDXRyYW5zZmVyRGVidDIEAmJyAmNyAWICbGEJARR0cmFuc2ZlckRlYnRJbnRlcm5hbAYJAKUIAQgFAWkGY2FsbGVyBQJicgUCY3IFAWIFAmxhBgFpAQ1mb3JjZUNvbGxhcHNlAgFyAWIJARVmb3JjZUNvbGxhcHNlSW50ZXJuYWwECQClCAEIBQFpBmNhbGxlcgUBcgUBYgcBaQEOZm9yY2VDb2xsYXBzZTICAXIBYgkBFWZvcmNlQ29sbGFwc2VJbnRlcm5hbAQJAKUIAQgFAWkGY2FsbGVyBQFyBQFiBgECdHgBBnZlcmlmeQAEEm1heWJlT3JhY2xlQWRkcmVzcwQHJG1hdGNoMAkAnQgCBQ1jb25maWdBZGRyZXNzAg5vcmFjbGVfYWRkcmVzcwMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAXMFByRtYXRjaDAJAKYIAQUBcwUEdW5pdAQGSEVJR0hUBQZoZWlnaHQEBEJBU0UA6AcEC3F1b3J1bVJhdGlvCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUNY29uZmlnQWRkcmVzcwIVcHJvcG9zYWxfcXVvcnVtX3JhdGlvAiJwcm9wb3NhbFF1b3J1bVJhdGlvIGlzIG5vdCBkZWZpbmVkBAtwYXNzZWRSYXRpbwkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCaCAIFDWNvbmZpZ0FkZHJlc3MCFXByb3Bvc2FsX3Bhc3NlZF9yYXRpbwIlcHJvcG9zYWxUaHJlc2hvbGRSYXRpbyBpcyBub3QgZGVmaW5lZAQOZ1ZpcmVzQ29udHJhY3QJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUNY29uZmlnQWRkcmVzcwISZGl2aWRlbmRzX2NvbnRyYWN0AhVubyBkaXZpZGVuZHNfY29udHJhY3QCGmludmFsaWQgZGl2aWRlbmRzX2NvbnRyYWN0BA52b3RpbmdDb250cmFjdAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkAnQgCBQ1jb25maWdBZGRyZXNzAg92b3RpbmdfY29udHJhY3QCEm5vIHZvdGluZ19jb250cmFjdAIXaW52YWxpZCB2b3RpbmdfY29udHJhY3QEAmlkCQDYBAEIBQJ0eAJpZAQIdm90ZXNZZXMJAQt2YWx1ZU9yRWxzZQIJAJoIAgUOdm90aW5nQ29udHJhY3QJAKwCAgINcHJvcG9zYWxfeWVzXwUCaWQAAAQHdm90ZXNObwkBC3ZhbHVlT3JFbHNlAgkAmggCBQ52b3RpbmdDb250cmFjdAkArAICAgxwcm9wb3NhbF9ub18FAmlkAAAEDnByb3Bvc2FsSGVpZ2h0CQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUOdm90aW5nQ29udHJhY3QJAKwCAgIQcHJvcG9zYWxfaGVpZ2h0XwUCaWQCF3Byb3Bvc2FsIG5vdCByZWdpc3RlcmVkBAphcHBseVN0YXJ0CQELdmFsdWVPckVsc2UCCQCaCAIFDnZvdGluZ0NvbnRyYWN0CQCsAgICFHByb3Bvc2FsX2FwcGx5c3RhcnRfBQJpZAAABAhhcHBseUVuZAkBC3ZhbHVlT3JFbHNlAgkAmggCBQ52b3RpbmdDb250cmFjdAkArAICAhJwcm9wb3NhbF9hcHBseWVuZF8FAmlkAAAEC3RvdGFsR1ZpcmVzCQELdmFsdWVPckVsc2UCCQCaCAIFDnZvdGluZ0NvbnRyYWN0CQCsAgICEHByb3Bvc2FsX2d2aXJlc18FAmlkAAAEB2VuYWJsZWQJAQt2YWx1ZU9yRWxzZQIJAJsIAgUNY29uZmlnQWRkcmVzcwIdb3BfZ292ZXJuYW5jZV9hcHBseV90eF9wYXVzZWQHBAd2b3RlWWVzBQh2b3Rlc1llcwQGdm90ZU5vBQd2b3Rlc05vBAp0b3RhbFZvdGVzCQBkAgUHdm90ZVllcwUGdm90ZU5vBAloYXNRdW9ydW0JAGcCCQBpAgkAaAIFCnRvdGFsVm90ZXMFBEJBU0UFC3RvdGFsR1ZpcmVzBQtxdW9ydW1SYXRpbwQJaGFzUGFzc2VkCQBnAgkAaQIJAGgCBQd2b3RlWWVzBQRCQVNFBQp0b3RhbFZvdGVzBQtwYXNzZWRSYXRpbwQIdG9vRWFybHkJAGcCBQphcHBseVN0YXJ0BQZIRUlHSFQEB3Rvb0xhdGUJAGcCBQZIRUlHSFQFCGFwcGx5RW5kBAl0aW1lRGVidWcJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgIRcHJvcG9zYWxIZWlnaHQgPSAJAKQDAQUOcHJvcG9zYWxIZWlnaHQCDywgYXBwbHlTdGFydCA9IAkApAMBBQphcHBseVN0YXJ0Ag0sIGFwcGx5RW5kID0gCQCkAwEFCGFwcGx5RW5kAgssIEhFSUdIVCA9IAkApAMBBQZIRUlHSFQECGJ5Vm90aW5nAwkBASEBBQdlbmFibGVkCQACAQIrdHggYXBwbGljYXRpb24gdGhyb3cgZ292ZXJuYW5jZSBub3QgZW5hYmxlZAMFCHRvb0Vhcmx5CQACAQkArAICAi5wcm9wb3NhbCBjYW4ndCBiZSBleGVjdXRlZCBhcyBpdCdzIHRvbyBlYXJseTogBQl0aW1lRGVidWcDBQd0b29MYXRlCQACAQkArAICAixwcm9wb3NhbCBjYW4ndCBiZSBleGVjdXRlZCBhcyBpdCdzIHRvbyBsYXRlOgUJdGltZURlYnVnAwkBASEBBQloYXNRdW9ydW0JAAIBCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICAgtubyBxdW9ydW06IAIMdG90YWxWb3RlczogCQCkAwEFCnRvdGFsVm90ZXMCDywgdG90YWxHVmlyZXM6IAkApAMBBQt0b3RhbEdWaXJlcwIPLCBxdW9ydW1SYXRpbzogCQCkAwEFC3F1b3J1bVJhdGlvAwkBASEBBQloYXNQYXNzZWQJAAIBCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICAhdubyB0aHJlc2hvbGQgYWNoaWV2ZWQ6IAIJdm90ZVllczogCQCkAwEFB3ZvdGVZZXMCCiwgdm90ZU5vOiAJAKQDAQUGdm90ZU5vAg8sIHBhc3NlZFJhdGlvOiAJAKQDAQULcGFzc2VkUmF0aW8GAwkA9AMDCAUCdHgJYm9keUJ5dGVzCQCRAwIIBQJ0eAZwcm9vZnMAAAgFAnR4D3NlbmRlclB1YmxpY0tleQYFCGJ5Vm90aW5n/kfi7A==",
    "chainId": 87,
    "height": 3596901,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let factorsBase = 1000
5+
6+func fCi (value,numerator,denominator) = {
7+    let cand = fraction(value, numerator, denominator)
8+    let D = 3037000499
9+    let exact = ((((cand % D) * (denominator % D)) % D) == (((value % D) * (numerator % D)) % D))
10+    if (exact)
11+        then cand
12+        else (cand + 1)
13+    }
14+
15+
16+func writeConstString (key,value) = if (!(isDefined(getString(this, key))))
17+    then StringEntry(key, value)
18+    else throw(("already initialized: " + key))
19+
20+
21+func asInt (value) = match value {
22+    case int: Int => 
23+        int
24+    case _ => 
25+        throw("m2:1")
26+}
27+
28+
29+func asInt3 (value) = match value {
30+    case x: (Int, Int, Int) => 
31+        x
32+    case t => 
33+        throw("2")
34+}
35+
36+
37+func asUserBalanceData (value) = match value {
38+    case x: (Int, Int, Int, Int, Int, Boolean) => 
39+        x
40+    case t => 
41+        throw("3")
42+}
43+
44+
45+let configStore = "config"
46+
47+let reservesStore = "reserves"
48+
49+let aTIdS = "aTokenId"
50+
51+let aIdS = "assetId"
52+
53+let configAddress = addressFromStringValue(getStringValue(this, configStore))
54+
55+let reservesStr = valueOrErrorMessage(getString(configAddress, "primary_reserves"), "no reserves registered")
56+
57+let reserves = split_4C(reservesStr, "|")
58+
59+let mVD = match getString(configAddress, "vires_distributor") {
60+    case d: String => 
61+        addressFromStringValue(d)
62+    case _ => 
63+        unit
64+}
65+
66+func assetIdOfReserve (rsr) = valueOrErrorMessage(getString(rsr, aIdS), "no assetId in reserve")
67+
68+
69+func collateralFactor (rsr) = valueOrErrorMessage(getInteger(configAddress, (assetIdOfReserve(rsr) + "_CollateralFactor")), "no 1")
70+
71+
72+func liquidationThreshold (rsr) = valueOrErrorMessage(getInteger(configAddress, (assetIdOfReserve(rsr) + "_LiquidationThreshold")), "no 2")
73+
74+
75+func liquidationPenalty (assetId) = valueOrErrorMessage(getInteger(configAddress, (assetId + "_LiquidationPenalty")), "no 3")
76+
77+
78+let accountHealthThreshold = valueOrErrorMessage(getInteger(configAddress, "account_health_threshold"), "no 4")
79+
80+let accountHealthOverlap = valueOrErrorMessage(getInteger(configAddress, "account_health_overlap"), "no 5")
81+
82+let collapsePenalty = valueOrErrorMessage(getInteger(configAddress, "collapse_penalty"), "no 6")
83+
84+let liquidators = valueOrElse(getString(configAddress, "liquidators"), "")
85+
86+func vlR (r) = if (contains(reservesStr, r))
87+    then valueOrErrorMessage(addressFromString(r), "main: bad rsr")
88+    else throw(("unknown rsr:" + r))
89+
90+
91+func userBalance (rsr,user) = asUserBalanceData(invoke(rsr, "userBalance", [user], nil))
92+
93+
94+let maybeProtected = match getString(configAddress, "protected_reserve") {
95+    case pds: String => 
96+        valueOrErrorMessage(addressFromString(pds), "bad protected")
97+    case _ => 
98+        unit
99+}
100+
101+func userPower (user) = {
102+    let protectedDeposit =     match maybeProtected {
103+        case pa: Address => 
104+            asInt(invoke(pa, "borrowPower", [user], nil))
105+        case _ => 
106+            0
107+    }
108+    func fold (totals,r) =     {
109+        let $t029382984 = totals
110+        let totalD = $t029382984._1
111+        let totalB = $t029382984._2
112+        let numberOfBorrows = $t029382984._3
113+        let rsr = valueOrErrorMessage(addressFromString(r), "rsr bad address")
114+        let cf = collateralFactor(rsr)
115+        let lt = liquidationThreshold(rsr)
116+        let $t031383222 = userBalance(rsr, user)
117+        let token = $t031383222._1
118+        let asset = $t031383222._2
119+        let depositUsd = $t031383222._3
120+        let debt = $t031383222._4
121+        let debtUsd = $t031383222._5
122+        let asCollateral = $t031383222._6
123+        let totalBorrows = (numberOfBorrows + (if ((debt > 0))
124+            then 1
125+            else 0))
126+        let effectiveDepositUsd = if (asCollateral)
127+            then depositUsd
128+            else 0
129+        let overlapUsd = min([debtUsd, effectiveDepositUsd])
130+        let overlapCharge = fCi(overlapUsd, accountHealthOverlap, factorsBase)
131+        if ((debtUsd > effectiveDepositUsd))
132+            then $Tuple3(totalD, ((totalB + fraction((debtUsd - effectiveDepositUsd), factorsBase, lt)) + overlapCharge), totalBorrows)
133+            else $Tuple3((totalD + fraction((effectiveDepositUsd - debtUsd), cf, factorsBase)), (totalB + overlapCharge), totalBorrows)
134+        }
135+
136+    let r = {
137+        let $l = reserves
138+        let $s = size($l)
139+        let $acc0 = $Tuple3(protectedDeposit, 0, 0)
140+        func $f0_1 ($a,$i) =         if (($i >= $s))
141+            then $a
142+            else fold($a, $l[$i])
143+
144+        func $f0_2 ($a,$i) =         if (($i >= $s))
145+            then $a
146+            else throw("List size exceeds 20")
147+
148+        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
149+        }
150+    if (if ((protectedDeposit > 0))
151+        then (r._3 > 4)
152+        else false)
153+        then throw("can't have more than 4 borrows")
154+        else r
155+    }
156+
157+
158+func getUserHealth (account) = {
159+    let $t039774028 = asInt3(userPower(account))
160+    let bp = $t039774028._1
161+    let bpu = $t039774028._2
162+    let ignore = $t039774028._3
163+    ((("bp:" + toString(bp)) + ", bpu:") + toString(bpu))
164+    }
165+
166+
167+func validateAfter (user,op) = {
168+    let $t041394170 = userPower(user)
169+    let bp = $t041394170._1
170+    let bpu = $t041394170._2
171+    let accHealth = (((bp - bpu) * factorsBase) / bp)
172+    if (if ((bp == 0))
173+        then (bpu == 0)
174+        else false)
175+        then nil
176+        else if (if ((bp == 0))
177+            then (bpu > 0)
178+            else false)
179+            then throw(((op + ": breaching liquidation threshold(bp=0, bpu=") + toString(bpu)))
180+            else if ((accountHealthThreshold > accHealth))
181+                then throw((((((((op + ": breaching liquidation threshold(bp=") + toString(bp)) + ", bpu=") + toString(bpu)) + ", health=") + toString(accHealth)) + ")"))
182+                else nil
183+    }
184+
185+
186+func updateStream (rsr,action,user,userChange,streamChange) = match mVD {
187+    case a: Address => 
188+        invoke(a, "onAction", [rsr, action, user, userChange, streamChange], nil)
189+    case _ => 
190+        unit
191+}
192+
193+
194+func moveStream (rsr,action,from,string,amt) = match mVD {
195+    case a: Address => 
196+        invoke(a, "move", [rsr, action, from, string, amt], nil)
197+    case _ => 
198+        unit
199+}
200+
201+
202+func syncRewards (rsr) = match mVD {
203+    case a: Address => 
204+        invoke(a, "syncHeight", [rsr], nil)
205+    case _ => 
206+        unit
207+}
208+
209+
210+func pureAssetId (assetId) = {
211+    let i = split(assetId, "_")[0]
212+    if ((i == "WAVES"))
213+        then unit
214+        else fromBase58String(i)
215+    }
216+
217+
218+func opAllowed (op,assetId) = match invoke(configAddress, "opAllowed", [assetId, op], nil) {
219+    case b: Boolean => 
220+        if (b)
221+            then true
222+            else throw((op + " not allowed"))
223+    case _ => 
224+        throw("opAllowed: unexpected result type")
225+}
226+
227+
228+func moveCollateral (addr,assetStr,rsr,reserveStr) = {
229+    let protectedReserve = valueOrErrorMessage(maybeProtected, "no protected rsr")
230+    let amt = asInt(invoke(protectedReserve, "withdrawToMain", [addr, assetStr], nil))
231+    if ((amt == amt))
232+        then {
233+            let assetId = if ((assetStr == "WAVES"))
234+                then unit
235+                else fromBase58String(assetStr)
236+            let dep = invoke(rsr, "depositFor", [addr, true], [AttachedPayment(pureAssetId(assetStr), amt)])
237+            if ((dep == dep))
238+                then {
239+                    let prop = updateStream(reserveStr, "deposit", addr, amt, amt)
240+                    if ((prop == prop))
241+                        then unit
242+                        else throw("Strict value is not equal to itself.")
243+                    }
244+                else throw("Strict value is not equal to itself.")
245+            }
246+        else throw("Strict value is not equal to itself.")
247+    }
248+
249+
250+func transferDebtInternal (liquidator,borrowReserve,collateralReserve,borrower,liquidateDebtAmount,fromProtected) = {
251+    let sh1 = syncRewards(borrowReserve)
252+    if ((sh1 == sh1))
253+        then {
254+            let sh2 = syncRewards(collateralReserve)
255+            if ((sh2 == sh2))
256+                then if ((0 >= liquidateDebtAmount))
257+                    then throw("non-positive amount")
258+                    else if ((collateralReserve == borrowReserve))
259+                        then throw("cr = br")
260+                        else if ((liquidator == borrower))
261+                            then throw("self")
262+                            else {
263+                                let $t067076742 = userPower(borrower)
264+                                let bp = $t067076742._1
265+                                let bpu = $t067076742._2
266+                                if ((bp > bpu))
267+                                    then throw((" healthy user: u=" + borrower))
268+                                    else {
269+                                        let br = vlR(borrowReserve)
270+                                        let cr = vlR(collateralReserve)
271+                                        let borrowAsset = valueOrErrorMessage(getString(br, aIdS), "no assetId in br")
272+                                        let collateralAsset = valueOrErrorMessage(getString(cr, aIdS), "no assetId in cr")
273+                                        let checks = opAllowed("liquidate", borrowAsset)
274+                                        if ((checks == checks))
275+                                            then {
276+                                                let isCollateral = valueOrElse(getBoolean(cr, (borrower + "_useAsCollateral")), false)
277+                                                if ((isCollateral == isCollateral))
278+                                                    then if (if (!(fromProtected))
279+                                                        then !(isCollateral)
280+                                                        else false)
281+                                                        then throw("deposit not used as collateral")
282+                                                        else {
283+                                                            let $t072657355 = userBalance(br, borrower)
284+                                                            if (($t072657355 == $t072657355))
285+                                                                then {
286+                                                                    let userDebtUsd = $t072657355._5
287+                                                                    let userDebt = $t072657355._4
288+                                                                    let userAssetUsd = $t072657355._3
289+                                                                    let userAsset = $t072657355._2
290+                                                                    let ignore = $t072657355._1
291+                                                                    if ((userAsset >= userDebt))
292+                                                                        then throw("positive saldo")
293+                                                                        else if ((0 >= liquidateDebtAmount))
294+                                                                            then throw("<= 0>")
295+                                                                            else {
296+                                                                                let factor = valueOrElse(getInteger(configAddress, (collateralAsset + "_LiquidationFractionFactor")), 2)
297+                                                                                if (((liquidateDebtAmount * factor) > (userDebt - userAsset)))
298+                                                                                    then throw(((("more than 1/factor of saldo: debt=" + toString(userDebt)) + ", liquidateDebtAmount = ") + toString(liquidateDebtAmount)))
299+                                                                                    else {
300+                                                                                        let collateralUsd = fraction(liquidateDebtAmount, userDebtUsd, userDebt)
301+                                                                                        let penaltizedUsd = fraction(collateralUsd, (factorsBase + liquidationPenalty(borrowAsset)), factorsBase)
302+                                                                                        let mc = if (fromProtected)
303+                                                                                            then moveCollateral(borrower, collateralAsset, cr, collateralReserve)
304+                                                                                            else unit
305+                                                                                        if ((mc == mc))
306+                                                                                            then {
307+                                                                                                let transferredCollateral = asInt(invoke(cr, "transferATokensFor", [borrower, liquidator, penaltizedUsd], nil))
308+                                                                                                if ((transferredCollateral == transferredCollateral))
309+                                                                                                    then {
310+                                                                                                        let pRw1 = moveStream(collateralReserve, "deposit", borrower, liquidator, transferredCollateral)
311+                                                                                                        if ((pRw1 == pRw1))
312+                                                                                                            then {
313+                                                                                                                let transferredDebt = asInt(invoke(br, "transferDebtFor", [borrower, liquidator, liquidateDebtAmount], nil))
314+                                                                                                                if ((transferredDebt == transferredDebt))
315+                                                                                                                    then {
316+                                                                                                                        let pRw2 = moveStream(borrowReserve, "borrow", borrower, liquidator, transferredDebt)
317+                                                                                                                        if ((pRw2 == pRw2))
318+                                                                                                                            then {
319+                                                                                                                                let liquidatorHealthCheck = if (contains(liquidators, liquidator))
320+                                                                                                                                    then nil
321+                                                                                                                                    else validateAfter(liquidator, "transferring debt")
322+                                                                                                                                if ((liquidatorHealthCheck == liquidatorHealthCheck))
323+                                                                                                                                    then $Tuple2(liquidatorHealthCheck, transferredCollateral)
324+                                                                                                                                    else throw("Strict value is not equal to itself.")
325+                                                                                                                                }
326+                                                                                                                            else throw("Strict value is not equal to itself.")
327+                                                                                                                        }
328+                                                                                                                    else throw("Strict value is not equal to itself.")
329+                                                                                                                }
330+                                                                                                            else throw("Strict value is not equal to itself.")
331+                                                                                                        }
332+                                                                                                    else throw("Strict value is not equal to itself.")
333+                                                                                                }
334+                                                                                            else throw("Strict value is not equal to itself.")
335+                                                                                        }
336+                                                                                }
337+                                                                    }
338+                                                                else throw("Strict value is not equal to itself.")
339+                                                            }
340+                                                    else throw("Strict value is not equal to itself.")
341+                                                }
342+                                            else throw("Strict value is not equal to itself.")
343+                                        }
344+                                }
345+                else throw("Strict value is not equal to itself.")
346+            }
347+        else throw("Strict value is not equal to itself.")
348+    }
349+
350+
351+func forceCollapseInternal (liquidator,rsr,borrower,fromProtected) = {
352+    let reserveAddress = vlR(rsr)
353+    if ((reserveAddress == reserveAddress))
354+        then {
355+            let sh = syncRewards(rsr)
356+            if ((sh == sh))
357+                then if ((liquidator == borrower))
358+                    then throw("can't collapse self in this function")
359+                    else {
360+                        let $t090039038 = userPower(borrower)
361+                        let bp = $t090039038._1
362+                        let bpu = $t090039038._2
363+                        if ((bp > bpu))
364+                            then throw(("can't force collapse healthy user " + borrower))
365+                            else {
366+                                let asset = valueOrErrorMessage(getString(reserveAddress, aIdS), ("no assetId field in rsr " + rsr))
367+                                let mc = if (fromProtected)
368+                                    then moveCollateral(borrower, asset, reserveAddress, rsr)
369+                                    else unit
370+                                if ((mc == mc))
371+                                    then {
372+                                        let $t093409448 = userBalance(reserveAddress, borrower)
373+                                        if (($t093409448 == $t093409448))
374+                                            then {
375+                                                let userDebtUsd = $t093409448._5
376+                                                let userDebt = $t093409448._4
377+                                                let userAssetUsd = $t093409448._3
378+                                                let borrowerDeposit = $t093409448._2
379+                                                let ignore = $t093409448._1
380+                                                let penaltizedUsd = fraction(min([userAssetUsd, userDebtUsd]), collapsePenalty, factorsBase)
381+                                                let transferredAssets = asInt(invoke(reserveAddress, "transferATokensFor", [borrower, liquidator, penaltizedUsd], nil))
382+                                                if ((transferredAssets == transferredAssets))
383+                                                    then {
384+                                                        let pRw1 = moveStream(rsr, "deposit", borrower, liquidator, transferredAssets)
385+                                                        if ((pRw1 == pRw1))
386+                                                            then {
387+                                                                let collapsed = asInt(invoke(reserveAddress, "collapseFor", [borrower], nil))
388+                                                                if ((collapsed == collapsed))
389+                                                                    then {
390+                                                                        let pRw2 = updateStream(rsr, "borrow", borrower, -(collapsed), -(collapsed))
391+                                                                        if ((pRw2 == pRw2))
392+                                                                            then {
393+                                                                                let pRw3 = updateStream(rsr, "deposit", borrower, -(collapsed), -(collapsed))
394+                                                                                if ((pRw3 == pRw3))
395+                                                                                    then nil
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+                                                    else throw("Strict value is not equal to itself.")
405+                                                }
406+                                            else throw("Strict value is not equal to itself.")
407+                                        }
408+                                    else throw("Strict value is not equal to itself.")
409+                                }
410+                        }
411+                else throw("Strict value is not equal to itself.")
412+            }
413+        else throw("Strict value is not equal to itself.")
414+    }
415+
416+
417+@Callable(i)
418+func initialize (ca) = [writeConstString(configStore, ca)]
419+
420+
421+
422+@Callable(i)
423+func transferDebt (br,cr,b,la) = transferDebtInternal(toString(i.caller), br, cr, b, la, false)
424+
425+
426+
427+@Callable(i)
428+func transferDebt2 (br,cr,b,la) = transferDebtInternal(toString(i.caller), br, cr, b, la, true)
429+
430+
431+
432+@Callable(i)
433+func forceCollapse (r,b) = forceCollapseInternal(toString(i.caller), r, b, false)
434+
435+
436+
437+@Callable(i)
438+func forceCollapse2 (r,b) = forceCollapseInternal(toString(i.caller), r, b, true)
439+
440+
441+@Verifier(tx)
442+func verify () = {
443+    let maybeOracleAddress =     match getString(configAddress, "oracle_address") {
444+        case s: String => 
445+            addressFromString(s)
446+        case _ => 
447+            unit
448+    }
449+    let HEIGHT = height
450+    let BASE = 1000
451+    let quorumRatio = valueOrErrorMessage(getInteger(configAddress, "proposal_quorum_ratio"), "proposalQuorumRatio is not defined")
452+    let passedRatio = valueOrErrorMessage(getInteger(configAddress, "proposal_passed_ratio"), "proposalThresholdRatio is not defined")
453+    let gViresContract = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, "dividends_contract"), "no dividends_contract")), "invalid dividends_contract")
454+    let votingContract = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(configAddress, "voting_contract"), "no voting_contract")), "invalid voting_contract")
455+    let id = toBase58String(tx.id)
456+    let votesYes = valueOrElse(getInteger(votingContract, ("proposal_yes_" + id)), 0)
457+    let votesNo = valueOrElse(getInteger(votingContract, ("proposal_no_" + id)), 0)
458+    let proposalHeight = valueOrErrorMessage(getInteger(votingContract, ("proposal_height_" + id)), "proposal not registered")
459+    let applyStart = valueOrElse(getInteger(votingContract, ("proposal_applystart_" + id)), 0)
460+    let applyEnd = valueOrElse(getInteger(votingContract, ("proposal_applyend_" + id)), 0)
461+    let totalGVires = valueOrElse(getInteger(votingContract, ("proposal_gvires_" + id)), 0)
462+    let enabled = valueOrElse(getBoolean(configAddress, "op_governance_apply_tx_paused"), false)
463+    let voteYes = votesYes
464+    let voteNo = votesNo
465+    let totalVotes = (voteYes + voteNo)
466+    let hasQuorum = (((totalVotes * BASE) / totalGVires) >= quorumRatio)
467+    let hasPassed = (((voteYes * BASE) / totalVotes) >= passedRatio)
468+    let tooEarly = (applyStart >= HEIGHT)
469+    let tooLate = (HEIGHT >= applyEnd)
470+    let timeDebug = ((((((("proposalHeight = " + toString(proposalHeight)) + ", applyStart = ") + toString(applyStart)) + ", applyEnd = ") + toString(applyEnd)) + ", HEIGHT = ") + toString(HEIGHT))
471+    let byVoting = if (!(enabled))
472+        then throw("tx application throw governance not enabled")
473+        else if (tooEarly)
474+            then throw(("proposal can't be executed as it's too early: " + timeDebug))
475+            else if (tooLate)
476+                then throw(("proposal can't be executed as it's too late:" + timeDebug))
477+                else if (!(hasQuorum))
478+                    then throw((((((("no quorum: " + "totalVotes: ") + toString(totalVotes)) + ", totalGVires: ") + toString(totalGVires)) + ", quorumRatio: ") + toString(quorumRatio)))
479+                    else if (!(hasPassed))
480+                        then throw((((((("no threshold achieved: " + "voteYes: ") + toString(voteYes)) + ", voteNo: ") + toString(voteNo)) + ", passedRatio: ") + toString(passedRatio)))
481+                        else true
482+    if (sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey))
483+        then true
484+        else byVoting
485+    }
486+
github/deemru/w8io/3ef1775 
31.87 ms ◑