tx · 8DRnRVogMj5xZV6m37f7T1mLNj1PH1gxFGiKX8tuiixS

3MrBtdped4oUFs1BvLNu53Dm1AMGiTHkT9B:  -0.05000000 Waves

2021.08.19 15:48 [1665256] smart account 3MrBtdped4oUFs1BvLNu53Dm1AMGiTHkT9B > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8DRnRVogMj5xZV6m37f7T1mLNj1PH1gxFGiKX8tuiixS",
    "fee": 5000000,
    "feeAssetId": null,
    "timestamp": 1629377318741,
    "version": 2,
    "chainId": 84,
    "sender": "3MrBtdped4oUFs1BvLNu53Dm1AMGiTHkT9B",
    "senderPublicKey": "62w8kveUcn6vWDTWBtmH6oZK77kaTVzWCESrTX9MikvY",
    "proofs": [
        "2fDkF3CtX7rGiK7j2W8kNdH7gxcNg9jv5Swh6fvVwhPcN8jUDGHWVPaiUrf6H3GSn5d8YdTeqHKF9hGvwXE3RHST"
    ],
    "script": "base64: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",
    "height": 1665256,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: AFEo55dWY1faXpTh7s8gkWyRWoRNKZnDbPjjACbfxkCA

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