tx · A39GaZW6jN363AdoaKKBJKb8j8a7gV5dGrA81BzYiNZE

3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX:  -0.03100000 Waves

2022.10.28 15:50 [2292277] smart account 3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "A39GaZW6jN363AdoaKKBJKb8j8a7gV5dGrA81BzYiNZE",
    "fee": 3100000,
    "feeAssetId": null,
    "timestamp": 1666961449067,
    "version": 2,
    "chainId": 84,
    "sender": "3MpygN8qm376tUAHB6mhC5BxG5NKYortiyX",
    "senderPublicKey": "BjnLnkAMaJLYAK36vQqSepUNjGeMDHfZGfmdYwGcLbmg",
    "proofs": [
        "2CVZ1vYLKqeUk9SyTD5FbDjY3zYro6rCHpyJQanwYLgEvGrSVnvKsM5JQUEAM7vDXBUqKNtpsd7dcFhg9QtS8NbL"
    ],
    "script": "base64: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",
    "height": 2292277,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: CPJBNgiqCoi4X64H6kPiZV8k5jRgYMuRPHtNh9CMpnJ4

Full: 

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