tx · G3Wn5xeQ4bheXBf1NE7Ci4TroLG5uS5W3Y4BjFCDo6q2

3NCz5XkCiEZAzYg9hBUhb4DNeLg1W1y6WT3:  -0.01400000 Waves

2020.11.30 13:50 [1288060] smart account 3NCz5XkCiEZAzYg9hBUhb4DNeLg1W1y6WT3 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "G3Wn5xeQ4bheXBf1NE7Ci4TroLG5uS5W3Y4BjFCDo6q2",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1606733458166,
    "version": 1,
    "sender": "3NCz5XkCiEZAzYg9hBUhb4DNeLg1W1y6WT3",
    "senderPublicKey": "Y13vgcBAg3gM6hNgNw3yBZHZUVEoj6d4tAppHgogpNx",
    "proofs": [
        "3zog8URie96GQXu27jNCRLi8kf9mo2eQuodKxcEM6RGvyUFqtN6Jd7BpiqEEMZSQc9wVQpBherz1fWN5JvatMq86"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1288060,
    "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 exchange (estimatedAmountToReceive,minAmountToReceive) = {
454+    let $t02313823213 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
455+    let pmtAmount = $t02313823213._1
456+    let pmtAssetId = $t02313823213._2
457+    if (!(isActive))
458+        then throwIsInactive()
459+        else if ((0 >= estimatedAmountToReceive))
460+            then throw(("Estimated amount must be positive. Actual: " + toString(estimatedAmountToReceive)))
461+            else if ((minAmountToReceive > estimatedAmountToReceive))
462+                then throw(((("Minimal amount can't be greater than estimated. Estimated: " + toString(estimatedAmountToReceive)) + ". Minimal: ") + toString(minAmountToReceive)))
463+                else if ((size(i.payments) != 1))
464+                    then throw("One attached payment expected")
465+                    else if (!(hasEnoughBalance))
466+                        then suspendSuspicious()
467+                        else if ((pmtAssetId == assetIdA))
468+                            then {
469+                                let assetIdSend = assetIdB
470+                                let amountWithoutFee = calculateHowManySendTokenB(estimatedAmountToReceive, minAmountToReceive, balanceA, balanceB, pmtAmount)
471+                                let amountWithFee = fraction(amountWithoutFee, (commissionScaleDelimiter - commission), commissionScaleDelimiter)
472+                                let governanceReward = fraction(amountWithoutFee, commissionGovernance, commissionScaleDelimiter)
473+                                let newAmountTokenA = (balanceA + pmtAmount)
474+                                let newAmountTokenB = ((balanceB - amountWithFee) - governanceReward)
475+                                let dAppThresholdAmount = fraction((newAmountTokenA + newAmountTokenB), dAppThreshold, (2 * dAppThresholdDelimiter))
476+                                if (if ((dAppThresholdAmount > newAmountTokenA))
477+                                    then true
478+                                    else (dAppThresholdAmount > newAmountTokenB))
479+                                    then throwThreshold(dAppThresholdAmount, newAmountTokenA, newAmountTokenB)
480+                                    else if (if (if ((assetIdA == USDN))
481+                                        then (stakedAmountUSDN >= newAmountTokenA)
482+                                        else false)
483+                                        then true
484+                                        else if ((assetIdB == USDN))
485+                                            then (stakedAmountUSDN >= newAmountTokenB)
486+                                            else false)
487+                                        then throwInsufficientAvailableBalance(amountWithFee, availableBalanceB, assetNameB)
488+                                        else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), IntegerEntry(keyInvariant, invariantCalc((balanceA + pmtAmount), ((balanceB - amountWithFee) - governanceReward))), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
489+                                }
490+                            else if ((pmtAssetId == assetIdB))
491+                                then {
492+                                    let assetIdSend = assetIdA
493+                                    let amountWithoutFee = calculateHowManySendTokenA(estimatedAmountToReceive, minAmountToReceive, balanceA, balanceB, pmtAmount)
494+                                    let amountWithFee = fraction(amountWithoutFee, (commissionScaleDelimiter - commission), commissionScaleDelimiter)
495+                                    let governanceReward = fraction(amountWithoutFee, commissionGovernance, commissionScaleDelimiter)
496+                                    let newAmountTokenA = ((balanceA - amountWithFee) - governanceReward)
497+                                    let newAmountTokenB = (balanceB + pmtAmount)
498+                                    let dAppThresholdAmount = fraction((newAmountTokenA + newAmountTokenB), dAppThreshold, (2 * dAppThresholdDelimiter))
499+                                    if (if ((dAppThresholdAmount > newAmountTokenA))
500+                                        then true
501+                                        else (dAppThresholdAmount > newAmountTokenB))
502+                                        then throwThreshold(dAppThresholdAmount, newAmountTokenA, newAmountTokenB)
503+                                        else if (if (if ((assetIdA == USDN))
504+                                            then (stakedAmountUSDN >= newAmountTokenA)
505+                                            else false)
506+                                            then true
507+                                            else if ((assetIdB == USDN))
508+                                                then (stakedAmountUSDN >= newAmountTokenB)
509+                                                else false)
510+                                            then throwInsufficientAvailableBalance(amountWithFee, availableBalanceA, assetNameA)
511+                                            else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), IntegerEntry(keyInvariant, invariantCalc(((balanceA - amountWithFee) - governanceReward), (balanceB + pmtAmount))), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
512+                                    }
513+                                else throwAssets()
514+    }
515+
516+
517+
518+@Callable(i)
519+func takeIntoAccountExtraFunds (amountLeave) = {
520+    let uncountableAmountEnrollAssetA = (accountBalanceWithStakedA - balanceA)
521+    let uncountableAmountEnrollAssetB = (accountBalanceWithStakedB - balanceB)
522+    let amountEnrollA = (uncountableAmountEnrollAssetA - (if ((assetIdA == USDN))
523+        then amountLeave
524+        else 0))
525+    let amountEnrollB = (uncountableAmountEnrollAssetB - (if ((assetIdB == USDN))
526+        then amountLeave
527+        else 0))
528+    if (!(isActive))
529+        then throwIsInactive()
530+        else if (!(containsElement([adminPubKey1, adminPubKey2, adminPubKey3, adminPubKeyStaking], i.callerPublicKey)))
531+            then throwOnlyAdmin()
532+            else if ((0 > amountLeave))
533+                then throw(("Argument 'amountLeave' cannot be negative. Actual: " + toString(amountLeave)))
534+                else if (if ((0 > uncountableAmountEnrollAssetA))
535+                    then true
536+                    else (0 > uncountableAmountEnrollAssetB))
537+                    then suspend("Enroll amount negative")
538+                    else if (if ((0 > amountEnrollA))
539+                        then true
540+                        else (0 > amountEnrollB))
541+                        then throw("Too large amountLeave")
542+                        else [IntegerEntry(keyBalanceA, (balanceA + amountEnrollA)), IntegerEntry(keyBalanceB, (balanceB + amountEnrollB))]
543+    }
544+
545+
546+@Verifier(tx)
547+func verify () = match tx {
548+    case invoke: InvokeScriptTransaction => 
549+        if (sigVerify(invoke.bodyBytes, invoke.proofs[0], adminPubKeyStaking))
550+            then (invoke.dApp == stakingAddress)
551+            else false
552+    case _ => 
553+        let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
554+            then 1
555+            else 0
556+        let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
557+            then 1
558+            else 0
559+        let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
560+            then 1
561+            else 0
562+        (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
563+}
564+
github/deemru/w8io/026f985 
35.79 ms ◑