w8 · tx · 3Jm···g4W

tx · 3Jm2Don2Su8d6W5NwRLE33BRWDxWWRrLpUGgX1XMyg4W

3P38HpNRkV2PxLtx97YPjbfW7qHHWdsyGba:  -0.02900000 Waves

2022.08.24 11:53 [3263820] smart account 3P38HpNRkV2PxLtx97YPjbfW7qHHWdsyGba > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "3Jm2Don2Su8d6W5NwRLE33BRWDxWWRrLpUGgX1XMyg4W",
    "fee": 2900000,
    "feeAssetId": null,
    "timestamp": 1661331000628,
    "version": 1,
    "sender": "3P38HpNRkV2PxLtx97YPjbfW7qHHWdsyGba",
    "senderPublicKey": "Hgxenqk2qCr4uTukXTAdimvGnYoNzcW3C6B8tRWv4yHn",
    "proofs": [
        "2RqyG2T5vLTpLSTEajtrZuJCaCZrWnUMMGY7DwYnuoUv9kt2ztVtdhpZ1tYs1cBE2BWx4GEYQWTbkrzZCwNLzhjf"
    ],
    "script": "base64:AAIFAAAAAAAAADQIAhIDCgEIEgkKBwgICAgBCAgSAwoBARIAEgASBQoDCAgIEgQKAggBEgMKAQgSAwoBCBIAAAAAOQAAAAADU0VQAgAAAAJfXwAAAAAFRU1QVFkCAAAAAAEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQAAAANrZXkJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABB0AAAACBQAAAAR0aGlzBQAAAANrZXkJAAEsAAAAAgIAAAAVTm8gZGF0YSBmb3IgdGhpcy5rZXk9BQAAAANrZXkBAAAAEGdldEJvb2xlYW5PckZhaWwAAAABAAAAA2tleQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEGwAAAAIFAAAABHRoaXMFAAAAA2tleQkAASwAAAACAgAAABVObyBkYXRhIGZvciB0aGlzLmtleT0FAAAAA2tleQEAAAATa2V5TWFuYWdlclB1YmxpY0tleQAAAAAJAAS5AAAAAgkABEwAAAACAgAAAAIlcwkABEwAAAACAgAAABBtYW5hZ2VyUHVibGljS2V5BQAAAANuaWwFAAAAA1NFUAEAAAAaa2V5UGVuZGluZ01hbmFnZXJQdWJsaWNLZXkAAAAACQAEuQAAAAIJAARMAAAAAgIAAAACJXMJAARMAAAAAgIAAAAXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkFAAAAA25pbAUAAAADU0VQAQAAAA5mYWlsRXhlY3V0ZUdldAAAAAQAAAADbXNnAAAADGJhc2VBc3NldFN0cgAAAA51c2VyQWRkcmVzc1N0cgAAAApnZXRUeElkU3RyCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIFAAAAA21zZwIAAAAPOiBiYXNlQXNzZXRTdHI9BQAAAAxiYXNlQXNzZXRTdHICAAAAECB1c2VyQWRkcmVzc1N0cj0FAAAADnVzZXJBZGRyZXNzU3RyAgAAAAwgZ2V0VHhJZFN0cj0FAAAACmdldFR4SWRTdHIBAAAAFmtleUFzc2V0c1N0b3JlQ29udHJhY3QAAAAACQAEuQAAAAIJAARMAAAAAgIAAAACJXMJAARMAAAAAgIAAAATYXNzZXRzU3RvcmVDb250cmFjdAUAAAADbmlsBQAAAANTRVABAAAAC2tleUFzc2V0Q2ZnAAAAAQAAAAxiYXNlQXNzZXRTdHIJAAEsAAAAAgIAAAAXJXMlcyVzX19jb25maWdfX2Fzc2V0X18FAAAADGJhc2VBc3NldFN0cgEAAAAPa2V5UHJveHlBZGRyZXNzAAAAAQAAAAdhc3NldElkCQAEuQAAAAIJAARMAAAAAgIAAAAEJXMlcwkABEwAAAACAgAAAAxwcm94eUFkZHJlc3MJAARMAAAAAgUAAAAHYXNzZXRJZAUAAAADbmlsBQAAAANTRVABAAAACmtleUJhbGFuY2UAAAABAAAAB2Fzc2V0SWQJAAS5AAAAAgkABEwAAAACAgAAAAQlcyVzCQAETAAAAAICAAAAB2JhbGFuY2UJAARMAAAAAgUAAAAHYXNzZXRJZAUAAAADbmlsBQAAAANTRVABAAAAFmtleU5leHRJbnRlcm5hbEFzc2V0SWQAAAAAAgAAABclc19fbmV4dEludGVybmFsQXNzZXRJZAEAAAAMa2V5UHJpY2VMYXN0AAAAAQAAABVpbnRlcm5hbEJhc2V0QXNzZXRTdHIJAAEsAAAAAgIAAAAVJXMlcyVkX19wcmljZV9fbGFzdF9fBQAAABVpbnRlcm5hbEJhc2V0QXNzZXRTdHIBAAAAEmtleVRvcFVwTGFzdEhlaWdodAAAAAIAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyAAAABnNlbmRlcgkABLkAAAACCQAETAAAAAICAAAAHyVzJXMlcyVkJXNfX3RvcHVwX19sYXN0X19oZWlnaHQJAARMAAAAAgUAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyCQAETAAAAAIFAAAABnNlbmRlcgUAAAADbmlsBQAAAANTRVABAAAAD2tleVByaWNlSGlzdG9yeQAAAAMAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyAAAAAWgAAAAJdGltZXN0YW1wCQAEuQAAAAIJAARMAAAAAgIAAAAaJXMlcyVkJWQlZF9fcHJpY2VfX2hpc3RvcnkJAARMAAAAAgUAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyCQAETAAAAAIJAAGkAAAAAQUAAAABaAkABEwAAAACCQABpAAAAAEFAAAACXRpbWVzdGFtcAUAAAADbmlsBQAAAANTRVABAAAADmtleVRvdGFsTG9ja2VkAAAAAQAAABVpbnRlcm5hbEJhc2V0QXNzZXRTdHIJAAEsAAAAAgIAAAAXJXMlcyVkX190b3RhbF9fbG9ja2VkX18FAAAAFWludGVybmFsQmFzZXRBc3NldFN0cgEAAAAUa2V5VG90YWxMb2NrZWRCeVVzZXIAAAACAAAAFGludGVybmFsQmFzZUFzc2V0U3RyAAAADnVzZXJBZGRyZXNzU3RyCQAEuQAAAAIJAARMAAAAAgIAAAAXJXMlcyVkJXNfX3RvdGFsX19sb2NrZWQJAARMAAAAAgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAARMAAAAAgUAAAAOdXNlckFkZHJlc3NTdHIFAAAAA25pbAUAAAADU0VQAQAAAB9rZXlNYXBwaW5nc0ludGVybmFsMmJhc2VBc3NldElkAAAAAQAAABFpbnRlcm5hbEJhc2VBc3NldAkAASwAAAACAgAAACglcyVzJWRfX21hcHBpbmdzX19pbnRlcm5hbDJiYXNlQXNzZXRJZF9fCQABpAAAAAEFAAAAEWludGVybmFsQmFzZUFzc2V0AQAAAB9rZXlNYXBwaW5nc0Jhc2VBc3NldDJpbnRlcm5hbElkAAAAAQAAAAxiYXNlQXNzZXRTdHIJAAEsAAAAAgIAAAAoJXMlcyVzX19tYXBwaW5nc19fYmFzZUFzc2V0MmludGVybmFsSWRfXwUAAAAMYmFzZUFzc2V0U3RyAQAAABxrZXlNYXBwaW5nc1NoYXJlMmJhc2VBc3NldElkAAAAAQAAAA1zaGFyZUFzc2V0U3RyCQABLAAAAAICAAAAJSVzJXMlc19fbWFwcGluZ3NfX3NoYXJlMmJhc2VBc3NldElkX18FAAAADXNoYXJlQXNzZXRTdHIBAAAAHGtleU1hcHBpbmdzQmFzZUFzc2V0MnNoYXJlSWQAAAABAAAADGJhc2VBc3NldFN0cgkAASwAAAACAgAAACUlcyVzJXNfX21hcHBpbmdzX19iYXNlQXNzZXQyc2hhcmVJZF9fBQAAAAxiYXNlQXNzZXRTdHIBAAAAF2tleVNodXRkb3duUHV0T3BlcmF0aW9uAAAAAQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkAASwAAAACAgAAABclcyVzJWRfX3NodXRkb3duX19wdXRfXwUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIBAAAAEmtleVNodXRkb3duTWFuYWdlcgAAAAEAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAAEsAAAAAgIAAAAbJXMlcyVkX19zaHV0ZG93bl9fbWFuYWdlcl9fBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgEAAAATYXNzZXRzU3RvcmVDb250cmFjdAAAAAAJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEJAQAAAAV2YWx1ZQAAAAEJAAQiAAAAAQkBAAAAFmtleUFzc2V0c1N0b3JlQ29udHJhY3QAAAAAAAAAABJJZHhDZmdTaGFyZUFzc2V0SWQAAAAAAAAAAAEAAAAAF0lkeENmZ0ludGVybmFsQmFzZUFzc2V0AAAAAAAAAAACAAAAABxJZHhDZmdEZWNpbWFsc011bHRCb3RoQXNzZXRzAAAAAAAAAAADAAAAABdJZHhDZmdEZWNpbWFsc011bHRQcmljZQAAAAAAAAAABAAAAAAUSWR4Q2ZnR2V0RGVsYXlCbG9ja3MAAAAAAAAAAAUBAAAADGRhdGFBc3NldENmZwAAAAUAAAANc2hhcmVBc3NldFN0cgAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzAAAAEWRlY2ltYWxzTXVsdFByaWNlAAAAEGdldERlbGF5SW5CbG9ja3MJAAS5AAAAAgkABEwAAAACAgAAAAolcyVkJWQlZCVkCQAETAAAAAIFAAAADXNoYXJlQXNzZXRTdHIJAARMAAAAAgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAARMAAAAAgkAAaQAAAABBQAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzCQAETAAAAAIJAAGkAAAAAQUAAAARZGVjaW1hbHNNdWx0UHJpY2UJAARMAAAAAgkAAaQAAAABBQAAABBnZXREZWxheUluQmxvY2tzBQAAAANuaWwFAAAAA1NFUAAAAAATSWR4VG90YWxMb2NrZWRTaGFyZQAAAAAAAAAAAQAAAAASSWR4VG90YWxMb2NrZWRCYXNlAAAAAAAAAAACAQAAAA9kYXRhVG90YWxMb2NrZWQAAAACAAAAEHNoYXJlQXNzZXRBbW91bnQAAAAPYmFzZUFzc2V0QW1vdW50CQAEuQAAAAIJAARMAAAAAgIAAAAEJWQlZAkABEwAAAACCQABpAAAAAEFAAAAEHNoYXJlQXNzZXRBbW91bnQJAARMAAAAAgkAAaQAAAABBQAAAA9iYXNlQXNzZXRBbW91bnQFAAAAA25pbAUAAAADU0VQAQAAAA9yZWFkVG90YWxMb2NrZWQAAAABAAAAA2tleQQAAAAQdG90YWxMb2NrZWRBcnJheQkABLUAAAACCQEAAAALdmFsdWVPckVsc2UAAAACCQAEHQAAAAIFAAAABHRoaXMFAAAAA2tleQkBAAAAD2RhdGFUb3RhbExvY2tlZAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAFAAAAA1NFUAkABEwAAAACAP//////////CQAETAAAAAIJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAABB0b3RhbExvY2tlZEFycmF5BQAAABNJZHhUb3RhbExvY2tlZFNoYXJlCQAETAAAAAIJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAABB0b3RhbExvY2tlZEFycmF5BQAAABJJZHhUb3RhbExvY2tlZEJhc2UFAAAAA25pbAEAAAAMa2V5T3BlcmF0aW9uAAAABAAAAA1vcGVyYXRpb25UeXBlAAAAFGludGVybmFsQmFzZUFzc2V0U3RyAAAAC3VzZXJBZGRyZXNzAAAABHR4SWQJAAS5AAAAAgkABEwAAAACAgAAAAglcyVkJXMlcwkABEwAAAACBQAAAA1vcGVyYXRpb25UeXBlCQAETAAAAAIFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyCQAETAAAAAIFAAAAC3VzZXJBZGRyZXNzCQAETAAAAAIFAAAABHR4SWQFAAAAA25pbAUAAAADU0VQAAAAAA1JZHhPcGVyU3RhdHVzAAAAAAAAAAABAAAAAA9JZHhPcGVySW5BbW91bnQAAAAAAAAAAAIAAAAADElkeE9wZXJQcmljZQAAAAAAAAAAAwAAAAAQSWR4T3Blck91dEFtb3VudAAAAAAAAAAABAAAAAASSWR4T3BlclN0YXJ0SGVpZ2h0AAAAAAAAAAAFAAAAABVJZHhPcGVyU3RhcnRUaW1lc3RhbXAAAAAAAAAAAAYAAAAAEElkeE9wZXJFbmRIZWlnaHQAAAAAAAAAAAcAAAAAE0lkeE9wZXJFbmRUaW1lc3RhbXAAAAAAAAAAAAgBAAAAHnByaXZhdGVEYXRhT3BlcmF0aW9uQWxsU3RyaW5ncwAAAAgAAAAGc3RhdHVzAAAADWluQXNzZXRBbW91bnQAAAAFcHJpY2UAAAAOb3V0QXNzZXRBbW91bnQAAAALc3RhcnRIZWlnaHQAAAAOc3RhcnRUaW1lc3RhbXAAAAAJZW5kSGVpZ2h0AAAADGVuZFRpbWVzdGFtcAkABLkAAAACCQAETAAAAAICAAAAECVzJWQlZCVkJWQlZCVkJWQJAARMAAAAAgUAAAAGc3RhdHVzCQAETAAAAAIFAAAADWluQXNzZXRBbW91bnQJAARMAAAAAgUAAAAFcHJpY2UJAARMAAAAAgUAAAAOb3V0QXNzZXRBbW91bnQJAARMAAAAAgUAAAALc3RhcnRIZWlnaHQJAARMAAAAAgUAAAAOc3RhcnRUaW1lc3RhbXAJAARMAAAAAgUAAAAJZW5kSGVpZ2h0CQAETAAAAAIFAAAADGVuZFRpbWVzdGFtcAUAAAADbmlsBQAAAANTRVABAAAADWRhdGFPcGVyYXRpb24AAAAIAAAABnN0YXR1cwAAAA1pbkFzc2V0QW1vdW50AAAABXByaWNlAAAADm91dEFzc2V0QW1vdW50AAAAC3N0YXJ0SGVpZ2h0AAAADnN0YXJ0VGltZXN0YW1wAAAACWVuZEhlaWdodAAAAAxlbmRUaW1lc3RhbXAJAQAAAB5wcml2YXRlRGF0YU9wZXJhdGlvbkFsbFN0cmluZ3MAAAAIBQAAAAZzdGF0dXMJAAGkAAAAAQUAAAANaW5Bc3NldEFtb3VudAkAAaQAAAABBQAAAAVwcmljZQkAAaQAAAABBQAAAA5vdXRBc3NldEFtb3VudAkAAaQAAAABBQAAAAtzdGFydEhlaWdodAkAAaQAAAABBQAAAA5zdGFydFRpbWVzdGFtcAkAAaQAAAABBQAAAAllbmRIZWlnaHQJAAGkAAAAAQUAAAAMZW5kVGltZXN0YW1wAQAAABxkYXRhT3BlcmF0aW9uRXhlY3V0aW9uVXBkYXRlAAAAAwAAAA1jdXJyT3BlckFycmF5AAAACW5ld1N0YXR1cwAAAA9uZXdFbmRUaW1lc3RhbXAJAQAAAB5wcml2YXRlRGF0YU9wZXJhdGlvbkFsbFN0cmluZ3MAAAAIBQAAAAluZXdTdGF0dXMJAAGRAAAAAgUAAAANY3Vyck9wZXJBcnJheQUAAAAPSWR4T3BlckluQW1vdW50CQABkQAAAAIFAAAADWN1cnJPcGVyQXJyYXkFAAAADElkeE9wZXJQcmljZQkAAZEAAAACBQAAAA1jdXJyT3BlckFycmF5BQAAABBJZHhPcGVyT3V0QW1vdW50CQABkQAAAAIFAAAADWN1cnJPcGVyQXJyYXkFAAAAEklkeE9wZXJTdGFydEhlaWdodAkAAZEAAAACBQAAAA1jdXJyT3BlckFycmF5BQAAABVJZHhPcGVyU3RhcnRUaW1lc3RhbXAJAAGRAAAAAgUAAAANY3Vyck9wZXJBcnJheQUAAAAQSWR4T3BlckVuZEhlaWdodAkAAaQAAAABBQAAAA9uZXdFbmRUaW1lc3RhbXABAAAAEnJlYWRBc3NldENmZ09yRmFpbAAAAAEAAAAMYmFzZUFzc2V0U3RyBAAAAANrZXkJAQAAAAtrZXlBc3NldENmZwAAAAEFAAAADGJhc2VBc3NldFN0cgkABLUAAAACCQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQUAAAADa2V5BQAAAANTRVABAAAAFGluY3JlbWVudFRvdGFsTG9ja2VkAAAAAwAAAANrZXkAAAAQc2hhcmVBc3NldEFtb3VudAAAAA9iYXNlQXNzZXRBbW91bnQEAAAACWRhdGFBcnJheQkBAAAAD3JlYWRUb3RhbExvY2tlZAAAAAEFAAAAA2tleQkBAAAAC1N0cmluZ0VudHJ5AAAAAgUAAAADa2V5CQEAAAAPZGF0YVRvdGFsTG9ja2VkAAAAAgkAAGQAAAACCQABkQAAAAIFAAAACWRhdGFBcnJheQUAAAATSWR4VG90YWxMb2NrZWRTaGFyZQUAAAAQc2hhcmVBc3NldEFtb3VudAkAAGQAAAACCQABkQAAAAIFAAAACWRhdGFBcnJheQUAAAASSWR4VG90YWxMb2NrZWRCYXNlBQAAAA9iYXNlQXNzZXRBbW91bnQBAAAAFGRlY3JlbWVudFRvdGFsTG9ja2VkAAAAAwAAAANrZXkAAAAQc2hhcmVBc3NldEFtb3VudAAAAA9iYXNlQXNzZXRBbW91bnQEAAAACWRhdGFBcnJheQkBAAAAD3JlYWRUb3RhbExvY2tlZAAAAAEFAAAAA2tleQkBAAAAC1N0cmluZ0VudHJ5AAAAAgUAAAADa2V5CQEAAAAPZGF0YVRvdGFsTG9ja2VkAAAAAgkAAGUAAAACCQABkQAAAAIFAAAACWRhdGFBcnJheQUAAAATSWR4VG90YWxMb2NrZWRTaGFyZQUAAAAQc2hhcmVBc3NldEFtb3VudAkAAGUAAAACCQABkQAAAAIFAAAACWRhdGFBcnJheQUAAAASSWR4VG90YWxMb2NrZWRCYXNlBQAAAA9iYXNlQXNzZXRBbW91bnQBAAAAFm1hbmFnZXJQdWJsaWNLZXlPclVuaXQAAAAABAAAAAckbWF0Y2gwCQAEIgAAAAEJAQAAABNrZXlNYW5hZ2VyUHVibGljS2V5AAAAAAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAGU3RyaW5nBAAAAAFzBQAAAAckbWF0Y2gwCQACWQAAAAEFAAAAAXMDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABFVuaXQFAAAABHVuaXQJAAACAAAAAQIAAAALTWF0Y2ggZXJyb3IBAAAAHXBlbmRpbmdNYW5hZ2VyUHVibGljS2V5T3JVbml0AAAAAAQAAAAHJG1hdGNoMAkABCIAAAABCQEAAAAaa2V5UGVuZGluZ01hbmFnZXJQdWJsaWNLZXkAAAAAAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAZTdHJpbmcEAAAAAXMFAAAAByRtYXRjaDAJAAJZAAAAAQUAAAABcwMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAEVW5pdAUAAAAEdW5pdAkAAAIAAAABAgAAAAtNYXRjaCBlcnJvcgEAAAANYmFsYW5jZU9yWmVybwAAAAEAAAAHYXNzZXRJZAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABB8AAAABCQEAAAAKa2V5QmFsYW5jZQAAAAEFAAAAB2Fzc2V0SWQAAAAAAAAAAAABAAAACWNhbGNQcmljZQAAAAYAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIAAAALYmFzZUFzc2V0SWQAAAAPdG9wVXBCYXNlQW1vdW50AAAADHNoYXJlQXNzZXRJZAAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzAAAAEWRlY2ltYWxzTXVsdFByaWNlBAAAABB0b3RhbExvY2tlZEFycmF5CQEAAAAPcmVhZFRvdGFsTG9ja2VkAAAAAQkBAAAADmtleVRvdGFsTG9ja2VkAAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIEAAAAFXRvdGFsTG9ja2VkQmFzZUFtb3VudAkAAZEAAAACBQAAABB0b3RhbExvY2tlZEFycmF5BQAAABJJZHhUb3RhbExvY2tlZEJhc2UEAAAAEGJhc2VBc3NldEJhbGFuY2UJAQAAAA1iYWxhbmNlT3JaZXJvAAAAAQkAAlgAAAABBQAAAAtiYXNlQXNzZXRJZAQAAAAfYmFzZUFzc2V0QmFsYW5jZUNvbnNpZGVyaW5nTG9jawkAAGQAAAACBQAAABBiYXNlQXNzZXRCYWxhbmNlBQAAAA90b3BVcEJhc2VBbW91bnQDCQAAZgAAAAIAAAAAAAAAAAAFAAAAH2Jhc2VBc3NldEJhbGFuY2VDb25zaWRlcmluZ0xvY2sJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAA2YmFzZUFzc2V0QmFsYW5jZUNvbnNpZGVyaW5nTG9jayA8IDA6IGJhc2VBc3NldEJhbGFuY2U9CQABpAAAAAEFAAAAEGJhc2VBc3NldEJhbGFuY2UCAAAAISBiYXNlQXNzZXRCYWxhbmNlQ29uc2lkZXJpbmdMb2NrPQkAAaQAAAABBQAAAB9iYXNlQXNzZXRCYWxhbmNlQ29uc2lkZXJpbmdMb2NrBAAAAA1zaGFyZUVtaXNzaW9uCAkBAAAABXZhbHVlAAAAAQkAA+wAAAABBQAAAAxzaGFyZUFzc2V0SWQAAAAIcXVhbnRpdHkEAAAABXByaWNlAwkAAAAAAAACBQAAAA1zaGFyZUVtaXNzaW9uAAAAAAAAAAAACQAAaAAAAAIAAAAAAAAAAAEFAAAAEWRlY2ltYWxzTXVsdFByaWNlCQAAawAAAAMFAAAAH2Jhc2VBc3NldEJhbGFuY2VDb25zaWRlcmluZ0xvY2sFAAAAEWRlY2ltYWxzTXVsdFByaWNlBQAAAA1zaGFyZUVtaXNzaW9uCQAFFwAAAAUFAAAABXByaWNlBQAAABBiYXNlQXNzZXRCYWxhbmNlBQAAABV0b3RhbExvY2tlZEJhc2VBbW91bnQFAAAAH2Jhc2VBc3NldEJhbGFuY2VDb25zaWRlcmluZ0xvY2sFAAAADXNoYXJlRW1pc3Npb24BAAAACGdldFByaWNlAAAABQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgAAAAtiYXNlQXNzZXRJZAAAAAxzaGFyZUFzc2V0SWQAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwAAABFkZWNpbWFsc011bHRQcmljZQQAAAAQdG90YWxMb2NrZWRBcnJheQkBAAAAD3JlYWRUb3RhbExvY2tlZAAAAAEJAQAAAA5rZXlUb3RhbExvY2tlZAAAAAEFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBAAAABV0b3RhbExvY2tlZEJhc2VBbW91bnQJAAGRAAAAAgUAAAAQdG90YWxMb2NrZWRBcnJheQUAAAASSWR4VG90YWxMb2NrZWRCYXNlBAAAABBiYXNlQXNzZXRCYWxhbmNlCQEAAAANYmFsYW5jZU9yWmVybwAAAAEJAAJYAAAAAQUAAAALYmFzZUFzc2V0SWQEAAAAH2Jhc2VBc3NldEJhbGFuY2VDb25zaWRlcmluZ0xvY2sFAAAAEGJhc2VBc3NldEJhbGFuY2UEAAAADXNoYXJlRW1pc3Npb24ICQEAAAAFdmFsdWUAAAABCQAD7AAAAAEFAAAADHNoYXJlQXNzZXRJZAAAAAhxdWFudGl0eQQAAAAFcHJpY2UJAQAAAAV2YWx1ZQAAAAEJAAQfAAAAAQkBAAAADGtleVByaWNlTGFzdAAAAAEFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyCQAFFwAAAAUFAAAABXByaWNlBQAAABBiYXNlQXNzZXRCYWxhbmNlBQAAABV0b3RhbExvY2tlZEJhc2VBbW91bnQFAAAAH2Jhc2VBc3NldEJhbGFuY2VDb25zaWRlcmluZ0xvY2sFAAAADXNoYXJlRW1pc3Npb24BAAAAG3ByaXZhdGVDdXJyZW50U3lzUGFyYW1zUkVTVAAAAAEAAAAMYmFzZUFzc2V0U3RyBAAAAAtiYXNlQXNzZXRJZAkAAlkAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAACGNmZ0FycmF5CQEAAAAScmVhZEFzc2V0Q2ZnT3JGYWlsAAAAAQUAAAAMYmFzZUFzc2V0U3RyBAAAAA1zaGFyZUFzc2V0U3RyCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAABJJZHhDZmdTaGFyZUFzc2V0SWQEAAAADHNoYXJlQXNzZXRJZAkAAlkAAAABBQAAAA1zaGFyZUFzc2V0U3RyBAAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAHElkeENmZ0RlY2ltYWxzTXVsdEJvdGhBc3NldHMEAAAAEWRlY2ltYWxzTXVsdFByaWNlCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAF0lkeENmZ0RlY2ltYWxzTXVsdFByaWNlBAAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkAAZEAAAACBQAAAAhjZmdBcnJheQUAAAAXSWR4Q2ZnSW50ZXJuYWxCYXNlQXNzZXQEAAAACHN5c1N0YXRlCQEAAAAIZ2V0UHJpY2UAAAAFBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAALYmFzZUFzc2V0SWQFAAAADHNoYXJlQXNzZXRJZAUAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwUAAAARZGVjaW1hbHNNdWx0UHJpY2UEAAAAD3RvcFVwTGFzdEhlaWdodAQAAAAHJG1hdGNoMAkABB8AAAABCQEAAAASa2V5VG9wVXBMYXN0SGVpZ2h0AAAAAgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAQAAABFAZXh0ck5hdGl2ZSgxMDU4KQAAAAEJAQAAAA9rZXlQcm94eUFkZHJlc3MAAAABBQAAAAxiYXNlQXNzZXRTdHIDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAA0ludAQAAAABaAUAAAAHJG1hdGNoMAkBAAAABXZhbHVlAAAAAQUAAAABaAMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAEVW5pdAkBAAAAEUBleHRyTmF0aXZlKDEwNTUpAAAAAQkBAAAAEmtleVRvcFVwTGFzdEhlaWdodAAAAAIFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyCQAEJQAAAAEJAQAAABRhZGRyZXNzRnJvbVB1YmxpY0tleQAAAAEJAAJZAAAAAQkBAAAAEUBleHRyTmF0aXZlKDEwNTgpAAAAAQkBAAAAE2tleU1hbmFnZXJQdWJsaWNLZXkAAAAACQAAAgAAAAECAAAAOHVuZGVmaW5lZCBiZWhhdmlvdXIgaW4gcHJpdmF0ZUN1cnJlbnRTeXNQYXJhbXNSRVNUIG1hdGNoCQAFGgAAAAgJAQAAAAxJbnRlZ2VyRW50cnkAAAACAgAAAAVwcmljZQgFAAAACHN5c1N0YXRlAAAAAl8xCQEAAAAMSW50ZWdlckVudHJ5AAAAAgIAAAARZGVjaW1hbHNNdWx0UHJpY2UFAAAAEWRlY2ltYWxzTXVsdFByaWNlCQEAAAAMSW50ZWdlckVudHJ5AAAAAgIAAAAQYmFzZUFzc2V0QmFsYW5jZQgFAAAACHN5c1N0YXRlAAAAAl8yCQEAAAAMSW50ZWdlckVudHJ5AAAAAgIAAAAVdG90YWxMb2NrZWRCYXNlQW1vdW50CAUAAAAIc3lzU3RhdGUAAAACXzMJAQAAAAxJbnRlZ2VyRW50cnkAAAACAgAAAB9iYXNlQXNzZXRCYWxhbmNlQ29uc2lkZXJpbmdMb2NrCAUAAAAIc3lzU3RhdGUAAAACXzQJAQAAAAxJbnRlZ2VyRW50cnkAAAACAgAAAA1zaGFyZUVtaXNzaW9uCAUAAAAIc3lzU3RhdGUAAAACXzUJAQAAAAxJbnRlZ2VyRW50cnkAAAACAgAAABFiYXNlQXNzZXREZWNpbWFscwgJAQAAAAV2YWx1ZQAAAAEJAAPsAAAAAQUAAAALYmFzZUFzc2V0SWQAAAAIZGVjaW1hbHMJAQAAAAxJbnRlZ2VyRW50cnkAAAACAgAAABJsYXN0VG9wVXBUaW1lc3RhbXAICQEAAAAFdmFsdWUAAAABCQAD7QAAAAEFAAAAD3RvcFVwTGFzdEhlaWdodAAAAAl0aW1lc3RhbXABAAAAC211c3RNYW5hZ2VyAAAAAQAAAAFpBAAAAAJwZAkAAAIAAAABAgAAABFwZXJtaXNzaW9uIGRlbmllZAQAAAAHJG1hdGNoMAkBAAAAFm1hbmFnZXJQdWJsaWNLZXlPclVuaXQAAAAAAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAApCeXRlVmVjdG9yBAAAAAJwawUAAAAHJG1hdGNoMAMJAAAAAAAAAggFAAAAAWkAAAAPY2FsbGVyUHVibGljS2V5BQAAAAJwawYFAAAAAnBkAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAARVbml0AwkAAAAAAAACCAUAAAABaQAAAAZjYWxsZXIFAAAABHRoaXMGBQAAAAJwZAkAAAIAAAABAgAAAAtNYXRjaCBlcnJvcgEAAAAQbXVzdFByb3h5QWRkcmVzcwAAAAIAAAABaQAAAAdhc3NldElkBAAAAAdpc1Byb3h5CQAAAAAAAAIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyCQEAAAALdmFsdWVPckVsc2UAAAACCQAEIgAAAAEJAQAAAA9rZXlQcm94eUFkZHJlc3MAAAABBQAAAAdhc3NldElkBQAAAAVFTVBUWQMFAAAAB2lzUHJveHkGBAAAAAtjaGVja0NhbGxlcgkBAAAAC211c3RNYW5hZ2VyAAAAAQUAAAABaQMJAAAAAAAAAgUAAAALY2hlY2tDYWxsZXIFAAAAC2NoZWNrQ2FsbGVyBgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAAKAAAAAWkBAAAAC2NvbnN0cnVjdG9yAAAAAQAAABNhc3NldHNTdG9yZUNvbnRyYWN0BAAAAAtjaGVja0NhbGxlcgkBAAAAC211c3RNYW5hZ2VyAAAAAQUAAAABaQMJAAAAAAAAAgUAAAALY2hlY2tDYWxsZXIFAAAAC2NoZWNrQ2FsbGVyCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABZrZXlBc3NldHNTdG9yZUNvbnRyYWN0AAAAAAUAAAATYXNzZXRzU3RvcmVDb250cmFjdAUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAABJhZG1pblJlZ2lzdGVyQXNzZXQAAAAHAAAADGJhc2VBc3NldFN0cgAAAA5zaGFyZUFzc2V0TmFtZQAAAA9zaGFyZUFzc2V0RGVzY3IAAAAOc2hhcmVBc3NldExvZ28AAAAQZ2V0RGVsYXlpbkJsb2NrcwAAABZzaHV0ZG93bk1hbmFnZXJBZGRyZXNzAAAADHByb3h5QWRkcmVzcwQAAAALYmFzZUFzc2V0SWQJAAJZAAAAAQUAAAAMYmFzZUFzc2V0U3RyBAAAAAhkZWNpbWFscwgJAQAAAAV2YWx1ZQAAAAEJAAPsAAAAAQUAAAALYmFzZUFzc2V0SWQAAAAIZGVjaW1hbHMEAAAABWNoZWNrCQEAAAALbXVzdE1hbmFnZXIAAAABBQAAAAFpAwkAAAAAAAACBQAAAAVjaGVjawUAAAAFY2hlY2sDCQEAAAACIT0AAAACCQAEJQAAAAEJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEFAAAAFnNodXRkb3duTWFuYWdlckFkZHJlc3MFAAAAFnNodXRkb3duTWFuYWdlckFkZHJlc3MJAAACAAAAAQIAAAAeaW52YWxpZCBzaHV0ZG93bk1hbmFnZXJBZGRyZXNzAwkAAGYAAAACAAAAAAAAAAAABQAAABBnZXREZWxheWluQmxvY2tzCQAAAgAAAAEJAAEsAAAAAgIAAAAZaW52YWxpZCBnZXREZWxheWluQmxvY2tzPQkAAaQAAAABBQAAABBnZXREZWxheWluQmxvY2tzBAAAABVzaGFyZUFzc2V0SXNzdWVBY3Rpb24JAARCAAAABQUAAAAOc2hhcmVBc3NldE5hbWUFAAAAD3NoYXJlQXNzZXREZXNjcgAAAAAAAAAAAQUAAAAIZGVjaW1hbHMGBAAAAAxzaGFyZUFzc2V0SWQJAAQ4AAAAAQUAAAAVc2hhcmVBc3NldElzc3VlQWN0aW9uBAAAAA1zaGFyZUFzc2V0U3RyCQACWAAAAAEFAAAADHNoYXJlQXNzZXRJZAQAAAARZGVjaW1hbHNNdWx0UHJpY2UJAABoAAAAAgkAAGgAAAACAAAAAAAAAABkAAAAAAAAAAPoAAAAAAAAAAPoBAAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzCQAAbAAAAAYAAAAAAAAAAAoAAAAAAAAAAAAFAAAACGRlY2ltYWxzAAAAAAAAAAAAAAAAAAAAAAAABQAAAARET1dOBAAAAApzdGFydFByaWNlCQAAaAAAAAIAAAAAAAAAAAEFAAAAEWRlY2ltYWxzTXVsdFByaWNlBAAAABRpbnRlcm5hbEJhc2VBc3NldHRJZAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABBoAAAACBQAAAAR0aGlzCQEAAAAWa2V5TmV4dEludGVybmFsQXNzZXRJZAAAAAAAAAAAAAAAAAAEAAAAFGludGVybmFsQmFzZUFzc2V0U3RyCQABpAAAAAEFAAAAFGludGVybmFsQmFzZUFzc2V0dElkCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAAtrZXlBc3NldENmZwAAAAEFAAAADGJhc2VBc3NldFN0cgkBAAAADGRhdGFBc3NldENmZwAAAAUFAAAADXNoYXJlQXNzZXRTdHIFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzBQAAABFkZWNpbWFsc011bHRQcmljZQUAAAAQZ2V0RGVsYXlpbkJsb2NrcwkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAfa2V5TWFwcGluZ3NJbnRlcm5hbDJiYXNlQXNzZXRJZAAAAAEFAAAAFGludGVybmFsQmFzZUFzc2V0dElkBQAAAAxiYXNlQXNzZXRTdHIJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAH2tleU1hcHBpbmdzQmFzZUFzc2V0MmludGVybmFsSWQAAAABBQAAAAxiYXNlQXNzZXRTdHIFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABxrZXlNYXBwaW5nc1NoYXJlMmJhc2VBc3NldElkAAAAAQUAAAANc2hhcmVBc3NldFN0cgUAAAAMYmFzZUFzc2V0U3RyCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABxrZXlNYXBwaW5nc0Jhc2VBc3NldDJzaGFyZUlkAAAAAQUAAAAMYmFzZUFzc2V0U3RyBQAAAA1zaGFyZUFzc2V0U3RyCQAETAAAAAIJAQAAAAxCb29sZWFuRW50cnkAAAACCQEAAAAXa2V5U2h1dGRvd25QdXRPcGVyYXRpb24AAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgcJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAEmtleVNodXRkb3duTWFuYWdlcgAAAAEFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAABZzaHV0ZG93bk1hbmFnZXJBZGRyZXNzCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAWa2V5TmV4dEludGVybmFsQXNzZXRJZAAAAAAJAABkAAAAAgUAAAAUaW50ZXJuYWxCYXNlQXNzZXR0SWQAAAAAAAAAAAEJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAAxrZXlQcmljZUxhc3QAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAKc3RhcnRQcmljZQkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAD2tleVByaWNlSGlzdG9yeQAAAAMFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAAZoZWlnaHQIBQAAAAlsYXN0QmxvY2sAAAAJdGltZXN0YW1wBQAAAApzdGFydFByaWNlCQAETAAAAAIFAAAAFXNoYXJlQXNzZXRJc3N1ZUFjdGlvbgkABEwAAAACCQEAAAAEQnVybgAAAAIFAAAADHNoYXJlQXNzZXRJZAAAAAAAAAAAAQkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAPa2V5UHJveHlBZGRyZXNzAAAAAQUAAAAMYmFzZUFzc2V0U3RyBQAAAAxwcm94eUFkZHJlc3MFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAABaQEAAAALc2h1dGRvd25QdXQAAAABAAAAE2ludGVybmFsQmFzZUFzc2V0SWQEAAAAFmludGVybmFsQmFzZUFzc2V0SWRTdHIJAAGkAAAAAQUAAAATaW50ZXJuYWxCYXNlQXNzZXRJZAQAAAAOYmFzZUFzc2V0SWRTdHIJAQAAAA9nZXRTdHJpbmdPckZhaWwAAAABCQEAAAAfa2V5TWFwcGluZ3NJbnRlcm5hbDJiYXNlQXNzZXRJZAAAAAEFAAAAE2ludGVybmFsQmFzZUFzc2V0SWQEAAAAFnNodXRkb3duTWFuYWdlckFkZHJlc3MJAQAAAA9nZXRTdHJpbmdPckZhaWwAAAABCQEAAAASa2V5U2h1dGRvd25NYW5hZ2VyAAAAAQUAAAAWaW50ZXJuYWxCYXNlQXNzZXRJZFN0cgMJAABmAAAAAgAAAAAAAAAAAQkAATEAAAABBQAAAA5iYXNlQXNzZXRJZFN0cgkAAAIAAAABAgAAABtpbnZhbGlkIGludGVybmFsQmFzZUFzc2V0SWQDCQEAAAACIT0AAAACCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgUAAAAWc2h1dGRvd25NYW5hZ2VyQWRkcmVzcwkAAAIAAAABAgAAAA1hY2Nlc3MgZGVuaWVkCQAETAAAAAIJAQAAAAxCb29sZWFuRW50cnkAAAACCQEAAAAXa2V5U2h1dGRvd25QdXRPcGVyYXRpb24AAAABCQABpAAAAAEFAAAAE2ludGVybmFsQmFzZUFzc2V0SWQGBQAAAANuaWwAAAABaQEAAAADcHV0AAAAAAQAAAADcG10CQEAAAAFdmFsdWUAAAABCQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAABAAAAAtiYXNlQXNzZXRJZAkBAAAABXZhbHVlAAAAAQgFAAAAA3BtdAAAAAdhc3NldElkBAAAAAxiYXNlQXNzZXRTdHIJAAJYAAAAAQUAAAALYmFzZUFzc2V0SWQEAAAADnVzZXJBZGRyZXNzU3RyCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgQAAAAIY2ZnQXJyYXkJAQAAABJyZWFkQXNzZXRDZmdPckZhaWwAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAADXNoYXJlQXNzZXRTdHIJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAEklkeENmZ1NoYXJlQXNzZXRJZAQAAAAMc2hhcmVBc3NldElkCQACWQAAAAEFAAAADXNoYXJlQXNzZXRTdHIEAAAAFmRlY2ltYWxzTXVsdEJvdGhBc3NldHMJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAAhjZmdBcnJheQUAAAAcSWR4Q2ZnRGVjaW1hbHNNdWx0Qm90aEFzc2V0cwQAAAARZGVjaW1hbHNNdWx0UHJpY2UJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAAhjZmdBcnJheQUAAAAXSWR4Q2ZnRGVjaW1hbHNNdWx0UHJpY2UEAAAAFGludGVybmFsQmFzZUFzc2V0U3RyCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAABdJZHhDZmdJbnRlcm5hbEJhc2VBc3NldAQAAAAMaXNQdXRCbG9ja2VkCQEAAAAQZ2V0Qm9vbGVhbk9yRmFpbAAAAAEJAQAAABdrZXlTaHV0ZG93blB1dE9wZXJhdGlvbgAAAAEFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyAwUAAAAMaXNQdXRCbG9ja2VkCQAAAgAAAAECAAAAGHB1dCBvcGVyYXRpb24gaXMgYmxvY2tlZAQAAAAKbmV3QmFsYW5jZQkAAGQAAAACCQEAAAANYmFsYW5jZU9yWmVybwAAAAEFAAAADGJhc2VBc3NldFN0cggFAAAAA3BtdAAAAAZhbW91bnQEAAAABXByaWNlCAkBAAAACGdldFByaWNlAAAABQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAAC2Jhc2VBc3NldElkBQAAAAxzaGFyZUFzc2V0SWQFAAAAFmRlY2ltYWxzTXVsdEJvdGhBc3NldHMFAAAAEWRlY2ltYWxzTXVsdFByaWNlAAAAAl8xBAAAABBzaGFyZUFzc2V0QW1vdW50CQEAAAAIZnJhY3Rpb24AAAAECAUAAAADcG10AAAABmFtb3VudAUAAAARZGVjaW1hbHNNdWx0UHJpY2UFAAAABXByaWNlBQAAAAdDRUlMSU5HCQAETAAAAAIJAQAAAAdSZWlzc3VlAAAAAwUAAAAMc2hhcmVBc3NldElkBQAAABBzaGFyZUFzc2V0QW1vdW50BgkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADCAUAAAABaQAAAAZjYWxsZXIFAAAAEHNoYXJlQXNzZXRBbW91bnQFAAAADHNoYXJlQXNzZXRJZAkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAMa2V5T3BlcmF0aW9uAAAABAIAAAABUAUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAADnVzZXJBZGRyZXNzU3RyCQACWAAAAAEIBQAAAAFpAAAADXRyYW5zYWN0aW9uSWQJAQAAAA1kYXRhT3BlcmF0aW9uAAAACAIAAAAIRklOSVNIRUQIBQAAAANwbXQAAAAGYW1vdW50BQAAAAVwcmljZQUAAAAQc2hhcmVBc3NldEFtb3VudAUAAAAGaGVpZ2h0CAUAAAAJbGFzdEJsb2NrAAAACXRpbWVzdGFtcAUAAAAGaGVpZ2h0CAUAAAAJbGFzdEJsb2NrAAAACXRpbWVzdGFtcAkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABCQEAAAAFdmFsdWUAAAABCQAEIgAAAAEJAQAAAA9rZXlQcm94eUFkZHJlc3MAAAABBQAAAAxiYXNlQXNzZXRTdHIIBQAAAANwbXQAAAAGYW1vdW50BQAAAAtiYXNlQXNzZXRJZAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAACmtleUJhbGFuY2UAAAABBQAAAAxiYXNlQXNzZXRTdHIFAAAACm5ld0JhbGFuY2UFAAAAA25pbAAAAAFpAQAAABBzdWJtaXRHZXRSZXF1ZXN0AAAAAAQAAAADcG10CQEAAAAFdmFsdWUAAAABCQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAABAAAAAxzaGFyZUFzc2V0SWQJAQAAAAV2YWx1ZQAAAAEIBQAAAANwbXQAAAAHYXNzZXRJZAQAAAANc2hhcmVBc3NldFN0cgkAAlgAAAABBQAAAAxzaGFyZUFzc2V0SWQEAAAADGNhbGxlclB1YlN0cgkAAlgAAAABCAUAAAABaQAAAA9jYWxsZXJQdWJsaWNLZXkEAAAAC3VzZXJBZGRyZXNzCAUAAAABaQAAAAZjYWxsZXIEAAAADnVzZXJBZGRyZXNzU3RyCQAEJQAAAAEFAAAAC3VzZXJBZGRyZXNzBAAAABBzaGFyZUFzc2V0QW1vdW50CAUAAAADcG10AAAABmFtb3VudAQAAAAMYmFzZUFzc2V0U3RyCQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQkBAAAAHGtleU1hcHBpbmdzU2hhcmUyYmFzZUFzc2V0SWQAAAABBQAAAA1zaGFyZUFzc2V0U3RyBAAAAAtiYXNlQXNzZXRJZAkAAlkAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAACGNmZ0FycmF5CQEAAAAScmVhZEFzc2V0Q2ZnT3JGYWlsAAAAAQUAAAAMYmFzZUFzc2V0U3RyBAAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAHElkeENmZ0RlY2ltYWxzTXVsdEJvdGhBc3NldHMEAAAAEWRlY2ltYWxzTXVsdFByaWNlCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAF0lkeENmZ0RlY2ltYWxzTXVsdFByaWNlBAAAAA5nZXREZWxheUJsb2NrcwkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAABRJZHhDZmdHZXREZWxheUJsb2NrcwQAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAF0lkeENmZ0ludGVybmFsQmFzZUFzc2V0BAAAAAVwcmljZQgJAQAAAAhnZXRQcmljZQAAAAUFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAAtiYXNlQXNzZXRJZAUAAAAMc2hhcmVBc3NldElkBQAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzBQAAABFkZWNpbWFsc011bHRQcmljZQAAAAJfMQQAAAAPYmFzZUFzc2V0QW1vdW50CQAAawAAAAMFAAAAEHNoYXJlQXNzZXRBbW91bnQFAAAABXByaWNlBQAAABFkZWNpbWFsc011bHRQcmljZQQAAAAMb3BlcmF0aW9uS2V5CQEAAAAMa2V5T3BlcmF0aW9uAAAABAIAAAABRwUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAADnVzZXJBZGRyZXNzU3RyCQACWAAAAAEIBQAAAAFpAAAADXRyYW5zYWN0aW9uSWQEAAAADW9wZXJhdGlvbkRhdGEJAQAAAA1kYXRhT3BlcmF0aW9uAAAACAIAAAAHUEVORElORwUAAAAQc2hhcmVBc3NldEFtb3VudAUAAAAFcHJpY2UFAAAAD2Jhc2VBc3NldEFtb3VudAUAAAAGaGVpZ2h0CAUAAAAJbGFzdEJsb2NrAAAACXRpbWVzdGFtcAkAAGQAAAACBQAAAAZoZWlnaHQFAAAADmdldERlbGF5QmxvY2tzAAAAAAAAAAAACQAETAAAAAIJAQAAAARCdXJuAAAAAgUAAAAMc2hhcmVBc3NldElkBQAAABBzaGFyZUFzc2V0QW1vdW50CQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIFAAAADG9wZXJhdGlvbktleQUAAAANb3BlcmF0aW9uRGF0YQkABEwAAAACCQEAAAAUaW5jcmVtZW50VG90YWxMb2NrZWQAAAADCQEAAAAOa2V5VG90YWxMb2NrZWQAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAQc2hhcmVBc3NldEFtb3VudAUAAAAPYmFzZUFzc2V0QW1vdW50CQAETAAAAAIJAQAAABRpbmNyZW1lbnRUb3RhbExvY2tlZAAAAAMJAQAAABRrZXlUb3RhbExvY2tlZEJ5VXNlcgAAAAIFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cgUAAAAQc2hhcmVBc3NldEFtb3VudAUAAAAPYmFzZUFzc2V0QW1vdW50CQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAKa2V5QmFsYW5jZQAAAAEFAAAADGJhc2VBc3NldFN0cgkAAGUAAAACCQEAAAANYmFsYW5jZU9yWmVybwAAAAEFAAAADGJhc2VBc3NldFN0cgUAAAAPYmFzZUFzc2V0QW1vdW50BQAAAANuaWwAAAABaQEAAAARZXhlY3V0ZUdldFJlcXVlc3QAAAADAAAADGJhc2VBc3NldFN0cgAAAA51c2VyQWRkcmVzc1N0cgAAAApnZXRUeElkU3RyBAAAAAt1c2VyQWRkcmVzcwkBAAAAEUBleHRyTmF0aXZlKDEwNjIpAAAAAQUAAAAOdXNlckFkZHJlc3NTdHIEAAAADWFzc2V0Q2ZnQXJyYXkJAQAAABJyZWFkQXNzZXRDZmdPckZhaWwAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAADHNoYXJlQXNzZXRJZAkAAlkAAAABCQABkQAAAAIFAAAADWFzc2V0Q2ZnQXJyYXkFAAAAEklkeENmZ1NoYXJlQXNzZXRJZAQAAAALYmFzZUFzc2V0SWQJAAJZAAAAAQUAAAAMYmFzZUFzc2V0U3RyBAAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkAAZEAAAACBQAAAA1hc3NldENmZ0FycmF5BQAAABdJZHhDZmdJbnRlcm5hbEJhc2VBc3NldAQAAAAMb3BlcmF0aW9uS2V5CQEAAAAMa2V5T3BlcmF0aW9uAAAABAIAAAABRwUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAADnVzZXJBZGRyZXNzU3RyBQAAAApnZXRUeElkU3RyBAAAAA5vcGVyYXRpb25BcnJheQkABLUAAAACCQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQUAAAAMb3BlcmF0aW9uS2V5BQAAAANTRVAEAAAABnN0YXR1cwkAAZEAAAACBQAAAA5vcGVyYXRpb25BcnJheQUAAAANSWR4T3BlclN0YXR1cwQAAAAJZW5kSGVpZ2h0CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAOb3BlcmF0aW9uQXJyYXkFAAAAEElkeE9wZXJFbmRIZWlnaHQEAAAADWluU2hhcmVBbW91bnQJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAA5vcGVyYXRpb25BcnJheQUAAAAPSWR4T3BlckluQW1vdW50BAAAAA1vdXRCYXNlQW1vdW50CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAOb3BlcmF0aW9uQXJyYXkFAAAAEElkeE9wZXJPdXRBbW91bnQDCQEAAAACIT0AAAACBQAAAAZzdGF0dXMCAAAAB1BFTkRJTkcJAQAAAA5mYWlsRXhlY3V0ZUdldAAAAAQCAAAAFVN0YXR1cyBpcyBub3QgUEVORElORwUAAAAMYmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cgUAAAAKZ2V0VHhJZFN0cgMJAABmAAAAAgUAAAAJZW5kSGVpZ2h0BQAAAAZoZWlnaHQJAQAAAA5mYWlsRXhlY3V0ZUdldAAAAAQJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAACkVuZEhlaWdodFsJAAGkAAAAAQUAAAAJZW5kSGVpZ2h0AgAAAARdID4gCQABpAAAAAEFAAAABmhlaWdodAUAAAAMYmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cgUAAAAKZ2V0VHhJZFN0cgkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADBQAAAAt1c2VyQWRkcmVzcwUAAAANb3V0QmFzZUFtb3VudAUAAAALYmFzZUFzc2V0SWQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgUAAAAMb3BlcmF0aW9uS2V5CQEAAAAcZGF0YU9wZXJhdGlvbkV4ZWN1dGlvblVwZGF0ZQAAAAMFAAAADm9wZXJhdGlvbkFycmF5AgAAAAhGSU5JU0hFRAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAJAARMAAAAAgkBAAAAFGRlY3JlbWVudFRvdGFsTG9ja2VkAAAAAwkBAAAADmtleVRvdGFsTG9ja2VkAAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAADWluU2hhcmVBbW91bnQFAAAADW91dEJhc2VBbW91bnQJAARMAAAAAgkBAAAAFGRlY3JlbWVudFRvdGFsTG9ja2VkAAAAAwkBAAAAFGtleVRvdGFsTG9ja2VkQnlVc2VyAAAAAgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAADnVzZXJBZGRyZXNzU3RyBQAAAA1pblNoYXJlQW1vdW50BQAAAA1vdXRCYXNlQW1vdW50BQAAAANuaWwAAAABaQEAAAAMdG9wVXBCYWxhbmNlAAAAAgAAAAxiYXNlQXNzZXRTdHIAAAAFZGVsdGEEAAAADWFzc2V0Q2ZnQXJyYXkJAQAAABJyZWFkQXNzZXRDZmdPckZhaWwAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAAA3BtdAkBAAAABXZhbHVlAAAAAQkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAQAAAAKcG10QXNzZXRJZAkBAAAABXZhbHVlAAAAAQgFAAAAA3BtdAAAAAdhc3NldElkBAAAAAtwbXRBc3NldFN0cgkAAlgAAAABBQAAAApwbXRBc3NldElkBAAAAAxzaGFyZUFzc2V0SWQJAAJZAAAAAQkAAZEAAAACBQAAAA1hc3NldENmZ0FycmF5BQAAABJJZHhDZmdTaGFyZUFzc2V0SWQEAAAAFmRlY2ltYWxzTXVsdEJvdGhBc3NldHMJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAA1hc3NldENmZ0FycmF5BQAAABxJZHhDZmdEZWNpbWFsc011bHRCb3RoQXNzZXRzBAAAABFkZWNpbWFsc011bHRQcmljZQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAADWFzc2V0Q2ZnQXJyYXkFAAAAF0lkeENmZ0RlY2ltYWxzTXVsdFByaWNlBAAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkAAZEAAAACBQAAAA1hc3NldENmZ0FycmF5BQAAABdJZHhDZmdJbnRlcm5hbEJhc2VBc3NldAQAAAASdG9wVXBMYXN0SGVpZ2h0S0VZCQEAAAASa2V5VG9wVXBMYXN0SGVpZ2h0AAAAAgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAAA90b3BVcExhc3RIZWlnaHQJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwUAAAASdG9wVXBMYXN0SGVpZ2h0S0VZAAAAAAAAAAAABAAAAAZjaGVja3MJAARMAAAAAgkBAAAAEG11c3RQcm94eUFkZHJlc3MAAAACBQAAAAFpBQAAAAxiYXNlQXNzZXRTdHIJAARMAAAAAgMJAQAAAAIhPQAAAAIFAAAAD3RvcFVwTGFzdEhlaWdodAUAAAAGaGVpZ2h0BgkAAAIAAAABAgAAACNvbmx5IG9uZSB0b3BVcCBwZXIgYmxvY2sgaXMgYWxsb3dlZAkABEwAAAACAwkAAGYAAAACBQAAAAVkZWx0YQAAAAAAAAAAAAYJAAACAAAAAQIAAAAeb25seSBwb3NpdGl2ZSBkZWx0YSBpcyBhbGxvd2VkBQAAAANuaWwDCQAAAAAAAAIFAAAABmNoZWNrcwUAAAAGY2hlY2tzAwkBAAAAAiE9AAAAAgUAAAAMYmFzZUFzc2V0U3RyBQAAAAtwbXRBc3NldFN0cgkAAAIAAAABAgAAAD5hdHRhY2hlZCBwYXltZW50J3MgYXNzZXQgaWQgaXMgTk9UIG1hdGNoZWQgcGFzc2VkIGJhc2VBc3NldFN0cgMJAABmAAAAAgkAAZAAAAABCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAQkAAAIAAAABAgAAACBvbmx5IG9uZSBwYXltZW50IGNhbiBiZSBhdHRhY2hlZAQAAAAFcHJpY2UICQEAAAAJY2FsY1ByaWNlAAAABgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAACnBtdEFzc2V0SWQFAAAABWRlbHRhBQAAAAxzaGFyZUFzc2V0SWQFAAAAFmRlY2ltYWxzTXVsdEJvdGhBc3NldHMFAAAAEWRlY2ltYWxzTXVsdFByaWNlAAAAAl8xCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAMa2V5UHJpY2VMYXN0AAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAABXByaWNlCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAPa2V5UHJpY2VIaXN0b3J5AAAAAwUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAABmhlaWdodAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAFAAAABXByaWNlCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAABJ0b3BVcExhc3RIZWlnaHRLRVkFAAAABmhlaWdodAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAACmtleUJhbGFuY2UAAAABBQAAAAtwbXRBc3NldFN0cgkAAGQAAAACCQEAAAANYmFsYW5jZU9yWmVybwAAAAEFAAAAC3BtdEFzc2V0U3RyBQAAAAVkZWx0YQUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAFpAQAAABRjdXJyZW50U3lzUGFyYW1zUkVTVAAAAAEAAAAMYmFzZUFzc2V0U3RyBAAAAA1zeXNTdGF0ZVR1cGxlCQEAAAAbcHJpdmF0ZUN1cnJlbnRTeXNQYXJhbXNSRVNUAAAAAQUAAAAMYmFzZUFzc2V0U3RyBAAAAAVwcmljZQgIBQAAAA1zeXNTdGF0ZVR1cGxlAAAAAl8xAAAABXZhbHVlBAAAABFkZWNpbWFsc011bHRQcmljZQgIBQAAAA1zeXNTdGF0ZVR1cGxlAAAAAl8yAAAABXZhbHVlBAAAABBiYXNlQXNzZXRCYWxhbmNlCAgFAAAADXN5c1N0YXRlVHVwbGUAAAACXzMAAAAFdmFsdWUEAAAAFXRvdGFsTG9ja2VkQmFzZUFtb3VudAgIBQAAAA1zeXNTdGF0ZVR1cGxlAAAAAl80AAAABXZhbHVlBAAAAB9iYXNlQXNzZXRCYWxhbmNlQ29uc2lkZXJpbmdMb2NrCAgFAAAADXN5c1N0YXRlVHVwbGUAAAACXzUAAAAFdmFsdWUEAAAADXNoYXJlRW1pc3Npb24ICAUAAAANc3lzU3RhdGVUdXBsZQAAAAJfNgAAAAV2YWx1ZQQAAAAIcmVzdERhdGEJAAS5AAAAAgkABEwAAAACAgAAABlzdGFydEN1cnJlbnRTeXNQYXJhbXNSRVNUCQAETAAAAAIJAAGkAAAAAQUAAAAFcHJpY2UJAARMAAAAAgkAAaQAAAABBQAAABFkZWNpbWFsc011bHRQcmljZQkABEwAAAACCQABpAAAAAEFAAAAEGJhc2VBc3NldEJhbGFuY2UJAARMAAAAAgkAAaQAAAABBQAAABV0b3RhbExvY2tlZEJhc2VBbW91bnQJAARMAAAAAgkAAaQAAAABBQAAAB9iYXNlQXNzZXRCYWxhbmNlQ29uc2lkZXJpbmdMb2NrCQAETAAAAAIJAAGkAAAAAQUAAAANc2hhcmVFbWlzc2lvbgkABEwAAAACAgAAABdlbmRDdXJyZW50U3lzUGFyYW1zUkVTVAUAAAADbmlsBQAAAANTRVAJAAACAAAAAQUAAAAIcmVzdERhdGEAAAABaQEAAAAKc2V0TWFuYWdlcgAAAAEAAAAXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkEAAAAC2NoZWNrQ2FsbGVyCQEAAAALbXVzdE1hbmFnZXIAAAABBQAAAAFpAwkAAAAAAAACBQAAAAtjaGVja0NhbGxlcgUAAAALY2hlY2tDYWxsZXIEAAAAFWNoZWNrTWFuYWdlclB1YmxpY0tleQkAAlkAAAABBQAAABdwZW5kaW5nTWFuYWdlclB1YmxpY0tleQMJAAAAAAAAAgUAAAAVY2hlY2tNYW5hZ2VyUHVibGljS2V5BQAAABVjaGVja01hbmFnZXJQdWJsaWNLZXkJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAGmtleVBlbmRpbmdNYW5hZ2VyUHVibGljS2V5AAAAAAUAAAAXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAWkBAAAADmNvbmZpcm1NYW5hZ2VyAAAAAAQAAAACcG0JAQAAAB1wZW5kaW5nTWFuYWdlclB1YmxpY0tleU9yVW5pdAAAAAAEAAAABWhhc1BNAwkBAAAACWlzRGVmaW5lZAAAAAEFAAAAAnBtBgkAAAIAAAABAgAAABJubyBwZW5kaW5nIG1hbmFnZXIDCQAAAAAAAAIFAAAABWhhc1BNBQAAAAVoYXNQTQQAAAAHY2hlY2tQTQMJAAAAAAAAAggFAAAAAWkAAAAPY2FsbGVyUHVibGljS2V5CQEAAAAFdmFsdWUAAAABBQAAAAJwbQYJAAACAAAAAQIAAAAbeW91IGFyZSBub3QgcGVuZGluZyBtYW5hZ2VyAwkAAAAAAAACBQAAAAdjaGVja1BNBQAAAAdjaGVja1BNCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABNrZXlNYW5hZ2VyUHVibGljS2V5AAAAAAkAAlgAAAABCQEAAAAFdmFsdWUAAAABBQAAAAJwbQkABEwAAAACCQEAAAALRGVsZXRlRW50cnkAAAABCQEAAAAaa2V5UGVuZGluZ01hbmFnZXJQdWJsaWNLZXkAAAAABQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAEAAAACdHgBAAAABnZlcmlmeQAAAAAEAAAAD3RhcmdldFB1YmxpY0tleQQAAAAHJG1hdGNoMAkBAAAAFm1hbmFnZXJQdWJsaWNLZXlPclVuaXQAAAAAAwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAApCeXRlVmVjdG9yBAAAAAJwawUAAAAHJG1hdGNoMAUAAAACcGsDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAABFVuaXQIBQAAAAJ0eAAAAA9zZW5kZXJQdWJsaWNLZXkJAAACAAAAAQIAAAALTWF0Y2ggZXJyb3IJAAH0AAAAAwgFAAAAAnR4AAAACWJvZHlCeXRlcwkAAZEAAAACCAUAAAACdHgAAAAGcHJvb2ZzAAAAAAAAAAAABQAAAA90YXJnZXRQdWJsaWNLZXm48HPv",
    "chainId": 87,
    "height": 3263820,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: HsdxjLVauxtxPQbXXKJs3q2VyXxEXLTXXY6hUEvFkoMJ

