tx · HrYmWNzyHft45jNm2oSb2azkTdfvvAQAeqHWKtjwUW8k

3N9be2mwrA52WJho6DiesZkk4351GvpnWuj:  -0.01400000 Waves

2022.03.24 09:26 [1977639] smart account 3N9be2mwrA52WJho6DiesZkk4351GvpnWuj > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HrYmWNzyHft45jNm2oSb2azkTdfvvAQAeqHWKtjwUW8k",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1648103221142,
    "version": 1,
    "sender": "3N9be2mwrA52WJho6DiesZkk4351GvpnWuj",
    "senderPublicKey": "6mzmbCza9iqbzxMEELcEA4Xc9NeF4CYpbTtz1zMK3C7x",
    "proofs": [
        "4c1qoFtPJDqoCZ49ZVPfg945fmydBLDTVrqhYnwb2PuEjiUDZZwRfAuo6LrdGMKYBoWjiYYkd3fk98yxn2NJKRNn",
        "5tvonumqXTvB1uMMdM3EeCjLrCe45tSDa58nt5TzRX9WPfJ74MBRSTcAjV9pdKZ9upimd77SNxrNcBfqkCHD4CJm",
        "4n5saztkTZKo3DSwDN4eBXWHkhchL9RarH8k4m7oWRLBFauQLywYCH2dJTeoQc3XXALXS8kUkHe9tGBuyDGfYai5"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1977639,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: GYffL1ZfVL6Lwz5DfunscQ3hkzUvnyFiBCKMMKSYkZD5
Next: FtDNSChYhtAPm16gApha11hdpHjD7oyD4GUyieiUry2c

Diff: 

OldNewDifferences
400400     }
401401 
402402 
403-@Callable(i)
404403 func commonWithdraw (account,index,swapTxId,withdrawTxId) = {
405-    let checkCaller = thisOnly(i)
406-    if ((checkCaller == checkCaller))
407-        then if ((size(i.payments) != 0))
408-            then throw("no payments allowed")
409-            else {
410-                let userAddress = addressFromStringValue(account)
411-                let feeManagerAddress = feeManagerAddressREAD()
412-                let dataArray = swapDataFailOrREAD(account, swapTxId)
413-                let selfUnlockHeight = parseIntValue(dataArray[sIdxSelfUnlockHeight])
414-                let swapType = dataArray[sIdxSwapType]
415-                let inAmount = parseIntValue(dataArray[sIdxInAmount])
416-                let swapStatus = dataArray[sIdxStatus]
417-                let startHeight = parseIntValue(dataArray[sIdxStartHeight])
418-                let outFeePart = valueOrElse(getInteger(this, outFeePartKEY(swapType)), DEFAULTSWAPFEE)
419-                let totalLocked = totalLockedREAD(swapType)
420-                let totalLockedByUser = totalLockedByUserREAD(swapType, account)
421-                let unlockHeight = (startHeight + getIntegerValue(this, balanceLockIntervalKEY(swapType)))
422-                let indexHeight = getHeightPriceByIndex(index)
423-                let prevIndexHeight = getHeightPriceByIndex((index - 1))
424-                let priceByIndex = getPriceHistory(indexHeight)
425-                let outAmountGrossTuple = if ((swapType == "waves"))
426-                    then $Tuple2(convertWavesToNeutrino(inAmount, priceByIndex), neutrinoAssetId)
427-                    else if ((swapType == "neutrino"))
428-                        then $Tuple2(convertNeutrinoToWaves(inAmount, priceByIndex), unit)
429-                        else throw(("Unsupported swap type " + swapType))
430-                let payoutsArray = applyFees(outAmountGrossTuple._1, outFeePart)
431-                let outNetAmount = payoutsArray[IdxNetAmount]
432-                let outFeeAmount = payoutsArray[IdxFeeAmount]
433-                if (isBlocked)
434-                    then emergencyShutdownFAIL()
435-                    else if ((swapStatus != "PENDING"))
436-                        then throw("swap has been already processed")
437-                        else if ((unlockHeight > height))
438-                            then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw funds"))
439-                            else if (if (if ((index > priceIndex))
440-                                then true
441-                                else (unlockHeight > indexHeight))
442-                                then true
443-                                else if ((prevIndexHeight != 0))
444-                                    then (prevIndexHeight >= unlockHeight)
404+    let userAddress = addressFromStringValue(account)
405+    let feeManagerAddress = feeManagerAddressREAD()
406+    let dataArray = swapDataFailOrREAD(account, swapTxId)
407+    let selfUnlockHeight = parseIntValue(dataArray[sIdxSelfUnlockHeight])
408+    let swapType = dataArray[sIdxSwapType]
409+    let inAmount = parseIntValue(dataArray[sIdxInAmount])
410+    let swapStatus = dataArray[sIdxStatus]
411+    let startHeight = parseIntValue(dataArray[sIdxStartHeight])
412+    let outFeePart = valueOrElse(getInteger(this, outFeePartKEY(swapType)), DEFAULTSWAPFEE)
413+    let totalLocked = totalLockedREAD(swapType)
414+    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
415+    let unlockHeight = (startHeight + getIntegerValue(this, balanceLockIntervalKEY(swapType)))
416+    let indexHeight = getHeightPriceByIndex(index)
417+    let prevIndexHeight = getHeightPriceByIndex((index - 1))
418+    let priceByIndex = getPriceHistory(indexHeight)
419+    let outAmountGrossTuple = if ((swapType == "waves"))
420+        then $Tuple2(convertWavesToNeutrino(inAmount, priceByIndex), neutrinoAssetId)
421+        else if ((swapType == "neutrino"))
422+            then $Tuple2(convertNeutrinoToWaves(inAmount, priceByIndex), unit)
423+            else throw(("Unsupported swap type " + swapType))
424+    let payoutsArray = applyFees(outAmountGrossTuple._1, outFeePart)
425+    let outNetAmount = payoutsArray[IdxNetAmount]
426+    let outFeeAmount = payoutsArray[IdxFeeAmount]
427+    if (isBlocked)
428+        then emergencyShutdownFAIL()
429+        else if ((swapStatus != "PENDING"))
430+            then throw("swap has been already processed")
431+            else if ((unlockHeight > height))
432+                then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw funds"))
433+                else if (if (if ((index > priceIndex))
434+                    then true
435+                    else (unlockHeight > indexHeight))
436+                    then true
437+                    else if ((prevIndexHeight != 0))
438+                        then (prevIndexHeight >= unlockHeight)
439+                        else false)
440+                    then priceIndexFAIL(index, priceIndex, indexHeight, unlockHeight, prevIndexHeight)
441+                    else if ((0 >= payoutsArray[IdxGrossAmount]))
442+                        then throw("balance equals zero")
443+                        else if (if ((0 > outFeePart))
444+                            then true
445+                            else (outFeePart >= PAULI))
446+                            then throw(((("invalid outFeePart config for " + swapType) + " swap: outFeePart=") + toString(outFeePart)))
447+                            else {
448+                                let leasePart = if (if ((swapType == "neutrino"))
449+                                    then (outAmountGrossTuple._1 > 0)
445450                                     else false)
446-                                then priceIndexFAIL(index, priceIndex, indexHeight, unlockHeight, prevIndexHeight)
447-                                else if ((0 >= payoutsArray[IdxGrossAmount]))
448-                                    then throw("balance equals zero")
449-                                    else if (if ((0 > outFeePart))
450-                                        then true
451-                                        else (outFeePart >= PAULI))
452-                                        then throw(((("invalid outFeePart config for " + swapType) + " swap: outFeePart=") + toString(outFeePart)))
453-                                        else {
454-                                            let leasePart = if (if ((swapType == "neutrino"))
455-                                                then (outAmountGrossTuple._1 > 0)
456-                                                else false)
457-                                                then prepareUnleaseAndLease(outAmountGrossTuple._1)
458-                                                else nil
459-                                            let nsbtStakingDeposit = invoke(nsbtStakingContract, "deposit", nil, [AttachedPayment(outAmountGrossTuple._2, outFeeAmount)])
460-                                            if ((nsbtStakingDeposit == nsbtStakingDeposit))
461-                                                then $Tuple2((leasePart ++ [IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser - inAmount)), IntegerEntry(totalLockedKEY(swapType), (totalLocked - inAmount)), ScriptTransfer(userAddress, outNetAmount, outAmountGrossTuple._2), StringEntry(swapKEY(account, swapTxId), finishSwapDATA(dataArray, priceByIndex, outNetAmount, outFeeAmount, unlockHeight, index, toBase58String(i.transactionId)))]), unit)
462-                                                else throw("Strict value is not equal to itself.")
463-                                            }
464-                }
465-        else throw("Strict value is not equal to itself.")
451+                                    then prepareUnleaseAndLease(outAmountGrossTuple._1)
452+                                    else nil
453+                                let state = (leasePart ++ [IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser - inAmount)), IntegerEntry(totalLockedKEY(swapType), (totalLocked - inAmount)), ScriptTransfer(userAddress, outNetAmount, outAmountGrossTuple._2), StringEntry(swapKEY(account, swapTxId), finishSwapDATA(dataArray, priceByIndex, outNetAmount, outFeeAmount, unlockHeight, index, withdrawTxId))])
454+                                $Tuple2(state, AttachedPayment(outAmountGrossTuple._2, outFeeAmount))
455+                                }
466456     }
467-
468457 
469458 
470459 @Callable(i)
492481 
493482 
494483 @Callable(i)
495-func swapWavesToNeutrino () = {
496-    let pmt = value(i.payments[0])
497-    if (isDefined(pmt.assetId))
498-        then throw("Only Waves token is allowed for swapping.")
499-        else if ((size(i.payments) > 1))
500-            then throw("swapWavesToNeutrino require only one payment")
484+func swapWavesToNeutrino () = if ((size(i.payments) != 1))
485+    then throw("swapWavesToNeutrino require only one payment")
486+    else {
487+        let pmt = value(i.payments[0])
488+        if (isDefined(pmt.assetId))
489+            then throw("Only Waves token is allowed for swapping.")
501490             else {
502491                 let userAddress = toString(i.caller)
503492                 let txId58 = toBase58String(i.transactionId)
505494                 let commonSwapResult = commonSwap("waves", pmt.amount, userAddress, txId58, swapParamsSTRUCT)
506495                 commonSwapResult
507496                 }
508-    }
497+        }
509498 
510499 
511500 
512501 @Callable(i)
513-func swapNeutrinoToWaves () = {
514-    let pmt = value(i.payments[0])
515-    if ((pmt.assetId != neutrinoAssetId))
516-        then throw("Only appropriate Neutrino tokens are allowed for swapping.")
517-        else if ((size(i.payments) > 1))
518-            then throw("swapNeutrinoToWaves require only one payment")
502+func swapNeutrinoToWaves () = if ((size(i.payments) != 1))
503+    then throw("swapNeutrinoToWaves require only one payment")
504+    else {
505+        let pmt = value(i.payments[0])
506+        if ((pmt.assetId != neutrinoAssetId))
507+            then throw("Only appropriate Neutrino tokens are allowed for swapping.")
519508             else {
520509                 let userAddress = toString(i.caller)
521510                 let txId58 = toBase58String(i.transactionId)
523512                 let commonSwapResult = commonSwap("neutrino", pmt.amount, userAddress, txId58, swapParamsSTRUCT)
524513                 commonSwapResult
525514                 }
526-    }
515+        }
527516 
528517 
529518 
531520 func withdraw (account,index,swapTxId) = if ((size(i.payments) != 0))
532521     then throw("no payments allowed")
533522     else {
534-        let commonWithdrawInv = invoke(this, "commonWithdraw", [account, index, swapTxId, toBase58String(i.transactionId)], nil)
535-        if ((commonWithdrawInv == commonWithdrawInv))
536-            then nil
523+        let $t02418624290 = commonWithdraw(account, index, swapTxId, toBase58String(i.transactionId))
524+        let state = $t02418624290._1
525+        let depositPayment = $t02418624290._2
526+        let nsbtStakingDeposit = invoke(nsbtStakingContract, "deposit", nil, [depositPayment])
527+        if ((nsbtStakingDeposit == nsbtStakingDeposit))
528+            then state
537529             else throw("Strict value is not equal to itself.")
538530         }
539531 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 func getNumberByKey (key) = valueOrElse(getInteger(this, key), 0)
55 
66 
77 func getStringByKey (key) = valueOrElse(getString(this, key), "")
88 
99 
1010 func getBoolByKey (key) = valueOrElse(getBoolean(this, key), false)
1111 
1212 
1313 func getNumberByAddressAndKey (address,key) = valueOrElse(getInteger(addressFromStringValue(address), key), 0)
1414 
1515 
1616 func getStringByAddressAndKey (address,key) = valueOrElse(getString(addressFromStringValue(address), key), "")
1717 
1818 
1919 func getBoolByAddressAndKey (address,key) = valueOrElse(getBoolean(addressFromStringValue(address), key), false)
2020 
2121 
2222 func asAnyList (val) = match val {
2323     case valAnyLyst: List[Any] => 
2424         valAnyLyst
2525     case _ => 
2626         throw("fail to cast into List[Any]")
2727 }
2828 
2929 
3030 func asString (val) = match val {
3131     case valStr: String => 
3232         valStr
3333     case _ => 
3434         throw("fail to cast into String")
3535 }
3636 
3737 
3838 func asInt (val) = match val {
3939     case valInt: Int => 
4040         valInt
4141     case _ => 
4242         throw("fail to cast into Int")
4343 }
4444 
4545 
4646 func asSwapParamsSTRUCT (val) = match val {
4747     case struct: (Int, Int, Int, Int, Int) => 
4848         struct
4949     case _ => 
5050         throw("fail to cast into Int")
5151 }
5252 
5353 
5454 let pubKeyAdminsList = ["ExtEEK19nmKj9mCpnWyvEEJFYATLMcVEMvohhUHkyHNm", "Ev5py5FfBQX9cZpYKnfQrTB49Byf8QmpZWeDVRim4yV7", "DUuuLjXu98nBwZc7fqwCTjtA3nnRwgTbkMSr5SU2NmDR", "5WRXFSjwcTbNfKcJs8ZqXmSSWYsSVJUtMvMqZj5hH4Nc"]
5555 
5656 let SEP = "__"
5757 
5858 let WAVELET = 100000000
5959 
6060 let PAULI = 1000000
6161 
6262 let PRICELET = 1000000
6363 
6464 let DEFAULTSWAPFEE = 20000
6565 
6666 let IdxNetAmount = 0
6767 
6868 let IdxFeeAmount = 1
6969 
7070 let IdxGrossAmount = 2
7171 
7272 let NeutrinoAssetIdKey = "neutrino_asset_id"
7373 
7474 let BondAssetIdKey = "bond_asset_id"
7575 
7676 let AuctionContractKey = "auction_contract"
7777 
7878 let NsbtStakingContractKey = "nsbtStakingContract"
7979 
8080 let LiquidationContractKey = "liquidation_contract"
8181 
8282 let RPDContractKey = "rpd_contract"
8383 
8484 let ContolContractKey = "control_contract"
8585 
8686 let MathContractKey = "math_contract"
8787 
8888 let BalanceWavesLockIntervalKey = "balance_waves_lock_interval"
8989 
9090 let BalanceNeutrinoLockIntervalKey = "balance_neutrino_lock_interval"
9191 
9292 let MinWavesSwapAmountKey = "min_waves_swap_amount"
9393 
9494 let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
9595 
9696 let NodeOracleProviderPubKeyKey = "node_oracle_provider"
9797 
9898 let NeutrinoOutFeePartKey = "neutrinoOut_swap_feePart"
9999 
100100 let WavesOutFeePartKey = "wavesOut_swap_feePart"
101101 
102102 let FeesManagerAddressKey = "fees_manager_address"
103103 
104104 let PriceKey = "price"
105105 
106106 let PriceIndexKey = "price_index"
107107 
108108 let IsBlockedKey = "is_blocked"
109109 
110110 func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
111111 
112112 
113113 func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
114114 
115115 
116116 func getStakingNodeByIndex (idx) = getStringByKey(makeString(["%s%d%s", "lease", toString(idx), "nodeAddress"], SEP))
117117 
118118 
119119 func getStakingNodeAddressByIndex (idx) = addressFromStringValue(getStakingNodeByIndex(idx))
120120 
121121 
122122 func getReservedAmountForSponsorship () = valueOrElse(getInteger(this, makeString(["%s%s", "lease", "sponsorshipWavesReserve"], SEP)), (1000 * WAVELET))
123123 
124124 
125125 func getBalanceUnlockBlockKey (owner) = ("balance_unlock_block_" + owner)
126126 
127127 
128128 func getLeaseIdKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "id"], SEP)
129129 
130130 
131131 func getLeaseAmountKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "amount"], SEP)
132132 
133133 
134134 func minSwapAmountKEY (swapType) = (("min_" + swapType) + "_swap_amount")
135135 
136136 
137137 func totalLockedKEY (swapType) = ("balance_lock_" + swapType)
138138 
139139 
140140 func totalLockedByUserKEY (swapType,owner) = makeString(["balance_lock", swapType, owner], "_")
141141 
142142 
143143 func balanceLockIntervalKEY (swapType) = (("balance_" + swapType) + "_lock_interval")
144144 
145145 
146146 func nodeBalanceLockIntervalKEY () = "balance_node_lock_interval"
147147 
148148 
149149 func outFeePartKEY (swapType) = (swapType + "Out_swap_feePart")
150150 
151151 
152152 func swapsTimeframeKEY () = "swaps_timeframe"
153153 
154154 
155155 func minSwapAmountREAD (swapType) = valueOrElse(getInteger(this, minSwapAmountKEY(swapType)), 0)
156156 
157157 
158158 func swapsTimeframeREAD () = valueOrElse(getInteger(this, swapsTimeframeKEY()), 1440)
159159 
160160 
161161 func totalLockedREAD (swapType) = valueOrElse(getInteger(this, totalLockedKEY(swapType)), 0)
162162 
163163 
164164 func totalLockedByUserREAD (swapType,owner) = valueOrElse(getInteger(this, totalLockedByUserKEY(swapType, owner)), 0)
165165 
166166 
167167 func balanceLockIntervalREAD (swapType) = valueOrElse(getInteger(this, balanceLockIntervalKEY(swapType)), 1440)
168168 
169169 
170170 func nodeBalanceLockIntervalREAD () = valueOrElse(getInteger(this, nodeBalanceLockIntervalKEY()), 1)
171171 
172172 
173173 func keySwapUserSpentInPeriod (userAddress) = makeString(["%s%s", "swapUserSpentInPeriod", userAddress], SEP)
174174 
175175 
176176 func keyUserLastSwapHeight (userAddress) = makeString(["%s%s", "userLastSwapHeight", userAddress], SEP)
177177 
178178 
179179 func feeManagerAddressREAD () = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, FeesManagerAddressKey), (FeesManagerAddressKey + " is not specified"))), (FeesManagerAddressKey + " invalid address format"))
180180 
181181 
182182 func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, PRICELET, price), WAVELET, PAULI)
183183 
184184 
185185 func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, PRICELET), PAULI, WAVELET)
186186 
187187 
188188 func convertWavesToBond (amount,price) = convertWavesToNeutrino(amount, price)
189189 
190190 
191191 func convertJsonArrayToList (jsonArray) = split(jsonArray, ",")
192192 
193193 
194194 func minSwapAmountFAIL (swapType,minSwapAmount) = throw(((("The specified amount in " + swapType) + " swap is less than the required minimum of ") + toString(minSwapAmount)))
195195 
196196 
197197 func emergencyShutdownFAIL () = throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
198198 
199199 
200200 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)))
201201 
202202 
203203 let liquidationContract = getStringByKey(LiquidationContractKey)
204204 
205205 let nsbtStakingContractStr = getStringByKey(NsbtStakingContractKey)
206206 
207207 let neutrinoAssetId = fromBase58String(getStringByKey(NeutrinoAssetIdKey))
208208 
209209 let auctionContract = getStringByKey(AuctionContractKey)
210210 
211211 let rpdContract = getStringByKey(RPDContractKey)
212212 
213213 let controlContract = getStringByKey(ContolContractKey)
214214 
215215 let mathContractAddress = getStringByKey(MathContractKey)
216216 
217217 let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
218218 
219219 let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
220220 
221221 let nodeOracleProviderPubKey = fromBase58String(getStringByKey(NodeOracleProviderPubKeyKey))
222222 
223223 let bondAssetId = fromBase58String("F3iaxzruFeKujfVfYSZEkejpjh67wmRfPCRHiNmWKp3Z")
224224 
225225 let deprecatedBondAssetId = fromBase58String("975akZBfnMj513U7MZaHKzQrmsEx5aE3wdWKTrHBhbjF")
226226 
227227 let neutrinoContract = this
228228 
229229 let mathContract = addressFromStringValue(mathContractAddress)
230230 
231231 let nsbtStakingContract = addressFromStringValue(nsbtStakingContractStr)
232232 
233233 let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
234234 
235235 func checkIsValidMinSponsoredFee (tx) = {
236236     let MINTRANSFERFEE = 100000
237237     let SponsoredFeeUpperBound = 1000
238238     let realNeutrinoFee = convertWavesToNeutrino(MINTRANSFERFEE, currentPrice)
239239     let minNeutrinoFee = (realNeutrinoFee * 2)
240240     let maxNeutrinoFee = fraction(realNeutrinoFee, SponsoredFeeUpperBound, 100)
241241     let inputFee = value(tx.minSponsoredAssetFee)
242242     if (if ((inputFee >= minNeutrinoFee))
243243         then (maxNeutrinoFee >= inputFee)
244244         else false)
245245         then (tx.assetId == neutrinoAssetId)
246246         else false
247247     }
248248 
249249 
250250 func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
251251 
252252 
253253 func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
254254 
255255 
256256 func keyLockParamUserAmount (userAddress) = makeString(["%s%s%s", "paramByUser", userAddress, "amount"], SEP)
257257 
258258 
259259 let sIdxSwapType = 1
260260 
261261 let sIdxStatus = 2
262262 
263263 let sIdxInAmount = 3
264264 
265265 let sIdxPrice = 4
266266 
267267 let sIdxOutNetAmount = 5
268268 
269269 let sIdxOutFeeAmount = 6
270270 
271271 let sIdxStartHeight = 7
272272 
273273 let sIdxStartTimestamp = 8
274274 
275275 let sIdxEndHeight = 9
276276 
277277 let sIdxEndTimestamp = 10
278278 
279279 let sIdxSelfUnlockHeight = 11
280280 
281281 let sIdxRandUnlockHeight = 12
282282 
283283 let sIdxIndex = 13
284284 
285285 let sIdxWithdrawTxId = 14
286286 
287287 let sIdxMinRand = 15
288288 
289289 let sIdxMaxRand = 16
290290 
291291 func swapKEY (userAddress,txId) = makeString(["%s%s", userAddress, txId], SEP)
292292 
293293 
294294 func strSwapDATA (swapType,status,inAmount,price,outNetAmount,outFeeAmount,startHeight,startTimestamp,endHeight,endTimestamp,selfUnlockHeight,randUnlockHeight,index,withdrawTxId,randMin,randMax) = 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, randMin, randMax], SEP)
295295 
296296 
297297 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")
298298 
299299 
300300 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, dataArray[sIdxMinRand], dataArray[sIdxMaxRand])
301301 
302302 
303303 func swapDataFailOrREAD (userAddress,swapTxId) = {
304304     let swapKey = swapKEY(userAddress, swapTxId)
305305     split(valueOrErrorMessage(getString(this, swapKey), ("no swap data for " + swapKey)), SEP)
306306     }
307307 
308308 
309309 func applyFees (amountGross,feePart) = {
310310     let feeAmount = fraction(amountGross, feePart, PAULI)
311311 [(amountGross - feeAmount), feeAmount, amountGross]
312312     }
313313 
314314 
315315 func abs (x) = if ((0 > x))
316316     then -(x)
317317     else x
318318 
319319 
320320 func selectNode (unleaseAmount) = {
321321     let amountToLease = ((wavesBalance(neutrinoContract).available - unleaseAmount) - getReservedAmountForSponsorship())
322322     let oldLeased0 = getNumberByKey(getLeaseAmountKey(0))
323323     let oldLeased1 = getNumberByKey(getLeaseAmountKey(1))
324324     let newLeased0 = (amountToLease + oldLeased0)
325325     let newLeased1 = (amountToLease + oldLeased1)
326326     if (if ((newLeased0 > 0))
327327         then true
328328         else (newLeased1 > 0))
329329         then {
330330             let delta0 = abs((newLeased0 - oldLeased1))
331331             let delta1 = abs((newLeased1 - oldLeased0))
332332             if ((delta1 >= delta0))
333333                 then $Tuple2(0, newLeased0)
334334                 else $Tuple2(1, newLeased1)
335335             }
336336         else $Tuple2(-1, 0)
337337     }
338338 
339339 
340340 func thisOnly (i) = if ((i.caller != this))
341341     then throw("Permission denied: this contract only allowed")
342342     else true
343343 
344344 
345345 func prepareUnleaseAndLease (unleaseAmount) = {
346346     let nodeTuple = selectNode(unleaseAmount)
347347     let nodeIndex = nodeTuple._1
348348     let newLeaseAmount = nodeTuple._2
349349     if ((newLeaseAmount > 0))
350350         then {
351351             let leaseIdKey = getLeaseIdKey(nodeIndex)
352352             let oldLease = getBinary(this, leaseIdKey)
353353             let unleaseOrEmpty = if (isDefined(oldLease))
354354                 then [LeaseCancel(value(oldLease))]
355355                 else nil
356356             let leaseAmountKey = getLeaseAmountKey(nodeIndex)
357357             let lease = Lease(getStakingNodeAddressByIndex(nodeIndex), newLeaseAmount)
358358             (unleaseOrEmpty ++ [lease, BinaryEntry(leaseIdKey, calculateLeaseId(lease)), IntegerEntry(getLeaseAmountKey(nodeIndex), newLeaseAmount)])
359359             }
360360         else nil
361361     }
362362 
363363 
364364 func commonSwap (swapType,pmtAmount,userAddressStr,txId58,swapParamsByUserSYSREADONLY) = {
365365     let $t01560515685 = swapParamsByUserSYSREADONLY
366366     let swapLimitMax = $t01560515685._1
367367     let swapLimitSpent = $t01560515685._2
368368     let blcks2LmtReset = $t01560515685._3
369369     let minSwapAmount = minSwapAmountREAD(swapType)
370370     let totalLocked = totalLockedREAD(swapType)
371371     let totalLockedByUser = totalLockedByUserREAD(swapType, userAddressStr)
372372     let nodeAddress = getStakingNodeByIndex(0)
373373     let priceByIndex = getPriceHistory(getHeightPriceByIndex(priceIndex))
374374     let isSwapByNode = (nodeAddress == userAddressStr)
375375     let balanceLockMaxInterval = if (isSwapByNode)
376376         then nodeBalanceLockIntervalREAD()
377377         else balanceLockIntervalREAD(swapType)
378378     let selfUnlockHeight = (height + balanceLockMaxInterval)
379379     let swapUsdnVolume = if ((swapType == "neutrino"))
380380         then pmtAmount
381381         else convertWavesToNeutrino(pmtAmount, priceByIndex)
382382     if ((minSwapAmount > pmtAmount))
383383         then minSwapAmountFAIL(swapType, minSwapAmount)
384384         else if (if (!(isSwapByNode))
385385             then (swapLimitSpent > 0)
386386             else false)
387387             then throw(("You have exceeded swap limit! Next allowed swap height is " + toString((height + blcks2LmtReset))))
388388             else if (if (!(isSwapByNode))
389389                 then (swapUsdnVolume > swapLimitMax)
390390                 else false)
391391                 then throw(((("You have exceeded your swap limit! Requested: " + toString(swapUsdnVolume)) + ", available: ") + toString(swapLimitMax)))
392392                 else if (isBlocked)
393393                     then emergencyShutdownFAIL()
394394                     else {
395395                         let leasePart = if ((swapType == "waves"))
396396                             then prepareUnleaseAndLease(0)
397397                             else nil
398398                         $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)
399399                         }
400400     }
401401 
402402 
403-@Callable(i)
404403 func commonWithdraw (account,index,swapTxId,withdrawTxId) = {
405-    let checkCaller = thisOnly(i)
406-    if ((checkCaller == checkCaller))
407-        then if ((size(i.payments) != 0))
408-            then throw("no payments allowed")
409-            else {
410-                let userAddress = addressFromStringValue(account)
411-                let feeManagerAddress = feeManagerAddressREAD()
412-                let dataArray = swapDataFailOrREAD(account, swapTxId)
413-                let selfUnlockHeight = parseIntValue(dataArray[sIdxSelfUnlockHeight])
414-                let swapType = dataArray[sIdxSwapType]
415-                let inAmount = parseIntValue(dataArray[sIdxInAmount])
416-                let swapStatus = dataArray[sIdxStatus]
417-                let startHeight = parseIntValue(dataArray[sIdxStartHeight])
418-                let outFeePart = valueOrElse(getInteger(this, outFeePartKEY(swapType)), DEFAULTSWAPFEE)
419-                let totalLocked = totalLockedREAD(swapType)
420-                let totalLockedByUser = totalLockedByUserREAD(swapType, account)
421-                let unlockHeight = (startHeight + getIntegerValue(this, balanceLockIntervalKEY(swapType)))
422-                let indexHeight = getHeightPriceByIndex(index)
423-                let prevIndexHeight = getHeightPriceByIndex((index - 1))
424-                let priceByIndex = getPriceHistory(indexHeight)
425-                let outAmountGrossTuple = if ((swapType == "waves"))
426-                    then $Tuple2(convertWavesToNeutrino(inAmount, priceByIndex), neutrinoAssetId)
427-                    else if ((swapType == "neutrino"))
428-                        then $Tuple2(convertNeutrinoToWaves(inAmount, priceByIndex), unit)
429-                        else throw(("Unsupported swap type " + swapType))
430-                let payoutsArray = applyFees(outAmountGrossTuple._1, outFeePart)
431-                let outNetAmount = payoutsArray[IdxNetAmount]
432-                let outFeeAmount = payoutsArray[IdxFeeAmount]
433-                if (isBlocked)
434-                    then emergencyShutdownFAIL()
435-                    else if ((swapStatus != "PENDING"))
436-                        then throw("swap has been already processed")
437-                        else if ((unlockHeight > height))
438-                            then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw funds"))
439-                            else if (if (if ((index > priceIndex))
440-                                then true
441-                                else (unlockHeight > indexHeight))
442-                                then true
443-                                else if ((prevIndexHeight != 0))
444-                                    then (prevIndexHeight >= unlockHeight)
404+    let userAddress = addressFromStringValue(account)
405+    let feeManagerAddress = feeManagerAddressREAD()
406+    let dataArray = swapDataFailOrREAD(account, swapTxId)
407+    let selfUnlockHeight = parseIntValue(dataArray[sIdxSelfUnlockHeight])
408+    let swapType = dataArray[sIdxSwapType]
409+    let inAmount = parseIntValue(dataArray[sIdxInAmount])
410+    let swapStatus = dataArray[sIdxStatus]
411+    let startHeight = parseIntValue(dataArray[sIdxStartHeight])
412+    let outFeePart = valueOrElse(getInteger(this, outFeePartKEY(swapType)), DEFAULTSWAPFEE)
413+    let totalLocked = totalLockedREAD(swapType)
414+    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
415+    let unlockHeight = (startHeight + getIntegerValue(this, balanceLockIntervalKEY(swapType)))
416+    let indexHeight = getHeightPriceByIndex(index)
417+    let prevIndexHeight = getHeightPriceByIndex((index - 1))
418+    let priceByIndex = getPriceHistory(indexHeight)
419+    let outAmountGrossTuple = if ((swapType == "waves"))
420+        then $Tuple2(convertWavesToNeutrino(inAmount, priceByIndex), neutrinoAssetId)
421+        else if ((swapType == "neutrino"))
422+            then $Tuple2(convertNeutrinoToWaves(inAmount, priceByIndex), unit)
423+            else throw(("Unsupported swap type " + swapType))
424+    let payoutsArray = applyFees(outAmountGrossTuple._1, outFeePart)
425+    let outNetAmount = payoutsArray[IdxNetAmount]
426+    let outFeeAmount = payoutsArray[IdxFeeAmount]
427+    if (isBlocked)
428+        then emergencyShutdownFAIL()
429+        else if ((swapStatus != "PENDING"))
430+            then throw("swap has been already processed")
431+            else if ((unlockHeight > height))
432+                then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw funds"))
433+                else if (if (if ((index > priceIndex))
434+                    then true
435+                    else (unlockHeight > indexHeight))
436+                    then true
437+                    else if ((prevIndexHeight != 0))
438+                        then (prevIndexHeight >= unlockHeight)
439+                        else false)
440+                    then priceIndexFAIL(index, priceIndex, indexHeight, unlockHeight, prevIndexHeight)
441+                    else if ((0 >= payoutsArray[IdxGrossAmount]))
442+                        then throw("balance equals zero")
443+                        else if (if ((0 > outFeePart))
444+                            then true
445+                            else (outFeePart >= PAULI))
446+                            then throw(((("invalid outFeePart config for " + swapType) + " swap: outFeePart=") + toString(outFeePart)))
447+                            else {
448+                                let leasePart = if (if ((swapType == "neutrino"))
449+                                    then (outAmountGrossTuple._1 > 0)
445450                                     else false)
446-                                then priceIndexFAIL(index, priceIndex, indexHeight, unlockHeight, prevIndexHeight)
447-                                else if ((0 >= payoutsArray[IdxGrossAmount]))
448-                                    then throw("balance equals zero")
449-                                    else if (if ((0 > outFeePart))
450-                                        then true
451-                                        else (outFeePart >= PAULI))
452-                                        then throw(((("invalid outFeePart config for " + swapType) + " swap: outFeePart=") + toString(outFeePart)))
453-                                        else {
454-                                            let leasePart = if (if ((swapType == "neutrino"))
455-                                                then (outAmountGrossTuple._1 > 0)
456-                                                else false)
457-                                                then prepareUnleaseAndLease(outAmountGrossTuple._1)
458-                                                else nil
459-                                            let nsbtStakingDeposit = invoke(nsbtStakingContract, "deposit", nil, [AttachedPayment(outAmountGrossTuple._2, outFeeAmount)])
460-                                            if ((nsbtStakingDeposit == nsbtStakingDeposit))
461-                                                then $Tuple2((leasePart ++ [IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser - inAmount)), IntegerEntry(totalLockedKEY(swapType), (totalLocked - inAmount)), ScriptTransfer(userAddress, outNetAmount, outAmountGrossTuple._2), StringEntry(swapKEY(account, swapTxId), finishSwapDATA(dataArray, priceByIndex, outNetAmount, outFeeAmount, unlockHeight, index, toBase58String(i.transactionId)))]), unit)
462-                                                else throw("Strict value is not equal to itself.")
463-                                            }
464-                }
465-        else throw("Strict value is not equal to itself.")
451+                                    then prepareUnleaseAndLease(outAmountGrossTuple._1)
452+                                    else nil
453+                                let state = (leasePart ++ [IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser - inAmount)), IntegerEntry(totalLockedKEY(swapType), (totalLocked - inAmount)), ScriptTransfer(userAddress, outNetAmount, outAmountGrossTuple._2), StringEntry(swapKEY(account, swapTxId), finishSwapDATA(dataArray, priceByIndex, outNetAmount, outFeeAmount, unlockHeight, index, withdrawTxId))])
454+                                $Tuple2(state, AttachedPayment(outAmountGrossTuple._2, outFeeAmount))
455+                                }
466456     }
467-
468457 
469458 
470459 @Callable(i)
471460 func constructor (neutrinoAssetIdPrm,bondAssetIdPrm,auctionContractPrm,liquidationContractPrm,rpdContractPrm,nodeOracleProviderPubKeyPrm,balanceWavesLockIntervalPrm,balanceNeutrinoLockIntervalPrm,minWavesSwapAmountPrm,minNeutrinoSwapAmountPrm,neutrinoOutFeePartPrm,wavesOutFeePartPrm) = {
472461     let checkCaller = thisOnly(i)
473462     if ((checkCaller == checkCaller))
474463         then if ((size(i.payments) != 0))
475464             then throw("no payments allowed")
476465             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)]
477466         else throw("Strict value is not equal to itself.")
478467     }
479468 
480469 
481470 
482471 @Callable(i)
483472 func constructorV2 (mathContract,nsbtStakingContract,swapsTimeframeBlocks) = {
484473     let checkCaller = thisOnly(i)
485474     if ((checkCaller == checkCaller))
486475         then if ((size(i.payments) != 0))
487476             then throw("no payments allowed")
488477             else [StringEntry(MathContractKey, mathContract), StringEntry(NsbtStakingContractKey, nsbtStakingContract), IntegerEntry(swapsTimeframeKEY(), swapsTimeframeBlocks)]
489478         else throw("Strict value is not equal to itself.")
490479     }
491480 
492481 
493482 
494483 @Callable(i)
495-func swapWavesToNeutrino () = {
496-    let pmt = value(i.payments[0])
497-    if (isDefined(pmt.assetId))
498-        then throw("Only Waves token is allowed for swapping.")
499-        else if ((size(i.payments) > 1))
500-            then throw("swapWavesToNeutrino require only one payment")
484+func swapWavesToNeutrino () = if ((size(i.payments) != 1))
485+    then throw("swapWavesToNeutrino require only one payment")
486+    else {
487+        let pmt = value(i.payments[0])
488+        if (isDefined(pmt.assetId))
489+            then throw("Only Waves token is allowed for swapping.")
501490             else {
502491                 let userAddress = toString(i.caller)
503492                 let txId58 = toBase58String(i.transactionId)
504493                 let swapParamsSTRUCT = asSwapParamsSTRUCT(invoke(this, "swapParamsByUserSYSREADONLY", [userAddress, 0], nil))
505494                 let commonSwapResult = commonSwap("waves", pmt.amount, userAddress, txId58, swapParamsSTRUCT)
506495                 commonSwapResult
507496                 }
508-    }
497+        }
509498 
510499 
511500 
512501 @Callable(i)
513-func swapNeutrinoToWaves () = {
514-    let pmt = value(i.payments[0])
515-    if ((pmt.assetId != neutrinoAssetId))
516-        then throw("Only appropriate Neutrino tokens are allowed for swapping.")
517-        else if ((size(i.payments) > 1))
518-            then throw("swapNeutrinoToWaves require only one payment")
502+func swapNeutrinoToWaves () = if ((size(i.payments) != 1))
503+    then throw("swapNeutrinoToWaves require only one payment")
504+    else {
505+        let pmt = value(i.payments[0])
506+        if ((pmt.assetId != neutrinoAssetId))
507+            then throw("Only appropriate Neutrino tokens are allowed for swapping.")
519508             else {
520509                 let userAddress = toString(i.caller)
521510                 let txId58 = toBase58String(i.transactionId)
522511                 let swapParamsSTRUCT = asSwapParamsSTRUCT(invoke(this, "swapParamsByUserSYSREADONLY", [userAddress, 0], nil))
523512                 let commonSwapResult = commonSwap("neutrino", pmt.amount, userAddress, txId58, swapParamsSTRUCT)
524513                 commonSwapResult
525514                 }
526-    }
515+        }
527516 
528517 
529518 
530519 @Callable(i)
531520 func withdraw (account,index,swapTxId) = if ((size(i.payments) != 0))
532521     then throw("no payments allowed")
533522     else {
534-        let commonWithdrawInv = invoke(this, "commonWithdraw", [account, index, swapTxId, toBase58String(i.transactionId)], nil)
535-        if ((commonWithdrawInv == commonWithdrawInv))
536-            then nil
523+        let $t02418624290 = commonWithdraw(account, index, swapTxId, toBase58String(i.transactionId))
524+        let state = $t02418624290._1
525+        let depositPayment = $t02418624290._2
526+        let nsbtStakingDeposit = invoke(nsbtStakingContract, "deposit", nil, [depositPayment])
527+        if ((nsbtStakingDeposit == nsbtStakingDeposit))
528+            then state
537529             else throw("Strict value is not equal to itself.")
538530         }
539531 
540532 
541533 
542534 @Callable(i)
543535 func transferToAuction () = if ((size(i.payments) != 0))
544536     then throw("no payments allowed")
545537     else {
546538         let neutrinoMetrics = asAnyList(invoke(mathContract, "calcNeutinoMetricsREADONLY", nil, nil))
547539         let reserve = asInt(neutrinoMetrics[3])
548540         let neutrinoSupply = asInt(neutrinoMetrics[5])
549541         let surplus = asInt(neutrinoMetrics[6])
550542         let nsbtSupply = asInt(neutrinoMetrics[9])
551543         let auctionNBAmount = (neutrinoSupply - assetBalance(addressFromStringValue(auctionContract), bondAssetId))
552544         let surplusWithLiquidation = (surplus - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
553545         if (isBlocked)
554546             then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
555547             else if ((auctionNBAmount > (1 * PAULI)))
556548                 then [ScriptTransfer(addressFromStringValue(auctionContract), auctionNBAmount, bondAssetId)]
557549                 else if ((surplusWithLiquidation >= (1 * PAULI)))
558550                     then [ScriptTransfer(addressFromStringValue(liquidationContract), surplusWithLiquidation, neutrinoAssetId)]
559551                     else throw(((((((("bond were generated or do not need it. Deficit:" + toString(auctionNBAmount)) + "|") + toString(0)) + ". Surplus:") + toString(surplusWithLiquidation)) + "|") + toString(surplus)))
560552         }
561553 
562554 
563555 
564556 @Callable(i)
565557 func transferUsdnToUser (amount,addr) = if ((i.caller != addressFromStringValue(auctionContract)))
566558     then throw("Only auction contract is authorized")
567559     else [ScriptTransfer(addressFromStringValue(addr), amount, neutrinoAssetId)]
568560 
569561 
570562 
571563 @Callable(i)
572564 func acceptWaves () = if ((i.caller != addressFromStringValue(auctionContract)))
573565     then throw("Currently only auction contract is allowed to call")
574566     else $Tuple2(prepareUnleaseAndLease(0), "success")
575567 
576568 
577569 
578570 @Callable(i)
579571 func swapParamsByUserSYSREADONLY (userAddressStr,nsbtDiff) = {
580572     let nsbtData = asAnyList(invoke(nsbtStakingContract, "nsbtStakingSYSREADONLY", [userAddressStr], nil))
581573     if ((nsbtData == nsbtData))
582574         then {
583575             let gnsbtAmt = (asInt(nsbtData[0]) + nsbtDiff)
584576             let gnsbtAmtTotal = (asInt(nsbtData[1]) + nsbtDiff)
585577             let swapLimitMax = asInt(invoke(mathContract, "calcSwapLimitREADONLY", [gnsbtAmt], nil))
586578             let lastSwapHeight = valueOrElse(getInteger(this, keyUserLastSwapHeight(userAddressStr)), 0)
587579             let swapLimitTimelifeBlocks = swapsTimeframeREAD()
588580             let passedBlocksAfterLastSwap = (height - lastSwapHeight)
589581             let isSwapTimelifeNew = (passedBlocksAfterLastSwap >= swapLimitTimelifeBlocks)
590582             let swapLimitSpent = if (isSwapTimelifeNew)
591583                 then 0
592584                 else valueOrElse(getInteger(this, keySwapUserSpentInPeriod(userAddressStr)), 0)
593585             let blcks2LmtReset = if (isSwapTimelifeNew)
594586                 then 0
595587                 else (swapLimitTimelifeBlocks - passedBlocksAfterLastSwap)
596588             $Tuple2(nil, $Tuple5(swapLimitMax, swapLimitSpent, blcks2LmtReset, gnsbtAmt, gnsbtAmtTotal))
597589             }
598590         else throw("Strict value is not equal to itself.")
599591     }
600592 
601593 
602594 @Verifier(tx)
603595 func verify () = {
604596     let id = toBase58String(tx.id)
605597     let count = ((((if (sigVerify(tx.bodyBytes, tx.proofs[0], fromBase58String(pubKeyAdminsList[0])))
606598         then 1
607599         else 0) + (if (sigVerify(tx.bodyBytes, tx.proofs[1], fromBase58String(pubKeyAdminsList[1])))
608600         then 1
609601         else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[2], fromBase58String(pubKeyAdminsList[2])))
610602         then 1
611603         else 0)) + (if (sigVerify(tx.bodyBytes, tx.proofs[3], fromBase58String(pubKeyAdminsList[3])))
612604         then 2
613605         else 0))
614606     match tx {
615607         case sponsorTx: SponsorFeeTransaction => 
616608             if (checkIsValidMinSponsoredFee(sponsorTx))
617609                 then (count >= 3)
618610                 else false
619611         case _ => 
620612             (count >= 3)
621613     }
622614     }
623615 
github/deemru/w8io/026f985 
83.83 ms ◑