tx · 9FrfSHfpi8eaq1cXYDGNWYbXTHt5tfBftaY53v2qFEFR

3PJEUtmcUTUj4UVgEPQi8Un5rpKvR4pFW5F:  -0.03200000 Waves

2023.06.15 01:07 [3688485] smart account 3PJEUtmcUTUj4UVgEPQi8Un5rpKvR4pFW5F > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9FrfSHfpi8eaq1cXYDGNWYbXTHt5tfBftaY53v2qFEFR",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1686780516792,
    "version": 2,
    "chainId": 87,
    "sender": "3PJEUtmcUTUj4UVgEPQi8Un5rpKvR4pFW5F",
    "senderPublicKey": "J3r76AEyKQeQyipx2NF8PXqD22qJKHe59vMo2cGonL6W",
    "proofs": [
        "39FXdhuyp5WR3iJ85gj1ZUvCicoa4tLVNSpdtW5vNzim4KZLRnecGmneLZFRwQwKCErhmeLspCqwPUrTgEGjwqAH"
    ],
    "script": "base64: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",
    "height": 3688485,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: DPaX9ipyYYLcgWprchuV145e6LMJXxSeJ5X166TKAbMP

Full: 

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