tx · 6usvhjw6yunhfmqYwUJTWMrT95MvhrFkiJMn7KNapvii

3Mugt2hvR1E3sXdG4BJKTgn6m3oXqPFsxHU:  -0.01400000 Waves

2021.06.05 23:32 [1557551] smart account 3Mugt2hvR1E3sXdG4BJKTgn6m3oXqPFsxHU > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6usvhjw6yunhfmqYwUJTWMrT95MvhrFkiJMn7KNapvii",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1622925242725,
    "version": 1,
    "sender": "3Mugt2hvR1E3sXdG4BJKTgn6m3oXqPFsxHU",
    "senderPublicKey": "7gZqd4sEGFUnh6UBNhC9xo5C1egJzZ3N4LVo5A5ZGDCf",
    "proofs": [
        "4gfxp5YRUtUjP1MDAXm9vzYMKp5X4AxBgZRNYhZwnG6fYoyNW5a64u8XGjkDTrM4nYf8o8tLNGiKpi8fCDATqvXG"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 1557551,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 4 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "2.0.0"
5+
6+let b = "version"
7+
8+let c = "active"
9+
10+let d = "A_asset_id"
11+
12+let e = "B_asset_id"
13+
14+let f = "A_asset_balance"
15+
16+let g = "B_asset_balance"
17+
18+let h = "share_asset_id"
19+
20+let i = "share_asset_supply"
21+
22+let j = "commission"
23+
24+let k = "commission_scale_delimiter"
25+
26+let l = "invariant"
27+
28+let m = "shutdown_cause"
29+
30+let n = base58'DXDY2itiEcYBtGkVLnkpHtDFyWQUkoLJz79uJ7ECbMrA'
31+
32+let o = base58'E6Wa1SGoktYcjHjsKrvjMiqJY3SWmGKcD8Q5L8kxSPS7'
33+
34+let p = base58'AZmWJtuy4GeVrMmJH4hfFBRApe1StvhJSk4jcbT6bArQ'
35+
36+let q = base58'EtVkT6ed8GtbUiVVEqdmEqsp2J4qbb3rre2HFgxeVYdg'
37+
38+let r = base58'Czn4yoAuUZCVCLJDRfskn8URfkwpknwBTZDbs1wFrY7h'
39+
40+let s = Address(base58'3N3AeA5FWm7EHheHoik8BBEA3GXXJosnVY8')
41+
42+let t = Address(base58'3PNikM6yp4NqcSU8guxQtmR5onr2D4e8yTJ')
43+
44+let u = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
45+
46+let v = (9 * value(value(assetInfo(u)).minSponsoredFee))
47+
48+let w = getBooleanValue(this, c)
49+
50+let x = getStringValue(this, d)
51+
52+let y = getStringValue(this, e)
53+
54+let z = if ((x == "WAVES"))
55+    then unit
56+    else fromBase58String(x)
57+
58+let A = if ((y == "WAVES"))
59+    then unit
60+    else fromBase58String(y)
61+
62+let B = {
63+    let C = z
64+    if ($isInstanceOf(C, "ByteVector"))
65+        then {
66+            let D = C
67+            value(assetInfo(D)).name
68+            }
69+        else if ($isInstanceOf(C, "Unit"))
70+            then {
71+                let E = C
72+                "WAVES"
73+                }
74+            else throw("Match error")
75+    }
76+
77+let F = {
78+    let C = A
79+    if ($isInstanceOf(C, "ByteVector"))
80+        then {
81+            let D = C
82+            value(assetInfo(D)).name
83+            }
84+        else if ($isInstanceOf(C, "Unit"))
85+            then {
86+                let E = C
87+                "WAVES"
88+                }
89+            else throw("Match error")
90+    }
91+
92+let G = getIntegerValue(this, f)
93+
94+let H = getIntegerValue(this, g)
95+
96+let I = fromBase58String(getStringValue(this, h))
97+
98+let J = getIntegerValue(this, i)
99+
100+let K = getIntegerValue(this, l)
101+
102+let L = 500
103+
104+let M = 200
105+
106+let N = 1000000
107+
108+let O = 1000
109+
110+let P = 100000000
111+
112+let Q = 1000000000000
113+
114+let R = 1000
115+
116+let S = 8
117+
118+let T = 50
119+
120+let U = 100
121+
122+let V = 90000000
123+
124+let W = 110000000
125+
126+let X = 50
127+
128+let Y = 2
129+
130+let Z = 46000000
131+
132+func aa (ab) = {
133+    let C = ab
134+    if ($isInstanceOf(C, "ByteVector"))
135+        then {
136+            let D = C
137+            assetBalance(this, D)
138+            }
139+        else if ($isInstanceOf(C, "Unit"))
140+            then {
141+                let E = C
142+                wavesBalance(this).available
143+                }
144+            else throw("Match error")
145+    }
146+
147+
148+let ac = {
149+    let C = getInteger(t, ((("rpd_balance_" + toBase58String(u)) + "_") + toString(this)))
150+    if ($isInstanceOf(C, "Int"))
151+        then {
152+            let ad = C
153+            ad
154+            }
155+        else if ($isInstanceOf(C, "Unit"))
156+            then {
157+                let ae = C
158+                0
159+                }
160+            else throw("Match error")
161+    }
162+
163+let af = (G - (if ((z == u))
164+    then ac
165+    else 0))
166+
167+let ag = (H - (if ((A == u))
168+    then ac
169+    else 0))
170+
171+let ah = (aa(z) + (if ((z == u))
172+    then ac
173+    else 0))
174+
175+let ai = (aa(A) + (if ((A == u))
176+    then ac
177+    else 0))
178+
179+let aj = if ((ah >= G))
180+    then (ai >= H)
181+    else false
182+
183+func ak (al,am) = (((fraction(Q, al, am) + fraction(Q, am, al)) / 2) / 10000)
184+
185+
186+func an (al,am) = {
187+    let ao = ak(al, am)
188+    (fraction((al + am), P, pow(ao, S, X, Y, S, UP)) + (2 * fraction(pow(fraction(al, am, P), 0, 5, 1, (S / 2), DOWN), pow((ao - Z), S, X, Y, S, DOWN), P)))
189+    }
190+
191+
192+func ap (aq,ar,as,at) = {
193+    let au = (P - ((P * 1) / 10000000))
194+    let av = (aq - ar)
195+    let al = (G + as)
196+    let am = (H + as)
197+    let aw = if ((at == z))
198+        then an(al, (H - aq))
199+        else if ((at == A))
200+            then an((G - aq), am)
201+            else throw("Wrong asset in payment")
202+    let ax = fraction(P, K, aw)
203+    func ay (az,aA) =     if ((az == -1))
204+        then {
205+            let aB = (aq - ((aA * av) / 5))
206+            let aC = if ((at == z))
207+                then an(al, (H - aB))
208+                else an((G - aB), am)
209+            if ((aC > K))
210+                then aB
211+                else -1
212+            }
213+        else az
214+
215+    let aD = {
216+        let aE = [1, 2, 3, 4, 5]
217+        let aF = size(aE)
218+        let aG = -1
219+        func aH (aI,aJ) =         if ((aJ >= aF))
220+            then aI
221+            else ay(aI, aE[aJ])
222+
223+        func aK (aI,aJ) =         if ((aJ >= aF))
224+            then aI
225+            else throw("List size exceeds 5")
226+
227+        aK(aH(aH(aH(aH(aH(aG, 0), 1), 2), 3), 4), 5)
228+        }
229+    if ((0 > aD))
230+        then throw("something went wrong while working with amountToSend")
231+        else if (if ((ax > au))
232+            then (aw > K)
233+            else false)
234+            then aq
235+            else aD
236+    }
237+
238+
239+func aL (ab) = {
240+    let C = ab
241+    if ($isInstanceOf(C, "ByteVector"))
242+        then {
243+            let D = C
244+            let aM = toBase58String(D)
245+            let aN = valueOrErrorMessage(assetInfo(D), (("Asset " + aM) + " doesn't exist"))
246+            $Tuple3(aM, aN.name, aN.decimals)
247+            }
248+        else if ($isInstanceOf(C, "Unit"))
249+            then {
250+                let E = C
251+                $Tuple3("WAVES", "WAVES", 8)
252+                }
253+            else throw("Match error")
254+    }
255+
256+
257+func aO (aP) = [BooleanEntry(c, false), StringEntry(m, aP)]
258+
259+
260+func aQ (aR,ab) = if ((ab == u))
261+    then {
262+        let aS = (aR - v)
263+        if ((0 >= aS))
264+            then throw((((("Insufficient amount " + toString(aR)) + " to deduct staking fee ") + toString(v)) + " USD-N"))
265+            else aS
266+        }
267+    else aR
268+
269+
270+func aT () = throw("DApp is already active")
271+
272+
273+func aU () = throw("DApp is inactive at this moment")
274+
275+
276+func aV () = throw("Only admin can call this function")
277+
278+
279+func aW () = throw(((("Incorrect assets attached. Expected: " + x) + " and ") + y))
280+
281+
282+func aX (aY,aZ,ba) = throw(((((((((("New balance in assets of the DApp is less than threshold " + toString(aY)) + ": ") + toString(aZ)) + " ") + B) + ", ") + toString(ba)) + " ") + F))
283+
284+
285+func bb (aR,bc,bd) = throw((((((((("Insufficient DApp balance to pay " + toString(aR)) + " ") + bd) + " due to staking. Available: ") + toString(bc)) + " ") + bd) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
286+
287+
288+func be (aZ,ba) = throw((((((((((((((((("Insufficient DApp balance to pay " + toString(aZ)) + " ") + B) + " and ") + toString(ba)) + " ") + F) + " due to staking. Available: ") + toString(af)) + " ") + B) + " and ") + toString(ag)) + " ") + F) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
289+
290+
291+func bf () = aO(((((((((((((((("Suspicious state. Actual balances: " + toString(G)) + " ") + B) + ", ") + toString(H)) + " ") + F) + ". State: ") + toString(aa(z))) + " ") + B) + ", ") + toString(aa(A))) + " ") + F))
292+
293+
294+@Callable(bg)
295+func init () = {
296+    let bh = $Tuple2(bg.payments[0].amount, bg.payments[0].assetId)
297+    let bi = bh._1
298+    let bj = bh._2
299+    let bk = $Tuple2(bg.payments[1].amount, bg.payments[1].assetId)
300+    let bl = bk._1
301+    let bm = bk._2
302+    let bn = aL(bj)
303+    let bo = bn._1
304+    let bp = bn._2
305+    let bq = bn._3
306+    let br = aL(bm)
307+    let bs = br._1
308+    let bt = br._2
309+    let bu = br._3
310+    if (isDefined(getBoolean(this, c)))
311+        then aT()
312+        else if ((bj == bm))
313+            then throw("Assets must be different")
314+            else {
315+                let bv = ((("s" + take(bp, 7)) + "_") + take(bt, 7))
316+                let bw = ((((("ShareToken of SwopFi protocol for " + bp) + " and ") + bt) + " at address ") + toString(this))
317+                let bx = ((bq + bu) / 2)
318+                let by = fraction(pow(bi, bq, 5, 1, bq, HALFDOWN), pow(bl, bu, 5, 1, bu, HALFDOWN), pow(10, 0, bx, 0, 0, HALFDOWN))
319+                let bz = Issue(bv, bw, by, bx, true)
320+                let bA = calculateAssetId(bz)
321+                let bB = an(bi, bl)
322+[StringEntry(b, a), BooleanEntry(c, true), StringEntry(d, bo), StringEntry(e, bs), IntegerEntry(f, bi), IntegerEntry(g, bl), IntegerEntry(l, bB), IntegerEntry(j, L), IntegerEntry(k, N), bz, StringEntry(h, toBase58String(bA)), IntegerEntry(i, by), ScriptTransfer(bg.caller, by, bA)]
323+                }
324+    }
325+
326+
327+
328+@Callable(bg)
329+func replenishWithTwoTokens (bC) = {
330+    let bj = bg.payments[0].assetId
331+    let bm = bg.payments[1].assetId
332+    let bi = aQ(bg.payments[0].amount, bj)
333+    let bl = aQ(bg.payments[1].amount, bm)
334+    let bD = fraction(fraction(P, G, bi), O, fraction(P, H, bl))
335+    let bE = fraction(P, bi, G)
336+    let bF = fraction(P, bl, H)
337+    let bG = fraction(min([bE, bF]), J, P)
338+    let bB = an((G + bi), (H + bl))
339+    if (!(w))
340+        then aU()
341+        else if (if ((0 > bC))
342+            then true
343+            else (bC > 10))
344+            then throw("Slippage tolerance must be <= 1%")
345+            else if ((size(bg.payments) != 2))
346+                then throw("Two attached assets expected")
347+                else if (if ((bj != z))
348+                    then true
349+                    else (bm != A))
350+                    then aW()
351+                    else if (if ((((O * (R - bC)) / R) > bD))
352+                        then true
353+                        else (bD > ((O * (R + bC)) / R)))
354+                        then throw("Incorrect assets amount: amounts must have the contract ratio")
355+                        else if ((bG == 0))
356+                            then throw("Too small amount to replenish")
357+                            else if (!(aj))
358+                                then bf()
359+                                else [IntegerEntry(f, (G + bi)), IntegerEntry(g, (H + bl)), IntegerEntry(i, (J + bG)), IntegerEntry(l, bB), Reissue(I, bG, true), ScriptTransfer(bg.caller, bG, I)]
360+    }
361+
362+
363+
364+@Callable(bg)
365+func replenishWithOneToken (bH,bI) = {
366+    let bJ = $Tuple2(bg.payments[0].amount, bg.payments[0].assetId)
367+    let bK = bJ._1
368+    let bL = bJ._2
369+    let bM = 5000000
370+    let bN = 50000000
371+    let bO = if ((bN > bK))
372+        then 100000
373+        else 1
374+    let bP = (P - ((P * bO) / 10000000))
375+    let bQ = (P + ((P * bO) / 10000000))
376+    let bR = (P - ((P * 1) / 10000000))
377+    if (!(w))
378+        then aU()
379+        else if ((bM > bK))
380+            then throw((((("Payment amount " + toString(bK)) + " does not exceed the minimum amount of ") + toString(bM)) + " tokens"))
381+            else if ((size(bg.payments) != 1))
382+                then throw("One attached payment expected")
383+                else if (!(aj))
384+                    then bf()
385+                    else if (if ((bL != z))
386+                        then (bL != A)
387+                        else false)
388+                        then aW()
389+                        else {
390+                            let bS = if ((bL == z))
391+                                then $Tuple6((bK - bH), bI, (G + bH), (H - bI), (G + bK), H)
392+                                else $Tuple6(bI, (bK - bH), (G - bI), (H + bH), G, (H + bK))
393+                            let bT = bS._1
394+                            let bU = bS._2
395+                            let bV = bS._3
396+                            let bW = bS._4
397+                            let bX = bS._5
398+                            let bY = bS._6
399+                            let aw = an(bV, bW)
400+                            let ax = fraction(P, K, aw)
401+                            let bZ = (fraction((P * P), bV, bW) / fraction(P, bT, bU))
402+                            let ca = fraction((bX + bY), T, (2 * U))
403+                            if (if ((bR >= ax))
404+                                then true
405+                                else (K > aw))
406+                                then throw("Incorrect virtualSwapTokenPay or virtualSwapTokenGet value")
407+                                else if (if ((bP > bZ))
408+                                    then true
409+                                    else (bZ > bQ))
410+                                    then throw("Swap with virtualSwapTokenPay and virtualSwapTokenGet is possible, but ratio after virtual swap is incorrect")
411+                                    else if (if ((ca > bX))
412+                                        then true
413+                                        else (ca > bY))
414+                                        then aX(ca, bX, bY)
415+                                        else {
416+                                            let bE = fraction(aQ(bT, z), P, bV)
417+                                            let bF = fraction(aQ(bU, A), P, bW)
418+                                            let bG = fraction(min([bE, bF]), J, P)
419+                                            let cb = fraction(bG, (N - (L / 2)), N)
420+                                            let cc = fraction(bG, (M / 2), N)
421+                                            let cd = fraction(cc, G, J)
422+                                            let ce = fraction(cc, H, J)
423+                                            let cf = if ((bL == z))
424+                                                then [IntegerEntry(f, (bX - cd)), IntegerEntry(g, (H - ce))]
425+                                                else [IntegerEntry(f, (G - cd)), IntegerEntry(g, (bY - ce))]
426+                                            let bB = if ((bL == z))
427+                                                then an((bX - cd), (H - ce))
428+                                                else an((G - cd), (bY - ce))
429+                                            ([Reissue(I, cb, true), ScriptTransfer(bg.caller, cb, I), ScriptTransfer(s, cd, z), ScriptTransfer(s, ce, A), IntegerEntry(i, (J + cb)), IntegerEntry(l, bB)] ++ cf)
430+                                            }
431+                            }
432+    }
433+
434+
435+
436+@Callable(bg)
437+func withdraw () = {
438+    let cg = $Tuple2(bg.payments[0].amount, bg.payments[0].assetId)
439+    let bK = cg._1
440+    let bL = cg._2
441+    let ch = aQ(fraction(bK, G, J), z)
442+    let ci = aQ(fraction(bK, H, J), A)
443+    let bB = an((G - ch), (H - ci))
444+    if (!(w))
445+        then aU()
446+        else if ((size(bg.payments) != 1))
447+            then throw("One attached payment expected")
448+            else if ((bL != I))
449+                then throw(("Incorrect asset attached. Expected: " + toBase58String(I)))
450+                else if (!(aj))
451+                    then bf()
452+                    else if (if ((ch > af))
453+                        then true
454+                        else (ci > ag))
455+                        then be(ch, ci)
456+                        else [IntegerEntry(f, (G - ch)), IntegerEntry(g, (H - ci)), IntegerEntry(i, (J - bK)), IntegerEntry(l, bB), Burn(I, bK), ScriptTransfer(bg.caller, ch, z), ScriptTransfer(bg.caller, ci, A)]
457+    }
458+
459+
460+
461+@Callable(bg)
462+func exchange (cj,ck) = {
463+    let cl = $Tuple2(bg.payments[0].amount, bg.payments[0].assetId)
464+    let bK = cl._1
465+    let bL = cl._2
466+    if (!(w))
467+        then aU()
468+        else if ((0 >= cj))
469+            then throw(("Estimated amount must be positive. Actual: " + toString(cj)))
470+            else if ((ck > cj))
471+                then throw(((("Minimal amount can't be greater than estimated. Estimated: " + toString(cj)) + ". Minimal: ") + toString(ck)))
472+                else if ((size(bg.payments) != 1))
473+                    then throw("One attached payment expected")
474+                    else if (!(aj))
475+                        then bf()
476+                        else if (if ((bL != z))
477+                            then (bL != A)
478+                            else false)
479+                            then aW()
480+                            else if ((10000000 > bK))
481+                                then throw("Only swap of 10.000000 or more tokens is allowed")
482+                                else if (if ((V > fraction(P, ck, bK)))
483+                                    then true
484+                                    else (fraction(P, cj, bK) > W))
485+                                    then throw("Incorrect args and pmt ratio")
486+                                    else {
487+                                        let cm = if ((bL == z))
488+                                            then A
489+                                            else z
490+                                        let aR = ap(cj, ck, bK, bL)
491+                                        let cn = fraction(aR, M, N)
492+                                        let co = fraction(aR, (N - L), N)
493+                                        let cp = if ((bL == z))
494+                                            then $Tuple2((G + bK), ((H - co) - cn))
495+                                            else $Tuple2(((G - co) - cn), (H + bK))
496+                                        let bX = cp._1
497+                                        let bY = cp._2
498+                                        let ca = fraction((bX + bY), T, (2 * U))
499+                                        if (if ((ca > bX))
500+                                            then true
501+                                            else (ca > bY))
502+                                            then aX(ca, bX, bY)
503+                                            else if (if (if ((z == u))
504+                                                then (cm == z)
505+                                                else false)
506+                                                then (ac >= bX)
507+                                                else false)
508+                                                then bb(co, af, B)
509+                                                else if (if (if ((A == u))
510+                                                    then (cm == A)
511+                                                    else false)
512+                                                    then (ac >= bY)
513+                                                    else false)
514+                                                    then bb(co, ag, F)
515+                                                    else [IntegerEntry(f, bX), IntegerEntry(g, bY), IntegerEntry(l, an(bX, bY)), ScriptTransfer(bg.caller, co, cm), ScriptTransfer(s, cn, cm)]
516+                                        }
517+    }
518+
519+
520+
521+@Callable(bg)
522+func shutdown () = if (!(w))
523+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, m), "the cause wasn't specified")))
524+    else if (!(containsElement([n, o, p, q], bg.callerPublicKey)))
525+        then aV()
526+        else aO("Paused by admin")
527+
528+
529+
530+@Callable(bg)
531+func activate () = if (w)
532+    then aT()
533+    else if (!(containsElement([n, o, p, q], bg.callerPublicKey)))
534+        then aV()
535+        else [BooleanEntry(c, true), DeleteEntry(m)]
536+
537+
538+
539+@Callable(bg)
540+func takeIntoAccountExtraFunds (cq) = {
541+    let cr = (ah - G)
542+    let cs = (ai - H)
543+    let ct = (cr - (if ((z == u))
544+        then cq
545+        else 0))
546+    let cu = (cs - (if ((A == u))
547+        then cq
548+        else 0))
549+    let aw = an((G + ct), (H + cu))
550+    if (!(w))
551+        then aU()
552+        else if ((bg.caller != this))
553+            then aV()
554+            else if ((0 > cq))
555+                then throw(("Argument 'amountLeave' cannot be negative. Actual: " + toString(cq)))
556+                else if (if ((0 > cr))
557+                    then true
558+                    else (0 > cs))
559+                    then aO("Enroll amount negative")
560+                    else if (if ((0 > ct))
561+                        then true
562+                        else (0 > cu))
563+                        then throw("Too large amountLeave")
564+                        else [IntegerEntry(l, aw), IntegerEntry(f, (G + ct)), IntegerEntry(g, (H + cu)), IntegerEntry(("last_income_" + x), ct), IntegerEntry(("last_income_" + y), cu)]
565+    }
566+
567+
568+@Verifier(cv)
569+func cw () = {
570+    let C = cv
571+    if ($isInstanceOf(C, "InvokeScriptTransaction"))
572+        then {
573+            let cx = C
574+            let cy = if ((cx.dApp == this))
575+                then (cx.function == "takeIntoAccountExtraFunds")
576+                else false
577+            let cz = if ((cx.dApp == t))
578+                then if (if (if ((cx.function == "lockNeutrino"))
579+                    then (size(cx.payments) == 1)
580+                    else false)
581+                    then (cx.payments[0].assetId == u)
582+                    else false)
583+                    then true
584+                    else if ((cx.function == "unlockNeutrino"))
585+                        then (size(cx.payments) == 0)
586+                        else false
587+                else false
588+            let cA = if (if (if (sigVerify(cv.bodyBytes, cv.proofs[0], n))
589+                then true
590+                else sigVerify(cv.bodyBytes, cv.proofs[0], o))
591+                then true
592+                else sigVerify(cv.bodyBytes, cv.proofs[0], p))
593+                then true
594+                else sigVerify(cv.bodyBytes, cv.proofs[0], r)
595+            if (if (cy)
596+                then true
597+                else cz)
598+                then cA
599+                else false
600+            }
601+        else {
602+            let cB = if (sigVerify(cv.bodyBytes, cv.proofs[0], n))
603+                then 1
604+                else 0
605+            let cC = if (sigVerify(cv.bodyBytes, cv.proofs[1], o))
606+                then 1
607+                else 0
608+            let cD = if (sigVerify(cv.bodyBytes, cv.proofs[2], p))
609+                then 1
610+                else 0
611+            (((cB + cC) + cD) >= 2)
612+            }
613+    }
614+
github/deemru/w8io/873ac7e 
42.85 ms ◑