tx · 9epzN5MhX2XGfVJSStYggB9krcGFaViUUWQLVfsKQGac

3MvMXhKFMPz4BuZj9Jr9UysuxbWFKRJZgb3:  -0.10000000 Waves

2023.01.24 12:05 [2418837] smart account 3MvMXhKFMPz4BuZj9Jr9UysuxbWFKRJZgb3 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9epzN5MhX2XGfVJSStYggB9krcGFaViUUWQLVfsKQGac",
    "fee": 10000000,
    "feeAssetId": null,
    "timestamp": 1674551208317,
    "version": 2,
    "chainId": 84,
    "sender": "3MvMXhKFMPz4BuZj9Jr9UysuxbWFKRJZgb3",
    "senderPublicKey": "DsnSbWaHh9UERrdY9ujfzmjph8zAbKdZPnUkX2hHFAZw",
    "proofs": [
        "5HnKe3HGUDmkFfioVHnHP4n4bCdrELLwfvR9FhaZ8GuFq9Ltz9at3Vh3V4iANFgRdXxwCveHdYKRZoo3iBE28rs9",
        "2jFfAZrSJ5gUHVCxkYqE3Aoyx6uEmnmLzLBPSxw57QzVxSKq5qUTjAtVq7fSnzaRCKhQoLK5ooV43BTt5xkFWJoo"
    ],
    "script": "base64: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",
    "height": 2418837,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 6UgAP4es1pmcvqtLGEP7p3RASGL1M31EK7SquG6NY8Bg
Next: 8rNSW1bvagcYARswfJfhVhDwwqWBZFQnWYHugVb9vckH

Diff: 

