tx · 59SJ2hstPaqQt54jsmRC6yRoxQGN4NfmiLfdS27QcCBD

3Mt9TxLouqgJkMVU7KE5byxnFsBZZoj2akt:  -0.01000000 Waves

2022.01.12 13:45 [1875634] smart account 3Mt9TxLouqgJkMVU7KE5byxnFsBZZoj2akt > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "59SJ2hstPaqQt54jsmRC6yRoxQGN4NfmiLfdS27QcCBD",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1641984345290,
    "version": 2,
    "chainId": 84,
    "sender": "3Mt9TxLouqgJkMVU7KE5byxnFsBZZoj2akt",
    "senderPublicKey": "EPELGbCtQpVU3DY9Nf1iEJtyF5R22KTaymRjPqjBsxRf",
    "proofs": [
        "39BBsJxJd4mUUTMDVnK5eMjB1DRDgXiYusNEZ8pqQ2aPjCEu1Q53MRDKP6B6CGFhvcCKBsuV3b669TGWHPruMyUJ"
    ],
    "script": "base64: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",
    "height": 1875634,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+func getNumberByKey (key) = valueOrElse(getInteger(this, key), 0)
5+
6+
7+func getStringByKey (key) = valueOrElse(getString(this, key), "")
8+
9+
10+func getBoolByKey (key) = valueOrElse(getBoolean(this, key), false)
11+
12+
13+func getNumberByAddressAndKey (address,key) = valueOrElse(getInteger(addressFromStringValue(address), key), 0)
14+
15+
16+func getStringByAddressAndKey (address,key) = valueOrElse(getString(addressFromStringValue(address), key), "")
17+
18+
19+func getBoolByAddressAndKey (address,key) = valueOrElse(getBoolean(addressFromStringValue(address), key), false)
20+
21+
22+let pubKeyAdminsList = ["GJdLSaLiv5K7xuejac8mcRcHoyo3dPrESrvktG3a6MAR", "FWVffYr2ALmHMejZm3WqeLz6Sdym3gLFGtJn4KTwyU5x", "3Wh2LaWcb5gg7K2pPcW3Ep6EAuRBzYkAgrdpt43jTDFa", "5WRXFSjwcTbNfKcJs8ZqXmSSWYsSVJUtMvMqZj5hH4Nc"]
23+
24+func asInt (val) = match val {
25+    case valInt: Int => 
26+        valInt
27+    case _ => 
28+        throw("Failed to cast into Int")
29+}
30+
31+
32+let SEP = "__"
33+
34+let WAVELET = 100000000
35+
36+let PAULI = 1000000
37+
38+let PRICELET = 1000000
39+
40+let DEFAULTSWAPFEE = 20000
41+
42+let IdxNetAmount = 0
43+
44+let IdxFeeAmount = 1
45+
46+let IdxGrossAmount = 2
47+
48+let dora2NsbtSymbol = "NSBT-USDT"
49+
50+let minRand = 60
51+
52+let maxRand = 1440
53+
54+let NeutrinoAssetIdKey = "neutrino_asset_id"
55+
56+let BondAssetIdKey = "bond_asset_id"
57+
58+let AuctionContractKey = "auction_contract"
59+
60+let LiquidationContractKey = "liquidation_contract"
61+
62+let RPDContractKey = "rpd_contract"
63+
64+let ControlContractKey = "control_contract"
65+
66+let BalanceWavesLockIntervalKey = "balance_waves_lock_interval"
67+
68+let BalanceNeutrinoLockIntervalKey = "balance_neutrino_lock_interval"
69+
70+let MinWavesSwapAmountKey = "min_waves_swap_amount"
71+
72+let MinNeutrinoSwapAmountKey = "min_neutrino_swap_amount"
73+
74+let NodeOracleProviderPubKeyKey = "node_oracle_provider"
75+
76+let NeutrinoOutFeePartKey = "neutrinoOut_swap_feePart"
77+
78+let WavesOutFeePartKey = "wavesOut_swap_feePart"
79+
80+let RsaRandPublic58Key = "rand_rsa_public"
81+
82+let keyGNsbtContract = "%s__gNsbtContract"
83+
84+let keyNsbtLockContract = "%s__nsbtLockContract"
85+
86+let keyDora2Contract = "%s__dora2Contract"
87+
88+let keyQuickSwapDelay = "%s__quickSwapDelay"
89+
90+let keyQuickSwapLimitDuration = "%s__quickSwapLimitDuration"
91+
92+let keyDora2LastHeightLimit = "%s__dora2LastHeightLimit"
93+
94+let PriceKey = "price"
95+
96+let PriceIndexKey = "price_index"
97+
98+let IsBlockedKey = "is_blocked"
99+
100+func getPriceHistoryKey (block) = ((PriceKey + "_") + toString(block))
101+
102+
103+func getHeightPriceByIndexKey (index) = ((PriceIndexKey + "_") + toString(index))
104+
105+
106+func getStakingNodeByIndex (idx) = getStringByKey(makeString(["%s%d%s", "lease", toString(idx), "nodeAddress"], SEP))
107+
108+
109+func getStakingNodeAddressByIndex (idx) = addressFromStringValue(getStakingNodeByIndex(idx))
110+
111+
112+func getReservedAmountForSponsorship () = valueOrElse(getInteger(this, makeString(["%s%s", "lease", "sponsorshipWavesReserve"], SEP)), (1000 * WAVELET))
113+
114+
115+func getBalanceUnlockBlockKey (owner) = ("balance_unlock_block_" + owner)
116+
117+
118+func getLeaseIdKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "id"], SEP)
119+
120+
121+func getLeaseAmountKey (nodeIndex) = makeString(["%s%d%s", "lease", toString(nodeIndex), "amount"], SEP)
122+
123+
124+func minSwapAmountKEY (swapType) = (("min_" + swapType) + "_swap_amount")
125+
126+
127+func totalLockedKEY (swapType) = ("balance_lock_" + swapType)
128+
129+
130+func totalLockedByUserKEY (swapType,owner) = makeString(["balance_lock", swapType, owner], "_")
131+
132+
133+func balanceLockIntervalKEY (swapType) = (("balance_" + swapType) + "_lock_interval")
134+
135+
136+func minBalanceLockIntervalKEY (swapType) = (("balance_" + swapType) + "_lock_interval_minimum")
137+
138+
139+func nodeBalanceLockIntervalKEY () = "balance_node_lock_interval"
140+
141+
142+func outFeePartKEY (swapType) = (swapType + "Out_swap_feePart")
143+
144+
145+func keyQuickSwapUserSpentInPeriod (userAddress) = makeString(["%s%s", "quickSwapUserSpentInPeriod", toString(userAddress)], SEP)
146+
147+
148+func keyUserLastQuickSwapHeight (userAddress) = makeString(["%s%s", "userLastQuickSwapHeight", toString(userAddress)], SEP)
149+
150+
151+func keyDora2Price (symbol) = makeString(["%s%s", "price", symbol], SEP)
152+
153+
154+func keyDora2LastHeight (symbol) = makeString(["%s%s", "lastHeight", symbol], SEP)
155+
156+
157+func minSwapAmountREAD (swapType) = valueOrElse(getInteger(this, minSwapAmountKEY(swapType)), 0)
158+
159+
160+func totalLockedREAD (swapType) = valueOrElse(getInteger(this, totalLockedKEY(swapType)), 0)
161+
162+
163+func totalLockedByUserREAD (swapType,owner) = valueOrElse(getInteger(this, totalLockedByUserKEY(swapType, owner)), 0)
164+
165+
166+func balanceLockIntervalREAD (swapType) = valueOrElse(getInteger(this, balanceLockIntervalKEY(swapType)), maxRand)
167+
168+
169+func minBalanceLockIntervalREAD (swapType) = valueOrElse(getInteger(this, minBalanceLockIntervalKEY(swapType)), minRand)
170+
171+
172+func nodeBalanceLockIntervalREAD () = valueOrElse(getInteger(this, nodeBalanceLockIntervalKEY()), 1)
173+
174+
175+func convertNeutrinoToWaves (amount,price) = fraction(fraction(amount, PRICELET, price), WAVELET, PAULI)
176+
177+
178+func convertWavesToNeutrino (amount,price) = fraction(fraction(amount, price, PRICELET), PAULI, WAVELET)
179+
180+
181+func convertWavesToBond (amount,price) = convertWavesToNeutrino(amount, price)
182+
183+
184+func convertJsonArrayToList (jsonArray) = split(jsonArray, ",")
185+
186+
187+func minSwapAmountFAIL (swapType,minSwapAmount) = throw(((("The specified amount in " + swapType) + " swap is less than the required minimum of ") + toString(minSwapAmount)))
188+
189+
190+func emergencyShutdownFAIL () = throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
191+
192+
193+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)))
194+
195+
196+let liquidationContract = getStringByKey(LiquidationContractKey)
197+
198+let neutrinoAssetId = fromBase58String(getStringByKey(NeutrinoAssetIdKey))
199+
200+let auctionContract = getStringByKey(AuctionContractKey)
201+
202+let rpdContract = getStringByKey(RPDContractKey)
203+
204+let controlContract = getStringByKey(ControlContractKey)
205+
206+let priceIndex = getNumberByAddressAndKey(controlContract, PriceIndexKey)
207+
208+let isBlocked = getBoolByAddressAndKey(controlContract, IsBlockedKey)
209+
210+let nodeOracleProviderPubKey = fromBase58String(getStringByKey(NodeOracleProviderPubKeyKey))
211+
212+let bondAssetId = fromBase58String("6nSpVyNH7yM69eg446wrQR94ipbbcmZMU1ENPwanC97g")
213+
214+let deprecatedBondAssetId = fromBase58String("975akZBfnMj513U7MZaHKzQrmsEx5aE3wdWKTrHBhbjF")
215+
216+let rsaPub = fromBase64String(valueOrErrorMessage(getString(this, RsaRandPublic58Key), "RSA public key has not been specified"))
217+
218+let neutrinoContract = this
219+
220+let currentPrice = getNumberByAddressAndKey(controlContract, PriceKey)
221+
222+let neutrinoLockedBalance = totalLockedREAD("neutrino")
223+
224+let wavesLockedBalance = totalLockedREAD("waves")
225+
226+let reserve = (wavesBalance(neutrinoContract).regular - wavesLockedBalance)
227+
228+let neutrinoSupply = (((neutrinoLockedBalance + value(assetInfo(neutrinoAssetId)).quantity) - assetBalance(neutrinoContract, neutrinoAssetId)) - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
229+
230+let surplus = (convertWavesToNeutrino(reserve, currentPrice) - neutrinoSupply)
231+
232+let deficit = (neutrinoSupply - convertWavesToNeutrino(reserve, currentPrice))
233+
234+func checkIsValidMinSponsoredFee (tx) = {
235+    let MINTRANSFERFEE = 100000
236+    let SponsoredFeeUpperBound = 1000
237+    let realNeutrinoFee = convertWavesToNeutrino(MINTRANSFERFEE, currentPrice)
238+    let minNeutrinoFee = (realNeutrinoFee * 2)
239+    let maxNeutrinoFee = fraction(realNeutrinoFee, SponsoredFeeUpperBound, 100)
240+    let inputFee = value(tx.minSponsoredAssetFee)
241+    if (if ((inputFee >= minNeutrinoFee))
242+        then (maxNeutrinoFee >= inputFee)
243+        else false)
244+        then (tx.assetId == neutrinoAssetId)
245+        else false
246+    }
247+
248+
249+func getPriceHistory (block) = getNumberByAddressAndKey(controlContract, getPriceHistoryKey(block))
250+
251+
252+func getHeightPriceByIndex (index) = getNumberByAddressAndKey(controlContract, getHeightPriceByIndexKey(index))
253+
254+
255+let sIdxSwapType = 1
256+
257+let sIdxStatus = 2
258+
259+let sIdxInAmount = 3
260+
261+let sIdxPrice = 4
262+
263+let sIdxOutNetAmount = 5
264+
265+let sIdxOutFeeAmount = 6
266+
267+let sIdxStartHeight = 7
268+
269+let sIdxStartTimestamp = 8
270+
271+let sIdxEndHeight = 9
272+
273+let sIdxEndTimestamp = 10
274+
275+let sIdxSelfUnlockHeight = 11
276+
277+let sIdxRandUnlockHeight = 12
278+
279+let sIdxIndex = 13
280+
281+let sIdxWithdrawTxId = 14
282+
283+let sIdxMinRand = 15
284+
285+let sIdxMaxRand = 16
286+
287+func swapKEY (userAddress,txId) = makeString(["%s%s", userAddress, txId], SEP)
288+
289+
290+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)
291+
292+
293+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", toString(minBalanceLockIntervalREAD(swapType)), toString(balanceLockIntervalREAD(swapType)))
294+
295+
296+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, if ((15 >= size(dataArray)))
297+    then toString(minRand)
298+    else dataArray[sIdxMinRand], if ((15 >= size(dataArray)))
299+    then toString(maxRand)
300+    else dataArray[sIdxMaxRand])
301+
302+
303+func swapDataFailOrREAD (userAddress,swapTxId) = {
304+    let swapKey = swapKEY(userAddress, swapTxId)
305+    split(valueOrErrorMessage(getString(this, swapKey), ("no swap data for " + swapKey)), SEP)
306+    }
307+
308+
309+func applyFees (amountGross,feePart) = {
310+    let feeAmount = fraction(amountGross, feePart, PAULI)
311+[(amountGross - feeAmount), feeAmount, amountGross]
312+    }
313+
314+
315+func randUnlockHeightOrFail (txId,rsaSig,swapType,startHeight,minMaxRandsTuple) = {
316+    let isRsaValid = rsaVerify_16Kb(SHA256, toBytes(txId), rsaSig, rsaPub)
317+    if (!(isRsaValid))
318+        then throw("invalid RSA signature")
319+        else {
320+            let minBalanceLockInterval = minMaxRandsTuple._1
321+            let maxBalanceLockInterval = minMaxRandsTuple._2
322+            let rand = (toInt(sha256_16Kb(rsaSig)) % (maxBalanceLockInterval - minBalanceLockInterval))
323+            let randLockInterval = (minBalanceLockInterval + (if ((0 > rand))
324+                then -(rand)
325+                else rand))
326+            (startHeight + randLockInterval)
327+            }
328+    }
329+
330+
331+func abs (x) = if ((0 > x))
332+    then -(x)
333+    else x
334+
335+
336+func selectNode (unleaseAmount) = {
337+    let amountToLease = ((wavesBalance(neutrinoContract).available - unleaseAmount) - getReservedAmountForSponsorship())
338+    let oldLeased0 = getNumberByKey(getLeaseAmountKey(0))
339+    let oldLeased1 = getNumberByKey(getLeaseAmountKey(1))
340+    let newLeased0 = (amountToLease + oldLeased0)
341+    let newLeased1 = (amountToLease + oldLeased1)
342+    if (if ((newLeased0 > 0))
343+        then true
344+        else (newLeased1 > 0))
345+        then {
346+            let delta0 = abs((newLeased0 - oldLeased1))
347+            let delta1 = abs((newLeased1 - oldLeased0))
348+            if ((delta1 >= delta0))
349+                then $Tuple2(0, newLeased0)
350+                else $Tuple2(1, newLeased1)
351+            }
352+        else $Tuple2(-1, 0)
353+    }
354+
355+
356+func prepareUnleaseAndLease (unleaseAmount) = {
357+    let $t01536515453 = selectNode(unleaseAmount)
358+    let nodeIndex = $t01536515453._1
359+    let newLeaseAmount = $t01536515453._2
360+    if ((newLeaseAmount > 0))
361+        then {
362+            let leaseIdKey = getLeaseIdKey(nodeIndex)
363+            let oldLease = getBinary(this, leaseIdKey)
364+            let unleaseOrEmpty = if (isDefined(oldLease))
365+                then [LeaseCancel(value(oldLease))]
366+                else nil
367+            let leaseAmountKey = getLeaseAmountKey(nodeIndex)
368+            let lease = Lease(getStakingNodeAddressByIndex(nodeIndex), newLeaseAmount)
369+            (unleaseOrEmpty ++ [lease, BinaryEntry(leaseIdKey, calculateLeaseId(lease)), IntegerEntry(getLeaseAmountKey(nodeIndex), newLeaseAmount)])
370+            }
371+        else nil
372+    }
373+
374+
375+func getDora2NSBTInfo () = {
376+    let dora2Contract = addressFromStringValue(getStringValue(this, keyDora2Contract))
377+    let price = valueOrErrorMessage(getInteger(dora2Contract, keyDora2Price(dora2NsbtSymbol)), "NSBT price is undefined")
378+    let lastHeight = valueOrElse(getInteger(dora2Contract, keyDora2LastHeight(dora2NsbtSymbol)), 0)
379+    $Tuple2(price, lastHeight)
380+    }
381+
382+
383+func getNSBTPrice () = {
384+    let $t01641116455 = getDora2NSBTInfo()
385+    let price = $t01641116455._1
386+    let lastHeight = $t01641116455._2
387+    price
388+    }
389+
390+
391+func commonSwap (swapType,i) = {
392+    let pmt = value(i.payments[0])
393+    let account = toString(i.caller)
394+    let txId58 = toBase58String(i.transactionId)
395+    let minSwapAmount = minSwapAmountREAD(swapType)
396+    let totalLocked = totalLockedREAD(swapType)
397+    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
398+    let nodeAddress = getStakingNodeByIndex(0)
399+    let balanceLockMaxInterval = if ((nodeAddress == account))
400+        then nodeBalanceLockIntervalREAD()
401+        else balanceLockIntervalREAD(swapType)
402+    let selfUnlockHeight = (height + balanceLockMaxInterval)
403+    if ((minSwapAmount > pmt.amount))
404+        then minSwapAmountFAIL(swapType, minSwapAmount)
405+        else if (isBlocked)
406+            then emergencyShutdownFAIL()
407+            else {
408+                let leasePart = if ((swapType == "waves"))
409+                    then prepareUnleaseAndLease(0)
410+                    else nil
411+                $Tuple2(([IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser + pmt.amount)), IntegerEntry(getBalanceUnlockBlockKey(account), selfUnlockHeight), IntegerEntry(totalLockedKEY(swapType), (totalLocked + pmt.amount)), StringEntry(swapKEY(account, txId58), pendingSwapDATA(swapType, pmt.amount, selfUnlockHeight))] ++ leasePart), unit)
412+                }
413+    }
414+
415+
416+func thisOnly (i) = if ((i.caller != this))
417+    then throw("Permission denied: this contract only allowed")
418+    else true
419+
420+
421+@Callable(i)
422+func prepareUnleaseAndLeaseWrapper (unleaseAmount) = {
423+    let checkCaller = [thisOnly(i)]
424+    if ((checkCaller == checkCaller))
425+        then prepareUnleaseAndLease(unleaseAmount)
426+        else throw("Strict value is not equal to itself.")
427+    }
428+
429+
430+
431+@Callable(i)
432+func constructor (neutrinoAssetIdPrm,bondAssetIdPrm,auctionContractPrm,liquidationContractPrm,rpdContractPrm,controlContractPrm,nodeOracleProviderPubKeyPrm,rsaRandPublicKeyPrm,balanceWavesLockIntervalPrm,balanceNeutrinoLockIntervalPrm,minWavesSwapAmountPrm,minNeutrinoSwapAmountPrm,neutrinoOutFeePartPrm,wavesOutFeePartPrm) = {
433+    let checkCaller = thisOnly(i)
434+    if ((checkCaller == checkCaller))
435+        then [StringEntry(NeutrinoAssetIdKey, neutrinoAssetIdPrm), StringEntry(BondAssetIdKey, bondAssetIdPrm), StringEntry(AuctionContractKey, auctionContractPrm), StringEntry(LiquidationContractKey, liquidationContractPrm), StringEntry(RPDContractKey, rpdContractPrm), StringEntry(ControlContractKey, controlContractPrm), StringEntry(NodeOracleProviderPubKeyKey, nodeOracleProviderPubKeyPrm), StringEntry(RsaRandPublic58Key, rsaRandPublicKeyPrm), IntegerEntry(BalanceWavesLockIntervalKey, balanceWavesLockIntervalPrm), IntegerEntry(BalanceNeutrinoLockIntervalKey, balanceNeutrinoLockIntervalPrm), IntegerEntry(MinWavesSwapAmountKey, minWavesSwapAmountPrm), IntegerEntry(MinNeutrinoSwapAmountKey, minNeutrinoSwapAmountPrm), IntegerEntry(NeutrinoOutFeePartKey, neutrinoOutFeePartPrm), IntegerEntry(WavesOutFeePartKey, wavesOutFeePartPrm)]
436+        else throw("Strict value is not equal to itself.")
437+    }
438+
439+
440+
441+@Callable(i)
442+func constructorV2 (gNsbtContract,nsbtLockContract,dora2Contract,quickSwapDelay,quickSwapLimitDuration,dora2LastHeightLimit) = {
443+    let checkCaller = thisOnly(i)
444+    if ((checkCaller == checkCaller))
445+        then [StringEntry(keyGNsbtContract, gNsbtContract), StringEntry(keyNsbtLockContract, nsbtLockContract), StringEntry(keyDora2Contract, dora2Contract), IntegerEntry(keyQuickSwapDelay, quickSwapDelay), IntegerEntry(keyQuickSwapLimitDuration, quickSwapLimitDuration), IntegerEntry(keyDora2LastHeightLimit, dora2LastHeightLimit)]
446+        else throw("Strict value is not equal to itself.")
447+    }
448+
449+
450+
451+@Callable(i)
452+func commonWithdraw (account,index,swapTxId,rsaSig,isQuick) = {
453+    let userAddress = addressFromStringValue(account)
454+    let checkCaller = [thisOnly(i), if (if (isQuick)
455+        then (i.originCaller != userAddress)
456+        else false)
457+        then throw(((("Permission denied: originCaller=" + toString(i.originCaller)) + ", account=") + account))
458+        else true]
459+    if ((checkCaller == checkCaller))
460+        then {
461+            let dataArray = swapDataFailOrREAD(account, swapTxId)
462+            let selfUnlockHeight = parseIntValue(dataArray[sIdxSelfUnlockHeight])
463+            let swapType = dataArray[sIdxSwapType]
464+            let inAmount = parseIntValue(dataArray[sIdxInAmount])
465+            let swapStatus = dataArray[sIdxStatus]
466+            let startHeight = parseIntValue(dataArray[sIdxStartHeight])
467+            let checkSwapType = if (if ((swapType != "waves"))
468+                then (swapType != "neutrino")
469+                else false)
470+                then throw(("Unsupported swap type " + swapType))
471+                else true
472+            if ((checkSwapType == checkSwapType))
473+                then {
474+                    let outFeePart = valueOrElse(getInteger(this, outFeePartKEY(swapType)), DEFAULTSWAPFEE)
475+                    let totalLocked = totalLockedREAD(swapType)
476+                    let totalLockedByUser = totalLockedByUserREAD(swapType, account)
477+                    let minMaxRandsTuple = if ((15 >= size(dataArray)))
478+                        then $Tuple2(minRand, maxRand)
479+                        else $Tuple2(parseIntValue(dataArray[sIdxMinRand]), parseIntValue(dataArray[sIdxMaxRand]))
480+                    let unlockHeight = if (isQuick)
481+                        then {
482+                            let quickSwapDelay = getIntegerValue(this, keyQuickSwapDelay)
483+                            (startHeight + quickSwapDelay)
484+                            }
485+                        else if ((rsaSig == base58''))
486+                            then selfUnlockHeight
487+                            else randUnlockHeightOrFail(swapTxId, rsaSig, swapType, startHeight, minMaxRandsTuple)
488+                    let indexHeight = getHeightPriceByIndex(index)
489+                    let prevIndexHeight = getHeightPriceByIndex((index - 1))
490+                    let priceByIndex = getPriceHistory(indexHeight)
491+                    let $t02196622162 = if ((swapType == "waves"))
492+                        then $Tuple2(convertWavesToNeutrino(inAmount, priceByIndex), neutrinoAssetId)
493+                        else $Tuple2(convertNeutrinoToWaves(inAmount, priceByIndex), unit)
494+                    let outAmountGross = $t02196622162._1
495+                    let outAsset = $t02196622162._2
496+                    let payoutsArray = applyFees(outAmountGross, outFeePart)
497+                    let outNetAmount = payoutsArray[IdxNetAmount]
498+                    let outFeeAmount = payoutsArray[IdxFeeAmount]
499+                    let quickSwapLimitDuration = getIntegerValue(this, keyQuickSwapLimitDuration)
500+                    let quickSwapUserSpentInPeriod = valueOrElse(getInteger(this, keyQuickSwapUserSpentInPeriod(userAddress)), 0)
501+                    let userLastQuickSwapHeight = valueOrElse(getInteger(this, keyUserLastQuickSwapHeight(userAddress)), 0)
502+                    let nsbtLockContract = addressFromStringValue(getStringValue(this, keyNsbtLockContract))
503+                    let userGNsbtAmountResult = invoke(nsbtLockContract, "gNsbtAmountREADONLY", [toString(userAddress)], nil)
504+                    if ((userGNsbtAmountResult == userGNsbtAmountResult))
505+                        then {
506+                            let userGNsbtAmount = asInt(userGNsbtAmountResult)
507+                            let $t02287422931 = getDora2NSBTInfo()
508+                            let nsbtPrice = $t02287422931._1
509+                            let nsbtPriceLastHeight = $t02287422931._2
510+                            let lastHeightLimit = getIntegerValue(this, keyDora2LastHeightLimit)
511+                            let isNewQuickSwapPeriod = ((height - userLastQuickSwapHeight) > quickSwapLimitDuration)
512+                            let quickSwapUserSpent = if (isNewQuickSwapPeriod)
513+                                then 0
514+                                else quickSwapUserSpentInPeriod
515+                            let quickSwapLimitTotal = fraction(userGNsbtAmount, nsbtPrice, WAVELET)
516+                            let quickSwapLimit = (quickSwapLimitTotal - quickSwapUserSpent)
517+                            let swapUsdnVolume = if ((swapType == "neutrino"))
518+                                then inAmount
519+                                else outAmountGross
520+                            let checks = [if (if (isQuick)
521+                                then ((height - nsbtPriceLastHeight) > lastHeightLimit)
522+                                else false)
523+                                then throw("NSBT price is outdated")
524+                                else true, if (if (isQuick)
525+                                then (swapUsdnVolume > quickSwapLimit)
526+                                else false)
527+                                then throw(((("You have exceeded the quick swaps limit: limit=" + toString(quickSwapLimit)) + ", attemptedAmount=") + toString(swapUsdnVolume)))
528+                                else true, if (isBlocked)
529+                                then emergencyShutdownFAIL()
530+                                else true, if ((swapStatus != "PENDING"))
531+                                then throw("swap has been already processed")
532+                                else true, if ((unlockHeight > height))
533+                                then throw((("please wait for: " + toString(unlockHeight)) + " block height to withdraw funds"))
534+                                else true, if (if (if ((index > priceIndex))
535+                                then true
536+                                else (unlockHeight > indexHeight))
537+                                then true
538+                                else if ((prevIndexHeight != 0))
539+                                    then (prevIndexHeight >= unlockHeight)
540+                                    else false)
541+                                then priceIndexFAIL(index, priceIndex, indexHeight, unlockHeight, prevIndexHeight)
542+                                else true, if ((0 >= payoutsArray[IdxGrossAmount]))
543+                                then throw("balance equals zero")
544+                                else true, if (if ((0 > outFeePart))
545+                                then true
546+                                else (outFeePart >= PAULI))
547+                                then throw(((("invalid outFeePart config for " + swapType) + " swap: outFeePart=") + toString(outFeePart)))
548+                                else true]
549+                            if ((checks == checks))
550+                                then {
551+                                    let leasePart = if (if ((swapType == "neutrino"))
552+                                        then (outAmountGross > 0)
553+                                        else false)
554+                                        then invoke(this, "prepareUnleaseAndLeaseWrapper", [outAmountGross], nil)
555+                                        else unit
556+                                    if ((leasePart == leasePart))
557+                                        then {
558+                                            let gNsbtContract = addressFromStringValue(getStringValue(this, keyGNsbtContract))
559+                                            let sendFee = invoke(gNsbtContract, "deposit", nil, [AttachedPayment(outAsset, outFeeAmount)])
560+                                            if ((sendFee == sendFee))
561+                                                then {
562+                                                    let quickSwapPart = if (isQuick)
563+                                                        then [IntegerEntry(keyQuickSwapUserSpentInPeriod(userAddress), (swapUsdnVolume + quickSwapUserSpent)), IntegerEntry(keyUserLastQuickSwapHeight(userAddress), height)]
564+                                                        else nil
565+                                                    (quickSwapPart ++ [IntegerEntry(totalLockedByUserKEY(swapType, account), (totalLockedByUser - inAmount)), IntegerEntry(totalLockedKEY(swapType), (totalLocked - inAmount)), ScriptTransfer(userAddress, outNetAmount, outAsset), StringEntry(swapKEY(account, swapTxId), finishSwapDATA(dataArray, priceByIndex, outNetAmount, outFeeAmount, unlockHeight, index, toBase58String(i.transactionId)))])
566+                                                    }
567+                                                else throw("Strict value is not equal to itself.")
568+                                            }
569+                                        else throw("Strict value is not equal to itself.")
570+                                    }
571+                                else throw("Strict value is not equal to itself.")
572+                            }
573+                        else throw("Strict value is not equal to itself.")
574+                    }
575+                else throw("Strict value is not equal to itself.")
576+            }
577+        else throw("Strict value is not equal to itself.")
578+    }
579+
580+
581+
582+@Callable(i)
583+func swapWavesToNeutrino () = {
584+    let pmt = value(i.payments[0])
585+    if (isDefined(pmt.assetId))
586+        then throw("Only Waves token is allowed for swapping.")
587+        else commonSwap("waves", i)
588+    }
589+
590+
591+
592+@Callable(i)
593+func swapNeutrinoToWaves () = {
594+    let pmt = value(i.payments[0])
595+    if ((pmt.assetId != neutrinoAssetId))
596+        then throw("Only appropriate Neutrino tokens are allowed for swapping.")
597+        else commonSwap("neutrino", i)
598+    }
599+
600+
601+
602+@Callable(i)
603+func withdraw (account,index,swapTxId) = {
604+    let result = invoke(this, "commonWithdraw", [account, index, swapTxId, base58'', false], nil)
605+    if ((result == result))
606+        then nil
607+        else throw("Strict value is not equal to itself.")
608+    }
609+
610+
611+
612+@Callable(i)
613+func withdrawV2 (account,index,swapTxId,isQuick) = {
614+    let result = invoke(this, "commonWithdraw", [account, index, swapTxId, base58'', isQuick], nil)
615+    if ((result == result))
616+        then nil
617+        else throw("Strict value is not equal to itself.")
618+    }
619+
620+
621+
622+@Callable(i)
623+func withdrawRand (account,index,swapTxId,rsaSig) = {
624+    let result = invoke(this, "commonWithdraw", [account, index, swapTxId, rsaSig, false], nil)
625+    if ((result == result))
626+        then nil
627+        else throw("Strict value is not equal to itself.")
628+    }
629+
630+
631+
632+@Callable(i)
633+func transferToAuction () = {
634+    let auctionNBAmount = (neutrinoSupply - assetBalance(addressFromStringValue(auctionContract), bondAssetId))
635+    let surplusWithLiquidation = (surplus - assetBalance(addressFromStringValue(liquidationContract), neutrinoAssetId))
636+    if (isBlocked)
637+        then throw("contract is blocked by EMERGENCY SHUTDOWN actions untill reactivation by emergency oracles")
638+        else if ((auctionNBAmount > (1 * PAULI)))
639+            then [ScriptTransfer(addressFromStringValue(auctionContract), auctionNBAmount, bondAssetId)]
640+            else if ((surplusWithLiquidation >= (1 * PAULI)))
641+                then [ScriptTransfer(addressFromStringValue(liquidationContract), surplusWithLiquidation, neutrinoAssetId)]
642+                else throw(((((((("bond were generated or do not need it. Deficit:" + toString(auctionNBAmount)) + "|") + toString(0)) + ". Surplus:") + toString(surplusWithLiquidation)) + "|") + toString(surplus)))
643+    }
644+
645+
646+
647+@Callable(i)
648+func acceptWaves () = if ((i.caller != addressFromStringValue(auctionContract)))
649+    then throw("Currently only auction contract is allowed to call")
650+    else $Tuple2(prepareUnleaseAndLease(0), "success")
651+
652+
653+
654+@Callable(i)
655+func quickSwapLimitREADONLY (gNsbtAmount) = $Tuple2(nil, (gNsbtAmount * getNSBTPrice()))
656+
657+
github/deemru/w8io/169f3d6 
37.70 ms ◑