tx · Fj2mFmLqwAtdwRV3wmtwdXrHzddcjAT7BzBLxp9G9C94

3MxbSjgfYsiDBaQjS12aeuL655CCnLBgbA6:  -0.01000000 Waves

2021.10.15 18:53 [1747592] smart account 3MxbSjgfYsiDBaQjS12aeuL655CCnLBgbA6 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Fj2mFmLqwAtdwRV3wmtwdXrHzddcjAT7BzBLxp9G9C94",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1634313234995,
    "version": 2,
    "chainId": 84,
    "sender": "3MxbSjgfYsiDBaQjS12aeuL655CCnLBgbA6",
    "senderPublicKey": "5Eq7ps2K5ivuwPzzJvnTdLT5FhsFpjDgsAiYZa9zdAfh",
    "proofs": [
        "KVHzWoQ1pkK2Nrv163ug5xc8qAsjmzYzffi5ie3X5XXYbMqL1N8DzTHcijEkZS8SLmEshfZuk4CAdwJcJPW4xP6"
    ],
    "script": "base64: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",
    "height": 1747592,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+func getNumberByKey (key) = valueOrElse(getInteger(this, key), 0)
5+
6+
7+func getStringByKey (key) = valueOrElse(getString(this, key), "")
8+
9+
10+func getBoolByKey (key) = valueOrElse(getBoolean(this, key), false)
11+
12+
13+func getNumberByAddressAndKey (address,key) = valueOrElse(getInteger(addressFromStringValue(address), key), 0)
14+
15+
16+func getStringByAddressAndKey (address,key) = valueOrElse(getString(addressFromStringValue(address), key), "")
17+
18+
19+func getBoolByAddressAndKey (address,key) = valueOrElse(getBoolean(addressFromStringValue(address), key), false)
20+
21+
22+let pubKeyAdminsList = ["GFmKZ2naZFRoCvNbwKAQVGmLb1uBeWGDgFabdGBuZiuy", "GmJXRyhRA79g8yUGgKBAVdnFfQFDMjQG98b1MmLDh5kk", "CFhbV6h41hVjbGHudGtS3fYUv7QAKRxFQzKNtx4B5PqP", "Kn7NpzaG12dLZgcHf2ipUftU6hbJygmrhFqQYE4B7ZK"]
23+
24+let SEP = "__"
25+
26+let WAVELET = 100000000
27+
28+let PAULI = 1000000
29+
30+let PRICELET = 1000000
31+
32+let DEFAULTSWAPFEE = 20000
33+
34+let IdxNetAmount = 0
35+
36+let IdxFeeAmount = 1
37+
38+let IdxGrossAmount = 2
39+
40+let NeutrinoAssetIdKey = "neutrino_asset_id"
41+
42+let BondAssetIdKey = "bond_asset_id"
43+
44+let AuctionContractKey = "auction_contract"
45+
46+let LiquidationContractKey = "liquidation_contract"
47+
48+let RPDContractKey = "rpd_contract"
49+
50+let ContolContractKey = "control_contract"
51+
52+let BalanceWavesLockIntervalKey = "balance_waves_lock_interval"
53+
54+let BalanceNeutrinoLockIntervalKey = "balance_neutrino_lock_interval"
55+
56+let MinWavesSwapAmountKey = "min_waves_swap_amount"
57+
58+let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
59+
60+let NodeOracleProviderPubKeyKey = "node_oracle_provider"
61+
62+let NeutrinoOutFeePartKey = "neutrinoOut_swap_feePart"
63+
64+let WavesOutFeePartKey = "wavesOut_swap_feePart"
65+
66+let FeesManagerAddressKey = "fees_manager_address"
67+
68+let RsaRandPublic58Key = "rand_rsa_public"
69+
70+let PriceKey = "price"
71+
72+let PriceIndexKey = "price_index"
73+
74+let IsBlockedKey = "is_blocked"
75+
76+func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
77+
78+
79+func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
80+
81+
82+func getStakingNodeByIndex (idx) = addressFromStringValue(getStringByKey(makeString(["%s%d%s", "lease", toString(idx), "nodeAddress"], SEP)))
83+
84+
85+func getReservedAmountForSponsorship () = valueOrElse(getInteger(this, makeString(["%s%s", "lease", "sponsorshipWavesReserve"], SEP)), (1000 * WAVELET))
86+
87+
88+func getBalanceUnlockBlockKey (owner) = ("balance_unlock_block_" + owner)
89+
90+
91+func getLeaseIdKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "id"], SEP)
92+
93+
94+func getLeaseAmountKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "amount"], SEP)
95+
96+
97+func minSwapAmountKEY (swapType) = (("min_" + swapType) + "_swap_amount")
98+
99+
100+func totalLockedKEY (swapType) = ("balance_lock_" + swapType)
101+
102+
103+func totalLockedByUserKEY (swapType,owner) = makeString(["balance_lock", swapType, owner], "_")
104+
105+
106+func balanceLockIntervalKEY (swapType) = (("balance_" + swapType) + "_lock_interval")
107+
108+
109+func minBalanceLockIntervalKEY (swapType) = (("balance_" + swapType) + "_lock_interval_minimum")
110+
111+
112+func outFeePartKEY (swapType) = (swapType + "Out_swap_feePart")
113+
114+
115+func minSwapAmountREAD (swapType) = valueOrElse(getInteger(this, minSwapAmountKEY(swapType)), 0)
116+
117+
118+func totalLockedREAD (swapType) = valueOrElse(getInteger(this, totalLockedKEY(swapType)), 0)
119+
120+
121+func totalLockedByUserREAD (swapType,owner) = valueOrElse(getInteger(this, totalLockedByUserKEY(swapType, owner)), 0)
122+
123+
124+func balanceLockIntervalREAD (swapType) = valueOrElse(getInteger(this, balanceLockIntervalKEY(swapType)), 1440)
125+
126+
127+func minBalanceLockIntervalREAD (swapType) = valueOrElse(getInteger(this, minBalanceLockIntervalKEY(swapType)), 60)
128+
129+
130+func feeManagerAddressREAD () = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, FeesManagerAddressKey), (FeesManagerAddressKey + " is not specified"))), (FeesManagerAddressKey + " invalid address format"))
131+
132+
133+func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, PRICELET, price), WAVELET, PAULI)
134+
135+
136+func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, PRICELET), PAULI, WAVELET)
137+
138+
139+func convertWavesToBond (amount,price) = convertWavesToNeutrino(amount, price)
140+
141+
142+func convertJsonArrayToList (jsonArray) = split(jsonArray, ",")
143+
144+
145+func minSwapAmountFAIL (swapType,minSwapAmount) = throw(((("The specified amount in " + swapType) + " swap is less than the required minimum of ") + toString(minSwapAmount)))
146+
147+
148+func emergencyShutdownFAIL () = throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
149+
150+
151+func priceIndexFAIL (index,priceIndex,indexHeight,unlockHeight,prevIndexHeight) = throw(((((((((("invalid price history index: index=" + toString(index)) + " priceIndex=") + toString(priceIndex)) + " indexHeight=") + toString(indexHeight)) + " unlockHeight=") + toString(unlockHeight)) + " prevIndexHeight=") + toString(prevIndexHeight)))
152+
153+
154+let liquidationContract = getStringByKey(LiquidationContractKey)
155+
156+let neutrinoAssetId = fromBase58String(getStringByKey(NeutrinoAssetIdKey))
157+
158+let auctionContract = getStringByKey(AuctionContractKey)
159+
160+let rpdContract = getStringByKey(RPDContractKey)
161+
162+let controlContract = getStringByKey(ContolContractKey)
163+
164+let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
165+
166+let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
167+
168+let nodeOracleProviderPubKey = fromBase58String(getStringByKey(NodeOracleProviderPubKeyKey))
169+
170+let bondAssetId = fromBase58String("6nSpVyNH7yM69eg446wrQR94ipbbcmZMU1ENPwanC97g")
171+
172+let deprecatedBondAssetId = fromBase58String("975akZBfnMj513U7MZaHKzQrmsEx5aE3wdWKTrHBhbjF")
173+
174+let rsaPub = fromBase64String(valueOrErrorMessage(getString(this, RsaRandPublic58Key), "RSA public key has not been specified"))
175+
176+let neutrinoContract = this
177+
178+let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
179+
180+let neutrinoLockedBalance = totalLockedREAD("neutrino")
181+
182+let wavesLockedBalance = totalLockedREAD("waves")
183+
184+let reserve = (wavesBalance(neutrinoContract).regular - wavesLockedBalance)
185+
186+let neutrinoSupply = (((neutrinoLockedBalance + value(assetInfo(neutrinoAssetId)).quantity) - assetBalance(neutrinoContract, neutrinoAssetId)) - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
187+
188+let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
189+
190+let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve, currentPrice))
191+
192+func checkIsValidMinSponsoredFee (tx) = {
193+    let MINTRANSFERFEE = 100000
194+    let SponsoredFeeUpperBound = 1000
195+    let realNeutrinoFee = convertWavesToNeutrino(MINTRANSFERFEE, currentPrice)
196+    let minNeutrinoFee = (realNeutrinoFee * 2)
197+    let maxNeutrinoFee = fraction(realNeutrinoFee, SponsoredFeeUpperBound, 100)
198+    let inputFee = value(tx.minSponsoredAssetFee)
199+    if (if ((inputFee >= minNeutrinoFee))
200+        then (maxNeutrinoFee >= inputFee)
201+        else false)
202+        then (tx.assetId == neutrinoAssetId)
203+        else false
204+    }
205+
206+
207+func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
208+
209+
210+func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
211+
212+
213+let sIdxSwapType = 1
214+
215+let sIdxStatus = 2
216+
217+let sIdxInAmount = 3
218+
219+let sIdxPrice = 4
220+
221+let sIdxOutNetAmount = 5
222+
223+let sIdxOutFeeAmount = 6
224+
225+let sIdxStartHeight = 7
226+
227+let sIdxStartTimestamp = 8
228+
229+let sIdxEndHeight = 9
230+
231+let sIdxEndTimestamp = 10
232+
233+let sIdxSelfUnlockHeight = 11
234+
235+let sIdxRandUnlockHeight = 12
236+
237+let sIdxIndex = 13
238+
239+let sIdxWithdrawTxId = 14
240+
241+func swapKEY (userAddress,txId) = makeString(["%s%s", userAddress, txId], SEP)
242+
243+
244+func strSwapDATA (swapType,status,inAmount,price,outNetAmount,outFeeAmount,startHeight,startTimestamp,endHeight,endTimestamp,selfUnlockHeight,randUnlockHeight,index,withdrawTxId) = makeString(["%s%s%d%d%d%d%d%d%d%d%d%d%d%s", swapType, status, inAmount, price, outNetAmount, outFeeAmount, startHeight, startTimestamp, endHeight, endTimestamp, selfUnlockHeight, randUnlockHeight, index, withdrawTxId], SEP)
245+
246+
247+func pendingSwapDATA (swapType,inAssetAmount,selfUnlockHeight) = strSwapDATA(swapType, "PENDING", toString(inAssetAmount), "0", "0", "0", toString(height), toString(lastBlock.timestamp), "0", "0", toString(selfUnlockHeight), "0", "0", "NULL")
248+
249+
250+func finishSwapDATA (dataArray,price,outNetAmount,outFeeAmount,randUnlockHeight,index,withdrawTxId) = strSwapDATA(dataArray[sIdxSwapType], "FINISHED", dataArray[sIdxInAmount], toString(price), toString(outNetAmount), toString(outFeeAmount), dataArray[sIdxStartHeight], dataArray[sIdxStartTimestamp], toString(height), toString(lastBlock.timestamp), dataArray[sIdxSelfUnlockHeight], toString(randUnlockHeight), toString(index), withdrawTxId)
251+
252+
253+func swapDataFailOrREAD (userAddress,swapTxId) = {
254+    let swapKey = swapKEY(userAddress, swapTxId)
255+    split(valueOrErrorMessage(getString(this, swapKey), ("no swap data for " + swapKey)), SEP)
256+    }
257+
258+
259+func applyFees (amountGross,feePart) = {
260+    let feeAmount = fraction(amountGross, feePart, PAULI)
261+[(amountGross - feeAmount), feeAmount, amountGross]
262+    }
263+
264+
265+func randUnlockHeightOrFail (txId,rsaSig,swapType,startHeight) = {
266+    let isRsaValid = rsaVerify_16Kb(SHA256, toBytes(txId), rsaSig, rsaPub)
267+    if (!(isRsaValid))
268+        then throw("invalid RSA signature")
269+        else {
270+            let maxBalanceLockInterval = balanceLockIntervalREAD(swapType)
271+            let minBalanceLockInterval = minBalanceLockIntervalREAD(swapType)
272+            let rand = (toInt(sha256_16Kb(rsaSig)) % (maxBalanceLockInterval - minBalanceLockInterval))
273+            let randLockInterval = (minBalanceLockInterval + (if ((0 > rand))
274+                then -(rand)
275+                else rand))
276+            (startHeight + randLockInterval)
277+            }
278+    }
279+
280+
281+func abs (x) = if ((0 > x))
282+    then -(x)
283+    else x
284+
285+
286+func selectNode (unleaseAmount) = {
287+    let amountToLease = ((wavesBalance(neutrinoContract).available - unleaseAmount) - getReservedAmountForSponsorship())
288+    let oldLeased0 = getNumberByKey(getLeaseAmountKey(0))
289+    let oldLeased1 = getNumberByKey(getLeaseAmountKey(1))
290+    let newLeased0 = (amountToLease + oldLeased0)
291+    let newLeased1 = (amountToLease + oldLeased1)
292+    if (if ((newLeased0 > 0))
293+        then true
294+        else (newLeased1 > 0))
295+        then {
296+            let delta0 = abs((newLeased0 - oldLeased1))
297+            let delta1 = abs((newLeased1 - oldLeased0))
298+            if ((delta1 >= delta0))
299+                then $Tuple2(0, newLeased0)
300+                else $Tuple2(1, newLeased1)
301+            }
302+        else $Tuple2(-1, 0)
303+    }
304+
305+
306+func prepareUnleaseAndLease (unleaseAmount) = {
307+    let nodeTuple = selectNode(unleaseAmount)
308+    let nodeIndex = nodeTuple._1
309+    let newLeaseAmount = nodeTuple._2
310+    if ((newLeaseAmount > 0))
311+        then {
312+            let leaseIdKey = getLeaseIdKey(nodeIndex)
313+            let oldLease = getBinary(this, leaseIdKey)
314+            let unleaseOrEmpty = if (isDefined(oldLease))
315+                then [LeaseCancel(value(oldLease))]
316+                else nil
317+            let leaseAmountKey = getLeaseAmountKey(nodeIndex)
318+            let lease = Lease(getStakingNodeByIndex(nodeIndex), newLeaseAmount)
319+            (unleaseOrEmpty ++ [lease, BinaryEntry(leaseIdKey, calculateLeaseId(lease)), IntegerEntry(getLeaseAmountKey(nodeIndex), newLeaseAmount)])
320+            }
321+        else nil
322+    }
323+
324+
325+func commonSwap (swapType,i) = {
326+    let pmt = value(i.payments[0])
327+    let account = toString(i.caller)
328+    let txId58 = toBase58String(i.transactionId)
329+    let minSwapAmount = minSwapAmountREAD(swapType)
330+    let totalLocked = totalLockedREAD(swapType)
331+    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
332+    let balanceLockMaxInterval = balanceLockIntervalREAD(swapType)
333+    let selfUnlockHeight = (height + balanceLockMaxInterval)
334+    if ((minSwapAmount > pmt.amount))
335+        then minSwapAmountFAIL(swapType, minSwapAmount)
336+        else if (isBlocked)
337+            then emergencyShutdownFAIL()
338+            else {
339+                let leasePart = if ((swapType == "waves"))
340+                    then prepareUnleaseAndLease(0)
341+                    else nil
342+                $Tuple2(([IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser + pmt.amount)), IntegerEntry(getBalanceUnlockBlockKey(account), (height + balanceLockMaxInterval)), IntegerEntry(totalLockedKEY(swapType), (totalLocked + pmt.amount)), StringEntry(swapKEY(account, txId58), pendingSwapDATA(swapType, pmt.amount, selfUnlockHeight))] ++ leasePart), unit)
343+                }
344+    }
345+
346+
347+func commonWithdraw (account,index,swapTxId,rsaSigOrUnit,i) = {
348+    let userAddress = addressFromStringValue(account)
349+    let feeManagerAddress = feeManagerAddressREAD()
350+    let dataArray = swapDataFailOrREAD(account, swapTxId)
351+    let selfUnlockHeight = parseIntValue(dataArray[sIdxSelfUnlockHeight])
352+    let swapType = dataArray[sIdxSwapType]
353+    let inAmount = parseIntValue(dataArray[sIdxInAmount])
354+    let swapStatus = dataArray[sIdxStatus]
355+    let startHeight = parseIntValue(dataArray[sIdxStartHeight])
356+    let outFeePart = valueOrElse(getInteger(this, outFeePartKEY(swapType)), DEFAULTSWAPFEE)
357+    let totalLocked = totalLockedREAD(swapType)
358+    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
359+    let unlockHeight =     match rsaSigOrUnit {
360+        case rsaSig: ByteVector => 
361+            randUnlockHeightOrFail(swapTxId, rsaSig, swapType, startHeight)
362+        case _: Unit => 
363+            selfUnlockHeight
364+        case _ => 
365+            throw("Match error")
366+    }
367+    let indexHeight = getHeightPriceByIndex(index)
368+    let prevIndexHeight = getHeightPriceByIndex((index - 1))
369+    let priceByIndex = getPriceHistory(indexHeight)
370+    let outAmountGrossTuple = if ((swapType == "waves"))
371+        then $Tuple2(convertWavesToNeutrino(inAmount, priceByIndex), neutrinoAssetId)
372+        else if ((swapType == "neutrino"))
373+            then $Tuple2(convertNeutrinoToWaves(inAmount, priceByIndex), unit)
374+            else throw(("Unsupported swap type " + swapType))
375+    let payoutsArray = applyFees(outAmountGrossTuple._1, outFeePart)
376+    let outNetAmount = payoutsArray[IdxNetAmount]
377+    let outFeeAmount = payoutsArray[IdxFeeAmount]
378+    if (isBlocked)
379+        then emergencyShutdownFAIL()
380+        else if ((swapStatus != "PENDING"))
381+            then throw("swap has been already processed")
382+            else if ((unlockHeight > height))
383+                then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw funds"))
384+                else if (if (if ((index > priceIndex))
385+                    then true
386+                    else (unlockHeight > indexHeight))
387+                    then true
388+                    else if ((prevIndexHeight != 0))
389+                        then (prevIndexHeight >= unlockHeight)
390+                        else false)
391+                    then priceIndexFAIL(index, priceIndex, indexHeight, unlockHeight, prevIndexHeight)
392+                    else if ((0 >= payoutsArray[IdxGrossAmount]))
393+                        then throw("balance equals zero")
394+                        else if (if ((0 > outFeePart))
395+                            then true
396+                            else (outFeePart >= PAULI))
397+                            then throw(((("invalid outFeePart config for " + swapType) + " swap: outFeePart=") + toString(outFeePart)))
398+                            else {
399+                                let leasePart = if (if ((swapType == "neutrino"))
400+                                    then (outAmountGrossTuple._1 > 0)
401+                                    else false)
402+                                    then prepareUnleaseAndLease(outAmountGrossTuple._1)
403+                                    else nil
404+                                $Tuple2((leasePart ++ [IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser - inAmount)), IntegerEntry(totalLockedKEY(swapType), (totalLocked - inAmount)), ScriptTransfer(userAddress, outNetAmount, outAmountGrossTuple._2), ScriptTransfer(feeManagerAddress, outFeeAmount, outAmountGrossTuple._2), StringEntry(swapKEY(account, swapTxId), finishSwapDATA(dataArray, priceByIndex, outNetAmount, outFeeAmount, unlockHeight, index, toBase58String(i.transactionId)))]), unit)
405+                                }
406+    }
407+
408+
409+@Callable(i)
410+func swapWavesToNeutrino () = {
411+    let pmt = value(i.payments[0])
412+    if (isDefined(pmt.assetId))
413+        then throw("Only Waves token is allowed for swapping.")
414+        else commonSwap("waves", i)
415+    }
416+
417+
418+
419+@Callable(i)
420+func swapNeutrinoToWaves () = {
421+    let pmt = value(i.payments[0])
422+    if ((pmt.assetId != neutrinoAssetId))
423+        then throw("Only appropriate Neutrino tokens are allowed for swapping.")
424+        else commonSwap("neutrino", i)
425+    }
426+
427+
428+
429+@Callable(i)
430+func withdraw (account,index,swapTxId) = commonWithdraw(account, index, swapTxId, unit, i)
431+
432+
433+
434+@Callable(i)
435+func withdrawRand (account,index,swapTxId,rsaSig) = commonWithdraw(account, index, swapTxId, rsaSig, i)
436+
437+
438+
439+@Callable(i)
440+func transferToAuction () = {
441+    let auctionNBAmount = (neutrinoSupply - assetBalance(addressFromStringValue(auctionContract), bondAssetId))
442+    let surplusWithLiquidation = (surplus - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
443+    if (isBlocked)
444+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
445+        else if ((auctionNBAmount > (1 * PAULI)))
446+            then [ScriptTransfer(addressFromStringValue(auctionContract), auctionNBAmount, bondAssetId)]
447+            else if ((surplusWithLiquidation >= (1 * PAULI)))
448+                then [ScriptTransfer(addressFromStringValue(liquidationContract), surplusWithLiquidation, neutrinoAssetId)]
449+                else throw(((((((("bond were generated or do not need it. Deficit:" + toString(auctionNBAmount)) + "|") + toString(0)) + ". Surplus:") + toString(surplusWithLiquidation)) + "|") + toString(surplus)))
450+    }
451+
452+
453+
454+@Callable(i)
455+func acceptWaves () = if ((i.caller != addressFromStringValue(auctionContract)))
456+    then throw("Currently only auction contract is allowed to call")
457+    else $Tuple2(prepareUnleaseAndLease(0), "success")
458+
459+
460+
461+@Callable(i)
462+func migrateActiveLeasings (leaseChunkTxId,chunkAmount,nodeIndex) = if ((i.callerPublicKey != nodeOracleProviderPubKey))
463+    then throw("not authorized")
464+    else {
465+        let leaseAmountKEY = getLeaseAmountKey(nodeIndex)
466+        let amountToAdd = ((wavesBalance(neutrinoContract).available + chunkAmount) - getReservedAmountForSponsorship())
467+        let oldLeasedAmount = getNumberByKey(leaseAmountKEY)
468+        let newLeaseAmount = (oldLeasedAmount + amountToAdd)
469+        let leaseIdKEY = getLeaseIdKey(nodeIndex)
470+        let oldLeaseId = getBinary(this, leaseIdKEY)
471+        let oldUnleaseOrEmpty = if (isDefined(oldLeaseId))
472+            then [LeaseCancel(value(oldLeaseId))]
473+            else nil
474+        let lease = Lease(getStakingNodeByIndex(nodeIndex), newLeaseAmount)
475+        (oldUnleaseOrEmpty ++ [LeaseCancel(fromBase58String(leaseChunkTxId)), lease, BinaryEntry(leaseIdKEY, calculateLeaseId(lease)), IntegerEntry(leaseAmountKEY, newLeaseAmount)])
476+        }
477+
478+
479+@Verifier(tx)
480+func verify () = {
481+    let id = toBase58String(tx.id)
482+    let count = ((((if (sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(pubKeyAdminsList[0])))
483+        then 1
484+        else 0) + (if (sigVerify(tx.bodyBytes, tx.proofs[1], fromBase58String(pubKeyAdminsList[1])))
485+        then 1
486+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[2], fromBase58String(pubKeyAdminsList[2])))
487+        then 1
488+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[3], fromBase58String(pubKeyAdminsList[3])))
489+        then 2
490+        else 0))
491+    match tx {
492+        case sponsorTx: SponsorFeeTransaction => 
493+            if (checkIsValidMinSponsoredFee(sponsorTx))
494+                then (count >= 3)
495+                else false
496+        case _ => 
497+            (count >= 3)
498+    }
499+    }
500+
github/deemru/w8io/026f985 
40.85 ms ◑