w8 · tx

2023.01.23 13:26 [3482981] smart account 3P8KMyAJCPWNcyedqrmymxaeWonvmkhGauz > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FkWznKHsfojKvpGbACrwm4HqwWyEu8Byv8PyP3uq1oyM",
    "fee": 3600000,
    "feeAssetId": null,
    "timestamp": 1674469423732,
    "version": 1,
    "sender": "3P8KMyAJCPWNcyedqrmymxaeWonvmkhGauz",
    "senderPublicKey": "DxhbzFs9BZTiN6kcnyybxmqPTV8xReD6Z5gWQ5AgRX8w",
    "proofs": [
        "k4dCShFkngeUkhTAbr3r1UBnAndEfgkHQV2x3WrbkWfZE38GCRJPNQuJfbHyybPJoeAgGPxkjLsC7F6gP28hdEt"
    ],
    "script": "base64:BgKJKQgCEgMKAQgSAwoBCBIAEgQKAgEEEgQKAgEEEgMKAQESABIECgIIARIAEgQKAggBEgQKAggBEgQKAgEBEgMKAQESBQoDAQEBEgUKAwEIARIECgIBCBIECgIBCBIECgIICBIECgIICBIECgIIARIAEgMKAQgSBQoDAQEBEgQKAggBEgQKAgEBEgQKAggIEgsKCQgBAQIBAggEBBIGCgQICAEIIgZzY2FsZTgiDHNjYWxlOEJpZ0ludCIHc2NhbGUxOCIKemVyb0JpZ0ludCIEYmlnMCIEYmlnMSIEYmlnMiIEYmlnMyIEYmlnNCIKc2xpcHBhZ2U0RCILd2F2ZXNTdHJpbmciBUFtdWx0IgVEY29udiIDU0VQIgVFTVBUWSIKUG9vbEFjdGl2ZSIKUG9vbFB1dERpcyIOUG9vbE1hdGNoZXJEaXMiDFBvb2xTaHV0ZG93biIOaWR4UG9vbEFkZHJlc3MiCWlkeFBvb2xTdCIJaWR4TFBBc0lkIglpZHhBbUFzSWQiCWlkeFByQXNJZCILaWR4QW10QXNEY20iDWlkeFByaWNlQXNEY20iC2lkeElBbXRBc0lkIg1pZHhJUHJpY2VBc0lkIg9pZHhGYWN0U3Rha0NudHIiEmlkeEZhY3RvcnlSZXN0Q250ciIQaWR4RmFjdFNsaXBwQ250ciIRaWR4RmFjdEd3eFJld0NudHIiCmZlZURlZmF1bHQiAnQxIgdvcmlnVmFsIg1vcmlnU2NhbGVNdWx0Igh0MUJpZ0ludCICZjEiA3ZhbCIPcmVzdWx0U2NhbGVNdWx0Igxmcm9tWDE4Um91bmQiBXJvdW5kIgJ0MiICZjIiAnRzIgNhbXQiCHJlc1NjYWxlIghjdXJTY2FsZSIDYWJzIglhYnNCaWdJbnQiAmZjIgNtcGsiBHBtcGsiAnBsIgJwaCIBaCIBdCIDcGF1IgJ1YSIEdHhJZCIDZ2F1IgJhYSICcGEiA2FtcCIDYWRhIgZrZXlGZWUiA2ZlZSIGa2V5RExwIhVrZXlETHBSZWZyZXNoZWRIZWlnaHQiEmtleURMcFJlZnJlc2hEZWxheSIWZExwUmVmcmVzaERlbGF5RGVmYXVsdCIPZExwUmVmcmVzaERlbGF5IgRmY2ZnIgRtdHBrIgJwYyIGaUFtdEFzIgVpUHJBcyIDbWJhIgViQVN0ciIDYXBzIhxrZXlBbGxvd2VkTHBTdGFibGVTY3JpcHRIYXNoIhZrZXlGZWVDb2xsZWN0b3JBZGRyZXNzIg90aHJvd09yZGVyRXJyb3IiCm9yZGVyVmFsaWQiDm9yZGVyVmFsaWRJbmZvIgtzZW5kZXJWYWxpZCIMbWF0Y2hlclZhbGlkIgRzdHJmIgRhZGRyIgNrZXkiBGludGYiCHRocm93RXJyIgNtc2ciBmZtdEVyciIDZmNhIgVpbkZlZSIBQCIGb3V0RmVlIgFBIgNpZ3MiAm1wIhNmZWVDb2xsZWN0b3JBZGRyZXNzIgNncGMiBWFtdEFzIgdwcmljZUFzIghpUHJpY2VBcyIMcGFyc2VBc3NldElkIgVpbnB1dCIPYXNzZXRJZFRvU3RyaW5nIg9wYXJzZVBvb2xDb25maWciCnBvb2xDb25maWciEHBvb2xDb25maWdQYXJzZWQiCyR0MDc5NjQ4MTkzIg5jZmdQb29sQWRkcmVzcyINY2ZnUG9vbFN0YXR1cyIMY2ZnTHBBc3NldElkIhBjZmdBbW91bnRBc3NldElkIg9jZmdQcmljZUFzc2V0SWQiFmNmZ0Ftb3VudEFzc2V0RGVjaW1hbHMiFWNmZ1ByaWNlQXNzZXREZWNpbWFscyISY2ZnSW5BbW91bnRBc3NlZElkIhFjZmdJblByaWNlQXNzZXRJZCIDZ2ZjIg1mYWN0b3J5Q29uZmlnIg9zdGFraW5nQ29udHJhY3QiD3NsaXBhZ2VDb250cmFjdCILZ3d4Q29udHJhY3QiDHJlc3RDb250cmFjdCIRZGF0YVB1dEFjdGlvbkluZm8iDWluQW10QXNzZXRBbXQiD2luUHJpY2VBc3NldEFtdCIIb3V0THBBbXQiBXByaWNlIgpzbGlwQnlVc2VyIgxzbGlwcGFnZVJlYWwiCHR4SGVpZ2h0Igt0eFRpbWVzdGFtcCIMc2xpcGFnZUFtQW10IgxzbGlwYWdlUHJBbXQiEWRhdGFHZXRBY3Rpb25JbmZvIg5vdXRBbXRBc3NldEFtdCIQb3V0UHJpY2VBc3NldEFtdCIHaW5McEFtdCINZ2V0QWNjQmFsYW5jZSIHYXNzZXRJZCIEY3BiaSIIcHJBbXRYMTgiCGFtQW10WDE4IgVjcGJpciIDdmFkIgJBMSICQTIiCHNsaXBwYWdlIgRkaWZmIgRwYXNzIgJ2ZCICRDEiAkQwIgRzbHBnIgRmYWlsIgNwY3AiCmFtQXNzZXREY20iCnByQXNzZXREY20iBWFtQW10IgVwckFtdCILYW10QXNBbXRYMTgiCnByQXNBbXRYMTgiCmNhbGNQcmljZXMiBWxwQW10IghhbXRBc0RjbSIHcHJBc0RjbSIIcHJpY2VYMTgiCGxwQW10WDE4Ig1scFBySW5BbUFzWDE4Ig1scFBySW5QckFzWDE4Ig9jYWxjdWxhdGVQcmljZXMiAXAiB3Rha2VGZWUiBmFtb3VudCIJZmVlQW1vdW50IgRnZXREIgJ4cCIDeHAwIgN4cDEiAXMiAWEiA2FubiILeHAwX3hwMV9uX24iBWFubl9zIgVhbm5fMSIJY2FsY0ROZXh0IgFkIgJkZCIDZGRkIgJkcCIEY2FsYyIDYWNjIgFpIgVkTmV4dCIIZERpZmZSYXciBWREaWZmIgNhcnIiDSR0MDEyNjkwMTI3MzgiAiRsIgIkcyIFJGFjYzAiBSRmMF8xIgIkYSICJGkiBSRmMF8yIgVmb3VuZCIDZWdvIgZ0eElkNTgiCnBtdEFzc2V0SWQiCHBtdExwQW10Igt1c2VyQWRkcmVzcyIEbHBJZCIEYW1JZCIEcHJJZCIFYW1EY20iBXByRGNtIgNzdHMiB2xwRW1pc3MiCWFtQmFsYW5jZSIMYW1CYWxhbmNlWDE4IglwckJhbGFuY2UiDHByQmFsYW5jZVgxOCILY3VyUHJpY2VYMTgiCGN1clByaWNlIgtwbXRMcEFtdFgxOCIKbHBFbWlzc1gxOCILb3V0QW1BbXRYMTgiC291dFByQW10WDE4IghvdXRBbUFtdCIIb3V0UHJBbXQiBXN0YXRlIgNlcG8iB2luQW1BbXQiBmluQW1JZCIHaW5QckFtdCIGaW5QcklkIgZpc0V2YWwiBmVtaXRMcCIKaXNPbmVBc3NldCIQdmFsaWRhdGVTbGlwcGFnZSIGcG10QW10IgVwbXRJZCIHYW1JZFN0ciIHcHJJZFN0ciIJaW5BbUlkU3RyIglpblBySWRTdHIiBmFtdERjbSIIcHJpY2VEY20iBGxwRW0iD2luQW1Bc3NldEFtdFgxOCIPaW5QckFzc2V0QW10WDE4Igx1c2VyUHJpY2VYMTgiAXIiBmNoZWNrRCILc2xpcHBhZ2VYMTgiD3NsaXBwYWdlUmVhbFgxOCINbHBFbWlzc2lvblgxOCIKcHJWaWFBbVgxOCIKYW1WaWFQclgxOCIMZXhwZWN0ZWRBbXRzIhFleHBBbXRBc3NldEFtdFgxOCITZXhwUHJpY2VBc3NldEFtdFgxOCIJY2FsY0xwQW10Ig5jYWxjQW1Bc3NldFBtdCIOY2FsY1ByQXNzZXRQbXQiDHNsaXBwYWdlQ2FsYyIJZW1pdExwQW10IgZhbURpZmYiBnByRGlmZiINJHQwMjA1NzcyMDkyMiIKd3JpdGVBbUFtdCIKd3JpdGVQckFtdCILY29tbW9uU3RhdGUiBWdldFlEIgFEIgFuIgF4IgphUHJlY2lzaW9uIgFjIgFiIgNjdXIiDSR0MDIyMTE3MjIxMzciAXkiBXlOZXh0IgV5RGlmZiINJHQwMjI0NDQyMjQ5MSIHY2FsY0RMcCINYW1vdW50QmFsYW5jZSIMcHJpY2VCYWxhbmNlIgpscEVtaXNzaW9uIgp1cGRhdGVkRExwIg5jYWxjQ3VycmVudERMcCIQYW1vdW50QXNzZXREZWx0YSIPcHJpY2VBc3NldERlbHRhIhRscEFzc2V0RW1pc3Npb25EZWx0YSISYW1vdW50QXNzZXRCYWxhbmNlIhFwcmljZUFzc2V0QmFsYW5jZSIPbHBBc3NldEVtaXNzaW9uIgpjdXJyZW50RExwIhJyZWZyZXNoRExwSW50ZXJuYWwiF2Ftb3VudEFzc2V0QmFsYW5jZURlbHRhIhZwcmljZUFzc2V0QmFsYW5jZURlbHRhIgdhY3Rpb25zIhJ2YWxpZGF0ZVVwZGF0ZWRETHAiBm9sZERMcCIbdmFsaWRhdGVNYXRjaGVyT3JkZXJBbGxvd2VkIgVvcmRlciIRYW1vdW50QXNzZXRBbW91bnQiEHByaWNlQXNzZXRBbW91bnQiDSR0MDI0NTM1MjQ3NDciA2RMcCINJHQwMjUwNzcyNTE3NyINdW51c2VkQWN0aW9ucyIGZExwTmV3Igxpc09yZGVyVmFsaWQiBGluZm8iAmNnIgNwbXQiAmNwIgZjYWxsZXIiB2FtQXNQbXQiB3ByQXNQbXQiDWNhbGNQdXRPbmVUa24iCXBtdEFtdFJhdyILd2l0aFRha2VGZWUiDWNoZWNoRW1pc3Npb24iDSR0MDI3NTI5Mjc5OTEiDGFtQmFsYW5jZU9sZCIMcHJCYWxhbmNlT2xkIg0kdDAyNzk5NzI4MTczIgthbUFtb3VudFJhdyILcHJBbW91bnRSYXciDSR0MDI4MTc3Mjg0MzEiCGFtQW1vdW50IghwckFtb3VudCIMYW1CYWxhbmNlTmV3IgxwckJhbGFuY2VOZXciCGxwQW1vdW50Ig5wb29sUHJvcG9ydGlvbiIPYW1vdW50QXNzZXRQYXJ0Ig5wcmljZUFzc2V0UGFydCIJbHBBbXRCb3RoIgVib251cyITZ2V0T25lVGtuVjJJbnRlcm5hbCIKb3V0QXNzZXRJZCIMbWluT3V0QW1vdW50IghwYXltZW50cyIMb3JpZ2luQ2FsbGVyIg10cmFuc2FjdGlvbklkIgphbURlY2ltYWxzIgpwckRlY2ltYWxzIgpwb29sU3RhdHVzIg0kdDAzMDU0MzMwNjU0Igh0b3RhbEdldCILdG90YWxBbW91bnQiDSR0MDMwODQ0MzExNTEiBW91dEFtIgVvdXRQciIIY3VyUHJYMTgiBWN1clByIhFvdXRBc3NldElkT3JXYXZlcyIQc2VuZEZlZVRvTWF0Y2hlciIEYnVybiINJHQwMzE5MzYzMjI4NiIQZmVlQW1vdW50Rm9yQ2FsYyIQb3V0SW5BbW91bnRBc3NldCINJHQwMzIyODkzMjM5NyIRcmVmcmVzaERMcEFjdGlvbnMiEWlzVXBkYXRlZERMcFZhbGlkIgFtIgckbWF0Y2gwIgJwbSICcGQiCWlzTWFuYWdlciICcGsiAm1tIhdwZW5kaW5nTWFuYWdlclB1YmxpY0tleSICY20iA2hwbSIDY3BtIgRzbGlwIglhdXRvU3Rha2UiB2ZhY3RDZmciC3N0YWtpbmdDbnRyIghzbGlwQ250ciIKYW1Bc3NldFBtdCIKcHJBc3NldFBtdCIBZSIJbHBBc3NldElkIgJlbCIGbGVnYWN5IgJzYSICc3AiCGxwVHJuc2ZyIgJzcyINJHQwMzY1NDYzNjY4OCIFY2hlY2siFGxwQXNzZXRFbWlzc2lvbkFmdGVyIiBpc1Bvb2xPbmVUb2tlbk9wZXJhdGlvbnNEaXNhYmxlZCINaXNQdXREaXNhYmxlZCIGY2hlY2tzIg0kdDAzODMyOTM4NDg3Igdlc3RpbUxQIg0kdDAzOTMwMjM5NjUxIhRwYXltZW50SW5BbW91bnRBc3NldCINJHQwMzk2NTQzOTc2MiIHbWF4U2xwZyIGZXN0UHV0Ig0kdDA0MDc5MjQwODU3IglvdXRBbXRBbXQiDSR0MDQyMDMwNDIxMTIiDWlzR2V0RGlzYWJsZWQiDSR0MDQyNzMwNDI4ODUiGGxhc3RSZWZyZXNoZWRCbG9ja0hlaWdodCIdY2hlY2tMYXN0UmVmcmVzaGVkQmxvY2tIZWlnaHQiDSR0MDQzNDA5NDM0NzMiEGRMcFVwZGF0ZUFjdGlvbnMiDWxwQXNzZXRBbW91bnQiBWluZGV4IgRuZXdZIgJkeSILdG90YWxHZXRSYXciDSR0MDQ0NDAzNDQ0NTgiDSR0MDQ0ODMzNDQ5NDgiDnN1bU9mR2V0QXNzZXRzIhJub0xlc3NUaGVuQW10QXNzZXQiFG5vTGVzc1RoZW5QcmljZUFzc2V0IhRidXJuTFBBc3NldE9uRmFjdG9yeSINJHQwNDYxMTQ0NjE5NSINY2hlY2tQYXltZW50cyIKZmFjdG9yeUNmZyIHc3Rha2luZyIKdW5zdGFrZUludiIBdiIFYnVybkEiDSR0MDQ3MjIyNDczMDMiDXVuc3Rha2VBbW91bnQiFW5vTGVzc1RoZW5BbW91bnRBc3NldCIDcmVzIgxjaGVja0Ftb3VudHMiDSR0MDQ4NTU0NDg2MzUiDSR0MDQ5NTMwNDk3MTgiEHBheW1lbnRBbW91bnRSYXciDnBheW1lbnRBc3NldElkIg0kdDA0OTg0NjQ5OTQ5Ig0kdDA1MDA5NzUwMjAxIghhbXRBc1N0ciIHcHJBc1N0ciIBayICcHIiDHJlc1NjYWxlTXVsdCIHdXNyQWRkciIHcG10QXNJZCICdHgiBnZlcmlmeSIPdGFyZ2V0UHVibGljS2V5IgptYXRjaGVyUHViIg0kdDA1Mjk5MzUzMDYyIgduZXdIYXNoIgthbGxvd2VkSGFzaCILY3VycmVudEhhc2iBAQABYQCAwtcvAAFiCQC2AgEAgMLXLwABYwkAtgIBAICAkLu61q3wDQABZAkAtgIBAAAAAWUJALYCAQAAAAFmCQC2AgEAAQABZwkAtgIBAAIAAWgJALYCAQADAAFpCQC2AgEABAABagkAtgIBCQBlAgUBYQkAaQIJAGgCBQFhAAEFAWEAAWsCBVdBVkVTAAFsAgMxMDAAAW0CATEAAW4CAl9fAAFvAgAAAXAAAQABcQACAAFyAAMAAXMABAABdAABAAF1AAIAAXYAAwABdwAEAAF4AAUAAXkABgABegAHAAFBAAgAAUIACQABQwABAAFEAAYAAUUABwABRgAKAAFHCQBrAwAKBQFhAJBOAQFIAgFJAUoJALwCAwkAtgIBBQFJBQFjCQC2AgEFAUoBAUsCAUkBSgkAvAIDBQFJBQFjBQFKAQFMAgFNAU4JAKADAQkAvAIDBQFNCQC2AgEFAU4FAWMBAU8DAU0BTgFQCQCgAwEJAL0CBAUBTQkAtgIBBQFOBQFjBQFQAQFRAgFJAUoJALwCAwUBSQUBYwkAtgIBBQFKAQFSAgFNAU4JALwCAwUBTQkAtgIBBQFOBQFjAQFTAwFUAVUBVgkAawMFAVQFAVUFAVYBAVcBAU0DCQC/AgIFAWQFAU0JAL4CAQUBTQUBTQEBWAEBTQMJAL8CAgUBZAUBTQkAvgIBBQFNBQFNAQFZAAITJXNfX2ZhY3RvcnlDb250cmFjdAEBWgACFCVzX19tYW5hZ2VyUHVibGljS2V5AQJhYQACGyVzX19wZW5kaW5nTWFuYWdlclB1YmxpY0tleQECYWIAAhElcyVzX19wcmljZV9fbGFzdAECYWMCAmFkAmFlCQC5CQIJAMwIAgIYJXMlcyVkJWRfX3ByaWNlX19oaXN0b3J5CQDMCAIJAKQDAQUCYWQJAMwIAgkApAMBBQJhZQUDbmlsBQFuAQJhZgICYWcCYWgJAKwCAgkArAICCQCsAgICCyVzJXMlc19fUF9fBQJhZwICX18FAmFoAQJhaQICYWcCYWgJAKwCAgkArAICCQCsAgICCyVzJXMlc19fR19fBQJhZwICX18FAmFoAQJhagACDyVzX19hbW91bnRBc3NldAECYWsAAg4lc19fcHJpY2VBc3NldAECYWwAAgclc19fYW1wAQJhbQACDSVzX19hZGRvbkFkZHIAAmFuAgclc19fZmVlAAJhbwkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBQJhbgUBRwACYXAJALkJAgkAzAgCAgIlcwkAzAgCAgNkTHAFA25pbAUBbgACYXEJALkJAgkAzAgCAgIlcwkAzAgCAhJkTHBSZWZyZXNoZWRIZWlnaHQFA25pbAUBbgACYXIJALkJAgkAzAgCAgIlcwkAzAgCAg9yZWZyZXNoRExwRGVsYXkFA25pbAUBbgACYXMAAQACYXQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwUCYXIFAmFzAQJhdQACESVzX19mYWN0b3J5Q29uZmlnAQJhdgACGCVzJXNfX21hdGNoZXJfX3B1YmxpY0tleQECYXcCAmF4AmF5CQCsAgIJAKwCAgkArAICCQCsAgICCCVkJWQlc19fBQJheAICX18FAmF5AghfX2NvbmZpZwECYXoBAmFBCQCsAgICKCVzJXMlc19fbWFwcGluZ3NfX2Jhc2VBc3NldDJpbnRlcm5hbElkX18FAmFBAQJhQgACDCVzX19zaHV0ZG93bgECYUMAAh0lc19fYWxsb3dlZExwU3RhYmxlU2NyaXB0SGFzaAECYUQAAhclc19fZmVlQ29sbGVjdG9yQWRkcmVzcwECYUUEAmFGAmFHAmFIAmFJCQACAQkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkArAICCQCsAgICJG9yZGVyIHZhbGlkYXRpb24gZmFpbGVkOiBvcmRlclZhbGlkPQkApQMBBQJhRgICICgFAmFHAgEpAg0gc2VuZGVyVmFsaWQ9CQClAwEFAmFIAg4gbWF0Y2hlclZhbGlkPQkApQMBBQJhSQECYUoCAmFLAmFMCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJ0IAgUCYUsFAmFMCQC5CQIJAMwIAgIKbWFuZGF0b3J5IAkAzAgCCQClCAEFAmFLCQDMCAICAS4JAMwIAgUCYUwJAMwIAgIMIG5vdCBkZWZpbmVkBQNuaWwCAAECYU0CAmFLAmFMCQETdmFsdWVPckVycm9yTWVzc2FnZQIJAJoIAgUCYUsFAmFMCQC5CQIJAMwIAgIKbWFuZGF0b3J5IAkAzAgCCQClCAEFAmFLCQDMCAICAS4JAMwIAgUCYUwJAMwIAgIMIG5vdCBkZWZpbmVkBQNuaWwCAAECYU4BAmFPCQACAQkAuQkCCQDMCAICD2xwX3N0YWJsZS5yaWRlOgkAzAgCBQJhTwUDbmlsAgEgAQJhUAECYU8JALkJAgkAzAgCAg9scF9zdGFibGUucmlkZToJAMwIAgUCYU8FA25pbAIBIAACYVEJARFAZXh0ck5hdGl2ZSgxMDYyKQEJAQJhSgIFBHRoaXMJAQFZAAACYVIKAAJhUwkA/AcEBQJhUQIQZ2V0SW5GZWVSRUFET05MWQkAzAgCCQClCAEFBHRoaXMFA25pbAUDbmlsAwkAAQIFAmFTAgNJbnQFAmFTCQACAQkArAICCQADAQUCYVMCGCBjb3VsZG4ndCBiZSBjYXN0IHRvIEludAACYVQKAAJhUwkA/AcEBQJhUQIRZ2V0T3V0RmVlUkVBRE9OTFkJAMwIAgkApQgBBQR0aGlzBQNuaWwFA25pbAMJAAECBQJhUwIDSW50BQJhUwkAAgEJAKwCAgkAAwEFAmFTAhggY291bGRuJ3QgYmUgY2FzdCB0byBJbnQAAmFVCQECYUoCBQR0aGlzCQECYWwAAQJhVgAJAQt2YWx1ZU9yRWxzZQIJAJsIAgUCYVEJAQJhQgAHAQJhVwAJANkEAQkBAmFKAgUCYVEJAQJhdgAAAmFYCQERQGV4dHJOYXRpdmUoMTA2MikBCQECYUoCBQJhUQkBAmFEAAECYVkABAJhWgkBAmFKAgUEdGhpcwkBAmFqAAQCYmEJAQJhSgIFBHRoaXMJAQJhawAEAmJiCQECYU0CBQJhUQkBAmF6AQUCYmEEAmF4CQECYU0CBQJhUQkBAmF6AQUCYVoJALUJAgkBAmFKAgUCYVEJAQJhdwIJAKQDAQUCYXgJAKQDAQUCYmIFAW4BAmJjAQJiZAMJAAACBQJiZAUBawUEdW5pdAkA2QQBBQJiZAECYmUBAmJkAwkAAAIFAmJkBQR1bml0BQFrCQDYBAEJAQV2YWx1ZQEFAmJkAQJiZgECYmcJAJsKCQkBEUBleHRyTmF0aXZlKDEwNjIpAQkAkQMCBQJiZwUBdAkBDXBhcnNlSW50VmFsdWUBCQCRAwIFAmJnBQF1CQDZBAEJAJEDAgUCYmcFAXYJAQJiYwEJAJEDAgUCYmcFAXcJAQJiYwEJAJEDAgUCYmcFAXgJAQ1wYXJzZUludFZhbHVlAQkAkQMCBQJiZwUBeQkBDXBhcnNlSW50VmFsdWUBCQCRAwIFAmJnBQF6CQDZBAEJAJEDAgUCYmcFAUEJANkEAQkAkQMCBQJiZwUBQgACYmgJAQJiZgEJAQJhWQAAAmJpBQJiaAACYmoIBQJiaQJfMQACYmsIBQJiaQJfMgACYmwIBQJiaQJfMwACYm0IBQJiaQJfNAACYm4IBQJiaQJfNQACYm8IBQJiaQJfNgACYnAIBQJiaQJfNwACYnEIBQJiaQJfOAACYnIIBQJiaQJfOQECYnMACQC1CQIJAQJhSgIFAmFRCQECYXUABQFuAAJidAkBAmJzAAACYnUJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFAmJ0BQFDAiBJbnZhbGlkIHN0YWtpbmcgY29udHJhY3QgYWRkcmVzcwACYnYJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFAmJ0BQFFAiBJbnZhbGlkIHNsaXBhZ2UgY29udHJhY3QgYWRkcmVzcwACYncJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFAmJ0BQFGAhxJbnZhbGlkIGd3eCBjb250cmFjdCBhZGRyZXNzAAJieAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEJAJEDAgUCYnQFAUQCHEludmFsaWQgZ3d4IGNvbnRyYWN0IGFkZHJlc3MBAmJ5CgJiegJiQQJiQgJiQwJiRAJiRQJiRgJiRwJiSAJiSQkAuQkCCQDMCAICFCVkJWQlZCVkJWQlZCVkJWQlZCVkCQDMCAIJAKQDAQUCYnoJAMwIAgkApAMBBQJiQQkAzAgCCQCkAwEFAmJCCQDMCAIJAKQDAQUCYkMJAMwIAgkApAMBBQJiRAkAzAgCCQCkAwEFAmJFCQDMCAIJAKQDAQUCYkYJAMwIAgkApAMBBQJiRwkAzAgCCQCkAwEFAmJICQDMCAIJAKQDAQUCYkkFA25pbAUBbgECYkoGAmJLAmJMAmJNAmJDAmJGAmJHCQC5CQIJAMwIAgIMJWQlZCVkJWQlZCVkCQDMCAIJAKQDAQUCYksJAMwIAgkApAMBBQJiTAkAzAgCCQCkAwEFAmJNCQDMCAIJAKQDAQUCYkMJAMwIAgkApAMBBQJiRgkAzAgCCQCkAwEFAmJHBQNuaWwFAW4BAmJOAQJiTwMJAAACBQJiTwIFV0FWRVMICQDvBwEFBHRoaXMJYXZhaWxhYmxlCQDwBwIFBHRoaXMJANkEAQUCYk8BAmJQAgJiUQJiUgkAvAIDBQJiUQUBYwUCYlIBAmJTAwJiUQJiUgFQCQC9AgQFAmJRBQFjBQJiUgUBUAECYlQDAmJVAmJWAmJXBAJiWAkAvAIDCQC4AgIFAmJVBQJiVgUBYgUCYlYEAmJZCQC/AgIJALgCAgUCYlcJAQFXAQUCYlgFAWQDCQEBIQEFAmJZCQACAQkArAICAgpCaWcgc2xwZzogCQCmAwEFAmJYCQCUCgIFAmJZCQCZAwEJAMwIAgUCYlUJAMwIAgUCYlYFA25pbAECYloDAmNhAmNiAmNjBAJiWAkAvAIDBQJjYgUBYgUCY2EEAmNkCQC/AgIFAmNjBQJiWAMDBQJjZAYJAL8CAgUCY2IFAmNhCQACAQkArAICCQCsAgIJAKwCAgkArAICCQCsAgIJAKwCAgkApgMBBQJjYgIBIAkApgMBBQJjYQIBIAkApgMBBQJiWAIBIAkApgMBBQJjYwUCY2QBAmNlBAJjZgJjZwJjaAJjaQQCY2oJAQFIAgUCY2gFAmNmBAJjawkBAUgCBQJjaQUCY2cJAQJiUAIFAmNrBQJjagECY2wDAmNoAmNpAmNtBAJjbgUCYm8EAmNvBQJicAQCY3AJAQJjZQQFAmNuBQJjbwUCY2gFAmNpBAJiUgkBAUgCBQJjaAUCY24EAmJRCQEBSAIFAmNpBQJjbwQCY3EJAQFIAgUCY20FAWEEAmNyCQECYlACBQJiUgUCY3EEAmNzCQECYlACBQJiUQUCY3EJAMwIAgUCY3AJAMwIAgUCY3IJAMwIAgUCY3MFA25pbAECY3QDAmNoAmNpAmNtBAJjdQkBAmNsAwUCY2gFAmNpBQJjbQkAzAgCCQEBTAIJAJEDAgUCY3UAAAUBYQkAzAgCCQEBTAIJAJEDAgUCY3UAAQUBYQkAzAgCCQEBTAIJAJEDAgUCY3UAAgUBYQUDbmlsAQJjdgICY3cCYW8EAmN4AwkAAAIFAmFvAAAAAAkAawMFAmN3BQJhbwUBYQkAlAoCCQBlAgUCY3cFAmN4BQJjeAECY3kBAmN6BAJjQQkAkQMCBQJjegAABAJjQgkAkQMCBQJjegABBAJjQwkAtwICBQJjQQUCY0IDCQAAAgUCY0MFAWUFAWUEAmNECQENcGFyc2VJbnRWYWx1ZQEFAmFVBAJjRQkAaAIFAmNEAAIEAmN1CQC8AgMFAmNBBQJjQgUBZgQCY0YJALwCAwUCY3UFAWkFAWYEAmNHCQC8AgMJALYCAQUCY0UFAmNDBQFmBAJjSAkAtgIBCQBlAgUCY0UAAQoBAmNJAQJjSgQCY0sJALwCAwUCY0oFAmNKBQFmBAJjTAkAvAIDBQJjSwUCY0oFAWYEAmNNCQC8AgMFAmNMBQFmBQJjRgkAvAIDCQC3AgIFAmNHCQC8AgMFAmNNBQFnBQFmBQJjSgkAtwICCQC8AgMFAmNIBQJjSgUBZgkAvAIDBQFoBQJjTQUBZgoBAmNOAgJjTwJjUAMIBQJjTwJfMgUCY08EAmNKCAUCY08CXzEEAmNRCQECY0kBBQJjSgQCY1IJALgCAgUCY1EJAQV2YWx1ZQEFAmNKBAJjUwMJAL8CAgUBZQUCY1IJAL4CAQUCY1IFAmNSAwkAwAICBQFmBQJjUwkAlAoCBQJjUQYJAJQKAgUCY1EHBAJjVAkAzAgCAAAJAMwIAgABCQDMCAIAAgkAzAgCAAMJAMwIAgAECQDMCAIABQkAzAgCAAYJAMwIAgAHCQDMCAIACAkAzAgCAAkJAMwIAgAKCQDMCAIACwkAzAgCAAwJAMwIAgANCQDMCAIADgUDbmlsBAJjVQoAAmNWBQJjVAoAAmNXCQCQAwEFAmNWCgACY1gJAJQKAgUCY0MHCgECY1kCAmNaAmRhAwkAZwIFAmRhBQJjVwUCY1oJAQJjTgIFAmNaCQCRAwIFAmNWBQJkYQoBAmRiAgJjWgJkYQMJAGcCBQJkYQUCY1cFAmNaCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTUJAQJkYgIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIFAmNYAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8EAmNKCAUCY1UCXzEEAmRjCAUCY1UCXzIDBQJkYwUCY0oJAAIBCQCsAgICGUQgY2FsY3VsYXRpb24gZXJyb3IsIEQgPSAJAKYDAQUCY0oBAmRkBAJkZQJkZgJkZwJkaAQCZGkFAmJsBAJkagkA2AQBCQEFdmFsdWUBBQJibQQCZGsJANgEAQkBBXZhbHVlAQUCYm4EAmRsBQJibwQCZG0FAmJwBAJkbgkApAMBBQJiawQCZG8ICQETdmFsdWVPckVycm9yTWVzc2FnZQIJAOwHAQUCZGkCC1dyb25nIExQIGlkCHF1YW50aXR5AwkBAiE9AgkA2AQBBQJkaQUCZGYJAAIBAg9Xcm9uZyBwbXQgYXNzZXQEAmRwCQECYk4BBQJkagQCZHEJAQFIAgUCZHAFAmRsBAJkcgkBAmJOAQUCZGsEAmRzCQEBSAIFAmRyBQJkbQQCZHQJAQJiUAIFAmRzBQJkcQQCZHUJAQFMAgUCZHQFAWEEAmR2CQEBSAIFAmRnBQFhBAJkdwkBAUgCBQJkbwUBYQQCZHgJALwCAwUCZHEFAmR2BQJkdwQCZHkJALwCAwUCZHMFAmR2BQJkdwQCZHoJAQFPAwUCZHgFAmRsBQVGTE9PUgQCZEEJAQFPAwUCZHkFAmRtBQVGTE9PUgQCZEIDCQAAAgUCZGUCAAUDbmlsCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFAmRoBQJkegMJAAACBQJkagIFV0FWRVMFBHVuaXQJANkEAQUCZGoJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwUCZGgFAmRBAwkAAAIFAmRrAgVXQVZFUwUEdW5pdAkA2QQBBQJkawkAzAgCCQELU3RyaW5nRW50cnkCCQECYWkCCQClCAEFAmRoBQJkZQkBAmJKBgUCZHoFAmRBBQJkZwUCZHUFBmhlaWdodAgFCWxhc3RCbG9jawl0aW1lc3RhbXAJAMwIAgkBDEludGVnZXJFbnRyeQIJAQJhYgAFAmR1CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQECYWMCBQZoZWlnaHQIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQJkdQUDbmlsCQCcCgoFAmR6BQJkQQUCZGoFAmRrBQJkcAUCZHIFAmRvBQJkdAUCZG4FAmRCAQJkQw0CZGUCYlcCZEQCZEUCZEYCZEcCZGgCZEgCZEkCZEoCZEsCZEwCZE0EAmRpBQJibAQCZE4JANgEAQkBBXZhbHVlAQUCYm0EAmRPCQDYBAEJAQV2YWx1ZQEFAmJuBAJkUAUCYnEEAmRRBQJicgQCZFIFAmJvBAJkUwUCYnAEAmRuCQCkAwEFAmJrBAJkVAgJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkA7AcBBQJkaQIIV3IgbHAgYXMIcXVhbnRpdHkEAmRwAwUCZEgJAQJiTgEFAmROAwMFAmRKCQAAAgUCZE0FAmROBwkAZQIJAQJiTgEFAmROBQJkTAMFAmRKCQECYk4BBQJkTgkAZQIJAQJiTgEFAmROBQJkRAQCZHIDBQJkSAkBAmJOAQUCZE8DAwUCZEoJAAACBQJkTQUCZE8HCQBlAgkBAmJOAQUCZE8FAmRMAwUCZEoJAQJiTgEFAmRPCQBlAgkBAmJOAQUCZE8FAmRGBAJkVQkBAUgCBQJkRAUCZFIEAmRWCQEBSAIFAmRGBQJkUwQCZFcJAQJiUAIFAmRWBQJkVQQCZHEJAQFIAgUCZHAFAmRSBAJkcwkBAUgCBQJkcgUCZFMEAmNiCQECY3kBCQDMCAIFAmRxCQDMCAIFAmRzBQNuaWwEAmRYAwkAAAIFAmRUAAAEAmNhCQECY3kBCQDMCAIJALcCAgUCZHEFAmRVCQDMCAIJALcCAgUCZHMFAmRWBQNuaWwEAmRZAwkAvwICBQJjYQUCY2IGCQACAQIcRDEgc2hvdWxkIGJlIGdyZWF0ZXIgdGhhbiBEMAMJAAACBQJkWQUCZFkEAmR0BQFkBAJkWgUBZAQCY3EFAmNhCQCXCgUJAQFMAgUCY3EFAWEJAQFMAgUCZFUFAmRSCQEBTAIFAmRWBQJkUwkBAmJQAgkAtwICBQJkcwUCZFYJALcCAgUCZHEFAmRVBQJkWgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgQCZHQJAQJiUAIFAmRzBQJkcQQCZWEJALwCAwkBAVcBCQC4AgIFAmR0BQJkVwUBYwUCZHQEAmRaCQEBSAIFAmJXBQFhAwMDBQJkSwkBAiE9AgUCZHQFAWQHCQC/AgIFAmVhBQJkWgcJAAIBCQCsAgIJAKwCAgkArAICAg9QcmljZSBzbGlwcGFnZSAJAKYDAQUCZWECAyA+IAkApgMBBQJkWgQCZWIJAQFIAgUCZFQFAWEEAmVjCQC9AgQFAmRVCQECYlMDBQJkcwUCZHEFB0NFSUxJTkcFAWMFB0NFSUxJTkcEAmVkCQC9AgQFAmRWBQFjCQECYlMDBQJkcwUCZHEFBUZMT09SBQdDRUlMSU5HBAJlZQMJAL8CAgUCZWMFAmRWCQCUCgIFAmVkBQJkVgkAlAoCBQJkVQUCZWMEAmVmCAUCZWUCXzEEAmVnCAUCZWUCXzIEAmNhCQECY3kBCQDMCAIJALcCAgUCZHEFAmVmCQDMCAIJALcCAgUCZHMFAmVnBQNuaWwEAmRZAwkAvwICBQJjYQUCY2IGCQACAQIcRDEgc2hvdWxkIGJlIGdyZWF0ZXIgdGhhbiBEMAMJAAACBQJkWQUCZFkEAmNxCQC8AgMFAmViCQC4AgIFAmNhBQJjYgUCY2IJAJcKBQkBAU8DBQJjcQUBYQUFRkxPT1IJAQFPAwUCZWYFAmRSBQdDRUlMSU5HCQEBTwMFAmVnBQJkUwUHQ0VJTElORwUCZHQFAmRaCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuBAJlaAgFAmRYAl8xBAJlaQgFAmRYAl8yBAJlaggFAmRYAl8zBAJkdQkBAUwCCAUCZFgCXzQFAWEEAmVrCQEBTAIIBQJkWAJfNQUBYQMJAGcCAAAFAmVoCQACAQIHTFAgPD0gMAQCZWwDCQEBIQEFAmRJAAAFAmVoBAJlbQkAZQIFAmREBQJlaQQCZW4JAGUCBQJkRgUCZWoEAmVvAwMFAmRKCQAAAgUCZE0FAmROBwkAlAoCBQJkTAAAAwMFAmRKCQAAAgUCZE0FAmRPBwkAlAoCAAAFAmRMCQCUCgIFAmVpBQJlagQCZXAIBQJlbwJfMQQCZXEIBQJlbwJfMgQCZXIJAMwIAgkBDEludGVnZXJFbnRyeQIJAQJhYgAFAmR1CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQECYWMCBQZoZWlnaHQIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQJkdQkAzAgCCQELU3RyaW5nRW50cnkCCQECYWYCBQJkaAUCZGUJAQJieQoFAmVwBQJlcQUCZWwFAmR1BQJiVwUCZWsFBmhlaWdodAgFCWxhc3RCbG9jawl0aW1lc3RhbXAFAmVtBQJlbgUDbmlsCQCfCg0FAmVoBQJlbAUCZHUFAmRwBQJkcgUCZFQFAmRpBQJkbgUCZXIFAmVtBQJlbgUCZEUFAmRHAQJlcwMCY3oCY1ACZXQEAmV1BQFnBAJldgkAkQMCBQJjegMJAAACBQJjUAAAAAEAAAQCZXcJAKcDAQUBbAQCY0QJALkCAgkApwMBBQJhVQUCZXcEAmNDBQJldgQCY0UJALkCAgUCY0QFAmV1BAJleAkAugICCQC5AgIJALkCAgkAugICCQC5AgIFAmV0BQJldAkAuQICBQJldgUCZXUFAmV0BQJldwkAuQICBQJjRQUCZXUEAmV5CQC4AgIJALcCAgUCY0MJALoCAgkAuQICBQJldAUCZXcFAmNFBQJldAoBAmNOAgJjTwJlegQCZUEFAmNPBAJlQggFAmVBAl8xBAJkYwgFAmVBAl8yAwkBAiE9AgUCZGMFBHVuaXQFAmNPBAJlQwkAugICCQC3AgIJALkCAgUCZUIFAmVCBQJleAkAtwICCQC5AgIFAWcFAmVCBQJleQQCZUQJAQFYAQkAuAICBQJlQwkBBXZhbHVlAQUCZUIDCQDAAgIFAWYFAmVECQCUCgIFAmVDBQJlegkAlAoCBQJlQwUEdW5pdAQCY1QJAMwIAgAACQDMCAIAAQkAzAgCAAIJAMwIAgADCQDMCAIABAkAzAgCAAUJAMwIAgAGCQDMCAIABwkAzAgCAAgJAMwIAgAJCQDMCAIACgkAzAgCAAsJAMwIAgAMCQDMCAIADQkAzAgCAA4FA25pbAQCZUUKAAJjVgUCY1QKAAJjVwkAkAMBBQJjVgoAAmNYCQCUCgIFAmV0BQR1bml0CgECY1kCAmNaAmRhAwkAZwIFAmRhBQJjVwUCY1oJAQJjTgIFAmNaCQCRAwIFAmNWBQJkYQoBAmRiAgJjWgJkYQMJAGcCBQJkYQUCY1cFAmNaCQACAQIUTGlzdCBzaXplIGV4Y2VlZHMgMTUJAQJkYgIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIJAQJjWQIFAmNYAAAAAQACAAMABAAFAAYABwAIAAkACgALAAwADQAOAA8EAmVCCAUCZUUCXzEEAmRjCAUCZUUCXzIDCQECIT0CBQJkYwUEdW5pdAUCZUIJAAIBCQCsAgICGVkgY2FsY3VsYXRpb24gZXJyb3IsIFkgPSAJAKYDAQUCZUIBAmVGAwJlRwJlSAJlSQQCZUoJALwCAwkBAmN5AQkAzAgCCQEBSwIFAmVHCQC2AgEFAmJvCQDMCAIJAQFLAgUCZUgJALYCAQUCYnAFA25pbAUBYwUCZUkDCQAAAgUCZUkFAWUFAWUFAmVKAQJlSwMCZUwCZU0CZU4EAmVPCQC4AgIJALYCAQkBAmJOAQkBAmJlAQUCYm0FAmVMBAJlUAkAuAICCQC2AgEJAQJiTgEJAQJiZQEFAmJuBQJlTQQCZVEJALgCAgkAtgIBCAkBBXZhbHVlAQkA7AcBBQJibAhxdWFudGl0eQUCZU4EAmVSCQECZUYDBQJlTwUCZVAFAmVRBQJlUgECZVMDAmVUAmVVAmVOBAJlTwkAZAIJAQJiTgEJAQJiZQEFAmJtBQJlVAQCZVAJAGQCCQECYk4BCQECYmUBBQJibgUCZVUEAmVRCQBkAggJAQV2YWx1ZQEJAOwHAQUCYmwIcXVhbnRpdHkFAmVOBAJlSgkBAmVGAwkAtgIBBQJlTwkAtgIBBQJlUAkAtgIBBQJlUQQCZVYJAMwIAgkBDEludGVnZXJFbnRyeQIFAmFxBQZoZWlnaHQJAMwIAgkBC1N0cmluZ0VudHJ5AgUCYXAJAKYDAQUCZUoFA25pbAkAlAoCBQJlVgUCZUoBAmVXAgJlWAJlSgMJAMACAgUCZUoFAmVYBgkBAmFOAQIidXBkYXRlZCBETHAgbG93ZXIgdGhhbiBjdXJyZW50IERMcAECZVkBAmVaBAJmYQgFAmVaBmFtb3VudAQCZmIJAG4ECAUCZVoGYW1vdW50CAUCZVoFcHJpY2UFAWEFBUZMT09SBAJmYwMJAAACCAUCZVoJb3JkZXJUeXBlBQNCdXkJAJQKAgUCZmEJAQEtAQUCZmIJAJQKAgkBAS0BBQJmYQUCZmIEAmVUCAUCZmMCXzEEAmVVCAUCZmMCXzIDAwMJAQJhVgAGCQAAAgUCYmsFAXIGCQAAAgUCYmsFAXMJAAIBAg1BZG1pbiBibG9ja2VkAwMJAQIhPQIICAUCZVoJYXNzZXRQYWlyC2Ftb3VudEFzc2V0BQJibQYJAQIhPQIICAUCZVoJYXNzZXRQYWlyCnByaWNlQXNzZXQFAmJuCQACAQIJV3IgYXNzZXRzBAJmZAkApwMBCQERQGV4dHJOYXRpdmUoMTA1MykCBQR0aGlzBQJhcAQCZmUJAQJlUwMFAmVUBQJlVQAABAJmZggFAmZlAl8xBAJmZwgFAmZlAl8yBAJmaAkAwAICBQJmZwUCZmQEAmZpCQC5CQIJAMwIAgkApgMBBQJmZAkAzAgCCQCmAwEFAmZnBQNuaWwCASAJAJQKAgUCZmgFAmZpAQJmagECY1ADCQECIT0CCQCQAwEIBQJjUAhwYXltZW50cwABCQACAQIKMSBwbW50IGV4cAQCZmsJAQV2YWx1ZQEJAJEDAggFAmNQCHBheW1lbnRzAAAEAmRmCQEFdmFsdWUBCAUCZmsHYXNzZXRJZAQCZEwIBQJmawZhbW91bnQEAmRYCQECZGQECQDYBAEIBQJjUA10cmFuc2FjdGlvbklkCQDYBAEFAmRmBQJkTAgFAmNQBmNhbGxlcgQCZHoIBQJkWAJfMQQCZEEIBQJkWAJfMgQCZG4JAQ1wYXJzZUludFZhbHVlAQgFAmRYAl85BAJkQggFAmRYA18xMAMDCQECYVYABgkAAAIFAmRuBQFzCQACAQkArAICAg9BZG1pbiBibG9ja2VkOiAJAKQDAQUCZG4JAJcKBQUCZHoFAmRBBQJkTAUCZGYFAmRCAQJmbAoCZm0CYWgCZm4CZm8CYlcCZEkCZEoCZEsCZEwCZE0EAmRYCQECZEMNBQJhaAUCYlcICQEFdmFsdWUBBQJmbgZhbW91bnQICQEFdmFsdWUBBQJmbgdhc3NldElkCAkBBXZhbHVlAQUCZm8GYW1vdW50CAkBBXZhbHVlAQUCZm8HYXNzZXRJZAUCZm0JAAACBQJhaAIABQJkSQUCZEoFAmRLBQJkTAUCZE0EAmRuCQENcGFyc2VJbnRWYWx1ZQEIBQJkWAJfOAMDAwkBAmFWAAYJAAACBQJkbgUBcQYJAAACBQJkbgUBcwkAAgEJAKwCAgIIQmxvY2tlZDoJAKQDAQUCZG4FAmRYAQJmcAUCZnECZGYCZGgCYWgCZnIEAmRqCQDYBAEJAQV2YWx1ZQEFAmJtBAJkawkA2AQBCQEFdmFsdWUBBQJibgQCZGkFAmJsBAJkUgUCYm8EAmRTBQJicAQCZVEJALYCAQgJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkA7AcBBQJkaQIQaW52YWxpZCBscCBhc3NldAhxdWFudGl0eQQCZnMDCQC/AgIFAmVRBQFlBgkAAgECImluaXRpYWwgZGVwb3NpdCByZXF1aXJlcyBhbGwgY29pbnMDCQAAAgUCZnMFAmZzBAJkcAkBAmJOAQUCZGoEAmRyCQECYk4BBQJkawQCZnQDCQAAAgUCYWgCAAkAlAoCBQJkcAUCZHIDCQAAAgUCZGYFAmRqAwkAZgIFAmZxBQJkcAkAAgECFmludmFsaWQgcGF5bWVudCBhbW91bnQJAJQKAgkAZQIFAmRwBQJmcQUCZHIDCQAAAgUCZGYFAmRrAwkAZgIFAmZxBQJkcgkAAgECFmludmFsaWQgcGF5bWVudCBhbW91bnQJAJQKAgUCZHAJAGUCBQJkcgUCZnEJAAIBAhB3cm9uZyBwbXRBc3NldElkBAJmdQgFAmZ0Al8xBAJmdggFAmZ0Al8yBAJmdwMJAAACBQJkZgUCZGoJAJQKAgUCZnEAAAMJAAACBQJkZgUCZGsJAJQKAgAABQJmcQkAAgECD2ludmFsaWQgcGF5bWVudAQCZngIBQJmdwJfMQQCZnkIBQJmdwJfMgQCZnoDBQJmcgkAlQoDCAkBAmN2AgUCZngFAmFSAl8xCAkBAmN2AgUCZnkFAmFSAl8xCAkBAmN2AgUCZnEFAmFSAl8yCQCVCgMFAmZ4BQJmeQAABAJmQQgFAmZ6Al8xBAJmQggFAmZ6Al8yBAJjeAgFAmZ6Al8zBAJmQwkAZAIFAmZ1BQJmQQQCZkQJAGQCBQJmdgUCZkIEAmNiCQECY3kBCQDMCAIJAQFIAgUCZnUFAmJvCQDMCAIJAQFIAgUCZnYFAmJwBQNuaWwEAmNhCQECY3kBCQDMCAIJAQFIAgUCZkMFAmJvCQDMCAIJAQFIAgUCZkQFAmJwBQNuaWwEAmRZAwkAvwICBQJjYQUCY2IGCQEFdGhyb3cAAwkAAAIFAmRZBQJkWQQCZkUJAL0CBAUCZVEJALgCAgUCY2EFAmNiBQJjYgUFRkxPT1IEAmR1CQEBTAIJAQJiUAIJAQFIAgUCZkQFAmRTCQEBSAIFAmZDBQJkUgUBYQQCZXIJAMwIAgkBDEludGVnZXJFbnRyeQIJAQJhYgAFAmR1CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQECYWMCBQZoZWlnaHQIBQlsYXN0QmxvY2sJdGltZXN0YW1wBQJkdQkAzAgCCQELU3RyaW5nRW50cnkCCQECYWYCBQJkaAUCYWgJAQJieQoFAmZ4BQJmeQkAoAMBBQJmRQUCZHUAAAAABQZoZWlnaHQIBQlsYXN0QmxvY2sJdGltZXN0YW1wAAAAAAUDbmlsBAJmRgkAawMFAmZ2BQFhBQJmdQQCZkcJAGsDBQJmcQUBYQkAZAIFAmZGBQFhBAJmSAkAZQIFAmZxBQJmRwQCZkkJALwCAwUCZVEJALYCAQUCZkgJALYCAQUCZnYEAmZKCQCgAwEJALwCAwkAuAICBQJmRQUCZkkFAWIFAmZJCQCWCgQJAKADAQUCZkUFAmVyBQJjeAUCZkoJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAmZLBgJmTAJmTQJmTgJmbQJmTwJmUAQCZGkJANgEAQkBBXZhbHVlAQUCYmwEAmRqCQDYBAEJAQV2YWx1ZQEFAmJtBAJkawkA2AQBCQEFdmFsdWUBBQJibgQCZlEFAmJvBAJmUgUCYnAEAmZTBQJiawQCZGgDCQAAAgUCZm0FAmJ4BQJmTwUCZm0EAmZrCQEFdmFsdWUBCQCRAwIFAmZOAAAEAmRmCQEFdmFsdWUBCAUCZmsHYXNzZXRJZAQCZEwIBQJmawZhbW91bnQEAmVSCQECZUsDBQFlBQFlBQFlAwkAAAIFAmVSBQJlUgQCZGUJANgEAQUCZlADCQECIT0CBQJkaQkA2AQBBQJkZgkAAgECCFdyb25nIExQBAJkcAkBAmJOAQUCZGoEAmRyCQECYk4BBQJkawQCZlQKAAJhUwkA/AcEBQR0aGlzAhNnZXRPbmVUa25WMlJFQURPTkxZCQDMCAIFAmZMCQDMCAIFAmRMBQNuaWwFA25pbAMJAAECBQJhUwIKKEludCwgSW50KQUCYVMJAAIBCQCsAgIJAAMBBQJhUwIfIGNvdWxkbid0IGJlIGNhc3QgdG8gKEludCwgSW50KQMJAAACBQJmVAUCZlQEAmN4CAUCZlQCXzIEAmZVCAUCZlQCXzEEAmZWAwMJAGYCBQJmTQAACQBmAgUCZk0FAmZVBwkBAmFOAQkAuQkCCQDMCAICH2Ftb3VudCB0byByZWNlaXZlIGlzIGxlc3MgdGhhbiAJAMwIAgkApAMBBQJmTQUDbmlsAgAFAmZVBAJmVwMJAAACBQJmTAUCZGoJAJYKBAUCZlYAAAkAZQIJAGUCBQJkcAUCZlYFAmN4BQJkcgMJAAACBQJmTAUCZGsJAJYKBAAABQJmVgUCZHAJAGUCCQBlAgUCZHIFAmZWBQJjeAkAAgECFGludmFsaWQgb3V0IGFzc2V0IGlkBAJmWAgFAmZXAl8xBAJmWQgFAmZXAl8yBAJmQwgFAmZXAl8zBAJmRAgFAmZXAl80BAJmWgkBAmJQAgkBAUgCBQJmRAUCZlIJAQFIAgUCZkMFAmZRBAJnYQkBAUwCBQJmWgUBYQQCZ2IDCQAAAgUCZkwCBVdBVkVTBQR1bml0CQDZBAEFAmZMBAJnYwMJAGYCBQJjeAAACQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFAmFYBQJjeAUCZ2IFA25pbAUDbmlsBAJkQgkAzggCCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFAmRoBQJmVgUCZ2IJAMwIAgkBC1N0cmluZ0VudHJ5AgkBAmFpAgkApQgBBQJkaAUCZGUJAQJiSgYFAmZYBQJmWQUCZEwFAmdhBQZoZWlnaHQIBQlsYXN0QmxvY2sJdGltZXN0YW1wCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQECYWIABQJnYQkAzAgCCQEMSW50ZWdlckVudHJ5AgkBAmFjAgUGaGVpZ2h0CAUJbGFzdEJsb2NrCXRpbWVzdGFtcAUCZ2EFA25pbAUCZ2MDCQAAAgUCZEIFAmRCBAJnZAkA/AcEBQJhUQIEYnVybgkAzAgCBQJkTAUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQJkZgUCZEwFA25pbAMJAAACBQJnZAUCZ2QEAmdlBAJnZgMJAAACBQR0aGlzBQJhWAAABQJjeAQCZ2cDCQAAAgkBAmJjAQUCZkwFAmJtBgcDBQJnZwkAlAoCCQEBLQEJAGQCBQJmVQUCZ2YAAAkAlAoCAAAJAQEtAQkAZAIFAmZVBQJnZgQCZVQIBQJnZQJfMQQCZVUIBQJnZQJfMgQCZ2gJAQJlUwMFAmVUBQJlVQAABAJnaQgFAmdoAl8xBAJlSggFAmdoAl8yBAJnagkBAmVXAgUCZVIFAmVKAwkAAAIFAmdqBQJnagkAlAoCCQDOCAIFAmRCBQJnaQUCZlYJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAmdrAAQCZ2wJAKIIAQkBAVoAAwkAAQIFAmdsAgZTdHJpbmcEAmNDBQJnbAkA2QQBBQJjQwMJAAECBQJnbAIEVW5pdAUEdW5pdAkAAgECC01hdGNoIGVycm9yAQJnbQAEAmdsCQCiCAEJAQJhYQADCQABAgUCZ2wCBlN0cmluZwQCY0MFAmdsCQDZBAEFAmNDAwkAAQIFAmdsAgRVbml0BQR1bml0CQACAQILTWF0Y2ggZXJyb3IAAmduCQACAQIRUGVybWlzc2lvbiBkZW5pZWQBAmdvAQJjUAQCZ2wJAQJnawADCQABAgUCZ2wCCkJ5dGVWZWN0b3IEAmdwBQJnbAkAAAIIBQJjUA9jYWxsZXJQdWJsaWNLZXkFAmdwAwkAAQIFAmdsAgRVbml0CQAAAggFAmNQBmNhbGxlcgUEdGhpcwkAAgECC01hdGNoIGVycm9yAQJncQECY1AEAmdsCQECZ2sAAwkAAQIFAmdsAgpCeXRlVmVjdG9yBAJncAUCZ2wDCQAAAggFAmNQD2NhbGxlclB1YmxpY0tleQUCZ3AGBQJnbgMJAAECBQJnbAIEVW5pdAMJAAACCAUCY1AGY2FsbGVyBQR0aGlzBgUCZ24JAAIBAgtNYXRjaCBlcnJvchwCY1ABC2NvbnN0cnVjdG9yAQFZBAJleAkBAmdxAQUCY1ADCQAAAgUCZXgFAmV4CQDMCAIJAQtTdHJpbmdFbnRyeQIJAQFZAAUBWQUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNQAQpzZXRNYW5hZ2VyAQJncgQCZXgJAQJncQEFAmNQAwkAAAIFAmV4BQJleAQCZ3MJANkEAQUCZ3IDCQAAAgUCZ3MFAmdzCQDMCAIJAQtTdHJpbmdFbnRyeQIJAQJhYQAFAmdyBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4CY1ABDmNvbmZpcm1NYW5hZ2VyAAQCY3UJAQJnbQAEAmd0AwkBCWlzRGVmaW5lZAEFAmN1BgkAAgECEk5vIHBlbmRpbmcgbWFuYWdlcgMJAAACBQJndAUCZ3QEAmd1AwkAAAIIBQJjUA9jYWxsZXJQdWJsaWNLZXkJAQV2YWx1ZQEFAmN1BgkAAgECG1lvdSBhcmUgbm90IHBlbmRpbmcgbWFuYWdlcgMJAAACBQJndQUCZ3UJAMwIAgkBC1N0cmluZ0VudHJ5AgkBAVoACQDYBAEJAQV2YWx1ZQEFAmN1CQDMCAIJAQtEZWxldGVFbnRyeQEJAQJhYQAFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJjUAEDcHV0AgJndgJndwQCZ3gJAQJicwAEAmd5CQETdmFsdWVPckVycm9yTWVzc2FnZQIJAKYIAQkAkQMCBQJneAUBQwIKV3Igc3QgYWRkcgQCZ3oJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkApggBCQCRAwIFAmd4BQFFAgpXciBzbCBhZGRyAwkAZgIAAAUCZ3YJAAIBAg5Xcm9uZyBzbGlwcGFnZQMJAQIhPQIJAJADAQgFAmNQCHBheW1lbnRzAAIJAAIBAgwyIHBtbnRzIGV4cGQEAmdBCQC2AgEICQEFdmFsdWUBCQCRAwIIBQJjUAhwYXltZW50cwAABmFtb3VudAQCZ0IJALYCAQgJAQV2YWx1ZQEJAJEDAggFAmNQCHBheW1lbnRzAAEGYW1vdW50BAJlTwkAuAICCQC2AgEJAQJiTgEJAQJiZQEFAmJtBQJnQQMJAAACBQJlTwUCZU8EAmVQCQC4AgIJALYCAQkBAmJOAQkBAmJlAQUCYm4FAmdCAwkAAAIFAmVQBQJlUAQCZVEJALYCAQgJAQV2YWx1ZQEJAOwHAQUCYmwIcXVhbnRpdHkDCQAAAgUCZVEFAmVRBAJlUgkBAmVLAwUCZ0EFAmdCCQC2AgEAAAMJAAACBQJlUgUCZVIEAmdDCQECZmwKCQClCAEIBQJjUAZjYWxsZXIJANgEAQgFAmNQDXRyYW5zYWN0aW9uSWQJAQ9BdHRhY2hlZFBheW1lbnQCCAkBBXZhbHVlAQkAkQMCCAUCY1AIcGF5bWVudHMAAAdhc3NldElkCAkBBXZhbHVlAQkAkQMCCAUCY1AIcGF5bWVudHMAAAZhbW91bnQJAJEDAggFAmNQCHBheW1lbnRzAAEFAmd2BgcGAAACAAQCZWwIBQJnQwJfMgQCZ0QIBQJnQwJfNwQCZEIIBQJnQwJfOQQCZW0IBQJnQwNfMTAEAmVuCAUCZ0MDXzExBAJkaggFAmdDA18xMgQCZGsIBQJnQwNfMTMEAmRYCQD8BwQFAmFRAgRlbWl0CQDMCAIFAmVsBQNuaWwFA25pbAMJAAACBQJkWAUCZFgEAmdFBAJnbAUCZFgDCQABAgUCZ2wCB0FkZHJlc3MEAmdGBQJnbAkA/AcEBQJnRgIEZW1pdAkAzAgCBQJlbAUDbmlsBQNuaWwFBHVuaXQDCQAAAgUCZ0UFAmdFBAJnRwMJAGYCBQJlbQAACQD8BwQFAmd6AgNwdXQFA25pbAkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUCZGoFAmVtBQNuaWwFA25pbAMJAAACBQJnRwUCZ0cEAmdIAwkAZgIFAmVuAAAJAPwHBAUCZ3oCA3B1dAUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQJkawUCZW4FA25pbAUDbmlsAwkAAAIFAmdIBQJnSAQCZ0kDBQJndwQCZ0oJAPwHBAUCZ3kCBXN0YWtlBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmdEBQJlbAUDbmlsAwkAAAIFAmdKBQJnSgUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQJjUAZjYWxsZXIFAmVsBQJnRAUDbmlsBAJnSwkBAmVTAwAAAAAAAAQCZ2kIBQJnSwJfMQQCZUoIBQJnSwJfMgQCZ0wDCQDAAgIFAmVKBQJlUgYJAQJhTgEJALkJAgkAzAgCAiJ1cGRhdGVkIERMcCBsb3dlciB0aGFuIGN1cnJlbnQgRExwCQDMCAIJAKYDAQUCZU8JAMwIAgkApgMBBQJlUAkAzAgCCQCmAwEFAmVRCQDMCAIJAKYDAQUCZVIJAMwIAgkApgMBBQJlSgkAzAgCCQCkAwEFAmVtCQDMCAIJAKQDAQUCZW4FA25pbAIBIAMJAAACBQJnTAUCZ0wEAmdNCAkBBXZhbHVlAQkA7AcBBQJibAhxdWFudGl0eQMJAAACBQJnTQUCZ00JAM4IAgkAzggCBQJkQgUCZ0kFAmdpCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNQAQtwdXRPbmVUa25WMgICZk0CZ3cEAmdOCgACYVMJAPwHBAUCYVECKGlzUG9vbE9uZVRva2VuT3BlcmF0aW9uc0Rpc2FibGVkUkVBRE9OTFkJAMwIAgkApQgBBQR0aGlzBQNuaWwFA25pbAMJAAECBQJhUwIHQm9vbGVhbgUCYVMJAAIBCQCsAgIJAAMBBQJhUwIcIGNvdWxkbid0IGJlIGNhc3QgdG8gQm9vbGVhbgQCZ08DAwMJAQJhVgAGCQAAAgUCYmsFAXEGCQAAAgUCYmsFAXMGBQJnTgQCZ1AJAMwIAgMDCQEBIQEFAmdPBgkBAmdvAQUCY1AGCQECYU4BAiFwdXQgb3BlcmF0aW9uIGlzIGJsb2NrZWQgYnkgYWRtaW4JAMwIAgMJAAACCQCQAwEIBQJjUAhwYXltZW50cwABBgkBAmFOAQIeZXhhY3RseSAxIHBheW1lbnQgYXJlIGV4cGVjdGVkBQNuaWwDCQAAAgUCZ1AFAmdQBAJkagkA2AQBCQEFdmFsdWUBBQJibQQCZGsJANgEAQkBBXZhbHVlAQUCYm4EAmRpBQJibAQCZlEFAmJvBAJmUgUCYnAEAmRoAwkAAAIIBQJjUAZjYWxsZXIFBHRoaXMIBQJjUAxvcmlnaW5DYWxsZXIIBQJjUAZjYWxsZXIEAmZrCQEFdmFsdWUBCQCRAwIIBQJjUAhwYXltZW50cwAABAJkZgkA2AQBCQEFdmFsdWUBCAUCZmsHYXNzZXRJZAQCZEwIBQJmawZhbW91bnQEAmVSAwkAAAIIBQJmawdhc3NldElkBQJibQkBAmVLAwkAtgIBBQJkTAkAtgIBAAAJALYCAQAACQECZUsDCQC2AgEAAAkAtgIBBQJkTAkAtgIBAAADCQAAAgUCZVIFAmVSBAJnUQkBAmZwBQUCZEwFAmRmCQClCAEFAmRoCQDYBAEIBQJjUA10cmFuc2FjdGlvbklkBgMJAAACBQJnUQUCZ1EEAmN4CAUCZ1ECXzMEAmRCCAUCZ1ECXzIEAmdSCAUCZ1ECXzEEAmVsAwMJAGYCBQJmTQAACQBmAgUCZk0FAmdSBwkBAmFOAQkAuQkCCQDMCAICH2Ftb3VudCB0byByZWNlaXZlIGlzIGxlc3MgdGhhbiAJAMwIAgkApAMBBQJmTQUDbmlsAgAFAmdSBAJnQwkA/AcEBQJhUQIEZW1pdAkAzAgCBQJlbAUDbmlsBQNuaWwDCQAAAgUCZ0MFAmdDBAJnRQQCZ2wFAmdDAwkAAQIFAmdsAgdBZGRyZXNzBAJnRgUCZ2wJAPwHBAUCZ0YCBGVtaXQJAMwIAgUCZWwFA25pbAUDbmlsBQR1bml0AwkAAAIFAmdFBQJnRQQCZ0kDBQJndwQCZ0oJAPwHBAUCYnUCBXN0YWtlBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmRpBQJlbAUDbmlsAwkAAAIFAmdKBQJnSgUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQJjUAZjYWxsZXIFAmVsBQJkaQUDbmlsBAJnYwMJAGYCBQJjeAAACQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMFAmFYBQJjeAkA2QQBBQJkZgUDbmlsBQNuaWwEAmdTAwkAAAIFBHRoaXMFAmFYCQCUCgIAAAAABAJnVAMJAAACCAUCZmsHYXNzZXRJZAUCYm0GBwMFAmdUCQCUCgIJAQEtAQUCY3gAAAkAlAoCAAAJAQEtAQUCY3gEAmVUCAUCZ1MCXzEEAmVVCAUCZ1MCXzIEAmdVCQECZVMDBQJlVAUCZVUAAAQCZ2kIBQJnVQJfMQQCZUoIBQJnVQJfMgQCZ2oJAQJlVwIFAmVSBQJlSgMJAAACBQJnagUCZ2oJAJQKAgkAzggCCQDOCAIJAM4IAgUCZEIFAmdJBQJnYwUCZ2kFAmVsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNQAQpwdXRGb3JGcmVlAQJnVgMJAGYCAAAFAmdWCQACAQIKV3Jvbmcgc2xwZwMJAQIhPQIJAJADAQgFAmNQCHBheW1lbnRzAAIJAAIBAgwyIHBtbnRzIGV4cGQEAmdXCQECZmwKCQClCAEIBQJjUAZjYWxsZXIJANgEAQgFAmNQDXRyYW5zYWN0aW9uSWQJAQ9BdHRhY2hlZFBheW1lbnQCCAkBBXZhbHVlAQkAkQMCCAUCY1AIcGF5bWVudHMAAAdhc3NldElkCAkBBXZhbHVlAQkAkQMCCAUCY1AIcGF5bWVudHMAAAZhbW91bnQJAJEDAggFAmNQCHBheW1lbnRzAAEFAmdWBwcGAAACAAQCZEIIBQJnVwJfOQQCZ0EJALYCAQgJAQV2YWx1ZQEJAJEDAggFAmNQCHBheW1lbnRzAAAGYW1vdW50BAJnQgkAtgIBCAkBBXZhbHVlAQkAkQMCCAUCY1AIcGF5bWVudHMAAQZhbW91bnQEAmVSCQECZUsDBQJnQQUCZ0IJALYCAQAAAwkAAAIFAmVSBQJlUgQCZ1gJAQJlUwMAAAAAAAAEAmdpCAUCZ1gCXzEEAmVKCAUCZ1gCXzIEAmdqCQECZVcCBQJlUgUCZUoDCQAAAgUCZ2oFAmdqCQDOCAIFAmRCBQJnaQkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJjUAEDZ2V0AAQCZVIJAQJlSwMJALYCAQAACQC2AgEAAAkAtgIBAAADCQAAAgUCZVIFAmVSBAJkWAkBAmZqAQUCY1AEAmdZCAUCZFgCXzEEAmRBCAUCZFgCXzIEAmRMCAUCZFgCXzMEAmRmCAUCZFgCXzQEAmRCCAUCZFgCXzUEAmV5CQD8BwQFAmFRAgRidXJuCQDMCAIFAmRMBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmRmBQJkTAUDbmlsAwkAAAIFAmV5BQJleQQCZ1oJAQJlUwMJAQEtAQUCZ1kJAQEtAQUCZEEAAAQCZ2kIBQJnWgJfMQQCZUoIBQJnWgJfMgQCZ2oJAQJlVwIFAmVSBQJlSgMJAAACBQJnagUCZ2oJAM4IAgUCZEIFAmdpCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNQAQtnZXRPbmVUa25WMgICZkwCZk0EAmdOCgACYVMJAPwHBAUCYVECKGlzUG9vbE9uZVRva2VuT3BlcmF0aW9uc0Rpc2FibGVkUkVBRE9OTFkJAMwIAgkApQgBBQR0aGlzBQNuaWwFA25pbAMJAAECBQJhUwIHQm9vbGVhbgUCYVMJAAIBCQCsAgIJAAMBBQJhUwIcIGNvdWxkbid0IGJlIGNhc3QgdG8gQm9vbGVhbgQCaGEDAwkBAmFWAAYJAAACBQJiawUBcwYFAmdOBAJnUAkAzAgCAwMJAQEhAQUCaGEGCQECZ28BBQJjUAYJAQJhTgECIWdldCBvcGVyYXRpb24gaXMgYmxvY2tlZCBieSBhZG1pbgkAzAgCAwkAAAIJAJADAQgFAmNQCHBheW1lbnRzAAEGCQECYU4BAh5leGFjdGx5IDEgcGF5bWVudCBhcmUgZXhwZWN0ZWQFA25pbAMJAAACBQJnUAUCZ1AEAmhiCQECZksGBQJmTAUCZk0IBQJjUAhwYXltZW50cwgFAmNQBmNhbGxlcggFAmNQDG9yaWdpbkNhbGxlcggFAmNQDXRyYW5zYWN0aW9uSWQEAmRCCAUCaGICXzEEAmZWCAUCaGICXzIJAJQKAgUCZEIFAmZWCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNQAQpyZWZyZXNoRExwAAQCaGMJAQt2YWx1ZU9yRWxzZQIJAJ8IAQUCYXEAAAQCaGQDCQBnAgkAZQIFBmhlaWdodAUCaGMFAmF0BQR1bml0CQECYU4BCQC5CQIJAMwIAgkApAMBBQJhdAkAzAgCAi8gYmxvY2tzIGhhdmUgbm90IHBhc3NlZCBzaW5jZSB0aGUgcHJldmlvdXMgY2FsbAUDbmlsAgADCQAAAgUCaGQFAmhkBAJmZAkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCoAwEJAQt2YWx1ZU9yRWxzZQIJAJ0IAgUEdGhpcwUCYXACATAJAQJhUAECC2ludmFsaWQgZExwBAJoZQkBAmVTAwAAAAAAAAQCaGYIBQJoZQJfMQQCZUoIBQJoZQJfMgQCZVYDCQECIT0CBQJmZAUCZUoFAmhmCQECYU4BAhJub3RoaW5nIHRvIHJlZnJlc2gJAJQKAgUCZVYJAKYDAQUCZUoJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4CY1ABE2dldE9uZVRrblYyUkVBRE9OTFkCAmZMAmhnBAJkagkA2AQBCQEFdmFsdWUBBQJibQQCZGsJANgEAQkBBXZhbHVlAQUCYm4EAmRpCQDYBAEJAQV2YWx1ZQEFAmJsBAJjegkAzAgCCQC2AgEJAQJiTgEFAmRqCQDMCAIJALYCAQkBAmJOAQUCZGsFA25pbAQCZUkJALYCAQgJARN2YWx1ZU9yRXJyb3JNZXNzYWdlAgkA7AcBCQDZBAEFAmRpAhBpbnZhbGlkIGxwIGFzc2V0CHF1YW50aXR5BAJjYgkBAmN5AQUCY3oEAmNhCQC4AgIFAmNiCQC8AgMJALYCAQUCaGcFAmNiBQJlSQQCaGgDCQAAAgUCZkwFAmRqAAADCQAAAgUCZkwFAmRrAAEJAAIBAhRpbnZhbGlkIG91dCBhc3NldCBpZAQCaGkJAQJlcwMFAmN6BQJoaAUCY2EEAmhqCQC4AgIJAJEDAgUCY3oFAmhoBQJoaQQCaGsJAJYDAQkAzAgCAAAJAMwIAgkAoAMBCQC4AgIFAmhqBQFmBQNuaWwEAmhsCQECY3YCBQJoawUCYVQEAmZVCAUCaGwCXzEEAmN4CAUCaGwCXzIJAJQKAgUDbmlsCQCUCgIFAmZVBQJjeAJjUAEcZ2V0T25lVGtuVjJXaXRoQm9udXNSRUFET05MWQICZkwCaGcEAmRqCQDYBAEJAQV2YWx1ZQEFAmJtBAJkawkA2AQBCQEFdmFsdWUBBQJibgQCZGkJANgEAQkBBXZhbHVlAQUCYmwEAmRwCQECYk4BBQJkagQCZHIJAQJiTgEFAmRrBAJobQoAAmFTCQD8BwQFBHRoaXMCE2dldE9uZVRrblYyUkVBRE9OTFkJAMwIAgUCZkwJAMwIAgUCaGcFA25pbAUDbmlsAwkAAQIFAmFTAgooSW50LCBJbnQpBQJhUwkAAgEJAKwCAgkAAwEFAmFTAh8gY291bGRuJ3QgYmUgY2FzdCB0byAoSW50LCBJbnQpBAJmVQgFAmhtAl8xBAJjeAgFAmhtAl8yBAJkWAkBAmRkBAIABQJkaQUCaGcFBHRoaXMEAmR6CAUCZFgCXzEEAmRBCAUCZFgCXzIEAmhuCQBkAgUCZHoFAmRBBAJmSgMJAAACBQJobgAAAwkAAAIFAmZVAAAAAAkAAgECF2JvbnVzIGNhbGN1bGF0aW9uIGVycm9yCQBrAwkAZQIFAmZVBQJobgUBYQUCaG4JAJQKAgUDbmlsCQCVCgMFAmZVBQJjeAUCZkoCY1ABCWdldE5vTGVzcwICaG8CaHAEAmRYCQECZmoBBQJjUAQCZHoIBQJkWAJfMQQCZEEIBQJkWAJfMgQCZEwIBQJkWAJfMwQCZGYIBQJkWAJfNAQCZEIIBQJkWAJfNQMJAGYCBQJobwUCZHoJAAIBCQCsAgIJAKwCAgkArAICAglGYWlsZWQ6ICAJAKQDAQUCZHoCAyA8IAkApAMBBQJobwMJAGYCBQJocAUCZEEJAAIBCQCsAgIJAKwCAgkArAICAghGYWlsZWQ6IAkApAMBBQJkQQIDIDwgCQCkAwEFAmhwBAJlUgkBAmVLAwkAtgIBAAAJALYCAQAACQC2AgEAAAMJAAACBQJlUgUCZVIEAmhxCQD8BwQFAmFRAgRidXJuCQDMCAIFAmRMBQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmRmBQJkTAUDbmlsAwkAAAIFAmhxBQJocQQCaHIJAQJlUwMJAQEtAQUCZHoJAQEtAQUCZEEAAAQCZ2kIBQJocgJfMQQCZUoIBQJocgJfMgQCZ2oJAQJlVwIFAmVSBQJlSgMJAAACBQJnagUCZ2oJAM4IAgUCZEIFAmdpCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNQAQ11bnN0YWtlQW5kR2V0AQJjdwQCaHMDCQECIT0CCQCQAwEIBQJjUAhwYXltZW50cwAACQACAQINTm8gcG1udHMgZXhwZAYDCQAAAgUCaHMFAmhzBAJodAkBAmJzAAQCZ0QFAmJsBAJodQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEJAJEDAgUCaHQFAUMCCldyIHN0IGFkZHIEAmVSCQECZUsDCQC2AgEAAAkAtgIBAAAJALYCAQAAAwkAAAIFAmVSBQJlUgQCaHYJAPwHBAUCaHUCB3Vuc3Rha2UJAMwIAgkA2AQBBQJnRAkAzAgCBQJjdwUDbmlsBQNuaWwDCQAAAgUCaHYFAmh2BAJkWAkBAmRkBAkA2AQBCAUCY1ANdHJhbnNhY3Rpb25JZAkA2AQBBQJnRAUCY3cIBQJjUAZjYWxsZXIEAmR6CAUCZFgCXzEEAmRBCAUCZFgCXzIEAmRuCQENcGFyc2VJbnRWYWx1ZQEIBQJkWAJfOQQCZEIIBQJkWANfMTAEAmh3AwMJAQJhVgAGCQAAAgUCZG4FAXMJAAIBCQCsAgICCUJsb2NrZWQ6IAkApAMBBQJkbgYDCQAAAgUCaHcFAmh3BAJoeAkA/AcEBQJhUQIEYnVybgkAzAgCBQJjdwUDbmlsCQDMCAIJAQ9BdHRhY2hlZFBheW1lbnQCBQJnRAUCY3cFA25pbAMJAAACBQJoeAUCaHgEAmh5CQECZVMDCQEBLQEFAmR6CQEBLQEFAmRBAAAEAmdpCAUCaHkCXzEEAmVKCAUCaHkCXzIEAmdqCQECZVcCBQJlUgUCZUoDCQAAAgUCZ2oFAmdqCQDOCAIFAmRCBQJnaQkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJjUAETdW5zdGFrZUFuZEdldE5vTGVzcwMCaHoCaEECaHAEAmhhAwkBAmFWAAYJAAACBQJiawUBcwQCZ1AJAMwIAgMJAQEhAQUCaGEGCQACAQIhZ2V0IG9wZXJhdGlvbiBpcyBibG9ja2VkIGJ5IGFkbWluCQDMCAIDCQAAAgkAkAMBCAUCY1AIcGF5bWVudHMAAAYJAAIBAhhubyBwYXltZW50cyBhcmUgZXhwZWN0ZWQFA25pbAMJAAACBQJnUAUCZ1AEAmVSCQECZUsDCQC2AgEAAAkAtgIBAAAJALYCAQAAAwkAAAIFAmVSBQJlUgQCaHYJAPwHBAUCYnUCB3Vuc3Rha2UJAMwIAgkA2AQBBQJibAkAzAgCBQJoegUDbmlsBQNuaWwDCQAAAgUCaHYFAmh2BAJoQgkBAmRkBAkA2AQBCAUCY1ANdHJhbnNhY3Rpb25JZAkA2AQBBQJibAUCaHoIBQJjUAZjYWxsZXIEAmR6CAUCaEICXzEEAmRBCAUCaEICXzIEAmRCCAUCaEIDXzEwBAJoQwkAzAgCAwkAZwIFAmR6BQJoQQYJAAIBCQC5CQIJAMwIAgIsYW1vdW50IGFzc2V0IGFtb3VudCB0byByZWNlaXZlIGlzIGxlc3MgdGhhbiAJAMwIAgkApAMBBQJoQQUDbmlsAgAJAMwIAgMJAGcCBQJkQQUCaHAGCQACAQkAuQkCCQDMCAICK3ByaWNlIGFzc2V0IGFtb3VudCB0byByZWNlaXZlIGlzIGxlc3MgdGhhbiAJAMwIAgkApAMBBQJocAUDbmlsAgAFA25pbAMJAAACBQJoQwUCaEMEAmhxCQD8BwQFAmFRAgRidXJuCQDMCAIFAmh6BQNuaWwJAMwIAgkBD0F0dGFjaGVkUGF5bWVudAIFAmJsBQJoegUDbmlsAwkAAAIFAmhxBQJocQQCaEQJAQJlUwMJAQEtAQUCZHoJAQEtAQUCZEEAAAQCZ2kIBQJoRAJfMQQCZUoIBQJoRAJfMgQCZ2oJAQJlVwIFAmVSBQJlSgMJAAACBQJnagUCZ2oJAM4IAgUCZEIFAmdpCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAmNQARV1bnN0YWtlQW5kR2V0T25lVGtuVjIDAmh6AmZMAmZNBAJnTgoAAmFTCQD8BwQFAmFRAihpc1Bvb2xPbmVUb2tlbk9wZXJhdGlvbnNEaXNhYmxlZFJFQURPTkxZCQDMCAIJAKUIAQUEdGhpcwUDbmlsBQNuaWwDCQABAgUCYVMCB0Jvb2xlYW4FAmFTCQACAQkArAICCQADAQUCYVMCHCBjb3VsZG4ndCBiZSBjYXN0IHRvIEJvb2xlYW4EAmhhAwMJAQJhVgAGCQAAAgUCYmsFAXMGBQJnTgQCZ1AJAMwIAgMDCQEBIQEFAmhhBgkBAmdvAQUCY1AGCQECYU4BAiFnZXQgb3BlcmF0aW9uIGlzIGJsb2NrZWQgYnkgYWRtaW4JAMwIAgMJAAACCQCQAwEIBQJjUAhwYXltZW50cwAABgkBAmFOAQIYbm8gcGF5bWVudHMgYXJlIGV4cGVjdGVkBQNuaWwDCQAAAgUCZ1AFAmdQBAJodAkBAmJzAAQCZ0QFAmJsBAJodQkBE3ZhbHVlT3JFcnJvck1lc3NhZ2UCCQCmCAEJAJEDAgUCaHQFAUMCCldyIHN0IGFkZHIEAmh2CQD8BwQFAmh1Agd1bnN0YWtlCQDMCAIJANgEAQUCZ0QJAMwIAgUCaHoFA25pbAUDbmlsAwkAAAIFAmh2BQJodgQCaEUJAQJmSwYFAmZMBQJmTQkAzAgCCQEPQXR0YWNoZWRQYXltZW50AgUCZ0QFAmh6BQNuaWwIBQJjUAZjYWxsZXIIBQJjUAxvcmlnaW5DYWxsZXIIBQJjUA10cmFuc2FjdGlvbklkBAJkQggFAmhFAl8xBAJmVggFAmhFAl8yCQCUCgIFAmRCBQJmVgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgJjUAEccHV0T25lVGtuVjJXaXRoQm9udXNSRUFET05MWQICaEYCaEcEAmhICQECZnAFBQJoRgUCaEcCAAIABgQCZkUIBQJoSAJfMQQCZEIIBQJoSAJfMgQCY3gIBQJoSAJfMwQCZkoIBQJoSAJfNAkAlAoCBQNuaWwJAJUKAwUCZkUFAmN4BQJmSgJjUAEhcHV0T25lVGtuVjJXaXRob3V0VGFrZUZlZVJFQURPTkxZAgJoRgJoRwQCaEkJAQJmcAUFAmhGBQJoRwIAAgAHBAJmRQgFAmhJAl8xBAJkQggFAmhJAl8yBAJjeAgFAmhJAl8zBAJmSggFAmhJAl80CQCUCgIFA25pbAkAlQoDBQJmRQUCY3gFAmZKAmNQAQhhY3RpdmF0ZQICaEoCaEsDCQECIT0CCQClCAEIBQJjUAZjYWxsZXIJAKUIAQUCYVEJAAIBAgZkZW5pZWQJAJQKAgkAzAgCCQELU3RyaW5nRW50cnkCCQECYWoABQJoSgkAzAgCCQELU3RyaW5nRW50cnkCCQECYWsABQJoSwUDbmlsAgdzdWNjZXNzAmNQAQRzZXRTAgJoTAJodwMJAQIhPQIJAKUIAQgFAmNQBmNhbGxlcgkBAmFKAgUEdGhpcwkBAmFtAAUCZ24JAMwIAgkBC1N0cmluZ0VudHJ5AgUCaEwFAmh3BQNuaWwCY1ABBHNldEkCAmhMAmh3AwkBAiE9AgkApQgBCAUCY1AGY2FsbGVyCQECYUoCBQR0aGlzCQECYW0ABQJnbgkAzAgCCQEMSW50ZWdlckVudHJ5AgUCaEwFAmh3BQNuaWwCY1ABHGdldFBvb2xDb25maWdXcmFwcGVyUkVBRE9OTFkACQCUCgIFA25pbAkBAmFZAAJjUAEcZ2V0QWNjQmFsYW5jZVdyYXBwZXJSRUFET05MWQECYk8JAJQKAgUDbmlsCQECYk4BBQJiTwJjUAEZY2FsY1ByaWNlc1dyYXBwZXJSRUFET05MWQMCY2gCY2kCY20EAmhNCQECY2wDBQJjaAUCY2kFAmNtCQCUCgIFA25pbAkAzAgCCQCmAwEJAJEDAgUCaE0AAAkAzAgCCQCmAwEJAJEDAgUCaE0AAQkAzAgCCQCmAwEJAJEDAgUCaE0AAgUDbmlsAmNQARZmcm9tWDE4V3JhcHBlclJFQURPTkxZAgFNAmhOCQCUCgIFA25pbAkBAUwCCQCnAwEFAU0FAmhOAmNQARR0b1gxOFdyYXBwZXJSRUFET05MWQIBSQFKCQCUCgIFA25pbAkApgMBCQEBSAIFAUkFAUoCY1ABHmNhbGNQcmljZUJpZ0ludFdyYXBwZXJSRUFET05MWQICYlECYlIJAJQKAgUDbmlsCQCmAwEJAQJiUAIJAKcDAQUCYlEJAKcDAQUCYlICY1ABI2VzdGltYXRlUHV0T3BlcmF0aW9uV3JhcHBlclJFQURPTkxZCQJkZQJiVwJkRAJkRQJkRgJkRwJoTwJkSAJkSQkAlAoCBQNuaWwJAQJkQw0FAmRlBQJiVwUCZEQFAmRFBQJkRgUCZEcFAmhPBQJkSAUCZEkGBwAAAgACY1ABI2VzdGltYXRlR2V0T3BlcmF0aW9uV3JhcHBlclJFQURPTkxZBAJkZQJoUAJkZwJoTwQCZFgJAQJkZAQFAmRlBQJoUAUCZGcJARFAZXh0ck5hdGl2ZSgxMDYyKQEFAmhPCQCUCgIFA25pbAkAnAoKCAUCZFgCXzEIBQJkWAJfMggFAmRYAl8zCAUCZFgCXzQIBQJkWAJfNQgFAmRYAl82CAUCZFgCXzcJAKYDAQgFAmRYAl84CAUCZFgCXzkIBQJkWANfMTABAmhRAQJoUgAEAmhTBAJnbAkBAmdrAAMJAAECBQJnbAIKQnl0ZVZlY3RvcgQCZ3AFAmdsBQJncAMJAAECBQJnbAIEVW5pdAgFAmhRD3NlbmRlclB1YmxpY0tleQkAAgECC01hdGNoIGVycm9yBAJnbAUCaFEDCQABAgUCZ2wCBU9yZGVyBAJlWgUCZ2wEAmhUCQECYVcABAJoVQkBAmVZAQUCZVoEAmFGCAUCaFUCXzEEAmFHCAUCaFUCXzIEAmFICQD0AwMIBQJlWglib2R5Qnl0ZXMJAJEDAggFAmVaBnByb29mcwAACAUCZVoPc2VuZGVyUHVibGljS2V5BAJhSQkA9AMDCAUCZVoJYm9keUJ5dGVzCQCRAwIIBQJlWgZwcm9vZnMAAQUCaFQDAwMFAmFGBQJhSAcFAmFJBwYJAQJhRQQFAmFGBQJhRwUCYUgFAmFJAwkAAQIFAmdsAhRTZXRTY3JpcHRUcmFuc2FjdGlvbgQCY0MFAmdsAwkA9AMDCAUCaFEJYm9keUJ5dGVzCQCRAwIIBQJoUQZwcm9vZnMAAAUCaFMGBAJoVgkA9gMBCQEFdmFsdWUBCAUCY0MGc2NyaXB0BAJoVwkA2wQBCQEFdmFsdWUBCQCdCAIFAmFRCQECYUMABAJoWAkA8QcBBQR0aGlzAwkAAAIFAmhXBQJoVgkBAiE9AgUCaFgFAmhWBwkA9AMDCAUCaFEJYm9keUJ5dGVzCQCRAwIIBQJoUQZwcm9vZnMAAAUCaFNP7bKc",
    "chainId": 87,
    "height": 3482981,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 4T55jj3B9Z7BZhSkcqacHyfzZ6QVrxu7Aea3FAUn8Jcq
