tx · 3gaq31qmeTQRT9yen4xRN2ffenA8gdwVUYo4JTrQFzbF

3MugZ2TLyAMfGVZyWQAkjh2GGA4Ev7msLKs:  -0.01000000 Waves

2020.01.28 18:10 [874325] smart account 3MugZ2TLyAMfGVZyWQAkjh2GGA4Ev7msLKs > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "3gaq31qmeTQRT9yen4xRN2ffenA8gdwVUYo4JTrQFzbF",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1580224295086,
    "version": 1,
    "sender": "3MugZ2TLyAMfGVZyWQAkjh2GGA4Ev7msLKs",
    "senderPublicKey": "2P9aHmCd4D68vte56ag4dMUgkWhdd8Bk8FG87CEFZWsX",
    "proofs": [
        "4f6dcyLq3Q2UTbwk6L6DGMTQbnKFN8tWSjjbYKtm3fCR1fVWzZHVggyzLeirszHKaYcub9rrCyJRNka7vsbu5JxC"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 874325,
    "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 PriceKey = "price"
55+
56+let BondAssetIdKey = "bond_asset_id"
57+
58+let NeutrinoAssetIdKey = "neutrino_asset_id"
59+
60+let ControlContractKey = "control_contract"
61+
62+let BalanceLockedkKey = "balance_lock_"
63+
64+let WavesLockedBalanceKey = (BalanceLockedkKey + "waves")
65+
66+let NeutrinoLockedBalanceKey = (BalanceLockedkKey + "neutrino")
67+
68+let FirstOrderKey = "order_first"
69+
70+let LastOrderKey = "order_last"
71+
72+func getOrderPrevKey (orderId) = ("order_prev_" + orderId)
73+
74+
75+func getOrderNextKey (orderId) = ("order_next_" + orderId)
76+
77+
78+func getOrderTotalKey (orderId) = ("order_total_" + orderId)
79+
80+
81+func getOrderOwnerKey (orderId) = ("order_owner_" + orderId)
82+
83+
84+func getOrderHeightKey (orderId) = ("order_height_" + orderId)
85+
86+
87+func getOrderStatusKey (orderId) = ("order_status_" + orderId)
88+
89+
90+func getOrderFilledTotalKey (orderId) = ("order_filled_total_" + orderId)
91+
92+
93+func getLastOrderOwnerKey (owner) = ("last_order_owner_" + owner)
94+
95+
96+func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, 100, price), WAVELET, PAULI)
97+
98+
99+func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, 100), PAULI, WAVELET)
100+
101+
102+func convertNeutrinoToBond (amount) = (amount / PAULI)
103+
104+
105+func convertBondToNeutrino (amount) = (amount * PAULI)
106+
107+
108+func convertWavesToBond (amount,price) = convertNeutrinoToBond(convertWavesToNeutrino(amount, price))
109+
110+
111+let neutrinoContract = addressFromStringValue(getStringByKey(NeutrinoContractKey))
112+
113+let controlContract = addressFromStringValue(getStringByAddressAndKey(neutrinoContract, ControlContractKey))
114+
115+let liquidationContract = this
116+
117+let neutrinoAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, NeutrinoAssetIdKey))
118+
119+let bondAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, BondAssetIdKey))
120+
121+let firstOrder = getStringByKey(FirstOrderKey)
122+
123+let lastOrder = getStringByKey(LastOrderKey)
124+
125+let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
126+
127+let neutrinoLockedBalance = getNumberByAddressAndKey(neutrinoContract, NeutrinoLockedBalanceKey)
128+
129+let wavesLockedBalance = getNumberByAddressAndKey(neutrinoContract, WavesLockedBalanceKey)
130+
131+let reserve = (wavesBalance(neutrinoContract) - wavesLockedBalance)
132+
133+let neutrinoSupply = (((neutrinoLockedBalance + extract(assetInfo(neutrinoAssetId)).quantity) - assetBalance(neutrinoContract, neutrinoAssetId)) - assetBalance(liquidationContract, neutrinoAssetId))
134+
135+let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
136+
137+func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
138+
139+
140+func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
141+
142+
143+func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
144+
145+
146+func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
147+
148+
149+func getOrderPrev (id) = getStringByKey(getOrderPrevKey(id))
150+
151+
152+func getOrderNext (id) = getStringByKey(getOrderNextKey(id))
153+
154+
155+func getOrderHeight (id) = getNumberByKey(getOrderHeightKey(id))
156+
157+
158+func getLastOrderOwner (owner) = getStringByKey(getLastOrderOwnerKey(owner))
159+
160+
161+@Callable(i)
162+func addLiquidationOrder () = {
163+    let pmt = extract(i.payment)
164+    let newOrderId = toBase58String(keccak256((((toBytes(pmt.amount) + i.caller.bytes) + toBytes(height)) + i.transactionId)))
165+    let nextOrder = getOrderNext(lastOrder)
166+    let orderStatus = getOrderStatus(lastOrder)
167+    let owner = toString(i.caller)
168+    if ((pmt.assetId != bondAssetId))
169+        then throw("can use appropriate neutrino bonds tokens only")
170+        else if ((getOrderOwner(newOrderId) != ""))
171+            then throw("an order is already exists")
172+            else if ((nextOrder != ""))
173+                then throw(("nextOrder is not last. Info:" + nextOrder))
174+                else if (if ((firstOrder != ""))
175+                    then (lastOrder == "")
176+                    else false)
177+                    then throw("invalid last order")
178+                    else if (if ((firstOrder != ""))
179+                        then (orderStatus != NEW)
180+                        else false)
181+                        then throw("last order status is not new")
182+                        else WriteSet([DataEntry(getLastOrderOwnerKey(owner), newOrderId), DataEntry(getOrderPrevKey(newOrderId), lastOrder), DataEntry(getOrderNextKey(lastOrder), if ((lastOrder == ""))
183+                            then ""
184+                            else newOrderId), DataEntry(FirstOrderKey, if ((firstOrder == ""))
185+                            then newOrderId
186+                            else firstOrder), DataEntry(LastOrderKey, newOrderId), DataEntry(getOrderTotalKey(newOrderId), pmt.amount), DataEntry(getOrderOwnerKey(newOrderId), owner), DataEntry(getOrderHeightKey(newOrderId), height), DataEntry(getOrderStatusKey(newOrderId), NEW)])
187+    }
188+
189+
190+
191+@Callable(i)
192+func cancelOrder (orderId) = {
193+    let owner = getOrderOwner(orderId)
194+    let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
195+    let nextOrder = getOrderNext(orderId)
196+    let prevOrder = getOrderPrev(orderId)
197+    if ((owner != toString(i.caller)))
198+        then throw("permission denied")
199+        else if ((getOrderStatus(orderId) != NEW))
200+            then throw("invalid order status")
201+            else ScriptResult(WriteSet([DataEntry(FirstOrderKey, if ((firstOrder == orderId))
202+                then nextOrder
203+                else firstOrder), DataEntry(LastOrderKey, if ((lastOrder == orderId))
204+                then prevOrder
205+                else lastOrder), DataEntry(getOrderNextKey(prevOrder), nextOrder), DataEntry(getOrderPrevKey(nextOrder), prevOrder), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, bondAssetId)]))
206+    }
207+
208+
209+
210+@Callable(i)
211+func liquidateBond () = {
212+    let surplusPositive = if ((0 >= surplus))
213+        then 0
214+        else surplus
215+    let liquidationBalance = assetBalance(this, neutrinoAssetId)
216+    let returnAmount = if ((surplusPositive >= liquidationBalance))
217+        then 0
218+        else (liquidationBalance - surplusPositive)
219+    let surplusBond = convertNeutrinoToBond(surplusPositive)
220+    if (if ((returnAmount == 0))
221+        then (liquidationBalance == 0)
222+        else false)
223+        then throw("cannot liquidate order without neutrino on the smart contract")
224+        else if ((returnAmount > 0))
225+            then TransferSet([ScriptTransfer(neutrinoContract, returnAmount, neutrinoAssetId)])
226+            else if ((0 >= surplusBond))
227+                then throw("there is no proficit on the smart contract now")
228+                else if ((firstOrder == ""))
229+                    then throw("empty orderbook")
230+                    else {
231+                        let nextOrder = getOrderNext(firstOrder)
232+                        let orderTotal = getOrderTotal(firstOrder)
233+                        let orderOwner = getOrderOwner(firstOrder)
234+                        let filledTotal = getOrderFilledTotal(firstOrder)
235+                        let amount = (orderTotal - filledTotal)
236+                        let newStatus = if ((surplusBond >= amount))
237+                            then FILLED
238+                            else NEW
239+                        let fillableOrderAmount = if ((surplusBond >= amount))
240+                            then amount
241+                            else surplusBond
242+                        ScriptResult(WriteSet([DataEntry(getOrderPrevKey(nextOrder), if ((newStatus == FILLED))
243+                            then ""
244+                            else firstOrder), DataEntry(FirstOrderKey, if ((newStatus == FILLED))
245+                            then nextOrder
246+                            else firstOrder), DataEntry(LastOrderKey, if (if ((newStatus == FILLED))
247+                            then (firstOrder == lastOrder)
248+                            else false)
249+                            then ""
250+                            else lastOrder), DataEntry(getOrderFilledTotalKey(firstOrder), (filledTotal + fillableOrderAmount)), DataEntry(getOrderStatusKey(firstOrder), newStatus)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), convertBondToNeutrino(fillableOrderAmount), neutrinoAssetId)]))
251+                        }
252+    }
253+
254+
255+
256+@Callable(i)
257+func updateReservesAndNeutrinoSupply () = {
258+    let idx = getNumberByKey("updateReservesAndNeutrinoSupplyIdx")
259+    let newIdx = (idx + 1)
260+    WriteSet([DataEntry("updateReservesAndNeutrinoSupplyIdx", newIdx), DataEntry("reserve", reserve), DataEntry("neutrinoSupply", neutrinoSupply), DataEntry("surplus", surplus)])
261+    }
262+
263+
264+@Verifier(tx)
265+func verify () = {
266+    let pubKeyAdminsList = ["GhfjByrxpjDqQ9JvJoGjxG2WTguunR9sujsPM8qYh3nL", "6dpqiSXuBAM7x3nrD5VuCaYQb2cz1g4NooFDS1xGdCV6", "9EU95UGWLuccZCpPK3KBjhiq5CFapNs8QWxtHqjJ25cc", "5WRXFSjwcTbNfKcJs8ZqXmSSWYsSVJUtMvMqZj5hH4Nc"]
267+    let count = ((((if (sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(pubKeyAdminsList[0])))
268+        then 1
269+        else 0) + (if (sigVerify(tx.bodyBytes, tx.proofs[1], fromBase58String(pubKeyAdminsList[1])))
270+        then 1
271+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[2], fromBase58String(pubKeyAdminsList[2])))
272+        then 1
273+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[3], fromBase58String(pubKeyAdminsList[3])))
274+        then 2
275+        else 0))
276+    (count >= 3)
277+    }
278+
github/deemru/w8io/026f985 
38.79 ms ◑