tx · DtnPPqZXor71n3iJtMQAB13ee419iGiCDx5qvcKjrPbD

3NC9wWawxuFG6a3sZdfckGwoMeVhLFjZFwH:  -0.01400000 Waves

2021.03.26 13:36 [1454597] smart account 3NC9wWawxuFG6a3sZdfckGwoMeVhLFjZFwH > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DtnPPqZXor71n3iJtMQAB13ee419iGiCDx5qvcKjrPbD",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1616755021238,
    "version": 1,
    "sender": "3NC9wWawxuFG6a3sZdfckGwoMeVhLFjZFwH",
    "senderPublicKey": "HoEvP2nFKMAsffQ9PUyAm6auWisyHgusY9HxDeMASrzZ",
    "proofs": [
        "2kHxkTQKemB8XTgkXTNhvgdZiJRMXDLMaZEUC4emqo3PXNKa2BAgs533yWZNu3dMnyS6Ftw13JftXQeDzs9Jp4Yu"
    ],
    "script": "base64:AAIEAAAAAAAAADoIAhIPCg0ICAgBCAEBAQgBAQEBEgMKAQESABIAEgUKAwgICBIFCgMICAgSAwoBCBIECgIIARIDCgEIAAAASgAAAAADU0VQAgAAAAJfXwEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQAAAANrZXkJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABB0AAAACBQAAAAR0aGlzBQAAAANrZXkJAAEsAAAAAgIAAAAVTm8gZGF0YSBmb3IgdGhpcy5rZXk9BQAAAANrZXkBAAAAEGdldEJvb2xlYW5PckZhaWwAAAABAAAAA2tleQkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEGwAAAAIFAAAABHRoaXMFAAAAA2tleQkAASwAAAACAgAAABVObyBkYXRhIGZvciB0aGlzLmtleT0FAAAAA2tleQEAAAAMZ2V0SW50T3JGYWlsAAAAAQAAAANrZXkJAQAAABN2YWx1ZU9yRXJyb3JNZXNzYWdlAAAAAgkABBoAAAACBQAAAAR0aGlzBQAAAANrZXkJAAEsAAAAAgIAAAAVTm8gZGF0YSBmb3IgdGhpcy5rZXk9BQAAAANrZXkBAAAADmZhaWxFeGVjdXRlR2V0AAAABQAAAANtc2cAAAAMYmFzZUFzc2V0U3RyAAAADnVzZXJBZGRyZXNzU3RyAAAADXN1Ym1pdFR4SWRTdHIAAAANb3BlcmF0aW9uVHlwZQkAAAIAAAABCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgUAAAADbXNnAgAAAA86IGJhc2VBc3NldFN0cj0FAAAADGJhc2VBc3NldFN0cgIAAAAQIHVzZXJBZGRyZXNzU3RyPQUAAAAOdXNlckFkZHJlc3NTdHICAAAADyBzdWJtaXRUeElkU3RyPQUAAAANc3VibWl0VHhJZFN0cgIAAAAPIG9wZXJhdGlvblR5cGU9BQAAAA1vcGVyYXRpb25UeXBlAQAAABdmYWlsU3VibWl0TGltaXRzRXhjZWVkcwAAAAQAAAANcmVtYWluaW5nQmFzZQAAAA5yZW1haW5pbmdTaGFyZQAAABBuZXdSZW1haW5pbmdCYXNlAAAAEW5ld1JlbWFpbmluZ1NoYXJlCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAASwAAAACAgAAACtzdWJtaXQgb3BlcmF0aW9uIGxpbWl0cyBoYXZlIGJlZW4gcmVhY2hlZDogAgAAAA8gcmVtYWluaW5nQmFzZT0JAAGkAAAAAQUAAAANcmVtYWluaW5nQmFzZQIAAAAQIHJlbWFpbmluZ1NoYXJlPQkAAaQAAAABBQAAAA5yZW1haW5pbmdTaGFyZQIAAAASIG5ld1JlbWFpbmluZ0Jhc2U9CQABpAAAAAEFAAAAEG5ld1JlbWFpbmluZ0Jhc2UCAAAAEyBuZXdSZW1haW5pbmdTaGFyZT0JAAGkAAAAAQUAAAARbmV3UmVtYWluaW5nU2hhcmUBAAAAFGZhaWxUb3B1cE1hbmFnZXJPbmx5AAAAAQAAABN0b3B1cE1hbmFnZXJBZGRyZXNzCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACAgAAACNvcGVydGlvbiBkZW5pZWQ6IG9ubHkgdG9wVXBNYW5hZ2VyPQUAAAATdG9wdXBNYW5hZ2VyQWRkcmVzcwIAAAAbIGNhbiBzZW5kIHN1Y2ggdHJhbnNhY3Rpb25zAQAAABFjb252ZXJ0U2hhcmUyQmFzZQAAAAMAAAALc2hhcmVBbW91bnQAAAAFcHJpY2UAAAAJcHJpY2VNdWx0CQAAawAAAAMFAAAAC3NoYXJlQW1vdW50BQAAAAVwcmljZQUAAAAJcHJpY2VNdWx0AQAAABFjb252ZXJ0QmFzZTJTaGFyZQAAAAMAAAAKYmFzZUFtb3VudAAAAAVwcmljZQAAAAlwcmljZU11bHQJAABrAAAAAwUAAAAKYmFzZUFtb3VudAUAAAAJcHJpY2VNdWx0BQAAAAVwcmljZQEAAAALa2V5QXNzZXRDZmcAAAABAAAADGJhc2VBc3NldFN0cgkAASwAAAACAgAAABclcyVzJXNfX2NvbmZpZ19fYXNzZXRfXwUAAAAMYmFzZUFzc2V0U3RyAQAAABZrZXlOZXh0SW50ZXJuYWxBc3NldElkAAAAAAIAAAAXJXNfX25leHRJbnRlcm5hbEFzc2V0SWQBAAAADGtleVByaWNlTGFzdAAAAAEAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyCQABLAAAAAICAAAAFSVzJXMlZF9fcHJpY2VfX2xhc3RfXwUAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyAQAAAAtrZXlQcmljZUFUSAAAAAEAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyCQABLAAAAAICAAAAFCVzJXMlZF9fcHJpY2VfX2F0aF9fBQAAABVpbnRlcm5hbEJhc2V0QXNzZXRTdHIBAAAAEmtleVByaWNlQnlUb3BVcElkeAAAAAIAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIAAAAIdG9wVXBJZHgJAAS5AAAAAgkABEwAAAACAgAAABslcyVzJWQlZF9fcHJpY2VfX2J5VG9wVXBJZHgJAARMAAAAAgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAARMAAAAAgkAAaQAAAABBQAAAAh0b3BVcElkeAUAAAADbmlsBQAAAANTRVABAAAAD2tleVByaWNlSGlzdG9yeQAAAAMAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyAAAAAWgAAAAJdGltZXN0YW1wCQAEuQAAAAIJAARMAAAAAgIAAAAaJXMlcyVkJWQlZF9fcHJpY2VfX2hpc3RvcnkJAARMAAAAAgUAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyCQAETAAAAAIJAAGkAAAAAQUAAAABaAkABEwAAAACCQABpAAAAAEFAAAACXRpbWVzdGFtcAUAAAADbmlsBQAAAANTRVABAAAADmtleVRvdGFsTG9ja2VkAAAAAQAAABVpbnRlcm5hbEJhc2V0QXNzZXRTdHIJAAEsAAAAAgIAAAAXJXMlcyVkX190b3RhbF9fbG9ja2VkX18FAAAAFWludGVybmFsQmFzZXRBc3NldFN0cgEAAAAUa2V5VG90YWxMb2NrZWRCeVVzZXIAAAACAAAAFGludGVybmFsQmFzZUFzc2V0U3RyAAAADnVzZXJBZGRyZXNzU3RyCQAEuQAAAAIJAARMAAAAAgIAAAAXJXMlcyVkJXNfX3RvdGFsX19sb2NrZWQJAARMAAAAAgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAARMAAAAAgUAAAAOdXNlckFkZHJlc3NTdHIFAAAAA25pbAUAAAADU0VQAQAAAB9rZXlNYXBwaW5nc0ludGVybmFsMmJhc2VBc3NldElkAAAAAQAAABFpbnRlcm5hbEJhc2VBc3NldAkAASwAAAACAgAAACglcyVzJWRfX21hcHBpbmdzX19pbnRlcm5hbDJiYXNlQXNzZXRJZF9fCQABpAAAAAEFAAAAEWludGVybmFsQmFzZUFzc2V0AQAAAB9rZXlNYXBwaW5nc0Jhc2VBc3NldDJpbnRlcm5hbElkAAAAAQAAAAxiYXNlQXNzZXRTdHIJAAEsAAAAAgIAAAAoJXMlcyVzX19tYXBwaW5nc19fYmFzZUFzc2V0MmludGVybmFsSWRfXwUAAAAMYmFzZUFzc2V0U3RyAQAAABxrZXlNYXBwaW5nc1NoYXJlMmJhc2VBc3NldElkAAAAAQAAAA1zaGFyZUFzc2V0U3RyCQABLAAAAAICAAAAJSVzJXMlc19fbWFwcGluZ3NfX3NoYXJlMmJhc2VBc3NldElkX18FAAAADXNoYXJlQXNzZXRTdHIBAAAAHGtleU1hcHBpbmdzQmFzZUFzc2V0MnNoYXJlSWQAAAABAAAADGJhc2VBc3NldFN0cgkAASwAAAACAgAAACUlcyVzJXNfX21hcHBpbmdzX19iYXNlQXNzZXQyc2hhcmVJZF9fBQAAAAxiYXNlQXNzZXRTdHIBAAAAF2tleVNodXRkb3duUHV0T3BlcmF0aW9uAAAAAQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkAASwAAAACAgAAABclcyVzJWRfX3NodXRkb3duX19wdXRfXwUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIBAAAAEmtleVNodXRkb3duTWFuYWdlcgAAAAEAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAAEsAAAAAgIAAAAbJXMlcyVkX19zaHV0ZG93bl9fbWFuYWdlcl9fBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgEAAAASa2V5VG9wVXBDdXJyZW50SWR4AAAAAQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkAASwAAAACAgAAABslcyVzJWRfX3RvcHVwX19jdXJyZW50SWR4X18FAAAAFGludGVybmFsQmFzZUFzc2V0U3RyAQAAABJrZXlUb3BVcExhc3RIZWlnaHQAAAACAAAAFWludGVybmFsQmFzZXRBc3NldFN0cgAAAAZzZW5kZXIJAAS5AAAAAgkABEwAAAACAgAAAB8lcyVzJXMlZCVzX190b3B1cF9fbGFzdF9faGVpZ2h0CQAETAAAAAIFAAAAFWludGVybmFsQmFzZXRBc3NldFN0cgkABEwAAAACBQAAAAZzZW5kZXIFAAAAA25pbAUAAAADU0VQAQAAAA5rZXlUb3B1cE11dGV4dAAAAAEAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyCQABLAAAAAICAAAAFiVzJXMlZF9fdG9wdXBfX211dGV4X18FAAAAFWludGVybmFsQmFzZXRBc3NldFN0cgEAAAAPa2V5VG9wdXBIaXN0b3J5AAAAAgAAABVpbnRlcm5hbEJhc2V0QXNzZXRTdHIAAAAIdG9wdXBJZHgJAAS5AAAAAgkABEwAAAACAgAAABglcyVzJWQlZF9fdG9wdXBfX2hpc3RvcnkJAARMAAAAAgUAAAAVaW50ZXJuYWxCYXNldEFzc2V0U3RyCQAETAAAAAIJAAGkAAAAAQUAAAAIdG9wdXBJZHgFAAAAA25pbAUAAAADU0VQAQAAABJrZXlMaW1pdHNSZW1haW5pbmcAAAABAAAAFWludGVybmFsQmFzZXRBc3NldFN0cgkAASwAAAACAgAAABslcyVzJWRfX2xpbWl0c19fcmVtYWluaW5nX18FAAAAFWludGVybmFsQmFzZXRBc3NldFN0cgAAAAASSWR4Q2ZnU2hhcmVBc3NldElkAAAAAAAAAAABAAAAABdJZHhDZmdJbnRlcm5hbEJhc2VBc3NldAAAAAAAAAAAAgAAAAAcSWR4Q2ZnRGVjaW1hbHNNdWx0Qm90aEFzc2V0cwAAAAAAAAAAAwAAAAAXSWR4Q2ZnRGVjaW1hbHNNdWx0UHJpY2UAAAAAAAAAAAQAAAAAFElkeENmZ0dldERlbGF5QmxvY2tzAAAAAAAAAAAFAAAAABtJZHhDZmdUb3B1cEludGVydmFsSW5CbG9ja3MAAAAAAAAAAAYAAAAAGklkeENmZ1RvcHVwTWF4TmVnYXRpdmVQYXJ0AAAAAAAAAAAHAAAAABlJZHhDZmdUb3B1cE1hbmFnZXJBZGRyZXNzAAAAAAAAAAAIAAAAABlJZHhDZmdTdWJtaXRMaW1pdHNCYXNlTWF4AAAAAAAAAAAJAAAAABtJZHhDZmdTdWJtaXRMaW1pdHNCYXNlUmVzZXQAAAAAAAAAAAoAAAAAGklkeENmZ1N1Ym1pdExpbWl0c1NoYXJlTWF4AAAAAAAAAAALAAAAABxJZHhDZmdTdWJtaXRMaW1pdHNTaGFyZVJlc2V0AAAAAAAAAAAMAQAAAAxkYXRhQXNzZXRDZmcAAAAMAAAADXNoYXJlQXNzZXRTdHIAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwAAABFkZWNpbWFsc011bHRQcmljZQAAABBnZXREZWxheUluQmxvY2tzAAAAFXRvcHVwSW50ZXJ2YWxJbkJsb2NrcwAAABR0b3B1cE1heE5lZ2F0aXZlUGFydAAAABN0b3B1cE1hbmFnZXJBZGRyZXNzAAAAE3N1Ym1pdExpbWl0c0Jhc2VNYXgAAAAVc3VibWl0TGltaXRzQmFzZVJlc2V0AAAAFHN1Ym1pdExpbWl0c1NoYXJlTWF4AAAAFnN1Ym1pdExpbWl0c1NoYXJlUmVzZXQJAAS5AAAAAgkABEwAAAACAgAAABglcyVkJWQlZCVkJWQlZCVzJWQlZCVkJWQJAARMAAAAAgUAAAANc2hhcmVBc3NldFN0cgkABEwAAAACBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkABEwAAAACCQABpAAAAAEFAAAAFmRlY2ltYWxzTXVsdEJvdGhBc3NldHMJAARMAAAAAgkAAaQAAAABBQAAABFkZWNpbWFsc011bHRQcmljZQkABEwAAAACCQABpAAAAAEFAAAAEGdldERlbGF5SW5CbG9ja3MJAARMAAAAAgkAAaQAAAABBQAAABV0b3B1cEludGVydmFsSW5CbG9ja3MJAARMAAAAAgkAAaQAAAABBQAAABR0b3B1cE1heE5lZ2F0aXZlUGFydAkABEwAAAACBQAAABN0b3B1cE1hbmFnZXJBZGRyZXNzCQAETAAAAAIJAAGkAAAAAQUAAAATc3VibWl0TGltaXRzQmFzZU1heAkABEwAAAACCQABpAAAAAEFAAAAFXN1Ym1pdExpbWl0c0Jhc2VSZXNldAkABEwAAAACCQABpAAAAAEFAAAAFHN1Ym1pdExpbWl0c1NoYXJlTWF4CQAETAAAAAIJAAGkAAAAAQUAAAAWc3VibWl0TGltaXRzU2hhcmVSZXNldAUAAAADbmlsBQAAAANTRVAAAAAAFUlkeFRvdGFsTG9ja2VkSW5TaGFyZQAAAAAAAAAAAQAAAAAVSWR4VG90YWxMb2NrZWRPdXRCYXNlAAAAAAAAAAACAAAAABRJZHhUb3RhbExvY2tlZEluQmFzZQAAAAAAAAAAAwAAAAAWSWR4VG90YWxMb2NrZWRPdXRTaGFyZQAAAAAAAAAABAEAAAAPZGF0YVRvdGFsTG9ja2VkAAAABAAAAA1pblNoYXJlQW1vdW50AAAADW91dEJhc2VBbW91bnQAAAAMaW5CYXNlQW1vdW50AAAADm91dFNoYXJlQW1vdW50CQAEuQAAAAIJAARMAAAAAgIAAAAIJWQlZCVkJWQJAARMAAAAAgkAAaQAAAABBQAAAA1pblNoYXJlQW1vdW50CQAETAAAAAIJAAGkAAAAAQUAAAANb3V0QmFzZUFtb3VudAkABEwAAAACCQABpAAAAAEFAAAADGluQmFzZUFtb3VudAkABEwAAAACCQABpAAAAAEFAAAADm91dFNoYXJlQW1vdW50BQAAAANuaWwFAAAAA1NFUAEAAAASZGF0YVRvdGFsTG9ja2VkSW50AAAABAAAAA1pblNoYXJlQW1vdW50AAAADW91dEJhc2VBbW91bnQAAAAMaW5CYXNlQW1vdW50AAAADm91dFNoYXJlQW1vdW50CQAETAAAAAIA//////////8JAARMAAAAAgUAAAANaW5TaGFyZUFtb3VudAkABEwAAAACBQAAAA1vdXRCYXNlQW1vdW50CQAETAAAAAIFAAAADGluQmFzZUFtb3VudAkABEwAAAACBQAAAA5vdXRTaGFyZUFtb3VudAUAAAADbmlsAQAAAA9yZWFkVG90YWxMb2NrZWQAAAABAAAAA2tleQQAAAAQdG90YWxMb2NrZWRBcnJheQkABLUAAAACCQEAAAALdmFsdWVPckVsc2UAAAACCQAEHQAAAAIFAAAABHRoaXMFAAAAA2tleQkBAAAAD2RhdGFUb3RhbExvY2tlZAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAAA1NFUAkBAAAAEmRhdGFUb3RhbExvY2tlZEludAAAAAQJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAABB0b3RhbExvY2tlZEFycmF5BQAAABVJZHhUb3RhbExvY2tlZEluU2hhcmUJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAABB0b3RhbExvY2tlZEFycmF5BQAAABVJZHhUb3RhbExvY2tlZE91dEJhc2UJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAABB0b3RhbExvY2tlZEFycmF5BQAAABRJZHhUb3RhbExvY2tlZEluQmFzZQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAAEHRvdGFsTG9ja2VkQXJyYXkFAAAAFklkeFRvdGFsTG9ja2VkT3V0U2hhcmUBAAAAE2NhbGNUb3RhbExvY2tlZERpZmYAAAAIAAAACWRpcmVjdGlvbgAAAA1vcGVyYXRpb25UeXBlAAAAFGludGVybmFsQmFzZUFzc2V0U3RyAAAABXByaWNlAAAACXByaWNlTXVsdAAAAAhpbkFtb3VudAAAAAtiYXNlQXNzZXRJZAAAAAxzaGFyZUFzc2V0SWQEAAAAAXQJAAEsAAAAAgUAAAAJZGlyZWN0aW9uBQAAAA1vcGVyYXRpb25UeXBlAwkAAAAAAAACBQAAAAF0AgAAAAdzdWJtaXRQBAAAAAl0b3RhbERpZmYJAQAAABJkYXRhVG90YWxMb2NrZWRJbnQAAAAEAAAAAAAAAAAAAAAAAAAAAAAABQAAAAhpbkFtb3VudAAAAAAAAAAAAAQAAAAIdXNlckRpZmYFAAAACXRvdGFsRGlmZgkABRYAAAAEBQAAAAl0b3RhbERpZmYFAAAACHVzZXJEaWZmAAAAAAAAAAAACQACWQAAAAECAAAAAAMJAAAAAAAAAgUAAAABdAIAAAAHc3VibWl0RwQAAAAJdG90YWxEaWZmCQEAAAASZGF0YVRvdGFsTG9ja2VkSW50AAAABAUAAAAIaW5BbW91bnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAACHVzZXJEaWZmBQAAAAl0b3RhbERpZmYJAAUWAAAABAUAAAAJdG90YWxEaWZmBQAAAAh1c2VyRGlmZgAAAAAAAAAAAAkAAlkAAAABAgAAAAADCQAAAAAAAAIFAAAAAXQCAAAACGV4ZWN1dGVQBAAAAAlvdXRBbW91bnQJAQAAABFjb252ZXJ0QmFzZTJTaGFyZQAAAAMFAAAACGluQW1vdW50BQAAAAVwcmljZQUAAAAJcHJpY2VNdWx0BAAAAAl0b3RhbERpZmYJAQAAABJkYXRhVG90YWxMb2NrZWRJbnQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAAAAlvdXRBbW91bnQEAAAACHVzZXJEaWZmCQEAAAASZGF0YVRvdGFsTG9ja2VkSW50AAAABAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAIaW5BbW91bnQAAAAAAAAAAAAJAAUWAAAABAUAAAAJdG90YWxEaWZmBQAAAAh1c2VyRGlmZgUAAAAJb3V0QW1vdW50BQAAAAxzaGFyZUFzc2V0SWQDCQAAAAAAAAIFAAAAAXQCAAAACGV4ZWN1dGVHBAAAAAlvdXRBbW91bnQJAQAAABFjb252ZXJ0U2hhcmUyQmFzZQAAAAMFAAAACGluQW1vdW50BQAAAAVwcmljZQUAAAAJcHJpY2VNdWx0BAAAAAl0b3RhbERpZmYJAQAAABJkYXRhVG90YWxMb2NrZWRJbnQAAAAEAAAAAAAAAAAABQAAAAlvdXRBbW91bnQAAAAAAAAAAAAAAAAAAAAAAAAEAAAACHVzZXJEaWZmCQEAAAASZGF0YVRvdGFsTG9ja2VkSW50AAAABAUAAAAIaW5BbW91bnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJAAUWAAAABAUAAAAJdG90YWxEaWZmBQAAAAh1c2VyRGlmZgUAAAAJb3V0QW1vdW50BQAAAAtiYXNlQXNzZXRJZAMJAAAAAAAAAgUAAAABdAIAAAAFdG9wdXAEAAAAEHRvdGFsTG9ja2VkQXJyYXkJAQAAAA9yZWFkVG90YWxMb2NrZWQAAAABCQEAAAAOa2V5VG90YWxMb2NrZWQAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgQAAAAXdG90YWxMb2NrZWRJbkJhc2VBbW91bnQJAAGRAAAAAgUAAAAQdG90YWxMb2NrZWRBcnJheQUAAAAUSWR4VG90YWxMb2NrZWRJbkJhc2UEAAAAGHRvdGFsTG9ja2VkSW5TaGFyZUFtb3VudAkAAZEAAAACBQAAABB0b3RhbExvY2tlZEFycmF5BQAAABVJZHhUb3RhbExvY2tlZEluU2hhcmUEAAAACXRvdGFsRGlmZgkBAAAAEmRhdGFUb3RhbExvY2tlZEludAAAAAQFAAAAGHRvdGFsTG9ja2VkSW5TaGFyZUFtb3VudAkAAGgAAAACAP//////////CQEAAAARY29udmVydFNoYXJlMkJhc2UAAAADBQAAABh0b3RhbExvY2tlZEluU2hhcmVBbW91bnQFAAAABXByaWNlBQAAAAlwcmljZU11bHQFAAAAF3RvdGFsTG9ja2VkSW5CYXNlQW1vdW50CQAAaAAAAAIA//////////8JAQAAABFjb252ZXJ0QmFzZTJTaGFyZQAAAAMFAAAAF3RvdGFsTG9ja2VkSW5CYXNlQW1vdW50BQAAAAVwcmljZQUAAAAJcHJpY2VNdWx0CQAFFgAAAAQFAAAACXRvdGFsRGlmZgUAAAADbmlsAAAAAAAAAAAACQACWQAAAAECAAAAAAkAAAIAAAABCQABLAAAAAICAAAAEVVuc3VwcG9ydGVkIFR5cGUgBQAAAAF0AQAAABZUb3RhbExvY2tlZFN0cmluZ0VudHJ5AAAAAwAAAAZhY3Rpb24AAAADa2V5AAAABGRpZmYKAQAAAAZVUERBVEUAAAACAAAAAWEAAAABYgMJAAAAAAAAAgUAAAAGYWN0aW9uAgAAAAlJTkNSRU1FTlQJAABkAAAAAgUAAAABYQUAAAABYgMJAAAAAAAAAgUAAAAGYWN0aW9uAgAAAAlERUNSRU1FTlQJAABlAAAAAgUAAAABYQUAAAABYgkAAAIAAAABCQABLAAAAAICAAAAE1Vuc3VwcG9ydGVkIGFjdGlvbiAFAAAABmFjdGlvbgQAAAAJZGF0YUFycmF5CQEAAAAPcmVhZFRvdGFsTG9ja2VkAAAAAQUAAAADa2V5CQEAAAALU3RyaW5nRW50cnkAAAACBQAAAANrZXkJAQAAAA9kYXRhVG90YWxMb2NrZWQAAAAECQEAAAAGVVBEQVRFAAAAAgkAAZEAAAACBQAAAAlkYXRhQXJyYXkFAAAAFUlkeFRvdGFsTG9ja2VkSW5TaGFyZQkAAZEAAAACBQAAAARkaWZmBQAAABVJZHhUb3RhbExvY2tlZEluU2hhcmUJAQAAAAZVUERBVEUAAAACCQABkQAAAAIFAAAACWRhdGFBcnJheQUAAAAVSWR4VG90YWxMb2NrZWRPdXRCYXNlCQABkQAAAAIFAAAABGRpZmYFAAAAFUlkeFRvdGFsTG9ja2VkT3V0QmFzZQkBAAAABlVQREFURQAAAAIJAAGRAAAAAgUAAAAJZGF0YUFycmF5BQAAABRJZHhUb3RhbExvY2tlZEluQmFzZQkAAZEAAAACBQAAAARkaWZmBQAAABRJZHhUb3RhbExvY2tlZEluQmFzZQkBAAAABlVQREFURQAAAAIJAAGRAAAAAgUAAAAJZGF0YUFycmF5BQAAABZJZHhUb3RhbExvY2tlZE91dFNoYXJlCQABkQAAAAIFAAAABGRpZmYFAAAAFklkeFRvdGFsTG9ja2VkT3V0U2hhcmUBAAAADGtleU9wZXJhdGlvbgAAAAQAAAANb3BlcmF0aW9uVHlwZQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgAAAAt1c2VyQWRkcmVzcwAAAAR0eElkCQAEuQAAAAIJAARMAAAAAgIAAAAIJXMlZCVzJXMJAARMAAAAAgUAAAANb3BlcmF0aW9uVHlwZQkABEwAAAACBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkABEwAAAACBQAAAAt1c2VyQWRkcmVzcwkABEwAAAACBQAAAAR0eElkBQAAAANuaWwFAAAAA1NFUAAAAAANSWR4T3BlclN0YXR1cwAAAAAAAAAAAQAAAAAPSWR4T3BlckluQW1vdW50AAAAAAAAAAACAAAAAAxJZHhPcGVyUHJpY2UAAAAAAAAAAAMAAAAAEElkeE9wZXJPdXRBbW91bnQAAAAAAAAAAAQAAAAAEklkeE9wZXJTdGFydEhlaWdodAAAAAAAAAAABQAAAAAVSWR4T3BlclN0YXJ0VGltZXN0YW1wAAAAAAAAAAAGAAAAABBJZHhPcGVyRW5kSGVpZ2h0AAAAAAAAAAAHAAAAABNJZHhPcGVyRW5kVGltZXN0YW1wAAAAAAAAAAAIAAAAABVJZHhPcGVyVG9wdXBVbmxvY2tJZHgAAAAAAAAAAAkBAAAAHnByaXZhdGVEYXRhT3BlcmF0aW9uQWxsU3RyaW5ncwAAAAkAAAAGc3RhdHVzAAAADWluQXNzZXRBbW91bnQAAAAFcHJpY2UAAAAOb3V0QXNzZXRBbW91bnQAAAALc3RhcnRIZWlnaHQAAAAOc3RhcnRUaW1lc3RhbXAAAAAJZW5kSGVpZ2h0AAAADGVuZFRpbWVzdGFtcAAAAARsb2NrCQAEuQAAAAIJAARMAAAAAgIAAAASJXMlZCVkJWQlZCVkJWQlZCVkCQAETAAAAAIFAAAABnN0YXR1cwkABEwAAAACBQAAAA1pbkFzc2V0QW1vdW50CQAETAAAAAIFAAAABXByaWNlCQAETAAAAAIFAAAADm91dEFzc2V0QW1vdW50CQAETAAAAAIFAAAAC3N0YXJ0SGVpZ2h0CQAETAAAAAIFAAAADnN0YXJ0VGltZXN0YW1wCQAETAAAAAIFAAAACWVuZEhlaWdodAkABEwAAAACBQAAAAxlbmRUaW1lc3RhbXAJAARMAAAAAgUAAAAEbG9jawUAAAADbmlsBQAAAANTRVABAAAADWRhdGFPcGVyYXRpb24AAAAJAAAABnN0YXR1cwAAAA1pbkFzc2V0QW1vdW50AAAABXByaWNlAAAADm91dEFzc2V0QW1vdW50AAAAC3N0YXJ0SGVpZ2h0AAAADnN0YXJ0VGltZXN0YW1wAAAACWVuZEhlaWdodAAAAAxlbmRUaW1lc3RhbXAAAAAOdG9wdXBVbmxvY2tJZHgJAQAAAB5wcml2YXRlRGF0YU9wZXJhdGlvbkFsbFN0cmluZ3MAAAAJBQAAAAZzdGF0dXMJAAGkAAAAAQUAAAANaW5Bc3NldEFtb3VudAkAAaQAAAABBQAAAAVwcmljZQkAAaQAAAABBQAAAA5vdXRBc3NldEFtb3VudAkAAaQAAAABBQAAAAtzdGFydEhlaWdodAkAAaQAAAABBQAAAA5zdGFydFRpbWVzdGFtcAkAAaQAAAABBQAAAAllbmRIZWlnaHQJAAGkAAAAAQUAAAAMZW5kVGltZXN0YW1wCQABpAAAAAEFAAAADnRvcHVwVW5sb2NrSWR4AQAAABxkYXRhT3BlcmF0aW9uRXhlY3V0aW9uVXBkYXRlAAAABAAAAA1jdXJyT3BlckFycmF5AAAACW5ld1N0YXR1cwAAAAhuZXdQcmljZQAAAAxuZXdPdXRBbW91bnQJAQAAAB5wcml2YXRlRGF0YU9wZXJhdGlvbkFsbFN0cmluZ3MAAAAJBQAAAAluZXdTdGF0dXMJAAGRAAAAAgUAAAANY3Vyck9wZXJBcnJheQUAAAAPSWR4T3BlckluQW1vdW50CQABpAAAAAEFAAAACG5ld1ByaWNlCQABpAAAAAEFAAAADG5ld091dEFtb3VudAkAAZEAAAACBQAAAA1jdXJyT3BlckFycmF5BQAAABJJZHhPcGVyU3RhcnRIZWlnaHQJAAGRAAAAAgUAAAANY3Vyck9wZXJBcnJheQUAAAAVSWR4T3BlclN0YXJ0VGltZXN0YW1wCQABpAAAAAEFAAAABmhlaWdodAkAAaQAAAABCAUAAAAJbGFzdEJsb2NrAAAACXRpbWVzdGFtcAkAAZEAAAACBQAAAA1jdXJyT3BlckFycmF5BQAAABVJZHhPcGVyVG9wdXBVbmxvY2tJZHgBAAAAEnJlYWRBc3NldENmZ09yRmFpbAAAAAEAAAAMYmFzZUFzc2V0U3RyBAAAAANrZXkJAQAAAAtrZXlBc3NldENmZwAAAAEFAAAADGJhc2VBc3NldFN0cgkABLUAAAACCQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQUAAAADa2V5BQAAAANTRVAAAAAAFklkeExpbWl0c1JlbWFpbmluZ0Jhc2UAAAAAAAAAAAEAAAAAF0lkeExpbWl0c1JlbWFpbmluZ1NoYXJlAAAAAAAAAAACAQAAABpSZW1haW5pbmdMaW1pdHNTdHJpbmdFbnRyeQAAAAMAAAADa2V5AAAAEmJhc2VSZW1haW5pbmdMaW1pdAAAABNzaGFyZVJlbWFpbmluZ0xpbWl0CQEAAAALU3RyaW5nRW50cnkAAAACBQAAAANrZXkJAAS5AAAAAgkABEwAAAACAgAAAAQlZCVkCQAETAAAAAIJAAGkAAAAAQUAAAASYmFzZVJlbWFpbmluZ0xpbWl0CQAETAAAAAIJAAGkAAAAAQUAAAATc2hhcmVSZW1haW5pbmdMaW1pdAUAAAADbmlsBQAAAANTRVABAAAAElRvcHVwTXV0ZXhJbnRFbnRyeQAAAAIAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIAAAAOYWNxdWlyZWRIZWlnaHQJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAAOa2V5VG9wdXBNdXRleHQAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAOYWNxdWlyZWRIZWlnaHQBAAAAEVRvcHVwSGlzdG9yeUVudHJ5AAAAAgAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgAAAAh0b3B1cElkeAIAAAAAAQAAABBnZW5lcmljQ2FsY1ByaWNlAAAABQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgAAAAtiYXNlQXNzZXRJZAAAAA90b3BVcEJhc2VBbW91bnQAAAAMc2hhcmVBc3NldElkAAAAEWRlY2ltYWxzTXVsdFByaWNlBAAAABB0b3RhbExvY2tlZEFycmF5CQEAAAAPcmVhZFRvdGFsTG9ja2VkAAAAAQkBAAAADmtleVRvdGFsTG9ja2VkAAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIEAAAAGHRvdGFsTG9ja2VkT3V0QmFzZUFtb3VudAkAAZEAAAACBQAAABB0b3RhbExvY2tlZEFycmF5BQAAABVJZHhUb3RhbExvY2tlZE91dEJhc2UEAAAAF3RvdGFsTG9ja2VkSW5CYXNlQW1vdW50CQABkQAAAAIFAAAAEHRvdGFsTG9ja2VkQXJyYXkFAAAAFElkeFRvdGFsTG9ja2VkSW5CYXNlBAAAABBiYXNlQXNzZXRCYWxhbmNlCQAD8AAAAAIFAAAABHRoaXMFAAAAC2Jhc2VBc3NldElkBAAAABNiYXNlQXNzZXRCYWxhbmNlV0NPCQAAZQAAAAIJAABlAAAAAgkAAGQAAAACBQAAABBiYXNlQXNzZXRCYWxhbmNlBQAAAA90b3BVcEJhc2VBbW91bnQFAAAAF3RvdGFsTG9ja2VkSW5CYXNlQW1vdW50BQAAABh0b3RhbExvY2tlZE91dEJhc2VBbW91bnQEAAAAGXRvdGFsTG9ja2VkT3V0U2hhcmVBbW91bnQJAAGRAAAAAgUAAAAQdG90YWxMb2NrZWRBcnJheQUAAAAWSWR4VG90YWxMb2NrZWRPdXRTaGFyZQQAAAAYdG90YWxMb2NrZWRJblNoYXJlQW1vdW50CQABkQAAAAIFAAAAEHRvdGFsTG9ja2VkQXJyYXkFAAAAFUlkeFRvdGFsTG9ja2VkSW5TaGFyZQQAAAANc2hhcmVFbWlzc2lvbggJAQAAAAV2YWx1ZQAAAAEJAAPsAAAAAQUAAAAMc2hhcmVBc3NldElkAAAACHF1YW50aXR5AwkAAGYAAAACAAAAAAAAAAAABQAAABNiYXNlQXNzZXRCYWxhbmNlV0NPCQAAAgAAAAEJAAEsAAAAAgkAASwAAAACCQABLAAAAAICAAAAKmJhc2VBc3NldEJhbGFuY2VXQ08gPCAwOiBiYXNlQXNzZXRCYWxhbmNlPQkAAaQAAAABBQAAABBiYXNlQXNzZXRCYWxhbmNlAgAAABUgYmFzZUFzc2V0QmFsYW5jZVdDTz0JAAGkAAAAAQUAAAATYmFzZUFzc2V0QmFsYW5jZVdDTwQAAAAJbGFzdFByaWNlCQEAAAAMZ2V0SW50T3JGYWlsAAAAAQkBAAAADGtleVByaWNlTGFzdAAAAAEFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBAAAAAVwcmljZQMJAAAAAAAAAgUAAAANc2hhcmVFbWlzc2lvbgAAAAAAAAAAAAUAAAAJbGFzdFByaWNlCQAAawAAAAMFAAAAE2Jhc2VBc3NldEJhbGFuY2VXQ08FAAAAEWRlY2ltYWxzTXVsdFByaWNlBQAAAA1zaGFyZUVtaXNzaW9uCQAFFwAAAAUFAAAABXByaWNlBQAAABBiYXNlQXNzZXRCYWxhbmNlAP//////////BQAAABNiYXNlQXNzZXRCYWxhbmNlV0NPBQAAAA1zaGFyZUVtaXNzaW9uAQAAAAljYWxjUHJpY2UAAAAEAAAAFGludGVybmFsQmFzZUFzc2V0U3RyAAAAC2Jhc2VBc3NldElkAAAADHNoYXJlQXNzZXRJZAAAABFkZWNpbWFsc011bHRQcmljZQkBAAAAEGdlbmVyaWNDYWxjUHJpY2UAAAAFBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAALYmFzZUFzc2V0SWQAAAAAAAAAAAAFAAAADHNoYXJlQXNzZXRJZAUAAAARZGVjaW1hbHNNdWx0UHJpY2UBAAAABnN1Ym1pdAAAAAUAAAANb3BlcmF0aW9uVHlwZQAAAAFpAAAACGluQW1vdW50AAAACWluQXNzZXRJZAAAAAxiYXNlQXNzZXRTdHIEAAAACmluQXNzZXRTdHIJAAJYAAAAAQUAAAAJaW5Bc3NldElkBAAAAA51c2VyQWRkcmVzc1N0cgkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIEAAAAC2Jhc2VBc3NldElkCQACWQAAAAEFAAAADGJhc2VBc3NldFN0cgQAAAAIY2ZnQXJyYXkJAQAAABJyZWFkQXNzZXRDZmdPckZhaWwAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAADXNoYXJlQXNzZXRTdHIJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAEklkeENmZ1NoYXJlQXNzZXRJZAQAAAAMc2hhcmVBc3NldElkCQACWQAAAAEFAAAADXNoYXJlQXNzZXRTdHIEAAAAFmRlY2ltYWxzTXVsdEJvdGhBc3NldHMJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAAhjZmdBcnJheQUAAAAcSWR4Q2ZnRGVjaW1hbHNNdWx0Qm90aEFzc2V0cwQAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAF0lkeENmZ0ludGVybmFsQmFzZUFzc2V0BAAAAAlsaW1pdHNLRVkJAQAAABJrZXlMaW1pdHNSZW1haW5pbmcAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgQAAAAObGltaXRzQ2ZnQXJyYXkJAAS1AAAAAgkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEFAAAACWxpbWl0c0tFWQUAAAADU0VQBAAAABNsaW1pdHNSZW1haW5pbmdCYXNlCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAObGltaXRzQ2ZnQXJyYXkFAAAAFklkeExpbWl0c1JlbWFpbmluZ0Jhc2UEAAAAFGxpbWl0c1JlbWFpbmluZ1NoYXJlCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAObGltaXRzQ2ZnQXJyYXkFAAAAF0lkeExpbWl0c1JlbWFpbmluZ1NoYXJlBAAAAAxpc1B1dEJsb2NrZWQJAQAAABBnZXRCb29sZWFuT3JGYWlsAAAAAQkBAAAAF2tleVNodXRkb3duUHV0T3BlcmF0aW9uAAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIDBQAAAAxpc1B1dEJsb2NrZWQJAAACAAAAAQIAAAAYcHV0IG9wZXJhdGlvbiBpcyBibG9ja2VkBAAAAA9vcGVyYXRpb25zTXV0ZXgJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwkBAAAADmtleVRvcHVwTXV0ZXh0AAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIAAAAAAAAAAAADCQAAZgAAAAIJAABkAAAAAgUAAAAPb3BlcmF0aW9uc011dGV4AAAAAAAAAAA8BQAAAAZoZWlnaHQJAAACAAAAAQIAAAAuc3VibWl0IG9wZXJhdGlvbnMgYXJlIGJsb2NrZWQgYnkgdG9wdXAgbWFuYWdlcgQAAAAJZGlmZlR1cGxlCQEAAAATY2FsY1RvdGFsTG9ja2VkRGlmZgAAAAgCAAAABnN1Ym1pdAUAAAANb3BlcmF0aW9uVHlwZQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIAAAAAAAAAAAAAAAAAAAAAAAAFAAAACGluQW1vdW50BQAAAAtiYXNlQXNzZXRJZAUAAAAMc2hhcmVBc3NldElkBAAAABZsaW1pdHNSZW1haW5pbmdCYXNlTmV3CQAAZQAAAAIFAAAAE2xpbWl0c1JlbWFpbmluZ0Jhc2UJAAGRAAAAAggFAAAACWRpZmZUdXBsZQAAAAJfMgUAAAAUSWR4VG90YWxMb2NrZWRJbkJhc2UEAAAAF2xpbWl0c1JlbWFpbmluZ1NoYXJlTmV3CQAAZQAAAAIFAAAAFGxpbWl0c1JlbWFpbmluZ1NoYXJlCQABkQAAAAIIBQAAAAlkaWZmVHVwbGUAAAACXzIFAAAAFUlkeFRvdGFsTG9ja2VkSW5TaGFyZQMDCQAAZgAAAAIAAAAAAAAAAAAFAAAAFmxpbWl0c1JlbWFpbmluZ0Jhc2VOZXcGCQAAZgAAAAIAAAAAAAAAAAAFAAAAF2xpbWl0c1JlbWFpbmluZ1NoYXJlTmV3CQEAAAAXZmFpbFN1Ym1pdExpbWl0c0V4Y2VlZHMAAAAEBQAAABNsaW1pdHNSZW1haW5pbmdCYXNlBQAAABRsaW1pdHNSZW1haW5pbmdTaGFyZQUAAAAWbGltaXRzUmVtYWluaW5nQmFzZU5ldwUAAAAXbGltaXRzUmVtYWluaW5nU2hhcmVOZXcEAAAAD3RvcFVwQ3VycmVudElkeAkBAAAADGdldEludE9yRmFpbAAAAAEJAQAAABJrZXlUb3BVcEN1cnJlbnRJZHgAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkABE0AAAACCQAETQAAAAIJAARNAAAAAgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAMa2V5T3BlcmF0aW9uAAAABAUAAAANb3BlcmF0aW9uVHlwZQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAADnVzZXJBZGRyZXNzU3RyCQACWAAAAAEIBQAAAAFpAAAADXRyYW5zYWN0aW9uSWQJAQAAAA1kYXRhT3BlcmF0aW9uAAAACQIAAAAHUEVORElORwUAAAAIaW5BbW91bnQAAAAAAAAAAAAAAAAAAAAAAAAFAAAABmhlaWdodAgFAAAACWxhc3RCbG9jawAAAAl0aW1lc3RhbXAAAAAAAAAAAAAAAAAAAAAAAAAJAABkAAAAAgUAAAAPdG9wVXBDdXJyZW50SWR4AAAAAAAAAAABBQAAAANuaWwJAQAAABZUb3RhbExvY2tlZFN0cmluZ0VudHJ5AAAAAwIAAAAJSU5DUkVNRU5UCQEAAAAOa2V5VG90YWxMb2NrZWQAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cggFAAAACWRpZmZUdXBsZQAAAAJfMQkBAAAAFlRvdGFsTG9ja2VkU3RyaW5nRW50cnkAAAADAgAAAAlJTkNSRU1FTlQJAQAAABRrZXlUb3RhbExvY2tlZEJ5VXNlcgAAAAIFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cggFAAAACWRpZmZUdXBsZQAAAAJfMgkBAAAAGlJlbWFpbmluZ0xpbWl0c1N0cmluZ0VudHJ5AAAAAwUAAAAJbGltaXRzS0VZBQAAABZsaW1pdHNSZW1haW5pbmdCYXNlTmV3BQAAABdsaW1pdHNSZW1haW5pbmdTaGFyZU5ldwEAAAAHZXhlY3V0ZQAAAAQAAAANb3BlcmF0aW9uVHlwZQAAAAxiYXNlQXNzZXRTdHIAAAAOdXNlckFkZHJlc3NTdHIAAAANc3VibWl0VHhJZFN0cgQAAAALdXNlckFkZHJlc3MJAQAAABFAZXh0ck5hdGl2ZSgxMDYyKQAAAAEFAAAADnVzZXJBZGRyZXNzU3RyBAAAAA1hc3NldENmZ0FycmF5CQEAAAAScmVhZEFzc2V0Q2ZnT3JGYWlsAAAAAQUAAAAMYmFzZUFzc2V0U3RyBAAAAAxzaGFyZUFzc2V0SWQJAAJZAAAAAQkAAZEAAAACBQAAAA1hc3NldENmZ0FycmF5BQAAABJJZHhDZmdTaGFyZUFzc2V0SWQEAAAAFGludGVybmFsQmFzZUFzc2V0U3RyCQABkQAAAAIFAAAADWFzc2V0Q2ZnQXJyYXkFAAAAF0lkeENmZ0ludGVybmFsQmFzZUFzc2V0BAAAABFkZWNpbWFsc011bHRQcmljZQkBAAAADXBhcnNlSW50VmFsdWUAAAABCQABkQAAAAIFAAAADWFzc2V0Q2ZnQXJyYXkFAAAAF0lkeENmZ0RlY2ltYWxzTXVsdFByaWNlBAAAAAtiYXNlQXNzZXRJZAkAAlkAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAADG9wZXJhdGlvbktleQkBAAAADGtleU9wZXJhdGlvbgAAAAQFAAAADW9wZXJhdGlvblR5cGUFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cgUAAAANc3VibWl0VHhJZFN0cgQAAAAOb3BlcmF0aW9uQXJyYXkJAAS1AAAAAgkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEFAAAADG9wZXJhdGlvbktleQUAAAADU0VQBAAAAAZzdGF0dXMJAAGRAAAAAgUAAAAOb3BlcmF0aW9uQXJyYXkFAAAADUlkeE9wZXJTdGF0dXMEAAAACGluQW1vdW50CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAOb3BlcmF0aW9uQXJyYXkFAAAAD0lkeE9wZXJJbkFtb3VudAQAAAAOdG9wdXBVbmxvY2tJZHgJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAA5vcGVyYXRpb25BcnJheQUAAAAVSWR4T3BlclRvcHVwVW5sb2NrSWR4BAAAAAxjdXJyVG9wVXBJZHgJAQAAAAxnZXRJbnRPckZhaWwAAAABCQEAAAASa2V5VG9wVXBDdXJyZW50SWR4AAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIEAAAADnByaWNlQnlUb3BVcElkCQEAAAAMZ2V0SW50T3JGYWlsAAAAAQkBAAAAEmtleVByaWNlQnlUb3BVcElkeAAAAAIFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAAxjdXJyVG9wVXBJZHgDCQEAAAACIT0AAAACBQAAAAZzdGF0dXMCAAAAB1BFTkRJTkcJAQAAAA5mYWlsRXhlY3V0ZUdldAAAAAUCAAAAFVN0YXR1cyBpcyBub3QgUEVORElORwUAAAAMYmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cgUAAAANc3VibWl0VHhJZFN0cgUAAAANb3BlcmF0aW9uVHlwZQMJAABmAAAAAgUAAAAOdG9wdXBVbmxvY2tJZHgFAAAADGN1cnJUb3BVcElkeAkBAAAADmZhaWxFeGVjdXRlR2V0AAAABQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAJT3BlckxvY2tbCQABpAAAAAEFAAAADnRvcHVwVW5sb2NrSWR4AgAAAARdID4gCQABpAAAAAEFAAAADGN1cnJUb3BVcElkeAUAAAAMYmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cgUAAAANc3VibWl0VHhJZFN0cgUAAAANb3BlcmF0aW9uVHlwZQQAAAAJZGlmZlR1cGxlCQEAAAATY2FsY1RvdGFsTG9ja2VkRGlmZgAAAAgCAAAAB2V4ZWN1dGUFAAAADW9wZXJhdGlvblR5cGUFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAA5wcmljZUJ5VG9wVXBJZAUAAAARZGVjaW1hbHNNdWx0UHJpY2UFAAAACGluQW1vdW50BQAAAAtiYXNlQXNzZXRJZAUAAAAMc2hhcmVBc3NldElkBAAAAAlvdXRBbW91bnQIBQAAAAlkaWZmVHVwbGUAAAACXzMEAAAAD291dFRyYW5zZmVyRGF0YQMJAAAAAAAAAggFAAAACWRpZmZUdXBsZQAAAAJfNAUAAAALYmFzZUFzc2V0SWQJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwUAAAALdXNlckFkZHJlc3MFAAAACW91dEFtb3VudAUAAAALYmFzZUFzc2V0SWQFAAAAA25pbAkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADBQAAAAt1c2VyQWRkcmVzcwUAAAAJb3V0QW1vdW50BQAAAAxzaGFyZUFzc2V0SWQFAAAAA25pbAkABE0AAAACCQAETQAAAAIJAARNAAAAAgUAAAAPb3V0VHJhbnNmZXJEYXRhCQEAAAALU3RyaW5nRW50cnkAAAACBQAAAAxvcGVyYXRpb25LZXkJAQAAABxkYXRhT3BlcmF0aW9uRXhlY3V0aW9uVXBkYXRlAAAABAUAAAAOb3BlcmF0aW9uQXJyYXkCAAAACEZJTklTSEVEBQAAAA5wcmljZUJ5VG9wVXBJZAUAAAAJb3V0QW1vdW50CQEAAAAWVG90YWxMb2NrZWRTdHJpbmdFbnRyeQAAAAMCAAAACURFQ1JFTUVOVAkBAAAADmtleVRvdGFsTG9ja2VkAAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIIBQAAAAlkaWZmVHVwbGUAAAACXzEJAQAAABZUb3RhbExvY2tlZFN0cmluZ0VudHJ5AAAAAwIAAAAJREVDUkVNRU5UCQEAAAAUa2V5VG90YWxMb2NrZWRCeVVzZXIAAAACBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAOdXNlckFkZHJlc3NTdHIIBQAAAAlkaWZmVHVwbGUAAAACXzIBAAAAG3ByaXZhdGVDdXJyZW50U3lzUGFyYW1zUkVTVAAAAAEAAAAMYmFzZUFzc2V0U3RyBAAAAAtiYXNlQXNzZXRJZAkAAlkAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAACGNmZ0FycmF5CQEAAAAScmVhZEFzc2V0Q2ZnT3JGYWlsAAAAAQUAAAAMYmFzZUFzc2V0U3RyBAAAAA1zaGFyZUFzc2V0U3RyCQABkQAAAAIFAAAACGNmZ0FycmF5BQAAABJJZHhDZmdTaGFyZUFzc2V0SWQEAAAADHNoYXJlQXNzZXRJZAkAAlkAAAABBQAAAA1zaGFyZUFzc2V0U3RyBAAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAHElkeENmZ0RlY2ltYWxzTXVsdEJvdGhBc3NldHMEAAAAEWRlY2ltYWxzTXVsdFByaWNlCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAIY2ZnQXJyYXkFAAAAF0lkeENmZ0RlY2ltYWxzTXVsdFByaWNlBAAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkAAZEAAAACBQAAAAhjZmdBcnJheQUAAAAXSWR4Q2ZnSW50ZXJuYWxCYXNlQXNzZXQEAAAACHN5c1N0YXRlCQEAAAAJY2FsY1ByaWNlAAAABAUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAAC2Jhc2VBc3NldElkBQAAAAxzaGFyZUFzc2V0SWQFAAAAEWRlY2ltYWxzTXVsdFByaWNlCQAFGAAAAAYJAQAAAAxJbnRlZ2VyRW50cnkAAAACAgAAAAVwcmljZQgFAAAACHN5c1N0YXRlAAAAAl8xCQEAAAAMSW50ZWdlckVudHJ5AAAAAgIAAAARZGVjaW1hbHNNdWx0UHJpY2UFAAAAEWRlY2ltYWxzTXVsdFByaWNlCQEAAAAMSW50ZWdlckVudHJ5AAAAAgIAAAAQYmFzZUFzc2V0QmFsYW5jZQgFAAAACHN5c1N0YXRlAAAAAl8yCQEAAAAMSW50ZWdlckVudHJ5AAAAAgIAAAACLTEIBQAAAAhzeXNTdGF0ZQAAAAJfMwkBAAAADEludGVnZXJFbnRyeQAAAAICAAAAE2Jhc2VBc3NldEJhbGFuY2VXQ08IBQAAAAhzeXNTdGF0ZQAAAAJfNAkBAAAADEludGVnZXJFbnRyeQAAAAICAAAADXNoYXJlRW1pc3Npb24IBQAAAAhzeXNTdGF0ZQAAAAJfNQAAAAkAAAABaQEAAAASYWRtaW5SZWdpc3RlckFzc2V0AAAADQAAAAxiYXNlQXNzZXRTdHIAAAAOc2hhcmVBc3NldE5hbWUAAAAPc2hhcmVBc3NldERlc2NyAAAAEGdldERlbGF5aW5CbG9ja3MAAAAWc2h1dGRvd25NYW5hZ2VyQWRkcmVzcwAAAApzdGFydFByaWNlAAAAFXRvcHVwSW50ZXJ2YWxJbkJsb2NrcwAAABR0b3B1cE1heE5lZ2F0aXZlUGFydAAAABN0b3B1cE1hbmFnZXJBZGRyZXNzAAAAE3N1Ym1pdExpbWl0c0Jhc2VNYXgAAAAVc3VibWl0TGltaXRzQmFzZVJlc2V0AAAAFHN1Ym1pdExpbWl0c1NoYXJlTWF4AAAAFnN1Ym1pdExpbWl0c1NoYXJlUmVzZXQEAAAAC2Jhc2VBc3NldElkCQACWQAAAAEFAAAADGJhc2VBc3NldFN0cgQAAAAIZGVjaW1hbHMICQEAAAAFdmFsdWUAAAABCQAD7AAAAAEFAAAAC2Jhc2VBc3NldElkAAAACGRlY2ltYWxzBAAAABZkZWNpbWFsc011bHRCb3RoQXNzZXRzCQAAbAAAAAYAAAAAAAAAAAoAAAAAAAAAAAAFAAAACGRlY2ltYWxzAAAAAAAAAAAAAAAAAAAAAAAABQAAAARET1dOBAAAABFkZWNpbWFsc011bHRQcmljZQkAAGgAAAACCQAAaAAAAAIAAAAAAAAAAGQAAAAAAAAAA+gAAAAAAAAAA+gEAAAAGHRvcHVwTWF4TmVnYXRpdmVQZXJjZW50cwkAAGsAAAADBQAAABR0b3B1cE1heE5lZ2F0aXZlUGFydAAAAAAAAAAAZAUAAAAWZGVjaW1hbHNNdWx0Qm90aEFzc2V0cwQAAAAQYmFzZUFzc2V0QmFsYW5jZQkAA/AAAAACBQAAAAR0aGlzBQAAAAtiYXNlQXNzZXRJZAMJAQAAAAIhPQAAAAIIBQAAAAFpAAAABmNhbGxlcgUAAAAEdGhpcwkAAAIAAAABAgAAABJwZXJtaXNzaW9ucyBkZW5pZWQDCQAAAAAAAAIFAAAAEGJhc2VBc3NldEJhbGFuY2UAAAAAAAAAAAAJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAQlAAAAAQUAAAAEdGhpcwIAAAAiIG11c3QgaGF2ZSBhbnkgaW5pdGlhbCBiYWxhbmNlIG9mIAUAAAAMYmFzZUFzc2V0U3RyAwkBAAAACWlzRGVmaW5lZAAAAAEJAAQdAAAAAgUAAAAEdGhpcwkBAAAAC2tleUFzc2V0Q2ZnAAAAAQUAAAAMYmFzZUFzc2V0U3RyCQAAAgAAAAEJAAEsAAAAAgUAAAAMYmFzZUFzc2V0U3RyAgAAABwgaGFzIGJlZW4gYWxyZWFkeSByZWdpc3RlcmVkAwkBAAAAAiE9AAAAAgkABCUAAAABCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABBQAAABZzaHV0ZG93bk1hbmFnZXJBZGRyZXNzBQAAABZzaHV0ZG93bk1hbmFnZXJBZGRyZXNzCQAAAgAAAAECAAAAHmludmFsaWQgc2h1dGRvd25NYW5hZ2VyQWRkcmVzcwMJAQAAAAIhPQAAAAIJAAQlAAAAAQkBAAAAEUBleHRyTmF0aXZlKDEwNjIpAAAAAQUAAAATdG9wdXBNYW5hZ2VyQWRkcmVzcwUAAAATdG9wdXBNYW5hZ2VyQWRkcmVzcwkAAAIAAAABAgAAABtpbnZhbGlkIHRvcHVwTWFuYWdlckFkZHJlc3MDCQAAZgAAAAIAAAAAAAAAAAAFAAAAEGdldERlbGF5aW5CbG9ja3MJAAACAAAAAQkAASwAAAACAgAAABlpbnZhbGlkIGdldERlbGF5aW5CbG9ja3M9CQABpAAAAAEFAAAAEGdldERlbGF5aW5CbG9ja3MDAwkAAGcAAAACAAAAAAAAAAAABQAAABh0b3B1cE1heE5lZ2F0aXZlUGVyY2VudHMGCQAAZwAAAAIFAAAAGHRvcHVwTWF4TmVnYXRpdmVQZXJjZW50cwAAAAAAAAAAYwkAAAIAAAABAgAAACZpbnZhbGlkIHRvcHVwTWF4TmVnYXRpdmVQYXJ0IHBhcmFtZXRlcgQAAAAPc2hhcmVJbml0QW1vdW50CQEAAAARY29udmVydEJhc2UyU2hhcmUAAAADBQAAABBiYXNlQXNzZXRCYWxhbmNlBQAAAApzdGFydFByaWNlBQAAABFkZWNpbWFsc011bHRQcmljZQQAAAAVc2hhcmVBc3NldElzc3VlQWN0aW9uCQAEQgAAAAUFAAAADnNoYXJlQXNzZXROYW1lBQAAAA9zaGFyZUFzc2V0RGVzY3IFAAAAD3NoYXJlSW5pdEFtb3VudAUAAAAIZGVjaW1hbHMGBAAAAAxzaGFyZUFzc2V0SWQJAAQ4AAAAAQUAAAAVc2hhcmVBc3NldElzc3VlQWN0aW9uBAAAAA1zaGFyZUFzc2V0U3RyCQACWAAAAAEFAAAADHNoYXJlQXNzZXRJZAQAAAATaW50ZXJuYWxCYXNlQXNzZXRJZAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABBoAAAACBQAAAAR0aGlzCQEAAAAWa2V5TmV4dEludGVybmFsQXNzZXRJZAAAAAAAAAAAAAAAAAAEAAAAFGludGVybmFsQmFzZUFzc2V0U3RyCQABpAAAAAEFAAAAE2ludGVybmFsQmFzZUFzc2V0SWQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAC2tleUFzc2V0Q2ZnAAAAAQUAAAAMYmFzZUFzc2V0U3RyCQEAAAAMZGF0YUFzc2V0Q2ZnAAAADAUAAAANc2hhcmVBc3NldFN0cgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIFAAAAFmRlY2ltYWxzTXVsdEJvdGhBc3NldHMFAAAAEWRlY2ltYWxzTXVsdFByaWNlBQAAABBnZXREZWxheWluQmxvY2tzBQAAABV0b3B1cEludGVydmFsSW5CbG9ja3MFAAAAFHRvcHVwTWF4TmVnYXRpdmVQYXJ0BQAAABN0b3B1cE1hbmFnZXJBZGRyZXNzBQAAABNzdWJtaXRMaW1pdHNCYXNlTWF4BQAAABVzdWJtaXRMaW1pdHNCYXNlUmVzZXQFAAAAFHN1Ym1pdExpbWl0c1NoYXJlTWF4BQAAABZzdWJtaXRMaW1pdHNTaGFyZVJlc2V0CQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAB9rZXlNYXBwaW5nc0ludGVybmFsMmJhc2VBc3NldElkAAAAAQUAAAATaW50ZXJuYWxCYXNlQXNzZXRJZAUAAAAMYmFzZUFzc2V0U3RyCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAB9rZXlNYXBwaW5nc0Jhc2VBc3NldDJpbnRlcm5hbElkAAAAAQUAAAAMYmFzZUFzc2V0U3RyBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAca2V5TWFwcGluZ3NTaGFyZTJiYXNlQXNzZXRJZAAAAAEFAAAADXNoYXJlQXNzZXRTdHIFAAAADGJhc2VBc3NldFN0cgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAAca2V5TWFwcGluZ3NCYXNlQXNzZXQyc2hhcmVJZAAAAAEFAAAADGJhc2VBc3NldFN0cgUAAAANc2hhcmVBc3NldFN0cgkABEwAAAACCQEAAAAMQm9vbGVhbkVudHJ5AAAAAgkBAAAAF2tleVNodXRkb3duUHV0T3BlcmF0aW9uAAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIHCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAABJrZXlTaHV0ZG93bk1hbmFnZXIAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAWc2h1dGRvd25NYW5hZ2VyQWRkcmVzcwkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAFmtleU5leHRJbnRlcm5hbEFzc2V0SWQAAAAACQAAZAAAAAIFAAAAE2ludGVybmFsQmFzZUFzc2V0SWQAAAAAAAAAAAEJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAAxrZXlQcmljZUxhc3QAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAKc3RhcnRQcmljZQkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAD2tleVByaWNlSGlzdG9yeQAAAAMFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAAZoZWlnaHQIBQAAAAlsYXN0QmxvY2sAAAAJdGltZXN0YW1wBQAAAApzdGFydFByaWNlCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAASa2V5VG9wVXBDdXJyZW50SWR4AAAAAQUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIAAAAAAAAAAAAJAARMAAAAAgkBAAAAGlJlbWFpbmluZ0xpbWl0c1N0cmluZ0VudHJ5AAAAAwkBAAAAEmtleUxpbWl0c1JlbWFpbmluZwAAAAEFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAABNzdWJtaXRMaW1pdHNCYXNlTWF4BQAAABRzdWJtaXRMaW1pdHNTaGFyZU1heAkABEwAAAACBQAAABVzaGFyZUFzc2V0SXNzdWVBY3Rpb24FAAAAA25pbAAAAAFpAQAAAAtzaHV0ZG93blB1dAAAAAEAAAATaW50ZXJuYWxCYXNlQXNzZXRJZAQAAAAWaW50ZXJuYWxCYXNlQXNzZXRJZFN0cgkAAaQAAAABBQAAABNpbnRlcm5hbEJhc2VBc3NldElkBAAAAA5iYXNlQXNzZXRJZFN0cgkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEJAQAAAB9rZXlNYXBwaW5nc0ludGVybmFsMmJhc2VBc3NldElkAAAAAQUAAAATaW50ZXJuYWxCYXNlQXNzZXRJZAQAAAAWc2h1dGRvd25NYW5hZ2VyQWRkcmVzcwkBAAAAD2dldFN0cmluZ09yRmFpbAAAAAEJAQAAABJrZXlTaHV0ZG93bk1hbmFnZXIAAAABBQAAABZpbnRlcm5hbEJhc2VBc3NldElkU3RyAwkAAGYAAAACAAAAAAAAAAABCQABMQAAAAEFAAAADmJhc2VBc3NldElkU3RyCQAAAgAAAAECAAAAG2ludmFsaWQgaW50ZXJuYWxCYXNlQXNzZXRJZAMJAQAAAAIhPQAAAAIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBQAAABZzaHV0ZG93bk1hbmFnZXJBZGRyZXNzCQAAAgAAAAECAAAADWFjY2VzcyBkZW5pZWQJAARMAAAAAgkBAAAADEJvb2xlYW5FbnRyeQAAAAIJAQAAABdrZXlTaHV0ZG93blB1dE9wZXJhdGlvbgAAAAEJAAGkAAAAAQUAAAATaW50ZXJuYWxCYXNlQXNzZXRJZAYFAAAAA25pbAAAAAFpAQAAAAlzdWJtaXRQdXQAAAAABAAAAANwbXQJAQAAAAV2YWx1ZQAAAAEJAAGRAAAAAggFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAAEAAAACGluQW1vdW50CAUAAAADcG10AAAABmFtb3VudAQAAAAJaW5Bc3NldElkCQEAAAAFdmFsdWUAAAABCAUAAAADcG10AAAAB2Fzc2V0SWQEAAAADGJhc2VBc3NldFN0cgkAAlgAAAABBQAAAAlpbkFzc2V0SWQJAQAAAAZzdWJtaXQAAAAFAgAAAAFQBQAAAAFpBQAAAAhpbkFtb3VudAUAAAAJaW5Bc3NldElkBQAAAAxiYXNlQXNzZXRTdHIAAAABaQEAAAAJc3VibWl0R2V0AAAAAAQAAAADcG10CQEAAAAFdmFsdWUAAAABCQABkQAAAAIIBQAAAAFpAAAACHBheW1lbnRzAAAAAAAAAAAABAAAAAhpbkFtb3VudAgFAAAAA3BtdAAAAAZhbW91bnQEAAAACWluQXNzZXRJZAkBAAAABXZhbHVlAAAAAQgFAAAAA3BtdAAAAAdhc3NldElkBAAAAA1zaGFyZUFzc2V0U3RyCQACWAAAAAEFAAAACWluQXNzZXRJZAQAAAAMYmFzZUFzc2V0U3RyCQEAAAAPZ2V0U3RyaW5nT3JGYWlsAAAAAQkBAAAAHGtleU1hcHBpbmdzU2hhcmUyYmFzZUFzc2V0SWQAAAABBQAAAA1zaGFyZUFzc2V0U3RyCQEAAAAGc3VibWl0AAAABQIAAAABRwUAAAABaQUAAAAIaW5BbW91bnQFAAAACWluQXNzZXRJZAUAAAAMYmFzZUFzc2V0U3RyAAAAAWkBAAAACmV4ZWN1dGVQdXQAAAADAAAADGJhc2VBc3NldFN0cgAAAA51c2VyQWRkcmVzc1N0cgAAAA1zdWJtaXRUeElkU3RyCQEAAAAHZXhlY3V0ZQAAAAQCAAAAAVAFAAAADGJhc2VBc3NldFN0cgUAAAAOdXNlckFkZHJlc3NTdHIFAAAADXN1Ym1pdFR4SWRTdHIAAAABaQEAAAAKZXhlY3V0ZUdldAAAAAMAAAAMYmFzZUFzc2V0U3RyAAAADnVzZXJBZGRyZXNzU3RyAAAADXN1Ym1pdFR4SWRTdHIJAQAAAAdleGVjdXRlAAAABAIAAAABRwUAAAAMYmFzZUFzc2V0U3RyBQAAAA51c2VyQWRkcmVzc1N0cgUAAAANc3VibWl0VHhJZFN0cgAAAAFpAQAAAA9vcGVyYXRpb25zTXV0ZXgAAAABAAAADGJhc2VBc3NldFN0cgQAAAANYXNzZXRDZmdBcnJheQkBAAAAEnJlYWRBc3NldENmZ09yRmFpbAAAAAEFAAAADGJhc2VBc3NldFN0cgQAAAAWdG9wVXBNYW5hZ2VyQWRkcmVzc1N0cgkAAZEAAAACBQAAAA1hc3NldENmZ0FycmF5BQAAABlJZHhDZmdUb3B1cE1hbmFnZXJBZGRyZXNzBAAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgkAAZEAAAACBQAAAA1hc3NldENmZ0FycmF5BQAAABdJZHhDZmdJbnRlcm5hbEJhc2VBc3NldAMJAQAAAAIhPQAAAAIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBQAAABZ0b3BVcE1hbmFnZXJBZGRyZXNzU3RyCQEAAAAUZmFpbFRvcHVwTWFuYWdlck9ubHkAAAABBQAAABZ0b3BVcE1hbmFnZXJBZGRyZXNzU3RyCQAETAAAAAIJAQAAABJUb3B1cE11dGV4SW50RW50cnkAAAACBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAGaGVpZ2h0BQAAAANuaWwAAAABaQEAAAAMdG9wVXBCYWxhbmNlAAAAAgAAAAxiYXNlQXNzZXRTdHIAAAAGYW1vdW50BAAAAAtiYXNlQXNzZXRJZAkAAlkAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAADWFzc2V0Q2ZnQXJyYXkJAQAAABJyZWFkQXNzZXRDZmdPckZhaWwAAAABBQAAAAxiYXNlQXNzZXRTdHIEAAAADHNoYXJlQXNzZXRJZAkAAlkAAAABCQABkQAAAAIFAAAADWFzc2V0Q2ZnQXJyYXkFAAAAEklkeENmZ1NoYXJlQXNzZXRJZAQAAAAJcHJpY2VNdWx0CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAANYXNzZXRDZmdBcnJheQUAAAAXSWR4Q2ZnRGVjaW1hbHNNdWx0UHJpY2UEAAAADWJvdGhBc3NldE11bHQJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAA1hc3NldENmZ0FycmF5BQAAABxJZHhDZmdEZWNpbWFsc011bHRCb3RoQXNzZXRzBAAAABV0b3B1cEludGVydmFsSW5CbG9ja3MJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAA1hc3NldENmZ0FycmF5BQAAABtJZHhDZmdUb3B1cEludGVydmFsSW5CbG9ja3MEAAAAFHRvcHVwTWF4TmVnYXRpdmVQYXJ0CQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAANYXNzZXRDZmdBcnJheQUAAAAaSWR4Q2ZnVG9wdXBNYXhOZWdhdGl2ZVBhcnQEAAAAFGludGVybmFsQmFzZUFzc2V0U3RyCQABkQAAAAIFAAAADWFzc2V0Q2ZnQXJyYXkFAAAAF0lkeENmZ0ludGVybmFsQmFzZUFzc2V0BAAAABZ0b3BVcE1hbmFnZXJBZGRyZXNzU3RyCQABkQAAAAIFAAAADWFzc2V0Q2ZnQXJyYXkFAAAAGUlkeENmZ1RvcHVwTWFuYWdlckFkZHJlc3MEAAAAEnRvcFVwQ3VycmVudElkeEtFWQkBAAAAEmtleVRvcFVwQ3VycmVudElkeAAAAAEFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBAAAAAxwcmV2VG9wVXBJZHgJAQAAAAxnZXRJbnRPckZhaWwAAAABBQAAABJ0b3BVcEN1cnJlbnRJZHhLRVkEAAAAD2N1cnJlbnRUb3BVcElkeAkAAGQAAAACBQAAAAxwcmV2VG9wVXBJZHgAAAAAAAAAAAEEAAAABXZhbGlkAwkAAGYAAAACBQAAAAZhbW91bnQAAAAAAAAAAAAEAAAAA3BtdAkBAAAABXZhbHVlAAAAAQkAAZEAAAACCAUAAAABaQAAAAhwYXltZW50cwAAAAAAAAAAAAQAAAAKcG10QXNzZXRJZAkBAAAABXZhbHVlAAAAAQgFAAAAA3BtdAAAAAdhc3NldElkAwkBAAAAAiE9AAAAAgUAAAALYmFzZUFzc2V0SWQFAAAACnBtdEFzc2V0SWQJAAACAAAAAQIAAAA+YXR0YWNoZWQgcGF5bWVudCdzIGFzc2V0IGlkIGlzIE5PVCBtYXRjaGVkIHBhc3NlZCBiYXNlQXNzZXRTdHIDCQAAZgAAAAIJAAGQAAAAAQgFAAAAAWkAAAAIcGF5bWVudHMAAAAAAAAAAAEJAAACAAAAAQIAAAAgb25seSBvbmUgcGF5bWVudCBjYW4gYmUgYXR0YWNoZWQDCQEAAAACIT0AAAACCAUAAAADcG10AAAABmFtb3VudAUAAAAGYW1vdW50CQAAAgAAAAECAAAAPWF0dGFjaGVkIHBheW1lbnQuYW1vdW50IGlzIE5PVCBtYXRjaGVkIHBhc3NlZCBhbW91bnQgYXJndW1lbnQGAwkAAGYAAAACAAAAAAAAAAAABQAAAAZhbW91bnQEAAAAC2Jhc2VCYWxhbmNlCQAD8AAAAAIFAAAABHRoaXMFAAAAC2Jhc2VBc3NldElkBAAAAA1hbGxvd2VkQW1vdW50CQAAawAAAAMFAAAAFHRvcHVwTWF4TmVnYXRpdmVQYXJ0BQAAAAtiYXNlQmFsYW5jZQUAAAANYm90aEFzc2V0TXVsdAMJAABmAAAAAgkBAAAAAS0AAAABBQAAAAZhbW91bnQFAAAADWFsbG93ZWRBbW91bnQJAAACAAAAAQkAASwAAAACAgAAAC90b3B1cCBuZWdhdGl2ZSBhbW91bnQgY291bGRuJ3QgYmUgZ3JlYXRlciB0aGFuIAkAAaQAAAABBQAAAA1hbGxvd2VkQW1vdW50BgkAAAIAAAABAgAAABp6ZXJvIGFtb3VudCBpcyBub3QgYWxsb3dlZAQAAAASdG9wVXBMYXN0SGVpZ2h0S0VZCQEAAAASa2V5VG9wVXBMYXN0SGVpZ2h0AAAAAgUAAAAUaW50ZXJuYWxCYXNlQXNzZXRTdHIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAAA90b3BVcExhc3RIZWlnaHQJAQAAAAt2YWx1ZU9yRWxzZQAAAAIJAAQaAAAAAgUAAAAEdGhpcwUAAAASdG9wVXBMYXN0SGVpZ2h0S0VZAAAAAAAAAAAAAwkBAAAAAiE9AAAAAgkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIFAAAAFnRvcFVwTWFuYWdlckFkZHJlc3NTdHIJAQAAABRmYWlsVG9wdXBNYW5hZ2VyT25seQAAAAEFAAAAFnRvcFVwTWFuYWdlckFkZHJlc3NTdHIDCQEAAAABIQAAAAEFAAAABXZhbGlkCQAAAgAAAAECAAAAEXZhbGlkYXRpb24gZmFpbGVkAwkAAGYAAAACBQAAABV0b3B1cEludGVydmFsSW5CbG9ja3MJAABlAAAAAgUAAAAGaGVpZ2h0BQAAAA90b3BVcExhc3RIZWlnaHQJAAACAAAAAQkAASwAAAACCQABLAAAAAICAAAADDEgdG9wdXAgcGVyIAkAAaQAAAABBQAAABV0b3B1cEludGVydmFsSW5CbG9ja3MCAAAAKCBibG9ja3MgZnJvbSB0aGUgc2FtZSBhZGRyZXNzIGlzIGFsbG93ZWQEAAAABXByaWNlCAkBAAAAEGdlbmVyaWNDYWxjUHJpY2UAAAAFBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAALYmFzZUFzc2V0SWQFAAAABmFtb3VudAUAAAAMc2hhcmVBc3NldElkBQAAAAlwcmljZU11bHQAAAACXzEEAAAACWRpZmZUdXBsZQkBAAAAE2NhbGNUb3RhbExvY2tlZERpZmYAAAAIAgAAAAV0b3B1cAIAAAAABQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAFcHJpY2UFAAAACXByaWNlTXVsdAAAAAAAAAAAAAUAAAALYmFzZUFzc2V0SWQFAAAADHNoYXJlQXNzZXRJZAQAAAAOdG9wdXBUb3RhbERpZmYIBQAAAAlkaWZmVHVwbGUAAAACXzEEAAAAC3ByaWNlQXRoS0VZCQEAAAALa2V5UHJpY2VBVEgAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgQAAAAMcHJldlByaWNlQVRICQEAAAALdmFsdWVPckVsc2UAAAACCQAEGgAAAAIFAAAABHRoaXMFAAAAC3ByaWNlQXRoS0VZAAAAAAAAAAAACQAETgAAAAIJAARNAAAAAgkABE0AAAACCQAETQAAAAIJAARNAAAAAgkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAADGtleVByaWNlTGFzdAAAAAEFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAAVwcmljZQkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAD2tleVByaWNlSGlzdG9yeQAAAAMFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAAZoZWlnaHQIBQAAAAlsYXN0QmxvY2sAAAAJdGltZXN0YW1wBQAAAAVwcmljZQkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAEmtleVByaWNlQnlUb3BVcElkeAAAAAIFAAAAFGludGVybmFsQmFzZUFzc2V0U3RyBQAAAA9jdXJyZW50VG9wVXBJZHgFAAAABXByaWNlCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACBQAAABJ0b3BVcEN1cnJlbnRJZHhLRVkFAAAAD2N1cnJlbnRUb3BVcElkeAkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgUAAAALcHJpY2VBdGhLRVkDCQAAZgAAAAIFAAAABXByaWNlBQAAAAxwcmV2UHJpY2VBVEgFAAAABXByaWNlBQAAAAxwcmV2UHJpY2VBVEgJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIFAAAAEnRvcFVwTGFzdEhlaWdodEtFWQUAAAAGaGVpZ2h0BQAAAANuaWwJAQAAABZUb3RhbExvY2tlZFN0cmluZ0VudHJ5AAAAAwIAAAAJREVDUkVNRU5UCQEAAAAOa2V5VG90YWxMb2NrZWQAAAABBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgUAAAAOdG9wdXBUb3RhbERpZmYJAQAAABJUb3B1cE11dGV4SW50RW50cnkAAAACBQAAABRpbnRlcm5hbEJhc2VBc3NldFN0cgAAAAAAAAAAAAkBAAAABEJ1cm4AAAACBQAAAAxzaGFyZUFzc2V0SWQJAAGRAAAAAgUAAAAOdG9wdXBUb3RhbERpZmYFAAAAFUlkeFRvdGFsTG9ja2VkSW5TaGFyZQkBAAAAB1JlaXNzdWUAAAADBQAAAAxzaGFyZUFzc2V0SWQJAQAAAAEtAAAAAQkAAZEAAAACBQAAAA50b3B1cFRvdGFsRGlmZgUAAAAWSWR4VG90YWxMb2NrZWRPdXRTaGFyZQYDCQAAZgAAAAIAAAAAAAAAAAAFAAAABmFtb3VudAkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADCAUAAAABaQAAAAZjYWxsZXIJAQAAAAEtAAAAAQUAAAAGYW1vdW50BQAAAAtiYXNlQXNzZXRJZAUAAAADbmlsBQAAAANuaWwAAAABaQEAAAAUY3VycmVudFN5c1BhcmFtc1JFU1QAAAABAAAADGJhc2VBc3NldFN0cgQAAAANc3lzU3RhdGVUdXBsZQkBAAAAG3ByaXZhdGVDdXJyZW50U3lzUGFyYW1zUkVTVAAAAAEFAAAADGJhc2VBc3NldFN0cgQAAAAFcHJpY2UICAUAAAANc3lzU3RhdGVUdXBsZQAAAAJfMQAAAAV2YWx1ZQQAAAARZGVjaW1hbHNNdWx0UHJpY2UICAUAAAANc3lzU3RhdGVUdXBsZQAAAAJfMgAAAAV2YWx1ZQQAAAAQYmFzZUFzc2V0QmFsYW5jZQgIBQAAAA1zeXNTdGF0ZVR1cGxlAAAAAl8zAAAABXZhbHVlBAAAABV0b3RhbExvY2tlZEJhc2VBbW91bnQICAUAAAANc3lzU3RhdGVUdXBsZQAAAAJfNAAAAAV2YWx1ZQQAAAATYmFzZUFzc2V0QmFsYW5jZVdDTwgIBQAAAA1zeXNTdGF0ZVR1cGxlAAAAAl81AAAABXZhbHVlBAAAAA1zaGFyZUVtaXNzaW9uCAgFAAAADXN5c1N0YXRlVHVwbGUAAAACXzYAAAAFdmFsdWUEAAAACHJlc3REYXRhCQAEuQAAAAIJAARMAAAAAgIAAAAZc3RhcnRDdXJyZW50U3lzUGFyYW1zUkVTVAkABEwAAAACCQABpAAAAAEFAAAABXByaWNlCQAETAAAAAIJAAGkAAAAAQUAAAARZGVjaW1hbHNNdWx0UHJpY2UJAARMAAAAAgkAAaQAAAABBQAAABBiYXNlQXNzZXRCYWxhbmNlCQAETAAAAAIJAAGkAAAAAQUAAAAVdG90YWxMb2NrZWRCYXNlQW1vdW50CQAETAAAAAIJAAGkAAAAAQUAAAATYmFzZUFzc2V0QmFsYW5jZVdDTwkABEwAAAACCQABpAAAAAEFAAAADXNoYXJlRW1pc3Npb24JAARMAAAAAgIAAAAXZW5kQ3VycmVudFN5c1BhcmFtc1JFU1QFAAAAA25pbAUAAAADU0VQCQAAAgAAAAEFAAAACHJlc3REYXRhAAAAADi3EUU=",
    "chainId": 84,
    "height": 1454597,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: F6XVGrwNfKoawn776NeSWJoTD3C1VpuxQxipH3TbBp3F
