tx · 68du3LNvteAgGJ6vZ6G2N2Gk1Y4CnY1F4ztkMKRgxqYT

3MwBMfHq2xGp8TJamHoFe3wrNsbHDxdoyVx:  -0.01000000 Waves

2020.04.03 16:37 [938061] smart account 3MwBMfHq2xGp8TJamHoFe3wrNsbHDxdoyVx > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "68du3LNvteAgGJ6vZ6G2N2Gk1Y4CnY1F4ztkMKRgxqYT",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1585921049109,
    "version": 1,
    "sender": "3MwBMfHq2xGp8TJamHoFe3wrNsbHDxdoyVx",
    "senderPublicKey": "7Jk5Fkkexfnmc8QRrWrgvCbnVdpXBgQAmH8MW2NN9Fbe",
    "proofs": [
        "4Bm11jgDS4F28SYcqmj48Zrvi6RtcRAEVK6ij8AVL83wcxKYNFvhhWrY9NLFyPmvtdQ5yLdcrCQWb7FJoDN2Dvsw"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 938061,
    "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 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("EsLKSqMDCMxmupi75orzyE781GeiDqmLbM9gof2TVYP")
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+func getCurrentDefaultOrder () = getStringByKey(getOrderStatusKey(CurrentDefaultOrderKey))
158+
159+
160+func internalAddLiquidationOrder (i,price,prevOrder) = {
161+    let pmt = extract(i.payment)
162+    let newOrderId = toBase58String(keccak256((((toBytes(pmt.amount) + i.caller.bytes) + toBytes(height)) + i.transactionId)))
163+    if (isBlocked)
164+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions until reactivation by emergency oracles")
165+        else if ((PAULI > pmt.amount))
166+            then throw("order amount must be higher than 1 NSBT")
167+            else if ((100 > price))
168+                then throw(("price should be equal or higher than 1 nsbt for 1 usdn. i.e. >= 100; price: " + toString(price)))
169+                else if ((pmt.assetId != bondAssetId))
170+                    then throw("can use appropriate neutrino base tokens (nsbt) only")
171+                    else if ((getOrderOwner(newOrderId) != ""))
172+                        then throw("an order is already exists")
173+                        else if (if ((prevOrder != ""))
174+                            then (getOrderStatus(prevOrder) != NEW)
175+                            else false)
176+                            then throw("prev order status is not new")
177+                            else {
178+                                let owner = toString(i.caller)
179+                                let nextOrder = if ((prevOrder == ""))
180+                                    then firstOrder
181+                                    else getNextOrder(prevOrder)
182+                                let nextOrderPrice = getNumberByKey(getOrderPriceKey(nextOrder))
183+                                let isNextOrderError = if (if ((nextOrder != ""))
184+                                    then (price >= nextOrderPrice)
185+                                    else false)
186+                                    then true
187+                                    else false
188+                                let prevOrderPrice = getNumberByKey(getOrderPriceKey(prevOrder))
189+                                let isPrevOrderError = if (if ((prevOrder != ""))
190+                                    then (prevOrderPrice > price)
191+                                    else false)
192+                                    then true
193+                                    else false
194+                                if (if (isNextOrderError)
195+                                    then true
196+                                    else isPrevOrderError)
197+                                    then throw(((("invalid order isPrevOrderError:" + toString(isPrevOrderError)) + " isNextOrderError:") + toString(isNextOrderError)))
198+                                    else WriteSet([DataEntry(getPrevOrderKey(newOrderId), prevOrder), DataEntry(getNextOrderKey(newOrderId), nextOrder), DataEntry(getNextOrderKey(prevOrder), if ((prevOrder == ""))
199+                                        then ""
200+                                        else newOrderId), DataEntry(getPrevOrderKey(nextOrder), if ((nextOrder == ""))
201+                                        then ""
202+                                        else newOrderId), DataEntry(FirstOrderKey, if (if ((firstOrder == ""))
203+                                        then true
204+                                        else (firstOrder == nextOrder))
205+                                        then newOrderId
206+                                        else firstOrder), DataEntry(getOrderPriceKey(newOrderId), price), DataEntry(getOrderTotalKey(newOrderId), pmt.amount), DataEntry(getOrderOwnerKey(newOrderId), owner), DataEntry(getOrderHeightKey(newOrderId), height), DataEntry(getOrderStatusKey(newOrderId), NEW), DataEntry(("debug_order_currentPrice_" + newOrderId), currentPrice), DataEntry(CurrentDefaultOrderKey, if ((price == 100))
207+                                        then newOrderId
208+                                        else getCurrentDefaultOrder())])
209+                                }
210+    }
211+
212+
213+func computeCurrentDefaultOrder (id) = {
214+    let currentDefaultOrder = getCurrentDefaultOrder()
215+    if ((id != currentDefaultOrder))
216+        then currentDefaultOrder
217+        else getPrevOrderKey(id)
218+    }
219+
220+
221+@Callable(i)
222+func addLiquidationOrderWithPrice (price,prevOrder) = internalAddLiquidationOrder(i, price, prevOrder)
223+
224+
225+
226+@Callable(i)
227+func addLiquidationOrder () = {
228+    let prevOrder = getCurrentDefaultOrder()
229+    internalAddLiquidationOrder(i, 100, prevOrder)
230+    }
231+
232+
233+
234+@Callable(i)
235+func cancelOrder (orderId) = {
236+    let owner = getOrderOwner(orderId)
237+    let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
238+    let caller = toString(i.caller)
239+    let nextOrder = getNextOrder(orderId)
240+    let prevOrder = getPrevOrder(orderId)
241+    if (isBlocked)
242+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions until reactivation by emergency oracles")
243+        else if ((owner != caller))
244+            then throw("permission denied")
245+            else if ((getOrderStatus(orderId) != NEW))
246+                then throw("invalid order status")
247+                else ScriptResult(WriteSet([DataEntry(CurrentDefaultOrderKey, computeCurrentDefaultOrder(orderId)), DataEntry(FirstOrderKey, if ((firstOrder == orderId))
248+                    then nextOrder
249+                    else firstOrder), DataEntry(getNextOrderKey(prevOrder), nextOrder), DataEntry(getPrevOrderKey(nextOrder), prevOrder), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, bondAssetId)]))
250+    }
251+
252+
253+
254+@Callable(i)
255+func liquidateBond () = {
256+    let liquidationBalance = assetBalance(this, neutrinoAssetId)
257+    let surplusPositive = if ((0 >= surplus))
258+        then 0
259+        else surplus
260+    let usdnAmount = if ((surplusPositive >= liquidationBalance))
261+        then liquidationBalance
262+        else surplusPositive
263+    let returnAmount = if ((surplusPositive >= liquidationBalance))
264+        then 0
265+        else (liquidationBalance - surplusPositive)
266+    if (isBlocked)
267+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions until reactivation by emergency oracles")
268+        else if ((liquidationBalance == 0))
269+            then throw("without base tokens to liquidate")
270+            else if ((returnAmount > 0))
271+                then TransferSet([ScriptTransfer(neutrinoContract, returnAmount, neutrinoAssetId)])
272+                else if ((firstOrder == ""))
273+                    then throw("empty orderbook")
274+                    else {
275+                        let nextOrder = getNextOrder(firstOrder)
276+                        let filledTotal = getOrderFilledTotal(firstOrder)
277+                        let orderPrice = getOrderPrice(firstOrder)
278+                        let remainedTotal = (getOrderTotal(firstOrder) - filledTotal)
279+                        let fillOrderCondition = (usdnAmount >= remainedTotal)
280+                        let fillableOrderAmount = if (fillOrderCondition)
281+                            then remainedTotal
282+                            else usdnAmount
283+                        let nbTokensLiquidateCondition = (fraction((surplus + neutrinoSupply), 100, neutrinoSupply) >= orderPrice)
284+                        if (!(nbTokensLiquidateCondition))
285+                            then throw(("innapropriate surplus: " + toString(surplus)))
286+                            else {
287+                                let newStatus = if (if (fillOrderCondition)
288+                                    then (remainedTotal == 0)
289+                                    else false)
290+                                    then FILLED
291+                                    else NEW
292+                                ScriptResult(WriteSet([DataEntry(getPrevOrderKey(nextOrder), if ((newStatus == FILLED))
293+                                    then ""
294+                                    else firstOrder), DataEntry(FirstOrderKey, if ((newStatus == FILLED))
295+                                    then nextOrder
296+                                    else firstOrder), DataEntry(getOrderFilledTotalKey(firstOrder), (filledTotal + fillableOrderAmount)), DataEntry(getOrderStatusKey(firstOrder), newStatus), DataEntry(CurrentDefaultOrderKey, computeCurrentDefaultOrder(firstOrder))]), TransferSet([ScriptTransfer(addressFromStringValue(getOrderOwner(firstOrder)), fillableOrderAmount, neutrinoAssetId), ScriptTransfer(neutrinoContract, fillableOrderAmount, bondAssetId)]))
297+                                }
298+                        }
299+    }
300+
301+
302+
303+@Callable(i)
304+func updateReservesAndNeutrinoSupply () = {
305+    func getNumberByKeyInternal (key) =         match getInteger(this, key) {
306+        case a: Int => 
307+            a
308+        case _ => 
309+            0
310+    }
311+
312+    let idx = getNumberByKeyInternal("updateReservesAndNeutrinoSupplyIdx")
313+    let newIdx = (idx + 1)
314+    WriteSet([DataEntry("updateReservesAndNeutrinoSupplyIdx", newIdx), DataEntry("reserve", reserve), DataEntry("neutrinoSupply", neutrinoSupply), DataEntry("surplus", surplus)])
315+    }
316+
317+
318+@Verifier(tx)
319+func verify () = {
320+    let pubKeyAdminsList = ["HBrpfZKJBpcfHmRJzvbm7eAxdYg5kvP67qoDt636hpcE", "FsDSmTj1ngRiQGNWYEJYzNZCSRFYzi4FvRMKGEXxDUbC", "EoaeH6Cax3obEMSzR6gtA5wS53ddK1M9QQfiz9bow4Jf", "5WRXFSjwcTbNfKcJs8ZqXmSSWYsSVJUtMvMqZj5hH4Nc"]
321+    let count = ((((if (sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(pubKeyAdminsList[0])))
322+        then 1
323+        else 0) + (if (sigVerify(tx.bodyBytes, tx.proofs[1], fromBase58String(pubKeyAdminsList[1])))
324+        then 1
325+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[2], fromBase58String(pubKeyAdminsList[2])))
326+        then 1
327+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[3], fromBase58String(pubKeyAdminsList[3])))
328+        then 2
329+        else 0))
330+    (count >= 3)
331+    }
332+
github/deemru/w8io/c3f4982 
25.68 ms ◑