tx · DYWQSbrtZ6iZ7Fozn7CeMSG2gjvGixYKFbpuz129iKwb

3N7rQQFZri7Npqi1fw9VnxyHYbHf1BHK1qt:  -0.01000000 Waves

2019.11.14 16:18 [764791] smart account 3N7rQQFZri7Npqi1fw9VnxyHYbHf1BHK1qt > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DYWQSbrtZ6iZ7Fozn7CeMSG2gjvGixYKFbpuz129iKwb",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1573737568056,
    "version": 1,
    "sender": "3N7rQQFZri7Npqi1fw9VnxyHYbHf1BHK1qt",
    "senderPublicKey": "TUCfRvTEQ2c1bmmjKdf1xLAySC45XZs1Xaf7arEjSiv",
    "proofs": [
        "CLDdVakZuRZc7oYkxh56JhQ6rV8jJc93THRgiLbkKun84JufkS8Lv1imWmMWidnLQL39RkQLQGtz7REK2om6ga4"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 764791,
    "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 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+let SENDTXEXPIRE = 30
53+
54+let LISTSPLITSYMBOL = "_"
55+
56+let LISTDATASYMBOL = "+"
57+
58+let WAVELET = 100000000
59+
60+let PAULI = 100
61+
62+let CRITICALSHARE = 20
63+
64+let LEASINGSHARE = 90
65+
66+let LEASINGTXCOUNT = 10
67+
68+let CANCELED = "canceled"
69+
70+let NEW = "new"
71+
72+let FILLED = "filled"
73+
74+let DEFICITOFFSET = 10
75+
76+let NeutrinoAssetIdKey = "neutrino_asset_id"
77+
78+let BondAssetIdKey = "bond_asset_id"
79+
80+let ReserveContractKey = "reserve_contract"
81+
82+let AuctionContractKey = "auction_contract"
83+
84+let RPDContractKey = "rpd_contract"
85+
86+let ControlContractKey = "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 NodeOracleProviderKey = "oracle_node_provider"
97+
98+let LeasingIntervalKey = "leasing_interval"
99+
100+let PriceKey = "price"
101+
102+let PriceIndexKey = "price_index"
103+
104+let ScriptUpdateIntervalKey = "script_update_interval"
105+
106+let NeutrinoBalanceKey = "neutrino_"
107+
108+let BalanceUnlockBlockKey = "balance_block_"
109+
110+let OrderbookKey = "orderbook"
111+
112+let OrderTotalKey = "order_total_"
113+
114+let OrderOwnerKey = "order_owner_"
115+
116+let OrderHeightKey = "order_height_"
117+
118+let OrderFilledTotalKey = "order_filled_total_"
119+
120+let OrderStatusKey = "order_status_"
121+
122+let RPDSyncIndexKey = "rpd_sync_index"
123+
124+let RPDProfitKey = "rpd_profit"
125+
126+let RPDBalanceKey = "rpd_balance"
127+
128+let IsBlockedKey = "is_blocked"
129+
130+let IsLeasingProfitTxExistKey = "is_leasing_profit"
131+
132+let ScriptUpdateBlockKey = "script_update_block"
133+
134+let LeaseTxKey = "lease_tx"
135+
136+let LeaseTxStatusKey = "lease_tx_status"
137+
138+let LeasingAmountKey = "leasing_amount"
139+
140+let LeaseTxExpireSendBlockKey = "leasing_expire_send"
141+
142+let LeasingExpireBlockKey = "leasing_expire_block"
143+
144+let IsRebalanceKey = "is_rebalance"
145+
146+let SwapNeutrinoLockedBalanceKey = "swap_neutrino_locked_balance"
147+
148+let LeasingTxCountKey = "leasing_index"
149+
150+let CancelLeaseTxReserveFeeKey = "cancel_lease_tx_reserve_fee"
151+
152+func getRPDSnapshotContractBalanceKey (count,assetId) = ((((RPDBalanceKey + "_") + toBase58String(assetId)) + "_") + toString(count))
153+
154+
155+func getRPDContractBalanceKey (assetId) = ((RPDBalanceKey + "_") + toBase58String(assetId))
156+
157+
158+func getRPDProfitKey (count) = ((RPDProfitKey + "_") + toString(count))
159+
160+
161+func getNeutrinoBalanceKey (owner) = (NeutrinoBalanceKey + owner)
162+
163+
164+func getBalanceUnlockBlockKey (owner) = (BalanceUnlockBlockKey + owner)
165+
166+
167+func getOrderTotalKey (orderId) = (OrderTotalKey + orderId)
168+
169+
170+func getOrderOwnerKey (orderId) = (OrderOwnerKey + orderId)
171+
172+
173+func getOrderHeightKey (orderId) = (OrderHeightKey + orderId)
174+
175+
176+func getOrderStatusKey (orderId) = (OrderStatusKey + orderId)
177+
178+
179+func getOrderFilledTotalKey (orderId) = (OrderFilledTotalKey + orderId)
180+
181+
182+func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
183+
184+
185+func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
186+
187+
188+func getLeaseTxStatusKey (hash) = ((LeaseTxStatusKey + "_") + hash)
189+
190+
191+func getLeaseTxAmountByHashKey (hash) = ((LeasingAmountKey + "_") + hash)
192+
193+
194+func getLeaseTxBytesByHashKey (hash) = ((LeaseTxKey + "_") + hash)
195+
196+
197+func getLeaseTxExpireSendBlockKey (hash) = ((LeaseTxExpireSendBlockKey + "_") + hash)
198+
199+
200+func getCancelLeaseTxReserveFeeKey (hash) = ((CancelLeaseTxReserveFeeKey + "_") + hash)
201+
202+
203+let neutrinoAssetId = fromBase58String(getStringByKey(NeutrinoAssetIdKey))
204+
205+let reserveContract = getStringByKey(ReserveContractKey)
206+
207+let auctionContract = getStringByKey(AuctionContractKey)
208+
209+let rpdContract = getStringByKey(RPDContractKey)
210+
211+let controlContract = getStringByKey(ControlContractKey)
212+
213+let price = getNumberByAddressAndKey(controlContract, PriceKey)
214+
215+let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
216+
217+func convertNeutrinoToWavesByPrice (amount,convertPrice) = ((((amount * 100) / convertPrice) * WAVELET) / PAULI)
218+
219+
220+func convertNeutrinoToWaves (amount) = ((((amount * 100) / price) * WAVELET) / PAULI)
221+
222+
223+func convertWavesToNeutrino (amount) = ((((amount * price) / 100) * PAULI) / WAVELET)
224+
225+
226+func convertNeutrinoToBond (amount) = (amount / PAULI)
227+
228+
229+func convertBondToNeutrino (amount) = (amount * PAULI)
230+
231+
232+func convertWavesToBond (amount) = convertNeutrinoToBond(convertWavesToNeutrino(amount))
233+
234+
235+let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
236+
237+let leasingTxCount = getNumberByKey(LeasingTxCountKey)
238+
239+let isRebalance = getBoolByKey(IsRebalanceKey)
240+
241+let leasingInterval = getNumberByKey(LeasingIntervalKey)
242+
243+let leasingExpireBlock = getNumberByKey(LeasingExpireBlockKey)
244+
245+let leasingAmount = getNumberByKey(LeasingAmountKey)
246+
247+let swapNeutrinoLockedBalance = getNumberByKey(SwapNeutrinoLockedBalanceKey)
248+
249+let nodeAddress = getStringByKey(NodeAddressKey)
250+
251+let nodeOracleProviderKey = getStringByKey(NodeOracleProviderKey)
252+
253+let rpdSyncIndex = getNumberByKey(RPDSyncIndexKey)
254+
255+let balanceLockInterval = getNumberByKey(BalanceLockIntervalKey)
256+
257+let minWavesSwapAmount = getNumberByKey(MinWavesSwapAmountKey)
258+
259+let minNeutrinoSwapAmount = getNumberByKey(MinNeutrinoSwapAmountKey)
260+
261+let reserve = wavesBalance(this)
262+
263+let reserveWithoutLeasing = (reserve - leasingAmount)
264+
265+let orderbook = getStringByKey(OrderbookKey)
266+
267+let bondAssetId = fromBase58String(getStringByKey(BondAssetIdKey))
268+
269+let bondSupply = {
270+    let info = extract(assetInfo(bondAssetId))
271+    (info.quantity - assetBalance(this, bondAssetId))
272+    }
273+
274+let neutrinoSupply = {
275+    let info = extract(assetInfo(neutrinoAssetId))
276+    ((info.quantity - assetBalance(this, neutrinoAssetId)) + swapNeutrinoLockedBalance)
277+    }
278+
279+let surplus = (convertWavesToNeutrino(reserve) - neutrinoSupply)
280+
281+let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve))
282+
283+func getRPDContractBalance (assetId) = getNumberByAddressAndKey(rpdContract, getRPDContractBalanceKey(assetId))
284+
285+
286+func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
287+
288+
289+func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
290+
291+
292+func getCancelLeaseTxReserveFee (hash) = getNumberByKey(getCancelLeaseTxReserveFeeKey(hash))
293+
294+
295+func getNeutrinoBalance (owner) = getNumberByKey(getNeutrinoBalanceKey(owner))
296+
297+
298+func getUnlockBalanceBlock (owner) = getNumberByKey(getBalanceUnlockBlockKey(owner))
299+
300+
301+func getOrderTotal (id) = getNumberByKey(getOrderTotalKey(id))
302+
303+
304+func getOrderOwner (id) = getStringByKey(getOrderOwnerKey(id))
305+
306+
307+func getOrderStatus (id) = getStringByKey(getOrderStatusKey(id))
308+
309+
310+func getOrderFilledTotal (id) = getNumberByKey(getOrderFilledTotalKey(id))
311+
312+
313+func getRPDProfit (count) = getNumberByKey(getRPDProfitKey(count))
314+
315+
316+func getLeaseTxStatus (hash) = getStringByKey(getLeaseTxStatusKey(hash))
317+
318+
319+func getLeaseTxAmountByHash (hash) = getNumberByKey(getLeaseTxAmountByHashKey(hash))
320+
321+
322+func getLeaseTxBytesByHash (hash) = getStringByKey(getLeaseTxBytesByHashKey(hash))
323+
324+
325+func getLeaseTxExpireSendBlock (hash) = getNumberByKey(getLeaseTxExpireSendBlockKey(hash))
326+
327+
328+func getOrderElementById (id) = (id + LISTSPLITSYMBOL)
329+
330+
331+func addOrder (orderId) = (orderbook + getOrderElementById(orderId))
332+
333+
334+func dropOrder (orderId) = {
335+    let parts = split(orderbook, getOrderElementById(orderId))
336+    (parts[0] + parts[1])
337+    }
338+
339+
340+@Callable(i)
341+func swapWavesToNeutrino () = {
342+    let pmt = extract(i.payment)
343+    if ((minWavesSwapAmount > pmt.amount))
344+        then throw((("The specified Waves amount is less than the required minimum of " + toString(minWavesSwapAmount)) + " wavelets."))
345+        else if (isDefined(pmt.assetId))
346+            then throw("Only Waves token is allowed for swapping.")
347+            else if (isBlocked)
348+                then throw("The contract is blocked by EMERGENCY SHUTDOWN. Please wait for reactivation by emergency oracles.")
349+                else {
350+                    let amount = convertWavesToNeutrino(pmt.amount)
351+                    TransferSet([ScriptTransfer(i.caller, amount, neutrinoAssetId)])
352+                    }
353+    }
354+
355+
356+
357+@Callable(i)
358+func swapNeutrinoToWaves () = {
359+    let pmt = extract(i.payment)
360+    let account = toString(i.caller)
361+    if ((minNeutrinoSwapAmount > pmt.amount))
362+        then throw((("The specified Neutrino amount is less than the required minimum of " + toString(minNeutrinoSwapAmount)) + " Neutrino cents."))
363+        else if (isBlocked)
364+            then throw("The contract is blocked by EMERGENCY SHUTDOWN. Please wait for reactivation by emergency oracles.")
365+            else if ((pmt.assetId != neutrinoAssetId))
366+                then throw("Only appropriate Neutrino tokens are allowed for swapping.")
367+                else if ((getUnlockBalanceBlock(account) > height))
368+                    then throw((("Please wait for " + toString((getUnlockBalanceBlock(account) - height))) + " blocks to complete."))
369+                    else if ((getNeutrinoBalance(account) != 0))
370+                        then throw("Please withdraw locked Neutrinos first.")
371+                        else {
372+                            let neutrinoAmount = pmt.amount
373+                            let newSwapNeutrinoLockedBalance = (swapNeutrinoLockedBalance + neutrinoAmount)
374+                            WriteSet([DataEntry(getNeutrinoBalanceKey(account), (getNeutrinoBalance(account) + neutrinoAmount)), DataEntry(getBalanceUnlockBlockKey(account), (height + balanceLockInterval)), DataEntry(SwapNeutrinoLockedBalanceKey, newSwapNeutrinoLockedBalance), DataEntry(IsRebalanceKey, if ((reserveWithoutLeasing >= convertNeutrinoToWaves(newSwapNeutrinoLockedBalance)))
375+                                then false
376+                                else true)])
377+                            }
378+    }
379+
380+
381+
382+@Callable(i)
383+func withdraw (account,index) = {
384+    let unlockHeight = getUnlockBalanceBlock(account)
385+    let neutrinoAmount = getNeutrinoBalance(account)
386+    let indexHeight = getHeightPriceByIndex(index)
387+    let nextIndexHeight = getHeightPriceByIndex((index + 1))
388+    let indexPrice = getPriceHistory(indexHeight)
389+    let amount = convertNeutrinoToWavesByPrice(neutrinoAmount, indexPrice)
390+    if (isBlocked)
391+        then throw("The contract is blocked by EMERGENCY SHUTDOWN. Please wait for reactivation by emergency oracles.")
392+        else if ((0 >= amount))
393+            then throw("No funds are available for withdrawal.")
394+            else if ((unlockHeight > height))
395+                then throw((("Please wait for the " + toString(unlockHeight)) + " block height to complete withdrawal."))
396+                else if (if (if ((index > priceIndex))
397+                    then true
398+                    else (indexHeight > unlockHeight))
399+                    then true
400+                    else if ((nextIndexHeight != 0))
401+                        then (unlockHeight >= nextIndexHeight)
402+                        else false)
403+                    then throw("Invalid price history index.")
404+                    else ScriptResult(WriteSet([DataEntry(getNeutrinoBalanceKey(account), (getNeutrinoBalance(account) - neutrinoAmount)), DataEntry(SwapNeutrinoLockedBalanceKey, (swapNeutrinoLockedBalance - neutrinoAmount))]), TransferSet([ScriptTransfer(addressFromStringValue(account), amount, unit)]))
405+    }
406+
407+
408+
409+@Callable(i)
410+func generateBond () = {
411+    let balanceAuction = assetBalance(addressFromStringValue(auctionContract), bondAssetId)
412+    let amount = (convertNeutrinoToBond(deficit) - balanceAuction)
413+    if (isBlocked)
414+        then throw("The contract is blocked by EMERGENCY SHUTDOWN. Please wait for reactivation by emergency oracles.")
415+        else if ((amount >= ((neutrinoSupply * DEFICITOFFSET) / 100)))
416+            then TransferSet([ScriptTransfer(addressFromStringValue(auctionContract), amount, bondAssetId)])
417+            else throw("Bonds were already generated or there is not enough deficit.")
418+    }
419+
420+
421+
422+@Callable(i)
423+func setOrder () = {
424+    let pmt = extract(i.payment)
425+    let newOrderId = toBase58String(keccak256(((toBytes(pmt.amount) + i.caller.bytes) + toBytes(height))))
426+    if ((pmt.assetId != bondAssetId))
427+        then throw("Can use appropriate Neutrino Bond tokens only.")
428+        else if ((getOrderOwner(newOrderId) != ""))
429+            then throw("This order already exists.")
430+            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)])
431+    }
432+
433+
434+
435+@Callable(i)
436+func cancelOrder (orderId) = {
437+    let owner = getOrderOwner(orderId)
438+    let amount = (getOrderTotal(orderId) - getOrderFilledTotal(orderId))
439+    if ((owner != toString(i.caller)))
440+        then throw("Only the owner of bond liquidation request can cancel it.")
441+        else if ((getOrderStatus(orderId) != NEW))
442+            then throw("Invalid liquidation request status.")
443+            else ScriptResult(WriteSet([DataEntry(OrderbookKey, dropOrder(orderId)), DataEntry(getOrderStatusKey(orderId), CANCELED)]), TransferSet([ScriptTransfer(i.caller, amount, bondAssetId)]))
444+    }
445+
446+
447+
448+@Callable(i)
449+func executeOrder () = {
450+    let orderId = split(orderbook, LISTSPLITSYMBOL)[0]
451+    let orderTotal = getOrderTotal(orderId)
452+    let orderOwner = getOrderOwner(orderId)
453+    let filledTotal = getOrderFilledTotal(orderId)
454+    let surplusBond = convertNeutrinoToBond(surplus)
455+    if (isBlocked)
456+        then throw("The contract is blocked by EMERGENCY SHUTDOWN. Please wait for reactivation by emergency oracles.")
457+        else if ((0 >= surplusBond))
458+            then throw("There is no surplus on the smart contract at the moment.")
459+            else if ((orderbook == ""))
460+                then throw("The orderbook is empty.")
461+                else {
462+                    let amount = (orderTotal - filledTotal)
463+                    let status = if ((surplusBond >= amount))
464+                        then FILLED
465+                        else NEW
466+                    let newFilledTotal = if ((surplusBond >= amount))
467+                        then amount
468+                        else surplusBond
469+                    ScriptResult(WriteSet([DataEntry(OrderbookKey, if ((surplusBond >= amount))
470+                        then dropOrder(orderId)
471+                        else orderbook), DataEntry(getOrderFilledTotalKey(orderId), (filledTotal + newFilledTotal)), DataEntry(getOrderStatusKey(orderId), status)]), TransferSet([ScriptTransfer(addressFromStringValue(orderOwner), convertBondToNeutrino(newFilledTotal), neutrinoAssetId)]))
472+                    }
473+    }
474+
475+
476+
477+@Callable(i)
478+func transfer (account) = {
479+    let pmt = extract(i.payment)
480+    TransferSet([ScriptTransfer(addressFromStringValue(account), pmt.amount, pmt.assetId)])
481+    }
482+
483+
484+
485+@Callable(i)
486+func nodeReward () = {
487+    let pmt = value(i.payment)
488+    if ((i.caller != addressFromStringValue(nodeAddress)))
489+        then throw("Only a node account is able to transfer staking rewards.")
490+        else if (isDefined(pmt.assetId))
491+            then throw("Only Waves tokens are allowed.")
492+            else {
493+                let amount = convertWavesToNeutrino(pmt.amount)
494+                let newRpdSyncIndex = (rpdSyncIndex + 1)
495+                ScriptResult(WriteSet([DataEntry(RPDSyncIndexKey, newRpdSyncIndex), DataEntry(getRPDProfitKey(rpdSyncIndex), amount), DataEntry(getRPDSnapshotContractBalanceKey(rpdSyncIndex, neutrinoAssetId), getRPDContractBalance(neutrinoAssetId))]), TransferSet([ScriptTransfer(addressFromStringValue(rpdContract), amount, neutrinoAssetId)]))
496+                }
497+    }
498+
499+
500+
501+@Callable(i)
502+func registrationLeaseTx (senderPublicKey,fee,timestamp,leaseTxHash) = {
503+    let totalFreeReserve = (((reserve * LEASINGSHARE) / 100) - convertNeutrinoToWaves(swapNeutrinoLockedBalance))
504+    let amount = (totalFreeReserve / LEASINGTXCOUNT)
505+    let txBytes = (((((base58'3h1H' + fromBase58String(senderPublicKey)) + fromBase58String(nodeAddress)) + toBytes(amount)) + toBytes(fee)) + toBytes(timestamp))
506+    let txHashBytes = blake2b256(txBytes)
507+    let txHash = toBase58String(txHashBytes)
508+    let pmt = extract(i.payment)
509+    if ((toString(i.caller) == nodeOracleProviderKey))
510+        then throw("invalid caller")
511+        else if (isDefined(pmt.assetId))
512+            then throw("invalid payment asset")
513+            else if ((leaseTxHash != txHash))
514+                then throw((("invalid tx hash (amount: " + toString(amount)) + ")"))
515+                else if ((leasingTxCount >= LEASINGTXCOUNT))
516+                    then throw("the number of leasing transactions exceeds the limit")
517+                    else if ((this != addressFromPublicKey(fromBase58String(senderPublicKey))))
518+                        then throw("invalid public key")
519+                        else if (if ((lastBlock.timestamp > timestamp))
520+                            then true
521+                            else (timestamp > (lastBlock.timestamp + 5400000)))
522+                            then throw((("invalid timestamp (lastBlock: " + toString(lastBlock.timestamp)) + ")"))
523+                            else if ((getLeaseTxStatus(txHash) != ""))
524+                                then throw("This tx already exists.")
525+                                else if ((pmt.amount != (fee * 2)))
526+                                    then throw("invalid payment amount")
527+                                    else if (if ((fee > 1000000))
528+                                        then true
529+                                        else (500000 > fee))
530+                                        then throw("invalid fee")
531+                                        else if (((totalFreeReserve - (leasingAmount + amount)) > reserveWithoutLeasing))
532+                                            then throw((("invalid amount(result:" + toString(((totalFreeReserve - (leasingAmount + amount)) > reserveWithoutLeasing))) + ")"))
533+                                            else WriteSet([DataEntry(getCancelLeaseTxReserveFeeKey(txHash), fee), DataEntry(LeasingTxCountKey, if ((getLeaseTxStatus(txHash) == ""))
534+                                                then (leasingTxCount + 1)
535+                                                else leasingTxCount), DataEntry(LeasingAmountKey, (leasingAmount + amount)), DataEntry(LeasingExpireBlockKey, if ((height > leasingExpireBlock))
536+                                                then (height + leasingInterval)
537+                                                else leasingExpireBlock), DataEntry(getLeaseTxStatusKey(txHash), NEW), DataEntry(getLeaseTxExpireSendBlockKey(txHash), (height + SENDTXEXPIRE)), DataEntry(getLeaseTxAmountByHashKey(txHash), amount), DataEntry(getLeaseTxBytesByHashKey(txHash), toBase64String(txBytes))])
538+    }
539+
540+
541+
542+@Callable(i)
543+func cancelStuckLeaseTx (txHash) = if (if (if ((getLeaseTxStatus(txHash) == NEW))
544+    then !(isDefined(transactionHeightById(fromBase58String(txHash))))
545+    else false)
546+    then (height > getLeaseTxExpireSendBlock(txHash))
547+    else false)
548+    then {
549+        let amount = getLeaseTxAmountByHash(txHash)
550+        WriteSet([DataEntry(LeasingTxCountKey, (leasingTxCount - 1)), DataEntry(LeasingAmountKey, (leasingAmount - amount)), DataEntry(getLeaseTxStatusKey(txHash), CANCELED), DataEntry(IsRebalanceKey, if (((reserveWithoutLeasing - amount) >= convertNeutrinoToWaves(swapNeutrinoLockedBalance)))
551+            then false
552+            else true)])
553+        }
554+    else throw("invalid tx hash")
555+
556+
557+
558+@Callable(i)
559+func registrationUnleaseTx (chainIdString,senderPublicKey,fee,timestamp,leaseTxHash) = {
560+    let txBytes = (((((base58'gm' + toBytes(chainIdString)) + fromBase58String(senderPublicKey)) + toBytes(fee)) + toBytes(timestamp)) + fromBase58String(leaseTxHash))
561+    let txHash = blake2b256(txBytes)
562+    if ((getLeaseTxStatus(leaseTxHash) != NEW))
563+        then throw("invalid tx status")
564+        else if ((this != addressFromPublicKey(fromBase58String(senderPublicKey))))
565+            then throw("invalid pubKey")
566+            else if (!(isDefined(transactionHeightById(txHash))))
567+                then throw("blockchain does not contain this transaction")
568+                else {
569+                    let amount = getLeaseTxAmountByHash(leaseTxHash)
570+                    WriteSet([DataEntry(LeasingTxCountKey, (leasingTxCount - 1)), DataEntry(LeasingAmountKey, (leasingAmount - amount)), DataEntry(getLeaseTxStatusKey(leaseTxHash), CANCELED), DataEntry(IsRebalanceKey, if (((reserveWithoutLeasing - amount) >= convertNeutrinoToWaves(swapNeutrinoLockedBalance)))
571+                        then false
572+                        else true)])
573+                    }
574+    }
575+
576+
577+@Verifier(tx)
578+func verify () = {
579+    let id = toBase58String(tx.id)
580+    match tx {
581+        case leaseTx: LeaseTransaction => 
582+            if (if ((leasingExpireBlock >= height))
583+                then (getLeaseTxExpireSendBlock(id) >= height)
584+                else false)
585+                then (getLeaseTxStatus(id) == NEW)
586+                else false
587+        case unleaseTx: LeaseCancelTransaction => 
588+            let leaseId = toBase58String(unleaseTx.leaseId)
589+            if (if (if ((height > leasingExpireBlock))
590+                then true
591+                else isRebalance)
592+                then (unleaseTx.fee == getCancelLeaseTxReserveFee(leaseId))
593+                else false)
594+                then (getLeaseTxStatus(leaseId) == NEW)
595+                else false
596+        case _ => 
597+            sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
598+    }
599+    }
600+
github/deemru/w8io/169f3d6 
28.45 ms ◑