tx · 7BvbTSqKTh5uXczr6Us6MpFp5zTXUA3NSgjr8AcrM5kK

3Mxob8GrFQULi64gzNXrbPiruLshtHARzhm:  -0.01400000 Waves

2020.11.28 15:23 [1285258] smart account 3Mxob8GrFQULi64gzNXrbPiruLshtHARzhm > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7BvbTSqKTh5uXczr6Us6MpFp5zTXUA3NSgjr8AcrM5kK",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1606566190310,
    "version": 1,
    "sender": "3Mxob8GrFQULi64gzNXrbPiruLshtHARzhm",
    "senderPublicKey": "wUMwwN2qmzSfYNyKsGG3eDYhccpG2TXQY3vjsseYH6v",
    "proofs": [
        "Mhm23veHftxGufxmeBRxxqdiWpESKr3fEeyCEA76w2QFmx75rRpdUde9u9rGSJxMV6Lvj73H8xZww8iGtfmRKEL"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1285258,
    "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 (true)
391+                                        then throw(toString(ratioVirtualBalanceToVirtualReplenish))
392+                                        else if (if ((slippageValueMinForReplenish > ratioVirtualBalanceToVirtualReplenish))
393+                                            then true
394+                                            else (ratioVirtualBalanceToVirtualReplenish > slippageValueMaxForReplenish))
395+                                            then throw("swop with virtualSwapTokenPay and virtualSwapTokenGet possible, but ratio after virtual swap incorrect")
396+                                            else {
397+                                                let ratioShareTokensInA = fraction(deductStakingFee(amountVirtualReplenishTokenA, assetIdA), scaleValue8, balanceAfterVirtualSwapA)
398+                                                let ratioShareTokensInB = fraction(deductStakingFee(amountVirtualReplenishTokenB, assetIdB), scaleValue8, balanceAfterVirtualSwapB)
399+                                                let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scaleValue8)
400+                                                let invariantCalculated = invariantCalc((balanceA + pmtAmount), balanceB)
401+                                                let newAmountTokenA = (balanceA + pmtAmount)
402+                                                let newAmountTokenB = balanceB
403+                                                let dAppThresholdAmount = fraction((newAmountTokenA + newAmountTokenB), dAppThreshold, (2 * dAppThresholdDelimiter))
404+                                                if (if ((dAppThresholdAmount > newAmountTokenA))
405+                                                    then true
406+                                                    else (dAppThresholdAmount > newAmountTokenB))
407+                                                    then throwThreshold(dAppThresholdAmount, newAmountTokenA, newAmountTokenB)
408+                                                    else [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId), IntegerEntry(keyShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyInvariant, invariantCalculated)]
409+                                                }
410+                                    }
411+                                else throw("incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
412+                            }
413+                        else if ((pmtAssetId == assetIdB))
414+                            then {
415+                                let amountVirtualReplenishTokenB = (pmtAmount - virtualSwapTokenPay)
416+                                let amountVirtualReplenishTokenA = virtualSwapTokenGet
417+                                let balanceAfterVirtualSwapA = (balanceA - virtualSwapTokenGet)
418+                                let balanceAfterVirtualSwapB = (balanceB + virtualSwapTokenPay)
419+                                let invariantNew = invariantCalc(balanceAfterVirtualSwapA, balanceAfterVirtualSwapB)
420+                                let invariantEstimatedRatio = fraction(invariant, scaleValue8, invariantNew)
421+                                if (if ((invariantEstimatedRatio > slippageValueMinForSwap))
422+                                    then ((invariantNew - invariant) >= 0)
423+                                    else false)
424+                                    then {
425+                                        let ratioVirtualBalanceToVirtualReplenish = (fraction(balanceAfterVirtualSwapA, (scaleValue8 * scaleValue8), balanceAfterVirtualSwapB) / fraction(amountVirtualReplenishTokenA, scaleValue8, amountVirtualReplenishTokenB))
426+                                        if (if ((slippageValueMinForReplenish > ratioVirtualBalanceToVirtualReplenish))
427+                                            then true
428+                                            else (ratioVirtualBalanceToVirtualReplenish > slippageValueMaxForReplenish))
429+                                            then throw("swop with virtualSwapTokenPay and virtualSwapTokenGet possible, but ratio after virtual swap incorrect")
430+                                            else {
431+                                                let ratioShareTokensInA = fraction(deductStakingFee(amountVirtualReplenishTokenA, assetIdA), scaleValue8, balanceAfterVirtualSwapA)
432+                                                let ratioShareTokensInB = fraction(deductStakingFee(amountVirtualReplenishTokenB, assetIdB), scaleValue8, balanceAfterVirtualSwapB)
433+                                                let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scaleValue8)
434+                                                let invariantCalculated = invariantCalc(balanceA, (balanceB + pmtAmount))
435+                                                let newAmountTokenA = balanceA
436+                                                let newAmountTokenB = (balanceB + pmtAmount)
437+                                                let dAppThresholdAmount = fraction((newAmountTokenA + newAmountTokenB), dAppThreshold, (2 * dAppThresholdDelimiter))
438+                                                if (if ((dAppThresholdAmount > newAmountTokenA))
439+                                                    then true
440+                                                    else (dAppThresholdAmount > newAmountTokenB))
441+                                                    then throwThreshold(dAppThresholdAmount, newAmountTokenA, newAmountTokenB)
442+                                                    else [Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId), IntegerEntry(keyShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(keyBalanceB, newAmountTokenB), IntegerEntry(keyInvariant, invariantCalculated)]
443+                                                }
444+                                        }
445+                                    else throw("incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
446+                                }
447+                            else throwAssets()
448+    }
449+
450+
451+
452+@Callable(i)
453+func withdraw () = {
454+    let $t02308323233 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
455+    let pmtAmount = $t02308323233._1
456+    let pmtAssetId = $t02308323233._2
457+    let amountToPayA = deductStakingFee(fraction(pmtAmount, balanceA, shareAssetSupply), assetIdA)
458+    let amountToPayB = deductStakingFee(fraction(pmtAmount, balanceB, shareAssetSupply), assetIdB)
459+    let invariantCalculated = invariantCalc((balanceA - amountToPayA), (balanceB - amountToPayB))
460+    if (!(isActive))
461+        then throwIsInactive()
462+        else if ((size(i.payments) != 1))
463+            then throw("One attached payment expected")
464+            else if ((pmtAssetId != shareAssetId))
465+                then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
466+                else if (!(hasEnoughBalance))
467+                    then suspendSuspicious()
468+                    else if (if ((amountToPayA > availableBalanceA))
469+                        then true
470+                        else (amountToPayB > availableBalanceB))
471+                        then throwInsufficientAvailableBalances(amountToPayA, amountToPayB)
472+                        else [IntegerEntry(keyBalanceA, (balanceA - amountToPayA)), IntegerEntry(keyBalanceB, (balanceB - amountToPayB)), IntegerEntry(keyShareAssetSupply, (shareAssetSupply - pmtAmount)), IntegerEntry(keyInvariant, invariantCalculated), Burn(shareAssetId, pmtAmount), ScriptTransfer(i.caller, amountToPayA, assetIdA), ScriptTransfer(i.caller, amountToPayB, assetIdB)]
473+    }
474+
475+
476+
477+@Callable(i)
478+func exchange (estimatedAmountToReceive,minAmountToReceive) = {
479+    let $t02452424599 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
480+    let pmtAmount = $t02452424599._1
481+    let pmtAssetId = $t02452424599._2
482+    if (!(isActive))
483+        then throwIsInactive()
484+        else if ((0 >= estimatedAmountToReceive))
485+            then throw(("Estimated amount must be positive. Actual: " + toString(estimatedAmountToReceive)))
486+            else if ((minAmountToReceive > estimatedAmountToReceive))
487+                then throw(((("Minimal amount can't be greater than estimated. Estimated: " + toString(estimatedAmountToReceive)) + ". Minimal: ") + toString(minAmountToReceive)))
488+                else if ((size(i.payments) != 1))
489+                    then throw("One attached payment expected")
490+                    else if (!(hasEnoughBalance))
491+                        then suspendSuspicious()
492+                        else if ((pmtAssetId == assetIdA))
493+                            then {
494+                                let assetIdSend = assetIdB
495+                                let amountWithoutFee = calculateHowManySendTokenB(estimatedAmountToReceive, minAmountToReceive, balanceA, balanceB, pmtAmount)
496+                                let amountWithFee = fraction(amountWithoutFee, (commissionScaleDelimiter - commission), commissionScaleDelimiter)
497+                                let governanceReward = fraction(amountWithoutFee, commissionGovernance, commissionScaleDelimiter)
498+                                let newAmountTokenA = (balanceA + pmtAmount)
499+                                let newAmountTokenB = ((balanceB - amountWithFee) - governanceReward)
500+                                let dAppThresholdAmount = fraction((newAmountTokenA + newAmountTokenB), dAppThreshold, (2 * dAppThresholdDelimiter))
501+                                if (if ((dAppThresholdAmount > newAmountTokenA))
502+                                    then true
503+                                    else (dAppThresholdAmount > newAmountTokenB))
504+                                    then throwThreshold(dAppThresholdAmount, newAmountTokenA, newAmountTokenB)
505+                                    else if (if (if ((assetIdA == USDN))
506+                                        then (stakedAmountUSDN >= newAmountTokenA)
507+                                        else false)
508+                                        then true
509+                                        else if ((assetIdB == USDN))
510+                                            then (stakedAmountUSDN >= newAmountTokenB)
511+                                            else false)
512+                                        then throwInsufficientAvailableBalance(amountWithFee, availableBalanceB, assetNameB)
513+                                        else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), IntegerEntry(keyInvariant, invariantCalc((balanceA + pmtAmount), ((balanceB - amountWithFee) - governanceReward))), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
514+                                }
515+                            else if ((pmtAssetId == assetIdB))
516+                                then {
517+                                    let assetIdSend = assetIdA
518+                                    let amountWithoutFee = calculateHowManySendTokenA(estimatedAmountToReceive, minAmountToReceive, balanceA, balanceB, pmtAmount)
519+                                    let amountWithFee = fraction(amountWithoutFee, (commissionScaleDelimiter - commission), commissionScaleDelimiter)
520+                                    let governanceReward = fraction(amountWithoutFee, commissionGovernance, commissionScaleDelimiter)
521+                                    let newAmountTokenA = ((balanceA - amountWithFee) - governanceReward)
522+                                    let newAmountTokenB = (balanceB + pmtAmount)
523+                                    let dAppThresholdAmount = fraction((newAmountTokenA + newAmountTokenB), dAppThreshold, (2 * dAppThresholdDelimiter))
524+                                    if (if ((dAppThresholdAmount > newAmountTokenA))
525+                                        then true
526+                                        else (dAppThresholdAmount > newAmountTokenB))
527+                                        then throwThreshold(dAppThresholdAmount, newAmountTokenA, newAmountTokenB)
528+                                        else if (if (if ((assetIdA == USDN))
529+                                            then (stakedAmountUSDN >= newAmountTokenA)
530+                                            else false)
531+                                            then true
532+                                            else if ((assetIdB == USDN))
533+                                                then (stakedAmountUSDN >= newAmountTokenB)
534+                                                else false)
535+                                            then throwInsufficientAvailableBalance(amountWithFee, availableBalanceA, assetNameA)
536+                                            else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), IntegerEntry(keyInvariant, invariantCalc(((balanceA - amountWithFee) - governanceReward), (balanceB + pmtAmount))), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
537+                                    }
538+                                else throwAssets()
539+    }
540+
541+
542+
543+@Callable(i)
544+func takeIntoAccountExtraFunds (amountLeave) = {
545+    let uncountableAmountEnrollAssetA = (accountBalanceWithStakedA - balanceA)
546+    let uncountableAmountEnrollAssetB = (accountBalanceWithStakedB - balanceB)
547+    let amountEnrollA = (uncountableAmountEnrollAssetA - (if ((assetIdA == USDN))
548+        then amountLeave
549+        else 0))
550+    let amountEnrollB = (uncountableAmountEnrollAssetB - (if ((assetIdB == USDN))
551+        then amountLeave
552+        else 0))
553+    if (!(isActive))
554+        then throwIsInactive()
555+        else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStaking], i.callerPublicKey)))
556+            then throwOnlyAdmin()
557+            else if ((0 > amountLeave))
558+                then throw(("Argument 'amountLeave' cannot be negative. Actual: " + toString(amountLeave)))
559+                else if (if ((0 > uncountableAmountEnrollAssetA))
560+                    then true
561+                    else (0 > uncountableAmountEnrollAssetB))
562+                    then suspend("Enroll amount negative")
563+                    else if (if ((0 > amountEnrollA))
564+                        then true
565+                        else (0 > amountEnrollB))
566+                        then throw("Too large amountLeave")
567+                        else [IntegerEntry(keyBalanceA, (balanceA + amountEnrollA)), IntegerEntry(keyBalanceB, (balanceB + amountEnrollB))]
568+    }
569+
570+
571+@Verifier(tx)
572+func verify () = match tx {
573+    case invoke: InvokeScriptTransaction => 
574+        if (sigVerify(invoke.bodyBytes, invoke.proofs[0], adminPubKeyStaking))
575+            then (invoke.dApp == stakingAddress)
576+            else false
577+    case _ => 
578+        let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
579+            then 1
580+            else 0
581+        let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
582+            then 1
583+            else 0
584+        let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
585+            then 1
586+            else 0
587+        (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
588+}
589+
github/deemru/w8io/026f985 
43.38 ms ◑