tx · EejPKGsBE3kbs16iZCZGnM9j87dtWtAm3SvqK5EdNa67

3NCN3YtoD6u2P2nV2u9cbSnzc7aBkfx6xms:  -0.10000000 Waves

2022.11.11 00:36 [2311601] smart account 3NCN3YtoD6u2P2nV2u9cbSnzc7aBkfx6xms > SELF 0.00000000 Waves

{ "type": 13, "id": "EejPKGsBE3kbs16iZCZGnM9j87dtWtAm3SvqK5EdNa67", "fee": 10000000, "feeAssetId": null, "timestamp": 1668116157600, "version": 1, "sender": "3NCN3YtoD6u2P2nV2u9cbSnzc7aBkfx6xms", "senderPublicKey": "HT5FLnfhENyRgfHtR3LUcJiWD87DqaQJAuM916uAveQR", "proofs": [ "CoHN8Dkfx6YJckxiCcUuom3ar8WBBtmTSSXmebwri1mW9ssK7mPBrrpXZdGEYbdffnRN6o8zvhJtNWiYAFe2V5y" ], "script": "base64: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", "chainId": 84, "height": 2311601, "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 = height
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(if ((z == 0))
1028+ then true
1029+ else (P >= (z + n))))
1030+ then throw("too often")
1031+ else if (Q((dw >= (P + n))))
1032+ then throw("insufficient time")
1033+ else {
1034+ let dx = ax
1035+ if (Q(if ((dv > 0))
1036+ then (k > dv)
1037+ else false))
1038+ then throw("out of base range")
1039+ else if (Q(if (if ((dv >= dx))
1040+ then ((dx * l) >= dv)
1041+ else false)
1042+ then true
1043+ else if ((dx > dv))
1044+ then ((dv * l) >= dx)
1045+ else false))
1046+ then throw("out of range")
1047+ else [IntegerEntry("initial_A", dx), IntegerEntry("future_A", dv), IntegerEntry("initial_A_time", P), IntegerEntry("future_A_time", dw)]
1048+ }
1049+
1050+
1051+
1052+@Callable(cB)
1053+func stop_ramp_A () = if (Q((cB.caller == u)))
1054+ then throw("only owner")
1055+ else {
1056+ let dy = ax
1057+[IntegerEntry("initial_A", dy), IntegerEntry("future_A", dy), IntegerEntry("initial_A_time", P), IntegerEntry("future_A_time", P)]
1058+ }
1059+
1060+
1061+
1062+@Callable(cB)
1063+func commit_new_fee (dz,dA) = if (Q((cB.caller == u)))
1064+ then throw("only owner")
1065+ else if (Q((C == 0)))
1066+ then throw("active action")
1067+ else if (Q((j >= dz)))
1068+ then throw("fee exceeds maximum")
1069+ else if (Q((i >= dA)))
1070+ then throw("admin fee exceeds maximum")
1071+ else {
1072+ let dB = (P + m)
1073+[IntegerEntry("admin_actions_deadline", dB), IntegerEntry("future_fee", dz), IntegerEntry("future_admin_fee", dA)]
1074+ }
1075+
1076+
1077+
1078+@Callable(cB)
1079+func apply_new_fee () = if (Q((cB.caller == u)))
1080+ then throw("only owner")
1081+ else if (Q((P >= C)))
1082+ then throw("insufficient time")
1083+ else if (Q((C != 0)))
1084+ then throw("no active action")
1085+ else [IntegerEntry("admin_actions_deadline", 0), IntegerEntry("fee", E), IntegerEntry("admin_fee", F)]
1086+
1087+
1088+
1089+@Callable(cB)
1090+func revert_new_parameters () = if (Q((cB.caller == u)))
1091+ then throw("only owner")
1092+ else [IntegerEntry("admin_actions_deadline", 0)]
1093+
1094+
1095+
1096+@Callable(cB)
1097+func commit_transfer_ownership (cC) = if (Q((cB.caller == u)))
1098+ then throw("only owner")
1099+ else if (Q((D == 0)))
1100+ then throw("active transfer")
1101+ else {
1102+ let dB = (P + m)
1103+[IntegerEntry("transfer_ownership_deadline", dB), StringEntry("future_owner", av(cC))]
1104+ }
1105+
1106+
1107+
1108+@Callable(cB)
1109+func apply_transfer_ownership () = if (Q((cB.caller == u)))
1110+ then throw("only owner")
1111+ else if (Q((P >= D)))
1112+ then throw("insufficient time")
1113+ else if (Q((D != 0)))
1114+ then throw("no active transfer")
1115+ else [IntegerEntry("transfer_ownership_deadline", 0), StringEntry("owner", G)]
1116+
1117+
1118+
1119+@Callable(cB)
1120+func revert_transfer_ownership () = if (Q((cB.caller == u)))
1121+ then throw("only owner")
1122+ else [IntegerEntry("transfer_ownership_deadline", 0)]
1123+
1124+
1125+
1126+@Callable(cB)
1127+func admin_balances (au) = $Tuple2(nil, at(au))
1128+
1129+
1130+
1131+@Callable(cB)
1132+func withdraw_admin_fees () = if (Q((cB.caller == u)))
1133+ then throw("only owner")
1134+ else {
1135+ func U (V,al) = (V :+ ScriptTransfer(u, at(al), fromBase58String(q[al])))
1136+
1137+ let X = am
1138+ let Y = size(X)
1139+ let Z = nil
1140+ func aa (ab,ac) = if ((ac >= Y))
1141+ then ab
1142+ else U(ab, X[ac])
1143+
1144+ func ad (ab,ac) = if ((ac >= Y))
1145+ then ab
1146+ else throw("List size exceeds 10")
1147+
1148+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1149+ }
1150+
1151+
1152+
1153+@Callable(cB)
1154+func donate_admin_fees () = if (Q((cB.caller == u)))
1155+ then throw("only owner")
1156+ else {
1157+ func U (V,al) = (V :+ (af[al] + at(al)))
1158+
1159+ let ch = {
1160+ let X = am
1161+ let Y = size(X)
1162+ let Z = nil
1163+ func aa (ab,ac) = if ((ac >= Y))
1164+ then ab
1165+ else U(ab, X[ac])
1166+
1167+ func ad (ab,ac) = if ((ac >= Y))
1168+ then ab
1169+ else throw("List size exceeds 10")
1170+
1171+ ad(aa(aa(aa(aa(aa(aa(aa(aa(aa(aa(Z, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
1172+ }
1173+[StringEntry("balances", makeString(S(ch), ","))]
1174+ }
1175+
1176+
1177+
1178+@Callable(cB)
1179+func set_auto_fees (dC) = if (Q((cB.caller == u)))
1180+ then throw("only owner")
1181+ else [BooleanEntry("is_auto_fees", dC)]
1182+
1183+
1184+
1185+@Callable(cB)
1186+func kill_me () = if (Q((cB.caller == u)))
1187+ then throw("only owner")
1188+ else if (Q((I > P)))
1189+ then throw("deadline has passed")
1190+ else [BooleanEntry("is_killed", true)]
1191+
1192+
1193+
1194+@Callable(cB)
1195+func unkill_me () = if (Q((cB.caller == u)))
1196+ then throw("only owner")
1197+ else [BooleanEntry("is_killed", false)]
1198+
1199+
1200+
1201+@Callable(cB)
1202+func set_height_address (dD) = if ((cB.caller != u))
1203+ then throw("only owner")
1204+ else [StringEntry("heightAddress", av(dD))]
1205+
1206+
1207+
1208+@Callable(au)
1209+func set_verifier (dE) = if ((au.caller != this))
1210+ then throw("self call only")
1211+ else {
1212+ let dF = {
1213+ let ar = addressFromString(dE)
1214+ if ($isInstanceOf(ar, "Address"))
1215+ then {
1216+ let R = ar
1217+ true
1218+ }
1219+ else false
1220+ }
1221+ if (!(dF))
1222+ then throw(("verifier wrong address " + dE))
1223+ else if (isDefined(getString(this, "verifier")))
1224+ then throw("verifier already defined")
1225+ else [StringEntry("verifier", dE)]
1226+ }
1227+
1228+
1229+@Verifier(dG)
1230+func dH () = {
1231+ let ar = getString(this, "verifier")
1232+ if ($isInstanceOf(ar, "String"))
1233+ then {
1234+ let dE = ar
1235+ valueOrElse(getBoolean(addressFromStringValue(dE), ((("status_" + toString(this)) + "_") + toBase58String(dG.id))), false)
1236+ }
1237+ else sigVerify(dG.bodyBytes, dG.proofs[0], dG.senderPublicKey)
1238+ }
1239+

github/deemru/w8io/169f3d6 
77.38 ms