Next: 5y4jsL6y5QC3bi8pwgxUvYANQrsYfEPDyQ4qEXvpLsCm

Diff: 
Old New Differences
14 14  let big1 = toBigInt(1)
15 15  
16 16  let big2 = toBigInt(2)
17 + 
18 + let big3 = toBigInt(3)
19 + 
20 + let big4 = toBigInt(4)
17 21  
18 22  let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
19 23  
66 70  func t1 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
67 71  
68 72  
73 + func t1BigInt (origVal,origScaleMult) = fraction(origVal, scale18, origScaleMult)
74 + 
75 + 
69 76  func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
77 + 
78 + 
79 + func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
80 + 
81 + 
82 + func t2 (origVal,origScaleMult) = fraction(origVal, scale18, toBigInt(origScaleMult))
83 + 
84 + 
85 + func f2 (val,resultScaleMult) = fraction(val, toBigInt(resultScaleMult), scale18)
70 86  
71 87  
72 88  func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)
115 131  func ada () = "%s__addonAddr"
116 132  
117 133  
134 + let keyFee = "%s__fee"
135 + 
136 + let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
137 + 
138 + let keyDLp = makeString(["%s", "dLp"], SEP)
139 + 
140 + let keyDLpRefreshedHeight = makeString(["%s", "dLpRefreshedHeight"], SEP)
141 + 
142 + let keyDLpRefreshDelay = makeString(["%s", "refreshDLpDelay"], SEP)
143 + 
144 + let dLpRefreshDelayDefault = 1
145 + 
146 + let dLpRefreshDelay = valueOrElse(getInteger(this, keyDLpRefreshDelay), dLpRefreshDelayDefault)
147 + 
118 148  func fcfg () = "%s__factoryConfig"
119 149  
120 150  
136 166  func keyFeeCollectorAddress () = "%s__feeCollectorAddress"
137 167  
138 168  
139 - func toe (orV,sendrV,matchV) = throw(((((("Failed: ordValid=" + toString(orV)) + " sndrValid=") + toString(sendrV)) + " mtchrValid=") + toString(matchV)))
140 - 
141 - 
142 - func str (val) = match val {
143 -     case valStr: String => 
144 -         valStr
145 -     case _ => 
146 -         throw("fail cast to String")
147 - }
169 + func throwOrderError (orderValid,orderValidInfo,senderValid,matcherValid) = throw((((((((("order validation failed: orderValid=" + toString(orderValid)) + " (") + orderValidInfo) + ")") + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
148 170  
149 171  
150 172  func strf (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
154 176  
155 177  
156 178  func throwErr (msg) = throw(makeString(["lp_stable.ride:", msg], " "))
179 + 
180 + 
181 + func fmtErr (msg) = makeString(["lp_stable.ride:", msg], " ")
157 182  
158 183  
159 184  let fca = addressFromStringValue(strf(this, fc()))
201 226      else toBase58String(value(input))
202 227  
203 228  
204 - func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]))
229 + func parsePoolConfig (poolConfig) = $Tuple9(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]), fromBase58String(poolConfig[idxIAmtAsId]), fromBase58String(poolConfig[idxIPriceAsId]))
205 230  
206 231  
207 232  let poolConfigParsed = parsePoolConfig(gpc())
208 233  
209 - let $t069097095 = poolConfigParsed
234 + let $t079648193 = poolConfigParsed
210 235  
211 - let cfgPoolAddress = $t069097095._1
236 + let cfgPoolAddress = $t079648193._1
212 237  
213 - let cfgPoolStatus = $t069097095._2
238 + let cfgPoolStatus = $t079648193._2
214 239  
215 - let cfgLpAssetId = $t069097095._3
240 + let cfgLpAssetId = $t079648193._3
216 241  
217 - let cfgAmountAssetId = $t069097095._4
242 + let cfgAmountAssetId = $t079648193._4
218 243  
219 - let cfgPriceAssetId = $t069097095._5
244 + let cfgPriceAssetId = $t079648193._5
220 245  
221 - let cfgAmountAssetDecimals = $t069097095._6
246 + let cfgAmountAssetDecimals = $t079648193._6
222 247  
223 - let cfgPriceAssetDecimals = $t069097095._7
248 + let cfgPriceAssetDecimals = $t079648193._7
249 + 
250 + let cfgInAmountAssedId = $t079648193._8
251 + 
252 + let cfgInPriceAssetId = $t079648193._9
224 253  
225 254  func gfc () = split(strf(fca, fcfg()), SEP)
226 255  
247 276  
248 277  
249 278  func cpbi (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
279 + 
280 + 
281 + func cpbir (prAmtX18,amAmtX18,round) = fraction(prAmtX18, scale18, amAmtX18, round)
250 282  
251 283  
252 284  func vad (A1,A2,slippage) = {
277 309  
278 310  
279 311  func calcPrices (amAmt,prAmt,lpAmt) = {
280 -     let cfg = gpc()
281 -     let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
282 -     let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
312 +     let amtAsDcm = cfgAmountAssetDecimals
313 +     let prAsDcm = cfgPriceAssetDecimals
283 314      let priceX18 = pcp(amtAsDcm, prAsDcm, amAmt, prAmt)
284 315      let amAmtX18 = t1(amAmt, amtAsDcm)
285 316      let prAmtX18 = t1(prAmt, prAsDcm)
304 335      }
305 336  
306 337  
338 + func getD (xp) = {
339 +     let xp0 = xp[0]
340 +     let xp1 = xp[1]
341 +     let s = (xp0 + xp1)
342 +     if ((s == big0))
343 +         then big0
344 +         else {
345 +             let a = parseIntValue(A)
346 +             let ann = (a * 2)
347 +             let p = fraction(xp0, xp1, big1)
348 +             let xp0_xp1_n_n = fraction(p, big4, big1)
349 +             let ann_s = fraction(toBigInt(ann), s, big1)
350 +             let ann_1 = toBigInt((ann - 1))
351 +             func calcDNext (d) =             {
352 +                 let dd = fraction(d, d, big1)
353 +                 let ddd = fraction(dd, d, big1)
354 +                 let dp = fraction(ddd, big1, xp0_xp1_n_n)
355 +                 fraction((ann_s + fraction(dp, big2, big1)), d, (fraction(ann_1, d, big1) + fraction(big3, dp, big1)))
356 +                 }
357 + 
358 +             func calc (acc,i) =             if (acc._2)
359 +                 then acc
360 +                 else {
361 +                     let d = acc._1
362 +                     let dNext = calcDNext(d)
363 +                     let dDiffRaw = (dNext - value(d))
364 +                     let dDiff = if ((big0 > dDiffRaw))
365 +                         then -(dDiffRaw)
366 +                         else dDiffRaw
367 +                     if ((big1 >= dDiff))
368 +                         then $Tuple2(dNext, true)
369 +                         else $Tuple2(dNext, false)
370 +                     }
371 + 
372 +             let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
373 +             let $t01269012738 = {
374 +                 let $l = arr
375 +                 let $s = size($l)
376 +                 let $acc0 = $Tuple2(s, false)
377 +                 func $f0_1 ($a,$i) =                 if (($i >= $s))
378 +                     then $a
379 +                     else calc($a, $l[$i])
380 + 
381 +                 func $f0_2 ($a,$i) =                 if (($i >= $s))
382 +                     then $a
383 +                     else throw("List size exceeds 15")
384 + 
385 +                 $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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
386 +                 }
387 +             let d = $t01269012738._1
388 +             let found = $t01269012738._2
389 +             if (found)
390 +                 then d
391 +                 else throw(("D calculation error, D = " + toString(d)))
392 +             }
393 +     }
394 + 
395 + 
307 396  func ego (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
308 -     let cfg = gpc()
309 -     let lpId = cfg[idxLPAsId]
310 -     let amId = cfg[idxAmAsId]
311 -     let prId = cfg[idxPrAsId]
312 -     let amDcm = parseIntValue(cfg[idxAmtAsDcm])
313 -     let prDcm = parseIntValue(cfg[idxPriceAsDcm])
314 -     let sts = cfg[idxPoolSt]
315 -     let lpEmiss = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Wrong LP id").quantity
316 -     if ((lpId != pmtAssetId))
397 +     let lpId = cfgLpAssetId
398 +     let amId = toBase58String(value(cfgAmountAssetId))
399 +     let prId = toBase58String(value(cfgPriceAssetId))
400 +     let amDcm = cfgAmountAssetDecimals
401 +     let prDcm = cfgPriceAssetDecimals
402 +     let sts = toString(cfgPoolStatus)
403 +     let lpEmiss = valueOrErrorMessage(assetInfo(lpId), "Wrong LP id").quantity
404 +     if ((toBase58String(lpId) != pmtAssetId))
317 405          then throw("Wrong pmt asset")
318 406          else {
319 407              let amBalance = getAccBalance(amId)
326 414              let lpEmissX18 = t1(lpEmiss, scale8)
327 415              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
328 416              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
329 -             let outAmAmt = f1(outAmAmtX18, amDcm)
330 -             let outPrAmt = f1(outPrAmtX18, prDcm)
417 +             let outAmAmt = fromX18Round(outAmAmtX18, amDcm, FLOOR)
418 +             let outPrAmt = fromX18Round(outPrAmtX18, prDcm, FLOOR)
331 419              let state = if ((txId58 == ""))
332 420                  then nil
333 421                  else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
341 429  
342 430  
343 431  func epo (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
344 -     let cfg = gpc()
345 -     let lpId = fromBase58String(cfg[idxLPAsId])
346 -     let amIdStr = cfg[idxAmAsId]
347 -     let prIdStr = cfg[idxPrAsId]
348 -     let inAmIdStr = cfg[idxIAmtAsId]
349 -     let inPrIdStr = cfg[idxIPriceAsId]
350 -     let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
351 -     let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
352 -     let sts = cfg[idxPoolSt]
432 +     let lpId = cfgLpAssetId
433 +     let amIdStr = toBase58String(value(cfgAmountAssetId))
434 +     let prIdStr = toBase58String(value(cfgPriceAssetId))
435 +     let inAmIdStr = cfgInAmountAssedId
436 +     let inPrIdStr = cfgInPriceAssetId
437 +     let amtDcm = cfgAmountAssetDecimals
438 +     let priceDcm = cfgPriceAssetDecimals
439 +     let sts = toString(cfgPoolStatus)
353 440      let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
354 441      let amBalance = if (isEval)
355 442          then getAccBalance(amIdStr)
374 461      let userPriceX18 = cpbi(inPrAssetAmtX18, inAmAssetAmtX18)
375 462      let amBalanceX18 = t1(amBalance, amtDcm)
376 463      let prBalanceX18 = t1(prBalance, priceDcm)
464 +     let D0 = getD([amBalanceX18, prBalanceX18])
377 465      let r = if ((lpEm == 0))
378 466          then {
379 -             let curPriceX18 = zeroBigInt
380 -             let slippageX18 = zeroBigInt
381 -             let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
382 -             $Tuple5(f1(lpAmtX18, scale8), f1(inAmAssetAmtX18, amtDcm), f1(inPrAssetAmtX18, priceDcm), cpbi((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
467 +             let D1 = getD([(amBalanceX18 + inAmAssetAmtX18), (prBalanceX18 + inPrAssetAmtX18)])
468 +             let checkD = if ((D1 > D0))
469 +                 then true
470 +                 else throw("D1 should be greater than D0")
471 +             if ((checkD == checkD))
472 +                 then {
473 +                     let curPriceX18 = zeroBigInt
474 +                     let slippageX18 = zeroBigInt
475 +                     let lpAmtX18 = D1
476 +                     $Tuple5(f1(lpAmtX18, scale8), f1(inAmAssetAmtX18, amtDcm), f1(inPrAssetAmtX18, priceDcm), cpbi((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
477 +                     }
478 +                 else throw("Strict value is not equal to itself.")
383 479              }
384 480          else {
385 481              let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
393 489                  then throw(((("Price slippage " + toString(slippageRealX18)) + " > ") + toString(slippageX18)))
394 490                  else {
395 491                      let lpEmissionX18 = t1(lpEm, scale8)
396 -                     let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
397 -                     let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
492 +                     let prViaAmX18 = fraction(inAmAssetAmtX18, cpbir(prBalanceX18, amBalanceX18, CEILING), scale18, CEILING)
493 +                     let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, cpbir(prBalanceX18, amBalanceX18, FLOOR), CEILING)
398 494                      let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
399 495                          then $Tuple2(amViaPrX18, inPrAssetAmtX18)
400 496                          else $Tuple2(inAmAssetAmtX18, prViaAmX18)
401 497                      let expAmtAssetAmtX18 = expectedAmts._1
402 498                      let expPriceAssetAmtX18 = expectedAmts._2
403 -                     let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
404 -                     $Tuple5(f1(lpAmtX18, scale8), f1(expAmtAssetAmtX18, amtDcm), f1(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
499 +                     let D1 = getD([(amBalanceX18 + expAmtAssetAmtX18), (prBalanceX18 + expPriceAssetAmtX18)])
500 +                     let checkD = if ((D1 > D0))
501 +                         then true
502 +                         else throw("D1 should be greater than D0")
503 +                     if ((checkD == checkD))
504 +                         then {
505 +                             let lpAmtX18 = fraction(lpEmissionX18, (D1 - D0), D0)
506 +                             $Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceDcm, CEILING), curPriceX18, slippageX18)
507 +                             }
508 +                         else throw("Strict value is not equal to itself.")
405 509                      }
406 510              }
407 511      let calcLpAmt = r._1
417 521                  else calcLpAmt
418 522              let amDiff = (inAmAmt - calcAmAssetPmt)
419 523              let prDiff = (inPrAmt - calcPrAssetPmt)
420 -             let $t01756217907 = if (if (isOneAsset)
524 +             let $t02057720922 = if (if (isOneAsset)
421 525                  then (pmtId == amIdStr)
422 526                  else false)
423 527                  then $Tuple2(pmtAmt, 0)
426 530                      else false)
427 531                      then $Tuple2(0, pmtAmt)
428 532                      else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
429 -             let writeAmAmt = $t01756217907._1
430 -             let writePrAmt = $t01756217907._2
533 +             let writeAmAmt = $t02057720922._1
534 +             let writePrAmt = $t02057720922._2
431 535              let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
432 536              $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
433 537              }
434 538      }
435 539  
436 540  
437 - func moa (order) = {
438 -     let cfg = gpc()
439 -     let amtAsId = cfg[idxAmAsId]
440 -     let prAsId = cfg[idxPrAsId]
441 -     let sts = parseIntValue(cfg[idxPoolSt])
442 -     let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
443 -     let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
444 -     let accAmtAsBalance = getAccBalance(amtAsId)
445 -     let accPrAsBalance = getAccBalance(prAsId)
446 -     let curPriceX18 = if ((order.orderType == Buy))
447 -         then pcp(amtAsDcm, prAsDcm, (accAmtAsBalance + order.amount), accPrAsBalance)
448 -         else pcp(amtAsDcm, prAsDcm, (accAmtAsBalance - order.amount), accPrAsBalance)
449 -     let curPrice = f1(curPriceX18, scale8)
541 + func getYD (xp,i,D) = {
542 +     let n = big2
543 +     let x = xp[if ((i == 0))
544 +         then 1
545 +         else 0]
546 +     let aPrecision = parseBigIntValue(Amult)
547 +     let a = (parseBigIntValue(A) * aPrecision)
548 +     let s = x
549 +     let ann = (a * n)
550 +     let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
551 +     let b = ((s + ((D * aPrecision) / ann)) - D)
552 +     func calc (acc,cur) =     {
553 +         let $t02211722137 = acc
554 +         let y = $t02211722137._1
555 +         let found = $t02211722137._2
556 +         if ((found != unit))
557 +             then acc
558 +             else {
559 +                 let yNext = (((y * y) + c) / ((big2 * y) + b))
560 +                 let yDiff = absBigInt((yNext - value(y)))
561 +                 if ((big1 >= yDiff))
562 +                     then $Tuple2(yNext, cur)
563 +                     else $Tuple2(yNext, unit)
564 +                 }
565 +         }
566 + 
567 +     let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
568 +     let $t02244422491 = {
569 +         let $l = arr
570 +         let $s = size($l)
571 +         let $acc0 = $Tuple2(D, unit)
572 +         func $f0_1 ($a,$i) =         if (($i >= $s))
573 +             then $a
574 +             else calc($a, $l[$i])
575 + 
576 +         func $f0_2 ($a,$i) =         if (($i >= $s))
577 +             then $a
578 +             else throw("List size exceeds 15")
579 + 
580 +         $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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
581 +         }
582 +     let y = $t02244422491._1
583 +     let found = $t02244422491._2
584 +     if ((found != unit))
585 +         then y
586 +         else throw(("Y calculation error, Y = " + toString(y)))
587 +     }
588 + 
589 + 
590 + func calcDLp (amountBalance,priceBalance,lpEmission) = {
591 +     let updatedDLp = fraction(getD([t1BigInt(amountBalance, toBigInt(cfgAmountAssetDecimals)), t1BigInt(priceBalance, toBigInt(cfgPriceAssetDecimals))]), scale18, lpEmission)
592 +     if ((lpEmission == big0))
593 +         then big0
594 +         else updatedDLp
595 +     }
596 + 
597 + 
598 + func calcCurrentDLp (amountAssetDelta,priceAssetDelta,lpAssetEmissionDelta) = {
599 +     let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amountAssetDelta)
600 +     let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - priceAssetDelta)
601 +     let lpAssetEmission = (toBigInt(value(assetInfo(cfgLpAssetId)).quantity) - lpAssetEmissionDelta)
602 +     let currentDLp = calcDLp(amountAssetBalance, priceAssetBalance, lpAssetEmission)
603 +     currentDLp
604 +     }
605 + 
606 + 
607 + func refreshDLpInternal (amountAssetBalanceDelta,priceAssetBalanceDelta,lpAssetEmissionDelta) = {
608 +     let amountAssetBalance = (getAccBalance(assetIdToString(cfgAmountAssetId)) + amountAssetBalanceDelta)
609 +     let priceAssetBalance = (getAccBalance(assetIdToString(cfgPriceAssetId)) + priceAssetBalanceDelta)
610 +     let lpAssetEmission = (value(assetInfo(cfgLpAssetId)).quantity + lpAssetEmissionDelta)
611 +     let updatedDLp = calcDLp(toBigInt(amountAssetBalance), toBigInt(priceAssetBalance), toBigInt(lpAssetEmission))
612 +     let actions = [IntegerEntry(keyDLpRefreshedHeight, height), StringEntry(keyDLp, toString(updatedDLp))]
613 +     $Tuple2(actions, updatedDLp)
614 +     }
615 + 
616 + 
617 + func validateUpdatedDLp (oldDLp,updatedDLp) = if ((updatedDLp >= oldDLp))
618 +     then true
619 +     else throwErr("updated DLp lower than current DLp")
620 + 
621 + 
622 + func validateMatcherOrderAllowed (order) = {
623 +     let amountAssetAmount = order.amount
624 +     let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
625 +     let $t02453524747 = if ((order.orderType == Buy))
626 +         then $Tuple2(amountAssetAmount, -(priceAssetAmount))
627 +         else $Tuple2(-(amountAssetAmount), priceAssetAmount)
628 +     let amountAssetBalanceDelta = $t02453524747._1
629 +     let priceAssetBalanceDelta = $t02453524747._2
450 630      if (if (if (igs())
451 631          then true
452 -         else (sts == PoolMatcherDis))
632 +         else (cfgPoolStatus == PoolMatcherDis))
453 633          then true
454 -         else (sts == PoolShutdown))
634 +         else (cfgPoolStatus == PoolShutdown))
455 635          then throw("Admin blocked")
456 -         else {
457 -             let orAmtAsset = order.assetPair.amountAsset
458 -             let orAmtAsStr = if ((orAmtAsset == unit))
459 -                 then "WAVES"
460 -                 else toBase58String(value(orAmtAsset))
461 -             let orPrAsset = order.assetPair.priceAsset
462 -             let orPrAsStr = if ((orPrAsset == unit))
463 -                 then "WAVES"
464 -                 else toBase58String(value(orPrAsset))
465 -             if (if ((orAmtAsStr != amtAsId))
466 -                 then true
467 -                 else (orPrAsStr != prAsId))
468 -                 then throw("Wr assets")
469 -                 else {
470 -                     let orderPrice = order.price
471 -                     let priceDcm = fraction(scale8, prAsDcm, amtAsDcm)
472 -                     let castOrderPrice = ts(orderPrice, scale8, priceDcm)
473 -                     let isOrderPriceValid = if ((order.orderType == Buy))
474 -                         then (curPrice >= castOrderPrice)
475 -                         else (castOrderPrice >= curPrice)
476 -                     true
477 -                     }
478 -             }
636 +         else if (if ((order.assetPair.amountAsset != cfgAmountAssetId))
637 +             then true
638 +             else (order.assetPair.priceAsset != cfgPriceAssetId))
639 +             then throw("Wr assets")
640 +             else {
641 +                 let dLp = parseBigIntValue(getStringValue(this, keyDLp))
642 +                 let $t02507725177 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
643 +                 let unusedActions = $t02507725177._1
644 +                 let dLpNew = $t02507725177._2
645 +                 let isOrderValid = (dLpNew >= dLp)
646 +                 let info = makeString([toString(dLp), toString(dLpNew)], " ")
647 +                 $Tuple2(isOrderValid, info)
648 +                 }
479 649      }
480 650  
481 651  
511 681      }
512 682  
513 683  
514 - func getD (xp) = {
515 -     let n = big2
516 -     let xp0 = xp[0]
517 -     let xp1 = xp[1]
518 -     let aPrecision = parseBigIntValue(Amult)
519 -     let a = (parseBigIntValue(A) * aPrecision)
520 -     let s = (xp0 + xp1)
521 -     if ((s == big0))
522 -         then big0
523 -         else {
524 -             let ann = (a * n)
525 -             let xp0_xp1_n_n = (((xp0 * xp1) * n) * n)
526 -             let ann_s_aPrecision = ((ann * s) / aPrecision)
527 -             let ann_aPrecision = (ann - aPrecision)
528 -             let n1 = (n + big1)
529 -             func calc (acc,cur) =             {
530 -                 let $t02245922479 = acc
531 -                 let d = $t02245922479._1
532 -                 let found = $t02245922479._2
533 -                 if ((found != unit))
534 -                     then acc
535 -                     else {
536 -                         let dp = (((d * d) * d) / xp0_xp1_n_n)
537 -                         let dNext = (((ann_s_aPrecision + (dp * n)) * d) / (((ann_aPrecision * d) / aPrecision) + (n1 * dp)))
538 -                         let dDiff = absBigInt((dNext - value(d)))
539 -                         if ((big1 >= dDiff))
540 -                             then $Tuple2(dNext, cur)
541 -                             else $Tuple2(dNext, unit)
542 -                         }
543 -                 }
544 - 
545 -             let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
546 -             let $t02290022947 = {
547 -                 let $l = arr
548 -                 let $s = size($l)
549 -                 let $acc0 = $Tuple2(s, unit)
550 -                 func $f0_1 ($a,$i) =                 if (($i >= $s))
551 -                     then $a
552 -                     else calc($a, $l[$i])
553 - 
554 -                 func $f0_2 ($a,$i) =                 if (($i >= $s))
555 -                     then $a
556 -                     else throw("List size exceeds 15")
557 - 
558 -                 $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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
559 -                 }
560 -             let d = $t02290022947._1
561 -             let found = $t02290022947._2
562 -             if ((found != unit))
563 -                 then d
564 -                 else throw(("D calculation error, D = " + toString(d)))
565 -             }
566 -     }
567 - 
568 - 
569 - func getYD (xp,i,D) = {
570 -     let n = big2
571 -     let x = xp[if ((i == 0))
572 -         then 1
573 -         else 0]
574 -     let aPrecision = parseBigIntValue(Amult)
575 -     let a = (parseBigIntValue(A) * aPrecision)
576 -     let s = x
577 -     let ann = (a * n)
578 -     let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
579 -     let b = ((s + ((D * aPrecision) / ann)) - D)
580 -     func calc (acc,cur) =     {
581 -         let $t02344723467 = acc
582 -         let y = $t02344723467._1
583 -         let found = $t02344723467._2
584 -         if ((found != unit))
585 -             then acc
586 -             else {
587 -                 let yNext = (((y * y) + c) / ((big2 * y) + b))
588 -                 let yDiff = absBigInt((yNext - value(y)))
589 -                 if ((big1 >= yDiff))
590 -                     then $Tuple2(yNext, cur)
591 -                     else $Tuple2(yNext, unit)
592 -                 }
593 -         }
594 - 
595 -     let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
596 -     let $t02377423821 = {
597 -         let $l = arr
598 -         let $s = size($l)
599 -         let $acc0 = $Tuple2(D, unit)
600 -         func $f0_1 ($a,$i) =         if (($i >= $s))
601 -             then $a
602 -             else calc($a, $l[$i])
603 - 
604 -         func $f0_2 ($a,$i) =         if (($i >= $s))
605 -             then $a
606 -             else throw("List size exceeds 15")
607 - 
608 -         $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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
609 -         }
610 -     let y = $t02377423821._1
611 -     let found = $t02377423821._2
612 -     if ((found != unit))
613 -         then y
614 -         else throw(("Y calculation error, Y = " + toString(y)))
615 -     }
616 - 
617 - 
618 684  func calcPutOneTkn (pmtAmtRaw,pmtAssetId,userAddress,txId,withTakeFee) = {
619 -     let poolConfig = gpc()
620 -     let amId = poolConfig[idxAmAsId]
621 -     let prId = poolConfig[idxPrAsId]
622 -     let lpId = poolConfig[idxLPAsId]
623 -     let amtDcm = parseIntValue(poolConfig[idxAmtAsDcm])
624 -     let priceDcm = parseIntValue(poolConfig[idxPriceAsDcm])
625 -     let lpAssetEmission = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "invalid lp asset").quantity)
685 +     let amId = toBase58String(value(cfgAmountAssetId))
686 +     let prId = toBase58String(value(cfgPriceAssetId))
687 +     let lpId = cfgLpAssetId
688 +     let amtDcm = cfgAmountAssetDecimals
689 +     let priceDcm = cfgPriceAssetDecimals
690 +     let lpAssetEmission = toBigInt(valueOrErrorMessage(assetInfo(lpId), "invalid lp asset").quantity)
626 691      let chechEmission = if ((lpAssetEmission > big0))
627 692          then true
628 693          else throw("initial deposit requires all coins")
630 695          then {
631 696              let amBalance = getAccBalance(amId)
632 697              let prBalance = getAccBalance(prId)
633 -             let $t02460425066 = if ((txId == ""))
698 +             let $t02752927991 = if ((txId == ""))
634 699                  then $Tuple2(amBalance, prBalance)
635 700                  else if ((pmtAssetId == amId))
636 701                      then if ((pmtAmtRaw > amBalance))
641 706                              then throw("invalid payment amount")
642 707                              else $Tuple2(amBalance, (prBalance - pmtAmtRaw))
643 708                          else throw("wrong pmtAssetId")
644 -             let amBalanceOld = $t02460425066._1
645 -             let prBalanceOld = $t02460425066._2
646 -             let $t02507225248 = if ((pmtAssetId == amId))
709 +             let amBalanceOld = $t02752927991._1
710 +             let prBalanceOld = $t02752927991._2
711 +             let $t02799728173 = if ((pmtAssetId == amId))
647 712                  then $Tuple2(pmtAmtRaw, 0)
648 713                  else if ((pmtAssetId == prId))
649 714                      then $Tuple2(0, pmtAmtRaw)
650 715                      else throw("invalid payment")
651 -             let amAmountRaw = $t02507225248._1
652 -             let prAmountRaw = $t02507225248._2
653 -             let $t02525225506 = if (withTakeFee)
716 +             let amAmountRaw = $t02799728173._1
717 +             let prAmountRaw = $t02799728173._2
718 +             let $t02817728431 = if (withTakeFee)
654 719                  then $Tuple3(takeFee(amAmountRaw, inFee)._1, takeFee(prAmountRaw, inFee)._1, takeFee(pmtAmtRaw, inFee)._2)
655 720                  else $Tuple3(amAmountRaw, prAmountRaw, 0)
656 -             let amAmount = $t02525225506._1
657 -             let prAmount = $t02525225506._2
658 -             let feeAmount = $t02525225506._3
721 +             let amAmount = $t02817728431._1
722 +             let prAmount = $t02817728431._2
723 +             let feeAmount = $t02817728431._3
659 724              let amBalanceNew = (amBalanceOld + amAmount)
660 725              let prBalanceNew = (prBalanceOld + prAmount)
661 -             let D0 = getD([toBigInt(amBalanceOld), toBigInt(prBalanceOld)])
662 -             let D1 = getD([toBigInt(amBalanceNew), toBigInt(prBalanceNew)])
726 +             let D0 = getD([t1(amBalanceOld, cfgAmountAssetDecimals), t1(prBalanceOld, cfgPriceAssetDecimals)])
727 +             let D1 = getD([t1(amBalanceNew, cfgAmountAssetDecimals), t1(prBalanceNew, cfgPriceAssetDecimals)])
663 728              let checkD = if ((D1 > D0))
664 729                  then true
665 730                  else throw()
666 731              if ((checkD == checkD))
667 732                  then {
668 -                     let lpAmount = fraction(lpAssetEmission, (D1 - D0), D0)
733 +                     let lpAmount = fraction(lpAssetEmission, (D1 - D0), D0, FLOOR)
669 734                      let curPrice = f1(cpbi(t1(prBalanceNew, priceDcm), t1(amBalanceNew, amtDcm)), scale8)
670 735                      let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId), dataPutActionInfo(amAmountRaw, prAmountRaw, toInt(lpAmount), curPrice, 0, 0, height, lastBlock.timestamp, 0, 0))]
671 736                      let poolProportion = fraction(prBalanceOld, scale8, amBalanceOld)
682 747  
683 748  
684 749  func getOneTknV2Internal (outAssetId,minOutAmount,payments,caller,originCaller,transactionId) = {
685 -     let poolConfig = gpc()
686 -     let lpId = poolConfig[idxLPAsId]
687 -     let amId = poolConfig[idxAmAsId]
688 -     let prId = poolConfig[idxPrAsId]
689 -     let amDecimals = parseIntValue(poolConfig[idxAmtAsDcm])
690 -     let prDecimals = parseIntValue(poolConfig[idxPriceAsDcm])
691 -     let poolStatus = poolConfig[idxPoolSt]
750 +     let lpId = toBase58String(value(cfgLpAssetId))
751 +     let amId = toBase58String(value(cfgAmountAssetId))
752 +     let prId = toBase58String(value(cfgPriceAssetId))
753 +     let amDecimals = cfgAmountAssetDecimals
754 +     let prDecimals = cfgPriceAssetDecimals
755 +     let poolStatus = cfgPoolStatus
692 756      let userAddress = if ((caller == restContract))
693 757          then originCaller
694 758          else caller
695 759      let pmt = value(payments[0])
696 760      let pmtAssetId = value(pmt.assetId)
697 761      let pmtAmt = pmt.amount
698 -     let txId58 = toBase58String(transactionId)
699 -     if ((lpId != toBase58String(pmtAssetId)))
700 -         then throw("Wrong LP")
701 -         else {
702 -             let amBalance = getAccBalance(amId)
703 -             let prBalance = getAccBalance(prId)
704 -             let $t02750827619 = {
705 -                 let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, pmtAmt], nil)
706 -                 if ($isInstanceOf(@, "(Int, Int)"))
707 -                     then @
708 -                     else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
709 -                 }
710 -             if (($t02750827619 == $t02750827619))
711 -                 then {
712 -                     let feeAmount = $t02750827619._2
713 -                     let totalGet = $t02750827619._1
714 -                     let totalAmount = if (if ((minOutAmount > 0))
715 -                         then (minOutAmount > totalGet)
716 -                         else false)
717 -                         then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
718 -                         else totalGet
719 -                     let $t02780928116 = if ((outAssetId == amId))
720 -                         then $Tuple4(totalAmount, 0, ((amBalance - totalAmount) - feeAmount), prBalance)
721 -                         else if ((outAssetId == prId))
722 -                             then $Tuple4(0, totalAmount, amBalance, ((prBalance - totalAmount) - feeAmount))
723 -                             else throw("invalid out asset id")
724 -                     let outAm = $t02780928116._1
725 -                     let outPr = $t02780928116._2
726 -                     let amBalanceNew = $t02780928116._3
727 -                     let prBalanceNew = $t02780928116._4
728 -                     let curPrX18 = cpbi(t1(prBalanceNew, prDecimals), t1(amBalanceNew, amDecimals))
729 -                     let curPr = f1(curPrX18, scale8)
730 -                     let outAssetIdOrWaves = if ((outAssetId == "WAVES"))
731 -                         then unit
732 -                         else fromBase58String(outAssetId)
733 -                     let sendFeeToMatcher = if ((feeAmount > 0))
734 -                         then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetIdOrWaves)]
735 -                         else nil
736 -                     let state = ([ScriptTransfer(userAddress, totalAmount, outAssetIdOrWaves), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAm, outPr, pmtAmt, curPr, height, lastBlock.timestamp)), IntegerEntry(pl(), curPr), IntegerEntry(ph(height, lastBlock.timestamp), curPr)] ++ sendFeeToMatcher)
737 -                     if ((state == state))
762 +     let currentDLp = calcCurrentDLp(big0, big0, big0)
763 +     if ((currentDLp == currentDLp))
764 +         then {
765 +             let txId58 = toBase58String(transactionId)
766 +             if ((lpId != toBase58String(pmtAssetId)))
767 +                 then throw("Wrong LP")
768 +                 else {
769 +                     let amBalance = getAccBalance(amId)
770 +                     let prBalance = getAccBalance(prId)
771 +                     let $t03054330654 = {
772 +                         let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, pmtAmt], nil)
773 +                         if ($isInstanceOf(@, "(Int, Int)"))
774 +                             then @
775 +                             else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
776 +                         }
777 +                     if (($t03054330654 == $t03054330654))
738 778                          then {
739 -                             let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
740 -                             if ((burn == burn))
741 -                                 then $Tuple2(state, totalAmount)
779 +                             let feeAmount = $t03054330654._2
780 +                             let totalGet = $t03054330654._1
781 +                             let totalAmount = if (if ((minOutAmount > 0))
782 +                                 then (minOutAmount > totalGet)
783 +                                 else false)
784 +                                 then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
785 +                                 else totalGet
786 +                             let $t03084431151 = if ((outAssetId == amId))
787 +                                 then $Tuple4(totalAmount, 0, ((amBalance - totalAmount) - feeAmount), prBalance)
788 +                                 else if ((outAssetId == prId))
789 +                                     then $Tuple4(0, totalAmount, amBalance, ((prBalance - totalAmount) - feeAmount))
790 +                                     else throw("invalid out asset id")
791 +                             let outAm = $t03084431151._1
792 +                             let outPr = $t03084431151._2
793 +                             let amBalanceNew = $t03084431151._3
794 +                             let prBalanceNew = $t03084431151._4
795 +                             let curPrX18 = cpbi(t1(prBalanceNew, prDecimals), t1(amBalanceNew, amDecimals))
796 +                             let curPr = f1(curPrX18, scale8)
797 +                             let outAssetIdOrWaves = if ((outAssetId == "WAVES"))
798 +                                 then unit
799 +                                 else fromBase58String(outAssetId)
800 +                             let sendFeeToMatcher = if ((feeAmount > 0))
801 +                                 then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetIdOrWaves)]
802 +                                 else nil
803 +                             let state = ([ScriptTransfer(userAddress, totalAmount, outAssetIdOrWaves), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAm, outPr, pmtAmt, curPr, height, lastBlock.timestamp)), IntegerEntry(pl(), curPr), IntegerEntry(ph(height, lastBlock.timestamp), curPr)] ++ sendFeeToMatcher)
804 +                             if ((state == state))
805 +                                 then {
806 +                                     let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
807 +                                     if ((burn == burn))
808 +                                         then {
809 +                                             let $t03193632286 = {
810 +                                                 let feeAmountForCalc = if ((this == feeCollectorAddress))
811 +                                                     then 0
812 +                                                     else feeAmount
813 +                                                 let outInAmountAsset = if ((parseAssetId(outAssetId) == cfgAmountAssetId))
814 +                                                     then true
815 +                                                     else false
816 +                                                 if (outInAmountAsset)
817 +                                                     then $Tuple2(-((totalGet + feeAmountForCalc)), 0)
818 +                                                     else $Tuple2(0, -((totalGet + feeAmountForCalc)))
819 +                                                 }
820 +                                             let amountAssetBalanceDelta = $t03193632286._1
821 +                                             let priceAssetBalanceDelta = $t03193632286._2
822 +                                             let $t03228932397 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
823 +                                             let refreshDLpActions = $t03228932397._1
824 +                                             let updatedDLp = $t03228932397._2
825 +                                             let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
826 +                                             if ((isUpdatedDLpValid == isUpdatedDLpValid))
827 +                                                 then $Tuple2((state ++ refreshDLpActions), totalAmount)
828 +                                                 else throw("Strict value is not equal to itself.")
829 +                                             }
830 +                                         else throw("Strict value is not equal to itself.")
831 +                                     }
742 832                                  else throw("Strict value is not equal to itself.")
743 833                              }
744 834                          else throw("Strict value is not equal to itself.")
745 835                      }
746 -                 else throw("Strict value is not equal to itself.")
747 836              }
837 +         else throw("Strict value is not equal to itself.")
748 838      }
749 839  
750 840  
849 939          else if ((size(i.payments) != 2))
850 940              then throw("2 pmnts expd")
851 941              else {
852 -                 let e = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true, false, true, 0, "")
853 -                 let emitLpAmt = e._2
854 -                 let lpAssetId = e._7
855 -                 let state = e._9
856 -                 let amDiff = e._10
857 -                 let prDiff = e._11
858 -                 let amId = e._12
859 -                 let prId = e._13
860 -                 let r = invoke(fca, "emit", [emitLpAmt], nil)
861 -                 if ((r == r))
942 +                 let amAssetPmt = toBigInt(value(i.payments[0]).amount)
943 +                 let prAssetPmt = toBigInt(value(i.payments[1]).amount)
944 +                 let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amAssetPmt)
945 +                 if ((amountAssetBalance == amountAssetBalance))
862 946                      then {
863 -                         let el =                         match r {
864 -                             case legacy: Address => 
865 -                                 invoke(legacy, "emit", [emitLpAmt], nil)
866 -                             case _ => 
867 -                                 unit
868 -                         }
869 -                         if ((el == el))
947 +                         let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - prAssetPmt)
948 +                         if ((priceAssetBalance == priceAssetBalance))
870 949                              then {
871 -                                 let sa = if ((amDiff > 0))
872 -                                     then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
873 -                                     else nil
874 -                                 if ((sa == sa))
950 +                                 let lpAssetEmission = toBigInt(value(assetInfo(cfgLpAssetId)).quantity)
951 +                                 if ((lpAssetEmission == lpAssetEmission))
875 952                                      then {
876 -                                         let sp = if ((prDiff > 0))
877 -                                             then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
878 -                                             else nil
879 -                                         if ((sp == sp))
953 +                                         let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
954 +                                         if ((currentDLp == currentDLp))
880 955                                              then {
881 -                                                 let lpTrnsfr = if (autoStake)
956 +                                                 let e = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true, false, true, 0, "")
957 +                                                 let emitLpAmt = e._2
958 +                                                 let lpAssetId = e._7
959 +                                                 let state = e._9
960 +                                                 let amDiff = e._10
961 +                                                 let prDiff = e._11
962 +                                                 let amId = e._12
963 +                                                 let prId = e._13
964 +                                                 let r = invoke(fca, "emit", [emitLpAmt], nil)
965 +                                                 if ((r == r))
882 966                                                      then {
883 -                                                         let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
884 -                                                         if ((ss == ss))
885 -                                                             then nil
967 +                                                         let el =                                                         match r {
968 +                                                             case legacy: Address => 
969 +                                                                 invoke(legacy, "emit", [emitLpAmt], nil)
970 +                                                             case _ => 
971 +                                                                 unit
972 +                                                         }
973 +                                                         if ((el == el))
974 +                                                             then {
975 +                                                                 let sa = if ((amDiff > 0))
976 +                                                                     then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
977 +                                                                     else nil
978 +                                                                 if ((sa == sa))
979 +                                                                     then {
980 +                                                                         let sp = if ((prDiff > 0))
981 +                                                                             then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
982 +                                                                             else nil
983 +                                                                         if ((sp == sp))
984 +                                                                             then {
985 +                                                                                 let lpTrnsfr = if (autoStake)
986 +                                                                                     then {
987 +                                                                                         let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
988 +                                                                                         if ((ss == ss))
989 +                                                                                             then nil
990 +                                                                                             else throw("Strict value is not equal to itself.")
991 +                                                                                         }
992 +                                                                                     else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
993 +                                                                                 let $t03654636688 = refreshDLpInternal(0, 0, 0)
994 +                                                                                 let refreshDLpActions = $t03654636688._1
995 +                                                                                 let updatedDLp = $t03654636688._2
996 +                                                                                 let check = if ((updatedDLp >= currentDLp))
997 +                                                                                     then true
998 +                                                                                     else throwErr(makeString(["updated DLp lower than current DLp", toString(amountAssetBalance), toString(priceAssetBalance), toString(lpAssetEmission), toString(currentDLp), toString(updatedDLp), toString(amDiff), toString(prDiff)], " "))
999 +                                                                                 if ((check == check))
1000 +                                                                                     then {
1001 +                                                                                         let lpAssetEmissionAfter = value(assetInfo(cfgLpAssetId)).quantity
1002 +                                                                                         if ((lpAssetEmissionAfter == lpAssetEmissionAfter))
1003 +                                                                                             then ((state ++ lpTrnsfr) ++ refreshDLpActions)
1004 +                                                                                             else throw("Strict value is not equal to itself.")
1005 +                                                                                         }
1006 +                                                                                     else throw("Strict value is not equal to itself.")
1007 +                                                                                 }
1008 +                                                                             else throw("Strict value is not equal to itself.")
1009 +                                                                         }
1010 +                                                                     else throw("Strict value is not equal to itself.")
1011 +                                                                 }
886 1012                                                              else throw("Strict value is not equal to itself.")
887 1013                                                          }
888 -                                                     else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
889 -                                                 (state ++ lpTrnsfr)
1014 +                                                     else throw("Strict value is not equal to itself.")
890 1015                                                  }
891 1016                                              else throw("Strict value is not equal to itself.")
892 1017                                          }
924 1049          else throwErr("exactly 1 payment are expected")]
925 1050      if ((checks == checks))
926 1051          then {
927 -             let poolConfig = gpc()
928 -             let amId = poolConfig[idxAmAsId]
929 -             let prId = poolConfig[idxPrAsId]
930 -             let lpId = fromBase58String(poolConfig[idxLPAsId])
931 -             let amDecimals = parseIntValue(poolConfig[idxAmtAsDcm])
932 -             let prDecimals = parseIntValue(poolConfig[idxPriceAsDcm])
1052 +             let amId = toBase58String(value(cfgAmountAssetId))
1053 +             let prId = toBase58String(value(cfgPriceAssetId))
1054 +             let lpId = cfgLpAssetId
1055 +             let amDecimals = cfgAmountAssetDecimals
1056 +             let prDecimals = cfgPriceAssetDecimals
933 1057              let userAddress = if ((i.caller == this))
934 1058                  then i.originCaller
935 1059                  else i.caller
936 1060              let pmt = value(i.payments[0])
937 1061              let pmtAssetId = toBase58String(value(pmt.assetId))
938 1062              let pmtAmt = pmt.amount
939 -             let $t03347833636 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
940 -             if (($t03347833636 == $t03347833636))
1063 +             let currentDLp = if ((pmt.assetId == cfgAmountAssetId))
1064 +                 then calcCurrentDLp(toBigInt(pmtAmt), toBigInt(0), toBigInt(0))
1065 +                 else calcCurrentDLp(toBigInt(0), toBigInt(pmtAmt), toBigInt(0))
1066 +             if ((currentDLp == currentDLp))
941 1067                  then {
942 -                     let feeAmount = $t03347833636._3
943 -                     let state = $t03347833636._2
944 -                     let estimLP = $t03347833636._1
945 -                     let emitLpAmt = if (if ((minOutAmount > 0))
946 -                         then (minOutAmount > estimLP)
947 -                         else false)
948 -                         then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
949 -                         else estimLP
950 -                     let e = invoke(fca, "emit", [emitLpAmt], nil)
951 -                     if ((e == e))
1068 +                     let $t03832938487 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1069 +                     if (($t03832938487 == $t03832938487))
952 1070                          then {
953 -                             let el =                             match e {
954 -                                 case legacy: Address => 
955 -                                     invoke(legacy, "emit", [emitLpAmt], nil)
956 -                                 case _ => 
957 -                                     unit
958 -                             }
959 -                             if ((el == el))
1071 +                             let feeAmount = $t03832938487._3
1072 +                             let state = $t03832938487._2
1073 +                             let estimLP = $t03832938487._1
1074 +                             let emitLpAmt = if (if ((minOutAmount > 0))
1075 +                                 then (minOutAmount > estimLP)
1076 +                                 else false)
1077 +                                 then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
1078 +                                 else estimLP
1079 +                             let e = invoke(fca, "emit", [emitLpAmt], nil)
1080 +                             if ((e == e))
960 1081                                  then {
961 -                                     let lpTrnsfr = if (autoStake)
1082 +                                     let el =                                     match e {
1083 +                                         case legacy: Address => 
1084 +                                             invoke(legacy, "emit", [emitLpAmt], nil)
1085 +                                         case _ => 
1086 +                                             unit
1087 +                                     }
1088 +                                     if ((el == el))
962 1089                                          then {
963 -                                             let ss = invoke(stakingContract, "stake", nil, [AttachedPayment(lpId, emitLpAmt)])
964 -                                             if ((ss == ss))
965 -                                                 then nil
1090 +                                             let lpTrnsfr = if (autoStake)
1091 +                                                 then {
1092 +                                                     let ss = invoke(stakingContract, "stake", nil, [AttachedPayment(lpId, emitLpAmt)])
1093 +                                                     if ((ss == ss))
1094 +                                                         then nil
1095 +                                                         else throw("Strict value is not equal to itself.")
1096 +                                                     }
1097 +                                                 else [ScriptTransfer(i.caller, emitLpAmt, lpId)]
1098 +                                             let sendFeeToMatcher = if ((feeAmount > 0))
1099 +                                                 then [ScriptTransfer(feeCollectorAddress, feeAmount, fromBase58String(pmtAssetId))]
1100 +                                                 else nil
1101 +                                             let $t03930239651 = if ((this == feeCollectorAddress))
1102 +                                                 then $Tuple2(0, 0)
1103 +                                                 else {
1104 +                                                     let paymentInAmountAsset = if ((pmt.assetId == cfgAmountAssetId))
1105 +                                                         then true
1106 +                                                         else false
1107 +                                                     if (paymentInAmountAsset)
1108 +                                                         then $Tuple2(-(feeAmount), 0)
1109 +                                                         else $Tuple2(0, -(feeAmount))
1110 +                                                     }
1111 +                                             let amountAssetBalanceDelta = $t03930239651._1
1112 +                                             let priceAssetBalanceDelta = $t03930239651._2
1113 +                                             let $t03965439762 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1114 +                                             let refreshDLpActions = $t03965439762._1
1115 +                                             let updatedDLp = $t03965439762._2
1116 +                                             let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1117 +                                             if ((isUpdatedDLpValid == isUpdatedDLpValid))
1118 +                                                 then $Tuple2((((state ++ lpTrnsfr) ++ sendFeeToMatcher) ++ refreshDLpActions), emitLpAmt)
966 1119                                                  else throw("Strict value is not equal to itself.")
967 1120                                              }
968 -                                         else [ScriptTransfer(i.caller, emitLpAmt, lpId)]
969 -                                     let sendFeeToMatcher = if ((feeAmount > 0))
970 -                                         then [ScriptTransfer(feeCollectorAddress, feeAmount, fromBase58String(pmtAssetId))]
971 -                                         else nil
972 -                                     $Tuple2(((state ++ lpTrnsfr) ++ sendFeeToMatcher), emitLpAmt)
1121 +                                         else throw("Strict value is not equal to itself.")
973 1122                                      }
974 1123                                  else throw("Strict value is not equal to itself.")
975 1124                              }
989 1138          then throw("2 pmnts expd")
990 1139          else {
991 1140              let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlpg, false, false, true, 0, "")
992 -             estPut._9
1141 +             let state = estPut._9
1142 +             let amAssetPmt = toBigInt(value(i.payments[0]).amount)
1143 +             let prAssetPmt = toBigInt(value(i.payments[1]).amount)
1144 +             let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
1145 +             if ((currentDLp == currentDLp))
1146 +                 then {
1147 +                     let $t04079240857 = refreshDLpInternal(0, 0, 0)
1148 +                     let refreshDLpActions = $t04079240857._1
1149 +                     let updatedDLp = $t04079240857._2
1150 +                     let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1151 +                     if ((isUpdatedDLpValid == isUpdatedDLpValid))
1152 +                         then (state ++ refreshDLpActions)
1153 +                         else throw("Strict value is not equal to itself.")
1154 +                     }
1155 +                 else throw("Strict value is not equal to itself.")
993 1156              }
994 1157  
995 1158  
996 1159  
997 1160  @Callable(i)
998 1161  func get () = {
999 -     let r = cg(i)
1000 -     let outAmtAmt = r._1
1001 -     let outPrAmt = r._2
1002 -     let pmtAmt = r._3
1003 -     let pmtAssetId = r._4
1004 -     let state = r._5
1005 -     let b = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1006 -     if ((b == b))
1007 -         then state
1162 +     let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1163 +     if ((currentDLp == currentDLp))
1164 +         then {
1165 +             let r = cg(i)
1166 +             let outAmtAmt = r._1
1167 +             let outPrAmt = r._2
1168 +             let pmtAmt = r._3
1169 +             let pmtAssetId = r._4
1170 +             let state = r._5
1171 +             let b = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1172 +             if ((b == b))
1173 +                 then {
1174 +                     let $t04203042112 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1175 +                     let refreshDLpActions = $t04203042112._1
1176 +                     let updatedDLp = $t04203042112._2
1177 +                     let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1178 +                     if ((isUpdatedDLpValid == isUpdatedDLpValid))
1179 +                         then (state ++ refreshDLpActions)
1180 +                         else throw("Strict value is not equal to itself.")
1181 +                     }
1182 +                 else throw("Strict value is not equal to itself.")
1183 +             }
1008 1184          else throw("Strict value is not equal to itself.")
1009 1185      }
1010 1186  
1032 1208          else throwErr("exactly 1 payment are expected")]
1033 1209      if ((checks == checks))
1034 1210          then {
1035 -             let $t03625836413 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1036 -             let state = $t03625836413._1
1037 -             let totalAmount = $t03625836413._2
1211 +             let $t04273042885 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1212 +             let state = $t04273042885._1
1213 +             let totalAmount = $t04273042885._2
1038 1214              $Tuple2(state, totalAmount)
1039 1215              }
1040 1216          else throw("Strict value is not equal to itself.")
1043 1219  
1044 1220  
1045 1221  @Callable(i)
1222 + func refreshDLp () = {
1223 +     let lastRefreshedBlockHeight = valueOrElse(getInteger(keyDLpRefreshedHeight), 0)
1224 +     let checkLastRefreshedBlockHeight = if (((height - lastRefreshedBlockHeight) >= dLpRefreshDelay))
1225 +         then unit
1226 +         else throwErr(makeString([toString(dLpRefreshDelay), " blocks have not passed since the previous call"], ""))
1227 +     if ((checkLastRefreshedBlockHeight == checkLastRefreshedBlockHeight))
1228 +         then {
1229 +             let dLp = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, keyDLp), "0")), fmtErr("invalid dLp"))
1230 +             let $t04340943473 = refreshDLpInternal(0, 0, 0)
1231 +             let dLpUpdateActions = $t04340943473._1
1232 +             let updatedDLp = $t04340943473._2
1233 +             let actions = if ((dLp != updatedDLp))
1234 +                 then dLpUpdateActions
1235 +                 else throwErr("nothing to refresh")
1236 +             $Tuple2(actions, toString(updatedDLp))
1237 +             }
1238 +         else throw("Strict value is not equal to itself.")
1239 +     }
1240 + 
1241 + 
1242 + 
1243 + @Callable(i)
1046 1244  func getOneTknV2READONLY (outAssetId,lpAssetAmount) = {
1047 -     let poolConfig = gpc()
1048 -     let amId = poolConfig[idxAmAsId]
1049 -     let prId = poolConfig[idxPrAsId]
1050 -     let lpId = poolConfig[idxLPAsId]
1245 +     let amId = toBase58String(value(cfgAmountAssetId))
1246 +     let prId = toBase58String(value(cfgPriceAssetId))
1247 +     let lpId = toBase58String(value(cfgLpAssetId))
1051 1248      let xp = [toBigInt(getAccBalance(amId)), toBigInt(getAccBalance(prId))]
1052 1249      let lpEmission = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "invalid lp asset").quantity)
1053 1250      let D0 = getD(xp)
1060 1257      let newY = getYD(xp, index, D1)
1061 1258      let dy = (xp[index] - newY)
1062 1259      let totalGetRaw = max([0, toInt((dy - big1))])
1063 -     let $t03720337258 = takeFee(totalGetRaw, outFee)
1064 -     let totalGet = $t03720337258._1
1065 -     let feeAmount = $t03720337258._2
1260 +     let $t04440344458 = takeFee(totalGetRaw, outFee)
1261 +     let totalGet = $t04440344458._1
1262 +     let feeAmount = $t04440344458._2
1066 1263      $Tuple2(nil, $Tuple2(totalGet, feeAmount))
1067 1264      }
1068 1265  
1070 1267  
1071 1268  @Callable(i)
1072 1269  func getOneTknV2WithBonusREADONLY (outAssetId,lpAssetAmount) = {
1073 -     let poolConfig = gpc()
1074 -     let amId = poolConfig[idxAmAsId]
1075 -     let prId = poolConfig[idxPrAsId]
1076 -     let lpId = poolConfig[idxLPAsId]
1270 +     let amId = toBase58String(value(cfgAmountAssetId))
1271 +     let prId = toBase58String(value(cfgPriceAssetId))
1272 +     let lpId = toBase58String(value(cfgLpAssetId))
1077 1273      let amBalance = getAccBalance(amId)
1078 1274      let prBalance = getAccBalance(prId)
1079 -     let $t03760337718 = {
1275 +     let $t04483344948 = {
1080 1276          let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, lpAssetAmount], nil)
1081 1277          if ($isInstanceOf(@, "(Int, Int)"))
1082 1278              then @
1083 1279              else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
1084 1280          }
1085 -     let totalGet = $t03760337718._1
1086 -     let feeAmount = $t03760337718._2
1281 +     let totalGet = $t04483344948._1
1282 +     let feeAmount = $t04483344948._2
1087 1283      let r = ego("", lpId, lpAssetAmount, this)
1088 1284      let outAmAmt = r._1
1089 1285      let outPrAmt = r._2
1111 1307          else if ((noLessThenPriceAsset > outPrAmt))
1112 1308              then throw(((("Failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
1113 1309              else {
1114 -                 let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1115 -                 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1116 -                     then state
1310 +                 let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1311 +                 if ((currentDLp == currentDLp))
1312 +                     then {
1313 +                         let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1314 +                         if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1315 +                             then {
1316 +                                 let $t04611446195 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1317 +                                 let refreshDLpActions = $t04611446195._1
1318 +                                 let updatedDLp = $t04611446195._2
1319 +                                 let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1320 +                                 if ((isUpdatedDLpValid == isUpdatedDLpValid))
1321 +                                     then (state ++ refreshDLpActions)
1322 +                                     else throw("Strict value is not equal to itself.")
1323 +                                 }
1324 +                             else throw("Strict value is not equal to itself.")
1325 +                         }
1117 1326                      else throw("Strict value is not equal to itself.")
1118 1327                  }
1119 1328      }
1127 1336          else true
1128 1337      if ((checkPayments == checkPayments))
1129 1338          then {
1130 -             let cfg = gpc()
1131 1339              let factoryCfg = gfc()
1132 -             let lpAssetId = fromBase58String(cfg[idxLPAsId])
1340 +             let lpAssetId = cfgLpAssetId
1133 1341              let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
1134 -             let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), amount], nil)
1135 -             if ((unstakeInv == unstakeInv))
1342 +             let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1343 +             if ((currentDLp == currentDLp))
1136 1344                  then {
1137 -                     let r = ego(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
1138 -                     let sts = parseIntValue(r._9)
1139 -                     let state = r._10
1140 -                     let v = if (if (igs())
1141 -                         then true
1142 -                         else (sts == PoolShutdown))
1143 -                         then throw(("Blocked: " + toString(sts)))
1144 -                         else true
1145 -                     if ((v == v))
1345 +                     let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), amount], nil)
1346 +                     if ((unstakeInv == unstakeInv))
1146 1347                          then {
1147 -                             let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1148 -                             if ((burnA == burnA))
1149 -                                 then state
1348 +                             let r = ego(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
1349 +                             let outAmAmt = r._1
1350 +                             let outPrAmt = r._2
1351 +                             let sts = parseIntValue(r._9)
1352 +                             let state = r._10
1353 +                             let v = if (if (igs())
1354 +                                 then true
1355 +                                 else (sts == PoolShutdown))
1356 +                                 then throw(("Blocked: " + toString(sts)))
1357 +                                 else true
1358 +                             if ((v == v))
1359 +                                 then {
1360 +                                     let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1361 +                                     if ((burnA == burnA))
1362 +                                         then {
1363 +                                             let $t04722247303 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1364 +                                             let refreshDLpActions = $t04722247303._1
1365 +                                             let updatedDLp = $t04722247303._2
1366 +                                             let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1367 +                                             if ((isUpdatedDLpValid == isUpdatedDLpValid))
1368 +                                                 then (state ++ refreshDLpActions)
1369 +                                                 else throw("Strict value is not equal to itself.")
1370 +                                             }
1371 +                                         else throw("Strict value is not equal to itself.")
1372 +                                     }
1150 1373                                  else throw("Strict value is not equal to itself.")
1151 1374                              }
1152 1375                          else throw("Strict value is not equal to itself.")
1170 1393          else throw("no payments are expected")]
1171 1394      if ((checks == checks))
1172 1395          then {
1173 -             let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1174 -             if ((unstakeInv == unstakeInv))
1396 +             let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1397 +             if ((currentDLp == currentDLp))
1175 1398                  then {
1176 -                     let res = ego(toBase58String(i.transactionId), toBase58String(cfgLpAssetId), unstakeAmount, i.caller)
1177 -                     let outAmAmt = res._1
1178 -                     let outPrAmt = res._2
1179 -                     let state = res._10
1180 -                     let checkAmounts = [if ((outAmAmt >= noLessThenAmountAsset))
1181 -                         then true
1182 -                         else throw(makeString(["amount asset amount to receive is less than ", toString(noLessThenAmountAsset)], "")), if ((outPrAmt >= noLessThenPriceAsset))
1183 -                         then true
1184 -                         else throw(makeString(["price asset amount to receive is less than ", toString(noLessThenPriceAsset)], ""))]
1185 -                     if ((checkAmounts == checkAmounts))
1399 +                     let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1400 +                     if ((unstakeInv == unstakeInv))
1186 1401                          then {
1187 -                             let burnLPAssetOnFactory = invoke(fca, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1188 -                             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1189 -                                 then state
1402 +                             let res = ego(toBase58String(i.transactionId), toBase58String(cfgLpAssetId), unstakeAmount, i.caller)
1403 +                             let outAmAmt = res._1
1404 +                             let outPrAmt = res._2
1405 +                             let state = res._10
1406 +                             let checkAmounts = [if ((outAmAmt >= noLessThenAmountAsset))
1407 +                                 then true
1408 +                                 else throw(makeString(["amount asset amount to receive is less than ", toString(noLessThenAmountAsset)], "")), if ((outPrAmt >= noLessThenPriceAsset))
1409 +                                 then true
1410 +                                 else throw(makeString(["price asset amount to receive is less than ", toString(noLessThenPriceAsset)], ""))]
1411 +                             if ((checkAmounts == checkAmounts))
1412 +                                 then {
1413 +                                     let burnLPAssetOnFactory = invoke(fca, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1414 +                                     if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1415 +                                         then {
1416 +                                             let $t04855448635 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1417 +                                             let refreshDLpActions = $t04855448635._1
1418 +                                             let updatedDLp = $t04855448635._2
1419 +                                             let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1420 +                                             if ((isUpdatedDLpValid == isUpdatedDLpValid))
1421 +                                                 then (state ++ refreshDLpActions)
1422 +                                                 else throw("Strict value is not equal to itself.")
1423 +                                             }
1424 +                                         else throw("Strict value is not equal to itself.")
1425 +                                     }
1190 1426                                  else throw("Strict value is not equal to itself.")
1191 1427                              }
1192 1428                          else throw("Strict value is not equal to itself.")
1220 1456          else throwErr("no payments are expected")]
1221 1457      if ((checks == checks))
1222 1458          then {
1223 -             let cfg = gpc()
1224 1459              let factoryCfg = gfc()
1225 -             let lpAssetId = fromBase58String(cfg[idxLPAsId])
1460 +             let lpAssetId = cfgLpAssetId
1226 1461              let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
1227 1462              let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), unstakeAmount], nil)
1228 1463              if ((unstakeInv == unstakeInv))
1229 1464                  then {
1230 -                     let $t04155641744 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1231 -                     let state = $t04155641744._1
1232 -                     let totalAmount = $t04155641744._2
1465 +                     let $t04953049718 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1466 +                     let state = $t04953049718._1
1467 +                     let totalAmount = $t04953049718._2
1233 1468                      $Tuple2(state, totalAmount)
1234 1469                      }
1235 1470                  else throw("Strict value is not equal to itself.")
1241 1476  
1242 1477  @Callable(i)
1243 1478  func putOneTknV2WithBonusREADONLY (paymentAmountRaw,paymentAssetId) = {
1244 -     let poolConfig = gpc()
1245 -     let amId = poolConfig[idxAmAsId]
1246 -     let prId = poolConfig[idxPrAsId]
1247 -     let lpId = poolConfig[idxLPAsId]
1248 -     let $t04200342106 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1249 -     let lpAmount = $t04200342106._1
1250 -     let state = $t04200342106._2
1251 -     let feeAmount = $t04200342106._3
1252 -     let bonus = $t04200342106._4
1479 +     let $t04984649949 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1480 +     let lpAmount = $t04984649949._1
1481 +     let state = $t04984649949._2
1482 +     let feeAmount = $t04984649949._3
1483 +     let bonus = $t04984649949._4
1253 1484      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1254 1485      }
1255 1486  
1257 1488  
1258 1489  @Callable(i)
1259 1490  func putOneTknV2WithoutTakeFeeREADONLY (paymentAmountRaw,paymentAssetId) = {
1260 -     let poolConfig = gpc()
1261 -     let amId = poolConfig[idxAmAsId]
1262 -     let prId = poolConfig[idxPrAsId]
1263 -     let lpId = poolConfig[idxLPAsId]
1264 -     let $t04238542489 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1265 -     let lpAmount = $t04238542489._1
1266 -     let state = $t04238542489._2
1267 -     let feeAmount = $t04238542489._3
1268 -     let bonus = $t04238542489._4
1491 +     let $t05009750201 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1492 +     let lpAmount = $t05009750201._1
1493 +     let state = $t05009750201._2
1494 +     let feeAmount = $t05009750201._3
1495 +     let bonus = $t05009750201._4
1269 1496      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1270 1497      }
1271 1498  
1350 1577      match tx {
1351 1578          case order: Order => 
1352 1579              let matcherPub = mp()
1353 -             let orderValid = moa(order)
1580 +             let $t05299353062 = validateMatcherOrderAllowed(order)
1581 +             let orderValid = $t05299353062._1
1582 +             let orderValidInfo = $t05299353062._2
1354 1583              let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
1355 1584              let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
1356 1585              if (if (if (orderValid)
1359 1588                  then matcherValid
1360 1589                  else false)
1361 1590                  then true
1362 -                 else toe(orderValid, senderValid, matcherValid)
1591 +                 else throwOrderError(orderValid, orderValidInfo, senderValid, matcherValid)
1363 1592          case s: SetScriptTransaction => 
1364 -             let newHash = blake2b256(value(s.script))
1365 -             let allowedHash = fromBase64String(value(getString(fca, keyAllowedLpStableScriptHash())))
1366 -             let currentHash = scriptHash(this)
1367 -             if (if ((allowedHash == newHash))
1368 -                 then (currentHash != newHash)
1369 -                 else false)
1593 +             if (sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey))
1370 1594                  then true
1371 -                 else sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
1595 +                 else {
1596 +                     let newHash = blake2b256(value(s.script))
1597 +                     let allowedHash = fromBase64String(value(getString(fca, keyAllowedLpStableScriptHash())))
1598 +                     let currentHash = scriptHash(this)
1599 +                     if ((allowedHash == newHash))
1600 +                         then (currentHash != newHash)
1601 +                         else false
1602 +                     }
1372 1603          case _ => 
1373 1604              sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
1374 1605      }
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let scale8 = 100000000
5 5  
6 6  let scale8BigInt = toBigInt(100000000)
7 7  
8 8  let scale18 = toBigInt(1000000000000000000)
9 9  
10 10  let zeroBigInt = toBigInt(0)
11 11  
12 12  let big0 = toBigInt(0)
13 13  
14 14  let big1 = toBigInt(1)
15 15  
16 16  let big2 = toBigInt(2)
17 + 
18 + let big3 = toBigInt(3)
19 + 
20 + let big4 = toBigInt(4)
17 21  
18 22  let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
19 23  
20 24  let wavesString = "WAVES"
21 25  
22 26  let Amult = "100"
23 27  
24 28  let Dconv = "1"
25 29  
26 30  let SEP = "__"
27 31  
28 32  let EMPTY = ""
29 33  
30 34  let PoolActive = 1
31 35  
32 36  let PoolPutDis = 2
33 37  
34 38  let PoolMatcherDis = 3
35 39  
36 40  let PoolShutdown = 4
37 41  
38 42  let idxPoolAddress = 1
39 43  
40 44  let idxPoolSt = 2
41 45  
42 46  let idxLPAsId = 3
43 47  
44 48  let idxAmAsId = 4
45 49  
46 50  let idxPrAsId = 5
47 51  
48 52  let idxAmtAsDcm = 6
49 53  
50 54  let idxPriceAsDcm = 7
51 55  
52 56  let idxIAmtAsId = 8
53 57  
54 58  let idxIPriceAsId = 9
55 59  
56 60  let idxFactStakCntr = 1
57 61  
58 62  let idxFactoryRestCntr = 6
59 63  
60 64  let idxFactSlippCntr = 7
61 65  
62 66  let idxFactGwxRewCntr = 10
63 67  
64 68  let feeDefault = fraction(10, scale8, 10000)
65 69  
66 70  func t1 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
67 71  
68 72  
73 + func t1BigInt (origVal,origScaleMult) = fraction(origVal, scale18, origScaleMult)
74 + 
75 + 
69 76  func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
77 + 
78 + 
79 + func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
80 + 
81 + 
82 + func t2 (origVal,origScaleMult) = fraction(origVal, scale18, toBigInt(origScaleMult))
83 + 
84 + 
85 + func f2 (val,resultScaleMult) = fraction(val, toBigInt(resultScaleMult), scale18)
70 86  
71 87  
72 88  func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)
73 89  
74 90  
75 91  func abs (val) = if ((zeroBigInt > val))
76 92      then -(val)
77 93      else val
78 94  
79 95  
80 96  func absBigInt (val) = if ((zeroBigInt > val))
81 97      then -(val)
82 98      else val
83 99  
84 100  
85 101  func fc () = "%s__factoryContract"
86 102  
87 103  
88 104  func mpk () = "%s__managerPublicKey"
89 105  
90 106  
91 107  func pmpk () = "%s__pendingManagerPublicKey"
92 108  
93 109  
94 110  func pl () = "%s%s__price__last"
95 111  
96 112  
97 113  func ph (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
98 114  
99 115  
100 116  func pau (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
101 117  
102 118  
103 119  func gau (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
104 120  
105 121  
106 122  func aa () = "%s__amountAsset"
107 123  
108 124  
109 125  func pa () = "%s__priceAsset"
110 126  
111 127  
112 128  func amp () = "%s__amp"
113 129  
114 130  
115 131  func ada () = "%s__addonAddr"
116 132  
117 133  
134 + let keyFee = "%s__fee"
135 + 
136 + let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
137 + 
138 + let keyDLp = makeString(["%s", "dLp"], SEP)
139 + 
140 + let keyDLpRefreshedHeight = makeString(["%s", "dLpRefreshedHeight"], SEP)
141 + 
142 + let keyDLpRefreshDelay = makeString(["%s", "refreshDLpDelay"], SEP)
143 + 
144 + let dLpRefreshDelayDefault = 1
145 + 
146 + let dLpRefreshDelay = valueOrElse(getInteger(this, keyDLpRefreshDelay), dLpRefreshDelayDefault)
147 + 
118 148  func fcfg () = "%s__factoryConfig"
119 149  
120 150  
121 151  func mtpk () = "%s%s__matcher__publicKey"
122 152  
123 153  
124 154  func pc (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
125 155  
126 156  
127 157  func mba (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
128 158  
129 159  
130 160  func aps () = "%s__shutdown"
131 161  
132 162  
133 163  func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
134 164  
135 165  
136 166  func keyFeeCollectorAddress () = "%s__feeCollectorAddress"
137 167  
138 168  
139 - func toe (orV,sendrV,matchV) = throw(((((("Failed: ordValid=" + toString(orV)) + " sndrValid=") + toString(sendrV)) + " mtchrValid=") + toString(matchV)))
140 - 
141 - 
142 - func str (val) = match val {
143 -     case valStr: String => 
144 -         valStr
145 -     case _ => 
146 -         throw("fail cast to String")
147 - }
169 + func throwOrderError (orderValid,orderValidInfo,senderValid,matcherValid) = throw((((((((("order validation failed: orderValid=" + toString(orderValid)) + " (") + orderValidInfo) + ")") + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
148 170  
149 171  
150 172  func strf (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
151 173  
152 174  
153 175  func intf (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
154 176  
155 177  
156 178  func throwErr (msg) = throw(makeString(["lp_stable.ride:", msg], " "))
179 + 
180 + 
181 + func fmtErr (msg) = makeString(["lp_stable.ride:", msg], " ")
157 182  
158 183  
159 184  let fca = addressFromStringValue(strf(this, fc()))
160 185  
161 186  let inFee = {
162 187      let @ = invoke(fca, "getInFeeREADONLY", [toString(this)], nil)
163 188      if ($isInstanceOf(@, "Int"))
164 189          then @
165 190          else throw(($getType(@) + " couldn't be cast to Int"))
166 191      }
167 192  
168 193  let outFee = {
169 194      let @ = invoke(fca, "getOutFeeREADONLY", [toString(this)], nil)
170 195      if ($isInstanceOf(@, "Int"))
171 196          then @
172 197          else throw(($getType(@) + " couldn't be cast to Int"))
173 198      }
174 199  
175 200  let A = strf(this, amp())
176 201  
177 202  func igs () = valueOrElse(getBoolean(fca, aps()), false)
178 203  
179 204  
180 205  func mp () = fromBase58String(strf(fca, mtpk()))
181 206  
182 207  
183 208  let feeCollectorAddress = addressFromStringValue(strf(fca, keyFeeCollectorAddress()))
184 209  
185 210  func gpc () = {
186 211      let amtAs = strf(this, aa())
187 212      let priceAs = strf(this, pa())
188 213      let iPriceAs = intf(fca, mba(priceAs))
189 214      let iAmtAs = intf(fca, mba(amtAs))
190 215      split(strf(fca, pc(toString(iAmtAs), toString(iPriceAs))), SEP)
191 216      }
192 217  
193 218  
194 219  func parseAssetId (input) = if ((input == wavesString))
195 220      then unit
196 221      else fromBase58String(input)
197 222  
198 223  
199 224  func assetIdToString (input) = if ((input == unit))
200 225      then wavesString
201 226      else toBase58String(value(input))
202 227  
203 228  
204 - func parsePoolConfig (poolConfig) = $Tuple7(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]))
229 + func parsePoolConfig (poolConfig) = $Tuple9(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]), fromBase58String(poolConfig[idxIAmtAsId]), fromBase58String(poolConfig[idxIPriceAsId]))
205 230  
206 231  
207 232  let poolConfigParsed = parsePoolConfig(gpc())
208 233  
209 - let $t069097095 = poolConfigParsed
234 + let $t079648193 = poolConfigParsed
210 235  
211 - let cfgPoolAddress = $t069097095._1
236 + let cfgPoolAddress = $t079648193._1
212 237  
213 - let cfgPoolStatus = $t069097095._2
238 + let cfgPoolStatus = $t079648193._2
214 239  
215 - let cfgLpAssetId = $t069097095._3
240 + let cfgLpAssetId = $t079648193._3
216 241  
217 - let cfgAmountAssetId = $t069097095._4
242 + let cfgAmountAssetId = $t079648193._4
218 243  
219 - let cfgPriceAssetId = $t069097095._5
244 + let cfgPriceAssetId = $t079648193._5
220 245  
221 - let cfgAmountAssetDecimals = $t069097095._6
246 + let cfgAmountAssetDecimals = $t079648193._6
222 247  
223 - let cfgPriceAssetDecimals = $t069097095._7
248 + let cfgPriceAssetDecimals = $t079648193._7
249 + 
250 + let cfgInAmountAssedId = $t079648193._8
251 + 
252 + let cfgInPriceAssetId = $t079648193._9
224 253  
225 254  func gfc () = split(strf(fca, fcfg()), SEP)
226 255  
227 256  
228 257  let factoryConfig = gfc()
229 258  
230 259  let stakingContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactStakCntr]), "Invalid staking contract address")
231 260  
232 261  let slipageContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactSlippCntr]), "Invalid slipage contract address")
233 262  
234 263  let gwxContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactGwxRewCntr]), "Invalid gwx contract address")
235 264  
236 265  let restContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactoryRestCntr]), "Invalid gwx contract address")
237 266  
238 267  func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slipByUser,slippageReal,txHeight,txTimestamp,slipageAmAmt,slipagePrAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slipByUser), toString(slippageReal), toString(txHeight), toString(txTimestamp), toString(slipageAmAmt), toString(slipagePrAmt)], SEP)
239 268  
240 269  
241 270  func dataGetActionInfo (outAmtAssetAmt,outPriceAssetAmt,inLpAmt,price,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d", toString(outAmtAssetAmt), toString(outPriceAssetAmt), toString(inLpAmt), toString(price), toString(txHeight), toString(txTimestamp)], SEP)
242 271  
243 272  
244 273  func getAccBalance (assetId) = if ((assetId == "WAVES"))
245 274      then wavesBalance(this).available
246 275      else assetBalance(this, fromBase58String(assetId))
247 276  
248 277  
249 278  func cpbi (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
279 + 
280 + 
281 + func cpbir (prAmtX18,amAmtX18,round) = fraction(prAmtX18, scale18, amAmtX18, round)
250 282  
251 283  
252 284  func vad (A1,A2,slippage) = {
253 285      let diff = fraction((A1 - A2), scale8BigInt, A2)
254 286      let pass = ((slippage - abs(diff)) > zeroBigInt)
255 287      if (!(pass))
256 288          then throw(("Big slpg: " + toString(diff)))
257 289          else $Tuple2(pass, min([A1, A2]))
258 290      }
259 291  
260 292  
261 293  func vd (D1,D0,slpg) = {
262 294      let diff = fraction(D0, scale8BigInt, D1)
263 295      let fail = (slpg > diff)
264 296      if (if (fail)
265 297          then true
266 298          else (D0 > D1))
267 299          then throw(((((((toString(D0) + " ") + toString(D1)) + " ") + toString(diff)) + " ") + toString(slpg)))
268 300          else fail
269 301      }
270 302  
271 303  
272 304  func pcp (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
273 305      let amtAsAmtX18 = t1(amAmt, amAssetDcm)
274 306      let prAsAmtX18 = t1(prAmt, prAssetDcm)
275 307      cpbi(prAsAmtX18, amtAsAmtX18)
276 308      }
277 309  
278 310  
279 311  func calcPrices (amAmt,prAmt,lpAmt) = {
280 -     let cfg = gpc()
281 -     let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
282 -     let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
312 +     let amtAsDcm = cfgAmountAssetDecimals
313 +     let prAsDcm = cfgPriceAssetDecimals
283 314      let priceX18 = pcp(amtAsDcm, prAsDcm, amAmt, prAmt)
284 315      let amAmtX18 = t1(amAmt, amtAsDcm)
285 316      let prAmtX18 = t1(prAmt, prAsDcm)
286 317      let lpAmtX18 = t1(lpAmt, scale8)
287 318      let lpPrInAmAsX18 = cpbi(amAmtX18, lpAmtX18)
288 319      let lpPrInPrAsX18 = cpbi(prAmtX18, lpAmtX18)
289 320  [priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
290 321      }
291 322  
292 323  
293 324  func calculatePrices (amAmt,prAmt,lpAmt) = {
294 325      let p = calcPrices(amAmt, prAmt, lpAmt)
295 326  [f1(p[0], scale8), f1(p[1], scale8), f1(p[2], scale8)]
296 327      }
297 328  
298 329  
299 330  func takeFee (amount,fee) = {
300 331      let feeAmount = if ((fee == 0))
301 332          then 0
302 333          else fraction(amount, fee, scale8)
303 334      $Tuple2((amount - feeAmount), feeAmount)
304 335      }
305 336  
306 337  
338 + func getD (xp) = {
339 +     let xp0 = xp[0]
340 +     let xp1 = xp[1]
341 +     let s = (xp0 + xp1)
342 +     if ((s == big0))
343 +         then big0
344 +         else {
345 +             let a = parseIntValue(A)
346 +             let ann = (a * 2)
347 +             let p = fraction(xp0, xp1, big1)
348 +             let xp0_xp1_n_n = fraction(p, big4, big1)
349 +             let ann_s = fraction(toBigInt(ann), s, big1)
350 +             let ann_1 = toBigInt((ann - 1))
351 +             func calcDNext (d) =             {
352 +                 let dd = fraction(d, d, big1)
353 +                 let ddd = fraction(dd, d, big1)
354 +                 let dp = fraction(ddd, big1, xp0_xp1_n_n)
355 +                 fraction((ann_s + fraction(dp, big2, big1)), d, (fraction(ann_1, d, big1) + fraction(big3, dp, big1)))
356 +                 }
357 + 
358 +             func calc (acc,i) =             if (acc._2)
359 +                 then acc
360 +                 else {
361 +                     let d = acc._1
362 +                     let dNext = calcDNext(d)
363 +                     let dDiffRaw = (dNext - value(d))
364 +                     let dDiff = if ((big0 > dDiffRaw))
365 +                         then -(dDiffRaw)
366 +                         else dDiffRaw
367 +                     if ((big1 >= dDiff))
368 +                         then $Tuple2(dNext, true)
369 +                         else $Tuple2(dNext, false)
370 +                     }
371 + 
372 +             let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
373 +             let $t01269012738 = {
374 +                 let $l = arr
375 +                 let $s = size($l)
376 +                 let $acc0 = $Tuple2(s, false)
377 +                 func $f0_1 ($a,$i) =                 if (($i >= $s))
378 +                     then $a
379 +                     else calc($a, $l[$i])
380 + 
381 +                 func $f0_2 ($a,$i) =                 if (($i >= $s))
382 +                     then $a
383 +                     else throw("List size exceeds 15")
384 + 
385 +                 $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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
386 +                 }
387 +             let d = $t01269012738._1
388 +             let found = $t01269012738._2
389 +             if (found)
390 +                 then d
391 +                 else throw(("D calculation error, D = " + toString(d)))
392 +             }
393 +     }
394 + 
395 + 
307 396  func ego (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
308 -     let cfg = gpc()
309 -     let lpId = cfg[idxLPAsId]
310 -     let amId = cfg[idxAmAsId]
311 -     let prId = cfg[idxPrAsId]
312 -     let amDcm = parseIntValue(cfg[idxAmtAsDcm])
313 -     let prDcm = parseIntValue(cfg[idxPriceAsDcm])
314 -     let sts = cfg[idxPoolSt]
315 -     let lpEmiss = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Wrong LP id").quantity
316 -     if ((lpId != pmtAssetId))
397 +     let lpId = cfgLpAssetId
398 +     let amId = toBase58String(value(cfgAmountAssetId))
399 +     let prId = toBase58String(value(cfgPriceAssetId))
400 +     let amDcm = cfgAmountAssetDecimals
401 +     let prDcm = cfgPriceAssetDecimals
402 +     let sts = toString(cfgPoolStatus)
403 +     let lpEmiss = valueOrErrorMessage(assetInfo(lpId), "Wrong LP id").quantity
404 +     if ((toBase58String(lpId) != pmtAssetId))
317 405          then throw("Wrong pmt asset")
318 406          else {
319 407              let amBalance = getAccBalance(amId)
320 408              let amBalanceX18 = t1(amBalance, amDcm)
321 409              let prBalance = getAccBalance(prId)
322 410              let prBalanceX18 = t1(prBalance, prDcm)
323 411              let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
324 412              let curPrice = f1(curPriceX18, scale8)
325 413              let pmtLpAmtX18 = t1(pmtLpAmt, scale8)
326 414              let lpEmissX18 = t1(lpEmiss, scale8)
327 415              let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
328 416              let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
329 -             let outAmAmt = f1(outAmAmtX18, amDcm)
330 -             let outPrAmt = f1(outPrAmtX18, prDcm)
417 +             let outAmAmt = fromX18Round(outAmAmtX18, amDcm, FLOOR)
418 +             let outPrAmt = fromX18Round(outPrAmtX18, prDcm, FLOOR)
331 419              let state = if ((txId58 == ""))
332 420                  then nil
333 421                  else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
334 422                      then unit
335 423                      else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
336 424                      then unit
337 425                      else fromBase58String(prId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
338 426              $Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmiss, curPriceX18, sts, state)
339 427              }
340 428      }
341 429  
342 430  
343 431  func epo (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
344 -     let cfg = gpc()
345 -     let lpId = fromBase58String(cfg[idxLPAsId])
346 -     let amIdStr = cfg[idxAmAsId]
347 -     let prIdStr = cfg[idxPrAsId]
348 -     let inAmIdStr = cfg[idxIAmtAsId]
349 -     let inPrIdStr = cfg[idxIPriceAsId]
350 -     let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
351 -     let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
352 -     let sts = cfg[idxPoolSt]
432 +     let lpId = cfgLpAssetId
433 +     let amIdStr = toBase58String(value(cfgAmountAssetId))
434 +     let prIdStr = toBase58String(value(cfgPriceAssetId))
435 +     let inAmIdStr = cfgInAmountAssedId
436 +     let inPrIdStr = cfgInPriceAssetId
437 +     let amtDcm = cfgAmountAssetDecimals
438 +     let priceDcm = cfgPriceAssetDecimals
439 +     let sts = toString(cfgPoolStatus)
353 440      let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
354 441      let amBalance = if (isEval)
355 442          then getAccBalance(amIdStr)
356 443          else if (if (isOneAsset)
357 444              then (pmtId == amIdStr)
358 445              else false)
359 446              then (getAccBalance(amIdStr) - pmtAmt)
360 447              else if (isOneAsset)
361 448                  then getAccBalance(amIdStr)
362 449                  else (getAccBalance(amIdStr) - inAmAmt)
363 450      let prBalance = if (isEval)
364 451          then getAccBalance(prIdStr)
365 452          else if (if (isOneAsset)
366 453              then (pmtId == prIdStr)
367 454              else false)
368 455              then (getAccBalance(prIdStr) - pmtAmt)
369 456              else if (isOneAsset)
370 457                  then getAccBalance(prIdStr)
371 458                  else (getAccBalance(prIdStr) - inPrAmt)
372 459      let inAmAssetAmtX18 = t1(inAmAmt, amtDcm)
373 460      let inPrAssetAmtX18 = t1(inPrAmt, priceDcm)
374 461      let userPriceX18 = cpbi(inPrAssetAmtX18, inAmAssetAmtX18)
375 462      let amBalanceX18 = t1(amBalance, amtDcm)
376 463      let prBalanceX18 = t1(prBalance, priceDcm)
464 +     let D0 = getD([amBalanceX18, prBalanceX18])
377 465      let r = if ((lpEm == 0))
378 466          then {
379 -             let curPriceX18 = zeroBigInt
380 -             let slippageX18 = zeroBigInt
381 -             let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
382 -             $Tuple5(f1(lpAmtX18, scale8), f1(inAmAssetAmtX18, amtDcm), f1(inPrAssetAmtX18, priceDcm), cpbi((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
467 +             let D1 = getD([(amBalanceX18 + inAmAssetAmtX18), (prBalanceX18 + inPrAssetAmtX18)])
468 +             let checkD = if ((D1 > D0))
469 +                 then true
470 +                 else throw("D1 should be greater than D0")
471 +             if ((checkD == checkD))
472 +                 then {
473 +                     let curPriceX18 = zeroBigInt
474 +                     let slippageX18 = zeroBigInt
475 +                     let lpAmtX18 = D1
476 +                     $Tuple5(f1(lpAmtX18, scale8), f1(inAmAssetAmtX18, amtDcm), f1(inPrAssetAmtX18, priceDcm), cpbi((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
477 +                     }
478 +                 else throw("Strict value is not equal to itself.")
383 479              }
384 480          else {
385 481              let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
386 482              let slippageRealX18 = fraction(abs((curPriceX18 - userPriceX18)), scale18, curPriceX18)
387 483              let slippageX18 = t1(slippage, scale8)
388 484              if (if (if (validateSlippage)
389 485                  then (curPriceX18 != zeroBigInt)
390 486                  else false)
391 487                  then (slippageRealX18 > slippageX18)
392 488                  else false)
393 489                  then throw(((("Price slippage " + toString(slippageRealX18)) + " > ") + toString(slippageX18)))
394 490                  else {
395 491                      let lpEmissionX18 = t1(lpEm, scale8)
396 -                     let prViaAmX18 = fraction(inAmAssetAmtX18, curPriceX18, scale18)
397 -                     let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, curPriceX18)
492 +                     let prViaAmX18 = fraction(inAmAssetAmtX18, cpbir(prBalanceX18, amBalanceX18, CEILING), scale18, CEILING)
493 +                     let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, cpbir(prBalanceX18, amBalanceX18, FLOOR), CEILING)
398 494                      let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
399 495                          then $Tuple2(amViaPrX18, inPrAssetAmtX18)
400 496                          else $Tuple2(inAmAssetAmtX18, prViaAmX18)
401 497                      let expAmtAssetAmtX18 = expectedAmts._1
402 498                      let expPriceAssetAmtX18 = expectedAmts._2
403 -                     let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
404 -                     $Tuple5(f1(lpAmtX18, scale8), f1(expAmtAssetAmtX18, amtDcm), f1(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
499 +                     let D1 = getD([(amBalanceX18 + expAmtAssetAmtX18), (prBalanceX18 + expPriceAssetAmtX18)])
500 +                     let checkD = if ((D1 > D0))
501 +                         then true
502 +                         else throw("D1 should be greater than D0")
503 +                     if ((checkD == checkD))
504 +                         then {
505 +                             let lpAmtX18 = fraction(lpEmissionX18, (D1 - D0), D0)
506 +                             $Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceDcm, CEILING), curPriceX18, slippageX18)
507 +                             }
508 +                         else throw("Strict value is not equal to itself.")
405 509                      }
406 510              }
407 511      let calcLpAmt = r._1
408 512      let calcAmAssetPmt = r._2
409 513      let calcPrAssetPmt = r._3
410 514      let curPrice = f1(r._4, scale8)
411 515      let slippageCalc = f1(r._5, scale8)
412 516      if ((0 >= calcLpAmt))
413 517          then throw("LP <= 0")
414 518          else {
415 519              let emitLpAmt = if (!(emitLp))
416 520                  then 0
417 521                  else calcLpAmt
418 522              let amDiff = (inAmAmt - calcAmAssetPmt)
419 523              let prDiff = (inPrAmt - calcPrAssetPmt)
420 -             let $t01756217907 = if (if (isOneAsset)
524 +             let $t02057720922 = if (if (isOneAsset)
421 525                  then (pmtId == amIdStr)
422 526                  else false)
423 527                  then $Tuple2(pmtAmt, 0)
424 528                  else if (if (isOneAsset)
425 529                      then (pmtId == prIdStr)
426 530                      else false)
427 531                      then $Tuple2(0, pmtAmt)
428 532                      else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
429 -             let writeAmAmt = $t01756217907._1
430 -             let writePrAmt = $t01756217907._2
533 +             let writeAmAmt = $t02057720922._1
534 +             let writePrAmt = $t02057720922._2
431 535              let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
432 536              $Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
433 537              }
434 538      }
435 539  
436 540  
437 - func moa (order) = {
438 -     let cfg = gpc()
439 -     let amtAsId = cfg[idxAmAsId]
440 -     let prAsId = cfg[idxPrAsId]
441 -     let sts = parseIntValue(cfg[idxPoolSt])
442 -     let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
443 -     let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
444 -     let accAmtAsBalance = getAccBalance(amtAsId)
445 -     let accPrAsBalance = getAccBalance(prAsId)
446 -     let curPriceX18 = if ((order.orderType == Buy))
447 -         then pcp(amtAsDcm, prAsDcm, (accAmtAsBalance + order.amount), accPrAsBalance)
448 -         else pcp(amtAsDcm, prAsDcm, (accAmtAsBalance - order.amount), accPrAsBalance)
449 -     let curPrice = f1(curPriceX18, scale8)
541 + func getYD (xp,i,D) = {
542 +     let n = big2
543 +     let x = xp[if ((i == 0))
544 +         then 1
545 +         else 0]
546 +     let aPrecision = parseBigIntValue(Amult)
547 +     let a = (parseBigIntValue(A) * aPrecision)
548 +     let s = x
549 +     let ann = (a * n)
550 +     let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
551 +     let b = ((s + ((D * aPrecision) / ann)) - D)
552 +     func calc (acc,cur) =     {
553 +         let $t02211722137 = acc
554 +         let y = $t02211722137._1
555 +         let found = $t02211722137._2
556 +         if ((found != unit))
557 +             then acc
558 +             else {
559 +                 let yNext = (((y * y) + c) / ((big2 * y) + b))
560 +                 let yDiff = absBigInt((yNext - value(y)))
561 +                 if ((big1 >= yDiff))
562 +                     then $Tuple2(yNext, cur)
563 +                     else $Tuple2(yNext, unit)
564 +                 }
565 +         }
566 + 
567 +     let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
568 +     let $t02244422491 = {
569 +         let $l = arr
570 +         let $s = size($l)
571 +         let $acc0 = $Tuple2(D, unit)
572 +         func $f0_1 ($a,$i) =         if (($i >= $s))
573 +             then $a
574 +             else calc($a, $l[$i])
575 + 
576 +         func $f0_2 ($a,$i) =         if (($i >= $s))
577 +             then $a
578 +             else throw("List size exceeds 15")
579 + 
580 +         $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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
581 +         }
582 +     let y = $t02244422491._1
583 +     let found = $t02244422491._2
584 +     if ((found != unit))
585 +         then y
586 +         else throw(("Y calculation error, Y = " + toString(y)))
587 +     }
588 + 
589 + 
590 + func calcDLp (amountBalance,priceBalance,lpEmission) = {
591 +     let updatedDLp = fraction(getD([t1BigInt(amountBalance, toBigInt(cfgAmountAssetDecimals)), t1BigInt(priceBalance, toBigInt(cfgPriceAssetDecimals))]), scale18, lpEmission)
592 +     if ((lpEmission == big0))
593 +         then big0
594 +         else updatedDLp
595 +     }
596 + 
597 + 
598 + func calcCurrentDLp (amountAssetDelta,priceAssetDelta,lpAssetEmissionDelta) = {
599 +     let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amountAssetDelta)
600 +     let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - priceAssetDelta)
601 +     let lpAssetEmission = (toBigInt(value(assetInfo(cfgLpAssetId)).quantity) - lpAssetEmissionDelta)
602 +     let currentDLp = calcDLp(amountAssetBalance, priceAssetBalance, lpAssetEmission)
603 +     currentDLp
604 +     }
605 + 
606 + 
607 + func refreshDLpInternal (amountAssetBalanceDelta,priceAssetBalanceDelta,lpAssetEmissionDelta) = {
608 +     let amountAssetBalance = (getAccBalance(assetIdToString(cfgAmountAssetId)) + amountAssetBalanceDelta)
609 +     let priceAssetBalance = (getAccBalance(assetIdToString(cfgPriceAssetId)) + priceAssetBalanceDelta)
610 +     let lpAssetEmission = (value(assetInfo(cfgLpAssetId)).quantity + lpAssetEmissionDelta)
611 +     let updatedDLp = calcDLp(toBigInt(amountAssetBalance), toBigInt(priceAssetBalance), toBigInt(lpAssetEmission))
612 +     let actions = [IntegerEntry(keyDLpRefreshedHeight, height), StringEntry(keyDLp, toString(updatedDLp))]
613 +     $Tuple2(actions, updatedDLp)
614 +     }
615 + 
616 + 
617 + func validateUpdatedDLp (oldDLp,updatedDLp) = if ((updatedDLp >= oldDLp))
618 +     then true
619 +     else throwErr("updated DLp lower than current DLp")
620 + 
621 + 
622 + func validateMatcherOrderAllowed (order) = {
623 +     let amountAssetAmount = order.amount
624 +     let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
625 +     let $t02453524747 = if ((order.orderType == Buy))
626 +         then $Tuple2(amountAssetAmount, -(priceAssetAmount))
627 +         else $Tuple2(-(amountAssetAmount), priceAssetAmount)
628 +     let amountAssetBalanceDelta = $t02453524747._1
629 +     let priceAssetBalanceDelta = $t02453524747._2
450 630      if (if (if (igs())
451 631          then true
452 -         else (sts == PoolMatcherDis))
632 +         else (cfgPoolStatus == PoolMatcherDis))
453 633          then true
454 -         else (sts == PoolShutdown))
634 +         else (cfgPoolStatus == PoolShutdown))
455 635          then throw("Admin blocked")
456 -         else {
457 -             let orAmtAsset = order.assetPair.amountAsset
458 -             let orAmtAsStr = if ((orAmtAsset == unit))
459 -                 then "WAVES"
460 -                 else toBase58String(value(orAmtAsset))
461 -             let orPrAsset = order.assetPair.priceAsset
462 -             let orPrAsStr = if ((orPrAsset == unit))
463 -                 then "WAVES"
464 -                 else toBase58String(value(orPrAsset))
465 -             if (if ((orAmtAsStr != amtAsId))
466 -                 then true
467 -                 else (orPrAsStr != prAsId))
468 -                 then throw("Wr assets")
469 -                 else {
470 -                     let orderPrice = order.price
471 -                     let priceDcm = fraction(scale8, prAsDcm, amtAsDcm)
472 -                     let castOrderPrice = ts(orderPrice, scale8, priceDcm)
473 -                     let isOrderPriceValid = if ((order.orderType == Buy))
474 -                         then (curPrice >= castOrderPrice)
475 -                         else (castOrderPrice >= curPrice)
476 -                     true
477 -                     }
478 -             }
636 +         else if (if ((order.assetPair.amountAsset != cfgAmountAssetId))
637 +             then true
638 +             else (order.assetPair.priceAsset != cfgPriceAssetId))
639 +             then throw("Wr assets")
640 +             else {
641 +                 let dLp = parseBigIntValue(getStringValue(this, keyDLp))
642 +                 let $t02507725177 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
643 +                 let unusedActions = $t02507725177._1
644 +                 let dLpNew = $t02507725177._2
645 +                 let isOrderValid = (dLpNew >= dLp)
646 +                 let info = makeString([toString(dLp), toString(dLpNew)], " ")
647 +                 $Tuple2(isOrderValid, info)
648 +                 }
479 649      }
480 650  
481 651  
482 652  func cg (i) = if ((size(i.payments) != 1))
483 653      then throw("1 pmnt exp")
484 654      else {
485 655          let pmt = value(i.payments[0])
486 656          let pmtAssetId = value(pmt.assetId)
487 657          let pmtAmt = pmt.amount
488 658          let r = ego(toBase58String(i.transactionId), toBase58String(pmtAssetId), pmtAmt, i.caller)
489 659          let outAmAmt = r._1
490 660          let outPrAmt = r._2
491 661          let sts = parseIntValue(r._9)
492 662          let state = r._10
493 663          if (if (igs())
494 664              then true
495 665              else (sts == PoolShutdown))
496 666              then throw(("Admin blocked: " + toString(sts)))
497 667              else $Tuple5(outAmAmt, outPrAmt, pmtAmt, pmtAssetId, state)
498 668          }
499 669  
500 670  
501 671  func cp (caller,txId,amAsPmt,prAsPmt,slippage,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
502 672      let r = epo(txId, slippage, value(amAsPmt).amount, value(amAsPmt).assetId, value(prAsPmt).amount, value(prAsPmt).assetId, caller, (txId == ""), emitLp, isOneAsset, validateSlippage, pmtAmt, pmtId)
503 673      let sts = parseIntValue(r._8)
504 674      if (if (if (igs())
505 675          then true
506 676          else (sts == PoolPutDis))
507 677          then true
508 678          else (sts == PoolShutdown))
509 679          then throw(("Blocked:" + toString(sts)))
510 680          else r
511 681      }
512 682  
513 683  
514 - func getD (xp) = {
515 -     let n = big2
516 -     let xp0 = xp[0]
517 -     let xp1 = xp[1]
518 -     let aPrecision = parseBigIntValue(Amult)
519 -     let a = (parseBigIntValue(A) * aPrecision)
520 -     let s = (xp0 + xp1)
521 -     if ((s == big0))
522 -         then big0
523 -         else {
524 -             let ann = (a * n)
525 -             let xp0_xp1_n_n = (((xp0 * xp1) * n) * n)
526 -             let ann_s_aPrecision = ((ann * s) / aPrecision)
527 -             let ann_aPrecision = (ann - aPrecision)
528 -             let n1 = (n + big1)
529 -             func calc (acc,cur) =             {
530 -                 let $t02245922479 = acc
531 -                 let d = $t02245922479._1
532 -                 let found = $t02245922479._2
533 -                 if ((found != unit))
534 -                     then acc
535 -                     else {
536 -                         let dp = (((d * d) * d) / xp0_xp1_n_n)
537 -                         let dNext = (((ann_s_aPrecision + (dp * n)) * d) / (((ann_aPrecision * d) / aPrecision) + (n1 * dp)))
538 -                         let dDiff = absBigInt((dNext - value(d)))
539 -                         if ((big1 >= dDiff))
540 -                             then $Tuple2(dNext, cur)
541 -                             else $Tuple2(dNext, unit)
542 -                         }
543 -                 }
544 - 
545 -             let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
546 -             let $t02290022947 = {
547 -                 let $l = arr
548 -                 let $s = size($l)
549 -                 let $acc0 = $Tuple2(s, unit)
550 -                 func $f0_1 ($a,$i) =                 if (($i >= $s))
551 -                     then $a
552 -                     else calc($a, $l[$i])
553 - 
554 -                 func $f0_2 ($a,$i) =                 if (($i >= $s))
555 -                     then $a
556 -                     else throw("List size exceeds 15")
557 - 
558 -                 $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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
559 -                 }
560 -             let d = $t02290022947._1
561 -             let found = $t02290022947._2
562 -             if ((found != unit))
563 -                 then d
564 -                 else throw(("D calculation error, D = " + toString(d)))
565 -             }
566 -     }
567 - 
568 - 
569 - func getYD (xp,i,D) = {
570 -     let n = big2
571 -     let x = xp[if ((i == 0))
572 -         then 1
573 -         else 0]
574 -     let aPrecision = parseBigIntValue(Amult)
575 -     let a = (parseBigIntValue(A) * aPrecision)
576 -     let s = x
577 -     let ann = (a * n)
578 -     let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
579 -     let b = ((s + ((D * aPrecision) / ann)) - D)
580 -     func calc (acc,cur) =     {
581 -         let $t02344723467 = acc
582 -         let y = $t02344723467._1
583 -         let found = $t02344723467._2
584 -         if ((found != unit))
585 -             then acc
586 -             else {
587 -                 let yNext = (((y * y) + c) / ((big2 * y) + b))
588 -                 let yDiff = absBigInt((yNext - value(y)))
589 -                 if ((big1 >= yDiff))
590 -                     then $Tuple2(yNext, cur)
591 -                     else $Tuple2(yNext, unit)
592 -                 }
593 -         }
594 - 
595 -     let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
596 -     let $t02377423821 = {
597 -         let $l = arr
598 -         let $s = size($l)
599 -         let $acc0 = $Tuple2(D, unit)
600 -         func $f0_1 ($a,$i) =         if (($i >= $s))
601 -             then $a
602 -             else calc($a, $l[$i])
603 - 
604 -         func $f0_2 ($a,$i) =         if (($i >= $s))
605 -             then $a
606 -             else throw("List size exceeds 15")
607 - 
608 -         $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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
609 -         }
610 -     let y = $t02377423821._1
611 -     let found = $t02377423821._2
612 -     if ((found != unit))
613 -         then y
614 -         else throw(("Y calculation error, Y = " + toString(y)))
615 -     }
616 - 
617 - 
618 684  func calcPutOneTkn (pmtAmtRaw,pmtAssetId,userAddress,txId,withTakeFee) = {
619 -     let poolConfig = gpc()
620 -     let amId = poolConfig[idxAmAsId]
621 -     let prId = poolConfig[idxPrAsId]
622 -     let lpId = poolConfig[idxLPAsId]
623 -     let amtDcm = parseIntValue(poolConfig[idxAmtAsDcm])
624 -     let priceDcm = parseIntValue(poolConfig[idxPriceAsDcm])
625 -     let lpAssetEmission = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "invalid lp asset").quantity)
685 +     let amId = toBase58String(value(cfgAmountAssetId))
686 +     let prId = toBase58String(value(cfgPriceAssetId))
687 +     let lpId = cfgLpAssetId
688 +     let amtDcm = cfgAmountAssetDecimals
689 +     let priceDcm = cfgPriceAssetDecimals
690 +     let lpAssetEmission = toBigInt(valueOrErrorMessage(assetInfo(lpId), "invalid lp asset").quantity)
626 691      let chechEmission = if ((lpAssetEmission > big0))
627 692          then true
628 693          else throw("initial deposit requires all coins")
629 694      if ((chechEmission == chechEmission))
630 695          then {
631 696              let amBalance = getAccBalance(amId)
632 697              let prBalance = getAccBalance(prId)
633 -             let $t02460425066 = if ((txId == ""))
698 +             let $t02752927991 = if ((txId == ""))
634 699                  then $Tuple2(amBalance, prBalance)
635 700                  else if ((pmtAssetId == amId))
636 701                      then if ((pmtAmtRaw > amBalance))
637 702                          then throw("invalid payment amount")
638 703                          else $Tuple2((amBalance - pmtAmtRaw), prBalance)
639 704                      else if ((pmtAssetId == prId))
640 705                          then if ((pmtAmtRaw > prBalance))
641 706                              then throw("invalid payment amount")
642 707                              else $Tuple2(amBalance, (prBalance - pmtAmtRaw))
643 708                          else throw("wrong pmtAssetId")
644 -             let amBalanceOld = $t02460425066._1
645 -             let prBalanceOld = $t02460425066._2
646 -             let $t02507225248 = if ((pmtAssetId == amId))
709 +             let amBalanceOld = $t02752927991._1
710 +             let prBalanceOld = $t02752927991._2
711 +             let $t02799728173 = if ((pmtAssetId == amId))
647 712                  then $Tuple2(pmtAmtRaw, 0)
648 713                  else if ((pmtAssetId == prId))
649 714                      then $Tuple2(0, pmtAmtRaw)
650 715                      else throw("invalid payment")
651 -             let amAmountRaw = $t02507225248._1
652 -             let prAmountRaw = $t02507225248._2
653 -             let $t02525225506 = if (withTakeFee)
716 +             let amAmountRaw = $t02799728173._1
717 +             let prAmountRaw = $t02799728173._2
718 +             let $t02817728431 = if (withTakeFee)
654 719                  then $Tuple3(takeFee(amAmountRaw, inFee)._1, takeFee(prAmountRaw, inFee)._1, takeFee(pmtAmtRaw, inFee)._2)
655 720                  else $Tuple3(amAmountRaw, prAmountRaw, 0)
656 -             let amAmount = $t02525225506._1
657 -             let prAmount = $t02525225506._2
658 -             let feeAmount = $t02525225506._3
721 +             let amAmount = $t02817728431._1
722 +             let prAmount = $t02817728431._2
723 +             let feeAmount = $t02817728431._3
659 724              let amBalanceNew = (amBalanceOld + amAmount)
660 725              let prBalanceNew = (prBalanceOld + prAmount)
661 -             let D0 = getD([toBigInt(amBalanceOld), toBigInt(prBalanceOld)])
662 -             let D1 = getD([toBigInt(amBalanceNew), toBigInt(prBalanceNew)])
726 +             let D0 = getD([t1(amBalanceOld, cfgAmountAssetDecimals), t1(prBalanceOld, cfgPriceAssetDecimals)])
727 +             let D1 = getD([t1(amBalanceNew, cfgAmountAssetDecimals), t1(prBalanceNew, cfgPriceAssetDecimals)])
663 728              let checkD = if ((D1 > D0))
664 729                  then true
665 730                  else throw()
666 731              if ((checkD == checkD))
667 732                  then {
668 -                     let lpAmount = fraction(lpAssetEmission, (D1 - D0), D0)
733 +                     let lpAmount = fraction(lpAssetEmission, (D1 - D0), D0, FLOOR)
669 734                      let curPrice = f1(cpbi(t1(prBalanceNew, priceDcm), t1(amBalanceNew, amtDcm)), scale8)
670 735                      let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId), dataPutActionInfo(amAmountRaw, prAmountRaw, toInt(lpAmount), curPrice, 0, 0, height, lastBlock.timestamp, 0, 0))]
671 736                      let poolProportion = fraction(prBalanceOld, scale8, amBalanceOld)
672 737                      let amountAssetPart = fraction(pmtAmtRaw, scale8, (poolProportion + scale8))
673 738                      let priceAssetPart = (pmtAmtRaw - amountAssetPart)
674 739                      let lpAmtBoth = fraction(lpAssetEmission, toBigInt(priceAssetPart), toBigInt(prBalanceOld))
675 740                      let bonus = toInt(fraction((lpAmount - lpAmtBoth), scale8BigInt, lpAmtBoth))
676 741                      $Tuple4(toInt(lpAmount), commonState, feeAmount, bonus)
677 742                      }
678 743                  else throw("Strict value is not equal to itself.")
679 744              }
680 745          else throw("Strict value is not equal to itself.")
681 746      }
682 747  
683 748  
684 749  func getOneTknV2Internal (outAssetId,minOutAmount,payments,caller,originCaller,transactionId) = {
685 -     let poolConfig = gpc()
686 -     let lpId = poolConfig[idxLPAsId]
687 -     let amId = poolConfig[idxAmAsId]
688 -     let prId = poolConfig[idxPrAsId]
689 -     let amDecimals = parseIntValue(poolConfig[idxAmtAsDcm])
690 -     let prDecimals = parseIntValue(poolConfig[idxPriceAsDcm])
691 -     let poolStatus = poolConfig[idxPoolSt]
750 +     let lpId = toBase58String(value(cfgLpAssetId))
751 +     let amId = toBase58String(value(cfgAmountAssetId))
752 +     let prId = toBase58String(value(cfgPriceAssetId))
753 +     let amDecimals = cfgAmountAssetDecimals
754 +     let prDecimals = cfgPriceAssetDecimals
755 +     let poolStatus = cfgPoolStatus
692 756      let userAddress = if ((caller == restContract))
693 757          then originCaller
694 758          else caller
695 759      let pmt = value(payments[0])
696 760      let pmtAssetId = value(pmt.assetId)
697 761      let pmtAmt = pmt.amount
698 -     let txId58 = toBase58String(transactionId)
699 -     if ((lpId != toBase58String(pmtAssetId)))
700 -         then throw("Wrong LP")
701 -         else {
702 -             let amBalance = getAccBalance(amId)
703 -             let prBalance = getAccBalance(prId)
704 -             let $t02750827619 = {
705 -                 let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, pmtAmt], nil)
706 -                 if ($isInstanceOf(@, "(Int, Int)"))
707 -                     then @
708 -                     else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
709 -                 }
710 -             if (($t02750827619 == $t02750827619))
711 -                 then {
712 -                     let feeAmount = $t02750827619._2
713 -                     let totalGet = $t02750827619._1
714 -                     let totalAmount = if (if ((minOutAmount > 0))
715 -                         then (minOutAmount > totalGet)
716 -                         else false)
717 -                         then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
718 -                         else totalGet
719 -                     let $t02780928116 = if ((outAssetId == amId))
720 -                         then $Tuple4(totalAmount, 0, ((amBalance - totalAmount) - feeAmount), prBalance)
721 -                         else if ((outAssetId == prId))
722 -                             then $Tuple4(0, totalAmount, amBalance, ((prBalance - totalAmount) - feeAmount))
723 -                             else throw("invalid out asset id")
724 -                     let outAm = $t02780928116._1
725 -                     let outPr = $t02780928116._2
726 -                     let amBalanceNew = $t02780928116._3
727 -                     let prBalanceNew = $t02780928116._4
728 -                     let curPrX18 = cpbi(t1(prBalanceNew, prDecimals), t1(amBalanceNew, amDecimals))
729 -                     let curPr = f1(curPrX18, scale8)
730 -                     let outAssetIdOrWaves = if ((outAssetId == "WAVES"))
731 -                         then unit
732 -                         else fromBase58String(outAssetId)
733 -                     let sendFeeToMatcher = if ((feeAmount > 0))
734 -                         then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetIdOrWaves)]
735 -                         else nil
736 -                     let state = ([ScriptTransfer(userAddress, totalAmount, outAssetIdOrWaves), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAm, outPr, pmtAmt, curPr, height, lastBlock.timestamp)), IntegerEntry(pl(), curPr), IntegerEntry(ph(height, lastBlock.timestamp), curPr)] ++ sendFeeToMatcher)
737 -                     if ((state == state))
762 +     let currentDLp = calcCurrentDLp(big0, big0, big0)
763 +     if ((currentDLp == currentDLp))
764 +         then {
765 +             let txId58 = toBase58String(transactionId)
766 +             if ((lpId != toBase58String(pmtAssetId)))
767 +                 then throw("Wrong LP")
768 +                 else {
769 +                     let amBalance = getAccBalance(amId)
770 +                     let prBalance = getAccBalance(prId)
771 +                     let $t03054330654 = {
772 +                         let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, pmtAmt], nil)
773 +                         if ($isInstanceOf(@, "(Int, Int)"))
774 +                             then @
775 +                             else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
776 +                         }
777 +                     if (($t03054330654 == $t03054330654))
738 778                          then {
739 -                             let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
740 -                             if ((burn == burn))
741 -                                 then $Tuple2(state, totalAmount)
779 +                             let feeAmount = $t03054330654._2
780 +                             let totalGet = $t03054330654._1
781 +                             let totalAmount = if (if ((minOutAmount > 0))
782 +                                 then (minOutAmount > totalGet)
783 +                                 else false)
784 +                                 then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
785 +                                 else totalGet
786 +                             let $t03084431151 = if ((outAssetId == amId))
787 +                                 then $Tuple4(totalAmount, 0, ((amBalance - totalAmount) - feeAmount), prBalance)
788 +                                 else if ((outAssetId == prId))
789 +                                     then $Tuple4(0, totalAmount, amBalance, ((prBalance - totalAmount) - feeAmount))
790 +                                     else throw("invalid out asset id")
791 +                             let outAm = $t03084431151._1
792 +                             let outPr = $t03084431151._2
793 +                             let amBalanceNew = $t03084431151._3
794 +                             let prBalanceNew = $t03084431151._4
795 +                             let curPrX18 = cpbi(t1(prBalanceNew, prDecimals), t1(amBalanceNew, amDecimals))
796 +                             let curPr = f1(curPrX18, scale8)
797 +                             let outAssetIdOrWaves = if ((outAssetId == "WAVES"))
798 +                                 then unit
799 +                                 else fromBase58String(outAssetId)
800 +                             let sendFeeToMatcher = if ((feeAmount > 0))
801 +                                 then [ScriptTransfer(feeCollectorAddress, feeAmount, outAssetIdOrWaves)]
802 +                                 else nil
803 +                             let state = ([ScriptTransfer(userAddress, totalAmount, outAssetIdOrWaves), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAm, outPr, pmtAmt, curPr, height, lastBlock.timestamp)), IntegerEntry(pl(), curPr), IntegerEntry(ph(height, lastBlock.timestamp), curPr)] ++ sendFeeToMatcher)
804 +                             if ((state == state))
805 +                                 then {
806 +                                     let burn = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
807 +                                     if ((burn == burn))
808 +                                         then {
809 +                                             let $t03193632286 = {
810 +                                                 let feeAmountForCalc = if ((this == feeCollectorAddress))
811 +                                                     then 0
812 +                                                     else feeAmount
813 +                                                 let outInAmountAsset = if ((parseAssetId(outAssetId) == cfgAmountAssetId))
814 +                                                     then true
815 +                                                     else false
816 +                                                 if (outInAmountAsset)
817 +                                                     then $Tuple2(-((totalGet + feeAmountForCalc)), 0)
818 +                                                     else $Tuple2(0, -((totalGet + feeAmountForCalc)))
819 +                                                 }
820 +                                             let amountAssetBalanceDelta = $t03193632286._1
821 +                                             let priceAssetBalanceDelta = $t03193632286._2
822 +                                             let $t03228932397 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
823 +                                             let refreshDLpActions = $t03228932397._1
824 +                                             let updatedDLp = $t03228932397._2
825 +                                             let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
826 +                                             if ((isUpdatedDLpValid == isUpdatedDLpValid))
827 +                                                 then $Tuple2((state ++ refreshDLpActions), totalAmount)
828 +                                                 else throw("Strict value is not equal to itself.")
829 +                                             }
830 +                                         else throw("Strict value is not equal to itself.")
831 +                                     }
742 832                                  else throw("Strict value is not equal to itself.")
743 833                              }
744 834                          else throw("Strict value is not equal to itself.")
745 835                      }
746 -                 else throw("Strict value is not equal to itself.")
747 836              }
837 +         else throw("Strict value is not equal to itself.")
748 838      }
749 839  
750 840  
751 841  func m () = match getString(mpk()) {
752 842      case s: String => 
753 843          fromBase58String(s)
754 844      case _: Unit => 
755 845          unit
756 846      case _ => 
757 847          throw("Match error")
758 848  }
759 849  
760 850  
761 851  func pm () = match getString(pmpk()) {
762 852      case s: String => 
763 853          fromBase58String(s)
764 854      case _: Unit => 
765 855          unit
766 856      case _ => 
767 857          throw("Match error")
768 858  }
769 859  
770 860  
771 861  let pd = throw("Permission denied")
772 862  
773 863  func isManager (i) = match m() {
774 864      case pk: ByteVector => 
775 865          (i.callerPublicKey == pk)
776 866      case _: Unit => 
777 867          (i.caller == this)
778 868      case _ => 
779 869          throw("Match error")
780 870  }
781 871  
782 872  
783 873  func mm (i) = match m() {
784 874      case pk: ByteVector => 
785 875          if ((i.callerPublicKey == pk))
786 876              then true
787 877              else pd
788 878      case _: Unit => 
789 879          if ((i.caller == this))
790 880              then true
791 881              else pd
792 882      case _ => 
793 883          throw("Match error")
794 884  }
795 885  
796 886  
797 887  @Callable(i)
798 888  func constructor (fc) = {
799 889      let c = mm(i)
800 890      if ((c == c))
801 891          then [StringEntry(fc(), fc)]
802 892          else throw("Strict value is not equal to itself.")
803 893      }
804 894  
805 895  
806 896  
807 897  @Callable(i)
808 898  func setManager (pendingManagerPublicKey) = {
809 899      let c = mm(i)
810 900      if ((c == c))
811 901          then {
812 902              let cm = fromBase58String(pendingManagerPublicKey)
813 903              if ((cm == cm))
814 904                  then [StringEntry(pmpk(), pendingManagerPublicKey)]
815 905                  else throw("Strict value is not equal to itself.")
816 906              }
817 907          else throw("Strict value is not equal to itself.")
818 908      }
819 909  
820 910  
821 911  
822 912  @Callable(i)
823 913  func confirmManager () = {
824 914      let p = pm()
825 915      let hpm = if (isDefined(p))
826 916          then true
827 917          else throw("No pending manager")
828 918      if ((hpm == hpm))
829 919          then {
830 920              let cpm = if ((i.callerPublicKey == value(p)))
831 921                  then true
832 922                  else throw("You are not pending manager")
833 923              if ((cpm == cpm))
834 924                  then [StringEntry(mpk(), toBase58String(value(p))), DeleteEntry(pmpk())]
835 925                  else throw("Strict value is not equal to itself.")
836 926              }
837 927          else throw("Strict value is not equal to itself.")
838 928      }
839 929  
840 930  
841 931  
842 932  @Callable(i)
843 933  func put (slip,autoStake) = {
844 934      let factCfg = gfc()
845 935      let stakingCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactStakCntr]), "Wr st addr")
846 936      let slipCntr = valueOrErrorMessage(addressFromString(factCfg[idxFactSlippCntr]), "Wr sl addr")
847 937      if ((0 > slip))
848 938          then throw("Wrong slippage")
849 939          else if ((size(i.payments) != 2))
850 940              then throw("2 pmnts expd")
851 941              else {
852 -                 let e = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true, false, true, 0, "")
853 -                 let emitLpAmt = e._2
854 -                 let lpAssetId = e._7
855 -                 let state = e._9
856 -                 let amDiff = e._10
857 -                 let prDiff = e._11
858 -                 let amId = e._12
859 -                 let prId = e._13
860 -                 let r = invoke(fca, "emit", [emitLpAmt], nil)
861 -                 if ((r == r))
942 +                 let amAssetPmt = toBigInt(value(i.payments[0]).amount)
943 +                 let prAssetPmt = toBigInt(value(i.payments[1]).amount)
944 +                 let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amAssetPmt)
945 +                 if ((amountAssetBalance == amountAssetBalance))
862 946                      then {
863 -                         let el =                         match r {
864 -                             case legacy: Address => 
865 -                                 invoke(legacy, "emit", [emitLpAmt], nil)
866 -                             case _ => 
867 -                                 unit
868 -                         }
869 -                         if ((el == el))
947 +                         let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - prAssetPmt)
948 +                         if ((priceAssetBalance == priceAssetBalance))
870 949                              then {
871 -                                 let sa = if ((amDiff > 0))
872 -                                     then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
873 -                                     else nil
874 -                                 if ((sa == sa))
950 +                                 let lpAssetEmission = toBigInt(value(assetInfo(cfgLpAssetId)).quantity)
951 +                                 if ((lpAssetEmission == lpAssetEmission))
875 952                                      then {
876 -                                         let sp = if ((prDiff > 0))
877 -                                             then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
878 -                                             else nil
879 -                                         if ((sp == sp))
953 +                                         let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
954 +                                         if ((currentDLp == currentDLp))
880 955                                              then {
881 -                                                 let lpTrnsfr = if (autoStake)
956 +                                                 let e = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], slip, true, false, true, 0, "")
957 +                                                 let emitLpAmt = e._2
958 +                                                 let lpAssetId = e._7
959 +                                                 let state = e._9
960 +                                                 let amDiff = e._10
961 +                                                 let prDiff = e._11
962 +                                                 let amId = e._12
963 +                                                 let prId = e._13
964 +                                                 let r = invoke(fca, "emit", [emitLpAmt], nil)
965 +                                                 if ((r == r))
882 966                                                      then {
883 -                                                         let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
884 -                                                         if ((ss == ss))
885 -                                                             then nil
967 +                                                         let el =                                                         match r {
968 +                                                             case legacy: Address => 
969 +                                                                 invoke(legacy, "emit", [emitLpAmt], nil)
970 +                                                             case _ => 
971 +                                                                 unit
972 +                                                         }
973 +                                                         if ((el == el))
974 +                                                             then {
975 +                                                                 let sa = if ((amDiff > 0))
976 +                                                                     then invoke(slipCntr, "put", nil, [AttachedPayment(amId, amDiff)])
977 +                                                                     else nil
978 +                                                                 if ((sa == sa))
979 +                                                                     then {
980 +                                                                         let sp = if ((prDiff > 0))
981 +                                                                             then invoke(slipCntr, "put", nil, [AttachedPayment(prId, prDiff)])
982 +                                                                             else nil
983 +                                                                         if ((sp == sp))
984 +                                                                             then {
985 +                                                                                 let lpTrnsfr = if (autoStake)
986 +                                                                                     then {
987 +                                                                                         let ss = invoke(stakingCntr, "stake", nil, [AttachedPayment(lpAssetId, emitLpAmt)])
988 +                                                                                         if ((ss == ss))
989 +                                                                                             then nil
990 +                                                                                             else throw("Strict value is not equal to itself.")
991 +                                                                                         }
992 +                                                                                     else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
993 +                                                                                 let $t03654636688 = refreshDLpInternal(0, 0, 0)
994 +                                                                                 let refreshDLpActions = $t03654636688._1
995 +                                                                                 let updatedDLp = $t03654636688._2
996 +                                                                                 let check = if ((updatedDLp >= currentDLp))
997 +                                                                                     then true
998 +                                                                                     else throwErr(makeString(["updated DLp lower than current DLp", toString(amountAssetBalance), toString(priceAssetBalance), toString(lpAssetEmission), toString(currentDLp), toString(updatedDLp), toString(amDiff), toString(prDiff)], " "))
999 +                                                                                 if ((check == check))
1000 +                                                                                     then {
1001 +                                                                                         let lpAssetEmissionAfter = value(assetInfo(cfgLpAssetId)).quantity
1002 +                                                                                         if ((lpAssetEmissionAfter == lpAssetEmissionAfter))
1003 +                                                                                             then ((state ++ lpTrnsfr) ++ refreshDLpActions)
1004 +                                                                                             else throw("Strict value is not equal to itself.")
1005 +                                                                                         }
1006 +                                                                                     else throw("Strict value is not equal to itself.")
1007 +                                                                                 }
1008 +                                                                             else throw("Strict value is not equal to itself.")
1009 +                                                                         }
1010 +                                                                     else throw("Strict value is not equal to itself.")
1011 +                                                                 }
886 1012                                                              else throw("Strict value is not equal to itself.")
887 1013                                                          }
888 -                                                     else [ScriptTransfer(i.caller, emitLpAmt, lpAssetId)]
889 -                                                 (state ++ lpTrnsfr)
1014 +                                                     else throw("Strict value is not equal to itself.")
890 1015                                                  }
891 1016                                              else throw("Strict value is not equal to itself.")
892 1017                                          }
893 1018                                      else throw("Strict value is not equal to itself.")
894 1019                                  }
895 1020                              else throw("Strict value is not equal to itself.")
896 1021                          }
897 1022                      else throw("Strict value is not equal to itself.")
898 1023                  }
899 1024      }
900 1025  
901 1026  
902 1027  
903 1028  @Callable(i)
904 1029  func putOneTknV2 (minOutAmount,autoStake) = {
905 1030      let isPoolOneTokenOperationsDisabled = {
906 1031          let @ = invoke(fca, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
907 1032          if ($isInstanceOf(@, "Boolean"))
908 1033              then @
909 1034              else throw(($getType(@) + " couldn't be cast to Boolean"))
910 1035          }
911 1036      let isPutDisabled = if (if (if (igs())
912 1037          then true
913 1038          else (cfgPoolStatus == PoolPutDis))
914 1039          then true
915 1040          else (cfgPoolStatus == PoolShutdown))
916 1041          then true
917 1042          else isPoolOneTokenOperationsDisabled
918 1043      let checks = [if (if (!(isPutDisabled))
919 1044          then true
920 1045          else isManager(i))
921 1046          then true
922 1047          else throwErr("put operation is blocked by admin"), if ((size(i.payments) == 1))
923 1048          then true
924 1049          else throwErr("exactly 1 payment are expected")]
925 1050      if ((checks == checks))
926 1051          then {
927 -             let poolConfig = gpc()
928 -             let amId = poolConfig[idxAmAsId]
929 -             let prId = poolConfig[idxPrAsId]
930 -             let lpId = fromBase58String(poolConfig[idxLPAsId])
931 -             let amDecimals = parseIntValue(poolConfig[idxAmtAsDcm])
932 -             let prDecimals = parseIntValue(poolConfig[idxPriceAsDcm])
1052 +             let amId = toBase58String(value(cfgAmountAssetId))
1053 +             let prId = toBase58String(value(cfgPriceAssetId))
1054 +             let lpId = cfgLpAssetId
1055 +             let amDecimals = cfgAmountAssetDecimals
1056 +             let prDecimals = cfgPriceAssetDecimals
933 1057              let userAddress = if ((i.caller == this))
934 1058                  then i.originCaller
935 1059                  else i.caller
936 1060              let pmt = value(i.payments[0])
937 1061              let pmtAssetId = toBase58String(value(pmt.assetId))
938 1062              let pmtAmt = pmt.amount
939 -             let $t03347833636 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
940 -             if (($t03347833636 == $t03347833636))
1063 +             let currentDLp = if ((pmt.assetId == cfgAmountAssetId))
1064 +                 then calcCurrentDLp(toBigInt(pmtAmt), toBigInt(0), toBigInt(0))
1065 +                 else calcCurrentDLp(toBigInt(0), toBigInt(pmtAmt), toBigInt(0))
1066 +             if ((currentDLp == currentDLp))
941 1067                  then {
942 -                     let feeAmount = $t03347833636._3
943 -                     let state = $t03347833636._2
944 -                     let estimLP = $t03347833636._1
945 -                     let emitLpAmt = if (if ((minOutAmount > 0))
946 -                         then (minOutAmount > estimLP)
947 -                         else false)
948 -                         then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
949 -                         else estimLP
950 -                     let e = invoke(fca, "emit", [emitLpAmt], nil)
951 -                     if ((e == e))
1068 +                     let $t03832938487 = calcPutOneTkn(pmtAmt, pmtAssetId, toString(userAddress), toBase58String(i.transactionId), true)
1069 +                     if (($t03832938487 == $t03832938487))
952 1070                          then {
953 -                             let el =                             match e {
954 -                                 case legacy: Address => 
955 -                                     invoke(legacy, "emit", [emitLpAmt], nil)
956 -                                 case _ => 
957 -                                     unit
958 -                             }
959 -                             if ((el == el))
1071 +                             let feeAmount = $t03832938487._3
1072 +                             let state = $t03832938487._2
1073 +                             let estimLP = $t03832938487._1
1074 +                             let emitLpAmt = if (if ((minOutAmount > 0))
1075 +                                 then (minOutAmount > estimLP)
1076 +                                 else false)
1077 +                                 then throwErr(makeString(["amount to receive is less than ", toString(minOutAmount)], ""))
1078 +                                 else estimLP
1079 +                             let e = invoke(fca, "emit", [emitLpAmt], nil)
1080 +                             if ((e == e))
960 1081                                  then {
961 -                                     let lpTrnsfr = if (autoStake)
1082 +                                     let el =                                     match e {
1083 +                                         case legacy: Address => 
1084 +                                             invoke(legacy, "emit", [emitLpAmt], nil)
1085 +                                         case _ => 
1086 +                                             unit
1087 +                                     }
1088 +                                     if ((el == el))
962 1089                                          then {
963 -                                             let ss = invoke(stakingContract, "stake", nil, [AttachedPayment(lpId, emitLpAmt)])
964 -                                             if ((ss == ss))
965 -                                                 then nil
1090 +                                             let lpTrnsfr = if (autoStake)
1091 +                                                 then {
1092 +                                                     let ss = invoke(stakingContract, "stake", nil, [AttachedPayment(lpId, emitLpAmt)])
1093 +                                                     if ((ss == ss))
1094 +                                                         then nil
1095 +                                                         else throw("Strict value is not equal to itself.")
1096 +                                                     }
1097 +                                                 else [ScriptTransfer(i.caller, emitLpAmt, lpId)]
1098 +                                             let sendFeeToMatcher = if ((feeAmount > 0))
1099 +                                                 then [ScriptTransfer(feeCollectorAddress, feeAmount, fromBase58String(pmtAssetId))]
1100 +                                                 else nil
1101 +                                             let $t03930239651 = if ((this == feeCollectorAddress))
1102 +                                                 then $Tuple2(0, 0)
1103 +                                                 else {
1104 +                                                     let paymentInAmountAsset = if ((pmt.assetId == cfgAmountAssetId))
1105 +                                                         then true
1106 +                                                         else false
1107 +                                                     if (paymentInAmountAsset)
1108 +                                                         then $Tuple2(-(feeAmount), 0)
1109 +                                                         else $Tuple2(0, -(feeAmount))
1110 +                                                     }
1111 +                                             let amountAssetBalanceDelta = $t03930239651._1
1112 +                                             let priceAssetBalanceDelta = $t03930239651._2
1113 +                                             let $t03965439762 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
1114 +                                             let refreshDLpActions = $t03965439762._1
1115 +                                             let updatedDLp = $t03965439762._2
1116 +                                             let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1117 +                                             if ((isUpdatedDLpValid == isUpdatedDLpValid))
1118 +                                                 then $Tuple2((((state ++ lpTrnsfr) ++ sendFeeToMatcher) ++ refreshDLpActions), emitLpAmt)
966 1119                                                  else throw("Strict value is not equal to itself.")
967 1120                                              }
968 -                                         else [ScriptTransfer(i.caller, emitLpAmt, lpId)]
969 -                                     let sendFeeToMatcher = if ((feeAmount > 0))
970 -                                         then [ScriptTransfer(feeCollectorAddress, feeAmount, fromBase58String(pmtAssetId))]
971 -                                         else nil
972 -                                     $Tuple2(((state ++ lpTrnsfr) ++ sendFeeToMatcher), emitLpAmt)
1121 +                                         else throw("Strict value is not equal to itself.")
973 1122                                      }
974 1123                                  else throw("Strict value is not equal to itself.")
975 1124                              }
976 1125                          else throw("Strict value is not equal to itself.")
977 1126                      }
978 1127                  else throw("Strict value is not equal to itself.")
979 1128              }
980 1129          else throw("Strict value is not equal to itself.")
981 1130      }
982 1131  
983 1132  
984 1133  
985 1134  @Callable(i)
986 1135  func putForFree (maxSlpg) = if ((0 > maxSlpg))
987 1136      then throw("Wrong slpg")
988 1137      else if ((size(i.payments) != 2))
989 1138          then throw("2 pmnts expd")
990 1139          else {
991 1140              let estPut = cp(toString(i.caller), toBase58String(i.transactionId), AttachedPayment(value(i.payments[0]).assetId, value(i.payments[0]).amount), i.payments[1], maxSlpg, false, false, true, 0, "")
992 -             estPut._9
1141 +             let state = estPut._9
1142 +             let amAssetPmt = toBigInt(value(i.payments[0]).amount)
1143 +             let prAssetPmt = toBigInt(value(i.payments[1]).amount)
1144 +             let currentDLp = calcCurrentDLp(amAssetPmt, prAssetPmt, toBigInt(0))
1145 +             if ((currentDLp == currentDLp))
1146 +                 then {
1147 +                     let $t04079240857 = refreshDLpInternal(0, 0, 0)
1148 +                     let refreshDLpActions = $t04079240857._1
1149 +                     let updatedDLp = $t04079240857._2
1150 +                     let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1151 +                     if ((isUpdatedDLpValid == isUpdatedDLpValid))
1152 +                         then (state ++ refreshDLpActions)
1153 +                         else throw("Strict value is not equal to itself.")
1154 +                     }
1155 +                 else throw("Strict value is not equal to itself.")
993 1156              }
994 1157  
995 1158  
996 1159  
997 1160  @Callable(i)
998 1161  func get () = {
999 -     let r = cg(i)
1000 -     let outAmtAmt = r._1
1001 -     let outPrAmt = r._2
1002 -     let pmtAmt = r._3
1003 -     let pmtAssetId = r._4
1004 -     let state = r._5
1005 -     let b = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1006 -     if ((b == b))
1007 -         then state
1162 +     let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1163 +     if ((currentDLp == currentDLp))
1164 +         then {
1165 +             let r = cg(i)
1166 +             let outAmtAmt = r._1
1167 +             let outPrAmt = r._2
1168 +             let pmtAmt = r._3
1169 +             let pmtAssetId = r._4
1170 +             let state = r._5
1171 +             let b = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1172 +             if ((b == b))
1173 +                 then {
1174 +                     let $t04203042112 = refreshDLpInternal(-(outAmtAmt), -(outPrAmt), 0)
1175 +                     let refreshDLpActions = $t04203042112._1
1176 +                     let updatedDLp = $t04203042112._2
1177 +                     let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1178 +                     if ((isUpdatedDLpValid == isUpdatedDLpValid))
1179 +                         then (state ++ refreshDLpActions)
1180 +                         else throw("Strict value is not equal to itself.")
1181 +                     }
1182 +                 else throw("Strict value is not equal to itself.")
1183 +             }
1008 1184          else throw("Strict value is not equal to itself.")
1009 1185      }
1010 1186  
1011 1187  
1012 1188  
1013 1189  @Callable(i)
1014 1190  func getOneTknV2 (outAssetId,minOutAmount) = {
1015 1191      let isPoolOneTokenOperationsDisabled = {
1016 1192          let @ = invoke(fca, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1017 1193          if ($isInstanceOf(@, "Boolean"))
1018 1194              then @
1019 1195              else throw(($getType(@) + " couldn't be cast to Boolean"))
1020 1196          }
1021 1197      let isGetDisabled = if (if (igs())
1022 1198          then true
1023 1199          else (cfgPoolStatus == PoolShutdown))
1024 1200          then true
1025 1201          else isPoolOneTokenOperationsDisabled
1026 1202      let checks = [if (if (!(isGetDisabled))
1027 1203          then true
1028 1204          else isManager(i))
1029 1205          then true
1030 1206          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 1))
1031 1207          then true
1032 1208          else throwErr("exactly 1 payment are expected")]
1033 1209      if ((checks == checks))
1034 1210          then {
1035 -             let $t03625836413 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1036 -             let state = $t03625836413._1
1037 -             let totalAmount = $t03625836413._2
1211 +             let $t04273042885 = getOneTknV2Internal(outAssetId, minOutAmount, i.payments, i.caller, i.originCaller, i.transactionId)
1212 +             let state = $t04273042885._1
1213 +             let totalAmount = $t04273042885._2
1038 1214              $Tuple2(state, totalAmount)
1039 1215              }
1040 1216          else throw("Strict value is not equal to itself.")
1041 1217      }
1042 1218  
1043 1219  
1044 1220  
1045 1221  @Callable(i)
1222 + func refreshDLp () = {
1223 +     let lastRefreshedBlockHeight = valueOrElse(getInteger(keyDLpRefreshedHeight), 0)
1224 +     let checkLastRefreshedBlockHeight = if (((height - lastRefreshedBlockHeight) >= dLpRefreshDelay))
1225 +         then unit
1226 +         else throwErr(makeString([toString(dLpRefreshDelay), " blocks have not passed since the previous call"], ""))
1227 +     if ((checkLastRefreshedBlockHeight == checkLastRefreshedBlockHeight))
1228 +         then {
1229 +             let dLp = valueOrErrorMessage(parseBigInt(valueOrElse(getString(this, keyDLp), "0")), fmtErr("invalid dLp"))
1230 +             let $t04340943473 = refreshDLpInternal(0, 0, 0)
1231 +             let dLpUpdateActions = $t04340943473._1
1232 +             let updatedDLp = $t04340943473._2
1233 +             let actions = if ((dLp != updatedDLp))
1234 +                 then dLpUpdateActions
1235 +                 else throwErr("nothing to refresh")
1236 +             $Tuple2(actions, toString(updatedDLp))
1237 +             }
1238 +         else throw("Strict value is not equal to itself.")
1239 +     }
1240 + 
1241 + 
1242 + 
1243 + @Callable(i)
1046 1244  func getOneTknV2READONLY (outAssetId,lpAssetAmount) = {
1047 -     let poolConfig = gpc()
1048 -     let amId = poolConfig[idxAmAsId]
1049 -     let prId = poolConfig[idxPrAsId]
1050 -     let lpId = poolConfig[idxLPAsId]
1245 +     let amId = toBase58String(value(cfgAmountAssetId))
1246 +     let prId = toBase58String(value(cfgPriceAssetId))
1247 +     let lpId = toBase58String(value(cfgLpAssetId))
1051 1248      let xp = [toBigInt(getAccBalance(amId)), toBigInt(getAccBalance(prId))]
1052 1249      let lpEmission = toBigInt(valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "invalid lp asset").quantity)
1053 1250      let D0 = getD(xp)
1054 1251      let D1 = (D0 - fraction(toBigInt(lpAssetAmount), D0, lpEmission))
1055 1252      let index = if ((outAssetId == amId))
1056 1253          then 0
1057 1254          else if ((outAssetId == prId))
1058 1255              then 1
1059 1256              else throw("invalid out asset id")
1060 1257      let newY = getYD(xp, index, D1)
1061 1258      let dy = (xp[index] - newY)
1062 1259      let totalGetRaw = max([0, toInt((dy - big1))])
1063 -     let $t03720337258 = takeFee(totalGetRaw, outFee)
1064 -     let totalGet = $t03720337258._1
1065 -     let feeAmount = $t03720337258._2
1260 +     let $t04440344458 = takeFee(totalGetRaw, outFee)
1261 +     let totalGet = $t04440344458._1
1262 +     let feeAmount = $t04440344458._2
1066 1263      $Tuple2(nil, $Tuple2(totalGet, feeAmount))
1067 1264      }
1068 1265  
1069 1266  
1070 1267  
1071 1268  @Callable(i)
1072 1269  func getOneTknV2WithBonusREADONLY (outAssetId,lpAssetAmount) = {
1073 -     let poolConfig = gpc()
1074 -     let amId = poolConfig[idxAmAsId]
1075 -     let prId = poolConfig[idxPrAsId]
1076 -     let lpId = poolConfig[idxLPAsId]
1270 +     let amId = toBase58String(value(cfgAmountAssetId))
1271 +     let prId = toBase58String(value(cfgPriceAssetId))
1272 +     let lpId = toBase58String(value(cfgLpAssetId))
1077 1273      let amBalance = getAccBalance(amId)
1078 1274      let prBalance = getAccBalance(prId)
1079 -     let $t03760337718 = {
1275 +     let $t04483344948 = {
1080 1276          let @ = invoke(this, "getOneTknV2READONLY", [outAssetId, lpAssetAmount], nil)
1081 1277          if ($isInstanceOf(@, "(Int, Int)"))
1082 1278              then @
1083 1279              else throw(($getType(@) + " couldn't be cast to (Int, Int)"))
1084 1280          }
1085 -     let totalGet = $t03760337718._1
1086 -     let feeAmount = $t03760337718._2
1281 +     let totalGet = $t04483344948._1
1282 +     let feeAmount = $t04483344948._2
1087 1283      let r = ego("", lpId, lpAssetAmount, this)
1088 1284      let outAmAmt = r._1
1089 1285      let outPrAmt = r._2
1090 1286      let sumOfGetAssets = (outAmAmt + outPrAmt)
1091 1287      let bonus = if ((sumOfGetAssets == 0))
1092 1288          then if ((totalGet == 0))
1093 1289              then 0
1094 1290              else throw("bonus calculation error")
1095 1291          else fraction((totalGet - sumOfGetAssets), scale8, sumOfGetAssets)
1096 1292      $Tuple2(nil, $Tuple3(totalGet, feeAmount, bonus))
1097 1293      }
1098 1294  
1099 1295  
1100 1296  
1101 1297  @Callable(i)
1102 1298  func getNoLess (noLessThenAmtAsset,noLessThenPriceAsset) = {
1103 1299      let r = cg(i)
1104 1300      let outAmAmt = r._1
1105 1301      let outPrAmt = r._2
1106 1302      let pmtAmt = r._3
1107 1303      let pmtAssetId = r._4
1108 1304      let state = r._5
1109 1305      if ((noLessThenAmtAsset > outAmAmt))
1110 1306          then throw(((("Failed:  " + toString(outAmAmt)) + " < ") + toString(noLessThenAmtAsset)))
1111 1307          else if ((noLessThenPriceAsset > outPrAmt))
1112 1308              then throw(((("Failed: " + toString(outPrAmt)) + " < ") + toString(noLessThenPriceAsset)))
1113 1309              else {
1114 -                 let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1115 -                 if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1116 -                     then state
1310 +                 let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1311 +                 if ((currentDLp == currentDLp))
1312 +                     then {
1313 +                         let burnLPAssetOnFactory = invoke(fca, "burn", [pmtAmt], [AttachedPayment(pmtAssetId, pmtAmt)])
1314 +                         if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1315 +                             then {
1316 +                                 let $t04611446195 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1317 +                                 let refreshDLpActions = $t04611446195._1
1318 +                                 let updatedDLp = $t04611446195._2
1319 +                                 let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1320 +                                 if ((isUpdatedDLpValid == isUpdatedDLpValid))
1321 +                                     then (state ++ refreshDLpActions)
1322 +                                     else throw("Strict value is not equal to itself.")
1323 +                                 }
1324 +                             else throw("Strict value is not equal to itself.")
1325 +                         }
1117 1326                      else throw("Strict value is not equal to itself.")
1118 1327                  }
1119 1328      }
1120 1329  
1121 1330  
1122 1331  
1123 1332  @Callable(i)
1124 1333  func unstakeAndGet (amount) = {
1125 1334      let checkPayments = if ((size(i.payments) != 0))
1126 1335          then throw("No pmnts expd")
1127 1336          else true
1128 1337      if ((checkPayments == checkPayments))
1129 1338          then {
1130 -             let cfg = gpc()
1131 1339              let factoryCfg = gfc()
1132 -             let lpAssetId = fromBase58String(cfg[idxLPAsId])
1340 +             let lpAssetId = cfgLpAssetId
1133 1341              let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
1134 -             let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), amount], nil)
1135 -             if ((unstakeInv == unstakeInv))
1342 +             let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1343 +             if ((currentDLp == currentDLp))
1136 1344                  then {
1137 -                     let r = ego(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
1138 -                     let sts = parseIntValue(r._9)
1139 -                     let state = r._10
1140 -                     let v = if (if (igs())
1141 -                         then true
1142 -                         else (sts == PoolShutdown))
1143 -                         then throw(("Blocked: " + toString(sts)))
1144 -                         else true
1145 -                     if ((v == v))
1345 +                     let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), amount], nil)
1346 +                     if ((unstakeInv == unstakeInv))
1146 1347                          then {
1147 -                             let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1148 -                             if ((burnA == burnA))
1149 -                                 then state
1348 +                             let r = ego(toBase58String(i.transactionId), toBase58String(lpAssetId), amount, i.caller)
1349 +                             let outAmAmt = r._1
1350 +                             let outPrAmt = r._2
1351 +                             let sts = parseIntValue(r._9)
1352 +                             let state = r._10
1353 +                             let v = if (if (igs())
1354 +                                 then true
1355 +                                 else (sts == PoolShutdown))
1356 +                                 then throw(("Blocked: " + toString(sts)))
1357 +                                 else true
1358 +                             if ((v == v))
1359 +                                 then {
1360 +                                     let burnA = invoke(fca, "burn", [amount], [AttachedPayment(lpAssetId, amount)])
1361 +                                     if ((burnA == burnA))
1362 +                                         then {
1363 +                                             let $t04722247303 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1364 +                                             let refreshDLpActions = $t04722247303._1
1365 +                                             let updatedDLp = $t04722247303._2
1366 +                                             let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1367 +                                             if ((isUpdatedDLpValid == isUpdatedDLpValid))
1368 +                                                 then (state ++ refreshDLpActions)
1369 +                                                 else throw("Strict value is not equal to itself.")
1370 +                                             }
1371 +                                         else throw("Strict value is not equal to itself.")
1372 +                                     }
1150 1373                                  else throw("Strict value is not equal to itself.")
1151 1374                              }
1152 1375                          else throw("Strict value is not equal to itself.")
1153 1376                      }
1154 1377                  else throw("Strict value is not equal to itself.")
1155 1378              }
1156 1379          else throw("Strict value is not equal to itself.")
1157 1380      }
1158 1381  
1159 1382  
1160 1383  
1161 1384  @Callable(i)
1162 1385  func unstakeAndGetNoLess (unstakeAmount,noLessThenAmountAsset,noLessThenPriceAsset) = {
1163 1386      let isGetDisabled = if (igs())
1164 1387          then true
1165 1388          else (cfgPoolStatus == PoolShutdown)
1166 1389      let checks = [if (!(isGetDisabled))
1167 1390          then true
1168 1391          else throw("get operation is blocked by admin"), if ((size(i.payments) == 0))
1169 1392          then true
1170 1393          else throw("no payments are expected")]
1171 1394      if ((checks == checks))
1172 1395          then {
1173 -             let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1174 -             if ((unstakeInv == unstakeInv))
1396 +             let currentDLp = calcCurrentDLp(toBigInt(0), toBigInt(0), toBigInt(0))
1397 +             if ((currentDLp == currentDLp))
1175 1398                  then {
1176 -                     let res = ego(toBase58String(i.transactionId), toBase58String(cfgLpAssetId), unstakeAmount, i.caller)
1177 -                     let outAmAmt = res._1
1178 -                     let outPrAmt = res._2
1179 -                     let state = res._10
1180 -                     let checkAmounts = [if ((outAmAmt >= noLessThenAmountAsset))
1181 -                         then true
1182 -                         else throw(makeString(["amount asset amount to receive is less than ", toString(noLessThenAmountAsset)], "")), if ((outPrAmt >= noLessThenPriceAsset))
1183 -                         then true
1184 -                         else throw(makeString(["price asset amount to receive is less than ", toString(noLessThenPriceAsset)], ""))]
1185 -                     if ((checkAmounts == checkAmounts))
1399 +                     let unstakeInv = invoke(stakingContract, "unstake", [toBase58String(cfgLpAssetId), unstakeAmount], nil)
1400 +                     if ((unstakeInv == unstakeInv))
1186 1401                          then {
1187 -                             let burnLPAssetOnFactory = invoke(fca, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1188 -                             if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1189 -                                 then state
1402 +                             let res = ego(toBase58String(i.transactionId), toBase58String(cfgLpAssetId), unstakeAmount, i.caller)
1403 +                             let outAmAmt = res._1
1404 +                             let outPrAmt = res._2
1405 +                             let state = res._10
1406 +                             let checkAmounts = [if ((outAmAmt >= noLessThenAmountAsset))
1407 +                                 then true
1408 +                                 else throw(makeString(["amount asset amount to receive is less than ", toString(noLessThenAmountAsset)], "")), if ((outPrAmt >= noLessThenPriceAsset))
1409 +                                 then true
1410 +                                 else throw(makeString(["price asset amount to receive is less than ", toString(noLessThenPriceAsset)], ""))]
1411 +                             if ((checkAmounts == checkAmounts))
1412 +                                 then {
1413 +                                     let burnLPAssetOnFactory = invoke(fca, "burn", [unstakeAmount], [AttachedPayment(cfgLpAssetId, unstakeAmount)])
1414 +                                     if ((burnLPAssetOnFactory == burnLPAssetOnFactory))
1415 +                                         then {
1416 +                                             let $t04855448635 = refreshDLpInternal(-(outAmAmt), -(outPrAmt), 0)
1417 +                                             let refreshDLpActions = $t04855448635._1
1418 +                                             let updatedDLp = $t04855448635._2
1419 +                                             let isUpdatedDLpValid = validateUpdatedDLp(currentDLp, updatedDLp)
1420 +                                             if ((isUpdatedDLpValid == isUpdatedDLpValid))
1421 +                                                 then (state ++ refreshDLpActions)
1422 +                                                 else throw("Strict value is not equal to itself.")
1423 +                                             }
1424 +                                         else throw("Strict value is not equal to itself.")
1425 +                                     }
1190 1426                                  else throw("Strict value is not equal to itself.")
1191 1427                              }
1192 1428                          else throw("Strict value is not equal to itself.")
1193 1429                      }
1194 1430                  else throw("Strict value is not equal to itself.")
1195 1431              }
1196 1432          else throw("Strict value is not equal to itself.")
1197 1433      }
1198 1434  
1199 1435  
1200 1436  
1201 1437  @Callable(i)
1202 1438  func unstakeAndGetOneTknV2 (unstakeAmount,outAssetId,minOutAmount) = {
1203 1439      let isPoolOneTokenOperationsDisabled = {
1204 1440          let @ = invoke(fca, "isPoolOneTokenOperationsDisabledREADONLY", [toString(this)], nil)
1205 1441          if ($isInstanceOf(@, "Boolean"))
1206 1442              then @
1207 1443              else throw(($getType(@) + " couldn't be cast to Boolean"))
1208 1444          }
1209 1445      let isGetDisabled = if (if (igs())
1210 1446          then true
1211 1447          else (cfgPoolStatus == PoolShutdown))
1212 1448          then true
1213 1449          else isPoolOneTokenOperationsDisabled
1214 1450      let checks = [if (if (!(isGetDisabled))
1215 1451          then true
1216 1452          else isManager(i))
1217 1453          then true
1218 1454          else throwErr("get operation is blocked by admin"), if ((size(i.payments) == 0))
1219 1455          then true
1220 1456          else throwErr("no payments are expected")]
1221 1457      if ((checks == checks))
1222 1458          then {
1223 -             let cfg = gpc()
1224 1459              let factoryCfg = gfc()
1225 -             let lpAssetId = fromBase58String(cfg[idxLPAsId])
1460 +             let lpAssetId = cfgLpAssetId
1226 1461              let staking = valueOrErrorMessage(addressFromString(factoryCfg[idxFactStakCntr]), "Wr st addr")
1227 1462              let unstakeInv = invoke(staking, "unstake", [toBase58String(lpAssetId), unstakeAmount], nil)
1228 1463              if ((unstakeInv == unstakeInv))
1229 1464                  then {
1230 -                     let $t04155641744 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1231 -                     let state = $t04155641744._1
1232 -                     let totalAmount = $t04155641744._2
1465 +                     let $t04953049718 = getOneTknV2Internal(outAssetId, minOutAmount, [AttachedPayment(lpAssetId, unstakeAmount)], i.caller, i.originCaller, i.transactionId)
1466 +                     let state = $t04953049718._1
1467 +                     let totalAmount = $t04953049718._2
1233 1468                      $Tuple2(state, totalAmount)
1234 1469                      }
1235 1470                  else throw("Strict value is not equal to itself.")
1236 1471              }
1237 1472          else throw("Strict value is not equal to itself.")
1238 1473      }
1239 1474  
1240 1475  
1241 1476  
1242 1477  @Callable(i)
1243 1478  func putOneTknV2WithBonusREADONLY (paymentAmountRaw,paymentAssetId) = {
1244 -     let poolConfig = gpc()
1245 -     let amId = poolConfig[idxAmAsId]
1246 -     let prId = poolConfig[idxPrAsId]
1247 -     let lpId = poolConfig[idxLPAsId]
1248 -     let $t04200342106 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1249 -     let lpAmount = $t04200342106._1
1250 -     let state = $t04200342106._2
1251 -     let feeAmount = $t04200342106._3
1252 -     let bonus = $t04200342106._4
1479 +     let $t04984649949 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", true)
1480 +     let lpAmount = $t04984649949._1
1481 +     let state = $t04984649949._2
1482 +     let feeAmount = $t04984649949._3
1483 +     let bonus = $t04984649949._4
1253 1484      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1254 1485      }
1255 1486  
1256 1487  
1257 1488  
1258 1489  @Callable(i)
1259 1490  func putOneTknV2WithoutTakeFeeREADONLY (paymentAmountRaw,paymentAssetId) = {
1260 -     let poolConfig = gpc()
1261 -     let amId = poolConfig[idxAmAsId]
1262 -     let prId = poolConfig[idxPrAsId]
1263 -     let lpId = poolConfig[idxLPAsId]
1264 -     let $t04238542489 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1265 -     let lpAmount = $t04238542489._1
1266 -     let state = $t04238542489._2
1267 -     let feeAmount = $t04238542489._3
1268 -     let bonus = $t04238542489._4
1491 +     let $t05009750201 = calcPutOneTkn(paymentAmountRaw, paymentAssetId, "", "", false)
1492 +     let lpAmount = $t05009750201._1
1493 +     let state = $t05009750201._2
1494 +     let feeAmount = $t05009750201._3
1495 +     let bonus = $t05009750201._4
1269 1496      $Tuple2(nil, $Tuple3(lpAmount, feeAmount, bonus))
1270 1497      }
1271 1498  
1272 1499  
1273 1500  
1274 1501  @Callable(i)
1275 1502  func activate (amtAsStr,prAsStr) = if ((toString(i.caller) != toString(fca)))
1276 1503      then throw("denied")
1277 1504      else $Tuple2([StringEntry(aa(), amtAsStr), StringEntry(pa(), prAsStr)], "success")
1278 1505  
1279 1506  
1280 1507  
1281 1508  @Callable(i)
1282 1509  func setS (k,v) = if ((toString(i.caller) != strf(this, ada())))
1283 1510      then pd
1284 1511      else [StringEntry(k, v)]
1285 1512  
1286 1513  
1287 1514  
1288 1515  @Callable(i)
1289 1516  func setI (k,v) = if ((toString(i.caller) != strf(this, ada())))
1290 1517      then pd
1291 1518      else [IntegerEntry(k, v)]
1292 1519  
1293 1520  
1294 1521  
1295 1522  @Callable(i)
1296 1523  func getPoolConfigWrapperREADONLY () = $Tuple2(nil, gpc())
1297 1524  
1298 1525  
1299 1526  
1300 1527  @Callable(i)
1301 1528  func getAccBalanceWrapperREADONLY (assetId) = $Tuple2(nil, getAccBalance(assetId))
1302 1529  
1303 1530  
1304 1531  
1305 1532  @Callable(i)
1306 1533  func calcPricesWrapperREADONLY (amAmt,prAmt,lpAmt) = {
1307 1534      let pr = calcPrices(amAmt, prAmt, lpAmt)
1308 1535      $Tuple2(nil, [toString(pr[0]), toString(pr[1]), toString(pr[2])])
1309 1536      }
1310 1537  
1311 1538  
1312 1539  
1313 1540  @Callable(i)
1314 1541  func fromX18WrapperREADONLY (val,resScaleMult) = $Tuple2(nil, f1(parseBigIntValue(val), resScaleMult))
1315 1542  
1316 1543  
1317 1544  
1318 1545  @Callable(i)
1319 1546  func toX18WrapperREADONLY (origVal,origScaleMult) = $Tuple2(nil, toString(t1(origVal, origScaleMult)))
1320 1547  
1321 1548  
1322 1549  
1323 1550  @Callable(i)
1324 1551  func calcPriceBigIntWrapperREADONLY (prAmtX18,amAmtX18) = $Tuple2(nil, toString(cpbi(parseBigIntValue(prAmtX18), parseBigIntValue(amAmtX18))))
1325 1552  
1326 1553  
1327 1554  
1328 1555  @Callable(i)
1329 1556  func estimatePutOperationWrapperREADONLY (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,usrAddr,isEval,emitLp) = $Tuple2(nil, epo(txId58, slippage, inAmAmt, inAmId, inPrAmt, inPrId, usrAddr, isEval, emitLp, true, false, 0, ""))
1330 1557  
1331 1558  
1332 1559  
1333 1560  @Callable(i)
1334 1561  func estimateGetOperationWrapperREADONLY (txId58,pmtAsId,pmtLpAmt,usrAddr) = {
1335 1562      let r = ego(txId58, pmtAsId, pmtLpAmt, addressFromStringValue(usrAddr))
1336 1563      $Tuple2(nil, $Tuple10(r._1, r._2, r._3, r._4, r._5, r._6, r._7, toString(r._8), r._9, r._10))
1337 1564      }
1338 1565  
1339 1566  
1340 1567  @Verifier(tx)
1341 1568  func verify () = {
1342 1569      let targetPublicKey =     match m() {
1343 1570          case pk: ByteVector => 
1344 1571              pk
1345 1572          case _: Unit => 
1346 1573              tx.senderPublicKey
1347 1574          case _ => 
1348 1575              throw("Match error")
1349 1576      }
1350 1577      match tx {
1351 1578          case order: Order => 
1352 1579              let matcherPub = mp()
1353 -             let orderValid = moa(order)
1580 +             let $t05299353062 = validateMatcherOrderAllowed(order)
1581 +             let orderValid = $t05299353062._1
1582 +             let orderValidInfo = $t05299353062._2
1354 1583              let senderValid = sigVerify(order.bodyBytes, order.proofs[0], order.senderPublicKey)
1355 1584              let matcherValid = sigVerify(order.bodyBytes, order.proofs[1], matcherPub)
1356 1585              if (if (if (orderValid)
1357 1586                  then senderValid
1358 1587                  else false)
1359 1588                  then matcherValid
1360 1589                  else false)
1361 1590                  then true
1362 -                 else toe(orderValid, senderValid, matcherValid)
1591 +                 else throwOrderError(orderValid, orderValidInfo, senderValid, matcherValid)
1363 1592          case s: SetScriptTransaction => 
1364 -             let newHash = blake2b256(value(s.script))
1365 -             let allowedHash = fromBase64String(value(getString(fca, keyAllowedLpStableScriptHash())))
1366 -             let currentHash = scriptHash(this)
1367 -             if (if ((allowedHash == newHash))
1368 -                 then (currentHash != newHash)
1369 -                 else false)
1593 +             if (sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey))
1370 1594                  then true
1371 -                 else sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
1595 +                 else {
1596 +                     let newHash = blake2b256(value(s.script))
1597 +                     let allowedHash = fromBase64String(value(getString(fca, keyAllowedLpStableScriptHash())))
1598 +                     let currentHash = scriptHash(this)
1599 +                     if ((allowedHash == newHash))
1600 +                         then (currentHash != newHash)
1601 +                         else false
1602 +                     }
1372 1603          case _ => 
1373 1604              sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
1374 1605      }
1375 1606      }
1376 1607

