tx · 9pcBoNpCF3hhNnNfYGwDdUG8coh6GcVfQ57fL1yRaQa6

3MvMXhKFMPz4BuZj9Jr9UysuxbWFKRJZgb3:  -0.10000000 Waves

2022.10.11 15:26 [2267670] smart account 3MvMXhKFMPz4BuZj9Jr9UysuxbWFKRJZgb3 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9pcBoNpCF3hhNnNfYGwDdUG8coh6GcVfQ57fL1yRaQa6",
    "fee": 10000000,
    "feeAssetId": null,
    "timestamp": 1665491203063,
    "version": 2,
    "chainId": 84,
    "sender": "3MvMXhKFMPz4BuZj9Jr9UysuxbWFKRJZgb3",
    "senderPublicKey": "DsnSbWaHh9UERrdY9ujfzmjph8zAbKdZPnUkX2hHFAZw",
    "proofs": [
        "3XgPo2uDnZaR8a2jCHJ5RbDRs9nEXvp7ri5dpodbmoyJFYKcnNvSqk9FdvAJLA4XC9DsxefJqzBmZrf5CpyBxhqE"
    ],
    "script": "base64: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",
    "height": 2267670,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 9itcGq1XDaRgbivt1FoQBwZx9yK2LpKJeBkrJf75at3J

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "2.0.0"
5+
6+let b = "version"
7+
8+let c = "active"
9+
10+let d = "A_asset_id"
11+
12+let e = "B_asset_id"
13+
14+let f = "A_asset_balance"
15+
16+let g = "B_asset_balance"
17+
18+let h = "share_asset_id"
19+
20+let i = "share_asset_supply"
21+
22+let j = "commission"
23+
24+let k = "invariant"
25+
26+let l = "shutdown_cause"
27+
28+let m = "staking_usdnnsbt_address"
29+
30+let n = "staking_eurn_address"
31+
32+let o = "discounts"
33+
34+let p = "discount_values"
35+
36+let q = "_SWOP_amount"
37+
38+let r = "first_harvest"
39+
40+let s = "first_harvest_height"
41+
42+let t = "share_limit_on_first_harvest"
43+
44+let u = "base_period"
45+
46+let v = "period_length"
47+
48+let w = "start_height"
49+
50+let x = "admin_pub_1"
51+
52+let y = "admin_pub_2"
53+
54+let z = "admin_pub_3"
55+
56+let A = "admin_invoke_pub"
57+
58+let B = "money_box_address"
59+
60+let C = "governance_address"
61+
62+let D = "voting_address"
63+
64+let E = Address(base58'3MvVBtsXroQpy1tsPw21TU2ET9A8WfmrNjz')
65+
66+func F (G) = {
67+    let H = getString(E, G)
68+    if ($isInstanceOf(H, "String"))
69+        then {
70+            let I = H
71+            fromBase58String(I)
72+            }
73+        else {
74+            let J = H
75+            throw((G + "is empty"))
76+            }
77+    }
78+
79+
80+let K = F(x)
81+
82+let L = F(y)
83+
84+let M = F(z)
85+
86+let N = F(A)
87+
88+let O = Address(F(B))
89+
90+let P = Address(F(C))
91+
92+let Q = Address(F(m))
93+
94+let R = Address(F(D))
95+
96+let S = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
97+
98+let T = [toBase58String(S)]
99+
100+let U = valueOrErrorMessage(getInteger(R, u), "Empty kBasePeriod")
101+
102+let V = valueOrErrorMessage(getInteger(R, w), "Empty kStartHeight")
103+
104+let W = valueOrErrorMessage(getInteger(R, v), "Empty kPeriodLength")
105+
106+let X = ((U + ((height - V) / W)) + 3)
107+
108+let Y = getBooleanValue(this, c)
109+
110+let Z = getStringValue(this, d)
111+
112+let aa = getStringValue(this, e)
113+
114+let ab = if ((Z == "WAVES"))
115+    then unit
116+    else fromBase58String(Z)
117+
118+let ac = if ((aa == "WAVES"))
119+    then unit
120+    else fromBase58String(aa)
121+
122+let ad = {
123+    let H = ab
124+    if ($isInstanceOf(H, "ByteVector"))
125+        then {
126+            let ae = H
127+            value(assetInfo(ae)).name
128+            }
129+        else if ($isInstanceOf(H, "Unit"))
130+            then {
131+                let af = H
132+                "WAVES"
133+                }
134+            else throw("Match error")
135+    }
136+
137+let ag = {
138+    let H = ac
139+    if ($isInstanceOf(H, "ByteVector"))
140+        then {
141+            let ae = H
142+            value(assetInfo(ae)).name
143+            }
144+        else if ($isInstanceOf(H, "Unit"))
145+            then {
146+                let af = H
147+                "WAVES"
148+                }
149+            else throw("Match error")
150+    }
151+
152+let ah = getIntegerValue(this, f)
153+
154+let ai = getIntegerValue(this, g)
155+
156+let aj = fromBase58String(getStringValue(this, h))
157+
158+let ak = getIntegerValue(this, i)
159+
160+let al = getIntegerValue(this, k)
161+
162+let am = getIntegerValue(this, j)
163+
164+let an = fraction(am, 40, 100)
165+
166+let ao = 1000000
167+
168+let ap = 1000
169+
170+let aq = 100000000
171+
172+let ar = 10000000000000000
173+
174+let as = 1000
175+
176+let at = 8
177+
178+let au = 50
179+
180+let av = 100
181+
182+let aw = 90000000
183+
184+let ax = 110000000
185+
186+let ay = 50
187+
188+let az = 2
189+
190+let aA = 4600000000000000
191+
192+func aB (aC) = {
193+    let H = aC
194+    if ($isInstanceOf(H, "ByteVector"))
195+        then {
196+            let ae = H
197+            assetBalance(this, ae)
198+            }
199+        else if ($isInstanceOf(H, "Unit"))
200+            then {
201+                let af = H
202+                wavesBalance(this).available
203+                }
204+            else throw("Match error")
205+    }
206+
207+
208+func aD (aC) = {
209+    let aE = {
210+        let H = aC
211+        if ($isInstanceOf(H, "ByteVector"))
212+            then {
213+                let aF = H
214+                if ((aF == S))
215+                    then getInteger(Q, ((("rpd_balance_" + toBase58String(aF)) + "_") + toString(this)))
216+                    else 0
217+                }
218+            else if ($isInstanceOf(H, "Unit"))
219+                then 0
220+                else throw("Match error")
221+        }
222+    let H = aE
223+    if ($isInstanceOf(H, "Int"))
224+        then {
225+            let aG = H
226+            aG
227+            }
228+        else 0
229+    }
230+
231+
232+let aH = aD(ab)
233+
234+let aI = aD(ac)
235+
236+let aJ = (ah - aH)
237+
238+let aK = (ai - aI)
239+
240+let aL = (aB(ab) + aH)
241+
242+let aM = (aB(ac) + aI)
243+
244+let aN = if ((aL >= ah))
245+    then (aM >= ai)
246+    else false
247+
248+func aO (aP,aQ) = ((fraction(ar, aP, aQ) + fraction(ar, aQ, aP)) / 2)
249+
250+
251+func aR (aP,aQ) = {
252+    let aS = aO(aP, aQ)
253+    (fraction((aP + aQ), ar, pow(aS, at, ay, az, at, CEILING)) + (2 * fraction(toInt(pow(fraction(toBigInt(aP), toBigInt(aQ), toBigInt(aq)), 0, toBigInt(5), 1, (at / 2), DOWN)), pow((aS - aA), at, ay, az, at, DOWN), aq)))
254+    }
255+
256+
257+func aT (aU,aV,aW,aX) = {
258+    let aY = (ar - ((ar * 1) / 10000000))
259+    let aZ = (aU - aV)
260+    let aP = (ah + aW)
261+    let aQ = (ai + aW)
262+    func ba (bb,bc) =     if ((bb._1 == -1))
263+        then {
264+            let bd = (aU - (((bc * aZ) / 3) / ap))
265+            let be = if ((aX == ab))
266+                then aR(aP, (ai - bd))
267+                else aR((ah - bd), aQ)
268+            if ((be > al))
269+                then $Tuple2(bd, be)
270+                else $Tuple2(-1, 0)
271+            }
272+        else bb
273+
274+    let bf = ba($Tuple2(-1, 0), 3000)
275+    if ((0 > bf._1))
276+        then throw("Price is worse than minReceived")
277+        else {
278+            let bg = if ((aX == ab))
279+                then aR(aP, (ai - aU))
280+                else if ((aX == ac))
281+                    then aR((ah - aU), aQ)
282+                    else throw("Wrong asset in payment")
283+            if ((al > bg))
284+                then if ((aY >= fraction(ar, al, bg)))
285+                    then throw("The requested price is too not profitable for user")
286+                    else {
287+                        let bh = {
288+                            let bi = [25, 200, 500]
289+                            let bj = size(bi)
290+                            let bk = $Tuple2(-1, 0)
291+                            func bl (bm,bn) =                             if ((bn >= bj))
292+                                then bm
293+                                else ba(bm, bi[bn])
294+
295+                            func bo (bm,bn) =                             if ((bn >= bj))
296+                                then bm
297+                                else throw("List size exceeds 3")
298+
299+                            bo(bl(bl(bl(bk, 0), 1), 2), 3)
300+                            }
301+                        if ((0 > bh._1))
302+                            then bf._1
303+                            else bh._1
304+                        }
305+                else {
306+                    let bh = {
307+                        let bi = [-500, -200, -25]
308+                        let bj = size(bi)
309+                        let bk = $Tuple2(-1, 0)
310+                        func bl (bm,bn) =                         if ((bn >= bj))
311+                            then bm
312+                            else ba(bm, bi[bn])
313+
314+                        func bo (bm,bn) =                         if ((bn >= bj))
315+                            then bm
316+                            else throw("List size exceeds 3")
317+
318+                        bo(bl(bl(bl(bk, 0), 1), 2), 3)
319+                        }
320+                    let bp = if ((0 > bh._1))
321+                        then $Tuple2(aU, bg)
322+                        else bh
323+                    if ((aY >= fraction(ar, al, bp._2)))
324+                        then throw("The requested price is too not profitable for user")
325+                        else bp._1
326+                    }
327+            }
328+    }
329+
330+
331+func bq (aC) = {
332+    let H = aC
333+    if ($isInstanceOf(H, "ByteVector"))
334+        then {
335+            let ae = H
336+            let br = toBase58String(ae)
337+            let bs = valueOrErrorMessage(assetInfo(ae), (("Asset " + br) + " doesn't exist"))
338+            $Tuple3(br, bs.name, bs.decimals)
339+            }
340+        else if ($isInstanceOf(H, "Unit"))
341+            then {
342+                let af = H
343+                $Tuple3("WAVES", "WAVES", 8)
344+                }
345+            else throw("Match error")
346+    }
347+
348+
349+func bt (bu) = [BooleanEntry(c, false), StringEntry(l, bu)]
350+
351+
352+func bv () = throw("DApp is already active")
353+
354+
355+func bw () = if (Y)
356+    then unit
357+    else throw("DApp is inactive at this moment")
358+
359+
360+func bx (aG) = if (containsElement([K, L, M], aG.callerPublicKey))
361+    then unit
362+    else throw("Only admin can call this function")
363+
364+
365+func by () = throw(((("Incorrect assets attached. Expected: " + Z) + " and ") + aa))
366+
367+
368+func bz () = throw("One attached payment expected")
369+
370+
371+func bA (bB,bC,bD) = throw(((((((((("New balance in assets of the DApp is less than threshold " + toString(bB)) + ": ") + toString(bC)) + " ") + ad) + ", ") + toString(bD)) + " ") + ag))
372+
373+
374+func bE () = bt(((((((((((((((("Suspicious state. Actual balances: " + toString(ah)) + " ") + ad) + ", ") + toString(ai)) + " ") + ag) + ". State: ") + toString(aB(ab))) + " ") + ad) + ", ") + toString(aB(ac))) + " ") + ag))
375+
376+
377+func bF (bG,aC) = if (bG)
378+    then $Tuple2("lockNeutrino", Q)
379+    else $Tuple2("unlockNeutrino", Q)
380+
381+
382+func bH (bG,bI,aC) = if (bG)
383+    then {
384+        let bJ = bF(bG, aC)
385+        let bK = bJ._1
386+        let bL = bJ._2
387+        $Tuple4(bK, bL, nil, [AttachedPayment(aC, bI)])
388+        }
389+    else {
390+        let bM = bF(bG, aC)
391+        let bK = bM._1
392+        let bL = bM._2
393+        $Tuple4(bK, bL, [bI, toBase58String(aC)], nil)
394+        }
395+
396+
397+func bN (bO) = {
398+    let bP = valueOrElse(getInteger(P, (toString(bO) + q)), 0)
399+    let bQ = split(getStringValue(E, p), ",")
400+    let bR = split(getStringValue(E, o), ",")
401+    if (if ((bP >= parseIntValue(bQ[0])))
402+        then (parseIntValue(bQ[1]) > bP)
403+        else false)
404+        then (ao - parseIntValue(bR[0]))
405+        else if (if ((bP >= parseIntValue(bQ[1])))
406+            then (parseIntValue(bQ[2]) > bP)
407+            else false)
408+            then (ao - parseIntValue(bR[1]))
409+            else if (if ((bP >= parseIntValue(bQ[2])))
410+                then (parseIntValue(bQ[3]) > bP)
411+                else false)
412+                then (ao - parseIntValue(bR[2]))
413+                else if (if ((bP >= parseIntValue(bQ[3])))
414+                    then (parseIntValue(bQ[4]) > bP)
415+                    else false)
416+                    then (ao - parseIntValue(bR[3]))
417+                    else if ((bP >= parseIntValue(bQ[4])))
418+                        then (ao - parseIntValue(bR[4]))
419+                        else ao
420+    }
421+
422+
423+@Callable(aG)
424+func init (bS) = {
425+    let bT = $Tuple2(aG.payments[0].amount, aG.payments[0].assetId)
426+    let bU = bT._1
427+    let bV = bT._2
428+    let bW = $Tuple2(aG.payments[1].amount, aG.payments[1].assetId)
429+    let bX = bW._1
430+    let bY = bW._2
431+    let bZ = bq(bV)
432+    let ca = bZ._1
433+    let cb = bZ._2
434+    let cc = bZ._3
435+    let cd = bq(bY)
436+    let ce = cd._1
437+    let cf = cd._2
438+    let cg = cd._3
439+    if (isDefined(getBoolean(this, c)))
440+        then bv()
441+        else if ((bV == bY))
442+            then throw("Assets must be different")
443+            else {
444+                let ch = ((("s" + take(cb, 7)) + "_") + take(cf, 7))
445+                let ci = ((((("ShareToken of SwopFi protocol for " + cb) + " and ") + cf) + " at address ") + toString(this))
446+                let cj = ((cc + cg) / 2)
447+                let ck = fraction(pow(bU, cc, 5, 1, cc, DOWN), pow(bX, cg, 5, 1, cg, DOWN), pow(10, 0, cj, 0, 0, DOWN))
448+                let cl = Issue(ch, ci, ck, cj, true)
449+                let cm = calculateAssetId(cl)
450+                let cn = aR(bU, bX)
451+                let co = if (containsElement(T, ca))
452+                    then invoke(this, "stakeUnstake", [true, bU, ca], nil)
453+                    else 0
454+                if ((co == co))
455+                    then {
456+                        let cp = if (containsElement(T, ce))
457+                            then invoke(this, "stakeUnstake", [true, bX, ce], nil)
458+                            else 0
459+                        if ((cp == cp))
460+                            then {
461+                                let cq = [StringEntry(b, a), BooleanEntry(c, true), StringEntry(d, ca), StringEntry(e, ce), IntegerEntry(f, bU), IntegerEntry(g, bX), IntegerEntry(k, cn), IntegerEntry(j, getIntegerValue(E, "base_fee_flat")), cl, StringEntry(h, toBase58String(cm)), IntegerEntry(i, ck), ScriptTransfer(aG.caller, ck, cm)]
462+                                if (bS)
463+                                    then (cq ++ [BooleanEntry(r, bS), IntegerEntry(s, (V + (X * W)))])
464+                                    else cq
465+                                }
466+                            else throw("Strict value is not equal to itself.")
467+                        }
468+                    else throw("Strict value is not equal to itself.")
469+                }
470+    }
471+
472+
473+
474+@Callable(aG)
475+func replenishWithTwoTokens () = valueOrElse(bw(), {
476+    let bV = aG.payments[0].assetId
477+    let bY = aG.payments[1].assetId
478+    let cr = fraction(aq, aG.payments[0].amount, ah)
479+    let cs = fraction(aq, aG.payments[1].amount, ai)
480+    let ct = bq(bV)
481+    let ca = ct._1
482+    let cb = ct._2
483+    let cc = ct._3
484+    let cu = bq(bY)
485+    let ce = cu._1
486+    let cf = cu._2
487+    let cg = cu._3
488+    let cv = if ((cs > cr))
489+        then {
490+            let cw = fraction(ai, cr, aq, CEILING)
491+            $Tuple5(aG.payments[0].amount, cw, (aG.payments[1].amount - cw), bY, cr)
492+            }
493+        else {
494+            let cw = fraction(ah, cs, aq, CEILING)
495+            $Tuple5(cw, aG.payments[1].amount, (aG.payments[0].amount - cw), bV, cs)
496+            }
497+    let bU = cv._1
498+    let bX = cv._2
499+    let cx = cv._3
500+    let cy = cv._4
501+    let cz = cv._5
502+    let cA = fraction(cz, ak, aq)
503+    if ((size(aG.payments) != 2))
504+        then throw("Two attached assets expected")
505+        else if (if ((bV != ab))
506+            then true
507+            else (bY != ac))
508+            then by()
509+            else if ((cA == 0))
510+                then throw("Too small amount to replenish")
511+                else if ((0 > cx))
512+                    then throw("Change < 0")
513+                    else if (!(aN))
514+                        then ([ScriptTransfer(aG.caller, bU, bV), ScriptTransfer(aG.caller, bX, bY)] ++ bE())
515+                        else {
516+                            let co = if (containsElement(T, ca))
517+                                then invoke(this, "stakeUnstake", [true, bU, ca], nil)
518+                                else 0
519+                            if ((co == co))
520+                                then {
521+                                    let cp = if (containsElement(T, ce))
522+                                        then invoke(this, "stakeUnstake", [true, bX, ce], nil)
523+                                        else 0
524+                                    if ((cp == cp))
525+                                        then [IntegerEntry(f, (ah + bU)), IntegerEntry(g, (ai + bX)), IntegerEntry(i, (ak + cA)), IntegerEntry(k, aR((ah + bU), (ai + bX))), Reissue(aj, cA, true), ScriptTransfer(aG.caller, cA, aj), ScriptTransfer(aG.caller, cx, cy)]
526+                                        else throw("Strict value is not equal to itself.")
527+                                    }
528+                                else throw("Strict value is not equal to itself.")
529+                            }
530+    })
531+
532+
533+
534+@Callable(aG)
535+func replenishWithOneToken (cB,cC) = valueOrElse(bw(), {
536+    let cD = $Tuple2(aG.payments[0].amount, aG.payments[0].assetId)
537+    let cE = cD._1
538+    let cF = cD._2
539+    let cG = bq(cF)
540+    let cH = cG._1
541+    let cI = cG._2
542+    let cJ = cG._3
543+    let cK = 5000000
544+    let cL = 50000000
545+    let cM = if ((cL > cE))
546+        then 100000
547+        else 1
548+    let cN = (aq - ((aq * cM) / 10000000))
549+    let cO = (aq + ((aq * cM) / 10000000))
550+    let cP = (aq - ((aq * 1) / 10000000))
551+    if ((cK > cE))
552+        then throw((((("Payment amount " + toString(cE)) + " does not exceed the minimum amount of ") + toString(cK)) + " tokens"))
553+        else if ((size(aG.payments) != 1))
554+            then bz()
555+            else if (!(aN))
556+                then ([ScriptTransfer(aG.caller, cE, cF)] ++ bE())
557+                else if (if ((cF != ab))
558+                    then (cF != ac)
559+                    else false)
560+                    then by()
561+                    else {
562+                        let cQ = if ((cF == ab))
563+                            then $Tuple6((cE - cB), cC, (ah + cB), (ai - cC), (ah + cE), ai)
564+                            else $Tuple6(cC, (cE - cB), (ah - cC), (ai + cB), ah, (ai + cE))
565+                        let cR = cQ._1
566+                        let cS = cQ._2
567+                        let cT = cQ._3
568+                        let cU = cQ._4
569+                        let cV = cQ._5
570+                        let cW = cQ._6
571+                        let cX = aR(cT, cU)
572+                        let cY = (fraction(ar, cT, cU) / fraction(aq, cR, cS))
573+                        let cZ = fraction((cV + cW), au, (2 * av))
574+                        if (if ((cP >= fraction(aq, al, cX)))
575+                            then true
576+                            else (al > cX))
577+                            then throw("Incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
578+                            else if (if ((cN > cY))
579+                                then true
580+                                else (cY > cO))
581+                                then throw("Swap with virtualSwapTokenPay and virtualSwapTokenGet is possible, but ratio after virtual swap is incorrect")
582+                                else if (if ((cZ > cV))
583+                                    then true
584+                                    else (cZ > cW))
585+                                    then bA(cZ, cV, cW)
586+                                    else {
587+                                        let cr = fraction(cR, aq, cT)
588+                                        let cs = fraction(cS, aq, cU)
589+                                        let cA = fraction(min([cr, cs]), ak, aq)
590+                                        let da = fraction(cA, (ao - (am / 2)), ao)
591+                                        let db = fraction(cA, (an / 2), ao)
592+                                        let dc = fraction(db, ah, ak)
593+                                        let dd = fraction(db, ai, ak)
594+                                        let de = if ((cH == Z))
595+                                            then $Tuple3((cE - dc), dd, aa)
596+                                            else $Tuple3((cE - dd), dc, Z)
597+                                        let df = de._1
598+                                        let dg = de._2
599+                                        let dh = de._3
600+                                        let co = if (containsElement(T, cH))
601+                                            then invoke(this, "stakeUnstake", [true, df, cH], nil)
602+                                            else 0
603+                                        if ((co == co))
604+                                            then {
605+                                                let cp = if (containsElement(T, dh))
606+                                                    then invoke(this, "stakeUnstake", [false, dg, dh], nil)
607+                                                    else 0
608+                                                if ((cp == cp))
609+                                                    then [Reissue(aj, da, true), ScriptTransfer(aG.caller, da, aj), ScriptTransfer(O, dc, ab), ScriptTransfer(O, dd, ac), IntegerEntry(f, (cV - dc)), IntegerEntry(g, (cW - dd)), IntegerEntry(i, (ak + da)), IntegerEntry(k, aR((cV - dc), (cW - dd)))]
610+                                                    else throw("Strict value is not equal to itself.")
611+                                                }
612+                                            else throw("Strict value is not equal to itself.")
613+                                        }
614+                        }
615+    })
616+
617+
618+
619+@Callable(aG)
620+func withdraw () = valueOrElse(bw(), {
621+    let di = $Tuple2(aG.payments[0].amount, aG.payments[0].assetId)
622+    let cE = di._1
623+    let cF = di._2
624+    let dj = fraction(cE, ah, ak)
625+    let dk = fraction(cE, ai, ak)
626+    let cn = aR((ah - dj), (ai - dk))
627+    if ((size(aG.payments) != 1))
628+        then bz()
629+        else if ((cF != aj))
630+            then throw(("Incorrect asset attached. Expected: " + toBase58String(aj)))
631+            else if (!(aN))
632+                then ([ScriptTransfer(aG.caller, cE, cF)] ++ bE())
633+                else {
634+                    let co = if (containsElement(T, Z))
635+                        then invoke(this, "stakeUnstake", [false, dj, Z], nil)
636+                        else 0
637+                    if ((co == co))
638+                        then {
639+                            let cp = if (containsElement(T, aa))
640+                                then invoke(this, "stakeUnstake", [false, dk, aa], nil)
641+                                else 0
642+                            if ((cp == cp))
643+                                then [IntegerEntry(f, (ah - dj)), IntegerEntry(g, (ai - dk)), IntegerEntry(i, (ak - cE)), IntegerEntry(k, cn), Burn(aj, cE), ScriptTransfer(aG.caller, dj, ab), ScriptTransfer(aG.caller, dk, ac)]
644+                                else throw("Strict value is not equal to itself.")
645+                            }
646+                        else throw("Strict value is not equal to itself.")
647+                    }
648+    })
649+
650+
651+
652+@Callable(aG)
653+func exchange (dl,dm) = valueOrElse(bw(), {
654+    let dn = $Tuple2(aG.payments[0].amount, aG.payments[0].assetId)
655+    let cE = dn._1
656+    let cF = dn._2
657+    if ((0 >= dl))
658+        then throw(("Estimated amount must be positive. Actual: " + toString(dl)))
659+        else if ((dm > dl))
660+            then throw("Minimal amount can't be greater than estimated.")
661+            else if ((size(aG.payments) != 1))
662+                then bz()
663+                else if (!(aN))
664+                    then ([ScriptTransfer(aG.caller, cE, cF)] ++ bE())
665+                    else if (if ((cF != ab))
666+                        then (cF != ac)
667+                        else false)
668+                        then by()
669+                        else if ((10000000 > cE))
670+                            then throw("Only swap of 10.000000 or more tokens is allowed")
671+                            else if (if ((aw > fraction(aq, dm, cE)))
672+                                then true
673+                                else (fraction(aq, dl, cE) > ax))
674+                                then throw("Incorrect args and pmt ratio")
675+                                else {
676+                                    let do = if ((cF == ab))
677+                                        then ac
678+                                        else ab
679+                                    let bI = aT(dl, dm, cE, cF)
680+                                    let dp = bN(aG.originCaller)
681+                                    let dq = fraction(bI, fraction(an, dp, ao, CEILING), ao)
682+                                    let dr = fraction(bI, (ao - fraction(am, dp, ao, CEILING)), ao)
683+                                    let ds = if ((cF == ab))
684+                                        then $Tuple2((ah + cE), ((ai - dr) - dq))
685+                                        else $Tuple2(((ah - dr) - dq), (ai + cE))
686+                                    let cV = ds._1
687+                                    let cW = ds._2
688+                                    let cZ = fraction((cV + cW), au, (2 * av))
689+                                    if (if ((cZ > cV))
690+                                        then true
691+                                        else (cZ > cW))
692+                                        then bA(cZ, cV, cW)
693+                                        else {
694+                                            let dt = bq(cF)
695+                                            let cH = dt._1
696+                                            let cI = dt._2
697+                                            let cJ = dt._3
698+                                            let du = bq(do)
699+                                            let dv = du._1
700+                                            let dw = du._2
701+                                            let dx = du._3
702+                                            let co = if (containsElement(T, cH))
703+                                                then invoke(this, "stakeUnstake", [true, cE, cH], nil)
704+                                                else 0
705+                                            if ((co == co))
706+                                                then {
707+                                                    let cp = if (containsElement(T, dv))
708+                                                        then invoke(this, "stakeUnstake", [false, (dr + dq), dv], nil)
709+                                                        else 0
710+                                                    if ((cp == cp))
711+                                                        then $Tuple2([IntegerEntry(f, cV), IntegerEntry(g, cW), IntegerEntry(k, aR(cV, cW)), ScriptTransfer(aG.caller, dr, do), ScriptTransfer(O, dq, do)], [dr, do])
712+                                                        else throw("Strict value is not equal to itself.")
713+                                                    }
714+                                                else throw("Strict value is not equal to itself.")
715+                                            }
716+                                    }
717+    })
718+
719+
720+
721+@Callable(aG)
722+func shutdown () = valueOrElse(bx(aG), if (!(Y))
723+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, l), "the cause wasn't specified")))
724+    else bt("Paused by admin"))
725+
726+
727+
728+@Callable(aG)
729+func activate () = valueOrElse(bx(aG), if (Y)
730+    then bv()
731+    else [BooleanEntry(c, true), DeleteEntry(l)])
732+
733+
734+
735+@Callable(aG)
736+func takeIntoAccountExtraFunds () = valueOrElse(bw(), {
737+    let dy = (aL - ah)
738+    let dz = (aM - ai)
739+    let cX = aR((ah + dy), (ai + dz))
740+    if ((aG.caller != O))
741+        then throw("Only the money box can call this function")
742+        else if (if ((0 > dy))
743+            then true
744+            else (0 > dz))
745+            then bt("Enroll amount negative")
746+            else if (if ((dy == 0))
747+                then (dz == 0)
748+                else false)
749+                then throw("No money to take")
750+                else {
751+                    let co = if (if (containsElement(T, Z))
752+                        then (dy > 0)
753+                        else false)
754+                        then invoke(this, "stakeUnstake", [true, dy, Z], nil)
755+                        else 0
756+                    if ((co == co))
757+                        then {
758+                            let cp = if (if (containsElement(T, aa))
759+                                then (dz > 0)
760+                                else false)
761+                                then invoke(this, "stakeUnstake", [true, dz, aa], nil)
762+                                else 0
763+                            if ((cp == cp))
764+                                then [IntegerEntry(k, cX), IntegerEntry(f, (ah + dy)), IntegerEntry(g, (ai + dz))]
765+                                else throw("Strict value is not equal to itself.")
766+                            }
767+                        else throw("Strict value is not equal to itself.")
768+                    }
769+    })
770+
771+
772+
773+@Callable(aG)
774+func keepLimitForFirstHarvest (dA) = valueOrElse(bw(), valueOrElse(bx(aG), [IntegerEntry(t, dA)]))
775+
776+
777+
778+@Callable(aG)
779+func stakeUnstake (bG,bI,dB) = if ((aG.caller != this))
780+    then throw("Only contract itself can invoke this function")
781+    else {
782+        let dC = bH(bG, bI, fromBase58String(dB))
783+        let bK = dC._1
784+        let dD = dC._2
785+        let dE = dC._3
786+        let dF = dC._4
787+        let dG = invoke(dD, bK, dE, dF)
788+        if ((dG == dG))
789+            then nil
790+            else throw("Strict value is not equal to itself.")
791+        }
792+
793+
794+@Verifier(dH)
795+func dI () = {
796+    let dJ = {
797+        let dK = if (sigVerify(dH.bodyBytes, dH.proofs[0], K))
798+            then 1
799+            else 0
800+        let dL = if (sigVerify(dH.bodyBytes, dH.proofs[1], L))
801+            then 1
802+            else 0
803+        let dM = if (sigVerify(dH.bodyBytes, dH.proofs[2], M))
804+            then 1
805+            else 0
806+        (((dK + dL) + dM) >= 2)
807+        }
808+    let H = dH
809+    if ($isInstanceOf(H, "InvokeScriptTransaction"))
810+        then {
811+            let dG = H
812+            let dN = if ((dG.dApp == this))
813+                then (dG.function == "takeIntoAccountExtraFunds")
814+                else false
815+            let dO = if (if (if (sigVerify(dH.bodyBytes, dH.proofs[0], K))
816+                then true
817+                else sigVerify(dH.bodyBytes, dH.proofs[0], L))
818+                then true
819+                else sigVerify(dH.bodyBytes, dH.proofs[0], M))
820+                then true
821+                else sigVerify(dH.bodyBytes, dH.proofs[0], N)
822+            if (if (dN)
823+                then dO
824+                else false)
825+                then true
826+                else dJ
827+            }
828+        else dJ
829+    }
830+
github/deemru/w8io/169f3d6 
49.31 ms ◑