tx · BwZV2GJFMC4zUXeX5uQvaGYH4yqKKRA6x9LkENbjo8Sx

3MyLDDChFqiZMV8At2rmymVkQzrrPbSE7EK:  -0.01000000 Waves

2022.03.16 16:09 [1966547] smart account 3MyLDDChFqiZMV8At2rmymVkQzrrPbSE7EK > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BwZV2GJFMC4zUXeX5uQvaGYH4yqKKRA6x9LkENbjo8Sx",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1647436238622,
    "version": 2,
    "chainId": 84,
    "sender": "3MyLDDChFqiZMV8At2rmymVkQzrrPbSE7EK",
    "senderPublicKey": "GFmKZ2naZFRoCvNbwKAQVGmLb1uBeWGDgFabdGBuZiuy",
    "proofs": [
        "2DvjrRaeB31DZXABd9FW3KQqbCGCkAo9aE8piDgWUu6U9pQfFzyU6qjKgyb8K5JckxrnqNkfvX24HqsjF97Rptfb"
    ],
    "script": "base64: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",
    "height": 1966547,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 5dV9FWiXPZGpMuk7omzA8p7eNmEWdFN1JX85JWAyXnqU
Next: 9Vi6dShqRBrogqSX8vt3DTNWaJHRG6yctKmES5BLEdaU

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 5 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
4+let a = base58'GFmKZ2naZFRoCvNbwKAQVGmLb1uBeWGDgFabdGBuZiuy'
5+
6+let b = base58'GmJXRyhRA79g8yUGgKBAVdnFfQFDMjQG98b1MmLDh5kk'
7+
8+let c = base58'CFhbV6h41hVjbGHudGtS3fYUv7QAKRxFQzKNtx4B5PqP'
9+
10+let d = base58'GFmKZ2naZFRoCvNbwKAQVGmLb1uBeWGDgFabdGBuZiuy'
11+
12+let e = base58'4FKEh3tmKwAdBv7cr6iMhVN9wDx7FiM6u62eKY3M4uBg'
13+
14+let f = "active"
15+
16+let g = "shutdown_cause"
17+
18+let h = "last_interest"
19+
20+let i = "_last_interest"
21+
22+let j = "_SWOP_amount"
23+
24+let k = "_getBackHeight"
25+
26+let l = "total_SWOP_amount"
27+
28+let m = "_user_total_SWOP_vote"
29+
30+let n = "_SWOP_option_amount"
31+
32+let o = "total_SWOP_option_amount"
33+
34+let p = "_SWOP_claimed_amount"
35+
36+let q = "_SWOP_last_claimed_amount"
37+
38+let r = "vote_name"
39+
40+let s = "_option_name"
41+
42+let t = "_startHeight"
43+
44+let u = "_vote_duration"
45+
46+let v = "_current_pool_fraction_reward"
47+
48+let w = "_previous_pool_fraction_reward"
49+
50+let x = "_pool_reward_update_height"
51+
52+let y = "total_reward_per_block_current"
53+
54+let z = "total_reward_per_block_previous"
55+
56+let A = "reward_update_height"
57+
58+let B = "reward_update_height_first_pagination"
59+
60+let C = "_vote_no"
61+
62+let D = "_vote_yes"
63+
64+let E = "max_amount_voting"
65+
66+let F = "_status"
67+
68+let G = "_finish_height"
69+
70+let H = "voting_active_cell_1"
71+
72+let I = "voting_active_cell_2"
73+
74+let J = "voting_active_cell_3"
75+
76+let K = "sum_reward_current"
77+
78+let L = "_bought_tickets"
79+
80+let M = "_swop_per_ticket"
81+
82+let N = "launchpad_active_id"
83+
84+let O = "_duration"
85+
86+let P = "_start_height"
87+
88+let Q = "_freeze_swop_duration"
89+
90+let R = valueOrElse(getBoolean(this, f), true)
91+
92+let S = Address(base58'3P73HDkPqG15nLXevjCbmXtazHYTZbpPoPw')
93+
94+let T = Address(base58'3PQZWxShKGRgBN1qoJw6B4s9YWS9FneZTPg')
95+
96+let U = Address(base58'3PHgHf5C4WvHJucSHrjoVnMFsP1EhWffVLt')
97+
98+let V = Address(base58'3P6YGPihPiF81VELikoV1myU55iwTvmcQaQ')
99+
100+let W = "SWOP_id"
101+
102+let X = fromBase58String(getStringValue(S, W))
103+
104+let Y = 100000000
105+
106+let Z = 10000000000
107+
108+let aa = "start_height"
109+
110+let ab = "base_period"
111+
112+let ac = "period_length"
113+
114+let ad = "_user_total_struc"
115+
116+let ae = valueOrErrorMessage(getInteger(T, ab), "Empty kBasePeriod at voting contract")
117+
118+let af = valueOrErrorMessage(getInteger(T, aa), "Empty kStartHeight at voting contract")
119+
120+let ag = valueOrErrorMessage(getInteger(T, ac), "Empty kPeriodLength at voting contract")
121+
122+let ah = valueOrElse(getString(U, H), "")
123+
124+let ai = valueOrElse(getString(U, I), "")
125+
126+let aj = valueOrElse(getString(U, J), "")
127+
128+let ak = (ae + ((height - af) / ag))
129+
130+func al (am) = [BooleanEntry(f, false), StringEntry(g, am)]
4131 
5132 
133+func an () = throw("Not enough SWOP: userSWOPLocked - userTotalVoteAmount < voteSWOPAmount")
134+
135+
136+func ao () = {
137+    let ap = valueOrElse(getInteger(this, h), 0)
138+    ap
139+    }
140+
141+
142+func aq (ar) = valueOrElse(getInteger(this, (toString(ar) + j)), 0)
143+
144+
145+func as (ar) = valueOrElse(getInteger(this, (toString(ar) + p)), 0)
146+
147+
148+func at (ar) = valueOrElse(getInteger(T, (toString(ar) + m)), 0)
149+
150+
151+func au (ar,ap) = {
152+    let av = aq(ar)
153+    let aw = getInteger(this, (toString(ar) + i))
154+    let ax = {
155+        let ay = aw
156+        if ($isInstanceOf(ay, "Int"))
157+            then {
158+                let aw = ay
159+                aw
160+                }
161+            else ap
162+        }
163+    $Tuple2(ax, av)
164+    }
165+
166+
167+func az (aA,ar) = {
168+    let aB = valueOrElse(getInteger(U, aA), -1)
169+    let aC = valueOrElse(getInteger(U, (toString(aB) + G)), 0)
170+    let aD = valueOrElse(getBoolean(U, (toString(aB) + F)), true)
171+    let aE = height
172+    if ((0 > aB))
173+        then 0
174+        else if (!(aD))
175+            then 0
176+            else if ((aC > aE))
177+                then (valueOrElse(getInteger(U, (((toString(ar) + "_") + toString(aB)) + D)), 0) + valueOrElse(getInteger(U, (((toString(ar) + "_") + toString(aB)) + C)), 0))
178+                else 0
179+    }
180+
181+
182+func aF (ar) = {
183+    let aG = [az(ah, ar), az(ai, ar), az(aj, ar)]
184+    max(aG)
185+    }
186+
187+
188+func aH (ar) = {
189+    let aI = toString(valueOrElse(getInteger(V, N), 0))
190+    if ((aI == "0"))
191+        then 0
192+        else {
193+            let aJ = valueOrElse(getInteger(V, (aI + P)), 0)
194+            let aK = valueOrElse(getInteger(V, (aI + O)), 0)
195+            let aL = valueOrElse(getInteger(V, (aI + Q)), 0)
196+            let aM = ((aJ + aK) + aL)
197+            if ((height > aM))
198+                then 0
199+                else {
200+                    let aN = valueOrElse(getInteger(V, (((toString(ar) + "_") + aI) + L)), 0)
201+                    let aO = valueOrElse(getInteger(V, (aI + M)), 0)
202+                    (aN * aO)
203+                    }
204+            }
205+    }
206+
207+
208+func aP () = valueOrElse(getInteger(this, l), 0)
209+
210+
211+func aQ (ar) = {
212+    let aR = if (isDefined(getString(T, (toString(ar) + ad))))
213+        then {
214+            let aS = split(valueOrErrorMessage(getString(T, (toString(ar) + ad)), "Empty kUserTotalStruc"), "_")
215+            $Tuple3(parseIntValue(aS[0]), parseIntValue(aS[1]), parseIntValue(aS[2]))
216+            }
217+        else {
218+            let aT = valueOrElse(getInteger(T, (toString(ar) + m)), 0)
219+            $Tuple3(aT, 0, ak)
220+            }
221+    let aU = aR._1
222+    let aV = aR._2
223+    let aW = aR._3
224+    let aX = if ((aW == ak))
225+        then aV
226+        else 0
227+    $Tuple2(aU, aX)
228+    }
229+
230+
231+func aY (ar) = valueOrElse(getInteger(this, (toString(ar) + n)), 0)
232+
233+
234+func aZ (ba) = valueOrElse(getInteger(this, (ba + t)), 0)
235+
236+
237+func bb (aA) = valueOrElse(getInteger(this, (aA + x)), 0)
238+
239+
240+func bc (aA) = isDefined(getInteger(this, (aA + x)))
241+
242+
243+func bd (aA) = valueOrElse(getInteger(this, (aA + v)), 0)
244+
245+
246+func be (aA) = valueOrElse(getInteger(this, (aA + w)), 0)
247+
248+
249+func bf (ar,ba,bg) = {
250+    let bh = getInteger(this, (((ba + bg) + toString(ar)) + n))
251+    let bi = {
252+        let ay = bh
253+        if ($isInstanceOf(ay, "Int"))
254+            then {
255+                let bi = ay
256+                bi
257+                }
258+            else if ($isInstanceOf(ay, "Unit"))
259+                then {
260+                    let bi = ay
261+                    0
262+                    }
263+                else throw("Match error")
264+        }
265+    valueOrErrorMessage(bi, (((("No data on the key: " + ba) + bg) + toString(ar)) + n))
266+    }
267+
268+
269+func bj (ba) = valueOrErrorMessage(getInteger(this, (ba + u)), (("No data on the key: " + ba) + u))
270+
271+
272+func bk (ba,bg) = {
273+    let bl = getInteger(this, ((ba + bg) + o))
274+    let bm = {
275+        let ay = bl
276+        if ($isInstanceOf(ay, "Int"))
277+            then {
278+                let bm = ay
279+                bm
280+                }
281+            else if ($isInstanceOf(ay, "Unit"))
282+                then {
283+                    let bm = ay
284+                    0
285+                    }
286+                else throw("Match error")
287+        }
288+    bm
289+    }
290+
291+
292+func bn (ba,bg,ar,bo) = {
293+    let bp = ((((((ba + "_") + bg) + "_") + toString(ar)) + "_") + toString(bo))
294+    valueOrErrorMessage(getInteger(this, bp), ("No data on the key: " + bp))
295+    }
296+
297+
298+func bq (br) = {
299+    let ap = ao()
300+    let bs = au(br, ap)
301+    let aw = bs._1
302+    let bt = bs._2
303+    let bu = fraction(bt, (ap - aw), Y)
304+    let bv = ap
305+    $Tuple2(bv, bu)
306+    }
307+
308+
309+@Callable(bw)
310+func airDrop () = if (!(R))
311+    then throw("DApp is inactive at this moment")
312+    else {
313+        let bx = $Tuple2(bw.payments[0].amount, bw.payments[0].assetId)
314+        let by = bx._1
315+        let bz = bx._2
316+        if ((bz != X))
317+            then throw("Incorrect pmtAssetId")
318+            else {
319+                let bA = aP()
320+                let ap = ao()
321+                let bB = (ap + fraction(by, Y, bA))
322+[IntegerEntry(h, bB)]
323+                }
324+        }
325+
326+
327+
328+@Callable(bw)
329+func lockSWOP () = if (!(R))
330+    then throw("DApp is inactive at this moment")
331+    else {
332+        let bC = $Tuple2(bw.payments[0].amount, bw.payments[0].assetId)
333+        let by = bC._1
334+        let bz = bC._2
335+        if ((bz != X))
336+            then throw("Incorrect pmtAssetId")
337+            else {
338+                let ap = ao()
339+                let bD = au(bw.caller, ap)
340+                let aw = bD._1
341+                let bt = bD._2
342+                let bu = fraction(bt, (ap - aw), Y)
343+                let bE = ((bt + by) + bu)
344+                let bv = ap
345+                let bA = aP()
346+                let bF = ((bA + by) + bu)
347+                let bG = as(bw.caller)
348+                let bH = (bG + bu)
349+[IntegerEntry((toString(bw.caller) + i), bv), IntegerEntry((toString(bw.caller) + j), bE), IntegerEntry(l, bF), IntegerEntry((toString(bw.caller) + p), bH), IntegerEntry((toString(bw.caller) + q), bu)]
350+                }
351+        }
352+
353+
354+
355+@Callable(bw)
356+func withdrawSWOP (bI) = if (!(R))
357+    then throw("DApp is inactive at this moment")
358+    else if ((0 >= bI))
359+        then throw("withdrawAmount <= 0")
360+        else {
361+            let bA = aP()
362+            let bt = aq(bw.caller)
363+            let bJ = bq(bw.caller)
364+            let bv = bJ._1
365+            let bu = bJ._2
366+            let bK = aQ(bw.caller)
367+            let bL = bK._1
368+            let bM = bK._2
369+            let bN = aF(bw.caller)
370+            let bO = aH(bw.caller)
371+            if (if (if ((0 > bM))
372+                then true
373+                else (0 > bL))
374+                then true
375+                else (0 > bN))
376+                then throw("userUnvoteAmount < 0 || userVoteAmount < 0 || userVoteAmountForNewPool < 0")
377+                else {
378+                    let bP = (bt - max([bN, (bL + bM), bO]))
379+                    if ((bI > bP))
380+                        then throw("withdrawAmount > availableToUnstake")
381+                        else {
382+                            let bF = ((bA + bu) - bI)
383+                            let bQ = ((bt + bu) - bI)
384+                            let bG = as(bw.caller)
385+                            let bH = (bG + bu)
386+[IntegerEntry((toString(bw.caller) + i), bv), IntegerEntry((toString(bw.caller) + j), bQ), IntegerEntry(l, bF), ScriptTransfer(bw.caller, bI, X), IntegerEntry((toString(bw.caller) + p), bH), IntegerEntry((toString(bw.caller) + q), bu)]
387+                            }
388+                    }
389+            }
390+
391+
392+
393+@Callable(bw)
394+func claimAndWithdrawSWOP () = if (!(R))
395+    then throw("DApp is inactive at this moment")
396+    else {
397+        let ap = ao()
398+        let bR = bq(bw.caller)
399+        let bv = bR._1
400+        let bu = bR._2
401+        let bG = as(bw.caller)
402+        let bH = (bG + bu)
403+        if ((bu == 0))
404+            then throw("You have 0 available SWOP")
405+            else [IntegerEntry((toString(bw.caller) + i), bv), IntegerEntry((toString(bw.caller) + p), bH), IntegerEntry((toString(bw.caller) + q), bu), ScriptTransfer(bw.caller, bu, X)]
406+        }
407+
408+
409+
410+@Callable(bw)
411+func claimAndStakeSWOP () = if (!(R))
412+    then throw("DApp is inactive at this moment")
413+    else {
414+        let bA = aP()
415+        let bt = aq(bw.caller)
416+        let ap = ao()
417+        let bS = bq(bw.caller)
418+        let bv = bS._1
419+        let bu = bS._2
420+        let bE = (bt + bu)
421+        let bF = (bA + bu)
422+        let bG = as(bw.caller)
423+        let bH = (bG + bu)
424+        if ((bu == 0))
425+            then throw("You have 0 available SWOP")
426+            else [IntegerEntry((toString(bw.caller) + i), bv), IntegerEntry(l, bF), IntegerEntry((toString(bw.caller) + j), bE), IntegerEntry((toString(bw.caller) + p), bH), IntegerEntry((toString(bw.caller) + q), bu)]
427+        }
428+
429+
430+
431+@Callable(bw)
432+func updateWeights (bT,bU,bV,bW) = if (!(R))
433+    then throw("DApp is inactive at this moment")
434+    else {
435+        let bX = 10
436+        let bY = valueOrElse(getInteger(this, A), 0)
437+        if (!(containsElement([a, b, c, d, e], bw.callerPublicKey)))
438+            then throw("Only admin can call this function")
439+            else if ((size(bT) > bX))
440+                then throw(("Max amount of pool is " + toString(bX)))
441+                else if ((bY >= bV))
442+                    then throw("rewardUpdateHeight <= totalRewardUpdateHeight")
443+                    else if ((height >= bV))
444+                        then throw("height >= rewardUpdateHeight")
445+                        else if ((0 >= bV))
446+                            then throw("0 >= rewardUpdateHeight ")
447+                            else {
448+                                func bZ (ca,cb) =                                 (ca + cb)
449+
450+                                func cc (cd,aA) =                                 {
451+                                    let ce = bb(aA)
452+                                    if (if (!(bc(aA)))
453+                                        then true
454+                                        else if ((bV != ce))
455+                                            then (ce == bY)
456+                                            else false)
457+                                        then {
458+                                            let cf = bd(aA)
459+IntegerEntry((aA + w), cf) :: cd
460+                                            }
461+                                        else {
462+                                            let cf = be(aA)
463+IntegerEntry((aA + w), cf) :: cd
464+                                            }
465+                                    }
466+
467+                                func cg (cd,aA) =                                 {
468+                                    let ch = value(indexOf(bT, aA))
469+                                    let cf = bU[ch]
470+                                    if ((0 > cf))
471+                                        then throw("PoolReward < 0")
472+                                        else IntegerEntry((aA + v), cf) :: cd
473+                                    }
474+
475+                                func ci (cd,aA) =                                 {
476+                                    let cj = bV
477+IntegerEntry((aA + x), cj) :: cd
478+                                    }
479+
480+                                func ck (cl,bW) =                                 if ((bW == 0))
481+                                    then if ((cl > Z))
482+                                        then throw(((("sumRewardPrevious > totalVoteShare or sumRewardCurrent > totalVoteShare - " + toString(bW)) + " ") + toString(cl)))
483+                                        else $Tuple2([IntegerEntry(K, cl)], [IntegerEntry(B, bV)])
484+                                    else if ((bW == 1))
485+                                        then {
486+                                            let cm = valueOrElse(getInteger(this, K), 0)
487+                                            let cn = valueOrElse(getInteger(this, B), 0)
488+                                            if (((cl + cm) > Z))
489+                                                then throw(((("sumRewardPrevious > totalVoteShare or sumRewardCurrent > totalVoteShare - " + toString(bW)) + " ") + toString((cl + cm))))
490+                                                else if ((cn != bV))
491+                                                    then throw("current rewardUpdateHeight != rewardUpdateHeightFirstPaginationEntry")
492+                                                    else $Tuple2([IntegerEntry(K, (cl + cm))], nil)
493+                                            }
494+                                        else if ((bW == 2))
495+                                            then {
496+                                                let co = (valueOrElse(getInteger(this, K), 0) + cl)
497+                                                let cn = valueOrElse(getInteger(this, B), 0)
498+                                                if ((co != Z))
499+                                                    then throw("sumRewardPrevious != totalVoteShare or sumRewardCurrent != totalVoteShare")
500+                                                    else if ((cn != bV))
501+                                                        then throw("current rewardUpdateHeight != rewardUpdateHeightFirstPaginationEntry")
502+                                                        else $Tuple2([IntegerEntry(K, co)], nil)
503+                                                }
504+                                            else throw("Incorrect pagination")
505+
506+                                let cp = {
507+                                    let cq = bT
508+                                    let cr = size(cq)
509+                                    let cs = nil
510+                                    func ct (cu,cv) =                                     if ((cv >= cr))
511+                                        then cu
512+                                        else cc(cu, cq[cv])
513+
514+                                    func cw (cu,cv) =                                     if ((cv >= cr))
515+                                        then cu
516+                                        else throw("List size exceeds 10")
517+
518+                                    cw(ct(ct(ct(ct(ct(ct(ct(ct(ct(ct(cs, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
519+                                    }
520+                                let cx = {
521+                                    let cq = bT
522+                                    let cr = size(cq)
523+                                    let cs = nil
524+                                    func cy (cu,cv) =                                     if ((cv >= cr))
525+                                        then cu
526+                                        else cg(cu, cq[cv])
527+
528+                                    func cz (cu,cv) =                                     if ((cv >= cr))
529+                                        then cu
530+                                        else throw("List size exceeds 10")
531+
532+                                    cz(cy(cy(cy(cy(cy(cy(cy(cy(cy(cy(cs, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
533+                                    }
534+                                let cA = {
535+                                    let cq = bT
536+                                    let cr = size(cq)
537+                                    let cs = nil
538+                                    func cB (cu,cv) =                                     if ((cv >= cr))
539+                                        then cu
540+                                        else ci(cu, cq[cv])
541+
542+                                    func cC (cu,cv) =                                     if ((cv >= cr))
543+                                        then cu
544+                                        else throw("List size exceeds 10")
545+
546+                                    cC(cB(cB(cB(cB(cB(cB(cB(cB(cB(cB(cs, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
547+                                    }
548+                                let cD = {
549+                                    let cq = bU
550+                                    let cr = size(cq)
551+                                    let cs = 0
552+                                    func cE (cu,cv) =                                     if ((cv >= cr))
553+                                        then cu
554+                                        else bZ(cu, cq[cv])
555+
556+                                    func cF (cu,cv) =                                     if ((cv >= cr))
557+                                        then cu
558+                                        else throw("List size exceeds 10")
559+
560+                                    cF(cE(cE(cE(cE(cE(cE(cE(cE(cE(cE(cs, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
561+                                    }
562+                                let cG = ck(cD, bW)
563+                                let cH = cG._1
564+                                let cn = cG._2
565+                                let cI = if ((bW == 2))
566+                                    then [IntegerEntry(A, bV)]
567+                                    else nil
568+                                if ((height > bV))
569+                                    then throw("rewardUpdateHeight < height")
570+                                    else (((((cp ++ cx) ++ cA) ++ cH) ++ cI) ++ cn)
571+                                }
572+        }
573+
574+
575+
576+@Callable(bw)
577+func shutdown () = if (!(R))
578+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, g), "the cause wasn't specified")))
579+    else if (!(containsElement([a, b, c, d], bw.callerPublicKey)))
580+        then throw("Only admin can call this function")
581+        else al("Paused by admin")
582+
583+
584+
585+@Callable(bw)
586+func activate () = if (R)
587+    then throw("DApp is already active")
588+    else if (!(containsElement([a, b, c, d], bw.callerPublicKey)))
589+        then throw("Only admin can call this function")
590+        else [BooleanEntry(f, true), DeleteEntry(g)]
591+
592+
593+@Verifier(cJ)
594+func cK () = {
595+    let cL = if (sigVerify(cJ.bodyBytes, cJ.proofs[0], a))
596+        then 1
597+        else 0
598+    let cM = if (sigVerify(cJ.bodyBytes, cJ.proofs[1], b))
599+        then 1
600+        else 0
601+    let cN = if (sigVerify(cJ.bodyBytes, cJ.proofs[2], c))
602+        then 1
603+        else 0
604+    (((cL + cM) + cN) >= 2)
605+    }
6606 
github/deemru/w8io/169f3d6 
56.20 ms ◑