tx · HJTy146V4iWR1wXF8WsQqaqkZst2TRD1Hr9EvwHNZeXM

3MyDtNTkCNyRCw3o2qv5BPPS7vvUosiQe6F:  -0.01000000 Waves

2019.10.22 00:06 [730357] smart account 3MyDtNTkCNyRCw3o2qv5BPPS7vvUosiQe6F > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HJTy146V4iWR1wXF8WsQqaqkZst2TRD1Hr9EvwHNZeXM",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1571692103288,
    "version": 1,
    "sender": "3MyDtNTkCNyRCw3o2qv5BPPS7vvUosiQe6F",
    "senderPublicKey": "3z5txV1G5GKezwMRCHZDkLThqb1Yggepxvi2wq6iP6oz",
    "proofs": [
        "599LBhAwRG5wKw3UdN244jBHv4qmf9Wm2DBbLDqT3HfuafKh1zya4zTVkE6zAmn7GZgQV3NTZ567dhMED6zoy8u"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 730357,
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: FuX67qawXudjpChrkZ4wfvRgFRVTWYLorMv36b3DmuaD

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 getBoolByKey (key) = match getBoolean(this, key) {
21+    case a: Boolean => 
22+        a
23+    case _ => 
24+        false
25+}
26+
27+
28+func getNumberByAddressAndKey (address,key) = match getInteger(addressFromStringValue(address), key) {
29+    case a: Int => 
30+        a
31+    case _ => 
32+        0
33+}
34+
35+
36+func getStringByAddressAndKey (address,key) = match getString(addressFromStringValue(address), key) {
37+    case a: String => 
38+        a
39+    case _ => 
40+        ""
41+}
42+
43+
44+func getBoolByAddressAndKey (address,key) = match getBoolean(addressFromStringValue(address), key) {
45+    case a: Boolean => 
46+        a
47+    case _ => 
48+        false
49+}
50+
51+
52+func isInt (val) = match val {
53+    case a: Int => 
54+        true
55+    case _ => 
56+        false
57+}
58+
59+
60+let LISTSPLITSYMBOL = "_"
61+
62+let LISTDATASYMBOL = "+"
63+
64+let WAVELET = 100000000
65+
66+let PAULI = 100
67+
68+let CRYTICALSHARE = 20
69+
70+let LEASINGSHARE = 50
71+
72+let CANCELED = "canceled"
73+
74+let NEW = "new"
75+
76+let FILLED = "filled"
77+
78+let NeutrinoAssetIdKey = "neutrino_asset_id"
79+
80+let BondAssetIdKey = "bond_asset_id"
81+
82+let AuctionContractKey = "auction_contract"
83+
84+let RPDContractKey = "rpd_contract"
85+
86+let ContolContractKey = "control_contract"
87+
88+let BalanceLockIntervalKey = "balance_lock_interval"
89+
90+let MinWavesSwapAmountKey = "min_waves_swap_amount"
91+
92+let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
93+
94+let NodeAddressKey = "node_address"
95+
96+let LeasingIntervalKey = "leasing_interval"
97+
98+let PriceKey = "price"
99+
100+let ScriptUpdateIntervalKey = "script_update_interval"
101+
102+let NeutrinoBalanceKey = "neutrino_"
103+
104+let WavesBalanceKey = "waves_"
105+
106+let BalanceUnlockBlockKey = "balance_block_"
107+
108+let OrderbookKey = "orderbook"
109+
110+let OrderTotalKey = "order_total_"
111+
112+let OrderOwnerKey = "order_owner_"
113+
114+let OrderHeightKey = "order_height_"
115+
116+let OrderFilledTotalKey = "order_filled_total_"
117+
118+let OrderStatusKey = "order_status_"
119+
120+let RPDSyncIndexKey = "rpd_sync_index"
121+
122+let RPDProfitKey = "rpd_profit"
123+
124+let RPDBalanceKey = "rpd_balance"
125+
126+let IsBlockedKey = "is_blocked"
127+
128+let IsLeasingProfitTxExistKey = "is_leasing_profit"
129+
130+let ScriptUpdateBlockKey = "script_update_block"
131+
132+let LeaseTxKey = "lease_tx"
133+
134+let LeaseTxHashKey = "lease_tx_hash"
135+
136+let LeasingAmountKey = "leasing_amount"
137+
138+let LeaseTxExpireSendBlockKey = "leasing_expire_send"
139+
140+let LeasingExpireBlockKey = "leasing_expire_block"
141+
142+let IsRebalanceKey = "is_rebalance"
143+
144+let SwapLockedBalanceKey = "swap_locked_balance"
145+
146+func getRPDSnapshotContractBalanceKey (count,assetId) = ((((RPDBalanceKey + "_") + toBase58String(assetId)) + "_") + toString(count))
147+
148+
149+func getRPDContractBalanceKey (assetId) = ((RPDBalanceKey + "_") + toBase58String(assetId))
150+
151+
152+func getRPDProfitKey (count) = ((RPDProfitKey + "_") + toString(count))
153+
154+
155+func getNeutrinoBalanceKey (owner) = (NeutrinoBalanceKey + owner)
156+
157+
158+func getWavesBalanceKey (owner) = (WavesBalanceKey + owner)
159+
160+
161+func getBalanceUnlockBlockKey (owner) = (BalanceUnlockBlockKey + owner)
162+
163+
164+func getOrderTotalKey (orderId) = (OrderTotalKey + orderId)
165+
166+
167+func getOrderOwnerKey (orderId) = (OrderOwnerKey + orderId)
168+
169+
170+func getOrderHeightKey (orderId) = (OrderHeightKey + orderId)
171+
172+
173+func getOrderStatusKey (orderId) = (OrderStatusKey + orderId)
174+
175+
176+func getOrderFilledTotalKey (orderId) = (OrderFilledTotalKey + orderId)
177+
178+
179+let controlContract = getStringByKey(ContolContractKey)
180+
181+let price = getNumberByAddressAndKey(controlContract, PriceKey)
182+
183+func convertNeutrinoToWaves (amount) = ((((amount * 100) / price) * WAVELET) / PAULI)
184+
185+
186+func convertWavesToNeutrino (amount) = ((((amount * price) / 100) * PAULI) / WAVELET)
187+
188+
189+func convertNeutrinoToBond (amount) = (amount / PAULI)
190+
191+
192+func convertBondToNeutrino (amount) = (amount * PAULI)
193+
194+
195+func convertWavesToBond (amount) = convertNeutrinoToBond(convertWavesToNeutrino(amount))
196+
197+
198+let isRebalance = getBoolByKey(IsRebalanceKey)
199+
200+let leasingInterval = getNumberByKey(LeasingIntervalKey)
201+
202+let leaseTxExpireSendBlock = getNumberByKey(LeaseTxExpireSendBlockKey)
203+
204+let leasingExpireBlock = getNumberByKey(LeasingExpireBlockKey)
205+
206+let leaseTxHash = getStringByKey(LeaseTxHashKey)
207+
208+let leaseTxBytes = getStringByKey(LeaseTxKey)
209+
210+let leasingAmount = getNumberByKey(LeasingAmountKey)
211+
212+let swapLockedBalance = getNumberByKey(SwapLockedBalanceKey)
213+
214+let nodeAddress = getStringByKey(NodeAddressKey)
215+
216+let scriptUpdateInterval = getNumberByAddressAndKey(ContolContractKey, ScriptUpdateIntervalKey)
217+
218+let scriptUpdateBlock = getNumberByAddressAndKey(controlContract, ScriptUpdateBlockKey)
219+
220+let rpdSyncIndex = getNumberByKey(RPDSyncIndexKey)
221+
222+let balanceLockInterval = getNumberByKey(BalanceLockIntervalKey)
223+
224+let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
225+
226+let minWavesSwapAmount = getNumberByKey(MinWavesSwapAmountKey)
227+
228+let minNeutrinoSwapAmount = getNumberByKey(MinNeutrinoSwapAmountKey)
229+
230+let neutrinoAssetId = fromBase58String(getStringByKey(NeutrinoAssetIdKey))
231+
232+let auctionContract = getStringByKey(AuctionContractKey)
233+
234+let rpdContract = getStringByKey(RPDContractKey)
235+
236+let reserve = (wavesBalance(this) - swapLockedBalance)
237+
238+let reserveWithoutLeasing = ((wavesBalance(this) - (leasingAmount * (if (isInt(transactionHeightById(fromBase58String(leaseTxHash))))
239+    then 1
240+    else 0))) - swapLockedBalance)
241+
242+let orderbook = getStringByKey(OrderbookKey)
243+
244+let bondAssetId = fromBase58String(getStringByKey(BondAssetIdKey))
245+
246+let bondSupply = {
247+    let info = extract(assetInfo(bondAssetId))
248+    (info.quantity - assetBalance(this, bondAssetId))
249+    }
250+
251+let neutrinoSupply = {
252+    let info = extract(assetInfo(neutrinoAssetId))
253+    (info.quantity - assetBalance(this, neutrinoAssetId))
254+    }
255+
256+let surplus = (convertWavesToNeutrino(reserve) - neutrinoSupply)
257+
258+let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve))
259+
260+func getRPDContractBalance (assetId) = getNumberByAddressAndKey(rpdContract, getRPDContractBalanceKey(assetId))
261+
262+
263+func getWavesBalance (owner) = getNumberByKey(getWavesBalanceKey(owner))
264+
265+
266+func getNeutrinoBalance (owner) = getNumberByKey(getNeutrinoBalanceKey(owner))
267+
268+
269+func getUnlockBalanceBlock (owner) = getNumberByKey(getBalanceUnlockBlockKey(owner))
270+
271+
272+func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
273+
274+
275+func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
276+
277+
278+func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
279+
280+
281+func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
282+
283+
284+func getRPDProfit (count) = getNumberByKey(getRPDProfitKey(count))
285+
286+
287+func getOrderElementById (id) = (id + LISTSPLITSYMBOL)
288+
289+
290+func addOrder (orderId) = (orderbook + getOrderElementById(orderId))
291+
292+
293+func dropOrder (orderId) = {
294+    let parts = split(orderbook, getOrderElementById(orderId))
295+    (parts[0] + parts[1])
296+    }
297+
298+
299+@Callable(i)
300+func setPrice () = WriteSet([DataEntry(PriceKey, price)])
301+
302+
303+
304+@Callable(i)
305+func swapWavesToNeutrino () = {
306+    let pmt = extract(i.payment)
307+    if ((minWavesSwapAmount > pmt.amount))
308+        then throw("amount less min")
309+        else if (isDefined(pmt.assetId))
310+            then throw("can use waves only")
311+            else if (isBlocked)
312+                then throw("contract is blocked")
313+                else {
314+                    let amount = convertWavesToNeutrino(pmt.amount)
315+                    TransferSet([ScriptTransfer(i.caller, amount, neutrinoAssetId)])
316+                    }
317+    }
318+
319+
320+
321+@Callable(i)
322+func swapNeutrinoToWaves () = {
323+    let pmt = extract(i.payment)
324+    if ((minNeutrinoSwapAmount > pmt.amount))
325+        then throw("amount less min")
326+        else if (isBlocked)
327+            then throw("contract is blocked")
328+            else if ((pmt.assetId != neutrinoAssetId))
329+                then throw("can use neutrino only")
330+                else {
331+                    let account = toBase58String(i.caller.bytes)
332+                    let amount = convertNeutrinoToWaves(pmt.amount)
333+                    WriteSet([DataEntry(getWavesBalanceKey(account), (getWavesBalance(account) + amount)), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceLockInterval)), DataEntry(IsRebalanceKey, (((reserve * CRYTICALSHARE) / 100) >= (reserveWithoutLeasing - amount))), DataEntry(SwapLockedBalanceKey, (swapLockedBalance + amount))])
334+                    }
335+    }
336+
337+
338+
339+@Callable(i)
340+func withdraw (account) = if ((getUnlockBalanceBlock(account) > height))
341+    then throw("wait a couple of blocks for withdraw")
342+    else ScriptResult(WriteSet([DataEntry(getWavesBalanceKey(account), 0), DataEntry(getNeutrinoBalanceKey(account), 0), DataEntry(SwapLockedBalanceKey, (swapLockedBalance - getWavesBalance(account)))]), TransferSet([ScriptTransfer(addressFromStringValue(account), getNeutrinoBalance(account), neutrinoAssetId), ScriptTransfer(addressFromStringValue(account), getWavesBalance(account), unit)]))
343+
344+
345+
346+@Callable(i)
347+func generateBond () = {
348+    let balanceAuction = assetBalance(addressFromStringValue(auctionContract), bondAssetId)
349+    let amount = (convertNeutrinoToBond(deficit) - balanceAuction)
350+    if (isBlocked)
351+        then throw("contract is blocked")
352+        else if ((amount >= 10))
353+            then TransferSet([ScriptTransfer(addressFromStringValue(auctionContract), amount, bondAssetId)])
354+            else throw("bond were generated or do not need it")
355+    }
356+
357+
358+
359+@Callable(i)
360+func setOrder () = {
361+    let pmt = extract(i.payment)
362+    let newOrderId = toBase58String(keccak256(((toBytes(pmt.amount) + i.caller.bytes) + toBytes(height))))
363+    if ((pmt.assetId != bondAssetId))
364+        then throw("can use bond only")
365+        else if ((getOrderOwner(newOrderId) != ""))
366+            then throw("order exists")
367+            else WriteSet([DataEntry(OrderbookKey, addOrder(newOrderId)), DataEntry(getOrderTotalKey(newOrderId), pmt.amount), DataEntry(getOrderOwnerKey(newOrderId), toString(i.caller)), DataEntry(getOrderHeightKey(newOrderId), height), DataEntry(getOrderStatusKey(newOrderId), NEW)])
368+    }
369+
370+
371+
372+@Callable(i)
373+func cancelOrder (orderId) = {
374+    let owner = getOrderOwner(orderId)
375+    let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
376+    if ((owner != toString(i.caller)))
377+        then throw("permission denied")
378+        else if ((getOrderStatus(orderId) != NEW))
379+            then throw("invalid order status")
380+            else ScriptResult(WriteSet([DataEntry(OrderbookKey, dropOrder(orderId)), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, bondAssetId)]))
381+    }
382+
383+
384+
385+@Callable(i)
386+func executeOrder () = {
387+    let orderId = split(orderbook, LISTSPLITSYMBOL)[0]
388+    let orderTotal = getOrderTotal(orderId)
389+    let orderOwner = getOrderOwner(orderId)
390+    let filledTotal = getOrderFilledTotal(orderId)
391+    let surplusBond = convertNeutrinoToBond(surplus)
392+    if (isBlocked)
393+        then throw("contract is blocked")
394+        else if ((0 >= surplusBond))
395+            then throw("surplus is less than zero")
396+            else if (if ((orderOwner == ""))
397+                then (surplusBond >= 10)
398+                else false)
399+                then {
400+                    let newRpdSyncIndex = (rpdSyncIndex + 1)
401+                    ScriptResult(WriteSet([DataEntry(RPDSyncIndexKey, newRpdSyncIndex), DataEntry(getRPDProfitKey(rpdSyncIndex), surplus), DataEntry(getRPDSnapshotContractBalanceKey(rpdSyncIndex, neutrinoAssetId), getRPDContractBalance(neutrinoAssetId))]), TransferSet([ScriptTransfer(addressFromStringValue(rpdContract), surplus, neutrinoAssetId)]))
402+                    }
403+                else {
404+                    let amount = (orderTotal - filledTotal)
405+                    let status = if ((surplusBond >= amount))
406+                        then FILLED
407+                        else NEW
408+                    let newFilledTotal = if ((surplusBond >= amount))
409+                        then orderTotal
410+                        else surplusBond
411+                    ScriptResult(WriteSet([DataEntry(OrderbookKey, if ((surplusBond >= amount))
412+                        then dropOrder(orderId)
413+                        else orderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + newFilledTotal)), DataEntry(getOrderStatusKey(orderId), status)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), convertBondToNeutrino(newFilledTotal), neutrinoAssetId)]))
414+                    }
415+    }
416+
417+
418+
419+@Callable(i)
420+func transfer (account) = {
421+    let pmt = extract(i.payment)
422+    if (isDefined(pmt.assetId))
423+        then throw("can use waves only at the moment")
424+        else TransferSet([ScriptTransfer(addressFromStringValue(account), pmt.amount, unit)])
425+    }
426+
427+
428+
429+@Callable(i)
430+func nodeReward () = {
431+    let pmt = value(i.payment)
432+    if ((i.caller != addressFromStringValue(nodeAddress)))
433+        then throw("permission denied")
434+        else if (isDefined(pmt.assetId))
435+            then throw("waves only")
436+            else {
437+                let amount = convertWavesToNeutrino(pmt.amount)
438+                let newRpdSyncIndex = (rpdSyncIndex + 1)
439+                ScriptResult(WriteSet([DataEntry(RPDSyncIndexKey, newRpdSyncIndex), DataEntry(getRPDProfitKey(rpdSyncIndex), amount), DataEntry(getRPDSnapshotContractBalanceKey(rpdSyncIndex, neutrinoAssetId), getRPDContractBalance(neutrinoAssetId))]), TransferSet([ScriptTransfer(addressFromStringValue(rpdContract), amount, neutrinoAssetId)]))
440+                }
441+    }
442+
443+
444+
445+@Callable(i)
446+func registrationLeaseTx (senderPublicKey,amount,fee,timestamp) = {
447+    let txBytes = (((((base58'3h1H' + fromBase58String(senderPublicKey)) + fromBase58String(nodeAddress)) + toBytes(amount)) + toBytes(fee)) + toBytes(timestamp))
448+    let balance = ((reserve * LEASINGSHARE) / 100)
449+    let txHashBytes = blake2b256(txBytes)
450+    let txHash = toBase58String(txHashBytes)
451+    if ((this != addressFromPublicKey(fromBase58String(senderPublicKey))))
452+        then throw("invalid pubKey")
453+        else if (if ((lastBlock.timestamp > timestamp))
454+            then true
455+            else (timestamp > (lastBlock.timestamp + 5400000)))
456+            then throw((("invalid timestamp(lastBlock: " + toString(lastBlock.timestamp)) + ")"))
457+            else if (if ((leaseTxHash != ""))
458+                then if (isInt(transactionHeightById(fromBase58String(leaseTxHash))))
459+                    then true
460+                    else (leaseTxExpireSendBlock >= height)
461+                else false)
462+                then throw("leasing not canceled")
463+                else if (if ((fee > 1000000))
464+                    then true
465+                    else (500000 > fee))
466+                    then throw("invalid fee")
467+                    else if (if ((amount != balance))
468+                        then true
469+                        else (amount == 0))
470+                        then throw((("invalid amount(leaseAmount:" + toString(balance)) + ")"))
471+                        else WriteSet([DataEntry(LeaseTxKey, toBase64String(txBytes)), DataEntry(LeaseTxHashKey, txHash), DataEntry(LeasingAmountKey, balance), DataEntry(LeaseTxExpireSendBlockKey, (height + 30)), DataEntry(LeasingExpireBlockKey, (height + leasingInterval))])
472+    }
473+
474+
475+
476+@Callable(i)
477+func registrationUnleaseTx (chainIdString,senderPublicKey,fee,timestamp) = {
478+    let txBytes = (((((base58'gm' + toBytes(chainIdString)) + fromBase58String(senderPublicKey)) + toBytes(fee)) + toBytes(timestamp)) + fromBase58String(leaseTxHash))
479+    let txHash = blake2b256(txBytes)
480+    if ((this != addressFromPublicKey(fromBase58String(senderPublicKey))))
481+        then throw("invalid pubKey")
482+        else if (!(isInt(transactionHeightById(txHash))))
483+            then throw("blockchain does not contain this transaction")
484+            else WriteSet([DataEntry(LeaseTxKey, ""), DataEntry(LeaseTxHashKey, ""), DataEntry(LeasingAmountKey, 0), DataEntry(LeaseTxExpireSendBlockKey, 0), DataEntry(LeasingExpireBlockKey, 0), DataEntry(IsRebalanceKey, false)])
485+    }
486+
487+
488+@Verifier(tx)
489+func verify () = match tx {
490+    case leaseTx: LeaseTransaction => 
491+        if (if ((fromBase58String(leaseTxHash) == leaseTx.id))
492+            then (leasingExpireBlock >= height)
493+            else false)
494+            then (leaseTxExpireSendBlock >= height)
495+            else false
496+    case unleaseTx: LeaseCancelTransaction => 
497+        if (if ((fromBase58String(leaseTxHash) == unleaseTx.leaseId))
498+            then if ((height > leasingExpireBlock))
499+                then true
500+                else isRebalance
501+            else false)
502+            then if ((unleaseTx.fee >= 500000))
503+                then (1000000 >= unleaseTx.fee)
504+                else false
505+            else false
506+    case _ => 
507+        sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
508+}
509+
github/deemru/w8io/873ac7e 
38.08 ms ◑