Full: 
Old New Differences
1 - # no script
1 + {-# STDLIB_VERSION 5 #-}
2 + {-# SCRIPT_TYPE ACCOUNT #-}
3 + {-# CONTENT_TYPE DAPP #-}
4 + let SEP = "__"
5 + 
6 + let EMPTY = ""
7 + 
8 + func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
9 + 
10 + 
11 + func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
12 + 
13 + 
14 + func keyManagerPublicKey () = makeString(["%s", "managerPublicKey"], SEP)
15 + 
16 + 
17 + func keyPendingManagerPublicKey () = makeString(["%s", "pendingManagerPublicKey"], SEP)
18 + 
19 + 
20 + func failExecuteGet (msg,baseAssetStr,userAddressStr,getTxIdStr) = throw(((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " getTxIdStr=") + getTxIdStr))
21 + 
22 + 
23 + func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], SEP)
24 + 
25 + 
26 + func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
27 + 
28 + 
29 + func keyProxyAddress (assetId) = makeString(["%s%s", "proxyAddress", assetId], SEP)
30 + 
31 + 
32 + func keyBalance (assetId) = makeString(["%s%s", "balance", assetId], SEP)
33 + 
34 + 
35 + func keyNextInternalAssetId () = "%s__nextInternalAssetId"
36 + 
37 + 
38 + func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
39 + 
40 + 
41 + func keyTopUpLastHeight (internalBasetAssetStr,sender) = makeString(["%s%s%s%d%s__topup__last__height", internalBasetAssetStr, sender], SEP)
42 + 
43 + 
44 + func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
45 + 
46 + 
47 + func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
48 + 
49 + 
50 + func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
51 + 
52 + 
53 + func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
54 + 
55 + 
56 + func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
57 + 
58 + 
59 + func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
60 + 
61 + 
62 + func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
63 + 
64 + 
65 + func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
66 + 
67 + 
68 + func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
69 + 
70 + 
71 + func assetsStoreContract () = addressFromStringValue(value(getString(keyAssetsStoreContract())))
72 + 
73 + 
74 + let IdxCfgShareAssetId = 1
75 + 
76 + let IdxCfgInternalBaseAsset = 2
77 + 
78 + let IdxCfgDecimalsMultBothAssets = 3
79 + 
80 + let IdxCfgDecimalsMultPrice = 4
81 + 
82 + let IdxCfgGetDelayBlocks = 5
83 + 
84 + func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks) = makeString(["%s%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks)], SEP)
85 + 
86 + 
87 + let IdxTotalLockedShare = 1
88 + 
89 + let IdxTotalLockedBase = 2
90 + 
91 + func dataTotalLocked (shareAssetAmount,baseAssetAmount) = makeString(["%d%d", toString(shareAssetAmount), toString(baseAssetAmount)], SEP)
92 + 
93 + 
94 + func readTotalLocked (key) = {
95 +     let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0)), SEP)
96 + [-1, parseIntValue(totalLockedArray[IdxTotalLockedShare]), parseIntValue(totalLockedArray[IdxTotalLockedBase])]
97 +     }
98 + 
99 + 
100 + func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
101 + 
102 + 
103 + let IdxOperStatus = 1
104 + 
105 + let IdxOperInAmount = 2
106 + 
107 + let IdxOperPrice = 3
108 + 
109 + let IdxOperOutAmount = 4
110 + 
111 + let IdxOperStartHeight = 5
112 + 
113 + let IdxOperStartTimestamp = 6
114 + 
115 + let IdxOperEndHeight = 7
116 + 
117 + let IdxOperEndTimestamp = 8
118 + 
119 + func privateDataOperationAllStrings (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp) = makeString(["%s%d%d%d%d%d%d%d", status, inAssetAmount, price, outAssetAmount, startHeight, startTimestamp, endHeight, endTimestamp], SEP)
120 + 
121 + 
122 + func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp))
123 + 
124 + 
125 + func dataOperationExecutionUpdate (currOperArray,newStatus,newEndTimestamp) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], currOperArray[IdxOperPrice], currOperArray[IdxOperOutAmount], currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], currOperArray[IdxOperEndHeight], toString(newEndTimestamp))
126 + 
127 + 
128 + func readAssetCfgOrFail (baseAssetStr) = {
129 +     let key = keyAssetCfg(baseAssetStr)
130 +     split(getStringOrFail(key), SEP)
131 +     }
132 + 
133 + 
134 + func incrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
135 +     let dataArray = readTotalLocked(key)
136 +     StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] + shareAssetAmount), (dataArray[IdxTotalLockedBase] + baseAssetAmount)))
137 +     }
138 + 
139 + 
140 + func decrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
141 +     let dataArray = readTotalLocked(key)
142 +     StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] - shareAssetAmount), (dataArray[IdxTotalLockedBase] - baseAssetAmount)))
143 +     }
144 + 
145 + 
146 + func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
147 +     case s: String => 
148 +         fromBase58String(s)
149 +     case _: Unit => 
150 +         unit
151 +     case _ => 
152 +         throw("Match error")
153 + }
154 + 
155 + 
156 + func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
157 +     case s: String => 
158 +         fromBase58String(s)
159 +     case _: Unit => 
160 +         unit
161 +     case _ => 
162 +         throw("Match error")
163 + }
164 + 
165 + 
166 + func balanceOrZero (assetId) = valueOrElse(getInteger(keyBalance(assetId)), 0)
167 + 
168 + 
169 + func calcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = {
170 +     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
171 +     let totalLockedBaseAmount = totalLockedArray[IdxTotalLockedBase]
172 +     let baseAssetBalance = balanceOrZero(toBase58String(baseAssetId))
173 +     let baseAssetBalanceConsideringLock = (baseAssetBalance + topUpBaseAmount)
174 +     if ((0 > baseAssetBalanceConsideringLock))
175 +         then throw(((("baseAssetBalanceConsideringLock < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceConsideringLock=") + toString(baseAssetBalanceConsideringLock)))
176 +         else {
177 +             let shareEmission = value(assetInfo(shareAssetId)).quantity
178 +             let price = if ((shareEmission == 0))
179 +                 then (1 * decimalsMultPrice)
180 +                 else fraction(baseAssetBalanceConsideringLock, decimalsMultPrice, shareEmission)
181 +             $Tuple5(price, baseAssetBalance, totalLockedBaseAmount, baseAssetBalanceConsideringLock, shareEmission)
182 +             }
183 +     }
184 + 
185 + 
186 + func getPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = {
187 +     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
188 +     let totalLockedBaseAmount = totalLockedArray[IdxTotalLockedBase]
189 +     let baseAssetBalance = balanceOrZero(toBase58String(baseAssetId))
190 +     let baseAssetBalanceConsideringLock = baseAssetBalance
191 +     let shareEmission = value(assetInfo(shareAssetId)).quantity
192 +     let price = value(getInteger(keyPriceLast(internalBaseAssetStr)))
193 +     $Tuple5(price, baseAssetBalance, totalLockedBaseAmount, baseAssetBalanceConsideringLock, shareEmission)
194 +     }
195 + 
196 + 
197 + func privateCurrentSysParamsREST (baseAssetStr) = {
198 +     let baseAssetId = fromBase58String(baseAssetStr)
199 +     let cfgArray = readAssetCfgOrFail(baseAssetStr)
200 +     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
201 +     let shareAssetId = fromBase58String(shareAssetStr)
202 +     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
203 +     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
204 +     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
205 +     let sysState = getPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)
206 +     let topUpLastHeight =     match getInteger(keyTopUpLastHeight(internalBaseAssetStr, getStringValue(keyProxyAddress(baseAssetStr)))) {
207 +         case h: Int => 
208 +             value(h)
209 +         case _: Unit => 
210 +             getIntegerValue(keyTopUpLastHeight(internalBaseAssetStr, toString(addressFromPublicKey(fromBase58String(getStringValue(keyManagerPublicKey()))))))
211 +         case _ => 
212 +             throw("undefined behaviour in privateCurrentSysParamsREST match")
213 +     }
214 +     $Tuple8(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5), IntegerEntry("baseAssetDecimals", value(assetInfo(baseAssetId)).decimals), IntegerEntry("lastTopUpTimestamp", value(blockInfoByHeight(topUpLastHeight)).timestamp))
215 +     }
216 + 
217 + 
218 + func mustManager (i) = {
219 +     let pd = throw("permission denied")
220 +     match managerPublicKeyOrUnit() {
221 +         case pk: ByteVector => 
222 +             if ((i.callerPublicKey == pk))
223 +                 then true
224 +                 else pd
225 +         case _: Unit => 
226 +             if ((i.caller == this))
227 +                 then true
228 +                 else pd
229 +         case _ => 
230 +             throw("Match error")
231 +     }
232 +     }
233 + 
234 + 
235 + func mustProxyAddress (i,assetId) = {
236 +     let isProxy = (toString(i.caller) == valueOrElse(getString(keyProxyAddress(assetId)), EMPTY))
237 +     if (isProxy)
238 +         then true
239 +         else {
240 +             let checkCaller = mustManager(i)
241 +             if ((checkCaller == checkCaller))
242 +                 then true
243 +                 else throw("Strict value is not equal to itself.")
244 +             }
245 +     }
246 + 
247 + 
248 + @Callable(i)
249 + func constructor (assetsStoreContract) = {
250 +     let checkCaller = mustManager(i)
251 +     if ((checkCaller == checkCaller))
252 +         then [StringEntry(keyAssetsStoreContract(), assetsStoreContract)]
253 +         else throw("Strict value is not equal to itself.")
254 +     }
255 + 
256 + 
257 + 
258 + @Callable(i)
259 + func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,shareAssetLogo,getDelayinBlocks,shutdownManagerAddress,proxyAddress) = {
260 +     let baseAssetId = fromBase58String(baseAssetStr)
261 +     let decimals = value(assetInfo(baseAssetId)).decimals
262 +     let check = mustManager(i)
263 +     if ((check == check))
264 +         then if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
265 +             then throw("invalid shutdownManagerAddress")
266 +             else if ((0 > getDelayinBlocks))
267 +                 then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
268 +                 else {
269 +                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, 1, decimals, true)
270 +                     let shareAssetId = calculateAssetId(shareAssetIssueAction)
271 +                     let shareAssetStr = toBase58String(shareAssetId)
272 +                     let decimalsMultPrice = ((100 * 1000) * 1000)
273 +                     let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
274 +                     let startPrice = (1 * decimalsMultPrice)
275 +                     let internalBaseAssettId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
276 +                     let internalBaseAssetStr = toString(internalBaseAssettId)
277 + [StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssettId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownPutOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssettId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), shareAssetIssueAction, Burn(shareAssetId, 1), StringEntry(keyProxyAddress(baseAssetStr), proxyAddress)]
278 +                     }
279 +         else throw("Strict value is not equal to itself.")
280 +     }
281 + 
282 + 
283 + 
284 + @Callable(i)
285 + func shutdownPut (internalBaseAssetId) = {
286 +     let internalBaseAssetIdStr = toString(internalBaseAssetId)
287 +     let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
288 +     let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
289 +     if ((1 > size(baseAssetIdStr)))
290 +         then throw("invalid internalBaseAssetId")
291 +         else if ((toString(i.caller) != shutdownManagerAddress))
292 +             then throw("access denied")
293 +             else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
294 +     }
295 + 
296 + 
297 + 
298 + @Callable(i)
299 + func put () = {
300 +     let pmt = value(i.payments[0])
301 +     let baseAssetId = value(pmt.assetId)
302 +     let baseAssetStr = toBase58String(baseAssetId)
303 +     let userAddressStr = toString(i.caller)
304 +     let cfgArray = readAssetCfgOrFail(baseAssetStr)
305 +     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
306 +     let shareAssetId = fromBase58String(shareAssetStr)
307 +     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
308 +     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
309 +     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
310 +     let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
311 +     if (isPutBlocked)
312 +         then throw("put operation is blocked")
313 +         else {
314 +             let newBalance = (balanceOrZero(baseAssetStr) + pmt.amount)
315 +             let price = getPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
316 +             let shareAssetAmount = fraction(pmt.amount, decimalsMultPrice, price, CEILING)
317 + [Reissue(shareAssetId, shareAssetAmount, true), ScriptTransfer(i.caller, shareAssetAmount, shareAssetId), StringEntry(keyOperation("P", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("FINISHED", pmt.amount, price, shareAssetAmount, height, lastBlock.timestamp, height, lastBlock.timestamp)), ScriptTransfer(addressFromStringValue(value(getString(keyProxyAddress(baseAssetStr)))), pmt.amount, baseAssetId), IntegerEntry(keyBalance(baseAssetStr), newBalance)]
318 +             }
319 +     }
320 + 
321 + 
322 + 
323 + @Callable(i)
324 + func submitGetRequest () = {
325 +     let pmt = value(i.payments[0])
326 +     let shareAssetId = value(pmt.assetId)
327 +     let shareAssetStr = toBase58String(shareAssetId)
328 +     let callerPubStr = toBase58String(i.callerPublicKey)
329 +     let userAddress = i.caller
330 +     let userAddressStr = toString(userAddress)
331 +     let shareAssetAmount = pmt.amount
332 +     let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
333 +     let baseAssetId = fromBase58String(baseAssetStr)
334 +     let cfgArray = readAssetCfgOrFail(baseAssetStr)
335 +     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
336 +     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
337 +     let getDelayBlocks = parseIntValue(cfgArray[IdxCfgGetDelayBlocks])
338 +     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
339 +     let price = getPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
340 +     let baseAssetAmount = fraction(shareAssetAmount, price, decimalsMultPrice)
341 +     let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId))
342 +     let operationData = dataOperation("PENDING", shareAssetAmount, price, baseAssetAmount, height, lastBlock.timestamp, (height + getDelayBlocks), 0)
343 + [Burn(shareAssetId, shareAssetAmount), StringEntry(operationKey, operationData), incrementTotalLocked(keyTotalLocked(internalBaseAssetStr), shareAssetAmount, baseAssetAmount), incrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), shareAssetAmount, baseAssetAmount), IntegerEntry(keyBalance(baseAssetStr), (balanceOrZero(baseAssetStr) - baseAssetAmount))]
344 +     }
345 + 
346 + 
347 + 
348 + @Callable(i)
349 + func executeGetRequest (baseAssetStr,userAddressStr,getTxIdStr) = {
350 +     let userAddress = addressFromStringValue(userAddressStr)
351 +     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
352 +     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
353 +     let baseAssetId = fromBase58String(baseAssetStr)
354 +     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
355 +     let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, getTxIdStr)
356 +     let operationArray = split(getStringOrFail(operationKey), SEP)
357 +     let status = operationArray[IdxOperStatus]
358 +     let endHeight = parseIntValue(operationArray[IdxOperEndHeight])
359 +     let inShareAmount = parseIntValue(operationArray[IdxOperInAmount])
360 +     let outBaseAmount = parseIntValue(operationArray[IdxOperOutAmount])
361 +     if ((status != "PENDING"))
362 +         then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, getTxIdStr)
363 +         else if ((endHeight > height))
364 +             then failExecuteGet(((("EndHeight[" + toString(endHeight)) + "] > ") + toString(height)), baseAssetStr, userAddressStr, getTxIdStr)
365 +             else [ScriptTransfer(userAddress, outBaseAmount, baseAssetId), StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", lastBlock.timestamp)), decrementTotalLocked(keyTotalLocked(internalBaseAssetStr), inShareAmount, outBaseAmount), decrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), inShareAmount, outBaseAmount)]
366 +     }
367 + 
368 + 
369 + 
370 + @Callable(i)
371 + func topUpBalance (baseAssetStr,delta) = {
372 +     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
373 +     let pmt = value(i.payments[0])
374 +     let pmtAssetId = value(pmt.assetId)
375 +     let pmtAssetStr = toBase58String(pmtAssetId)
376 +     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
377 +     let decimalsMultBothAssets = parseIntValue(assetCfgArray[IdxCfgDecimalsMultBothAssets])
378 +     let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
379 +     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
380 +     let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
381 +     let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
382 +     let checks = [mustProxyAddress(i, baseAssetStr), if ((topUpLastHeight != height))
383 +         then true
384 +         else throw("only one topUp per block is allowed"), if ((delta > 0))
385 +         then true
386 +         else throw("only positive delta is allowed")]
387 +     if ((checks == checks))
388 +         then if ((baseAssetStr != pmtAssetStr))
389 +             then throw("attached payment's asset id is NOT matched passed baseAssetStr")
390 +             else if ((size(i.payments) > 1))
391 +                 then throw("only one payment can be attached")
392 +                 else {
393 +                     let price = calcPrice(internalBaseAssetStr, pmtAssetId, delta, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
394 + [IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(topUpLastHeightKEY, height), IntegerEntry(keyBalance(pmtAssetStr), (balanceOrZero(pmtAssetStr) + delta))]
395 +                     }
396 +         else throw("Strict value is not equal to itself.")
397 +     }
398 + 
399 + 
400 + 
401 + @Callable(i)
402 + func currentSysParamsREST (baseAssetStr) = {
403 +     let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
404 +     let price = sysStateTuple._1.value
405 +     let decimalsMultPrice = sysStateTuple._2.value
406 +     let baseAssetBalance = sysStateTuple._3.value
407 +     let totalLockedBaseAmount = sysStateTuple._4.value
408 +     let baseAssetBalanceConsideringLock = sysStateTuple._5.value
409 +     let shareEmission = sysStateTuple._6.value
410 +     let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
411 +     throw(restData)
412 +     }
413 + 
414 + 
415 + 
416 + @Callable(i)
417 + func setManager (pendingManagerPublicKey) = {
418 +     let checkCaller = mustManager(i)
419 +     if ((checkCaller == checkCaller))
420 +         then {
421 +             let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
422 +             if ((checkManagerPublicKey == checkManagerPublicKey))
423 +                 then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
424 +                 else throw("Strict value is not equal to itself.")
425 +             }
426 +         else throw("Strict value is not equal to itself.")
427 +     }
428 + 
429 + 
430 + 
431 + @Callable(i)
432 + func confirmManager () = {
433 +     let pm = pendingManagerPublicKeyOrUnit()
434 +     let hasPM = if (isDefined(pm))
435 +         then true
436 +         else throw("no pending manager")
437 +     if ((hasPM == hasPM))
438 +         then {
439 +             let checkPM = if ((i.callerPublicKey == value(pm)))
440 +                 then true
441 +                 else throw("you are not pending manager")
442 +             if ((checkPM == checkPM))
443 +                 then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
444 +                 else throw("Strict value is not equal to itself.")
445 +             }
446 +         else throw("Strict value is not equal to itself.")
447 +     }
448 + 
449 + 
450 + @Verifier(tx)
451 + func verify () = {
452 +     let targetPublicKey =     match managerPublicKeyOrUnit() {
453 +         case pk: ByteVector => 
454 +             pk
455 +         case _: Unit => 
456 +             tx.senderPublicKey
457 +         case _ => 
458 +             throw("Match error")
459 +     }
460 +     sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
461 +     }
462 +

Old	New		Differences
1		-	# no script
	1	+	{-# STDLIB_VERSION 5 #-}
	2	+	{-# SCRIPT_TYPE ACCOUNT #-}
	3	+	{-# CONTENT_TYPE DAPP #-}
	4	+	let SEP = "__"
	5	+
	6	+	let EMPTY = ""
	7	+
	8	+	func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
	9	+
	10	+
	11	+	func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
	12	+
	13	+
	14	+	func keyManagerPublicKey () = makeString(["%s", "managerPublicKey"], SEP)
	15	+
	16	+
	17	+	func keyPendingManagerPublicKey () = makeString(["%s", "pendingManagerPublicKey"], SEP)
	18	+
	19	+
	20	+	func failExecuteGet (msg,baseAssetStr,userAddressStr,getTxIdStr) = throw(((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " getTxIdStr=") + getTxIdStr))
	21	+
	22	+
	23	+	func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], SEP)
	24	+
	25	+
	26	+	func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
	27	+
	28	+
	29	+	func keyProxyAddress (assetId) = makeString(["%s%s", "proxyAddress", assetId], SEP)
	30	+
	31	+
	32	+	func keyBalance (assetId) = makeString(["%s%s", "balance", assetId], SEP)
	33	+
	34	+
	35	+	func keyNextInternalAssetId () = "%s__nextInternalAssetId"
	36	+
	37	+
	38	+	func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
	39	+
	40	+
	41	+	func keyTopUpLastHeight (internalBasetAssetStr,sender) = makeString(["%s%s%s%d%s__topup__last__height", internalBasetAssetStr, sender], SEP)
	42	+
	43	+
	44	+	func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
	45	+
	46	+
	47	+	func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
	48	+
	49	+
	50	+	func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
	51	+
	52	+
	53	+	func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
	54	+
	55	+
	56	+	func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
	57	+
	58	+
	59	+	func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
	60	+
	61	+
	62	+	func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
	63	+
	64	+
	65	+	func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
	66	+
	67	+
	68	+	func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
	69	+
	70	+
	71	+	func assetsStoreContract () = addressFromStringValue(value(getString(keyAssetsStoreContract())))
	72	+
	73	+
	74	+	let IdxCfgShareAssetId = 1
	75	+
	76	+	let IdxCfgInternalBaseAsset = 2
	77	+
	78	+	let IdxCfgDecimalsMultBothAssets = 3
	79	+
	80	+	let IdxCfgDecimalsMultPrice = 4
	81	+
	82	+	let IdxCfgGetDelayBlocks = 5
	83	+
	84	+	func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks) = makeString(["%s%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks)], SEP)
	85	+
	86	+
	87	+	let IdxTotalLockedShare = 1
	88	+
	89	+	let IdxTotalLockedBase = 2
	90	+
	91	+	func dataTotalLocked (shareAssetAmount,baseAssetAmount) = makeString(["%d%d", toString(shareAssetAmount), toString(baseAssetAmount)], SEP)
	92	+
	93	+
	94	+	func readTotalLocked (key) = {
	95	+	let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0)), SEP)
	96	+	[-1, parseIntValue(totalLockedArray[IdxTotalLockedShare]), parseIntValue(totalLockedArray[IdxTotalLockedBase])]
	97	+	}
	98	+
	99	+
	100	+	func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
	101	+
	102	+
	103	+	let IdxOperStatus = 1
	104	+
	105	+	let IdxOperInAmount = 2
	106	+
	107	+	let IdxOperPrice = 3
	108	+
	109	+	let IdxOperOutAmount = 4
	110	+
	111	+	let IdxOperStartHeight = 5
	112	+
	113	+	let IdxOperStartTimestamp = 6
	114	+
	115	+	let IdxOperEndHeight = 7
	116	+
	117	+	let IdxOperEndTimestamp = 8
	118	+
	119	+	func privateDataOperationAllStrings (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp) = makeString(["%s%d%d%d%d%d%d%d", status, inAssetAmount, price, outAssetAmount, startHeight, startTimestamp, endHeight, endTimestamp], SEP)
	120	+
	121	+
	122	+	func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp))
	123	+
	124	+
	125	+	func dataOperationExecutionUpdate (currOperArray,newStatus,newEndTimestamp) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], currOperArray[IdxOperPrice], currOperArray[IdxOperOutAmount], currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], currOperArray[IdxOperEndHeight], toString(newEndTimestamp))
	126	+
	127	+
	128	+	func readAssetCfgOrFail (baseAssetStr) = {
	129	+	let key = keyAssetCfg(baseAssetStr)
	130	+	split(getStringOrFail(key), SEP)
	131	+	}
	132	+
	133	+
	134	+	func incrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
	135	+	let dataArray = readTotalLocked(key)
	136	+	StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] + shareAssetAmount), (dataArray[IdxTotalLockedBase] + baseAssetAmount)))
	137	+	}
	138	+
	139	+
	140	+	func decrementTotalLocked (key,shareAssetAmount,baseAssetAmount) = {
	141	+	let dataArray = readTotalLocked(key)
	142	+	StringEntry(key, dataTotalLocked((dataArray[IdxTotalLockedShare] - shareAssetAmount), (dataArray[IdxTotalLockedBase] - baseAssetAmount)))
	143	+	}
	144	+
	145	+
	146	+	func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
	147	+	case s: String =>
	148	+	fromBase58String(s)
	149	+	case _: Unit =>
	150	+	unit
	151	+	case _ =>
	152	+	throw("Match error")
	153	+	}
	154	+
	155	+
	156	+	func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
	157	+	case s: String =>
	158	+	fromBase58String(s)
	159	+	case _: Unit =>
	160	+	unit
	161	+	case _ =>
	162	+	throw("Match error")
	163	+	}
	164	+
	165	+
	166	+	func balanceOrZero (assetId) = valueOrElse(getInteger(keyBalance(assetId)), 0)
	167	+
	168	+
	169	+	func calcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = {
	170	+	let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
	171	+	let totalLockedBaseAmount = totalLockedArray[IdxTotalLockedBase]
	172	+	let baseAssetBalance = balanceOrZero(toBase58String(baseAssetId))
	173	+	let baseAssetBalanceConsideringLock = (baseAssetBalance + topUpBaseAmount)
	174	+	if ((0 > baseAssetBalanceConsideringLock))
	175	+	then throw(((("baseAssetBalanceConsideringLock < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceConsideringLock=") + toString(baseAssetBalanceConsideringLock)))
	176	+	else {
	177	+	let shareEmission = value(assetInfo(shareAssetId)).quantity
	178	+	let price = if ((shareEmission == 0))
	179	+	then (1 * decimalsMultPrice)
	180	+	else fraction(baseAssetBalanceConsideringLock, decimalsMultPrice, shareEmission)
	181	+	$Tuple5(price, baseAssetBalance, totalLockedBaseAmount, baseAssetBalanceConsideringLock, shareEmission)
	182	+	}
	183	+	}
	184	+
	185	+
	186	+	func getPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultBothAssets,decimalsMultPrice) = {
	187	+	let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
	188	+	let totalLockedBaseAmount = totalLockedArray[IdxTotalLockedBase]
	189	+	let baseAssetBalance = balanceOrZero(toBase58String(baseAssetId))
	190	+	let baseAssetBalanceConsideringLock = baseAssetBalance
	191	+	let shareEmission = value(assetInfo(shareAssetId)).quantity
	192	+	let price = value(getInteger(keyPriceLast(internalBaseAssetStr)))
	193	+	$Tuple5(price, baseAssetBalance, totalLockedBaseAmount, baseAssetBalanceConsideringLock, shareEmission)
	194	+	}
	195	+
	196	+
	197	+	func privateCurrentSysParamsREST (baseAssetStr) = {
	198	+	let baseAssetId = fromBase58String(baseAssetStr)
	199	+	let cfgArray = readAssetCfgOrFail(baseAssetStr)
	200	+	let shareAssetStr = cfgArray[IdxCfgShareAssetId]
	201	+	let shareAssetId = fromBase58String(shareAssetStr)
	202	+	let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
	203	+	let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
	204	+	let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	205	+	let sysState = getPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)
	206	+	let topUpLastHeight = match getInteger(keyTopUpLastHeight(internalBaseAssetStr, getStringValue(keyProxyAddress(baseAssetStr)))) {
	207	+	case h: Int =>
	208	+	value(h)
	209	+	case _: Unit =>
	210	+	getIntegerValue(keyTopUpLastHeight(internalBaseAssetStr, toString(addressFromPublicKey(fromBase58String(getStringValue(keyManagerPublicKey()))))))
	211	+	case _ =>
	212	+	throw("undefined behaviour in privateCurrentSysParamsREST match")
	213	+	}
	214	+	$Tuple8(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5), IntegerEntry("baseAssetDecimals", value(assetInfo(baseAssetId)).decimals), IntegerEntry("lastTopUpTimestamp", value(blockInfoByHeight(topUpLastHeight)).timestamp))
	215	+	}
	216	+
	217	+
	218	+	func mustManager (i) = {
	219	+	let pd = throw("permission denied")
	220	+	match managerPublicKeyOrUnit() {
	221	+	case pk: ByteVector =>
	222	+	if ((i.callerPublicKey == pk))
	223	+	then true
	224	+	else pd
	225	+	case _: Unit =>
	226	+	if ((i.caller == this))
	227	+	then true
	228	+	else pd
	229	+	case _ =>
	230	+	throw("Match error")
	231	+	}
	232	+	}
	233	+
	234	+
	235	+	func mustProxyAddress (i,assetId) = {
	236	+	let isProxy = (toString(i.caller) == valueOrElse(getString(keyProxyAddress(assetId)), EMPTY))
	237	+	if (isProxy)
	238	+	then true
	239	+	else {
	240	+	let checkCaller = mustManager(i)
	241	+	if ((checkCaller == checkCaller))
	242	+	then true
	243	+	else throw("Strict value is not equal to itself.")
	244	+	}
	245	+	}
	246	+
	247	+
	248	+	@Callable(i)
	249	+	func constructor (assetsStoreContract) = {
	250	+	let checkCaller = mustManager(i)
	251	+	if ((checkCaller == checkCaller))
	252	+	then [StringEntry(keyAssetsStoreContract(), assetsStoreContract)]
	253	+	else throw("Strict value is not equal to itself.")
	254	+	}
	255	+
	256	+
	257	+
	258	+	@Callable(i)
	259	+	func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,shareAssetLogo,getDelayinBlocks,shutdownManagerAddress,proxyAddress) = {
	260	+	let baseAssetId = fromBase58String(baseAssetStr)
	261	+	let decimals = value(assetInfo(baseAssetId)).decimals
	262	+	let check = mustManager(i)
	263	+	if ((check == check))
	264	+	then if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
	265	+	then throw("invalid shutdownManagerAddress")
	266	+	else if ((0 > getDelayinBlocks))
	267	+	then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
	268	+	else {
	269	+	let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, 1, decimals, true)
	270	+	let shareAssetId = calculateAssetId(shareAssetIssueAction)
	271	+	let shareAssetStr = toBase58String(shareAssetId)
	272	+	let decimalsMultPrice = ((100 * 1000) * 1000)
	273	+	let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
	274	+	let startPrice = (1 * decimalsMultPrice)
	275	+	let internalBaseAssettId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
	276	+	let internalBaseAssetStr = toString(internalBaseAssettId)
	277	+	[StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssettId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownPutOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssettId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), shareAssetIssueAction, Burn(shareAssetId, 1), StringEntry(keyProxyAddress(baseAssetStr), proxyAddress)]
	278	+	}
	279	+	else throw("Strict value is not equal to itself.")
	280	+	}
	281	+
	282	+
	283	+
	284	+	@Callable(i)
	285	+	func shutdownPut (internalBaseAssetId) = {
	286	+	let internalBaseAssetIdStr = toString(internalBaseAssetId)
	287	+	let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
	288	+	let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
	289	+	if ((1 > size(baseAssetIdStr)))
	290	+	then throw("invalid internalBaseAssetId")
	291	+	else if ((toString(i.caller) != shutdownManagerAddress))
	292	+	then throw("access denied")
	293	+	else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
	294	+	}
	295	+
	296	+
	297	+
	298	+	@Callable(i)
	299	+	func put () = {
	300	+	let pmt = value(i.payments[0])
	301	+	let baseAssetId = value(pmt.assetId)
	302	+	let baseAssetStr = toBase58String(baseAssetId)
	303	+	let userAddressStr = toString(i.caller)
	304	+	let cfgArray = readAssetCfgOrFail(baseAssetStr)
	305	+	let shareAssetStr = cfgArray[IdxCfgShareAssetId]
	306	+	let shareAssetId = fromBase58String(shareAssetStr)
	307	+	let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
	308	+	let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
	309	+	let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	310	+	let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
	311	+	if (isPutBlocked)
	312	+	then throw("put operation is blocked")
	313	+	else {
	314	+	let newBalance = (balanceOrZero(baseAssetStr) + pmt.amount)
	315	+	let price = getPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
	316	+	let shareAssetAmount = fraction(pmt.amount, decimalsMultPrice, price, CEILING)
	317	+	[Reissue(shareAssetId, shareAssetAmount, true), ScriptTransfer(i.caller, shareAssetAmount, shareAssetId), StringEntry(keyOperation("P", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("FINISHED", pmt.amount, price, shareAssetAmount, height, lastBlock.timestamp, height, lastBlock.timestamp)), ScriptTransfer(addressFromStringValue(value(getString(keyProxyAddress(baseAssetStr)))), pmt.amount, baseAssetId), IntegerEntry(keyBalance(baseAssetStr), newBalance)]
	318	+	}
	319	+	}
	320	+
	321	+
	322	+
	323	+	@Callable(i)
	324	+	func submitGetRequest () = {
	325	+	let pmt = value(i.payments[0])
	326	+	let shareAssetId = value(pmt.assetId)
	327	+	let shareAssetStr = toBase58String(shareAssetId)
	328	+	let callerPubStr = toBase58String(i.callerPublicKey)
	329	+	let userAddress = i.caller
	330	+	let userAddressStr = toString(userAddress)
	331	+	let shareAssetAmount = pmt.amount
	332	+	let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
	333	+	let baseAssetId = fromBase58String(baseAssetStr)
	334	+	let cfgArray = readAssetCfgOrFail(baseAssetStr)
	335	+	let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
	336	+	let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
	337	+	let getDelayBlocks = parseIntValue(cfgArray[IdxCfgGetDelayBlocks])
	338	+	let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
	339	+	let price = getPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
	340	+	let baseAssetAmount = fraction(shareAssetAmount, price, decimalsMultPrice)
	341	+	let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId))
	342	+	let operationData = dataOperation("PENDING", shareAssetAmount, price, baseAssetAmount, height, lastBlock.timestamp, (height + getDelayBlocks), 0)
	343	+	[Burn(shareAssetId, shareAssetAmount), StringEntry(operationKey, operationData), incrementTotalLocked(keyTotalLocked(internalBaseAssetStr), shareAssetAmount, baseAssetAmount), incrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), shareAssetAmount, baseAssetAmount), IntegerEntry(keyBalance(baseAssetStr), (balanceOrZero(baseAssetStr) - baseAssetAmount))]
	344	+	}
	345	+
	346	+
	347	+
	348	+	@Callable(i)
	349	+	func executeGetRequest (baseAssetStr,userAddressStr,getTxIdStr) = {
	350	+	let userAddress = addressFromStringValue(userAddressStr)
	351	+	let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
	352	+	let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
	353	+	let baseAssetId = fromBase58String(baseAssetStr)
	354	+	let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
	355	+	let operationKey = keyOperation("G", internalBaseAssetStr, userAddressStr, getTxIdStr)
	356	+	let operationArray = split(getStringOrFail(operationKey), SEP)
	357	+	let status = operationArray[IdxOperStatus]
	358	+	let endHeight = parseIntValue(operationArray[IdxOperEndHeight])
	359	+	let inShareAmount = parseIntValue(operationArray[IdxOperInAmount])
	360	+	let outBaseAmount = parseIntValue(operationArray[IdxOperOutAmount])
	361	+	if ((status != "PENDING"))
	362	+	then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, getTxIdStr)
	363	+	else if ((endHeight > height))
	364	+	then failExecuteGet(((("EndHeight[" + toString(endHeight)) + "] > ") + toString(height)), baseAssetStr, userAddressStr, getTxIdStr)
	365	+	else [ScriptTransfer(userAddress, outBaseAmount, baseAssetId), StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", lastBlock.timestamp)), decrementTotalLocked(keyTotalLocked(internalBaseAssetStr), inShareAmount, outBaseAmount), decrementTotalLocked(keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), inShareAmount, outBaseAmount)]
	366	+	}
	367	+
	368	+
	369	+
	370	+	@Callable(i)
	371	+	func topUpBalance (baseAssetStr,delta) = {
	372	+	let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
	373	+	let pmt = value(i.payments[0])
	374	+	let pmtAssetId = value(pmt.assetId)
	375	+	let pmtAssetStr = toBase58String(pmtAssetId)
	376	+	let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
	377	+	let decimalsMultBothAssets = parseIntValue(assetCfgArray[IdxCfgDecimalsMultBothAssets])
	378	+	let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
	379	+	let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
	380	+	let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
	381	+	let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
	382	+	let checks = [mustProxyAddress(i, baseAssetStr), if ((topUpLastHeight != height))
	383	+	then true
	384	+	else throw("only one topUp per block is allowed"), if ((delta > 0))
	385	+	then true
	386	+	else throw("only positive delta is allowed")]
	387	+	if ((checks == checks))
	388	+	then if ((baseAssetStr != pmtAssetStr))
	389	+	then throw("attached payment's asset id is NOT matched passed baseAssetStr")
	390	+	else if ((size(i.payments) > 1))
	391	+	then throw("only one payment can be attached")
	392	+	else {
	393	+	let price = calcPrice(internalBaseAssetStr, pmtAssetId, delta, shareAssetId, decimalsMultBothAssets, decimalsMultPrice)._1
	394	+	[IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(topUpLastHeightKEY, height), IntegerEntry(keyBalance(pmtAssetStr), (balanceOrZero(pmtAssetStr) + delta))]
	395	+	}
	396	+	else throw("Strict value is not equal to itself.")
	397	+	}
	398	+
	399	+
	400	+
	401	+	@Callable(i)
	402	+	func currentSysParamsREST (baseAssetStr) = {
	403	+	let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
	404	+	let price = sysStateTuple._1.value
	405	+	let decimalsMultPrice = sysStateTuple._2.value
	406	+	let baseAssetBalance = sysStateTuple._3.value
	407	+	let totalLockedBaseAmount = sysStateTuple._4.value
	408	+	let baseAssetBalanceConsideringLock = sysStateTuple._5.value
	409	+	let shareEmission = sysStateTuple._6.value
	410	+	let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
	411	+	throw(restData)
	412	+	}
	413	+
	414	+
	415	+
	416	+	@Callable(i)
	417	+	func setManager (pendingManagerPublicKey) = {
	418	+	let checkCaller = mustManager(i)
	419	+	if ((checkCaller == checkCaller))
	420	+	then {
	421	+	let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
	422	+	if ((checkManagerPublicKey == checkManagerPublicKey))
	423	+	then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
	424	+	else throw("Strict value is not equal to itself.")
	425	+	}
	426	+	else throw("Strict value is not equal to itself.")
	427	+	}
	428	+
	429	+
	430	+
	431	+	@Callable(i)
	432	+	func confirmManager () = {
	433	+	let pm = pendingManagerPublicKeyOrUnit()
	434	+	let hasPM = if (isDefined(pm))
	435	+	then true
	436	+	else throw("no pending manager")
	437	+	if ((hasPM == hasPM))
	438	+	then {
	439	+	let checkPM = if ((i.callerPublicKey == value(pm)))
	440	+	then true
	441	+	else throw("you are not pending manager")
	442	+	if ((checkPM == checkPM))
	443	+	then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
	444	+	else throw("Strict value is not equal to itself.")
	445	+	}
	446	+	else throw("Strict value is not equal to itself.")
	447	+	}
	448	+
	449	+
	450	+	@Verifier(tx)
	451	+	func verify () = {
	452	+	let targetPublicKey = match managerPublicKeyOrUnit() {
	453	+	case pk: ByteVector =>
	454	+	pk
	455	+	case _: Unit =>
	456	+	tx.senderPublicKey
	457	+	case _ =>
	458	+	throw("Match error")
	459	+	}
	460	+	sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
	461	+	}
	462	+

github/deemru/w8io/3ef1775 
31.21 ms ◑