tx · FjBfhctLNEGBhmDTMiNyRt6anbei8C2NMC1t9CVpETg4

3NCSkSKFXn5HxJhKFRVEjaZexubfTjdsvLk:  -0.02300000 Waves

2023.09.26 10:32 [2772082] smart account 3NCSkSKFXn5HxJhKFRVEjaZexubfTjdsvLk > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "FjBfhctLNEGBhmDTMiNyRt6anbei8C2NMC1t9CVpETg4",
    "fee": 2300000,
    "feeAssetId": null,
    "timestamp": 1695713504777,
    "version": 2,
    "chainId": 84,
    "sender": "3NCSkSKFXn5HxJhKFRVEjaZexubfTjdsvLk",
    "senderPublicKey": "EiQRGyXMSPywdZJcLQzgNDBrrvLUyhi8X8EeNn1KTjKu",
    "proofs": [
        "5fvSLGnmFKBNP8gx6CoUCJJXzugzdjzM8R9tM8SVqqrNLGZBc9ysr5heRWeZ3gQRifVvovQq7hyPD3K1ra87iR6e"
    ],
    "script": "base64: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",
    "height": 2772082,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: BJAKoPXKEdFMoca254FBVuz9b5X3cF3cPc7HWVqd1tvr

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, d)
227+    let aA = indexOf(D, unit)
228+    let aB = l((("static_" + r(s)) + "_weight"))
229+    let aC = q("static_feeToken")
230+    if ((aC == f))
231+        then {
232+            let aD = L[value(indexOf(D, b))]
233+            let aE = l((("global_" + f) + "_balance"))
234+            let aF = fraction(ai, (aE / aD), (au / aB))
235+            let aG = getIntegerValue(i, "global_lastPuzzlePrice")
236+            fraction((aF * aG), 1, X)
237+            }
238+        else if ((aC == g))
239+            then {
240+                let aH = L[value(ay)]
241+                let aI = l((("global_" + g) + "_balance"))
242+                fraction(ai, (aI / aH), (au / aB))
243+                }
244+            else if ((aC == h))
245+                then {
246+                    let aH = L[value(az)]
247+                    let aI = l((("global_" + h) + "_balance"))
248+                    fraction(ai, (aI / aH), (au / aB))
249+                    }
250+                else if ((aC == e))
251+                    then {
252+                        let aJ = L[value(indexOf(D, a))]
253+                        let aK = {
254+                            let n = av
255+                            if ($isInstanceOf(n, "Int"))
256+                                then {
257+                                    let ad = n
258+                                    av
259+                                    }
260+                                else l((("global_" + r(a)) + "_balance"))
261+                            }
262+                        fraction(ai, (value(aK) / aJ), (au / aB))
263+                        }
264+                    else {
265+                        let aL = 3000
266+                        let aM = (l("global_WAVES_balance") / 50)
267+                        fraction(ai, (aM / aL), (au / aB))
268+                        }
269+    }
270+
271+
272+func aN (am) = {
273+    func aO (w,aP) =     (w ++ [aP.assetId])
274+
275+    let aQ = {
276+        let E = am
277+        let F = size(E)
278+        let G = nil
279+        func ar (I,J) =         if ((J >= F))
280+            then I
281+            else aO(I, E[J])
282+
283+        func as (I,J) =         if ((J >= F))
284+            then I
285+            else throw("List size exceeds 10")
286+
287+        as(ar(ar(ar(ar(ar(ar(ar(ar(ar(ar(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
288+        }
289+    if ((aQ == aQ))
290+        then {
291+            func aR (w,s) =             if ((indexOf(aQ, s) != unit))
292+                then (w + 1)
293+                else throw(("asset not attached: " + r(s)))
294+
295+            let aS = {
296+                let E = D
297+                let F = size(E)
298+                let G = 0
299+                func aT (I,J) =                 if ((J >= F))
300+                    then I
301+                    else aR(I, E[J])
302+
303+                func aU (I,J) =                 if ((J >= F))
304+                    then I
305+                    else throw("List size exceeds 10")
306+
307+                aU(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
308+                }
309+            if ((aS == aS))
310+                then true
311+                else throw("Strict value is not equal to itself.")
312+            }
313+        else throw("Strict value is not equal to itself.")
314+    }
315+
316+
317+func aV (ap,am,aW,aX) = {
318+    func aY (ag) =     {
319+        func an (w,aP) =         if ((aP.assetId == ag))
320+            then aP.amount
321+            else w
322+
323+        let E = am
324+        let F = size(E)
325+        let G = 0
326+        func ar (I,J) =         if ((J >= F))
327+            then I
328+            else an(I, E[J])
329+
330+        func as (I,J) =         if ((J >= F))
331+            then I
332+            else throw("List size exceeds 10")
333+
334+        as(ar(ar(ar(ar(ar(ar(ar(ar(ar(ar(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
335+        }
336+
337+    func aZ (w,ag) =     {
338+        let ba = l((("global_" + r(ag)) + "_balance"))
339+        let bb = l("global_poolToken_amount")
340+        let bc = l((("static_" + r(ag)) + "_scale"))
341+        let bd = fraction((fraction((bb + ap), bc, bb, CEILING) - bc), ba, bc, CEILING)
342+        let be = aY(ag)
343+        let bf = ((if ((be != 0))
344+            then be
345+            else 0) - bd)
346+        let bg = if (if (aX)
347+            then (bf > 0)
348+            else false)
349+            then [ScriptTransfer(aW, bf, ag)]
350+            else nil
351+        ((w ++ bg) ++ [IntegerEntry((("global_" + r(ag)) + "_balance"), (ba + bd))])
352+        }
353+
354+    let E = D
355+    let F = size(E)
356+    let G = nil
357+    func ar (I,J) =     if ((J >= F))
358+        then I
359+        else aZ(I, E[J])
360+
361+    func as (I,J) =     if ((J >= F))
362+        then I
363+        else throw("List size exceeds 10")
364+
365+    as(ar(ar(ar(ar(ar(ar(ar(ar(ar(ar(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
366+    }
367+
368+
369+func bh (bi,aW) = {
370+    func bj (w,ag) =     {
371+        let ba = l((("global_" + r(ag)) + "_balance"))
372+        let bb = l("global_poolToken_amount")
373+        let bc = l((("static_" + r(ag)) + "_scale"))
374+        let ai = toInt(fraction((toBigInt(X) - fraction(toBigInt((bb - bi)), toBigInt(X), toBigInt(bb), CEILING)), toBigInt(ba), toBigInt(X), DOWN))
375+        (w ++ [IntegerEntry((("global_" + r(ag)) + "_balance"), (ba - ai)), ScriptTransfer(aW, ai, ag)])
376+        }
377+
378+    let E = D
379+    let F = size(E)
380+    let G = nil
381+    func ar (I,J) =     if ((J >= F))
382+        then I
383+        else bj(I, E[J])
384+
385+    func as (I,J) =     if ((J >= F))
386+        then I
387+        else throw("List size exceeds 10")
388+
389+    as(ar(ar(ar(ar(ar(ar(ar(ar(ar(ar(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
390+    }
391+
392+
393+func bk (bl,bm,bn,bo,bp) = {
394+    let bq = value(indexOf(D, bm))
395+    let br = value(indexOf(D, bn))
396+    if ((bq == br))
397+        then bl
398+        else fraction(bp, ((X * X) - toInt(pow(fraction(toBigInt(bo), toBigInt((X * X)), toBigInt((bo + bl)), HALFUP), 16, toBigInt(fraction(L[bq], 10000, L[br])), 4, 16, CEILING))), (X * X), DOWN)
399+    }
400+
401+
402+func bs (s) = {
403+    let n = s
404+    if ($isInstanceOf(n, "ByteVector"))
405+        then {
406+            let bg = n
407+            assetBalance(this, bg)
408+            }
409+        else wavesBalance(this).available
410+    }
411+
412+
413+func bt (s,u,au,bu) = {
414+    let bv = l("global_indexStaked")
415+    let bw = bu
416+    let bx = (bs(s) - au)
417+    let by = if ((bx > bw))
418+        then bx
419+        else bw
420+    let bz = (by - bw)
421+    let bA = if ((bv == 0))
422+        then 0
423+        else fraction(bz, X, bv)
424+    let bB = l((("global_lastCheck_" + u) + "_interest"))
425+    (bB + bA)
426+    }
427+
428+
429+func bC (bD) = {
430+    let bE = toString(bD)
431+    let bF = l((bE + "_indexStaked"))
432+    func an (w,s) =     {
433+        let u = r(s)
434+        let au = l((("global_" + r(s)) + "_balance"))
435+        let bu = l((("global_lastCheck_" + u) + "_earnings"))
436+        let bG = bt(s, u, au, bu)
437+        let by = max([bu, (bs(s) - au)])
438+        let bH = fraction(bF, (bG - l((((bE + "_lastCheck_") + u) + "_interest"))), X)
439+        let bI = if ((bH == 0))
440+            then nil
441+            else [ScriptTransfer(bD, bH, s)]
442+        $Tuple2(((w._1 ++ bI) ++ [IntegerEntry((("global_lastCheck_" + u) + "_earnings"), (by - bH)), IntegerEntry((("global_lastCheck_" + u) + "_interest"), bG), IntegerEntry((((bE + "_lastCheck_") + u) + "_interest"), bG)]), (w._2 + at(s, bH, au, unit)))
443+        }
444+
445+    let w = {
446+        let E = ab
447+        let F = size(E)
448+        let G = $Tuple2(nil, 0)
449+        func ar (I,J) =         if ((J >= F))
450+            then I
451+            else an(I, E[J])
452+
453+        func as (I,J) =         if ((J >= F))
454+            then I
455+            else throw("List size exceeds 10")
456+
457+        as(ar(ar(ar(ar(ar(ar(ar(ar(ar(ar(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
458+        }
459+    $Tuple2((w._1 ++ [IntegerEntry((bE + "_claimedRewardValue"), (l((bE + "_claimedRewardValue")) + w._2)), IntegerEntry((bE + "_lastClaim"), lastBlock.timestamp)]), w._2)
460+    }
461+
462+
463+func bJ (bE,ai) = {
464+    let bK = bC(addressFromStringValue(bE))._1
465+    (bK ++ [IntegerEntry((bE + "_indexStaked"), (l((bE + "_indexStaked")) + ai)), IntegerEntry("global_indexStaked", (l("global_indexStaked") + ai))])
466+    }
467+
468+
469+func bL (w,bM) = (w + parseIntValue(bM))
470+
471+
472+@Callable(bN)
473+func preInit (bO,bP,bQ,bR,bS,bT) = {
474+    let bU = Address(fromBase58String(bS))
475+    if (ac())
476+        then throw("contract is on stop")
477+        else if ((this != bN.caller))
478+            then throw("admin only")
479+            else if ((size(bR) > 13))
480+                then throw("too large pool domain")
481+                else if (if ((bT > 500))
482+                    then true
483+                    else (50 > bT))
484+                    then throw("fee value must be between 50 and 500 (0.5-5%)")
485+                    else if (if (if (if (if ((indexOf(bO, f) == unit))
486+                        then (indexOf(bO, e) == unit)
487+                        else false)
488+                        then (indexOf(bO, g) == unit)
489+                        else false)
490+                        then (indexOf(bO, "WAVES") == unit)
491+                        else false)
492+                        then (indexOf(bO, h) == unit)
493+                        else false)
494+                        then throw("pool must have USDT-WXG, USDT-PPT, USDN, WAVES or PUZZLE in the composition")
495+                        else {
496+                            let bV = split(bO, ",")
497+                            let bW = {
498+                                let E = bV
499+                                let F = size(E)
500+                                let G = nil
501+                                func ar (I,J) =                                 if ((J >= F))
502+                                    then I
503+                                    else v(I, E[J])
504+
505+                                func as (I,J) =                                 if ((J >= F))
506+                                    then I
507+                                    else throw("List size exceeds 10")
508+
509+                                as(ar(ar(ar(ar(ar(ar(ar(ar(ar(ar(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
510+                                }
511+                            let bX = split(bP, ",")
512+                            let bY = {
513+                                let E = bX
514+                                let F = size(E)
515+                                let G = 0
516+                                func aT (I,J) =                                 if ((J >= F))
517+                                    then I
518+                                    else bL(I, E[J])
519+
520+                                func aU (I,J) =                                 if ((J >= F))
521+                                    then I
522+                                    else throw("List size exceeds 10")
523+
524+                                aU(aT(aT(aT(aT(aT(aT(aT(aT(aT(aT(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
525+                                }
526+                            let aC = if ((indexOf(bO, e) != unit))
527+                                then e
528+                                else if ((indexOf(bO, "WAVES") != unit))
529+                                    then "WAVES"
530+                                    else if ((indexOf(bO, g) != unit))
531+                                        then g
532+                                        else if ((indexOf(bO, f) != unit))
533+                                            then f
534+                                            else h
535+                            func bZ (w,ca) =                             if ((ca >= size(bW)))
536+                                then w
537+                                else {
538+                                    let cb = {
539+                                        let n = bW[ca]
540+                                        if ($isInstanceOf(n, "ByteVector"))
541+                                            then {
542+                                                let ad = n
543+                                                value(assetInfo(ad)).decimals
544+                                                }
545+                                            else 8
546+                                        }
547+                                    (w ++ [IntegerEntry((("static_" + bV[ca]) + "_scale"), pow(10, 0, cb, 0, 0, DOWN)), IntegerEntry((("static_" + bV[ca]) + "_decimals"), cb), IntegerEntry((("static_" + bV[ca]) + "_weight"), value(parseInt(bX[ca])))])
548+                                    }
549+
550+                            if ((bY != 10000))
551+                                then throw("sum of token weights must be equal to 10000")
552+                                else ({
553+                                    let E = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
554+                                    let F = size(E)
555+                                    let G = nil
556+                                    func cc (I,J) =                                     if ((J >= F))
557+                                        then I
558+                                        else bZ(I, E[J])
559+
560+                                    func cd (I,J) =                                     if ((J >= F))
561+                                        then I
562+                                        else throw("List size exceeds 10")
563+
564+                                    cd(cc(cc(cc(cc(cc(cc(cc(cc(cc(cc(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
565+                                    } ++ [StringEntry("static_tokenIds", bO), StringEntry("static_feeToken", aC), StringEntry("static_tokenWeights", bP), IntegerEntry("static_tokensAmount", size(bW)), StringEntry("static_poolDomain", bR), StringEntry("static_baseTokenId", bQ), StringEntry("static_poolOwner", bS), IntegerEntry("static_fee", bT)])
566+                            }
567+    }
568+
569+
570+
571+@Callable(bN)
572+func deInit () = if (ac())
573+    then throw("contract is on stop")
574+    else if ((bN.caller != this))
575+        then throw("admin only")
576+        else [IntegerEntry("global_wasInited", 0)]
577+
578+
579+
580+@Callable(bN)
581+func init () = {
582+    func ce () =     {
583+        func an (w,bM) =         (w ++ [IntegerEntry((("global_" + r(bM.assetId)) + "_balance"), bM.amount)])
584+
585+        let E = bN.payments
586+        let F = size(E)
587+        let G = nil
588+        func ar (I,J) =         if ((J >= F))
589+            then I
590+            else an(I, E[J])
591+
592+        func as (I,J) =         if ((J >= F))
593+            then I
594+            else throw("List size exceeds 10")
595+
596+        as(ar(ar(ar(ar(ar(ar(ar(ar(ar(ar(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
597+        }
598+
599+    func cf (am) =     {
600+        func an (w,cg) =         {
601+            let s = cg.assetId
602+            func aR (w,bM) =             if ((bM == s))
603+                then value(indexOf(D, bM))
604+                else w
605+
606+            let ch = {
607+                let E = D
608+                let F = size(E)
609+                let G = 1
610+                func ar (I,J) =                 if ((J >= F))
611+                    then I
612+                    else aR(I, E[J])
613+
614+                func as (I,J) =                 if ((J >= F))
615+                    then I
616+                    else throw("List size exceeds 10")
617+
618+                as(ar(ar(ar(ar(ar(ar(ar(ar(ar(ar(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
619+                }
620+            fraction(w, pow(cg.amount, O[ch], L[ch], V, 8, FLOOR), X)
621+            }
622+
623+        let E = am
624+        let F = size(E)
625+        let G = aa
626+        func ar (I,J) =         if ((J >= F))
627+            then I
628+            else an(I, E[J])
629+
630+        func as (I,J) =         if ((J >= F))
631+            then I
632+            else throw("List size exceeds 10")
633+
634+        as(ar(ar(ar(ar(ar(ar(ar(ar(ar(ar(G, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
635+        }
636+
637+    if (ac())
638+        then throw("contract is on stop")
639+        else if ((l("global_wasInited") > 0))
640+            then throw("pool already inited")
641+            else {
642+                let ci = cf(bN.payments)
643+                if ((ci == 0))
644+                    then throw("you need a bigger tokens amount to launch the pool")
645+                    else {
646+                        let cj = Issue(("PZ " + q("static_poolDomain")), "Puzzle Swap: pool index token", ci, Z, true, unit, 0)
647+                        let ck = calculateAssetId(cj)
648+                        (ce() ++ [cj, IntegerEntry("global_poolToken_amount", ci), IntegerEntry("global_wasInited", 1), BinaryEntry("global_poolToken_id", ck), StringEntry("static_poolToken_idStr", r(ck)), IntegerEntry((toString(bN.caller) + "_indexStaked"), ci), IntegerEntry("global_indexStaked", ci)])
649+                        }
650+                }
651+    }
652+
653+
654+
655+@Callable(bN)
656+func generateIndex (aX) = if ((size(bN.payments) != C))
657+    then throw(("you need to attach all pool tokens. amount of pool tokens: " + toString(C)))
658+    else if (!(aN(bN.payments)))
659+        then throw("wrong assets attached")
660+        else {
661+            let ap = al(bN.payments)
662+            let cl = Reissue(getBinaryValue("global_poolToken_id"), ap, true)
663+            let cm = aV(ap, bN.payments, bN.originCaller, aX)
664+            $Tuple2((cm ++ [cl, ScriptTransfer(bN.caller, ap, p("global_poolToken_id")), IntegerEntry("global_poolToken_amount", (l("global_poolToken_amount") + ap))]), ap)
665+            }
666+
667+
668+
669+@Callable(bN)
670+func stakeIndex () = {
671+    let bE = toString(bN.originCaller)
672+    let cg = bN.payments[0]
673+    if ((value(cg.assetId) != p("global_poolToken_id")))
674+        then throw("wrong asset attached")
675+        else bJ(bE, cg.amount)
676+    }
677+
678+
679+
680+@Callable(bN)
681+func unstakeIndex (bF) = {
682+    let bE = toString(bN.originCaller)
683+    let cn = l((bE + "_indexStaked"))
684+    if (ac())
685+        then throw("contract is on stop")
686+        else if ((bF > cn))
687+            then throw("you don't have index tokens available")
688+            else if (ac())
689+                then throw("contract is on stop")
690+                else (bC(bN.originCaller)._1 ++ [IntegerEntry((bE + "_indexStaked"), (cn - bF)), IntegerEntry("global_indexStaked", (l("global_indexStaked") - bF)), ScriptTransfer(bN.caller, bF, getBinaryValue("global_poolToken_id"))])
691+    }
692+
693+
694+
695+@Callable(bN)
696+func claimIndexRewards () = if (ac())
697+    then throw("contract is on stop")
698+    else bC(bN.caller)
699+
700+
701+
702+@Callable(bN)
703+func evaluateClaim (co) = $Tuple2(nil, bC(addressFromStringValue(co))._2)
704+
705+
706+
707+@Callable(bN)
708+func redeemIndex (cp) = {
709+    let cg = bN.payments[0]
710+    if ((cg.assetId != p("global_poolToken_id")))
711+        then throw("please attach pool share token")
712+        else if (ac())
713+            then throw("contract is on stop")
714+            else {
715+                let bi = cg.amount
716+                let cm = bh(bi, if (cp)
717+                    then bN.originCaller
718+                    else bN.caller)
719+                (cm ++ [Burn(p("global_poolToken_id"), bi), IntegerEntry("global_poolToken_amount", (l("global_poolToken_amount") - bi))])
720+                }
721+    }
722+
723+
724+
725+@Callable(bN)
726+func swap (bn,cq) = {
727+    let cg = if ((size(bN.payments) == 1))
728+        then value(bN.payments[0])
729+        else throw("please attach exactly one payment")
730+    let bl = value(bN.payments[0].amount)
731+    let cr = cg.assetId
732+    let cs = t(bn)
733+    let ct = q("static_feeToken")
734+    let cu = if ((ct == ""))
735+        then a
736+        else t(ct)
737+    let cv = l((("global_" + r(cr)) + "_balance"))
738+    let cw = l((("global_" + bn) + "_balance"))
739+    let cx = fraction(bl, U, Y)
740+    let cy = (bl - cx)
741+    let cz = bk(cy, cr, cs, cv, cw)
742+    let cA = (cw - cz)
743+    let cB = (cv + cy)
744+    let cC = if ((cu == cr))
745+        then cB
746+        else if ((cu == cs))
747+            then cA
748+            else l((("global_" + r(cu)) + "_balance"))
749+    let cD = bk(cx, cr, cu, cv, cC)
750+    if ((cq > cz))
751+        then throw("amount to recieve is lower than given one")
752+        else if ((cs == cr))
753+            then throw("this swap is not allowed")
754+            else if ((0 > (cw - cz)))
755+                then throw("contract is out of reserves")
756+                else if (ac())
757+                    then throw("contract is on stop")
758+                    else {
759+                        let cE = fraction(cD, 1, 10)
760+                        let cF = fraction(cD, 4, 10)
761+                        let cG = if (if ((cu == a))
762+                            then true
763+                            else (cu == b))
764+                            then reentrantInvoke(Address(base58'3PFTbywqxtFfukX3HyT881g4iW5K4QL3FAS'), "topUpReward", nil, [AttachedPayment(cu, cF)])
765+                            else unit
766+                        if ((cG == cG))
767+                            then {
768+                                let cH = cB
769+                                let cI = (cA - (if ((cs == cu))
770+                                    then cD
771+                                    else 0))
772+                                let cJ = if (if ((cu != cr))
773+                                    then (cu != cs)
774+                                    else false)
775+                                    then (cC - cD)
776+                                    else unit
777+                                let cK = IntegerEntry((("global_" + r(cr)) + "_balance"), cH)
778+                                let cL = IntegerEntry((("global_" + bn) + "_balance"), cI)
779+                                let cM = if ((cJ != unit))
780+                                    then IntegerEntry((("global_" + r(cu)) + "_balance"), value(cJ))
781+                                    else StringEntry("hello", "world")
782+                                let cN = at(cr, bl, cv, cC)
783+                                $Tuple2(([cL, cK, cM, ScriptTransfer(bN.caller, cz, cs), ScriptTransfer(addressFromStringValue(q("static_poolOwner")), cE, cu), IntegerEntry("global_earnedByOwner", (l("global_earnedByOwner") + cE)), IntegerEntry("global_volume", (l("global_volume") + cN))] ++ (if ((cG == unit))
784+                                    then [ScriptTransfer(Address(base58'3PFWAVKmXjfHXyzJb12jCbhP4Uhi9t4uWiD'), cF, cu)]
785+                                    else nil)), cz)
786+                                }
787+                            else throw("Strict value is not equal to itself.")
788+                        }
789+    }
790+
791+
792+
793+@Callable(bN)
794+func transferOwnership (cO) = if ((toString(bN.caller) != q("static_poolOwner")))
795+    then throw("this call available only for pool owner")
796+    else [StringEntry("static_poolOwner", cO)]
797+
798+
799+@Verifier(cP)
800+func cQ () = if (ac())
801+    then false
802+    else if (sigVerify(cP.bodyBytes, cP.proofs[0], cP.senderPublicKey))
803+        then true
804+        else sigVerify(cP.bodyBytes, cP.proofs[0], k)
805+
github/deemru/w8io/169f3d6 
51.75 ms ◑