tx · 9xiQZW1NPnEwFDsKu2UAYnnWteiAvFKULkH3GD2HFhHV

3PBhJMugz8Gxvn3mNs7a3sbJY6fbsAQMKfg:  -0.03500000 Waves

2022.09.22 18:37 [3305959] smart account 3PBhJMugz8Gxvn3mNs7a3sbJY6fbsAQMKfg > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9xiQZW1NPnEwFDsKu2UAYnnWteiAvFKULkH3GD2HFhHV",
    "fee": 3500000,
    "feeAssetId": null,
    "timestamp": 1663861089373,
    "version": 2,
    "chainId": 87,
    "sender": "3PBhJMugz8Gxvn3mNs7a3sbJY6fbsAQMKfg",
    "senderPublicKey": "6HroEdc5WXn2cvBrujAQhcu9HR4zC2iUoXZVvmSrxyyb",
    "proofs": [
        "38X2VuvgGPGef3P5NkS5x4DbHwyxrjM4v7xyDbdaj7fWPCNnb2J6vTi5Q4zTR3PcomZjGFobJoTaHsd1wzsWPxaS"
    ],
    "script": "base64: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",
    "height": 3305959,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: FabvQhQiL89SSAQDjnsG6zntzunGFgrGWNg7cAJuVjy7

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let PRECISION = 1000000
5+
6+let MAX_A = 1000000
7+
8+let MAX_A_CHANGE = 10
9+
10+let DECIMALS = 6
11+
12+let MIN_RAMP_TIME = (86400 / 60)
13+
14+let version = "3.0.0"
15+
16+let kVersion = "version"
17+
18+let kAssets = "asset_ids"
19+
20+let kAssetBalance = "_balance"
21+
22+let kActive = "active"
23+
24+let kCause = "shutdown_cause"
25+
26+let kShareAssetId = "share_asset_id"
27+
28+let kShareAssetSupply = "share_asset_supply"
29+
30+let kFee = "commission"
31+
32+let kDAppThresholdCoef = "dAppThresholdCoef"
33+
34+let kUSDNAddress = "staking_usdnnsbt_address"
35+
36+let kDiscounts = "discounts"
37+
38+let kDiscountValues = "discount_values"
39+
40+let kUserSwopInGov = "_SWOP_amount"
41+
42+let kAdminPubKey1 = "admin_pub_1"
43+
44+let kAdminPubKey2 = "admin_pub_2"
45+
46+let kAdminPubKey3 = "admin_pub_3"
47+
48+let kAdminInvokePubKey = "admin_invoke_pub"
49+
50+let kMoneyBoxAddress = "money_box_address"
51+
52+let kGovAddress = "governance_address"
53+
54+let kVotingAddress = "voting_address"
55+
56+let kFarmingAddress = "farming_address"
57+
58+let kLPFarmingAddress = "lp_farming"
59+
60+let oracle = Address(base58'3PEbqViERCoKnmcSULh6n2aiMvUdSQdCsom')
61+
62+func getBase58FromOracle (key) = match getString(oracle, key) {
63+    case string: String => 
64+        fromBase58String(string)
65+    case nothing => 
66+        throw((key + "is empty"))
67+}
68+
69+
70+let adminPubKey1 = getBase58FromOracle(kAdminPubKey1)
71+
72+let adminPubKey2 = getBase58FromOracle(kAdminPubKey2)
73+
74+let adminPubKey3 = getBase58FromOracle(kAdminPubKey3)
75+
76+let adminPubKeyInvoke = getBase58FromOracle(kAdminInvokePubKey)
77+
78+let moneyBoxAddress = Address(getBase58FromOracle(kMoneyBoxAddress))
79+
80+let govAddress = Address(getBase58FromOracle(kGovAddress))
81+
82+let stakingUSDNAddress = Address(getBase58FromOracle(kUSDNAddress))
83+
84+let votingAddress = Address(getBase58FromOracle(kVotingAddress))
85+
86+let farmingAddress = Address(getBase58FromOracle(kFarmingAddress))
87+
88+let lpFarmingAddress = Address(getBase58FromOracle(kLPFarmingAddress))
89+
90+let USDN = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
91+
92+let stakingAssets = [toBase58String(USDN)]
93+
94+let active = getBooleanValue(this, kActive)
95+
96+let shareAssetId = fromBase58String(getStringValue(this, kShareAssetId))
97+
98+let shareSupply = getIntegerValue(this, kShareAssetSupply)
99+
100+let feeScale6 = 1000000
101+
102+let fee = getIntegerValue(this, kFee)
103+
104+let feeGovernance = fraction(40, feeScale6, 100)
105+
106+let initial_A = getIntegerValue(this, "initial_A")
107+
108+let future_A = getIntegerValue(this, "future_A")
109+
110+let initial_A_time = valueOrElse(getInteger(this, "initial_A_time"), 0)
111+
112+let future_A_time = valueOrElse(getInteger(this, "future_A_time"), 0)
113+
114+let assetIds = split(getStringValue(this, kAssets), ",")
115+
116+let nCoins = size(assetIds)
117+
118+func suspend (cause) = [BooleanEntry(kActive, false), StringEntry(kCause, cause)]
119+
120+
121+func throwIsActive () = throw("DApp is already active")
122+
123+
124+func isActive () = if (active)
125+    then unit
126+    else throw("DApp is inactive at this moment")
127+
128+
129+func isAdminCall (i) = if (containsElement([adminPubKey1, adminPubKey2, adminPubKey3], i.callerPublicKey))
130+    then unit
131+    else throw("Only admin can call this function")
132+
133+
134+func isSelfCall (i) = if ((this == i.caller))
135+    then unit
136+    else throw("Only contract itself can call this function")
137+
138+
139+let big2 = toBigInt(2)
140+
141+let blockTimestamp = height
142+
143+func assert (a) = if (a)
144+    then false
145+    else true
146+
147+
148+func calculateFeeDiscount (userAddr) = {
149+    let user =     match userAddr {
150+        case u: Address => 
151+            toString(u)
152+        case u: String => 
153+            u
154+        case _ => 
155+            throw("Unknow type of user Addr")
156+    }
157+    let swopAmount = valueOrElse(getInteger(govAddress, (user + kUserSwopInGov)), 0)
158+    let discountValues = split(getStringValue(oracle, kDiscountValues), ",")
159+    let discounts = split(getStringValue(oracle, kDiscounts), ",")
160+    if (if ((swopAmount >= parseIntValue(discountValues[0])))
161+        then (parseIntValue(discountValues[1]) > swopAmount)
162+        else false)
163+        then (feeScale6 - parseIntValue(discounts[0]))
164+        else if (if ((swopAmount >= parseIntValue(discountValues[1])))
165+            then (parseIntValue(discountValues[2]) > swopAmount)
166+            else false)
167+            then (feeScale6 - parseIntValue(discounts[1]))
168+            else if (if ((swopAmount >= parseIntValue(discountValues[2])))
169+                then (parseIntValue(discountValues[3]) > swopAmount)
170+                else false)
171+                then (feeScale6 - parseIntValue(discounts[2]))
172+                else if (if ((swopAmount >= parseIntValue(discountValues[3])))
173+                    then (parseIntValue(discountValues[4]) > swopAmount)
174+                    else false)
175+                    then (feeScale6 - parseIntValue(discounts[3]))
176+                    else if ((swopAmount >= parseIntValue(discountValues[4])))
177+                        then (feeScale6 - parseIntValue(discounts[4]))
178+                        else feeScale6
179+    }
180+
181+
182+func _A () = {
183+    let t1 = future_A_time
184+    let A1 = future_A
185+    if ((t1 > blockTimestamp))
186+        then {
187+            let A0 = initial_A
188+            let t0 = initial_A_time
189+            if ((A1 > A0))
190+                then (A0 + (((A1 - A0) * (blockTimestamp - t0)) / (t1 - t0)))
191+                else (A0 - (((A0 - A1) * (blockTimestamp - t0)) / (t1 - t0)))
192+            }
193+        else A1
194+    }
195+
196+
197+func _xp () = {
198+    func assetBalances (acc,assetId) =     (acc :+ valueOrElse(getInteger(this, (assetId + kAssetBalance)), 0))
199+
200+    let $l = assetIds
201+    let $s = size($l)
202+    let $acc0 = nil
203+    func $f0_1 ($a,$i) =     if (($i >= $s))
204+        then $a
205+        else assetBalances($a, $l[$i])
206+
207+    func $f0_2 ($a,$i) =     if (($i >= $s))
208+        then $a
209+        else throw("List size exceeds 15")
210+
211+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
212+    }
213+
214+
215+func _xp_mem (xp) = xp
216+
217+
218+func sumList (acc,element) = (acc + element)
219+
220+
221+func get_D (xp,amp) = {
222+    let @ = invoke(this, "D", [xp, amp], nil)
223+    if ($isInstanceOf(@, "Int"))
224+        then @
225+        else throw(($getType(invoke(this, "D", [xp, amp], nil)) + " couldn't be cast to Int"))
226+    }
227+
228+
229+func get_D_internal (xp,amp) = {
230+    let S = {
231+        let $l = xp
232+        let $s = size($l)
233+        let $acc0 = 0
234+        func $f0_1 ($a,$i) =         if (($i >= $s))
235+            then $a
236+            else sumList($a, $l[$i])
237+
238+        func $f0_2 ($a,$i) =         if (($i >= $s))
239+            then $a
240+            else throw("List size exceeds 15")
241+
242+        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
243+        }
244+    if ((S == 0))
245+        then 0
246+        else {
247+            let Ann = (amp * nCoins)
248+            let AnnS = (toBigInt(Ann) * toBigInt(S))
249+            let Ann1 = toBigInt((Ann - 1))
250+            func Dproc (acc,i) =             if ((acc._2 == true))
251+                then acc
252+                else {
253+                    let Dprev = acc._1
254+                    func D_PProc (D_P,i) =                     if ((nCoins > i))
255+                        then ((D_P * Dprev) / (toBigInt(xp[i]) * toBigInt(nCoins)))
256+                        else D_P
257+
258+                    let D_P = {
259+                        let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
260+                        let $s = size($l)
261+                        let $acc0 = Dprev
262+                        func $f1_1 ($a,$i) =                         if (($i >= $s))
263+                            then $a
264+                            else D_PProc($a, $l[$i])
265+
266+                        func $f1_2 ($a,$i) =                         if (($i >= $s))
267+                            then $a
268+                            else throw("List size exceeds 15")
269+
270+                        $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
271+                        }
272+                    let D = fraction((AnnS + (toBigInt(nCoins) * D_P)), Dprev, ((Ann1 * Dprev) + (toBigInt((nCoins + 1)) * D_P)))
273+                    if ((D > Dprev))
274+                        then if ((1 >= toInt((D - Dprev))))
275+                            then $Tuple2(D, true)
276+                            else $Tuple2(D, false)
277+                        else if ((1 >= toInt((Dprev - D))))
278+                            then $Tuple2(D, true)
279+                            else $Tuple2(D, false)
280+                    }
281+
282+            let $t061916303 = {
283+                let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
284+                let $s = size($l)
285+                let $acc0 = $Tuple2(toBigInt(S), false)
286+                func $f1_1 ($a,$i) =                 if (($i >= $s))
287+                    then $a
288+                    else Dproc($a, $l[$i])
289+
290+                func $f1_2 ($a,$i) =                 if (($i >= $s))
291+                    then $a
292+                    else throw("List size exceeds 15")
293+
294+                $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
295+                }
296+            let D = $t061916303._1
297+            let finished = $t061916303._2
298+            if ((finished == false))
299+                then throw(("get_D() not finished with " + toString(D)))
300+                else toInt(D)
301+            }
302+    }
303+
304+
305+func getDMem (xp,amp) = get_D(_xp_mem(xp), amp)
306+
307+
308+func getY (in,out,x,xp_) = if (assert((in != out)))
309+    then throw("same coin")
310+    else if (assert(if ((out >= 0))
311+        then (in >= 0)
312+        else false))
313+        then throw("below zero")
314+        else if (assert(if ((nCoins > out))
315+            then (nCoins > in)
316+            else false))
317+            then throw("above N_COINS")
318+            else {
319+                let amp = _A()
320+                let D = get_D(xp_, amp)
321+                let Ann = (amp * nCoins)
322+                func S_c (acc,i) =                 {
323+                    let $t068746891 = acc
324+                    let S_ = $t068746891._1
325+                    let c = $t068746891._2
326+                    let x_ = if ((in == i))
327+                        then x
328+                        else xp_[i]
329+                    if (if ((i != out))
330+                        then (nCoins > i)
331+                        else false)
332+                        then $Tuple2((S_ + x_), fraction(c, toBigInt(D), toBigInt((x_ * nCoins))))
333+                        else $Tuple2(S_, c)
334+                    }
335+
336+                let $t070997200 = {
337+                    let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
338+                    let $s = size($l)
339+                    let $acc0 = $Tuple2(0, toBigInt(D))
340+                    func $f0_1 ($a,$i) =                     if (($i >= $s))
341+                        then $a
342+                        else S_c($a, $l[$i])
343+
344+                    func $f0_2 ($a,$i) =                     if (($i >= $s))
345+                        then $a
346+                        else throw("List size exceeds 15")
347+
348+                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
349+                    }
350+                let S_ = $t070997200._1
351+                let c_ = $t070997200._2
352+                let c = fraction(c_, toBigInt(D), toBigInt((Ann * nCoins)))
353+                let bD = toBigInt(((S_ + (D / Ann)) - D))
354+                func y_proc (acc,_i) =                 if ((acc._2 == true))
355+                    then acc
356+                    else {
357+                        let y_prev = acc._1
358+                        let y = (((y_prev * y_prev) + c) / ((big2 * y_prev) + bD))
359+                        if ((y > y_prev))
360+                            then if ((1 >= toInt((y - y_prev))))
361+                                then $Tuple2(y, true)
362+                                else $Tuple2(y, false)
363+                            else if ((1 >= toInt((y_prev - y))))
364+                                then $Tuple2(y, true)
365+                                else $Tuple2(y, false)
366+                        }
367+
368+                let $t076827799 = {
369+                    let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
370+                    let $s = size($l)
371+                    let $acc0 = $Tuple2(toBigInt(D), false)
372+                    func $f1_1 ($a,$i) =                     if (($i >= $s))
373+                        then $a
374+                        else y_proc($a, $l[$i])
375+
376+                    func $f1_2 ($a,$i) =                     if (($i >= $s))
377+                        then $a
378+                        else throw("List size exceeds 16")
379+
380+                    $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
381+                    }
382+                let y = $t076827799._1
383+                let finished = $t076827799._2
384+                if ((finished == false))
385+                    then throw(("getY() not finished with " + toString(y)))
386+                    else toInt(y)
387+                }
388+
389+
390+func get_y_D (A_,in,xp,D) = if (assert((in >= 0)))
391+    then throw("i below zero")
392+    else if (assert((nCoins > in)))
393+        then throw("i above N_COINS")
394+        else {
395+            let Ann = (A_ * nCoins)
396+            func S_c (acc,i) =             {
397+                let $t081788195 = acc
398+                let S_ = $t081788195._1
399+                let c = $t081788195._2
400+                let x_ = if (if ((in != i))
401+                    then (nCoins > i)
402+                    else false)
403+                    then xp[i]
404+                    else 0
405+                if (if ((nCoins > i))
406+                    then (in != i)
407+                    else false)
408+                    then $Tuple2((S_ + x_), fraction(c, toBigInt(D), toBigInt((x_ * nCoins))))
409+                    else $Tuple2(S_, c)
410+                }
411+
412+            let $t084158516 = {
413+                let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
414+                let $s = size($l)
415+                let $acc0 = $Tuple2(0, toBigInt(D))
416+                func $f0_1 ($a,$i) =                 if (($i >= $s))
417+                    then $a
418+                    else S_c($a, $l[$i])
419+
420+                func $f0_2 ($a,$i) =                 if (($i >= $s))
421+                    then $a
422+                    else throw("List size exceeds 15")
423+
424+                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
425+                }
426+            let S_ = $t084158516._1
427+            let c_ = $t084158516._2
428+            let c = fraction(c_, toBigInt(D), toBigInt((Ann * nCoins)))
429+            let bD = toBigInt(((S_ + (D / Ann)) - D))
430+            func y_D_proc (acc,i) =             if ((acc._2 == true))
431+                then acc
432+                else {
433+                    let y_prev = acc._1
434+                    let y = (((y_prev * y_prev) + c) / ((big2 * y_prev) + bD))
435+                    if ((y > y_prev))
436+                        then if ((1 >= toInt((y - y_prev))))
437+                            then $Tuple2(y, true)
438+                            else $Tuple2(y, false)
439+                        else if ((1 >= toInt((y_prev - y))))
440+                            then $Tuple2(y, true)
441+                            else $Tuple2(y, false)
442+                    }
443+
444+            let $t089999118 = {
445+                let $l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
446+                let $s = size($l)
447+                let $acc0 = $Tuple2(toBigInt(D), false)
448+                func $f1_1 ($a,$i) =                 if (($i >= $s))
449+                    then $a
450+                    else y_D_proc($a, $l[$i])
451+
452+                func $f1_2 ($a,$i) =                 if (($i >= $s))
453+                    then $a
454+                    else throw("List size exceeds 16")
455+
456+                $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
457+                }
458+            let y = $t089999118._1
459+            let finished = $t089999118._2
460+            if ((finished == false))
461+                then throw(("get_y_D() not finished with " + toString(y)))
462+                else toInt(y)
463+            }
464+
465+
466+func _calcWithdrawOneCoin (xp,_token_amount,i,caller) = {
467+    let feeDiscount = calculateFeeDiscount(caller)
468+    let amp = _A()
469+    let _fee = ((fraction(fee, feeDiscount, feeScale6, CEILING) * nCoins) / (4 * (nCoins - 1)))
470+    let total_supply = shareSupply
471+    let D0 = get_D(xp, amp)
472+    let D1 = (D0 - fraction(_token_amount, D0, total_supply))
473+    let new_y = get_y_D(amp, i, xp, D1)
474+    let dy_0 = (xp[i] - new_y)
475+    func xp_reduced_proc (acc,xp_j) =     {
476+        let $t097599788 = acc
477+        let xp_reduced = $t097599788._1
478+        let index = $t097599788._2
479+        let dx_expected = if ((index == i))
480+            then (fraction(xp_j, D1, D0) - new_y)
481+            else (xp_j - fraction(xp_j, D1, D0))
482+        $Tuple2((xp_reduced :+ (xp_j - fraction(_fee, dx_expected, feeScale6))), (index + 1))
483+        }
484+
485+    let $t01005010114 = {
486+        let $l = xp
487+        let $s = size($l)
488+        let $acc0 = $Tuple2(nil, 0)
489+        func $f0_1 ($a,$i) =         if (($i >= $s))
490+            then $a
491+            else xp_reduced_proc($a, $l[$i])
492+
493+        func $f0_2 ($a,$i) =         if (($i >= $s))
494+            then $a
495+            else throw("List size exceeds 15")
496+
497+        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
498+        }
499+    let xp_reduced = $t01005010114._1
500+    let index = $t01005010114._2
501+    let xp_reduced_i = xp_reduced[i]
502+    let dy = ((xp_reduced_i - get_y_D(amp, i, xp_reduced, D1)) - 1)
503+    $Tuple2(dy, (dy_0 - dy))
504+    }
505+
506+
507+func getStrAssetId (assetId) = match assetId {
508+    case id: ByteVector => 
509+        toBase58String(id)
510+    case waves: Unit => 
511+        "WAVES"
512+    case _ => 
513+        throw("Match error")
514+}
515+
516+
517+func calcStakingFuncAndAddres (stake,assetId) = if (stake)
518+    then $Tuple2("lockNeutrino", stakingUSDNAddress)
519+    else $Tuple2("unlockNeutrino", stakingUSDNAddress)
520+
521+
522+func calcStakingParams (stake,amount,assetId) = if (stake)
523+    then {
524+        let $t01067810744 = calcStakingFuncAndAddres(stake, assetId)
525+        let call = $t01067810744._1
526+        let stakingAddr = $t01067810744._2
527+        $Tuple4(call, stakingAddr, nil, [AttachedPayment(assetId, amount)])
528+        }
529+    else {
530+        let $t01083010896 = calcStakingFuncAndAddres(stake, assetId)
531+        let call = $t01083010896._1
532+        let stakingAddr = $t01083010896._2
533+        $Tuple4(call, stakingAddr, [amount, toBase58String(assetId)], nil)
534+        }
535+
536+
537+func stake (amount,assetIdString) = if (containsElement(stakingAssets, assetIdString))
538+    then {
539+        let $t01108311185 = calcStakingParams(true, amount, fromBase58String(assetIdString))
540+        let call = $t01108311185._1
541+        let addr = $t01108311185._2
542+        let params = $t01108311185._3
543+        let payments = $t01108311185._4
544+        invoke(addr, call, params, payments)
545+        }
546+    else 0
547+
548+
549+func unstake (amount,assetIdString) = if (containsElement(stakingAssets, assetIdString))
550+    then {
551+        let $t01137011473 = calcStakingParams(false, amount, fromBase58String(assetIdString))
552+        let call = $t01137011473._1
553+        let addr = $t01137011473._2
554+        let params = $t01137011473._3
555+        let payments = $t01137011473._4
556+        invoke(addr, call, params, payments)
557+        }
558+    else 0
559+
560+
561+func stakedAmount (assetId) = {
562+    let stakedAmountCalculated =     match assetId {
563+        case aId: ByteVector => 
564+            if ((aId == USDN))
565+                then getInteger(stakingUSDNAddress, ((("rpd_balance_" + toBase58String(aId)) + "_") + toString(this)))
566+                else 0
567+        case _: Unit => 
568+            0
569+        case _ => 
570+            throw("Match error")
571+    }
572+    match stakedAmountCalculated {
573+        case i: Int => 
574+            i
575+        case _ => 
576+            0
577+    }
578+    }
579+
580+
581+func checkSuspicious () = {
582+    let contractBalances = _xp()
583+    func checkBalance (acc,assetId) =     {
584+        let $t01208412109 = acc
585+        let suspicious = $t01208412109._1
586+        let i = $t01208412109._2
587+        if (suspicious)
588+            then $Tuple2(suspicious, i)
589+            else {
590+                let aBalance = (assetBalance(this, fromBase58String(assetId)) + stakedAmount(fromBase58String(assetId)))
591+                if ((contractBalances[i] > aBalance))
592+                    then $Tuple2(true, i)
593+                    else $Tuple2(false, (i + 1))
594+                }
595+        }
596+
597+    let $l = assetIds
598+    let $s = size($l)
599+    let $acc0 = $Tuple2(false, 0)
600+    func $f0_1 ($a,$i) =     if (($i >= $s))
601+        then $a
602+        else checkBalance($a, $l[$i])
603+
604+    func $f0_2 ($a,$i) =     if (($i >= $s))
605+        then $a
606+        else throw("List size exceeds 15")
607+
608+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
609+    }
610+
611+
612+func suspendSuspicious (i) = suspend(("Suspicious state with asset: " + assetIds[i]))
613+
614+
615+func returnPayments (caller,payments) = {
616+    func parsePayments (acc,payment) =     (acc :+ ScriptTransfer(caller, payment.amount, payment.assetId))
617+
618+    let $l = payments
619+    let $s = size($l)
620+    let $acc0 = nil
621+    func $f0_1 ($a,$i) =     if (($i >= $s))
622+        then $a
623+        else parsePayments($a, $l[$i])
624+
625+    func $f0_2 ($a,$i) =     if (($i >= $s))
626+        then $a
627+        else throw("List size exceeds 15")
628+
629+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
630+    }
631+
632+
633+func checkDAppThreshold (newBalances) = {
634+    let dAppThresholdCoef = valueOrErrorMessage(getInteger(this, kDAppThresholdCoef), "No dAppThresholdCoef key")
635+    let thresholdScale = 10000
636+    let maxBalance = max(newBalances)
637+    let minBalance = min(newBalances)
638+    let ratio = fraction(maxBalance, thresholdScale, minBalance)
639+    if ((ratio > (dAppThresholdCoef * thresholdScale)))
640+        then throw("New balance in assets of the DApp is less than threshold")
641+        else false
642+    }
643+
644+
645+func checkCoins (assetIds) = {
646+    let coins = split(assetIds, ",")
647+    func checkCoin (error,assetId) =     {
648+        let asset = valueOrErrorMessage(fromBase58String(assetId), ("fromBase58String: " + assetId))
649+        let decimals = valueOrErrorMessage(assetInfo(asset), ("assetInfo: " + assetId)).decimals
650+        if ((decimals != DECIMALS))
651+            then throw("wrong decimals")
652+            else false
653+        }
654+
655+    let $l = coins
656+    let $s = size($l)
657+    let $acc0 = false
658+    func $f0_1 ($a,$i) =     if (($i >= $s))
659+        then $a
660+        else checkCoin($a, $l[$i])
661+
662+    func $f0_2 ($a,$i) =     if (($i >= $s))
663+        then $a
664+        else throw("List size exceeds 15")
665+
666+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
667+    }
668+
669+
670+@Callable(msg)
671+func D (xp,amp) = {
672+    let D = get_D_internal(xp, amp)
673+    $Tuple2([IntegerEntry("D", D)], D)
674+    }
675+
676+
677+
678+@Callable(msg)
679+func init (assetIds,_A,_dAppThresholdCoef) = if (!(isDataStorageUntouched(this)))
680+    then throw("Already initialized")
681+    else if ((0 >= _A))
682+        then throw("Amp must be must > 0")
683+        else if ((0 >= _dAppThresholdCoef))
684+            then throw("dApp Threshold Coef must be > 0")
685+            else {
686+                let shareName = "multiUSDC"
687+                let shareDescription = ("ShareToken of SwopFi protocol for multi-stable USDC pool at address " + toString(this))
688+                let issueToken = Issue(shareName, shareDescription, 0, 6, true)
689+                let tokenId = calculateAssetId(issueToken)
690+                if (checkCoins(assetIds))
691+                    then throw()
692+                    else [StringEntry(kVersion, version), StringEntry(kAssets, assetIds), IntegerEntry("initial_A", _A), IntegerEntry("future_A", _A), IntegerEntry(kFee, getIntegerValue(oracle, "base_fee_flat")), StringEntry(kShareAssetId, toBase58String(tokenId)), IntegerEntry(kShareAssetSupply, 0), IntegerEntry(kDAppThresholdCoef, _dAppThresholdCoef), BooleanEntry(kActive, true), issueToken]
693+                }
694+
695+
696+
697+@Callable(msg)
698+func addLiquidity (minMintAmount,stakeFarming) = valueOrElse(isActive(), {
699+    let amp = _A()
700+    let xp = _xp()
701+    let D0 = if ((shareSupply == 0))
702+        then 0
703+        else getDMem(xp, amp)
704+    let payments = msg.payments
705+    let paymentsSize = size(payments)
706+    func validPayments (n) =     if ((paymentsSize > nCoins))
707+        then throw(("payments size > " + toString(nCoins)))
708+        else if ((1 > paymentsSize))
709+            then throw("payments size < 1")
710+            else if (if ((shareSupply == 0))
711+                then (nCoins != paymentsSize)
712+                else false)
713+                then throw("initial deposit requires all coins")
714+                else {
715+                    func paymantValid (acc,payment) =                     if (containsElement(assetIds, getStrAssetId(payment.assetId)))
716+                        then true
717+                        else throw("Invalid asset in payment")
718+
719+                    let $l = payments
720+                    let $s = size($l)
721+                    let $acc0 = false
722+                    func $f0_1 ($a,$i) =                     if (($i >= $s))
723+                        then $a
724+                        else paymantValid($a, $l[$i])
725+
726+                    func $f0_2 ($a,$i) =                     if (($i >= $s))
727+                        then $a
728+                        else throw("List size exceeds 15")
729+
730+                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
731+                    }
732+
733+    if (!(validPayments(paymentsSize)))
734+        then throw()
735+        else {
736+            let suspicious = checkSuspicious()
737+            if (suspicious._1)
738+                then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.caller, payments))
739+                else {
740+                    func parsePayments (acc,assetId) =                     {
741+                        let $t01612516154 = acc
742+                        let newBalances = $t01612516154._1
743+                        let i = $t01612516154._2
744+                        let j = $t01612516154._3
745+                        if (if ((paymentsSize > j))
746+                            then (getStrAssetId(payments[j].assetId) == assetId)
747+                            else false)
748+                            then $Tuple3((newBalances :+ (xp[i] + payments[j].amount)), (i + 1), (j + 1))
749+                            else $Tuple3((newBalances :+ xp[i]), (i + 1), j)
750+                        }
751+
752+                    let $t01637416460 = {
753+                        let $l = assetIds
754+                        let $s = size($l)
755+                        let $acc0 = $Tuple3(nil, 0, 0)
756+                        func $f0_1 ($a,$i) =                         if (($i >= $s))
757+                            then $a
758+                            else parsePayments($a, $l[$i])
759+
760+                        func $f0_2 ($a,$i) =                         if (($i >= $s))
761+                            then $a
762+                            else throw("List size exceeds 15")
763+
764+                        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
765+                        }
766+                    let newBalances = $t01637416460._1
767+                    let k = $t01637416460._2
768+                    let parsedPayments = $t01637416460._3
769+                    if ((paymentsSize > parsedPayments))
770+                        then throw("Incorect payments order")
771+                        else if (checkDAppThreshold(newBalances))
772+                            then throw()
773+                            else {
774+                                let D1 = getDMem(newBalances, amp)
775+                                if (assert((D1 > D0)))
776+                                    then throw("D1 > D0")
777+                                    else {
778+                                        let feeDiscount = calculateFeeDiscount(msg.caller)
779+                                        func calcScriptActions (acc,newBalance) =                                         {
780+                                            let $t01686116902 = acc
781+                                            let invBalances = $t01686116902._1
782+                                            let scriptActions = $t01686116902._2
783+                                            let i = $t01686116902._3
784+                                            if ((shareSupply > 0))
785+                                                then {
786+                                                    let _fee = ((fraction(fee, feeDiscount, feeScale6, CEILING) * nCoins) / (4 * (nCoins - 1)))
787+                                                    let fees = {
788+                                                        let idealBalance = fraction(D1, xp[i], D0)
789+                                                        let difference = if ((idealBalance > newBalance))
790+                                                            then (idealBalance - newBalance)
791+                                                            else (newBalance - idealBalance)
792+                                                        fraction(_fee, difference, feeScale6)
793+                                                        }
794+                                                    let governanceFees = fraction(fees, feeGovernance, feeScale6)
795+                                                    let finalBalance = (newBalance - fees)
796+                                                    let invariantBalance = (newBalance - fees)
797+                                                    let pmt = (newBalance - xp[i])
798+                                                    let lpFees = (fees - governanceFees)
799+                                                    let inv = if ((pmt > 0))
800+                                                        then stake((pmt - fees), assetIds[i])
801+                                                        else unstake(fees, assetIds[i])
802+                                                    if ((inv == inv))
803+                                                        then {
804+                                                            let airdrop = if ((lpFees > 0))
805+                                                                then invoke(lpFarmingAddress, "airDrop", nil, [AttachedPayment(fromBase58String(assetIds[i]), lpFees)])
806+                                                                else 0
807+                                                            if ((airdrop == airdrop))
808+                                                                then $Tuple3((invBalances :+ invariantBalance), (scriptActions ++ [ScriptTransfer(moneyBoxAddress, governanceFees, fromBase58String(assetIds[i])), IntegerEntry((assetIds[i] + kAssetBalance), finalBalance)]), (i + 1))
809+                                                                else throw("Strict value is not equal to itself.")
810+                                                            }
811+                                                        else throw("Strict value is not equal to itself.")
812+                                                    }
813+                                                else {
814+                                                    let inv = stake(newBalance, assetIds[i])
815+                                                    if ((inv == inv))
816+                                                        then $Tuple3((invBalances :+ newBalance), (scriptActions :+ IntegerEntry((assetIds[i] + kAssetBalance), newBalance)), (i + 1))
817+                                                        else throw("Strict value is not equal to itself.")
818+                                                    }
819+                                            }
820+
821+                                        let $t01860718695 = {
822+                                            let $l = newBalances
823+                                            let $s = size($l)
824+                                            let $acc0 = $Tuple3(nil, nil, 0)
825+                                            func $f1_1 ($a,$i) =                                             if (($i >= $s))
826+                                                then $a
827+                                                else calcScriptActions($a, $l[$i])
828+
829+                                            func $f1_2 ($a,$i) =                                             if (($i >= $s))
830+                                                then $a
831+                                                else throw("List size exceeds 15")
832+
833+                                            $f1_2($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($f1_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
834+                                            }
835+                                        let invBalances = $t01860718695._1
836+                                        let scriptActions = $t01860718695._2
837+                                        let D2 = getDMem(invBalances, amp)
838+                                        let mint_amount = if ((shareSupply == 0))
839+                                            then D1
840+                                            else fraction(shareSupply, (D2 - D0), D0)
841+                                        if (assert((mint_amount >= minMintAmount)))
842+                                            then throw("Slippage screwed you")
843+                                            else if (stakeFarming)
844+                                                then {
845+                                                    let re = invoke(this, "reissueShare", [mint_amount], nil)
846+                                                    if ((re == re))
847+                                                        then {
848+                                                            let s = invoke(farmingAddress, "lockShareTokens", [toString(this)], [AttachedPayment(shareAssetId, mint_amount)])
849+                                                            if ((s == s))
850+                                                                then (scriptActions :+ IntegerEntry(kShareAssetSupply, (shareSupply + mint_amount)))
851+                                                                else throw("Strict value is not equal to itself.")
852+                                                            }
853+                                                        else throw("Strict value is not equal to itself.")
854+                                                    }
855+                                                else (scriptActions ++ [Reissue(shareAssetId, mint_amount, true), ScriptTransfer(msg.caller, mint_amount, shareAssetId), IntegerEntry(kShareAssetSupply, (shareSupply + mint_amount))])
856+                                        }
857+                                }
858+                    }
859+            }
860+    })
861+
862+
863+
864+@Callable(msg)
865+func calcMintAmount (newBalances,user) = {
866+    let amp = _A()
867+    let xp = _xp()
868+    let D1 = getDMem(newBalances, amp)
869+    if ((shareSupply == 0))
870+        then $Tuple2(nil, D1)
871+        else {
872+            let D0 = getDMem(xp, amp)
873+            let feeDiscount = calculateFeeDiscount(user)
874+            func calcInvBalances (acc,newBalance) =             {
875+                let $t01988419910 = acc
876+                let invBalances = $t01988419910._1
877+                let i = $t01988419910._2
878+                let _fee = ((fraction(fee, feeDiscount, feeScale6, CEILING) * nCoins) / (4 * (nCoins - 1)))
879+                let fees = {
880+                    let idealBalance = fraction(D1, xp[i], D0)
881+                    let difference = if ((idealBalance > newBalance))
882+                        then (idealBalance - newBalance)
883+                        else (newBalance - idealBalance)
884+                    fraction(_fee, difference, feeScale6)
885+                    }
886+                let invariantBalance = (newBalance - fees)
887+                $Tuple2((invBalances :+ invariantBalance), (i + 1))
888+                }
889+
890+            let $t02051220582 = {
891+                let $l = newBalances
892+                let $s = size($l)
893+                let $acc0 = $Tuple2(nil, 0)
894+                func $f0_1 ($a,$i) =                 if (($i >= $s))
895+                    then $a
896+                    else calcInvBalances($a, $l[$i])
897+
898+                func $f0_2 ($a,$i) =                 if (($i >= $s))
899+                    then $a
900+                    else throw("List size exceeds 15")
901+
902+                $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
903+                }
904+            let invBalances = $t02051220582._1
905+            let k = $t02051220582._2
906+            let D2 = getDMem(invBalances, amp)
907+            let mintAmount = fraction(shareSupply, (D2 - D0), D0)
908+            $Tuple2(nil, mintAmount)
909+            }
910+    }
911+
912+
913+
914+@Callable(msg)
915+func reissueShare (amount) = valueOrElse(isSelfCall(msg), [Reissue(shareAssetId, amount, true)])
916+
917+
918+
919+@Callable(msg)
920+func getDy (assetFrom,assetTo,dx,userAddress) = {
921+    let xp = _xp()
922+    let fromIndex = valueOrErrorMessage(indexOf(assetIds, assetFrom), "unknown token in")
923+    let toIndex = valueOrErrorMessage(indexOf(assetIds, assetTo), "unknown token out")
924+    let x = (xp[fromIndex] + dx)
925+    let y = getY(fromIndex, toIndex, x, xp)
926+    let dy = ((xp[toIndex] - y) - 1)
927+    let feeDiscount = calculateFeeDiscount(Address(fromBase58String(userAddress)))
928+    let _fee = fraction(fraction(fee, feeDiscount, feeScale6, CEILING), dy, feeScale6)
929+    $Tuple2(nil, $Tuple2((dy - _fee), _fee))
930+    }
931+
932+
933+
934+@Callable(msg)
935+func exchange (tokenOut,min_dy) = valueOrElse(isActive(), if ((size(msg.payments) != 1))
936+    then throw("size(payments) != 1")
937+    else {
938+        let suspicious = checkSuspicious()
939+        if (suspicious._1)
940+            then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.caller, msg.payments))
941+            else {
942+                let payment = msg.payments[0]
943+                let tokenIn = getStrAssetId(payment.assetId)
944+                let tokenOutB58 = fromBase58String(tokenOut)
945+                let dx = payment.amount
946+                let fromIndex = valueOrErrorMessage(indexOf(assetIds, tokenIn), "unknown token in")
947+                let toIndex = valueOrErrorMessage(indexOf(assetIds, tokenOut), "unknown token out")
948+                let xp = _xp()
949+                let x = (xp[fromIndex] + dx)
950+                let y = getY(fromIndex, toIndex, x, xp)
951+                let _dy = ((xp[toIndex] - y) - 1)
952+                let feeDiscount = calculateFeeDiscount(msg.originCaller)
953+                let _fee = fraction(_dy, fraction(fee, feeDiscount, feeScale6, CEILING), feeScale6)
954+                let dy = (_dy - _fee)
955+                let governanceFees = fraction(_fee, feeGovernance, feeScale6)
956+                if (assert((dy >= min_dy)))
957+                    then throw("Exchange resulted in fewer coins than expected")
958+                    else {
959+                        func makeNewBalances (acc,tokenBalance) =                         {
960+                            let $t02262322649 = acc
961+                            let newBalances = $t02262322649._1
962+                            let i = $t02262322649._2
963+                            if ((i == fromIndex))
964+                                then $Tuple2((newBalances :+ (tokenBalance + dx)), (i + 1))
965+                                else if ((i == toIndex))
966+                                    then $Tuple2((newBalances :+ (tokenBalance - _dy)), (i + 1))
967+                                    else $Tuple2((newBalances :+ tokenBalance), (i + 1))
968+                            }
969+
970+                        let $t02290022961 = {
971+                            let $l = xp
972+                            let $s = size($l)
973+                            let $acc0 = $Tuple2(nil, 0)
974+                            func $f0_1 ($a,$i) =                             if (($i >= $s))
975+                                then $a
976+                                else makeNewBalances($a, $l[$i])
977+
978+                            func $f0_2 ($a,$i) =                             if (($i >= $s))
979+                                then $a
980+                                else throw("List size exceeds 15")
981+
982+                            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
983+                            }
984+                        let newBalances = $t02290022961._1
985+                        let i = $t02290022961._2
986+                        if (checkDAppThreshold(newBalances))
987+                            then throw()
988+                            else {
989+                                let s = stake(payment.amount, getStrAssetId(payment.assetId))
990+                                if ((s == s))
991+                                    then {
992+                                        let us = unstake(_dy, tokenOut)
993+                                        if ((us == us))
994+                                            then {
995+                                                let lpFees = (_fee - governanceFees)
996+                                                let airdrop = if ((lpFees > 0))
997+                                                    then invoke(lpFarmingAddress, "airDrop", nil, [AttachedPayment(tokenOutB58, lpFees)])
998+                                                    else 0
999+                                                if ((airdrop == airdrop))
1000+                                                    then $Tuple2([IntegerEntry((tokenIn + kAssetBalance), x), IntegerEntry((tokenOut + kAssetBalance), (xp[toIndex] - _dy)), ScriptTransfer(msg.caller, dy, tokenOutB58), ScriptTransfer(moneyBoxAddress, governanceFees, tokenOutB58)], [dy, tokenOutB58])
1001+                                                    else throw("Strict value is not equal to itself.")
1002+                                                }
1003+                                            else throw("Strict value is not equal to itself.")
1004+                                        }
1005+                                    else throw("Strict value is not equal to itself.")
1006+                                }
1007+                        }
1008+                }
1009+        })
1010+
1011+
1012+
1013+@Callable(msg)
1014+func withdraw (minAmounts) = valueOrElse(isActive(), if ((size(msg.payments) != 1))
1015+    then throw("size(payments) != 1")
1016+    else {
1017+        let pmtAmount = msg.payments[0].amount
1018+        let pmtAssetId = msg.payments[0].assetId
1019+        if ((shareAssetId != pmtAssetId))
1020+            then throw("unknown payment token")
1021+            else {
1022+                let suspicious = checkSuspicious()
1023+                if (suspicious._1)
1024+                    then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.originCaller, msg.payments))
1025+                    else {
1026+                        func calcScriptActions (acc,balance) =                         {
1027+                            let $t02425224280 = acc
1028+                            let scriptActions = $t02425224280._1
1029+                            let i = $t02425224280._2
1030+                            let wAmount = fraction(balance, pmtAmount, shareSupply)
1031+                            if (assert((wAmount >= minAmounts[i])))
1032+                                then throw("Withdrawal resulted in fewer coins than expected")
1033+                                else {
1034+                                    let us = unstake(wAmount, assetIds[i])
1035+                                    if ((us == us))
1036+                                        then $Tuple2((scriptActions ++ [IntegerEntry((assetIds[i] + kAssetBalance), (balance - wAmount)), ScriptTransfer(msg.originCaller, wAmount, fromBase58String(assetIds[i]))]), (i + 1))
1037+                                        else throw("Strict value is not equal to itself.")
1038+                                    }
1039+                            }
1040+
1041+                        let $t02477024838 = {
1042+                            let $l = _xp()
1043+                            let $s = size($l)
1044+                            let $acc0 = $Tuple2(nil, 0)
1045+                            func $f0_1 ($a,$i) =                             if (($i >= $s))
1046+                                then $a
1047+                                else calcScriptActions($a, $l[$i])
1048+
1049+                            func $f0_2 ($a,$i) =                             if (($i >= $s))
1050+                                then $a
1051+                                else throw("List size exceeds 15")
1052+
1053+                            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
1054+                            }
1055+                        let scriptActions = $t02477024838._1
1056+                        let i = $t02477024838._2
1057+                        (scriptActions ++ [Burn(shareAssetId, pmtAmount), IntegerEntry(kShareAssetSupply, (shareSupply - pmtAmount))])
1058+                        }
1059+                }
1060+        })
1061+
1062+
1063+
1064+@Callable(msg)
1065+func withdrawWithUnlock (minAmounts,unlockAmount) = valueOrElse(isActive(), if ((0 >= unlockAmount))
1066+    then throw("Unlock amount must be positive")
1067+    else {
1068+        let suspicious = checkSuspicious()
1069+        if (suspicious._1)
1070+            then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.caller, msg.payments))
1071+            else {
1072+                let pmtAmount = if ((size(msg.payments) > 0))
1073+                    then if ((size(msg.payments) != 1))
1074+                        then throw("size(payments) != 1")
1075+                        else {
1076+                            let pmtAssetId = msg.payments[0].assetId
1077+                            if ((shareAssetId != pmtAssetId))
1078+                                then throw("unknown payment token")
1079+                                else msg.payments[0].amount
1080+                            }
1081+                    else 0
1082+                let unlock = invoke(farmingAddress, "withdrawShareTokens", [toString(this), unlockAmount], nil)
1083+                if ((unlock == unlock))
1084+                    then {
1085+                        let withdrawAmount = (pmtAmount + unlockAmount)
1086+                        let inv = invoke(this, "withdraw", [minAmounts], [AttachedPayment(shareAssetId, withdrawAmount)])
1087+                        if ((inv == inv))
1088+                            then nil
1089+                            else throw("Strict value is not equal to itself.")
1090+                        }
1091+                    else throw("Strict value is not equal to itself.")
1092+                }
1093+        })
1094+
1095+
1096+
1097+@Callable(msg)
1098+func calcWithdrawOneCoin (tokenAmount,tokenOut,user) = {
1099+    let i = valueOrErrorMessage(indexOf(assetIds, tokenOut), "unknown token out")
1100+    $Tuple2(nil, _calcWithdrawOneCoin(_xp(), tokenAmount, i, Address(fromBase58String(user)))._1)
1101+    }
1102+
1103+
1104+
1105+@Callable(msg)
1106+func withdrawOneCoin (tokenOut,minAmount) = valueOrElse(isActive(), if ((size(msg.payments) != 1))
1107+    then throw("size(payments) != 1")
1108+    else {
1109+        let suspicious = checkSuspicious()
1110+        if (suspicious._1)
1111+            then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.originCaller, msg.payments))
1112+            else {
1113+                let pmtAmount = msg.payments[0].amount
1114+                let pmtAssetId = msg.payments[0].assetId
1115+                if ((pmtAssetId != shareAssetId))
1116+                    then throw("unknown token")
1117+                    else {
1118+                        let outIndex = valueOrErrorMessage(indexOf(assetIds, tokenOut), "unknown token out")
1119+                        let tokenOutB58 = fromBase58String(tokenOut)
1120+                        let xp = _xp()
1121+                        let $t02680226884 = _calcWithdrawOneCoin(xp, pmtAmount, outIndex, msg.originCaller)
1122+                        let dy = $t02680226884._1
1123+                        let dy_fee = $t02680226884._2
1124+                        if (assert((dy >= minAmount)))
1125+                            then throw("Not enough coins removed")
1126+                            else {
1127+                                let governanceFees = fraction(dy_fee, feeGovernance, feeScale6)
1128+                                let dy_and_fee = (dy + dy_fee)
1129+                                func makeNewBalances (acc,tokenBalance) =                                 {
1130+                                    let $t02714227168 = acc
1131+                                    let newBalances = $t02714227168._1
1132+                                    let i = $t02714227168._2
1133+                                    if ((i == outIndex))
1134+                                        then $Tuple2((newBalances :+ (tokenBalance - dy_and_fee)), (i + 1))
1135+                                        else $Tuple2((newBalances :+ tokenBalance), (i + 1))
1136+                                    }
1137+
1138+                                let $t02733527396 = {
1139+                                    let $l = xp
1140+                                    let $s = size($l)
1141+                                    let $acc0 = $Tuple2(nil, 0)
1142+                                    func $f0_1 ($a,$i) =                                     if (($i >= $s))
1143+                                        then $a
1144+                                        else makeNewBalances($a, $l[$i])
1145+
1146+                                    func $f0_2 ($a,$i) =                                     if (($i >= $s))
1147+                                        then $a
1148+                                        else throw("List size exceeds 15")
1149+
1150+                                    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
1151+                                    }
1152+                                let newBalances = $t02733527396._1
1153+                                let v = $t02733527396._2
1154+                                if (checkDAppThreshold(newBalances))
1155+                                    then throw()
1156+                                    else {
1157+                                        let us = unstake(dy_and_fee, tokenOut)
1158+                                        if ((us == us))
1159+                                            then {
1160+                                                let lpFees = (dy_fee - governanceFees)
1161+                                                let airdrop = if ((lpFees > 0))
1162+                                                    then invoke(lpFarmingAddress, "airDrop", nil, [AttachedPayment(tokenOutB58, lpFees)])
1163+                                                    else 0
1164+                                                if ((airdrop == airdrop))
1165+                                                    then [ScriptTransfer(msg.originCaller, dy, tokenOutB58), IntegerEntry((assetIds[outIndex] + kAssetBalance), (xp[outIndex] - dy_and_fee)), Burn(shareAssetId, pmtAmount), ScriptTransfer(moneyBoxAddress, governanceFees, tokenOutB58), IntegerEntry(kShareAssetSupply, (shareSupply - pmtAmount))]
1166+                                                    else throw("Strict value is not equal to itself.")
1167+                                                }
1168+                                            else throw("Strict value is not equal to itself.")
1169+                                        }
1170+                                }
1171+                        }
1172+                }
1173+        })
1174+
1175+
1176+
1177+@Callable(msg)
1178+func withdrawOneCoinWithUnlock (tokenOut,minAmount,unlockAmount) = valueOrElse(isActive(), if ((0 >= unlockAmount))
1179+    then throw("Unlock amount must be positive")
1180+    else {
1181+        let suspicious = checkSuspicious()
1182+        if (suspicious._1)
1183+            then (suspendSuspicious(suspicious._2) ++ returnPayments(msg.caller, msg.payments))
1184+            else {
1185+                let pmtAmount = if ((size(msg.payments) > 0))
1186+                    then if ((size(msg.payments) != 1))
1187+                        then throw("size(payments) != 1")
1188+                        else {
1189+                            let pmtAssetId = msg.payments[0].assetId
1190+                            if ((shareAssetId != pmtAssetId))
1191+                                then throw("unknown payment token")
1192+                                else msg.payments[0].amount
1193+                            }
1194+                    else 0
1195+                let unlock = invoke(farmingAddress, "withdrawShareTokens", [toString(this), unlockAmount], nil)
1196+                if ((unlock == unlock))
1197+                    then {
1198+                        let withdrawAmount = (pmtAmount + unlockAmount)
1199+                        let inv = invoke(this, "withdrawOneCoin", [tokenOut, minAmount], [AttachedPayment(shareAssetId, withdrawAmount)])
1200+                        if ((inv == inv))
1201+                            then nil
1202+                            else throw("Strict value is not equal to itself.")
1203+                        }
1204+                    else throw("Strict value is not equal to itself.")
1205+                }
1206+        })
1207+
1208+
1209+
1210+@Callable(msg)
1211+func A () = $Tuple2(nil, _A())
1212+
1213+
1214+
1215+@Callable(msg)
1216+func getVirtualPrice () = {
1217+    let D = get_D(_xp(), _A())
1218+    $Tuple2(nil, fraction(D, PRECISION, shareSupply))
1219+    }
1220+
1221+
1222+
1223+@Callable(msg)
1224+func calcTokenAmount (amounts,deposit) = {
1225+    let amp = _A()
1226+    let balances = _xp()
1227+    let D0 = getDMem(balances, amp)
1228+    func calcNewBalances (acc,balance) =     {
1229+        let $t02941329439 = acc
1230+        let newBalances = $t02941329439._1
1231+        let i = $t02941329439._2
1232+        let newBalance = (balance + (if (deposit)
1233+            then amounts[i]
1234+            else -(amounts[i])))
1235+        $Tuple2((newBalances :+ newBalance), (i + 1))
1236+        }
1237+
1238+    let newBalances = (    let $l = balances
1239+    let $s = size($l)
1240+    let $acc0 = $Tuple2(nil, 0)
1241+    func $f0_1 ($a,$i) =     if (($i >= $s))
1242+        then $a
1243+        else calcNewBalances($a, $l[$i])
1244+
1245+    func $f0_2 ($a,$i) =     if (($i >= $s))
1246+        then $a
1247+        else throw("List size exceeds 15")
1248+
1249+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15))._1
1250+    let D1 = getDMem(newBalances, amp)
1251+    let diff = if (deposit)
1252+        then (D1 - D0)
1253+        else (D0 - D1)
1254+    $Tuple2(nil, fraction(diff, shareSupply, D0))
1255+    }
1256+
1257+
1258+
1259+@Callable(msg)
1260+func rampA (_futureA,_futureTime) = valueOrElse(isActive(), valueOrElse(isAdminCall(msg), if (assert((blockTimestamp >= (initial_A_time + MIN_RAMP_TIME))))
1261+    then throw("too often")
1262+    else if (assert((_futureTime >= (blockTimestamp + MIN_RAMP_TIME))))
1263+        then throw("insufficient time")
1264+        else {
1265+            let _initial_A = _A()
1266+            if (assert(if ((_futureA > 0))
1267+                then (MAX_A > _futureA)
1268+                else false))
1269+                then throw("out of base range")
1270+                else if (assert(if (if ((_futureA >= _initial_A))
1271+                    then ((_initial_A * MAX_A_CHANGE) >= _futureA)
1272+                    else false)
1273+                    then true
1274+                    else if ((_initial_A > _futureA))
1275+                        then ((_futureA * MAX_A_CHANGE) >= _initial_A)
1276+                        else false))
1277+                    then throw("out of range")
1278+                    else [IntegerEntry("initial_A", _initial_A), IntegerEntry("future_A", _futureA), IntegerEntry("initial_A_time", blockTimestamp), IntegerEntry("future_A_time", _futureTime)]
1279+            }))
1280+
1281+
1282+
1283+@Callable(msg)
1284+func stopRampA () = valueOrElse(isActive(), valueOrElse(isAdminCall(msg), {
1285+    let currentA = _A()
1286+[IntegerEntry("initial_A", currentA), IntegerEntry("future_A", currentA), IntegerEntry("initial_A_time", blockTimestamp), IntegerEntry("future_A_time", blockTimestamp)]
1287+    }))
1288+
1289+
1290+
1291+@Callable(msg)
1292+func shutdown () = valueOrElse(isAdminCall(msg), if (!(active))
1293+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, kCause), "the cause wasn't specified")))
1294+    else suspend("Paused by admin"))
1295+
1296+
1297+
1298+@Callable(msg)
1299+func activate () = valueOrElse(isAdminCall(msg), if (active)
1300+    then throwIsActive()
1301+    else [BooleanEntry(kActive, true), DeleteEntry(kCause)])
1302+
1303+
1304+
1305+@Callable(msg)
1306+func takeIntoAccountExtraFunds () = valueOrElse(isActive(), if ((msg.caller != moneyBoxAddress))
1307+    then throw("Only the wallet can call this function")
1308+    else {
1309+        let balances = _xp()
1310+        func takeExtraFunds (acc,assetId) =         {
1311+            let $t03178131799 = acc
1312+            let sum = $t03178131799._1
1313+            let i = $t03178131799._2
1314+            let tokenB58 = fromBase58String(assetId)
1315+            let rBalance = (assetBalance(this, tokenB58) + stakedAmount(tokenB58))
1316+            let enrollAmount = (rBalance - balances[i])
1317+            if ((0 > enrollAmount))
1318+                then suspend(("Enroll amount negative for asset" + assetId))
1319+                else {
1320+                    let airdrop = if ((enrollAmount > 0))
1321+                        then invoke(lpFarmingAddress, "airDrop", nil, [AttachedPayment(tokenB58, enrollAmount)])
1322+                        else 0
1323+                    if ((airdrop == airdrop))
1324+                        then $Tuple2((sum + enrollAmount), (i + 1))
1325+                        else throw("Strict value is not equal to itself.")
1326+                    }
1327+            }
1328+
1329+        let k = {
1330+            let $l = assetIds
1331+            let $s = size($l)
1332+            let $acc0 = $Tuple2(0, 0)
1333+            func $f0_1 ($a,$i) =             if (($i >= $s))
1334+                then $a
1335+                else takeExtraFunds($a, $l[$i])
1336+
1337+            func $f0_2 ($a,$i) =             if (($i >= $s))
1338+                then $a
1339+                else throw("List size exceeds 15")
1340+
1341+            $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15)
1342+            }
1343+        if ((k._1 == 0))
1344+            then throw("No money to take")
1345+            else nil
1346+        })
1347+
1348+
1349+@Verifier(tx)
1350+func verify () = {
1351+    let multiSignedByAdmins = {
1352+        let adminPubKey1Signed = if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
1353+            then 1
1354+            else 0
1355+        let adminPubKey2Signed = if (sigVerify(tx.bodyBytes, tx.proofs[1], adminPubKey2))
1356+            then 1
1357+            else 0
1358+        let adminPubKey3Signed = if (sigVerify(tx.bodyBytes, tx.proofs[2], adminPubKey3))
1359+            then 1
1360+            else 0
1361+        (((adminPubKey1Signed + adminPubKey2Signed) + adminPubKey3Signed) >= 2)
1362+        }
1363+    match tx {
1364+        case inv: InvokeScriptTransaction => 
1365+            let callTakeIntoAccount = if ((inv.dApp == this))
1366+                then (inv.function == "takeIntoAccountExtraFunds")
1367+                else false
1368+            let signedByAdmin = if (if (if (sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey1))
1369+                then true
1370+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey2))
1371+                then true
1372+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKey3))
1373+                then true
1374+                else sigVerify(tx.bodyBytes, tx.proofs[0], adminPubKeyInvoke)
1375+            if (if (callTakeIntoAccount)
1376+                then signedByAdmin
1377+                else false)
1378+                then true
1379+                else multiSignedByAdmins
1380+        case _ => 
1381+            multiSignedByAdmins
1382+    }
1383+    }
1384+
github/deemru/w8io/873ac7e 
122.82 ms ◑