Old	New		Differences
14	14		let big1 = toBigInt(1)
15	15
16	16		let big2 = toBigInt(2)
	17	+
	18	+	let big3 = toBigInt(3)
	19	+
	20	+	let big4 = toBigInt(4)
17	21
18	22		let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
19	23

66	70		func t1 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
67	71
68	72
	73	+	func t1BigInt (origVal,origScaleMult) = fraction(origVal, scale18, origScaleMult)
	74	+
	75	+
69	76		func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
	77	+
	78	+
	79	+	func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
	80	+
	81	+
	82	+	func t2 (origVal,origScaleMult) = fraction(origVal, scale18, toBigInt(origScaleMult))
	83	+
	84	+
	85	+	func f2 (val,resultScaleMult) = fraction(val, toBigInt(resultScaleMult), scale18)
70	86
71	87
72	88		func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)

115	131		func ada () = "%s__addonAddr"
116	132
117	133
	134	+	let keyFee = "%s__fee"
	135	+
	136	+	let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
	137	+
	138	+	let keyDLp = makeString(["%s", "dLp"], SEP)
	139	+
	140	+	let keyDLpRefreshedHeight = makeString(["%s", "dLpRefreshedHeight"], SEP)
	141	+
	142	+	let keyDLpRefreshDelay = makeString(["%s", "refreshDLpDelay"], SEP)
	143	+
	144	+	let dLpRefreshDelayDefault = 1
	145	+
	146	+	let dLpRefreshDelay = valueOrElse(getInteger(this, keyDLpRefreshDelay), dLpRefreshDelayDefault)
	147	+
