tx · 68be7LZWxU1pWvSfa3o7AQUoZqthi9aMPtmPc1abokAm

3N6Grmu8pZHV5Azabv7Vrz9i5jwoujw1Wi9:  -0.01000000 Waves

2019.11.16 17:40 [767797] smart account 3N6Grmu8pZHV5Azabv7Vrz9i5jwoujw1Wi9 > SELF 0.00000000 Waves

{ "type": 13, "id": "68be7LZWxU1pWvSfa3o7AQUoZqthi9aMPtmPc1abokAm", "fee": 1000000, "feeAssetId": null, "timestamp": 1573915243952, "version": 1, "sender": "3N6Grmu8pZHV5Azabv7Vrz9i5jwoujw1Wi9", "senderPublicKey": "EU8XJTqdDYpBRYp42CAE42focQhM8UwCpmg4XZ8dxyEp", "proofs": [ "4QzEa9cGdgLMB4dzSFVkdy8WdcaWeaqTuZR718ECFLK4ag2qGCrwKjntkZUY4CLPZusWuTrVDJYDgzC9DnVFr1ri" ], "script": "base64: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", "chainId": 84, "height": 767797, "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 
39.92 ms