tx · FyZk5aeXzDyX8guAEC47kGQ4bZjU7NbzyLhW6TGBePmz

3P7Uf5GF5feqnG39dTBEMqhGJzEq3T7MPUW:  -0.04600000 Waves

2023.10.31 21:55 [3889038] smart account 3P7Uf5GF5feqnG39dTBEMqhGJzEq3T7MPUW > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FyZk5aeXzDyX8guAEC47kGQ4bZjU7NbzyLhW6TGBePmz",
    "fee": 4600000,
    "feeAssetId": null,
    "timestamp": 1698778521457,
    "version": 2,
    "chainId": 87,
    "sender": "3P7Uf5GF5feqnG39dTBEMqhGJzEq3T7MPUW",
    "senderPublicKey": "EpUMhYKYeQHgj4vTF27Kc9KkTbuhwgjV6xaP6Ce31JPz",
    "proofs": [
        "3aGnecqTsUhx63cAq2cjVY3VcGDKsv6zaawz5fJeEFJqfd3HE1DRatGyR3do3MTbb95sLFJoPeqnY9m2mrbwAAoH"
    ],
    "script": "base64:AAIEAAAAAAAAABkIAhIECgIBCBIAEgASBAoCCAgSABIDCgEIAAAAdwEAAAARa2V5QWNjdW11bGF0ZWRGZWUAAAAAAgAAABIlc19fYWNjdW11bGF0ZWRGZWUBAAAAGWtleUFjY3VtdWxhdGVkUHJvdG9jb2xGZWUAAAAAAgAAABolc19fYWNjdW11bGF0ZWRQcm90b2NvbEZlZQEAAAAOa2V5VWNvbGxhdGVyYWwAAAAAAgAAAA8lc19fdWNvbGxhdGVyYWwBAAAAGWtleVRvdGFsTGVuZGVkQXRPdGhlckFjY3MAAAAAAgAAABolc19fdG90YWxMZW5kZWRBdE90aGVyQWNjcwEAAAATa2V5QXNzZXRMb2NrZWRUb3RhbAAAAAEAAAAHYXNzZXRJZAkAASwAAAACAgAAABglcyVzX19hc3NldExvY2tlZFRvdGFsX18FAAAAB2Fzc2V0SWQBAAAAE2tleUFjY291bnRPcGVyYXRpb24AAAADAAAADHVubG9ja0hlaWdodAAAAAdhZGRyZXNzAAAABnN0YXR1cwkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAHiVzJXMlZCVzX19kZWZvQXNzZXRPcGVyYXRpb25fXwUAAAAHYWRkcmVzcwIAAAACX18JAAGkAAAAAQUAAAAMdW5sb2NrSGVpZ2h0AgAAAAJfXwUAAAAGc3RhdHVzAQAAAAprZXlGYWN0b3J5AAAAAAIAAAALJXNfX2ZhY3RvcnkBAAAAGmtleUxlbmRlZEFtb3VudEJ5QXNzZXRDb2RlAAAAAQAAAAlhc3NldENvZGUJAAEsAAAAAgIAAAAdJXMlc19fbGVuZGVkQmFzZUFzc2V0QW1vdW50X18FAAAACWFzc2V0Q29kZQEAAAAIa2V5UHJpY2UAAAABAAAACWFzc2V0Q29kZQkAASwAAAACAgAAAA0lcyVzX19wcmljZV9fBQAAAAlhc3NldENvZGUBAAAAFGtleUNvbnRyb2xMYXN0SGVpZ2h0AAAAAQAAAAlhc3NldENvZGUJAAEsAAAAAgIAAAASJXMlc19fbGFzdEhlaWdodF9fBQAAAAlhc3NldENvZGUAAAAAFElkeE9wZXJhdGlvbkFtb3VudEluAAAAAAAAAAABAAAAABNJZHhPcGVyYXRpb25Bc3NldEluAAAAAAAAAAACAAAAABFJZHhPcGVyYXRpb25QcmljZQAAAAAAAAAAAwAAAAAVSWR4T3BlcmF0aW9uQW1vdW50T3V0AAAAAAAAAAAEAAAAABRJZHhPcGVyYXRpb25Bc3NldE91dAAAAAAAAAAABQEAAAAWYXNzZXREYXRhU3dhcE9wZXJhdGlvbgAAAAgAAAAIYW1vdW50SW4AAAAHYXNzZXRJbgAAAAVwcmljZQAAAAlhbW91bnRPdXQAAAAIYXNzZXRPdXQAAAAMYnJ1dHRvQW1vdW50AAAACWZlZUFtb3VudAAAABFwcm90b2NvbEZlZUFtb3VudAkABLkAAAACCQAETAAAAAICAAAAECVkJXMlZCVzJWQlZCVkJWQJAARMAAAAAgkAAaQAAAABBQAAAAhhbW91bnRJbgkABEwAAAACBQAAAAdhc3NldEluCQAETAAAAAIJAAGkAAAAAQUAAAAJYW1vdW50T3V0CQAETAAAAAIFAAAACGFzc2V0T3V0CQAETAAAAAIJAAGkAAAAAQUAAAAFcHJpY2UJAARMAAAAAgkAAaQAAAABBQAAAAxicnV0dG9BbW91bnQJAARMAAAAAgkAAaQAAAABBQAAAAlmZWVBbW91bnQJAARMAAAAAgkAAaQAAAABBQAAABFwcm90b2NvbEZlZUFtb3VudAUAAAADbmlsAgAAAAJfXwEAAAAXYXNzZXREYXRhUmViYWxhbmNlVHJhY2UAAAAFAAAAD2RlYnRvckFzc2V0Q29kZQAAAAdkZWJ0UG10AAAAB2Jhc2VQbXQAAAAPbGVuZGVkQW10QmVmb3JlAAAADmxlbmRlZEFtdEFmdGVyCQAEuQAAAAIJAARMAAAAAgIAAAAOJXMlcyVkJXMlZCVkJWQJAARMAAAAAgUAAAAPZGVidG9yQXNzZXRDb2RlCQAETAAAAAIJAAJYAAAAAQkBAAAABXZhbHVlAAAAAQgFAAAAB2RlYnRQbXQAAAAHYXNzZXRJZAkABEwAAAACCQABpAAAAAEIBQAAAAdkZWJ0UG10AAAABmFtb3VudAkABEwAAAACCQACWAAAAAEJAQAAAAV2YWx1ZQAAAAEIBQAAAAdiYXNlUG10AAAAB2Fzc2V0SWQJAARMAAAAAgkAAaQAAAABCAUAAAAHYmFzZVBtdAAAAAZhbW91bnQJAARMAAAAAgkAAaQAAAABBQAAAA9sZW5kZWRBbXRCZWZvcmUJAARMAAAAAgkAAaQAAAABBQAAAA5sZW5kZWRBbXRBZnRlcgUAAAADbmlsAgAAAAJfXwEAAAAcYXNzZXRSZWFkU3dhcERhdGFBcnJheU9yRmFpbAAAAAEAAAAPYWNjT3BlcmF0aW9uS2V5BAAAABNhY2NPcGVyYXRpb25EYXRhU3RyCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQdAAAAAgUAAAAEdGhpcwUAAAAPYWNjT3BlcmF0aW9uS2V5CQABLAAAAAICAAAAKlRoZXJlIGlzIG5vIHJlcXVlc3QgZm9yIHBhc3NlZCBhcmd1bWVudHM6IAUAAAAPYWNjT3BlcmF0aW9uS2V5CQAEtQAAAAIFAAAAE2FjY09wZXJhdGlvbkRhdGFTdHICAAAAAl9fAAAAAAdudWxsSW50AP//////////AAAAAAdudWxsU3RyAgAAAAROVUxMAAAAAApmYWN0b3J5QWNjCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQdAAAAAgUAAAAEdGhpcwkBAAAACmtleUZhY3RvcnkAAAAACQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAABJObyBjb25maWcgYXQgdGhpcz0JAAQlAAAAAQUAAAAEdGhpcwIAAAAJIGZvciBrZXk9CQEAAAAKa2V5RmFjdG9yeQAAAAABAAAAJGtleUZhY3RvcnlOZXV0cmlub0NvbnRyYWN0QWRkcmVzc0tleQAAAAACAAAAKyVzJXNfX2NvbW1vbkNvbmZpZ19fbmV1dHJpbm9Db250cmFjdEFkZHJlc3MBAAAAFWtleUZhY3RvcnlEZWJ0QXNzZXRJZAAAAAACAAAAHyVzJXNfX2NvbW1vbkNvbmZpZ19fZGVidEFzc2V0SWQBAAAAIGtleUZhY3RvcnlEZWJ0QXNzZXRFdGFsb25CYWxhbmNlAAAAAAIAAAAqJXMlc19fY29tbW9uQ29uZmlnX19kZWJ0QXNzZXRFdGFsb25CYWxhbmNlAQAAABJrZXlGYWN0b3J5QXNzZXRDZmcAAAABAAAAD2Fzc2V0QWRkcmVzc1N0cgkAASwAAAACCQABLAAAAAICAAAAEyVzJXMlc19fZGVmb0Fzc2V0X18FAAAAD2Fzc2V0QWRkcmVzc1N0cgIAAAAIX19jb25maWcBAAAAGmtleUZhY3RvcnlBc3NldEN1cnJlbnRQb29sAAAAAQAAAA9hc3NldEFjY0FkZHJlc3MJAAEsAAAAAgkAASwAAAACAgAAABMlcyVzJXNfX2RlZm9Bc3NldF9fCQAEJQAAAAEFAAAAD2Fzc2V0QWNjQWRkcmVzcwIAAAANX19jdXJyZW50UG9vbAEAAAAga2V5RmFjdG9yeURlZm9BZGRyZXNzQnlBc3NldENvZGUAAAABAAAACWFzc2V0Q29kZQkAASwAAAACCQABLAAAAAICAAAAEyVzJXMlc19fZGVmb0Fzc2V0X18FAAAACWFzc2V0Q29kZQIAAAAUX19hZGRyZXNzQnlBc3NldENvZGUBAAAAGWtleUZhY3RvcnlBc3NldFBvb2xNYWtlcnMAAAABAAAADGFzc2V0QWRkcmVzcwkAASwAAAACCQABLAAAAAICAAAAEyVzJXMlc19fZGVmb0Fzc2V0X18FAAAADGFzc2V0QWRkcmVzcwIAAAAMX19wb29sTWFrZXJzAQAAACFrZXlGYWN0b3J5RGVmb1N0YWtpbmdQYWNlbWFrZXJQdWIAAAAAAgAAACslcyVzX19jb21tb25Db25maWdfX2RlZm9TdGFraW5nUGFjZW1ha2VyUHViAQAAACNrZXlGYWN0b3J5UG9vbE1ha2VyTGlxdWlkaXR5UmVxdWVzdAAAAAMAAAAMYXNzZXRBZGRyZXNzAAAAEHBvb2xNYWtlckFkZHJlc3MAAAABaAkABLkAAAACCQAETAAAAAICAAAAECVzJXMlcyVkJXNfX3Bvb2wJAARMAAAAAgUAAAAMYXNzZXRBZGRyZXNzCQAETAAAAAIFAAAAEHBvb2xNYWtlckFkZHJlc3MJAARMAAAAAgkAAaQAAAABBQAAAAFoCQAETAAAAAICAAAAEGxpcXVpZGl0eVJlcXVlc3QFAAAAA25pbAIAAAACX18BAAAAH2tleUZhY3RvcnlQb29sTWFrZXJVbmxvY2tIZWlnaHQAAAACAAAADGFzc2V0QWRkcmVzcwAAABBwb29sTWFrZXJBZGRyZXNzCQAEuQAAAAIJAARMAAAAAgIAAAAOJXMlcyVzJXNfX3Bvb2wJAARMAAAAAgUAAAAMYXNzZXRBZGRyZXNzCQAETAAAAAIFAAAAEHBvb2xNYWtlckFkZHJlc3MJAARMAAAAAgIAAAAMdW5sb2NrSGVpZ2h0BQAAAANuaWwCAAAAAl9fAQAAABZmYWN0b3J5UmVhZERlYnRBc3NldElkAAAAAAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEHQAAAAIFAAAACmZhY3RvcnlBY2MJAQAAABVrZXlGYWN0b3J5RGVidEFzc2V0SWQAAAAACQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAABVObyBjb25maWcgYXQgZmFjdG9yeT0JAAQlAAAAAQUAAAAKZmFjdG9yeUFjYwIAAAAJIGZvciBrZXk9CQEAAAAVa2V5RmFjdG9yeURlYnRBc3NldElkAAAAAAEAAAAcZmFjdG9yeVJlYWRBc3NldENmZ0J5QWRkcmVzcwAAAAEAAAAPYXNzZXRBZGRyZXNzU3RyCQAEtQAAAAIJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABB0AAAACBQAAAApmYWN0b3J5QWNjCQEAAAASa2V5RmFjdG9yeUFzc2V0Q2ZnAAAAAQUAAAAPYXNzZXRBZGRyZXNzU3RyCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAABVObyBjb25maWcgYXQgZmFjdG9yeT0JAAQlAAAAAQUAAAAKZmFjdG9yeUFjYwIAAAAJIGZvciBrZXk9CQEAAAASa2V5RmFjdG9yeUFzc2V0Q2ZnAAAAAQUAAAAPYXNzZXRBZGRyZXNzU3RyAgAAAAJfXwEAAAAZZmFjdG9yeVJlYWRBc3NldENmZ0J5Q29kZQAAAAEAAAAJYXNzZXRDb2RlBAAAAA9hc3NldEFkZHJlc3NTdHIJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABB0AAAACBQAAAApmYWN0b3J5QWNjCQEAAAAga2V5RmFjdG9yeURlZm9BZGRyZXNzQnlBc3NldENvZGUAAAABBQAAAAlhc3NldENvZGUJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAFU5vIGNvbmZpZyBhdCBmYWN0b3J5PQkABCUAAAABBQAAAApmYWN0b3J5QWNjAgAAAAkgZm9yIGtleT0JAQAAACBrZXlGYWN0b3J5RGVmb0FkZHJlc3NCeUFzc2V0Q29kZQAAAAEFAAAACWFzc2V0Q29kZQkABRQAAAACBQAAAA9hc3NldEFkZHJlc3NTdHIJAQAAABxmYWN0b3J5UmVhZEFzc2V0Q2ZnQnlBZGRyZXNzAAAAAQUAAAAPYXNzZXRBZGRyZXNzU3RyAQAAACdmYWN0b3J5UmVhZE5leHRQb29sTWFrZXJUb0Rpc3RyaWJ1dGVGZWUAAAABAAAAD2Fzc2V0QWRkcmVzc1N0cgkBAAAAEUBleHRyTmF0aXZlKDEwNjIpAAAAAQIAAAAjM1BFczE5YnY0cVQ0R3o1aWRqY1d5bmtReXJIOXBzR2lwbXcBAAAAImZhY3RvcnlSZWFkRGVmb1N0YWtpbmdQYWNlbWFrZXJQdWIAAAAACQACWQAAAAEJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABB0AAAACBQAAAApmYWN0b3J5QWNjCQEAAAAha2V5RmFjdG9yeURlZm9TdGFraW5nUGFjZW1ha2VyUHViAAAAAAkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAVTm8gY29uZmlnIGF0IGZhY3Rvcnk9CQAEJQAAAAEFAAAACmZhY3RvcnlBY2MCAAAACSBmb3Iga2V5PQkBAAAAIWtleUZhY3RvcnlEZWZvU3Rha2luZ1BhY2VtYWtlclB1YgAAAAAAAAAAEElkeERlZm9Bc3NldENvZGUAAAAAAAAAAAEAAAAADklkeERlZm9Bc3NldElkAAAAAAAAAAACAAAAABJJZHhEZWZvQXNzZXRTdGF0dXMAAAAAAAAAAAMAAAAAEElkeFByaWNlRGVjaW1hbHMAAAAAAAAAAAQAAAAADklkeEJhc2VBc3NldElkAAAAAAAAAAAFAAAAABhJZHhPdmVyQ29sbGF0ZXJhbFBlcmNlbnQAAAAAAAAAAAYAAAAADklkeE1pbkluaXRQb29sAAAAAAAAAAAHAAAAABVJZHhQcmljZU9yYWNsZUFkZHJlc3MAAAAAAAAAAAgAAAAAEElkeE1pbkJ1eVBheW1lbnQAAAAAAAAAAAkAAAAAEUlkeE1pblNlbGxQYXltZW50AAAAAAAAAAAKAAAAABJJZHhCdXlMb2NrSW50ZXJ2YWwAAAAAAAAAAAsAAAAAE0lkeFNlbGxMb2NrSW50ZXJ2YWwAAAAAAAAAAAwAAAAAEElkeEJ1eUZlZVBlcmNlbnQAAAAAAAAAAA0AAAAAEUlkeFNlbGxGZWVQZXJjZW50AAAAAAAAAAAOAAAAABhJZHhQb29sUmVkZW1wdGlvblRpbWVvdXQAAAAAAAAAAA8AAAAAIUlkeFdlZWtlbmRzUHJpY2VDaGFuZ2VDb2VmZmljaWVudAAAAAAAAAAAEAAAAAAYSWR4QXNzZXRBY2NvdW50UHVibGljU3RyAAAAAAAAAAARAAAAACBJZHhBc3NldFN0YWtpbmdSZWZlcnJhbFB1YmxpY1N0cgAAAAAAAAAAEgAAAAAbSWR4Q3Jvc3NFeGNoYW5nZUNvZWZmaWNpZW50AAAAAAAAAAATAAAAACNJZHhTdGFraW5nTWluQW10RnJvbVNlbGxDb2VmZmljaWVudAAAAAAAAAAAFAAAAAAXSWR4UG9vbFN0YWJpbGl0eUZlZVBhcnQAAAAAAAAAABUAAAAAFUlkeFByb3RvY29sRmVlUGVyY2VudAAAAAAAAAAAFgAAAAAMdGhpc0NmZ0FycmF5CQEAAAAcZmFjdG9yeVJlYWRBc3NldENmZ0J5QWRkcmVzcwAAAAEJAAQlAAAAAQUAAAAEdGhpcwAAAAANZGVmb0Fzc2V0Q29kZQkAAZEAAAACBQAAAAx0aGlzQ2ZnQXJyYXkFAAAAEElkeERlZm9Bc3NldENvZGUAAAAADmRlZm9Bc3NldElkU3RyCQABkQAAAAIFAAAADHRoaXNDZmdBcnJheQUAAAAOSWR4RGVmb0Fzc2V0SWQAAAAAC2RlZm9Bc3NldElkCQACWQAAAAEFAAAADmRlZm9Bc3NldElkU3RyAAAAAA5wcmljZU9yYWNsZUFjYwkBAAAAEUBleHRyTmF0aXZlKDEwNjIpAAAAAQkAAZEAAAACBQAAAAx0aGlzQ2ZnQXJyYXkFAAAAFUlkeFByaWNlT3JhY2xlQWRkcmVzcwAAAAAVb3ZlckNvbGxhdGVyYWxQZXJjZW50CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAMdGhpc0NmZ0FycmF5BQAAABhJZHhPdmVyQ29sbGF0ZXJhbFBlcmNlbnQAAAAADmJhc2VBc3NldElkU3RyCQABkQAAAAIFAAAADHRoaXNDZmdBcnJheQUAAAAOSWR4QmFzZUFzc2V0SWQAAAAAC2Jhc2VBc3NldElkCQACWQAAAAEFAAAADmJhc2VBc3NldElkU3RyAAAAAA1wcmljZURlY2ltYWxzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAMdGhpc0NmZ0FycmF5BQAAABBJZHhQcmljZURlY2ltYWxzAAAAABFtaW5CYXNpY0J1eUFtb3VudAkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAADHRoaXNDZmdBcnJheQUAAAAQSWR4TWluQnV5UGF5bWVudAAAAAASbWluU3ludGhTZWxsQW1vdW50CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAMdGhpc0NmZ0FycmF5BQAAABFJZHhNaW5TZWxsUGF5bWVudAAAAAAPYnV5TG9ja0ludGVydmFsCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAMdGhpc0NmZ0FycmF5BQAAABJJZHhCdXlMb2NrSW50ZXJ2YWwAAAAAEHNlbGxMb2NrSW50ZXJ2YWwJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAAx0aGlzQ2ZnQXJyYXkFAAAAE0lkeFNlbGxMb2NrSW50ZXJ2YWwAAAAADWJ1eUZlZVBlcmNlbnQJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAAx0aGlzQ2ZnQXJyYXkFAAAAEElkeEJ1eUZlZVBlcmNlbnQAAAAADnNlbGxGZWVQZXJjZW50CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAMdGhpc0NmZ0FycmF5BQAAABFJZHhTZWxsRmVlUGVyY2VudAAAAAAed2Vla2VuZHNQcmljZUNoYW5nZUNvZWZmaWNpZW50CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAMdGhpc0NmZ0FycmF5BQAAACFJZHhXZWVrZW5kc1ByaWNlQ2hhbmdlQ29lZmZpY2llbnQAAAAAFWFzc2V0QWNjb3VudFB1YmxpY1N0cgkAAZEAAAACBQAAAAx0aGlzQ2ZnQXJyYXkFAAAAGElkeEFzc2V0QWNjb3VudFB1YmxpY1N0cgAAAAAdYXNzZXRTdGFraW5nUmVmZXJyYWxQdWJsaWNTdHIJAAGRAAAAAgUAAAAMdGhpc0NmZ0FycmF5BQAAACBJZHhBc3NldFN0YWtpbmdSZWZlcnJhbFB1YmxpY1N0cgAAAAAYY3Jvc3NFeGNoYW5nZUNvZWZmaWNpZW50CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAMdGhpc0NmZ0FycmF5BQAAABtJZHhDcm9zc0V4Y2hhbmdlQ29lZmZpY2llbnQAAAAAIHN0YWtpbmdNaW5BbXRGcm9tU2VsbENvZWZmaWNpZW50CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAMdGhpc0NmZ0FycmF5BQAAACNJZHhTdGFraW5nTWluQW10RnJvbVNlbGxDb2VmZmljaWVudAAAAAAUcG9vbFN0YWJpbGl0eUZlZVBhcnQJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAAx0aGlzQ2ZnQXJyYXkFAAAAF0lkeFBvb2xTdGFiaWxpdHlGZWVQYXJ0AAAAABJwcm90b2NvbEZlZVBlcmNlbnQJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAAx0aGlzQ2ZnQXJyYXkFAAAAFUlkeFByb3RvY29sRmVlUGVyY2VudAEAAAAMa2V5SXNCbG9ja2VkAAAAAAIAAAANJXNfX2lzQmxvY2tlZAEAAAARa2V5SXNNYXJrZXRPcGVuZWQAAAABAAAACWFzc2V0Q29kZQkAASwAAAACAgAAABYlcyVzX19pc01hcmtldE9wZW5lZF9fBQAAAAlhc3NldENvZGUAAAAACWlzQmxvY2tlZAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABBsAAAACBQAAAA5wcmljZU9yYWNsZUFjYwkBAAAADGtleUlzQmxvY2tlZAAAAAAHAAAAAA5pc01hcmtldE9wZW5lZAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABBsAAAACBQAAAA5wcmljZU9yYWNsZUFjYwkBAAAAEWtleUlzTWFya2V0T3BlbmVkAAAAAQUAAAANZGVmb0Fzc2V0Q29kZQcBAAAAE2NvbnRyb2xBY2NSZWFkUHJpY2UAAAABAAAACWFzc2V0Q29kZQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEGgAAAAIFAAAADnByaWNlT3JhY2xlQWNjCQEAAAAIa2V5UHJpY2UAAAABBQAAAAlhc3NldENvZGUJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAGE5vIHByaWNlIGF0IHByaWNlT3JhY2xlPQkABCUAAAABBQAAAA5wcmljZU9yYWNsZUFjYwIAAAAJIGZvciBrZXk9CQEAAAAIa2V5UHJpY2UAAAABBQAAAAlhc3NldENvZGUBAAAAGGNvbnRyb2xBY2NSZWFkTGFzdEhlaWdodAAAAAEAAAAJYXNzZXRDb2RlCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQaAAAAAgUAAAAOcHJpY2VPcmFjbGVBY2MJAQAAABRrZXlDb250cm9sTGFzdEhlaWdodAAAAAEFAAAACWFzc2V0Q29kZQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAdTm8gbGFzdEhlaWdodCBhdCBwcmljZU9yYWNsZT0JAAQlAAAAAQUAAAAOcHJpY2VPcmFjbGVBY2MCAAAACSBmb3Iga2V5PQkBAAAAFGtleUNvbnRyb2xMYXN0SGVpZ2h0AAAAAQUAAAAJYXNzZXRDb2RlAQAAABtjb250cm9sQWNjUmVhZEN1cnJJZHhPckZhaWwAAAAACQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQaAAAAAgUAAAAOcHJpY2VPcmFjbGVBY2MCAAAAB2N1cnJJZHgJAAEsAAAAAgIAAAAZTm8gY3VycklkeCBhdCBjb250cm9sQWNjPQkABCUAAAABBQAAAA5wcmljZU9yYWNsZUFjYwEAAAAXY29udHJvbEFjY1JlYWRJZHhIZWlnaHQAAAABAAAAA2lkeAQAAAAMaWR4SGVpZ2h0S2V5CQABLAAAAAICAAAACmlkeEhlaWdodF8JAAGkAAAAAQUAAAADaWR4CQEAAAALdmFsdWVPckVsc2UAAAACCQAEGgAAAAIFAAAADnByaWNlT3JhY2xlQWNjBQAAAAxpZHhIZWlnaHRLZXkAAAAAAAAAAAABAAAAG2NvbnRyb2xBY2NSZWFkUHJpY2VCeUhlaWdodAAAAAEAAAALcHJpY2VIZWlnaHQEAAAAEHByaWNlQnlIZWlnaHRLZXkJAAEsAAAAAgIAAAAGcHJpY2VfCQABpAAAAAEFAAAAC3ByaWNlSGVpZ2h0CQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQaAAAAAgUAAAAOcHJpY2VPcmFjbGVBY2MFAAAAEHByaWNlQnlIZWlnaHRLZXkJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAA05vIAUAAAAQcHJpY2VCeUhlaWdodEtleQIAAAAPIGF0IGNvbnRyb2xBY2M9CQAEJQAAAAEFAAAADnByaWNlT3JhY2xlQWNjAAAAAA9wcmljZUxhc3RIZWlnaHQJAQAAABhjb250cm9sQWNjUmVhZExhc3RIZWlnaHQAAAABBQAAAA1kZWZvQXNzZXRDb2RlAAAAABVpc0Jsb2NrZWRCeUxhc3RIZWlnaHQJAABmAAAAAgkAAGUAAAACBQAAAAZoZWlnaHQFAAAAD3ByaWNlTGFzdEhlaWdodAAAAAAAAAAABQEAAAAYa2V5RmVlc01hbmFnZXJBZGRyZXNzS2V5AAAAAAIAAAAUZmVlc19tYW5hZ2VyX2FkZHJlc3MAAAAAD25ldXRyaW5vTWFpbkFjYwkBAAAAEUBleHRyTmF0aXZlKDEwNjIpAAAAAQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEHQAAAAIFAAAACmZhY3RvcnlBY2MJAQAAACRrZXlGYWN0b3J5TmV1dHJpbm9Db250cmFjdEFkZHJlc3NLZXkAAAAACQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAABVObyBjb25maWcgYXQgZmFjdG9yeT0JAAQlAAAAAQUAAAAKZmFjdG9yeUFjYwIAAAAJIGZvciBrZXk9CQEAAAAka2V5RmFjdG9yeU5ldXRyaW5vQ29udHJhY3RBZGRyZXNzS2V5AAAAAAAAAAARZmVlTWFuYWdlckFkZHJlc3MJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABCYAAAABCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQdAAAAAgUAAAAPbmV1dHJpbm9NYWluQWNjCQEAAAAYa2V5RmVlc01hbmFnZXJBZGRyZXNzS2V5AAAAAAkAASwAAAACCQEAAAAYa2V5RmVlc01hbmFnZXJBZGRyZXNzS2V5AAAAAAIAAAARIGlzIG5vdCBzcGVjaWZpZWQJAAEsAAAAAgkBAAAAGGtleUZlZXNNYW5hZ2VyQWRkcmVzc0tleQAAAAACAAAAFyBpbnZhbGlkIGFkZHJlc3MgZm9ybWF0AAAAABVrZXlEZWZvU3Rha2luZ0FkZHJlc3MCAAAAJiVzJXNfX2NvbW1vbkNvbmZpZ19fZGVmb1N0YWtpbmdBZGRyZXNzAAAAABlrZXlOZXV0cmlub1N0YWtpbmdBZGRyZXNzAgAAAColcyVzX19jb21tb25Db25maWdfX25ldXRyaW5vU3Rha2luZ0FkZHJlc3MBAAAAGmtleURlZm9TdGFraW5nQXNzZXRCYWxhbmNlAAAAAQAAAAdhc3NldElkCQABLAAAAAICAAAAFiVzJXNfX3N0YWtpbmdCYWxhbmNlX18FAAAAB2Fzc2V0SWQBAAAAGWtleU5ldXRyaW5vU3Rha2luZ0JhbGFuY2UAAAAACQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAAAxycGRfYmFsYW5jZV8FAAAADmJhc2VBc3NldElkU3RyAgAAAAFfCQAEJQAAAAEFAAAABHRoaXMAAAAADmRlZm9TdGFraW5nQWNjCQEAAAATdmFsdWVPckVycm9yTWVzc2FnZQAAAAIJAAQmAAAAAQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEHQAAAAIFAAAACmZhY3RvcnlBY2MFAAAAFWtleURlZm9TdGFraW5nQWRkcmVzcwkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAXTm8gY29uZmlnIGF0IGZhY3RvcnlBY2MJAAQlAAAAAQUAAAAKZmFjdG9yeUFjYwIAAAAJIGZvciBrZXk9BQAAABVrZXlEZWZvU3Rha2luZ0FkZHJlc3MJAAEsAAAAAgIAAAAhYWRkcmVzcyBleHRyYWN0aW9uIGVycm9yIGZvciBrZXk9BQAAABVrZXlEZWZvU3Rha2luZ0FkZHJlc3MAAAAAEm5ldXRyaW5vU3Rha2luZ0FjYwkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEJgAAAAEJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABB0AAAACBQAAAApmYWN0b3J5QWNjBQAAABlrZXlOZXV0cmlub1N0YWtpbmdBZGRyZXNzCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAABdObyBjb25maWcgYXQgZmFjdG9yeUFjYwkABCUAAAABBQAAAApmYWN0b3J5QWNjAgAAAAkgZm9yIGtleT0FAAAAGWtleU5ldXRyaW5vU3Rha2luZ0FkZHJlc3MJAAEsAAAAAgIAAAAhYWRkcmVzcyBleHRyYWN0aW9uIGVycm9yIGZvciBrZXk9BQAAABlrZXlOZXV0cmlub1N0YWtpbmdBZGRyZXNzAQAAABlnZXRUaGlzRGVmb1N0YWtpbmdCYWxhbmNlAAAAAAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABBoAAAACBQAAAA5kZWZvU3Rha2luZ0FjYwkBAAAAGmtleURlZm9TdGFraW5nQXNzZXRCYWxhbmNlAAAAAQUAAAAOZGVmb0Fzc2V0SWRTdHIAAAAAAAAAAAABAAAAHWdldFRoaXNOZXV0cmlub1N0YWtpbmdCYWxhbmNlAAAAAAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABBoAAAACBQAAABJuZXV0cmlub1N0YWtpbmdBY2MJAQAAABlrZXlOZXV0cmlub1N0YWtpbmdCYWxhbmNlAAAAAAAAAAAAAAAAAAAAAAALdWNvbGxhdGVyYWwJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwkBAAAADmtleVVjb2xsYXRlcmFsAAAAAAAAAAAAAAAAAAAAAAAOYWNjdW11bGF0ZWRGZWUJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwkBAAAAEWtleUFjY3VtdWxhdGVkRmVlAAAAAAAAAAAAAAAAAAAAAAAWYWNjdW11bGF0ZWRQcm90b2NvbEZlZQkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABBoAAAACBQAAAAR0aGlzCQEAAAAZa2V5QWNjdW11bGF0ZWRQcm90b2NvbEZlZQAAAAAAAAAAAAAAAAAAAAAADmN1cnJQb29sQW1vdW50CQEAAAARQGV4dHJOYXRpdmUoMTA1MCkAAAACBQAAAApmYWN0b3J5QWNjCQEAAAAaa2V5RmFjdG9yeUFzc2V0Q3VycmVudFBvb2wAAAABBQAAAAR0aGlzAAAAAAtkZWJ0QXNzZXRJZAkAAlkAAAABCQEAAAAWZmFjdG9yeVJlYWREZWJ0QXNzZXRJZAAAAAAAAAAAFmRlYnRBc3NldEV0YWxvbkJhbGFuY2UJAQAAABFAZXh0ck5hdGl2ZSgxMDUwKQAAAAIFAAAACmZhY3RvcnlBY2MJAQAAACBrZXlGYWN0b3J5RGVidEFzc2V0RXRhbG9uQmFsYW5jZQAAAAAAAAAAEmxlbmRlZE9yRGVidEFtb3VudAkAAGUAAAACBQAAABZkZWJ0QXNzZXRFdGFsb25CYWxhbmNlCQAD8AAAAAIFAAAABHRoaXMFAAAAC2RlYnRBc3NldElkAAAAABdjdXJyZW50QmFzZUFzc2V0QmFsYW5jZQkAAGQAAAACCQAAZAAAAAIJAAPwAAAAAgUAAAAEdGhpcwUAAAALYmFzZUFzc2V0SWQJAQAAAB1nZXRUaGlzTmV1dHJpbm9TdGFraW5nQmFsYW5jZQAAAAAFAAAAEmxlbmRlZE9yRGVidEFtb3VudAAAAAAMY29udHJvbFByaWNlCQEAAAATY29udHJvbEFjY1JlYWRQcmljZQAAAAEJAAGRAAAAAgUAAAAMdGhpc0NmZ0FycmF5BQAAABBJZHhEZWZvQXNzZXRDb2RlAAAAAAhlbWlzc2lvbgkAAGUAAAACCAkBAAAABXZhbHVlAAAAAQkAA+wAAAABBQAAAAtkZWZvQXNzZXRJZAAAAAhxdWFudGl0eQkAA/AAAAACBQAAAAR0aGlzBQAAAAtkZWZvQXNzZXRJZAEAAAALZ2V0QnV5UHJpY2UAAAABAAAAC2NoYW5nZUNvZWZmAwUAAAAOaXNNYXJrZXRPcGVuZWQFAAAADGNvbnRyb2xQcmljZQkAAGsAAAADCQAAZQAAAAIFAAAADXByaWNlRGVjaW1hbHMFAAAAC2NoYW5nZUNvZWZmBQAAAAxjb250cm9sUHJpY2UFAAAADXByaWNlRGVjaW1hbHMBAAAAI2dldEJ1eUZlZUNvbnNpZGVyaW5nU3Rha2luZ1JlZmVycmFsAAAAAQAAAA5jYWxsZXJQdWI1OFN0cgMJAAAAAAAAAgUAAAAdYXNzZXRTdGFraW5nUmVmZXJyYWxQdWJsaWNTdHIFAAAADmNhbGxlclB1YjU4U3RyAAAAAAAAAAAABQAAAA1idXlGZWVQZXJjZW50AQAAAChnZXRQcm90b2NvbEZlZUNvbnNpZGVyaW5nU3Rha2luZ1JlZmVycmFsAAAAAQAAAA5jYWxsZXJQdWI1OFN0cgMJAAAAAAAAAgUAAAAdYXNzZXRTdGFraW5nUmVmZXJyYWxQdWJsaWNTdHIFAAAADmNhbGxlclB1YjU4U3RyAAAAAAAAAAAABQAAABJwcm90b2NvbEZlZVBlcmNlbnQBAAAAJWdldEJ1eVByaWNlQ29uc2lkZXJpbmdTdGFraW5nUmVmZXJyYWwAAAACAAAAC2NoYW5nZUNvZWZmAAAADmNhbGxlclB1YjU4U3RyAwkAAAAAAAACBQAAAB1hc3NldFN0YWtpbmdSZWZlcnJhbFB1YmxpY1N0cgUAAAAOY2FsbGVyUHViNThTdHIFAAAADGNvbnRyb2xQcmljZQkBAAAAC2dldEJ1eVByaWNlAAAAAQUAAAALY2hhbmdlQ29lZmYBAAAADGdldFNlbGxQcmljZQAAAAEAAAALY2hhbmdlQ29lZmYDBQAAAA5pc01hcmtldE9wZW5lZAUAAAAMY29udHJvbFByaWNlCQAAawAAAAMJAABkAAAAAgUAAAANcHJpY2VEZWNpbWFscwUAAAALY2hhbmdlQ29lZmYFAAAADGNvbnRyb2xQcmljZQUAAAANcHJpY2VEZWNpbWFscwEAAAAQZ2V0U2VsbFByaWNlRnJvbQAAAAIAAAAJZnJvbVByaWNlAAAAC2NoYW5nZUNvZWZmAwUAAAAOaXNNYXJrZXRPcGVuZWQFAAAACWZyb21QcmljZQkAAGsAAAADCQAAZAAAAAIFAAAADXByaWNlRGVjaW1hbHMFAAAAC2NoYW5nZUNvZWZmBQAAAAlmcm9tUHJpY2UFAAAADXByaWNlRGVjaW1hbHMBAAAAEGludGVybmFsQnV5QXNzZXQAAAAHAAAACnNlbGxlckFkZHIAAAAHc2VsbEFtdAAAAAtzZWxsQXNzZXRJZAAAAAptaW5TZWxsQW10AAAADWJ1eTJzZWxsUHJpY2UAAAARcG9vbE1ha2Vyc0ZlZVBhcnQAAAAPcHJvdG9jb2xGZWVQYXJ0BAAAABRkZWZvQXNzZXRBbW91bnRHcm9zcwkAAGsAAAADBQAAAAdzZWxsQW10BQAAAA1idXkyc2VsbFByaWNlBQAAAA1wcmljZURlY2ltYWxzBAAAABZzdGFiaWxpdHlGZWVEZWZvQW1vdW50CQAAawAAAAMFAAAAFHBvb2xTdGFiaWxpdHlGZWVQYXJ0BQAAABRkZWZvQXNzZXRBbW91bnRHcm9zcwUAAAANcHJpY2VEZWNpbWFscwQAAAAXcG9vbE1ha2Vyc0ZlZURlZm9BbW91bnQJAABrAAAAAwUAAAARcG9vbE1ha2Vyc0ZlZVBhcnQFAAAAFGRlZm9Bc3NldEFtb3VudEdyb3NzBQAAAA1wcmljZURlY2ltYWxzBAAAABVwcm90b2NvbEZlZURlZm9BbW91bnQJAABrAAAAAwUAAAAPcHJvdG9jb2xGZWVQYXJ0BQAAABRkZWZvQXNzZXRBbW91bnRHcm9zcwUAAAANcHJpY2VEZWNpbWFscwQAAAAPZGVmb0Fzc2V0QW1vdW50CQAAZQAAAAIJAABlAAAAAgkAAGUAAAACBQAAABRkZWZvQXNzZXRBbW91bnRHcm9zcwUAAAAWc3RhYmlsaXR5RmVlRGVmb0Ftb3VudAUAAAAXcG9vbE1ha2Vyc0ZlZURlZm9BbW91bnQFAAAAFXByb3RvY29sRmVlRGVmb0Ftb3VudAQAAAAYcmVxdWlyZWRCYXNpY0Fzc2V0QW1vdW50CQAAawAAAAMFAAAAFGRlZm9Bc3NldEFtb3VudEdyb3NzBQAAAA1wcmljZURlY2ltYWxzBQAAAA1idXkyc2VsbFByaWNlBAAAAAZjaGFuZ2UJAABlAAAAAgUAAAAHc2VsbEFtdAUAAAAYcmVxdWlyZWRCYXNpY0Fzc2V0QW1vdW50AwMJAABmAAAAAgUAAAAKbWluU2VsbEFtdAUAAAAHc2VsbEFtdAkBAAAAAiE9AAAAAgkABCUAAAABBQAAAApzZWxsZXJBZGRyCQAEJQAAAAEFAAAADmRlZm9TdGFraW5nQWNjBwkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAYaW1wb3NzaWJsZSB0byBpc3N1ZSBuZXcgBQAAAA1kZWZvQXNzZXRDb2RlAgAAAAo6IHBheW1lbnQ9CQABpAAAAAEFAAAAB3NlbGxBbXQCAAAAGGlzIGxlc3MgdGhlbiBtaW4gYW1vdW50PQkAAaQAAAABBQAAAAptaW5TZWxsQW10CQAFFAAAAAIJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAA5rZXlVY29sbGF0ZXJhbAAAAAAJAABkAAAAAgUAAAALdWNvbGxhdGVyYWwFAAAAGHJlcXVpcmVkQmFzaWNBc3NldEFtb3VudAkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAATa2V5QWNjb3VudE9wZXJhdGlvbgAAAAMFAAAABmhlaWdodAkABCUAAAABBQAAAApzZWxsZXJBZGRyAgAAAAhGSU5JU0hFRAkBAAAAFmFzc2V0RGF0YVN3YXBPcGVyYXRpb24AAAAIBQAAAAdzZWxsQW10CQACWAAAAAEFAAAAC3NlbGxBc3NldElkBQAAAAxjb250cm9sUHJpY2UFAAAAD2RlZm9Bc3NldEFtb3VudAkAAlgAAAABBQAAAAtkZWZvQXNzZXRJZAUAAAAUZGVmb0Fzc2V0QW1vdW50R3Jvc3MFAAAAF3Bvb2xNYWtlcnNGZWVEZWZvQW1vdW50BQAAABVwcm90b2NvbEZlZURlZm9BbW91bnQJAARMAAAAAgkBAAAAB1JlaXNzdWUAAAADBQAAAAtkZWZvQXNzZXRJZAkAAGQAAAACCQAAZAAAAAIFAAAAD2RlZm9Bc3NldEFtb3VudAUAAAAXcG9vbE1ha2Vyc0ZlZURlZm9BbW91bnQFAAAAFXByb3RvY29sRmVlRGVmb0Ftb3VudAYJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwUAAAAKc2VsbGVyQWRkcgUAAAAPZGVmb0Fzc2V0QW1vdW50BQAAAAtkZWZvQXNzZXRJZAkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADBQAAAApzZWxsZXJBZGRyBQAAAAZjaGFuZ2UFAAAAC3NlbGxBc3NldElkCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMJAQAAACdmYWN0b3J5UmVhZE5leHRQb29sTWFrZXJUb0Rpc3RyaWJ1dGVGZWUAAAABCQAEJQAAAAEFAAAABHRoaXMFAAAAF3Bvb2xNYWtlcnNGZWVEZWZvQW1vdW50BQAAAAtkZWZvQXNzZXRJZAkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADBQAAABFmZWVNYW5hZ2VyQWRkcmVzcwUAAAAVcHJvdG9jb2xGZWVEZWZvQW1vdW50BQAAAAtkZWZvQXNzZXRJZAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAEWtleUFjY3VtdWxhdGVkRmVlAAAAAAkAAGQAAAACBQAAAA5hY2N1bXVsYXRlZEZlZQUAAAAXcG9vbE1ha2Vyc0ZlZURlZm9BbW91bnQJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAABlrZXlBY2N1bXVsYXRlZFByb3RvY29sRmVlAAAAAAkAAGQAAAACBQAAABZhY2N1bXVsYXRlZFByb3RvY29sRmVlBQAAABVwcm90b2NvbEZlZURlZm9BbW91bnQFAAAAA25pbAUAAAAGY2hhbmdlAAAABgAAAAFpAQAAAAptbmdzdXJwbHVzAAAAAgAAAANhbXQAAAACdG8DCQEAAAACIT0AAAACBQAAAAR0aGlzCAUAAAABaQAAAAZjYWxsZXIJAAACAAAAAQIAAAAGZGVuaWVkCgEAAAAdZ2V0QXNzZXRDdXJycmVudFBvb2xBbW91bnRLZXkAAAABAAAADGFzc2V0QWRkcmVzcwkAASwAAAACCQABLAAAAAICAAAAEyVzJXMlc19fZGVmb0Fzc2V0X18FAAAADGFzc2V0QWRkcmVzcwIAAAANX19jdXJyZW50UG9vbAoBAAAAG2dldFBvb2xUb3RhbExvY2tlZEFtb3VudEtleQAAAAEAAAAMYXNzZXRBZGRyZXNzCQAEuQAAAAIJAARMAAAAAgIAAAAMJXMlcyVzX19wb29sCQAETAAAAAIFAAAADGFzc2V0QWRkcmVzcwkABEwAAAACAgAAABF0b3RhbExvY2tlZEFtb3VudAUAAAADbmlsAgAAAAJfXwQAAAANbXVsdGlwbGljYXRvcgAAAAAAAA9CQAQAAAANYXNzZXRFbWlzc2lvbgUAAAAIZW1pc3Npb24EAAAAGmFzc2V0T3ZlckNvbGxhdGVyYWxQZXJjZW50AAAAAAAAAAAABAAAAAxjdXJyZW50UHJpY2UFAAAADGNvbnRyb2xQcmljZQQAAAAfYXNzZXRFbWlzc2lvbk92ZXJjb2xsYXRlcmFsUmF0ZQkAAGsAAAADCQAAZAAAAAIFAAAADW11bHRpcGxpY2F0b3IFAAAAGmFzc2V0T3ZlckNvbGxhdGVyYWxQZXJjZW50BQAAAA1hc3NldEVtaXNzaW9uBQAAAA1tdWx0aXBsaWNhdG9yBAAAABl1c2RuTmVlZGVkVG9Db3ZlckVtaXNzaW9uCQAAawAAAAMFAAAAH2Fzc2V0RW1pc3Npb25PdmVyY29sbGF0ZXJhbFJhdGUFAAAADW11bHRpcGxpY2F0b3IFAAAADGN1cnJlbnRQcmljZQQAAAAWYXNzZXRVc2RuQmFsYW5jZUFtb3VudAkAA/AAAAACBQAAAAR0aGlzBQAAAAtiYXNlQXNzZXRJZAQAAAAVYXNzZXRVc2RuU3Rha2VkQW1vdW50CQEAAAAdZ2V0VGhpc05ldXRyaW5vU3Rha2luZ0JhbGFuY2UAAAAABAAAABhwb29sVG90YWxMb2NrZWRBbW91bnRLZXkJAQAAABtnZXRQb29sVG90YWxMb2NrZWRBbW91bnRLZXkAAAABCQAEJQAAAAEFAAAABHRoaXMEAAAADnBvb2xBY3R1YWxTaXplCQEAAAALdmFsdWVPckVsc2UAAAACCQAEGgAAAAIFAAAACmZhY3RvcnlBY2MJAQAAAB1nZXRBc3NldEN1cnJyZW50UG9vbEFtb3VudEtleQAAAAEJAAQlAAAAAQUAAAAEdGhpcwAAAAAAAAAAAAQAAAAPcG9vbFRvdGFsTG9ja2VkCQEAAAALdmFsdWVPckVsc2UAAAACCQAEGgAAAAIFAAAACmZhY3RvcnlBY2MFAAAAGHBvb2xUb3RhbExvY2tlZEFtb3VudEtleQAAAAAAAAAAAAQAAAAUYXNzZXRUb3RhbFVzZG5BbW91bnQJAABkAAAAAgkAAGUAAAACCQAAZAAAAAIFAAAAFWFzc2V0VXNkblN0YWtlZEFtb3VudAUAAAAWYXNzZXRVc2RuQmFsYW5jZUFtb3VudAUAAAAPcG9vbFRvdGFsTG9ja2VkBQAAABJsZW5kZWRPckRlYnRBbW91bnQEAAAADHVjb2xsYXRlcmFsRgkAAGUAAAACBQAAABRhc3NldFRvdGFsVXNkbkFtb3VudAUAAAAOcG9vbEFjdHVhbFNpemUEAAAAB3N1cnBsdXMJAABlAAAAAgUAAAAMdWNvbGxhdGVyYWxGBQAAABl1c2RuTmVlZGVkVG9Db3ZlckVtaXNzaW9uAwkAAGYAAAACBQAAAANhbXQFAAAAB3N1cnBsdXMJAAACAAAAAQIAAAAoUGFzc2VkIGFtdCBncmVhdGVyIHRoYW4gZXhpc3Rpbmcgc3VycGx1cwkAAAIAAAABCQABLAAAAAICAAAACHN1cnBsdXM9CQABpAAAAAEFAAAAB3N1cnBsdXMAAAABaQEAAAAIYnV5QXNzZXQAAAAABAAAAANwbXQJAQAAAAV2YWx1ZQAAAAEJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAEAAAACnBtdEFzc2V0SWQJAQAAAAV2YWx1ZQAAAAEIBQAAAANwbXQAAAAHYXNzZXRJZAQAAAAOY2FsbGVyUHViNThTdHIJAAJYAAAAAQgFAAAAAWkAAAAPY2FsbGVyUHVibGljS2V5AwUAAAAJaXNCbG9ja2VkCQAAAgAAAAECAAAAWmNvbnRyYWN0IGlzIGJsb2NrZWQgYnkgRU1FUkdFTkNZIFNIVVRET1dOIGFjdGlvbnMgdW50aWxsIHJlYWN0aXZhdGlvbiBieSBlbWVyZ2VuY3kgb3JhY2xlcwMJAQAAAAIhPQAAAAIFAAAACnBtdEFzc2V0SWQFAAAAC2Jhc2VBc3NldElkCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAANVBheW1lbnQgYXNzZXQgaWQgZG9lc24ndCBtYXRjaCBiYXNpYyBhc3NldDogZXhwZWN0ZWQ9CQACWAAAAAEFAAAAC2Jhc2VBc3NldElkAgAAAAggYWN0dWFsPQkAAlgAAAABBQAAAApwbXRBc3NldElkCAkBAAAAEGludGVybmFsQnV5QXNzZXQAAAAHCAUAAAABaQAAAAZjYWxsZXIIBQAAAANwbXQAAAAGYW1vdW50BQAAAApwbXRBc3NldElkBQAAABFtaW5CYXNpY0J1eUFtb3VudAkBAAAAJWdldEJ1eVByaWNlQ29uc2lkZXJpbmdTdGFraW5nUmVmZXJyYWwAAAACBQAAAB53ZWVrZW5kc1ByaWNlQ2hhbmdlQ29lZmZpY2llbnQFAAAADmNhbGxlclB1YjU4U3RyCQEAAAAjZ2V0QnV5RmVlQ29uc2lkZXJpbmdTdGFraW5nUmVmZXJyYWwAAAABBQAAAA5jYWxsZXJQdWI1OFN0cgkBAAAAKGdldFByb3RvY29sRmVlQ29uc2lkZXJpbmdTdGFraW5nUmVmZXJyYWwAAAABBQAAAA5jYWxsZXJQdWI1OFN0cgAAAAJfMQAAAAFpAQAAAAlzZWxsQXNzZXQAAAAABAAAAANwbXQJAQAAAAV2YWx1ZQAAAAEJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAEAAAACHBtdEFzc2V0CQEAAAAFdmFsdWUAAAABCAUAAAADcG10AAAAB2Fzc2V0SWQEAAAADWNhbGxlckFkZHJlc3MJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAAAlzZWxsUHJpY2UJAQAAAAxnZXRTZWxsUHJpY2UAAAABBQAAAB53ZWVrZW5kc1ByaWNlQ2hhbmdlQ29lZmZpY2llbnQDBQAAAAlpc0Jsb2NrZWQJAAACAAAAAQIAAABaY29udHJhY3QgaXMgYmxvY2tlZCBieSBFTUVSR0VOQ1kgU0hVVERPV04gYWN0aW9ucyB1bnRpbGwgcmVhY3RpdmF0aW9uIGJ5IGVtZXJnZW5jeSBvcmFjbGVzAwkBAAAAAiE9AAAAAgUAAAAIcG10QXNzZXQFAAAAC2RlZm9Bc3NldElkCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAI0ludmFsaWQgcGF5bWVudCBhc3NldCBpZDogZXhwZWN0ZWQ9CQACWAAAAAEFAAAAC2RlZm9Bc3NldElkAgAAAAggYWN0dWFsPQkAAlgAAAABBQAAAAhwbXRBc3NldAMJAABmAAAAAgUAAAASbWluU3ludGhTZWxsQW1vdW50CAUAAAADcG10AAAABmFtb3VudAkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAADpQYXltZW50IGFtb3VudCBsZXNzIHRoZW4gbWluaW5pbWFsIGFsbG93ZWQ6IHBheW1lbnRBbW91bnQ9CQABpAAAAAEIBQAAAANwbXQAAAAGYW1vdW50AgAAAAsgbWluQW1vdW50PQkAAaQAAAABBQAAABJtaW5TeW50aFNlbGxBbW91bnQEAAAAHWJhc2VBc3NldEFtb3VudE5vQmFsYW5jZUxpbWl0CQAAawAAAAMIBQAAAANwbXQAAAAGYW1vdW50BQAAAA1wcmljZURlY2ltYWxzBQAAAAlzZWxsUHJpY2UEAAAAGGJhc2VBc3NldEFtb3VudEF2YWlsYWJsZQMJAABmAAAAAgUAAAAdYmFzZUFzc2V0QW1vdW50Tm9CYWxhbmNlTGltaXQFAAAAF2N1cnJlbnRCYXNlQXNzZXRCYWxhbmNlBQAAABdjdXJyZW50QmFzZUFzc2V0QmFsYW5jZQUAAAAdYmFzZUFzc2V0QW1vdW50Tm9CYWxhbmNlTGltaXQEAAAAGHNvbGREZWZvQXNzZXRBbW91bnRHcm9zcwkAAGsAAAADBQAAABhiYXNlQXNzZXRBbW91bnRBdmFpbGFibGUFAAAACXNlbGxQcmljZQUAAAANcHJpY2VEZWNpbWFscwQAAAAGY2hhbmdlCQAAZQAAAAIIBQAAAANwbXQAAAAGYW1vdW50BQAAABhzb2xkRGVmb0Fzc2V0QW1vdW50R3Jvc3MEAAAAFnN0YWJpbGl0eUZlZURlZm9BbW91bnQJAABrAAAAAwAAAAAAAAAAAAUAAAAYc29sZERlZm9Bc3NldEFtb3VudEdyb3NzBQAAAA1wcmljZURlY2ltYWxzBAAAABdwb29sTWFrZXJzRmVlRGVmb0Ftb3VudAkAAGsAAAADAAAAAAAAAAAABQAAABhzb2xkRGVmb0Fzc2V0QW1vdW50R3Jvc3MFAAAADXByaWNlRGVjaW1hbHMEAAAAFXByb3RvY29sRmVlRGVmb0Ftb3VudAkAAGsAAAADAAAAAAAAAAAABQAAABhzb2xkRGVmb0Fzc2V0QW1vdW50R3Jvc3MFAAAADXByaWNlRGVjaW1hbHMEAAAAE3NvbGREZWZvQXNzZXRBbW91bnQJAABlAAAAAgkAAGUAAAACCQAAZQAAAAIFAAAAGHNvbGREZWZvQXNzZXRBbW91bnRHcm9zcwUAAAAWc3RhYmlsaXR5RmVlRGVmb0Ftb3VudAUAAAAXcG9vbE1ha2Vyc0ZlZURlZm9BbW91bnQFAAAAFXByb3RvY29sRmVlRGVmb0Ftb3VudAQAAAAVYmFzZUFzc2V0QW1vdW50VG9TZW5kCQAAawAAAAMFAAAAE3NvbGREZWZvQXNzZXRBbW91bnQFAAAADXByaWNlRGVjaW1hbHMFAAAACXNlbGxQcmljZQkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAADmtleVVjb2xsYXRlcmFsAAAAAAkAAGUAAAACBQAAAAt1Y29sbGF0ZXJhbAUAAAAVYmFzZUFzc2V0QW1vdW50VG9TZW5kCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABNrZXlBY2NvdW50T3BlcmF0aW9uAAAAAwUAAAAGaGVpZ2h0BQAAAA1jYWxsZXJBZGRyZXNzAgAAAAhGSU5JU0hFRAkBAAAAFmFzc2V0RGF0YVN3YXBPcGVyYXRpb24AAAAICAUAAAADcG10AAAABmFtb3VudAkAAlgAAAABBQAAAAhwbXRBc3NldAUAAAAJc2VsbFByaWNlBQAAABViYXNlQXNzZXRBbW91bnRUb1NlbmQFAAAADmJhc2VBc3NldElkU3RyBQAAABhzb2xkRGVmb0Fzc2V0QW1vdW50R3Jvc3MFAAAAF3Bvb2xNYWtlcnNGZWVEZWZvQW1vdW50BQAAABVwcm90b2NvbEZlZURlZm9BbW91bnQJAARMAAAAAgkBAAAABEJ1cm4AAAACBQAAAAtkZWZvQXNzZXRJZAkAAGQAAAACBQAAABNzb2xkRGVmb0Fzc2V0QW1vdW50BQAAABZzdGFiaWxpdHlGZWVEZWZvQW1vdW50CQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMIBQAAAAFpAAAABmNhbGxlcgUAAAAVYmFzZUFzc2V0QW1vdW50VG9TZW5kBQAAAAtiYXNlQXNzZXRJZAkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADCAUAAAABaQAAAAZjYWxsZXIFAAAABmNoYW5nZQUAAAALZGVmb0Fzc2V0SWQJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwUAAAARZmVlTWFuYWdlckFkZHJlc3MFAAAAFXByb3RvY29sRmVlRGVmb0Ftb3VudAUAAAALZGVmb0Fzc2V0SWQJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwkBAAAAJ2ZhY3RvcnlSZWFkTmV4dFBvb2xNYWtlclRvRGlzdHJpYnV0ZUZlZQAAAAEJAAQlAAAAAQUAAAAEdGhpcwUAAAAXcG9vbE1ha2Vyc0ZlZURlZm9BbW91bnQFAAAAC2RlZm9Bc3NldElkCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAARa2V5QWNjdW11bGF0ZWRGZWUAAAAACQAAZAAAAAIFAAAADmFjY3VtdWxhdGVkRmVlBQAAABdwb29sTWFrZXJzRmVlRGVmb0Ftb3VudAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAGWtleUFjY3VtdWxhdGVkUHJvdG9jb2xGZWUAAAAACQAAZAAAAAIFAAAAFmFjY3VtdWxhdGVkUHJvdG9jb2xGZWUFAAAAFXByb3RvY29sRmVlRGVmb0Ftb3VudAUAAAADbmlsAAAAAWkBAAAADWNyb3NzRXhjaGFuZ2UAAAACAAAAE2J1eUFzc2V0Q29kZUNvbmZpcm0AAAAUc2VsbEFzc2V0Q29kZUNvbmZpcm0JAAACAAAAAQkAASwAAAACCQABLAAAAAICAAAAZ0RlRm8gYnV5IGFuZCBjcm9zc0V4Y2hhbmdlIG9wZXJhdGlvbnMgYXJlIHN0b3BwZWQgZHVlIHRvIGZ1bmRhbWVudGFsIGNoYW5nZXMgaW4gdGhlIE5ldXRyaW5vIHByb3RvY29sLiACAAAAR1NlbGwgYW5kIHJlZGVlbUZyb21Qb29sIG9wZXJhdGlvbnMgd2lsbCByZW1haW4gYXZhaWxhYmxlIGFsbCB0aGUgdGltZSwgAgAAAENzbyB0aGF0IGV2ZXJ5b25lIGNhbiBzd2FwIERlRm8gdG9rZW5zIHRvIHRoZSBiYXNlIHVuZGVybHlpbmcgdG9rZW4uAAAAAWkBAAAADnJlYmFsYW5jZURlYnRzAAAAAAQAAAAIZGVidFBtdDAJAQAAAAV2YWx1ZQAAAAEJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAEAAAADWRlYnRQbXRBc3NldDAJAQAAAAV2YWx1ZQAAAAEIBQAAAAhkZWJ0UG10MAAAAAdhc3NldElkBAAAAAhiYXNlUG10MQkBAAAABXZhbHVlAAAAAQkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAQQAAAANYmFzZVBtdEFzc2V0MQkBAAAABXZhbHVlAAAAAQgFAAAACGJhc2VQbXQxAAAAB2Fzc2V0SWQEAAAADWRlYnRvckFkZHJlc3MJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAAA5kZWJ0b3JBc3NldENmZwkBAAAAHGZhY3RvcnlSZWFkQXNzZXRDZmdCeUFkZHJlc3MAAAABBQAAAA1kZWJ0b3JBZGRyZXNzBAAAAA9kZWJ0b3JBc3NldENvZGUJAAGRAAAAAgUAAAAOZGVidG9yQXNzZXRDZmcFAAAAEElkeERlZm9Bc3NldENvZGUEAAAAGmxlbmRlZEFtb3VudEJ5QXNzZXRDb2RlS2V5CQEAAAAaa2V5TGVuZGVkQW1vdW50QnlBc3NldENvZGUAAAABBQAAAA9kZWJ0b3JBc3NldENvZGUEAAAACWxlbmRlZEFtdAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEGgAAAAIFAAAABHRoaXMFAAAAGmxlbmRlZEFtb3VudEJ5QXNzZXRDb2RlS2V5CQABLAAAAAICAAAADU5vIGRlYnRzIGZvciAFAAAAD2RlYnRvckFzc2V0Q29kZQMJAQAAAAIhPQAAAAIJAAGQAAAAAQgFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAIJAAACAAAAAQIAAAAhZXhhY3QgMiBwYXltZW50cyBtdXN0IGJlIGF0dGFjaGVkAwUAAAAJaXNCbG9ja2VkCQAAAgAAAAECAAAAWmNvbnRyYWN0IGlzIGJsb2NrZWQgYnkgRU1FUkdFTkNZIFNIVVRET1dOIGFjdGlvbnMgdW50aWxsIHJlYWN0aXZhdGlvbiBieSBlbWVyZ2VuY3kgb3JhY2xlcwMJAQAAAAIhPQAAAAIFAAAAC2RlYnRBc3NldElkBQAAAA1kZWJ0UG10QXNzZXQwCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAANGludmFsaWQgZGVidCBhc3NldCBpZCBpbiB0aGUgZmlyc3QgcGF5bWV0OiBleHBlY3RlZD0JAAJYAAAAAQUAAAALZGVidEFzc2V0SWQCAAAACCBhY3R1YWw9CQACWAAAAAEFAAAADWRlYnRQbXRBc3NldDADCQEAAAACIT0AAAACBQAAAAtiYXNlQXNzZXRJZAUAAAANYmFzZVBtdEFzc2V0MQkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAADZpbnZhbGlkIGJhc2UgYXNzZXQgaWQgaW4gdGhlIHNlY29uZCBwYXltZW50OiBleHBlY3RlZD0JAAJYAAAAAQUAAAALYmFzZUFzc2V0SWQCAAAACCBhY3R1YWw9CQACWAAAAAEFAAAADWJhc2VQbXRBc3NldDEDCQEAAAACIT0AAAACCAUAAAAIZGVidFBtdDAAAAAGYW1vdW50CAUAAAAIYmFzZVBtdDEAAAAGYW1vdW50CQAAAgAAAAECAAAAP2ZpcnN0IHBheW1lbnQgYW1vdW50IGRvZXNuJ3QgbWF0Y2ggdG8gdGhlIHNlY29uZCBwYXltZW50IGFtb3VudAMJAABnAAAAAgAAAAAAAAAAAAUAAAAJbGVuZGVkQW10CQAAAgAAAAEJAAEsAAAAAgIAAAAnbGVuZGVkQW10IGlzIGxlc3MgdGhlbiB6ZXJvOiBsZW5kZWRBbXQ9CQABpAAAAAEFAAAACWxlbmRlZEFtdAMJAABnAAAAAgkAAGgAAAACAAAAAAAAAABkBQAAAA1wcmljZURlY2ltYWxzCAUAAAAIZGVidFBtdDAAAAAGYW1vdW50CQAAAgAAAAEJAAEsAAAAAgIAAAA3YXR0YWNoZWQgcGF5bWVudCBtdXN0IGJlIGdyZWF0ZXIgdGhlbiAxMDA6IHBtdDAuYW1vdW50PQkAAaQAAAABCAUAAAAIZGVidFBtdDAAAAAGYW1vdW50AwkAAGYAAAACCAUAAAAIZGVidFBtdDAAAAAGYW1vdW50BQAAAAlsZW5kZWRBbXQJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAA0YXR0YWNoZWQgcGF5bWVudCBpcyBncmF0ZXIgdGhhbiByZXF1aXJlZDogcG10QW1vdW50PQkAAaQAAAABCAUAAAAIZGVidFBtdDAAAAAGYW1vdW50AgAAAAsgbGVuZGVkQW10PQkAAaQAAAABBQAAAAlsZW5kZWRBbXQEAAAAFnRvdGFsTGVuZGVkQXRPdGhlckFjY3MJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwkBAAAAGWtleVRvdGFsTGVuZGVkQXRPdGhlckFjY3MAAAAAAAAAAAAAAAAABAAAAA5sZW5kZWRBbXRBZnRlcgkAAGUAAAACBQAAAAlsZW5kZWRBbXQIBQAAAAhkZWJ0UG10MAAAAAZhbW91bnQJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAGmxlbmRlZEFtb3VudEJ5QXNzZXRDb2RlS2V5BQAAAA5sZW5kZWRBbXRBZnRlcgkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAGWtleVRvdGFsTGVuZGVkQXRPdGhlckFjY3MAAAAACQAAZQAAAAIFAAAAFnRvdGFsTGVuZGVkQXRPdGhlckFjY3MIBQAAAAhkZWJ0UG10MAAAAAZhbW91bnQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkAASwAAAACAgAAABYlcyVzX19yZWJhbGFuY2VUcmFjZV9fCQACWAAAAAEIBQAAAAFpAAAADXRyYW5zYWN0aW9uSWQJAQAAABdhc3NldERhdGFSZWJhbGFuY2VUcmFjZQAAAAUFAAAAD2RlYnRvckFzc2V0Q29kZQUAAAAIZGVidFBtdDAFAAAACGJhc2VQbXQxBQAAAAlsZW5kZWRBbXQFAAAADmxlbmRlZEFtdEFmdGVyBQAAAANuaWwAAAABaQEAAAAUZnVsZmlsbFJlZGVlbVJlcXVlc3QAAAABAAAAEHBvb2xNYWtlckFkZHJlc3MEAAAADnRoaXNBZGRyZXNzU3RyCQAEJQAAAAEFAAAABHRoaXMEAAAAGHBvb2xNYWtlclVubG9ja0hlaWdodEtleQkBAAAAH2tleUZhY3RvcnlQb29sTWFrZXJVbmxvY2tIZWlnaHQAAAACBQAAAA50aGlzQWRkcmVzc1N0cgUAAAAQcG9vbE1ha2VyQWRkcmVzcwQAAAAVcG9vbE1ha2VyVW5sb2NrSGVpZ2h0CQEAAAALdmFsdWVPckVsc2UAAAACCQAEGgAAAAIFAAAACmZhY3RvcnlBY2MFAAAAGHBvb2xNYWtlclVubG9ja0hlaWdodEtleQAAAAAAAAAAAAMJAABnAAAAAgAAAAAAAAAAAAUAAAAVcG9vbE1ha2VyVW5sb2NrSGVpZ2h0CQAAAgAAAAECAAAAH0FsbCBsaXF1aWRpdHkgcmVxdWVzdCBmdWxmaWxsZWQEAAAAHHBvb2xNYWtlckxpcXVpZGl0eVJlcXVlc3RLZXkJAQAAACNrZXlGYWN0b3J5UG9vbE1ha2VyTGlxdWlkaXR5UmVxdWVzdAAAAAMFAAAADnRoaXNBZGRyZXNzU3RyBQAAABBwb29sTWFrZXJBZGRyZXNzBQAAABVwb29sTWFrZXJVbmxvY2tIZWlnaHQEAAAAH3Bvb2xNYWtlckxpcXVpZGl0eVJlcXVlc3RBbW91bnQJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABBoAAAACBQAAAApmYWN0b3J5QWNjBQAAABxwb29sTWFrZXJMaXF1aWRpdHlSZXF1ZXN0S2V5AgAAADFFbXB0eSBwb29sTWFrZXJMaXF1aWRpdHlSZXF1ZXN0S2V5IGF0IGZhY3RvcnkgYWNjAwkBAAAACWlzRGVmaW5lZAAAAAEJAAQaAAAAAgUAAAAEdGhpcwUAAAAccG9vbE1ha2VyTGlxdWlkaXR5UmVxdWVzdEtleQkAAAIAAAABAgAAACxMaXF1aWRpdHkgcmVxdWVzdCBoYXMgYmVlbiBhbHJlYWR5IGZ1bGZpbGxlZAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAAccG9vbE1ha2VyTGlxdWlkaXR5UmVxdWVzdEtleQUAAAAfcG9vbE1ha2VyTGlxdWlkaXR5UmVxdWVzdEFtb3VudAkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADBQAAAApmYWN0b3J5QWNjBQAAAB9wb29sTWFrZXJMaXF1aWRpdHlSZXF1ZXN0QW1vdW50BQAAAAtiYXNlQXNzZXRJZAUAAAADbmlsAAAAAQAAAAJ0eAEAAAAGdmVyaWZ5AAAAAAQAAAAHJG1hdGNoMAUAAAACdHgDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAF0ludm9rZVNjcmlwdFRyYW5zYWN0aW9uBAAAAANpbnYFAAAAByRtYXRjaDADCQAAZgAAAAIIBQAAAANpbnYAAAADZmVlCQAAaAAAAAIAAAAAAAAAA4QAAAAAAAAAA+gJAAACAAAAAQkAASwAAAACAgAAAChmZWUgYW1vdW50IGlzIGdyZWF0ZXIgdGhhbiBtYXggYWxsb3dlZDogCQABpAAAAAEIBQAAAANpbnYAAAADZmVlAwkBAAAACWlzRGVmaW5lZAAAAAEIBQAAAANpbnYAAAAKZmVlQXNzZXRJZAkAAAIAAAABAgAAACNvbmx5IFdhdmVzIGlzIGFsbG93ZWQgYXMgZmVlQXNzZXRJZAMJAAAAAAAAAggFAAAAA2ludgAAAAhmdW5jdGlvbgIAAAAOcmViYWxhbmNlRGVidHMEAAAADmludkRhcHBBZGRyZXNzCQAEJQAAAAEJAAQkAAAAAQgFAAAAA2ludgAAAARkQXBwAwkBAAAAAiE9AAAAAgkAAZEAAAACCQEAAAAcZmFjdG9yeVJlYWRBc3NldENmZ0J5QWRkcmVzcwAAAAEFAAAADmludkRhcHBBZGRyZXNzBQAAABJJZHhEZWZvQXNzZXRTdGF0dXMCAAAABklTU1VFRAkAAAIAAAABAgAAABlvbmx5IGRlZm8gZGFwcCBpcyBhbGxvd2VkAwkAAAAAAAACBQAAAA5pbnZEYXBwQWRkcmVzcwkABCUAAAABBQAAAAR0aGlzCQAAAgAAAAECAAAAJWltcG9zc2libGUgdG8gY2FsbCBzZWxmIHJlYmVhbG5jZURlYnQGAwMDCQAAAAAAAAIIBQAAAANpbnYAAAAIZnVuY3Rpb24CAAAADGxvY2tOZXV0cmlubwYJAAAAAAAAAggFAAAAA2ludgAAAAhmdW5jdGlvbgIAAAAObG9ja05ldXRyaW5vU1AGCQAAAAAAAAIIBQAAAANpbnYAAAAIZnVuY3Rpb24CAAAADnVubG9ja05ldXRyaW5vAwkBAAAAAiE9AAAAAgkABCUAAAABBQAAABJuZXV0cmlub1N0YWtpbmdBY2MJAAQlAAAAAQkABCQAAAABCAUAAAADaW52AAAABGRBcHAJAAACAAAAAQIAAAAlaW52YWxpZCBuZXV0cmlubyBzdGFraW5nIGRhcHAgYWRkcmVzcwkAAfQAAAADCAUAAAACdHgAAAAJYm9keUJ5dGVzCQABkQAAAAIIBQAAAAJ0eAAAAAZwcm9vZnMAAAAAAAAAAAAJAQAAACJmYWN0b3J5UmVhZERlZm9TdGFraW5nUGFjZW1ha2VyUHViAAAAAAkAAAIAAAABAgAAACNOb3QgYWxsb3dlZCBpbnZvY2F0aW9uIG1ldGhvZCBjYWxscwkACcgAAAADCAUAAAACdHgAAAAJYm9keUJ5dGVzCQABkQAAAAIIBQAAAAJ0eAAAAAZwcm9vZnMAAAAAAAAAAAAJAAJZAAAAAQIAAAAsQXRITUxqcjJUUHk4YmRwc00xcmp1c0N5bzdnaHYzY0NYZEVQWnE0UnRpMmFvEhcW",
    "height": 3889038,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8CjH9tEq4AGy1J9DL5b5ett34v1WWtRtJphwbEuRZaGn