118	148		func fcfg () = "%s__factoryConfig"
119	149
120	150

136	166		func keyFeeCollectorAddress () = "%s__feeCollectorAddress"
137	167
138	168
139		-	func toe (orV,sendrV,matchV) = throw(((((("Failed: ordValid=" + toString(orV)) + " sndrValid=") + toString(sendrV)) + " mtchrValid=") + toString(matchV)))
140		-
141		-
142		-	func str (val) = match val {
143		-	case valStr: String =>
144		-	valStr
145		-	case _ =>
146		-	throw("fail cast to String")
147		-	}
	169	+	func throwOrderError (orderValid,orderValidInfo,senderValid,matcherValid) = throw((((((((("order validation failed: orderValid=" + toString(orderValid)) + " (") + orderValidInfo) + ")") + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
148	170
149	171
150	172		func strf (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))

154	176
155	177
156	178		func throwErr (msg) = throw(makeString(["lp_stable.ride:", msg], " "))
	179	+
	180	+
	181	+	func fmtErr (msg) = makeString(["lp_stable.ride:", msg], " ")
157	182
158	183
159	184		let fca = addressFromStringValue(strf(this, fc()))

201	226		else toBase58String(value(input))
202	227
203	228
204		-	func parsePoolConfig (poolConfig) = $~~Tuple7~~(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]))
	229	+	func parsePoolConfig (poolConfig) = $Tuple9(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]), fromBase58String(poolConfig[idxIAmtAsId]), fromBase58String(poolConfig[idxIPriceAsId]))
