tx · 2Ffjmi2GLxHceearzriaH7EhJFqXDzxcQdQWjCdgjfir

3N2wEQGk9SJyw6miZiLG66wqECUcdHXCYXH:  -0.03000000 Waves

2025.03.12 15:05 [3540795] smart account 3N2wEQGk9SJyw6miZiLG66wqECUcdHXCYXH > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "2Ffjmi2GLxHceearzriaH7EhJFqXDzxcQdQWjCdgjfir",
    "fee": 3000000,
    "feeAssetId": null,
    "timestamp": 1741781177198,
    "version": 2,
    "chainId": 84,
    "sender": "3N2wEQGk9SJyw6miZiLG66wqECUcdHXCYXH",
    "senderPublicKey": "49pJcBuD9hnPFw7NTHkGEb6m25uVZTteuJtPFNBMgs7G",
    "proofs": [
        "4hneHVxj8GNsyoWPtwwxAX4RF173ATby6YVPrH2qm96ry5jUfrwuZBBMF3P98HnQD7DXZQs8K6cFGQ1XMxxZRFCq"
    ],
    "script": "base64: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",
    "height": 3540795,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 7 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = 10000
5+
6+let b = 10000000000
7+
8+let c = 1000
9+
10+let d = 3
11+
12+let e = 1
13+
14+let f = (c * e)
15+
16+let g = 530
17+
18+let h = (c * g)
19+
20+let i = 10
21+
22+let j = 10
23+
24+let k = (j * c)
25+
26+let l = "validatorStatus:"
27+
28+let m = "activeValidators"
29+
30+let n = "adminFeeBP"
31+
32+let o = "leasingPoolValue:"
33+
34+let p = "cycleDurationInBlocks"
35+
36+let q = "emergencyUserVotes:"
37+
38+let r = "emergencyVotes:"
39+
40+let s = "emergencyVotingThreshold"
41+
42+let t = "emergencyUserLock:"
43+
44+let u = "isLeasingInProgress:"
45+
46+let v = "latestLeasingCycle"
47+
48+let w = "latestLeasingCycle:"
49+
50+let x = "registrationCycle:"
51+
52+let y = "leaseId:"
53+
54+let z = "processedLeases:"
55+
56+let A = "requestedXWavesWithdraw:"
57+
58+let B = "requestedWavesWithdraw:"
59+
60+let C = "requiredWXXAmount"
61+
62+let D = "startBlock"
63+
64+let E = "contractStatus"
65+
66+let F = "stopManager"
67+
68+let G = "totalRequestedWavesWithdraw"
69+
70+let H = "totalVotes"
71+
72+let I = "unlockBlock:"
73+
74+let J = "userLock:"
75+
76+let K = "userVote:"
77+
78+let L = "validatorMeta:"
79+
80+let M = "validatorAddress:"
81+
82+let N = "validatorId:"
83+
84+let O = "validatorLeases:"
85+
86+let P = "votes:"
87+
88+let Q = "withdrawXWavexQuantityState"
89+
90+let R = "withdrawWavesBalanceState"
91+
92+let S = "wxxAssetId"
93+
94+let T = "xWavesAssetId"
95+
96+let U = "xWavesWrapper"
97+
98+let V = "adminFeeCollector"
99+
100+let W = "ignoreVotes:"
101+
102+let X = "ignoredValidators:"
103+
104+let Y = "admin"
105+
106+let Z = "xWavexQuantity"
107+
108+let aa = "puzzleSwap"
109+
110+let ab = "Unreachable"
111+
112+let ac = "Already initialized"
113+
114+let ad = "Already leased"
115+
116+let ae = "Already registered"
117+
118+let af = "Contract is not active"
119+
120+let ag = "Invalid interval"
121+
122+let ah = "Invalid WXX amount"
123+
124+let ai = "Leasing in progress"
125+
126+let aj = "No emergency votes for user"
127+
128+let ak = "No requested withdraw"
129+
130+let al = "Not one payment"
131+
132+let am = "Too early"
133+
134+let an = "Unauthorized"
135+
136+let ao = "Unexpected asset id"
137+
138+let ap = "Unknown lock"
139+
140+let aq = "Unknown validator"
141+
142+let ar = "Validator is not ready to lease"
143+
144+let as = "Not enough WAVES. Please try later"
145+
146+let at = "Validator was kicked"
147+
148+let au = "Invalid adminFeeBP"
149+
150+let av = "Invalid Uint"
151+
152+let aw = wavesBalance(this).available
153+
154+let ax = getBinaryValue(S)
155+
156+let ay = getBinaryValue(T)
157+
158+let az = Address(getBinaryValue(U))
159+
160+let aA = valueOrErrorMessage(assetInfo(ax), ab)
161+
162+let aB = getIntegerValue(Z)
163+
164+let aC = ((lastBlock.height - getIntegerValue(D)) / c)
165+
166+let aD = valueOrElse(getInteger(R), wavesBalance(this).regular)
167+
168+let aE = valueOrElse(getInteger(Q), aB)
169+
170+let aF = (W + toString(aC))
171+
172+let aG = (X + toString(aC))
173+
174+let aH = valueOrElse(getInteger(aF), 0)
175+
176+let aI = valueOrElse(getInteger(aG), 0)
177+
178+let aJ = getIntegerValue(H)
179+
180+let aK = (aJ - aH)
181+
182+let aL = valueOrElse(getInteger(G), 0)
183+
184+let aM = getBooleanValue(E)
185+
186+let aN = getBinaryValue(F)
187+
188+let aO = getBinaryValue(Y)
189+
190+let aP = valueOrElse(getInteger(n), 50)
191+
192+let aQ = valueOrElse(getInteger(m), 0)
193+
194+let aR = (aQ - aI)
195+
196+let aS = Address(getBinaryValue(aa))
197+
198+func aT (aU,aV) = if (aU)
199+    then unit
200+    else throw(aV)
201+
202+
203+func aW (aX,aU) = {
204+    let aY = aT((aU >= 0), av)
205+    if ((aY == aY))
206+        then IntegerEntry(aX, aU)
207+        else throw("Strict value is not equal to itself.")
208+    }
209+
210+
211+func aZ (ba) = getBoolean((l + toString(ba)))
212+
213+
214+func bb (ba) = valueOrErrorMessage(aZ(ba), aq)
215+
216+
217+func bc (ba) = {
218+    let bd = (y + toBase58String(ba.bytes))
219+    let be = getBinary(bd)
220+    if ($isInstanceOf(be, "ByteVector"))
221+        then {
222+            let bf = be
223+[LeaseCancel(bf)]
224+            }
225+        else if ($isInstanceOf(be, "Unit"))
226+            then nil
227+            else throw("Match error")
228+    }
229+
230+
231+func bg (ba) = valueOrErrorMessage(getInteger((x + toString(ba))), aq)
232+
233+
234+func bh (ba) = {
235+    let bi = (N + toString(ba))
236+    let bj = getIntegerValue(bi)
237+    let bk = (M + toString(bj))
238+    if (if ((bj == aQ))
239+        then true
240+        else (aQ == 1))
241+        then [DeleteEntry(bi), DeleteEntry(bk)]
242+        else {
243+            let bl = (M + toString(aQ))
244+            let bm = getBinaryValue(bl)
245+            let bn = (N + toBase58String(bm))
246+[IntegerEntry(bn, bj), BinaryEntry(bk, bm), DeleteEntry(bi), DeleteEntry(bl)]
247+            }
248+    }
249+
250+
251+func bo (ba) = aT(isDefined(getString((L + toString(ba)))), aq)
252+
253+
254+func bp (bq) = aT((size(bq.payments) == 1), al)
255+
256+
257+func br () = {
258+    let bs = valueOrElse(getBoolean((u + toString(aC))), false)
259+    aT(!(bs), ai)
260+    }
261+
262+
263+func bt (bq,bu) = aT((bq.payments[0].assetId == bu), ao)
264+
265+
266+func bv (bq,bu) = {
267+    let bw = bp(bq)
268+    if ((bw == bw))
269+        then {
270+            let bx = bt(bq, bu)
271+            if ((bx == bx))
272+                then unit
273+                else throw("Strict value is not equal to itself.")
274+            }
275+        else throw("Strict value is not equal to itself.")
276+    }
277+
278+
279+func by (ba) = aT(bb(ba), at)
280+
281+
282+func bz (ba) = aT((aC > bg(ba)), ar)
283+
284+
285+func bA () = aT(aM, af)
286+
287+
288+func bB (bq,bC) = aT((bC == bq.caller.bytes), an)
289+
290+
291+func bD (bq) = bB(bq, this.bytes)
292+
293+
294+func bE (bq) = bB(bq, aN)
295+
296+
297+func bF (bq) = bB(bq, aO)
298+
299+
300+func bG (bH,bI) = aT(if ((lastBlock.height >= bH))
301+    then true
302+    else !(valueOrElse(aZ(bI), false)), am)
303+
304+
305+@Callable(bq)
306+func init (bJ,aO,aN,bK,aS,az) = {
307+    let bL = bD(bq)
308+    if ((bL == bL))
309+        then {
310+            let bM = aT(!(isDefined(getInteger(D))), ac)
311+            if ((bM == bM))
312+                then {
313+                    let bN = addressFromStringValue(aN)
314+                    let bO = addressFromStringValue(aO)
315+                    let bP = addressFromStringValue(bK)
316+                    let bQ = addressFromStringValue(aS)
317+                    let bR = addressFromStringValue(az)
318+                    let bS = getBinaryValue(bR, "xWavesAssetId")
319+[aW(H, 0), aW(Z, 0), BooleanEntry(E, true), BinaryEntry(S, bJ), BinaryEntry(T, bS), aW(n, aP), aW(G, 0), aW(D, lastBlock.height), aW(C, b), BinaryEntry(F, bN.bytes), aW(p, c), BinaryEntry(V, bP.bytes), BinaryEntry(Y, bO.bytes), aW(s, i), BinaryEntry(aa, bQ.bytes), BinaryEntry(U, bR.bytes)]
320+                    }
321+                else throw("Strict value is not equal to itself.")
322+            }
323+        else throw("Strict value is not equal to itself.")
324+    }
325+
326+
327+
328+@Callable(bq)
329+func stop () = {
330+    let bL = bE(bq)
331+    if ((bL == bL))
332+        then [BooleanEntry(E, false)]
333+        else throw("Strict value is not equal to itself.")
334+    }
335+
336+
337+
338+@Callable(bq)
339+func setStopManager (bT) = {
340+    let bL = bF(bq)
341+    if ((bL == bL))
342+        then {
343+            let bU = addressFromStringValue(bT)
344+[BinaryEntry(F, bU.bytes)]
345+            }
346+        else throw("Strict value is not equal to itself.")
347+    }
348+
349+
350+
351+@Callable(bq)
352+func setFeeCollector (bV) = {
353+    let bL = bF(bq)
354+    if ((bL == bL))
355+        then {
356+            let bW = addressFromStringValue(bV)
357+[BinaryEntry(V, bW.bytes)]
358+            }
359+        else throw("Strict value is not equal to itself.")
360+    }
361+
362+
363+
364+@Callable(bq)
365+func setAdmin (bX) = {
366+    let bL = bF(bq)
367+    if ((bL == bL))
368+        then {
369+            let bY = addressFromStringValue(bX)
370+[BinaryEntry(Y, bY.bytes)]
371+            }
372+        else throw("Strict value is not equal to itself.")
373+    }
374+
375+
376+
377+@Callable(bq)
378+func setAdminFeeBP (bZ) = {
379+    let bL = bF(bq)
380+    if ((bL == bL))
381+        then {
382+            let ca = aT(if ((bZ >= 0))
383+                then (a >= bZ)
384+                else false, au)
385+            if ((ca == ca))
386+                then [aW(n, bZ)]
387+                else throw("Strict value is not equal to itself.")
388+            }
389+        else throw("Strict value is not equal to itself.")
390+    }
391+
392+
393+
394+@Callable(bq)
395+func swapRewardTokens (cb,cc,cd) = {
396+    let bL = bF(bq)
397+    if ((bL == bL))
398+        then {
399+            let ce = split(takeRight(cb, 50), ",")
400+            let cf = ce[(size(ce) - 1)]
401+            let cg = fromBase58String(cf)
402+            let ch = invoke(aS, "swap", [cb, cd], [AttachedPayment(cg, cc)])
403+            if ((ch == ch))
404+                then nil
405+                else throw("Strict value is not equal to itself.")
406+            }
407+        else throw("Strict value is not equal to itself.")
408+    }
409+
410+
411+
412+@Callable(bq)
413+func register (ci) = {
414+    let cj = bA()
415+    if ((cj == cj))
416+        then {
417+            let ck = br()
418+            if ((ck == ck))
419+                then {
420+                    let cl = bv(bq, ax)
421+                    if ((cl == cl))
422+                        then {
423+                            let bI = toString(bq.caller)
424+                            let cm = bq.payments[0].amount
425+                            let cn = (L + bI)
426+                            let co = (x + bI)
427+                            let bf = (aQ + 1)
428+                            let cp = (N + bI)
429+                            let cq = (M + toString(bf))
430+                            let cr = aT(!(isDefined(getString(cn))), ae)
431+                            if ((cr == cr))
432+                                then {
433+                                    let cs = aT((b == cm), ah)
434+                                    if ((cs == cs))
435+                                        then [aW(co, aC), StringEntry(cn, ci), BooleanEntry((l + bI), true), aW(aG, (aI + 1)), aW(m, (aQ + 1)), IntegerEntry(cp, bf), BinaryEntry(cq, bq.caller.bytes)]
436+                                        else throw("Strict value is not equal to itself.")
437+                                    }
438+                                else throw("Strict value is not equal to itself.")
439+                            }
440+                        else throw("Strict value is not equal to itself.")
441+                    }
442+                else throw("Strict value is not equal to itself.")
443+            }
444+        else throw("Strict value is not equal to itself.")
445+    }
446+
447+
448+
449+@Callable(bq)
450+func deregister () = {
451+    let ck = br()
452+    if ((ck == ck))
453+        then {
454+            let ba = bq.caller
455+            let bI = toString(bq.caller)
456+            let ct = (l + bI)
457+            let cu = (P + bI)
458+            let co = (x + bI)
459+            let cv = bo(ba)
460+            if ((cv == cv))
461+                then {
462+                    let cw = bh(ba)
463+                    let bd = (y + bI)
464+                    let cx = bc(ba)
465+                    let cy = if (bb(ba))
466+                        then {
467+                            let cz = valueOrElse(getInteger(cu), 0)
468+                            (cw ++ [aW(m, (aQ - 1)), aW(H, (aJ - cz)), ScriptTransfer(ba, b, ax)])
469+                            }
470+                        else nil
471+                    let cA = if ((bg(ba) == aC))
472+                        then [aW(aG, (aI - 1))]
473+                        else nil
474+                    (((cy ++ cA) ++ cx) ++ [DeleteEntry(cu), DeleteEntry(co), DeleteEntry(ct), DeleteEntry((L + bI)), DeleteEntry((O + bI)), DeleteEntry(bd), DeleteEntry((w + bI))])
475+                    }
476+                else throw("Strict value is not equal to itself.")
477+            }
478+        else throw("Strict value is not equal to itself.")
479+    }
480+
481+
482+
483+@Callable(bq)
484+func deposit () = {
485+    let cj = bA()
486+    if ((cj == cj))
487+        then {
488+            let ck = br()
489+            if ((ck == ck))
490+                then {
491+                    let cl = bv(bq, unit)
492+                    if ((cl == cl))
493+                        then {
494+                            let cB = bq.payments[0].amount
495+                            let cC = if ((aB == 0))
496+                                then cB
497+                                else fraction(cB, aB, (wavesBalance(this).regular - cB))
498+                            let cD = fraction(cC, aP, a, CEILING)
499+                            let cE = (cC - cD)
500+                            let cF = Address(getBinaryValue(V))
501+                            let cG = invoke(az, "mint", [cC], nil)
502+                            if ((cG == cG))
503+                                then [aW(Z, (aB + cC)), ScriptTransfer(bq.caller, cE, ay), ScriptTransfer(cF, cD, ay)]
504+                                else throw("Strict value is not equal to itself.")
505+                            }
506+                        else throw("Strict value is not equal to itself.")
507+                    }
508+                else throw("Strict value is not equal to itself.")
509+            }
510+        else throw("Strict value is not equal to itself.")
511+    }
512+
513+
514+
515+@Callable(bq)
516+func requestWithdraw () = {
517+    let ck = br()
518+    if ((ck == ck))
519+        then {
520+            let cl = bv(bq, ay)
521+            if ((cl == cl))
522+                then {
523+                    let cC = bq.payments[0].amount
524+                    let cB = fraction(cC, aD, aE)
525+                    let cH = toString(bq.caller)
526+                    let cI = (A + cH)
527+                    let cJ = (B + cH)
528+                    let cK = valueOrElse(getInteger(cI), 0)
529+                    let cL = valueOrElse(getInteger(cJ), 0)
530+[aW(cI, (cK + cC)), aW(cJ, (cL + cB)), aW(G, (aL + cB))]
531+                    }
532+                else throw("Strict value is not equal to itself.")
533+            }
534+        else throw("Strict value is not equal to itself.")
535+    }
536+
537+
538+
539+@Callable(bq)
540+func processWithdraw (cM) = {
541+    let ck = br()
542+    if ((ck == ck))
543+        then {
544+            let cN = addressFromStringValue(cM)
545+            let cI = (A + cM)
546+            let cJ = (B + cM)
547+            let cO = valueOrErrorMessage(getInteger(cJ), ak)
548+            let cP = valueOrErrorMessage(getInteger(cI), ak)
549+            let cQ = aT((aw >= cO), as)
550+            if ((cQ == cQ))
551+                then {
552+                    let cR = invoke(az, "burn", nil, [AttachedPayment(ay, cP)])
553+                    if ((cR == cR))
554+                        then [aW(G, (aL - cO)), DeleteEntry(cI), DeleteEntry(cJ), aW(Z, (aB - cP)), ScriptTransfer(cN, cO, unit)]
555+                        else throw("Strict value is not equal to itself.")
556+                    }
557+                else throw("Strict value is not equal to itself.")
558+            }
559+        else throw("Strict value is not equal to itself.")
560+    }
561+
562+
563+
564+@Callable(bq)
565+func revokeWithdraw () = {
566+    let ck = br()
567+    if ((ck == ck))
568+        then {
569+            let cM = toString(bq.caller)
570+            let cI = (A + cM)
571+            let cJ = (B + cM)
572+            let cO = valueOrErrorMessage(getInteger(cJ), ak)
573+            let cP = valueOrErrorMessage(getInteger(cI), ak)
574+[aW(G, (aL - cO)), ScriptTransfer(bq.caller, cP, ay), DeleteEntry(cI), DeleteEntry(cJ)]
575+            }
576+        else throw("Strict value is not equal to itself.")
577+    }
578+
579+
580+
581+@Callable(bq)
582+func vote (bI,cS) = {
583+    let cj = bA()
584+    if ((cj == cj))
585+        then {
586+            let ck = br()
587+            if ((ck == ck))
588+                then {
589+                    let ba = addressFromStringValue(bI)
590+                    let cT = by(ba)
591+                    if ((cT == cT))
592+                        then {
593+                            let cl = bv(bq, ax)
594+                            if ((cl == cl))
595+                                then {
596+                                    let cU = aT(if ((cS >= f))
597+                                        then (h >= cS)
598+                                        else false, ag)
599+                                    if ((cU == cU))
600+                                        then {
601+                                            let bH = (lastBlock.height + cS)
602+                                            let cV = bq.payments[0].amount
603+                                            let cW = fraction(cV, sqrt(cS, 0, 0, FLOOR), d)
604+                                            let cX = ((toString(bq.caller) + "|") + toString(bH))
605+                                            let cY = (I + cX)
606+                                            let cZ = (P + bI)
607+                                            let da = (K + cX)
608+                                            let db = (J + cX)
609+                                            let dc = (valueOrElse(getInteger(da), 0) + cV)
610+                                            let dd = (valueOrElse(getInteger(db), 0) + cW)
611+                                            let de = valueOrElse(getInteger(cZ), 0)
612+                                            let df = if ((bg(ba) == aC))
613+                                                then [aW(aF, (aH + cW))]
614+                                                else nil
615+                                            (df ++ [aW(da, dd), aW(db, dc), BinaryEntry(cY, ba.bytes), aW(cZ, (de + cW)), aW(H, (aJ + cW))])
616+                                            }
617+                                        else throw("Strict value is not equal to itself.")
618+                                    }
619+                                else throw("Strict value is not equal to itself.")
620+                            }
621+                        else throw("Strict value is not equal to itself.")
622+                    }
623+                else throw("Strict value is not equal to itself.")
624+            }
625+        else throw("Strict value is not equal to itself.")
626+    }
627+
628+
629+
630+@Callable(bq)
631+func redeem (bH) = {
632+    let ck = br()
633+    if ((ck == ck))
634+        then {
635+            let cX = ((toString(bq.caller) + "|") + toString(bH))
636+            let cY = (I + cX)
637+            let da = (K + cX)
638+            let db = (J + cX)
639+            let ba = Address(valueOrErrorMessage(getBinary(cY), ap))
640+            let cu = (P + toBase58String(ba.bytes))
641+            let dg = bG(bH, ba)
642+            if ((dg == dg))
643+                then {
644+                    let dd = getIntegerValue(da)
645+                    let dc = getIntegerValue(db)
646+                    let dh = valueOrElse(aZ(ba), false)
647+                    let di = if (dh)
648+                        then [aW(cu, (getIntegerValue(cu) - dd)), aW(H, (aJ - dd))]
649+                        else nil
650+                    (di ++ [ScriptTransfer(bq.caller, dc, ax), DeleteEntry(da), DeleteEntry(cY), DeleteEntry(db)])
651+                    }
652+                else throw("Strict value is not equal to itself.")
653+            }
654+        else throw("Strict value is not equal to itself.")
655+    }
656+
657+
658+
659+@Callable(bq)
660+func leasing (bI) = {
661+    let ba = addressFromStringValue(bI)
662+    let dj = by(ba)
663+    if ((dj == dj))
664+        then {
665+            let dk = bz(ba)
666+            if ((dk == dk))
667+                then {
668+                    let bd = (y + bI)
669+                    let dl = (w + bI)
670+                    let dm = (O + bI)
671+                    let dn = toString(aC)
672+                    let do = (z + dn)
673+                    let dp = (o + dn)
674+                    let dq = (u + dn)
675+                    let cz = valueOrElse(getInteger((P + bI)), 0)
676+                    let dr = valueOrElse(getInteger(dm), 0)
677+                    let ds = bc(ba)
678+                    let dt = aT((valueOrElse(getInteger(dl), -1) != aC), ad)
679+                    if ((dt == dt))
680+                        then {
681+                            let du = (valueOrElse(getInteger(do), 0) + 1)
682+                            let dv = valueOrElse(getInteger(dp), wavesBalance(this).regular)
683+                            let dw = if ((aR > du))
684+                                then [BooleanEntry(dq, true), aW(do, du), aW(dp, dv)]
685+                                else [aW(R, dv), aW(Q, aB), IntegerEntry(v, aC), DeleteEntry(dq), DeleteEntry(do), DeleteEntry(dp), DeleteEntry(aG), DeleteEntry(aF)]
686+                            let dx = if (isDefined(getInteger(dm)))
687+                                then [DeleteEntry(dm), DeleteEntry(bd)]
688+                                else nil
689+                            let dy = fraction((dv - aL), cz, aK)
690+                            if (if (!(aM))
691+                                then true
692+                                else (aK == 0))
693+                                then ((ds ++ dx) ++ dw)
694+                                else if ((dy != dr))
695+                                    then {
696+                                        let dz = Lease(ba, dy)
697+                                        let dA = if ((dy == 0))
698+                                            then dx
699+                                            else [dz, BinaryEntry(bd, calculateLeaseId(dz)), aW(dm, dy)]
700+                                        (((ds ++ dA) ++ dw) :+ aW(dl, aC))
701+                                        }
702+                                    else (dw :+ aW(dl, aC))
703+                            }
704+                        else throw("Strict value is not equal to itself.")
705+                    }
706+                else throw("Strict value is not equal to itself.")
707+            }
708+        else throw("Strict value is not equal to itself.")
709+    }
710+
711+
712+
713+@Callable(bq)
714+func emergencyVoting (bI) = {
715+    let ck = br()
716+    if ((ck == ck))
717+        then {
718+            let cj = bA()
719+            if ((cj == cj))
720+                then {
721+                    let ba = addressFromStringValue(bI)
722+                    let cT = by(ba)
723+                    if ((cT == cT))
724+                        then {
725+                            let cl = bv(bq, ay)
726+                            if ((cl == cl))
727+                                then {
728+                                    let dB = bq.payments[0].amount
729+                                    let cH = toString(bq.caller)
730+                                    let bH = (lastBlock.height + k)
731+                                    let dC = (r + bI)
732+                                    let dD = (((q + cH) + "|") + bI)
733+                                    let cu = (P + bI)
734+                                    let bd = (y + bI)
735+                                    let dE = (((t + cH) + "|") + toString(bH))
736+                                    let dF = (dB + valueOrElse(getInteger(dC), 0))
737+                                    let dG = (((dF * 100) / aB) > i)
738+                                    let dH = if (dG)
739+                                        then {
740+                                            let cx = bc(ba)
741+                                            let de = valueOrElse(getInteger(cu), 0)
742+                                            let dI = bb(ba)
743+                                            let dJ = if (dI)
744+                                                then [aW(m, (aQ - 1))]
745+                                                else nil
746+                                            let cw = bh(ba)
747+                                            (((cw ++ dJ) ++ cx) ++ [ScriptTransfer(aA.issuer, b, ax), aW(H, (aJ - de)), BooleanEntry((l + bI), false), DeleteEntry((O + bI)), DeleteEntry(bd), DeleteEntry((w + bI))])
748+                                            }
749+                                        else nil
750+                                    (dH ++ [BinaryEntry(dE, ba.bytes), aW(dC, dF), aW(dD, (valueOrElse(getInteger(dD), 0) + dB))])
751+                                    }
752+                                else throw("Strict value is not equal to itself.")
753+                            }
754+                        else throw("Strict value is not equal to itself.")
755+                    }
756+                else throw("Strict value is not equal to itself.")
757+            }
758+        else throw("Strict value is not equal to itself.")
759+    }
760+
761+
762+
763+@Callable(bq)
764+func redeemEmergencyVote (bH) = {
765+    let cH = toString(bq.caller)
766+    let dE = (((t + cH) + "|") + toString(bH))
767+    let ba = Address(valueOrErrorMessage(getBinary(dE), ap))
768+    let bI = toString(ba)
769+    let dg = bG(bH, ba)
770+    if ((dg == dg))
771+        then {
772+            let dC = (r + bI)
773+            let dD = (((q + cH) + "|") + bI)
774+            let dK = valueOrErrorMessage(getInteger(dD), aj)
775+            let dF = (getIntegerValue(dC) - dK)
776+[ScriptTransfer(bq.caller, dK, ay), aW(dC, dF), DeleteEntry(dD), DeleteEntry(dE)]
777+            }
778+        else throw("Strict value is not equal to itself.")
779+    }
780+
781+
782+@Verifier(dL)
783+func dM () = {
784+    let be = dL
785+    if ($isInstanceOf(be, "SetScriptTransaction"))
786+        then {
787+            let dN = be
788+            !(isDefined(getInteger(D)))
789+            }
790+        else sigVerify(dL.bodyBytes, dL.proofs[0], dL.senderPublicKey)
791+    }
792+
github/deemru/w8io/169f3d6 
40.73 ms ◑