tx · 8Ndd4zfTQuici7f1MWLryUR5eCjkK7mcTURfVajovXVa

3N5nmMvMH8o3RPEyCKCaoWahBTYTexnZy62:  -0.01000000 Waves

2020.05.05 02:28 [983984] smart account 3N5nmMvMH8o3RPEyCKCaoWahBTYTexnZy62 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8Ndd4zfTQuici7f1MWLryUR5eCjkK7mcTURfVajovXVa",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1588634891508,
    "version": 1,
    "sender": "3N5nmMvMH8o3RPEyCKCaoWahBTYTexnZy62",
    "senderPublicKey": "6PBV8fVJwLaUQbCyG7iqoKR3x1nqFRZFNeuN9qodoiTu",
    "proofs": [
        "27Lk6eCqWxyViLFNBaqUKLRwC2Np5nSGojbKyG5PsKzUaJEFtnyWi2RpYRrRU1XvFZdzmUUV2oW336tfMaAaFreb"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 983984,
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: LyGaKAz7PEJmzSxEi8J5xcT9qoKCnTJwdSQrDmufB25

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 PAULI = 1000000
47+
48+let CANCELED = "canceled"
49+
50+let NEW = "new"
51+
52+let FILLED = "filled"
53+
54+let NeutrinoContractKey = "neutrino_contract"
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+let FirstOrderKey = "order_first"
71+
72+let CurrentDefaultOrderKey = "order_default"
73+
74+func getOrderPriceKey (orderId) = ("order_price_" + orderId)
75+
76+
77+func getOrderTotalKey (orderId) = ("order_total_" + orderId)
78+
79+
80+func getOrderOwnerKey (orderId) = ("order_owner_" + orderId)
81+
82+
83+func getOrderHeightKey (orderId) = ("order_height_" + orderId)
84+
85+
86+func getOrderStatusKey (orderId) = ("order_status_" + orderId)
87+
88+
89+func getOrderFilledTotalKey (orderId) = ("order_filled_total_" + orderId)
90+
91+
92+func getPrevOrderKey (orderId) = ("order_prev_" + orderId)
93+
94+
95+func getNextOrderKey (orderId) = ("order_next_" + orderId)
96+
97+
98+func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, 100, price), WAVELET, PAULI)
99+
100+
101+func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, 100), PAULI, WAVELET)
102+
103+
104+func convertWavesToBond (amount,price) = convertWavesToNeutrino(amount, price)
105+
106+
107+let neutrinoContract = addressFromStringValue(getStringByKey(NeutrinoContractKey))
108+
109+let controlContract = addressFromStringValue(getStringByAddressAndKey(neutrinoContract, ControlContractKey))
110+
111+let liquidationContract = this
112+
113+let neutrinoAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, NeutrinoAssetIdKey))
114+
115+let bondAssetId = fromBase58String("BGhPYquXSK6UYjnPLEn94gFhetp4Jvf7toekEY4x1VDH")
116+
117+let firstOrder = getStringByKey(FirstOrderKey)
118+
119+let isBlocked = getBoolByAddressAndKey(controlContract, "is_blocked")
120+
121+let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
122+
123+let neutrinoLockedBalance = getNumberByAddressAndKey(neutrinoContract, NeutrinoLockedBalanceKey)
124+
125+let wavesLockedBalance = getNumberByAddressAndKey(neutrinoContract, WavesLockedBalanceKey)
126+
127+let reserve = (wavesBalance(neutrinoContract) - wavesLockedBalance)
128+
129+let neutrinoSupply = (((neutrinoLockedBalance + extract(assetInfo(neutrinoAssetId)).quantity) - assetBalance(neutrinoContract, neutrinoAssetId)) - assetBalance(liquidationContract, neutrinoAssetId))
130+
131+let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
132+
133+func getOrderPrice (id) = getNumberByKey(getOrderPriceKey(id))
134+
135+
136+func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
137+
138+
139+func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
140+
141+
142+func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
143+
144+
145+func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
146+
147+
148+func getOrderHeight (id) = getNumberByKey(getOrderHeightKey(id))
149+
150+
151+func getPrevOrder (id) = getStringByKey(getPrevOrderKey(id))
152+
153+
154+func getNextOrder (id) = getStringByKey(getNextOrderKey(id))
155+
156+
157+let currentDefaultOrder = getStringByKey(CurrentDefaultOrderKey)
158+
159+func generateDataEntryToAddOrder (price,newOrderId,i,prevOrder,nextOrder,firstOrder) = {
160+    let amount = extract(i.payment).amount
161+    let isOneForOneOrder = (price == 100)
162+    let isFirstOrderEmty = (firstOrder == "")
163+    let isNewOrderPriceLowerThanCurrentFirstOrder = (getOrderPrice(firstOrder) > price)
164+    let newFirstOrder = if (isFirstOrderEmty)
165+        then newOrderId
166+        else if (isNewOrderPriceLowerThanCurrentFirstOrder)
167+            then newOrderId
168+            else firstOrder
169+[DataEntry(getPrevOrderKey(newOrderId), prevOrder), DataEntry(getNextOrderKey(newOrderId), nextOrder), DataEntry(getNextOrderKey(prevOrder), if ((prevOrder == ""))
170+        then prevOrder
171+        else newOrderId), DataEntry(getPrevOrderKey(nextOrder), if ((nextOrder == ""))
172+        then nextOrder
173+        else newOrderId), DataEntry(FirstOrderKey, newFirstOrder), DataEntry(getOrderPriceKey(newOrderId), price), DataEntry(getOrderTotalKey(newOrderId), amount), DataEntry(getOrderOwnerKey(newOrderId), toString(i.caller)), DataEntry(getOrderHeightKey(newOrderId), height), DataEntry(getOrderStatusKey(newOrderId), NEW), DataEntry(CurrentDefaultOrderKey, if (isOneForOneOrder)
174+        then newOrderId
175+        else currentDefaultOrder)]
176+    }
177+
178+
179+func internalAddLiquidationOrder (i,price,prevOrder) = {
180+    let pmt = extract(i.payment)
181+    let newOrderId = toBase58String(keccak256((((toBytes(pmt.amount) + i.caller.bytes) + toBytes(height)) + i.transactionId)))
182+    let owner = toString(i.caller)
183+    let isEmptyPrevOrder = (prevOrder == "")
184+    let isEmptyFirstOrder = (firstOrder == "")
185+    if (isBlocked)
186+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions until reactivation by emergency oracles")
187+        else if ((PAULI > pmt.amount))
188+            then throw("order amount should be higher than 1 NSBT")
189+            else if ((100 > price))
190+                then throw(("price should be equal or higher than 1 nsbt for 1 usdn. i.e. >= 100; price: " + toString(price)))
191+                else if ((pmt.assetId != bondAssetId))
192+                    then throw("can use appropriate neutrino base tokens (nsbt) only")
193+                    else if ((getOrderOwner(newOrderId) != ""))
194+                        then throw("the order already exists")
195+                        else if (if (!(isEmptyPrevOrder))
196+                            then (getOrderStatus(prevOrder) != NEW)
197+                            else false)
198+                            then throw("prev order status is not new")
199+                            else if (if (isEmptyFirstOrder)
200+                                then !(isEmptyPrevOrder)
201+                                else false)
202+                                then throw("wrong prev order parameter")
203+                                else {
204+                                    let nextOrder = if (isEmptyPrevOrder)
205+                                        then firstOrder
206+                                        else getNextOrder(prevOrder)
207+                                    let isEmptyNextOrder = (nextOrder == "")
208+                                    if (isEmptyFirstOrder)
209+                                        then WriteSet(generateDataEntryToAddOrder(price, newOrderId, i, prevOrder, nextOrder, firstOrder))
210+                                        else {
211+                                            let nextOrderPrice = getNumberByKey(getOrderPriceKey(nextOrder))
212+                                            let prevOrderPrice = getNumberByKey(getOrderPriceKey(prevOrder))
213+                                            let isNextOrderError = if (!(isEmptyNextOrder))
214+                                                then (price >= nextOrderPrice)
215+                                                else false
216+                                            let isPrevOrderError = if (!(isEmptyPrevOrder))
217+                                                then (prevOrderPrice > price)
218+                                                else false
219+                                            if (if (isNextOrderError)
220+                                                then true
221+                                                else isPrevOrderError)
222+                                                then throw(((("invalid order isPrevOrderError:" + toString(isPrevOrderError)) + " isNextOrderError:") + toString(isNextOrderError)))
223+                                                else WriteSet(generateDataEntryToAddOrder(price, newOrderId, i, prevOrder, nextOrder, firstOrder))
224+                                            }
225+                                    }
226+    }
227+
228+
229+func computeCurrentDefaultOrder (id) = if ((id != currentDefaultOrder))
230+    then currentDefaultOrder
231+    else ""
232+
233+
234+@Callable(i)
235+func addLiquidationOrderWithPrice (price,prevOrder) = internalAddLiquidationOrder(i, price, prevOrder)
236+
237+
238+
239+@Callable(i)
240+func addLiquidationOrder () = internalAddLiquidationOrder(i, 100, currentDefaultOrder)
241+
242+
243+
244+@Callable(i)
245+func cancelOrder (orderId) = {
246+    let owner = getOrderOwner(orderId)
247+    let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
248+    let caller = toString(i.caller)
249+    let nextOrder = getNextOrder(orderId)
250+    let prevOrder = getPrevOrder(orderId)
251+    let isDefaultOrder = (orderId == currentDefaultOrder)
252+    let isPrevCanBecomeDefault = (getOrderStatus(prevOrder) == NEW)
253+    let newDefaultOrder = if (isDefaultOrder)
254+        then if (isPrevCanBecomeDefault)
255+            then prevOrder
256+            else ""
257+        else currentDefaultOrder
258+    if (isBlocked)
259+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions until reactivation by emergency oracles")
260+        else if ((owner != caller))
261+            then throw("permission denied")
262+            else if ((getOrderStatus(orderId) != NEW))
263+                then throw("invalid order status")
264+                else ScriptResult(WriteSet([DataEntry(CurrentDefaultOrderKey, newDefaultOrder), DataEntry(FirstOrderKey, if ((firstOrder == orderId))
265+                    then nextOrder
266+                    else firstOrder), DataEntry(getNextOrderKey(prevOrder), nextOrder), DataEntry(getPrevOrderKey(nextOrder), prevOrder), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, bondAssetId)]))
267+    }
268+
269+
270+
271+@Callable(i)
272+func liquidateBond () = {
273+    let liquidationBalance = assetBalance(this, neutrinoAssetId)
274+    let surplusPositive = if ((0 >= surplus))
275+        then 0
276+        else surplus
277+    let usdnAmount = if ((surplusPositive >= liquidationBalance))
278+        then liquidationBalance
279+        else surplusPositive
280+    let returnAmount = if ((surplusPositive >= liquidationBalance))
281+        then 0
282+        else (liquidationBalance - surplusPositive)
283+    if (isBlocked)
284+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions until reactivation by emergency oracles")
285+        else if ((liquidationBalance == 0))
286+            then throw("without base tokens to liquidate")
287+            else if ((returnAmount > 0))
288+                then TransferSet([ScriptTransfer(neutrinoContract, returnAmount, neutrinoAssetId)])
289+                else if ((firstOrder == ""))
290+                    then throw("empty orderbook")
291+                    else {
292+                        let nextOrder = getNextOrder(firstOrder)
293+                        let filledTotal = getOrderFilledTotal(firstOrder)
294+                        let orderPrice = getOrderPrice(firstOrder)
295+                        let remainedTotal = (getOrderTotal(firstOrder) - filledTotal)
296+                        let totalUSDNRequiredToFillOrder = fraction(remainedTotal, orderPrice, 100)
297+                        let isOrderFullyFilable = (usdnAmount >= totalUSDNRequiredToFillOrder)
298+                        let fillableOrderAmount = if (isOrderFullyFilable)
299+                            then totalUSDNRequiredToFillOrder
300+                            else usdnAmount
301+                        let finalNBTFillable = fraction(fillableOrderAmount, 100, orderPrice)
302+                        let nbTokensLiquidateCondition = (fraction((surplus + neutrinoSupply), 100, neutrinoSupply) >= orderPrice)
303+                        if (!(nbTokensLiquidateCondition))
304+                            then throw(("innapropriate surplus: " + toString(surplus)))
305+                            else {
306+                                let isNothingToFillNow = (remainedTotal == 0)
307+                                let isNothingToFillAtAll = ((filledTotal + finalNBTFillable) == getOrderTotal(firstOrder))
308+                                let newStatus = if (if (isOrderFullyFilable)
309+                                    then if (isNothingToFillNow)
310+                                        then true
311+                                        else isNothingToFillAtAll
312+                                    else false)
313+                                    then FILLED
314+                                    else NEW
315+                                ScriptResult(WriteSet([DataEntry(getPrevOrderKey(nextOrder), if ((newStatus == FILLED))
316+                                    then ""
317+                                    else firstOrder), DataEntry(FirstOrderKey, if ((newStatus == FILLED))
318+                                    then nextOrder
319+                                    else firstOrder), DataEntry(getOrderFilledTotalKey(firstOrder), (filledTotal + finalNBTFillable)), DataEntry(getOrderStatusKey(firstOrder), newStatus), DataEntry(CurrentDefaultOrderKey, computeCurrentDefaultOrder(firstOrder))]), TransferSet([ScriptTransfer(addressFromStringValue(getOrderOwner(firstOrder)), fillableOrderAmount, neutrinoAssetId), ScriptTransfer(neutrinoContract, finalNBTFillable, bondAssetId)]))
320+                                }
321+                        }
322+    }
323+
324+
325+
326+@Callable(i)
327+func updateReservesAndNeutrinoSupply () = {
328+    func getNumberByKeyInternal (key) =         match getInteger(this, key) {
329+        case a: Int => 
330+            a
331+        case _ => 
332+            0
333+    }
334+
335+    let idx = getNumberByKeyInternal("updateReservesAndNeutrinoSupplyIdx")
336+    let newIdx = (idx + 1)
337+    WriteSet([DataEntry("updateReservesAndNeutrinoSupplyIdx", newIdx), DataEntry("reserve", reserve), DataEntry("neutrinoSupply", neutrinoSupply), DataEntry("surplus", surplus)])
338+    }
339+
340+
341+@Verifier(tx)
342+func verify () = {
343+    let pubKeyAdminsList = ["GXxmZaCigPgJsT6d1cLr8nUXA65nGX8V7FuAzzrY8wQE", "3xumx4hrPpeeoo79HLGbZCgfz95L39ZFdxxwWeSUC2Pu", "D4CqtK5fBsnzRo33ZMhrM7niLseDH2uRoK6weBq2JQ3A", "5WRXFSjwcTbNfKcJs8ZqXmSSWYsSVJUtMvMqZj5hH4Nc"]
344+    let count = ((((if (sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(pubKeyAdminsList[0])))
345+        then 1
346+        else 0) + (if (sigVerify(tx.bodyBytes, tx.proofs[1], fromBase58String(pubKeyAdminsList[1])))
347+        then 1
348+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[2], fromBase58String(pubKeyAdminsList[2])))
349+        then 1
350+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[3], fromBase58String(pubKeyAdminsList[3])))
351+        then 2
352+        else 0))
353+    (count >= 3)
354+    }
355+
github/deemru/w8io/873ac7e 
40.46 ms ◑