tx · AZH1P4BFQHDjd24qSq4S9BXkbaa8mmV263zsxzBKAkkW

3NAmMfoooCbyCCU9oV3cpjB7hhi3p344SqX:  -0.10000000 Waves

2022.11.06 18:18 [2305433] smart account 3NAmMfoooCbyCCU9oV3cpjB7hhi3p344SqX > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "AZH1P4BFQHDjd24qSq4S9BXkbaa8mmV263zsxzBKAkkW",
    "fee": 10000000,
    "feeAssetId": null,
    "timestamp": 1667747930749,
    "version": 1,
    "sender": "3NAmMfoooCbyCCU9oV3cpjB7hhi3p344SqX",
    "senderPublicKey": "6wh2k2M52zz96CQbrSbgQk6U7QJejQw67s7FmdVtj85U",
    "proofs": [
        "3fGVJmByf16SQJQhZezGjEmK39qQqPg9uY8HUA2HwVvP47mXJNLyT5sKADbND55YLnodpm72E1dqyEupDhkJ5Ti4"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2305433,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = getIntegerValue(this, "N_COINS")
5+
6+let b = toBigInt(a)
7+
8+let c = 10
9+
10+let d = 6
11+
12+let e = 1000000
13+
14+let f = 10000000000
15+
16+let g = 1000000
17+
18+let h = 6
19+
20+let i = 10000000000
21+
22+let j = 5000000000
23+
24+let k = 1000000
25+
26+let l = 10
27+
28+let m = ((3 * 86400) / 60)
29+
30+let n = (86400 / 60)
31+
32+let o = 86400000
33+
34+let p = 1000000000000
35+
36+let q = split(getStringValue(this, "coins"), ",")
37+
38+let r = getIntegerValue(this, "fee")
39+
40+let s = getIntegerValue(this, "admin_fee")
41+
42+let t = getBooleanValue(this, "is_auto_fees")
43+
44+let u = addressFromStringValue(getStringValue(this, "owner"))
45+
46+let v = fromBase58String(getStringValue(this, "token"))
47+
48+let w = value(assetInfo(v)).quantity
49+
50+let x = getIntegerValue(this, "initial_A")
51+
52+let y = getIntegerValue(this, "future_A")
53+
54+let z = valueOrElse(getInteger(this, "initial_A_time"), 0)
55+
56+let B = valueOrElse(getInteger(this, "future_A_time"), 0)
57+
58+let C = valueOrElse(getInteger(this, "admin_actions_deadline"), 0)
59+
60+let D = valueOrElse(getInteger(this, "transfer_ownership_deadline"), 0)
61+
62+let E = getIntegerValue(this, "future_fee")
63+
64+let F = getIntegerValue(this, "future_admin_fee")
65+
66+let G = getStringValue(this, "future_owner")
67+
68+let H = getBooleanValue(this, "is_killed")
69+
70+let I = getIntegerValue(this, "kill_deadline")
71+
72+let J = (((2 * 30) * 86400) / 60)
73+
74+let K = toBigInt(0)
75+
76+let L = toBigInt(1)
77+
78+let M = toBigInt(2)
79+
80+let N = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, "heightAddress"), "no settings defined")), "bad settings address")
81+
82+let O = valueOrElse(getInteger(N, "__MOCK_HEIGHT"), 0)
83+
84+let P = O
85+
86+func Q (R) = if (R)
87+    then false
88+    else true
89+
90+
91+func S (T) = if ((size(T) > c))
92+    then throw("list_itos: list.size() > N_COINS_MAX")
93+    else {
94+        func U (V,W) =         (V :+ toString(W))
95+
96+        let X = T
97+        let Y = size(X)
98+        let Z = nil
99+        func aa (ab,ac) =         if ((ac >= Y))
100+            then ab
101+            else U(ab, X[ac])
102+
103+        func ad (ab,ac) =         if ((ac >= Y))
104+            then ab
105+            else throw("List size exceeds 10")
106+
107+        ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
108+        }
109+
110+
111+func ae (T) = if ((size(T) > c))
112+    then throw("list_stoi: list.size() > N_COINS_MAX")
113+    else {
114+        func U (V,W) =         (V :+ parseIntValue(W))
115+
116+        let X = T
117+        let Y = size(X)
118+        let Z = nil
119+        func aa (ab,ac) =         if ((ac >= Y))
120+            then ab
121+            else U(ab, X[ac])
122+
123+        func ad (ab,ac) =         if ((ac >= Y))
124+            then ab
125+            else throw("List size exceeds 10")
126+
127+        ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
128+        }
129+
130+
131+let af = ae(split(getStringValue(this, "balances"), ","))
132+
133+let ag = ae(split(getStringValue(this, "rates"), ","))
134+
135+let ah = size(ag)
136+
137+let ai = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
138+
139+func aj (ak) = if ((ak > c))
140+    then throw("index_n: n > N_COINS_MAX")
141+    else {
142+        func U (V,al) =         if ((ak > al))
143+            then (V :+ al)
144+            else V
145+
146+        let X = ai
147+        let Y = size(X)
148+        let Z = nil
149+        func aa (ab,ac) =         if ((ac >= Y))
150+            then ab
151+            else U(ab, X[ac])
152+
153+        func ad (ab,ac) =         if ((ac >= Y))
154+            then ab
155+            else throw("List size exceeds 10")
156+
157+        ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
158+        }
159+
160+
161+let am = aj(a)
162+
163+let an = (am :+ a)
164+
165+func ao (T) = if ((size(T) != a))
166+    then throw("big_list: list.size() != N_COINS")
167+    else {
168+        func U (V,al) =         (V :+ toBigInt(fraction(T[al], e, ag[al])))
169+
170+        let X = am
171+        let Y = size(X)
172+        let Z = nil
173+        func aa (ab,ac) =         if ((ac >= Y))
174+            then ab
175+            else U(ab, X[ac])
176+
177+        func ad (ab,ac) =         if ((ac >= Y))
178+            then ab
179+            else throw("List size exceeds 10")
180+
181+        ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
182+        }
183+
184+
185+func ap (aq) = {
186+    let ar = aq.assetId
187+    if ($isInstanceOf(ar, "ByteVector"))
188+        then {
189+            let as = ar
190+            valueOrErrorMessage(indexOf(q, toBase58String(as)), (toBase58String(as) + " out of pool"))
191+            }
192+        else throw("unsupported assetId")
193+    }
194+
195+
196+func at (au) = if (if ((0 > au))
197+    then true
198+    else (au > a))
199+    then throw("i out of index")
200+    else (assetBalance(this, fromBase58String(q[au])) - af[au])
201+
202+
203+func av (aw) = {
204+    let R = addressFromStringValue(aw)
205+    toString(R)
206+    }
207+
208+
209+let ax = {
210+    let ay = B
211+    let az = y
212+    if ((ay > P))
213+        then {
214+            let aA = x
215+            let aB = z
216+            if ((az > aA))
217+                then (aA + (((az - aA) * (P - aB)) / (ay - aB)))
218+                else (aA - (((aA - az) * (P - aB)) / (ay - aB)))
219+            }
220+        else az
221+    }
222+
223+func aC (T) = {
224+    func U (V,W) =     (V + W)
225+
226+    let X = T
227+    let Y = size(X)
228+    let Z = K
229+    func aa (ab,ac) =     if ((ac >= Y))
230+        then ab
231+        else U(ab, X[ac])
232+
233+    func ad (ab,ac) =     if ((ac >= Y))
234+        then ab
235+        else throw("List size exceeds 10")
236+
237+    ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
238+    }
239+
240+
241+func aD (T) = {
242+    func U (V,W) =     fraction(fraction(V, W, L), b, L)
243+
244+    let X = T
245+    let Y = size(X)
246+    let Z = L
247+    func aa (ab,ac) =     if ((ac >= Y))
248+        then ab
249+        else U(ab, X[ac])
250+
251+    func ad (ab,ac) =     if ((ac >= Y))
252+        then ab
253+        else throw("List size exceeds 10")
254+
255+    ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
256+    }
257+
258+
259+let aE = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
260+
261+func aF (aG,ax) = {
262+    let aH = aC(aG)
263+    if ((toInt(aH) == 0))
264+        then 0
265+        else {
266+            let aI = (ax * a)
267+            let aJ = fraction(toBigInt(aI), aH, L)
268+            let aK = toBigInt((aI - 1))
269+            let aL = aD(aG)
270+            let aM = (a + 1)
271+            let aN = toBigInt(aM)
272+            func aO (W) =             {
273+                func U (V,al) =                 fraction(V, W, L)
274+
275+                let X = an
276+                let Y = size(X)
277+                let Z = L
278+                func aa (ab,ac) =                 if ((ac >= Y))
279+                    then ab
280+                    else U(ab, X[ac])
281+
282+                func ad (ab,ac) =                 if ((ac >= Y))
283+                    then ab
284+                    else throw("List size exceeds 11")
285+
286+                ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11)
287+                }
288+
289+            func aP (V,aQ) =             if ((V._2 == true))
290+                then V
291+                else {
292+                    let aR = V._1
293+                    let aS = fraction(aO(aR), L, aL)
294+                    let aT = fraction((aJ + fraction(b, aS, L)), aR, (fraction(aK, aR, L) + fraction(aN, aS, L)))
295+                    if ((aT > aR))
296+                        then if ((1 >= toInt((aT - aR))))
297+                            then $Tuple2(aT, true)
298+                            else $Tuple2(aT, false)
299+                        else if ((1 >= toInt((aR - aT))))
300+                            then $Tuple2(aT, true)
301+                            else $Tuple2(aT, false)
302+                    }
303+
304+            let aU = {
305+                let X = aE
306+                let Y = size(X)
307+                let Z = $Tuple2(aH, false)
308+                func aa (ab,ac) =                 if ((ac >= Y))
309+                    then ab
310+                    else aP(ab, X[ac])
311+
312+                func ad (ab,ac) =                 if ((ac >= Y))
313+                    then ab
314+                    else throw("List size exceeds 16")
315+
316+                ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
317+                }
318+            let aT = aU._1
319+            let aV = aU._2
320+            if ((aV == false))
321+                then throw(("D_proc() not finished with " + toString(aT)))
322+                else toInt(aT)
323+            }
324+    }
325+
326+
327+func aW (au,aX,aY,aG) = if (Q((au != aX)))
328+    then throw("same coin")
329+    else if (Q(if ((aX >= 0))
330+        then (au >= 0)
331+        else false))
332+        then throw("below zero")
333+        else if (Q(if ((a > aX))
334+            then (a > au)
335+            else false))
336+            then throw("above N_COINS")
337+            else {
338+                let aT = aF(aG, ax)
339+                let aZ = toBigInt(aT)
340+                let ba = toBigInt((ax * a))
341+                func bb (V,al) =                 {
342+                    let bc = V
343+                    let bd = bc._1
344+                    let be = bc._2
345+                    let bf = if ((al == au))
346+                        then toBigInt(fraction(aY, e, ag[al]))
347+                        else aG[al]
348+                    if ((al != aX))
349+                        then $Tuple2((bd + bf), fraction(be, aZ, fraction(bf, b, L)))
350+                        else $Tuple2(bd, be)
351+                    }
352+
353+                let bg = {
354+                    let X = am
355+                    let Y = size(X)
356+                    let Z = $Tuple2(K, aZ)
357+                    func aa (ab,ac) =                     if ((ac >= Y))
358+                        then ab
359+                        else bb(ab, X[ac])
360+
361+                    func ad (ab,ac) =                     if ((ac >= Y))
362+                        then ab
363+                        else throw("List size exceeds 10")
364+
365+                    ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
366+                    }
367+                let bd = bg._1
368+                let bh = bg._2
369+                let be = fraction(bh, aZ, fraction(ba, b, L))
370+                let bi = ((bd + fraction(aZ, L, ba)) - aZ)
371+                func bj (V,aQ) =                 if ((V._2 == true))
372+                    then V
373+                    else {
374+                        let bk = V._1
375+                        let bl = fraction((fraction(bk, bk, L) + be), L, (fraction(M, bk, L) + bi))
376+                        if ((bl > bk))
377+                            then if ((1 >= toInt((bl - bk))))
378+                                then $Tuple2(bl, true)
379+                                else $Tuple2(bl, false)
380+                            else if ((1 >= toInt((bk - bl))))
381+                                then $Tuple2(bl, true)
382+                                else $Tuple2(bl, false)
383+                        }
384+
385+                let bm = {
386+                    let X = aE
387+                    let Y = size(X)
388+                    let Z = $Tuple2(aZ, false)
389+                    func bn (ab,ac) =                     if ((ac >= Y))
390+                        then ab
391+                        else bj(ab, X[ac])
392+
393+                    func bo (ab,ac) =                     if ((ac >= Y))
394+                        then ab
395+                        else throw("List size exceeds 16")
396+
397+                    bo(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
398+                    }
399+                let bl = bm._1
400+                let aV = bm._2
401+                if ((aV == false))
402+                    then throw(("y_proc() not finished with " + toString(bl)))
403+                    else $Tuple2(fraction(toInt(bl), ag[aX], e), aT)
404+                }
405+
406+
407+func bp (ax,au,aG,aT) = if (Q((au >= 0)))
408+    then throw("i below zero")
409+    else if (Q((a > au)))
410+        then throw("i above N_COINS")
411+        else {
412+            let aZ = toBigInt(aT)
413+            let ba = toBigInt((ax * a))
414+            func bb (V,al) =             {
415+                let bq = V
416+                let bd = bq._1
417+                let be = bq._2
418+                let bf = if ((al == au))
419+                    then K
420+                    else aG[al]
421+                if ((al != au))
422+                    then $Tuple2((bd + bf), fraction(be, aZ, fraction(bf, b, L)))
423+                    else $Tuple2(bd, be)
424+                }
425+
426+            let br = {
427+                let X = am
428+                let Y = size(X)
429+                let Z = $Tuple2(K, aZ)
430+                func aa (ab,ac) =                 if ((ac >= Y))
431+                    then ab
432+                    else bb(ab, X[ac])
433+
434+                func ad (ab,ac) =                 if ((ac >= Y))
435+                    then ab
436+                    else throw("List size exceeds 10")
437+
438+                ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
439+                }
440+            let bd = br._1
441+            let bh = br._2
442+            let be = fraction(bh, aZ, fraction(ba, b, L))
443+            let bi = ((bd + fraction(aZ, L, ba)) - aZ)
444+            func bj (V,aQ) =             if ((V._2 == true))
445+                then V
446+                else {
447+                    let bk = V._1
448+                    let bl = fraction((fraction(bk, bk, L) + be), L, (fraction(M, bk, L) + bi))
449+                    if ((bl > bk))
450+                        then if ((1 >= toInt((bl - bk))))
451+                            then $Tuple2(bl, true)
452+                            else $Tuple2(bl, false)
453+                        else if ((1 >= toInt((bk - bl))))
454+                            then $Tuple2(bl, true)
455+                            else $Tuple2(bl, false)
456+                    }
457+
458+            let bs = {
459+                let X = aE
460+                let Y = size(X)
461+                let Z = $Tuple2(aZ, false)
462+                func bn (ab,ac) =                 if ((ac >= Y))
463+                    then ab
464+                    else bj(ab, X[ac])
465+
466+                func bo (ab,ac) =                 if ((ac >= Y))
467+                    then ab
468+                    else throw("List size exceeds 16")
469+
470+                bo(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16)
471+                }
472+            let bl = bs._1
473+            let aV = bs._2
474+            if ((aV == false))
475+                then throw(("y_proc() not finished with " + toString(bl)))
476+                else fraction(toInt(bl), ag[au], e)
477+            }
478+
479+
480+func bt (bu,au) = {
481+    let bv = ((r * a) / (4 * (a - 1)))
482+    let aG = ao(af)
483+    let bw = aF(aG, ax)
484+    let bx = (bw - fraction(bu, bw, w))
485+    let by = bp(ax, au, aG, bx)
486+    let bz = (af[au] - by)
487+    func U (V,al) =     {
488+        let bA = af[al]
489+        let bB = if ((al == au))
490+            then (fraction(bA, bx, bw) - by)
491+            else (bA - fraction(bA, bx, bw))
492+        (V :+ (bA - fraction(bv, bB, f)))
493+        }
494+
495+    let bC = {
496+        let X = am
497+        let Y = size(X)
498+        let Z = nil
499+        func aa (ab,ac) =         if ((ac >= Y))
500+            then ab
501+            else U(ab, X[ac])
502+
503+        func ad (ab,ac) =         if ((ac >= Y))
504+            then ab
505+            else throw("List size exceeds 10")
506+
507+        ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
508+        }
509+    let bD = bC[au]
510+    let bE = ((bD - bp(ax, au, ao(bC), bx)) - 1)
511+    $Tuple3(bE, (bz - bE), bw)
512+    }
513+
514+
515+func bF (aT) = fraction(aT, p, w)
516+
517+
518+func bG (aT,bH) = {
519+    let bI = (parseBigIntValue(valueOrElse(getString("vol"), "0")) + toBigInt(bH))
520+    let bJ = toString(bI)
521+    ([StringEntry("vol", bJ)] ++ {
522+        let bK = toString((lastBlock.timestamp / o))
523+        let bL = ("log_" + bK)
524+        if (isDefined(getString(bL)))
525+            then nil
526+            else [StringEntry(bL, ((((toString(bF(aT)) + "_") + bJ) + "_") + toString(lastBlock.timestamp)))]
527+        })
528+    }
529+
530+
531+func bM (bN) = {
532+    func U (bO,bP) =     if ((bO != ""))
533+        then bO
534+        else {
535+            let bL = ("log_" + toString((bN - bP)))
536+            valueOrElse(getString(bL), "")
537+            }
538+
539+    let bQ = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
540+    let bR = [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20, -21, -22, -23, -24, -25, -26, -27, -28, -29, -30]
541+    let bS = {
542+        let X = bQ
543+        let Y = size(X)
544+        let Z = ""
545+        func aa (ab,ac) =         if ((ac >= Y))
546+            then ab
547+            else U(ab, X[ac])
548+
549+        func ad (ab,ac) =         if ((ac >= Y))
550+            then ab
551+            else throw("List size exceeds 30")
552+
553+        ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30)
554+        }
555+    if ((bS != ""))
556+        then bS
557+        else {
558+            let X = bR
559+            let Y = size(X)
560+            let Z = ""
561+            func bn (ab,ac) =             if ((ac >= Y))
562+                then ab
563+                else U(ab, X[ac])
564+
565+            func bo (ab,ac) =             if ((ac >= Y))
566+                then ab
567+                else throw("List size exceeds 30")
568+
569+            bo(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(bn(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30)
570+            }
571+    }
572+
573+
574+func bT (bU) = {
575+    let bV = bF(aF(ao(af), ax))
576+    let bW = lastBlock.timestamp
577+    let aB = if ((0 >= bU))
578+        then (bW + bU)
579+        else bU
580+    let bX = (aB / o)
581+    let bO = bM(bX)
582+    if ((bO == ""))
583+        then $Tuple3(bV, bV, 0)
584+        else {
585+            let bY = split(bO, "_")
586+            let bZ = parseIntValue(bY[0])
587+            let ca = parseIntValue(bY[2])
588+            $Tuple3(bV, bZ, (bW - ca))
589+            }
590+    }
591+
592+
593+func cb (bU) = {
594+    let cc = parseBigIntValue(valueOrElse(getString("vol"), "0"))
595+    let cd = lastBlock.timestamp
596+    let aB = if ((0 >= bU))
597+        then (cd + bU)
598+        else bU
599+    let bX = (aB / o)
600+    let bO = bM(bX)
601+    if ((bO == ""))
602+        then $Tuple3(cc, cc, 0)
603+        else {
604+            let bY = split(bO, "_")
605+            let ce = parseBigIntValue(bY[1])
606+            let cf = parseIntValue(bY[2])
607+            $Tuple3(cc, ce, (cd - cf))
608+            }
609+    }
610+
611+
612+func cg (ch) = {
613+    let bw = if ((w == 0))
614+        then 0
615+        else aF(ao(af), ax)
616+    let bx = aF(ao(ch), ax)
617+    if (Q((bx > bw)))
618+        then throw("D1 > D0")
619+        else {
620+            let ci = if ((w > 0))
621+                then {
622+                    func cj (ck,cl) =                     {
623+                        let bv = ((r * a) / (4 * (a - 1)))
624+                        let ak = size(ck)
625+                        func U (V,al) =                         {
626+                            let cm = ck[al]
627+                            let cn = cl[al]
628+                            let co = fraction(bx, cm, bw)
629+                            let cp = if ((co > cn))
630+                                then (co - cn)
631+                                else (cn - co)
632+                            let cq = fraction(bv, cp, f)
633+                            let cr = fraction(cq, s, f)
634+                            $Tuple4((V._1 :+ (cn - cr)), (V._2 :+ (cn - cq)), if (if (t)
635+                                then (cr > 0)
636+                                else false)
637+                                then (V._3 :+ ScriptTransfer(u, cr, fromBase58String(q[al])))
638+                                else V._3, (V._4 + fraction(cq, e, ag[al])))
639+                            }
640+
641+                        let X = am
642+                        let Y = size(X)
643+                        let Z = $Tuple4(nil, nil, nil, 0)
644+                        func aa (ab,ac) =                         if ((ac >= Y))
645+                            then ab
646+                            else U(ab, X[ac])
647+
648+                        func ad (ab,ac) =                         if ((ac >= Y))
649+                            then ab
650+                            else throw("List size exceeds 10")
651+
652+                        ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
653+                        }
654+
655+                    let cs = cj(af, ch)
656+                    let ct = cs._1
657+                    let cu = cs._2
658+                    let cv = cs._3
659+                    let cw = cs._4
660+                    $Tuple3(ct, aF(ao(cu), ax), (cv ++ bG(bw, fraction(cw, f, r))))
661+                    }
662+                else $Tuple3(ch, bx, nil)
663+            let cx = ci._1
664+            let cy = ci._2
665+            let cz = ci._3
666+            let cA = if ((w == 0))
667+                then bx
668+                else fraction(w, (cy - bw), bw)
669+            $Tuple3(cx, cA, cz)
670+            }
671+    }
672+
673+
674+@Callable(cB)
675+func init (cC,cD,cE,cF,bv,cG) = if (!(isDataStorageUntouched(this)))
676+    then throw("already initialized")
677+    else if ((cB.caller != this))
678+        then throw("self initialization only")
679+        else {
680+            let cH = split(cD, ",")
681+            let ak = size(cH)
682+            if ((2 > ak))
683+                then throw("too small coins")
684+                else if ((ak > c))
685+                    then throw("too many coins")
686+                    else {
687+                        func cI (V,al) =                         if (if ((al >= ak))
688+                            then true
689+                            else (V == false))
690+                            then V
691+                            else (indexOf(cH, cH[al]) == al)
692+
693+                        if ((false == {
694+                            let X = ai
695+                            let Y = size(X)
696+                            let Z = true
697+                            func aa (ab,ac) =                             if ((ac >= Y))
698+                                then ab
699+                                else cI(ab, X[ac])
700+
701+                            func ad (ab,ac) =                             if ((ac >= Y))
702+                                then ab
703+                                else throw("List size exceeds 10")
704+
705+                            ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
706+                            }))
707+                            then throw("duplicate coin detected")
708+                            else {
709+                                func cJ (cK) =                                 valueOrErrorMessage(assetInfo(valueOrErrorMessage(fromBase58String(cK), ("fromBase58String: " + cK))), ("assetInfo: " + cK)).decimals
710+
711+                                func U (V,cK) =                                 $Tuple3((V._1 + 1), (V._2 :+ 0), (V._3 :+ pow(10, 0, cJ(cK), 0, 0, DOWN)))
712+
713+                                let cL = {
714+                                    let X = cH
715+                                    let Y = size(X)
716+                                    let Z = $Tuple3(0, nil, nil)
717+                                    func aa (ab,ac) =                                     if ((ac >= Y))
718+                                        then ab
719+                                        else U(ab, X[ac])
720+
721+                                    func ad (ab,ac) =                                     if ((ac >= Y))
722+                                        then ab
723+                                        else throw("List size exceeds 10")
724+
725+                                    ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
726+                                    }
727+                                let cM = cL._1
728+                                let cN = cL._2
729+                                let cO = cL._3
730+                                let cP = Issue(cE, ("LP token for " + cD), 0, d, true)
731+                                let cQ = toBase58String(calculateAssetId(cP))
732+[StringEntry("coins", cD), StringEntry("rates", makeString(S(cO), ",")), StringEntry("balances", makeString(S(cN), ",")), IntegerEntry("N_COINS", cM), IntegerEntry("initial_A", cF), IntegerEntry("future_A", cF), IntegerEntry("fee", bv), IntegerEntry("admin_fee", cG), StringEntry("owner", av(cC)), IntegerEntry("kill_deadline", (height + J)), StringEntry("token", cQ), BooleanEntry("is_killed", false), BooleanEntry("is_auto_fees", true), cP]
733+                                }
734+                        }
735+            }
736+
737+
738+
739+@Callable(cB)
740+func add_liquidity (cR) = if (Q(!(H)))
741+    then throw("is killed")
742+    else {
743+        func cS (cT,cU,cV) =         {
744+            func U (V,al) =             (V :+ (cT[al] + (if ((al == cU))
745+                then cV
746+                else 0)))
747+
748+            let X = am
749+            let Y = size(X)
750+            let Z = nil
751+            func aa (ab,ac) =             if ((ac >= Y))
752+                then ab
753+                else U(ab, X[ac])
754+
755+            func ad (ab,ac) =             if ((ac >= Y))
756+                then ab
757+                else throw("List size exceeds 10")
758+
759+            ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
760+            }
761+
762+        func cW (cT,cX) =         {
763+            let ak = size(cX)
764+            if ((1 > ak))
765+                then throw("payments size < 1")
766+                else if ((ak > c))
767+                    then throw("payments size > N_COINS_MAX")
768+                    else {
769+                        func U (V,aq) =                         cS(V, ap(aq), aq.amount)
770+
771+                        let X = cX
772+                        let Y = size(X)
773+                        let Z = cT
774+                        func aa (ab,ac) =                         if ((ac >= Y))
775+                            then ab
776+                            else U(ab, X[ac])
777+
778+                        func ad (ab,ac) =                         if ((ac >= Y))
779+                            then ab
780+                            else throw("List size exceeds 10")
781+
782+                        ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
783+                        }
784+            }
785+
786+        let ch = cW(af, cB.payments)
787+        if (if ((w == 0))
788+            then (min(ch) == 0)
789+            else false)
790+            then throw("initial deposit requires all coins")
791+            else {
792+                let cY = cg(ch)
793+                let cx = cY._1
794+                let cA = cY._2
795+                let cz = cY._3
796+                if (Q((cA >= cR)))
797+                    then throw("slippage screwed you")
798+                    else ([StringEntry("balances", makeString(S(cx), ",")), Reissue(v, cA, true), ScriptTransfer(cB.caller, cA, v)] ++ cz)
799+                }
800+        }
801+
802+
803+
804+@Callable(cB)
805+func get_dy (au,aX,cZ) = {
806+    let da = af[au]
807+    let bA = af[aX]
808+    let aY = (da + cZ)
809+    let db = aW(au, aX, aY, ao(af))
810+    let bl = db._1
811+    let aT = db._2
812+    let dc = ((bA - bl) - 1)
813+    let dd = fraction(dc, r, f)
814+    let bE = (dc - dd)
815+    $Tuple2(nil, bE)
816+    }
817+
818+
819+
820+@Callable(cB)
821+func exchange (aX,de) = if (Q(!(H)))
822+    then throw("is killed")
823+    else if ((size(cB.payments) != 1))
824+        then throw("size( payments ) != 1")
825+        else {
826+            let aq = cB.payments[0]
827+            let cZ = aq.amount
828+            let au = ap(aq)
829+            let da = af[au]
830+            let bA = af[aX]
831+            let aY = (da + cZ)
832+            let df = aW(au, aX, aY, ao(af))
833+            let bl = df._1
834+            let aT = df._2
835+            let dc = ((bA - bl) - 1)
836+            let dd = fraction(dc, r, f)
837+            let bE = (dc - dd)
838+            if (Q((bE >= de)))
839+                then throw("exchange resulted in fewer coins than expected")
840+                else {
841+                    let dg = fraction(dd, s, f)
842+                    func U (V,al) =                     (V :+ (if ((al == au))
843+                        then (af[al] + cZ)
844+                        else if ((al == aX))
845+                            then ((af[al] - bE) - dg)
846+                            else af[al]))
847+
848+                    let cx = {
849+                        let X = am
850+                        let Y = size(X)
851+                        let Z = nil
852+                        func aa (ab,ac) =                         if ((ac >= Y))
853+                            then ab
854+                            else U(ab, X[ac])
855+
856+                        func ad (ab,ac) =                         if ((ac >= Y))
857+                            then ab
858+                            else throw("List size exceeds 10")
859+
860+                        ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
861+                        }
862+                    let dh = fromBase58String(q[aX])
863+                    $Tuple2((([StringEntry("balances", makeString(S(cx), ",")), ScriptTransfer(cB.caller, bE, dh)] ++ (if (if (t)
864+                        then (dg > 0)
865+                        else false)
866+                        then [ScriptTransfer(u, dg, dh)]
867+                        else nil)) ++ bG(aT, fraction(cZ, e, ag[au]))), bE)
868+                    }
869+            }
870+
871+
872+
873+@Callable(cB)
874+func remove_liquidity (di) = if ((size(cB.payments) != 1))
875+    then throw("size( payments ) != 1")
876+    else {
877+        let aq = cB.payments[0]
878+        if ((aq.assetId != v))
879+            then throw("unknown token")
880+            else {
881+                let dj = if ((di == "0"))
882+                    then nil
883+                    else ae(split(di, ","))
884+                if (if ((di != "0"))
885+                    then (size(dj) != a)
886+                    else false)
887+                    then throw("min_amounts.size() != N_COINS")
888+                    else {
889+                        let cV = aq.amount
890+                        let dk = cB.caller
891+                        func U (V,al) =                         {
892+                            let dl = af[al]
893+                            let dm = fraction(dl, cV, w)
894+                            if (if ((di != "0"))
895+                                then (dj[al] > dm)
896+                                else false)
897+                                then throw("withdrawal resulted in fewer coins than expected")
898+                                else $Tuple2((V._1 :+ ScriptTransfer(dk, dm, fromBase58String(q[al]))), (V._2 :+ (dl - dm)))
899+                            }
900+
901+                        let dn = {
902+                            let X = am
903+                            let Y = size(X)
904+                            let Z = $Tuple2(nil, nil)
905+                            func aa (ab,ac) =                             if ((ac >= Y))
906+                                then ab
907+                                else U(ab, X[ac])
908+
909+                            func ad (ab,ac) =                             if ((ac >= Y))
910+                                then ab
911+                                else throw("List size exceeds 10")
912+
913+                            ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
914+                            }
915+                        let do = dn._1
916+                        let cx = dn._2
917+                        (do ++ [StringEntry("balances", makeString(S(cx), ",")), Burn(v, cV)])
918+                        }
919+                }
920+        }
921+
922+
923+
924+@Callable(cB)
925+func calc_withdraw_one_coin (bu,au) = $Tuple2(nil, bt(bu, au)._1)
926+
927+
928+
929+@Callable(cB)
930+func remove_liquidity_one_coin (au,dp) = if (Q(!(H)))
931+    then throw("is killed")
932+    else if ((size(cB.payments) != 1))
933+        then throw("size( payments ) != 1")
934+        else {
935+            let aq = cB.payments[0]
936+            if ((aq.assetId != v))
937+                then throw("unknown token")
938+                else {
939+                    let bu = aq.amount
940+                    let dq = bt(bu, au)
941+                    let bE = dq._1
942+                    let dd = dq._2
943+                    let aT = dq._3
944+                    if (Q((bE >= dp)))
945+                        then throw("not enough coins removed")
946+                        else {
947+                            let dg = fraction(dd, s, f)
948+                            let dr = (bE + dg)
949+                            func U (V,al) =                             (V :+ (af[al] - (if ((al == au))
950+                                then dr
951+                                else 0)))
952+
953+                            let cx = {
954+                                let X = am
955+                                let Y = size(X)
956+                                let Z = nil
957+                                func aa (ab,ac) =                                 if ((ac >= Y))
958+                                    then ab
959+                                    else U(ab, X[ac])
960+
961+                                func ad (ab,ac) =                                 if ((ac >= Y))
962+                                    then ab
963+                                    else throw("List size exceeds 10")
964+
965+                                ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
966+                                }
967+                            let dh = fromBase58String(q[au])
968+                            $Tuple2((([StringEntry("balances", makeString(S(cx), ",")), ScriptTransfer(cB.caller, bE, dh), Burn(v, bu)] ++ (if (if (t)
969+                                then (dg > 0)
970+                                else false)
971+                                then [ScriptTransfer(u, dg, dh)]
972+                                else nil)) ++ bG(aT, fraction(fraction(dd, e, ag[au]), f, r))), bE)
973+                            }
974+                    }
975+            }
976+
977+
978+
979+@Callable(cB)
980+func A () = $Tuple2(nil, ax)
981+
982+
983+
984+@Callable(cB)
985+func get_virtual_price () = {
986+    let aT = aF(ao(af), ax)
987+    $Tuple2(nil, bF(aT))
988+    }
989+
990+
991+
992+@Callable(cB)
993+func calc_token_amount (ds) = {
994+    let dt = ae(split(ds, ","))
995+    if ((size(dt) != a))
996+        then throw("not enought amounts")
997+        else {
998+            func U (V,al) =             (V :+ (af[al] + dt[al]))
999+
1000+            let ch = {
1001+                let X = am
1002+                let Y = size(X)
1003+                let Z = nil
1004+                func aa (ab,ac) =                 if ((ac >= Y))
1005+                    then ab
1006+                    else U(ab, X[ac])
1007+
1008+                func ad (ab,ac) =                 if ((ac >= Y))
1009+                    then ab
1010+                    else throw("List size exceeds 10")
1011+
1012+                ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1013+                }
1014+            let du = cg(ch)
1015+            let cx = du._1
1016+            let cA = du._2
1017+            let cz = du._3
1018+            $Tuple2(nil, cA)
1019+            }
1020+    }
1021+
1022+
1023+
1024+@Callable(cB)
1025+func ramp_A (dv,dw) = if (Q((cB.caller == u)))
1026+    then throw("only owner")
1027+    else if (Q((P >= (z + n))))
1028+        then throw("too often")
1029+        else if (Q((dw >= (P + n))))
1030+            then throw("insufficient time")
1031+            else {
1032+                let dx = ax
1033+                if (Q(if ((dv > 0))
1034+                    then (k > dv)
1035+                    else false))
1036+                    then throw("out of base range")
1037+                    else if (Q(if (if ((dv >= dx))
1038+                        then ((dx * l) >= dv)
1039+                        else false)
1040+                        then true
1041+                        else if ((dx > dv))
1042+                            then ((dv * l) >= dx)
1043+                            else false))
1044+                        then throw("out of range")
1045+                        else [IntegerEntry("initial_A", dx), IntegerEntry("future_A", dv), IntegerEntry("initial_A_time", P), IntegerEntry("future_A_time", dw)]
1046+                }
1047+
1048+
1049+
1050+@Callable(cB)
1051+func stop_ramp_A () = if (Q((cB.caller == u)))
1052+    then throw("only owner")
1053+    else {
1054+        let dy = ax
1055+[IntegerEntry("initial_A", dy), IntegerEntry("future_A", dy), IntegerEntry("initial_A_time", P), IntegerEntry("future_A_time", P)]
1056+        }
1057+
1058+
1059+
1060+@Callable(cB)
1061+func commit_new_fee (dz,dA) = if (Q((cB.caller == u)))
1062+    then throw("only owner")
1063+    else if (Q((C == 0)))
1064+        then throw("active action")
1065+        else if (Q((j >= dz)))
1066+            then throw("fee exceeds maximum")
1067+            else if (Q((i >= dA)))
1068+                then throw("admin fee exceeds maximum")
1069+                else {
1070+                    let dB = (P + m)
1071+[IntegerEntry("admin_actions_deadline", dB), IntegerEntry("future_fee", dz), IntegerEntry("future_admin_fee", dA)]
1072+                    }
1073+
1074+
1075+
1076+@Callable(cB)
1077+func apply_new_fee () = if (Q((cB.caller == u)))
1078+    then throw("only owner")
1079+    else if (Q((P >= C)))
1080+        then throw("insufficient time")
1081+        else if (Q((C != 0)))
1082+            then throw("no active action")
1083+            else [IntegerEntry("admin_actions_deadline", 0), IntegerEntry("fee", E), IntegerEntry("admin_fee", F)]
1084+
1085+
1086+
1087+@Callable(cB)
1088+func revert_new_parameters () = if (Q((cB.caller == u)))
1089+    then throw("only owner")
1090+    else [IntegerEntry("admin_actions_deadline", 0)]
1091+
1092+
1093+
1094+@Callable(cB)
1095+func commit_transfer_ownership (cC) = if (Q((cB.caller == u)))
1096+    then throw("only owner")
1097+    else if (Q((D == 0)))
1098+        then throw("active transfer")
1099+        else {
1100+            let dB = (P + m)
1101+[IntegerEntry("transfer_ownership_deadline", dB), StringEntry("future_owner", av(cC))]
1102+            }
1103+
1104+
1105+
1106+@Callable(cB)
1107+func apply_transfer_ownership () = if (Q((cB.caller == u)))
1108+    then throw("only owner")
1109+    else if (Q((P >= D)))
1110+        then throw("insufficient time")
1111+        else if (Q((D != 0)))
1112+            then throw("no active transfer")
1113+            else [IntegerEntry("transfer_ownership_deadline", 0), StringEntry("owner", G)]
1114+
1115+
1116+
1117+@Callable(cB)
1118+func revert_transfer_ownership () = if (Q((cB.caller == u)))
1119+    then throw("only owner")
1120+    else [IntegerEntry("transfer_ownership_deadline", 0)]
1121+
1122+
1123+
1124+@Callable(cB)
1125+func admin_balances (au) = $Tuple2(nil, at(au))
1126+
1127+
1128+
1129+@Callable(cB)
1130+func withdraw_admin_fees () = if (Q((cB.caller == u)))
1131+    then throw("only owner")
1132+    else {
1133+        func U (V,al) =         (V :+ ScriptTransfer(u, at(al), fromBase58String(q[al])))
1134+
1135+        let X = am
1136+        let Y = size(X)
1137+        let Z = nil
1138+        func aa (ab,ac) =         if ((ac >= Y))
1139+            then ab
1140+            else U(ab, X[ac])
1141+
1142+        func ad (ab,ac) =         if ((ac >= Y))
1143+            then ab
1144+            else throw("List size exceeds 10")
1145+
1146+        ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1147+        }
1148+
1149+
1150+
1151+@Callable(cB)
1152+func donate_admin_fees () = if (Q((cB.caller == u)))
1153+    then throw("only owner")
1154+    else {
1155+        func U (V,al) =         (V :+ (af[al] + at(al)))
1156+
1157+        let ch = {
1158+            let X = am
1159+            let Y = size(X)
1160+            let Z = nil
1161+            func aa (ab,ac) =             if ((ac >= Y))
1162+                then ab
1163+                else U(ab, X[ac])
1164+
1165+            func ad (ab,ac) =             if ((ac >= Y))
1166+                then ab
1167+                else throw("List size exceeds 10")
1168+
1169+            ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1170+            }
1171+[StringEntry("balances", makeString(S(ch), ","))]
1172+        }
1173+
1174+
1175+
1176+@Callable(cB)
1177+func set_auto_fees (dC) = if (Q((cB.caller == u)))
1178+    then throw("only owner")
1179+    else [BooleanEntry("is_auto_fees", dC)]
1180+
1181+
1182+
1183+@Callable(cB)
1184+func kill_me () = if (Q((cB.caller == u)))
1185+    then throw("only owner")
1186+    else if (Q((I > P)))
1187+        then throw("deadline has passed")
1188+        else [BooleanEntry("is_killed", true)]
1189+
1190+
1191+
1192+@Callable(cB)
1193+func unkill_me () = if (Q((cB.caller == u)))
1194+    then throw("only owner")
1195+    else [BooleanEntry("is_killed", false)]
1196+
1197+
1198+
1199+@Callable(cB)
1200+func set_height_address (dD) = if ((cB.caller != u))
1201+    then throw("only owner")
1202+    else [StringEntry("heightAddress", av(dD))]
1203+
1204+
1205+
1206+@Callable(au)
1207+func set_verifier (dE) = if ((au.caller != this))
1208+    then throw("self call only")
1209+    else {
1210+        let dF = {
1211+            let ar = addressFromString(dE)
1212+            if ($isInstanceOf(ar, "Address"))
1213+                then {
1214+                    let R = ar
1215+                    true
1216+                    }
1217+                else false
1218+            }
1219+        if (!(dF))
1220+            then throw(("verifier wrong address " + dE))
1221+            else if (isDefined(getString(this, "verifier")))
1222+                then throw("verifier already defined")
1223+                else [StringEntry("verifier", dE)]
1224+        }
1225+
1226+
1227+@Verifier(dG)
1228+func dH () = {
1229+    let ar = getString(this, "verifier")
1230+    if ($isInstanceOf(ar, "String"))
1231+        then {
1232+            let dE = ar
1233+            valueOrElse(getBoolean(addressFromStringValue(dE), ((("status_" + toString(this)) + "_") + toBase58String(dG.id))), false)
1234+            }
1235+        else sigVerify(dG.bodyBytes, dG.proofs[0], dG.senderPublicKey)
1236+    }
1237+
github/deemru/w8io/873ac7e 
61.22 ms ◑