tx · HwakPCNeSE5n3sWdPvqgbnkwA5VEgHN8Xr8xUHxGWMaK

3N8UgZisULWETwrwrAEqhCZCzu2LdQZBLQ4:  -0.01000000 Waves

2021.04.05 22:04 [1469545] smart account 3N8UgZisULWETwrwrAEqhCZCzu2LdQZBLQ4 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HwakPCNeSE5n3sWdPvqgbnkwA5VEgHN8Xr8xUHxGWMaK",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1617649504823,
    "version": 2,
    "chainId": 84,
    "sender": "3N8UgZisULWETwrwrAEqhCZCzu2LdQZBLQ4",
    "senderPublicKey": "Dn6s75jJPgLqyGVWqzruzB3X5veLgb3zsaBZaJSXyHPk",
    "proofs": [
        "3ePKrfAMLoHXpJ8YzbX79FL5RHqTDai7YtoL26yCqsQMF6ropBP9ocMtaHr8Be1PjVoZnLJ468kkZygNdqPYEZN7"
    ],
    "script": "base64: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",
    "height": 1469545,
    "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 = "1.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 = "shutdown_cause"
27+
28+let m = base58'DXDY2itiEcYBtGkVLnkpHtDFyWQUkoLJz79uJ7ECbMrA'
29+
30+let n = base58'E6Wa1SGoktYcjHjsKrvjMiqJY3SWmGKcD8Q5L8kxSPS7'
31+
32+let o = base58'AZmWJtuy4GeVrMmJH4hfFBRApe1StvhJSk4jcbT6bArQ'
33+
34+let p = base58'EtVkT6ed8GtbUiVVEqdmEqsp2J4qbb3rre2HFgxeVYdg'
35+
36+let q = base58'Czn4yoAuUZCVCLJDRfskn8URfkwpknwBTZDbs1wFrY7h'
37+
38+let r = Address(base58'3NAGTtZz6WpupSN89NZD5rMZwwziZEg4Kx4')
39+
40+let s = Address(base58'3N6q7sCGSSLBUXDdjBdYGTJbZGZfhhh8cNg')
41+
42+let t = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
43+
44+let u = (9 * value(value(assetInfo(t)).minSponsoredFee))
45+
46+let v = getBooleanValue(this, c)
47+
48+let w = getStringValue(this, d)
49+
50+let x = getStringValue(this, e)
51+
52+let y = if ((w == "WAVES"))
53+    then unit
54+    else fromBase58String(w)
55+
56+let z = if ((x == "WAVES"))
57+    then unit
58+    else fromBase58String(x)
59+
60+let A = {
61+    let B = y
62+    if ($isInstanceOf(B, "ByteVector"))
63+        then {
64+            let C = B
65+            value(assetInfo(C)).name
66+            }
67+        else if ($isInstanceOf(B, "Unit"))
68+            then {
69+                let D = B
70+                "WAVES"
71+                }
72+            else throw("Match error")
73+    }
74+
75+let E = {
76+    let B = z
77+    if ($isInstanceOf(B, "ByteVector"))
78+        then {
79+            let C = B
80+            value(assetInfo(C)).name
81+            }
82+        else if ($isInstanceOf(B, "Unit"))
83+            then {
84+                let D = B
85+                "WAVES"
86+                }
87+            else throw("Match error")
88+    }
89+
90+let F = getIntegerValue(this, f)
91+
92+let G = getIntegerValue(this, g)
93+
94+let H = fromBase58String(getStringValue(this, h))
95+
96+let I = getIntegerValue(this, i)
97+
98+let J = 3000
99+
100+let K = 1200
101+
102+let L = 1000000
103+
104+let M = 1000
105+
106+let N = 100000000
107+
108+let O = 1000
109+
110+let P = 8
111+
112+func Q (R) = {
113+    let B = R
114+    if ($isInstanceOf(B, "ByteVector"))
115+        then {
116+            let C = B
117+            assetBalance(this, C)
118+            }
119+        else if ($isInstanceOf(B, "Unit"))
120+            then {
121+                let D = B
122+                wavesBalance(this).available
123+                }
124+            else throw("Match error")
125+    }
126+
127+
128+let S = {
129+    let B = getInteger(s, ((("rpd_balance_" + toBase58String(t)) + "_") + toString(this)))
130+    if ($isInstanceOf(B, "Int"))
131+        then {
132+            let T = B
133+            T
134+            }
135+        else if ($isInstanceOf(B, "Unit"))
136+            then {
137+                let U = B
138+                0
139+                }
140+            else throw("Match error")
141+    }
142+
143+let V = (F - (if ((y == t))
144+    then S
145+    else 0))
146+
147+let W = (G - (if ((z == t))
148+    then S
149+    else 0))
150+
151+let X = (Q(y) + (if ((y == t))
152+    then S
153+    else 0))
154+
155+let Y = (Q(z) + (if ((z == t))
156+    then S
157+    else 0))
158+
159+let Z = if ((X >= F))
160+    then (Y >= G)
161+    else false
162+
163+func aa (R) = {
164+    let B = R
165+    if ($isInstanceOf(B, "ByteVector"))
166+        then {
167+            let C = B
168+            let ab = toBase58String(C)
169+            let ac = valueOrErrorMessage(assetInfo(C), (("Asset " + ab) + " doesn't exist"))
170+            $Tuple3(ab, ac.name, ac.decimals)
171+            }
172+        else if ($isInstanceOf(B, "Unit"))
173+            then {
174+                let D = B
175+                $Tuple3("WAVES", "WAVES", 8)
176+                }
177+            else throw("Match error")
178+    }
179+
180+
181+func ad (ae) = [BooleanEntry(c, false), StringEntry(l, ae)]
182+
183+
184+func af (ag,R) = if ((R == t))
185+    then {
186+        let ah = (ag - u)
187+        if ((0 >= ah))
188+            then throw((((("Insufficient amount " + toString(ag)) + " to deduct staking fee ") + toString(u)) + " USD-N"))
189+            else ah
190+        }
191+    else ag
192+
193+
194+func ai (ag,aj,ak) = throw((((((((("Insufficient DApp balance to pay " + toString(ag)) + " ") + ak) + " due to staking. Available: ") + toString(aj)) + " ") + ak) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
195+
196+
197+func al (am,an) = throw((((((((((((((((("Insufficient DApp balance to pay " + toString(am)) + " ") + A) + " and ") + toString(an)) + " ") + E) + " due to staking. Available: ") + toString(V)) + " ") + A) + " and ") + toString(W)) + " ") + E) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
198+
199+
200+@Callable(ao)
201+func init () = {
202+    let ap = $Tuple2(ao.payments[0].amount, ao.payments[0].assetId)
203+    let aq = ap._1
204+    let ar = ap._2
205+    let as = $Tuple2(ao.payments[1].amount, ao.payments[1].assetId)
206+    let at = as._1
207+    let au = as._2
208+    let av = aa(ar)
209+    let aw = av._1
210+    let ax = av._2
211+    let ay = av._3
212+    let az = aa(au)
213+    let aA = az._1
214+    let aB = az._2
215+    let aC = az._3
216+    if (isDefined(getBoolean(this, c)))
217+        then throw("DApp is already active")
218+        else if ((ar == au))
219+            then throw("Assets must be different")
220+            else {
221+                let aD = ((("s" + take(ax, 7)) + "_") + take(aB, 7))
222+                let aE = ((((("ShareToken of SwopFi protocol for " + ax) + " and ") + aB) + " at address ") + toString(this))
223+                let aF = ((ay + aC) / 2)
224+                let aG = fraction(pow(aq, ay, 5, 1, ay, HALFDOWN), pow(at, aC, 5, 1, aC, HALFDOWN), pow(10, 0, aF, 0, 0, HALFDOWN))
225+                let aH = Issue(aD, aE, aG, aF, true)
226+                let aI = calculateAssetId(aH)
227+[StringEntry(b, a), BooleanEntry(c, true), StringEntry(d, aw), StringEntry(e, aA), IntegerEntry(f, aq), IntegerEntry(g, at), IntegerEntry(j, J), IntegerEntry(k, L), aH, StringEntry(h, toBase58String(aI)), IntegerEntry(i, aG), ScriptTransfer(ao.caller, aG, aI)]
228+                }
229+    }
230+
231+
232+
233+@Callable(ao)
234+func replenishWithTwoTokens (aJ) = {
235+    let ar = ao.payments[0].assetId
236+    let au = ao.payments[1].assetId
237+    let aq = af(ao.payments[0].amount, ar)
238+    let at = af(ao.payments[1].amount, au)
239+    let aK = fraction(aq, N, F)
240+    let aL = fraction(at, N, G)
241+    func aM (aN,aO,aP) =     {
242+        let aQ = fraction(aO, aP, (aP + aN))
243+        let aR = fraction(aQ, (L - J), L)
244+        let aS = fraction(aQ, K, L)
245+        $Tuple3(aQ, aR, aS)
246+        }
247+
248+    func aT (F,G,aU,aV) =     {
249+        let aW = ((fraction(F, N, 1) + fraction(aU, N, 2)) - fraction(fraction(N, F, 2), aV, G))
250+        let aX = ((((pow(aU, 0, 2, 0, P, UP) / 4) + ((F * F) * N)) - fraction(fraction(aU, (N * aV), 2), F, G)) + (pow(fraction(aV, (F * N), (2 * G)), 0, 2, 0, 0, DOWN) / N))
251+        let aY = (-(aW) + pow(aX, 0, 5, 1, (P / 2), DOWN))
252+        let aZ = (aY + (F * N))
253+        let ba = fraction(aY, (G * N), aZ)
254+        if (if (if ((N > aY))
255+            then (aY > -(N))
256+            else false)
257+            then true
258+            else if ((ba > -(N)))
259+                then (N > ba)
260+                else false)
261+            then $Tuple2(0, 0)
262+            else if ((aL > aK))
263+                then $Tuple2(aY, ba)
264+                else if ((aK > aL))
265+                    then $Tuple2(-(ba), -(aY))
266+                    else $Tuple2(0, 0)
267+        }
268+
269+    let bb = aT(F, G, aq, at)
270+    let bc = bb._1
271+    let bd = bb._2
272+    if (!(v))
273+        then throw("DApp is inactive at this moment")
274+        else if (if ((0 > aJ))
275+            then true
276+            else (aJ > O))
277+            then throw(((("Slippage tolerance must be between 0 and " + toString(O)) + " inclusively. Actual: ") + toString(aJ)))
278+            else if ((size(ao.payments) != 2))
279+                then throw("Two attached assets expected")
280+                else if (if ((ar != y))
281+                    then true
282+                    else (au != z))
283+                    then throw(((("Incorrect assets attached. Expected: " + w) + " and ") + x))
284+                    else if (!(Z))
285+                        then ad(((((((((((((((("Suspicious state. Actual balances: " + toString(F)) + " ") + A) + ", ") + toString(G)) + " ") + E) + ". State: ") + toString(Q(y))) + " ") + A) + ", ") + toString(Q(z))) + " ") + E))
286+                        else if (if ((bc == 0))
287+                            then (bd == 0)
288+                            else false)
289+                            then {
290+                                let be = fraction(aq, N, F)
291+                                let bf = fraction(at, N, G)
292+                                let bg = fraction(min([be, bf]), I, N)
293+                                if ((bg == 0))
294+                                    then throw("Too small amount to replenish")
295+                                    else [IntegerEntry(f, (F + aq)), IntegerEntry(g, (G + at)), IntegerEntry(i, (I + bg)), Reissue(H, bg, true), ScriptTransfer(ao.caller, bg, H)]
296+                                }
297+                            else if ((aK > aL))
298+                                then {
299+                                    let bh = au
300+                                    let bi = aM(G, F, (bc / N))
301+                                    let aQ = bi._1
302+                                    let aR = bi._2
303+                                    let aS = bi._3
304+                                    let bj = (aq - aQ)
305+                                    let bk = (at + (bc / N))
306+                                    let bl = ((F + bj) + aQ)
307+                                    let bm = ((G + bk) - (bc / N))
308+                                    let bn = 1
309+                                    let be = fraction(bj, N, bl)
310+                                    let bf = fraction(bk, N, bm)
311+                                    let bg = fraction(min([be, bf]), I, N)
312+                                    if ((bg == 0))
313+                                        then throw("Too small amount to replenish")
314+                                        else if (if (if ((y == t))
315+                                            then (S >= bl)
316+                                            else false)
317+                                            then true
318+                                            else if ((z == t))
319+                                                then (S >= bm)
320+                                                else false)
321+                                            then ai(aR, W, E)
322+                                            else [IntegerEntry(f, bl), IntegerEntry(g, bm), IntegerEntry(i, (I + bg)), Reissue(H, bg, true), ScriptTransfer(ao.caller, bj, ar), ScriptTransfer(ao.caller, bk, bh), ScriptTransfer(ao.caller, bg, H)]
323+                                    }
324+                                else if ((aL > aK))
325+                                    then {
326+                                        let bh = ar
327+                                        let bo = aM(F, G, (bc / N))
328+                                        let aQ = bo._1
329+                                        let aR = bo._2
330+                                        let aS = bo._3
331+                                        let bj = (aq + (bc / N))
332+                                        let bk = (at - aQ)
333+                                        let bl = ((F + bj) - (bc / N))
334+                                        let bm = ((G + bk) + aQ)
335+                                        let bn = 1
336+                                        let be = fraction(bj, N, bl)
337+                                        let bf = fraction(bk, N, bm)
338+                                        let bg = fraction(min([be, bf]), I, N)
339+                                        if ((bg == 0))
340+                                            then throw("Too small amount to replenish")
341+                                            else if (if (if ((y == t))
342+                                                then (S >= bl)
343+                                                else false)
344+                                                then true
345+                                                else if ((z == t))
346+                                                    then (S >= bm)
347+                                                    else false)
348+                                                then ai(aR, V, A)
349+                                                else [IntegerEntry(f, bl), IntegerEntry(g, bm), IntegerEntry(i, (I + bg)), Reissue(H, bg, true), ScriptTransfer(ao.caller, bj, bh), ScriptTransfer(ao.caller, bk, au), ScriptTransfer(ao.caller, bg, H)]
350+                                        }
351+                                    else throw("mistake")
352+    }
353+
354+
355+
356+@Callable(ao)
357+func withdraw () = {
358+    let bp = $Tuple2(ao.payments[0].amount, ao.payments[0].assetId)
359+    let aP = bp._1
360+    let bq = bp._2
361+    let br = af(fraction(aP, F, I), y)
362+    let bs = af(fraction(aP, G, I), z)
363+    if (!(v))
364+        then throw("DApp is inactive at this moment")
365+        else if ((size(ao.payments) != 1))
366+            then throw("One attached payment expected")
367+            else if ((bq != H))
368+                then throw(("Incorrect asset attached. Expected: " + toBase58String(H)))
369+                else if (!(Z))
370+                    then ad(((((((((((((((("Suspicious state. Actual balances: " + toString(F)) + " ") + A) + ", ") + toString(G)) + " ") + E) + ". State: ") + toString(Q(y))) + " ") + A) + ", ") + toString(Q(z))) + " ") + E))
371+                    else if (if ((br > V))
372+                        then true
373+                        else (bs > W))
374+                        then al(br, bs)
375+                        else [IntegerEntry(f, (F - br)), IntegerEntry(g, (G - bs)), IntegerEntry(i, (I - aP)), Burn(H, aP), ScriptTransfer(ao.caller, br, y), ScriptTransfer(ao.caller, bs, z)]
376+    }
377+
378+
379+
380+@Callable(ao)
381+func exchange (bt) = {
382+    let bu = $Tuple2(ao.payments[0].amount, ao.payments[0].assetId)
383+    let aP = bu._1
384+    let bq = bu._2
385+    func aM (aN,aO) =     {
386+        let aQ = fraction(aO, aP, (aP + aN))
387+        let aR = fraction(aQ, (L - J), L)
388+        let aS = fraction(aQ, K, L)
389+        if ((bt > aR))
390+            then throw(((("Calculated amount to receive " + toString(aR)) + " is less than specified minimum ") + toString(bt)))
391+            else $Tuple3(aQ, aR, aS)
392+        }
393+
394+    if (!(v))
395+        then throw("DApp is inactive at this moment")
396+        else if ((0 >= bt))
397+            then throw(("Minimal amount to receive must be positive. Actual: " + toString(bt)))
398+            else if ((size(ao.payments) != 1))
399+                then throw("One attached payment expected")
400+                else if (!(Z))
401+                    then ad(((((((((((((((("Suspicious state. Actual balances: " + toString(F)) + " ") + A) + ", ") + toString(G)) + " ") + E) + ". State: ") + toString(Q(y))) + " ") + A) + ", ") + toString(Q(z))) + " ") + E))
402+                    else if ((bq == y))
403+                        then {
404+                            let bh = z
405+                            let bv = aM(F, G)
406+                            let aQ = bv._1
407+                            let aR = bv._2
408+                            let aS = bv._3
409+                            let bl = (F + aP)
410+                            let bm = ((G - aR) - aS)
411+                            if (if (if ((y == t))
412+                                then (S >= bl)
413+                                else false)
414+                                then true
415+                                else if ((z == t))
416+                                    then (S >= bm)
417+                                    else false)
418+                                then ai(aR, W, E)
419+                                else [IntegerEntry(f, bl), IntegerEntry(g, bm), ScriptTransfer(ao.caller, aR, bh), ScriptTransfer(r, aS, bh)]
420+                            }
421+                        else if ((bq == z))
422+                            then {
423+                                let bh = y
424+                                let bw = aM(G, F)
425+                                let aQ = bw._1
426+                                let aR = bw._2
427+                                let aS = bw._3
428+                                let bl = ((F - aR) - aS)
429+                                let bm = (G + aP)
430+                                if (if (if ((y == t))
431+                                    then (S >= bl)
432+                                    else false)
433+                                    then true
434+                                    else if ((z == t))
435+                                        then (S >= bm)
436+                                        else false)
437+                                    then ai(aR, V, A)
438+                                    else [IntegerEntry(f, bl), IntegerEntry(g, bm), ScriptTransfer(ao.caller, aR, bh), ScriptTransfer(r, aS, bh)]
439+                                }
440+                            else throw(((("Incorrect asset attached. Expected: " + w) + " or ") + x))
441+    }
442+
443+
444+
445+@Callable(ao)
446+func shutdown () = if (!(v))
447+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, l), "the cause wasn't specified")))
448+    else if (!(containsElement([m, n, o, p], ao.callerPublicKey)))
449+        then throw("Only admin can call this function")
450+        else ad("Paused by admin")
451+
452+
453+
454+@Callable(ao)
455+func activate () = if (v)
456+    then throw("DApp is already active")
457+    else if (!(containsElement([m, n, o, p], ao.callerPublicKey)))
458+        then throw("Only admin can call this function")
459+        else [BooleanEntry(c, true), DeleteEntry(l)]
460+
461+
462+
463+@Callable(ao)
464+func takeIntoAccountExtraFunds (bx) = {
465+    let by = (X - F)
466+    let bz = (Y - G)
467+    let bA = (by - (if ((y == t))
468+        then bx
469+        else 0))
470+    let bB = (bz - (if ((z == t))
471+        then bx
472+        else 0))
473+    if (!(v))
474+        then throw("DApp is inactive at this moment")
475+        else if ((ao.caller != this))
476+            then throw("Only the DApp itself can call this function")
477+            else if ((0 > bx))
478+                then throw(("Argument 'amountLeave' cannot be negative. Actual: " + toString(bx)))
479+                else if (if ((0 > by))
480+                    then true
481+                    else (0 > bz))
482+                    then ad("Enroll amount negative")
483+                    else if (if ((0 > bA))
484+                        then true
485+                        else (0 > bB))
486+                        then throw("Too large amountLeave")
487+                        else [IntegerEntry(f, (F + bA)), IntegerEntry(g, (G + bB)), IntegerEntry(("last_income_" + w), bA), IntegerEntry(("last_income_" + x), bB)]
488+    }
489+
490+
github/deemru/w8io/026f985 
39.33 ms ◑