tx · Eo9sx1pFjrdQVHZjHcGUAnpKZBMdzN2bBLct5uaKV68Q

3MxZ7YNAqigXR5jrgvpb48Uc6B29ouDzQyN:  -0.03400000 Waves

2023.03.06 22:39 [2478657] smart account 3MxZ7YNAqigXR5jrgvpb48Uc6B29ouDzQyN > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Eo9sx1pFjrdQVHZjHcGUAnpKZBMdzN2bBLct5uaKV68Q",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1678131559886,
    "version": 2,
    "chainId": 84,
    "sender": "3MxZ7YNAqigXR5jrgvpb48Uc6B29ouDzQyN",
    "senderPublicKey": "HHCdafdi3D2htEYJw8cBoNYC8w76euLWKYENK4kanmGM",
    "proofs": [
        "5WgjbfEw9aJJdrAdKj3H6vsH9rPJtqBo7o76YNfngoTdYVJBupdCq9JiYJzV4eQC6qgAN8gt4RPG7yCc5h5Bqh8u"
    ],
    "script": "base64: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",
    "height": 2478657,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: AejWijU8Z9T6JnLSGmZ75dH1xNnQj4RGUwa9UNthJe8m

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "k_totalSupply"
5+
6+let b = "k_rewardBalance"
7+
8+let c = "k_lockedBalance"
9+
10+let d = "k_freeBalance"
11+
12+let e = "k_rate"
13+
14+let f = "k_lastUpdateTime"
15+
16+let g = "k_rewardPerTokenStored"
17+
18+let h = "k_rewardRate"
19+
20+let i = "k_periodFinish"
21+
22+let j = "k_userRewardPerToken"
23+
24+let k = "k_userReward"
25+
26+let l = "k_balance"
27+
28+let m = "k_average_rate"
29+
30+let n = "k_withdraw_limit"
31+
32+let o = "k_last_withdraw_date"
33+
34+let p = "k_withdraw_in_period"
35+
36+let q = "k_initialized"
37+
38+let r = "k_coordinatorAddress"
39+
40+let s = "k_amm"
41+
42+let t = "k_gov_asset"
43+
44+let u = "k_quote_asset"
45+
46+let v = "k_admin_address"
47+
48+let w = "k_manager_address"
49+
50+let x = "k_collateral_address"
51+
52+func y (z,A) = ((z + "_") + A)
53+
54+
55+func B () = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(this, r), "Coordinator not set")), "Coordinator address invalid")
56+
57+
58+func C () = addressFromString(valueOrErrorMessage(getString(B(), v), "Admin address not set"))
59+
60+
61+func D (A) = valueOrElse(getBoolean(B(), y(s, A)), false)
62+
63+
64+func E () = fromBase58String(valueOrErrorMessage(getString(B(), t), "Governance asset not set"))
65+
66+
67+func F () = fromBase58String(valueOrErrorMessage(getString(B(), u), "Quote asset not set"))
68+
69+
70+func G () = valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(B(), w), "Manager address not set")), "Manager address invalid")
71+
72+
73+let H = (1 * (((((((10 * 10) * 10) * 10) * 10) * 10) * 10) * 10))
74+
75+let I = (((7 * 60) * 60) * 24)
76+
77+let J = ""
78+
79+let K = 0
80+
81+func L (M) = (M / 100)
82+
83+
84+func N (M) = (M * 100)
85+
86+
87+func O (P,Q) = fraction(P, H, Q, HALFEVEN)
88+
89+
90+func R (P,Q) = fraction(P, Q, H, HALFEVEN)
91+
92+
93+func S (P) = if ((P > 0))
94+    then P
95+    else -(P)
96+
97+
98+func T (P,Q) = if ((P > Q))
99+    then Q
100+    else P
101+
102+
103+let U = (86400 * 1000)
104+
105+let V = O((1 * H), (4 * H))
106+
107+func W (X) = valueOrErrorMessage(getInteger(this, X), ("no value for " + X))
108+
109+
110+func Y (X) = valueOrElse(getInteger(this, X), 0)
111+
112+
113+func Z (X) = valueOrElse(getInteger(this, X), H)
114+
115+
116+func aa () = Y(a)
117+
118+
119+func ab () = Z(e)
120+
121+
122+func ac (ad) = Y(y(l, ad))
123+
124+
125+func ae (ad) = Y(y(m, ad))
126+
127+
128+func af (ad) = Y(y(n, ad))
129+
130+
131+func ag (ad) = Y(y(p, ad))
132+
133+
134+func ah (ad) = Y(y(o, ad))
135+
136+
137+func ai () = Y(d)
138+
139+
140+func aj () = Y(c)
141+
142+
143+func ak () = Y(g)
144+
145+
146+func al () = Y(f)
147+
148+
149+func am () = Y(h)
150+
151+
152+func an () = Y(i)
153+
154+
155+func ao () = Y(b)
156+
157+
158+func ap (ad) = Y(y(k, ad))
159+
160+
161+func aq (ad) = Y(y(j, ad))
162+
163+
164+func ar () = valueOrElse(getBoolean(this, q), false)
165+
166+
167+func as () = lastBlock.timestamp
168+
169+
170+func at () = (as() / 1000)
171+
172+
173+func au (ad) = {
174+    let av = as()
175+    let aw = ah(ad)
176+    let ax = if (((av - aw) > U))
177+        then $Tuple3(av, af(ad), 0)
178+        else $Tuple3(aw, (af(ad) - ag(ad)), ag(ad))
179+    let ay = ax._1
180+    let az = ax._2
181+    let aA = ax._3
182+    $Tuple3(ay, az, aA)
183+    }
184+
185+
186+func aB (aC) = {
187+    let aD = if ((aa() > 0))
188+        then O((ai() + aC), aa())
189+        else H
190+    aD
191+    }
192+
193+
194+func aE () = T(at(), an())
195+
196+
197+func aF (aG) = if (((aa() + aG) == 0))
198+    then ak()
199+    else {
200+        let aH = (aE() - al())
201+        let aI = if ((0 > aH))
202+            then 0
203+            else aH
204+        let aJ = O((am() * aI), (aa() + aG))
205+        (ak() + aJ)
206+        }
207+
208+
209+func aK (ad,aG) = {
210+    let aL = (aF(aG) - aq(ad))
211+    (R((ac(ad) + aG), aL) + ap(ad))
212+    }
213+
214+
215+func aM (ad,aG) = {
216+    let aN = aF(aG)
217+    let aO = at()
218+    let aP = if ((ad != ""))
219+        then $Tuple2(aK(ad, aG), aN)
220+        else $Tuple2(0, 0)
221+    let aQ = aP._1
222+    let aR = aP._2
223+    $Tuple4(aN, aO, aQ, aR)
224+    }
225+
226+
227+func aS (aT,aU) = if (((ac(aT) + aU) >= 0))
228+    then [IntegerEntry(y(l, aT), (ac(aT) + aU))]
229+    else throw(((("Vault: can not update user balance. Balance: " + toString(ac(aT))) + " change: ") + toString(aU)))
230+
231+
232+func aV (aT,aW) = [IntegerEntry(y(n, aT), aW)]
233+
234+
235+func aX (aT,aW) = [IntegerEntry(y(m, aT), aW)]
236+
237+
238+func aY (aU) = {
239+    let aZ = ai()
240+    if (((aZ + aU) >= 0))
241+        then [IntegerEntry(d, (aZ + aU))]
242+        else throw(((("Vault: can not update free balance. Balance: " + toString(aZ)) + " change: ") + toString(aU)))
243+    }
244+
245+
246+func ba (aU) = {
247+    let aZ = aj()
248+    if (((aZ + aU) >= 0))
249+        then [IntegerEntry(c, (aZ + aU))]
250+        else throw(((("Vault: can not update locked balance. Balance: " + toString(aZ)) + " change: ") + toString(aU)))
251+    }
252+
253+
254+func bb (aU) = [IntegerEntry(a, (aa() + aU))]
255+
256+
257+func bc (aW) = [IntegerEntry(e, aW)]
258+
259+
260+func bd (aT,be,bf) = [IntegerEntry(y(o, aT), be), IntegerEntry(y(p, aT), bf)]
261+
262+
263+func bg (bh) = [IntegerEntry(b, (ao() + bh))]
264+
265+
266+func bi (bj) = [IntegerEntry(h, bj)]
267+
268+
269+func bk (bl,bm) = [IntegerEntry(f, bl), IntegerEntry(i, bm)]
270+
271+
272+func bn (bo) = [IntegerEntry(g, bo)]
273+
274+
275+func bp (ad,bq,br) = [IntegerEntry(y(k, ad), bq), IntegerEntry(y(j, ad), br)]
276+
277+
278+@Callable(bs)
279+func initialize (bt) = if (if (ar())
280+    then true
281+    else (bs.caller != this))
282+    then throw("Unable to initialize")
283+    else [StringEntry(r, toString(valueOrErrorMessage(addressFromString(bt), "Invalid coordinator address"))), BooleanEntry(q, true)]
284+
285+
286+
287+@Callable(bs)
288+func stake () = {
289+    let ad = toString(bs.caller)
290+    let M = N(bs.payments[0].amount)
291+    if (if (if ((bs.payments[0].assetId != F()))
292+        then true
293+        else (size(bs.payments) != 1))
294+        then true
295+        else !(ar()))
296+        then throw("Invalid call to stake")
297+        else {
298+            let bu = aM(ad, 0)
299+            let aN = bu._1
300+            let aO = bu._2
301+            let aQ = bu._3
302+            let aR = bu._4
303+            let bv = ab()
304+            let bw = ae(ad)
305+            let bx = O(M, bv)
306+            let by = O((R(bx, bv) + R(ac(ad), bw)), (bx + ac(ad)))
307+            let bz = (bx + ac(ad))
308+            let bA = R(bz, V)
309+            let bB = invoke(G(), "deposit", nil, [AttachedPayment(F(), L(M))])
310+            if ((bB == bB))
311+                then (((((((bp(ad, aQ, aR) ++ bn(aN)) ++ bk(aO, an())) ++ aY(M)) ++ aS(ad, bx)) ++ aX(ad, by)) ++ aV(ad, bA)) ++ bb(bx))
312+                else throw("Strict value is not equal to itself.")
313+            }
314+    }
315+
316+
317+
318+@Callable(bs)
319+func unStake (M) = {
320+    let ad = toString(bs.caller)
321+    let bC = N(M)
322+    if (if (if ((bs.payments != nil))
323+        then true
324+        else (0 >= bC))
325+        then true
326+        else !(ar()))
327+        then throw("Invalid call to unStake")
328+        else {
329+            let bD = aM(ad, 0)
330+            let aN = bD._1
331+            let aO = bD._2
332+            let aQ = bD._3
333+            let aR = bD._4
334+            let bE = au(ad)
335+            let ay = bE._1
336+            let az = bE._2
337+            let aA = bE._3
338+            let bx = O(bC, ab())
339+            if ((bx > az))
340+                then throw("Invalid call to unStake: withdraw over limit")
341+                else {
342+                    let bF = (aA + bx)
343+                    if ((bC > ai()))
344+                        then throw("Invalid call to unStake: balance too low")
345+                        else {
346+                            let bG = invoke(G(), "withdraw", [toBase58String(F()), L(bC)], nil)
347+                            if ((bG == bG))
348+                                then (((((((bp(ad, aQ, aR) ++ bn(aN)) ++ bk(aO, an())) ++ aY(-(bC))) ++ aS(ad, -(bx))) ++ bb(-(bx))) ++ bd(ad, ay, bF)) ++ [ScriptTransfer(bs.caller, L(bC), F())])
349+                                else throw("Strict value is not equal to itself.")
350+                            }
351+                    }
352+            }
353+    }
354+
355+
356+
357+@Callable(bs)
358+func withdrawRewards () = {
359+    let ad = toString(bs.caller)
360+    let bH = aM(ad, 0)
361+    let aN = bH._1
362+    let aO = bH._2
363+    let aQ = bH._3
364+    let aR = bH._4
365+    if (if ((0 >= aQ))
366+        then true
367+        else !(ar()))
368+        then throw("No reward: Vault")
369+        else ((((bp(ad, 0, aR) ++ bn(aN)) ++ bk(aO, an())) ++ bg(-(aQ))) ++ [ScriptTransfer(bs.caller, aQ, E())])
370+    }
371+
372+
373+
374+@Callable(bs)
375+func addFree () = {
376+    let M = N(bs.payments[0].amount)
377+    if (if (if (if ((bs.payments[0].assetId != F()))
378+        then true
379+        else (size(bs.payments) != 1))
380+        then true
381+        else !(ar()))
382+        then true
383+        else !(if (D(toString(bs.caller)))
384+            then true
385+            else (bs.caller == C())))
386+        then throw("Invalid addFree params")
387+        else {
388+            let aD = aB(M)
389+            let bB = invoke(G(), "deposit", nil, [AttachedPayment(F(), L(M))])
390+            if ((bB == bB))
391+                then (aY(M) ++ bc(aD))
392+                else throw("Strict value is not equal to itself.")
393+            }
394+    }
395+
396+
397+
398+@Callable(bs)
399+func addLocked () = {
400+    let M = N(bs.payments[0].amount)
401+    if (if (if (if ((bs.payments[0].assetId != F()))
402+        then true
403+        else (size(bs.payments) != 1))
404+        then true
405+        else !(ar()))
406+        then true
407+        else !(if (D(toString(bs.caller)))
408+            then true
409+            else (bs.caller == C())))
410+        then throw("Invalid addLocked params")
411+        else {
412+            let bG = invoke(G(), "deposit", nil, [AttachedPayment(F(), L(M))])
413+            if ((bG == bG))
414+                then ba(M)
415+                else throw("Strict value is not equal to itself.")
416+            }
417+    }
418+
419+
420+
421+@Callable(bs)
422+func exchangeFreeAndLocked (M) = if (if (!(ar()))
423+    then true
424+    else !(D(toString(bs.caller))))
425+    then throw("Invalid exchangeFreeAndLocked params")
426+    else {
427+        let bC = N(M)
428+        let aD = aB(-(bC))
429+        ((ba(bC) ++ aY(-(bC))) ++ bc(aD))
430+        }
431+
432+
433+
434+@Callable(bs)
435+func withdrawLocked (M) = if (if (if (!(ar()))
436+    then true
437+    else (0 >= M))
438+    then true
439+    else !(D(toString(bs.caller))))
440+    then throw("Invalid withdrawLocked params")
441+    else {
442+        let bC = N(M)
443+        let bG = invoke(G(), "withdraw", [toBase58String(F()), L(bC)], nil)
444+        if ((bG == bG))
445+            then (ba(-(bC)) ++ [ScriptTransfer(bs.caller, L(bC), F())])
446+            else throw("Strict value is not equal to itself.")
447+        }
448+
449+
450+
451+@Callable(bs)
452+func addRewards () = if (if (if ((bs.payments[0].assetId != E()))
453+    then true
454+    else (size(bs.payments) != 1))
455+    then true
456+    else !(ar()))
457+    then throw("Invalid addRewards params")
458+    else {
459+        let bq = bs.payments[0].amount
460+        let aN = aM(J, K)._1
461+        let bI = at()
462+        let bJ = if ((bI > an()))
463+            then (bq / I)
464+            else {
465+                let bK = (an() - bI)
466+                let bL = (am() * bK)
467+                ((bq + bL) / I)
468+                }
469+        (((bi(bJ) ++ bn(aN)) ++ bg(bq)) ++ bk(bI, (bI + I)))
470+        }
471+
472+
473+
474+@Callable(bs)
475+func ackRewards () = {
476+    let bM = invoke(G(), "claimProfit", [toBase58String(F())], nil)
477+    if ((bM == bM))
478+        then {
479+            let bN = {
480+                let bO = bM
481+                if ($isInstanceOf(bO, "Int"))
482+                    then {
483+                        let bP = bO
484+                        N(bP)
485+                        }
486+                    else throw("Invalid claimProfit response")
487+                }
488+            let bQ = if ((bN > 0))
489+                then {
490+                    let aD = aB(bN)
491+                    let bB = invoke(G(), "deposit", nil, [AttachedPayment(F(), L(bN))])
492+                    if ((bB == bB))
493+                        then (aY(bN) ++ bc(aD))
494+                        else throw("Strict value is not equal to itself.")
495+                    }
496+                else nil
497+            if ((bQ == bQ))
498+                then bQ
499+                else throw("Strict value is not equal to itself.")
500+            }
501+        else throw("Strict value is not equal to itself.")
502+    }
503+
504+
505+
506+@Callable(bs)
507+func view_reward (ad) = {
508+    let aZ = ac(ad)
509+    let bR = R(ae(ad), aZ)
510+    let bS = R(ab(), aZ)
511+    let bT = (bS - bR)
512+    throw(toString(bT))
513+    }
514+
515+
516+
517+@Callable(bs)
518+func view_stakingReward (ad) = {
519+    let aQ = aM(ad, 0)._3
520+    throw(toString(L(aQ)))
521+    }
522+
523+
524+
525+@Callable(bs)
526+func view_withdrawLimit (ad) = {
527+    let az = au(ad)._2
528+    let bU = L(R(az, ab()))
529+    throw(toString(bU))
530+    }
531+
532+
533+@Verifier(bV)
534+func bW () = {
535+    let bX = getString(this, r)
536+    if (isDefined(bX))
537+        then {
538+            let bY = getString(addressFromStringValue(value(bX)), v)
539+            if (isDefined(bY))
540+                then valueOrElse(getBoolean(addressFromStringValue(value(bY)), ((("status_" + toString(this)) + "_") + toBase58String(bV.id))), false)
541+                else throw("unable to verify: admin not set in coordinator")
542+            }
543+        else sigVerify(bV.bodyBytes, bV.proofs[0], bV.senderPublicKey)
544+    }
545+
github/deemru/w8io/026f985 
31.44 ms ◑