tx · BXnZWnefUkZFWdf3f6ZhHWoxxa4NqYT3KhDHCRWygfMG

3MpDRYpprtgrhmggSZNTVd17xrKfJQaHz2a:  -0.01400000 Waves

2020.12.09 00:11 [1300208] smart account 3MpDRYpprtgrhmggSZNTVd17xrKfJQaHz2a > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BXnZWnefUkZFWdf3f6ZhHWoxxa4NqYT3KhDHCRWygfMG",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1607461912936,
    "version": 1,
    "sender": "3MpDRYpprtgrhmggSZNTVd17xrKfJQaHz2a",
    "senderPublicKey": "szVzqyNFXM2dNmGfvSJhUMoT99WTZMCYLwdoY1VxaLm",
    "proofs": [
        "3iWYCPvYnCNHiAak5VY5doCxZfGs9ZfKeKmqfvhbcXuTFxZPCVLVwVw7TGCvw3F4tuwaeN4TLE9tXmPXs3RcsXwM"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1300208,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 4 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let version = "2.0.0"
5+
6+let keyVersion = "version"
7+
8+let keyActive = "active"
9+
10+let keyAssetIdA = "A_asset_id"
11+
12+let keyAssetIdB = "B_asset_id"
13+
14+let keyBalanceA = "A_asset_balance"
15+
16+let keyBalanceB = "B_asset_balance"
17+
18+let keyShareAssetId = "share_asset_id"
19+
20+let keyShareAssetSupply = "share_asset_supply"
21+
22+let keyCommission = "commission"
23+
24+let keyCommissionScaleDelimiter = "commission_scale_delimiter"
25+
26+let keyCommissionGovernance = "commission_governance"
27+
28+let keyInvariant = "invariant"
29+
30+let keyCause = "shutdown_cause"
31+
32+let adminPubKey1 = base58'7FhFLst7Htn4uYxGH7xYMTAmbydLVoiZef3eFghi7CG4'
33+
34+let adminPubKey2 = base58'7FhFLst7Htn4uYxGH7xYMTAmbydLVoiZef3eFghi7CG4'
35+
36+let adminPubKey3 = base58'7FhFLst7Htn4uYxGH7xYMTAmbydLVoiZef3eFghi7CG4'
37+
38+let adminPubKeyStartStop = base58'7FhFLst7Htn4uYxGH7xYMTAmbydLVoiZef3eFghi7CG4'
39+
40+let adminPubKeyStaking = base58'7FhFLst7Htn4uYxGH7xYMTAmbydLVoiZef3eFghi7CG4'
41+
42+let governanceAddress = Address(base58'3MTobDiK1kQpEw4XpwKvTYWXVoAH5wUZxBE')
43+
44+let stakingAddress = Address(base58'3MTobDiK1kQpEw4XpwKvTYWXVoAH5wUZxBE')
45+
46+let USDN = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
47+
48+let stakingFeeInUSDN = (9 * value(value(assetInfo(USDN)).minSponsoredFee))
49+
50+let isActive = getBooleanValue(this, keyActive)
51+
52+let strAssetIdA = getStringValue(this, keyAssetIdA)
53+
54+let strAssetIdB = getStringValue(this, keyAssetIdB)
55+
56+let assetIdA = if ((strAssetIdA == "WAVES"))
57+    then unit
58+    else fromBase58String(strAssetIdA)
59+
60+let assetIdB = if ((strAssetIdB == "WAVES"))
61+    then unit
62+    else fromBase58String(strAssetIdB)
63+
64+let assetNameA = match assetIdA {
65+    case id: ByteVector => 
66+        value(assetInfo(id)).name
67+    case waves: Unit => 
68+        "WAVES"
69+    case _ => 
70+        throw("Match error")
71+}
72+
73+let assetNameB = match assetIdB {
74+    case id: ByteVector => 
75+        value(assetInfo(id)).name
76+    case waves: Unit => 
77+        "WAVES"
78+    case _ => 
79+        throw("Match error")
80+}
81+
82+let balanceA = getIntegerValue(this, keyBalanceA)
83+
84+let balanceB = getIntegerValue(this, keyBalanceB)
85+
86+let shareAssetId = fromBase58String(getStringValue(this, keyShareAssetId))
87+
88+let shareAssetSupply = getIntegerValue(this, keyShareAssetSupply)
89+
90+let invariant = getIntegerValue(this, keyInvariant)
91+
92+let commission = 500
93+
94+let commissionGovernance = 200
95+
96+let commissionScaleDelimiter = 1000000
97+
98+let scaleValue3 = 1000
99+
100+let scaleValue8 = 100000000
101+
102+let scaleValue12 = 1000000000000
103+
104+let slippageToleranceDelimiter = 1000
105+
106+let scaleValue8Digits = 8
107+
108+let scaleValue12Digits = 12
109+
110+let dAppThreshold = 50
111+
112+let dAppThresholdDelimiter = 100
113+
114+let ratioThresholdMax = 100000000
115+
116+let ratioThresholdMin = 99999000
117+
118+let alpha = 50
119+
120+let alphaDigits = 2
121+
122+let beta = 46000000
123+
124+let betaDigits = 8
125+
126+func accountBalance (assetId) = match assetId {
127+    case id: ByteVector => 
128+        assetBalance(this, id)
129+    case waves: Unit => 
130+        wavesBalance(this).available
131+    case _ => 
132+        throw("Match error")
133+}
134+
135+
136+let stakedAmountUSDN = match getInteger(stakingAddress, ((("rpd_balance_" + toBase58String(USDN)) + "_") + toString(this))) {
137+    case staked: Int => 
138+        staked
139+    case nothing: Unit => 
140+        0
141+    case _ => 
142+        throw("Match error")
143+}
144+
145+let availableBalanceA = (balanceA - (if ((assetIdA == USDN))
146+    then stakedAmountUSDN
147+    else 0))
148+
149+let availableBalanceB = (balanceB - (if ((assetIdB == USDN))
150+    then stakedAmountUSDN
151+    else 0))
152+
153+let accountBalanceWithStakedA = (accountBalance(assetIdA) + (if ((assetIdA == USDN))
154+    then stakedAmountUSDN
155+    else 0))
156+
157+let accountBalanceWithStakedB = (accountBalance(assetIdB) + (if ((assetIdB == USDN))
158+    then stakedAmountUSDN
159+    else 0))
160+
161+let hasEnoughBalance = if ((accountBalanceWithStakedA >= balanceA))
162+    then (accountBalanceWithStakedB >= balanceB)
163+    else false
164+
165+func skewness (x,y) = (((fraction(scaleValue12, x, y) + fraction(scaleValue12, y, x)) / 2) / 10000)
166+
167+
168+func invariantCalc (x,y) = {
169+    let sk = skewness(x, y)
170+    (fraction((x + y), scaleValue8, pow(sk, scaleValue8Digits, alpha, alphaDigits, scaleValue8Digits, UP)) + (2 * fraction(pow(fraction(x, y, scaleValue8), 0, 5, 1, (scaleValue8Digits / 2), DOWN), pow((sk - beta), scaleValue8Digits, alpha, alphaDigits, scaleValue8Digits, DOWN), scaleValue8)))
171+    }
172+
173+
174+func calculateHowManySendTokenA (amountToSendEstimated,minTokenReceiveAmount,amountTokenA,amountTokenB,tokenReceiveAmount) = {
175+    let slippageValue = (scaleValue8 - ((scaleValue8 * 1) / 10000000))
176+    let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
177+    let amountToSendStep1 = (amountToSendEstimated - ((1 * deltaBetweenMaxAndMinSendValue) / 5))
178+    let amountToSendStep2 = (amountToSendEstimated - ((2 * deltaBetweenMaxAndMinSendValue) / 5))
179+    let amountToSendStep3 = (amountToSendEstimated - ((3 * deltaBetweenMaxAndMinSendValue) / 5))
180+    let amountToSendStep4 = (amountToSendEstimated - ((4 * deltaBetweenMaxAndMinSendValue) / 5))
181+    let amountToSendStep5 = (amountToSendEstimated - ((5 * deltaBetweenMaxAndMinSendValue) / 5))
182+    let y = (amountTokenB + tokenReceiveAmount)
183+    let invariantNew = invariantCalc((amountTokenA - amountToSendEstimated), y)
184+    let invariantEstimatedRatio = fraction(invariant, scaleValue8, invariantNew)
185+    if ((0 >= (invariantCalc((amountTokenA - amountToSendStep5), y) - invariant)))
186+        then throw("minTokenReceiveAmount too large.err1")
187+        else if (if ((invariantEstimatedRatio > slippageValue))
188+            then ((invariantNew - invariant) > 0)
189+            else false)
190+            then amountToSendEstimated
191+            else if (((invariantCalc((amountTokenA - amountToSendStep1), y) - invariant) > 0))
192+                then ((amountToSendStep1 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
193+                else if (((invariantCalc((amountTokenA - amountToSendStep2), y) - invariant) > 0))
194+                    then ((amountToSendStep2 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
195+                    else if (((invariantCalc((amountTokenA - amountToSendStep3), y) - invariant) > 0))
196+                        then ((amountToSendStep3 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
197+                        else if (((invariantCalc((amountTokenA - amountToSendStep4), y) - invariant) > 0))
198+                            then ((amountToSendStep4 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
199+                            else if (((invariantCalc((amountTokenA - amountToSendStep5), y) - invariant) > 0))
200+                                then ((amountToSendStep5 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
201+                                else throw("something went wrong while working with amountToSendStep. err2")
202+    }
203+
204+
205+func calculateHowManySendTokenB (amountToSendEstimated,minTokenReceiveAmount,amountTokenA,amountTokenB,tokenReceiveAmount) = {
206+    let slippageValue = (scaleValue8 - ((scaleValue8 * 1) / 10000000))
207+    let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
208+    let amountToSendStep1 = (amountToSendEstimated - ((1 * deltaBetweenMaxAndMinSendValue) / 5))
209+    let amountToSendStep2 = (amountToSendEstimated - ((2 * deltaBetweenMaxAndMinSendValue) / 5))
210+    let amountToSendStep3 = (amountToSendEstimated - ((3 * deltaBetweenMaxAndMinSendValue) / 5))
211+    let amountToSendStep4 = (amountToSendEstimated - ((4 * deltaBetweenMaxAndMinSendValue) / 5))
212+    let amountToSendStep5 = (amountToSendEstimated - ((5 * deltaBetweenMaxAndMinSendValue) / 5))
213+    let x = (amountTokenA + tokenReceiveAmount)
214+    let invariantNew = invariantCalc(x, (amountTokenB - amountToSendEstimated))
215+    let invariantEstimatedRatio = fraction(invariant, scaleValue8, invariantNew)
216+    if ((0 >= (invariantCalc(x, (amountTokenB - amountToSendStep5)) - invariant)))
217+        then throw("minTokenReceiveAmount too large.err1")
218+        else if (if ((invariantEstimatedRatio > slippageValue))
219+            then ((invariantNew - invariant) > 0)
220+            else false)
221+            then amountToSendEstimated
222+            else if (((invariantCalc(x, (amountTokenB - amountToSendStep1)) - invariant) > 0))
223+                then ((amountToSendStep1 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
224+                else if (((invariantCalc(x, (amountTokenB - amountToSendStep2)) - invariant) > 0))
225+                    then ((amountToSendStep2 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
226+                    else if (((invariantCalc(x, (amountTokenB - amountToSendStep3)) - invariant) > 0))
227+                        then ((amountToSendStep3 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
228+                        else if (((invariantCalc(x, (amountTokenB - amountToSendStep4)) - invariant) > 0))
229+                            then ((amountToSendStep4 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
230+                            else if (((invariantCalc(x, (amountTokenB - amountToSendStep5)) - invariant) > 0))
231+                                then ((amountToSendStep5 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
232+                                else throw("something went wrong while working with amountToSendStep. err2")
233+    }
234+
235+
236+func getAssetInfo (assetId) = match assetId {
237+    case id: ByteVector => 
238+        let stringId = toBase58String(id)
239+        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
240+        $Tuple3(stringId, info.name, info.decimals)
241+    case waves: Unit => 
242+        $Tuple3("WAVES", "WAVES", 8)
243+    case _ => 
244+        throw("Match error")
245+}
246+
247+
248+func suspend (cause) = [BooleanEntry(keyActive, false), StringEntry(keyCause, cause)]
249+
250+
251+func deductStakingFee (amount,assetId) = if ((assetId == USDN))
252+    then {
253+        let result = (amount - stakingFeeInUSDN)
254+        if ((0 >= result))
255+            then throw((((("Insufficient amount " + toString(amount)) + " to deduct staking fee ") + toString(stakingFeeInUSDN)) + " USD-N"))
256+            else result
257+        }
258+    else amount
259+
260+
261+func throwIsActive () = throw("DApp is already active")
262+
263+
264+func throwIsInactive () = throw("DApp is inactive at this moment")
265+
266+
267+func throwOnlyAdmin () = throw("Only admin can call this function")
268+
269+
270+func throwAssets () = throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
271+
272+
273+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))
274+
275+
276+func throwInsufficientAvailableBalance (amount,available,assetName) = throw((((((((("Insufficient DApp balance to pay " + toString(amount)) + " ") + assetName) + " due to staking. Available: ") + toString(available)) + " ") + assetName) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
277+
278+
279+func throwInsufficientAvailableBalances (amountA,amountB) = throw((((((((((((((((("Insufficient DApp balance to pay " + toString(amountA)) + " ") + assetNameA) + " and ") + toString(amountB)) + " ") + assetNameB) + " due to staking. Available: ") + toString(availableBalanceA)) + " ") + assetNameA) + " and ") + toString(availableBalanceB)) + " ") + assetNameB) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
280+
281+
282+func suspendSuspicious () = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB) + ". State: ") + toString(accountBalance(assetIdA))) + " ") + assetNameA) + ", ") + toString(accountBalance(assetIdB))) + " ") + assetNameB))
283+
284+
285+@Callable(i)
286+func init () = {
287+    let $t01164811725 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
288+    let pmtAmountA = $t01164811725._1
289+    let pmtAssetIdA = $t01164811725._2
290+    let $t01173011807 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
291+    let pmtAmountB = $t01173011807._1
292+    let pmtAssetIdB = $t01173011807._2
293+    let $t01181211889 = getAssetInfo(pmtAssetIdA)
294+    let pmtStrAssetIdA = $t01181211889._1
295+    let pmtAssetNameA = $t01181211889._2
296+    let pmtDecimalsA = $t01181211889._3
297+    let $t01189411971 = getAssetInfo(pmtAssetIdB)
298+    let pmtStrAssetIdB = $t01189411971._1
299+    let pmtAssetNameB = $t01189411971._2
300+    let pmtDecimalsB = $t01189411971._3
301+    if (isDefined(getBoolean(this, keyActive)))
302+        then throwIsActive()
303+        else if ((pmtAssetIdA == pmtAssetIdB))
304+            then throw("Assets must be different")
305+            else {
306+                let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
307+                let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
308+                let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
309+                let shareInitialSupply = fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, HALFDOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, HALFDOWN), pow(10, 0, shareDecimals, 0, 0, HALFDOWN))
310+                let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
311+                let shareIssueId = calculateAssetId(shareIssue)
312+                let invariantCalculated = invariantCalc(pmtAmountA, pmtAmountB)
313+[StringEntry(keyVersion, version), BooleanEntry(keyActive, true), StringEntry(keyAssetIdA, pmtStrAssetIdA), StringEntry(keyAssetIdB, pmtStrAssetIdB), IntegerEntry(keyBalanceA, pmtAmountA), IntegerEntry(keyBalanceB, pmtAmountB), IntegerEntry(keyInvariant, invariantCalculated), IntegerEntry(keyCommission, commission), IntegerEntry(keyCommissionScaleDelimiter, commissionScaleDelimiter), shareIssue, StringEntry(keyShareAssetId, toBase58String(shareIssueId)), IntegerEntry(keyShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
314+                }
315+    }
316+
317+
318+
319+@Callable(i)
320+func replenishWithTwoTokens (slippageTolerance) = {
321+    let pmtAssetIdA = i.payments[0].assetId
322+    let pmtAssetIdB = i.payments[1].assetId
323+    let pmtAmountA = deductStakingFee(i.payments[0].amount, pmtAssetIdA)
324+    let pmtAmountB = deductStakingFee(i.payments[1].amount, pmtAssetIdB)
325+    let tokenRatio = fraction(fraction(balanceA, scaleValue8, pmtAmountA), scaleValue3, fraction(balanceB, scaleValue8, pmtAmountB))
326+    let ratioShareTokensInA = fraction(pmtAmountA, scaleValue8, balanceA)
327+    let ratioShareTokensInB = fraction(pmtAmountB, scaleValue8, balanceB)
328+    let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scaleValue8)
329+    let invariantCalculated = invariantCalc((balanceA + pmtAmountA), (balanceB + pmtAmountB))
330+    if (!(isActive))
331+        then throwIsInactive()
332+        else if (if ((0 > slippageTolerance))
333+            then true
334+            else (slippageTolerance > slippageToleranceDelimiter))
335+            then throw(((("Slippage tolerance must be between 0 and " + toString(slippageToleranceDelimiter)) + " inclusively. Actual: ") + toString(slippageTolerance)))
336+            else if ((size(i.payments) != 2))
337+                then throw("Two attached assets expected")
338+                else if (if ((pmtAssetIdA != assetIdA))
339+                    then true
340+                    else (pmtAssetIdB != assetIdB))
341+                    then throwAssets()
342+                    else if (if ((((scaleValue3 * (slippageToleranceDelimiter - slippageTolerance)) / slippageToleranceDelimiter) > tokenRatio))
343+                        then true
344+                        else (tokenRatio > ((scaleValue3 * (slippageToleranceDelimiter + slippageTolerance)) / slippageToleranceDelimiter)))
345+                        then throw("Incorrect assets amount: amounts must have the contract ratio")
346+                        else if ((shareTokenToPayAmount == 0))
347+                            then throw("Too small amount to replenish")
348+                            else if (!(hasEnoughBalance))
349+                                then suspendSuspicious()
350+                                else [IntegerEntry(keyBalanceA, (balanceA + pmtAmountA)), IntegerEntry(keyBalanceB, (balanceB + pmtAmountB)), IntegerEntry(keyShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(keyInvariant, invariantCalculated), Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId)]
351+    }
352+
353+
354+
355+@Callable(i)
356+func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet) = {
357+    let $t01649816573 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
358+    let pmtAmount = $t01649816573._1
359+    let pmtAssetId = $t01649816573._2
360+    let pmtMinThreshold = 5000000
361+    let thresholdValueForMinTolerance = 50000000
362+    let tolerance = if ((thresholdValueForMinTolerance > pmtAmount))
363+        then 100000
364+        else 1
365+    let slippageValueMinForReplenish = (scaleValue8 - ((scaleValue8 * tolerance) / 10000000))
366+    let slippageValueMaxForReplenish = (scaleValue8 + ((scaleValue8 * tolerance) / 10000000))
367+    let slippageValueMinForSwap = (scaleValue8 - ((scaleValue8 * 1) / 10000000))
368+    let slippageValueMaxForSwap = (scaleValue8 + ((scaleValue8 * 1) / 10000000))
369+    if (!(isActive))
370+        then throwIsInactive()
371+        else if ((pmtMinThreshold > pmtAmount))
372+            then throw((((("Payment amount " + toString(pmtAmount)) + " does not exceed the minimum amount of ") + toString(pmtMinThreshold)) + " tokens"))
373+            else if ((size(i.payments) != 1))
374+                then throw("One attached payment expected")
375+                else if (!(hasEnoughBalance))
376+                    then suspendSuspicious()
377+                    else if ((pmtAssetId == assetIdA))
378+                        then {
379+                            let amountVirtualReplenishTokenA = (pmtAmount - virtualSwapTokenPay)
380+                            let amountVirtualReplenishTokenB = virtualSwapTokenGet
381+                            let balanceAfterVirtualSwapA = (balanceA + virtualSwapTokenPay)
382+                            let balanceAfterVirtualSwapB = (balanceB - virtualSwapTokenGet)
383+                            let invariantNew = invariantCalc(balanceAfterVirtualSwapA, balanceAfterVirtualSwapB)
384+                            let invariantEstimatedRatio = fraction(invariant, scaleValue8, invariantNew)
385+                            if (if ((invariantEstimatedRatio > slippageValueMinForSwap))
386+                                then ((invariantNew - invariant) >= 0)
387+                                else false)
388+                                then {
389+                                    let ratioVirtualBalanceToVirtualReplenish = (fraction(balanceAfterVirtualSwapA, (scaleValue8 * scaleValue8), balanceAfterVirtualSwapB) / fraction(amountVirtualReplenishTokenA, scaleValue8, amountVirtualReplenishTokenB))
390+                                    if (if ((slippageValueMinForReplenish > ratioVirtualBalanceToVirtualReplenish))
391+                                        then true
392+                                        else (ratioVirtualBalanceToVirtualReplenish > slippageValueMaxForReplenish))
393+                                        then throw("swop with virtualSwapTokenPay and virtualSwapTokenGet possible, but ratio after virtual swap incorrect")
394+                                        else {
395+                                            let ratioShareTokensInA = fraction((amountVirtualReplenishTokenA - 270000), scaleValue8, balanceAfterVirtualSwapA)
396+                                            let ratioShareTokensInB = fraction(deductStakingFee(amountVirtualReplenishTokenB, assetIdB), scaleValue8, balanceAfterVirtualSwapB)
397+                                            if (true)
398+                                                then throw(((toString(ratioShareTokensInA) + " ") + toString(ratioShareTokensInB)))
399+                                                else {
400+                                                    let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scaleValue8)
401+                                                    let shareTokenToPayAmountToDelete = fraction(max([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scaleValue8)
402+                                                    if (true)
403+                                                        then throw(((((((toString(shareTokenToPayAmount) + " ") + toString(shareTokenToPayAmountToDelete)) + "") + toString(amountVirtualReplenishTokenA)) + " ") + toString(amountVirtualReplenishTokenB)))
404+                                                        else {
405+                                                            let invariantCalculated = invariantCalc((balanceA + pmtAmount), balanceB)
406+                                                            let newAmountTokenA = (balanceA + pmtAmount)
407+                                                            let newAmountTokenB = balanceB
408+                                                            let dAppThresholdAmount = fraction((newAmountTokenA + newAmountTokenB), dAppThreshold, (2 * dAppThresholdDelimiter))
409+                                                            if (if ((dAppThresholdAmount > newAmountTokenA))
410+                                                                then true
411+                                                                else (dAppThresholdAmount > newAmountTokenB))
412+                                                                then throwThreshold(dAppThresholdAmount, newAmountTokenA, newAmountTokenB)
413+                                                                else [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId), IntegerEntry(keyShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyInvariant, invariantCalculated)]
414+                                                            }
415+                                                    }
416+                                            }
417+                                    }
418+                                else throw("incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
419+                            }
420+                        else if ((pmtAssetId == assetIdB))
421+                            then {
422+                                let amountVirtualReplenishTokenB = (pmtAmount - virtualSwapTokenPay)
423+                                let amountVirtualReplenishTokenA = virtualSwapTokenGet
424+                                let balanceAfterVirtualSwapA = (balanceA - virtualSwapTokenGet)
425+                                let balanceAfterVirtualSwapB = (balanceB + virtualSwapTokenPay)
426+                                let invariantNew = invariantCalc(balanceAfterVirtualSwapA, balanceAfterVirtualSwapB)
427+                                let invariantEstimatedRatio = fraction(invariant, scaleValue8, invariantNew)
428+                                if (if ((invariantEstimatedRatio > slippageValueMinForSwap))
429+                                    then ((invariantNew - invariant) >= 0)
430+                                    else false)
431+                                    then {
432+                                        let ratioVirtualBalanceToVirtualReplenish = (fraction(balanceAfterVirtualSwapA, (scaleValue8 * scaleValue8), balanceAfterVirtualSwapB) / fraction(amountVirtualReplenishTokenA, scaleValue8, amountVirtualReplenishTokenB))
433+                                        if (if ((slippageValueMinForReplenish > ratioVirtualBalanceToVirtualReplenish))
434+                                            then true
435+                                            else (ratioVirtualBalanceToVirtualReplenish > slippageValueMaxForReplenish))
436+                                            then throw("swop with virtualSwapTokenPay and virtualSwapTokenGet possible, but ratio after virtual swap incorrect")
437+                                            else {
438+                                                let ratioShareTokensInA = fraction(deductStakingFee(amountVirtualReplenishTokenA, assetIdA), scaleValue8, balanceAfterVirtualSwapA)
439+                                                let ratioShareTokensInB = fraction(deductStakingFee(amountVirtualReplenishTokenB, assetIdB), scaleValue8, balanceAfterVirtualSwapB)
440+                                                let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scaleValue8)
441+                                                let invariantCalculated = invariantCalc(balanceA, (balanceB + pmtAmount))
442+                                                let newAmountTokenA = balanceA
443+                                                let newAmountTokenB = (balanceB + pmtAmount)
444+                                                let dAppThresholdAmount = fraction((newAmountTokenA + newAmountTokenB), dAppThreshold, (2 * dAppThresholdDelimiter))
445+                                                if (if ((dAppThresholdAmount > newAmountTokenA))
446+                                                    then true
447+                                                    else (dAppThresholdAmount > newAmountTokenB))
448+                                                    then throwThreshold(dAppThresholdAmount, newAmountTokenA, newAmountTokenB)
449+                                                    else [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId), IntegerEntry(keyShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(keyBalanceB, newAmountTokenB), IntegerEntry(keyInvariant, invariantCalculated)]
450+                                                }
451+                                        }
452+                                    else throw("incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
453+                                }
454+                            else throwAssets()
455+    }
456+
457+
458+
459+@Callable(i)
460+func exchange (estimatedAmountToReceive,minAmountToReceive) = {
461+    let $t02365123726 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
462+    let pmtAmount = $t02365123726._1
463+    let pmtAssetId = $t02365123726._2
464+    if (!(isActive))
465+        then throwIsInactive()
466+        else if ((0 >= estimatedAmountToReceive))
467+            then throw(("Estimated amount must be positive. Actual: " + toString(estimatedAmountToReceive)))
468+            else if ((minAmountToReceive > estimatedAmountToReceive))
469+                then throw(((("Minimal amount can't be greater than estimated. Estimated: " + toString(estimatedAmountToReceive)) + ". Minimal: ") + toString(minAmountToReceive)))
470+                else if ((size(i.payments) != 1))
471+                    then throw("One attached payment expected")
472+                    else if (!(hasEnoughBalance))
473+                        then suspendSuspicious()
474+                        else if ((pmtAssetId == assetIdA))
475+                            then {
476+                                let assetIdSend = assetIdB
477+                                let amountWithoutFee = calculateHowManySendTokenB(estimatedAmountToReceive, minAmountToReceive, balanceA, balanceB, pmtAmount)
478+                                let amountWithFee = fraction(amountWithoutFee, (commissionScaleDelimiter - commission), commissionScaleDelimiter)
479+                                let governanceReward = fraction(amountWithoutFee, commissionGovernance, commissionScaleDelimiter)
480+                                let newAmountTokenA = (balanceA + pmtAmount)
481+                                let newAmountTokenB = ((balanceB - amountWithFee) - governanceReward)
482+                                let dAppThresholdAmount = fraction((newAmountTokenA + newAmountTokenB), dAppThreshold, (2 * dAppThresholdDelimiter))
483+                                if (if ((dAppThresholdAmount > newAmountTokenA))
484+                                    then true
485+                                    else (dAppThresholdAmount > newAmountTokenB))
486+                                    then throwThreshold(dAppThresholdAmount, newAmountTokenA, newAmountTokenB)
487+                                    else if (if (if ((assetIdA == USDN))
488+                                        then (stakedAmountUSDN >= newAmountTokenA)
489+                                        else false)
490+                                        then true
491+                                        else if ((assetIdB == USDN))
492+                                            then (stakedAmountUSDN >= newAmountTokenB)
493+                                            else false)
494+                                        then throwInsufficientAvailableBalance(amountWithFee, availableBalanceB, assetNameB)
495+                                        else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), IntegerEntry(keyInvariant, invariantCalc((balanceA + pmtAmount), ((balanceB - amountWithFee) - governanceReward))), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
496+                                }
497+                            else if ((pmtAssetId == assetIdB))
498+                                then {
499+                                    let assetIdSend = assetIdA
500+                                    let amountWithoutFee = calculateHowManySendTokenA(estimatedAmountToReceive, minAmountToReceive, balanceA, balanceB, pmtAmount)
501+                                    let amountWithFee = fraction(amountWithoutFee, (commissionScaleDelimiter - commission), commissionScaleDelimiter)
502+                                    let governanceReward = fraction(amountWithoutFee, commissionGovernance, commissionScaleDelimiter)
503+                                    let newAmountTokenA = ((balanceA - amountWithFee) - governanceReward)
504+                                    let newAmountTokenB = (balanceB + pmtAmount)
505+                                    let dAppThresholdAmount = fraction((newAmountTokenA + newAmountTokenB), dAppThreshold, (2 * dAppThresholdDelimiter))
506+                                    if (if ((dAppThresholdAmount > newAmountTokenA))
507+                                        then true
508+                                        else (dAppThresholdAmount > newAmountTokenB))
509+                                        then throwThreshold(dAppThresholdAmount, newAmountTokenA, newAmountTokenB)
510+                                        else if (if (if ((assetIdA == USDN))
511+                                            then (stakedAmountUSDN >= newAmountTokenA)
512+                                            else false)
513+                                            then true
514+                                            else if ((assetIdB == USDN))
515+                                                then (stakedAmountUSDN >= newAmountTokenB)
516+                                                else false)
517+                                            then throwInsufficientAvailableBalance(amountWithFee, availableBalanceA, assetNameA)
518+                                            else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), IntegerEntry(keyInvariant, invariantCalc(((balanceA - amountWithFee) - governanceReward), (balanceB + pmtAmount))), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
519+                                    }
520+                                else throwAssets()
521+    }
522+
523+
524+
525+@Callable(i)
526+func takeIntoAccountExtraFunds (amountLeave) = {
527+    let uncountableAmountEnrollAssetA = (accountBalanceWithStakedA - balanceA)
528+    let uncountableAmountEnrollAssetB = (accountBalanceWithStakedB - balanceB)
529+    let amountEnrollA = (uncountableAmountEnrollAssetA - (if ((assetIdA == USDN))
530+        then amountLeave
531+        else 0))
532+    let amountEnrollB = (uncountableAmountEnrollAssetB - (if ((assetIdB == USDN))
533+        then amountLeave
534+        else 0))
535+    if (!(isActive))
536+        then throwIsInactive()
537+        else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStaking], i.callerPublicKey)))
538+            then throwOnlyAdmin()
539+            else if ((0 > amountLeave))
540+                then throw(("Argument 'amountLeave' cannot be negative. Actual: " + toString(amountLeave)))
541+                else if (if ((0 > uncountableAmountEnrollAssetA))
542+                    then true
543+                    else (0 > uncountableAmountEnrollAssetB))
544+                    then suspend("Enroll amount negative")
545+                    else if (if ((0 > amountEnrollA))
546+                        then true
547+                        else (0 > amountEnrollB))
548+                        then throw("Too large amountLeave")
549+                        else [IntegerEntry(keyBalanceA, (balanceA + amountEnrollA)), IntegerEntry(keyBalanceB, (balanceB + amountEnrollB))]
550+    }
551+
552+
github/deemru/w8io/026f985 
54.52 ms ◑