205	230
206	231
207	232		let poolConfigParsed = parsePoolConfig(gpc())
208	233
209		-	let $~~t069097095~~ = poolConfigParsed
	234	+	let $t079648193 = poolConfigParsed
210	235
211		-	let cfgPoolAddress = $~~t069097095~~._1
	236	+	let cfgPoolAddress = $t079648193._1
212	237
213		-	let cfgPoolStatus = $~~t069097095~~._2
	238	+	let cfgPoolStatus = $t079648193._2
214	239
215		-	let cfgLpAssetId = $~~t069097095~~._3
	240	+	let cfgLpAssetId = $t079648193._3
216	241
217		-	let cfgAmountAssetId = $~~t069097095~~._4
	242	+	let cfgAmountAssetId = $t079648193._4
218	243
219		-	let cfgPriceAssetId = $~~t069097095~~._5
	244	+	let cfgPriceAssetId = $t079648193._5
220	245
221		-	let cfgAmountAssetDecimals = $~~t069097095~~._6
	246	+	let cfgAmountAssetDecimals = $t079648193._6
222	247
223		-	let cfgPriceAssetDecimals = $t069097095._7
	248	+	let cfgPriceAssetDecimals = $t079648193._7
	249	+
	250	+	let cfgInAmountAssedId = $t079648193._8
	251	+
	252	+	let cfgInPriceAssetId = $t079648193._9
