tx · 6zMrSnh1QwfVD8rRMvm6MpzapTu8SPYuDjovuK4BKxq8

3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP:  -0.03000000 Waves

2023.08.18 10:24 [2715739] smart account 3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6zMrSnh1QwfVD8rRMvm6MpzapTu8SPYuDjovuK4BKxq8",
    "fee": 3000000,
    "feeAssetId": null,
    "timestamp": 1692343513613,
    "version": 1,
    "sender": "3N6HSS7Toat1RhyEsyqVGgVSRzH19W1FTbP",
    "senderPublicKey": "AoKo4segKHU4DeJnxXQYJj2u7J6XJeux6r8KLW52cd2Q",
    "proofs": [
        "3jraVKHLpZSJv6dJ9Aux2s9Mjk5bJQyXoKHPfY5AwSd5HEJ9bQkk75Kvtoqeh3FEfoVfraEYtsQ3LtBBB2pNPGTp"
    ],
    "script": "base64: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",
    "chainId": 84,
    "height": 2715739,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: C6nJEhHC3gt1HYmX8YKGzcowMBD5bxC3E9FJhmPW4W6T
Next: 2ERVgNQCKUuV6ebrqq37auJs3tAFugjYQbWrY6qoxNmo

Full: 

OldNewDifferences
1-{-# STDLIB_VERSION 6 #-}
1+{-# STDLIB_VERSION 7 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
4-func b () = {
5-    let c = [$Tuple2("a", 0), $Tuple2("b", 1), $Tuple2("c", 2)]
6-    func d (e,f) =     {
7-        let g = f
8-        let h = g._1
9-        let i = g._2
10-        let j = invoke(this, "foo", [h, i], nil)
11-        if ((j == j))
12-            then 0
13-            else throw("Strict value is not equal to itself.")
14-        }
4+let a = "__"
155 
16-    let k = c
17-    let l = size(k)
18-    let m = 0
19-    func n (o,p) =     if ((p >= l))
20-        then o
21-        else d(o, k[p])
6+let b = "calculator.ride"
227 
23-    func q (o,p) =     if ((p >= l))
24-        then o
25-        else throw("List size exceeds 10")
8+let c = 100000000
269 
27-    q(n(n(n(n(n(n(n(n(n(n(m, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
10+let d = "PENDING"
11+
12+let e = "WAVES"
13+
14+func f (g) = ((b + ": ") + g)
15+
16+
17+func h (g) = throw(f(g))
18+
19+
20+func i (j) = {
21+    let k = j
22+    if ($isInstanceOf(k, "ByteVector"))
23+        then {
24+            let l = k
25+            toBase58String(l)
26+            }
27+        else if ($isInstanceOf(k, "Unit"))
28+            then e
29+            else throw("Match error")
2830     }
2931 
3032 
31-@Callable(r)
32-func foo (h,i) = [IntegerEntry(h, i)]
33+func m (g) = if ((g == e))
34+    then unit
35+    else fromBase58String(g)
36+
37+
38+func n (o) = if ((0 > o))
39+    then -(o)
40+    else o
41+
42+
43+func p () = makeString(["%s", "factory"], a)
44+
45+
46+func q () = makeString(["%s", "managerPublicKey"], a)
47+
48+
49+func r () = makeString(["%s", "lpAssetId"], a)
50+
51+
52+func s () = makeString(["%s", "proxyTreasury"], a)
53+
54+
55+func t () = makeString(["%s", "mainTreasury"], a)
56+
57+
58+func u () = makeString(["%s", "businessTreasury"], a)
59+
60+
61+func v () = makeString(["%s", "businessTreasuryPart"], a)
62+
63+
64+func w () = makeString(["%s", "powerContract"], a)
65+
66+
67+func x () = makeString(["%s", "powerShareRatio"], a)
68+
69+
70+func y () = makeString(["%s", "powerAssetId"], a)
71+
72+
73+func z (j) = makeString(["%s%s", "invested", i(j)], a)
74+
75+
76+func A (j) = makeString(["%s%s", "donated", i(j)], a)
77+
78+
79+func B (C) = makeString(["%s%s", "available", toString(C)], a)
80+
81+
82+func D (C) = makeString(["%s%s", "claimed", toString(C)], a)
83+
84+
85+func E () = makeString(["%s", "currentPeriod"], a)
86+
87+
88+func F (G) = makeString(["%s%d", "price", toString(G)], a)
89+
90+
91+func H (G) = makeString(["%s%d", "startHeight", toString(G)], a)
92+
93+
94+func I (G) = makeString(["%s%d", "powerManagerBonus", toString(G)], a)
95+
96+
97+func J (G) = makeString(["%s%d", "claimWavesAmount", toString(G)], a)
98+
99+
100+func K () = "%s__periodLength"
101+
102+
103+func L () = "%s__investPeriodLength"
104+
105+
106+func M () = "%s__blockProcessingReward"
107+
108+
109+func N () = "%s__nextBlockToProcess"
110+
111+
112+func O (P) = makeString(["%s%d", "blockProcessed", toString(P)], a)
113+
114+
115+func Q () = "%s__withdrawal"
116+
117+
118+func R (C,S) = makeString(["%s%s%s", "withdrawal", toString(C), toBase58String(S)], a)
119+
120+
121+func T (U,V,W,X) = {
122+    let Y = {
123+        let k = X
124+        if ($isInstanceOf(k, "ByteVector"))
125+            then {
126+                let l = k
127+                toBase58String(l)
128+                }
129+            else if ($isInstanceOf(k, "Unit"))
130+                then "SOON"
131+                else throw("Match error")
132+        }
133+    makeString(["%s%d%d%s", U, toString(V), toString(W), Y], a)
134+    }
135+
136+
137+func Z (C,S) = makeString(["%s%s%s", "withdrawalHistory", toString(C), toBase58String(S)], a)
138+
139+
140+func aa (G) = makeString(["%s%d", "periodReward", toString(G)], a)
141+
142+
143+func ab (G) = makeString(["%s%d", "periodRewardAmount", toString(G)], a)
144+
145+
146+func ac (g) = {
147+    let ad = split(g, a)
148+    if ((size(ad) == 5))
149+        then {
150+            let U = ad[1]
151+            let V = valueOrErrorMessage(parseInt(ad[2]), f("invalid lpAssetAmount"))
152+            let W = valueOrErrorMessage(parseInt(ad[3]), f("invalid targetPeriod"))
153+            let X = ad[4]
154+            $Tuple4(U, V, W, X)
155+            }
156+        else h("invalid withdrawal request value")
157+    }
158+
159+
160+let ae = {
161+    let k = getString(this, p())
162+    if ($isInstanceOf(k, "String"))
163+        then {
164+            let g = k
165+            addressFromString(g)
166+            }
167+        else if ($isInstanceOf(k, "Unit"))
168+            then unit
169+            else throw("Match error")
170+    }
171+
172+let af = valueOrErrorMessage(ae, f("invalid factory address"))
173+
174+let ag = {
175+    let k = ae
176+    if ($isInstanceOf(k, "Address"))
177+        then {
178+            let ah = k
179+            let ai = getString(ah, r())
180+            if ($isInstanceOf(ai, "String"))
181+                then {
182+                    let g = ai
183+                    fromBase58String(g)
184+                    }
185+                else if ($isInstanceOf(ai, "Unit"))
186+                    then unit
187+                    else throw("Match error")
188+            }
189+        else if ($isInstanceOf(k, "Unit"))
190+            then unit
191+            else throw("Match error")
192+    }
193+
194+let aj = valueOrErrorMessage(ag, f("invalid lpAssetId"))
195+
196+let ak = {
197+    let k = ae
198+    if ($isInstanceOf(k, "Address"))
199+        then {
200+            let ah = k
201+            let ai = getString(ah, s())
202+            if ($isInstanceOf(ai, "String"))
203+                then {
204+                    let g = ai
205+                    addressFromString(g)
206+                    }
207+                else if ($isInstanceOf(ai, "Unit"))
208+                    then unit
209+                    else throw("Match error")
210+            }
211+        else if ($isInstanceOf(k, "Unit"))
212+            then unit
213+            else throw("Match error")
214+    }
215+
216+let al = valueOrErrorMessage(ak, f("invalid proxy treasury address"))
217+
218+let am = {
219+    let k = ae
220+    if ($isInstanceOf(k, "Address"))
221+        then {
222+            let ah = k
223+            let ai = getString(ah, t())
224+            if ($isInstanceOf(ai, "String"))
225+                then {
226+                    let g = ai
227+                    addressFromString(g)
228+                    }
229+                else if ($isInstanceOf(ai, "Unit"))
230+                    then unit
231+                    else throw("Match error")
232+            }
233+        else if ($isInstanceOf(k, "Unit"))
234+            then unit
235+            else throw("Match error")
236+    }
237+
238+let an = {
239+    let k = ae
240+    if ($isInstanceOf(k, "Address"))
241+        then {
242+            let ah = k
243+            let ai = getString(ah, u())
244+            if ($isInstanceOf(ai, "String"))
245+                then {
246+                    let g = ai
247+                    addressFromString(g)
248+                    }
249+                else if ($isInstanceOf(ai, "Unit"))
250+                    then unit
251+                    else throw("Match error")
252+            }
253+        else if ($isInstanceOf(k, "Unit"))
254+            then unit
255+            else throw("Match error")
256+    }
257+
258+let ao = valueOrErrorMessage(am, f("invalid main treasury address"))
259+
260+let ap = valueOrErrorMessage(an, f("invalid business treasury address"))
261+
262+let aq = {
263+    let k = ae
264+    if ($isInstanceOf(k, "Address"))
265+        then {
266+            let ah = k
267+            let ai = getString(ah, w())
268+            if ($isInstanceOf(ai, "String"))
269+                then {
270+                    let g = ai
271+                    addressFromString(g)
272+                    }
273+                else if ($isInstanceOf(ai, "Unit"))
274+                    then unit
275+                    else throw("Match error")
276+            }
277+        else if ($isInstanceOf(k, "Unit"))
278+            then unit
279+            else throw("Match error")
280+    }
281+
282+let ar = valueOrErrorMessage(aq, f("invalid power contract address"))
283+
284+let as = valueOrErrorMessage(getString(af, y()), f("power asset id not found"))
285+
286+func at () = {
287+    let k = ae
288+    if ($isInstanceOf(k, "Address"))
289+        then {
290+            let au = k
291+            let ai = getString(au, q())
292+            if ($isInstanceOf(ai, "String"))
293+                then {
294+                    let av = ai
295+                    fromBase58String(av)
296+                    }
297+                else unit
298+            }
299+        else unit
300+    }
301+
302+
303+func aw (ax,ay) = if ((ax.caller == ay))
304+    then true
305+    else h("permission denied")
306+
307+
308+func az (ax) = aw(ax, af)
309+
310+
311+func aA (aB,aC) = {
312+    let g = size(aB)
313+    let aD = aB[0]
314+    let aE = aD._1
315+    let aF = aD._2
316+    let aG = aB[1]
317+    let aH = aG._1
318+    let aI = aG._2
319+    let aJ = aB[2]
320+    let aK = aJ._1
321+    let aL = aJ._2
322+    if (if ((g > 0))
323+        then (aE == aC)
324+        else false)
325+        then aF
326+        else if (if ((g > 1))
327+            then (aH == aC)
328+            else false)
329+            then aI
330+            else if (if ((g > 2))
331+                then (aK == aC)
332+                else false)
333+                then aL
334+                else unit
335+    }
336+
337+
338+func aM (aN) = {
339+    let aO = valueOrElse(getInteger(af, Q()), 0)
340+    let aP = valueOrErrorMessage(assetInfo(aj), f("invalid lpAsset info")).quantity
341+    let aQ = fraction(aN, c, (aP - aO))
342+    let aR = if ((aQ != 0))
343+        then true
344+        else h("LP price cannot be 0")
345+    if ((aR == aR))
346+        then {
347+            let aS = (aP - aO)
348+            $Tuple3(aQ, aO, aS)
349+            }
350+        else throw("Strict value is not equal to itself.")
351+    }
352+
353+
354+func aT (aU,S) = {
355+    let C = Address(aU)
356+    let aV = valueOrErrorMessage(getInteger(af, E()), f("invalid period"))
357+    let aW = valueOrErrorMessage(getString(af, R(C, S)), f("invalid withdrawal request"))
358+    let aX = ac(aW)
359+    let U = aX._1
360+    let V = aX._2
361+    let W = aX._3
362+    let X = aX._4
363+    if ((W > aV))
364+        then h("invalid withdrawal request period")
365+        else {
366+            let aY = valueOrErrorMessage(getInteger(af, F(W)), f("invalid price"))
367+            let aZ = if ((aY > 0))
368+                then fraction(V, aY, c)
369+                else 0
370+            let ba = getStringValue(af, aa(aV))
371+            let bb = getStringValue(af, ab(aV))
372+            $Tuple6(C, V, W, aZ, ba, bb)
373+            }
374+    }
375+
376+
377+func bc (aU,S) = {
378+    let bd = aT(aU, S)
379+    let C = bd._1
380+    let V = bd._2
381+    let W = bd._3
382+    let aZ = bd._4
383+    let ba = bd._5
384+    let bb = bd._6
385+    let be = makeString(removeByIndex(split_51C(ba, a), 0), ":")
386+    let bf = makeString(removeByIndex(split_51C(bb, a), 0), ":")
387+    makeString(["%d%s%s", toString(aZ), be, bf], a)
388+    }
389+
390+
391+@Callable(ax)
392+func claimLP (aU) = {
393+    let bg = az(ax)
394+    if ((bg == bg))
395+        then {
396+            let C = Address(aU)
397+            let bh = valueOrElse(getInteger(af, B(C)), 0)
398+            let bi = valueOrElse(getInteger(af, D(C)), 0)
399+            let bj = if ((bh > 0))
400+                then [invoke(af, "transferAsset", [aU, bh, aj], nil), invoke(af, "integerEntry", [B(C), 0], nil), invoke(af, "integerEntry", [D(C), (bi + bh)], nil)]
401+                else h("nothing to claim")
402+            $Tuple2(nil, bj)
403+            }
404+        else throw("Strict value is not equal to itself.")
405+    }
33406 
34407 
35408 
36-@Callable(r)
37-func a () = {
38-    let h = b()
39-    if ((h == h))
40-        then nil
409+@Callable(ax)
410+func finalize (aU,bk,aN,bl,bm) = {
411+    let bg = az(ax)
412+    if ((bg == bg))
413+        then {
414+            let aV = valueOrErrorMessage(getInteger(af, E()), f("invalid period"))
415+            let bn = valueOrErrorMessage(getInteger(af, K()), f("invalid period length"))
416+            let bo = valueOrErrorMessage(getInteger(af, H(aV)), f("invalid start height"))
417+            let bp = valueOrErrorMessage(getInteger(af, F(aV)), f("invalid price"))
418+            let bq = valueOrErrorMessage(getInteger(af, N()), f("invalid next block to process"))
419+            let br = ((bo + bn) - 1)
420+            let bs = [if ((ax.originCaller == ao))
421+                then true
422+                else h("permission denied"), if ((bq > br))
423+                then true
424+                else h("unprocessed blocks"), if ((bk >= 0))
425+                then true
426+                else h("invalid donation part"), if ((aN >= 0))
427+                then true
428+                else h("invalid lp part"), if ((bl >= 0))
429+                then true
430+                else h("invalid claim part"), if ((bm >= 0))
431+                then true
432+                else h("invalid PWR stake part")]
433+            if ((bs == bs))
434+                then {
435+                    let bt = aM(aN)
436+                    let aQ = bt._1
437+                    let aO = bt._2
438+                    let aS = bt._3
439+                    let bu = (aV + 1)
440+                    func bv (bw,bx) =                     {
441+                        let by = bw
442+                        let bz = by._1
443+                        let bA = by._2
444+                        let bb = by._3
445+                        let bB = bx.amount
446+                        let bC = bx.assetId
447+                        let bD = ("%s" + makeString([bA, i(bC)], a))
448+                        let bE = ("%d" + makeString([bb, toString(bB)], a))
449+                        let bF = ScriptTransfer(af, bB, bC)
450+                        $Tuple3((bz :+ bF), bD, bE)
451+                        }
452+
453+                    let bG = {
454+                        let bH = ax.payments
455+                        let bI = size(bH)
456+                        let bJ = $Tuple3(nil, "", "")
457+                        func bK (bL,bM) =                         if ((bM >= bI))
458+                            then bL
459+                            else bv(bL, bH[bM])
460+
461+                        func bN (bL,bM) =                         if ((bM >= bI))
462+                            then bL
463+                            else throw("List size exceeds 10")
464+
465+                        bN(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bJ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
466+                        }
467+                    let bz = bG._1
468+                    let bO = bG._2
469+                    let bP = bG._3
470+                    let bj = [invoke(af, "integerEntry", [I(aV), bm], nil), invoke(af, "integerEntry", [J(aV), bl], nil), invoke(af, "integerEntry", [E(), bu], nil), invoke(af, "integerEntry", [F(bu), aQ], nil), invoke(af, "integerEntry", [H(bu), (br + 1)], nil), invoke(af, "burn", [aO], nil), invoke(af, "integerEntry", [Q(), 0], nil), invoke(af, "integerEntry", [z(unit), aN], nil), invoke(af, "integerEntry", [A(unit), bk], nil), invoke(af, "stringEntry", [aa(bu), bO], nil), invoke(af, "stringEntry", [ab(bu), bP], nil)]
471+                    $Tuple2(bz, bj)
472+                    }
473+                else throw("Strict value is not equal to itself.")
474+            }
41475         else throw("Strict value is not equal to itself.")
42476     }
43477 
478+
479+
480+@Callable(ax)
481+func finalizeREADONLY (bk,aN,bl,bm) = {
482+    let aV = valueOrErrorMessage(getInteger(af, E()), f("invalid period"))
483+    let bn = valueOrErrorMessage(getInteger(af, K()), f("invalid period length"))
484+    let bo = valueOrErrorMessage(getInteger(af, H(aV)), f("invalid start height"))
485+    let bp = valueOrErrorMessage(getInteger(af, F(aV)), f("invalid price"))
486+    let bq = valueOrErrorMessage(getInteger(af, N()), f("invalid next block to process"))
487+    let br = ((bo + bn) - 1)
488+    let bs = [if ((bq > br))
489+        then true
490+        else h("unprocessed blocks"), if ((bk >= 0))
491+        then true
492+        else h("invalid donation part"), if ((aN >= 0))
493+        then true
494+        else h("invalid lp part"), if ((bl >= 0))
495+        then true
496+        else h("invalid claim part"), if ((bm >= 0))
497+        then true
498+        else h("invalid PWR stake part")]
499+    if ((bs == bs))
500+        then {
501+            let bQ = aM(aN)
502+            let aQ = bQ._1
503+            let aO = bQ._2
504+            let aS = bQ._3
505+            $Tuple2(nil, $Tuple6(bl, aN, bk, aQ, aO, aS))
506+            }
507+        else throw("Strict value is not equal to itself.")
508+    }
509+
510+
511+
512+@Callable(ax)
513+func invest (aU) = {
514+    let bg = az(ax)
515+    if ((bg == bg))
516+        then {
517+            let C = Address(aU)
518+            let aV = valueOrErrorMessage(getInteger(af, E()), f("invalid period"))
519+            let bo = valueOrErrorMessage(getInteger(af, H(aV)), f("invalid start height"))
520+            let bR = getIntegerValue(af, L())
521+            let bS = if (((bo + bR) > height))
522+                then true
523+                else h("too late to invest in this period")
524+            if ((bS == bS))
525+                then {
526+                    let bp = valueOrErrorMessage(getInteger(af, F(aV)), f("invalid price"))
527+                    let bx = if ((size(ax.payments) == 1))
528+                        then ax.payments[0]
529+                        else h("invalid payments")
530+                    let bT = if (if ((bx.assetId == unit))
531+                        then (bx.amount > 0)
532+                        else false)
533+                        then $Tuple2(bx.amount, bx.assetId)
534+                        else h("invalid payment amount")
535+                    let bB = bT._1
536+                    let bC = bT._2
537+                    let bU = valueOrElse(getInteger(af, v()), 0)
538+                    let bV = fraction(bB, (c - bU), c)
539+                    let V = if ((bp > 0))
540+                        then fraction(bV, c, bp)
541+                        else 0
542+                    let bW = valueOrElse(getInteger(af, z(unit)), 0)
543+                    let bw = [ScriptTransfer(ao, bV, bC), ScriptTransfer(ap, bU, bC)]
544+                    let bj = [invoke(af, "integerEntry", [z(unit), (bW + bV)], nil), invoke(af, "reissue", [V], nil), invoke(af, "transferAsset", [aU, V, aj], nil)]
545+                    $Tuple2(bw, bj)
546+                    }
547+                else throw("Strict value is not equal to itself.")
548+            }
549+        else throw("Strict value is not equal to itself.")
550+    }
551+
552+
553+
554+@Callable(ax)
555+func withdraw (aU) = {
556+    let bg = az(ax)
557+    if ((bg == bg))
558+        then {
559+            let C = Address(aU)
560+            let aV = valueOrErrorMessage(getInteger(af, E()), f("invalid period"))
561+            let bx = if ((size(ax.payments) == 1))
562+                then ax.payments[0]
563+                else h(f("invalid payments"))
564+            let bC = if ((bx.assetId == aj))
565+                then aj
566+                else h("invalid payment asset")
567+            let bB = if ((bx.amount > 0))
568+                then bx.amount
569+                else h("invalid payment amount")
570+            let bX = valueOrElse(getInteger(af, Q()), 0)
571+            let bw = [ScriptTransfer(af, bB, bC)]
572+            let bj = [invoke(af, "integerEntry", [Q(), (bX + bB)], nil), invoke(af, "stringEntry", [R(C, ax.transactionId), T(d, bB, (aV + 1), unit)], nil)]
573+            if ((bj == bj))
574+                then $Tuple2(bw, bj)
575+                else throw("Strict value is not equal to itself.")
576+            }
577+        else throw("Strict value is not equal to itself.")
578+    }
579+
580+
581+
582+@Callable(ax)
583+func cancelWithdraw (aU,S) = {
584+    let bg = az(ax)
585+    if ((bg == bg))
586+        then {
587+            let C = Address(aU)
588+            let aW = valueOrErrorMessage(getString(af, R(C, S)), f("invalid withdrawal request"))
589+            let aV = valueOrErrorMessage(getInteger(af, E()), f("invalid period"))
590+            let bY = ac(aW)
591+            let U = bY._1
592+            let V = bY._2
593+            let W = bY._3
594+            let X = bY._4
595+            let bs = [if ((U == d))
596+                then true
597+                else h("invalid withdrawal request status"), if ((W > aV))
598+                then true
599+                else h("invalid withdrawal request period")]
600+            if ((bs == bs))
601+                then {
602+                    let bX = valueOrErrorMessage(getInteger(af, Q()), f("invalid total withdrawal amount"))
603+                    let bj = [invoke(af, "integerEntry", [Q(), if ((bX >= V))
604+                        then (bX - V)
605+                        else h("invalid withdrawal amount")], nil), invoke(af, "deleteEntry", [R(C, S)], nil), invoke(af, "transferAsset", [aU, V, aj], nil)]
606+                    if ((bj == bj))
607+                        then $Tuple2(nil, bj)
608+                        else throw("Strict value is not equal to itself.")
609+                    }
610+                else throw("Strict value is not equal to itself.")
611+            }
612+        else throw("Strict value is not equal to itself.")
613+    }
614+
615+
616+
617+@Callable(ax)
618+func claimCollateral (aU,S) = {
619+    let bg = az(ax)
620+    if ((bg == bg))
621+        then {
622+            let bZ = aT(aU, fromBase58String(S))
623+            let C = bZ._1
624+            let V = bZ._2
625+            let W = bZ._3
626+            let aZ = bZ._4
627+            let ba = bZ._5
628+            let bb = bZ._6
629+            let ca = removeByIndex(split_51C(ba, a), 0)
630+            let cb = removeByIndex(split_51C(bb, a), 0)
631+            let bj = [invoke(af, "deleteEntry", [R(C, fromBase58String(S))], nil), invoke(af, "integerEntry", [Z(C, fromBase58String(S)), V], nil), invoke(af, "transferAssets", [aU, ca, cb], nil)]
632+            $Tuple2(nil, bj)
633+            }
634+        else throw("Strict value is not equal to itself.")
635+    }
636+
637+
638+
639+@Callable(ax)
640+func claimCollateralBulk (aU,cc) = {
641+    let bg = az(ax)
642+    if ((bg == bg))
643+        then {
644+            func bv (cd,S) =             {
645+                let ce = aT(aU, fromBase58String(S))
646+                let C = ce._1
647+                let V = ce._2
648+                let W = ce._3
649+                let aZ = ce._4
650+                let ba = ce._5
651+                let bb = ce._6
652+                let ca = removeByIndex(split_51C(ba, a), 0)
653+                let cb = removeByIndex(split_51C(bb, a), 0)
654+                let cf = [invoke(af, "deleteEntry", [R(C, fromBase58String(S))], nil), invoke(af, "integerEntry", [Z(C, fromBase58String(S)), V], nil), invoke(af, "transferAssets", [aU, ca, cb], nil)]
655+                (cd ++ cf)
656+                }
657+
658+            let cg = {
659+                let bH = cc
660+                let bI = size(bH)
661+                let bJ = nil
662+                func bK (bL,bM) =                 if ((bM >= bI))
663+                    then bL
664+                    else bv(bL, bH[bM])
665+
666+                func bN (bL,bM) =                 if ((bM >= bI))
667+                    then bL
668+                    else throw("List size exceeds 10")
669+
670+                bN(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bJ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
671+                }
672+            $Tuple2(nil, cg)
673+            }
674+        else throw("Strict value is not equal to itself.")
675+    }
676+
677+
678+
679+@Callable(ax)
680+func claimCollateralREADONLY (aU,S) = {
681+    let ch = bc(aU, fromBase58String(S))
682+    $Tuple2(nil, ch)
683+    }
684+
685+
686+
687+@Callable(ax)
688+func claimCollateralBulkREADONLY (aU,cc) = {
689+    func ci (cd,S) =     {
690+        let ch = bc(aU, fromBase58String(S))
691+        (cd :+ ch)
692+        }
693+
694+    let cj = {
695+        let bH = cc
696+        let bI = size(bH)
697+        let bJ = nil
698+        func bK (bL,bM) =         if ((bM >= bI))
699+            then bL
700+            else ci(bL, bH[bM])
701+
702+        func bN (bL,bM) =         if ((bM >= bI))
703+            then bL
704+            else throw("List size exceeds 10")
705+
706+        bN(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bJ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
707+        }
708+    $Tuple2(nil, cj)
709+    }
710+
711+
712+
713+@Callable(ax)
714+func processBlocks (aU) = {
715+    let bg = az(ax)
716+    if ((bg == bg))
717+        then {
718+            let C = Address(aU)
719+            let aV = valueOrErrorMessage(getInteger(af, E()), f("invalid period"))
720+            let bn = valueOrErrorMessage(getInteger(af, K()), f("invalid period length"))
721+            let bo = valueOrErrorMessage(getInteger(af, H(aV)), f("invalid start height"))
722+            let bp = valueOrErrorMessage(getInteger(af, F(aV)), f("invalid price"))
723+            let bq = valueOrErrorMessage(getInteger(af, N()), f("invalid next block to process"))
724+            let br = ((bo + bn) - 1)
725+            let ck = 20
726+            let cl = if (if (if ((height >= bq))
727+                then if ((bq >= bo))
728+                    then true
729+                    else (aV == 0)
730+                else false)
731+                then (br >= bq)
732+                else false)
733+                then min([((br - bq) + 1), ck])
734+                else h(f("invalid target block"))
735+            let cm = valueOrErrorMessage(getInteger(af, M()), f("invalid block processing reward"))
736+            let cn = (cm / cl)
737+            let co = (cm - (cn * cl))
738+            func cp (cq,cr) =             if ((cr >= cl))
739+                then cq
740+                else {
741+                    let cs = (bq + cr)
742+                    let ct = valueOrErrorMessage(blockInfoByHeight(cs), f("invalid block info"))
743+                    let cu = valueOrErrorMessage(aA(ct.rewards, al), f(("invalid treasury reward for height " + toString(cs))))
744+                    let cv = ct.generator
745+                    let bh = valueOrElse(getInteger(af, B(cv)), 0)
746+                    let cw = if ((cr == (cl - 1)))
747+                        then (cn + co)
748+                        else cn
749+                    let cx = max([0, min([valueOrElse(getInteger(af, x()), 0), c])])
750+                    let cy = fraction((cu - cw), cx, c)
751+                    let V = if ((bp > 0))
752+                        then fraction(((cu - cw) - cy), c, bp)
753+                        else 0
754+                    let cz = [invoke(af, "stringEntry", [O(cs), makeString([toBase58String(ax.transactionId), toString(aV), toString(cv), toBase58String(aU), toString(cu), toString(cw), toString(V), toString(cy)], a)], nil), invoke(af, "integerEntry", [B(cv), (bh + V)], nil)]
755+                    if ((cz == cz))
756+                        then {
757+                            let cA = cq
758+                            let cB = cA._1
759+                            let cC = cA._2
760+                            let cD = cA._3
761+                            let cE = cD
762+                            let cF = cE._1
763+                            let cG = cE._2
764+                            let cH = (cG :+ $Tuple2(toString(cv), cy))
765+                            $Tuple3((cB + V), (cC + cu), $Tuple2((cF + cy), cH))
766+                            }
767+                        else throw("Strict value is not equal to itself.")
768+                    }
769+
770+            let cI = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
771+            let cJ = {
772+                let bH = cI
773+                let bI = size(bH)
774+                let bJ = $Tuple3(0, 0, $Tuple2(0, nil))
775+                func bK (bL,bM) =                 if ((bM >= bI))
776+                    then bL
777+                    else cp(bL, bH[bM])
778+
779+                func bN (bL,bM) =                 if ((bM >= bI))
780+                    then bL
781+                    else throw("List size exceeds 20")
782+
783+                bN(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bK(bJ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
784+                }
785+            if ((cJ == cJ))
786+                then {
787+                    let cD = cJ._3
788+                    let cK = cJ._2
789+                    let cL = cJ._1
790+                    let cM = cD
791+                    let cN = cM._1
792+                    let cO = cM._2
793+                    let cP = valueOrElse(getInteger(af, v()), 0)
794+                    let cQ = fraction(cK, cP, c)
795+                    let cR = (((cK - cQ) - cm) - cN)
796+                    let bW = valueOrElse(getInteger(af, z(unit)), 0)
797+                    let cS = if ((cN > 0))
798+                        then {
799+                            let cT = [invoke(af, "transferFromProxyTreasury", [af.bytes, cN], nil)]
800+                            if ((cT == cT))
801+                                then {
802+                                    let cU = invoke(af, "swap", [as], [AttachedPayment(unit, cN)])
803+                                    if ((cU == cU))
804+                                        then {
805+                                            let cV = {
806+                                                let k = cU
807+                                                if ($isInstanceOf(k, "Int"))
808+                                                    then {
809+                                                        let cW = k
810+                                                        cW
811+                                                        }
812+                                                    else 0
813+                                                }
814+                                            func cX (cq,cY) =                                             {
815+                                                let cZ = cY
816+                                                let cv = cZ._1
817+                                                let da = cZ._2
818+                                                if ((cN > 0))
819+                                                    then {
820+                                                        let db = fraction(da, cV, cN)
821+                                                        let dc = invoke(af, "powerStake", [fromBase58String(cv)], [AttachedPayment(fromBase58String(as), db)])
822+                                                        if ((dc == dc))
823+                                                            then nil
824+                                                            else throw("Strict value is not equal to itself.")
825+                                                        }
826+                                                    else nil
827+                                                }
828+
829+                                            let dd = {
830+                                                let bH = cO
831+                                                let bI = size(bH)
832+                                                let bJ = 0
833+                                                func de (bL,bM) =                                                 if ((bM >= bI))
834+                                                    then bL
835+                                                    else cX(bL, bH[bM])
836+
837+                                                func df (bL,bM) =                                                 if ((bM >= bI))
838+                                                    then bL
839+                                                    else throw("List size exceeds 20")
840+
841+                                                df(de(de(de(de(de(de(de(de(de(de(de(de(de(de(de(de(de(de(de(de(bJ, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
842+                                                }
843+                                            if ((dd == dd))
844+                                                then nil
845+                                                else throw("Strict value is not equal to itself.")
846+                                            }
847+                                        else throw("Strict value is not equal to itself.")
848+                                    }
849+                                else throw("Strict value is not equal to itself.")
850+                            }
851+                        else nil
852+                    if ((cS == cS))
853+                        then {
854+                            let bw = [invoke(af, "reissue", [cL], nil), invoke(af, "integerEntry", [N(), (bq + cl)], nil), invoke(af, "transferFromProxyTreasury", [ao.bytes, cR], nil), invoke(af, "transferFromProxyTreasury", [aU, cm], nil), invoke(af, "transferFromProxyTreasury", [ap.bytes, cQ], nil), invoke(af, "integerEntry", [z(unit), (bW + cR)], nil)]
855+                            if ((bw == bw))
856+                                then $Tuple2(nil, unit)
857+                                else throw("Strict value is not equal to itself.")
858+                            }
859+                        else throw("Strict value is not equal to itself.")
860+                    }
861+                else throw("Strict value is not equal to itself.")
862+            }
863+        else throw("Strict value is not equal to itself.")
864+    }
865+
866+
867+@Verifier(dg)
868+func dh () = {
869+    let di = {
870+        let k = at()
871+        if ($isInstanceOf(k, "ByteVector"))
872+            then {
873+                let av = k
874+                av
875+                }
876+            else dg.senderPublicKey
877+        }
878+    sigVerify(dg.bodyBytes, dg.proofs[0], di)
879+    }
44880 
github/deemru/w8io/169f3d6 
57.49 ms ◑