tx · 5jaVeT5eh5xbMdDVSHtzwKV6P1PmdYB6GLTR92kfMfkz

3NBby6fvByWpVkgRB4V5mzk95HdYne7xmmy:  -0.02800000 Waves

2022.06.07 12:05 [2085743] smart account 3NBby6fvByWpVkgRB4V5mzk95HdYne7xmmy > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "5jaVeT5eh5xbMdDVSHtzwKV6P1PmdYB6GLTR92kfMfkz",
    "fee": 2800000,
    "feeAssetId": null,
    "timestamp": 1654592748488,
    "version": 2,
    "chainId": 84,
    "sender": "3NBby6fvByWpVkgRB4V5mzk95HdYne7xmmy",
    "senderPublicKey": "66sC8L6DbVC5kfvE7gjBEdhAVAkPbUzrU7tHEu7aiFHi",
    "proofs": [
        "43Jm8HkvYJmiq2G3ygVM8Sn1tqiSkfziCrtrPyjTxzP7Rsgo5wrfi9zKLXRzqHwPBW9oyPMVwyVkUwGD2kTXsNZj"
    ],
    "script": "base64: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",
    "height": 2085743,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: GP1Zbx8xNQnWZbsE2Qu84SQE8ubDk8ENJW9jfGjV69hC

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let version = "2.0.0"
5+
6+let kVersion = "version"
7+
8+let kActive = "active"
9+
10+let kAssetIdA = "A_asset_id"
11+
12+let kAssetIdB = "B_asset_id"
13+
14+let kBalanceA = "A_asset_balance"
15+
16+let kBalanceB = "B_asset_balance"
17+
18+let kShareAssetId = "share_asset_id"
19+
20+let kShareAssetSupply = "share_asset_supply"
21+
22+let kFee = "commission"
23+
24+let kInvariant = "invariant"
25+
26+let kCause = "shutdown_cause"
27+
28+let kUSDNAddress = "staking_usdnnsbt_address"
29+
30+let kEURNAddress = "staking_eurn_address"
31+
32+let kDiscounts = "discounts"
33+
34+let kDiscountValues = "discount_values"
35+
36+let kUserSwopInGov = "_SWOP_amount"
37+
38+let kAdminPubKey1 = "admin_pub_1"
39+
40+let kAdminPubKey2 = "admin_pub_2"
41+
42+let kAdminPubKey3 = "admin_pub_3"
43+
44+let kAdminInvokePubKey = "admin_invoke_pub"
45+
46+let kMoneyBoxAddress = "money_box_address"
47+
48+let kGovAddress = "governance_address"
49+
50+let oracle = Address(base58'3NBBWfzZtZtszaXbitTKnrB2xXwv26Bn7H9')
51+
52+func getBase58FromOracle (key) = match getString(oracle, key) {
53+    case string: String => 
54+        fromBase58String(string)
55+    case nothing => 
56+        throw((key + "is empty"))
57+}
58+
59+
60+let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
61+
62+let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
63+
64+let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
65+
66+let adminPubKeyInvoke = getBase58FromOracle(kAdminInvokePubKey)
67+
68+let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
69+
70+let govAddress = Address(getBase58FromOracle(kGovAddress))
71+
72+let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
73+
74+let USDN = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
75+
76+let stakingAssets = [toBase58String(USDN)]
77+
78+let active = getBooleanValue(this, kActive)
79+
80+let strAssetIdA = getStringValue(this, kAssetIdA)
81+
82+let strAssetIdB = getStringValue(this, kAssetIdB)
83+
84+let assetIdA = if ((strAssetIdA == "WAVES"))
85+    then unit
86+    else fromBase58String(strAssetIdA)
87+
88+let assetIdB = if ((strAssetIdB == "WAVES"))
89+    then unit
90+    else fromBase58String(strAssetIdB)
91+
92+let assetNameA = match assetIdA {
93+    case id: ByteVector => 
94+        value(assetInfo(id)).name
95+    case waves: Unit => 
96+        "WAVES"
97+    case _ => 
98+        throw("Match error")
99+}
100+
101+let assetNameB = match assetIdB {
102+    case id: ByteVector => 
103+        value(assetInfo(id)).name
104+    case waves: Unit => 
105+        "WAVES"
106+    case _ => 
107+        throw("Match error")
108+}
109+
110+let balanceA = getIntegerValue(this, kBalanceA)
111+
112+let balanceB = getIntegerValue(this, kBalanceB)
113+
114+let shareAssetId = fromBase58String(getStringValue(this, kShareAssetId))
115+
116+let shareAssetSupply = getIntegerValue(this, kShareAssetSupply)
117+
118+let invariant = getIntegerValue(this, kInvariant)
119+
120+let fee = getIntegerValue(this, kFee)
121+
122+let feeGovernance = fraction(fee, 40, 100)
123+
124+let feeScale6 = 1000000
125+
126+let scale3 = 1000
127+
128+let scale8 = 100000000
129+
130+let scale16 = 10000000000000000
131+
132+let slippageScale3 = 1000
133+
134+let digits8 = 8
135+
136+let dAppThreshold = 125
137+
138+let dAppThresholdScale2 = 1000
139+
140+let exchangeRatioLimitCoef = 2500000
141+
142+let exchangeRatioLimit = 93500000
143+
144+let alpha = 50
145+
146+let alphaDigits = 2
147+
148+let beta = 4600000000000000
149+
150+func accountBalance (assetId) = match assetId {
151+    case id: ByteVector => 
152+        assetBalance(this, id)
153+    case waves: Unit => 
154+        wavesBalance(this).available
155+    case _ => 
156+        throw("Match error")
157+}
158+
159+
160+func stakedAmount (assetId) = {
161+    let stakedAmountCalculated =     match assetId {
162+        case aId: ByteVector => 
163+            if ((aId == USDN))
164+                then getInteger(stakingUSDNAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(this)))
165+                else 0
166+        case _: Unit => 
167+            0
168+        case _ => 
169+            throw("Match error")
170+    }
171+    match stakedAmountCalculated {
172+        case i: Int => 
173+            i
174+        case _ => 
175+            0
176+    }
177+    }
178+
179+
180+let stakedAmountA = stakedAmount(assetIdA)
181+
182+let stakedAmountB = stakedAmount(assetIdB)
183+
184+let availableBalanceA = (balanceA - stakedAmountA)
185+
186+let availableBalanceB = (balanceB - stakedAmountB)
187+
188+let accountBalanceWithStakedA = (accountBalance(assetIdA) + stakedAmountA)
189+
190+let accountBalanceWithStakedB = (accountBalance(assetIdB) + stakedAmountB)
191+
192+let hasEnoughBalance = if ((accountBalanceWithStakedA >= balanceA))
193+    then (accountBalanceWithStakedB >= balanceB)
194+    else false
195+
196+func skewness (x,y) = ((fraction(scale16, x, y) + fraction(scale16, y, x)) / 2)
197+
198+
199+func invariantCalc (x,y) = {
200+    let sk = skewness(x, y)
201+    (fraction((x + y), scale16, pow(sk, digits8, alpha, alphaDigits, digits8, CEILING)) + (2 * fraction(toInt(pow(fraction(toBigInt(x), toBigInt(y), toBigInt(scale8)), 0, toBigInt(5), 1, (digits8 / 2), DOWN)), pow((sk - beta), digits8, alpha, alphaDigits, digits8, DOWN), scale8)))
202+    }
203+
204+
205+func calculateSendAmount (amountToSendEstimated,minTokenReceiveAmount,tokenReceiveAmount,tokenId) = {
206+    let worstAllowedNewInvariantRatio = (scale16 - ((scale16 * 1) / 10000000))
207+    let deltaBetweenMaxAndMinSendValue = (amountToSendEstimated - minTokenReceiveAmount)
208+    let x = (balanceA + tokenReceiveAmount)
209+    let y = (balanceB + tokenReceiveAmount)
210+    func getStepAmount (acc,step) =     if ((acc._1 == -1))
211+        then {
212+            let amountToSend = (amountToSendEstimated - (((step * deltaBetweenMaxAndMinSendValue) / 3) / scale3))
213+            let stepInvariant = if ((tokenId == assetIdA))
214+                then invariantCalc(x, (balanceB - amountToSend))
215+                else invariantCalc((balanceA - amountToSend), y)
216+            if ((stepInvariant > invariant))
217+                then $Tuple2(amountToSend, stepInvariant)
218+                else $Tuple2(-1, 0)
219+            }
220+        else acc
221+
222+    let amountToSendMin = getStepAmount($Tuple2(-1, 0), 3000)
223+    if ((0 > amountToSendMin._1))
224+        then throw("Price is worse than minReceived")
225+        else {
226+            let invEstimated = if ((tokenId == assetIdA))
227+                then invariantCalc(x, (balanceB - amountToSendEstimated))
228+                else if ((tokenId == assetIdB))
229+                    then invariantCalc((balanceA - amountToSendEstimated), y)
230+                    else throw("Wrong asset in payment")
231+            if ((invariant > invEstimated))
232+                then if ((worstAllowedNewInvariantRatio >= fraction(scale16, invariant, invEstimated)))
233+                    then throw("The requested price is too not profitable for user")
234+                    else {
235+                        let a = {
236+                            let $l = [25, 200, 500]
237+                            let $s = size($l)
238+                            let $acc0 = $Tuple2(-1, 0)
239+                            func $f0_1 ($a,$i) =                             if (($i >= $s))
240+                                then $a
241+                                else getStepAmount($a, $l[$i])
242+
243+                            func $f0_2 ($a,$i) =                             if (($i >= $s))
244+                                then $a
245+                                else throw("List size exceeds 3")
246+
247+                            $f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
248+                            }
249+                        if ((0 > a._1))
250+                            then amountToSendMin._1
251+                            else a._1
252+                        }
253+                else {
254+                    let a = {
255+                        let $l = [-500, -200, -25]
256+                        let $s = size($l)
257+                        let $acc0 = $Tuple2(-1, 0)
258+                        func $f0_1 ($a,$i) =                         if (($i >= $s))
259+                            then $a
260+                            else getStepAmount($a, $l[$i])
261+
262+                        func $f0_2 ($a,$i) =                         if (($i >= $s))
263+                            then $a
264+                            else throw("List size exceeds 3")
265+
266+                        $f0_2($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3)
267+                        }
268+                    let tupleSendBetter = if ((0 > a._1))
269+                        then $Tuple2(amountToSendEstimated, invEstimated)
270+                        else a
271+                    if ((worstAllowedNewInvariantRatio >= fraction(scale16, invariant, tupleSendBetter._2)))
272+                        then throw("The requested price is too not profitable for user")
273+                        else tupleSendBetter._1
274+                    }
275+            }
276+    }
277+
278+
279+func getAssetInfo (assetId) = match assetId {
280+    case id: ByteVector => 
281+        let stringId = toBase58String(id)
282+        let info = valueOrErrorMessage(assetInfo(id), (("Asset " + stringId) + " doesn't exist"))
283+        $Tuple3(stringId, info.name, info.decimals)
284+    case waves: Unit => 
285+        $Tuple3("WAVES", "WAVES", 8)
286+    case _ => 
287+        throw("Match error")
288+}
289+
290+
291+func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
292+
293+
294+func throwIsActive () = throw("DApp is already active")
295+
296+
297+func isActive () = if (active)
298+    then unit
299+    else throw("DApp is inactive at this moment")
300+
301+
302+func isAdminCall (i) = if (containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey))
303+    then unit
304+    else throw("Only admin can call this function")
305+
306+
307+func throwAssets () = throw(((("Incorrect assets attached. Expected: " + strAssetIdA) + " and ") + strAssetIdB))
308+
309+
310+func throwOnePayment () = throw("One attached payment expected")
311+
312+
313+func suspendSuspicious () = suspend(((((((((((((((("Suspicious state. Actual balances: " + toString(balanceA)) + " ") + assetNameA) + ", ") + toString(balanceB)) + " ") + assetNameB) + ". State: ") + toString(accountBalance(assetIdA))) + " ") + assetNameA) + ", ") + toString(accountBalance(assetIdB))) + " ") + assetNameB))
314+
315+
316+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))
317+
318+
319+func calcStakingFuncAndAddres (stake,assetId) = if (stake)
320+    then $Tuple2("lockNeutrino", stakingUSDNAddress)
321+    else $Tuple2("unlockNeutrino", stakingUSDNAddress)
322+
323+
324+func calcStakingParams (stake,amount,assetId) = if (stake)
325+    then {
326+        let $t093629428 = calcStakingFuncAndAddres(stake, assetId)
327+        let call = $t093629428._1
328+        let stakingAddr = $t093629428._2
329+        $Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
330+        }
331+    else {
332+        let $t095149580 = calcStakingFuncAndAddres(stake, assetId)
333+        let call = $t095149580._1
334+        let stakingAddr = $t095149580._2
335+        $Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
336+        }
337+
338+
339+func calculateFeeDiscount (userAddr) = {
340+    let swopAmount = valueOrElse(getInteger(govAddress, (toString(userAddr) + kUserSwopInGov)), 0)
341+    let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
342+    let discounts = split(getStringValue(oracle, kDiscounts), ",")
343+    if (if ((swopAmount >= parseIntValue(discountValues[0])))
344+        then (parseIntValue(discountValues[1]) > swopAmount)
345+        else false)
346+        then (feeScale6 - parseIntValue(discounts[0]))
347+        else if (if ((swopAmount >= parseIntValue(discountValues[1])))
348+            then (parseIntValue(discountValues[2]) > swopAmount)
349+            else false)
350+            then (feeScale6 - parseIntValue(discounts[1]))
351+            else if (if ((swopAmount >= parseIntValue(discountValues[2])))
352+                then (parseIntValue(discountValues[3]) > swopAmount)
353+                else false)
354+                then (feeScale6 - parseIntValue(discounts[2]))
355+                else if (if ((swopAmount >= parseIntValue(discountValues[3])))
356+                    then (parseIntValue(discountValues[4]) > swopAmount)
357+                    else false)
358+                    then (feeScale6 - parseIntValue(discounts[3]))
359+                    else if ((swopAmount >= parseIntValue(discountValues[4])))
360+                        then (feeScale6 - parseIntValue(discounts[4]))
361+                        else feeScale6
362+    }
363+
364+
365+func calcBalanceAndPmtRatio (ABalance,BBalance,minAmountToReceive,pmtAmount,pmtAssetId) = if ((balanceA > balanceB))
366+    then {
367+        let ratio = fraction(scale8, balanceA, balanceB)
368+        let pratio = if ((pmtAssetId == assetIdA))
369+            then fraction(scale8, minAmountToReceive, pmtAmount)
370+            else fraction(scale8, minAmountToReceive, pmtAmount)
371+        $Tuple2(ratio, pratio)
372+        }
373+    else {
374+        let ratio = fraction(scale8, balanceB, balanceA)
375+        let pratio = if ((pmtAssetId == assetIdA))
376+            then fraction(scale8, minAmountToReceive, pmtAmount)
377+            else fraction(scale8, minAmountToReceive, pmtAmount)
378+        $Tuple2(ratio, pratio)
379+        }
380+
381+
382+@Callable(i)
383+func init () = {
384+    let $t01149811575 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
385+    let pmtAmountA = $t01149811575._1
386+    let pmtAssetIdA = $t01149811575._2
387+    let $t01158011657 = $Tuple2(i.payments[1].amount, i.payments[1].assetId)
388+    let pmtAmountB = $t01158011657._1
389+    let pmtAssetIdB = $t01158011657._2
390+    let $t01166211739 = getAssetInfo(pmtAssetIdA)
391+    let pmtStrAssetIdA = $t01166211739._1
392+    let pmtAssetNameA = $t01166211739._2
393+    let pmtDecimalsA = $t01166211739._3
394+    let $t01174411821 = getAssetInfo(pmtAssetIdB)
395+    let pmtStrAssetIdB = $t01174411821._1
396+    let pmtAssetNameB = $t01174411821._2
397+    let pmtDecimalsB = $t01174411821._3
398+    if (isDefined(getBoolean(this, kActive)))
399+        then throwIsActive()
400+        else if ((pmtAssetIdA == pmtAssetIdB))
401+            then throw("Assets must be different")
402+            else {
403+                let shareName = ((("s" + take(pmtAssetNameA, 7)) + "_") + take(pmtAssetNameB, 7))
404+                let shareDescription = ((((("ShareToken of SwopFi protocol for " + pmtAssetNameA) + " and ") + pmtAssetNameB) + " at address ") + toString(this))
405+                let shareDecimals = ((pmtDecimalsA + pmtDecimalsB) / 2)
406+                let shareInitialSupply = fraction(pow(pmtAmountA, pmtDecimalsA, 5, 1, pmtDecimalsA, DOWN), pow(pmtAmountB, pmtDecimalsB, 5, 1, pmtDecimalsB, DOWN), pow(10, 0, shareDecimals, 0, 0, DOWN))
407+                let shareIssue = Issue(shareName, shareDescription, shareInitialSupply, shareDecimals, true)
408+                let shareIssueId = calculateAssetId(shareIssue)
409+                let invariantCalculated = invariantCalc(pmtAmountA, pmtAmountB)
410+                let stake1 = if (containsElement(stakingAssets, pmtStrAssetIdA))
411+                    then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
412+                    else 0
413+                if ((stake1 == stake1))
414+                    then {
415+                        let stake2 = if (containsElement(stakingAssets, pmtStrAssetIdB))
416+                            then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
417+                            else 0
418+                        if ((stake2 == stake2))
419+                            then [StringEntry(kVersion, version), BooleanEntry(kActive, true), StringEntry(kAssetIdA, pmtStrAssetIdA), StringEntry(kAssetIdB, pmtStrAssetIdB), IntegerEntry(kBalanceA, pmtAmountA), IntegerEntry(kBalanceB, pmtAmountB), IntegerEntry(kInvariant, invariantCalculated), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_flat")), shareIssue, StringEntry(kShareAssetId, toBase58String(shareIssueId)), IntegerEntry(kShareAssetSupply, shareInitialSupply), ScriptTransfer(i.caller, shareInitialSupply, shareIssueId)]
420+                            else throw("Strict value is not equal to itself.")
421+                        }
422+                    else throw("Strict value is not equal to itself.")
423+                }
424+    }
425+
426+
427+
428+@Callable(i)
429+func replenishWithTwoTokens () = valueOrElse(isActive(), {
430+    let pmtAssetIdA = i.payments[0].assetId
431+    let pmtAssetIdB = i.payments[1].assetId
432+    let ratioShareTokensInA = fraction(scale8, i.payments[0].amount, balanceA)
433+    let ratioShareTokensInB = fraction(scale8, i.payments[1].amount, balanceB)
434+    let $t01446914546 = getAssetInfo(pmtAssetIdA)
435+    let pmtStrAssetIdA = $t01446914546._1
436+    let pmtAssetNameA = $t01446914546._2
437+    let pmtDecimalsA = $t01446914546._3
438+    let $t01455114668 = getAssetInfo(pmtAssetIdB)
439+    let pmtStrAssetIdB = $t01455114668._1
440+    let pmtAssetNameB = $t01455114668._2
441+    let pmtDecimalsB = $t01455114668._3
442+    let $t01467315177 = if ((ratioShareTokensInB > ratioShareTokensInA))
443+        then {
444+            let pmt = fraction(balanceB, ratioShareTokensInA, scale8, CEILING)
445+            $Tuple5(i.payments[0].amount, pmt, (i.payments[1].amount - pmt), pmtAssetIdB, ratioShareTokensInA)
446+            }
447+        else {
448+            let pmt = fraction(balanceA, ratioShareTokensInB, scale8, CEILING)
449+            $Tuple5(pmt, i.payments[1].amount, (i.payments[0].amount - pmt), pmtAssetIdA, ratioShareTokensInB)
450+            }
451+    let pmtAmountA = $t01467315177._1
452+    let pmtAmountB = $t01467315177._2
453+    let change = $t01467315177._3
454+    let changeAssetId = $t01467315177._4
455+    let shareTokenRatio = $t01467315177._5
456+    let shareTokenToPayAmount = fraction(shareTokenRatio, shareAssetSupply, scale8)
457+    if ((size(i.payments) != 2))
458+        then throw("Two attached assets expected")
459+        else if (if ((pmtAssetIdA != assetIdA))
460+            then true
461+            else (pmtAssetIdB != assetIdB))
462+            then throwAssets()
463+            else if ((shareTokenToPayAmount == 0))
464+                then throw("Too small amount to replenish")
465+                else if ((0 > change))
466+                    then throw("Change < 0")
467+                    else if (!(hasEnoughBalance))
468+                        then ([ScriptTransfer(i.caller, pmtAmountA, pmtAssetIdA), ScriptTransfer(i.caller, pmtAmountB, pmtAssetIdB)] ++ suspendSuspicious())
469+                        else {
470+                            let stake1 = if (containsElement(stakingAssets, pmtStrAssetIdA))
471+                                then invoke(this, "stakeUnstake", [true, pmtAmountA, pmtStrAssetIdA], nil)
472+                                else 0
473+                            if ((stake1 == stake1))
474+                                then {
475+                                    let stake2 = if (containsElement(stakingAssets, pmtStrAssetIdB))
476+                                        then invoke(this, "stakeUnstake", [true, pmtAmountB, pmtStrAssetIdB], nil)
477+                                        else 0
478+                                    if ((stake2 == stake2))
479+                                        then [IntegerEntry(kBalanceA, (balanceA + pmtAmountA)), IntegerEntry(kBalanceB, (balanceB + pmtAmountB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmount)), IntegerEntry(kInvariant, invariantCalc((balanceA + pmtAmountA), (balanceB + pmtAmountB))), Reissue(shareAssetId, shareTokenToPayAmount, true), ScriptTransfer(i.caller, shareTokenToPayAmount, shareAssetId), ScriptTransfer(i.caller, change, changeAssetId)]
480+                                        else throw("Strict value is not equal to itself.")
481+                                    }
482+                                else throw("Strict value is not equal to itself.")
483+                            }
484+    })
485+
486+
487+
488+@Callable(i)
489+func replenishWithOneToken (virtualSwapTokenPay,virtualSwapTokenGet) = valueOrElse(isActive(), {
490+    let $t01691016985 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
491+    let pmtAmount = $t01691016985._1
492+    let pmtAssetId = $t01691016985._2
493+    let $t01699017063 = getAssetInfo(pmtAssetId)
494+    let pmtStrAssetId = $t01699017063._1
495+    let pmtAssetName = $t01699017063._2
496+    let pmtDecimals = $t01699017063._3
497+    let pmtMinThreshold = 5000000
498+    let thresholdValueForMinTolerance = 50000000
499+    let tolerance = if ((thresholdValueForMinTolerance > pmtAmount))
500+        then 100000
501+        else 1
502+    let slippageValueMinForReplenish = (scale8 - ((scale8 * tolerance) / 10000000))
503+    let slippageValueMaxForReplenish = (scale8 + ((scale8 * tolerance) / 10000000))
504+    let slippageValueMinForSwap = (scale8 - ((scale8 * 1) / 10000000))
505+    if ((pmtMinThreshold > pmtAmount))
506+        then throw((((("Payment amount " + toString(pmtAmount)) + " does not exceed the minimum amount of ") + toString(pmtMinThreshold)) + " tokens"))
507+        else if ((size(i.payments) != 1))
508+            then throwOnePayment()
509+            else if (!(hasEnoughBalance))
510+                then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
511+                else if (if ((pmtAssetId != assetIdA))
512+                    then (pmtAssetId != assetIdB)
513+                    else false)
514+                    then throwAssets()
515+                    else {
516+                        let $t01804118683 = if ((pmtAssetId == assetIdA))
517+                            then $Tuple6((pmtAmount - virtualSwapTokenPay), virtualSwapTokenGet, (balanceA + virtualSwapTokenPay), (balanceB - virtualSwapTokenGet), (balanceA + pmtAmount), balanceB)
518+                            else $Tuple6(virtualSwapTokenGet, (pmtAmount - virtualSwapTokenPay), (balanceA - virtualSwapTokenGet), (balanceB + virtualSwapTokenPay), balanceA, (balanceB + pmtAmount))
519+                        let virtualReplenishA = $t01804118683._1
520+                        let virtualReplenishB = $t01804118683._2
521+                        let balanceAfterSwapA = $t01804118683._3
522+                        let balanceAfterSwapB = $t01804118683._4
523+                        let newBalanceA = $t01804118683._5
524+                        let newBalanceB = $t01804118683._6
525+                        let invariantNew = invariantCalc(balanceAfterSwapA, balanceAfterSwapB)
526+                        let ratioVirtualBalanceToVirtualReplenish = (fraction(scale16, balanceAfterSwapA, balanceAfterSwapB) / fraction(scale8, virtualReplenishA, virtualReplenishB))
527+                        if (if ((slippageValueMinForSwap >= fraction(scale8, invariant, invariantNew)))
528+                            then true
529+                            else (invariant > invariantNew))
530+                            then throw("Incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
531+                            else if (if ((slippageValueMinForReplenish > ratioVirtualBalanceToVirtualReplenish))
532+                                then true
533+                                else (ratioVirtualBalanceToVirtualReplenish > slippageValueMaxForReplenish))
534+                                then throw("Swap with virtualSwapTokenPay and virtualSwapTokenGet is possible, but ratio after virtual swap is incorrect")
535+                                else {
536+                                    let ratioShareTokensInA = fraction(virtualReplenishA, scale8, balanceAfterSwapA)
537+                                    let ratioShareTokensInB = fraction(virtualReplenishB, scale8, balanceAfterSwapB)
538+                                    let shareTokenToPayAmount = fraction(min([ratioShareTokensInA, ratioShareTokensInB]), shareAssetSupply, scale8)
539+                                    let shareTokenToPayAmountAfterFee = fraction(shareTokenToPayAmount, (feeScale6 - (fee / 2)), feeScale6)
540+                                    let shareTokenGovernanceReward = fraction(shareTokenToPayAmount, (feeGovernance / 2), feeScale6)
541+                                    let governanceRewardTokenA = fraction(shareTokenGovernanceReward, balanceA, shareAssetSupply)
542+                                    let governanceRewardTokenB = fraction(shareTokenGovernanceReward, balanceB, shareAssetSupply)
543+                                    let $t02039420689 = if ((pmtStrAssetId == strAssetIdA))
544+                                        then $Tuple3((pmtAmount - governanceRewardTokenA), governanceRewardTokenB, strAssetIdB)
545+                                        else $Tuple3((pmtAmount - governanceRewardTokenB), governanceRewardTokenA, strAssetIdA)
546+                                    let stakeAmount = $t02039420689._1
547+                                    let unstakeAmount = $t02039420689._2
548+                                    let unstakeAsset = $t02039420689._3
549+                                    let stake1 = if (containsElement(stakingAssets, pmtStrAssetId))
550+                                        then invoke(this, "stakeUnstake", [true, stakeAmount, pmtStrAssetId], nil)
551+                                        else 0
552+                                    if ((stake1 == stake1))
553+                                        then {
554+                                            let stake2 = if (containsElement(stakingAssets, unstakeAsset))
555+                                                then invoke(this, "stakeUnstake", [false, unstakeAmount, unstakeAsset], nil)
556+                                                else 0
557+                                            if ((stake2 == stake2))
558+                                                then [Reissue(shareAssetId, shareTokenToPayAmountAfterFee, true), ScriptTransfer(i.caller, shareTokenToPayAmountAfterFee, shareAssetId), ScriptTransfer(moneyBoxAddress, governanceRewardTokenA, assetIdA), ScriptTransfer(moneyBoxAddress, governanceRewardTokenB, assetIdB), IntegerEntry(kBalanceA, (newBalanceA - governanceRewardTokenA)), IntegerEntry(kBalanceB, (newBalanceB - governanceRewardTokenB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply + shareTokenToPayAmountAfterFee)), IntegerEntry(kInvariant, invariantCalc((newBalanceA - governanceRewardTokenA), (newBalanceB - governanceRewardTokenB)))]
559+                                                else throw("Strict value is not equal to itself.")
560+                                            }
561+                                        else throw("Strict value is not equal to itself.")
562+                                    }
563+                        }
564+    })
565+
566+
567+
568+@Callable(i)
569+func withdraw () = valueOrElse(isActive(), {
570+    let $t02197622051 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
571+    let pmtAmount = $t02197622051._1
572+    let pmtAssetId = $t02197622051._2
573+    let amountToPayA = fraction(pmtAmount, balanceA, shareAssetSupply)
574+    let amountToPayB = fraction(pmtAmount, balanceB, shareAssetSupply)
575+    let invariantCalculated = invariantCalc((balanceA - amountToPayA), (balanceB - amountToPayB))
576+    if ((size(i.payments) != 1))
577+        then throwOnePayment()
578+        else if ((pmtAssetId != shareAssetId))
579+            then throw(("Incorrect asset attached. Expected: " + toBase58String(shareAssetId)))
580+            else if (!(hasEnoughBalance))
581+                then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
582+                else {
583+                    let stake1 = if (containsElement(stakingAssets, strAssetIdA))
584+                        then invoke(this, "stakeUnstake", [false, amountToPayA, strAssetIdA], nil)
585+                        else 0
586+                    if ((stake1 == stake1))
587+                        then {
588+                            let stake2 = if (containsElement(stakingAssets, strAssetIdB))
589+                                then invoke(this, "stakeUnstake", [false, amountToPayB, strAssetIdB], nil)
590+                                else 0
591+                            if ((stake2 == stake2))
592+                                then [IntegerEntry(kBalanceA, (balanceA - amountToPayA)), IntegerEntry(kBalanceB, (balanceB - amountToPayB)), IntegerEntry(kShareAssetSupply, (shareAssetSupply - pmtAmount)), IntegerEntry(kInvariant, invariantCalculated), Burn(shareAssetId, pmtAmount), ScriptTransfer(i.caller, amountToPayA, assetIdA), ScriptTransfer(i.caller, amountToPayB, assetIdB)]
593+                                else throw("Strict value is not equal to itself.")
594+                            }
595+                        else throw("Strict value is not equal to itself.")
596+                    }
597+    })
598+
599+
600+
601+@Callable(i)
602+func exchange (estimatedAmountToReceive,minAmountToReceive) = valueOrElse(isActive(), {
603+    let $t02360223677 = $Tuple2(i.payments[0].amount, i.payments[0].assetId)
604+    let pmtAmount = $t02360223677._1
605+    let pmtAssetId = $t02360223677._2
606+    if ((0 >= estimatedAmountToReceive))
607+        then throw(("Estimated amount must be positive. Actual: " + toString(estimatedAmountToReceive)))
608+        else if ((minAmountToReceive > estimatedAmountToReceive))
609+            then throw("Minimal amount can't be greater than estimated.")
610+            else if ((size(i.payments) != 1))
611+                then throwOnePayment()
612+                else if (!(hasEnoughBalance))
613+                    then ([ScriptTransfer(i.caller, pmtAmount, pmtAssetId)] ++ suspendSuspicious())
614+                    else if (if ((pmtAssetId != assetIdA))
615+                        then (pmtAssetId != assetIdB)
616+                        else false)
617+                        then throwAssets()
618+                        else if ((10000000 > pmtAmount))
619+                            then throw("Only swap of 10.000000 or more tokens is allowed")
620+                            else {
621+                                let $t02436324479 = calcBalanceAndPmtRatio(balanceA, balanceB, minAmountToReceive, pmtAmount, pmtAssetId)
622+                                let balanceRatio = $t02436324479._1
623+                                let pmtRatio = $t02436324479._2
624+                                if (((exchangeRatioLimit - fraction(exchangeRatioLimitCoef, balanceRatio, scale8)) > pmtRatio))
625+                                    then throw("Incorrect args and pmt ratio")
626+                                    else {
627+                                        let sendAssetId = if ((pmtAssetId == assetIdA))
628+                                            then assetIdB
629+                                            else assetIdA
630+                                        let amount = calculateSendAmount(estimatedAmountToReceive, minAmountToReceive, pmtAmount, pmtAssetId)
631+                                        let feeDiscount = calculateFeeDiscount(i.originCaller)
632+                                        let governanceReward = fraction(amount, fraction(feeGovernance, feeDiscount, feeScale6, CEILING), feeScale6)
633+                                        let amountMinusFee = fraction(amount, (feeScale6 - fraction(fee, feeDiscount, feeScale6, CEILING)), feeScale6)
634+                                        let $t02523425512 = if ((pmtAssetId == assetIdA))
635+                                            then $Tuple2((balanceA + pmtAmount), ((balanceB - amountMinusFee) - governanceReward))
636+                                            else $Tuple2(((balanceA - amountMinusFee) - governanceReward), (balanceB + pmtAmount))
637+                                        let newBalanceA = $t02523425512._1
638+                                        let newBalanceB = $t02523425512._2
639+                                        let dAppThresholdAmount = fraction((newBalanceA + newBalanceB), dAppThreshold, (2 * dAppThresholdScale2))
640+                                        if (if ((dAppThresholdAmount > newBalanceA))
641+                                            then true
642+                                            else (dAppThresholdAmount > newBalanceB))
643+                                            then throwThreshold(dAppThresholdAmount, newBalanceA, newBalanceB)
644+                                            else {
645+                                                let $t02583125904 = getAssetInfo(pmtAssetId)
646+                                                let pmtStrAssetId = $t02583125904._1
647+                                                let pmtAssetName = $t02583125904._2
648+                                                let pmtDecimals = $t02583125904._3
649+                                                let $t02592125998 = getAssetInfo(sendAssetId)
650+                                                let sendStrAssetId = $t02592125998._1
651+                                                let sendAssetName = $t02592125998._2
652+                                                let sendDecimals = $t02592125998._3
653+                                                let stake1 = if (containsElement(stakingAssets, pmtStrAssetId))
654+                                                    then invoke(this, "stakeUnstake", [true, pmtAmount, pmtStrAssetId], nil)
655+                                                    else 0
656+                                                if ((stake1 == stake1))
657+                                                    then {
658+                                                        let stake2 = if (containsElement(stakingAssets, sendStrAssetId))
659+                                                            then invoke(this, "stakeUnstake", [false, (amountMinusFee + governanceReward), sendStrAssetId], nil)
660+                                                            else 0
661+                                                        if ((stake2 == stake2))
662+                                                            then $Tuple2([IntegerEntry(kBalanceA, newBalanceA), IntegerEntry(kBalanceB, newBalanceB), IntegerEntry(kInvariant, invariantCalc(newBalanceA, newBalanceB)), ScriptTransfer(i.caller, amountMinusFee, sendAssetId), ScriptTransfer(moneyBoxAddress, governanceReward, sendAssetId)], $Tuple2(amountMinusFee, sendAssetId))
663+                                                            else throw("Strict value is not equal to itself.")
664+                                                        }
665+                                                    else throw("Strict value is not equal to itself.")
666+                                                }
667+                                        }
668+                                }
669+    })
670+
671+
672+
673+@Callable(i)
674+func shutdown () = valueOrElse(isAdminCall(i), if (!(active))
675+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, kCause), "the cause wasn't specified")))
676+    else suspend("Paused by admin"))
677+
678+
679+
680+@Callable(i)
681+func activate () = valueOrElse(isAdminCall(i), if (active)
682+    then throwIsActive()
683+    else [BooleanEntry(kActive, true), DeleteEntry(kCause)])
684+
685+
686+
687+@Callable(i)
688+func takeIntoAccountExtraFunds () = valueOrElse(isActive(), {
689+    let amountEnrollA = (accountBalanceWithStakedA - balanceA)
690+    let amountEnrollB = (accountBalanceWithStakedB - balanceB)
691+    let invariantNew = invariantCalc((balanceA + amountEnrollA), (balanceB + amountEnrollB))
692+    if ((i.caller != moneyBoxAddress))
693+        then throw("Only the money box can call this function")
694+        else if (if ((0 > amountEnrollA))
695+            then true
696+            else (0 > amountEnrollB))
697+            then suspend("Enroll amount negative")
698+            else if (if ((amountEnrollA == 0))
699+                then (amountEnrollB == 0)
700+                else false)
701+                then throw("No money to take")
702+                else {
703+                    let stake1 = if (if (containsElement(stakingAssets, strAssetIdA))
704+                        then (amountEnrollA > 0)
705+                        else false)
706+                        then invoke(this, "stakeUnstake", [true, amountEnrollA, strAssetIdA], nil)
707+                        else 0
708+                    if ((stake1 == stake1))
709+                        then {
710+                            let stake2 = if (if (containsElement(stakingAssets, strAssetIdB))
711+                                then (amountEnrollB > 0)
712+                                else false)
713+                                then invoke(this, "stakeUnstake", [true, amountEnrollB, strAssetIdB], nil)
714+                                else 0
715+                            if ((stake2 == stake2))
716+                                then [IntegerEntry(kInvariant, invariantNew), IntegerEntry(kBalanceA, (balanceA + amountEnrollA)), IntegerEntry(kBalanceB, (balanceB + amountEnrollB))]
717+                                else throw("Strict value is not equal to itself.")
718+                            }
719+                        else throw("Strict value is not equal to itself.")
720+                    }
721+    })
722+
723+
724+
725+@Callable(i)
726+func stakeUnstake (stake,amount,assetIdString) = if ((i.caller != this))
727+    then throw("Only contract itself can invoke this function")
728+    else {
729+        let $t02904129144 = calcStakingParams(stake, amount, fromBase58String(assetIdString))
730+        let call = $t02904129144._1
731+        let addr = $t02904129144._2
732+        let params = $t02904129144._3
733+        let payments = $t02904129144._4
734+        let inv = invoke(addr, call, params, payments)
735+        if ((inv == inv))
736+            then nil
737+            else throw("Strict value is not equal to itself.")
738+        }
739+
740+
741+
742+@Callable(i)
743+func toBigIntInvariant () = valueOrElse(isAdminCall(i), [IntegerEntry(kInvariant, invariantCalc(balanceA, balanceB))])
744+
745+
746+@Verifier(tx)
747+func verify () = {
748+    let multiSignedByAdmins = {
749+        let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
750+            then 1
751+            else 0
752+        let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
753+            then 1
754+            else 0
755+        let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
756+            then 1
757+            else 0
758+        (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
759+        }
760+    match tx {
761+        case inv: InvokeScriptTransaction => 
762+            let callTakeIntoAccount = if ((inv.dApp == this))
763+                then (inv.function == "takeIntoAccountExtraFunds")
764+                else false
765+            let signedByAdmin = if (if (if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
766+                then true
767+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey2))
768+                then true
769+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey3))
770+                then true
771+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKeyInvoke)
772+            if (if (callTakeIntoAccount)
773+                then signedByAdmin
774+                else false)
775+                then true
776+                else multiSignedByAdmins
777+        case _ => 
778+            multiSignedByAdmins
779+    }
780+    }
781+
github/deemru/w8io/169f3d6 
47.32 ms ◑