tx · 2qCSAK6np9xR7Q6vcGDN8dAPiSn3SyXmEYCKL5x2gtCw

3N4nCQiTrf6eH73RpgL1TiVYArbKcbxS29k:  -0.03000000 Waves

2022.12.20 11:37 [2368383] smart account 3N4nCQiTrf6eH73RpgL1TiVYArbKcbxS29k > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2qCSAK6np9xR7Q6vcGDN8dAPiSn3SyXmEYCKL5x2gtCw",
    "fee": 3000000,
    "feeAssetId": null,
    "timestamp": 1671525510633,
    "version": 2,
    "chainId": 84,
    "sender": "3N4nCQiTrf6eH73RpgL1TiVYArbKcbxS29k",
    "senderPublicKey": "2ZZeNG8QEzbey4ofnP8FVJaGbRJjWrib3SiAwYTGzQXd",
    "proofs": [
        "La6ysQbquUh4iJgNJpyA4od7yh5iZTK1p7w5ge9StbnJRDBQybqFZPyQkeurd8jF4vyE4rQp54FZFK981YZkp6n"
    ],
    "script": "base64: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",
    "height": 2368383,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let revisionNum = ""
5+
6+func getStringOrFail (address,key) = valueOrErrorMessage(getString(address, key), makeString(["mandatory ", toString(address), ".", key, " is not defined"], ""))
7+
8+
9+func lcalc (l) = calculateLeaseId(l)
10+
11+
12+func getNumberByKey (key) = valueOrElse(getInteger(this, key), 0)
13+
14+
15+func getStringByKey (key) = valueOrElse(getString(this, key), "")
16+
17+
18+func getBoolByKey (key) = valueOrElse(getBoolean(this, key), false)
19+
20+
21+func getNumberByAddressAndKey (address,key) = valueOrElse(getInteger(address, key), 0)
22+
23+
24+func getStringByAddressAndKey (address,key) = valueOrElse(getString(addressFromStringValue(address), key), "")
25+
26+
27+func getBoolByAddressAndKey (address,key) = valueOrElse(getBoolean(address, key), false)
28+
29+
30+func asAnyList (v) = match v {
31+    case l: List[Any] => 
32+        l
33+    case _ => 
34+        throw("fail to cast into List[Any]")
35+}
36+
37+
38+func asString (v) = match v {
39+    case s: String => 
40+        s
41+    case _ => 
42+        throw("fail to cast into String")
43+}
44+
45+
46+func asInt (v) = match v {
47+    case i: Int => 
48+        i
49+    case _ => 
50+        throw("fail to cast into Int")
51+}
52+
53+
54+func asBytes (val) = match val {
55+    case valByte: ByteVector => 
56+        valByte
57+    case _ => 
58+        throw("fail to cast into ByteVector")
59+}
60+
61+
62+func asPayment (v) = match v {
63+    case p: AttachedPayment => 
64+        p
65+    case _ => 
66+        throw("fail to cast into AttachedPayment")
67+}
68+
69+
70+func asSwapParamsSTRUCT (v) = match v {
71+    case struct: (Int, Int, Int, Int, Int, Int, Int) => 
72+        struct
73+    case _ => 
74+        throw("fail to cast into Tuple5 ints")
75+}
76+
77+
78+let SEP = "__"
79+
80+let WAVELET = 100000000
81+
82+let PAULI = 1000000
83+
84+let PRICELET = 1000000
85+
86+let DEFAULTSWAPFEE = 20000
87+
88+let BRPROTECTED = 100000
89+
90+let IdxNetAmount = 0
91+
92+let IdxFeeAmount = 1
93+
94+let IdxGrossAmount = 2
95+
96+let IdxControlCfgNeutrinoDapp = 1
97+
98+let IdxControlCfgAuctionDapp = 2
99+
100+let IdxControlCfgRpdDapp = 3
101+
102+let IdxControlCfgMathDapp = 4
103+
104+let IdxControlCfgLiquidationDapp = 5
105+
106+let IdxControlCfgRestDapp = 6
107+
108+let IdxControlCfgNodeRegistryDapp = 7
109+
110+let IdxControlCfgNsbtStakingDapp = 8
111+
112+let IdxControlCfgMediatorDapp = 9
113+
114+let IdxControlCfgSurfStakingDapp = 10
115+
116+let IdxControlCfgGnsbtControllerDapp = 11
117+
118+func keyControlAddress () = "%s%s__config__controlAddress"
119+
120+
121+func keyControlCfg () = "%s__controlConfig"
122+
123+
124+func readControlCfgOrFail (control) = split(getStringOrFail(control, keyControlCfg()), SEP)
125+
126+
127+func getContractAddressOrFail (controlCfg,idx) = valueOrErrorMessage(addressFromString(controlCfg[idx]), ("Control cfg doesn't contain address at index " + toString(idx)))
128+
129+
130+let controlContract = addressFromStringValue(valueOrElse(getString(this, keyControlAddress()), "3P5Bfd58PPfNvBM2Hy8QfbcDqMeNtzg7KfP"))
131+
132+let controlCfg = readControlCfgOrFail(controlContract)
133+
134+let mathContract = getContractAddressOrFail(controlCfg, IdxControlCfgMathDapp)
135+
136+let nsbtStakingContract = getContractAddressOrFail(controlCfg, IdxControlCfgNsbtStakingDapp)
137+
138+let surfStakingContract = getContractAddressOrFail(controlCfg, IdxControlCfgSurfStakingDapp)
139+
140+let gnsbtControllerContract = getContractAddressOrFail(controlCfg, IdxControlCfgGnsbtControllerDapp)
141+
142+let auctionContract = getContractAddressOrFail(controlCfg, IdxControlCfgAuctionDapp)
143+
144+let nodeRegistryContract = getContractAddressOrFail(controlCfg, IdxControlCfgNodeRegistryDapp)
145+
146+let NeutrinoAssetIdKey = "neutrino_asset_id"
147+
148+let BondAssetIdKey = "bond_asset_id"
149+
150+let AuctionContractKey = "auction_contract"
151+
152+let NsbtStakingContractKey = "nsbtStakingContract"
153+
154+let LiquidationContractKey = "liquidation_contract"
155+
156+let RPDContractKey = "rpd_contract"
157+
158+let ContolContractKey = "control_contract"
159+
160+let MathContractKey = "math_contract"
161+
162+let BalanceWavesLockIntervalKey = "balance_waves_lock_interval"
163+
164+let BalanceNeutrinoLockIntervalKey = "balance_neutrino_lock_interval"
165+
166+let MinWavesSwapAmountKey = "min_waves_swap_amount"
167+
168+let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
169+
170+let NodeOracleProviderPubKeyKey = "node_oracle_provider"
171+
172+let NeutrinoOutFeePartKey = "neutrinoOut_swap_feePart"
173+
174+let WavesOutFeePartKey = "wavesOut_swap_feePart"
175+
176+func keyNodeRegistry (address) = ("%s__" + address)
177+
178+
179+let PriceKey = "price"
180+
181+let PriceIndexKey = "price_index"
182+
183+let IsBlockedKey = "is_blocked"
184+
185+func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
186+
187+
188+func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
189+
190+
191+func getStakingNodeByIndex (idx) = getStringByKey(makeString(["%s%d%s", "lease", toString(idx), "nodeAddress"], SEP))
192+
193+
194+func getStakingNodeAddressByIndex (idx) = addressFromStringValue(getStakingNodeByIndex(idx))
195+
196+
197+func getReservedAmountForSponsorship () = valueOrElse(getInteger(this, makeString(["%s%s", "lease", "sponsorshipWavesReserve"], SEP)), (1000 * WAVELET))
198+
199+
200+func getBalanceUnlockBlockKey (owner) = ("balance_unlock_block_" + owner)
201+
202+
203+func getLeaseIdKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "id"], SEP)
204+
205+
206+func getLeaseIdByAddressKey (nodeAddress) = makeString(["%s%s%s", "leaseByAddress", nodeAddress, "id"], SEP)
207+
208+
209+func getLeaseAmountKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "amount"], SEP)
210+
211+
212+func getLeaseAmountByAddressKey (nodeAddress) = makeString(["%s%s%s", "leaseByAddress", nodeAddress, "amount"], SEP)
213+
214+
215+func getLeaseGroupNodeListKey (groupNum) = makeString(["%s%d%s", "leaseGroup", toString(groupNum), "nodeList"], SEP)
216+
217+
218+func minSwapAmountKEY (swapType) = (("min_" + swapType) + "_swap_amount")
219+
220+
221+func totalLockedKEY (swapType) = ("balance_lock_" + swapType)
222+
223+
224+func totalLockedByUserKEY (swapType,owner) = makeString(["balance_lock", swapType, owner], "_")
225+
226+
227+func balanceLockIntervalKEY (swapType) = (("balance_" + swapType) + "_lock_interval")
228+
229+
230+func nodeBalanceLockIntervalKEY () = "balance_node_lock_interval"
231+
232+
233+func outFeePartKEY (swapType) = (swapType + "Out_swap_feePart")
234+
235+
236+func swapsTimeframeKEY () = "swaps_timeframe"
237+
238+
239+func brProtectedKEY () = "min_BR_protection_level"
240+
241+
242+func minSwapAmountREAD (swapType) = valueOrElse(getInteger(this, minSwapAmountKEY(swapType)), 0)
243+
244+
245+func swapsTimeframeREAD () = valueOrElse(getInteger(this, swapsTimeframeKEY()), 1440)
246+
247+
248+func totalLockedREAD (swapType) = valueOrElse(getInteger(this, totalLockedKEY(swapType)), 0)
249+
250+
251+func totalLockedByUserREAD (swapType,owner) = valueOrElse(getInteger(this, totalLockedByUserKEY(swapType, owner)), 0)
252+
253+
254+func balanceLockIntervalREAD (swapType) = valueOrElse(getInteger(this, balanceLockIntervalKEY(swapType)), 1440)
255+
256+
257+func nodeBalanceLockIntervalREAD () = valueOrElse(getInteger(this, nodeBalanceLockIntervalKEY()), 1)
258+
259+
260+func keySwapUserSpentInPeriod (userAddress) = makeString(["%s%s", "swapUserSpentInPeriod", userAddress], SEP)
261+
262+
263+func keyUserLastSwapHeight (userAddress) = makeString(["%s%s", "userLastSwapHeight", userAddress], SEP)
264+
265+
266+func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, PRICELET, price), WAVELET, PAULI)
267+
268+
269+func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, PRICELET), PAULI, WAVELET)
270+
271+
272+func convertWavesToBond (amount,price) = convertWavesToNeutrino(amount, price)
273+
274+
275+func convertJsonArrayToList (jsonArray) = split(jsonArray, ",")
276+
277+
278+func minSwapAmountFAIL (swapType,minSwapAmount) = throw(((("The specified amount in " + swapType) + " swap is less than the required minimum of ") + toString(minSwapAmount)))
279+
280+
281+func emergencyShutdownFAIL () = throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
282+
283+
284+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)))
285+
286+
287+let neutrinoAssetId = fromBase58String(getStringByKey(NeutrinoAssetIdKey))
288+
289+let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
290+
291+let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
292+
293+let nodeOracleProviderPubKey = fromBase58String(getStringByKey(NodeOracleProviderPubKeyKey))
294+
295+let bondAssetId = fromBase58String("6nSpVyNH7yM69eg446wrQR94ipbbcmZMU1ENPwanC97g")
296+
297+let deprecatedBondAssetId = fromBase58String("975akZBfnMj513U7MZaHKzQrmsEx5aE3wdWKTrHBhbjF")
298+
299+let neutrinoContract = this
300+
301+let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
302+
303+func checkIsValidMinSponsoredFee (tx) = {
304+    let MINTRANSFERFEE = 100000
305+    let SponsoredFeeUpperBound = 1000
306+    let realNeutrinoFee = convertWavesToNeutrino(MINTRANSFERFEE, currentPrice)
307+    let minNeutrinoFee = (realNeutrinoFee * 2)
308+    let maxNeutrinoFee = fraction(realNeutrinoFee, SponsoredFeeUpperBound, 100)
309+    let inputFee = value(tx.minSponsoredAssetFee)
310+    if (if ((inputFee >= minNeutrinoFee))
311+        then (maxNeutrinoFee >= inputFee)
312+        else false)
313+        then (tx.assetId == neutrinoAssetId)
314+        else false
315+    }
316+
317+
318+func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
319+
320+
321+func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
322+
323+
324+func keyLockParamUserAmount (userAddress) = makeString(["%s%s%s", "paramByUser", userAddress, "amount"], SEP)
325+
326+
327+let sIdxSwapType = 1
328+
329+let sIdxStatus = 2
330+
331+let sIdxInAmount = 3
332+
333+let sIdxPrice = 4
334+
335+let sIdxOutNetAmount = 5
336+
337+let sIdxOutFeeAmount = 6
338+
339+let sIdxStartHeight = 7
340+
341+let sIdxStartTimestamp = 8
342+
343+let sIdxEndHeight = 9
344+
345+let sIdxEndTimestamp = 10
346+
347+let sIdxSelfUnlockHeight = 11
348+
349+let sIdxRandUnlockHeight = 12
350+
351+let sIdxIndex = 13
352+
353+let sIdxWithdrawTxId = 14
354+
355+let sIdxMinRand = 15
356+
357+let sIdxMaxRand = 16
358+
359+let sIdxOutSurfAmount = 17
360+
361+let sIdxBR = 18
362+
363+func swapKEY (userAddress,txId) = makeString(["%s%s", userAddress, txId], SEP)
364+
365+
366+func strSwapDATA (swapType,status,inAmount,price,outNetAmount,outFeeAmount,startHeight,startTimestamp,endHeight,endTimestamp,selfUnlockHeight,randUnlockHeight,index,withdrawTxId,randMin,randMax,outSurfAmt,br) = makeString(["%s%s%d%d%d%d%d%d%d%d%d%d%d%s%d%d%d%d", swapType, status, inAmount, price, outNetAmount, outFeeAmount, startHeight, startTimestamp, endHeight, endTimestamp, selfUnlockHeight, randUnlockHeight, index, withdrawTxId, randMin, randMax, outSurfAmt, br], SEP)
367+
368+
369+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", "0", "0", "0", "0")
370+
371+
372+func finishSwapDATA (dataArray,price,outNetAmount,outFeeAmount,randUnlockHeight,index,withdrawTxId,outSurfAmt,br) = 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, dataArray[sIdxMinRand], dataArray[sIdxMaxRand], toString(outSurfAmt), toString(br))
373+
374+
375+func swapDataFailOrREAD (userAddress,swapTxId) = {
376+    let swapKey = swapKEY(userAddress, swapTxId)
377+    split(valueOrErrorMessage(getString(this, swapKey), ("no swap data for " + swapKey)), SEP)
378+    }
379+
380+
381+func applyFees (amountOutGross,inAmtToSURF,feePart) = {
382+    let feeAmount = fraction(amountOutGross, feePart, PAULI)
383+[(amountOutGross - feeAmount), feeAmount]
384+    }
385+
386+
387+func abs (x) = if ((0 > x))
388+    then -(x)
389+    else x
390+
391+
392+func selectNode (unleaseAmount) = {
393+    let amountToLease = ((wavesBalance(neutrinoContract).available - unleaseAmount) - getReservedAmountForSponsorship())
394+    let oldLeased0 = getNumberByKey(getLeaseAmountKey(0))
395+    let oldLeased1 = getNumberByKey(getLeaseAmountKey(1))
396+    let newLeased0 = (amountToLease + oldLeased0)
397+    let newLeased1 = (amountToLease + oldLeased1)
398+    if (if ((newLeased0 > 0))
399+        then true
400+        else (newLeased1 > 0))
401+        then {
402+            let delta0 = abs((newLeased0 - oldLeased1))
403+            let delta1 = abs((newLeased1 - oldLeased0))
404+            if ((delta1 >= delta0))
405+                then $Tuple2(0, newLeased0)
406+                else $Tuple2(1, newLeased1)
407+            }
408+        else $Tuple2(-1, 0)
409+    }
410+
411+
412+func thisOnly (i) = if ((i.caller != this))
413+    then throw("Permission denied: this contract only allowed")
414+    else true
415+
416+
417+func prepareUnleaseAndLease (unleaseAmount) = {
418+    let nodeTuple = selectNode(unleaseAmount)
419+    let nodeIndex = nodeTuple._1
420+    let newLeaseAmount = nodeTuple._2
421+    if ((newLeaseAmount > 0))
422+        then {
423+            let leaseIdKey = getLeaseIdKey(nodeIndex)
424+            let oldLease = getBinary(this, leaseIdKey)
425+            let unleaseOrEmpty = if (isDefined(oldLease))
426+                then [LeaseCancel(value(oldLease))]
427+                else nil
428+            let leaseAmountKey = getLeaseAmountKey(nodeIndex)
429+            let lease = Lease(getStakingNodeAddressByIndex(nodeIndex), newLeaseAmount)
430+            (unleaseOrEmpty ++ [lease, BinaryEntry(leaseIdKey, lcalc(lease)), IntegerEntry(getLeaseAmountKey(nodeIndex), newLeaseAmount)])
431+            }
432+        else nil
433+    }
434+
435+
436+func readNodeInfo (nodeIdx) = {
437+    let nodeAddress = getStakingNodeAddressByIndex(nodeIdx)
438+    let leasedAmtKEY = getLeaseAmountKey(nodeIdx)
439+    let leasedAmt = getNumberByKey(leasedAmtKEY)
440+    let leaseIdKEY = getLeaseIdKey(nodeIdx)
441+    let leaseId = value(getBinary(this, leaseIdKEY))
442+    $Tuple5(nodeAddress, leasedAmtKEY, leasedAmt, leaseIdKEY, leaseId)
443+    }
444+
445+
446+func commonSwap (swapType,pmtAmount,userAddressStr,txId58,swapParamsByUserSYSREADONLY) = {
447+    let swapLimitSpent = swapParamsByUserSYSREADONLY._2
448+    let blcks2LmtReset = swapParamsByUserSYSREADONLY._3
449+    let wavesSwapLimitMax = swapParamsByUserSYSREADONLY._6
450+    let usdnSwapLimitMax = swapParamsByUserSYSREADONLY._7
451+    let minSwapAmount = minSwapAmountREAD(swapType)
452+    let totalLocked = totalLockedREAD(swapType)
453+    let totalLockedByUser = totalLockedByUserREAD(swapType, userAddressStr)
454+    let nodeAddress = getStakingNodeByIndex(0)
455+    let priceByIndex = getPriceHistory(getHeightPriceByIndex(priceIndex))
456+    let isSwapByNode = (nodeAddress == userAddressStr)
457+    let balanceLockMaxInterval = if (isSwapByNode)
458+        then nodeBalanceLockIntervalREAD()
459+        else balanceLockIntervalREAD(swapType)
460+    let selfUnlockHeight = (height + balanceLockMaxInterval)
461+    let swapUsdnVolume = if ((swapType == "neutrino"))
462+        then pmtAmount
463+        else convertWavesToNeutrino(pmtAmount, priceByIndex)
464+    let swapLimitMax = if ((swapType == "neutrino"))
465+        then usdnSwapLimitMax
466+        else convertWavesToNeutrino(wavesSwapLimitMax, priceByIndex)
467+    if ((minSwapAmount > pmtAmount))
468+        then minSwapAmountFAIL(swapType, minSwapAmount)
469+        else if (if (!(isSwapByNode))
470+            then (swapLimitSpent > 0)
471+            else false)
472+            then throw(("You have exceeded swap limit! Next allowed swap height is " + toString((height + blcks2LmtReset))))
473+            else if (if (!(isSwapByNode))
474+                then (swapUsdnVolume > swapLimitMax)
475+                else false)
476+                then throw(((("You have exceeded your swap limit! Requested: " + toString(swapUsdnVolume)) + ", available: ") + toString(swapLimitMax)))
477+                else if (isBlocked)
478+                    then emergencyShutdownFAIL()
479+                    else {
480+                        let leasePart = if ((swapType == "waves"))
481+                            then prepareUnleaseAndLease(0)
482+                            else nil
483+                        $Tuple2(([IntegerEntry(keySwapUserSpentInPeriod(userAddressStr), swapUsdnVolume), IntegerEntry(keyUserLastSwapHeight(userAddressStr), height), IntegerEntry(totalLockedByUserKEY(swapType, userAddressStr), (totalLockedByUser + pmtAmount)), IntegerEntry(getBalanceUnlockBlockKey(userAddressStr), selfUnlockHeight), IntegerEntry(totalLockedKEY(swapType), (totalLocked + pmtAmount)), StringEntry(swapKEY(userAddressStr, txId58), pendingSwapDATA(swapType, pmtAmount, selfUnlockHeight))] ++ leasePart), unit)
484+                        }
485+    }
486+
487+
488+let nMetricIdxPrice = 0
489+
490+let nMetricIdxUsdnLockedBalance = 1
491+
492+let nMetricIdxWavesLockedBalance = 2
493+
494+let nMetricIdxReserve = 3
495+
496+let nMetricIdxReserveInUsdn = 4
497+
498+let nMetricIdxUsdnSupply = 5
499+
500+let nMetricIdxSurplus = 6
501+
502+let nMetricIdxSurplusPercent = 7
503+
504+let nMetricIdxBR = 8
505+
506+let nMetricIdxNsbtSupply = 9
507+
508+let nMetricIdxMaxNsbtSupply = 10
509+
510+let nMetricIdxSurfSupply = 11
511+
512+let bFuncIdxSurf = 0
513+
514+let bFuncIdxWaves = 1
515+
516+let bFuncIdxUsdn = 2
517+
518+let bFuncIdxReserveStart = 3
519+
520+let bFuncIdxSupplyStart = 4
521+
522+let bFuncIdxBRStart = 5
523+
524+let bFuncIdxReserveEnd = 6
525+
526+let bFuncIdxSupplyEnd = 7
527+
528+let bFuncIdxBREnd = 8
529+
530+let bFuncIdxRest = 9
531+
532+let bFuncIdxWavesPrice = 10
533+
534+func calcWithdrawW2U (wavesIn,price) = {
535+    let outAmtGross = convertWavesToNeutrino(wavesIn, price)
536+    $Tuple9(outAmtGross, neutrinoAssetId, 0, unit, 0, wavesIn, 0, 0, 0)
537+    }
538+
539+
540+func calcWithdrawU2W (usdnIn,price,br,reservesInUsdn,usdnSupply) = {
541+    let brProtected = valueOrElse(getInteger(this, brProtectedKEY()), BRPROTECTED)
542+    let maxAllowedUsdnBeforeMinBr = if ((brProtected >= br))
543+        then 0
544+        else fraction((reservesInUsdn - fraction(brProtected, usdnSupply, PAULI)), PAULI, (PAULI - brProtected))
545+    let allowedUsdnBeforeMinBr = if ((usdnIn > maxAllowedUsdnBeforeMinBr))
546+        then maxAllowedUsdnBeforeMinBr
547+        else usdnIn
548+    let allowedUsdnAfterMinBr = if ((usdnIn > maxAllowedUsdnBeforeMinBr))
549+        then fraction((usdnIn - maxAllowedUsdnBeforeMinBr), br, PAULI)
550+        else 0
551+    let allowedUsdn = (allowedUsdnBeforeMinBr + allowedUsdnAfterMinBr)
552+    let usdn2SURF = (usdnIn - allowedUsdn)
553+    let outAmtGross = convertNeutrinoToWaves(allowedUsdn, price)
554+    $Tuple9(outAmtGross, unit, usdn2SURF, neutrinoAssetId, outAmtGross, allowedUsdn, maxAllowedUsdnBeforeMinBr, allowedUsdnBeforeMinBr, allowedUsdnAfterMinBr)
555+    }
556+
557+
558+func calcWithdraw (swapType,inAmount,price,neutrinoMetrics) = {
559+    let outFeePart = valueOrElse(getInteger(this, outFeePartKEY(swapType)), DEFAULTSWAPFEE)
560+    if (if ((0 > outFeePart))
561+        then true
562+        else (outFeePart >= PAULI))
563+        then throw(((("invalid outFeePart config for " + swapType) + " swap: outFeePart=") + toString(outFeePart)))
564+        else {
565+            let brProtected = valueOrElse(getInteger(this, brProtectedKEY()), BRPROTECTED)
566+            let BR = asInt(neutrinoMetrics[nMetricIdxBR])
567+            let reservesInUsdn = asInt(neutrinoMetrics[nMetricIdxReserveInUsdn])
568+            let usdnSupply = asInt(neutrinoMetrics[nMetricIdxUsdnSupply])
569+            let outDataTuple = if ((swapType == "waves"))
570+                then calcWithdrawW2U(inAmount, price)
571+                else if ((swapType == "neutrino"))
572+                    then calcWithdrawU2W(inAmount, price, BR, reservesInUsdn, usdnSupply)
573+                    else throw(("Unsupported swap type " + swapType))
574+            let outAmtGross = outDataTuple._1
575+            let outAssetId = outDataTuple._2
576+            let inAmtToSurfPart = outDataTuple._3
577+            let inAssetId = outDataTuple._4
578+            let unleaseAmt = outDataTuple._5
579+            let payoutsArray = applyFees(outAmtGross, inAmtToSurfPart, outFeePart)
580+            let outNetAmt = payoutsArray[IdxNetAmount]
581+            let outFeeAmt = payoutsArray[IdxFeeAmount]
582+            let outSurfAmt = if ((0 >= inAmtToSurfPart))
583+                then 0
584+                else {
585+                    let surfResult = asAnyList(invoke(mathContract, "surfFunctionREADONLY", [inAmtToSurfPart, inAssetId], nil))
586+                    asInt(surfResult[bFuncIdxSurf])
587+                    }
588+            $Tuple7(outNetAmt, outAssetId, outSurfAmt, inAmtToSurfPart, unleaseAmt, outFeeAmt, outAmtGross)
589+            }
590+    }
591+
592+
593+func commonWithdraw (account,index,swapTxId,withdrawTxId,neutrinoMetrics) = {
594+    let userAddress = addressFromStringValue(account)
595+    let dataArray = swapDataFailOrREAD(account, swapTxId)
596+    let selfUnlockHeight = parseIntValue(dataArray[sIdxSelfUnlockHeight])
597+    let swapType = dataArray[sIdxSwapType]
598+    let inAmount = parseIntValue(dataArray[sIdxInAmount])
599+    let swapStatus = dataArray[sIdxStatus]
600+    let startHeight = parseIntValue(dataArray[sIdxStartHeight])
601+    let outFeePart = valueOrElse(getInteger(this, outFeePartKEY(swapType)), DEFAULTSWAPFEE)
602+    let totalLocked = totalLockedREAD(swapType)
603+    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
604+    let unlockHeight = selfUnlockHeight
605+    let indexHeight = getHeightPriceByIndex(index)
606+    let prevIndexHeight = getHeightPriceByIndex((index - 1))
607+    let priceByIndex = getPriceHistory(indexHeight)
608+    if (isBlocked)
609+        then emergencyShutdownFAIL()
610+        else if ((swapStatus != "PENDING"))
611+            then throw("swap has been already processed")
612+            else if ((unlockHeight > height))
613+                then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw funds"))
614+                else if (if (if ((index > priceIndex))
615+                    then true
616+                    else (unlockHeight > indexHeight))
617+                    then true
618+                    else if ((prevIndexHeight != 0))
619+                        then (prevIndexHeight >= unlockHeight)
620+                        else false)
621+                    then priceIndexFAIL(index, priceIndex, indexHeight, unlockHeight, prevIndexHeight)
622+                    else {
623+                        let withdrawTuple = calcWithdraw(swapType, inAmount, priceByIndex, neutrinoMetrics)
624+                        let outNetAmount = withdrawTuple._1
625+                        let outAssetId = withdrawTuple._2
626+                        let outSurfAmt = withdrawTuple._3
627+                        let inAmtToSurfPart = withdrawTuple._4
628+                        let unleaseAmt = withdrawTuple._5
629+                        let outFeeAmount = withdrawTuple._6
630+                        let outAmtGross = withdrawTuple._7
631+                        if ((0 >= outAmtGross))
632+                            then throw("balance equals zero")
633+                            else {
634+                                let BR = asInt(neutrinoMetrics[nMetricIdxBR])
635+                                let state = [IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser - inAmount)), IntegerEntry(totalLockedKEY(swapType), (totalLocked - inAmount)), ScriptTransfer(userAddress, outNetAmount, outAssetId), StringEntry(swapKEY(account, swapTxId), finishSwapDATA(dataArray, priceByIndex, outNetAmount, outFeeAmount, unlockHeight, index, withdrawTxId, outSurfAmt, BR))]
636+                                let surfCondition = if ((outSurfAmt > 0))
637+                                    then {
638+                                        let issueResult = invoke(auctionContract, "issueSurf", [outSurfAmt, account], nil)
639+                                        if ((issueResult == issueResult))
640+                                            then 0
641+                                            else throw("Strict value is not equal to itself.")
642+                                        }
643+                                    else 0
644+                                if ((surfCondition == surfCondition))
645+                                    then $Tuple3(state, AttachedPayment(outAssetId, outFeeAmount), unleaseAmt)
646+                                    else throw("Strict value is not equal to itself.")
647+                                }
648+                        }
649+    }
650+
651+
652+@Callable(i)
653+func constructor (neutrinoAssetIdPrm,bondAssetIdPrm,auctionContractPrm,liquidationContractPrm,rpdContractPrm,nodeOracleProviderPubKeyPrm,balanceWavesLockIntervalPrm,balanceNeutrinoLockIntervalPrm,minWavesSwapAmountPrm,minNeutrinoSwapAmountPrm,neutrinoOutFeePartPrm,wavesOutFeePartPrm) = {
654+    let checkCaller = thisOnly(i)
655+    if ((checkCaller == checkCaller))
656+        then if ((size(i.payments) != 0))
657+            then throw("no payments allowed")
658+            else [StringEntry(NeutrinoAssetIdKey, neutrinoAssetIdPrm), StringEntry(BondAssetIdKey, bondAssetIdPrm), StringEntry(AuctionContractKey, auctionContractPrm), StringEntry(LiquidationContractKey, liquidationContractPrm), StringEntry(RPDContractKey, rpdContractPrm), StringEntry(NodeOracleProviderPubKeyKey, nodeOracleProviderPubKeyPrm), IntegerEntry(BalanceWavesLockIntervalKey, balanceWavesLockIntervalPrm), IntegerEntry(BalanceNeutrinoLockIntervalKey, balanceNeutrinoLockIntervalPrm), IntegerEntry(MinWavesSwapAmountKey, minWavesSwapAmountPrm), IntegerEntry(MinNeutrinoSwapAmountKey, minNeutrinoSwapAmountPrm), IntegerEntry(NeutrinoOutFeePartKey, neutrinoOutFeePartPrm), IntegerEntry(WavesOutFeePartKey, wavesOutFeePartPrm)]
659+        else throw("Strict value is not equal to itself.")
660+    }
661+
662+
663+
664+@Callable(i)
665+func constructorV2 (mathContract,nsbtStakingContract,swapsTimeframeBlocks) = {
666+    let checkCaller = thisOnly(i)
667+    if ((checkCaller == checkCaller))
668+        then if ((size(i.payments) != 0))
669+            then throw("no payments allowed")
670+            else [StringEntry(MathContractKey, mathContract), StringEntry(NsbtStakingContractKey, nsbtStakingContract), IntegerEntry(swapsTimeframeKEY(), swapsTimeframeBlocks)]
671+        else throw("Strict value is not equal to itself.")
672+    }
673+
674+
675+
676+@Callable(i)
677+func swapWavesToNeutrino () = if ((size(i.payments) != 1))
678+    then throw("swapWavesToNeutrino require only one payment")
679+    else {
680+        let pmt = value(i.payments[0])
681+        if (isDefined(pmt.assetId))
682+            then throw("Only Waves token is allowed for swapping.")
683+            else {
684+                let userAddress = toString(i.caller)
685+                let txId58 = toBase58String(i.transactionId)
686+                let swapParamsSTRUCT = asSwapParamsSTRUCT(invoke(this, "swapParamsByUserSYSREADONLY", [userAddress, 0], nil))
687+                let commonSwapResult = commonSwap("waves", pmt.amount, userAddress, txId58, swapParamsSTRUCT)
688+                commonSwapResult
689+                }
690+        }
691+
692+
693+
694+@Callable(i)
695+func swapNeutrinoToWaves () = if ((size(i.payments) != 1))
696+    then throw("swapNeutrinoToWaves require only one payment")
697+    else {
698+        let pmt = value(i.payments[0])
699+        if ((pmt.assetId != neutrinoAssetId))
700+            then throw("Only appropriate Neutrino tokens are allowed for swapping.")
701+            else {
702+                let userAddress = toString(i.caller)
703+                let txId58 = toBase58String(i.transactionId)
704+                let swapParamsSTRUCT = asSwapParamsSTRUCT(invoke(this, "swapParamsByUserSYSREADONLY", [userAddress, 0], nil))
705+                let commonSwapResult = commonSwap("neutrino", pmt.amount, userAddress, txId58, swapParamsSTRUCT)
706+                commonSwapResult
707+                }
708+        }
709+
710+
711+
712+@Callable(i)
713+func withdraw (account,index,swapTxId) = {
714+    let txId = toBase58String(i.transactionId)
715+    if ((size(i.payments) != 0))
716+        then throw("no payments allowed")
717+        else {
718+            let neutrinoMetrics = asAnyList(invoke(mathContract, "calcNeutinoMetricsREADONLY", nil, nil))
719+            let BR = asInt(neutrinoMetrics[nMetricIdxBR])
720+            let commonTuple = commonWithdraw(account, index, swapTxId, txId, neutrinoMetrics)
721+            let state = commonTuple._1
722+            let fee = commonTuple._2
723+            let unleaseAmt = commonTuple._3
724+            let unleaseInvOrEmpty = invoke(this, "internalUnleaseAndLease", [unleaseAmt], nil)
725+            if ((unleaseInvOrEmpty == unleaseInvOrEmpty))
726+                then {
727+                    let gnsbtData = asAnyList(invoke(gnsbtControllerContract, "gnsbtInfoSYSREADONLY", ["", 0, 0], nil))
728+                    let gnsbtAmtTotal = asInt(gnsbtData[1])
729+                    let gnsbtAmtFromSurfTotal = asInt(asAnyList(gnsbtData[3])[3])
730+                    let surfFeeAmt1 = if ((gnsbtAmtTotal != 0))
731+                        then fraction(fee.amount, gnsbtAmtFromSurfTotal, gnsbtAmtTotal)
732+                        else 0
733+                    let surfFeeAmt2 = if ((gnsbtAmtTotal != 0))
734+                        then fraction(fee.amount, (PAULI - BR), PAULI)
735+                        else 0
736+                    let surfFeeAmt = max([surfFeeAmt1, surfFeeAmt2])
737+                    let nsbtFeeAmt = (fee.amount - surfFeeAmt)
738+                    let surfDeposit = if ((surfFeeAmt > 0))
739+                        then {
740+                            let surfInv = invoke(surfStakingContract, "deposit", nil, [AttachedPayment(fee.assetId, surfFeeAmt)])
741+                            if ((surfInv == surfInv))
742+                                then nil
743+                                else throw("Strict value is not equal to itself.")
744+                            }
745+                        else nil
746+                    if ((surfDeposit == surfDeposit))
747+                        then {
748+                            let nsbtDeposit = if ((nsbtFeeAmt > 0))
749+                                then {
750+                                    let nsbtInv = invoke(nsbtStakingContract, "deposit", nil, [AttachedPayment(fee.assetId, nsbtFeeAmt)])
751+                                    if ((nsbtInv == nsbtInv))
752+                                        then nil
753+                                        else throw("Strict value is not equal to itself.")
754+                                    }
755+                                else nil
756+                            if ((nsbtDeposit == nsbtDeposit))
757+                                then state
758+                                else throw("Strict value is not equal to itself.")
759+                            }
760+                        else throw("Strict value is not equal to itself.")
761+                    }
762+                else throw("Strict value is not equal to itself.")
763+            }
764+    }
765+
766+
767+
768+@Callable(i)
769+func internalUnleaseAndLease (unleaseAmount) = if ((i.caller != this))
770+    then throw("internalUnleaseAndLease is not public method")
771+    else prepareUnleaseAndLease(unleaseAmount)
772+
773+
774+
775+@Callable(i)
776+func transferUsdnToUser (amount,addr) = if ((i.caller != auctionContract))
777+    then throw("Only auction contract is authorized")
778+    else [ScriptTransfer(addressFromStringValue(addr), amount, neutrinoAssetId)]
779+
780+
781+
782+@Callable(i)
783+func acceptWaves () = if ((i.caller != auctionContract))
784+    then throw("Currently only auction contract is allowed to call")
785+    else $Tuple2(prepareUnleaseAndLease(0), "success")
786+
787+
788+
789+@Callable(i)
790+func approveLeasings (nListS,groupNum,lAmt) = {
791+    let nIdxs = [0, 1, 2, 3, 4, 5, 6, 7]
792+    let mngPubS = valueOrElse(getString("%s%s__cfg__leasingManagerPub"), "7AUMX54ukYMYvPmma7yoFf5NjZhs4Bu5nz3Ez9EV8sur")
793+    let mngPub = fromBase58String(mngPubS)
794+    let nodeRegAddrStr = valueOrElse(getString("%s%s__cfg__nodesRegistryAddress"), "3P9vKqQKjUdmpXAfiWau8krREYAY1Xr69pE")
795+    let nodeRegAddr = addressFromStringValue(nodeRegAddrStr)
796+    let lGroupNodeListKEY = getLeaseGroupNodeListKey(groupNum)
797+    let lGrNodeOpt = getString(this, lGroupNodeListKEY)
798+    if (isDefined(lGrNodeOpt))
799+        then throw((("group " + toString(groupNum)) + " already initialized"))
800+        else {
801+            let nList = split(nListS, SEP)
802+            let expCount = size(nIdxs)
803+            if ((i.callerPublicKey != mngPub))
804+                then throw("approveLeasings not authorized")
805+                else {
806+                    let $t03442434486 = readNodeInfo(0)
807+                    let nAddr0 = $t03442434486._1
808+                    let lAmtKEY0 = $t03442434486._2
809+                    let lAmt0 = $t03442434486._3
810+                    let lIdKEY0 = $t03442434486._4
811+                    let lId0 = $t03442434486._5
812+                    let newL0 = Lease(nAddr0, (lAmt0 - (lAmt * expCount)))
813+                    let validation = invoke(nodeRegAddr, "validateAndApproveLeasings", [nListS], nil)
814+                    if ((validation == validation))
815+                        then {
816+                            func forEachNodeValidateAndGenerateLease (a,i) =                             {
817+                                let node = nList[i]
818+                                let la = Lease(addressFromStringValue(node), lAmt)
819+                                (a ++ [la, BinaryEntry(getLeaseIdByAddressKey(node), lcalc(la)), IntegerEntry(getLeaseAmountByAddressKey(node), lAmt)])
820+                                }
821+
822+                            ([StringEntry(lGroupNodeListKEY, nListS), BinaryEntry(lIdKEY0, lcalc(newL0)), IntegerEntry(lAmtKEY0, newL0.amount), LeaseCancel(lId0), newL0] ++ {
823+                                let $l = nIdxs
824+                                let $s = size($l)
825+                                let $acc0 = nil
826+                                func $f0_1 ($a,$i) =                                 if (($i >= $s))
827+                                    then $a
828+                                    else forEachNodeValidateAndGenerateLease($a, $l[$i])
829+
830+                                func $f0_2 ($a,$i) =                                 if (($i >= $s))
831+                                    then $a
832+                                    else throw("List size exceeds 8")
833+
834+                                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8)
835+                                })
836+                            }
837+                        else throw("Strict value is not equal to itself.")
838+                    }
839+            }
840+    }
841+
842+
843+
844+@Callable(i)
845+func rebalanceLeasings (amount,groupNum) = {
846+    let nIdxs = [0, 1, 2, 3, 4, 5, 6, 7]
847+    let mngPubS = valueOrElse(getString("%s%s__cfg__leasingManagerPub"), "7AUMX54ukYMYvPmma7yoFf5NjZhs4Bu5nz3Ez9EV8sur")
848+    let mngPub = fromBase58String(mngPubS)
849+    let lGroupNodeListKEY = getLeaseGroupNodeListKey(groupNum)
850+    let nListS = getStringOrFail(this, lGroupNodeListKEY)
851+    let nList = split(nListS, SEP)
852+    if ((i.callerPublicKey != mngPub))
853+        then throw("rebalanceLeasings not authorized")
854+        else {
855+            let unleaseAmt = ((amount / size(nList)) + 1)
856+            let $t03572635788 = readNodeInfo(0)
857+            let nAddr0 = $t03572635788._1
858+            let lAmtKEY0 = $t03572635788._2
859+            let lAmt0 = $t03572635788._3
860+            let lIdKEY0 = $t03572635788._4
861+            let lId0 = $t03572635788._5
862+            let newL0 = Lease(nAddr0, (lAmt0 + (unleaseAmt * size(nList))))
863+            func forEachNodeDoUnlease (a,i) =             {
864+                let node = nList[i]
865+                let lIdKEY = getLeaseIdByAddressKey(node)
866+                let lId = getBinaryValue(this, lIdKEY)
867+                let lAmtKEY = getLeaseAmountByAddressKey(node)
868+                let lAmt = getIntegerValue(this, lAmtKEY)
869+                let ula = LeaseCancel(value(lId))
870+                let la = Lease(addressFromStringValue(node), (lAmt - unleaseAmt))
871+                (a ++ [LeaseCancel(value(lId)), la, BinaryEntry(lIdKEY, lcalc(la)), IntegerEntry(lAmtKEY, la.amount)])
872+                }
873+
874+            ({
875+                let $l = nIdxs
876+                let $s = size($l)
877+                let $acc0 = nil
878+                func $f0_1 ($a,$i) =                 if (($i >= $s))
879+                    then $a
880+                    else forEachNodeDoUnlease($a, $l[$i])
881+
882+                func $f0_2 ($a,$i) =                 if (($i >= $s))
883+                    then $a
884+                    else throw("List size exceeds 8")
885+
886+                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8)
887+                } ++ [BinaryEntry(lIdKEY0, lcalc(newL0)), IntegerEntry(lAmtKEY0, newL0.amount), LeaseCancel(lId0), newL0])
888+            }
889+    }
890+
891+
892+
893+@Callable(i)
894+func swapParamsByUserSYSREADONLY (userAddressStr,gnsbtDiff) = {
895+    let gnsbtData = asAnyList(invoke(gnsbtControllerContract, "gnsbtInfoSYSREADONLY", [userAddressStr, 0, 0], nil))
896+    let gnsbtAmt = (asInt(gnsbtData[0]) + gnsbtDiff)
897+    let gnsbtAmtTotal = (asInt(gnsbtData[1]) + gnsbtDiff)
898+    let swapLimitData = asAnyList(invoke(mathContract, "calcSwapLimitREADONLY", [gnsbtAmt], nil))
899+    let wavesSwapLimitInUsdnMax = asInt(swapLimitData[0])
900+    let wavesSwapLimitMax = asInt(swapLimitData[1])
901+    let usdnSwapLimitMax = asInt(swapLimitData[2])
902+    let lastSwapHeight = valueOrElse(getInteger(this, keyUserLastSwapHeight(userAddressStr)), 0)
903+    let swapLimitTimelifeBlocks = swapsTimeframeREAD()
904+    let passedBlocksAfterLastSwap = (height - lastSwapHeight)
905+    let isSwapTimelifeNew = (passedBlocksAfterLastSwap >= swapLimitTimelifeBlocks)
906+    let swapLimitSpentInUsdn = if (isSwapTimelifeNew)
907+        then 0
908+        else valueOrElse(getInteger(this, keySwapUserSpentInPeriod(userAddressStr)), 0)
909+    let blcks2LmtReset = if (isSwapTimelifeNew)
910+        then 0
911+        else (swapLimitTimelifeBlocks - passedBlocksAfterLastSwap)
912+    $Tuple2(nil, $Tuple7(wavesSwapLimitInUsdnMax, swapLimitSpentInUsdn, blcks2LmtReset, gnsbtAmt, gnsbtAmtTotal, wavesSwapLimitMax, usdnSwapLimitMax))
913+    }
914+
915+
916+
917+@Callable(i)
918+func calcWithdrawResultSYSREADONLY (swapType,inAmount,price) = {
919+    let neutrinoMetrics = asAnyList(invoke(mathContract, "calcNeutinoMetricsREADONLY", nil, nil))
920+    $Tuple2(nil, calcWithdraw(swapType, inAmount, price, neutrinoMetrics))
921+    }
922+
923+
924+
925+@Callable(i)
926+func replaceCommunityNode (oldAddrStr,newAddrStr,groupNum,penaltyAmount) = {
927+    let mngPubS = valueOrElse(getString("%s%s__cfg__leasingManagerPub"), "7AUMX54ukYMYvPmma7yoFf5NjZhs4Bu5nz3Ez9EV8sur")
928+    let mngPub = fromBase58String(mngPubS)
929+    if ((i.callerPublicKey != mngPub))
930+        then throw("replaceCommunityNode not authorized")
931+        else {
932+            let groupKey = getLeaseGroupNodeListKey(groupNum)
933+            let groupNodeListS = getStringOrFail(this, groupKey)
934+            if (!(contains(groupNodeListS, oldAddrStr)))
935+                then throw(((("Group " + toString(groupNum)) + " does not contain address ") + oldAddrStr))
936+                else {
937+                    let doReplace = invoke(nodeRegistryContract, "replaceApprovedNode", [oldAddrStr, newAddrStr, groupNum, penaltyAmount], nil)
938+                    if ((doReplace == doReplace))
939+                        then {
940+                            let oldLeaseIdKey = getLeaseIdByAddressKey(oldAddrStr)
941+                            let oldLeaseAmtKey = getLeaseAmountByAddressKey(oldAddrStr)
942+                            let leaseAmt = getIntegerValue(oldLeaseAmtKey)
943+                            let newLeaseIdKey = getLeaseIdByAddressKey(oldAddrStr)
944+                            let newLeaseAmtKey = getLeaseAmountByAddressKey(oldAddrStr)
945+                            let newLease = Lease(addressFromStringValue(newAddrStr), leaseAmt)
946+                            let updatedGroupNodeListS = makeString(split(groupNodeListS, oldAddrStr), newAddrStr)
947+                            $Tuple2([LeaseCancel(getBinaryValue(oldLeaseIdKey)), DeleteEntry(oldLeaseIdKey), DeleteEntry(oldLeaseAmtKey), StringEntry(groupKey, updatedGroupNodeListS), newLease, BinaryEntry(newLeaseIdKey, lcalc(newLease)), IntegerEntry(newLeaseAmtKey, leaseAmt)], unit)
948+                            }
949+                        else throw("Strict value is not equal to itself.")
950+                    }
951+            }
952+    }
953+
954+
955+@Verifier(tx)
956+func verify () = {
957+    let id = toBase58String(tx.id)
958+    let pubKeyAdminsListStr = makeString(["9so3YELTNtXgo1ZXBB9NB9T6ufy6Jt3yUtfPyg11hV1v", "EYwZmURd5KKaQRBjsVa6g8DPisFoS6SovRJtFiL5gMHU", "DtmAfuDdCrHK8spdAeAYzq6MsZegeD9gnsrpuTRkCbVA", "9so3YELTNtXgo1ZXBB9NB9T6ufy6Jt3yUtfPyg11hV1v"], SEP)
959+    let pubKeyAdminsList = split(valueOrElse(getString(controlContract, "%s__multisig"), pubKeyAdminsListStr), SEP)
960+    let count = ((((if (sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(pubKeyAdminsList[0])))
961+        then 1
962+        else 0) + (if (sigVerify(tx.bodyBytes, tx.proofs[1], fromBase58String(pubKeyAdminsList[1])))
963+        then 1
964+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[2], fromBase58String(pubKeyAdminsList[2])))
965+        then 1
966+        else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[3], fromBase58String(pubKeyAdminsList[3])))
967+        then 2
968+        else 0))
969+    match tx {
970+        case sponsorTx: SponsorFeeTransaction => 
971+            if (checkIsValidMinSponsoredFee(sponsorTx))
972+                then (count >= 3)
973+                else false
974+        case _ => 
975+            (count >= 3)
976+    }
977+    }
978+
github/deemru/w8io/026f985 
41.60 ms ◑