tx · 6tSZpPiMPMjaggcTMjwxTgYWuNXdJDZM6p352Rwdk3Jw

3NCt9HRcKUigCsKJKDnvW8uFnJp21JW9vJk:  -0.01000000 Waves

2022.01.11 17:45 [1874423] smart account 3NCt9HRcKUigCsKJKDnvW8uFnJp21JW9vJk > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6tSZpPiMPMjaggcTMjwxTgYWuNXdJDZM6p352Rwdk3Jw",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1641912360074,
    "version": 2,
    "chainId": 84,
    "sender": "3NCt9HRcKUigCsKJKDnvW8uFnJp21JW9vJk",
    "senderPublicKey": "G9mbKxfZcMMsc33E8YkLJ6Hq95hD8qt2dsLDgXbx6NjK",
    "proofs": [
        "5dXKgSc3wEfYsrGXUxtSa8pYdZssQMR9kcCfaUBBk5L9iwnjB3XQsdgK3puBxSdeR1VYJE4KEAty5ASt8yesroxj"
    ],
    "script": "base64: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",
    "height": 1874423,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 2gmWTWqYMKHcMVB83QX2G3h8o7hpDf2vYnZYB3xdxKCh

Full: 

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