tx · 7VQkCP7eVgoM4GVmroL11bc1cwPph2PtKxYNbYwVpm6P

3N4WiZFC8jGMNvHwycYMZjgWqa1yFhG7STx:  -0.02600000 Waves

2024.10.14 13:58 [3326419] smart account 3N4WiZFC8jGMNvHwycYMZjgWqa1yFhG7STx > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "7VQkCP7eVgoM4GVmroL11bc1cwPph2PtKxYNbYwVpm6P",
    "fee": 2600000,
    "feeAssetId": null,
    "timestamp": 1728903562978,
    "version": 2,
    "chainId": 84,
    "sender": "3N4WiZFC8jGMNvHwycYMZjgWqa1yFhG7STx",
    "senderPublicKey": "4x7pnj1zoxtD3sm66ZjPX4ZAcuMVa5BXyJ4vEtTzWdSQ",
    "proofs": [
        "5ZAXtX8FwBSRiZ61kZdspEGxMJcvACKJqzrXUvhMCxy66VWe2DTCCSBqBhEHZWf2mmo58v2QgxX4caXdjzBxwgHK"
    ],
    "script": "base64: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",
    "height": 3326419,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: GZeFQwKE2CkCXXrpSWxcMnXnVgDtC3rEdJG4BdpZyUHV

Full: 

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