tx · HT1o8kaQLrJahFFqVZ83YoNTc8em6KgsBABweM8tkaAm

3N8E9LU71MDkdP8FWtbP4TBXCNhoc15hWfs:  -0.10000000 Waves

2022.10.11 11:51 [2267466] smart account 3N8E9LU71MDkdP8FWtbP4TBXCNhoc15hWfs > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "HT1o8kaQLrJahFFqVZ83YoNTc8em6KgsBABweM8tkaAm",
    "fee": 10000000,
    "feeAssetId": null,
    "timestamp": 1665478252565,
    "version": 2,
    "chainId": 84,
    "sender": "3N8E9LU71MDkdP8FWtbP4TBXCNhoc15hWfs",
    "senderPublicKey": "2EDucEDvqYfn6hdx4PbvykQFRoNgPMWX6SiVPjM8AyxM",
    "proofs": [
        "36yViAfz5LzUAY5AvmqUeEELp9WYNbyPVgzPzCErzxAcDJoeiVXrNNZgadZZfn4ADs2kbuiWXoACsT1LLJ7u62Qh"
    ],
    "script": "base64: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",
    "height": 2267466,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: FyHkarCnBzEjCo6XAg9Bj2dZs7pPz62Mwb9fqAii9fcP

Full: 

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