tx · BsPCjrs8tkRj2Z4yoWkgztqhg3irBaJ4HM6mAHHmC6in

3MpvXmHDYaho1DE5zvSc7NjEU59j8NzbCs8:  -0.01000000 Waves

2022.03.11 16:35 [1959356] smart account 3MpvXmHDYaho1DE5zvSc7NjEU59j8NzbCs8 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BsPCjrs8tkRj2Z4yoWkgztqhg3irBaJ4HM6mAHHmC6in",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1647005703908,
    "version": 2,
    "chainId": 84,
    "sender": "3MpvXmHDYaho1DE5zvSc7NjEU59j8NzbCs8",
    "senderPublicKey": "BvocwbF1Cy4Ra6LXzzQiXf1k7knWqq8AwqjQWxHghY4e",
    "proofs": [
        "41sp9ibEwCiP2YpTEd7sY9LsggEorU1FBjjTqp2XHkj2S1Y951VKwsmyZsjQKySX1RoCMcf7bVPhKorqjrV1Cqyb"
    ],
    "script": "base64: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",
    "height": 1959356,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

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