tx · Ev2bvMKb3opuwHLgmYN9uokTUYgTgD5xyR3yEV29iSoy

3P78KN9grDkkkErVBtZmZpVECMpwcyQ28wk:  -0.03200000 Waves

2023.01.10 00:42 [3463473] smart account 3P78KN9grDkkkErVBtZmZpVECMpwcyQ28wk > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Ev2bvMKb3opuwHLgmYN9uokTUYgTgD5xyR3yEV29iSoy",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1673300577179,
    "version": 2,
    "chainId": 87,
    "sender": "3P78KN9grDkkkErVBtZmZpVECMpwcyQ28wk",
    "senderPublicKey": "48jru3aWWXy8JmmA9gKAN172VYgRqHgkbLvWZYKH51Cy",
    "proofs": [
        "etgEvgFCH9mWBmpxrzpmJPjthNN1C5riFwgxjVTFcvc72zZGGenXqavb2hZmb81emBQfW4bNbqsboNcFnadNxe8"
    ],
    "script": "base64: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",
    "height": 3463473,
    "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 = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
5+
6+let b = base58'HEB8Qaw9xrWpWs8tHsiATYGBWDBtP2S7kcPALrMu43AS'
7+
8+let c = base58'34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ'
9+
10+let d = "DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p"
11+
12+let e = "HEB8Qaw9xrWpWs8tHsiATYGBWDBtP2S7kcPALrMu43AS"
13+
14+let f = "34N9YcEETLWn93qYQ64EsP1x89tSruJU44RrEMSXXEPJ"
15+
16+let g = Address(base58'3PFDgzu1UtswAkCMxqqQjbTeHaX4cMab8Kh')
17+
18+let h = Address(base58'3PLjwHcz9NEuaTo63NZR9B9okQiKQxZSbmf')
19+
20+let i = base58'4z8CKSYQBKkzx7PBb5uBP1YPa6YAHRNTApW1sQVHT5eU'
21+
22+func j (k) = {
23+    let l = getInteger(this, k)
24+    if ($isInstanceOf(l, "Int"))
25+        then {
26+            let m = l
27+            m
28+            }
29+        else 0
30+    }
31+
32+
33+func n (k) = {
34+    let l = getBinary(this, k)
35+    if ($isInstanceOf(l, "ByteVector"))
36+        then {
37+            let m = l
38+            m
39+            }
40+        else base58''
41+    }
42+
43+
44+func o (k) = {
45+    let l = getString(this, k)
46+    if ($isInstanceOf(l, "String"))
47+        then {
48+            let m = l
49+            m
50+            }
51+        else ""
52+    }
53+
54+
55+func p (q) = {
56+    let l = q
57+    if ($isInstanceOf(l, "ByteVector"))
58+        then {
59+            let m = l
60+            toBase58String(m)
61+            }
62+        else "WAVES"
63+    }
64+
65+
66+func r (s) = if ((s == "WAVES"))
67+    then unit
68+    else fromBase58String(s)
69+
70+
71+func t (u,v) = (u ++ [r(v)])
72+
73+
74+func w (u,v) = (u ++ [j((("static_" + p(v)) + "_weight"))])
75+
76+
77+func x (u,v) = (u ++ [j((("static_" + p(v)) + "_decimals"))])
78+
79+
80+func y (u,v) = (u ++ [j((("static_" + p(v)) + "_scale"))])
81+
82+
83+func z (u,v) = (u ++ [parseIntValue(v)])
84+
85+
86+let A = j("static_tokensAmount")
87+
88+let B = {
89+    let C = split(o("static_tokenIds"), ",")
90+    let D = size(C)
91+    let E = nil
92+    func F (G,H) =     if ((H >= D))
93+        then G
94+        else t(G, C[H])
95+
96+    func I (G,H) =     if ((H >= D))
97+        then G
98+        else throw("List size exceeds 10")
99+
100+    I(F(F(F(F(F(F(F(F(F(F(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
101+    }
102+
103+let J = {
104+    let C = B
105+    let D = size(C)
106+    let E = nil
107+    func K (G,H) =     if ((H >= D))
108+        then G
109+        else w(G, C[H])
110+
111+    func L (G,H) =     if ((H >= D))
112+        then G
113+        else throw("List size exceeds 10")
114+
115+    L(K(K(K(K(K(K(K(K(K(K(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
116+    }
117+
118+let M = {
119+    let C = B
120+    let D = size(C)
121+    let E = nil
122+    func N (G,H) =     if ((H >= D))
123+        then G
124+        else x(G, C[H])
125+
126+    func O (G,H) =     if ((H >= D))
127+        then G
128+        else throw("List size exceeds 10")
129+
130+    O(N(N(N(N(N(N(N(N(N(N(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
131+    }
132+
133+let P = {
134+    let C = B
135+    let D = size(C)
136+    let E = nil
137+    func Q (G,H) =     if ((H >= D))
138+        then G
139+        else y(G, C[H])
140+
141+    func R (G,H) =     if ((H >= D))
142+        then G
143+        else throw("List size exceeds 10")
144+
145+    R(Q(Q(Q(Q(Q(Q(Q(Q(Q(Q(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
146+    }
147+
148+let S = j("static_fee")
149+
150+let T = 4
151+
152+let U = 10000
153+
154+let V = 100000000
155+
156+let W = 10000
157+
158+let X = 8
159+
160+let Y = pow(10, 0, X, 0, 0, HALFUP)
161+
162+let Z = B
163+
164+func aa () = {
165+    let l = getBoolean(Address(base58'3PEpv9hRFWEEBU22WRnLsw1bH4YGtcU728o'), "is_shutdown")
166+    if ($isInstanceOf(l, "Boolean"))
167+        then {
168+            let ab = l
169+            ab
170+            }
171+        else false
172+    }
173+
174+
175+func ac (ad) = {
176+    let ae = p(B[ad])
177+    j((("global_" + ae) + "_balance"))
178+    }
179+
180+
181+func af (ag,ae) = {
182+    let ah = j("global_poolToken_amount")
183+    let ai = j((("global_" + p(ae)) + "_balance"))
184+    fraction(ag, ah, ai, DOWN)
185+    }
186+
187+
188+func aj (ak) = {
189+    func al (u,am) =     {
190+        let an = af(am.amount, am.assetId)
191+        if ((an == 0))
192+            then throw("one of the tokens amounts is too low")
193+            else if (if ((u == 0))
194+                then true
195+                else (u > an))
196+                then an
197+                else u
198+        }
199+
200+    let ao = {
201+        let C = ak
202+        let D = size(C)
203+        let E = 0
204+        func ap (G,H) =         if ((H >= D))
205+            then G
206+            else al(G, C[H])
207+
208+        func aq (G,H) =         if ((H >= D))
209+            then G
210+            else throw("List size exceeds 10")
211+
212+        aq(ap(ap(ap(ap(ap(ap(ap(ap(ap(ap(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
213+        }
214+    ao
215+    }
216+
217+
218+func ar (q,ag,as,at) = {
219+    let au = indexOf(B, a)
220+    let av = indexOf(B, c)
221+    let aw = J[value(indexOf(B, q))]
222+    if (if ((au == unit))
223+        then (av == unit)
224+        else false)
225+        then {
226+            let ax = J[value(indexOf(B, b))]
227+            let ay = j((("global_" + e) + "_balance"))
228+            let az = fraction(ag, (ay / ax), (as / aw))
229+            let aA = getIntegerValue(g, "global_lastPuzzlePrice")
230+            fraction((az * aA), 1, V)
231+            }
232+        else if ((av != unit))
233+            then {
234+                let aB = J[value(av)]
235+                let aC = j((("global_" + f) + "_balance"))
236+                fraction(ag, (aC / aB), (as / aw))
237+                }
238+            else {
239+                let aD = J[value(indexOf(B, a))]
240+                let aE = {
241+                    let l = at
242+                    if ($isInstanceOf(l, "Int"))
243+                        then {
244+                            let ab = l
245+                            at
246+                            }
247+                        else j((("global_" + p(a)) + "_balance"))
248+                    }
249+                fraction(ag, (value(aE) / aD), (as / aw))
250+                }
251+    }
252+
253+
254+func aF (ak) = {
255+    func aG (u,aH) =     (u ++ [aH.assetId])
256+
257+    let aI = {
258+        let C = ak
259+        let D = size(C)
260+        let E = nil
261+        func ap (G,H) =         if ((H >= D))
262+            then G
263+            else aG(G, C[H])
264+
265+        func aq (G,H) =         if ((H >= D))
266+            then G
267+            else throw("List size exceeds 10")
268+
269+        aq(ap(ap(ap(ap(ap(ap(ap(ap(ap(ap(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
270+        }
271+    if ((aI == aI))
272+        then {
273+            func aJ (u,q) =             if ((indexOf(aI, q) != unit))
274+                then (u + 1)
275+                else throw(("asset not attached: " + p(q)))
276+
277+            let aK = {
278+                let C = B
279+                let D = size(C)
280+                let E = 0
281+                func aL (G,H) =                 if ((H >= D))
282+                    then G
283+                    else aJ(G, C[H])
284+
285+                func aM (G,H) =                 if ((H >= D))
286+                    then G
287+                    else throw("List size exceeds 10")
288+
289+                aM(aL(aL(aL(aL(aL(aL(aL(aL(aL(aL(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
290+                }
291+            if ((aK == aK))
292+                then true
293+                else throw("Strict value is not equal to itself.")
294+            }
295+        else throw("Strict value is not equal to itself.")
296+    }
297+
298+
299+func aN (an,ak,aO,aP) = {
300+    func aQ (ae) =     {
301+        func al (u,aH) =         if ((aH.assetId == ae))
302+            then aH.amount
303+            else u
304+
305+        let C = ak
306+        let D = size(C)
307+        let E = 0
308+        func ap (G,H) =         if ((H >= D))
309+            then G
310+            else al(G, C[H])
311+
312+        func aq (G,H) =         if ((H >= D))
313+            then G
314+            else throw("List size exceeds 10")
315+
316+        aq(ap(ap(ap(ap(ap(ap(ap(ap(ap(ap(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
317+        }
318+
319+    func aR (u,ae) =     {
320+        let aS = j((("global_" + p(ae)) + "_balance"))
321+        let aT = j("global_poolToken_amount")
322+        let aU = j((("static_" + p(ae)) + "_scale"))
323+        let aV = fraction((fraction((aT + an), aU, aT, CEILING) - aU), aS, aU, CEILING)
324+        let aW = aQ(ae)
325+        let aX = ((if ((aW != 0))
326+            then aW
327+            else 0) - aV)
328+        let aY = if (if (aP)
329+            then (aX > 0)
330+            else false)
331+            then [ScriptTransfer(aO, aX, ae)]
332+            else nil
333+        ((u ++ aY) ++ [IntegerEntry((("global_" + p(ae)) + "_balance"), (aS + aV))])
334+        }
335+
336+    let C = B
337+    let D = size(C)
338+    let E = nil
339+    func ap (G,H) =     if ((H >= D))
340+        then G
341+        else aR(G, C[H])
342+
343+    func aq (G,H) =     if ((H >= D))
344+        then G
345+        else throw("List size exceeds 10")
346+
347+    aq(ap(ap(ap(ap(ap(ap(ap(ap(ap(ap(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
348+    }
349+
350+
351+func aZ (ba,aO) = {
352+    func bb (u,ae) =     {
353+        let aS = j((("global_" + p(ae)) + "_balance"))
354+        let aT = j("global_poolToken_amount")
355+        let aU = j((("static_" + p(ae)) + "_scale"))
356+        let ag = toInt(fraction((toBigInt(V) - fraction(toBigInt((aT - ba)), toBigInt(V), toBigInt(aT), CEILING)), toBigInt(aS), toBigInt(V), DOWN))
357+        (u ++ [IntegerEntry((("global_" + p(ae)) + "_balance"), (aS - ag)), ScriptTransfer(aO, ag, ae)])
358+        }
359+
360+    let C = B
361+    let D = size(C)
362+    let E = nil
363+    func ap (G,H) =     if ((H >= D))
364+        then G
365+        else bb(G, C[H])
366+
367+    func aq (G,H) =     if ((H >= D))
368+        then G
369+        else throw("List size exceeds 10")
370+
371+    aq(ap(ap(ap(ap(ap(ap(ap(ap(ap(ap(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
372+    }
373+
374+
375+func bc (bd,be,bf,bg,bh) = {
376+    let bi = value(indexOf(B, be))
377+    let bj = value(indexOf(B, bf))
378+    if ((bi == bj))
379+        then bd
380+        else fraction(bh, ((V * V) - toInt(pow(fraction(toBigInt(bg), toBigInt((V * V)), toBigInt((bg + bd)), HALFUP), 16, toBigInt(fraction(J[bi], 10000, J[bj])), 4, 16, CEILING))), (V * V), DOWN)
381+    }
382+
383+
384+func bk (q) = {
385+    let l = q
386+    if ($isInstanceOf(l, "ByteVector"))
387+        then {
388+            let aY = l
389+            assetBalance(this, aY)
390+            }
391+        else wavesBalance(this).available
392+    }
393+
394+
395+func bl (q,s,as,bm) = {
396+    let bn = j("global_indexStaked")
397+    let bo = bm
398+    let bp = (bk(q) - as)
399+    let bq = if ((bp > bo))
400+        then bp
401+        else bo
402+    let br = (bq - bo)
403+    let bs = if ((bn == 0))
404+        then 0
405+        else fraction(br, V, bn)
406+    let bt = j((("global_lastCheck_" + s) + "_interest"))
407+    (bt + bs)
408+    }
409+
410+
411+func bu (bv) = {
412+    let bw = toString(bv)
413+    let bx = j((bw + "_indexStaked"))
414+    func al (u,q) =     {
415+        let s = p(q)
416+        let as = j((("global_" + p(q)) + "_balance"))
417+        let bm = j((("global_lastCheck_" + s) + "_earnings"))
418+        let by = bl(q, s, as, bm)
419+        let bq = max([bm, (bk(q) - as)])
420+        let bz = fraction(bx, (by - j((((bw + "_lastCheck_") + s) + "_interest"))), V)
421+        let bA = if ((bz == 0))
422+            then nil
423+            else [ScriptTransfer(bv, bz, q)]
424+        $Tuple2(((u._1 ++ bA) ++ [IntegerEntry((("global_lastCheck_" + s) + "_earnings"), (bq - bz)), IntegerEntry((("global_lastCheck_" + s) + "_interest"), by), IntegerEntry((((bw + "_lastCheck_") + s) + "_interest"), by)]), (u._2 + ar(q, bz, as, unit)))
425+        }
426+
427+    let u = {
428+        let C = Z
429+        let D = size(C)
430+        let E = $Tuple2(nil, 0)
431+        func ap (G,H) =         if ((H >= D))
432+            then G
433+            else al(G, C[H])
434+
435+        func aq (G,H) =         if ((H >= D))
436+            then G
437+            else throw("List size exceeds 10")
438+
439+        aq(ap(ap(ap(ap(ap(ap(ap(ap(ap(ap(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
440+        }
441+    $Tuple2((u._1 ++ [IntegerEntry((bw + "_claimedRewardValue"), (j((bw + "_claimedRewardValue")) + u._2)), IntegerEntry((bw + "_lastClaim"), lastBlock.timestamp)]), u._2)
442+    }
443+
444+
445+func bB (bw,ag) = {
446+    let bC = bu(addressFromStringValue(bw))._1
447+    (bC ++ [IntegerEntry((bw + "_indexStaked"), (j((bw + "_indexStaked")) + ag)), IntegerEntry("global_indexStaked", (j("global_indexStaked") + ag))])
448+    }
449+
450+
451+func bD (u,bE) = (u + parseIntValue(bE))
452+
453+
454+@Callable(bF)
455+func preInit (bG,bH,bI,bJ,bK,bL) = {
456+    let bM = Address(fromBase58String(bK))
457+    if ((this != bF.caller))
458+        then throw("admin only")
459+        else if ((size(bJ) > 13))
460+            then throw("too large pool domain")
461+            else if (if ((bL > 500))
462+                then true
463+                else (50 > bL))
464+                then throw("fee value must be between 50 and 500 (0.5-5%)")
465+                else if (if (if ((indexOf(bG, e) == unit))
466+                    then (indexOf(bG, d) == unit)
467+                    else false)
468+                    then (indexOf(bG, f) == unit)
469+                    else false)
470+                    then throw("pool must have USDT, USDN or PUZZLE in the composition")
471+                    else {
472+                        let bN = split(bG, ",")
473+                        let bO = {
474+                            let C = bN
475+                            let D = size(C)
476+                            let E = nil
477+                            func ap (G,H) =                             if ((H >= D))
478+                                then G
479+                                else t(G, C[H])
480+
481+                            func aq (G,H) =                             if ((H >= D))
482+                                then G
483+                                else throw("List size exceeds 10")
484+
485+                            aq(ap(ap(ap(ap(ap(ap(ap(ap(ap(ap(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
486+                            }
487+                        let bP = split(bH, ",")
488+                        let bQ = {
489+                            let C = bP
490+                            let D = size(C)
491+                            let E = 0
492+                            func aL (G,H) =                             if ((H >= D))
493+                                then G
494+                                else bD(G, C[H])
495+
496+                            func aM (G,H) =                             if ((H >= D))
497+                                then G
498+                                else throw("List size exceeds 10")
499+
500+                            aM(aL(aL(aL(aL(aL(aL(aL(aL(aL(aL(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
501+                            }
502+                        let bR = if ((indexOf(bG, d) == unit))
503+                            then if ((indexOf(bG, e) == unit))
504+                                then f
505+                                else e
506+                            else d
507+                        func bS (u,bT) =                         if ((bT >= size(bO)))
508+                            then u
509+                            else {
510+                                let bU = {
511+                                    let l = bO[bT]
512+                                    if ($isInstanceOf(l, "ByteVector"))
513+                                        then {
514+                                            let ab = l
515+                                            value(assetInfo(ab)).decimals
516+                                            }
517+                                        else 8
518+                                    }
519+                                (u ++ [IntegerEntry((("static_" + bN[bT]) + "_scale"), pow(10, 0, bU, 0, 0, DOWN)), IntegerEntry((("static_" + bN[bT]) + "_decimals"), bU), IntegerEntry((("static_" + bN[bT]) + "_weight"), value(parseInt(bP[bT])))])
520+                                }
521+
522+                        if ((bQ != 10000))
523+                            then throw("sum of token weights must be equal to 10000")
524+                            else ({
525+                                let C = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
526+                                let D = size(C)
527+                                let E = nil
528+                                func bV (G,H) =                                 if ((H >= D))
529+                                    then G
530+                                    else bS(G, C[H])
531+
532+                                func bW (G,H) =                                 if ((H >= D))
533+                                    then G
534+                                    else throw("List size exceeds 10")
535+
536+                                bW(bV(bV(bV(bV(bV(bV(bV(bV(bV(bV(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
537+                                } ++ [StringEntry("static_tokenIds", bG), StringEntry("static_feeToken", bR), StringEntry("static_tokenWeights", bH), IntegerEntry("static_tokensAmount", size(bO)), StringEntry("static_poolDomain", bJ), StringEntry("static_baseTokenId", bI), StringEntry("static_poolOwner", bK), IntegerEntry("static_fee", bL)])
538+                        }
539+    }
540+
541+
542+
543+@Callable(bF)
544+func deInit () = if ((bF.caller != this))
545+    then throw("admin only")
546+    else [IntegerEntry("global_wasInited", 0)]
547+
548+
549+
550+@Callable(bF)
551+func init () = {
552+    func bX () =     {
553+        func al (u,bE) =         (u ++ [IntegerEntry((("global_" + p(bE.assetId)) + "_balance"), bE.amount)])
554+
555+        let C = bF.payments
556+        let D = size(C)
557+        let E = nil
558+        func ap (G,H) =         if ((H >= D))
559+            then G
560+            else al(G, C[H])
561+
562+        func aq (G,H) =         if ((H >= D))
563+            then G
564+            else throw("List size exceeds 10")
565+
566+        aq(ap(ap(ap(ap(ap(ap(ap(ap(ap(ap(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
567+        }
568+
569+    func bY (ak) =     {
570+        func al (u,bZ) =         {
571+            let q = bZ.assetId
572+            func aJ (u,bE) =             if ((bE == q))
573+                then value(indexOf(B, bE))
574+                else u
575+
576+            let ca = {
577+                let C = B
578+                let D = size(C)
579+                let E = 1
580+                func ap (G,H) =                 if ((H >= D))
581+                    then G
582+                    else aJ(G, C[H])
583+
584+                func aq (G,H) =                 if ((H >= D))
585+                    then G
586+                    else throw("List size exceeds 10")
587+
588+                aq(ap(ap(ap(ap(ap(ap(ap(ap(ap(ap(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
589+                }
590+            fraction(u, pow(bZ.amount, M[ca], J[ca], T, 8, FLOOR), V)
591+            }
592+
593+        let C = ak
594+        let D = size(C)
595+        let E = Y
596+        func ap (G,H) =         if ((H >= D))
597+            then G
598+            else al(G, C[H])
599+
600+        func aq (G,H) =         if ((H >= D))
601+            then G
602+            else throw("List size exceeds 10")
603+
604+        aq(ap(ap(ap(ap(ap(ap(ap(ap(ap(ap(E, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
605+        }
606+
607+    if ((j("global_wasInited") > 0))
608+        then throw("pool already inited")
609+        else {
610+            let cb = bY(bF.payments)
611+            if ((cb == 0))
612+                then throw("you need a bigger tokens amount to launch the pool")
613+                else {
614+                    let cc = Issue(("PZ " + o("static_poolDomain")), "Puzzle Swap: pool index token", cb, X, true, unit, 0)
615+                    let cd = calculateAssetId(cc)
616+                    (bX() ++ [cc, IntegerEntry("global_poolToken_amount", cb), IntegerEntry("global_wasInited", 1), BinaryEntry("global_poolToken_id", cd), StringEntry("static_poolToken_idStr", p(cd)), IntegerEntry((toString(bF.caller) + "_indexStaked"), cb), IntegerEntry("global_indexStaked", cb)])
617+                    }
618+            }
619+    }
620+
621+
622+
623+@Callable(bF)
624+func generateIndex (aP) = if ((size(bF.payments) != A))
625+    then throw(("you need to attach all pool tokens. amount of pool tokens: " + toString(A)))
626+    else if (!(aF(bF.payments)))
627+        then throw("wrong assets attached")
628+        else {
629+            let an = aj(bF.payments)
630+            let ce = Reissue(getBinaryValue("global_poolToken_id"), an, true)
631+            let cf = aN(an, bF.payments, bF.originCaller, aP)
632+            $Tuple2((cf ++ [ce, ScriptTransfer(bF.caller, an, n("global_poolToken_id")), IntegerEntry("global_poolToken_amount", (j("global_poolToken_amount") + an))]), an)
633+            }
634+
635+
636+
637+@Callable(bF)
638+func stakeIndex () = {
639+    let bw = toString(bF.originCaller)
640+    let bZ = bF.payments[0]
641+    if ((value(bZ.assetId) != n("global_poolToken_id")))
642+        then throw("wrong asset attached")
643+        else bB(bw, bZ.amount)
644+    }
645+
646+
647+
648+@Callable(bF)
649+func unstakeIndex (bx) = {
650+    let bw = toString(bF.originCaller)
651+    let cg = j((bw + "_indexStaked"))
652+    if ((bx > cg))
653+        then throw("you don't have index tokens available")
654+        else if (aa())
655+            then throw("contract is on stop")
656+            else (bu(bF.originCaller)._1 ++ [IntegerEntry((bw + "_indexStaked"), (cg - bx)), IntegerEntry("global_indexStaked", (j("global_indexStaked") - bx)), ScriptTransfer(bF.caller, bx, getBinaryValue("global_poolToken_id"))])
657+    }
658+
659+
660+
661+@Callable(bF)
662+func claimIndexRewards () = if (aa())
663+    then throw("contract is on stop")
664+    else bu(bF.caller)
665+
666+
667+
668+@Callable(bF)
669+func evaluateClaim (ch) = $Tuple2(nil, bu(addressFromStringValue(ch))._2)
670+
671+
672+
673+@Callable(bF)
674+func redeemIndex (ci) = {
675+    let bZ = bF.payments[0]
676+    if ((bZ.assetId != n("global_poolToken_id")))
677+        then throw("please attach pool share token")
678+        else if (aa())
679+            then throw("contract is on stop")
680+            else {
681+                let ba = bZ.amount
682+                let cf = aZ(ba, if (ci)
683+                    then bF.originCaller
684+                    else bF.caller)
685+                (cf ++ [Burn(n("global_poolToken_id"), ba), IntegerEntry("global_poolToken_amount", (j("global_poolToken_amount") - ba))])
686+                }
687+    }
688+
689+
690+
691+@Callable(bF)
692+func swap (bf,cj) = {
693+    let bZ = if ((size(bF.payments) == 1))
694+        then value(bF.payments[0])
695+        else throw("please attach exactly one payment")
696+    let bd = value(bF.payments[0].amount)
697+    let ck = bZ.assetId
698+    let cl = r(bf)
699+    let cm = o("static_feeToken")
700+    let cn = if ((cm == ""))
701+        then a
702+        else fromBase58String(cm)
703+    let co = j((("global_" + p(ck)) + "_balance"))
704+    let cp = j((("global_" + bf) + "_balance"))
705+    let cq = fraction(bd, S, W)
706+    let cr = (bd - cq)
707+    let cs = bc(cr, ck, cl, co, cp)
708+    let ct = (cp - cs)
709+    let cu = (co + cr)
710+    let cv = if ((cn == ck))
711+        then cu
712+        else if ((cn == cl))
713+            then ct
714+            else j((("global_" + p(cn)) + "_balance"))
715+    let cw = bc(cq, ck, cn, co, cv)
716+    if ((cj > cs))
717+        then throw(("amount to recieve is lower than given one: " + toString(cs)))
718+        else if ((cl == ck))
719+            then throw("this swap is not allowed")
720+            else if ((0 > (cp - cs)))
721+                then throw("contract is out of reserves")
722+                else if (aa())
723+                    then throw("contract is on stop")
724+                    else {
725+                        let cx = fraction(cw, 1, 10)
726+                        let cy = fraction(cw, 4, 10)
727+                        let cz = if ((cn == a))
728+                            then reentrantInvoke(Address(base58'3PFTbywqxtFfukX3HyT881g4iW5K4QL3FAS'), "topUpReward", nil, [AttachedPayment(cn, cy)])
729+                            else unit
730+                        if ((cz == cz))
731+                            then {
732+                                let cA = (cu - (if ((ck == cn))
733+                                    then cw
734+                                    else 0))
735+                                let cB = (ct - (if ((cl == cn))
736+                                    then cw
737+                                    else 0))
738+                                let cC = if (if ((cn != ck))
739+                                    then (cn != cl)
740+                                    else false)
741+                                    then (cv - cw)
742+                                    else unit
743+                                let cD = IntegerEntry((("global_" + p(ck)) + "_balance"), cA)
744+                                let cE = IntegerEntry((("global_" + bf) + "_balance"), cB)
745+                                let cF = if ((cC != unit))
746+                                    then IntegerEntry((("global_" + p(cn)) + "_balance"), cv)
747+                                    else StringEntry("hello", "world")
748+                                $Tuple2(([cE, cD, cF, ScriptTransfer(bF.caller, cs, cl), ScriptTransfer(addressFromStringValue(o("static_poolOwner")), cx, cn), IntegerEntry("global_earnedByOwner", (j("global_earnedByOwner") + cx)), IntegerEntry("global_volume", (j("global_volume") + ar(ck, bd, co, cv)))] ++ (if ((cz == unit))
749+                                    then [ScriptTransfer(Address(base58'3P4kBiU4wr2yV1S5gMfu3MdkVvy7kxXHsKe'), cy, cn)]
750+                                    else nil)), cs)
751+                                }
752+                            else throw("Strict value is not equal to itself.")
753+                        }
754+    }
755+
756+
757+@Verifier(cG)
758+func cH () = if (aa())
759+    then false
760+    else if (sigVerify(cG.bodyBytes, cG.proofs[0], cG.senderPublicKey))
761+        then true
762+        else sigVerify(cG.bodyBytes, cG.proofs[0], i)
763+
github/deemru/w8io/3ef1775 
39.97 ms ◑