tx · 8NaR8mcuaHgMsRtuVCgNVCzix2fkiKuibdDtCjR663vy

3P4ArV98YffUFmx9RueDK4T5FgvPYRU6cNq:  -0.01400000 Waves

2020.11.05 22:13 [2316217] smart account 3P4ArV98YffUFmx9RueDK4T5FgvPYRU6cNq > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8NaR8mcuaHgMsRtuVCgNVCzix2fkiKuibdDtCjR663vy",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1604603595375,
    "version": 1,
    "sender": "3P4ArV98YffUFmx9RueDK4T5FgvPYRU6cNq",
    "senderPublicKey": "Gm4g8qNCWBoSt3pENwiEETY3EwdFYVYANak9soqJpJYR",
    "proofs": [
        "LSSwCK1SSM2gfCrcaQ4VzFVeiCqAEGMNVvs98S4hd7F3Y2dY9H2opS6r5qwErGrcuYu61PbsbEtRhqybxMTrZxJ"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 2316217,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: EMuxW1nWSzSGJe51LimDUzFLcRAo7wyzW5fG2koPrr1Q

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 adminPubKey1 = base58'3y2wvtQtxqwbSZB4R9Au17XqyGs9UgRHw5sPLAcAvQMu'
31+
32+let adminPubKey2 = base58'3y2wvtQtxqwbSZB4R9Au17XqyGs9UgRHw5sPLAcAvQMu'
33+
34+let adminPubKey3 = base58'3y2wvtQtxqwbSZB4R9Au17XqyGs9UgRHw5sPLAcAvQMu'
35+
36+let governanceAddress = Address(base58'3P5SBcTmP5zu1F9JVmNHycgC69KEer9Pza9')
37+
38+let isActive = getBooleanValue(this, keyActive)
39+
40+let strAssetIdA = getStringValue(this, keyAssetIdA)
41+
42+let strAssetIdB = getStringValue(this, keyAssetIdB)
43+
44+let assetIdA = fromBase58String(strAssetIdA)
45+
46+let assetIdB = fromBase58String(strAssetIdB)
47+
48+let balanceA = getIntegerValue(this, keyBalanceA)
49+
50+let balanceB = getIntegerValue(this, keyBalanceB)
51+
52+let shareAssetId = fromBase58String(getStringValue(this, keyShareAssetId))
53+
54+let shareAssetSupply = getIntegerValue(this, keyShareAssetSupply)
55+
56+let invariant = getIntegerValue(this, keyInvariant)
57+
58+let assetNameA = value(assetInfo(assetIdA)).name
59+
60+let assetNameB = value(assetInfo(assetIdB)).name
61+
62+let commission = 500
63+
64+let commissionGovernance = 200
65+
66+let commissionScaleDelimiter = 1000000
67+
68+let scaleValue3 = 1000
69+
70+let scaleValue8 = 100000000
71+
72+let scaleValue12 = 1000000000000
73+
74+let slippageToleranceDelimiter = 1000
75+
76+let scaleValue8Digits = 8
77+
78+let scaleValue12Digits = 12
79+
80+let dAppThreshold = 80
81+
82+let dAppThresholdDelimiter = 100
83+
84+let ratioThresholdMax = 100000000
85+
86+let ratioThresholdMin = 99999000
87+
88+let alpha = 50
89+
90+let alphaDigits = 2
91+
92+let beta = 46000000
93+
94+let betaDigits = 8
95+
96+func skewness (x,y) = (((fraction(scaleValue12, x, y) + fraction(scaleValue12, y, x)) / 2) / 10000)
97+
98+
99+func invariantCalc (x,y) = {
100+    let sk = skewness(x, y)
101+    (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)))
102+    }
103+
104+
105+func calculateHowManySendTokenA (amountToSendEstimated,minTokenReceiveAmount,amountTokenA,amountTokenB,tokenReceiveAmount) = {
106+    let slippageValue = (scaleValue8 - ((scaleValue8 * 1) / 10000000))
107+    let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
108+    let amountToSendStep1 = (amountToSendEstimated - ((1 * deltaBetweenMaxAndMinSendValue) / 5))
109+    let amountToSendStep2 = (amountToSendEstimated - ((2 * deltaBetweenMaxAndMinSendValue) / 5))
110+    let amountToSendStep3 = (amountToSendEstimated - ((3 * deltaBetweenMaxAndMinSendValue) / 5))
111+    let amountToSendStep4 = (amountToSendEstimated - ((4 * deltaBetweenMaxAndMinSendValue) / 5))
112+    let amountToSendStep5 = (amountToSendEstimated - ((5 * deltaBetweenMaxAndMinSendValue) / 5))
113+    let y = (amountTokenB + tokenReceiveAmount)
114+    let invariantEstimatedRatio = fraction(invariant, scaleValue8, invariantCalc((amountTokenA - amountToSendEstimated), y))
115+    if ((0 > (invariantCalc((amountTokenA - amountToSendStep5), y) - invariant)))
116+        then throw("minTokenReceiveAmount too large.err1")
117+        else if (if ((invariantEstimatedRatio > slippageValue))
118+            then (scaleValue8 > invariantEstimatedRatio)
119+            else false)
120+            then amountToSendEstimated
121+            else if (((invariantCalc((amountTokenA - amountToSendStep1), y) - invariant) > 0))
122+                then ((amountToSendStep1 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
123+                else if (((invariantCalc((amountTokenA - amountToSendStep2), y) - invariant) > 0))
124+                    then ((amountToSendStep2 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
125+                    else if (((invariantCalc((amountTokenA - amountToSendStep3), y) - invariant) > 0))
126+                        then ((amountToSendStep3 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
127+                        else if (((invariantCalc((amountTokenA - amountToSendStep4), y) - invariant) > 0))
128+                            then ((amountToSendStep4 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
129+                            else if (((invariantCalc((amountTokenA - amountToSendStep5), y) - invariant) > 0))
130+                                then ((amountToSendStep5 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
131+                                else throw("something went wrong while working with amountToSendStep. err2")
132+    }
133+
134+
135+func calculateHowManySendTokenB (amountToSendEstimated,minTokenReceiveAmount,amountTokenA,amountTokenB,tokenReceiveAmount) = {
136+    let slippageValue = (scaleValue8 - ((scaleValue8 * 1) / 10000000))
137+    let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
138+    let amountToSendStep1 = (amountToSendEstimated - ((1 * deltaBetweenMaxAndMinSendValue) / 5))
139+    let amountToSendStep2 = (amountToSendEstimated - ((2 * deltaBetweenMaxAndMinSendValue) / 5))
140+    let amountToSendStep3 = (amountToSendEstimated - ((3 * deltaBetweenMaxAndMinSendValue) / 5))
141+    let amountToSendStep4 = (amountToSendEstimated - ((4 * deltaBetweenMaxAndMinSendValue) / 5))
142+    let amountToSendStep5 = (amountToSendEstimated - ((5 * deltaBetweenMaxAndMinSendValue) / 5))
143+    let x = (amountTokenA + tokenReceiveAmount)
144+    let invariantEstimatedRatio = fraction(invariant, scaleValue8, invariantCalc(x, (amountTokenB - amountToSendEstimated)))
145+    if ((0 > (invariantCalc(x, (amountTokenB - amountToSendStep5)) - invariant)))
146+        then throw("minTokenReceiveAmount too large.err1")
147+        else if (if ((invariantEstimatedRatio > slippageValue))
148+            then (scaleValue8 > invariantEstimatedRatio)
149+            else false)
150+            then amountToSendEstimated
151+            else if (((invariantCalc(x, (amountTokenB - amountToSendStep1)) - invariant) > 0))
152+                then ((amountToSendStep1 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
153+                else if (((invariantCalc(x, (amountTokenB - amountToSendStep2)) - invariant) > 0))
154+                    then ((amountToSendStep2 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
155+                    else if (((invariantCalc(x, (amountTokenB - amountToSendStep3)) - invariant) > 0))
156+                        then ((amountToSendStep3 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
157+                        else if (((invariantCalc(x, (amountTokenB - amountToSendStep4)) - invariant) > 0))
158+                            then ((amountToSendStep4 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
159+                            else if (((invariantCalc(x, (amountTokenB - amountToSendStep5)) - invariant) > 0))
160+                                then ((amountToSendStep5 * (commissionScaleDelimiter - commission)) / commissionScaleDelimiter)
161+                                else throw("something went wrong while working with amountToSendStep. err2")
162+    }
163+
164+
165+func getAssetInfo (assetId) = match assetId {
166+    case id: ByteVector => 
167+        let stringId = toBase58String(id)
168+        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
169+        $Tuple3(stringId, info.name, info.decimals)
170+    case waves: Unit => 
171+        $Tuple3("WAVES", "WAVES", 8)
172+    case _ => 
173+        throw("Match error")
174+}
175+
176+
177+@Callable(i)
178+func init () = {
179+    let $t079958072 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
180+    let pmtAmountA = $t079958072._1
181+    let pmtAssetIdA = $t079958072._2
182+    let $t080778154 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
183+    let pmtAmountB = $t080778154._1
184+    let pmtAssetIdB = $t080778154._2
185+    let $t081598236 = getAssetInfo(pmtAssetIdA)
186+    let pmtStrAssetIdA = $t081598236._1
187+    let pmtAssetNameA = $t081598236._2
188+    let pmtDecimalsA = $t081598236._3
189+    let $t082418318 = getAssetInfo(pmtAssetIdB)
190+    let pmtStrAssetIdB = $t082418318._1
191+    let pmtAssetNameB = $t082418318._2
192+    let pmtDecimalsB = $t082418318._3
193+    if (isDefined(getBoolean(this, keyActive)))
194+        then throw("DApp is already active")
195+        else if ((pmtAssetIdA == pmtAssetIdB))
196+            then throw("Assets must be different")
197+            else {
198+                let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
199+                let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
200+                let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
201+                let shareInitialSupply = fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, HALFDOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, HALFDOWN), pow(10, 0, shareDecimals, 0, 0, HALFDOWN))
202+                let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
203+                let shareIssueId = calculateAssetId(shareIssue)
204+                let invariantCalculated = invariantCalc(pmtAmountA, pmtAmountB)
205+[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)]
206+                }
207+    }
208+
209+
210+
211+@Callable(i)
212+func replenishWithTwoTokens (slippageTolerance) = {
213+    let $t01042410501 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
214+    let pmtAmountA = $t01042410501._1
215+    let pmtAssetIdA = $t01042410501._2
216+    let $t01050610700 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
217+    let pmtAmountB = $t01050610700._1
218+    let pmtAssetIdB = $t01050610700._2
219+    let tokenRatio = (fraction(balanceA, (scaleValue8 * scaleValue3), pmtAmountA) / fraction(balanceB, scaleValue8, pmtAmountB))
220+    let ratioShareTokensInA = fraction(pmtAmountA, scaleValue8, balanceA)
221+    let ratioShareTokensInB = fraction(pmtAmountB, scaleValue8, balanceB)
222+    let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scaleValue8)
223+    let invariantCalculated = invariantCalc((balanceA + pmtAmountA), (balanceB + pmtAmountB))
224+    if (!(isActive))
225+        then throw("DApp is inactive at this moment")
226+        else if (if ((0 > slippageTolerance))
227+            then true
228+            else (slippageTolerance > slippageToleranceDelimiter))
229+            then throw(((("Slippage tolerance must be between 0 and " + toString(slippageToleranceDelimiter)) + " inclusively. Actual: ") + toString(slippageTolerance)))
230+            else if ((size(i.payments) != 2))
231+                then throw("Two attached assets expected")
232+                else if (if ((pmtAssetIdA != assetIdA))
233+                    then true
234+                    else (pmtAssetIdB != assetIdB))
235+                    then throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
236+                    else if (if ((((scaleValue3 * (slippageToleranceDelimiter - slippageTolerance)) / slippageToleranceDelimiter) > tokenRatio))
237+                        then true
238+                        else (tokenRatio > ((scaleValue3 * (slippageToleranceDelimiter + slippageTolerance)) / slippageToleranceDelimiter)))
239+                        then throw("Incorrect assets amount: amounts must have the contract ratio")
240+                        else if ((shareTokenToPayAmount == 0))
241+                            then throw("Too small amount to replenish")
242+                            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)]
243+    }
244+
245+
246+
247+@Callable(i)
248+func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet) = {
249+    let $t01274012815 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
250+    let pmtAmount = $t01274012815._1
251+    let pmtAssetId = $t01274012815._2
252+    let slippageValueMin = (scaleValue8 - ((scaleValue8 * 1) / 10000000))
253+    let slippageValueMax = (scaleValue8 + ((scaleValue8 * 1) / 10000000))
254+    if (!(isActive))
255+        then throw("DApp is inactive at this moment")
256+        else if ((size(i.payments) != 1))
257+            then throw("One attached payment expected")
258+            else if ((pmtAssetId == assetIdA))
259+                then {
260+                    let amountVirtualReplenishTokenA = (pmtAmount - virtualSwapTokenPay)
261+                    let amountVirtualReplenishTokenB = virtualSwapTokenGet
262+                    let balanceAfterVirtualSwapA = (balanceA + virtualSwapTokenPay)
263+                    let balanceAfterVirtualSwapB = (balanceB - virtualSwapTokenGet)
264+                    let invariantEstimatedRatio = fraction(invariant, scaleValue8, invariantCalc(balanceAfterVirtualSwapA, balanceAfterVirtualSwapB))
265+                    if (if ((invariantEstimatedRatio > slippageValueMin))
266+                        then (scaleValue8 >= invariantEstimatedRatio)
267+                        else false)
268+                        then {
269+                            let ratioVirtualBalanceToVirtualReplenish = (fraction(balanceAfterVirtualSwapA, (scaleValue8 * scaleValue8), balanceAfterVirtualSwapB) / fraction(amountVirtualReplenishTokenA, scaleValue8, amountVirtualReplenishTokenB))
270+                            if (if ((slippageValueMin > ratioVirtualBalanceToVirtualReplenish))
271+                                then true
272+                                else (ratioVirtualBalanceToVirtualReplenish > slippageValueMax))
273+                                then throw("swop with virtualSwapTokenPay and virtualSwapTokenGet possible, but ratio after virtual swap incorrect")
274+                                else {
275+                                    let ratioShareTokensInA = fraction(amountVirtualReplenishTokenA, scaleValue8, balanceAfterVirtualSwapA)
276+                                    let ratioShareTokensInB = fraction(amountVirtualReplenishTokenB, scaleValue8, balanceAfterVirtualSwapB)
277+                                    let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scaleValue8)
278+                                    let invariantCalculated = invariantCalc((balanceA + pmtAmount), balanceB)
279+[Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId), IntegerEntry(keyShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(keyBalanceA, (balanceA + pmtAmount)), IntegerEntry(keyInvariant, invariantCalculated)]
280+                                    }
281+                            }
282+                        else throw("incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
283+                    }
284+                else if ((pmtAssetId == assetIdB))
285+                    then {
286+                        let amountVirtualReplenishTokenB = (pmtAmount - virtualSwapTokenPay)
287+                        let amountVirtualReplenishTokenA = virtualSwapTokenGet
288+                        let balanceAfterVirtualSwapA = (balanceA - virtualSwapTokenGet)
289+                        let balanceAfterVirtualSwapB = (balanceB + virtualSwapTokenPay)
290+                        let invariantEstimatedRatio = fraction(invariant, scaleValue8, invariantCalc(balanceAfterVirtualSwapA, balanceAfterVirtualSwapB))
291+                        if (if ((invariantEstimatedRatio > slippageValueMin))
292+                            then (scaleValue8 >= invariantEstimatedRatio)
293+                            else false)
294+                            then {
295+                                let ratioVirtualBalanceToVirtualReplenish = (fraction(balanceAfterVirtualSwapA, (scaleValue8 * scaleValue8), balanceAfterVirtualSwapB) / fraction(amountVirtualReplenishTokenA, scaleValue8, amountVirtualReplenishTokenB))
296+                                if (if ((slippageValueMin > ratioVirtualBalanceToVirtualReplenish))
297+                                    then true
298+                                    else (ratioVirtualBalanceToVirtualReplenish > slippageValueMax))
299+                                    then throw("swop with virtualSwapTokenPay and virtualSwapTokenGet possible, but ratio after virtual swap incorrect")
300+                                    else {
301+                                        let ratioShareTokensInA = fraction(amountVirtualReplenishTokenA, scaleValue8, balanceAfterVirtualSwapA)
302+                                        let ratioShareTokensInB = fraction(amountVirtualReplenishTokenB, scaleValue8, balanceAfterVirtualSwapB)
303+                                        let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scaleValue8)
304+                                        let invariantCalculated = invariantCalc(balanceA, (balanceB + pmtAmount))
305+[Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId), IntegerEntry(keyShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(keyBalanceB, (balanceB + pmtAmount)), IntegerEntry(keyInvariant, invariantCalculated)]
306+                                        }
307+                                }
308+                            else throw("incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
309+                        }
310+                    else throw("incorrect assets in payment")
311+    }
312+
313+
314+
315+@Callable(i)
316+func withdraw () = {
317+    let $t01748617561 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
318+    let pmtAmount = $t01748617561._1
319+    let pmtAssetId = $t01748617561._2
320+    let amountToPayA = fraction(pmtAmount, balanceA, shareAssetSupply)
321+    let amountToPayB = fraction(pmtAmount, balanceB, shareAssetSupply)
322+    let invariantCalculated = invariantCalc((balanceA - amountToPayA), (balanceB - amountToPayB))
323+    if (!(isActive))
324+        then throw("DApp is inactive at this moment")
325+        else if ((size(i.payments) != 1))
326+            then throw("One attached payment expected")
327+            else if ((pmtAssetId != shareAssetId))
328+                then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
329+                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)]
330+    }
331+
332+
333+
334+@Callable(i)
335+func exchange (estimatedAmountToReceive,minAmountToReceive) = {
336+    let $t01860418679 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
337+    let pmtAmount = $t01860418679._1
338+    let pmtAssetId = $t01860418679._2
339+    if (!(isActive))
340+        then throw("DApp is inactive at this moment")
341+        else if ((0 >= estimatedAmountToReceive))
342+            then throw(("Estimated amount must be positive. Actual: " + toString(estimatedAmountToReceive)))
343+            else if ((minAmountToReceive > estimatedAmountToReceive))
344+                then throw(((("Minimal amount can't be greater than estimated. Estimated: " + toString(estimatedAmountToReceive)) + ". Minimal: ") + toString(minAmountToReceive)))
345+                else if ((size(i.payments) != 1))
346+                    then throw("One attached payment expected")
347+                    else if ((pmtAssetId == assetIdA))
348+                        then {
349+                            let assetIdSend = assetIdB
350+                            let amountWithoutFee = calculateHowManySendTokenB(estimatedAmountToReceive, minAmountToReceive, balanceA, balanceB, pmtAmount)
351+                            let amountWithFee = fraction(amountWithoutFee, (commissionScaleDelimiter - commission), commissionScaleDelimiter)
352+                            let governanceReward = fraction(amountWithoutFee, commissionGovernance, commissionScaleDelimiter)
353+                            let newAmountTokenA = (balanceA + pmtAmount)
354+                            let newAmountTokenB = ((balanceB - amountWithFee) - governanceReward)
355+                            let dAppThresholdAmount = fraction((balanceA + balanceB), dAppThreshold, (2 * dAppThresholdDelimiter))
356+                            if (if ((dAppThresholdAmount > newAmountTokenA))
357+                                then true
358+                                else (dAppThresholdAmount > newAmountTokenB))
359+                                then throw(((((((((("New balance in assets of the DApp is less than threshold " + toString(dAppThresholdAmount)) + ". ") + assetNameA) + ": ") + toString(newAmountTokenA)) + ", ") + assetNameB) + ": ") + toString(newAmountTokenB)))
360+                                else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), IntegerEntry(keyInvariant, invariantCalc((balanceA + pmtAmount), ((balanceB - amountWithFee) - governanceReward))), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
361+                            }
362+                        else if ((pmtAssetId == assetIdB))
363+                            then {
364+                                let assetIdSend = assetIdA
365+                                let amountWithoutFee = calculateHowManySendTokenA(estimatedAmountToReceive, minAmountToReceive, balanceA, balanceB, pmtAmount)
366+                                let amountWithFee = fraction(amountWithoutFee, (commissionScaleDelimiter - commission), commissionScaleDelimiter)
367+                                let governanceReward = fraction(amountWithoutFee, commissionGovernance, commissionScaleDelimiter)
368+                                let newAmountTokenA = ((balanceA - amountWithFee) - governanceReward)
369+                                let newAmountTokenB = (balanceB + pmtAmount)
370+                                let dAppThresholdAmount = fraction((balanceA + balanceB), dAppThreshold, (2 * dAppThresholdDelimiter))
371+                                if (if ((dAppThresholdAmount > newAmountTokenA))
372+                                    then true
373+                                    else (dAppThresholdAmount > newAmountTokenB))
374+                                    then throw(((((((((("New balance in assets of the DApp is less than threshold " + toString(dAppThresholdAmount)) + ". ") + assetNameA) + ": ") + toString(newAmountTokenA)) + ", ") + assetNameB) + ": ") + toString(newAmountTokenB)))
375+                                    else [IntegerEntry(keyBalanceA, newAmountTokenA), IntegerEntry(keyBalanceB, newAmountTokenB), IntegerEntry(keyInvariant, invariantCalc(((balanceA - amountWithFee) - governanceReward), (balanceB + pmtAmount))), ScriptTransfer(i.caller, amountWithFee, assetIdSend), ScriptTransfer(governanceAddress, governanceReward, assetIdSend)]
376+                                }
377+                            else throw(((("Incorrect asset attached. Expected: " + strAssetIdA) + " or ") + strAssetIdB))
378+    }
379+
380+
381+
382+@Callable(i)
383+func shutdown () = if (containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey))
384+    then [BooleanEntry(keyActive, false)]
385+    else throw("Only admin can call this function")
386+
387+
388+@Verifier(tx)
389+func verify () = {
390+    let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
391+        then 1
392+        else 0
393+    let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
394+        then 1
395+        else 0
396+    let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
397+        then 1
398+        else 0
399+    (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
400+    }
401+
github/deemru/w8io/873ac7e 
184.51 ms ◑