tx · GAvQkrT86ENNfnZ1EQiBXNwZkGjdvpH9rq8FLjRsywE

3N1Crs5pSkPJqv3iugDjt3ZocFzbLR94Pw7:  -0.01000000 Waves

2020.03.20 06:16 [917095] smart account 3N1Crs5pSkPJqv3iugDjt3ZocFzbLR94Pw7 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "GAvQkrT86ENNfnZ1EQiBXNwZkGjdvpH9rq8FLjRsywE",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1584674215496,
    "version": 1,
    "sender": "3N1Crs5pSkPJqv3iugDjt3ZocFzbLR94Pw7",
    "senderPublicKey": "DkcfFEL6aYZYuVKoUpLzZRB38zvNVnbKT8B11HbUjxQ7",
    "proofs": [
        "2BQPn78VLJWvy2yL4DdBhaL6YvrzQc77X84ozpGuoU6DPrX3FYnkoM8KwXXrSAa3g7rYb5iU2vnpXSW7C1RLHtA"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 917095,
    "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 getBoolByAddressAndKey (address,key) = match getBoolean(address, key) {
21+    case a: Boolean => 
22+        a
23+    case _ => 
24+        false
25+}
26+
27+
28+func getStringByAddressAndKey (address,key) = match getString(address, key) {
29+    case a: String => 
30+        a
31+    case _ => 
32+        ""
33+}
34+
35+
36+func getNumberByAddressAndKey (address,key) = match getInteger(address, key) {
37+    case a: Int => 
38+        a
39+    case _ => 
40+        0
41+}
42+
43+
44+let WAVELET = 100000000
45+
46+let ORDERSPLITSYMBOL = "_"
47+
48+let PAULI = 1000000
49+
50+let PERCENTACCURACY = 1000
51+
52+let MAXDISCOUNT = 50
53+
54+let CANCELED = "canceled"
55+
56+let NEW = "new"
57+
58+let FILLED = "filled"
59+
60+let NeutrinoContractKey = "neutrino_contract"
61+
62+let PriceKey = "price"
63+
64+let BondAssetIdKey = "bond_asset_id"
65+
66+let NeutrinoAssetIdKey = "neutrino_asset_id"
67+
68+let ControlContractKey = "control_contract"
69+
70+let BalanceLockedkKey = "balance_lock_"
71+
72+let WavesLockedBalanceKey = (BalanceLockedkKey + "waves")
73+
74+let NeutrinoLockedBalanceKey = (BalanceLockedkKey + "neutrino")
75+
76+let FirstOrderKey = "order_first"
77+
78+let LastOrderKey = "order_last"
79+
80+func getOrderPrevKey (orderId) = ("order_prev_" + orderId)
81+
82+
83+func getOrderNextKey (orderId) = ("order_next_" + orderId)
84+
85+
86+func getOrderTotalKey (orderId) = ("order_total_" + orderId)
87+
88+
89+func getOrderOwnerKey (orderId) = ("order_owner_" + orderId)
90+
91+
92+func getOrderHeightKey (orderId) = ("order_height_" + orderId)
93+
94+
95+func getOrderStatusKey (orderId) = ("order_status_" + orderId)
96+
97+
98+func getOrderFilledTotalKey (orderId) = ("order_filled_total_" + orderId)
99+
100+
101+func getLastOrderOwnerKey (owner) = ("last_order_owner_" + owner)
102+
103+
104+func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, 100, price), WAVELET, PAULI)
105+
106+
107+func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, 100), PAULI, WAVELET)
108+
109+
110+func convertNeutrinoToBond (amount) = (amount / PAULI)
111+
112+
113+func convertBondToNeutrino (amount) = (amount * PAULI)
114+
115+
116+func convertWavesToBond (amount,price) = convertNeutrinoToBond(convertWavesToNeutrino(amount, price))
117+
118+
119+let neutrinoContract = addressFromStringValue(getStringByKey(NeutrinoContractKey))
120+
121+let controlContract = addressFromStringValue(getStringByAddressAndKey(neutrinoContract, ControlContractKey))
122+
123+let liquidationContract = this
124+
125+let neutrinoAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, NeutrinoAssetIdKey))
126+
127+let bondAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, BondAssetIdKey))
128+
129+let firstOrder = getStringByKey(FirstOrderKey)
130+
131+let lastOrder = getStringByKey(LastOrderKey)
132+
133+let isBlocked = getBoolByAddressAndKey(controlContract, "is_blocked")
134+
135+let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
136+
137+let neutrinoLockedBalance = getNumberByAddressAndKey(neutrinoContract, NeutrinoLockedBalanceKey)
138+
139+let wavesLockedBalance = getNumberByAddressAndKey(neutrinoContract, WavesLockedBalanceKey)
140+
141+let reserve = (wavesBalance(neutrinoContract) - wavesLockedBalance)
142+
143+let neutrinoSupply = (((neutrinoLockedBalance + extract(assetInfo(neutrinoAssetId)).quantity) - assetBalance(neutrinoContract, neutrinoAssetId)) - assetBalance(liquidationContract, neutrinoAssetId))
144+
145+let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
146+
147+func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
148+
149+
150+func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
151+
152+
153+func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
154+
155+
156+func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
157+
158+
159+func getOrderPrev (id) = getStringByKey(getOrderPrevKey(id))
160+
161+
162+func getOrderNext (id) = getStringByKey(getOrderNextKey(id))
163+
164+
165+func getOrderHeight (id) = getNumberByKey(getOrderHeightKey(id))
166+
167+
168+func getLastOrderOwner (owner) = getStringByKey(getLastOrderOwnerKey(owner))
169+
170+
171+@Callable(i)
172+func addLiquidationOrder () = {
173+    let pmt = extract(i.payment)
174+    let newOrderId = toBase58String(keccak256((((toBytes(pmt.amount) + i.caller.bytes) + toBytes(height)) + i.transactionId)))
175+    let nextOrder = getOrderNext(lastOrder)
176+    let orderStatus = getOrderStatus(lastOrder)
177+    let owner = toString(i.caller)
178+    if (isBlocked)
179+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
180+        else if ((pmt.assetId != bondAssetId))
181+            then throw("can use appropriate neutrino bonds tokens only")
182+            else if ((getOrderOwner(newOrderId) != ""))
183+                then throw("an order is already exists")
184+                else if ((nextOrder != ""))
185+                    then throw(("nextOrder is not last. Info:" + nextOrder))
186+                    else if (if ((firstOrder != ""))
187+                        then (lastOrder == "")
188+                        else false)
189+                        then throw("invalid last order")
190+                        else if (if ((firstOrder != ""))
191+                            then (orderStatus != NEW)
192+                            else false)
193+                            then throw("last order status is not new")
194+                            else WriteSet([DataEntry(getLastOrderOwnerKey(owner), newOrderId), DataEntry(getOrderPrevKey(newOrderId), lastOrder), DataEntry(getOrderNextKey(lastOrder), if ((lastOrder == ""))
195+                                then ""
196+                                else newOrderId), DataEntry(FirstOrderKey, if ((firstOrder == ""))
197+                                then newOrderId
198+                                else firstOrder), DataEntry(LastOrderKey, newOrderId), DataEntry(getOrderTotalKey(newOrderId), pmt.amount), DataEntry(getOrderOwnerKey(newOrderId), owner), DataEntry(getOrderHeightKey(newOrderId), height), DataEntry(getOrderStatusKey(newOrderId), NEW)])
199+    }
200+
201+
202+
203+@Callable(i)
204+func cancelOrder (orderId) = {
205+    let owner = getOrderOwner(orderId)
206+    let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
207+    let nextOrder = getOrderNext(orderId)
208+    let prevOrder = getOrderPrev(orderId)
209+    if (isBlocked)
210+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
211+        else if ((owner != toString(i.caller)))
212+            then throw("permission denied")
213+            else if ((getOrderStatus(orderId) != NEW))
214+                then throw("invalid order status")
215+                else ScriptResult(WriteSet([DataEntry(FirstOrderKey, if ((firstOrder == orderId))
216+                    then nextOrder
217+                    else firstOrder), DataEntry(LastOrderKey, if ((lastOrder == orderId))
218+                    then prevOrder
219+                    else lastOrder), DataEntry(getOrderNextKey(prevOrder), nextOrder), DataEntry(getOrderPrevKey(nextOrder), prevOrder), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, bondAssetId)]))
220+    }
221+
222+
223+
224+@Callable(i)
225+func liquidateBond () = {
226+    let surplusPositive = if ((0 >= surplus))
227+        then 0
228+        else surplus
229+    let liquidationBalance = assetBalance(this, neutrinoAssetId)
230+    let returnAmount = if ((surplusPositive >= liquidationBalance))
231+        then 0
232+        else (liquidationBalance - surplusPositive)
233+    let surplusBond = convertNeutrinoToBond(surplusPositive)
234+    if (isBlocked)
235+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
236+        else if (if ((returnAmount == 0))
237+            then (liquidationBalance == 0)
238+            else false)
239+            then throw("cannot liquidate order without neutrino on the smart contract")
240+            else if ((returnAmount > 0))
241+                then TransferSet([ScriptTransfer(neutrinoContract, returnAmount, neutrinoAssetId)])
242+                else if ((0 >= surplusBond))
243+                    then throw("there is no proficit on the smart contract now")
244+                    else if ((firstOrder == ""))
245+                        then throw("empty orderbook")
246+                        else {
247+                            let nextOrder = getOrderNext(firstOrder)
248+                            let orderTotal = getOrderTotal(firstOrder)
249+                            let orderOwner = getOrderOwner(firstOrder)
250+                            let filledTotal = getOrderFilledTotal(firstOrder)
251+                            let amount = (orderTotal - filledTotal)
252+                            let newStatus = if ((surplusBond >= amount))
253+                                then FILLED
254+                                else NEW
255+                            let fillableOrderAmount = if ((surplusBond >= amount))
256+                                then amount
257+                                else surplusBond
258+                            ScriptResult(WriteSet([DataEntry(getOrderPrevKey(nextOrder), if ((newStatus == FILLED))
259+                                then ""
260+                                else firstOrder), DataEntry(FirstOrderKey, if ((newStatus == FILLED))
261+                                then nextOrder
262+                                else firstOrder), DataEntry(LastOrderKey, if (if ((newStatus == FILLED))
263+                                then (firstOrder == lastOrder)
264+                                else false)
265+                                then ""
266+                                else lastOrder), DataEntry(getOrderFilledTotalKey(firstOrder), (filledTotal + fillableOrderAmount)), DataEntry(getOrderStatusKey(firstOrder), newStatus)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), convertBondToNeutrino(fillableOrderAmount), neutrinoAssetId)]))
267+                            }
268+    }
269+
270+
github/deemru/w8io/873ac7e 
41.22 ms ◑