224	253
225	254		func gfc () = split(strf(fca, fcfg()), SEP)
226	255

247	276
248	277
249	278		func cpbi (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
	279	+
	280	+
	281	+	func cpbir (prAmtX18,amAmtX18,round) = fraction(prAmtX18, scale18, amAmtX18, round)
250	282
251	283
252	284		func vad (A1,A2,slippage) = {

277	309
278	310
279	311		func calcPrices (amAmt,prAmt,lpAmt) = {
280		-	let cfg = gpc()
281		-	let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
282		-	let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
	312	+	let amtAsDcm = cfgAmountAssetDecimals
	313	+	let prAsDcm = cfgPriceAssetDecimals
283	314		let priceX18 = pcp(amtAsDcm, prAsDcm, amAmt, prAmt)
284	315		let amAmtX18 = t1(amAmt, amtAsDcm)
285	316		let prAmtX18 = t1(prAmt, prAsDcm)

304	335		}
305	336
306	337
	338	+	func getD (xp) = {
	339	+	let xp0 = xp[0]
	340	+	let xp1 = xp[1]
	341	+	let s = (xp0 + xp1)
	342	+	if ((s == big0))
	343	+	then big0
	344	+	else {
	345	+	let a = parseIntValue(A)
	346	+	let ann = (a * 2)
	347	+	let p = fraction(xp0, xp1, big1)
	348	+	let xp0_xp1_n_n = fraction(p, big4, big1)
	349	+	let ann_s = fraction(toBigInt(ann), s, big1)
	350	+	let ann_1 = toBigInt((ann - 1))
	351	+	func calcDNext (d) = {
	352	+	let dd = fraction(d, d, big1)
	353	+	let ddd = fraction(dd, d, big1)
	354	+	let dp = fraction(ddd, big1, xp0_xp1_n_n)
	355	+	fraction((ann_s + fraction(dp, big2, big1)), d, (fraction(ann_1, d, big1) + fraction(big3, dp, big1)))
	356	+	}
	357	+
	358	+	func calc (acc,i) = if (acc._2)
	359	+	then acc
	360	+	else {
	361	+	let d = acc._1
	362	+	let dNext = calcDNext(d)
	363	+	let dDiffRaw = (dNext - value(d))
	364	+	let dDiff = if ((big0 > dDiffRaw))
	365	+	then -(dDiffRaw)
	366	+	else dDiffRaw
	367	+	if ((big1 >= dDiff))
	368	+	then $Tuple2(dNext, true)
	369	+	else $Tuple2(dNext, false)
	370	+	}
	371	+
	372	+	let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
	373	+	let $t01269012738 = {
	374	+	let $l = arr
	375	+	let $s = size($l)
	376	+	let $acc0 = $Tuple2(s, false)
	377	+	func $f0_1 ($a,$i) = if (($i >= $s))
	378	+	then $a
	379	+	else calc($a, $l[$i])
	380	+
	381	+	func $f0_2 ($a,$i) = if (($i >= $s))
	382	+	then $a
	383	+	else throw("List size exceeds 15")
	384	+
	385	+	$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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
	386	+	}
	387	+	let d = $t01269012738._1
	388	+	let found = $t01269012738._2
	389	+	if (found)
	390	+	then d
	391	+	else throw(("D calculation error, D = " + toString(d)))
	392	+	}
	393	+	}
	394	+
	395	+
307	396		func ego (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
308		-	let cfg = gpc()
309		-	let lpId = cfg[idxLPAsId]
310		-	let amId = cfg[idxAmAsId]
311		-	let prId = cfg[idxPrAsId]
312		-	let amDcm = parseIntValue(cfg[idxAmtAsDcm])
313		-	let prDcm = parseIntValue(cfg[idxPriceAsDcm])
314		-	let sts = cfg[idxPoolSt]
315		-	let lpEmiss = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Wrong LP id").quantity
316		-	if ((lpId != pmtAssetId))
	397	+	let lpId = cfgLpAssetId
	398	+	let amId = toBase58String(value(cfgAmountAssetId))
	399	+	let prId = toBase58String(value(cfgPriceAssetId))
	400	+	let amDcm = cfgAmountAssetDecimals
	401	+	let prDcm = cfgPriceAssetDecimals
	402	+	let sts = toString(cfgPoolStatus)
	403	+	let lpEmiss = valueOrErrorMessage(assetInfo(lpId), "Wrong LP id").quantity
	404	+	if ((toBase58String(lpId) != pmtAssetId))
317	405		then throw("Wrong pmt asset")
318	406		else {
319	407		let amBalance = getAccBalance(amId)

326	414		let lpEmissX18 = t1(lpEmiss, scale8)
327	415		let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
328	416		let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
329		-	let outAmAmt = f1(outAmAmtX18, amDcm)
330		-	let outPrAmt = f1(outPrAmtX18, prDcm)
	417	+	let outAmAmt = fromX18Round(outAmAmtX18, amDcm, FLOOR)
	418	+	let outPrAmt = fromX18Round(outPrAmtX18, prDcm, FLOOR)
331	419		let state = if ((txId58 == ""))
332	420		then nil
333	421		else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))

341	429
342	430
343	431		func epo (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
344		-	let cfg = gpc()
345		-	let lpId = fromBase58String(cfg[idxLPAsId])
346		-	let amIdStr = cfg[idxAmAsId]
347		-	let prIdStr = cfg[idxPrAsId]
348		-	let inAmIdStr = cfg[idxIAmtAsId]
349		-	let inPrIdStr = cfg[idxIPriceAsId]
350		-	let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
351		-	let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
352		-	let sts = cfg[idxPoolSt]
	432	+	let lpId = cfgLpAssetId
	433	+	let amIdStr = toBase58String(value(cfgAmountAssetId))
	434	+	let prIdStr = toBase58String(value(cfgPriceAssetId))
	435	+	let inAmIdStr = cfgInAmountAssedId
	436	+	let inPrIdStr = cfgInPriceAssetId
	437	+	let amtDcm = cfgAmountAssetDecimals
	438	+	let priceDcm = cfgPriceAssetDecimals
	439	+	let sts = toString(cfgPoolStatus)
353	440		let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
354	441		let amBalance = if (isEval)
355	442		then getAccBalance(amIdStr)

374	461		let userPriceX18 = cpbi(inPrAssetAmtX18, inAmAssetAmtX18)
375	462		let amBalanceX18 = t1(amBalance, amtDcm)
376	463		let prBalanceX18 = t1(prBalance, priceDcm)
	464	+	let D0 = getD([amBalanceX18, prBalanceX18])
377	465		let r = if ((lpEm == 0))
378	466		then {
379		-	let curPriceX18 = zeroBigInt
380		-	let slippageX18 = zeroBigInt
381		-	let lpAmtX18 = pow((inAmAssetAmtX18 * inPrAssetAmtX18), 0, toBigInt(5), 1, 0, DOWN)
382		-	$Tuple5(f1(lpAmtX18, scale8), f1(inAmAssetAmtX18, amtDcm), f1(inPrAssetAmtX18, priceDcm), cpbi((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
	467	+	let D1 = getD([(amBalanceX18 + inAmAssetAmtX18), (prBalanceX18 + inPrAssetAmtX18)])
	468	+	let checkD = if ((D1 > D0))
	469	+	then true
	470	+	else throw("D1 should be greater than D0")
	471	+	if ((checkD == checkD))
	472	+	then {
	473	+	let curPriceX18 = zeroBigInt
	474	+	let slippageX18 = zeroBigInt
	475	+	let lpAmtX18 = D1
	476	+	$Tuple5(f1(lpAmtX18, scale8), f1(inAmAssetAmtX18, amtDcm), f1(inPrAssetAmtX18, priceDcm), cpbi((prBalanceX18 + inPrAssetAmtX18), (amBalanceX18 + inAmAssetAmtX18)), slippageX18)
	477	+	}
	478	+	else throw("Strict value is not equal to itself.")
383	479		}
384	480		else {
385	481		let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)

393	489		then throw(((("Price slippage " + toString(slippageRealX18)) + " > ") + toString(slippageX18)))
394	490		else {
395	491		let lpEmissionX18 = t1(lpEm, scale8)
396		-	let prViaAmX18 = fraction(inAmAssetAmtX18, ~~curPriceX18~~, scale18)
397		-	let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, ~~curPriceX18~~)
	492	+	let prViaAmX18 = fraction(inAmAssetAmtX18, cpbir(prBalanceX18, amBalanceX18, CEILING), scale18, CEILING)
	493	+	let amViaPrX18 = fraction(inPrAssetAmtX18, scale18, cpbir(prBalanceX18, amBalanceX18, FLOOR), CEILING)
398	494		let expectedAmts = if ((prViaAmX18 > inPrAssetAmtX18))
399	495		then $Tuple2(amViaPrX18, inPrAssetAmtX18)
400	496		else $Tuple2(inAmAssetAmtX18, prViaAmX18)
401	497		let expAmtAssetAmtX18 = expectedAmts._1
402	498		let expPriceAssetAmtX18 = expectedAmts._2
403		-	let lpAmtX18 = fraction(lpEmissionX18, expPriceAssetAmtX18, prBalanceX18)
404		-	$Tuple5(f1(lpAmtX18, scale8), f1(expAmtAssetAmtX18, amtDcm), f1(expPriceAssetAmtX18, priceDcm), curPriceX18, slippageX18)
	499	+	let D1 = getD([(amBalanceX18 + expAmtAssetAmtX18), (prBalanceX18 + expPriceAssetAmtX18)])
	500	+	let checkD = if ((D1 > D0))
	501	+	then true
	502	+	else throw("D1 should be greater than D0")
	503	+	if ((checkD == checkD))
	504	+	then {
	505	+	let lpAmtX18 = fraction(lpEmissionX18, (D1 - D0), D0)
	506	+	$Tuple5(fromX18Round(lpAmtX18, scale8, FLOOR), fromX18Round(expAmtAssetAmtX18, amtDcm, CEILING), fromX18Round(expPriceAssetAmtX18, priceDcm, CEILING), curPriceX18, slippageX18)
	507	+	}
	508	+	else throw("Strict value is not equal to itself.")
405	509		}
406	510		}
407	511		let calcLpAmt = r._1

417	521		else calcLpAmt
418	522		let amDiff = (inAmAmt - calcAmAssetPmt)
419	523		let prDiff = (inPrAmt - calcPrAssetPmt)
420		-	let $~~t01756217907~~ = if (if (isOneAsset)
	524	+	let $t02057720922 = if (if (isOneAsset)
421	525		then (pmtId == amIdStr)
422	526		else false)
423	527		then $Tuple2(pmtAmt, 0)

426	530		else false)
427	531		then $Tuple2(0, pmtAmt)
428	532		else $Tuple2(calcAmAssetPmt, calcPrAssetPmt)
429		-	let writeAmAmt = $~~t01756217907~~._1
430		-	let writePrAmt = $~~t01756217907~~._2
	533	+	let writeAmAmt = $t02057720922._1
	534	+	let writePrAmt = $t02057720922._2
431	535		let commonState = [IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice), StringEntry(pau(userAddress, txId58), dataPutActionInfo(writeAmAmt, writePrAmt, emitLpAmt, curPrice, slippage, slippageCalc, height, lastBlock.timestamp, amDiff, prDiff))]
432	536		$Tuple13(calcLpAmt, emitLpAmt, curPrice, amBalance, prBalance, lpEm, lpId, sts, commonState, amDiff, prDiff, inAmId, inPrId)
433	537		}
434	538		}
435	539
436	540
437		-	func moa (order) = {
438		-	let cfg = gpc()
439		-	let amtAsId = cfg[idxAmAsId]
440		-	let prAsId = cfg[idxPrAsId]
441		-	let sts = parseIntValue(cfg[idxPoolSt])
442		-	let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
443		-	let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
444		-	let accAmtAsBalance = getAccBalance(amtAsId)
445		-	let accPrAsBalance = getAccBalance(prAsId)
446		-	let curPriceX18 = if ((order.orderType == Buy))
447		-	then pcp(amtAsDcm, prAsDcm, (accAmtAsBalance + order.amount), accPrAsBalance)
448		-	else pcp(amtAsDcm, prAsDcm, (accAmtAsBalance - order.amount), accPrAsBalance)
449		-	let curPrice = f1(curPriceX18, scale8)
	541	+	func getYD (xp,i,D) = {
	542	+	let n = big2
	543	+	let x = xp[if ((i == 0))
	544	+	then 1
	545	+	else 0]
	546	+	let aPrecision = parseBigIntValue(Amult)
	547	+	let a = (parseBigIntValue(A) * aPrecision)
	548	+	let s = x
	549	+	let ann = (a * n)
	550	+	let c = (((((D * D) / (x * n)) * D) * aPrecision) / (ann * n))
	551	+	let b = ((s + ((D * aPrecision) / ann)) - D)
	552	+	func calc (acc,cur) = {
	553	+	let $t02211722137 = acc
	554	+	let y = $t02211722137._1
	555	+	let found = $t02211722137._2
	556	+	if ((found != unit))
	557	+	then acc
	558	+	else {
	559	+	let yNext = (((y * y) + c) / ((big2 * y) + b))
	560	+	let yDiff = absBigInt((yNext - value(y)))
	561	+	if ((big1 >= yDiff))
	562	+	then $Tuple2(yNext, cur)
	563	+	else $Tuple2(yNext, unit)
	564	+	}
	565	+	}
	566	+
	567	+	let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
	568	+	let $t02244422491 = {
	569	+	let $l = arr
	570	+	let $s = size($l)
	571	+	let $acc0 = $Tuple2(D, unit)
	572	+	func $f0_1 ($a,$i) = if (($i >= $s))
	573	+	then $a
	574	+	else calc($a, $l[$i])
	575	+
	576	+	func $f0_2 ($a,$i) = if (($i >= $s))
	577	+	then $a
	578	+	else throw("List size exceeds 15")
	579	+
	580	+	$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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
	581	+	}
	582	+	let y = $t02244422491._1
	583	+	let found = $t02244422491._2
	584	+	if ((found != unit))
	585	+	then y
	586	+	else throw(("Y calculation error, Y = " + toString(y)))
	587	+	}
	588	+
	589	+
	590	+	func calcDLp (amountBalance,priceBalance,lpEmission) = {
	591	+	let updatedDLp = fraction(getD([t1BigInt(amountBalance, toBigInt(cfgAmountAssetDecimals)), t1BigInt(priceBalance, toBigInt(cfgPriceAssetDecimals))]), scale18, lpEmission)
	592	+	if ((lpEmission == big0))
	593	+	then big0
	594	+	else updatedDLp
	595	+	}
	596	+
	597	+
	598	+	func calcCurrentDLp (amountAssetDelta,priceAssetDelta,lpAssetEmissionDelta) = {
	599	+	let amountAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgAmountAssetId))) - amountAssetDelta)
	600	+	let priceAssetBalance = (toBigInt(getAccBalance(assetIdToString(cfgPriceAssetId))) - priceAssetDelta)
	601	+	let lpAssetEmission = (toBigInt(value(assetInfo(cfgLpAssetId)).quantity) - lpAssetEmissionDelta)
	602	+	let currentDLp = calcDLp(amountAssetBalance, priceAssetBalance, lpAssetEmission)
	603	+	currentDLp
	604	+	}
	605	+
	606	+
	607	+	func refreshDLpInternal (amountAssetBalanceDelta,priceAssetBalanceDelta,lpAssetEmissionDelta) = {
	608	+	let amountAssetBalance = (getAccBalance(assetIdToString(cfgAmountAssetId)) + amountAssetBalanceDelta)
	609	+	let priceAssetBalance = (getAccBalance(assetIdToString(cfgPriceAssetId)) + priceAssetBalanceDelta)
	610	+	let lpAssetEmission = (value(assetInfo(cfgLpAssetId)).quantity + lpAssetEmissionDelta)
	611	+	let updatedDLp = calcDLp(toBigInt(amountAssetBalance), toBigInt(priceAssetBalance), toBigInt(lpAssetEmission))
	612	+	let actions = [IntegerEntry(keyDLpRefreshedHeight, height), StringEntry(keyDLp, toString(updatedDLp))]
	613	+	$Tuple2(actions, updatedDLp)
	614	+	}
	615	+
	616	+
	617	+	func validateUpdatedDLp (oldDLp,updatedDLp) = if ((updatedDLp >= oldDLp))
	618	+	then true
	619	+	else throwErr("updated DLp lower than current DLp")
	620	+
	621	+
	622	+	func validateMatcherOrderAllowed (order) = {
	623	+	let amountAssetAmount = order.amount
	624	+	let priceAssetAmount = fraction(order.amount, order.price, scale8, FLOOR)
	625	+	let $t02453524747 = if ((order.orderType == Buy))
	626	+	then $Tuple2(amountAssetAmount, -(priceAssetAmount))
	627	+	else $Tuple2(-(amountAssetAmount), priceAssetAmount)
	628	+	let amountAssetBalanceDelta = $t02453524747._1
	629	+	let priceAssetBalanceDelta = $t02453524747._2
450	630		if (if (if (igs())
451	631		then true
452		-	else (~~sts~~ == PoolMatcherDis))
	632	+	else (cfgPoolStatus == PoolMatcherDis))
453	633		then true
454		-	else (~~sts~~ == PoolShutdown))
	634	+	else (cfgPoolStatus == PoolShutdown))
