tx · 2zzWDBPLCPeCPxDvoVs6WKeTdBjYza2YFDixgFQNrzHV

3NASpBKQc8WXK6SAyvfbtuE2kwiJkY21tAS:  -0.01400000 Waves

2019.10.03 12:23 [703362] smart account 3NASpBKQc8WXK6SAyvfbtuE2kwiJkY21tAS > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2zzWDBPLCPeCPxDvoVs6WKeTdBjYza2YFDixgFQNrzHV",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1570094669845,
    "version": 1,
    "sender": "3NASpBKQc8WXK6SAyvfbtuE2kwiJkY21tAS",
    "senderPublicKey": "G5sPQotxGaroKXnhfRbWXoGgBponD7RQFH4bg1PS9mJE",
    "proofs": [
        "3c8uZqAXUEzC7HPiwHPmJ7dbcHv5jTwME3GJGzdQRnaxwbDew9FtX21AxF4t2ko5aNQznVyBkyGxSaAXUTNdd6X4"
    ],
    "script": "base64:AAIDAAAAAAAAAAAAAAAjAQAAAA5nZXROdW1iZXJCeUtleQAAAAEAAAADa2V5BAAAAAckbWF0Y2gwCQAEGgAAAAIFAAAABHRoaXMFAAAAA2tleQMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAADSW50BAAAAAFhBQAAAAckbWF0Y2gwBQAAAAFhAAAAAAAAAAAAAQAAAA5nZXRTdHJpbmdCeUtleQAAAAEAAAADa2V5BAAAAAckbWF0Y2gwCQAEHQAAAAIFAAAABHRoaXMFAAAAA2tleQMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAGU3RyaW5nBAAAAAFhBQAAAAckbWF0Y2gwBQAAAAFhAgAAAAABAAAADGdldEJvb2xCeUtleQAAAAEAAAADa2V5BAAAAAckbWF0Y2gwCQAEGwAAAAIFAAAABHRoaXMFAAAAA2tleQMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAHQm9vbGVhbgQAAAABYQUAAAAHJG1hdGNoMAUAAAABYQcBAAAAGGdldE51bWJlckJ5QWRkcmVzc0FuZEtleQAAAAIAAAAHYWRkcmVzcwAAAANrZXkEAAAAByRtYXRjaDAJAAQaAAAAAgkBAAAAHEBleHRyVXNlcihhZGRyZXNzRnJvbVN0cmluZykAAAABBQAAAAdhZGRyZXNzBQAAAANrZXkDCQAAAQAAAAIFAAAAByRtYXRjaDACAAAAA0ludAQAAAABYQUAAAAHJG1hdGNoMAUAAAABYQAAAAAAAAAAAAEAAAAYZ2V0U3RyaW5nQnlBZGRyZXNzQW5kS2V5AAAAAgAAAAdhZGRyZXNzAAAAA2tleQQAAAAHJG1hdGNoMAkABB0AAAACCQEAAAAcQGV4dHJVc2VyKGFkZHJlc3NGcm9tU3RyaW5nKQAAAAEFAAAAB2FkZHJlc3MFAAAAA2tleQMJAAABAAAAAgUAAAAHJG1hdGNoMAIAAAAGU3RyaW5nBAAAAAFhBQAAAAckbWF0Y2gwBQAAAAFhAgAAAAAAAAAAD0xJU1RTUExJVFNZTUJPTAIAAAABXwAAAAAPUEVSQ0VOVEFDQ1VSQUNZAAAAAAAAACcQAAAAABJOZXV0cmlub0Fzc2V0SWRLZXkCAAAAEW5ldXRyaW5vX2Fzc2V0X2lkAAAAAA5Cb25kQXNzZXRJZEtleQIAAAANYm9uZF9hc3NldF9pZAAAAAATTmV1dHJpbm9Db250cmFjdEtleQIAAAARbmV1dHJpbm9fY29udHJhY3QAAAAACkJhbGFuY2VLZXkCAAAAC3JwZF9iYWxhbmNlAAAAAAxTeW5jSW5kZXhLZXkCAAAADnJwZF9zeW5jX2luZGV4AAAAAAlQcm9maXRLZXkCAAAACnJwZF9wcm9maXQAAAAAEUJhbGFuY2VIaXN0b3J5S2V5AgAAAA9iYWxhbmNlX2hpc3RvcnkAAAAADElzQ2xhaW1lZEtleQIAAAAKaXNfY2xhaW1lZAEAAAAYZ2V0VXNlckJhbGFuY2VIaXN0b3J5S2V5AAAAAQAAAAVvd25lcgkAASwAAAACCQABLAAAAAIFAAAAEUJhbGFuY2VIaXN0b3J5S2V5AgAAAAFfBQAAAAVvd25lcgEAAAARZ2V0VXNlckJhbGFuY2VLZXkAAAACAAAABW93bmVyAAAAB2Fzc2V0SWQJAAEsAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgUAAAAKQmFsYW5jZUtleQIAAAABXwUAAAAHYXNzZXRJZAIAAAABXwUAAAAFb3duZXIBAAAAGGdldFVzZXJCYWxhbmNlS2V5QnlDb3VudAAAAAMAAAAFb3duZXIAAAAFY291bnQAAAAHYXNzZXRJZAkAASwAAAACCQABLAAAAAIJAQAAABFnZXRVc2VyQmFsYW5jZUtleQAAAAIFAAAABW93bmVyBQAAAAdhc3NldElkAgAAAAFfCQABpAAAAAEFAAAABWNvdW50AQAAAA9nZXRJc0NsYWltZWRLZXkAAAACAAAABW93bmVyAAAABWNvdW50CQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIFAAAADElzQ2xhaW1lZEtleQIAAAABXwUAAAAFb3duZXICAAAAAV8JAAGkAAAAAQUAAAAFY291bnQBAAAAFWdldENvbnRyYWN0QmFsYW5jZUtleQAAAAEAAAAHYXNzZXRJZAkAASwAAAACCQABLAAAAAIFAAAACkJhbGFuY2VLZXkCAAAAAV8FAAAAB2Fzc2V0SWQBAAAAHWdldFNuYXBzaG90Q29udHJhY3RCYWxhbmNlS2V5AAAAAgAAAAVjb3VudAAAAAdhc3NldElkCQABLAAAAAIJAAEsAAAAAgkAASwAAAACCQABLAAAAAIFAAAACkJhbGFuY2VLZXkCAAAAAV8FAAAAB2Fzc2V0SWQCAAAAAV8JAAGkAAAAAQUAAAAFY291bnQBAAAADGdldFByb2ZpdEtleQAAAAEAAAAFY291bnQJAAEsAAAAAgkAASwAAAACBQAAAAlQcm9maXRLZXkCAAAAAV8JAAGkAAAAAQUAAAAFY291bnQAAAAAEG5ldXRyaW5vQ29udHJhY3QJAQAAAA5nZXRTdHJpbmdCeUtleQAAAAEFAAAAE05ldXRyaW5vQ29udHJhY3RLZXkAAAAAD25ldXRyaW5vQXNzZXRJZAkAAlkAAAABCQEAAAAYZ2V0U3RyaW5nQnlBZGRyZXNzQW5kS2V5AAAAAgUAAAAQbmV1dHJpbm9Db250cmFjdAUAAAASTmV1dHJpbm9Bc3NldElkS2V5AAAAAAtib25kQXNzZXRJZAkAAlkAAAABCQEAAAAYZ2V0U3RyaW5nQnlBZGRyZXNzQW5kS2V5AAAAAgUAAAAQbmV1dHJpbm9Db250cmFjdAUAAAAOQm9uZEFzc2V0SWRLZXkAAAAACXN5bmNJbmRleAkBAAAAGGdldE51bWJlckJ5QWRkcmVzc0FuZEtleQAAAAIFAAAAEG5ldXRyaW5vQ29udHJhY3QFAAAADFN5bmNJbmRleEtleQEAAAASZ2V0Q29udHJhY3RCYWxhbmNlAAAAAQAAAAdhc3NldElkCQEAAAAOZ2V0TnVtYmVyQnlLZXkAAAABCQEAAAAVZ2V0Q29udHJhY3RCYWxhbmNlS2V5AAAAAQUAAAAHYXNzZXRJZAEAAAAaZ2V0U25hcHNob3RDb250cmFjdEJhbGFuY2UAAAACAAAABWNvdW50AAAAB2Fzc2V0SWQJAQAAABhnZXROdW1iZXJCeUFkZHJlc3NBbmRLZXkAAAACBQAAABBuZXV0cmlub0NvbnRyYWN0CQEAAAAdZ2V0U25hcHNob3RDb250cmFjdEJhbGFuY2VLZXkAAAACBQAAAAVjb3VudAUAAAAHYXNzZXRJZAEAAAAJZ2V0UHJvZml0AAAAAQAAAAVjb3VudAkBAAAAGGdldE51bWJlckJ5QWRkcmVzc0FuZEtleQAAAAIFAAAAEG5ldXRyaW5vQ29udHJhY3QJAQAAAAxnZXRQcm9maXRLZXkAAAABBQAAAAVjb3VudAEAAAAOZ2V0VXNlckJhbGFuY2UAAAACAAAABW93bmVyAAAAB2Fzc2V0SWQJAQAAAA5nZXROdW1iZXJCeUtleQAAAAEJAQAAABFnZXRVc2VyQmFsYW5jZUtleQAAAAIFAAAABW93bmVyBQAAAAdhc3NldElkAQAAABVnZXRVc2VyQmFsYW5jZUJ5Q291bnQAAAADAAAABW93bmVyAAAABWNvdW50AAAAB2Fzc2V0SWQJAQAAAA5nZXROdW1iZXJCeUtleQAAAAEJAQAAABhnZXRVc2VyQmFsYW5jZUtleUJ5Q291bnQAAAADBQAAAAVvd25lcgUAAAAFY291bnQFAAAAB2Fzc2V0SWQBAAAAFWdldFVzZXJCYWxhbmNlSGlzdG9yeQAAAAEAAAAFb3duZXIJAQAAAA5nZXRTdHJpbmdCeUtleQAAAAEJAQAAABhnZXRVc2VyQmFsYW5jZUhpc3RvcnlLZXkAAAABBQAAAAVvd25lcgEAAAAJaXNDbGFpbWVkAAAAAgAAAAVvd25lcgAAAAVjb3VudAkBAAAADGdldEJvb2xCeUtleQAAAAEJAQAAAA9nZXRJc0NsYWltZWRLZXkAAAACBQAAAAVvd25lcgUAAAAFY291bnQBAAAAEWdldEhpc3RvcnlFbGVtZW50AAAAAQAAAAVjb3VudAkAASwAAAACCQABpAAAAAEFAAAABWNvdW50BQAAAA9MSVNUU1BMSVRTWU1CT0wBAAAAEWFkZEJhbGFuY2VIaXN0b3J5AAAAAgAAAAdoaXN0b3J5AAAAB2VsZW1lbnQJAAEsAAAAAgUAAAAHaGlzdG9yeQUAAAAHZWxlbWVudAAAAAMAAAABaQEAAAAMbG9ja05ldXRyaW5vAAAAAAQAAAADcG10CQEAAAAHZXh0cmFjdAAAAAEIBQAAAAFpAAAAB3BheW1lbnQDAwkBAAAAAiE9AAAAAggFAAAAA3BtdAAAAAdhc3NldElkBQAAAA9uZXV0cmlub0Fzc2V0SWQJAQAAAAIhPQAAAAIIBQAAAANwbXQAAAAHYXNzZXRJZAUAAAALYm9uZEFzc2V0SWQHCQAAAgAAAAECAAAAHWNhbiB1c2UgbmV1dHJpbm8gb3IgYm9uZCBvbmx5BAAAAAdhY2NvdW50CQAEJQAAAAEIBQAAAAFpAAAABmNhbGxlcgQAAAANYXNzZXRJZFN0cmluZwkAAlgAAAABCQEAAAAFdmFsdWUAAAABCAUAAAADcG10AAAAB2Fzc2V0SWQEAAAAB2JhbGFuY2UJAABkAAAAAgkBAAAADmdldFVzZXJCYWxhbmNlAAAAAgUAAAAHYWNjb3VudAUAAAANYXNzZXRJZFN0cmluZwgFAAAAA3BtdAAAAAZhbW91bnQEAAAADWhpc3RvcnlTdHJpbmcJAQAAABVnZXRVc2VyQmFsYW5jZUhpc3RvcnkAAAABBQAAAAdhY2NvdW50BAAAAAdoaXN0b3J5CQAEtQAAAAIFAAAADWhpc3RvcnlTdHJpbmcFAAAAD0xJU1RTUExJVFNZTUJPTAQAAAAFaW5kZXgJAABlAAAAAgkAAZAAAAABBQAAAAdoaXN0b3J5AAAAAAAAAAACBAAAAApuZXdIaXN0b3J5AwMJAQAAAAIhPQAAAAIFAAAADWhpc3RvcnlTdHJpbmcCAAAAAAkAAAAAAAACCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAHaGlzdG9yeQUAAAAFaW5kZXgFAAAACXN5bmNJbmRleAcFAAAADWhpc3RvcnlTdHJpbmcJAQAAABFhZGRCYWxhbmNlSGlzdG9yeQAAAAIFAAAADWhpc3RvcnlTdHJpbmcJAQAAABFnZXRIaXN0b3J5RWxlbWVudAAAAAEFAAAACXN5bmNJbmRleAkBAAAACFdyaXRlU2V0AAAAAQkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgkBAAAAFWdldENvbnRyYWN0QmFsYW5jZUtleQAAAAEFAAAADWFzc2V0SWRTdHJpbmcJAABkAAAAAgkBAAAAEmdldENvbnRyYWN0QmFsYW5jZQAAAAEFAAAADWFzc2V0SWRTdHJpbmcIBQAAAANwbXQAAAAGYW1vdW50CQAETAAAAAIJAQAAAAlEYXRhRW50cnkAAAACCQEAAAARZ2V0VXNlckJhbGFuY2VLZXkAAAACBQAAAAdhY2NvdW50BQAAAA1hc3NldElkU3RyaW5nBQAAAAdiYWxhbmNlCQAETAAAAAIJAQAAAAlEYXRhRW50cnkAAAACCQEAAAAYZ2V0VXNlckJhbGFuY2VLZXlCeUNvdW50AAAAAwUAAAAHYWNjb3VudAUAAAAJc3luY0luZGV4BQAAAA1hc3NldElkU3RyaW5nBQAAAAdiYWxhbmNlCQAETAAAAAIJAQAAAAlEYXRhRW50cnkAAAACCQEAAAAYZ2V0VXNlckJhbGFuY2VIaXN0b3J5S2V5AAAAAQUAAAAHYWNjb3VudAUAAAAKbmV3SGlzdG9yeQUAAAADbmlsAAAAAWkBAAAADnVubG9ja05ldXRyaW5vAAAAAgAAAAx1bmxvY2tBbW91bnQAAAANYXNzZXRJZFN0cmluZwQAAAAHYWNjb3VudAkABCUAAAABCAUAAAABaQAAAAZjYWxsZXIEAAAAB2Fzc2V0SWQJAAJZAAAAAQUAAAANYXNzZXRJZFN0cmluZwQAAAAHYmFsYW5jZQkAAGUAAAACCQEAAAAOZ2V0VXNlckJhbGFuY2UAAAACBQAAAAdhY2NvdW50BQAAAA1hc3NldElkU3RyaW5nBQAAAAx1bmxvY2tBbW91bnQDCQAAZgAAAAIAAAAAAAAAAAAFAAAAB2JhbGFuY2UJAAACAAAAAQIAAAAOaW52YWxpZCBhbW91bnQDAwkBAAAAAiE9AAAAAgUAAAAHYXNzZXRJZAUAAAAPbmV1dHJpbm9Bc3NldElkCQEAAAACIT0AAAACBQAAAAdhc3NldElkBQAAAAtib25kQXNzZXRJZAcJAAACAAAAAQIAAAAdY2FuIHVzZSBuZXV0cmlubyBvciBib25kIG9ubHkEAAAADWhpc3RvcnlTdHJpbmcJAQAAABVnZXRVc2VyQmFsYW5jZUhpc3RvcnkAAAABBQAAAAdhY2NvdW50BAAAAAdoaXN0b3J5CQAEtQAAAAIFAAAADWhpc3RvcnlTdHJpbmcFAAAAD0xJU1RTUExJVFNZTUJPTAQAAAAFaW5kZXgJAABlAAAAAgkAAZAAAAABBQAAAAdoaXN0b3J5AAAAAAAAAAACBAAAAApuZXdIaXN0b3J5AwMJAQAAAAIhPQAAAAIFAAAADWhpc3RvcnlTdHJpbmcCAAAAAAkAAAAAAAACCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAHaGlzdG9yeQUAAAAFaW5kZXgFAAAACXN5bmNJbmRleAcFAAAADWhpc3RvcnlTdHJpbmcJAQAAABFhZGRCYWxhbmNlSGlzdG9yeQAAAAIFAAAADWhpc3RvcnlTdHJpbmcJAQAAABFnZXRIaXN0b3J5RWxlbWVudAAAAAEFAAAACXN5bmNJbmRleAkBAAAADFNjcmlwdFJlc3VsdAAAAAIJAQAAAAhXcml0ZVNldAAAAAEJAARMAAAAAgkBAAAACURhdGFFbnRyeQAAAAIFAAAACkJhbGFuY2VLZXkJAABlAAAAAgkBAAAAEmdldENvbnRyYWN0QmFsYW5jZQAAAAEFAAAADWFzc2V0SWRTdHJpbmcFAAAADHVubG9ja0Ftb3VudAkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgkBAAAAEWdldFVzZXJCYWxhbmNlS2V5AAAAAgUAAAAHYWNjb3VudAUAAAANYXNzZXRJZFN0cmluZwUAAAAHYmFsYW5jZQkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgkBAAAAGGdldFVzZXJCYWxhbmNlS2V5QnlDb3VudAAAAAMFAAAAB2FjY291bnQFAAAACXN5bmNJbmRleAUAAAANYXNzZXRJZFN0cmluZwUAAAAHYmFsYW5jZQkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgkBAAAAGGdldFVzZXJCYWxhbmNlSGlzdG9yeUtleQAAAAEFAAAAB2FjY291bnQFAAAACm5ld0hpc3RvcnkFAAAAA25pbAkBAAAAC1RyYW5zZmVyU2V0AAAAAQkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADCQEAAAAcQGV4dHJVc2VyKGFkZHJlc3NGcm9tU3RyaW5nKQAAAAEFAAAAB2FjY291bnQFAAAADHVubG9ja0Ftb3VudAUAAAAPbmV1dHJpbm9Bc3NldElkBQAAAANuaWwAAAABaQEAAAAId2l0aGRyYXcAAAACAAAAD3Byb2ZpdFN5bmNJbmRleAAAAAxoaXN0b3J5SW5kZXgEAAAAB2FjY291bnQJAAQlAAAAAQgFAAAAAWkAAAAGY2FsbGVyBAAAAA1oaXN0b3J5U3RyaW5nCQEAAAAVZ2V0VXNlckJhbGFuY2VIaXN0b3J5AAAAAQUAAAAHYWNjb3VudAQAAAAHaGlzdG9yeQkABLUAAAACBQAAAA1oaXN0b3J5U3RyaW5nBQAAAA9MSVNUU1BMSVRTWU1CT0wEAAAACmxvY2tBY3R1YWwJAQAAAA1wYXJzZUludFZhbHVlAAAAAQkAAZEAAAACBQAAAAdoaXN0b3J5BQAAAAxoaXN0b3J5SW5kZXgDCQEAAAAJaXNDbGFpbWVkAAAAAgUAAAAHYWNjb3VudAUAAAAPcHJvZml0U3luY0luZGV4CQAAAgAAAAEJAAEsAAAAAgIAAAAdYWNjb3VudCBpcyBjbGFpbWVkIHJwZF9jb3VudDoJAAGkAAAAAQUAAAAPcHJvZml0U3luY0luZGV4AwMJAABmAAAAAgUAAAAPcHJvZml0U3luY0luZGV4BQAAAApsb2NrQWN0dWFsBgMJAABmAAAAAgkAAZAAAAABBQAAAAdoaXN0b3J5CQAAZAAAAAIFAAAADGhpc3RvcnlJbmRleAAAAAAAAAAAAgkAAGYAAAACCQEAAAANcGFyc2VJbnRWYWx1ZQAAAAEJAAGRAAAAAgUAAAAHaGlzdG9yeQkAAGQAAAACBQAAAAxoaXN0b3J5SW5kZXgAAAAAAAAAAAEFAAAAD3Byb2ZpdFN5bmNJbmRleAcJAAACAAAAAQIAAAAVaW52YWxpZCBoaXN0b3J5IGluZGV4BAAAABVuZXV0cmlub0Fzc2V0SWRTdHJpbmcJAAJYAAAAAQUAAAAPbmV1dHJpbm9Bc3NldElkBAAAABFib25kQXNzZXRJZFN0cmluZwkAAlgAAAABBQAAAAtib25kQXNzZXRJZAQAAAAHYmFsYW5jZQkAAGQAAAACCQEAAAAVZ2V0VXNlckJhbGFuY2VCeUNvdW50AAAAAwUAAAAHYWNjb3VudAUAAAAKbG9ja0FjdHVhbAUAAAAVbmV1dHJpbm9Bc3NldElkU3RyaW5nCQEAAAAVZ2V0VXNlckJhbGFuY2VCeUNvdW50AAAAAwUAAAAHYWNjb3VudAUAAAAKbG9ja0FjdHVhbAUAAAARYm9uZEFzc2V0SWRTdHJpbmcEAAAADHNoYXJlUGVyY2VudAkAAGkAAAACCQAAaAAAAAIJAABoAAAAAgUAAAAHYmFsYW5jZQUAAAAPUEVSQ0VOVEFDQ1VSQUNZAAAAAAAAAABkCQAAZAAAAAIJAQAAABpnZXRTbmFwc2hvdENvbnRyYWN0QmFsYW5jZQAAAAIFAAAAD3Byb2ZpdFN5bmNJbmRleAUAAAAVbmV1dHJpbm9Bc3NldElkU3RyaW5nCQEAAAAaZ2V0U25hcHNob3RDb250cmFjdEJhbGFuY2UAAAACBQAAAA9wcm9maXRTeW5jSW5kZXgFAAAAEWJvbmRBc3NldElkU3RyaW5nBAAAAAZwcm9maXQJAABpAAAAAgkAAGkAAAACCQAAaAAAAAIFAAAADHNoYXJlUGVyY2VudAkBAAAACWdldFByb2ZpdAAAAAEFAAAAD3Byb2ZpdFN5bmNJbmRleAAAAAAAAAAAZAUAAAAPUEVSQ0VOVEFDQ1VSQUNZCQEAAAAMU2NyaXB0UmVzdWx0AAAAAgkBAAAACFdyaXRlU2V0AAAAAQkABEwAAAACCQEAAAAJRGF0YUVudHJ5AAAAAgkBAAAAD2dldElzQ2xhaW1lZEtleQAAAAIFAAAAB2FjY291bnQFAAAAD3Byb2ZpdFN5bmNJbmRleAYFAAAAA25pbAkBAAAAC1RyYW5zZmVyU2V0AAAAAQkABEwAAAACCQEAAAAOU2NyaXB0VHJhbnNmZXIAAAADCQEAAAAcQGV4dHJVc2VyKGFkZHJlc3NGcm9tU3RyaW5nKQAAAAEFAAAAB2FjY291bnQFAAAABnByb2ZpdAUAAAAPbmV1dHJpbm9Bc3NldElkBQAAAANuaWwAAAAAM2QPfg==",
    "chainId": 84,
    "height": 703362,
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 7HJWEXazpTg4iwqwgN8fMSeqBcJUBSqpv5bAabmK8G2z

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 getBoolByKey (key) = match getBoolean(this, key) {
21+    case a: Boolean => 
22+        a
23+    case _ => 
24+        false
25+}
26+
27+
28+func getNumberByAddressAndKey (address,key) = match getInteger(addressFromStringValue(address), key) {
29+    case a: Int => 
30+        a
31+    case _ => 
32+        0
33+}
34+
35+
36+func getStringByAddressAndKey (address,key) = match getString(addressFromStringValue(address), key) {
37+    case a: String => 
38+        a
39+    case _ => 
40+        ""
41+}
42+
43+
44+let LISTSPLITSYMBOL = "_"
45+
46+let PERCENTACCURACY = 10000
47+
48+let NeutrinoAssetIdKey = "neutrino_asset_id"
49+
50+let BondAssetIdKey = "bond_asset_id"
51+
52+let NeutrinoContractKey = "neutrino_contract"
53+
54+let BalanceKey = "rpd_balance"
55+
56+let SyncIndexKey = "rpd_sync_index"
57+
58+let ProfitKey = "rpd_profit"
59+
60+let BalanceHistoryKey = "balance_history"
61+
62+let IsClaimedKey = "is_claimed"
63+
64+func getUserBalanceHistoryKey (owner) = ((BalanceHistoryKey + "_") + owner)
65+
66+
67+func getUserBalanceKey (owner,assetId) = ((((BalanceKey + "_") + assetId) + "_") + owner)
68+
69+
70+func getUserBalanceKeyByCount (owner,count,assetId) = ((getUserBalanceKey(owner, assetId) + "_") + toString(count))
71+
72+
73+func getIsClaimedKey (owner,count) = ((((IsClaimedKey + "_") + owner) + "_") + toString(count))
74+
75+
76+func getContractBalanceKey (assetId) = ((BalanceKey + "_") + assetId)
77+
78+
79+func getSnapshotContractBalanceKey (count,assetId) = ((((BalanceKey + "_") + assetId) + "_") + toString(count))
80+
81+
82+func getProfitKey (count) = ((ProfitKey + "_") + toString(count))
83+
84+
85+let neutrinoContract = getStringByKey(NeutrinoContractKey)
86+
87+let neutrinoAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, NeutrinoAssetIdKey))
88+
89+let bondAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, BondAssetIdKey))
90+
91+let syncIndex = getNumberByAddressAndKey(neutrinoContract, SyncIndexKey)
92+
93+func getContractBalance (assetId) = getNumberByKey(getContractBalanceKey(assetId))
94+
95+
96+func getSnapshotContractBalance (count,assetId) = getNumberByAddressAndKey(neutrinoContract, getSnapshotContractBalanceKey(count, assetId))
97+
98+
99+func getProfit (count) = getNumberByAddressAndKey(neutrinoContract, getProfitKey(count))
100+
101+
102+func getUserBalance (owner,assetId) = getNumberByKey(getUserBalanceKey(owner, assetId))
103+
104+
105+func getUserBalanceByCount (owner,count,assetId) = getNumberByKey(getUserBalanceKeyByCount(owner, count, assetId))
106+
107+
108+func getUserBalanceHistory (owner) = getStringByKey(getUserBalanceHistoryKey(owner))
109+
110+
111+func isClaimed (owner,count) = getBoolByKey(getIsClaimedKey(owner, count))
112+
113+
114+func getHistoryElement (count) = (toString(count) + LISTSPLITSYMBOL)
115+
116+
117+func addBalanceHistory (history,element) = (history + element)
118+
119+
120+@Callable(i)
121+func lockNeutrino () = {
122+    let pmt = extract(i.payment)
123+    if (if ((pmt.assetId != neutrinoAssetId))
124+        then (pmt.assetId != bondAssetId)
125+        else false)
126+        then throw("can use neutrino or bond only")
127+        else {
128+            let account = toString(i.caller)
129+            let assetIdString = toBase58String(value(pmt.assetId))
130+            let balance = (getUserBalance(account, assetIdString) + pmt.amount)
131+            let historyString = getUserBalanceHistory(account)
132+            let history = split(historyString, LISTSPLITSYMBOL)
133+            let index = (size(history) - 2)
134+            let newHistory = if (if ((historyString != ""))
135+                then (parseIntValue(history[index]) == syncIndex)
136+                else false)
137+                then historyString
138+                else addBalanceHistory(historyString, getHistoryElement(syncIndex))
139+            WriteSet([DataEntry(getContractBalanceKey(assetIdString), (getContractBalance(assetIdString) + pmt.amount)), DataEntry(getUserBalanceKey(account, assetIdString), balance), DataEntry(getUserBalanceKeyByCount(account, syncIndex, assetIdString), balance), DataEntry(getUserBalanceHistoryKey(account), newHistory)])
140+            }
141+    }
142+
143+
144+
145+@Callable(i)
146+func unlockNeutrino (unlockAmount,assetIdString) = {
147+    let account = toString(i.caller)
148+    let assetId = fromBase58String(assetIdString)
149+    let balance = (getUserBalance(account, assetIdString) - unlockAmount)
150+    if ((0 > balance))
151+        then throw("invalid amount")
152+        else if (if ((assetId != neutrinoAssetId))
153+            then (assetId != bondAssetId)
154+            else false)
155+            then throw("can use neutrino or bond only")
156+            else {
157+                let historyString = getUserBalanceHistory(account)
158+                let history = split(historyString, LISTSPLITSYMBOL)
159+                let index = (size(history) - 2)
160+                let newHistory = if (if ((historyString != ""))
161+                    then (parseIntValue(history[index]) == syncIndex)
162+                    else false)
163+                    then historyString
164+                    else addBalanceHistory(historyString, getHistoryElement(syncIndex))
165+                ScriptResult(WriteSet([DataEntry(BalanceKey, (getContractBalance(assetIdString) - unlockAmount)), DataEntry(getUserBalanceKey(account, assetIdString), balance), DataEntry(getUserBalanceKeyByCount(account, syncIndex, assetIdString), balance), DataEntry(getUserBalanceHistoryKey(account), newHistory)]), TransferSet([ScriptTransfer(addressFromStringValue(account), unlockAmount, neutrinoAssetId)]))
166+                }
167+    }
168+
169+
170+
171+@Callable(i)
172+func withdraw (profitSyncIndex,historyIndex) = {
173+    let account = toString(i.caller)
174+    let historyString = getUserBalanceHistory(account)
175+    let history = split(historyString, LISTSPLITSYMBOL)
176+    let lockActual = parseIntValue(history[historyIndex])
177+    if (isClaimed(account, profitSyncIndex))
178+        then throw(("account is claimed rpd_count:" + toString(profitSyncIndex)))
179+        else if (if ((profitSyncIndex > lockActual))
180+            then true
181+            else if ((size(history) > (historyIndex + 2)))
182+                then (parseIntValue(history[(historyIndex + 1)]) > profitSyncIndex)
183+                else false)
184+            then throw("invalid history index")
185+            else {
186+                let neutrinoAssetIdString = toBase58String(neutrinoAssetId)
187+                let bondAssetIdString = toBase58String(bondAssetId)
188+                let balance = (getUserBalanceByCount(account, lockActual, neutrinoAssetIdString) + getUserBalanceByCount(account, lockActual, bondAssetIdString))
189+                let sharePercent = (((balance * PERCENTACCURACY) * 100) / (getSnapshotContractBalance(profitSyncIndex, neutrinoAssetIdString) + getSnapshotContractBalance(profitSyncIndex, bondAssetIdString)))
190+                let profit = (((sharePercent * getProfit(profitSyncIndex)) / 100) / PERCENTACCURACY)
191+                ScriptResult(WriteSet([DataEntry(getIsClaimedKey(account, profitSyncIndex), true)]), TransferSet([ScriptTransfer(addressFromStringValue(account), profit, neutrinoAssetId)]))
192+                }
193+    }
194+
195+
github/deemru/w8io/169f3d6 
55.27 ms ◑