tx · 2yZVVqyvpU9eAVijdxmzTnhiR2ygZ5WMFcSHxH6pue5V

3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C:  -0.02400000 Waves

2022.08.08 10:48 [3240707] smart account 3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2yZVVqyvpU9eAVijdxmzTnhiR2ygZ5WMFcSHxH6pue5V",
    "fee": 2400000,
    "feeAssetId": null,
    "timestamp": 1659941385166,
    "version": 1,
    "sender": "3PBiotFpqjRMkkeFBccnQNUXUopy7KFez5C",
    "senderPublicKey": "BYLtcNg4P4UcUd6tFdxeuhyRqgkYZujzyfwdEHNmo89c",
    "proofs": [
        "3KnCs8mrRyPzJhwfTpqSHySR3By4WWMAnfEL8D9NmpU8nCgmTzqPLLbYxn58M1tDjyPVEyyzGZnWUMYEhByjnqPV"
    ],
    "script": "base64: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",
    "chainId": 87,
    "height": 3240707,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: JC5Tc3eau8MEGK75s9k1iX3r49bHbb7XVXsSf6EDu6X5

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "cbd0bdc8bbba91db64066b16a84913a4c965e23e"
5+
6+let b = "__"
7+
8+let c = "__"
9+
10+let d = 1000000
11+
12+let e = 100000000
13+
14+let f = toBigInt(d)
15+
16+let g = toBigInt(e)
17+
18+let h = toBigInt(1000000000000000000)
19+
20+let i = "WAVES"
21+
22+let j = fromBase58String(i)
23+
24+let k = 1
25+
26+let l = 2
27+
28+let m = 3
29+
30+let n = 4
31+
32+let o = 5
33+
34+let p = 6
35+
36+let q = 7
37+
38+let r = 8
39+
40+let s = 9
41+
42+let t = 10
43+
44+let u = 11
45+
46+func v (w,x) = valueOrErrorMessage(getString(w, x), (((("mandatory " + toString(w)) + ".") + x) + " is not defined"))
47+
48+
49+func y () = "%s%s__config__controlAddress"
50+
51+
52+func z () = "%s__controlConfig"
53+
54+
55+func A () = "%s%s__cfg__gnsbtFromSurfCoeff"
56+
57+
58+func B (C) = split(v(C, z()), c)
59+
60+
61+func D (E,F) = valueOrErrorMessage(addressFromString(E[F]), ("Control cfg doesn't contain address at index " + toString(F)))
62+
63+
64+let G = addressFromStringValue(valueOrElse(getString(this, y()), "3P5Bfd58PPfNvBM2Hy8QfbcDqMeNtzg7KfP"))
65+
66+let E = B(G)
67+
68+let H = D(E, n)
69+
70+let I = D(E, k)
71+
72+let J = D(E, l)
73+
74+let K = valueOrElse(getInteger(this, A()), 300)
75+
76+func L () = "bond_asset_id"
77+
78+
79+func M () = "auction_contract"
80+
81+
82+func N () = "%s__minLockAmount"
83+
84+
85+func O () = "%s__stakedAssetId"
86+
87+
88+func P (Q) = makeString(["%s%s%s", "paramByUser", toString(Q), "amount"], b)
89+
90+
91+func R (Q) = makeString(["%s%s%s", "paramByUser", toString(Q), "start"], b)
92+
93+
94+func S (Q) = makeString(["%s%s%s", "paramByUser", toString(Q), "vpEffectiveHeight"], b)
95+
96+
97+func T (U,Q,V) = makeString(["%s%s%s%s", "history", U, toString(Q), toBase58String(V)], b)
98+
99+
100+func W () = makeString(["%s%s", "stats", "activeTotalLocked"], b)
101+
102+
103+func X () = makeString(["%s%s", "stats", "locksCount"], b)
104+
105+
106+func Y () = makeString(["%s%s", "stats", "activeUsersCount"], b)
107+
108+
109+func Z () = "%s__nextPeriod"
110+
111+
112+func aa () = "supportedRewardAssets"
113+
114+
115+func ab () = makeString(["%s%s%s", "dep", "lastNum"], b)
116+
117+
118+func ac (Q) = makeString(["%s%s%s", "userRwdFromDepNum", Q], b)
119+
120+
121+func ad (ae,af) = makeString(["%s%d", "rwdPerNsbtSumByDepNum", toString(ae), af], b)
122+
123+
124+func ag (Q,af) = makeString(["%s%s%s", "rwd", Q, af], b)
125+
126+
127+func ah (Q,af) = makeString(["%s%s%s", "clm", Q, af], b)
128+
129+
130+func ai (af) = makeString(["%s%s", "notDistributed", af], b)
131+
132+
133+func aj (ak,al) = fraction(toBigInt(ak), h, al)
134+
135+
136+func am (x) = valueOrElse(getInteger(this, x), 0)
137+
138+
139+func an (x,ao) = valueOrElse(getInteger(this, x), ao)
140+
141+
142+func ap (x) = valueOrErrorMessage(getInteger(this, x), (("Mandatory this." + x) + " is not defined"))
143+
144+
145+func aq (x,ao) = valueOrElse(getString(this, x), ao)
146+
147+
148+func ar (as) = valueOrErrorMessage(addressFromString(as), ("couldn't parse passed addressStr=" + as))
149+
150+
151+func at (au) = if ((au == i))
152+    then unit
153+    else fromBase58String(au)
154+
155+
156+func av (aw) = {
157+    let ax = aw
158+    if ($isInstanceOf(ax, "Int"))
159+        then {
160+            let ay = ax
161+            ay
162+            }
163+        else throw("fail to cast into Int")
164+    }
165+
166+
167+func az (aA,aB,aC,aD) = makeString(["%d%d%d%d%d%d", toString(lastBlock.height), toString(lastBlock.timestamp), toString(aA), toString(aB), toString(aC), toString(aD)], b)
168+
169+
170+func aE (aF,aG) = makeString(["%s%d%d%s", aF, toString(lastBlock.height), toString(lastBlock.timestamp), aG], b)
171+
172+
173+func aH (U,Q,V,aA,aB,aC,aD) = StringEntry(T(U, Q, V), az(aA, aB, aC, aD))
174+
175+
176+func aI (Q,V,aG) = StringEntry(T("claim", Q, V), aE(toString(Q), aG))
177+
178+
179+func aJ (aK,aL,aM) = {
180+    let aN = am(X())
181+    let aO = am(Y())
182+    let aP = am(W())
183+    let aQ = (aP + aK)
184+    $Tuple3([IntegerEntry(X(), (aN + aL)), IntegerEntry(Y(), (aO + aM)), IntegerEntry(W(), aQ)], aP, aQ)
185+    }
186+
187+
188+func aR (Q,aS,aT) = [IntegerEntry(P(Q), aS), IntegerEntry(R(Q), aT)]
189+
190+
191+func aU () = $Tuple2(fromBase58String(v(this, O())), ap(N()))
192+
193+
194+func aV (Q) = (an(P(Q), 0) > 0)
195+
196+
197+func aW (Q) = if (aV(Q))
198+    then $Tuple3(false, ap(P(Q)), ap(R(Q)))
199+    else unit
200+
201+
202+func aX (Q) = valueOrErrorMessage(aW(Q), (("User " + toString(Q)) + " is not defined"))
203+
204+
205+let aY = aq(aa(), "")
206+
207+let aZ = split(aY, "_")
208+
209+func ba (Q,bb,bc,bd,be) = {
210+    let bf = ad(be, bb)
211+    let bg = parseBigIntValue(aq(ad(be, bb), "0"))
212+    let bh = parseBigIntValue(aq(ad(bd, bb), "0"))
213+    let bi = toInt(fraction((bg - bh), bc, h))
214+    let bj = ag(Q, bb)
215+    let bk = an(bj, 0)
216+    $Tuple4((bk + bi), bk, bi, bj)
217+    }
218+
219+
220+func bl (bm,Q,bn) = {
221+    let bc = toBigInt(bn)
222+    let bo = ac(Q)
223+    let bd = an(bo, -1)
224+    let be = an(ab(), -1)
225+    func bp (bq,br) =     {
226+        let bs = ba(Q, br, bc, bd, be)
227+        let bt = bs._1
228+        let bu = bs._2
229+        let bv = bs._3
230+        let bj = bs._4
231+        (bq :+ IntegerEntry(bj, bt))
232+        }
233+
234+    if (if ((be == -1))
235+        then (bd == -1)
236+        else false)
237+        then nil
238+        else if (if ((be == -1))
239+            then (bd > -1)
240+            else false)
241+            then throw("invalid depositNumLast and depositNumUser state")
242+            else if (if ((be > -1))
243+                then (bd >= -1)
244+                else false)
245+                then if (bm)
246+                    then [IntegerEntry(bo, be)]
247+                    else ({
248+                        let bw = aZ
249+                        let bx = size(bw)
250+                        let by = nil
251+                        func bz (bA,bB) =                         if ((bB >= bx))
252+                            then bA
253+                            else bp(bA, bw[bB])
254+
255+                        func bC (bA,bB) =                         if ((bB >= bx))
256+                            then bA
257+                            else throw("List size exceeds 10")
258+
259+                        bC(bz(bz(bz(bz(bz(bz(bz(bz(bz(bz(by, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
260+                        } :+ IntegerEntry(bo, be))
261+                else throw(((("uncovered condition: depositNumLast=" + toString(be)) + " depositNumUser=") + toString(bd)))
262+    }
263+
264+
265+func bD (af,bE) = {
266+    let bF = ai(af)
267+    let bG = an(bF, 0)
268+[IntegerEntry(bF, (bG + bE))]
269+    }
270+
271+
272+func bH (bI) = (bI / K)
273+
274+
275+func bJ (bK,bL,bM,bN) = {
276+    let bO = (bL - height)
277+    if ((0 >= bO))
278+        then (height + bK)
279+        else {
280+            let bP = (bK - bO)
281+            let bQ = if ((bN != 0))
282+                then fraction(bM, e, bN)
283+                else bL
284+            ((bK + height) - fraction(bP, bQ, e))
285+            }
286+    }
287+
288+
289+func bR (Q,bS) = {
290+    let bT = valueOrElse(aW(Q), $Tuple3(true, 0, 0))
291+    let bm = bT._1
292+    let bn = bT._2
293+    let bL = bT._3
294+    let bU = if (bm)
295+        then bS
296+        else (bS + bn)
297+    let bK = (1440 * 14)
298+    let bV = if (bm)
299+        then (bK + height)
300+        else bJ(bK, bL, bn, bU)
301+    $Tuple5(bm, bn, bL, bU, bV)
302+    }
303+
304+
305+func bW (Q,bX) = {
306+    let bY = aU()
307+    let bZ = bY._1
308+    let ca = bY._2
309+    if ((size(bX.payments) != 1))
310+        then throw("Invalid payments size")
311+        else {
312+            let cb = bX.payments[0]
313+            let aS = cb.amount
314+            let cc = (("Invalid asset. " + toBase58String(bZ)) + " is expected")
315+            let bb = valueOrErrorMessage(cb.assetId, cc)
316+            if ((bb != bZ))
317+                then throw(cc)
318+                else {
319+                    let cd = toString(Q)
320+                    let ce = bR(Q, aS)
321+                    let bm = ce._1
322+                    let bn = ce._2
323+                    let bL = ce._3
324+                    let bU = ce._4
325+                    let bV = ce._5
326+                    if ((ca > bU))
327+                        then throw(("Min lock amount is " + toString(ca)))
328+                        else {
329+                            let cf = aJ(aS, 1, if (bm)
330+                                then 1
331+                                else 0)
332+                            let cg = cf._1
333+                            let ch = cf._2
334+                            let ci = cf._3
335+                            ((([aH("stake", Q, bX.transactionId, bn, bL, bU, bV)] ++ bl(bm, cd, bn)) ++ aR(Q, bU, bV)) ++ cg)
336+                            }
337+                    }
338+            }
339+    }
340+
341+
342+func cj (Q,bX) = {
343+    let cd = toString(Q)
344+    if ((size(bX.payments) > 0))
345+        then throw("payments are not accepted")
346+        else {
347+            let ck = valueOrElse(aW(Q), $Tuple3(true, 0, 0))
348+            let bm = ck._1
349+            let bn = ck._2
350+            let cl = ck._3
351+            let bc = toBigInt(bn)
352+            let bo = ac(cd)
353+            let bd = an(bo, -1)
354+            let be = an(ab(), -1)
355+            func cm (bq,br) =             {
356+                let cn = ba(cd, br, bc, bd, be)
357+                let bt = cn._1
358+                let bu = cn._2
359+                let bv = cn._3
360+                let bj = cn._4
361+                let co = ah(cd, br)
362+                let cp = bq
363+                let cq = cp._1
364+                let cr = cp._2
365+                let cs = makeString([br, toString(bt)], ":")
366+                let ct = makeString([cr, cs], "_")
367+                if ((0 >= bt))
368+                    then $Tuple2(cq, ct)
369+                    else $Tuple2((((cq :+ ScriptTransfer(Q, bt, at(br))) :+ IntegerEntry(co, (valueOrElse(getInteger(co), 0) + bt))) :+ IntegerEntry(bj, 0)), ct)
370+                }
371+
372+            let cu = {
373+                let bw = aZ
374+                let bx = size(bw)
375+                let by = $Tuple2(nil, "")
376+                func bz (bA,bB) =                 if ((bB >= bx))
377+                    then bA
378+                    else cm(bA, bw[bB])
379+
380+                func bC (bA,bB) =                 if ((bB >= bx))
381+                    then bA
382+                    else throw("List size exceeds 10")
383+
384+                bC(bz(bz(bz(bz(bz(bz(bz(bz(bz(bz(by, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
385+                }
386+            let cv = cu._1
387+            let cw = cu._2
388+            if ((0 >= size(cv)))
389+                then nil
390+                else ((cv :+ IntegerEntry(bo, be)) :+ aI(Q, bX.transactionId, drop(cw, 1)))
391+            }
392+    }
393+
394+
395+@Callable(bX)
396+func constructor (ca,cx,bZ) = if ((bX.caller != this))
397+    then throw("Permission denied")
398+    else [IntegerEntry(N(), ca), StringEntry(aa(), cx), StringEntry(O(), bZ)]
399+
400+
401+
402+@Callable(bX)
403+func stake () = bW(bX.caller, bX)
404+
405+
406+
407+@Callable(bX)
408+func stakeByOriginCaller () = bW(bX.originCaller, bX)
409+
410+
411+
412+@Callable(bX)
413+func unstake (aS) = if ((size(bX.payments) != 0))
414+    then throw("unstake doesn't require any payment")
415+    else {
416+        let Q = bX.caller
417+        let cd = toString(Q)
418+        let cy = aU()
419+        let bZ = cy._1
420+        let ca = cy._2
421+        let cz = aX(Q)
422+        let bm = cz._1
423+        let bn = cz._2
424+        let bL = cz._3
425+        if ((0 >= bn))
426+            then throw("Nothing to unstake")
427+            else if ((aS > bn))
428+                then throw(((("Requested " + toString(aS)) + ", but staked only ") + toString(bn)))
429+                else {
430+                    let bU = (bn - aS)
431+                    let cA = aJ(-(aS), if ((aS == bn))
432+                        then -1
433+                        else 0, if ((aS == bn))
434+                        then -1
435+                        else 0)
436+                    let cg = cA._1
437+                    let ch = cA._2
438+                    let ci = cA._3
439+                    ((([ScriptTransfer(Q, aS, bZ), aH("unstake", Q, bX.transactionId, bn, bL, bU, bL)] ++ bl(false, cd, bn)) ++ aR(Q, bU, bL)) ++ cg)
440+                    }
441+        }
442+
443+
444+
445+@Callable(bX)
446+func deposit () = if ((size(bX.payments) != 1))
447+    then throw("exact 1 payment is allowed only")
448+    else {
449+        let cB = bX.payments[0]
450+        let aS = cB.amount
451+        let cC = valueOrElse(cB.assetId, j)
452+        let cD = toBase58String(cC)
453+        let cE = if ((cC == j))
454+            then g
455+            else f
456+        let cF = toBigInt(aS)
457+        let ch = an(W(), 0)
458+        let cG = toBigInt(ch)
459+        if ((0 > ch))
460+            then throw("TODO: case is not supported")
461+            else if ((ch == 0))
462+                then bD(cD, aS)
463+                else {
464+                    let cH = fraction(cF, h, cG)
465+                    let cI = ab()
466+                    let be = an(cI, -1)
467+                    let cJ = (be + 1)
468+                    if (!(contains(aY, cD)))
469+                        then throw(((aY + " doesn't contain ") + cD))
470+                        else {
471+                            func cK (bq,cL) =                             {
472+                                let cM = ad(cJ, cL)
473+                                let cN = aq(ad(be, cL), "0")
474+                                (bq :+ (if ((cL == cD))
475+                                    then StringEntry(cM, toString((parseBigIntValue(cN) + cH)))
476+                                    else StringEntry(cM, cN)))
477+                                }
478+
479+                            ({
480+                                let bw = aZ
481+                                let bx = size(bw)
482+                                let by = nil
483+                                func bz (bA,bB) =                                 if ((bB >= bx))
484+                                    then bA
485+                                    else cK(bA, bw[bB])
486+
487+                                func bC (bA,bB) =                                 if ((bB >= bx))
488+                                    then bA
489+                                    else throw("List size exceeds 10")
490+
491+                                bC(bz(bz(bz(bz(bz(bz(bz(bz(bz(bz(by, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
492+                                } :+ IntegerEntry(cI, cJ))
493+                            }
494+                    }
495+        }
496+
497+
498+
499+@Callable(bX)
500+func claimRewards () = cj(bX.caller, bX)
501+
502+
503+
504+@Callable(bX)
505+func claimRewardsByOriginCaller () = cj(bX.originCaller, bX)
506+
507+
508+
509+@Callable(bX)
510+func unclaimedRewardsREADONLY (cd) = {
511+    func cO (bq,br) =     ((bq + makeString([br, "0", "0"], ":")) + "_")
512+
513+    let cP = if ((cd == ""))
514+        then {
515+            let bw = aZ
516+            let bx = size(bw)
517+            let by = ""
518+            func bz (bA,bB) =             if ((bB >= bx))
519+                then bA
520+                else cO(bA, bw[bB])
521+
522+            func bC (bA,bB) =             if ((bB >= bx))
523+                then bA
524+                else throw("List size exceeds 10")
525+
526+            bC(bz(bz(bz(bz(bz(bz(bz(bz(bz(bz(by, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
527+            }
528+        else {
529+            let Q = addressFromStringValue(cd)
530+            let cQ = valueOrElse(aW(Q), $Tuple3(true, 0, 0))
531+            let bm = cQ._1
532+            let bn = cQ._2
533+            let cl = cQ._3
534+            let bc = toBigInt(bn)
535+            let bo = ac(cd)
536+            let bd = an(bo, -1)
537+            let be = an(ab(), -1)
538+            func cm (bq,br) =             {
539+                let cR = ba(cd, br, bc, bd, be)
540+                let bt = cR._1
541+                let bu = cR._2
542+                let bv = cR._3
543+                let bj = cR._4
544+                let cS = valueOrElse(getInteger(ah(cd, br)), 0)
545+                ((bq + makeString([br, toString(bt), toString(cS)], ":")) + "_")
546+                }
547+
548+            let bw = aZ
549+            let bx = size(bw)
550+            let by = ""
551+            func bz (bA,bB) =             if ((bB >= bx))
552+                then bA
553+                else cm(bA, bw[bB])
554+
555+            func bC (bA,bB) =             if ((bB >= bx))
556+                then bA
557+                else throw("List size exceeds 10")
558+
559+            bC(bz(bz(bz(bz(bz(bz(bz(bz(bz(bz(by, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
560+            }
561+    $Tuple2(nil, dropRight(cP, 1))
562+    }
563+
564+
565+
566+@Callable(bX)
567+func surfStakingSYSREADONLY (cT,cU) = {
568+    let cV = an(W(), 0)
569+    let cW = bH(cV)
570+    if ((cT == ""))
571+        then $Tuple2(nil, [0, cV, 0, cW, 0, height, height])
572+        else {
573+            let Q = ar(cT)
574+            let ce = bR(Q, cU)
575+            let bm = ce._1
576+            let bn = ce._2
577+            let bL = ce._3
578+            let bU = ce._4
579+            let bV = ce._5
580+            let cX = bn
581+            let cY = bH(cX)
582+            $Tuple2(nil, [cX, cV, cY, cW, bL, bV])
583+            }
584+    }
585+
586+
587+
588+@Callable(bX)
589+func gnsbtFromSurfSYSREADONLY (bI) = $Tuple2(nil, bH(bI))
590+
591+
592+
593+@Callable(bX)
594+func configSYSREADONLY () = {
595+    let cZ = getIntegerValue(N())
596+    let da = (1440 * 14)
597+    let db = 1150000
598+    $Tuple2(nil, [cZ, (K * d), da, db])
599+    }
600+
601+
github/deemru/w8io/3ef1775 
129.86 ms ◑