tx · BRCYjwm4voPhGPrzL4th1RHLQYvxYfx9WXinLXAcgCTr

3Mpm7DMEeq2x3sfV6GjfHR1YBBPE25enpEb:  -0.01000000 Waves

2019.12.24 17:24 [823202] smart account 3Mpm7DMEeq2x3sfV6GjfHR1YBBPE25enpEb > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BRCYjwm4voPhGPrzL4th1RHLQYvxYfx9WXinLXAcgCTr",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1577197454748,
    "version": 1,
    "sender": "3Mpm7DMEeq2x3sfV6GjfHR1YBBPE25enpEb",
    "senderPublicKey": "3GankTKvWzm8KcxAUcBiyRMaukR5gNSD94QmY1tkz1rt",
    "proofs": [
        "1yopMZQFv9nXXQ2eoGnA48hDkY5kyJz5Aag8UYCcVCNhpEKo5G2sPeAtmNat6fo2byHVt6LhfYw73WNgT6AZyE6"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 823202,
    "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+let LastConfirmTxKey = "last_confirm_tx"
71+
72+func getOrderTotalKey (orderId) = ("order_total_" + orderId)
73+
74+
75+func getOrderOwnerKey (orderId) = ("order_owner_" + orderId)
76+
77+
78+func getOrderHeightKey (orderId) = ("order_height_" + orderId)
79+
80+
81+func getOrderStatusKey (orderId) = ("order_status_" + orderId)
82+
83+
84+func getOrderFilledTotalKey (orderId) = ("order_filled_total_" + orderId)
85+
86+
87+func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, 100, price), WAVELET, PAULI)
88+
89+
90+func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, 100), PAULI, WAVELET)
91+
92+
93+func convertNeutrinoToBond (amount) = (amount / PAULI)
94+
95+
96+func convertBondToNeutrino (amount) = (amount * PAULI)
97+
98+
99+func convertWavesToBond (amount,price) = convertNeutrinoToBond(convertWavesToNeutrino(amount, price))
100+
101+
102+func convertJsonArrayToList (jsonArray) = split(jsonArray, ",")
103+
104+
105+let orderbook = getStringByKey(OrderbookKey)
106+
107+let neutrinoContract = addressFromStringValue(getStringByKey(NeutrinoContractKey))
108+
109+let controlContract = addressFromStringValue(getStringByAddressAndKey(neutrinoContract, ControlContractKey))
110+
111+let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
112+
113+let neutrinoLockedBalance = getNumberByAddressAndKey(neutrinoContract, NeutrinoLockedBalanceKey)
114+
115+let wavesLockedBalance = getNumberByAddressAndKey(neutrinoContract, WavesLockedBalanceKey)
116+
117+let neutrinoAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, NeutrinoAssetIdKey))
118+
119+let bondAssetId = fromBase58String(getStringByAddressAndKey(neutrinoContract, BondAssetIdKey))
120+
121+let reserve = (wavesBalance(neutrinoContract) - wavesLockedBalance)
122+
123+let neutrinoSupply = (((extract(assetInfo(neutrinoAssetId)).quantity - assetBalance(neutrinoContract, neutrinoAssetId)) + neutrinoLockedBalance) - assetBalance(this, neutrinoAssetId))
124+
125+let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
126+
127+let lastConfirmTx = getStringByAddressAndKey(controlContract, LastConfirmTxKey)
128+
129+func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
130+
131+
132+func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
133+
134+
135+func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
136+
137+
138+func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
139+
140+
141+func getOrderElementById (id) = (id + ORDERSPLITSYMBOL)
142+
143+
144+func addOrder (orderId,position) = {
145+    let orders = split(orderbook, ORDERSPLITSYMBOL)
146+    let newOrder = getOrderElementById(orderId)
147+    if ((position == 0))
148+        then (newOrder + orderbook)
149+        else if ((position >= (size(orders) - 1)))
150+            then (orderbook + newOrder)
151+            else {
152+                let parts = split(orderbook, getOrderElementById(orders[position]))
153+                (((parts[0] + newOrder) + getOrderElementById(orders[position])) + parts[1])
154+                }
155+    }
156+
157+
158+func dropOrder (orderId) = {
159+    let parts = split(orderbook, getOrderElementById(orderId))
160+    (parts[0] + parts[1])
161+    }
162+
163+
164+func getOrdersInOrderbook (orderbook) = split(orderbook, ORDERSPLITSYMBOL)
165+
166+
167+@Callable(i)
168+func addLiquidationOrder () = {
169+    let pmt = extract(i.payment)
170+    let newOrderId = toBase58String(keccak256(((toBytes(pmt.amount) + i.caller.bytes) + toBytes(height))))
171+    if ((pmt.assetId != bondAssetId))
172+        then throw("can use appropriate neutrino bonds tokens only")
173+        else if ((getOrderOwner(newOrderId) != ""))
174+            then throw("an order is already exists")
175+            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)])
176+    }
177+
178+
179+
180+@Callable(i)
181+func cancelOrder (orderId) = {
182+    let owner = getOrderOwner(orderId)
183+    let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
184+    if ((owner != toString(i.caller)))
185+        then throw("permission denied")
186+        else if ((getOrderStatus(orderId) != NEW))
187+            then throw("invalid order status")
188+            else ScriptResult(WriteSet([DataEntry(OrderbookKey, dropOrder(orderId)), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, bondAssetId)]))
189+    }
190+
191+
192+
193+@Callable(i)
194+func liquidateBond () = {
195+    let surplusBond = convertNeutrinoToBond(surplus)
196+    let neutrinoBalance = assetBalance(this, neutrinoAssetId)
197+    let surplusPositive = if ((0 >= surplus))
198+        then 0
199+        else surplus
200+    let bondAmount = if ((surplusPositive >= neutrinoBalance))
201+        then neutrinoBalance
202+        else surplusPositive
203+    let returnAmount = if ((surplusPositive >= neutrinoBalance))
204+        then 0
205+        else (neutrinoBalance - surplusPositive)
206+    if (if ((returnAmount == 0))
207+        then (neutrinoBalance == 0)
208+        else false)
209+        then throw("without surplus")
210+        else if (if ((0 >= surplusBond))
211+            then (returnAmount > 0)
212+            else false)
213+            then TransferSet([ScriptTransfer(neutrinoContract, returnAmount, neutrinoAssetId)])
214+            else if ((0 >= surplusBond))
215+                then throw("there is no proficit on the smart contract now")
216+                else if ((orderbook == ""))
217+                    then throw("empty orderbook")
218+                    else {
219+                        let orderId = getOrdersInOrderbook(orderbook)[0]
220+                        let orderTotal = getOrderTotal(orderId)
221+                        let orderOwner = getOrderOwner(orderId)
222+                        let filledTotal = getOrderFilledTotal(orderId)
223+                        let amount = (orderTotal - filledTotal)
224+                        let status = if ((surplusBond >= amount))
225+                            then FILLED
226+                            else NEW
227+                        let newTotal = if ((surplusBond >= amount))
228+                            then amount
229+                            else surplusBond
230+                        ScriptResult(WriteSet([DataEntry(OrderbookKey, if ((status == FILLED))
231+                            then dropOrder(orderId)
232+                            else orderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + newTotal)), DataEntry(getOrderStatusKey(orderId), status)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), convertBondToNeutrino(newTotal), neutrinoAssetId), ScriptTransfer(neutrinoContract, returnAmount, neutrinoAssetId)]))
233+                        }
234+    }
235+
236+
github/deemru/w8io/169f3d6 
24.12 ms ◑