tx · 9uoWHHz1d6TF7s9rZTkAkbjKCt23N2hVFfgXDh3W3iyq

3PGegnCpCPYBAicG8Y7DcTC3xPAZ3a88zDX:  -0.01800000 Waves

2022.10.16 14:50 [3340332] smart account 3PGegnCpCPYBAicG8Y7DcTC3xPAZ3a88zDX > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "9uoWHHz1d6TF7s9rZTkAkbjKCt23N2hVFfgXDh3W3iyq",
    "fee": 1800000,
    "feeAssetId": null,
    "timestamp": 1665920991975,
    "version": 2,
    "chainId": 87,
    "sender": "3PGegnCpCPYBAicG8Y7DcTC3xPAZ3a88zDX",
    "senderPublicKey": "EfCjbkuvL1rhPmbtteoieWwhCUCQJX7hYEwgCk6XBNMM",
    "proofs": [
        "bRWyc9L8BkJj7b3fnRrVRHVxWAHiX1uaG2E3UmFag2jUXYLvbMUb5JsvkLbAtYTp7d3rnP6BExL7xdsvjDL94Ad"
    ],
    "script": "base64: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",
    "height": 3340332,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "undefined"
5+
6+let b = ";"
7+
8+let c = "config"
9+
10+let d = "collector_address"
11+
12+let e = "history_address"
13+
14+let f = "paymaker_address"
15+
16+let g = "admins"
17+
18+let h = addressFromStringValue(getStringValue(this, c))
19+
20+let i = addressFromStringValue(getStringValue(h, d))
21+
22+let j = addressFromStringValue(getStringValue(h, e))
23+
24+let k = addressFromStringValue(getStringValue(h, f))
25+
26+func l (m) = {
27+    let n = valueOrElse(getString(h, g), "")
28+    if (if ((m == this))
29+        then true
30+        else contains(n, toString(m)))
31+        then true
32+        else false
33+    }
34+
35+
36+func o (p) = ("checker_" + p)
37+
38+
39+func q (p) = {
40+    let r = isDefined(getBoolean(h, o(p)))
41+    r
42+    }
43+
44+
45+let s = base58'DG2xFkPdDwKUoBkzGAhQtLpSGzfXLiCYPEzeKH2Ad24p'
46+
47+let t = 10000000
48+
49+let u = 5
50+
51+let v = 100
52+
53+let w = "first_event"
54+
55+let x = "last_event"
56+
57+let y = "first_finished_event"
58+
59+let z = "last_finished_event"
60+
61+let A = "first_active_event"
62+
63+let B = "last_active_event"
64+
65+func C (D) = (D + "_start_block")
66+
67+
68+func E (D) = (D + "_end_block")
69+
70+
71+func F (D) = (D + "_finish_at_block")
72+
73+
74+func G (D) = (D + "_answer_dapp")
75+
76+
77+func H (D) = (D + "_answer_func")
78+
79+
80+func I (D) = (D + "_result")
81+
82+
83+func J (D) = (D + "_id")
84+
85+
86+func K (D,L) = ((D + "_answer_") + toString(L))
87+
88+
89+func M (D) = (D + "_answers_count")
90+
91+
92+func N (D) = (D + "_status")
93+
94+
95+func O (D) = (D + "_description")
96+
97+
98+func P (D) = (D + "_prev_event")
99+
100+
101+func Q (D) = (D + "_next_event")
102+
103+
104+func R (D) = (D + "_claim_available")
105+
106+
107+func S (D) = (D + "_params")
108+
109+
110+func T (D) = (D + "_total_amount")
111+
112+
113+func U (D) = (D + "_claimed_winners_count")
114+
115+
116+func V (D,L) = (((D + "_") + toString(L)) + "_amount")
117+
118+
119+func W (D,L) = (((D + "_") + toString(L)) + "_count")
120+
121+
122+func X (D,Y) = (((D + "_") + Y) + "_amount")
123+
124+
125+func Z (D,Y) = (((D + "_") + Y) + "_choice")
126+
127+
128+func aa (D,Y) = (((D + "_") + Y) + "_already_claimed")
129+
130+
131+func ab (ac) = {
132+    let ad = ac
133+    if ($isInstanceOf(ad, "Int"))
134+        then {
135+            let ae = ad
136+            ae
137+            }
138+        else {
139+            let af = ad
140+            throw("#err")
141+            }
142+    }
143+
144+
145+func ag (ac) = {
146+    let ad = ac
147+    if ($isInstanceOf(ad, "String"))
148+        then {
149+            let ae = ad
150+            ae
151+            }
152+        else throw("#err")
153+    }
154+
155+
156+func ah (D) = {
157+    let ai = valueOrElse(getString(this, N(D)), "#")
158+    if (if (if ((ai == "finished"))
159+        then true
160+        else (ai == "#"))
161+        then true
162+        else (ai == "ended"))
163+        then ai
164+        else {
165+            let aj = getIntegerValue(this, F(D))
166+            let ak = getIntegerValue(this, C(D))
167+            let al = getIntegerValue(this, E(D))
168+            if ((ak > height))
169+                then "awaiting"
170+                else if (if ((height >= ak))
171+                    then (al >= height)
172+                    else false)
173+                    then "active"
174+                    else if (if ((height > al))
175+                        then (aj >= height)
176+                        else false)
177+                        then "confirmation"
178+                        else if ((height > aj))
179+                            then "finished"
180+                            else throw("unknown status")
181+            }
182+    }
183+
184+
185+func am (D) = {
186+    let an = valueOrElse(getBoolean(this, R(D)), false)
187+    if ((an == true))
188+        then true
189+        else throw("claim is not available")
190+    }
191+
192+
193+func ao (ap,aq,ak,al,aj,ar,as,at) = {
194+    let D = ap
195+    let au = ab(invoke(this, "check", [ar, as, at], nil))
196+    if ((au == au))
197+        then {
198+            let av = invoke(this, "insertToList", [D, true], nil)
199+            if ((av == av))
200+                then {
201+                    let aw = invoke(this, "concatLists", nil, nil)
202+                    if ((aw == aw))
203+                        then [IntegerEntry(C(D), ak), IntegerEntry(E(D), al), IntegerEntry(F(D), aj), StringEntry(G(D), ar), StringEntry(H(D), as), StringEntry(O(D), aq), StringEntry(N(D), "active"), StringEntry(J(D), D), StringEntry(K(D, 1), "NO"), StringEntry(K(D, 2), "YES"), IntegerEntry(M(D), 2), IntegerEntry(I(D), 1), StringEntry(S(D), at)]
204+                        else throw("Strict value is not equal to itself.")
205+                    }
206+                else throw("Strict value is not equal to itself.")
207+            }
208+        else throw("Strict value is not equal to itself.")
209+    }
210+
211+
212+func ax (ay,az) = {
213+    let Y = addressFromString(az)
214+    let aA = isDefined(Y)
215+    let D = ag(valueOrElse(getString(this, J(ay)), getString(this, w)))
216+    let aB = getStringValue(this, Q(D))
217+    let ak = getIntegerValue(this, C(D))
218+    let al = getIntegerValue(this, E(D))
219+    let aC = getIntegerValue(this, F(D))
220+    let ar = getStringValue(this, G(D))
221+    let as = getStringValue(this, H(D))
222+    let aq = getStringValue(this, O(D))
223+    let ai = ah(D)
224+    let aD = getIntegerValue(this, I(D))
225+    let aE = getIntegerValue(this, M(D))
226+    let aF = (((((("[" + (if ((aE >= 1))
227+        then ((((("" + "{\"v\":\"") + getStringValue(this, K(D, 1))) + "\", \"a\":") + toString(valueOrElse(getInteger(this, V(D, 1)), 0))) + "}")
228+        else "")) + (if ((aE >= 2))
229+        then ((((("," + "{\"v\":\"") + getStringValue(this, K(D, 2))) + "\", \"a\":") + toString(valueOrElse(getInteger(this, V(D, 2)), 0))) + "}")
230+        else "")) + (if ((aE >= 3))
231+        then ((((("," + "{\"v\":\"") + getStringValue(this, K(D, 3))) + "\", \"a\":") + toString(valueOrElse(getInteger(this, V(D, 3)), 0))) + "}")
232+        else "")) + (if ((aE >= 4))
233+        then ((((("," + "{\"v\":\"") + getStringValue(this, K(D, 4))) + "\", \"a\":") + toString(valueOrElse(getInteger(this, V(D, 4)), 0))) + "}")
234+        else "")) + (if ((aE >= 5))
235+        then ((((("," + "{\"v\":\"") + getStringValue(this, K(D, 5))) + "\", \"a\":") + toString(valueOrElse(getInteger(this, V(D, 5)), 0))) + "}")
236+        else "")) + "]")
237+    let aG = if (aA)
238+        then valueOrElse(getInteger(this, Z(D, az)), 0)
239+        else 0
240+    let aH = if (aA)
241+        then valueOrElse(getInteger(this, X(D, az)), 0)
242+        else 0
243+    let aI = if (if (aA)
244+        then (valueOrElse(getBoolean(this, aa(D, az)), false) == true)
245+        else false)
246+        then 1
247+        else 0
248+    let aJ = ((((((((((((((((((("{" + "\"") + "ch") + "\"") + ":") + toString(aG)) + ",") + "\"") + "am") + "\"") + ":") + toString(aH)) + ",") + "\"") + "ac") + "\"") + ":") + toString(aI)) + "") + "}")
249+    let aK = ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((("{" + "\"") + "id") + "\"") + ":") + "\"") + D) + "\"") + ",") + "\"") + "startBlock") + "\"") + ":") + toString(ak)) + ",") + "\"") + "endBlock") + "\"") + ":") + toString(al)) + ",") + "\"") + "finishBlock") + "\"") + ":") + toString(aC)) + ",") + "\"") + "checkerDapp") + "\"") + ":") + "\"") + ar) + "\"") + ",") + "\"") + "checkerFunc") + "\"") + ":") + "\"") + as) + "\"") + ",") + "\"") + "desc") + "\"") + ":") + "\"") + aq) + "\"") + ",") + "\"") + "status") + "\"") + ":") + "\"") + ai) + "\"") + ",") + "\"") + "result") + "\"") + ":") + toString(aD)) + ",") + "\"") + "answersCount") + "\"") + ":") + toString(aE)) + ",") + "\"") + "answers") + "\"") + ":") + "") + aF) + ",") + "\"") + "u") + "\"") + ":") + "") + aJ) + "") + "}")
250+    $Tuple2(aB, aK)
251+    }
252+
253+
254+func aL (ay,az,aM) = if (if (if ((aM != 3))
255+    then (aM != 6)
256+    else false)
257+    then (aM != 9)
258+    else false)
259+    then throw(("only 3, 6 and 9 in array. Param = " + toString(aM)))
260+    else {
261+        let aN = ax(ay, az)
262+        let aO = if ((aN._1 != a))
263+            then ax(aN._1, az)
264+            else $Tuple2(a, "")
265+        let aP = if ((aO._1 != a))
266+            then ax(aO._1, az)
267+            else $Tuple2(a, "")
268+        let aQ = if (if ((aM >= 6))
269+            then (aP._1 != a)
270+            else false)
271+            then ax(aP._1, az)
272+            else $Tuple2(a, "")
273+        let aR = if (if ((aM >= 6))
274+            then (aQ._1 != a)
275+            else false)
276+            then ax(aQ._1, az)
277+            else $Tuple2(a, "")
278+        let aS = if (if ((aM >= 6))
279+            then (aR._1 != a)
280+            else false)
281+            then ax(aR._1, az)
282+            else $Tuple2(a, "")
283+        let aT = if (if ((aM >= 9))
284+            then (aS._1 != a)
285+            else false)
286+            then ax(aS._1, az)
287+            else $Tuple2(a, "")
288+        let aU = if (if ((aM >= 9))
289+            then (aT._1 != a)
290+            else false)
291+            then ax(aT._1, az)
292+            else $Tuple2(a, "")
293+        let aV = if (if ((aM >= 9))
294+            then (aU._1 != a)
295+            else false)
296+            then ax(aU._1, az)
297+            else $Tuple2(a, "")
298+        let aW = (((((((((("[" + aN._2) + (if ((aN._1 != a))
299+            then ("," + aO._2)
300+            else "")) + (if ((aO._1 != a))
301+            then ("," + aP._2)
302+            else "")) + (if ((aP._1 != a))
303+            then ("," + aQ._2)
304+            else "")) + (if ((aQ._1 != a))
305+            then ("," + aR._2)
306+            else "")) + (if ((aR._1 != a))
307+            then ("," + aS._2)
308+            else "")) + (if ((aS._1 != a))
309+            then ("," + aT._2)
310+            else "")) + (if ((aT._1 != a))
311+            then ("," + aU._2)
312+            else "")) + (if ((aU._1 != a))
313+            then ("," + aV._2)
314+            else "")) + "]")
315+        $Tuple2(aV._1, aW)
316+        }
317+
318+
319+@Callable(aX)
320+func init (aY) = if ((aX.caller != this))
321+    then throw("only main can do")
322+    else {
323+        let r = isDefined(getString(this, c))
324+        if (!(r))
325+            then [StringEntry(c, aY)]
326+            else throw("already inited")
327+        }
328+
329+
330+
331+@Callable(aX)
332+func appendEventer (aq) = if (!(l(aX.caller)))
333+    then throw("only admin can do")
334+    else {
335+        let aZ = invoke(h, "setEventer", [toString(this), aq], nil)
336+        if ((aZ == aZ))
337+            then nil
338+            else throw("Strict value is not equal to itself.")
339+        }
340+
341+
342+
343+@Callable(aX)
344+func resetList () = if (!(l(aX.caller)))
345+    then throw("only admin can do")
346+    else [StringEntry(w, a), StringEntry(x, a), StringEntry(A, a), StringEntry(B, a), StringEntry(y, a), StringEntry(z, a)]
347+
348+
349+
350+@Callable(aX)
351+func insertToList (D,ba) = if ((this != aX.caller))
352+    then throw("only main can do")
353+    else {
354+        let bb = if (ba)
355+            then B
356+            else z
357+        let bc = if (ba)
358+            then A
359+            else y
360+        let bd = valueOrElse(getString(this, bc), a)
361+        let be = valueOrElse(getString(this, bb), a)
362+        let bf = if ((be == a))
363+            then bb
364+            else P(bd)
365+[StringEntry(bc, D), StringEntry(bf, D), StringEntry(Q(D), bd)]
366+        }
367+
368+
369+
370+@Callable(aX)
371+func deleteFromList (D,ba) = if ((this != aX.caller))
372+    then throw("only main can do")
373+    else {
374+        let bb = if (ba)
375+            then B
376+            else z
377+        let bc = if (ba)
378+            then A
379+            else y
380+        let bd = valueOrElse(getString(this, bc), a)
381+        let be = valueOrElse(getString(this, bb), a)
382+        let bg = valueOrElse(getString(this, P(D)), a)
383+        let bh = valueOrElse(getString(this, Q(D)), a)
384+        let bi = if ((D == bd))
385+            then a
386+            else bg
387+        let bj = if ((D == be))
388+            then a
389+            else bh
390+        if (if ((bi == a))
391+            then (bj == a)
392+            else false)
393+            then [StringEntry(bc, a), StringEntry(bb, a)]
394+            else if (if ((bi != a))
395+                then (bj != a)
396+                else false)
397+                then [StringEntry(P(bj), bi), StringEntry(Q(bi), bj)]
398+                else if ((bi != a))
399+                    then [StringEntry(bb, bi), StringEntry(Q(bi), a)]
400+                    else [StringEntry(bc, bj), StringEntry(P(bj), a)]
401+        }
402+
403+
404+
405+@Callable(aX)
406+func concatLists () = if (!(l(aX.caller)))
407+    then throw("only admin can do")
408+    else {
409+        let bk = valueOrElse(getString(this, A), a)
410+        let bl = valueOrElse(getString(this, B), a)
411+        let bm = valueOrElse(getString(this, y), a)
412+        let bn = valueOrElse(getString(this, z), a)
413+        let bd = if ((bk != a))
414+            then bk
415+            else bm
416+        let be = if ((bn != a))
417+            then bn
418+            else bl
419+        if (if ((bm != a))
420+            then (bl != a)
421+            else false)
422+            then [StringEntry(w, bd), StringEntry(x, be), StringEntry(Q(bl), bm), StringEntry(P(bm), bl)]
423+            else [StringEntry(w, bd), StringEntry(x, be)]
424+        }
425+
426+
427+
428+@Callable(aX)
429+func fullRegisterEvent (aq,ak,bo,ar,as,at) = {
430+    let bp = if ((ak == 0))
431+        then height
432+        else ak
433+    let al = (bp + bo)
434+    let aj = (al + 1440)
435+    if (!(l(aX.caller)))
436+        then throw("only admin can do")
437+        else {
438+            let ap = toBase58String(aX.transactionId)
439+            ao(ap, aq, bp, al, aj, ar, as, at)
440+            }
441+    }
442+
443+
444+
445+@Callable(aX)
446+func choice (D,bq) = {
447+    let Y = toString(aX.caller)
448+    let br = invoke(this, "checkResult", [D], nil)
449+    if ((br == br))
450+        then {
451+            let ai = ah(D)
452+            if ((ai == "active"))
453+                then if (if ((size(aX.payments) == 1))
454+                    then (aX.payments[0].assetId == s)
455+                    else false)
456+                    then {
457+                        let bs = aX.payments[0].amount
458+                        if ((t > bs))
459+                            then throw("amount is less than allowed")
460+                            else {
461+                                let aE = getIntegerValue(this, M(D))
462+                                if (if ((bq == 0))
463+                                    then true
464+                                    else (bq > aE))
465+                                    then throw("choice is invalid")
466+                                    else {
467+                                        let bt = valueOrElse(getInteger(this, T(D)), 0)
468+                                        let bu = valueOrElse(getInteger(this, V(D, bq)), 0)
469+                                        let bv = valueOrElse(getInteger(this, W(D, bq)), 0)
470+                                        let aH = valueOrElse(getInteger(this, X(D, Y)), 0)
471+                                        if ((aH != 0))
472+                                            then throw("betting from this address is exists")
473+                                            else {
474+                                                let bw = invoke(j, "saveToHistory", [D, Y], nil)
475+                                                if ((bw == bw))
476+                                                    then [IntegerEntry(T(D), (bt + bs)), IntegerEntry(V(D, bq), (bu + bs)), IntegerEntry(W(D, bq), (bv + 1)), IntegerEntry(Z(D, Y), bq), IntegerEntry(X(D, Y), bs)]
477+                                                    else throw("Strict value is not equal to itself.")
478+                                                }
479+                                        }
480+                                }
481+                        }
482+                    else throw("Bad payment")
483+                else throw("You can`t do it")
484+            }
485+        else throw("Strict value is not equal to itself.")
486+    }
487+
488+
489+
490+@Callable(aX)
491+func claim (D,bx) = if (!(am(D)))
492+    then throw("claim is not available")
493+    else if (if (if (!(l(aX.caller)))
494+        then (bx != toString(aX.caller))
495+        else false)
496+        then (aX.caller != k)
497+        else false)
498+        then throw("claim is not available for you")
499+        else {
500+            let Y = addressFromStringValue(bx)
501+            let ai = ah(D)
502+            if ((ai == "finished"))
503+                then {
504+                    let by = getIntegerValue(this, T(D))
505+                    let aI = valueOrElse(getBoolean(this, aa(D, toString(Y))), false)
506+                    if (aI)
507+                        then throw("Reward already claimed")
508+                        else {
509+                            let aG = getIntegerValue(this, Z(D, toString(Y)))
510+                            let aD = getIntegerValue(this, I(D))
511+                            let bu = getIntegerValue(this, V(D, aD))
512+                            let aH = getIntegerValue(this, X(D, toString(Y)))
513+                            if ((aG == aD))
514+                                then {
515+                                    let bz = fraction(by, aH, bu)
516+                                    let bA = fraction(bz, u, v)
517+                                    let bB = (valueOrElse(getInteger(this, U(D)), 0) + 1)
518+                                    let bv = getIntegerValue(this, W(D, aD))
519+                                    if ((bB == bv))
520+                                        then [StringEntry(N(D), "ended"), BooleanEntry(aa(D, toString(Y)), true), IntegerEntry(U(D), bB), ScriptTransfer(Y, (bz - bA), s), ScriptTransfer(i, bA, s)]
521+                                        else [BooleanEntry(aa(D, toString(Y)), true), IntegerEntry(U(D), bB), ScriptTransfer(Y, (bz - bA), s), ScriptTransfer(i, bA, s)]
522+                                    }
523+                                else throw("Something went wrong")
524+                            }
525+                    }
526+                else throw("You can`t do it")
527+            }
528+
529+
530+
531+@Callable(aX)
532+func allowClaim (D) = if (!(l(aX.caller)))
533+    then throw("only admin can do")
534+    else [BooleanEntry(R(D), true)]
535+
536+
537+
538+@Callable(aX)
539+func check (bC,bD,at) = if ((this != aX.caller))
540+    then throw("only main can do")
541+    else if (!(q(bC)))
542+        then throw("is not checker")
543+        else {
544+            let au = ab(invoke(addressFromStringValue(bC), bD, [at], nil))
545+            $Tuple2(nil, au)
546+            }
547+
548+
549+
550+@Callable(aX)
551+func checkResult (D) = {
552+    let ai = ah(D)
553+    if (if ((ai == "active"))
554+        then true
555+        else (ai == "confirmation"))
556+        then {
557+            let ar = getString(this, G(D))
558+            let as = getString(this, H(D))
559+            let at = valueOrElse(getString(this, S(D)), "")
560+            let bE = getIntegerValue(this, I(D))
561+            let au = ab(invoke(this, "check", [ar, as, at], nil))
562+            if ((au == au))
563+                then if ((au != bE))
564+                    then {
565+                        let bF = invoke(this, "deleteFromList", [D, true], nil)
566+                        if ((bF == bF))
567+                            then {
568+                                let av = invoke(this, "insertToList", [D, false], nil)
569+                                if ((av == av))
570+                                    then {
571+                                        let aw = invoke(this, "concatLists", nil, nil)
572+                                        if ((aw == aw))
573+                                            then [StringEntry(N(D), "finished"), IntegerEntry(I(D), au)]
574+                                            else throw("Strict value is not equal to itself.")
575+                                        }
576+                                    else throw("Strict value is not equal to itself.")
577+                                }
578+                            else throw("Strict value is not equal to itself.")
579+                        }
580+                    else if ((aX.caller == this))
581+                        then nil
582+                        else throw()
583+                else throw("Strict value is not equal to itself.")
584+            }
585+        else throw("Event not active")
586+    }
587+
588+
589+
590+@Callable(aX)
591+func tempChangeResult (D,aD) = if (!(l(aX.caller)))
592+    then throw("only admin can do")
593+    else [IntegerEntry(I(D), aD)]
594+
595+
github/deemru/w8io/873ac7e 
41.59 ms ◑