tx · H21cseDEsB2EbDWJ74fMipXrhU8DK9YtthpqzSiSfEeQ

3NC4yuNEo3Z5VZDacNq9eFzMPg94xCHMZRS:  -0.04300000 Waves

2024.09.27 13:44 [3301934] smart account 3NC4yuNEo3Z5VZDacNq9eFzMPg94xCHMZRS > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "H21cseDEsB2EbDWJ74fMipXrhU8DK9YtthpqzSiSfEeQ",
    "fee": 4300000,
    "feeAssetId": null,
    "timestamp": 1727433877734,
    "version": 2,
    "chainId": 84,
    "sender": "3NC4yuNEo3Z5VZDacNq9eFzMPg94xCHMZRS",
    "senderPublicKey": "HicNLFvqDeULvqVAGxGmDk2vjsM1NSvfFRpjp3tTqPwF",
    "proofs": [
        "27LYM9fGSMcAPZzevuqZikDensZ1R5JDqa8gv1RLbnT5xbfekc1Mbg5dKRa7Wx4MiyRZtNPkrXAVgR8PZ9Bv9ztY"
    ],
    "script": "base64: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",
    "height": 3301934,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 8 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = 9223372036854775807
5+
6+let b = 100000000
7+
8+let c = (20000 * b)
9+
10+let d = ","
11+
12+let e = 32
13+
14+let f = 20
15+
16+let g = 32
17+
18+let h = 10
19+
20+let i = 40
21+
22+let j = 16
23+
24+let k = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
25+
26+let l = "allMiners"
27+
28+let m = "mainChainId"
29+
30+let n = "lastChainId"
31+
32+let o = "firstValidAltChainId"
33+
34+let p = "minerReward"
35+
36+let q = "block_0x"
37+
38+let r = "finalizedBlock"
39+
40+let s = "tokenId"
41+
42+let t = "elBridgeAddress"
43+
44+let u = "nativeTransfersCount"
45+
46+func v (w) = {
47+    let x = toString(w)
48+    let y = size(x)
49+    if ((1 == y))
50+        then ("0000000" + x)
51+        else if ((2 == y))
52+            then ("000000" + x)
53+            else if ((3 == y))
54+                then ("00000" + x)
55+                else if ((4 == y))
56+                    then ("0000" + x)
57+                    else if ((5 == y))
58+                        then ("000" + x)
59+                        else if ((6 == y))
60+                            then ("00" + x)
61+                            else if ((7 == y))
62+                                then ("0" + x)
63+                                else x
64+    }
65+
66+
67+let z = addressFromStringValue("3N5c7DCCGmicNiHRGouUp3BaV6e8eDUDnHw")
68+
69+let A = "circuitBreakerClosed"
70+
71+func B () = if (valueOrElse(getBoolean(this, A), true))
72+    then true
73+    else throw("circuit breaker is opened")
74+
75+
76+func C (D) = ("elToClTransfers_0x" + D)
77+
78+
79+func E (F) = ("epoch_" + v(F))
80+
81+
82+func G (H) = (("chain" + toString(H)) + "FirstBlock")
83+
84+
85+func I (H) = ("chain_" + v(H))
86+
87+
88+func J (H,K) = ((("chain_" + v(H)) + "_") + toString(K))
89+
90+
91+func L (H) = (("chain_" + v(H)) + "ForkedHeight")
92+
93+
94+func M (H) = (("chain" + toString(H)) + "Supporters")
95+
96+
97+func N (O) = (("miner_" + O) + "_RewardAddress")
98+
99+
100+func P (Q) = (("miner_0x" + Q) + "_PK")
101+
102+
103+func R (K) = (("miner_" + toString(K)) + "_ChainId")
104+
105+
106+let S = valueOrElse(getInteger(this, u), 0)
107+
108+func T (U) = ("nativeTransfer_" + toString(U))
109+
110+
111+func V (U,W,X) = StringEntry(T(U), ((("0x" + W) + d) + toString(X)))
112+
113+
114+func Y (Z,aa,ab) = {
115+    let ac = if (ab)
116+        then (j - 1)
117+        else j
118+    let ad = (aa - Z)
119+    let ae = if ((ad > ac))
120+        then throw(((("Allowed only " + toString(ac)) + " transfers, got ") + toString(ad)))
121+        else true
122+    if ((ae == ae))
123+        then if ((aa >= S))
124+            then throw(((("Attempt to transfer #" + toString(aa)) + ". Available transfers: ") + toString(S)))
125+            else true
126+        else throw("Strict value is not equal to itself.")
127+    }
128+
129+
130+func af (ag,ah,ai) = if ((ag.amount >= ah))
131+    then true
132+    else throw((((((("Transferring amount " + toString(ag.amount)) + " should be >= ") + toString(ah)) + " for queue size of ") + toString(ai)) + ". Transfer more or wait"))
133+
134+
135+func aj (ak) = wavesBalance(ak).generating
136+
137+
138+func al (H) = {
139+    let x = getStringValue(I(H))
140+    let am = split(x, d)
141+    $Tuple2(parseIntValue(am[0]), am[1])
142+    }
143+
144+
145+func an (H,ao,D) = StringEntry(I(H), ((toString(ao) + d) + D))
146+
147+
148+let ap = valueOrElse(getInteger(m), 0)
149+
150+let aq = al(ap)
151+
152+let ar = aq._1
153+
154+let as = aq._2
155+
156+func at (F) = {
157+    let y = getString(E(F))
158+    if ($isInstanceOf(y, "String"))
159+        then {
160+            let x = y
161+            let au = split(x, d)
162+            $Tuple3(addressFromStringValue(au[0]), parseIntValue(au[1]), au[2])
163+            }
164+        else unit
165+    }
166+
167+
168+let av = {
169+    let y = at(height)
170+    if ($isInstanceOf(y, "(Address, Int, String)"))
171+        then {
172+            let aw = y
173+            aw
174+            }
175+        else $Tuple2(unit, 0)
176+    }
177+
178+let ax = av._1
179+
180+let ay = av._2
181+
182+let az = valueOrElse(getString(l), "")
183+
184+let aA = {
185+    let y = az
186+    if (("" == y))
187+        then nil
188+        else if ($isInstanceOf(y, "String"))
189+            then {
190+                let aB = y
191+                split_4C(aB, d)
192+                }
193+            else throw("Match error")
194+    }
195+
196+func aC (aD) = {
197+    let aE = getBinaryValue((q + aD))
198+    let aF = size(aE)
199+    let aG = toInt(aE)
200+    let aH = toInt(aE, 8)
201+    let aI = take(drop(aE, 16), e)
202+    let H = toInt(aE, (16 + e))
203+    let aJ = (24 + e)
204+    let aK = (aF - aJ)
205+    let aL = if ((aK >= g))
206+        then take(drop(aE, aJ), g)
207+        else base58''
208+    let aM = if (if ((aK == 8))
209+        then true
210+        else (aK > g))
211+        then toInt(aE, (aJ + size(aL)))
212+        else -1
213+    $Tuple6(aG, aH, aI, H, aL, aM)
214+    }
215+
216+
217+func aN (D,aG,aO,H,aP,aM) = {
218+    let aQ = fromBase16String(aP)
219+    let aR = size(aQ)
220+    let aS = if (if ((aR == 0))
221+        then true
222+        else (aR == g))
223+        then true
224+        else throw(((("Transfers root hash should have 0 or " + toString(g)) + " bytes, got ") + toString(aR)))
225+    if ((aS == aS))
226+        then {
227+            let aT = (((((toBytes(aG) + toBytes(height)) + fromBase16String(aO)) + toBytes(H)) + aQ) + toBytes(aM))
228+            BinaryEntry((q + D), aT)
229+            }
230+        else throw("Strict value is not equal to itself.")
231+    }
232+
233+
234+func aU (K,H) = {
235+    let y = getInteger(J(H, K))
236+    if ($isInstanceOf(y, "Int"))
237+        then {
238+            let aV = y
239+            aV
240+            }
241+        else {
242+            let aW = getStringValue(((("chain" + toString(H)) + "LastMinedBy") + toString(K)))
243+            aC(aW)._1
244+            }
245+    }
246+
247+
248+let aX = {
249+    let aY = {
250+        let y = lastBlock.vrf
251+        if ($isInstanceOf(y, "ByteVector"))
252+            then {
253+                let aZ = y
254+                aZ
255+                }
256+            else lastBlock.generationSignature
257+        }
258+    func ba (bb,K) =     {
259+        let bc = bb
260+        let bd = bc._1
261+        let be = bc._2
262+        let bf = bc._3
263+        let bg = bc._4
264+        let bh = addressFromStringValue(K)
265+        let bi = wavesBalance(bh).generating
266+        let bj = aj(bh)
267+        if (if ((c > bi))
268+            then true
269+            else (0 >= bj))
270+            then bb
271+            else {
272+                let bk = calculateDelay(bh, bj)
273+                if ((bf > bk))
274+                    then $Tuple4(K, (be + bj), bk, (bg :+ K))
275+                    else $Tuple4(bd, (be + bj), bf, (bg :+ K))
276+                }
277+        }
278+
279+    let bl = aA
280+    let bm = size(bl)
281+    let bn = $Tuple4("", 0, a, nil)
282+    func bo (bp,bq) =     if ((bq >= bm))
283+        then bp
284+        else ba(bp, bl[bq])
285+
286+    func br (bp,bq) =     if ((bq >= bm))
287+        then bp
288+        else throw("List size exceeds 50")
289+
290+    br(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bn, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
291+    }
292+
293+let bs = aX._1
294+
295+let bt = aX._2
296+
297+let bu = aC(as)
298+
299+let bv = bu._1
300+
301+let bw = bu._2
302+
303+func bx (by,bz,bA) = {
304+    let bB = split_4C("::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::", "")
305+    let bC = (bt / 2)
306+    func bD (bb,bE) =     {
307+        let bF = bb
308+        let bG = bF._1
309+        let bH = bF._2
310+        let bI = bF._3
311+        let bg = bF._4
312+        let y = bH
313+        if ($isInstanceOf(y, "Unit"))
314+            then {
315+                let bJ = if ((bG == height))
316+                    then $Tuple3(by, bz, bA)
317+                    else value(at(bG))
318+                let K = bJ._1
319+                let bK = bJ._2
320+                let bL = bJ._3
321+                if (if ((bK == 0))
322+                    then true
323+                    else ((height - bG) >= 100))
324+                    then $Tuple4(bG, bL, bI, aA)
325+                    else {
326+                        let bM = if (containsElement(bg, K))
327+                            then $Tuple2(bI, bg)
328+                            else $Tuple2((bI + aj(K)), K :: bg)
329+                        let bN = bM._1
330+                        let bO = bM._2
331+                        if ((bN > bC))
332+                            then $Tuple4(bG, bL, bN, aA)
333+                            else $Tuple4(bK, unit, bN, bO)
334+                        }
335+                }
336+            else bb
337+        }
338+
339+    let bP = {
340+        let bl = bB
341+        let bm = size(bl)
342+        let bn = $Tuple4(height, unit, 0, nil)
343+        func bo (bp,bq) =         if ((bq >= bm))
344+            then bp
345+            else bD(bp, bl[bq])
346+
347+        func br (bp,bq) =         if ((bq >= bm))
348+            then bp
349+            else throw("List size exceeds 100")
350+
351+        br(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bn, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64), 65), 66), 67), 68), 69), 70), 71), 72), 73), 74), 75), 76), 77), 78), 79), 80), 81), 82), 83), 84), 85), 86), 87), 88), 89), 90), 91), 92), 93), 94), 95), 96), 97), 98), 99), 100)
352+        }
353+    let bQ = bP._1
354+    let bR = bP._2
355+    let y = bR
356+    if ($isInstanceOf(y, "String"))
357+        then {
358+            let bS = y
359+            bS
360+            }
361+        else value(at(bQ))._3
362+    }
363+
364+
365+func bT (H) = {
366+    func bU (bV,bW) =     {
367+        let bX = bV
368+        let bI = bX._1
369+        let bY = bX._2
370+        let bZ = addressFromStringValue(bW)
371+        if (containsElement(bY, bZ))
372+            then bV
373+            else {
374+                let ca = aj(bZ)
375+                $Tuple2((bI + ca), (bY :+ bZ))
376+                }
377+        }
378+
379+    let cb = split_4C(getStringValue(M(H)), d)
380+    let cc = {
381+        let bl = cb
382+        let bm = size(bl)
383+        let bn = $Tuple2(0, nil)
384+        func bo (bp,bq) =         if ((bq >= bm))
385+            then bp
386+            else bU(bp, bl[bq])
387+
388+        func br (bp,bq) =         if ((bq >= bm))
389+            then bp
390+            else throw("List size exceeds 100")
391+
392+        br(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bn, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50), 51), 52), 53), 54), 55), 56), 57), 58), 59), 60), 61), 62), 63), 64), 65), 66), 67), 68), 69), 70), 71), 72), 73), 74), 75), 76), 77), 78), 79), 80), 81), 82), 83), 84), 85), 86), 87), 88), 89), 90), 91), 92), 93), 94), 95), 96), 97), 98), 99), 100)
393+        }
394+    let ca = cc._1
395+    let cd = cc._2
396+    ca
397+    }
398+
399+
400+func ce () = isDefined(getInteger(p))
401+
402+
403+func cf (bZ) = if ((toString(bZ) != bs))
404+    then throw(((((toBase58String(bZ.bytes) + " is not allowed to mine in ") + toString(height)) + " epoch. Expected ") + bs))
405+    else unit
406+
407+
408+func cg (ch,ci) = if ((ch == ci))
409+    then unit
410+    else throw(((("Expected a reference to the chain last block: 0x" + ci) + ". Got: 0x") + ch))
411+
412+
413+func cj (H) = {
414+    let ck = getStringValue(G(H))
415+    let cl = valueOrElse(getInteger(o), 0)
416+    if ((cl > H))
417+        then true
418+        else (aC(getStringValue(r))._1 > aC(ck)._1)
419+    }
420+
421+
422+func cm (K) = valueOrElse(getInteger(R(K)), getInteger(("chainIdOf" + toString(K))))
423+
424+
425+func cn (bZ,co,cp) = {
426+    let cq = {
427+        let y = cp
428+        if ($isInstanceOf(y, "String"))
429+            then {
430+                let aW = y
431+                let cr = aU(bZ, ap)
432+                ((aC(aW)._1 + 1) > cr)
433+                }
434+            else true
435+        }
436+    let y = cm(bZ)
437+    if ($isInstanceOf(y, "Int"))
438+        then {
439+            let cs = y
440+            if (if ((cs == co))
441+                then true
442+                else if (cj(cs))
443+                    then cq
444+                    else false)
445+                then unit
446+                else throw(("miner is mining other chain " + toString(cs)))
447+            }
448+        else unit
449+    }
450+
451+
452+let ct = (" at height " + toString(height))
453+
454+func cu (cv) = valueOrErrorMessage(valueOrErrorMessage(blockInfoByHeight(cv), ("last block is not available" + ct)).vrf, ("VRF is not available" + ct))
455+
456+
457+func cw (cx) = {
458+    let cy = cu(height)
459+    if ((cx == cy))
460+        then unit
461+        else throw((((("Expected VRF " + toBase58String(cx)) + " does not match actual ") + toBase58String(cy)) + ct))
462+    }
463+
464+
465+func cz (H,bZ) = {
466+    let cA = getStringValue(M(H))
467+    let cB = split_4C(cA, d)
468+    if (containsElement(cB, toString(bZ)))
469+        then nil
470+        else [StringEntry(M(H), ((cA + d) + toString(bZ)))]
471+    }
472+
473+
474+func cC (cD,U) = if ((0 > U))
475+    then throw(("Can't withdraw at negative index: " + toString(U)))
476+    else {
477+        let cE = size(cD)
478+        if ((U >= cE))
479+            then {
480+                let cF = (U - cE)
481+                if ((cF > size(k)))
482+                    then throw((("Can't add " + toString(cF)) + " empty flags. Contact with developers"))
483+                    else ((cD + take(k, cF)) + "1")
484+                }
485+            else {
486+                let cG = drop(cD, U)
487+                let cH = take(cG, 1)
488+                if ((cH == "0"))
489+                    then ((take(cD, U) + "1") + drop(cG, 1))
490+                    else throw((("Transfer #" + toString(U)) + " has been already taken"))
491+                }
492+        }
493+
494+
495+func cI (cJ) = {
496+    let cK = fromBase16String(cJ)
497+    if ((size(cK) != e))
498+        then throw("invalid block id length")
499+        else cJ
500+    }
501+
502+
503+func cL (cM,cN,bK) = {
504+    let cO = aC(getStringValue(r))._1
505+    let cP = bx(cM, bK, cN)
506+    if (if ((cP == cN))
507+        then true
508+        else (aC(cP)._1 > cO))
509+        then [StringEntry(r, cP)]
510+        else nil
511+    }
512+
513+
514+@Callable(w)
515+func extendMainChain (D,cQ,aZ,aP,aM) = {
516+    let cR = B()
517+    if ((cR == cR))
518+        then {
519+            let cS = cI(D)
520+            if ((cS == cS))
521+                then {
522+                    let cT = cw(aZ)
523+                    if ((cT == cT))
524+                        then {
525+                            let cU = cn(w.originCaller, ap, unit)
526+                            if ((cU == cU))
527+                                then {
528+                                    let cV = cg(cQ, as)
529+                                    if ((cV == cV))
530+                                        then {
531+                                            let cW = Y(aC(cQ)._6, aM, true)
532+                                            if ((cW == cW))
533+                                                then {
534+                                                    let cX = {
535+                                                        let y = at(height)
536+                                                        if ($isInstanceOf(y, "Unit"))
537+                                                            then StringEntry(E(height), ((((toString(w.originCaller) + d) + toString(bw)) + d) + D))
538+                                                            else {
539+                                                                let cY = y
540+                                                                throw("Epoch already started")
541+                                                                }
542+                                                        }
543+                                                    if ((cX == cX))
544+                                                        then {
545+                                                            let cZ = cf(w.originCaller)
546+                                                            if ((cZ == cZ))
547+                                                                then {
548+                                                                    let da = cL(w.originCaller, D, bw)
549+                                                                    let ao = (ar + 1)
550+                                                                    ([aN(D, ao, as, ap, aP, aM), an(ap, ao, D), IntegerEntry(R(w.originCaller), ap), IntegerEntry(J(ap, w.originCaller), ao), cX] ++ da)
551+                                                                    }
552+                                                                else throw("Strict value is not equal to itself.")
553+                                                            }
554+                                                        else throw("Strict value is not equal to itself.")
555+                                                    }
556+                                                else throw("Strict value is not equal to itself.")
557+                                            }
558+                                        else throw("Strict value is not equal to itself.")
559+                                    }
560+                                else throw("Strict value is not equal to itself.")
561+                            }
562+                        else throw("Strict value is not equal to itself.")
563+                    }
564+                else throw("Strict value is not equal to itself.")
565+            }
566+        else throw("Strict value is not equal to itself.")
567+    }
568+
569+
570+
571+@Callable(w)
572+func startAltChain (D,cQ,aZ,aP,aM) = {
573+    let cR = B()
574+    if ((cR == cR))
575+        then {
576+            let cS = cI(D)
577+            if ((cS == cS))
578+                then {
579+                    let cT = cw(aZ)
580+                    if ((cT == cT))
581+                        then {
582+                            let db = aC(cQ)
583+                            let dc = db._1
584+                            let dd = db._2
585+                            let de = db._3
586+                            let df = db._4
587+                            let dg = db._5
588+                            let Z = db._6
589+                            let dh = aC(getStringValue(r))._2
590+                            let di = if ((dd >= dh))
591+                                then dd
592+                                else throw((((("Can not start alt chain from epoch " + toString(dd)) + ", epoch ") + toString(dh)) + " is finalized"))
593+                            let cU = cn(w.originCaller, ap, cQ)
594+                            if ((cU == cU))
595+                                then {
596+                                    let cW = Y(Z, aM, true)
597+                                    if ((cW == cW))
598+                                        then {
599+                                            let dj = (valueOrElse(getInteger(n), 0) + 1)
600+                                            let ao = (dc + 1)
601+                                            let cX = {
602+                                                let y = at(height)
603+                                                if ($isInstanceOf(y, "Unit"))
604+                                                    then StringEntry(E(height), ((((toString(w.originCaller) + d) + toString(di)) + d) + D))
605+                                                    else {
606+                                                        let cY = y
607+                                                        throw("Epoch already started")
608+                                                        }
609+                                                }
610+                                            let cZ = cf(w.originCaller)
611+                                            if ((cZ == cZ))
612+                                                then [cX, aN(D, ao, cQ, dj, aP, aM), StringEntry(G(dj), D), an(dj, ao, D), IntegerEntry(R(w.originCaller), dj), IntegerEntry(J(dj, w.originCaller), ao), IntegerEntry(J(ap, w.originCaller), ao), StringEntry(M(dj), toString(w.originCaller)), IntegerEntry(n, dj)]
613+                                                else throw("Strict value is not equal to itself.")
614+                                            }
615+                                        else throw("Strict value is not equal to itself.")
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+
626+
627+
628+@Callable(w)
629+func extendAltChain (D,cQ,aZ,H,aP,aM) = {
630+    let cR = B()
631+    if ((cR == cR))
632+        then {
633+            let cS = cI(D)
634+            if ((cS == cS))
635+                then {
636+                    let cT = cw(aZ)
637+                    if ((cT == cT))
638+                        then {
639+                            let dk = aC(getStringValue(G(H)))
640+                            let cU = cn(w.originCaller, H, toBase16String(dk._3))
641+                            if ((cU == cU))
642+                                then {
643+                                    let dl = al(H)
644+                                    let dm = dl._1
645+                                    let dn = dl._2
646+                                    let cV = cg(cQ, dn)
647+                                    if ((cV == cV))
648+                                        then {
649+                                            let cW = Y(aC(cQ)._6, aM, true)
650+                                            if ((cW == cW))
651+                                                then {
652+                                                    let ao = (dm + 1)
653+                                                    let bK = aC(cQ)._2
654+                                                    let do = if ((bT(H) > (bt / 2)))
655+                                                        then {
656+                                                            let dp = valueOrElse(getInteger(n), 0)
657+                                                            let da = cL(w.originCaller, D, bK)
658+                                                            ([IntegerEntry(L(ap), dk._1), IntegerEntry(m, H), IntegerEntry(o, (dp + 1))] ++ da)
659+                                                            }
660+                                                        else nil
661+                                                    let cX = {
662+                                                        let y = at(height)
663+                                                        if ($isInstanceOf(y, "Unit"))
664+                                                            then StringEntry(E(height), ((((toString(w.originCaller) + d) + toString(bK)) + d) + D))
665+                                                            else {
666+                                                                let cY = y
667+                                                                throw("Epoch already started")
668+                                                                }
669+                                                        }
670+                                                    if ((cX == cX))
671+                                                        then {
672+                                                            let cZ = cf(w.originCaller)
673+                                                            if ((cZ == cZ))
674+                                                                then {
675+                                                                    let dq = if (if ((do == nil))
676+                                                                        then (valueOrElse(cm(w.originCaller), 0) != H)
677+                                                                        else false)
678+                                                                        then [IntegerEntry(J(ap, w.originCaller), dk._1)]
679+                                                                        else nil
680+                                                                    ((([aN(D, ao, cQ, H, aP, aM), an(H, ao, D), cX, IntegerEntry(R(w.originCaller), H), IntegerEntry(J(H, w.originCaller), ao)] ++ do) ++ cz(H, w.originCaller)) ++ dq)
681+                                                                    }
682+                                                                else throw("Strict value is not equal to itself.")
683+                                                            }
684+                                                        else throw("Strict value is not equal to itself.")
685+                                                    }
686+                                                else throw("Strict value is not equal to itself.")
687+                                            }
688+                                        else throw("Strict value is not equal to itself.")
689+                                    }
690+                                else throw("Strict value is not equal to itself.")
691+                            }
692+                        else throw("Strict value is not equal to itself.")
693+                    }
694+                else throw("Strict value is not equal to itself.")
695+            }
696+        else throw("Strict value is not equal to itself.")
697+    }
698+
699+
700+
701+@Callable(w)
702+func appendBlock (D,cQ,aP,aM) = {
703+    let cR = B()
704+    if ((cR == cR))
705+        then {
706+            let dr = if ((ax == w.originCaller))
707+                then true
708+                else {
709+                    let y = ax
710+                    if ($isInstanceOf(y, "Address"))
711+                        then {
712+                            let ds = y
713+                            throw(("not allowed to forge blocks in this epoch, expected from " + toString(ds)))
714+                            }
715+                        else throw("not allowed to forge blocks in this epoch, epoch miner is absent")
716+                    }
717+            if ((dr == dr))
718+                then {
719+                    let H = valueOrElse(cm(w.originCaller), ap)
720+                    let dt = al(H)
721+                    let dm = dt._1
722+                    let du = dt._2
723+                    let cV = cg(cQ, du)
724+                    if ((cV == cV))
725+                        then {
726+                            let cW = Y(aC(cQ)._6, aM, false)
727+                            if ((cW == cW))
728+                                then {
729+                                    let ao = (dm + 1)
730+                                    let cS = cI(D)
731+                                    if ((cS == cS))
732+                                        then [aN(D, ao, du, H, aP, aM), IntegerEntry(J(H, w.originCaller), ao), an(H, ao, D), StringEntry(E(height), ((((toString(value(ax)) + d) + toString(ay)) + d) + D))]
733+                                        else throw("Strict value is not equal to itself.")
734+                                    }
735+                                else throw("Strict value is not equal to itself.")
736+                            }
737+                        else throw("Strict value is not equal to itself.")
738+                    }
739+                else throw("Strict value is not equal to itself.")
740+            }
741+        else throw("Strict value is not equal to itself.")
742+    }
743+
744+
745+
746+@Callable(w)
747+func join (Q) = {
748+    let cR = B()
749+    if ((cR == cR))
750+        then {
751+            func dv (dw) =             {
752+                let y = getBinary(P(dw))
753+                if ($isInstanceOf(y, "ByteVector"))
754+                    then {
755+                        let dx = y
756+                        if ((dx == w.originCallerPublicKey))
757+                            then unit
758+                            else throw(((("EL miner address " + dw) + " is already linked with ") + toBase58String(dx)))
759+                        }
760+                    else unit
761+                }
762+
763+            if (!(ce()))
764+                then throw("The contract has not yet set up")
765+                else if ((c > wavesBalance(w.originCaller).generating))
766+                    then throw(((("Insufficient generating balance: " + toString(wavesBalance(w.originCaller).generating)) + ". Required: ") + toString(c)))
767+                    else if ((size(Q) != 20))
768+                        then throw("rewardAddress should be an L2 address")
769+                        else if ((size(aA) >= 50))
770+                            then throw("too many miners")
771+                            else {
772+                                func dy (dz,K) =                                 if (dz)
773+                                    then true
774+                                    else (K == toString(w.originCaller))
775+
776+                                let dA = {
777+                                    let bl = aA
778+                                    let bm = size(bl)
779+                                    let bn = false
780+                                    func bo (bp,bq) =                                     if ((bq >= bm))
781+                                        then bp
782+                                        else dy(bp, bl[bq])
783+
784+                                    func br (bp,bq) =                                     if ((bq >= bm))
785+                                        then bp
786+                                        else throw("List size exceeds 50")
787+
788+                                    br(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bn, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
789+                                    }
790+                                if (dA)
791+                                    then nil
792+                                    else {
793+                                        let dB = toString(w.originCaller)
794+                                        let dC = toBase16String(Q)
795+                                        let dD = dv(dC)
796+                                        if ((dD == dD))
797+                                            then {
798+                                                let bO = if ((size(aA) == 0))
799+                                                    then dB
800+                                                    else ((az + d) + dB)
801+                                                let dE = {
802+                                                    let y = getString(N(dB))
803+                                                    if ($isInstanceOf(y, "String"))
804+                                                        then {
805+                                                            let dF = y
806+                                                            if ((dF == toBase16String(Q)))
807+                                                                then nil
808+                                                                else [DeleteEntry(P(dF))]
809+                                                            }
810+                                                        else nil
811+                                                    }
812+                                                ([StringEntry(l, bO), StringEntry(N(dB), ("0x" + dC)), BinaryEntry(P(dC), w.originCallerPublicKey)] ++ dE)
813+                                                }
814+                                            else throw("Strict value is not equal to itself.")
815+                                        }
816+                                }
817+            }
818+        else throw("Strict value is not equal to itself.")
819+    }
820+
821+
822+
823+@Callable(w)
824+func leave () = {
825+    let cR = B()
826+    if ((cR == cR))
827+        then {
828+            let dG = toString(w.originCaller)
829+            func dH (bV,K) =             if ((K == dG))
830+                then bV
831+                else (bV :+ K)
832+
833+            let dI = {
834+                let bl = aA
835+                let bm = size(bl)
836+                let bn = nil
837+                func bo (bp,bq) =                 if ((bq >= bm))
838+                    then bp
839+                    else dH(bp, bl[bq])
840+
841+                func br (bp,bq) =                 if ((bq >= bm))
842+                    then bp
843+                    else throw("List size exceeds 50")
844+
845+                br(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bo(bn, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
846+                }
847+            let dJ = N(dG)
848+            let dK = valueOrErrorMessage(getString(this, dJ), "miner has never joined")
849+            if ((dK == dK))
850+                then if ((ax == w.originCaller))
851+                    then throw("designated miner can't leave")
852+                    else [StringEntry(l, makeString_2C(dI, d))]
853+                else throw("Strict value is not equal to itself.")
854+            }
855+        else throw("Strict value is not equal to itself.")
856+    }
857+
858+
859+
860+@Callable(w)
861+func transfer (W) = {
862+    let dL = if ((size(W) == i))
863+        then fromBase16String(W)
864+        else throw(((("Address should have " + toString(i)) + " characters, got ") + toString(size(W))))
865+    if ((dL == dL))
866+        then {
867+            let dM = if ((size(w.payments) == 1))
868+                then true
869+                else throw(("Expected one payment as a transfer amount, got " + toString(size(w.payments))))
870+            if ((dM == dM))
871+                then {
872+                    let dN = getStringValue(s)
873+                    let dO = fromBase58String(dN)
874+                    let ag = w.payments[0]
875+                    let dP = {
876+                        let y = ag.assetId
877+                        if ($isInstanceOf(y, "ByteVector"))
878+                            then {
879+                                let dQ = y
880+                                if ((dQ == dO))
881+                                    then true
882+                                    else throw(((("Expected " + dN) + " in the payment, got ") + toBase58String(dQ)))
883+                                }
884+                            else throw((("Expected " + dN) + " in the payment, got Waves"))
885+                        }
886+                    if ((dP == dP))
887+                        then {
888+                            let dR = aC(as)._6
889+                            let ai = (S - dR)
890+                            let dS = if ((160 > ai))
891+                                then af(ag, 1000000, ai)
892+                                else if ((1600 > ai))
893+                                    then af(ag, 10000000, ai)
894+                                    else if ((3200 > ai))
895+                                        then af(ag, 100000000, ai)
896+                                        else if ((6400 > ai))
897+                                            then af(ag, 1000000000, ai)
898+                                            else throw((("Transfers denied for queue size of " + toString(ai)) + ". Wait until current transfers processed"))
899+                            if ((dS == dS))
900+                                then [IntegerEntry(u, (S + 1)), V(S, W, ag.amount), Burn(dO, ag.amount)]
901+                                else throw("Strict value is not equal to itself.")
902+                            }
903+                        else throw("Strict value is not equal to itself.")
904+                    }
905+                else throw("Strict value is not equal to itself.")
906+            }
907+        else throw("Strict value is not equal to itself.")
908+    }
909+
910+
911+
912+@Callable(w)
913+func withdraw (D,dT,dU,X) = {
914+    let dV = aC(D)
915+    let dW = dV._1
916+    let dX = aC(getStringValue(r))._1
917+    let dY = aC(as)._1
918+    if ((dW > dX))
919+        then throw(((("EL block #" + toString(dW)) + " is not finalized. The current finalized is #") + toString(dX)))
920+        else if ((size(dT) != h))
921+            then throw(((("Expected " + toString(h)) + " proofs, got ") + toString(size(dT))))
922+            else if ((0 > dU))
923+                then throw(("Transfer index in block should be nonnegative, got " + toString(dU)))
924+                else if ((0 >= X))
925+                    then throw(("Amount should be positive, got " + toString(X)))
926+                    else {
927+                        let dZ = dV._4
928+                        let ea = (dZ == ap)
929+                        let eb = {
930+                            let y = getInteger(L(dZ))
931+                            if ($isInstanceOf(y, "Int"))
932+                                then {
933+                                    let ec = y
934+                                    (ec > dW)
935+                                    }
936+                                else throw((((D + " is on an alternative chain #") + toString(dZ)) + " that was not approved by majority. Wait for some blocks"))
937+                            }
938+                        if (if (ea)
939+                            then true
940+                            else eb)
941+                            then {
942+                                let ed = w.originCaller
943+                                let ee = take(drop(ed.bytes, 2), f)
944+                                let ef = base58'11111111111111111111111111111111111111111111'
945+                                let eg = toBytes(X)
946+                                let eh = ((ee + take(ef, (size(ef) - size(eg)))) + eg)
947+                                let ei = blake2b256_16Kb(eh)
948+                                let ej = createMerkleRoot(dT, ei, dU)
949+                                let ek = dV._5
950+                                if ((ej == ek))
951+                                    then {
952+                                        let dO = fromBase58String(getStringValue(s))
953+                                        let el = C(D)
954+[Reissue(dO, X, true), ScriptTransfer(ed, X, dO), StringEntry(el, cC(valueOrElse(getString(el), ""), dU))]
955+                                        }
956+                                    else throw((((((("Expected root hash: " + toBase16String(ek)) + ", got: ") + toBase16String(ej)) + ". Event data digest: ") + toBase64String(ei)) + ". Check your withdraw arguments"))
957+                                }
958+                            else throw((("Expected " + D) + " to be either on the main chain or relate to it"))
959+                        }
960+    }
961+
962+
963+
964+@Callable(w)
965+func setup (em,en) = if (ce())
966+    then throw("The contract has been already set up")
967+    else if ((w.originCaller != this))
968+        then throw(("setup() must be invoked by " + toString(this)))
969+        else if ((0 > en))
970+            then throw("The miner reward must be non-negative")
971+            else {
972+                let eo = fromBase16String(em)
973+                let ep = if ((size(eo) == e))
974+                    then true
975+                    else throw("Wrong genesis block hash")
976+                if ((ep == ep))
977+                    then {
978+                        let eq = base58'11111111111111111111111111111111'
979+                        let er = addressFromPublicKey(eq)
980+                        let es = base58'11111111111111111111'
981+                        let et = "0000000000000000000000000000000000000000000000000000000000000000"
982+                        let eu = Issue("UNIT1", "Native token", 0, 8, true)
983+                        let dO = calculateAssetId(eu)
984+                        let ev = aN(em, 0, et, 0, toBase16String(base58''), -1)
985+[ev, StringEntry(G(0), em), an(0, 0, em), IntegerEntry(p, en), StringEntry(E(height), ((toString(er) + ",0,") + em)), StringEntry(r, em), eu, StringEntry(s, toBase58String(dO)), StringEntry(t, "0x0000000000000000000000000000000000006a7e")]
986+                        }
987+                    else throw("Strict value is not equal to itself.")
988+                }
989+
990+
991+
992+@Callable(w)
993+func halt () = {
994+    let ew = split(valueOrErrorMessage(getStringValue(z, "sentinels"), "sentinel list is empty"), d)
995+    if (!(containsElement(ew, toString(w.originCaller))))
996+        then throw((toString(w.originCaller) + " is not a sentinel"))
997+        else [BooleanEntry(A, false)]
998+    }
999+
1000+
1001+@Verifier(ex)
1002+func ey () = {
1003+    let ez = valueOrErrorMessage(getInteger(valueOrErrorMessage(addressFromString(valueOrErrorMessage(getString(z, "contract_voting_result"), "no contract_voting_result")), "invalid contract_voting_result address"), ((("proposal_allow_broadcast_" + toString(this)) + "_") + toBase58String(ex.id))), ("no vote result for transaction " + toBase58String(ex.id)))
1004+    if (if (valueOrElse(getBoolean(z, "op_governance_apply_tx_allowed"), true))
1005+        then true
1006+        else throw("circuit breaker is opened"))
1007+        then (height >= ez)
1008+        else false
1009+    }
1010+
github/deemru/w8io/169f3d6 
52.77 ms ◑