Next: 24w2yoHRoB44ajZVdmtj6acdRUA8Vhf5Xr9niZFGveAw

Diff: 

OldNewDifferences
1616 
1717 
1818 func failSubmitLimitsExceeds (remainingBase,remainingShare,newRemainingBase,newRemainingShare) = throw((((((((("submit operation limits have been reached: " + " remainingBase=") + toString(remainingBase)) + " remainingShare=") + toString(remainingShare)) + " newRemainingBase=") + toString(newRemainingBase)) + " newRemainingShare=") + toString(newRemainingShare)))
19+
20+
21+func failTopupManagerOnly (topupManagerAddress) = throw((("opertion denied: only topUpManager=" + topupManagerAddress) + " can send such transactions"))
1922 
2023 
2124 func convertShare2Base (shareAmount,price,priceMult) = fraction(shareAmount, price, priceMult)
7073 
7174 
7275 func keyTopUpLastHeight (internalBasetAssetStr,sender) = makeString(["%s%s%s%d%s__topup__last__height", internalBasetAssetStr, sender], SEP)
76+
77+
78+func keyTopupMutext (internalBasetAssetStr) = ("%s%s%d__topup__mutex__" + internalBasetAssetStr)
79+
80+
81+func keyTopupHistory (internalBasetAssetStr,topupIdx) = makeString(["%s%s%d%d__topup__history", internalBasetAssetStr, toString(topupIdx)], SEP)
7382 
7483 
7584 func keyLimitsRemaining (internalBasetAssetStr) = ("%s%s%d__limits__remaining__" + internalBasetAssetStr)
193202 
194203 let IdxOperEndTimestamp = 8
195204 
196-let IdxOperLock = 9
205+let IdxOperTopupUnlockIdx = 9
197206 
198207 func privateDataOperationAllStrings (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,lock) = makeString(["%s%d%d%d%d%d%d%d%d", status, inAssetAmount, price, outAssetAmount, startHeight, startTimestamp, endHeight, endTimestamp, lock], SEP)
199208 
200209 
201-func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,lock) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp), toString(lock))
210+func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,topupUnlockIdx) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp), toString(topupUnlockIdx))
202211 
203212 
204-func dataOperationExecutionUpdate (currOperArray,newStatus,newPrice,newOutAmount) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], toString(newPrice), toString(newOutAmount), currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], toString(height), toString(lastBlock.timestamp), currOperArray[IdxOperLock])
213+func dataOperationExecutionUpdate (currOperArray,newStatus,newPrice,newOutAmount) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], toString(newPrice), toString(newOutAmount), currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], toString(height), toString(lastBlock.timestamp), currOperArray[IdxOperTopupUnlockIdx])
205214 
206215 
207216 func readAssetCfgOrFail (baseAssetStr) = {
217226 func RemainingLimitsStringEntry (key,baseRemainingLimit,shareRemainingLimit) = StringEntry(key, makeString(["%d%d", toString(baseRemainingLimit), toString(shareRemainingLimit)], SEP))
218227 
219228 
229+func TopupMutexIntEntry (internalBaseAssetStr,acquiredHeight) = IntegerEntry(keyTopupMutext(internalBaseAssetStr), acquiredHeight)
230+
231+
232+func TopupHistoryEntry (internalBaseAssetStr,topupIdx) = ""
233+
234+
220235 func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultPrice) = {
221236     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
222237     let totalLockedOutBaseAmount = totalLockedArray[IdxTotalLockedOutBase]
223238     let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
224239     let baseAssetBalance = assetBalance(this, baseAssetId)
225-    let baseAssetBalanceCALC = (((baseAssetBalance + topUpBaseAmount) - totalLockedInBaseAmount) - totalLockedOutBaseAmount)
240+    let baseAssetBalanceWCO = (((baseAssetBalance + topUpBaseAmount) - totalLockedInBaseAmount) - totalLockedOutBaseAmount)
226241     let totalLockedOutShareAmount = totalLockedArray[IdxTotalLockedOutShare]
227242     let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
228243     let shareEmission = value(assetInfo(shareAssetId)).quantity
229-    let shareEmissionCALC = (shareEmission + totalLockedOutShareAmount)
230-    if ((0 > baseAssetBalanceCALC))
231-        then throw(((("baseAssetBalanceCALC < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceCALC=") + toString(baseAssetBalanceCALC)))
244+    if ((0 > baseAssetBalanceWCO))
245+        then throw(((("baseAssetBalanceWCO < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceWCO=") + toString(baseAssetBalanceWCO)))
232246         else {
233247             let lastPrice = getIntOrFail(keyPriceLast(internalBaseAssetStr))
234248             let price = if ((shareEmission == 0))
235249                 then lastPrice
236-                else fraction(baseAssetBalanceCALC, decimalsMultPrice, shareEmissionCALC)
237-            $Tuple5(price, baseAssetBalance, totalLockedOutBaseAmount, baseAssetBalanceCALC, shareEmission)
250+                else fraction(baseAssetBalanceWCO, decimalsMultPrice, shareEmission)
251+            $Tuple5(price, baseAssetBalance, -1, baseAssetBalanceWCO, shareEmission)
238252             }
239253     }
240254 
259273     if (isPutBlocked)
260274         then throw("put operation is blocked")
261275         else {
262-            let diffTuple = calcTotalLockedDiff("submit", operationType, internalBaseAssetStr, 0, 0, inAmount, baseAssetId, shareAssetId)
263-            let limitsRemainingBaseNew = (limitsRemainingBase - diffTuple._2[IdxTotalLockedInBase])
264-            let limitsRemainingShareNew = (limitsRemainingShare - diffTuple._2[IdxTotalLockedInShare])
265-            if (if ((0 > limitsRemainingBaseNew))
266-                then true
267-                else (0 > limitsRemainingShareNew))
268-                then failSubmitLimitsExceeds(limitsRemainingBase, limitsRemainingShare, limitsRemainingBaseNew, limitsRemainingShareNew)
276+            let operationsMutex = valueOrElse(getInteger(this, keyTopupMutext(internalBaseAssetStr)), 0)
277+            if (((operationsMutex + 60) > height))
278+                then throw("submit operations are blocked by topup manager")
269279                 else {
270-                    let topUpCurrentIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
271-                    ((([StringEntry(keyOperation(operationType, internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("PENDING", inAmount, 0, 0, height, lastBlock.timestamp, 0, 0, (topUpCurrentIdx + 1)))] :+ TotalLockedStringEntry("INCREMENT", keyTotalLocked(internalBaseAssetStr), diffTuple._1)) :+ TotalLockedStringEntry("INCREMENT", keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), diffTuple._2)) :+ RemainingLimitsStringEntry(limitsKEY, limitsRemainingBaseNew, limitsRemainingShareNew))
280+                    let diffTuple = calcTotalLockedDiff("submit", operationType, internalBaseAssetStr, 0, 0, inAmount, baseAssetId, shareAssetId)
281+                    let limitsRemainingBaseNew = (limitsRemainingBase - diffTuple._2[IdxTotalLockedInBase])
282+                    let limitsRemainingShareNew = (limitsRemainingShare - diffTuple._2[IdxTotalLockedInShare])
283+                    if (if ((0 > limitsRemainingBaseNew))
284+                        then true
285+                        else (0 > limitsRemainingShareNew))
286+                        then failSubmitLimitsExceeds(limitsRemainingBase, limitsRemainingShare, limitsRemainingBaseNew, limitsRemainingShareNew)
287+                        else {
288+                            let topUpCurrentIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
289+                            ((([StringEntry(keyOperation(operationType, internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("PENDING", inAmount, 0, 0, height, lastBlock.timestamp, 0, 0, (topUpCurrentIdx + 1)))] :+ TotalLockedStringEntry("INCREMENT", keyTotalLocked(internalBaseAssetStr), diffTuple._1)) :+ TotalLockedStringEntry("INCREMENT", keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), diffTuple._2)) :+ RemainingLimitsStringEntry(limitsKEY, limitsRemainingBaseNew, limitsRemainingShareNew))
290+                            }
272291                     }
273292             }
274293     }
285304     let operationArray = split(getStringOrFail(operationKey), SEP)
286305     let status = operationArray[IdxOperStatus]
287306     let inAmount = parseIntValue(operationArray[IdxOperInAmount])
288-    let operLock = parseIntValue(operationArray[IdxOperLock])
307+    let topupUnlockIdx = parseIntValue(operationArray[IdxOperTopupUnlockIdx])
289308     let currTopUpIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
290309     let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(internalBaseAssetStr, currTopUpIdx))
291310     if ((status != "PENDING"))
292311         then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, submitTxIdStr, operationType)
293-        else if ((operLock > currTopUpIdx))
294-            then failExecuteGet(((("OperLock[" + toString(operLock)) + "] > ") + toString(currTopUpIdx)), baseAssetStr, userAddressStr, submitTxIdStr, operationType)
312+        else if ((topupUnlockIdx > currTopUpIdx))
313+            then failExecuteGet(((("OperLock[" + toString(topupUnlockIdx)) + "] > ") + toString(currTopUpIdx)), baseAssetStr, userAddressStr, submitTxIdStr, operationType)
295314             else {
296315                 let diffTuple = calcTotalLockedDiff("execute", operationType, internalBaseAssetStr, priceByTopUpId, decimalsMultPrice, inAmount, baseAssetId, shareAssetId)
297316                 let outAmount = diffTuple._3
298317                 let outTransferData = if ((diffTuple._4 == baseAssetId))
299318                     then [ScriptTransfer(userAddress, outAmount, baseAssetId)]
300-                    else [Reissue(shareAssetId, outAmount, true), ScriptTransfer(userAddress, outAmount, shareAssetId)]
319+                    else [ScriptTransfer(userAddress, outAmount, shareAssetId)]
301320                 (((outTransferData :+ StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", priceByTopUpId, outAmount))) :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), diffTuple._1)) :+ TotalLockedStringEntry("DECREMENT", keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), diffTuple._2))
302321                 }
303322     }
312331     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
313332     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
314333     let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPrice)
315-    $Tuple6(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5))
334+    $Tuple6(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("-1", sysState._3), IntegerEntry("baseAssetBalanceWCO", sysState._4), IntegerEntry("shareEmission", sysState._5))
316335     }
317336 
318337 
401420 
402421 
403422 @Callable(i)
423+func operationsMutex (baseAssetStr) = {
424+    let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
425+    let topUpManagerAddressStr = assetCfgArray[IdxCfgTopupManagerAddress]
426+    let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
427+    if ((toString(i.caller) != topUpManagerAddressStr))
428+        then failTopupManagerOnly(topUpManagerAddressStr)
429+        else [TopupMutexIntEntry(internalBaseAssetStr, height)]
430+    }
431+
432+
433+
434+@Callable(i)
404435 func topUpBalance (baseAssetStr,amount) = {
405436     let baseAssetId = fromBase58String(baseAssetStr)
406437     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
431462                 let baseBalance = assetBalance(this, baseAssetId)
432463                 let allowedAmount = fraction(topupMaxNegativePart, baseBalance, bothAssetMult)
433464                 if ((-(amount) > allowedAmount))
434-                    then throw(("Topup negative amount couldn't be greater than " + toString(allowedAmount)))
465+                    then throw(("topup negative amount couldn't be greater than " + toString(allowedAmount)))
435466                     else true
436467                 }
437468             else throw("zero amount is not allowed")
438469     let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
439470     let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
440471     if ((toString(i.caller) != topUpManagerAddressStr))
441-        then throw((("only topUpManager=" + topUpManagerAddressStr) + " can send topUp transactions"))
472+        then failTopupManagerOnly(topUpManagerAddressStr)
442473         else if (!(valid))
443474             then throw("validation failed")
444475             else if ((topupIntervalInBlocks > (height - topUpLastHeight)))
449480                     let topupTotalDiff = diffTuple._1
450481                     let priceAthKEY = keyPriceATH(internalBaseAssetStr)
451482                     let prevPriceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
452-                    ((([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx), IntegerEntry(priceAthKEY, if ((price > prevPriceATH))
483+                    ((((([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx), IntegerEntry(priceAthKEY, if ((price > prevPriceATH))
453484                         then price
454-                        else prevPriceATH), IntegerEntry(topUpLastHeightKEY, height)] :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), topupTotalDiff)) :+ Burn(shareAssetId, topupTotalDiff[IdxTotalLockedInShare])) ++ (if ((0 > amount))
485+                        else prevPriceATH), IntegerEntry(topUpLastHeightKEY, height)] :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), topupTotalDiff)) :+ TopupMutexIntEntry(internalBaseAssetStr, 0)) :+ Burn(shareAssetId, topupTotalDiff[IdxTotalLockedInShare])) :+ Reissue(shareAssetId, -(topupTotalDiff[IdxTotalLockedOutShare]), true)) ++ (if ((0 > amount))
455486                         then [ScriptTransfer(i.caller, -(amount), baseAssetId)]
456487                         else nil))
457488                     }
466497     let decimalsMultPrice = sysStateTuple._2.value
467498     let baseAssetBalance = sysStateTuple._3.value
468499     let totalLockedBaseAmount = sysStateTuple._4.value
469-    let baseAssetBalanceConsideringLock = sysStateTuple._5.value
500+    let baseAssetBalanceWCO = sysStateTuple._5.value
470501     let shareEmission = sysStateTuple._6.value
471-    let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
502+    let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceWCO), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
472503     throw(restData)
473504     }
474505 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 4 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let SEP = "__"
55 
66 func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), ("No data for this.key=" + key))
77 
88 
99 func getBooleanOrFail (key) = valueOrErrorMessage(getBoolean(this, key), ("No data for this.key=" + key))
1010 
1111 
1212 func getIntOrFail (key) = valueOrErrorMessage(getInteger(this, key), ("No data for this.key=" + key))
1313 
1414 
1515 func failExecuteGet (msg,baseAssetStr,userAddressStr,submitTxIdStr,operationType) = throw(((((((((msg + ": baseAssetStr=") + baseAssetStr) + " userAddressStr=") + userAddressStr) + " submitTxIdStr=") + submitTxIdStr) + " operationType=") + operationType))
1616 
1717 
1818 func failSubmitLimitsExceeds (remainingBase,remainingShare,newRemainingBase,newRemainingShare) = throw((((((((("submit operation limits have been reached: " + " remainingBase=") + toString(remainingBase)) + " remainingShare=") + toString(remainingShare)) + " newRemainingBase=") + toString(newRemainingBase)) + " newRemainingShare=") + toString(newRemainingShare)))
19+
20+
21+func failTopupManagerOnly (topupManagerAddress) = throw((("opertion denied: only topUpManager=" + topupManagerAddress) + " can send such transactions"))
1922 
2023 
2124 func convertShare2Base (shareAmount,price,priceMult) = fraction(shareAmount, price, priceMult)
2225 
2326 
2427 func convertBase2Share (baseAmount,price,priceMult) = fraction(baseAmount, priceMult, price)
2528 
2629 
2730 func keyAssetCfg (baseAssetStr) = ("%s%s%s__config__asset__" + baseAssetStr)
2831 
2932 
3033 func keyNextInternalAssetId () = "%s__nextInternalAssetId"
3134 
3235 
3336 func keyPriceLast (internalBasetAssetStr) = ("%s%s%d__price__last__" + internalBasetAssetStr)
3437 
3538 
3639 func keyPriceATH (internalBasetAssetStr) = ("%s%s%d__price__ath__" + internalBasetAssetStr)
3740 
3841 
3942 func keyPriceByTopUpIdx (internalBaseAssetStr,topUpIdx) = makeString(["%s%s%d%d__price__byTopUpIdx", internalBaseAssetStr, toString(topUpIdx)], SEP)
4043 
4144 
4245 func keyPriceHistory (internalBasetAssetStr,h,timestamp) = makeString(["%s%s%d%d%d__price__history", internalBasetAssetStr, toString(h), toString(timestamp)], SEP)
4346 
4447 
4548 func keyTotalLocked (internalBasetAssetStr) = ("%s%s%d__total__locked__" + internalBasetAssetStr)
4649 
4750 
4851 func keyTotalLockedByUser (internalBaseAssetStr,userAddressStr) = makeString(["%s%s%d%s__total__locked", internalBaseAssetStr, userAddressStr], SEP)
4952 
5053 
5154 func keyMappingsInternal2baseAssetId (internalBaseAsset) = ("%s%s%d__mappings__internal2baseAssetId__" + toString(internalBaseAsset))
5255 
5356 
5457 func keyMappingsBaseAsset2internalId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2internalId__" + baseAssetStr)
5558 
5659 
5760 func keyMappingsShare2baseAssetId (shareAssetStr) = ("%s%s%s__mappings__share2baseAssetId__" + shareAssetStr)
5861 
5962 
6063 func keyMappingsBaseAsset2shareId (baseAssetStr) = ("%s%s%s__mappings__baseAsset2shareId__" + baseAssetStr)
6164 
6265 
6366 func keyShutdownPutOperation (internalBaseAssetStr) = ("%s%s%d__shutdown__put__" + internalBaseAssetStr)
6467 
6568 
6669 func keyShutdownManager (internalBaseAssetStr) = ("%s%s%d__shutdown__manager__" + internalBaseAssetStr)
6770 
6871 
6972 func keyTopUpCurrentIdx (internalBaseAssetStr) = ("%s%s%d__topup__currentIdx__" + internalBaseAssetStr)
7073 
7174 
7275 func keyTopUpLastHeight (internalBasetAssetStr,sender) = makeString(["%s%s%s%d%s__topup__last__height", internalBasetAssetStr, sender], SEP)
76+
77+
78+func keyTopupMutext (internalBasetAssetStr) = ("%s%s%d__topup__mutex__" + internalBasetAssetStr)
79+
80+
81+func keyTopupHistory (internalBasetAssetStr,topupIdx) = makeString(["%s%s%d%d__topup__history", internalBasetAssetStr, toString(topupIdx)], SEP)
7382 
7483 
7584 func keyLimitsRemaining (internalBasetAssetStr) = ("%s%s%d__limits__remaining__" + internalBasetAssetStr)
7685 
7786 
7887 let IdxCfgShareAssetId = 1
7988 
8089 let IdxCfgInternalBaseAsset = 2
8190 
8291 let IdxCfgDecimalsMultBothAssets = 3
8392 
8493 let IdxCfgDecimalsMultPrice = 4
8594 
8695 let IdxCfgGetDelayBlocks = 5
8796 
8897 let IdxCfgTopupIntervalInBlocks = 6
8998 
9099 let IdxCfgTopupMaxNegativePart = 7
91100 
92101 let IdxCfgTopupManagerAddress = 8
93102 
94103 let IdxCfgSubmitLimitsBaseMax = 9
95104 
96105 let IdxCfgSubmitLimitsBaseReset = 10
97106 
98107 let IdxCfgSubmitLimitsShareMax = 11
99108 
100109 let IdxCfgSubmitLimitsShareReset = 12
101110 
102111 func dataAssetCfg (shareAssetStr,internalBaseAssetStr,decimalsMultBothAssets,decimalsMultPrice,getDelayInBlocks,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress,submitLimitsBaseMax,submitLimitsBaseReset,submitLimitsShareMax,submitLimitsShareReset) = makeString(["%s%d%d%d%d%d%d%s%d%d%d%d", shareAssetStr, internalBaseAssetStr, toString(decimalsMultBothAssets), toString(decimalsMultPrice), toString(getDelayInBlocks), toString(topupIntervalInBlocks), toString(topupMaxNegativePart), topupManagerAddress, toString(submitLimitsBaseMax), toString(submitLimitsBaseReset), toString(submitLimitsShareMax), toString(submitLimitsShareReset)], SEP)
103112 
104113 
105114 let IdxTotalLockedInShare = 1
106115 
107116 let IdxTotalLockedOutBase = 2
108117 
109118 let IdxTotalLockedInBase = 3
110119 
111120 let IdxTotalLockedOutShare = 4
112121 
113122 func dataTotalLocked (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = makeString(["%d%d%d%d", toString(inShareAmount), toString(outBaseAmount), toString(inBaseAmount), toString(outShareAmount)], SEP)
114123 
115124 
116125 func dataTotalLockedInt (inShareAmount,outBaseAmount,inBaseAmount,outShareAmount) = [-1, inShareAmount, outBaseAmount, inBaseAmount, outShareAmount]
117126 
118127 
119128 func readTotalLocked (key) = {
120129     let totalLockedArray = split(valueOrElse(getString(this, key), dataTotalLocked(0, 0, 0, 0)), SEP)
121130     dataTotalLockedInt(parseIntValue(totalLockedArray[IdxTotalLockedInShare]), parseIntValue(totalLockedArray[IdxTotalLockedOutBase]), parseIntValue(totalLockedArray[IdxTotalLockedInBase]), parseIntValue(totalLockedArray[IdxTotalLockedOutShare]))
122131     }
123132 
124133 
125134 func calcTotalLockedDiff (direction,operationType,internalBaseAssetStr,price,priceMult,inAmount,baseAssetId,shareAssetId) = {
126135     let t = (direction + operationType)
127136     if ((t == "submitP"))
128137         then {
129138             let totalDiff = dataTotalLockedInt(0, 0, inAmount, 0)
130139             let userDiff = totalDiff
131140             $Tuple4(totalDiff, userDiff, 0, fromBase58String(""))
132141             }
133142         else if ((t == "submitG"))
134143             then {
135144                 let totalDiff = dataTotalLockedInt(inAmount, 0, 0, 0)
136145                 let userDiff = totalDiff
137146                 $Tuple4(totalDiff, userDiff, 0, fromBase58String(""))
138147                 }
139148             else if ((t == "executeP"))
140149                 then {
141150                     let outAmount = convertBase2Share(inAmount, price, priceMult)
142151                     let totalDiff = dataTotalLockedInt(0, 0, 0, outAmount)
143152                     let userDiff = dataTotalLockedInt(0, 0, inAmount, 0)
144153                     $Tuple4(totalDiff, userDiff, outAmount, shareAssetId)
145154                     }
146155                 else if ((t == "executeG"))
147156                     then {
148157                         let outAmount = convertShare2Base(inAmount, price, priceMult)
149158                         let totalDiff = dataTotalLockedInt(0, outAmount, 0, 0)
150159                         let userDiff = dataTotalLockedInt(inAmount, 0, 0, 0)
151160                         $Tuple4(totalDiff, userDiff, outAmount, baseAssetId)
152161                         }
153162                     else if ((t == "topup"))
154163                         then {
155164                             let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
156165                             let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
157166                             let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
158167                             let totalDiff = dataTotalLockedInt(totalLockedInShareAmount, (-1 * convertShare2Base(totalLockedInShareAmount, price, priceMult)), totalLockedInBaseAmount, (-1 * convertBase2Share(totalLockedInBaseAmount, price, priceMult)))
159168                             $Tuple4(totalDiff, nil, 0, fromBase58String(""))
160169                             }
161170                         else throw(("Unsupported Type " + t))
162171     }
163172 
164173 
165174 func TotalLockedStringEntry (action,key,diff) = {
166175     func UPDATE (a,b) =     if ((action == "INCREMENT"))
167176         then (a + b)
168177         else if ((action == "DECREMENT"))
169178             then (a - b)
170179             else throw(("Unsupported action " + action))
171180 
172181     let dataArray = readTotalLocked(key)
173182     StringEntry(key, dataTotalLocked(UPDATE(dataArray[IdxTotalLockedInShare], diff[IdxTotalLockedInShare]), UPDATE(dataArray[IdxTotalLockedOutBase], diff[IdxTotalLockedOutBase]), UPDATE(dataArray[IdxTotalLockedInBase], diff[IdxTotalLockedInBase]), UPDATE(dataArray[IdxTotalLockedOutShare], diff[IdxTotalLockedOutShare])))
174183     }
175184 
176185 
177186 func keyOperation (operationType,internalBaseAssetStr,userAddress,txId) = makeString(["%s%d%s%s", operationType, internalBaseAssetStr, userAddress, txId], SEP)
178187 
179188 
180189 let IdxOperStatus = 1
181190 
182191 let IdxOperInAmount = 2
183192 
184193 let IdxOperPrice = 3
185194 
186195 let IdxOperOutAmount = 4
187196 
188197 let IdxOperStartHeight = 5
189198 
190199 let IdxOperStartTimestamp = 6
191200 
192201 let IdxOperEndHeight = 7
193202 
194203 let IdxOperEndTimestamp = 8
195204 
196-let IdxOperLock = 9
205+let IdxOperTopupUnlockIdx = 9
197206 
198207 func privateDataOperationAllStrings (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,lock) = makeString(["%s%d%d%d%d%d%d%d%d", status, inAssetAmount, price, outAssetAmount, startHeight, startTimestamp, endHeight, endTimestamp, lock], SEP)
199208 
200209 
201-func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,lock) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp), toString(lock))
210+func dataOperation (status,inAssetAmount,price,outAssetAmount,startHeight,startTimestamp,endHeight,endTimestamp,topupUnlockIdx) = privateDataOperationAllStrings(status, toString(inAssetAmount), toString(price), toString(outAssetAmount), toString(startHeight), toString(startTimestamp), toString(endHeight), toString(endTimestamp), toString(topupUnlockIdx))
202211 
203212 
204-func dataOperationExecutionUpdate (currOperArray,newStatus,newPrice,newOutAmount) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], toString(newPrice), toString(newOutAmount), currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], toString(height), toString(lastBlock.timestamp), currOperArray[IdxOperLock])
213+func dataOperationExecutionUpdate (currOperArray,newStatus,newPrice,newOutAmount) = privateDataOperationAllStrings(newStatus, currOperArray[IdxOperInAmount], toString(newPrice), toString(newOutAmount), currOperArray[IdxOperStartHeight], currOperArray[IdxOperStartTimestamp], toString(height), toString(lastBlock.timestamp), currOperArray[IdxOperTopupUnlockIdx])
205214 
206215 
207216 func readAssetCfgOrFail (baseAssetStr) = {
208217     let key = keyAssetCfg(baseAssetStr)
209218     split(getStringOrFail(key), SEP)
210219     }
211220 
212221 
213222 let IdxLimitsRemainingBase = 1
214223 
215224 let IdxLimitsRemainingShare = 2
216225 
217226 func RemainingLimitsStringEntry (key,baseRemainingLimit,shareRemainingLimit) = StringEntry(key, makeString(["%d%d", toString(baseRemainingLimit), toString(shareRemainingLimit)], SEP))
218227 
219228 
229+func TopupMutexIntEntry (internalBaseAssetStr,acquiredHeight) = IntegerEntry(keyTopupMutext(internalBaseAssetStr), acquiredHeight)
230+
231+
232+func TopupHistoryEntry (internalBaseAssetStr,topupIdx) = ""
233+
234+
220235 func genericCalcPrice (internalBaseAssetStr,baseAssetId,topUpBaseAmount,shareAssetId,decimalsMultPrice) = {
221236     let totalLockedArray = readTotalLocked(keyTotalLocked(internalBaseAssetStr))
222237     let totalLockedOutBaseAmount = totalLockedArray[IdxTotalLockedOutBase]
223238     let totalLockedInBaseAmount = totalLockedArray[IdxTotalLockedInBase]
224239     let baseAssetBalance = assetBalance(this, baseAssetId)
225-    let baseAssetBalanceCALC = (((baseAssetBalance + topUpBaseAmount) - totalLockedInBaseAmount) - totalLockedOutBaseAmount)
240+    let baseAssetBalanceWCO = (((baseAssetBalance + topUpBaseAmount) - totalLockedInBaseAmount) - totalLockedOutBaseAmount)
226241     let totalLockedOutShareAmount = totalLockedArray[IdxTotalLockedOutShare]
227242     let totalLockedInShareAmount = totalLockedArray[IdxTotalLockedInShare]
228243     let shareEmission = value(assetInfo(shareAssetId)).quantity
229-    let shareEmissionCALC = (shareEmission + totalLockedOutShareAmount)
230-    if ((0 > baseAssetBalanceCALC))
231-        then throw(((("baseAssetBalanceCALC < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceCALC=") + toString(baseAssetBalanceCALC)))
244+    if ((0 > baseAssetBalanceWCO))
245+        then throw(((("baseAssetBalanceWCO < 0: baseAssetBalance=" + toString(baseAssetBalance)) + " baseAssetBalanceWCO=") + toString(baseAssetBalanceWCO)))
232246         else {
233247             let lastPrice = getIntOrFail(keyPriceLast(internalBaseAssetStr))
234248             let price = if ((shareEmission == 0))
235249                 then lastPrice
236-                else fraction(baseAssetBalanceCALC, decimalsMultPrice, shareEmissionCALC)
237-            $Tuple5(price, baseAssetBalance, totalLockedOutBaseAmount, baseAssetBalanceCALC, shareEmission)
250+                else fraction(baseAssetBalanceWCO, decimalsMultPrice, shareEmission)
251+            $Tuple5(price, baseAssetBalance, -1, baseAssetBalanceWCO, shareEmission)
238252             }
239253     }
240254 
241255 
242256 func calcPrice (internalBaseAssetStr,baseAssetId,shareAssetId,decimalsMultPrice) = genericCalcPrice(internalBaseAssetStr, baseAssetId, 0, shareAssetId, decimalsMultPrice)
243257 
244258 
245259 func submit (operationType,i,inAmount,inAssetId,baseAssetStr) = {
246260     let inAssetStr = toBase58String(inAssetId)
247261     let userAddressStr = toString(i.caller)
248262     let baseAssetId = fromBase58String(baseAssetStr)
249263     let cfgArray = readAssetCfgOrFail(baseAssetStr)
250264     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
251265     let shareAssetId = fromBase58String(shareAssetStr)
252266     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
253267     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
254268     let limitsKEY = keyLimitsRemaining(internalBaseAssetStr)
255269     let limitsCfgArray = split(getStringOrFail(limitsKEY), SEP)
256270     let limitsRemainingBase = parseIntValue(limitsCfgArray[IdxLimitsRemainingBase])
257271     let limitsRemainingShare = parseIntValue(limitsCfgArray[IdxLimitsRemainingShare])
258272     let isPutBlocked = getBooleanOrFail(keyShutdownPutOperation(internalBaseAssetStr))
259273     if (isPutBlocked)
260274         then throw("put operation is blocked")
261275         else {
262-            let diffTuple = calcTotalLockedDiff("submit", operationType, internalBaseAssetStr, 0, 0, inAmount, baseAssetId, shareAssetId)
263-            let limitsRemainingBaseNew = (limitsRemainingBase - diffTuple._2[IdxTotalLockedInBase])
264-            let limitsRemainingShareNew = (limitsRemainingShare - diffTuple._2[IdxTotalLockedInShare])
265-            if (if ((0 > limitsRemainingBaseNew))
266-                then true
267-                else (0 > limitsRemainingShareNew))
268-                then failSubmitLimitsExceeds(limitsRemainingBase, limitsRemainingShare, limitsRemainingBaseNew, limitsRemainingShareNew)
276+            let operationsMutex = valueOrElse(getInteger(this, keyTopupMutext(internalBaseAssetStr)), 0)
277+            if (((operationsMutex + 60) > height))
278+                then throw("submit operations are blocked by topup manager")
269279                 else {
270-                    let topUpCurrentIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
271-                    ((([StringEntry(keyOperation(operationType, internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("PENDING", inAmount, 0, 0, height, lastBlock.timestamp, 0, 0, (topUpCurrentIdx + 1)))] :+ TotalLockedStringEntry("INCREMENT", keyTotalLocked(internalBaseAssetStr), diffTuple._1)) :+ TotalLockedStringEntry("INCREMENT", keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), diffTuple._2)) :+ RemainingLimitsStringEntry(limitsKEY, limitsRemainingBaseNew, limitsRemainingShareNew))
280+                    let diffTuple = calcTotalLockedDiff("submit", operationType, internalBaseAssetStr, 0, 0, inAmount, baseAssetId, shareAssetId)
281+                    let limitsRemainingBaseNew = (limitsRemainingBase - diffTuple._2[IdxTotalLockedInBase])
282+                    let limitsRemainingShareNew = (limitsRemainingShare - diffTuple._2[IdxTotalLockedInShare])
283+                    if (if ((0 > limitsRemainingBaseNew))
284+                        then true
285+                        else (0 > limitsRemainingShareNew))
286+                        then failSubmitLimitsExceeds(limitsRemainingBase, limitsRemainingShare, limitsRemainingBaseNew, limitsRemainingShareNew)
287+                        else {
288+                            let topUpCurrentIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
289+                            ((([StringEntry(keyOperation(operationType, internalBaseAssetStr, userAddressStr, toBase58String(i.transactionId)), dataOperation("PENDING", inAmount, 0, 0, height, lastBlock.timestamp, 0, 0, (topUpCurrentIdx + 1)))] :+ TotalLockedStringEntry("INCREMENT", keyTotalLocked(internalBaseAssetStr), diffTuple._1)) :+ TotalLockedStringEntry("INCREMENT", keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), diffTuple._2)) :+ RemainingLimitsStringEntry(limitsKEY, limitsRemainingBaseNew, limitsRemainingShareNew))
290+                            }
272291                     }
273292             }
274293     }
275294 
276295 
277296 func execute (operationType,baseAssetStr,userAddressStr,submitTxIdStr) = {
278297     let userAddress = addressFromStringValue(userAddressStr)
279298     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
280299     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
281300     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
282301     let decimalsMultPrice = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
283302     let baseAssetId = fromBase58String(baseAssetStr)
284303     let operationKey = keyOperation(operationType, internalBaseAssetStr, userAddressStr, submitTxIdStr)
285304     let operationArray = split(getStringOrFail(operationKey), SEP)
286305     let status = operationArray[IdxOperStatus]
287306     let inAmount = parseIntValue(operationArray[IdxOperInAmount])
288-    let operLock = parseIntValue(operationArray[IdxOperLock])
307+    let topupUnlockIdx = parseIntValue(operationArray[IdxOperTopupUnlockIdx])
289308     let currTopUpIdx = getIntOrFail(keyTopUpCurrentIdx(internalBaseAssetStr))
290309     let priceByTopUpId = getIntOrFail(keyPriceByTopUpIdx(internalBaseAssetStr, currTopUpIdx))
291310     if ((status != "PENDING"))
292311         then failExecuteGet("Status is not PENDING", baseAssetStr, userAddressStr, submitTxIdStr, operationType)
293-        else if ((operLock > currTopUpIdx))
294-            then failExecuteGet(((("OperLock[" + toString(operLock)) + "] > ") + toString(currTopUpIdx)), baseAssetStr, userAddressStr, submitTxIdStr, operationType)
312+        else if ((topupUnlockIdx > currTopUpIdx))
313+            then failExecuteGet(((("OperLock[" + toString(topupUnlockIdx)) + "] > ") + toString(currTopUpIdx)), baseAssetStr, userAddressStr, submitTxIdStr, operationType)
295314             else {
296315                 let diffTuple = calcTotalLockedDiff("execute", operationType, internalBaseAssetStr, priceByTopUpId, decimalsMultPrice, inAmount, baseAssetId, shareAssetId)
297316                 let outAmount = diffTuple._3
298317                 let outTransferData = if ((diffTuple._4 == baseAssetId))
299318                     then [ScriptTransfer(userAddress, outAmount, baseAssetId)]
300-                    else [Reissue(shareAssetId, outAmount, true), ScriptTransfer(userAddress, outAmount, shareAssetId)]
319+                    else [ScriptTransfer(userAddress, outAmount, shareAssetId)]
301320                 (((outTransferData :+ StringEntry(operationKey, dataOperationExecutionUpdate(operationArray, "FINISHED", priceByTopUpId, outAmount))) :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), diffTuple._1)) :+ TotalLockedStringEntry("DECREMENT", keyTotalLockedByUser(internalBaseAssetStr, userAddressStr), diffTuple._2))
302321                 }
303322     }
304323 
305324 
306325 func privateCurrentSysParamsREST (baseAssetStr) = {
307326     let baseAssetId = fromBase58String(baseAssetStr)
308327     let cfgArray = readAssetCfgOrFail(baseAssetStr)
309328     let shareAssetStr = cfgArray[IdxCfgShareAssetId]
310329     let shareAssetId = fromBase58String(shareAssetStr)
311330     let decimalsMultBothAssets = parseIntValue(cfgArray[IdxCfgDecimalsMultBothAssets])
312331     let decimalsMultPrice = parseIntValue(cfgArray[IdxCfgDecimalsMultPrice])
313332     let internalBaseAssetStr = cfgArray[IdxCfgInternalBaseAsset]
314333     let sysState = calcPrice(internalBaseAssetStr, baseAssetId, shareAssetId, decimalsMultPrice)
315-    $Tuple6(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("totalLockedBaseAmount", sysState._3), IntegerEntry("baseAssetBalanceConsideringLock", sysState._4), IntegerEntry("shareEmission", sysState._5))
334+    $Tuple6(IntegerEntry("price", sysState._1), IntegerEntry("decimalsMultPrice", decimalsMultPrice), IntegerEntry("baseAssetBalance", sysState._2), IntegerEntry("-1", sysState._3), IntegerEntry("baseAssetBalanceWCO", sysState._4), IntegerEntry("shareEmission", sysState._5))
316335     }
317336 
318337 
319338 @Callable(i)
320339 func adminRegisterAsset (baseAssetStr,shareAssetName,shareAssetDescr,getDelayinBlocks,shutdownManagerAddress,startPrice,topupIntervalInBlocks,topupMaxNegativePart,topupManagerAddress,submitLimitsBaseMax,submitLimitsBaseReset,submitLimitsShareMax,submitLimitsShareReset) = {
321340     let baseAssetId = fromBase58String(baseAssetStr)
322341     let decimals = value(assetInfo(baseAssetId)).decimals
323342     let decimalsMultBothAssets = pow(10, 0, decimals, 0, 0, DOWN)
324343     let decimalsMultPrice = ((100 * 1000) * 1000)
325344     let topupMaxNegativePercents = fraction(topupMaxNegativePart, 100, decimalsMultBothAssets)
326345     let baseAssetBalance = assetBalance(this, baseAssetId)
327346     if ((i.caller != this))
328347         then throw("permissions denied")
329348         else if ((baseAssetBalance == 0))
330349             then throw(((toString(this) + " must have any initial balance of ") + baseAssetStr))
331350             else if (isDefined(getString(this, keyAssetCfg(baseAssetStr))))
332351                 then throw((baseAssetStr + " has been already registered"))
333352                 else if ((toString(addressFromStringValue(shutdownManagerAddress)) != shutdownManagerAddress))
334353                     then throw("invalid shutdownManagerAddress")
335354                     else if ((toString(addressFromStringValue(topupManagerAddress)) != topupManagerAddress))
336355                         then throw("invalid topupManagerAddress")
337356                         else if ((0 > getDelayinBlocks))
338357                             then throw(("invalid getDelayinBlocks=" + toString(getDelayinBlocks)))
339358                             else if (if ((0 >= topupMaxNegativePercents))
340359                                 then true
341360                                 else (topupMaxNegativePercents >= 99))
342361                                 then throw("invalid topupMaxNegativePart parameter")
343362                                 else {
344363                                     let shareInitAmount = convertBase2Share(baseAssetBalance, startPrice, decimalsMultPrice)
345364                                     let shareAssetIssueAction = Issue(shareAssetName, shareAssetDescr, shareInitAmount, decimals, true)
346365                                     let shareAssetId = calculateAssetId(shareAssetIssueAction)
347366                                     let shareAssetStr = toBase58String(shareAssetId)
348367                                     let internalBaseAssetId = valueOrElse(getInteger(this, keyNextInternalAssetId()), 0)
349368                                     let internalBaseAssetStr = toString(internalBaseAssetId)
350369 [StringEntry(keyAssetCfg(baseAssetStr), dataAssetCfg(shareAssetStr, internalBaseAssetStr, decimalsMultBothAssets, decimalsMultPrice, getDelayinBlocks, topupIntervalInBlocks, topupMaxNegativePart, topupManagerAddress, submitLimitsBaseMax, submitLimitsBaseReset, submitLimitsShareMax, submitLimitsShareReset)), StringEntry(keyMappingsInternal2baseAssetId(internalBaseAssetId), baseAssetStr), StringEntry(keyMappingsBaseAsset2internalId(baseAssetStr), internalBaseAssetStr), StringEntry(keyMappingsShare2baseAssetId(shareAssetStr), baseAssetStr), StringEntry(keyMappingsBaseAsset2shareId(baseAssetStr), shareAssetStr), BooleanEntry(keyShutdownPutOperation(internalBaseAssetStr), false), StringEntry(keyShutdownManager(internalBaseAssetStr), shutdownManagerAddress), IntegerEntry(keyNextInternalAssetId(), (internalBaseAssetId + 1)), IntegerEntry(keyPriceLast(internalBaseAssetStr), startPrice), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), startPrice), IntegerEntry(keyTopUpCurrentIdx(internalBaseAssetStr), 0), RemainingLimitsStringEntry(keyLimitsRemaining(internalBaseAssetStr), submitLimitsBaseMax, submitLimitsShareMax), shareAssetIssueAction]
351370                                     }
352371     }
353372 
354373 
355374 
356375 @Callable(i)
357376 func shutdownPut (internalBaseAssetId) = {
358377     let internalBaseAssetIdStr = toString(internalBaseAssetId)
359378     let baseAssetIdStr = getStringOrFail(keyMappingsInternal2baseAssetId(internalBaseAssetId))
360379     let shutdownManagerAddress = getStringOrFail(keyShutdownManager(internalBaseAssetIdStr))
361380     if ((1 > size(baseAssetIdStr)))
362381         then throw("invalid internalBaseAssetId")
363382         else if ((toString(i.caller) != shutdownManagerAddress))
364383             then throw("access denied")
365384             else [BooleanEntry(keyShutdownPutOperation(toString(internalBaseAssetId)), true)]
366385     }
367386 
368387 
369388 
370389 @Callable(i)
371390 func submitPut () = {
372391     let pmt = value(i.payments[0])
373392     let inAmount = pmt.amount
374393     let inAssetId = value(pmt.assetId)
375394     let baseAssetStr = toBase58String(inAssetId)
376395     submit("P", i, inAmount, inAssetId, baseAssetStr)
377396     }
378397 
379398 
380399 
381400 @Callable(i)
382401 func submitGet () = {
383402     let pmt = value(i.payments[0])
384403     let inAmount = pmt.amount
385404     let inAssetId = value(pmt.assetId)
386405     let shareAssetStr = toBase58String(inAssetId)
387406     let baseAssetStr = getStringOrFail(keyMappingsShare2baseAssetId(shareAssetStr))
388407     submit("G", i, inAmount, inAssetId, baseAssetStr)
389408     }
390409 
391410 
392411 
393412 @Callable(i)
394413 func executePut (baseAssetStr,userAddressStr,submitTxIdStr) = execute("P", baseAssetStr, userAddressStr, submitTxIdStr)
395414 
396415 
397416 
398417 @Callable(i)
399418 func executeGet (baseAssetStr,userAddressStr,submitTxIdStr) = execute("G", baseAssetStr, userAddressStr, submitTxIdStr)
400419 
401420 
402421 
403422 @Callable(i)
423+func operationsMutex (baseAssetStr) = {
424+    let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
425+    let topUpManagerAddressStr = assetCfgArray[IdxCfgTopupManagerAddress]
426+    let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
427+    if ((toString(i.caller) != topUpManagerAddressStr))
428+        then failTopupManagerOnly(topUpManagerAddressStr)
429+        else [TopupMutexIntEntry(internalBaseAssetStr, height)]
430+    }
431+
432+
433+
434+@Callable(i)
404435 func topUpBalance (baseAssetStr,amount) = {
405436     let baseAssetId = fromBase58String(baseAssetStr)
406437     let assetCfgArray = readAssetCfgOrFail(baseAssetStr)
407438     let shareAssetId = fromBase58String(assetCfgArray[IdxCfgShareAssetId])
408439     let priceMult = parseIntValue(assetCfgArray[IdxCfgDecimalsMultPrice])
409440     let bothAssetMult = parseIntValue(assetCfgArray[IdxCfgDecimalsMultBothAssets])
410441     let topupIntervalInBlocks = parseIntValue(assetCfgArray[IdxCfgTopupIntervalInBlocks])
411442     let topupMaxNegativePart = parseIntValue(assetCfgArray[IdxCfgTopupMaxNegativePart])
412443     let internalBaseAssetStr = assetCfgArray[IdxCfgInternalBaseAsset]
413444     let topUpManagerAddressStr = assetCfgArray[IdxCfgTopupManagerAddress]
414445     let topUpCurrentIdxKEY = keyTopUpCurrentIdx(internalBaseAssetStr)
415446     let prevTopUpIdx = getIntOrFail(topUpCurrentIdxKEY)
416447     let currentTopUpIdx = (prevTopUpIdx + 1)
417448     let valid = if ((amount > 0))
418449         then {
419450             let pmt = value(i.payments[0])
420451             let pmtAssetId = value(pmt.assetId)
421452             if ((baseAssetId != pmtAssetId))
422453                 then throw("attached payment's asset id is NOT matched passed baseAssetStr")
423454                 else if ((size(i.payments) > 1))
424455                     then throw("only one payment can be attached")
425456                     else if ((pmt.amount != amount))
426457                         then throw("attached payment.amount is NOT matched passed amount argument")
427458                         else true
428459             }
429460         else if ((0 > amount))
430461             then {
431462                 let baseBalance = assetBalance(this, baseAssetId)
432463                 let allowedAmount = fraction(topupMaxNegativePart, baseBalance, bothAssetMult)
433464                 if ((-(amount) > allowedAmount))
434-                    then throw(("Topup negative amount couldn't be greater than " + toString(allowedAmount)))
465+                    then throw(("topup negative amount couldn't be greater than " + toString(allowedAmount)))
435466                     else true
436467                 }
437468             else throw("zero amount is not allowed")
438469     let topUpLastHeightKEY = keyTopUpLastHeight(internalBaseAssetStr, toString(i.caller))
439470     let topUpLastHeight = valueOrElse(getInteger(this, topUpLastHeightKEY), 0)
440471     if ((toString(i.caller) != topUpManagerAddressStr))
441-        then throw((("only topUpManager=" + topUpManagerAddressStr) + " can send topUp transactions"))
472+        then failTopupManagerOnly(topUpManagerAddressStr)
442473         else if (!(valid))
443474             then throw("validation failed")
444475             else if ((topupIntervalInBlocks > (height - topUpLastHeight)))
445476                 then throw((("1 topup per " + toString(topupIntervalInBlocks)) + " blocks from the same address is allowed"))
446477                 else {
447478                     let price = genericCalcPrice(internalBaseAssetStr, baseAssetId, amount, shareAssetId, priceMult)._1
448479                     let diffTuple = calcTotalLockedDiff("topup", "", internalBaseAssetStr, price, priceMult, 0, baseAssetId, shareAssetId)
449480                     let topupTotalDiff = diffTuple._1
450481                     let priceAthKEY = keyPriceATH(internalBaseAssetStr)
451482                     let prevPriceATH = valueOrElse(getInteger(this, priceAthKEY), 0)
452-                    ((([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx), IntegerEntry(priceAthKEY, if ((price > prevPriceATH))
483+                    ((((([IntegerEntry(keyPriceLast(internalBaseAssetStr), price), IntegerEntry(keyPriceHistory(internalBaseAssetStr, height, lastBlock.timestamp), price), IntegerEntry(keyPriceByTopUpIdx(internalBaseAssetStr, currentTopUpIdx), price), IntegerEntry(topUpCurrentIdxKEY, currentTopUpIdx), IntegerEntry(priceAthKEY, if ((price > prevPriceATH))
453484                         then price
454-                        else prevPriceATH), IntegerEntry(topUpLastHeightKEY, height)] :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), topupTotalDiff)) :+ Burn(shareAssetId, topupTotalDiff[IdxTotalLockedInShare])) ++ (if ((0 > amount))
485+                        else prevPriceATH), IntegerEntry(topUpLastHeightKEY, height)] :+ TotalLockedStringEntry("DECREMENT", keyTotalLocked(internalBaseAssetStr), topupTotalDiff)) :+ TopupMutexIntEntry(internalBaseAssetStr, 0)) :+ Burn(shareAssetId, topupTotalDiff[IdxTotalLockedInShare])) :+ Reissue(shareAssetId, -(topupTotalDiff[IdxTotalLockedOutShare]), true)) ++ (if ((0 > amount))
455486                         then [ScriptTransfer(i.caller, -(amount), baseAssetId)]
456487                         else nil))
457488                     }
458489     }
459490 
460491 
461492 
462493 @Callable(i)
463494 func currentSysParamsREST (baseAssetStr) = {
464495     let sysStateTuple = privateCurrentSysParamsREST(baseAssetStr)
465496     let price = sysStateTuple._1.value
466497     let decimalsMultPrice = sysStateTuple._2.value
467498     let baseAssetBalance = sysStateTuple._3.value
468499     let totalLockedBaseAmount = sysStateTuple._4.value
469-    let baseAssetBalanceConsideringLock = sysStateTuple._5.value
500+    let baseAssetBalanceWCO = sysStateTuple._5.value
470501     let shareEmission = sysStateTuple._6.value
471-    let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceConsideringLock), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
502+    let restData = makeString(["startCurrentSysParamsREST", toString(price), toString(decimalsMultPrice), toString(baseAssetBalance), toString(totalLockedBaseAmount), toString(baseAssetBalanceWCO), toString(shareEmission), "endCurrentSysParamsREST"], SEP)
472503     throw(restData)
473504     }
474505 
475506 
github/deemru/w8io/873ac7e 
132.42 ms ◑