455	635		then throw("Admin blocked")
456		-	else {
457		-	let orAmtAsset = order.assetPair.amountAsset
458		-	let orAmtAsStr = if ((orAmtAsset == unit))
459		-	then "WAVES"
460		-	else toBase58String(value(orAmtAsset))
461		-	let orPrAsset = order.assetPair.priceAsset
462		-	let orPrAsStr = if ((orPrAsset == unit))
463		-	then "WAVES"
464		-	else toBase58String(value(orPrAsset))
465		-	if (if ((orAmtAsStr != amtAsId))
466		-	then true
467		-	else (orPrAsStr != prAsId))
468		-	then throw("Wr assets")
469		-	else {
470		-	let orderPrice = order.price
471		-	let priceDcm = fraction(scale8, prAsDcm, amtAsDcm)
472		-	let castOrderPrice = ts(orderPrice, scale8, priceDcm)
473		-	let isOrderPriceValid = if ((order.orderType == Buy))
474		-	then (curPrice >= castOrderPrice)
475		-	else (castOrderPrice >= curPrice)
476		-	true
477		-	}
478		-	}
	636	+	else if (if ((order.assetPair.amountAsset != cfgAmountAssetId))
	637	+	then true
	638	+	else (order.assetPair.priceAsset != cfgPriceAssetId))
	639	+	then throw("Wr assets")
	640	+	else {
	641	+	let dLp = parseBigIntValue(getStringValue(this, keyDLp))
	642	+	let $t02507725177 = refreshDLpInternal(amountAssetBalanceDelta, priceAssetBalanceDelta, 0)
	643	+	let unusedActions = $t02507725177._1
	644	+	let dLpNew = $t02507725177._2
	645	+	let isOrderValid = (dLpNew >= dLp)
	646	+	let info = makeString([toString(dLp), toString(dLpNew)], " ")
	647	+	$Tuple2(isOrderValid, info)
	648	+	}