OldNewDifferences
88 let kActive = "active"
99 
1010 let kActiveGlob = "active_all_contracts"
11+
12+let kDeprecated = "deprecated_"
1113 
1214 let kAssetIdA = "A_asset_id"
1315 
5052 let kPeriodLength = "period_length"
5153 
5254 let kStartHeight = "start_height"
55+
56+let kDAppThreshold = "dApp_threshold"
5357 
5458 let kAdminPubKey1 = "admin_pub_1"
5559 
115119 
116120 let activeGlob = valueOrElse(getBoolean(oracle, kActiveGlob), true)
117121 
122+let deprecatedPool = valueOrElse(getBoolean(oracle, (kDeprecated + toString(this))), false)
123+
118124 let strAssetIdA = getStringValue(this, kAssetIdA)
119125 
120126 let strAssetIdB = getStringValue(this, kAssetIdB)
169175 
170176 let digits8 = 8
171177 
172-let dAppThreshold = 50
178+let exchangeRatioLimitMin = 60000000
173179 
174-let dAppThresholdScale2 = 100
175-
176-let exchangeRatioLimitMin = 90000000
177-
178-let exchangeRatioLimitMax = 110000000
180+let exchangeRatioLimitMax = 140000000
179181 
180182 let alpha = 50
181183 
337339     else throw("DApp is inactive at this moment")
338340 
339341 
342+func isDepricated () = if (!(deprecatedPool))
343+    then unit
344+    else throw("Pool is deprecated. Only withdraw action allowed.")
345+
346+
340347 func isAdminCall (i) = if (containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey))
341348     then unit
342349     else throw("Only admin can call this function")
353360 func throwOnePayment () = throw("One attached payment expected")
354361 
355362 
356-func throwThreshold (threshold,amountA,amountB) = throw(((((((((("New balance in assets of the DApp is less than threshold " + toString(threshold)) + ": ") + toString(amountA)) + " ") + assetNameA) + ", ") + toString(amountB)) + " ") + assetNameB))
357-
358-
359363 func suspendSuspicious () = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB) + ". State: ") + toString(accountBalance(assetIdA))) + " ") + assetNameA) + ", ") + toString(accountBalance(assetIdB))) + " ") + assetNameB))
360364 
361365 
366370 
367371 func calcStakingParams (stake,amount,assetId) = if (stake)
368372     then {
369-        let $t01050410570 = calcStakingFuncAndAddres(stake, assetId)
370-        let call = $t01050410570._1
371-        let stakingAddr = $t01050410570._2
373+        let $t01044410510 = calcStakingFuncAndAddres(stake, assetId)
374+        let call = $t01044410510._1
375+        let stakingAddr = $t01044410510._2
372376         $Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
373377         }
374378     else {
375-        let $t01065610722 = calcStakingFuncAndAddres(stake, assetId)
376-        let call = $t01065610722._1
377-        let stakingAddr = $t01065610722._2
379+        let $t01059610662 = calcStakingFuncAndAddres(stake, assetId)
380+        let call = $t01059610662._1
381+        let stakingAddr = $t01059610662._2
378382         $Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
379383         }
380384 
406410     }
407411 
408412 
413+func checkDAppThreshold (newBalanceA,newBalanceB,pmtAssetId) = {
414+    let dAppThreshold = getIntegerValue(this, kDAppThreshold)
415+    let ratio = if (if ((pmtAssetId == assetIdA))
416+        then (newBalanceA > newBalanceB)
417+        else false)
418+        then fraction(newBalanceA, 1, newBalanceB, CEILING)
419+        else if (if ((pmtAssetId == assetIdB))
420+            then (newBalanceB > newBalanceA)
421+            else false)
422+            then fraction(newBalanceB, 1, newBalanceA, CEILING)
423+            else 0
424+    if ((ratio > dAppThreshold))
425+        then {
426+            let $t01240712515 = if ((pmtAssetId == assetIdA))
427+                then $Tuple2(assetNameB, assetNameA)
428+                else $Tuple2(assetNameA, assetNameB)
429+            let token1 = $t01240712515._1
430+            let token2 = $t01240712515._2
431+            throw((((("Buying " + token1) + " is temporarily unavailable due to the ") + token2) + " depeg"))
432+            }
433+        else true
434+    }
435+
436+
409437 func replenishWithTwoTokensCalc (i,stakeFarming,lockType) = {
410438     let pmtAssetIdA = i.payments[0].assetId
411439     let pmtAssetIdB = i.payments[1].assetId
412440     let ratioShareTokensInA = fraction(scale8, i.payments[0].amount, balanceA)
413441     let ratioShareTokensInB = fraction(scale8, i.payments[1].amount, balanceB)
414-    let $t01231312390 = getAssetInfo(pmtAssetIdA)
415-    let pmtStrAssetIdA = $t01231312390._1
416-    let pmtAssetNameA = $t01231312390._2
417-    let pmtDecimalsA = $t01231312390._3
418-    let $t01239512512 = getAssetInfo(pmtAssetIdB)
419-    let pmtStrAssetIdB = $t01239512512._1
420-    let pmtAssetNameB = $t01239512512._2
421-    let pmtDecimalsB = $t01239512512._3
422-    let $t01251713021 = if ((ratioShareTokensInB > ratioShareTokensInA))
442+    let $t01297513052 = getAssetInfo(pmtAssetIdA)
443+    let pmtStrAssetIdA = $t01297513052._1
444+    let pmtAssetNameA = $t01297513052._2
445+    let pmtDecimalsA = $t01297513052._3
446+    let $t01305713174 = getAssetInfo(pmtAssetIdB)
447+    let pmtStrAssetIdB = $t01305713174._1
448+    let pmtAssetNameB = $t01305713174._2
449+    let pmtDecimalsB = $t01305713174._3
450+    let $t01317913683 = if ((ratioShareTokensInB > ratioShareTokensInA))
423451         then {
424452             let pmt = fraction(balanceB, ratioShareTokensInA, scale8, CEILING)
425453             $Tuple5(i.payments[0].amount, pmt, (i.payments[1].amount - pmt), pmtAssetIdB, ratioShareTokensInA)
428456             let pmt = fraction(balanceA, ratioShareTokensInB, scale8, CEILING)
429457             $Tuple5(pmt, i.payments[1].amount, (i.payments[0].amount - pmt), pmtAssetIdA, ratioShareTokensInB)
430458             }
431-    let pmtAmountA = $t01251713021._1
432-    let pmtAmountB = $t01251713021._2
433-    let change = $t01251713021._3
434-    let changeAssetId = $t01251713021._4
435-    let shareTokenRatio = $t01251713021._5
459+    let pmtAmountA = $t01317913683._1
460+    let pmtAmountB = $t01317913683._2
461+    let change = $t01317913683._3
462+    let changeAssetId = $t01317913683._4
463+    let shareTokenRatio = $t01317913683._5
436464     let shareTokenToPayAmount = fraction(shareTokenRatio, shareAssetSupply, scale8)
437465     if (if ((size(i.payments) != 2))
438466         then (size(i.payments) != 3)
487515 
488516 
489517 func replenishWithOneTokenCalc (i,virtualSwapTokenPay,virtualSwapTokenGet,stakeFarming,lockType) = {
490-    let $t01541115486 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
491-    let pmtAmount = $t01541115486._1
492-    let pmtAssetId = $t01541115486._2
493-    let $t01549115564 = getAssetInfo(pmtAssetId)
494-    let pmtStrAssetId = $t01549115564._1
495-    let pmtAssetName = $t01549115564._2
496-    let pmtDecimals = $t01549115564._3
518+    let $t01607316148 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
519+    let pmtAmount = $t01607316148._1
520+    let pmtAssetId = $t01607316148._2
521+    let $t01615316226 = getAssetInfo(pmtAssetId)
522+    let pmtStrAssetId = $t01615316226._1
523+    let pmtAssetName = $t01615316226._2
524+    let pmtDecimals = $t01615316226._3
497525     let pmtMinThreshold = 5000000
498526     let thresholdValueForMinTolerance = 50000000
499527     let tolerance = if ((thresholdValueForMinTolerance > pmtAmount))
515543                     else false)
516544                     then throwAssets()
517545                     else {
518-                        let $t01657117213 = if ((pmtAssetId == assetIdA))
546+                        let $t01722817870 = if ((pmtAssetId == assetIdA))
519547                             then $Tuple6((pmtAmount - virtualSwapTokenPay), virtualSwapTokenGet, (balanceA + virtualSwapTokenPay), (balanceB - virtualSwapTokenGet), (balanceA + pmtAmount), balanceB)
520548                             else $Tuple6(virtualSwapTokenGet, (pmtAmount - virtualSwapTokenPay), (balanceA - virtualSwapTokenGet), (balanceB + virtualSwapTokenPay), balanceA, (balanceB + pmtAmount))
521-                        let virtualReplenishA = $t01657117213._1
522-                        let virtualReplenishB = $t01657117213._2
523-                        let balanceAfterSwapA = $t01657117213._3
524-                        let balanceAfterSwapB = $t01657117213._4
525-                        let newBalanceA = $t01657117213._5
526-                        let newBalanceB = $t01657117213._6
549+                        let virtualReplenishA = $t01722817870._1
550+                        let virtualReplenishB = $t01722817870._2
551+                        let balanceAfterSwapA = $t01722817870._3
552+                        let balanceAfterSwapB = $t01722817870._4
553+                        let newBalanceA = $t01722817870._5
554+                        let newBalanceB = $t01722817870._6
527555                         let invariantNew = invariantCalc(balanceAfterSwapA, balanceAfterSwapB)
528556                         let ratioVirtualBalanceToVirtualReplenish = (fraction(scale16, balanceAfterSwapA, balanceAfterSwapB) / fraction(scale8, virtualReplenishA, virtualReplenishB))
529-                        let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))
530557                         if (if ((slippageValueMinForSwap >= fraction(scale8, invariant, invariantNew)))
531558                             then true
532559                             else (invariant > invariantNew))
535562                                 then true
536563                                 else (ratioVirtualBalanceToVirtualReplenish > slippageValueMaxForReplenish))
537564                                 then throw("Swap with virtualSwapTokenPay and virtualSwapTokenGet is possible, but ratio after virtual swap is incorrect")
538-                                else if (if ((dAppThresholdAmount > newBalanceA))
539-                                    then true
540-                                    else (dAppThresholdAmount > newBalanceB))
541-                                    then throwThreshold(dAppThresholdAmount, newBalanceA, newBalanceB)
565+                                else if (!(checkDAppThreshold(newBalanceA, newBalanceB, pmtAssetId)))
566+                                    then throw()
542567                                     else {
543568                                         let ratioShareTokensInA = fraction(virtualReplenishA, scale8, balanceAfterSwapA)
544569                                         let ratioShareTokensInB = fraction(virtualReplenishB, scale8, balanceAfterSwapB)
547572                                         let shareTokenGovernanceReward = fraction(shareTokenToPayAmount, (feeGovernance / 2), feeScale6)
548573                                         let governanceRewardTokenA = fraction(shareTokenGovernanceReward, balanceA, shareAssetSupply)
549574                                         let governanceRewardTokenB = fraction(shareTokenGovernanceReward, balanceB, shareAssetSupply)
550-                                        let $t01920319498 = if ((pmtStrAssetId == strAssetIdA))
575+                                        let $t01962119904 = if ((pmtStrAssetId == strAssetIdA))
551576                                             then $Tuple3((pmtAmount - governanceRewardTokenA), governanceRewardTokenB, strAssetIdB)
552577                                             else $Tuple3((pmtAmount - governanceRewardTokenB), governanceRewardTokenA, strAssetIdA)
553-                                        let stakeAmount = $t01920319498._1
554-                                        let unstakeAmount = $t01920319498._2
555-                                        let unstakeAsset = $t01920319498._3
578+                                        let stakeAmount = $t01962119904._1
579+                                        let unstakeAmount = $t01962119904._2
580+                                        let unstakeAsset = $t01962119904._3
556581                                         let stake1 = if (contains(stakingAssets, pmtStrAssetId))
557582                                             then invoke(this, "stakeUnstake", [true, stakeAmount, pmtStrAssetId], nil)
558583                                             else 0
592617 
593618 
594619 func withdrawCalc (i,unlockAmount) = {
595-    let $t02148521820 = if ((size(i.payments) == 1))
620+    let $t02175322088 = if ((size(i.payments) == 1))
596621         then if ((i.payments[0].assetId != shareAssetId))
597622             then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
598623             else $Tuple2(i.payments[0].amount, i.payments[0].assetId)
599624         else $Tuple2(0, shareAssetId)
600-    let pmtAmount = $t02148521820._1
601-    let pmtAssetId = $t02148521820._2
625+    let pmtAmount = $t02175322088._1
626+    let pmtAssetId = $t02175322088._2
602627     if (!(hasEnoughBalance))
603628         then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
604629         else {
632657 
633658 @Callable(i)
634659 func init (firstHarvest) = {
635-    let $t02337223449 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
636-    let pmtAmountA = $t02337223449._1
637-    let pmtAssetIdA = $t02337223449._2
638-    let $t02345423531 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
639-    let pmtAmountB = $t02345423531._1
640-    let pmtAssetIdB = $t02345423531._2
641-    let $t02353623613 = getAssetInfo(pmtAssetIdA)
642-    let pmtStrAssetIdA = $t02353623613._1
643-    let pmtAssetNameA = $t02353623613._2
644-    let pmtDecimalsA = $t02353623613._3
645-    let $t02361823695 = getAssetInfo(pmtAssetIdB)
646-    let pmtStrAssetIdB = $t02361823695._1
647-    let pmtAssetNameB = $t02361823695._2
648-    let pmtDecimalsB = $t02361823695._3
660+    let $t02364023717 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
661+    let pmtAmountA = $t02364023717._1
662+    let pmtAssetIdA = $t02364023717._2
663+    let $t02372223799 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
664+    let pmtAmountB = $t02372223799._1
665+    let pmtAssetIdB = $t02372223799._2
666+    let $t02380423881 = getAssetInfo(pmtAssetIdA)
667+    let pmtStrAssetIdA = $t02380423881._1
668+    let pmtAssetNameA = $t02380423881._2
669+    let pmtDecimalsA = $t02380423881._3
670+    let $t02388623963 = getAssetInfo(pmtAssetIdB)
671+    let pmtStrAssetIdB = $t02388623963._1
672+    let pmtAssetNameB = $t02388623963._2
673+    let pmtDecimalsB = $t02388623963._3
649674     if (isDefined(getBoolean(this, kActive)))
650675         then throwIsActive()
651676         else if ((pmtAssetIdA == pmtAssetIdB))
668693                             else 0
669694                         if ((stake2 == stake2))
670695                             then {
671-                                let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kInvariant, invariantCalculated), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_flat")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
696+                                let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kInvariant, invariantCalculated), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_flat")), IntegerEntry(kDAppThreshold, 3), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
672697                                 if (firstHarvest)
673698                                     then (baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
674699                                     else baseEntry
682707 
683708 
684709 @Callable(i)
685-func replenishWithTwoTokensV2 (stakeFarming,lockType) = valueOrElse(isActive(), replenishWithTwoTokensCalc(i, stakeFarming, lockType))
710+func replenishWithTwoTokensV2 (stakeFarming,lockType) = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithTwoTokensCalc(i, stakeFarming, lockType)))
686711 
687712 
688713 
689714 @Callable(i)
690-func replenishWithOneTokenV2 (virtualSwapTokenPay,virtualSwapTokenGet,stakeFarming,lockType) = valueOrElse(isActive(), replenishWithOneTokenCalc(i, virtualSwapTokenPay, virtualSwapTokenGet, stakeFarming, lockType))
715+func replenishWithOneTokenV2 (virtualSwapTokenPay,virtualSwapTokenGet,stakeFarming,lockType) = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithOneTokenCalc(i, virtualSwapTokenPay, virtualSwapTokenGet, stakeFarming, lockType)))
691716 
692717 
693718 
697722 
698723 
699724 @Callable(i)
700-func withdrawOneToken (unlockAmount,withdrawAsset,estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), {
701-    let $t02706527400 = if ((size(i.payments) == 1))
725+func withdrawOneToken (unlockAmount,withdrawAsset,estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), valueOrElse(isDepricated(), {
726+    let $t02752527884 = if ((size(i.payments) == 1))
702727         then if ((i.payments[0].assetId != shareAssetId))
703728             then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
704729             else $Tuple2(i.payments[0].amount, i.payments[0].assetId)
705730         else $Tuple2(0, shareAssetId)
706-    let pmtAmount = $t02706527400._1
707-    let pmtAssetId = $t02706527400._2
731+    let pmtAmount = $t02752527884._1
732+    let pmtAssetId = $t02752527884._2
708733     let withdrawAmount = (pmtAmount + unlockAmount)
709734     if (if ((withdrawAsset != strAssetIdA))
710735         then (withdrawAsset != strAssetIdB)
730755                                 else calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, amountToPayA, assetIdA, newVirtBalcA, newVirtBalcB, invariantCalc(newVirtBalcA, newVirtBalcB))
731756                             let govReward = fraction(amountExchangedWithFee, fraction(feeGovernance, feeDiscount, feeScale6, CEILING), feeScale6)
732757                             let amountExchanged = fraction(amountExchangedWithFee, (feeScale6 - fraction(fee, feeDiscount, feeScale6, CEILING)), feeScale6)
733-                            let $t02900329332 = if ((withdrawAsset == strAssetIdA))
734-                                then $Tuple3((amountToPayA + amountExchanged), (((balanceA - amountToPayA) - amountExchanged) - govReward), balanceB)
735-                                else $Tuple3((amountToPayB + amountExchanged), balanceA, (((balanceB - amountToPayB) - amountExchanged) - govReward))
736-                            let amountToPay = $t02900329332._1
737-                            let balanceANew = $t02900329332._2
738-                            let balanceBNew = $t02900329332._3
739-                            let invariantCalculated = invariantCalc(balanceANew, balanceBNew)
740-                            let stake1 = if (contains(stakingAssets, withdrawAsset))
741-                                then invoke(this, "stakeUnstake", [false, (amountToPay + govReward), withdrawAsset], nil)
742-                                else 0
743-                            if ((stake1 == stake1))
744-                                then [IntegerEntry(kBalanceA, balanceANew), IntegerEntry(kBalanceB, balanceBNew), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), IntegerEntry(kInvariant, invariantCalculated), Burn(shareAssetId, withdrawAmount), ScriptTransfer(i.caller, amountToPay, fromBase58String(withdrawAsset)), ScriptTransfer(moneyBoxAddress, govReward, fromBase58String(withdrawAsset))]
745-                                else throw("Strict value is not equal to itself.")
758+                            let $t02957529949 = if ((withdrawAsset == strAssetIdA))
759+                                then $Tuple4((amountToPayA + amountExchanged), (((balanceA - amountToPayA) - amountExchanged) - govReward), balanceB, assetIdB)
760+                                else $Tuple4((amountToPayB + amountExchanged), balanceA, (((balanceB - amountToPayB) - amountExchanged) - govReward), assetIdA)
761+                            let amountToPay = $t02957529949._1
762+                            let balanceANew = $t02957529949._2
763+                            let balanceBNew = $t02957529949._3
764+                            let virtAssetId = $t02957529949._4
765+                            if (!(checkDAppThreshold(balanceANew, balanceBNew, virtAssetId)))
766+                                then throw()
767+                                else {
768+                                    let invariantCalculated = invariantCalc(balanceANew, balanceBNew)
769+                                    let stake1 = if (contains(stakingAssets, withdrawAsset))
770+                                        then invoke(this, "stakeUnstake", [false, (amountToPay + govReward), withdrawAsset], nil)
771+                                        else 0
772+                                    if ((stake1 == stake1))
773+                                        then [IntegerEntry(kBalanceA, balanceANew), IntegerEntry(kBalanceB, balanceBNew), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), IntegerEntry(kInvariant, invariantCalculated), Burn(shareAssetId, withdrawAmount), ScriptTransfer(i.caller, amountToPay, fromBase58String(withdrawAsset)), ScriptTransfer(moneyBoxAddress, govReward, fromBase58String(withdrawAsset))]
774+                                        else throw("Strict value is not equal to itself.")
775+                                    }
746776                             }
747777                         else throw("Strict value is not equal to itself.")
748778                     }
749-    })
779+    }))
750780 
751781 
752782 
753783 @Callable(i)
754-func exchange (estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), {
755-    let $t03020530280 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
756-    let pmtAmount = $t03020530280._1
757-    let pmtAssetId = $t03020530280._2
784+func exchange (estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), valueOrElse(isDepricated(), {
785+    let $t03101931094 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
786+    let pmtAmount = $t03101931094._1
787+    let pmtAssetId = $t03101931094._2
758788     if ((0 >= estimatedAmountToReceive))
759789         then throw(("Estimated amount must be positive. Actual: " + toString(estimatedAmountToReceive)))
760790         else if ((minAmountToReceive > estimatedAmountToReceive))
781811                                     let feeDiscount = calculateFeeDiscount(i.originCaller)
782812                                     let governanceReward = fraction(amount, fraction(feeGovernance, feeDiscount, feeScale6, CEILING), feeScale6)
783813                                     let amountMinusFee = fraction(amount, (feeScale6 - fraction(fee, feeDiscount, feeScale6, CEILING)), feeScale6)
784-                                    let $t03176432026 = if ((pmtAssetId == assetIdA))
814+                                    let $t03269032968 = if ((pmtAssetId == assetIdA))
785815                                         then $Tuple2((balanceA + pmtAmount), ((balanceB - amountMinusFee) - governanceReward))
786816                                         else $Tuple2(((balanceA - amountMinusFee) - governanceReward), (balanceB + pmtAmount))
787-                                    let newBalanceA = $t03176432026._1
788-                                    let newBalanceB = $t03176432026._2
789-                                    let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))
790-                                    if (if ((dAppThresholdAmount > newBalanceA))
791-                                        then true
792-                                        else (dAppThresholdAmount > newBalanceB))
793-                                        then throwThreshold(dAppThresholdAmount, newBalanceA, newBalanceB)
817+                                    let newBalanceA = $t03269032968._1
818+                                    let newBalanceB = $t03269032968._2
819+                                    if (!(checkDAppThreshold(newBalanceA, newBalanceB, pmtAssetId)))
820+                                        then throw()
794821                                         else {
795-                                            let $t03232532398 = getAssetInfo(pmtAssetId)
796-                                            let pmtStrAssetId = $t03232532398._1
797-                                            let pmtAssetName = $t03232532398._2
798-                                            let pmtDecimals = $t03232532398._3
799-                                            let $t03241132488 = getAssetInfo(sendAssetId)
800-                                            let sendStrAssetId = $t03241132488._1
801-                                            let sendAssetName = $t03241132488._2
802-                                            let sendDecimals = $t03241132488._3
822+                                            let $t03307433147 = getAssetInfo(pmtAssetId)
823+                                            let pmtStrAssetId = $t03307433147._1
824+                                            let pmtAssetName = $t03307433147._2
825+                                            let pmtDecimals = $t03307433147._3
826+                                            let $t03316033237 = getAssetInfo(sendAssetId)
827+                                            let sendStrAssetId = $t03316033237._1
828+                                            let sendAssetName = $t03316033237._2
829+                                            let sendDecimals = $t03316033237._3
803830                                             let stake1 = if (contains(stakingAssets, pmtStrAssetId))
804831                                                 then invoke(this, "stakeUnstake", [true, pmtAmount, pmtStrAssetId], nil)
805832                                                 else 0
815842                                                 else throw("Strict value is not equal to itself.")
816843                                             }
817844                                     }
818-    })
845+    }))
819846 
820847 
821848 
894921 func stakeUnstake (stake,amount,assetIdString) = if ((i.caller != this))
895922     then throw("Only contract itself can invoke this function")
896923     else {
897-        let $t03593236035 = calcStakingParams(stake, amount, fromBase58String(assetIdString))
898-        let call = $t03593236035._1
899-        let addr = $t03593236035._2
900-        let params = $t03593236035._3
901-        let payments = $t03593236035._4
924+        let $t03688936992 = calcStakingParams(stake, amount, fromBase58String(assetIdString))
925+        let call = $t03688936992._1
926+        let addr = $t03688936992._2
927+        let params = $t03688936992._3
928+        let payments = $t03688936992._4
902929         let inv = invoke(addr, call, params, payments)
903930         if ((inv == inv))
904931             then nil
908935 
909936 
910937 @Callable(i)
911-func replenishWithTwoTokens () = valueOrElse(isActive(), replenishWithTwoTokensCalc(i, false, 0))
938+func replenishWithTwoTokens () = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithTwoTokensCalc(i, false, 0)))
912939 
913940 
914941 
915942 @Callable(i)
916-func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet) = valueOrElse(isActive(), replenishWithOneTokenCalc(i, virtualSwapTokenPay, virtualSwapTokenGet, false, 0))
943+func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet) = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithOneTokenCalc(i, virtualSwapTokenPay, virtualSwapTokenGet, false, 0)))
917944 
918945 
919946 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let version = "2.0.0"
55 
66 let kVersion = "version"
77 
88 let kActive = "active"
99 
1010 let kActiveGlob = "active_all_contracts"
11+
12+let kDeprecated = "deprecated_"
1113 
1214 let kAssetIdA = "A_asset_id"
1315 
1416 let kAssetIdB = "B_asset_id"
1517 
1618 let kBalanceA = "A_asset_balance"
1719 
1820 let kBalanceB = "B_asset_balance"
1921 
2022 let kShareAssetId = "share_asset_id"
2123 
2224 let kShareAssetSupply = "share_asset_supply"
2325 
2426 let kFee = "commission"
2527 
2628 let kInvariant = "invariant"
2729 
2830 let kCause = "shutdown_cause"
2931 
3032 let kUSDNAddress = "staking_usdnnsbt_address"
3133 
3234 let kEURNAddress = "staking_eurn_address"
3335 
3436 let kDiscounts = "discounts"
3537 
3638 let kDiscountValues = "discount_values"
3739 
3840 let kUserSwopInGov = "_SWOP_amount"
3941 
4042 let kUserGSwopInGov = "_GSwop_amount"
4143 
4244 let kFirstHarvest = "first_harvest"
4345 
4446 let kFirstHarvestHeight = "first_harvest_height"
4547 
4648 let kShareLimit = "share_limit_on_first_harvest"
4749 
4850 let kBasePeriod = "base_period"
4951 
5052 let kPeriodLength = "period_length"
5153 
5254 let kStartHeight = "start_height"
55+
56+let kDAppThreshold = "dApp_threshold"
5357 
5458 let kAdminPubKey1 = "admin_pub_1"
5559 
5660 let kAdminPubKey2 = "admin_pub_2"
5761 
5862 let kAdminPubKey3 = "admin_pub_3"
5963 
6064 let kAdminInvokePubKey = "admin_invoke_pub"
6165 
6266 let kMoneyBoxAddress = "money_box_address"
6367 
6468 let kGovAddress = "governance_address"
6569 
6670 let kFarmingAddress = "farming_address"
6771 
6872 let kVotingAddress = "voting_address"
6973 
7074 let kUSDNAssetId = "usdn_asset_id"
7175 
7276 let kStakingAssets = "staking_assets"
7377 
7478 let oracle = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
7579 
7680 func getBase58FromOracle (key) = match getString(oracle, key) {
7781     case string: String => 
7882         fromBase58String(string)
7983     case nothing => 
8084         throw((key + "is empty"))
8185 }
8286 
8387 
8488 let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
8589 
8690 let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
8791 
8892 let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
8993 
9094 let adminPubKeyInvoke = getBase58FromOracle(kAdminInvokePubKey)
9195 
9296 let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
9397 
9498 let govAddress = Address(getBase58FromOracle(kGovAddress))
9599 
96100 let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
97101 
98102 let votingAddress = Address(getBase58FromOracle(kVotingAddress))
99103 
100104 let farmingAddress = Address(getBase58FromOracle(kFarmingAddress))
101105 
102106 let USDN = getBase58FromOracle(kUSDNAssetId)
103107 
104108 let stakingAssets = getStringValue(oracle, kStakingAssets)
105109 
106110 let basePeriod = valueOrErrorMessage(getInteger(votingAddress, kBasePeriod), "Empty kBasePeriod")
107111 
108112 let startHeight = valueOrErrorMessage(getInteger(votingAddress, kStartHeight), "Empty kStartHeight")
109113 
110114 let periodLength = valueOrErrorMessage(getInteger(votingAddress, kPeriodLength), "Empty kPeriodLength")
111115 
112116 let firstHarvestEndPeriod = ((basePeriod + ((height - startHeight) / periodLength)) + 3)
113117 
114118 let active = getBooleanValue(this, kActive)
115119 
116120 let activeGlob = valueOrElse(getBoolean(oracle, kActiveGlob), true)
117121 
122+let deprecatedPool = valueOrElse(getBoolean(oracle, (kDeprecated + toString(this))), false)
123+
118124 let strAssetIdA = getStringValue(this, kAssetIdA)
119125 
120126 let strAssetIdB = getStringValue(this, kAssetIdB)
121127 
122128 let assetIdA = if ((strAssetIdA == "WAVES"))
123129     then unit
124130     else fromBase58String(strAssetIdA)
125131 
126132 let assetIdB = if ((strAssetIdB == "WAVES"))
127133     then unit
128134     else fromBase58String(strAssetIdB)
129135 
130136 let assetNameA = match assetIdA {
131137     case id: ByteVector => 
132138         value(assetInfo(id)).name
133139     case waves: Unit => 
134140         "WAVES"
135141     case _ => 
136142         throw("Match error")
137143 }
138144 
139145 let assetNameB = match assetIdB {
140146     case id: ByteVector => 
141147         value(assetInfo(id)).name
142148     case waves: Unit => 
143149         "WAVES"
144150     case _ => 
145151         throw("Match error")
146152 }
147153 
148154 let balanceA = getIntegerValue(this, kBalanceA)
149155 
150156 let balanceB = getIntegerValue(this, kBalanceB)
151157 
152158 let shareAssetId = fromBase58String(getStringValue(this, kShareAssetId))
153159 
154160 let shareAssetSupply = getIntegerValue(this, kShareAssetSupply)
155161 
156162 let invariant = getIntegerValue(this, kInvariant)
157163 
158164 let fee = getIntegerValue(this, kFee)
159165 
160166 let feeGovernance = fraction(fee, 40, 100)
161167 
162168 let feeScale6 = 1000000
163169 
164170 let scale3 = 1000
165171 
166172 let scale8 = 100000000
167173 
168174 let scale16 = 10000000000000000
169175 
170176 let digits8 = 8
171177 
172-let dAppThreshold = 50
178+let exchangeRatioLimitMin = 60000000
173179 
174-let dAppThresholdScale2 = 100
175-
176-let exchangeRatioLimitMin = 90000000
177-
178-let exchangeRatioLimitMax = 110000000
180+let exchangeRatioLimitMax = 140000000
179181 
180182 let alpha = 50
181183 
182184 let alphaDigits = 2
183185 
184186 let beta = 4600000000000000
185187 
186188 func accountBalance (assetId) = match assetId {
187189     case id: ByteVector => 
188190         assetBalance(this, id)
189191     case waves: Unit => 
190192         wavesBalance(this).available
191193     case _ => 
192194         throw("Match error")
193195 }
194196 
195197 
196198 func stakedAmount (assetId) = {
197199     let stakedAmountCalculated =     match assetId {
198200         case aId: ByteVector => 
199201             if ((aId == USDN))
200202                 then getInteger(stakingUSDNAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(this)))
201203                 else 0
202204         case _: Unit => 
203205             0
204206         case _ => 
205207             throw("Match error")
206208     }
207209     match stakedAmountCalculated {
208210         case i: Int => 
209211             i
210212         case _ => 
211213             0
212214     }
213215     }
214216 
215217 
216218 let stakedAmountA = stakedAmount(assetIdA)
217219 
218220 let stakedAmountB = stakedAmount(assetIdB)
219221 
220222 let availableBalanceA = (balanceA - stakedAmountA)
221223 
222224 let availableBalanceB = (balanceB - stakedAmountB)
223225 
224226 let accountBalanceWithStakedA = (accountBalance(assetIdA) + stakedAmountA)
225227 
226228 let accountBalanceWithStakedB = (accountBalance(assetIdB) + stakedAmountB)
227229 
228230 let hasEnoughBalance = if ((accountBalanceWithStakedA >= balanceA))
229231     then (accountBalanceWithStakedB >= balanceB)
230232     else false
231233 
232234 func skewness (x,y) = ((fraction(scale16, x, y) + fraction(scale16, y, x)) / 2)
233235 
234236 
235237 func invariantCalc (x,y) = {
236238     let sk = skewness(x, y)
237239     (fraction((x + y), scale16, pow(sk, digits8, alpha, alphaDigits, digits8, CEILING)) + (2 * fraction(toInt(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN)), pow((sk - beta), digits8, alpha, alphaDigits, digits8, DOWN), scale8)))
238240     }
239241 
240242 
241243 func calculateSendAmount (amountToSendEstimated,minTokenReceiveAmount,tokenReceiveAmount,tokenId,balcA,balcB,invCur) = {
242244     let worstAllowedNewInvariantRatio = (scale16 - ((scale16 * 1) / 10000000))
243245     let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
244246     let x = (balcA + tokenReceiveAmount)
245247     let y = (balcB + tokenReceiveAmount)
246248     func getStepAmount (acc,step) =     if ((acc._1 == -1))
247249         then {
248250             let amountToSend = (amountToSendEstimated - (((step * deltaBetweenMaxAndMinSendValue) / 3) / scale3))
249251             let stepInvariant = if ((tokenId == assetIdA))
250252                 then invariantCalc(x, (balcB - amountToSend))
251253                 else invariantCalc((balcA - amountToSend), y)
252254             if ((stepInvariant > invCur))
253255                 then $Tuple2(amountToSend, stepInvariant)
254256                 else $Tuple2(-1, 0)
255257             }
256258         else acc
257259 
258260     let amountToSendMin = getStepAmount($Tuple2(-1, 0), 3000)
259261     if ((0 > amountToSendMin._1))
260262         then throw("Price is worse than minReceived")
261263         else {
262264             let invEstimated = if ((tokenId == assetIdA))
263265                 then invariantCalc(x, (balcB - amountToSendEstimated))
264266                 else if ((tokenId == assetIdB))
265267                     then invariantCalc((balcA - amountToSendEstimated), y)
266268                     else throw("Wrong asset in payment")
267269             if ((invCur > invEstimated))
268270                 then if ((worstAllowedNewInvariantRatio >= fraction(scale16, invCur, invEstimated)))
269271                     then throw("The requested price is too not profitable for user")
270272                     else {
271273                         let a = {
272274                             let $l = [25, 200, 500]
273275                             let $s = size($l)
274276                             let $acc0 = $Tuple2(-1, 0)
275277                             func $f0_1 ($a,$i) =                             if (($i >= $s))
276278                                 then $a
277279                                 else getStepAmount($a, $l[$i])
278280 
279281                             func $f0_2 ($a,$i) =                             if (($i >= $s))
280282                                 then $a
281283                                 else throw("List size exceeds 3")
282284 
283285                             $f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
284286                             }
285287                         if ((0 > a._1))
286288                             then amountToSendMin._1
287289                             else a._1
288290                         }
289291                 else {
290292                     let a = {
291293                         let $l = [-500, -200, -25]
292294                         let $s = size($l)
293295                         let $acc0 = $Tuple2(-1, 0)
294296                         func $f0_1 ($a,$i) =                         if (($i >= $s))
295297                             then $a
296298                             else getStepAmount($a, $l[$i])
297299 
298300                         func $f0_2 ($a,$i) =                         if (($i >= $s))
299301                             then $a
300302                             else throw("List size exceeds 3")
301303 
302304                         $f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
303305                         }
304306                     let tupleSendBetter = if ((0 > a._1))
305307                         then $Tuple2(amountToSendEstimated, invEstimated)
306308                         else a
307309                     if ((worstAllowedNewInvariantRatio >= fraction(scale16, invCur, tupleSendBetter._2)))
308310                         then throw("The requested price is too not profitable for user")
309311                         else tupleSendBetter._1
310312                     }
311313             }
312314     }
313315 
314316 
315317 func getAssetInfo (assetId) = match assetId {
316318     case id: ByteVector => 
317319         let stringId = toBase58String(id)
318320         let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
319321         $Tuple3(stringId, info.name, info.decimals)
320322     case waves: Unit => 
321323         $Tuple3("WAVES", "WAVES", 8)
322324     case _ => 
323325         throw("Match error")
324326 }
325327 
326328 
327329 func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
328330 
329331 
330332 func throwIsActive () = throw("DApp is already active")
331333 
332334 
333335 func isActive () = if (if (active)
334336     then activeGlob
335337     else false)
336338     then unit
337339     else throw("DApp is inactive at this moment")
338340 
339341 
342+func isDepricated () = if (!(deprecatedPool))
343+    then unit
344+    else throw("Pool is deprecated. Only withdraw action allowed.")
345+
346+
340347 func isAdminCall (i) = if (containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey))
341348     then unit
342349     else throw("Only admin can call this function")
343350 
344351 
345352 func isSelfCall (i) = if ((this == i.caller))
346353     then unit
347354     else throw("Only contract itself can call this function")
348355 
349356 
350357 func throwAssets () = throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
351358 
352359 
353360 func throwOnePayment () = throw("One attached payment expected")
354361 
355362 
356-func throwThreshold (threshold,amountA,amountB) = throw(((((((((("New balance in assets of the DApp is less than threshold " + toString(threshold)) + ": ") + toString(amountA)) + " ") + assetNameA) + ", ") + toString(amountB)) + " ") + assetNameB))
357-
358-
359363 func suspendSuspicious () = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB) + ". State: ") + toString(accountBalance(assetIdA))) + " ") + assetNameA) + ", ") + toString(accountBalance(assetIdB))) + " ") + assetNameB))
360364 
361365 
362366 func calcStakingFuncAndAddres (stake,assetId) = if (stake)
363367     then $Tuple2("lockNeutrino", stakingUSDNAddress)
364368     else $Tuple2("unlockNeutrino", stakingUSDNAddress)
365369 
366370 
367371 func calcStakingParams (stake,amount,assetId) = if (stake)
368372     then {
369-        let $t01050410570 = calcStakingFuncAndAddres(stake, assetId)
370-        let call = $t01050410570._1
371-        let stakingAddr = $t01050410570._2
373+        let $t01044410510 = calcStakingFuncAndAddres(stake, assetId)
374+        let call = $t01044410510._1
375+        let stakingAddr = $t01044410510._2
372376         $Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
373377         }
374378     else {
375-        let $t01065610722 = calcStakingFuncAndAddres(stake, assetId)
376-        let call = $t01065610722._1
377-        let stakingAddr = $t01065610722._2
379+        let $t01059610662 = calcStakingFuncAndAddres(stake, assetId)
380+        let call = $t01059610662._1
381+        let stakingAddr = $t01059610662._2
378382         $Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
379383         }
380384 
381385 
382386 func calculateFeeDiscount (userAddr) = {
383387     let swopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserSwopInGov)), 0)
384388     let gSwopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserGSwopInGov)), swopAmount)
385389     let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
386390     let discounts = split(getStringValue(oracle, kDiscounts), ",")
387391     if (if ((gSwopAmount >= parseIntValue(discountValues[0])))
388392         then (parseIntValue(discountValues[1]) > gSwopAmount)
389393         else false)
390394         then (feeScale6 - parseIntValue(discounts[0]))
391395         else if (if ((gSwopAmount >= parseIntValue(discountValues[1])))
392396             then (parseIntValue(discountValues[2]) > gSwopAmount)
393397             else false)
394398             then (feeScale6 - parseIntValue(discounts[1]))
395399             else if (if ((gSwopAmount >= parseIntValue(discountValues[2])))
396400                 then (parseIntValue(discountValues[3]) > gSwopAmount)
397401                 else false)
398402                 then (feeScale6 - parseIntValue(discounts[2]))
399403                 else if (if ((gSwopAmount >= parseIntValue(discountValues[3])))
400404                     then (parseIntValue(discountValues[4]) > gSwopAmount)
401405                     else false)
402406                     then (feeScale6 - parseIntValue(discounts[3]))
403407                     else if ((gSwopAmount >= parseIntValue(discountValues[4])))
404408                         then (feeScale6 - parseIntValue(discounts[4]))
405409                         else feeScale6
406410     }
407411 
408412 
413+func checkDAppThreshold (newBalanceA,newBalanceB,pmtAssetId) = {
414+    let dAppThreshold = getIntegerValue(this, kDAppThreshold)
415+    let ratio = if (if ((pmtAssetId == assetIdA))
416+        then (newBalanceA > newBalanceB)
417+        else false)
418+        then fraction(newBalanceA, 1, newBalanceB, CEILING)
419+        else if (if ((pmtAssetId == assetIdB))
420+            then (newBalanceB > newBalanceA)
421+            else false)
422+            then fraction(newBalanceB, 1, newBalanceA, CEILING)
423+            else 0
424+    if ((ratio > dAppThreshold))
425+        then {
426+            let $t01240712515 = if ((pmtAssetId == assetIdA))
427+                then $Tuple2(assetNameB, assetNameA)
428+                else $Tuple2(assetNameA, assetNameB)
429+            let token1 = $t01240712515._1
430+            let token2 = $t01240712515._2
431+            throw((((("Buying " + token1) + " is temporarily unavailable due to the ") + token2) + " depeg"))
432+            }
433+        else true
434+    }
435+
436+
409437 func replenishWithTwoTokensCalc (i,stakeFarming,lockType) = {
410438     let pmtAssetIdA = i.payments[0].assetId
411439     let pmtAssetIdB = i.payments[1].assetId
412440     let ratioShareTokensInA = fraction(scale8, i.payments[0].amount, balanceA)
413441     let ratioShareTokensInB = fraction(scale8, i.payments[1].amount, balanceB)
414-    let $t01231312390 = getAssetInfo(pmtAssetIdA)
415-    let pmtStrAssetIdA = $t01231312390._1
416-    let pmtAssetNameA = $t01231312390._2
417-    let pmtDecimalsA = $t01231312390._3
418-    let $t01239512512 = getAssetInfo(pmtAssetIdB)
419-    let pmtStrAssetIdB = $t01239512512._1
420-    let pmtAssetNameB = $t01239512512._2
421-    let pmtDecimalsB = $t01239512512._3
422-    let $t01251713021 = if ((ratioShareTokensInB > ratioShareTokensInA))
442+    let $t01297513052 = getAssetInfo(pmtAssetIdA)
443+    let pmtStrAssetIdA = $t01297513052._1
444+    let pmtAssetNameA = $t01297513052._2
445+    let pmtDecimalsA = $t01297513052._3
446+    let $t01305713174 = getAssetInfo(pmtAssetIdB)
447+    let pmtStrAssetIdB = $t01305713174._1
448+    let pmtAssetNameB = $t01305713174._2
449+    let pmtDecimalsB = $t01305713174._3
450+    let $t01317913683 = if ((ratioShareTokensInB > ratioShareTokensInA))
423451         then {
424452             let pmt = fraction(balanceB, ratioShareTokensInA, scale8, CEILING)
425453             $Tuple5(i.payments[0].amount, pmt, (i.payments[1].amount - pmt), pmtAssetIdB, ratioShareTokensInA)
426454             }
427455         else {
428456             let pmt = fraction(balanceA, ratioShareTokensInB, scale8, CEILING)
429457             $Tuple5(pmt, i.payments[1].amount, (i.payments[0].amount - pmt), pmtAssetIdA, ratioShareTokensInB)
430458             }
431-    let pmtAmountA = $t01251713021._1
432-    let pmtAmountB = $t01251713021._2
433-    let change = $t01251713021._3
434-    let changeAssetId = $t01251713021._4
435-    let shareTokenRatio = $t01251713021._5
459+    let pmtAmountA = $t01317913683._1
460+    let pmtAmountB = $t01317913683._2
461+    let change = $t01317913683._3
462+    let changeAssetId = $t01317913683._4
463+    let shareTokenRatio = $t01317913683._5
436464     let shareTokenToPayAmount = fraction(shareTokenRatio, shareAssetSupply, scale8)
437465     if (if ((size(i.payments) != 2))
438466         then (size(i.payments) != 3)
439467         else false)
440468         then throw("Two or three payments expected")
441469         else if (if ((pmtAssetIdA != assetIdA))
442470             then true
443471             else (pmtAssetIdB != assetIdB))
444472             then throwAssets()
445473             else if ((shareTokenToPayAmount == 0))
446474                 then throw("Too small amount to replenish")
447475                 else if ((0 > change))
448476                     then throw("Change < 0")
449477                     else if (!(hasEnoughBalance))
450478                         then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
451479                         else {
452480                             let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
453481                                 then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
454482                                 else 0
455483                             if ((stake1 == stake1))
456484                                 then {
457485                                     let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
458486                                         then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
459487                                         else 0
460488                                     if ((stake2 == stake2))
461489                                         then {
462490                                             let scriptActions = [IntegerEntry(kBalanceA, (balanceA + pmtAmountA)), IntegerEntry(kBalanceB, (balanceB + pmtAmountB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(kInvariant, invariantCalc((balanceA + pmtAmountA), (balanceB + pmtAmountB))), ScriptTransfer(i.caller, change, changeAssetId)]
463491                                             if (stakeFarming)
464492                                                 then {
465493                                                     let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmount)] ++ (if ((size(i.payments) == 3))
466494                                                         then [AttachedPayment(if ((i.payments[2].assetId == base58''))
467495                                                             then unit
468496                                                             else i.payments[2].assetId, i.payments[2].amount)]
469497                                                         else nil))
470498                                                     let re = invoke(this, "reissueShare", [shareTokenToPayAmount], nil)
471499                                                     if ((re == re))
472500                                                         then {
473501                                                             let s = invoke(farmingAddress, "lockShareTokensFromPool", [i.caller.bytes, toString(this), lockType], stPayments)
474502                                                             if ((s == s))
475503                                                                 then scriptActions
476504                                                                 else throw("Strict value is not equal to itself.")
477505                                                             }
478506                                                         else throw("Strict value is not equal to itself.")
479507                                                     }
480508                                                 else (scriptActions ++ [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId)])
481509                                             }
482510                                         else throw("Strict value is not equal to itself.")
483511                                     }
484512                                 else throw("Strict value is not equal to itself.")
485513                             }
486514     }
487515 
488516 
489517 func replenishWithOneTokenCalc (i,virtualSwapTokenPay,virtualSwapTokenGet,stakeFarming,lockType) = {
490-    let $t01541115486 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
491-    let pmtAmount = $t01541115486._1
492-    let pmtAssetId = $t01541115486._2
493-    let $t01549115564 = getAssetInfo(pmtAssetId)
494-    let pmtStrAssetId = $t01549115564._1
495-    let pmtAssetName = $t01549115564._2
496-    let pmtDecimals = $t01549115564._3
518+    let $t01607316148 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
519+    let pmtAmount = $t01607316148._1
520+    let pmtAssetId = $t01607316148._2
521+    let $t01615316226 = getAssetInfo(pmtAssetId)
522+    let pmtStrAssetId = $t01615316226._1
523+    let pmtAssetName = $t01615316226._2
524+    let pmtDecimals = $t01615316226._3
497525     let pmtMinThreshold = 5000000
498526     let thresholdValueForMinTolerance = 50000000
499527     let tolerance = if ((thresholdValueForMinTolerance > pmtAmount))
500528         then 100000
501529         else 1
502530     let slippageValueMinForReplenish = (scale8 - ((scale8 * tolerance) / 10000000))
503531     let slippageValueMaxForReplenish = (scale8 + ((scale8 * tolerance) / 10000000))
504532     let slippageValueMinForSwap = (scale8 - ((scale8 * 1) / 10000000))
505533     if ((pmtMinThreshold > pmtAmount))
506534         then throw((((("Payment amount " + toString(pmtAmount)) + " does not exceed the minimum amount of ") + toString(pmtMinThreshold)) + " tokens"))
507535         else if (if ((size(i.payments) != 1))
508536             then (size(i.payments) != 2)
509537             else false)
510538             then throw("One or two payments expected")
511539             else if (!(hasEnoughBalance))
512540                 then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
513541                 else if (if ((pmtAssetId != assetIdA))
514542                     then (pmtAssetId != assetIdB)
515543                     else false)
516544                     then throwAssets()
517545                     else {
518-                        let $t01657117213 = if ((pmtAssetId == assetIdA))
546+                        let $t01722817870 = if ((pmtAssetId == assetIdA))
519547                             then $Tuple6((pmtAmount - virtualSwapTokenPay), virtualSwapTokenGet, (balanceA + virtualSwapTokenPay), (balanceB - virtualSwapTokenGet), (balanceA + pmtAmount), balanceB)
520548                             else $Tuple6(virtualSwapTokenGet, (pmtAmount - virtualSwapTokenPay), (balanceA - virtualSwapTokenGet), (balanceB + virtualSwapTokenPay), balanceA, (balanceB + pmtAmount))
521-                        let virtualReplenishA = $t01657117213._1
522-                        let virtualReplenishB = $t01657117213._2
523-                        let balanceAfterSwapA = $t01657117213._3
524-                        let balanceAfterSwapB = $t01657117213._4
525-                        let newBalanceA = $t01657117213._5
526-                        let newBalanceB = $t01657117213._6
549+                        let virtualReplenishA = $t01722817870._1
550+                        let virtualReplenishB = $t01722817870._2
551+                        let balanceAfterSwapA = $t01722817870._3
552+                        let balanceAfterSwapB = $t01722817870._4
553+                        let newBalanceA = $t01722817870._5
554+                        let newBalanceB = $t01722817870._6
527555                         let invariantNew = invariantCalc(balanceAfterSwapA, balanceAfterSwapB)
528556                         let ratioVirtualBalanceToVirtualReplenish = (fraction(scale16, balanceAfterSwapA, balanceAfterSwapB) / fraction(scale8, virtualReplenishA, virtualReplenishB))
529-                        let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))
530557                         if (if ((slippageValueMinForSwap >= fraction(scale8, invariant, invariantNew)))
531558                             then true
532559                             else (invariant > invariantNew))
533560                             then throw("Incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
534561                             else if (if ((slippageValueMinForReplenish > ratioVirtualBalanceToVirtualReplenish))
535562                                 then true
536563                                 else (ratioVirtualBalanceToVirtualReplenish > slippageValueMaxForReplenish))
537564                                 then throw("Swap with virtualSwapTokenPay and virtualSwapTokenGet is possible, but ratio after virtual swap is incorrect")
538-                                else if (if ((dAppThresholdAmount > newBalanceA))
539-                                    then true
540-                                    else (dAppThresholdAmount > newBalanceB))
541-                                    then throwThreshold(dAppThresholdAmount, newBalanceA, newBalanceB)
565+                                else if (!(checkDAppThreshold(newBalanceA, newBalanceB, pmtAssetId)))
566+                                    then throw()
542567                                     else {
543568                                         let ratioShareTokensInA = fraction(virtualReplenishA, scale8, balanceAfterSwapA)
544569                                         let ratioShareTokensInB = fraction(virtualReplenishB, scale8, balanceAfterSwapB)
545570                                         let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scale8)
546571                                         let shareTokenToPayAmountAfterFee = fraction(shareTokenToPayAmount, (feeScale6 - (fee / 2)), feeScale6)
547572                                         let shareTokenGovernanceReward = fraction(shareTokenToPayAmount, (feeGovernance / 2), feeScale6)
548573                                         let governanceRewardTokenA = fraction(shareTokenGovernanceReward, balanceA, shareAssetSupply)
549574                                         let governanceRewardTokenB = fraction(shareTokenGovernanceReward, balanceB, shareAssetSupply)
550-                                        let $t01920319498 = if ((pmtStrAssetId == strAssetIdA))
575+                                        let $t01962119904 = if ((pmtStrAssetId == strAssetIdA))
551576                                             then $Tuple3((pmtAmount - governanceRewardTokenA), governanceRewardTokenB, strAssetIdB)
552577                                             else $Tuple3((pmtAmount - governanceRewardTokenB), governanceRewardTokenA, strAssetIdA)
553-                                        let stakeAmount = $t01920319498._1
554-                                        let unstakeAmount = $t01920319498._2
555-                                        let unstakeAsset = $t01920319498._3
578+                                        let stakeAmount = $t01962119904._1
579+                                        let unstakeAmount = $t01962119904._2
580+                                        let unstakeAsset = $t01962119904._3
556581                                         let stake1 = if (contains(stakingAssets, pmtStrAssetId))
557582                                             then invoke(this, "stakeUnstake", [true, stakeAmount, pmtStrAssetId], nil)
558583                                             else 0
559584                                         if ((stake1 == stake1))
560585                                             then {
561586                                                 let stake2 = if (contains(stakingAssets, unstakeAsset))
562587                                                     then invoke(this, "stakeUnstake", [false, unstakeAmount, unstakeAsset], nil)
563588                                                     else 0
564589                                                 if ((stake2 == stake2))
565590                                                     then {
566591                                                         let scriptActions = [IntegerEntry(kBalanceA, (newBalanceA - governanceRewardTokenA)), IntegerEntry(kBalanceB, (newBalanceB - governanceRewardTokenB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmountAfterFee)), IntegerEntry(kInvariant, invariantCalc((newBalanceA - governanceRewardTokenA), (newBalanceB - governanceRewardTokenB))), ScriptTransfer(moneyBoxAddress, governanceRewardTokenA, assetIdA), ScriptTransfer(moneyBoxAddress, governanceRewardTokenB, assetIdB)]
567592                                                         if (stakeFarming)
568593                                                             then {
569594                                                                 let stPayments = ([AttachedPayment(shareAssetId, shareTokenToPayAmountAfterFee)] ++ (if ((size(i.payments) == 2))
570595                                                                     then [AttachedPayment(if ((i.payments[1].assetId == base58''))
571596                                                                         then unit
572597                                                                         else i.payments[1].assetId, i.payments[1].amount)]
573598                                                                     else nil))
574599                                                                 let re = invoke(this, "reissueShare", [shareTokenToPayAmountAfterFee], nil)
575600                                                                 if ((re == re))
576601                                                                     then {
577602                                                                         let s = invoke(farmingAddress, "lockShareTokensFromPool", [i.caller.bytes, toString(this), lockType], stPayments)
578603                                                                         if ((s == s))
579604                                                                             then scriptActions
580605                                                                             else throw("Strict value is not equal to itself.")
581606                                                                         }
582607                                                                     else throw("Strict value is not equal to itself.")
583608                                                                 }
584609                                                             else (scriptActions ++ [Reissue(shareAssetId, shareTokenToPayAmountAfterFee, true), ScriptTransfer(i.caller, shareTokenToPayAmountAfterFee, shareAssetId)])
585610                                                         }
586611                                                     else throw("Strict value is not equal to itself.")
587612                                                 }
588613                                             else throw("Strict value is not equal to itself.")
589614                                         }
590615                         }
591616     }
592617 
593618 
594619 func withdrawCalc (i,unlockAmount) = {
595-    let $t02148521820 = if ((size(i.payments) == 1))
620+    let $t02175322088 = if ((size(i.payments) == 1))
596621         then if ((i.payments[0].assetId != shareAssetId))
597622             then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
598623             else $Tuple2(i.payments[0].amount, i.payments[0].assetId)
599624         else $Tuple2(0, shareAssetId)
600-    let pmtAmount = $t02148521820._1
601-    let pmtAssetId = $t02148521820._2
625+    let pmtAmount = $t02175322088._1
626+    let pmtAssetId = $t02175322088._2
602627     if (!(hasEnoughBalance))
603628         then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
604629         else {
605630             let unlock = if ((unlockAmount > 0))
606631                 then invoke(farmingAddress, "withdrawShareTokensFromPool", [i.caller.bytes, toString(this), unlockAmount], nil)
607632                 else 0
608633             if ((unlock == unlock))
609634                 then {
610635                     let withdrawAmount = (pmtAmount + unlockAmount)
611636                     let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
612637                     let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
613638                     let invariantCalculated = invariantCalc((balanceA - amountToPayA), (balanceB - amountToPayB))
614639                     let stake1 = if (contains(stakingAssets, strAssetIdA))
615640                         then invoke(this, "stakeUnstake", [false, amountToPayA, strAssetIdA], nil)
616641                         else 0
617642                     if ((stake1 == stake1))
618643                         then {
619644                             let stake2 = if (contains(stakingAssets, strAssetIdB))
620645                                 then invoke(this, "stakeUnstake", [false, amountToPayB, strAssetIdB], nil)
621646                                 else 0
622647                             if ((stake2 == stake2))
623648                                 then [IntegerEntry(kBalanceA, (balanceA - amountToPayA)), IntegerEntry(kBalanceB, (balanceB - amountToPayB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), IntegerEntry(kInvariant, invariantCalculated), Burn(shareAssetId, withdrawAmount), ScriptTransfer(i.caller, amountToPayA, assetIdA), ScriptTransfer(i.caller, amountToPayB, assetIdB)]
624649                                 else throw("Strict value is not equal to itself.")
625650                             }
626651                         else throw("Strict value is not equal to itself.")
627652                     }
628653                 else throw("Strict value is not equal to itself.")
629654             }
630655     }
631656 
632657 
633658 @Callable(i)
634659 func init (firstHarvest) = {
635-    let $t02337223449 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
636-    let pmtAmountA = $t02337223449._1
637-    let pmtAssetIdA = $t02337223449._2
638-    let $t02345423531 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
639-    let pmtAmountB = $t02345423531._1
640-    let pmtAssetIdB = $t02345423531._2
641-    let $t02353623613 = getAssetInfo(pmtAssetIdA)
642-    let pmtStrAssetIdA = $t02353623613._1
643-    let pmtAssetNameA = $t02353623613._2
644-    let pmtDecimalsA = $t02353623613._3
645-    let $t02361823695 = getAssetInfo(pmtAssetIdB)
646-    let pmtStrAssetIdB = $t02361823695._1
647-    let pmtAssetNameB = $t02361823695._2
648-    let pmtDecimalsB = $t02361823695._3
660+    let $t02364023717 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
661+    let pmtAmountA = $t02364023717._1
662+    let pmtAssetIdA = $t02364023717._2
663+    let $t02372223799 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
664+    let pmtAmountB = $t02372223799._1
665+    let pmtAssetIdB = $t02372223799._2
666+    let $t02380423881 = getAssetInfo(pmtAssetIdA)
667+    let pmtStrAssetIdA = $t02380423881._1
668+    let pmtAssetNameA = $t02380423881._2
669+    let pmtDecimalsA = $t02380423881._3
670+    let $t02388623963 = getAssetInfo(pmtAssetIdB)
671+    let pmtStrAssetIdB = $t02388623963._1
672+    let pmtAssetNameB = $t02388623963._2
673+    let pmtDecimalsB = $t02388623963._3
649674     if (isDefined(getBoolean(this, kActive)))
650675         then throwIsActive()
651676         else if ((pmtAssetIdA == pmtAssetIdB))
652677             then throw("Assets must be different")
653678             else {
654679                 let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
655680                 let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
656681                 let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
657682                 let shareInitialSupply = fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN), pow(10, 0, shareDecimals, 0, 0, DOWN))
658683                 let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
659684                 let shareIssueId = calculateAssetId(shareIssue)
660685                 let invariantCalculated = invariantCalc(pmtAmountA, pmtAmountB)
661686                 let stake1 = if (contains(stakingAssets, pmtStrAssetIdA))
662687                     then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
663688                     else 0
664689                 if ((stake1 == stake1))
665690                     then {
666691                         let stake2 = if (contains(stakingAssets, pmtStrAssetIdB))
667692                             then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
668693                             else 0
669694                         if ((stake2 == stake2))
670695                             then {
671-                                let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kInvariant, invariantCalculated), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_flat")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
696+                                let baseEntry = [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kInvariant, invariantCalculated), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_flat")), IntegerEntry(kDAppThreshold, 3), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
672697                                 if (firstHarvest)
673698                                     then (baseEntry ++ [BooleanEntry(kFirstHarvest, firstHarvest), IntegerEntry(kFirstHarvestHeight, (startHeight + (firstHarvestEndPeriod * periodLength)))])
674699                                     else baseEntry
675700                                 }
676701                             else throw("Strict value is not equal to itself.")
677702                         }
678703                     else throw("Strict value is not equal to itself.")
679704                 }
680705     }
681706 
682707 
683708 
684709 @Callable(i)
685-func replenishWithTwoTokensV2 (stakeFarming,lockType) = valueOrElse(isActive(), replenishWithTwoTokensCalc(i, stakeFarming, lockType))
710+func replenishWithTwoTokensV2 (stakeFarming,lockType) = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithTwoTokensCalc(i, stakeFarming, lockType)))
686711 
687712 
688713 
689714 @Callable(i)
690-func replenishWithOneTokenV2 (virtualSwapTokenPay,virtualSwapTokenGet,stakeFarming,lockType) = valueOrElse(isActive(), replenishWithOneTokenCalc(i, virtualSwapTokenPay, virtualSwapTokenGet, stakeFarming, lockType))
715+func replenishWithOneTokenV2 (virtualSwapTokenPay,virtualSwapTokenGet,stakeFarming,lockType) = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithOneTokenCalc(i, virtualSwapTokenPay, virtualSwapTokenGet, stakeFarming, lockType)))
691716 
692717 
693718 
694719 @Callable(i)
695720 func withdrawV2 (unlockAmount) = valueOrElse(isActive(), withdrawCalc(i, unlockAmount))
696721 
697722 
698723 
699724 @Callable(i)
700-func withdrawOneToken (unlockAmount,withdrawAsset,estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), {
701-    let $t02706527400 = if ((size(i.payments) == 1))
725+func withdrawOneToken (unlockAmount,withdrawAsset,estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), valueOrElse(isDepricated(), {
726+    let $t02752527884 = if ((size(i.payments) == 1))
702727         then if ((i.payments[0].assetId != shareAssetId))
703728             then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
704729             else $Tuple2(i.payments[0].amount, i.payments[0].assetId)
705730         else $Tuple2(0, shareAssetId)
706-    let pmtAmount = $t02706527400._1
707-    let pmtAssetId = $t02706527400._2
731+    let pmtAmount = $t02752527884._1
732+    let pmtAssetId = $t02752527884._2
708733     let withdrawAmount = (pmtAmount + unlockAmount)
709734     if (if ((withdrawAsset != strAssetIdA))
710735         then (withdrawAsset != strAssetIdB)
711736         else false)
712737         then throw("Incorrect withdraw asset")
713738         else if ((0 >= withdrawAmount))
714739             then throw("withdraw amount must be grater than 0")
715740             else if (!(hasEnoughBalance))
716741                 then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
717742                 else {
718743                     let unlock = if ((unlockAmount > 0))
719744                         then invoke(farmingAddress, "withdrawShareTokensFromPool", [i.caller.bytes, toString(this), unlockAmount], nil)
720745                         else 0
721746                     if ((unlock == unlock))
722747                         then {
723748                             let amountToPayA = fraction(withdrawAmount, balanceA, shareAssetSupply)
724749                             let amountToPayB = fraction(withdrawAmount, balanceB, shareAssetSupply)
725750                             let newVirtBalcA = (balanceA - amountToPayA)
726751                             let newVirtBalcB = (balanceB - amountToPayB)
727752                             let feeDiscount = calculateFeeDiscount(i.originCaller)
728753                             let amountExchangedWithFee = if ((withdrawAsset == strAssetIdA))
729754                                 then calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, amountToPayB, assetIdB, newVirtBalcA, newVirtBalcB, invariantCalc(newVirtBalcA, newVirtBalcB))
730755                                 else calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, amountToPayA, assetIdA, newVirtBalcA, newVirtBalcB, invariantCalc(newVirtBalcA, newVirtBalcB))
731756                             let govReward = fraction(amountExchangedWithFee, fraction(feeGovernance, feeDiscount, feeScale6, CEILING), feeScale6)
732757                             let amountExchanged = fraction(amountExchangedWithFee, (feeScale6 - fraction(fee, feeDiscount, feeScale6, CEILING)), feeScale6)
733-                            let $t02900329332 = if ((withdrawAsset == strAssetIdA))
734-                                then $Tuple3((amountToPayA + amountExchanged), (((balanceA - amountToPayA) - amountExchanged) - govReward), balanceB)
735-                                else $Tuple3((amountToPayB + amountExchanged), balanceA, (((balanceB - amountToPayB) - amountExchanged) - govReward))
736-                            let amountToPay = $t02900329332._1
737-                            let balanceANew = $t02900329332._2
738-                            let balanceBNew = $t02900329332._3
739-                            let invariantCalculated = invariantCalc(balanceANew, balanceBNew)
740-                            let stake1 = if (contains(stakingAssets, withdrawAsset))
741-                                then invoke(this, "stakeUnstake", [false, (amountToPay + govReward), withdrawAsset], nil)
742-                                else 0
743-                            if ((stake1 == stake1))
744-                                then [IntegerEntry(kBalanceA, balanceANew), IntegerEntry(kBalanceB, balanceBNew), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), IntegerEntry(kInvariant, invariantCalculated), Burn(shareAssetId, withdrawAmount), ScriptTransfer(i.caller, amountToPay, fromBase58String(withdrawAsset)), ScriptTransfer(moneyBoxAddress, govReward, fromBase58String(withdrawAsset))]
745-                                else throw("Strict value is not equal to itself.")
758+                            let $t02957529949 = if ((withdrawAsset == strAssetIdA))
759+                                then $Tuple4((amountToPayA + amountExchanged), (((balanceA - amountToPayA) - amountExchanged) - govReward), balanceB, assetIdB)
760+                                else $Tuple4((amountToPayB + amountExchanged), balanceA, (((balanceB - amountToPayB) - amountExchanged) - govReward), assetIdA)
761+                            let amountToPay = $t02957529949._1
762+                            let balanceANew = $t02957529949._2
763+                            let balanceBNew = $t02957529949._3
764+                            let virtAssetId = $t02957529949._4
765+                            if (!(checkDAppThreshold(balanceANew, balanceBNew, virtAssetId)))
766+                                then throw()
767+                                else {
768+                                    let invariantCalculated = invariantCalc(balanceANew, balanceBNew)
769+                                    let stake1 = if (contains(stakingAssets, withdrawAsset))
770+                                        then invoke(this, "stakeUnstake", [false, (amountToPay + govReward), withdrawAsset], nil)
771+                                        else 0
772+                                    if ((stake1 == stake1))
773+                                        then [IntegerEntry(kBalanceA, balanceANew), IntegerEntry(kBalanceB, balanceBNew), IntegerEntry(kShareAssetSupply, (shareAssetSupply - withdrawAmount)), IntegerEntry(kInvariant, invariantCalculated), Burn(shareAssetId, withdrawAmount), ScriptTransfer(i.caller, amountToPay, fromBase58String(withdrawAsset)), ScriptTransfer(moneyBoxAddress, govReward, fromBase58String(withdrawAsset))]
774+                                        else throw("Strict value is not equal to itself.")
775+                                    }
746776                             }
747777                         else throw("Strict value is not equal to itself.")
748778                     }
749-    })
779+    }))
750780 
751781 
752782 
753783 @Callable(i)
754-func exchange (estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), {
755-    let $t03020530280 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
756-    let pmtAmount = $t03020530280._1
757-    let pmtAssetId = $t03020530280._2
784+func exchange (estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), valueOrElse(isDepricated(), {
785+    let $t03101931094 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
786+    let pmtAmount = $t03101931094._1
787+    let pmtAssetId = $t03101931094._2
758788     if ((0 >= estimatedAmountToReceive))
759789         then throw(("Estimated amount must be positive. Actual: " + toString(estimatedAmountToReceive)))
760790         else if ((minAmountToReceive > estimatedAmountToReceive))
761791             then throw("Minimal amount can't be greater than estimated.")
762792             else if ((size(i.payments) != 1))
763793                 then throwOnePayment()
764794                 else if (!(hasEnoughBalance))
765795                     then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
766796                     else if (if ((pmtAssetId != assetIdA))
767797                         then (pmtAssetId != assetIdB)
768798                         else false)
769799                         then throwAssets()
770800                         else if ((10000000 > pmtAmount))
771801                             then throw("Only swap of 10.000000 or more tokens is allowed")
772802                             else if (if ((exchangeRatioLimitMin > fraction(scale8, minAmountToReceive, pmtAmount)))
773803                                 then true
774804                                 else (fraction(scale8, estimatedAmountToReceive, pmtAmount) > exchangeRatioLimitMax))
775805                                 then throw("Incorrect args and pmt ratio")
776806                                 else {
777807                                     let sendAssetId = if ((pmtAssetId == assetIdA))
778808                                         then assetIdB
779809                                         else assetIdA
780810                                     let amount = calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, pmtAmount, pmtAssetId, balanceA, balanceB, invariant)
781811                                     let feeDiscount = calculateFeeDiscount(i.originCaller)
782812                                     let governanceReward = fraction(amount, fraction(feeGovernance, feeDiscount, feeScale6, CEILING), feeScale6)
783813                                     let amountMinusFee = fraction(amount, (feeScale6 - fraction(fee, feeDiscount, feeScale6, CEILING)), feeScale6)
784-                                    let $t03176432026 = if ((pmtAssetId == assetIdA))
814+                                    let $t03269032968 = if ((pmtAssetId == assetIdA))
785815                                         then $Tuple2((balanceA + pmtAmount), ((balanceB - amountMinusFee) - governanceReward))
786816                                         else $Tuple2(((balanceA - amountMinusFee) - governanceReward), (balanceB + pmtAmount))
787-                                    let newBalanceA = $t03176432026._1
788-                                    let newBalanceB = $t03176432026._2
789-                                    let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))
790-                                    if (if ((dAppThresholdAmount > newBalanceA))
791-                                        then true
792-                                        else (dAppThresholdAmount > newBalanceB))
793-                                        then throwThreshold(dAppThresholdAmount, newBalanceA, newBalanceB)
817+                                    let newBalanceA = $t03269032968._1
818+                                    let newBalanceB = $t03269032968._2
819+                                    if (!(checkDAppThreshold(newBalanceA, newBalanceB, pmtAssetId)))
820+                                        then throw()
794821                                         else {
795-                                            let $t03232532398 = getAssetInfo(pmtAssetId)
796-                                            let pmtStrAssetId = $t03232532398._1
797-                                            let pmtAssetName = $t03232532398._2
798-                                            let pmtDecimals = $t03232532398._3
799-                                            let $t03241132488 = getAssetInfo(sendAssetId)
800-                                            let sendStrAssetId = $t03241132488._1
801-                                            let sendAssetName = $t03241132488._2
802-                                            let sendDecimals = $t03241132488._3
822+                                            let $t03307433147 = getAssetInfo(pmtAssetId)
823+                                            let pmtStrAssetId = $t03307433147._1
824+                                            let pmtAssetName = $t03307433147._2
825+                                            let pmtDecimals = $t03307433147._3
826+                                            let $t03316033237 = getAssetInfo(sendAssetId)
827+                                            let sendStrAssetId = $t03316033237._1
828+                                            let sendAssetName = $t03316033237._2
829+                                            let sendDecimals = $t03316033237._3
803830                                             let stake1 = if (contains(stakingAssets, pmtStrAssetId))
804831                                                 then invoke(this, "stakeUnstake", [true, pmtAmount, pmtStrAssetId], nil)
805832                                                 else 0
806833                                             if ((stake1 == stake1))
807834                                                 then {
808835                                                     let stake2 = if (contains(stakingAssets, sendStrAssetId))
809836                                                         then invoke(this, "stakeUnstake", [false, (amountMinusFee + governanceReward), sendStrAssetId], nil)
810837                                                         else 0
811838                                                     if ((stake2 == stake2))
812839                                                         then $Tuple2([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), IntegerEntry(kInvariant, invariantCalc(newBalanceA, newBalanceB)), ScriptTransfer(i.caller, amountMinusFee, sendAssetId), ScriptTransfer(moneyBoxAddress, governanceReward, sendAssetId)], [amountMinusFee, sendAssetId])
813840                                                         else throw("Strict value is not equal to itself.")
814841                                                     }
815842                                                 else throw("Strict value is not equal to itself.")
816843                                             }
817844                                     }
818-    })
845+    }))
819846 
820847 
821848 
822849 @Callable(msg)
823850 func reissueShare (amount) = valueOrElse(isSelfCall(msg), [Reissue(shareAssetId, amount, true)])
824851 
825852 
826853 
827854 @Callable(i)
828855 func shutdown () = valueOrElse(isAdminCall(i), if (!(active))
829856     then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, kCause), "the cause wasn't specified")))
830857     else suspend("Paused by admin"))
831858 
832859 
833860 
834861 @Callable(i)
835862 func activate () = valueOrElse(isAdminCall(i), if (active)
836863     then throwIsActive()
837864     else [BooleanEntry(kActive, true), DeleteEntry(kCause)])
838865 
839866 
840867 
841868 @Callable(i)
842869 func takeIntoAccountExtraFunds () = valueOrElse(isActive(), {
843870     let claim = if (if ((assetIdA == USDN))
844871         then true
845872         else (assetIdB == USDN))
846873         then invoke(stakingUSDNAddress, "claimRewards", nil, nil)
847874         else 0
848875     if ((claim == claim))
849876         then {
850877             let amountEnrollA = (accountBalanceWithStakedA - balanceA)
851878             let amountEnrollB = (accountBalanceWithStakedB - balanceB)
852879             let invariantNew = invariantCalc((balanceA + amountEnrollA), (balanceB + amountEnrollB))
853880             if ((i.caller != moneyBoxAddress))
854881                 then throw("Only the money box can call this function")
855882                 else if (if ((0 > amountEnrollA))
856883                     then true
857884                     else (0 > amountEnrollB))
858885                     then suspend("Enroll amount negative")
859886                     else if (if ((amountEnrollA == 0))
860887                         then (amountEnrollB == 0)
861888                         else false)
862889                         then throw("No money to take")
863890                         else {
864891                             let stake1 = if (if (contains(stakingAssets, strAssetIdA))
865892                                 then (amountEnrollA > 0)
866893                                 else false)
867894                                 then invoke(this, "stakeUnstake", [true, amountEnrollA, strAssetIdA], nil)
868895                                 else 0
869896                             if ((stake1 == stake1))
870897                                 then {
871898                                     let stake2 = if (if (contains(stakingAssets, strAssetIdB))
872899                                         then (amountEnrollB > 0)
873900                                         else false)
874901                                         then invoke(this, "stakeUnstake", [true, amountEnrollB, strAssetIdB], nil)
875902                                         else 0
876903                                     if ((stake2 == stake2))
877904                                         then [IntegerEntry(kInvariant, invariantNew), IntegerEntry(kBalanceA, (balanceA + amountEnrollA)), IntegerEntry(kBalanceB, (balanceB + amountEnrollB))]
878905                                         else throw("Strict value is not equal to itself.")
879906                                     }
880907                                 else throw("Strict value is not equal to itself.")
881908                             }
882909             }
883910         else throw("Strict value is not equal to itself.")
884911     })
885912 
886913 
887914 
888915 @Callable(i)
889916 func keepLimitForFirstHarvest (shareLimit) = valueOrElse(isActive(), valueOrElse(isAdminCall(i), [IntegerEntry(kShareLimit, shareLimit)]))
890917 
891918 
892919 
893920 @Callable(i)
894921 func stakeUnstake (stake,amount,assetIdString) = if ((i.caller != this))
895922     then throw("Only contract itself can invoke this function")
896923     else {
897-        let $t03593236035 = calcStakingParams(stake, amount, fromBase58String(assetIdString))
898-        let call = $t03593236035._1
899-        let addr = $t03593236035._2
900-        let params = $t03593236035._3
901-        let payments = $t03593236035._4
924+        let $t03688936992 = calcStakingParams(stake, amount, fromBase58String(assetIdString))
925+        let call = $t03688936992._1
926+        let addr = $t03688936992._2
927+        let params = $t03688936992._3
928+        let payments = $t03688936992._4
902929         let inv = invoke(addr, call, params, payments)
903930         if ((inv == inv))
904931             then nil
905932             else throw("Strict value is not equal to itself.")
906933         }
907934 
908935 
909936 
910937 @Callable(i)
911-func replenishWithTwoTokens () = valueOrElse(isActive(), replenishWithTwoTokensCalc(i, false, 0))
938+func replenishWithTwoTokens () = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithTwoTokensCalc(i, false, 0)))
912939 
913940 
914941 
915942 @Callable(i)
916-func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet) = valueOrElse(isActive(), replenishWithOneTokenCalc(i, virtualSwapTokenPay, virtualSwapTokenGet, false, 0))
943+func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet) = valueOrElse(isActive(), valueOrElse(isDepricated(), replenishWithOneTokenCalc(i, virtualSwapTokenPay, virtualSwapTokenGet, false, 0)))
917944 
918945 
919946 
920947 @Callable(i)
921948 func withdraw () = valueOrElse(isActive(), withdrawCalc(i, 0))
922949 
923950 
924951 @Verifier(tx)
925952 func verify () = {
926953     let multiSignedByAdmins = {
927954         let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
928955             then 1
929956             else 0
930957         let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
931958             then 1
932959             else 0
933960         let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
934961             then 1
935962             else 0
936963         (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
937964         }
938965     match tx {
939966         case inv: InvokeScriptTransaction => 
940967             let callTakeIntoAccount = if ((inv.dApp == this))
941968                 then (inv.function == "takeIntoAccountExtraFunds")
942969                 else false
943970             let signedByAdmin = if (if (if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
944971                 then true
945972                 else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey2))
946973                 then true
947974                 else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey3))
948975                 then true
949976                 else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKeyInvoke)
950977             if (if (callTakeIntoAccount)
951978                 then signedByAdmin
952979                 else false)
953980                 then true
954981                 else multiSignedByAdmins
955982         case _ => 
956983             multiSignedByAdmins
957984     }
958985     }
959986 
github/deemru/w8io/169f3d6 
136.71 ms ◑