tx · DgqwdNWEhSAKdSZ3PeMRfzqSTUnxohoo6erkBqiLcR4K

3N1BEXuoepNEwqkbeZYKviaLQfvBQV3ibYE:  -0.02000000 Waves

2023.05.25 17:02 [2593604] smart account 3N1BEXuoepNEwqkbeZYKviaLQfvBQV3ibYE > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DgqwdNWEhSAKdSZ3PeMRfzqSTUnxohoo6erkBqiLcR4K",
    "fee": 2000000,
    "feeAssetId": null,
    "timestamp": 1685023385044,
    "version": 2,
    "chainId": 84,
    "sender": "3N1BEXuoepNEwqkbeZYKviaLQfvBQV3ibYE",
    "senderPublicKey": "6t3vrhP1jCmG7CeKBmL8hUibtdP3cMXGC2XtPYEPPC5w",
    "proofs": [
        "EewfDm7KPMTn1ssoWgxhtvkm7QeyrQghuCyPjDkdWjXFWjgLQ6objYTx6z4gnsd6mschfNfQfCgKtXRUN9J2CoR"
    ],
    "script": "base64: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",
    "height": 2593604,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: Bc95Do6JTLtq5bwhfkTyPGVPfHCKgJefqJ1gTkckU3wr

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "__"
5+
6+let b = 100000000
7+
8+func c (d) = makeString(["voting_verified_v2.ride:", d], " ")
9+
10+
11+func e (d) = throw(c(d))
12+
13+
14+func f (g) = {
15+    let h = g
16+    if ($isInstanceOf(h, "Int"))
17+        then {
18+            let i = h
19+            i
20+            }
21+        else throw("Failed to cast into Integer")
22+    }
23+
24+
25+func j (k,l) = valueOrElse(getInteger(k, l), 0)
26+
27+
28+func m (k,l) = valueOrErrorMessage(getInteger(k, l), c((l + " is not defined")))
29+
30+
31+func n (k,l) = valueOrElse(getString(k, l), "")
32+
33+
34+func o (k,l) = valueOrErrorMessage(getString(k, l), c((l + " is not defined")))
35+
36+
37+let p = makeString(["%s", "boostingContract"], a)
38+
39+let q = makeString(["%s", "emissionContract"], a)
40+
41+let r = makeString(["%s", "assetsStoreContract"], a)
42+
43+let s = addressFromStringValue(getStringValue(p))
44+
45+let t = addressFromStringValue(getStringValue(q))
46+
47+let u = addressFromStringValue(getStringValue(r))
48+
49+let v = makeString(["%s", "config"], a)
50+
51+let w = split(o(t, v), a)[1]
52+
53+let x = fromBase58String(w)
54+
55+let y = makeString(["%s%s", "votingThreshold", "add"], a)
56+
57+let z = makeString(["%s%s", "votingThreshold", "remove"], a)
58+
59+func A (B,C) = makeString(["%s%s%d", "periodLengthAdd", B, toString(C)], a)
60+
61+
62+let D = makeString(["%s", "periodLengthRemove"], a)
63+
64+func E (B,C) = makeString(["%s%s%d", "currentVotingHeightStart", B, toString(C)], a)
65+
66+
67+func F (B) = makeString(["%s%s", "verified", B], a)
68+
69+
70+func G (B) = makeString(["%s%s%s", "verification", "inProgress", B], a)
71+
72+
73+func H (B) = makeString(["%s%s%s", "deverification", "inProgress", B], a)
74+
75+
76+let I = makeString(["%s", "maxPeriodLength"], a)
77+
78+let J = makeString(["%s", "minPeriodLength"], a)
79+
80+func K (B,C) = makeString(["%s%s%d", "votingRewardAssetId", B, toString(C)], a)
81+
82+
83+func L (B,C) = makeString(["%s%s%d", "votingReward", B, toString(C)], a)
84+
85+
86+let M = makeString(["%s", "finalizeCallRewardAmount"], a)
87+
88+let N = makeString(["%s", "minSuggestRemoveBalance"], a)
89+
90+func O (B) = makeString(["%s%s", "currentIndex", B], a)
91+
92+
93+func P (B,C,Q) = makeString(["%s%s%d%s", "vote", B, toString(C), toString(Q)], a)
94+
95+
96+func R (S,T) = makeString(["%s%d", toString(S), toString(T)], a)
97+
98+
99+func U (B,C) = makeString(["%s%s%d", "votingResult", B, toString(C)], a)
100+
101+
102+func V (W,X) = makeString(["%d%d", toString(W), toString(X)], a)
103+
104+
105+let Y = makeString(["%d%d", "0", "0"], a)
106+
107+func Z (B,C) = makeString(["%s%s%d", "suggestIssuer", B, toString(C)], a)
108+
109+
110+func aa (ab,B,C) = makeString(["%s%s%s%d", "history", toString(ab), B, toString(C)], a)
111+
112+
113+func ac (T) = makeString(["%d%s", toString(T)], a)
114+
115+
116+func ad (B,C) = makeString(["%s%s%d", "votingEndHeight", B, toString(C)], a)
117+
118+
119+let ae = makeString(["%s", "wxForSuggestAddAmountRequired"], a)
120+
121+let af = makeString(["%s", "wxForSuggestRemoveAmountRequired"], a)
122+
123+let ag = makeString(["%s", "wxSuggestAddBurnAmount"], a)
124+
125+func ah (ab,ai) = {
126+    let T = invoke(s, "getUserGwxAmountAtHeightREADONLY", [ab, ai], nil)
127+    f(T)
128+    }
129+
130+
131+func aj (B,ak) = {
132+    let al = valueOrElse(getBoolean(G(B)), false)
133+    let am = valueOrElse(getBoolean(H(B)), false)
134+    let an = valueOrErrorMessage(getString(Z(B, ak)), c("voting issuer not found"))
135+    let ao = valueOrErrorMessage(getInteger(E(B, ak)), c("voting start height not found"))
136+    let ap = if (al)
137+        then valueOrErrorMessage(getInteger(A(B, ak)), c("voting period length not found"))
138+        else value(getInteger(D))
139+    let aq = [if (if (al)
140+        then true
141+        else am)
142+        then true
143+        else e("no voting in progress"), if (((ao + ap) > height))
144+        then true
145+        else e("voting expired")]
146+    if ((aq == aq))
147+        then $Tuple5(al, am, ao, ap, an)
148+        else throw("Strict value is not equal to itself.")
149+    }
150+
151+
152+func ar (as,B,C) = {
153+    let at = P(B, C, as)
154+    let au = valueOrErrorMessage(getString(at), c("you have not voted"))
155+    let av = split(au, a)
156+    let S = av[1]
157+    let aw = if ((S == "true"))
158+        then {
159+            let T = parseIntValue(av[2])
160+            let ax = valueOrErrorMessage(getString(U(B, C)), c("voting does not exist"))
161+            let ay = split(ax, a)
162+            let az = parseIntValue(ay[1])
163+            let aA = fraction(T, b, az)
164+            let aB = valueOrElse(getInteger(L(B, C)), 0)
165+            let aw = fraction(aA, aB, b, FLOOR)
166+            aw
167+            }
168+        else 0
169+    aw
170+    }
171+
172+
173+@Callable(aC)
174+func suggestAdd (B,aD,aE) = {
175+    let aF = valueOrErrorMessage(assetInfo(fromBase58String(B)), "Invalid asset ID")
176+    if ((aF == aF))
177+        then {
178+            let aG = O(B)
179+            let ak = getInteger(aG)
180+            let aH = if (isDefined(ak))
181+                then (value(ak) + 1)
182+                else 0
183+            let aI = aC.payments[0]
184+            let aJ = value(aI.assetId)
185+            let aK = value(aI.amount)
186+            let aL = if ((size(aC.payments) > 1))
187+                then {
188+                    let aM = aC.payments[1]
189+                    let aN = toBase58String(value(aM.assetId))
190+                    let aO = value(aM.amount)
191+[StringEntry(K(B, aH), aN), IntegerEntry(L(B, aH), aO)]
192+                    }
193+                else nil
194+            let aP = getIntegerValue(J)
195+            let aQ = getIntegerValue(I)
196+            let aq = [if (if ((aD >= aP))
197+                then (aQ >= aD)
198+                else false)
199+                then true
200+                else e("invalid periodLength"), if ((getBoolean(F(B)) == unit))
201+                then true
202+                else e("already verified"), if ((getBoolean(G(B)) == unit))
203+                then true
204+                else e("already in progress"), if ((aK == value(getInteger(ae))))
205+                then true
206+                else e("invalid payment amount")]
207+            if ((aq == aq))
208+                then {
209+                    let aR = invoke(u, "createOrUpdate", [B, aE, false], nil)
210+                    if ((aR == aR))
211+                        then {
212+                            let aS = (height + aD)
213+                            ([IntegerEntry(aG, aH), BooleanEntry(G(B), true), IntegerEntry(E(B, aH), height), IntegerEntry(A(B, aH), aD), StringEntry(Z(B, aH), toString(aC.caller)), IntegerEntry(ad(B, aH), aS), Burn(aJ, getIntegerValue(ag))] ++ aL)
214+                            }
215+                        else throw("Strict value is not equal to itself.")
216+                    }
217+                else throw("Strict value is not equal to itself.")
218+            }
219+        else throw("Strict value is not equal to itself.")
220+    }
221+
222+
223+
224+@Callable(aC)
225+func suggestRemove (B) = {
226+    let aT = ah(toString(aC.caller), height)
227+    let aU = getIntegerValue(N)
228+    let aV = valueOrElse(getBoolean(F(B)), false)
229+    let aq = [if (aV)
230+        then true
231+        else e(makeString([B, "not verified"], " ")), if ((aT >= aU))
232+        then true
233+        else e("not enough gWXes")]
234+    if ((aq == aq))
235+        then {
236+            let aG = O(B)
237+            let ak = getInteger(aG)
238+            let aH = if (isDefined(ak))
239+                then (value(ak) + 1)
240+                else 0
241+            let aD = valueOrErrorMessage(getInteger(D), c("periodLengthRemove not set"))
242+            let aS = (height + aD)
243+[IntegerEntry(aG, aH), BooleanEntry(H(B), true), IntegerEntry(E(B, aH), height), StringEntry(Z(B, aH), toString(aC.caller)), IntegerEntry(ad(B, aH), aS)]
244+            }
245+        else throw("Strict value is not equal to itself.")
246+    }
247+
248+
249+
250+@Callable(aC)
251+func vote (B,S) = {
252+    let aG = O(B)
253+    let ak = valueOrErrorMessage(getInteger(aG), c("voting does not exist"))
254+    let aW = aj(B, ak)
255+    if ((aW == aW))
256+        then {
257+            let ao = aW._3
258+            let ap = aW._4
259+            let aX = ah(toString(aC.caller), (ao + ap))
260+            let at = P(B, ak, aC.caller)
261+            let aY = U(B, ak)
262+            let aq = [if ((getString(at) == unit))
263+                then true
264+                else e("You have already voted"), if ((aX > 0))
265+                then true
266+                else throw("You'll not have gWX at the end of voting")]
267+            if ((aq == aq))
268+                then {
269+                    let ax = valueOrElse(getString(aY), Y)
270+                    let ay = split(ax, a)
271+                    let aZ = if (S)
272+                        then V((parseIntValue(ay[1]) + aX), parseIntValue(ay[2]))
273+                        else V(parseIntValue(ay[1]), (parseIntValue(ay[2]) + aX))
274+[StringEntry(at, R(S, aX)), StringEntry(aY, aZ)]
275+                    }
276+                else throw("Strict value is not equal to itself.")
277+            }
278+        else throw("Strict value is not equal to itself.")
279+    }
280+
281+
282+
283+@Callable(aC)
284+func cancelVote (B) = {
285+    let aG = O(B)
286+    let ak = valueOrErrorMessage(getInteger(aG), c("voting does not exist"))
287+    let at = P(B, ak, aC.caller)
288+    let aY = U(B, ak)
289+    let au = valueOrErrorMessage(getString(at), c("you have not voted"))
290+    let av = split(au, a)
291+    let S = av[1]
292+    let T = parseIntValue(av[2])
293+    let aW = aj(B, ak)
294+    if ((aW == aW))
295+        then {
296+            let aq = [if (if ((S == "true"))
297+                then true
298+                else (S == "false"))
299+                then true
300+                else e("invalid vote")]
301+            if ((aq == aq))
302+                then {
303+                    let ax = valueOrElse(getString(aY), Y)
304+                    let ay = split(ax, a)
305+                    let ba = if ((S == "true"))
306+                        then V((parseIntValue(ay[1]) - T), parseIntValue(ay[2]))
307+                        else V(parseIntValue(ay[1]), (parseIntValue(ay[2]) - T))
308+[DeleteEntry(at), StringEntry(aY, ba)]
309+                    }
310+                else throw("Strict value is not equal to itself.")
311+            }
312+        else throw("Strict value is not equal to itself.")
313+    }
314+
315+
316+
317+@Callable(aC)
318+func finalize (B) = {
319+    let al = valueOrElse(getBoolean(G(B)), false)
320+    let am = valueOrElse(getBoolean(H(B)), false)
321+    let aG = O(B)
322+    let ak = valueOrElse(getInteger(aG), 0)
323+    let bb = valueOrErrorMessage(getInteger(y), c("votingThresholdAdd not set"))
324+    let bc = valueOrErrorMessage(getInteger(z), c("votingThresholdRemove not set"))
325+    let bd = if (al)
326+        then $Tuple3([DeleteEntry(G(B)), BooleanEntry(F(B), true)], true, bb)
327+        else $Tuple3([DeleteEntry(H(B)), DeleteEntry(F(B))], true, bc)
328+    let be = bd._1
329+    let bf = bd._2
330+    let bg = bd._3
331+    let ax = valueOrElse(getString(U(B, ak)), Y)
332+    let ay = split(ax, a)
333+    let bh = parseIntValue(ay[1])
334+    let bi = parseIntValue(ay[2])
335+    let bj = (bh + bi)
336+    let aS = valueOrErrorMessage(getInteger(ad(B, ak)), c("voting end height not found"))
337+    let aq = [if (if (al)
338+        then true
339+        else am)
340+        then true
341+        else e("nothing to finalize"), if ((height >= aS))
342+        then true
343+        else e("voting not finished"), if ((bj >= bg))
344+        then true
345+        else e("not enough votes")]
346+    if ((aq == aq))
347+        then {
348+            let bk = if ((bi > bh))
349+                then {
350+                    let bl = invoke(u, "setVerified", [B, bf], nil)
351+                    if ((bl == bl))
352+                        then {
353+                            let bm = valueOrElse(getInteger(M), 0)
354+[ScriptTransfer(aC.caller, bm, x)]
355+                            }
356+                        else throw("Strict value is not equal to itself.")
357+                    }
358+                else nil
359+            (be ++ bk)
360+            }
361+        else throw("Strict value is not equal to itself.")
362+    }
363+
364+
365+
366+@Callable(aC)
367+func claimREADONLY (B,C) = {
368+    let bn = aC.caller
369+    let bo = getString(K(B, C))
370+    let aw = if (isDefined(bo))
371+        then ar(bn, B, C)
372+        else 0
373+    $Tuple2(nil, aw)
374+    }
375+
376+
377+
378+@Callable(aC)
379+func claim (B,C) = {
380+    let bn = aC.caller
381+    let bp = aa(bn, B, C)
382+    let bq = getString(bp)
383+    let aq = [if ((bq == unit))
384+        then true
385+        else e("already claimed")]
386+    if ((aq == aq))
387+        then {
388+            let aw = if ((ar(bn, B, C) > 0))
389+                then ar(bn, B, C)
390+                else e("nothing to claim")
391+            let bo = getString(K(B, C))
392+            let br = if (isDefined(bo))
393+                then {
394+                    let bs = fromBase58String(value(bo))
395+[ScriptTransfer(bn, aw, bs), StringEntry(bp, ac(aw))]
396+                    }
397+                else e("nothing to claim")
398+            br
399+            }
400+        else throw("Strict value is not equal to itself.")
401+    }
402+
403+
github/deemru/w8io/169f3d6 
32.31 ms ◑