tx · EKrJfYM3KNJPPPu5F4Lt9vZGZjbGXDcm8LzGvim2MJ69

3N7d3jPxKqSi3XVnAgg8oFsHLcrgctFWpVw:  -0.01000000 Waves

2019.10.22 00:06 [730357] smart account 3N7d3jPxKqSi3XVnAgg8oFsHLcrgctFWpVw > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EKrJfYM3KNJPPPu5F4Lt9vZGZjbGXDcm8LzGvim2MJ69",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1571692107763,
    "version": 1,
    "sender": "3N7d3jPxKqSi3XVnAgg8oFsHLcrgctFWpVw",
    "senderPublicKey": "GHnaLgezSnGCGe7LuhRy8j4JzCcySjwndqh6X9xHQNhz",
    "proofs": [
        "4EaTsBxEdKeWirJr7xd8a4WEeZ65Xq8u862GL2FR3oS6SFXfu6H5GfGWmZUPet7p6g5x1WcPT1TY6tEqTbE5zaAH"
    ],
    "script": "base64:AAIDAAAAAAAAAA8IARIECgIBARIDCgEIEgAAAAA3AQAAAA5nZXROdW1iZXJCeUtleQAAAAEAAAADa2V5BAAAAAckbWF0Y2gwCQAEGgAAAAIFAAAABHRoaXMFAAAAA2tleQMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAADSW50BAAAAAFhBQAAAAckbWF0Y2gwBQAAAAFhAAAAAAAAAAAAAQAAAA5nZXRTdHJpbmdCeUtleQAAAAEAAAADa2V5BAAAAAckbWF0Y2gwCQAEHQAAAAIFAAAABHRoaXMFAAAAA2tleQMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAGU3RyaW5nBAAAAAFhBQAAAAckbWF0Y2gwBQAAAAFhAgAAAAABAAAAGGdldFN0cmluZ0J5QWRkcmVzc0FuZEtleQAAAAIAAAAHYWRkcmVzcwAAAANrZXkEAAAAByRtYXRjaDAJAAQdAAAAAgUAAAAHYWRkcmVzcwUAAAADa2V5AwkAAAEAAAACBQAAAAckbWF0Y2gwAgAAAAZTdHJpbmcEAAAAAWEFAAAAByRtYXRjaDAFAAAAAWECAAAAAAEAAAAYZ2V0TnVtYmVyQnlBZGRyZXNzQW5kS2V5AAAAAgAAAAdhZGRyZXNzAAAAA2tleQQAAAAHJG1hdGNoMAkABBoAAAACBQAAAAdhZGRyZXNzBQAAAANrZXkDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAA0ludAQAAAABYQUAAAAHJG1hdGNoMAUAAAABYQAAAAAAAAAAAAAAAAAHV0FWRUxFVAAAAAAABfXhAAAAAAAQT1JERVJTUExJVFNZTUJPTAIAAAABXwAAAAAFUEFVTEkAAAAAAAAAAGQAAAAACENBTkNFTEVEAgAAAAhjYW5jZWxlZAAAAAADTkVXAgAAAANuZXcAAAAABkZJTExFRAIAAAAGZmlsbGVkAAAAAA9QRVJDRU5UQUNDVVJBQ1kAAAAAAAAAA+gAAAAADE9yZGVyQm9va0tleQIAAAAJb3JkZXJib29rAAAAAA1PcmRlclByaWNlS2V5AgAAAAxvcmRlcl9wcmljZV8AAAAADU9yZGVyVG90YWxLZXkCAAAADG9yZGVyX3RvdGFsXwAAAAATT3JkZXJGaWxsZWRUb3RhbEtleQIAAAATb3JkZXJfZmlsbGVkX3RvdGFsXwAAAAANT3JkZXJPd25lcktleQIAAAAMb3JkZXJfb3duZXJfAAAAAA5PcmRlckhlaWdodEtleQIAAAANb3JkZXJfaGVpZ2h0XwAAAAAOT3JkZXJTdGF0dXNLZXkCAAAADW9yZGVyX3N0YXR1c18AAAAACFByaWNlS2V5AgAAAAVwcmljZQAAAAAOQm9uZEFzc2V0SWRLZXkCAAAADWJvbmRfYXNzZXRfaWQAAAAAEk5ldXRyaW5vQXNzZXRJZEtleQIAAAARbmV1dHJpbm9fYXNzZXRfaWQAAAAAE05ldXRyaW5vQ29udHJhY3RLZXkCAAAAEW5ldXRyaW5vX2NvbnRyYWN0AAAAABJDb250cm9sQ29udHJhY3RLZXkCAAAAEGNvbnRyb2xfY29udHJhY3QAAAAAD09yZGVySGlzdG9yeUtleQIAAAAOb3JkZXJfaGlzdG9yeV8AAAAAFFN3YXBMb2NrZWRCYWxhbmNlS2V5AgAAABNzd2FwX2xvY2tlZF9iYWxhbmNlAQAAABBnZXRPcmRlclByaWNlS2V5AAAAAQAAAAdvcmRlcklkCQABLAAAAAIFAAAADU9yZGVyUHJpY2VLZXkFAAAAB29yZGVySWQBAAAAEGdldE9yZGVyVG90YWxLZXkAAAABAAAAB29yZGVySWQJAAEsAAAAAgUAAAANT3JkZXJUb3RhbEtleQUAAAAHb3JkZXJJZAEAAAAQZ2V0T3JkZXJPd25lcktleQAAAAEAAAAHb3JkZXJJZAkAASwAAAACBQAAAA1PcmRlck93bmVyS2V5BQAAAAdvcmRlcklkAQAAABFnZXRPcmRlckhlaWdodEtleQAAAAEAAAAHb3JkZXJJZAkAASwAAAACBQAAAA5PcmRlckhlaWdodEtleQUAAAAHb3JkZXJJZAEAAAARZ2V0T3JkZXJTdGF0dXNLZXkAAAABAAAAB29yZGVySWQJAAEsAAAAAgUAAAAOT3JkZXJTdGF0dXNLZXkFAAAAB29yZGVySWQBAAAAFmdldE9yZGVyRmlsbGVkVG90YWxLZXkAAAABAAAAB29yZGVySWQJAAEsAAAAAgUAAAATT3JkZXJGaWxsZWRUb3RhbEtleQUAAAAHb3JkZXJJZAEAAAASZ2V0T3JkZXJIaXN0b3J5S2V5AAAAAQAAAAZoZWlnaHQJAAEsAAAAAgUAAAAPT3JkZXJIaXN0b3J5S2V5CQABpAAAAAEFAAAABmhlaWdodAAAAAAQbmV1dHJpbm9Db250cmFjdAkBAAAAHEBleHRyVXNlcihhZGRyZXNzRnJvbVN0cmluZykAAAABCQEAAAAOZ2V0U3RyaW5nQnlLZXkAAAABBQAAABNOZXV0cmlub0NvbnRyYWN0S2V5AAAAAA9jb250cm9sQ29udHJhY3QJAQAAABxAZXh0clVzZXIoYWRkcmVzc0Zyb21TdHJpbmcpAAAAAQkBAAAAGGdldFN0cmluZ0J5QWRkcmVzc0FuZEtleQAAAAIFAAAAEG5ldXRyaW5vQ29udHJhY3QFAAAAEkNvbnRyb2xDb250cmFjdEtleQAAAAANcHJpY2VOZXV0cmlubwkBAAAAGGdldE51bWJlckJ5QWRkcmVzc0FuZEtleQAAAAIFAAAAD2NvbnRyb2xDb250cmFjdAUAAAAIUHJpY2VLZXkBAAAAFmNvbnZlcnROZXV0cmlub1RvV2F2ZXMAAAABAAAABmFtb3VudAkAAGkAAAACCQAAaAAAAAIJAABpAAAAAgkAAGgAAAACBQAAAAZhbW91bnQAAAAAAAAAAGQFAAAADXByaWNlTmV1dHJpbm8FAAAAB1dBVkVMRVQFAAAABVBBVUxJAQAAABZjb252ZXJ0V2F2ZXNUb05ldXRyaW5vAAAAAQAAAAZhbW91bnQJAABpAAAAAgkAAGgAAAACCQAAaQAAAAIJAABoAAAAAgUAAAAGYW1vdW50BQAAAA1wcmljZU5ldXRyaW5vAAAAAAAAAABkBQAAAAVQQVVMSQUAAAAHV0FWRUxFVAEAAAAVY29udmVydE5ldXRyaW5vVG9Cb25kAAAAAQAAAAZhbW91bnQJAABpAAAAAgUAAAAGYW1vdW50BQAAAAVQQVVMSQEAAAAVY29udmVydEJvbmRUb05ldXRyaW5vAAAAAQAAAAZhbW91bnQJAABoAAAAAgUAAAAGYW1vdW50BQAAAAVQQVVMSQEAAAASY29udmVydFdhdmVzVG9Cb25kAAAAAQAAAAZhbW91bnQJAQAAABVjb252ZXJ0TmV1dHJpbm9Ub0JvbmQAAAABCQEAAAAWY29udmVydFdhdmVzVG9OZXV0cmlubwAAAAEFAAAABmFtb3VudAAAAAARc3dhcExvY2tlZEJhbGFuY2UJAQAAABhnZXROdW1iZXJCeUFkZHJlc3NBbmRLZXkAAAACBQAAABBuZXV0cmlub0NvbnRyYWN0BQAAABRTd2FwTG9ja2VkQmFsYW5jZUtleQAAAAAPbmV1dHJpbm9Bc3NldElkCQACWQAAAAEJAQAAABhnZXRTdHJpbmdCeUFkZHJlc3NBbmRLZXkAAAACBQAAABBuZXV0cmlub0NvbnRyYWN0BQAAABJOZXV0cmlub0Fzc2V0SWRLZXkAAAAAC2JvbmRBc3NldElkCQACWQAAAAEJAQAAABhnZXRTdHJpbmdCeUFkZHJlc3NBbmRLZXkAAAACBQAAABBuZXV0cmlub0NvbnRyYWN0BQAAAA5Cb25kQXNzZXRJZEtleQAAAAAJb3JkZXJib29rCQEAAAAOZ2V0U3RyaW5nQnlLZXkAAAABBQAAAAxPcmRlckJvb2tLZXkAAAAAB3Jlc2VydmUJAABlAAAAAgkBAAAADHdhdmVzQmFsYW5jZQAAAAEFAAAABHRoaXMFAAAAEXN3YXBMb2NrZWRCYWxhbmNlAAAAAA5uZXV0cmlub1N1cHBseQQAAAAEaW5mbwkBAAAAB2V4dHJhY3QAAAABCQAD7AAAAAEFAAAAD25ldXRyaW5vQXNzZXRJZAkAAGUAAAACCAUAAAAEaW5mbwAAAAhxdWFudGl0eQkAA+sAAAACBQAAABBuZXV0cmlub0NvbnRyYWN0BQAAAA9uZXV0cmlub0Fzc2V0SWQAAAAAB2RlZmljaXQJAABlAAAAAgUAAAAObmV1dHJpbm9TdXBwbHkJAQAAABZjb252ZXJ0V2F2ZXNUb05ldXRyaW5vAAAAAQUAAAAHcmVzZXJ2ZQEAAAANZ2V0T3JkZXJQcmljZQAAAAEAAAACaWQJAQAAAA5nZXROdW1iZXJCeUtleQAAAAEJAQAAABBnZXRPcmRlclByaWNlS2V5AAAAAQUAAAACaWQBAAAADWdldE9yZGVyVG90YWwAAAABAAAAAmlkCQEAAAAOZ2V0TnVtYmVyQnlLZXkAAAABCQEAAAAQZ2V0T3JkZXJUb3RhbEtleQAAAAEFAAAAAmlkAQAAAA1nZXRPcmRlck93bmVyAAAAAQAAAAJpZAkBAAAADmdldFN0cmluZ0J5S2V5AAAAAQkBAAAAEGdldE9yZGVyT3duZXJLZXkAAAABBQAAAAJpZAEAAAAOZ2V0T3JkZXJTdGF0dXMAAAABAAAAAmlkCQEAAAAOZ2V0U3RyaW5nQnlLZXkAAAABCQEAAAARZ2V0T3JkZXJTdGF0dXNLZXkAAAABBQAAAAJpZAEAAAATZ2V0T3JkZXJGaWxsZWRUb3RhbAAAAAEAAAACaWQJAQAAAA5nZXROdW1iZXJCeUtleQAAAAEJAQAAABZnZXRPcmRlckZpbGxlZFRvdGFsS2V5AAAAAQUAAAACaWQBAAAAE2dldE9yZGVyRWxlbWVudEJ5SWQAAAABAAAAAmlkCQABLAAAAAIFAAAAAmlkBQAAABBPUkRFUlNQTElUU1lNQk9MAQAAAAhhZGRPcmRlcgAAAAIAAAAHb3JkZXJJZAAAAAhwb3NpdGlvbgQAAAAGb3JkZXJzCQAEtQAAAAIFAAAACW9yZGVyYm9vawUAAAAQT1JERVJTUExJVFNZTUJPTAQAAAAIbmV3T3JkZXIJAQAAABNnZXRPcmRlckVsZW1lbnRCeUlkAAAAAQUAAAAHb3JkZXJJZAMJAAAAAAAAAgUAAAAIcG9zaXRpb24AAAAAAAAAAAAJAAEsAAAAAgUAAAAIbmV3T3JkZXIFAAAACW9yZGVyYm9vawMJAABnAAAAAgUAAAAIcG9zaXRpb24JAABlAAAAAgkAAZAAAAABBQAAAAZvcmRlcnMAAAAAAAAAAAEJAAEsAAAAAgUAAAAJb3JkZXJib29rBQAAAAhuZXdPcmRlcgQAAAAFcGFydHMJAAS1AAAAAgUAAAAJb3JkZXJib29rCQEAAAATZ2V0T3JkZXJFbGVtZW50QnlJZAAAAAEJAAGRAAAAAgUAAAAGb3JkZXJzBQAAAAhwb3NpdGlvbgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgkAAZEAAAACBQAAAAVwYXJ0cwAAAAAAAAAAAAUAAAAIbmV3T3JkZXIJAQAAABNnZXRPcmRlckVsZW1lbnRCeUlkAAAAAQkAAZEAAAACBQAAAAZvcmRlcnMFAAAACHBvc2l0aW9uCQABkQAAAAIFAAAABXBhcnRzAAAAAAAAAAABAQAAAAlkcm9wT3JkZXIAAAABAAAAB29yZGVySWQEAAAABXBhcnRzCQAEtQAAAAIFAAAACW9yZGVyYm9vawkBAAAAE2dldE9yZGVyRWxlbWVudEJ5SWQAAAABBQAAAAdvcmRlcklkCQABLAAAAAIJAAGRAAAAAgUAAAAFcGFydHMAAAAAAAAAAAAJAAGRAAAAAgUAAAAFcGFydHMAAAAAAAAAAAEAAAADAAAAAWkBAAAACHNldE9yZGVyAAAAAgAAAAVwcmljZQAAAAhwb3NpdGlvbgQAAAADcG10CQEAAAAHZXh0cmFjdAAAAAEIBQAAAAFpAAAAB3BheW1lbnQEAAAACm5ld09yZGVySWQJAAJYAAAAAQkAAfUAAAABCQAAywAAAAIJAADLAAAAAgkAAMsAAAACCQABmgAAAAEFAAAABXByaWNlCQABmgAAAAEIBQAAAANwbXQAAAAGYW1vdW50CAgFAAAAAWkAAAAGY2FsbGVyAAAABWJ5dGVzCQABmgAAAAEFAAAABmhlaWdodAMJAQAAAAIhPQAAAAIIBQAAAANwbXQAAAAHYXNzZXRJZAUAAAAPbmV1dHJpbm9Bc3NldElkCQAAAgAAAAECAAAAFWNhbiB1c2UgbmV1dHJpbm8gb25seQMJAABnAAAAAgAAAAAAAAAAAAUAAAAFcHJpY2UJAAACAAAAAQIAAAAPcHJpY2UgbGVzcyB6ZXJvAwkBAAAAAiE9AAAAAgkBAAAADWdldE9yZGVyT3duZXIAAAABBQAAAApuZXdPcmRlcklkAgAAAAAJAAACAAAAAQIAAAAMb3JkZXIgZXhpc3RzBAAAAAZvcmRlcnMJAAS1AAAAAgUAAAAJb3JkZXJib29rBQAAABBPUkRFUlNQTElUU1lNQk9MBAAAAAtuZXh0T3JkZXJJZAMJAAAAAAAAAgUAAAAIcG9zaXRpb24AAAAAAAAAAAACAAAAAAkAAZEAAAACBQAAAAZvcmRlcnMJAABlAAAAAgUAAAAIcG9zaXRpb24AAAAAAAAAAAEEAAAADm5leHRPcmRlclByaWNlCQEAAAANZ2V0T3JkZXJQcmljZQAAAAEFAAAAC25leHRPcmRlcklkBAAAABBpc05leHRPcmRlckVycm9yAwMJAQAAAAIhPQAAAAIFAAAAC25leHRPcmRlcklkAgAAAAAJAABmAAAAAgUAAAAFcHJpY2UFAAAADm5leHRPcmRlclByaWNlBwYHBAAAAAtwcmV2T3JkZXJJZAkAAZEAAAACBQAAAAZvcmRlcnMFAAAACHBvc2l0aW9uBAAAAA5wcmV2T3JkZXJQcmljZQkBAAAADWdldE9yZGVyUHJpY2UAAAABBQAAAAtwcmV2T3JkZXJJZAQAAAAQaXNQcmV2T3JkZXJFcnJvcgMJAABnAAAAAgUAAAAOcHJldk9yZGVyUHJpY2UFAAAABXByaWNlBgcDAwUAAAAQaXNOZXh0T3JkZXJFcnJvcgYFAAAAEGlzUHJldk9yZGVyRXJyb3IJAAACAAAAAQkAASwAAAACCQABLAAAAAIJAAEsAAAAAgIAAAAfaW52YWxpZCBvcmRlciBpc1ByZXZPcmRlckVycm9yOgkAAaUAAAABBQAAABBpc1ByZXZPcmRlckVycm9yAgAAABIgaXNOZXh0T3JkZXJFcnJvcjoJAAGlAAAAAQUAAAAQaXNOZXh0T3JkZXJFcnJvcgkBAAAACFdyaXRlU2V0AAAAAQkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgUAAAAMT3JkZXJCb29rS2V5CQEAAAAIYWRkT3JkZXIAAAACBQAAAApuZXdPcmRlcklkBQAAAAhwb3NpdGlvbgkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgkBAAAAEGdldE9yZGVyUHJpY2VLZXkAAAABBQAAAApuZXdPcmRlcklkBQAAAAVwcmljZQkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgkBAAAAEGdldE9yZGVyVG90YWxLZXkAAAABBQAAAApuZXdPcmRlcklkCAUAAAADcG10AAAABmFtb3VudAkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgkBAAAAEGdldE9yZGVyT3duZXJLZXkAAAABBQAAAApuZXdPcmRlcklkCQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgkBAAAAEWdldE9yZGVySGVpZ2h0S2V5AAAAAQUAAAAKbmV3T3JkZXJJZAUAAAAGaGVpZ2h0CQAETAAAAAIJAQAAAAlEYXRhRW50cnkAAAACCQEAAAARZ2V0T3JkZXJTdGF0dXNLZXkAAAABBQAAAApuZXdPcmRlcklkBQAAAANORVcFAAAAA25pbAAAAAFpAQAAAAtjYW5jZWxPcmRlcgAAAAEAAAAHb3JkZXJJZAQAAAAFb3duZXIJAQAAAA1nZXRPcmRlck93bmVyAAAAAQUAAAAHb3JkZXJJZAQAAAAGYW1vdW50CQAAZQAAAAIJAQAAAA1nZXRPcmRlclRvdGFsAAAAAQUAAAAHb3JkZXJJZAkBAAAAE2dldE9yZGVyRmlsbGVkVG90YWwAAAABBQAAAAdvcmRlcklkAwkBAAAAAiE9AAAAAgUAAAAFb3duZXIJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyCQAAAgAAAAECAAAAEXBlcm1pc3Npb24gZGVuaWVkAwkBAAAAAiE9AAAAAgkBAAAADmdldE9yZGVyU3RhdHVzAAAAAQUAAAAHb3JkZXJJZAUAAAADTkVXCQAAAgAAAAECAAAAFGludmFsaWQgb3JkZXIgc3RhdHVzCQEAAAAMU2NyaXB0UmVzdWx0AAAAAgkBAAAACFdyaXRlU2V0AAAAAQkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgUAAAAMT3JkZXJCb29rS2V5CQEAAAAJZHJvcE9yZGVyAAAAAQUAAAAHb3JkZXJJZAkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgkBAAAAEWdldE9yZGVyU3RhdHVzS2V5AAAAAQUAAAAHb3JkZXJJZAUAAAAIQ0FOQ0VMRUQFAAAAA25pbAkBAAAAC1RyYW5zZmVyU2V0AAAAAQkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADCAUAAAABaQAAAAZjYWxsZXIFAAAABmFtb3VudAUAAAAPbmV1dHJpbm9Bc3NldElkBQAAAANuaWwAAAABaQEAAAAMZXhlY3V0ZU9yZGVyAAAAAAQAAAALYm9uZEJhbGFuY2UJAAPrAAAAAgUAAAAEdGhpcwUAAAALYm9uZEFzc2V0SWQEAAAAD2RlZmljaXRQb3NpdGl2ZQMJAABnAAAAAgAAAAAAAAAAAAUAAAAHZGVmaWNpdAAAAAAAAAAAAAUAAAAHZGVmaWNpdAQAAAAKYm9uZEFtb3VudAMJAABnAAAAAgUAAAAPZGVmaWNpdFBvc2l0aXZlBQAAAAtib25kQmFsYW5jZQUAAAALYm9uZEJhbGFuY2UFAAAAD2RlZmljaXRQb3NpdGl2ZQQAAAAMcmV0dXJuQW1vdW50AwkAAGcAAAACBQAAAA9kZWZpY2l0UG9zaXRpdmUFAAAAC2JvbmRCYWxhbmNlAAAAAAAAAAAACQAAZQAAAAIFAAAAC2JvbmRCYWxhbmNlBQAAAA9kZWZpY2l0UG9zaXRpdmUDAwkAAAAAAAACBQAAAAxyZXR1cm5BbW91bnQAAAAAAAAAAAAJAAAAAAAAAgUAAAAKYm9uZEFtb3VudAAAAAAAAAAAAAcJAAACAAAAAQIAAAAPd2l0aG91dCBkZWZpY2l0AwkAAAAAAAACBQAAAApib25kQW1vdW50AAAAAAAAAAAACQEAAAALVHJhbnNmZXJTZXQAAAABCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMFAAAAEG5ldXRyaW5vQ29udHJhY3QFAAAADHJldHVybkFtb3VudAUAAAALYm9uZEFzc2V0SWQFAAAAA25pbAQAAAAHb3JkZXJJZAkAAZEAAAACCQAEtQAAAAIFAAAACW9yZGVyYm9vawUAAAAQT1JERVJTUExJVFNZTUJPTAAAAAAAAAAAAAQAAAALZmlsbGVkVG90YWwJAQAAABNnZXRPcmRlckZpbGxlZFRvdGFsAAAAAQUAAAAHb3JkZXJJZAQAAAAKb3JkZXJUb3RhbAkBAAAADWdldE9yZGVyVG90YWwAAAABBQAAAAdvcmRlcklkBAAAAApvcmRlclByaWNlCQEAAAANZ2V0T3JkZXJQcmljZQAAAAEFAAAAB29yZGVySWQEAAAACm9yZGVyT3duZXIJAQAAAA1nZXRPcmRlck93bmVyAAAAAQUAAAAHb3JkZXJJZAQAAAAGYW1vdW50CQEAAAAVY29udmVydE5ldXRyaW5vVG9Cb25kAAAAAQkAAGkAAAACCQAAaAAAAAIJAABlAAAAAgUAAAAKb3JkZXJUb3RhbAUAAAALZmlsbGVkVG90YWwAAAAAAAAAAGQFAAAACm9yZGVyUHJpY2UEAAAADG5ld09yZGVyYm9vawMJAABnAAAAAgUAAAAKYm9uZEFtb3VudAUAAAAGYW1vdW50CQEAAAAJZHJvcE9yZGVyAAAAAQUAAAAHb3JkZXJJZAUAAAAJb3JkZXJib29rBAAAAAxmaWxsZWRBbW91bnQDCQAAZwAAAAIFAAAACmJvbmRBbW91bnQFAAAABmFtb3VudAUAAAAGYW1vdW50BQAAAApib25kQW1vdW50BAAAAAV0b3RhbAkAAGkAAAACCQAAaAAAAAIJAABoAAAAAgUAAAAMZmlsbGVkQW1vdW50BQAAAApvcmRlclByaWNlBQAAAAVQQVVMSQAAAAAAAAAAZAQAAAAGc3RhdHVzAwkAAGcAAAACBQAAAApib25kQW1vdW50BQAAAAZhbW91bnQFAAAABkZJTExFRAUAAAADTkVXAwkAAAAAAAACBQAAAAV0b3RhbAAAAAAAAAAAAAkAAAIAAAABAgAAABB0b3RhbCBlcXVhbCB6ZXJvCQEAAAAMU2NyaXB0UmVzdWx0AAAAAgkBAAAACFdyaXRlU2V0AAAAAQkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgUAAAAMT3JkZXJCb29rS2V5BQAAAAxuZXdPcmRlcmJvb2sJAARMAAAAAgkBAAAACURhdGFFbnRyeQAAAAIJAQAAABZnZXRPcmRlckZpbGxlZFRvdGFsS2V5AAAAAQUAAAAHb3JkZXJJZAkAAGQAAAACBQAAAAtmaWxsZWRUb3RhbAUAAAAFdG90YWwJAARMAAAAAgkBAAAACURhdGFFbnRyeQAAAAIJAQAAABFnZXRPcmRlclN0YXR1c0tleQAAAAEFAAAAB29yZGVySWQFAAAABnN0YXR1cwkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgkBAAAAEmdldE9yZGVySGlzdG9yeUtleQAAAAEFAAAABmhlaWdodAUAAAAKb3JkZXJQcmljZQUAAAADbmlsCQEAAAALVHJhbnNmZXJTZXQAAAABCQAETAAAAAIJAQAAAA5TY3JpcHRUcmFuc2ZlcgAAAAMJAQAAABxAZXh0clVzZXIoYWRkcmVzc0Zyb21TdHJpbmcpAAAAAQUAAAAKb3JkZXJPd25lcgUAAAAMZmlsbGVkQW1vdW50BQAAAAtib25kQXNzZXRJZAkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADBQAAABBuZXV0cmlub0NvbnRyYWN0BQAAAAV0b3RhbAUAAAAPbmV1dHJpbm9Bc3NldElkBQAAAANuaWwAAAAAjAaP+Q==",
    "chainId": 84,
    "height": 730357,
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 4gUdK8m5AW1i7V99LMhDzajkGG64k8UExbA9waGYMBBK

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 3 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+func getNumberByKey (key) = match getInteger(this, key) {
5+    case a: Int => 
6+        a
7+    case _ => 
8+        0
9+}
10+
11+
12+func getStringByKey (key) = match getString(this, key) {
13+    case a: String => 
14+        a
15+    case _ => 
16+        ""
17+}
18+
19+
20+func getStringByAddressAndKey (address,key) = match getString(address, key) {
21+    case a: String => 
22+        a
23+    case _ => 
24+        ""
25+}
26+
27+
28+func getNumberByAddressAndKey (address,key) = match getInteger(address, key) {
29+    case a: Int => 
30+        a
31+    case _ => 
32+        0
33+}
34+
35+
36+let WAVELET = 100000000
37+
38+let ORDERSPLITSYMBOL = "_"
39+
40+let PAULI = 100
41+
42+let CANCELED = "canceled"
43+
44+let NEW = "new"
45+
46+let FILLED = "filled"
47+
48+let PERCENTACCURACY = 1000
49+
50+let OrderBookKey = "orderbook"
51+
52+let OrderPriceKey = "order_price_"
53+
54+let OrderTotalKey = "order_total_"
55+
56+let OrderFilledTotalKey = "order_filled_total_"
57+
58+let OrderOwnerKey = "order_owner_"
59+
60+let OrderHeightKey = "order_height_"
61+
62+let OrderStatusKey = "order_status_"
63+
64+let PriceKey = "price"
65+
66+let BondAssetIdKey = "bond_asset_id"
67+
68+let NeutrinoAssetIdKey = "neutrino_asset_id"
69+
70+let NeutrinoContractKey = "neutrino_contract"
71+
72+let ControlContractKey = "control_contract"
73+
74+let OrderHistoryKey = "order_history_"
75+
76+let SwapLockedBalanceKey = "swap_locked_balance"
77+
78+func getOrderPriceKey (orderId) = (OrderPriceKey + orderId)
79+
80+
81+func getOrderTotalKey (orderId) = (OrderTotalKey + orderId)
82+
83+
84+func getOrderOwnerKey (orderId) = (OrderOwnerKey + orderId)
85+
86+
87+func getOrderHeightKey (orderId) = (OrderHeightKey + orderId)
88+
89+
90+func getOrderStatusKey (orderId) = (OrderStatusKey + orderId)
91+
92+
93+func getOrderFilledTotalKey (orderId) = (OrderFilledTotalKey + orderId)
94+
95+
96+func getOrderHistoryKey (height) = (OrderHistoryKey + toString(height))
97+
98+
99+let neutrinoContract = addressFromStringValue(getStringByKey(NeutrinoContractKey))
100+
101+let controlContract = addressFromStringValue(getStringByAddressAndKey(neutrinoContract, ControlContractKey))
102+
103+let priceNeutrino = getNumberByAddressAndKey(controlContract, PriceKey)
104+
105+func convertNeutrinoToWaves (amount) = ((((amount * 100) / priceNeutrino) * WAVELET) / PAULI)
106+
107+
108+func convertWavesToNeutrino (amount) = ((((amount * priceNeutrino) / 100) * PAULI) / WAVELET)
109+
110+
111+func convertNeutrinoToBond (amount) = (amount / PAULI)
112+
113+
114+func convertBondToNeutrino (amount) = (amount * PAULI)
115+
116+
117+func convertWavesToBond (amount) = convertNeutrinoToBond(convertWavesToNeutrino(amount))
118+
119+
120+let swapLockedBalance = getNumberByAddressAndKey(neutrinoContract, SwapLockedBalanceKey)
121+
122+let neutrinoAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, NeutrinoAssetIdKey))
123+
124+let bondAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, BondAssetIdKey))
125+
126+let orderbook = getStringByKey(OrderBookKey)
127+
128+let reserve = (wavesBalance(this) - swapLockedBalance)
129+
130+let neutrinoSupply = {
131+    let info = extract(assetInfo(neutrinoAssetId))
132+    (info.quantity - assetBalance(neutrinoContract, neutrinoAssetId))
133+    }
134+
135+let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve))
136+
137+func getOrderPrice (id) = getNumberByKey(getOrderPriceKey(id))
138+
139+
140+func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
141+
142+
143+func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
144+
145+
146+func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
147+
148+
149+func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
150+
151+
152+func getOrderElementById (id) = (id + ORDERSPLITSYMBOL)
153+
154+
155+func addOrder (orderId,position) = {
156+    let orders = split(orderbook, ORDERSPLITSYMBOL)
157+    let newOrder = getOrderElementById(orderId)
158+    if ((position == 0))
159+        then (newOrder + orderbook)
160+        else if ((position >= (size(orders) - 1)))
161+            then (orderbook + newOrder)
162+            else {
163+                let parts = split(orderbook, getOrderElementById(orders[position]))
164+                (((parts[0] + newOrder) + getOrderElementById(orders[position])) + parts[1])
165+                }
166+    }
167+
168+
169+func dropOrder (orderId) = {
170+    let parts = split(orderbook, getOrderElementById(orderId))
171+    (parts[0] + parts[1])
172+    }
173+
174+
175+@Callable(i)
176+func setOrder (price,position) = {
177+    let pmt = extract(i.payment)
178+    let newOrderId = toBase58String(keccak256((((toBytes(price) + toBytes(pmt.amount)) + i.caller.bytes) + toBytes(height))))
179+    if ((pmt.assetId != neutrinoAssetId))
180+        then throw("can use neutrino only")
181+        else if ((0 >= price))
182+            then throw("price less zero")
183+            else if ((getOrderOwner(newOrderId) != ""))
184+                then throw("order exists")
185+                else {
186+                    let orders = split(orderbook, ORDERSPLITSYMBOL)
187+                    let nextOrderId = if ((position == 0))
188+                        then ""
189+                        else orders[(position - 1)]
190+                    let nextOrderPrice = getOrderPrice(nextOrderId)
191+                    let isNextOrderError = if (if ((nextOrderId != ""))
192+                        then (price > nextOrderPrice)
193+                        else false)
194+                        then true
195+                        else false
196+                    let prevOrderId = orders[position]
197+                    let prevOrderPrice = getOrderPrice(prevOrderId)
198+                    let isPrevOrderError = if ((prevOrderPrice >= price))
199+                        then true
200+                        else false
201+                    if (if (isNextOrderError)
202+                        then true
203+                        else isPrevOrderError)
204+                        then throw(((("invalid order isPrevOrderError:" + toString(isPrevOrderError)) + " isNextOrderError:") + toString(isNextOrderError)))
205+                        else WriteSet([DataEntry(OrderBookKey, addOrder(newOrderId, position)), DataEntry(getOrderPriceKey(newOrderId), price), DataEntry(getOrderTotalKey(newOrderId), pmt.amount), DataEntry(getOrderOwnerKey(newOrderId), toString(i.caller)), DataEntry(getOrderHeightKey(newOrderId), height), DataEntry(getOrderStatusKey(newOrderId), NEW)])
206+                    }
207+    }
208+
209+
210+
211+@Callable(i)
212+func cancelOrder (orderId) = {
213+    let owner = getOrderOwner(orderId)
214+    let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
215+    if ((owner != toString(i.caller)))
216+        then throw("permission denied")
217+        else if ((getOrderStatus(orderId) != NEW))
218+            then throw("invalid order status")
219+            else ScriptResult(WriteSet([DataEntry(OrderBookKey, dropOrder(orderId)), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, neutrinoAssetId)]))
220+    }
221+
222+
223+
224+@Callable(i)
225+func executeOrder () = {
226+    let bondBalance = assetBalance(this, bondAssetId)
227+    let deficitPositive = if ((0 >= deficit))
228+        then 0
229+        else deficit
230+    let bondAmount = if ((deficitPositive >= bondBalance))
231+        then bondBalance
232+        else deficitPositive
233+    let returnAmount = if ((deficitPositive >= bondBalance))
234+        then 0
235+        else (bondBalance - deficitPositive)
236+    if (if ((returnAmount == 0))
237+        then (bondAmount == 0)
238+        else false)
239+        then throw("without deficit")
240+        else if ((bondAmount == 0))
241+            then TransferSet([ScriptTransfer(neutrinoContract, returnAmount, bondAssetId)])
242+            else {
243+                let orderId = split(orderbook, ORDERSPLITSYMBOL)[0]
244+                let filledTotal = getOrderFilledTotal(orderId)
245+                let orderTotal = getOrderTotal(orderId)
246+                let orderPrice = getOrderPrice(orderId)
247+                let orderOwner = getOrderOwner(orderId)
248+                let amount = convertNeutrinoToBond((((orderTotal - filledTotal) * 100) / orderPrice))
249+                let newOrderbook = if ((bondAmount >= amount))
250+                    then dropOrder(orderId)
251+                    else orderbook
252+                let filledAmount = if ((bondAmount >= amount))
253+                    then amount
254+                    else bondAmount
255+                let total = (((filledAmount * orderPrice) * PAULI) / 100)
256+                let status = if ((bondAmount >= amount))
257+                    then FILLED
258+                    else NEW
259+                if ((total == 0))
260+                    then throw("total equal zero")
261+                    else ScriptResult(WriteSet([DataEntry(OrderBookKey, newOrderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + total)), DataEntry(getOrderStatusKey(orderId), status), DataEntry(getOrderHistoryKey(height), orderPrice)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), filledAmount, bondAssetId), ScriptTransfer(neutrinoContract, total, neutrinoAssetId)]))
262+                }
263+    }
264+
265+
github/deemru/w8io/3ef1775 
34.29 ms ◑