tx · 7WK3nbW4XPavzAUPK3qe13NSXDW2wd8a2p1TuKWSD4A7

3NBuDtQkhUjztpDF7qyYBXHzBRxzWuT1VCS:  -0.01000000 Waves

2020.01.17 23:37 [858655] smart account 3NBuDtQkhUjztpDF7qyYBXHzBRxzWuT1VCS > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7WK3nbW4XPavzAUPK3qe13NSXDW2wd8a2p1TuKWSD4A7",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1579293470789,
    "version": 1,
    "sender": "3NBuDtQkhUjztpDF7qyYBXHzBRxzWuT1VCS",
    "senderPublicKey": "AYMDMq9Bt9p416yBQAnvvz6f4FjoS8DvPFDhvCNRLaM6",
    "proofs": [
        "36FQYJcFJy4HKmu3ziGJ6uvdWJAx7zGWrFpvqTDXvkcN7yWDaZgxuLTtzCFNVmV92CpYtjGMVdDLjYnBFpP7UpZG"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 858655,
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

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 = 1000000
41+
42+let PERCENTACCURACY = 1000
43+
44+let MAXDISCOUNT = 50
45+
46+let CANCELED = "canceled"
47+
48+let NEW = "new"
49+
50+let FILLED = "filled"
51+
52+let NeutrinoContractKey = "neutrino_contract"
53+
54+let OrderbookKey = "orderbook"
55+
56+let PriceKey = "price"
57+
58+let BondAssetIdKey = "bond_asset_id"
59+
60+let NeutrinoAssetIdKey = "neutrino_asset_id"
61+
62+let ControlContractKey = "control_contract"
63+
64+let BalanceLockedkKey = "balance_lock_"
65+
66+let WavesLockedBalanceKey = (BalanceLockedkKey + "waves")
67+
68+let NeutrinoLockedBalanceKey = (BalanceLockedkKey + "neutrino")
69+
70+func getOrderTotalKey (orderId) = ("order_total_" + orderId)
71+
72+
73+func getOrderOwnerKey (orderId) = ("order_owner_" + orderId)
74+
75+
76+func getOrderHeightKey (orderId) = ("order_height_" + orderId)
77+
78+
79+func getOrderStatusKey (orderId) = ("order_status_" + orderId)
80+
81+
82+func getOrderFilledTotalKey (orderId) = ("order_filled_total_" + orderId)
83+
84+
85+func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, 100, price), WAVELET, PAULI)
86+
87+
88+func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, 100), PAULI, WAVELET)
89+
90+
91+func convertNeutrinoToBond (amount) = (amount / PAULI)
92+
93+
94+func convertBondToNeutrino (amount) = (amount * PAULI)
95+
96+
97+func convertWavesToBond (amount,price) = convertNeutrinoToBond(convertWavesToNeutrino(amount, price))
98+
99+
100+func convertJsonArrayToList (jsonArray) = split(jsonArray, ",")
101+
102+
103+let orderbook = getStringByKey(OrderbookKey)
104+
105+let neutrinoContract = addressFromStringValue(getStringByKey(NeutrinoContractKey))
106+
107+let controlContract = addressFromStringValue(getStringByAddressAndKey(neutrinoContract, ControlContractKey))
108+
109+let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
110+
111+let neutrinoLockedBalance = getNumberByAddressAndKey(neutrinoContract, NeutrinoLockedBalanceKey)
112+
113+let wavesLockedBalance = getNumberByAddressAndKey(neutrinoContract, WavesLockedBalanceKey)
114+
115+let neutrinoAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, NeutrinoAssetIdKey))
116+
117+let bondAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, BondAssetIdKey))
118+
119+let reserve = (wavesBalance(neutrinoContract) - wavesLockedBalance)
120+
121+let neutrinoSupply = (((extract(assetInfo(neutrinoAssetId)).quantity - assetBalance(neutrinoContract, neutrinoAssetId)) + neutrinoLockedBalance) - assetBalance(this, neutrinoAssetId))
122+
123+let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
124+
125+func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
126+
127+
128+func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
129+
130+
131+func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
132+
133+
134+func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
135+
136+
137+func getOrderElementById (id) = (id + ORDERSPLITSYMBOL)
138+
139+
140+func addOrder (orderId,position) = {
141+    let orders = split(orderbook, ORDERSPLITSYMBOL)
142+    let newOrder = getOrderElementById(orderId)
143+    if ((position == 0))
144+        then (newOrder + orderbook)
145+        else if ((position >= (size(orders) - 1)))
146+            then (orderbook + newOrder)
147+            else {
148+                let parts = split(orderbook, getOrderElementById(orders[position]))
149+                (((parts[0] + newOrder) + getOrderElementById(orders[position])) + parts[1])
150+                }
151+    }
152+
153+
154+func dropOrder (orderId) = {
155+    let parts = split(orderbook, getOrderElementById(orderId))
156+    (parts[0] + parts[1])
157+    }
158+
159+
160+func getOrdersInOrderbook (orderbook) = split(orderbook, ORDERSPLITSYMBOL)
161+
162+
163+@Callable(i)
164+func addLiquidationOrder () = {
165+    let pmt = extract(i.payment)
166+    let newOrderId = toBase58String(keccak256(((toBytes(pmt.amount) + i.caller.bytes) + toBytes(height))))
167+    if ((pmt.assetId != bondAssetId))
168+        then throw("can use appropriate neutrino bonds tokens only")
169+        else if ((getOrderOwner(newOrderId) != ""))
170+            then throw("an order is already exists")
171+            else WriteSet([DataEntry(OrderbookKey, addOrder(newOrderId, size(getOrdersInOrderbook(orderbook)))), DataEntry(getOrderTotalKey(newOrderId), pmt.amount), DataEntry(getOrderOwnerKey(newOrderId), toString(i.caller)), DataEntry(getOrderHeightKey(newOrderId), height), DataEntry(getOrderStatusKey(newOrderId), NEW)])
172+    }
173+
174+
175+
176+@Callable(i)
177+func cancelOrder (orderId) = {
178+    let owner = getOrderOwner(orderId)
179+    let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
180+    if ((owner != toString(i.caller)))
181+        then throw("permission denied")
182+        else if ((getOrderStatus(orderId) != NEW))
183+            then throw("invalid order status")
184+            else ScriptResult(WriteSet([DataEntry(OrderbookKey, dropOrder(orderId)), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, bondAssetId)]))
185+    }
186+
187+
188+
189+@Callable(i)
190+func liquidateBond () = {
191+    let surplusBond = convertNeutrinoToBond(surplus)
192+    let neutrinoBalance = assetBalance(this, neutrinoAssetId)
193+    let surplusPositive = if ((0 >= surplus))
194+        then 0
195+        else surplus
196+    let bondAmount = if ((surplusPositive >= neutrinoBalance))
197+        then neutrinoBalance
198+        else surplusPositive
199+    let returnAmount = if ((surplusPositive >= neutrinoBalance))
200+        then 0
201+        else (neutrinoBalance - surplusPositive)
202+    if (if ((returnAmount == 0))
203+        then (neutrinoBalance == 0)
204+        else false)
205+        then throw("without surplus")
206+        else if (if ((0 >= surplusBond))
207+            then (returnAmount > 0)
208+            else false)
209+            then TransferSet([ScriptTransfer(neutrinoContract, returnAmount, neutrinoAssetId)])
210+            else if ((0 >= surplusBond))
211+                then throw("there is no proficit on the smart contract now")
212+                else if ((orderbook == ""))
213+                    then throw("empty orderbook")
214+                    else {
215+                        let orderId = getOrdersInOrderbook(orderbook)[0]
216+                        let orderTotal = getOrderTotal(orderId)
217+                        let orderOwner = getOrderOwner(orderId)
218+                        let filledTotal = getOrderFilledTotal(orderId)
219+                        let amount = (orderTotal - filledTotal)
220+                        let status = if ((surplusBond >= amount))
221+                            then FILLED
222+                            else NEW
223+                        let newTotal = if ((surplusBond >= amount))
224+                            then amount
225+                            else surplusBond
226+                        ScriptResult(WriteSet([DataEntry(OrderbookKey, if ((status == FILLED))
227+                            then dropOrder(orderId)
228+                            else orderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + newTotal)), DataEntry(getOrderStatusKey(orderId), status)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), convertBondToNeutrino(newTotal), neutrinoAssetId), ScriptTransfer(neutrinoContract, returnAmount, neutrinoAssetId)]))
229+                        }
230+    }
231+
232+
233+@Verifier(tx)
234+func verify () = {
235+    let pubKeyAdminsList = ["BLEoguzPVKVTfXxxT3W7Rqf8aUm2ggC9Vemd2MQawM2G", "FWVffYr2ALmHMejZm3WqeLz6Sdym3gLFGtJn4KTwyU5x", "3Wh2LaWcb5gg7K2pPcW3Ep6EAuRBzYkAgrdpt43jTDFa", "5WRXFSjwcTbNfKcJs8ZqXmSSWYsSVJUtMvMqZj5hH4Nc"]
236+    let count = ((((if (sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(pubKeyAdminsList[0])))
237+        then 1
238+        else 0) + (if (sigVerify(tx.bodyBytes, tx.proofs[1], fromBase58String(pubKeyAdminsList[1])))
239+        then 1
240+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[2], fromBase58String(pubKeyAdminsList[2])))
241+        then 1
242+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[3], fromBase58String(pubKeyAdminsList[3])))
243+        then 2
244+        else 0))
245+    (count >= 3)
246+    }
247+
github/deemru/w8io/026f985 
37.62 ms ◑