Next: CcxWfL7rSS7SuFy52QSPpf8n8zDNM7qTERH6kdNuj1rR

Diff: 

OldNewDifferences
324324 
325325 
326326 @Callable(i)
327+func mngsurplus (amt,to) = if ((this != i.caller))
328+    then throw("denied")
329+    else {
330+        func getAssetCurrrentPoolAmountKey (assetAddress) =         (("%s%s%s__defoAsset__" + assetAddress) + "__currentPool")
331+
332+        func getPoolTotalLockedAmountKey (assetAddress) =         makeString(["%s%s%s__pool", assetAddress, "totalLockedAmount"], "__")
333+
334+        let multiplicator = 1000000
335+        let assetEmission = emission
336+        let assetOverCollateralPercent = 0
337+        let currentPrice = controlPrice
338+        let assetEmissionOvercollateralRate = fraction((multiplicator + assetOverCollateralPercent), assetEmission, multiplicator)
339+        let usdnNeededToCoverEmission = fraction(assetEmissionOvercollateralRate, multiplicator, currentPrice)
340+        let assetUsdnBalanceAmount = assetBalance(this, baseAssetId)
341+        let assetUsdnStakedAmount = getThisNeutrinoStakingBalance()
342+        let poolTotalLockedAmountKey = getPoolTotalLockedAmountKey(toString(this))
343+        let poolActualSize = valueOrElse(getInteger(factoryAcc, getAssetCurrrentPoolAmountKey(toString(this))), 0)
344+        let poolTotalLocked = valueOrElse(getInteger(factoryAcc, poolTotalLockedAmountKey), 0)
345+        let assetTotalUsdnAmount = (((assetUsdnStakedAmount + assetUsdnBalanceAmount) - poolTotalLocked) + lendedOrDebtAmount)
346+        let ucollateralF = (assetTotalUsdnAmount - poolActualSize)
347+        let surplus = (ucollateralF - usdnNeededToCoverEmission)
348+        if ((amt > surplus))
349+            then throw("Passed amt greater than existing surplus")
350+            else throw(("surplus=" + toString(surplus)))
351+        }
352+
353+
354+
355+@Callable(i)
327356 func buyAsset () = {
328357     let pmt = value(i.payments[0])
329358     let pmtAssetId = value(pmt.assetId)

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 4 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 func keyAccumulatedFee () = "%s__accumulatedFee"
55 
66 
77 func keyAccumulatedProtocolFee () = "%s__accumulatedProtocolFee"
88 
99 
1010 func keyUcollateral () = "%s__ucollateral"
1111 
1212 
1313 func keyTotalLendedAtOtherAccs () = "%s__totalLendedAtOtherAccs"
1414 
1515 
1616 func keyAssetLockedTotal (assetId) = ("%s%s__assetLockedTotal__" + assetId)
1717 
1818 
1919 func keyAccountOperation (unlockHeight,address,status) = ((((("%s%s%d%s__defoAssetOperation__" + address) + "__") + toString(unlockHeight)) + "__") + status)
2020 
2121 
2222 func keyFactory () = "%s__factory"
2323 
2424 
2525 func keyLendedAmountByAssetCode (assetCode) = ("%s%s__lendedBaseAssetAmount__" + assetCode)
2626 
2727 
2828 func keyPrice (assetCode) = ("%s%s__price__" + assetCode)
2929 
3030 
3131 func keyControlLastHeight (assetCode) = ("%s%s__lastHeight__" + assetCode)
3232 
3333 
3434 let IdxOperationAmountIn = 1
3535 
3636 let IdxOperationAssetIn = 2
3737 
3838 let IdxOperationPrice = 3
3939 
4040 let IdxOperationAmountOut = 4
4141 
4242 let IdxOperationAssetOut = 5
4343 
4444 func assetDataSwapOperation (amountIn,assetIn,price,amountOut,assetOut,bruttoAmount,feeAmount,protocolFeeAmount) = makeString(["%d%s%d%s%d%d%d%d", toString(amountIn), assetIn, toString(amountOut), assetOut, toString(price), toString(bruttoAmount), toString(feeAmount), toString(protocolFeeAmount)], "__")
4545 
4646 
4747 func assetDataRebalanceTrace (debtorAssetCode,debtPmt,basePmt,lendedAmtBefore,lendedAmtAfter) = makeString(["%s%s%d%s%d%d%d", debtorAssetCode, toBase58String(value(debtPmt.assetId)), toString(debtPmt.amount), toBase58String(value(basePmt.assetId)), toString(basePmt.amount), toString(lendedAmtBefore), toString(lendedAmtAfter)], "__")
4848 
4949 
5050 func assetReadSwapDataArrayOrFail (accOperationKey) = {
5151     let accOperationDataStr = valueOrErrorMessage(getString(this, accOperationKey), ("There is no request for passed arguments: " + accOperationKey))
5252     split(accOperationDataStr, "__")
5353     }
5454 
5555 
5656 let nullInt = -1
5757 
5858 let nullStr = "NULL"
5959 
6060 let factoryAcc = addressFromStringValue(valueOrErrorMessage(getString(this, keyFactory()), ((("No config at this=" + toString(this)) + " for key=") + keyFactory())))
6161 
6262 func keyFactoryNeutrinoContractAddressKey () = "%s%s__commonConfig__neutrinoContractAddress"
6363 
6464 
6565 func keyFactoryDebtAssetId () = "%s%s__commonConfig__debtAssetId"
6666 
6767 
6868 func keyFactoryDebtAssetEtalonBalance () = "%s%s__commonConfig__debtAssetEtalonBalance"
6969 
7070 
7171 func keyFactoryAssetCfg (assetAddressStr) = (("%s%s%s__defoAsset__" + assetAddressStr) + "__config")
7272 
7373 
7474 func keyFactoryAssetCurrentPool (assetAccAddress) = (("%s%s%s__defoAsset__" + toString(assetAccAddress)) + "__currentPool")
7575 
7676 
7777 func keyFactoryDefoAddressByAssetCode (assetCode) = (("%s%s%s__defoAsset__" + assetCode) + "__addressByAssetCode")
7878 
7979 
8080 func keyFactoryAssetPoolMakers (assetAddress) = (("%s%s%s__defoAsset__" + assetAddress) + "__poolMakers")
8181 
8282 
8383 func keyFactoryDefoStakingPacemakerPub () = "%s%s__commonConfig__defoStakingPacemakerPub"
8484 
8585 
8686 func keyFactoryPoolMakerLiquidityRequest (assetAddress,poolMakerAddress,h) = makeString(["%s%s%s%d%s__pool", assetAddress, poolMakerAddress, toString(h), "liquidityRequest"], "__")
8787 
8888 
8989 func keyFactoryPoolMakerUnlockHeight (assetAddress,poolMakerAddress) = makeString(["%s%s%s%s__pool", assetAddress, poolMakerAddress, "unlockHeight"], "__")
9090 
9191 
9292 func factoryReadDebtAssetId () = valueOrErrorMessage(getString(factoryAcc, keyFactoryDebtAssetId()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDebtAssetId()))
9393 
9494 
9595 func factoryReadAssetCfgByAddress (assetAddressStr) = split(valueOrErrorMessage(getString(factoryAcc, keyFactoryAssetCfg(assetAddressStr)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryAssetCfg(assetAddressStr))), "__")
9696 
9797 
9898 func factoryReadAssetCfgByCode (assetCode) = {
9999     let assetAddressStr = valueOrErrorMessage(getString(factoryAcc, keyFactoryDefoAddressByAssetCode(assetCode)), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDefoAddressByAssetCode(assetCode)))
100100     $Tuple2(assetAddressStr, factoryReadAssetCfgByAddress(assetAddressStr))
101101     }
102102 
103103 
104104 func factoryReadNextPoolMakerToDistributeFee (assetAddressStr) = addressFromStringValue("3PEs19bv4qT4Gz5idjcWynkQyrH9psGipmw")
105105 
106106 
107107 func factoryReadDefoStakingPacemakerPub () = fromBase58String(valueOrErrorMessage(getString(factoryAcc, keyFactoryDefoStakingPacemakerPub()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryDefoStakingPacemakerPub())))
108108 
109109 
110110 let IdxDefoAssetCode = 1
111111 
112112 let IdxDefoAssetId = 2
113113 
114114 let IdxDefoAssetStatus = 3
115115 
116116 let IdxPriceDecimals = 4
117117 
118118 let IdxBaseAssetId = 5
119119 
120120 let IdxOverCollateralPercent = 6
121121 
122122 let IdxMinInitPool = 7
123123 
124124 let IdxPriceOracleAddress = 8
125125 
126126 let IdxMinBuyPayment = 9
127127 
128128 let IdxMinSellPayment = 10
129129 
130130 let IdxBuyLockInterval = 11
131131 
132132 let IdxSellLockInterval = 12
133133 
134134 let IdxBuyFeePercent = 13
135135 
136136 let IdxSellFeePercent = 14
137137 
138138 let IdxPoolRedemptionTimeout = 15
139139 
140140 let IdxWeekendsPriceChangeCoefficient = 16
141141 
142142 let IdxAssetAccountPublicStr = 17
143143 
144144 let IdxAssetStakingReferralPublicStr = 18
145145 
146146 let IdxCrossExchangeCoefficient = 19
147147 
148148 let IdxStakingMinAmtFromSellCoefficient = 20
149149 
150150 let IdxPoolStabilityFeePart = 21
151151 
152152 let IdxProtocolFeePercent = 22
153153 
154154 let thisCfgArray = factoryReadAssetCfgByAddress(toString(this))
155155 
156156 let defoAssetCode = thisCfgArray[IdxDefoAssetCode]
157157 
158158 let defoAssetIdStr = thisCfgArray[IdxDefoAssetId]
159159 
160160 let defoAssetId = fromBase58String(defoAssetIdStr)
161161 
162162 let priceOracleAcc = addressFromStringValue(thisCfgArray[IdxPriceOracleAddress])
163163 
164164 let overCollateralPercent = parseIntValue(thisCfgArray[IdxOverCollateralPercent])
165165 
166166 let baseAssetIdStr = thisCfgArray[IdxBaseAssetId]
167167 
168168 let baseAssetId = fromBase58String(baseAssetIdStr)
169169 
170170 let priceDecimals = parseIntValue(thisCfgArray[IdxPriceDecimals])
171171 
172172 let minBasicBuyAmount = parseIntValue(thisCfgArray[IdxMinBuyPayment])
173173 
174174 let minSynthSellAmount = parseIntValue(thisCfgArray[IdxMinSellPayment])
175175 
176176 let buyLockInterval = parseIntValue(thisCfgArray[IdxBuyLockInterval])
177177 
178178 let sellLockInterval = parseIntValue(thisCfgArray[IdxSellLockInterval])
179179 
180180 let buyFeePercent = parseIntValue(thisCfgArray[IdxBuyFeePercent])
181181 
182182 let sellFeePercent = parseIntValue(thisCfgArray[IdxSellFeePercent])
183183 
184184 let weekendsPriceChangeCoefficient = parseIntValue(thisCfgArray[IdxWeekendsPriceChangeCoefficient])
185185 
186186 let assetAccountPublicStr = thisCfgArray[IdxAssetAccountPublicStr]
187187 
188188 let assetStakingReferralPublicStr = thisCfgArray[IdxAssetStakingReferralPublicStr]
189189 
190190 let crossExchangeCoefficient = parseIntValue(thisCfgArray[IdxCrossExchangeCoefficient])
191191 
192192 let stakingMinAmtFromSellCoefficient = parseIntValue(thisCfgArray[IdxStakingMinAmtFromSellCoefficient])
193193 
194194 let poolStabilityFeePart = parseIntValue(thisCfgArray[IdxPoolStabilityFeePart])
195195 
196196 let protocolFeePercent = parseIntValue(thisCfgArray[IdxProtocolFeePercent])
197197 
198198 func keyIsBlocked () = "%s__isBlocked"
199199 
200200 
201201 func keyIsMarketOpened (assetCode) = ("%s%s__isMarketOpened__" + assetCode)
202202 
203203 
204204 let isBlocked = valueOrElse(getBoolean(priceOracleAcc, keyIsBlocked()), false)
205205 
206206 let isMarketOpened = valueOrElse(getBoolean(priceOracleAcc, keyIsMarketOpened(defoAssetCode)), false)
207207 
208208 func controlAccReadPrice (assetCode) = valueOrErrorMessage(getInteger(priceOracleAcc, keyPrice(assetCode)), ((("No price at priceOracle=" + toString(priceOracleAcc)) + " for key=") + keyPrice(assetCode)))
209209 
210210 
211211 func controlAccReadLastHeight (assetCode) = valueOrErrorMessage(getInteger(priceOracleAcc, keyControlLastHeight(assetCode)), ((("No lastHeight at priceOracle=" + toString(priceOracleAcc)) + " for key=") + keyControlLastHeight(assetCode)))
212212 
213213 
214214 func controlAccReadCurrIdxOrFail () = valueOrErrorMessage(getInteger(priceOracleAcc, "currIdx"), ("No currIdx at controlAcc=" + toString(priceOracleAcc)))
215215 
216216 
217217 func controlAccReadIdxHeight (idx) = {
218218     let idxHeightKey = ("idxHeight_" + toString(idx))
219219     valueOrElse(getInteger(priceOracleAcc, idxHeightKey), 0)
220220     }
221221 
222222 
223223 func controlAccReadPriceByHeight (priceHeight) = {
224224     let priceByHeightKey = ("price_" + toString(priceHeight))
225225     valueOrErrorMessage(getInteger(priceOracleAcc, priceByHeightKey), ((("No " + priceByHeightKey) + " at controlAcc=") + toString(priceOracleAcc)))
226226     }
227227 
228228 
229229 let priceLastHeight = controlAccReadLastHeight(defoAssetCode)
230230 
231231 let isBlockedByLastHeight = ((height - priceLastHeight) > 5)
232232 
233233 func keyFeesManagerAddressKey () = "fees_manager_address"
234234 
235235 
236236 let neutrinoMainAcc = addressFromStringValue(valueOrErrorMessage(getString(factoryAcc, keyFactoryNeutrinoContractAddressKey()), ((("No config at factory=" + toString(factoryAcc)) + " for key=") + keyFactoryNeutrinoContractAddressKey())))
237237 
238238 let feeManagerAddress = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(neutrinoMainAcc, keyFeesManagerAddressKey()), (keyFeesManagerAddressKey() + " is not specified"))), (keyFeesManagerAddressKey() + " invalid address format"))
239239 
240240 let keyDefoStakingAddress = "%s%s__commonConfig__defoStakingAddress"
241241 
242242 let keyNeutrinoStakingAddress = "%s%s__commonConfig__neutrinoStakingAddress"
243243 
244244 func keyDefoStakingAssetBalance (assetId) = ("%s%s__stakingBalance__" + assetId)
245245 
246246 
247247 func keyNeutrinoStakingBalance () = ((("rpd_balance_" + baseAssetIdStr) + "_") + toString(this))
248248 
249249 
250250 let defoStakingAcc = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyDefoStakingAddress), ((("No config at factoryAcc" + toString(factoryAcc)) + " for key=") + keyDefoStakingAddress))), ("address extraction error for key=" + keyDefoStakingAddress))
251251 
252252 let neutrinoStakingAcc = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(factoryAcc, keyNeutrinoStakingAddress), ((("No config at factoryAcc" + toString(factoryAcc)) + " for key=") + keyNeutrinoStakingAddress))), ("address extraction error for key=" + keyNeutrinoStakingAddress))
253253 
254254 func getThisDefoStakingBalance () = valueOrElse(getInteger(defoStakingAcc, keyDefoStakingAssetBalance(defoAssetIdStr)), 0)
255255 
256256 
257257 func getThisNeutrinoStakingBalance () = valueOrElse(getInteger(neutrinoStakingAcc, keyNeutrinoStakingBalance()), 0)
258258 
259259 
260260 let ucollateral = valueOrElse(getInteger(this, keyUcollateral()), 0)
261261 
262262 let accumulatedFee = valueOrElse(getInteger(this, keyAccumulatedFee()), 0)
263263 
264264 let accumulatedProtocolFee = valueOrElse(getInteger(this, keyAccumulatedProtocolFee()), 0)
265265 
266266 let currPoolAmount = getIntegerValue(factoryAcc, keyFactoryAssetCurrentPool(this))
267267 
268268 let debtAssetId = fromBase58String(factoryReadDebtAssetId())
269269 
270270 let debtAssetEtalonBalance = getIntegerValue(factoryAcc, keyFactoryDebtAssetEtalonBalance())
271271 
272272 let lendedOrDebtAmount = (debtAssetEtalonBalance - assetBalance(this, debtAssetId))
273273 
274274 let currentBaseAssetBalance = ((assetBalance(this, baseAssetId) + getThisNeutrinoStakingBalance()) + lendedOrDebtAmount)
275275 
276276 let controlPrice = controlAccReadPrice(thisCfgArray[IdxDefoAssetCode])
277277 
278278 let emission = (value(assetInfo(defoAssetId)).quantity - assetBalance(this, defoAssetId))
279279 
280280 func getBuyPrice (changeCoeff) = if (isMarketOpened)
281281     then controlPrice
282282     else fraction((priceDecimals - changeCoeff), controlPrice, priceDecimals)
283283 
284284 
285285 func getBuyFeeConsideringStakingReferral (callerPub58Str) = if ((assetStakingReferralPublicStr == callerPub58Str))
286286     then 0
287287     else buyFeePercent
288288 
289289 
290290 func getProtocolFeeConsideringStakingReferral (callerPub58Str) = if ((assetStakingReferralPublicStr == callerPub58Str))
291291     then 0
292292     else protocolFeePercent
293293 
294294 
295295 func getBuyPriceConsideringStakingReferral (changeCoeff,callerPub58Str) = if ((assetStakingReferralPublicStr == callerPub58Str))
296296     then controlPrice
297297     else getBuyPrice(changeCoeff)
298298 
299299 
300300 func getSellPrice (changeCoeff) = if (isMarketOpened)
301301     then controlPrice
302302     else fraction((priceDecimals + changeCoeff), controlPrice, priceDecimals)
303303 
304304 
305305 func getSellPriceFrom (fromPrice,changeCoeff) = if (isMarketOpened)
306306     then fromPrice
307307     else fraction((priceDecimals + changeCoeff), fromPrice, priceDecimals)
308308 
309309 
310310 func internalBuyAsset (sellerAddr,sellAmt,sellAssetId,minSellAmt,buy2sellPrice,poolMakersFeePart,protocolFeePart) = {
311311     let defoAssetAmountGross = fraction(sellAmt, buy2sellPrice, priceDecimals)
312312     let stabilityFeeDefoAmount = fraction(poolStabilityFeePart, defoAssetAmountGross, priceDecimals)
313313     let poolMakersFeeDefoAmount = fraction(poolMakersFeePart, defoAssetAmountGross, priceDecimals)
314314     let protocolFeeDefoAmount = fraction(protocolFeePart, defoAssetAmountGross, priceDecimals)
315315     let defoAssetAmount = (((defoAssetAmountGross - stabilityFeeDefoAmount) - poolMakersFeeDefoAmount) - protocolFeeDefoAmount)
316316     let requiredBasicAssetAmount = fraction(defoAssetAmountGross, priceDecimals, buy2sellPrice)
317317     let change = (sellAmt - requiredBasicAssetAmount)
318318     if (if ((minSellAmt > sellAmt))
319319         then (toString(sellerAddr) != toString(defoStakingAcc))
320320         else false)
321321         then throw(((((("impossible to issue new " + defoAssetCode) + ": payment=") + toString(sellAmt)) + "is less then min amount=") + toString(minSellAmt)))
322322         else $Tuple2([IntegerEntry(keyUcollateral(), (ucollateral + requiredBasicAssetAmount)), StringEntry(keyAccountOperation(height, toString(sellerAddr), "FINISHED"), assetDataSwapOperation(sellAmt, toBase58String(sellAssetId), controlPrice, defoAssetAmount, toBase58String(defoAssetId), defoAssetAmountGross, poolMakersFeeDefoAmount, protocolFeeDefoAmount)), Reissue(defoAssetId, ((defoAssetAmount + poolMakersFeeDefoAmount) + protocolFeeDefoAmount), true), ScriptTransfer(sellerAddr, defoAssetAmount, defoAssetId), ScriptTransfer(sellerAddr, change, sellAssetId), ScriptTransfer(factoryReadNextPoolMakerToDistributeFee(toString(this)), poolMakersFeeDefoAmount, defoAssetId), ScriptTransfer(feeManagerAddress, protocolFeeDefoAmount, defoAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + poolMakersFeeDefoAmount)), IntegerEntry(keyAccumulatedProtocolFee(), (accumulatedProtocolFee + protocolFeeDefoAmount))], change)
323323     }
324324 
325325 
326326 @Callable(i)
327+func mngsurplus (amt,to) = if ((this != i.caller))
328+    then throw("denied")
329+    else {
330+        func getAssetCurrrentPoolAmountKey (assetAddress) =         (("%s%s%s__defoAsset__" + assetAddress) + "__currentPool")
331+
332+        func getPoolTotalLockedAmountKey (assetAddress) =         makeString(["%s%s%s__pool", assetAddress, "totalLockedAmount"], "__")
333+
334+        let multiplicator = 1000000
335+        let assetEmission = emission
336+        let assetOverCollateralPercent = 0
337+        let currentPrice = controlPrice
338+        let assetEmissionOvercollateralRate = fraction((multiplicator + assetOverCollateralPercent), assetEmission, multiplicator)
339+        let usdnNeededToCoverEmission = fraction(assetEmissionOvercollateralRate, multiplicator, currentPrice)
340+        let assetUsdnBalanceAmount = assetBalance(this, baseAssetId)
341+        let assetUsdnStakedAmount = getThisNeutrinoStakingBalance()
342+        let poolTotalLockedAmountKey = getPoolTotalLockedAmountKey(toString(this))
343+        let poolActualSize = valueOrElse(getInteger(factoryAcc, getAssetCurrrentPoolAmountKey(toString(this))), 0)
344+        let poolTotalLocked = valueOrElse(getInteger(factoryAcc, poolTotalLockedAmountKey), 0)
345+        let assetTotalUsdnAmount = (((assetUsdnStakedAmount + assetUsdnBalanceAmount) - poolTotalLocked) + lendedOrDebtAmount)
346+        let ucollateralF = (assetTotalUsdnAmount - poolActualSize)
347+        let surplus = (ucollateralF - usdnNeededToCoverEmission)
348+        if ((amt > surplus))
349+            then throw("Passed amt greater than existing surplus")
350+            else throw(("surplus=" + toString(surplus)))
351+        }
352+
353+
354+
355+@Callable(i)
327356 func buyAsset () = {
328357     let pmt = value(i.payments[0])
329358     let pmtAssetId = value(pmt.assetId)
330359     let callerPub58Str = toBase58String(i.callerPublicKey)
331360     if (isBlocked)
332361         then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
333362         else if ((pmtAssetId != baseAssetId))
334363             then throw(((("Payment asset id doesn't match basic asset: expected=" + toBase58String(baseAssetId)) + " actual=") + toBase58String(pmtAssetId)))
335364             else internalBuyAsset(i.caller, pmt.amount, pmtAssetId, minBasicBuyAmount, getBuyPriceConsideringStakingReferral(weekendsPriceChangeCoefficient, callerPub58Str), getBuyFeeConsideringStakingReferral(callerPub58Str), getProtocolFeeConsideringStakingReferral(callerPub58Str))._1
336365     }
337366 
338367 
339368 
340369 @Callable(i)
341370 func sellAsset () = {
342371     let pmt = value(i.payments[0])
343372     let pmtAsset = value(pmt.assetId)
344373     let callerAddress = toString(i.caller)
345374     let sellPrice = getSellPrice(weekendsPriceChangeCoefficient)
346375     if (isBlocked)
347376         then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
348377         else if ((pmtAsset != defoAssetId))
349378             then throw(((("Invalid payment asset id: expected=" + toBase58String(defoAssetId)) + " actual=") + toBase58String(pmtAsset)))
350379             else if ((minSynthSellAmount > pmt.amount))
351380                 then throw(((("Payment amount less then mininimal allowed: paymentAmount=" + toString(pmt.amount)) + " minAmount=") + toString(minSynthSellAmount)))
352381                 else {
353382                     let baseAssetAmountNoBalanceLimit = fraction(pmt.amount, priceDecimals, sellPrice)
354383                     let baseAssetAmountAvailable = if ((baseAssetAmountNoBalanceLimit > currentBaseAssetBalance))
355384                         then currentBaseAssetBalance
356385                         else baseAssetAmountNoBalanceLimit
357386                     let soldDefoAssetAmountGross = fraction(baseAssetAmountAvailable, sellPrice, priceDecimals)
358387                     let change = (pmt.amount - soldDefoAssetAmountGross)
359388                     let stabilityFeeDefoAmount = fraction(0, soldDefoAssetAmountGross, priceDecimals)
360389                     let poolMakersFeeDefoAmount = fraction(0, soldDefoAssetAmountGross, priceDecimals)
361390                     let protocolFeeDefoAmount = fraction(0, soldDefoAssetAmountGross, priceDecimals)
362391                     let soldDefoAssetAmount = (((soldDefoAssetAmountGross - stabilityFeeDefoAmount) - poolMakersFeeDefoAmount) - protocolFeeDefoAmount)
363392                     let baseAssetAmountToSend = fraction(soldDefoAssetAmount, priceDecimals, sellPrice)
364393 [IntegerEntry(keyUcollateral(), (ucollateral - baseAssetAmountToSend)), StringEntry(keyAccountOperation(height, callerAddress, "FINISHED"), assetDataSwapOperation(pmt.amount, toBase58String(pmtAsset), sellPrice, baseAssetAmountToSend, baseAssetIdStr, soldDefoAssetAmountGross, poolMakersFeeDefoAmount, protocolFeeDefoAmount)), Burn(defoAssetId, (soldDefoAssetAmount + stabilityFeeDefoAmount)), ScriptTransfer(i.caller, baseAssetAmountToSend, baseAssetId), ScriptTransfer(i.caller, change, defoAssetId), ScriptTransfer(feeManagerAddress, protocolFeeDefoAmount, defoAssetId), ScriptTransfer(factoryReadNextPoolMakerToDistributeFee(toString(this)), poolMakersFeeDefoAmount, defoAssetId), IntegerEntry(keyAccumulatedFee(), (accumulatedFee + poolMakersFeeDefoAmount)), IntegerEntry(keyAccumulatedProtocolFee(), (accumulatedProtocolFee + protocolFeeDefoAmount))]
365394                     }
366395     }
367396 
368397 
369398 
370399 @Callable(i)
371400 func crossExchange (buyAssetCodeConfirm,sellAssetCodeConfirm) = throw((("DeFo buy and crossExchange operations are stopped due to fundamental changes in the Neutrino protocol. " + "Sell and redeemFromPool operations will remain available all the time, ") + "so that everyone can swap DeFo tokens to the base underlying token."))
372401 
373402 
374403 
375404 @Callable(i)
376405 func rebalanceDebts () = {
377406     let debtPmt0 = value(i.payments[0])
378407     let debtPmtAsset0 = value(debtPmt0.assetId)
379408     let basePmt1 = value(i.payments[1])
380409     let basePmtAsset1 = value(basePmt1.assetId)
381410     let debtorAddress = toString(i.caller)
382411     let debtorAssetCfg = factoryReadAssetCfgByAddress(debtorAddress)
383412     let debtorAssetCode = debtorAssetCfg[IdxDefoAssetCode]
384413     let lendedAmountByAssetCodeKey = keyLendedAmountByAssetCode(debtorAssetCode)
385414     let lendedAmt = valueOrErrorMessage(getInteger(this, lendedAmountByAssetCodeKey), ("No debts for " + debtorAssetCode))
386415     if ((size(i.payments) != 2))
387416         then throw("exact 2 payments must be attached")
388417         else if (isBlocked)
389418             then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
390419             else if ((debtAssetId != debtPmtAsset0))
391420                 then throw(((("invalid debt asset id in the first paymet: expected=" + toBase58String(debtAssetId)) + " actual=") + toBase58String(debtPmtAsset0)))
392421                 else if ((baseAssetId != basePmtAsset1))
393422                     then throw(((("invalid base asset id in the second payment: expected=" + toBase58String(baseAssetId)) + " actual=") + toBase58String(basePmtAsset1)))
394423                     else if ((debtPmt0.amount != basePmt1.amount))
395424                         then throw("first payment amount doesn't match to the second payment amount")
396425                         else if ((0 >= lendedAmt))
397426                             then throw(("lendedAmt is less then zero: lendedAmt=" + toString(lendedAmt)))
398427                             else if (((100 * priceDecimals) >= debtPmt0.amount))
399428                                 then throw(("attached payment must be greater then 100: pmt0.amount=" + toString(debtPmt0.amount)))
400429                                 else if ((debtPmt0.amount > lendedAmt))
401430                                     then throw(((("attached payment is grater than required: pmtAmount=" + toString(debtPmt0.amount)) + " lendedAmt=") + toString(lendedAmt)))
402431                                     else {
403432                                         let totalLendedAtOtherAccs = valueOrElse(getInteger(this, keyTotalLendedAtOtherAccs()), 0)
404433                                         let lendedAmtAfter = (lendedAmt - debtPmt0.amount)
405434 [IntegerEntry(lendedAmountByAssetCodeKey, lendedAmtAfter), IntegerEntry(keyTotalLendedAtOtherAccs(), (totalLendedAtOtherAccs - debtPmt0.amount)), StringEntry(("%s%s__rebalanceTrace__" + toBase58String(i.transactionId)), assetDataRebalanceTrace(debtorAssetCode, debtPmt0, basePmt1, lendedAmt, lendedAmtAfter))]
406435                                         }
407436     }
408437 
409438 
410439 
411440 @Callable(i)
412441 func fulfillRedeemRequest (poolMakerAddress) = {
413442     let thisAddressStr = toString(this)
414443     let poolMakerUnlockHeightKey = keyFactoryPoolMakerUnlockHeight(thisAddressStr, poolMakerAddress)
415444     let poolMakerUnlockHeight = valueOrElse(getInteger(factoryAcc, poolMakerUnlockHeightKey), 0)
416445     if ((0 >= poolMakerUnlockHeight))
417446         then throw("All liquidity request fulfilled")
418447         else {
419448             let poolMakerLiquidityRequestKey = keyFactoryPoolMakerLiquidityRequest(thisAddressStr, poolMakerAddress, poolMakerUnlockHeight)
420449             let poolMakerLiquidityRequestAmount = valueOrErrorMessage(getInteger(factoryAcc, poolMakerLiquidityRequestKey), "Empty poolMakerLiquidityRequestKey at factory acc")
421450             if (isDefined(getInteger(this, poolMakerLiquidityRequestKey)))
422451                 then throw("Liquidity request has been already fulfilled")
423452                 else [IntegerEntry(poolMakerLiquidityRequestKey, poolMakerLiquidityRequestAmount), ScriptTransfer(factoryAcc, poolMakerLiquidityRequestAmount, baseAssetId)]
424453             }
425454     }
426455 
427456 
428457 @Verifier(tx)
429458 func verify () = match tx {
430459     case inv: InvokeScriptTransaction => 
431460         if ((inv.fee > (900 * 1000)))
432461             then throw(("fee amount is greater than max allowed: " + toString(inv.fee)))
433462             else if (isDefined(inv.feeAssetId))
434463                 then throw("only Waves is allowed as feeAssetId")
435464                 else if ((inv.function == "rebalanceDebts"))
436465                     then {
437466                         let invDappAddress = toString(addressFromRecipient(inv.dApp))
438467                         if ((factoryReadAssetCfgByAddress(invDappAddress)[IdxDefoAssetStatus] != "ISSUED"))
439468                             then throw("only defo dapp is allowed")
440469                             else if ((invDappAddress == toString(this)))
441470                                 then throw("impossible to call self rebealnceDebt")
442471                                 else true
443472                         }
444473                     else if (if (if ((inv.function == "lockNeutrino"))
445474                         then true
446475                         else (inv.function == "lockNeutrinoSP"))
447476                         then true
448477                         else (inv.function == "unlockNeutrino"))
449478                         then if ((toString(neutrinoStakingAcc) != toString(addressFromRecipient(inv.dApp))))
450479                             then throw("invalid neutrino staking dapp address")
451480                             else sigVerify(tx.bodyBytes, tx.proofs[0], factoryReadDefoStakingPacemakerPub())
452481                         else throw("Not allowed invocation method calls")
453482     case _ => 
454483         sigVerify_128Kb(tx.bodyBytes, tx.proofs[0], fromBase58String("AtHMLjr2TPy8bdpsM1rjusCyo7ghv3cCXdEPZq4Rti2a"))
455484 }
456485 
github/deemru/w8io/6500d08 
63.61 ms ◑