479	649		}
480	650
481	651

511	681		}
512	682
513	683
514		-	func getD (xp) = {
515		-	let n = big2
516		-	let xp0 = xp[0]
517		-	let xp1 = xp[1]
518		-	let aPrecision = parseBigIntValue(Amult)
519		-	let a = (parseBigIntValue(A) * aPrecision)
520		-	let s = (xp0 + xp1)
521		-	if ((s == big0))
522		-	then big0
523		-	else {
524		-	let ann = (a * n)
525		-	let xp0_xp1_n_n = (((xp0 * xp1) * n) * n)

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let scale8 = 100000000
5	5
6	6		let scale8BigInt = toBigInt(100000000)
7	7
8	8		let scale18 = toBigInt(1000000000000000000)
9	9
10	10		let zeroBigInt = toBigInt(0)
11	11
12	12		let big0 = toBigInt(0)
13	13
14	14		let big1 = toBigInt(1)
15	15
16	16		let big2 = toBigInt(2)
	17	+
	18	+	let big3 = toBigInt(3)
	19	+
	20	+	let big4 = toBigInt(4)
17	21
18	22		let slippage4D = toBigInt((scale8 - ((scale8 * 1) / scale8)))
19	23
20	24		let wavesString = "WAVES"
21	25
22	26		let Amult = "100"
23	27
24	28		let Dconv = "1"
25	29
26	30		let SEP = "__"
27	31
28	32		let EMPTY = ""
29	33
30	34		let PoolActive = 1
31	35
32	36		let PoolPutDis = 2
33	37
34	38		let PoolMatcherDis = 3
35	39
36	40		let PoolShutdown = 4
37	41
38	42		let idxPoolAddress = 1
39	43
40	44		let idxPoolSt = 2
41	45
42	46		let idxLPAsId = 3
43	47
44	48		let idxAmAsId = 4
45	49
46	50		let idxPrAsId = 5
47	51
48	52		let idxAmtAsDcm = 6
49	53
50	54		let idxPriceAsDcm = 7
51	55
52	56		let idxIAmtAsId = 8
53	57
54	58		let idxIPriceAsId = 9
55	59
56	60		let idxFactStakCntr = 1
57	61
58	62		let idxFactoryRestCntr = 6
59	63
60	64		let idxFactSlippCntr = 7
61	65
62	66		let idxFactGwxRewCntr = 10
63	67
64	68		let feeDefault = fraction(10, scale8, 10000)
65	69
66	70		func t1 (origVal,origScaleMult) = fraction(toBigInt(origVal), scale18, toBigInt(origScaleMult))
67	71
68	72
	73	+	func t1BigInt (origVal,origScaleMult) = fraction(origVal, scale18, origScaleMult)
	74	+
	75	+
69	76		func f1 (val,resultScaleMult) = toInt(fraction(val, toBigInt(resultScaleMult), scale18))
	77	+
	78	+
	79	+	func fromX18Round (val,resultScaleMult,round) = toInt(fraction(val, toBigInt(resultScaleMult), scale18, round))
	80	+
	81	+
	82	+	func t2 (origVal,origScaleMult) = fraction(origVal, scale18, toBigInt(origScaleMult))
	83	+
	84	+
	85	+	func f2 (val,resultScaleMult) = fraction(val, toBigInt(resultScaleMult), scale18)
70	86
71	87
72	88		func ts (amt,resScale,curScale) = fraction(amt, resScale, curScale)
73	89
74	90
75	91		func abs (val) = if ((zeroBigInt > val))
76	92		then -(val)
77	93		else val
78	94
79	95
80	96		func absBigInt (val) = if ((zeroBigInt > val))
81	97		then -(val)
82	98		else val
83	99
84	100
85	101		func fc () = "%s__factoryContract"
86	102
87	103
88	104		func mpk () = "%s__managerPublicKey"
89	105
90	106
91	107		func pmpk () = "%s__pendingManagerPublicKey"
92	108
93	109
94	110		func pl () = "%s%s__price__last"
95	111
96	112
97	113		func ph (h,t) = makeString(["%s%s%d%d__price__history", toString(h), toString(t)], SEP)
98	114
99	115
100	116		func pau (ua,txId) = ((("%s%s%s__P__" + ua) + "__") + txId)
101	117
102	118
103	119		func gau (ua,txId) = ((("%s%s%s__G__" + ua) + "__") + txId)
104	120
105	121
106	122		func aa () = "%s__amountAsset"
107	123
108	124
109	125		func pa () = "%s__priceAsset"
110	126
111	127
112	128		func amp () = "%s__amp"
113	129
114	130
115	131		func ada () = "%s__addonAddr"
116	132
117	133
	134	+	let keyFee = "%s__fee"
	135	+
	136	+	let fee = valueOrElse(getInteger(this, keyFee), feeDefault)
	137	+
	138	+	let keyDLp = makeString(["%s", "dLp"], SEP)
	139	+
	140	+	let keyDLpRefreshedHeight = makeString(["%s", "dLpRefreshedHeight"], SEP)
	141	+
	142	+	let keyDLpRefreshDelay = makeString(["%s", "refreshDLpDelay"], SEP)
	143	+
	144	+	let dLpRefreshDelayDefault = 1
	145	+
	146	+	let dLpRefreshDelay = valueOrElse(getInteger(this, keyDLpRefreshDelay), dLpRefreshDelayDefault)
	147	+
118	148		func fcfg () = "%s__factoryConfig"
119	149
120	150
121	151		func mtpk () = "%s%s__matcher__publicKey"
122	152
123	153
124	154		func pc (iAmtAs,iPrAs) = (((("%d%d%s__" + iAmtAs) + "__") + iPrAs) + "__config")
125	155
126	156
127	157		func mba (bAStr) = ("%s%s%s__mappings__baseAsset2internalId__" + bAStr)
128	158
129	159
130	160		func aps () = "%s__shutdown"
131	161
132	162
133	163		func keyAllowedLpStableScriptHash () = "%s__allowedLpStableScriptHash"
134	164
135	165
136	166		func keyFeeCollectorAddress () = "%s__feeCollectorAddress"
137	167
138	168
139		-	func toe (orV,sendrV,matchV) = throw(((((("Failed: ordValid=" + toString(orV)) + " sndrValid=") + toString(sendrV)) + " mtchrValid=") + toString(matchV)))
140		-
141		-
142		-	func str (val) = match val {
143		-	case valStr: String =>
144		-	valStr
145		-	case _ =>
146		-	throw("fail cast to String")
147		-	}
	169	+	func throwOrderError (orderValid,orderValidInfo,senderValid,matcherValid) = throw((((((((("order validation failed: orderValid=" + toString(orderValid)) + " (") + orderValidInfo) + ")") + " senderValid=") + toString(senderValid)) + " matcherValid=") + toString(matcherValid)))
148	170
149	171
150	172		func strf (addr,key) = valueOrErrorMessage(getString(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
151	173
152	174
153	175		func intf (addr,key) = valueOrErrorMessage(getInteger(addr, key), makeString(["mandatory ", toString(addr), ".", key, " not defined"], ""))
154	176
155	177
156	178		func throwErr (msg) = throw(makeString(["lp_stable.ride:", msg], " "))
	179	+
	180	+
	181	+	func fmtErr (msg) = makeString(["lp_stable.ride:", msg], " ")
157	182
158	183
159	184		let fca = addressFromStringValue(strf(this, fc()))
160	185
161	186		let inFee = {
162	187		let @ = invoke(fca, "getInFeeREADONLY", [toString(this)], nil)
163	188		if ($isInstanceOf(@, "Int"))
164	189		then @
165	190		else throw(($getType(@) + " couldn't be cast to Int"))
166	191		}
167	192
168	193		let outFee = {
169	194		let @ = invoke(fca, "getOutFeeREADONLY", [toString(this)], nil)
170	195		if ($isInstanceOf(@, "Int"))
171	196		then @
172	197		else throw(($getType(@) + " couldn't be cast to Int"))
173	198		}
174	199
175	200		let A = strf(this, amp())
176	201
177	202		func igs () = valueOrElse(getBoolean(fca, aps()), false)
178	203
179	204
180	205		func mp () = fromBase58String(strf(fca, mtpk()))
181	206
182	207
183	208		let feeCollectorAddress = addressFromStringValue(strf(fca, keyFeeCollectorAddress()))
184	209
185	210		func gpc () = {
186	211		let amtAs = strf(this, aa())
187	212		let priceAs = strf(this, pa())
188	213		let iPriceAs = intf(fca, mba(priceAs))
189	214		let iAmtAs = intf(fca, mba(amtAs))
190	215		split(strf(fca, pc(toString(iAmtAs), toString(iPriceAs))), SEP)
191	216		}
192	217
193	218
194	219		func parseAssetId (input) = if ((input == wavesString))
195	220		then unit
196	221		else fromBase58String(input)
197	222
198	223
199	224		func assetIdToString (input) = if ((input == unit))
200	225		then wavesString
201	226		else toBase58String(value(input))
202	227
203	228
204		-	func parsePoolConfig (poolConfig) = $~~Tuple7~~(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]))
	229	+	func parsePoolConfig (poolConfig) = $Tuple9(addressFromStringValue(poolConfig[idxPoolAddress]), parseIntValue(poolConfig[idxPoolSt]), fromBase58String(poolConfig[idxLPAsId]), parseAssetId(poolConfig[idxAmAsId]), parseAssetId(poolConfig[idxPrAsId]), parseIntValue(poolConfig[idxAmtAsDcm]), parseIntValue(poolConfig[idxPriceAsDcm]), fromBase58String(poolConfig[idxIAmtAsId]), fromBase58String(poolConfig[idxIPriceAsId]))
205	230
206	231
207	232		let poolConfigParsed = parsePoolConfig(gpc())
208	233
209		-	let $~~t069097095~~ = poolConfigParsed
	234	+	let $t079648193 = poolConfigParsed
210	235
211		-	let cfgPoolAddress = $~~t069097095~~._1
	236	+	let cfgPoolAddress = $t079648193._1
212	237
213		-	let cfgPoolStatus = $~~t069097095~~._2
	238	+	let cfgPoolStatus = $t079648193._2
214	239
215		-	let cfgLpAssetId = $~~t069097095~~._3
	240	+	let cfgLpAssetId = $t079648193._3
216	241
217		-	let cfgAmountAssetId = $~~t069097095~~._4
	242	+	let cfgAmountAssetId = $t079648193._4
218	243
219		-	let cfgPriceAssetId = $~~t069097095~~._5
	244	+	let cfgPriceAssetId = $t079648193._5
220	245
221		-	let cfgAmountAssetDecimals = $~~t069097095~~._6
	246	+	let cfgAmountAssetDecimals = $t079648193._6
222	247
223		-	let cfgPriceAssetDecimals = $t069097095._7
	248	+	let cfgPriceAssetDecimals = $t079648193._7
	249	+
	250	+	let cfgInAmountAssedId = $t079648193._8
	251	+
	252	+	let cfgInPriceAssetId = $t079648193._9
224	253
225	254		func gfc () = split(strf(fca, fcfg()), SEP)
226	255
227	256
228	257		let factoryConfig = gfc()
229	258
230	259		let stakingContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactStakCntr]), "Invalid staking contract address")
231	260
232	261		let slipageContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactSlippCntr]), "Invalid slipage contract address")
233	262
234	263		let gwxContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactGwxRewCntr]), "Invalid gwx contract address")
235	264
236	265		let restContract = valueOrErrorMessage(addressFromString(factoryConfig[idxFactoryRestCntr]), "Invalid gwx contract address")
237	266
238	267		func dataPutActionInfo (inAmtAssetAmt,inPriceAssetAmt,outLpAmt,price,slipByUser,slippageReal,txHeight,txTimestamp,slipageAmAmt,slipagePrAmt) = makeString(["%d%d%d%d%d%d%d%d%d%d", toString(inAmtAssetAmt), toString(inPriceAssetAmt), toString(outLpAmt), toString(price), toString(slipByUser), toString(slippageReal), toString(txHeight), toString(txTimestamp), toString(slipageAmAmt), toString(slipagePrAmt)], SEP)
239	268
240	269
241	270		func dataGetActionInfo (outAmtAssetAmt,outPriceAssetAmt,inLpAmt,price,txHeight,txTimestamp) = makeString(["%d%d%d%d%d%d", toString(outAmtAssetAmt), toString(outPriceAssetAmt), toString(inLpAmt), toString(price), toString(txHeight), toString(txTimestamp)], SEP)
242	271
243	272
244	273		func getAccBalance (assetId) = if ((assetId == "WAVES"))
245	274		then wavesBalance(this).available
246	275		else assetBalance(this, fromBase58String(assetId))
247	276
248	277
249	278		func cpbi (prAmtX18,amAmtX18) = fraction(prAmtX18, scale18, amAmtX18)
	279	+
	280	+
	281	+	func cpbir (prAmtX18,amAmtX18,round) = fraction(prAmtX18, scale18, amAmtX18, round)
250	282
251	283
252	284		func vad (A1,A2,slippage) = {
253	285		let diff = fraction((A1 - A2), scale8BigInt, A2)
254	286		let pass = ((slippage - abs(diff)) > zeroBigInt)
255	287		if (!(pass))
256	288		then throw(("Big slpg: " + toString(diff)))
257	289		else $Tuple2(pass, min([A1, A2]))
258	290		}
259	291
260	292
261	293		func vd (D1,D0,slpg) = {
262	294		let diff = fraction(D0, scale8BigInt, D1)
263	295		let fail = (slpg > diff)
264	296		if (if (fail)
265	297		then true
266	298		else (D0 > D1))
267	299		then throw(((((((toString(D0) + " ") + toString(D1)) + " ") + toString(diff)) + " ") + toString(slpg)))
268	300		else fail
269	301		}
270	302
271	303
272	304		func pcp (amAssetDcm,prAssetDcm,amAmt,prAmt) = {
273	305		let amtAsAmtX18 = t1(amAmt, amAssetDcm)
274	306		let prAsAmtX18 = t1(prAmt, prAssetDcm)
275	307		cpbi(prAsAmtX18, amtAsAmtX18)
276	308		}
277	309
278	310
279	311		func calcPrices (amAmt,prAmt,lpAmt) = {
280		-	let cfg = gpc()
281		-	let amtAsDcm = parseIntValue(cfg[idxAmtAsDcm])
282		-	let prAsDcm = parseIntValue(cfg[idxPriceAsDcm])
	312	+	let amtAsDcm = cfgAmountAssetDecimals
	313	+	let prAsDcm = cfgPriceAssetDecimals
283	314		let priceX18 = pcp(amtAsDcm, prAsDcm, amAmt, prAmt)
284	315		let amAmtX18 = t1(amAmt, amtAsDcm)
285	316		let prAmtX18 = t1(prAmt, prAsDcm)
286	317		let lpAmtX18 = t1(lpAmt, scale8)
287	318		let lpPrInAmAsX18 = cpbi(amAmtX18, lpAmtX18)
288	319		let lpPrInPrAsX18 = cpbi(prAmtX18, lpAmtX18)
289	320		[priceX18, lpPrInAmAsX18, lpPrInPrAsX18]
290	321		}
291	322
292	323
293	324		func calculatePrices (amAmt,prAmt,lpAmt) = {
294	325		let p = calcPrices(amAmt, prAmt, lpAmt)
295	326		[f1(p[0], scale8), f1(p[1], scale8), f1(p[2], scale8)]
296	327		}
297	328
298	329
299	330		func takeFee (amount,fee) = {
300	331		let feeAmount = if ((fee == 0))
301	332		then 0
302	333		else fraction(amount, fee, scale8)
303	334		$Tuple2((amount - feeAmount), feeAmount)
304	335		}
305	336
306	337
	338	+	func getD (xp) = {
	339	+	let xp0 = xp[0]
	340	+	let xp1 = xp[1]
	341	+	let s = (xp0 + xp1)
	342	+	if ((s == big0))
	343	+	then big0
	344	+	else {
	345	+	let a = parseIntValue(A)
	346	+	let ann = (a * 2)
	347	+	let p = fraction(xp0, xp1, big1)
	348	+	let xp0_xp1_n_n = fraction(p, big4, big1)
	349	+	let ann_s = fraction(toBigInt(ann), s, big1)
	350	+	let ann_1 = toBigInt((ann - 1))
	351	+	func calcDNext (d) = {
	352	+	let dd = fraction(d, d, big1)
	353	+	let ddd = fraction(dd, d, big1)
	354	+	let dp = fraction(ddd, big1, xp0_xp1_n_n)
	355	+	fraction((ann_s + fraction(dp, big2, big1)), d, (fraction(ann_1, d, big1) + fraction(big3, dp, big1)))
	356	+	}
	357	+
	358	+	func calc (acc,i) = if (acc._2)
	359	+	then acc
	360	+	else {
	361	+	let d = acc._1
	362	+	let dNext = calcDNext(d)
	363	+	let dDiffRaw = (dNext - value(d))
	364	+	let dDiff = if ((big0 > dDiffRaw))
	365	+	then -(dDiffRaw)
	366	+	else dDiffRaw
	367	+	if ((big1 >= dDiff))
	368	+	then $Tuple2(dNext, true)
	369	+	else $Tuple2(dNext, false)
	370	+	}
	371	+
	372	+	let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
	373	+	let $t01269012738 = {
	374	+	let $l = arr
	375	+	let $s = size($l)
	376	+	let $acc0 = $Tuple2(s, false)
	377	+	func $f0_1 ($a,$i) = if (($i >= $s))
	378	+	then $a
	379	+	else calc($a, $l[$i])
	380	+
	381	+	func $f0_2 ($a,$i) = if (($i >= $s))
	382	+	then $a
	383	+	else throw("List size exceeds 15")
	384	+
	385	+	$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($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
	386	+	}
	387	+	let d = $t01269012738._1
	388	+	let found = $t01269012738._2
	389	+	if (found)
	390	+	then d
	391	+	else throw(("D calculation error, D = " + toString(d)))
	392	+	}
	393	+	}
	394	+
	395	+
307	396		func ego (txId58,pmtAssetId,pmtLpAmt,userAddress) = {
308		-	let cfg = gpc()
309		-	let lpId = cfg[idxLPAsId]
310		-	let amId = cfg[idxAmAsId]
311		-	let prId = cfg[idxPrAsId]
312		-	let amDcm = parseIntValue(cfg[idxAmtAsDcm])
313		-	let prDcm = parseIntValue(cfg[idxPriceAsDcm])
314		-	let sts = cfg[idxPoolSt]
315		-	let lpEmiss = valueOrErrorMessage(assetInfo(fromBase58String(lpId)), "Wrong LP id").quantity
316		-	if ((lpId != pmtAssetId))
	397	+	let lpId = cfgLpAssetId
	398	+	let amId = toBase58String(value(cfgAmountAssetId))
	399	+	let prId = toBase58String(value(cfgPriceAssetId))
	400	+	let amDcm = cfgAmountAssetDecimals
	401	+	let prDcm = cfgPriceAssetDecimals
	402	+	let sts = toString(cfgPoolStatus)
	403	+	let lpEmiss = valueOrErrorMessage(assetInfo(lpId), "Wrong LP id").quantity
	404	+	if ((toBase58String(lpId) != pmtAssetId))
317	405		then throw("Wrong pmt asset")
318	406		else {
319	407		let amBalance = getAccBalance(amId)
320	408		let amBalanceX18 = t1(amBalance, amDcm)
321	409		let prBalance = getAccBalance(prId)
322	410		let prBalanceX18 = t1(prBalance, prDcm)
323	411		let curPriceX18 = cpbi(prBalanceX18, amBalanceX18)
324	412		let curPrice = f1(curPriceX18, scale8)
325	413		let pmtLpAmtX18 = t1(pmtLpAmt, scale8)
326	414		let lpEmissX18 = t1(lpEmiss, scale8)
327	415		let outAmAmtX18 = fraction(amBalanceX18, pmtLpAmtX18, lpEmissX18)
328	416		let outPrAmtX18 = fraction(prBalanceX18, pmtLpAmtX18, lpEmissX18)
329		-	let outAmAmt = f1(outAmAmtX18, amDcm)
330		-	let outPrAmt = f1(outPrAmtX18, prDcm)
	417	+	let outAmAmt = fromX18Round(outAmAmtX18, amDcm, FLOOR)
	418	+	let outPrAmt = fromX18Round(outPrAmtX18, prDcm, FLOOR)
331	419		let state = if ((txId58 == ""))
332	420		then nil
333	421		else [ScriptTransfer(userAddress, outAmAmt, if ((amId == "WAVES"))
334	422		then unit
335	423		else fromBase58String(amId)), ScriptTransfer(userAddress, outPrAmt, if ((prId == "WAVES"))
336	424		then unit
337	425		else fromBase58String(prId)), StringEntry(gau(toString(userAddress), txId58), dataGetActionInfo(outAmAmt, outPrAmt, pmtLpAmt, curPrice, height, lastBlock.timestamp)), IntegerEntry(pl(), curPrice), IntegerEntry(ph(height, lastBlock.timestamp), curPrice)]
338	426		$Tuple10(outAmAmt, outPrAmt, amId, prId, amBalance, prBalance, lpEmiss, curPriceX18, sts, state)
339	427		}
340	428		}
341	429
342	430
343	431		func epo (txId58,slippage,inAmAmt,inAmId,inPrAmt,inPrId,userAddress,isEval,emitLp,isOneAsset,validateSlippage,pmtAmt,pmtId) = {
344		-	let cfg = gpc()
345		-	let lpId = fromBase58String(cfg[idxLPAsId])
346		-	let amIdStr = cfg[idxAmAsId]
347		-	let prIdStr = cfg[idxPrAsId]
348		-	let inAmIdStr = cfg[idxIAmtAsId]
349		-	let inPrIdStr = cfg[idxIPriceAsId]
350		-	let amtDcm = parseIntValue(cfg[idxAmtAsDcm])
351		-	let priceDcm = parseIntValue(cfg[idxPriceAsDcm])
352		-	let sts = cfg[idxPoolSt]
	432	+	let lpId = cfgLpAssetId
	433	+	let amIdStr = toBase58String(value(cfgAmountAssetId))
	434	+	let prIdStr = toBase58String(value(cfgPriceAssetId))
	435	+	let inAmIdStr = cfgInAmountAssedId
	436	+	let inPrIdStr = cfgInPriceAssetId
	437	+	let amtDcm = cfgAmountAssetDecimals
	438	+	let priceDcm = cfgPriceAssetDecimals
	439	+	let sts = toString(cfgPoolStatus)
353	440		let lpEm = valueOrErrorMessage(assetInfo(lpId), "Wr lp as").quantity
354	441		let amBalance = if (isEval)
355	442		then getAccBalance(amIdStr)
356	443		else if (if (isOneAsset)
357	444		then (pmtId == amIdStr)
358	445		else false)
359	446		then (getAccBalance(amIdStr) - pmtAmt)
360	447		else if (isOneAsset)
361	448		then getAccBalance(amIdStr)
362	449		else (getAccBalance(amIdStr) - inAmAmt)
363	450		let prBalance = if (isEval)
364	451		then getAccBalance(prIdStr)
365	452		else if (if (isOneAsset)
366	453		then (pmtId == prIdStr)
367	454		else false)
368	455		then (getAccBalance(prIdStr) - pmtAmt)
369	456		else if (isOneAsset)
370	457		then getAccBalance(prIdStr)
371	458		else (getAccBalance(prIdStr) - inPrAmt)
372	459		let inAmAssetAmtX18 = t1(inAmAmt, amtDcm)

github/deemru/w8io/786bc32 
182.12 ms ◑