tx · BwvAgnLwfGv1Yh4TMkTRw64tzVy6xoiSXP8ULFM5VKVs

3N18chURfHheNr6SfHREbjehupe9qvNTpNS:  -0.01000000 Waves

2021.07.14 10:51 [1613009] smart account 3N18chURfHheNr6SfHREbjehupe9qvNTpNS > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "BwvAgnLwfGv1Yh4TMkTRw64tzVy6xoiSXP8ULFM5VKVs",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1626249105183,
    "version": 2,
    "chainId": 84,
    "sender": "3N18chURfHheNr6SfHREbjehupe9qvNTpNS",
    "senderPublicKey": "FdZrw5TzNcmvRhW6x2yTcnUG9jjUMubmooBpciUGebrx",
    "proofs": [
        "2HpPAJjSKDusKv1ktGqGScuX9A3Svz2S1YeLgPF4bR9VbFtzRSJhBBWVNvhtDCnhmi2pmHV2CGNHcvUXbExvZ5eY"
    ],
    "script": "base64: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",
    "height": 1613009,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 5 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "1.0.0"
5+
6+let b = "version"
7+
8+let c = "active"
9+
10+let d = "A_asset_id"
11+
12+let e = "B_asset_id"
13+
14+let f = "A_asset_balance"
15+
16+let g = "B_asset_balance"
17+
18+let h = "A_asset_init"
19+
20+let i = "B_asset_init"
21+
22+let j = "share_asset_id"
23+
24+let k = "share_asset_supply"
25+
26+let l = "commission"
27+
28+let m = "commission_scale_delimiter"
29+
30+let n = "shutdown_cause"
31+
32+let o = "first_harvest"
33+
34+let p = "first_harvest_height"
35+
36+let q = "share_limit_on_first_harvest"
37+
38+let r = "base_period"
39+
40+let s = "period_length"
41+
42+let t = "start_height"
43+
44+let u = "first_harvest_height"
45+
46+let v = "admin_pub_1"
47+
48+let w = "admin_pub_2"
49+
50+let x = "admin_pub_3"
51+
52+let y = Address(base58'3N1cPjixuHTujhGvb5HQoFvGt4fkUG8o3KF')
53+
54+func z (A) = {
55+    let B = getString(y, A)
56+    if ($isInstanceOf(B, "String"))
57+        then {
58+            let C = B
59+            fromBase58String(C)
60+            }
61+        else {
62+            let D = B
63+            throw("Admin public key is empty")
64+            }
65+    }
66+
67+
68+let E = z(v)
69+
70+let F = z(w)
71+
72+let G = z(x)
73+
74+let H = base58'Kn7NpzaG12dLZgcHf2ipUftU6hbJygmrhFqQYE4B7ZK'
75+
76+let I = base58'Kn7NpzaG12dLZgcHf2ipUftU6hbJygmrhFqQYE4B7ZK'
77+
78+let J = Address(base58'3NAGTtZz6WpupSN89NZD5rMZwwziZEg4Kx4')
79+
80+let K = Address(base58'3MrJgdL1GniipErHy44YF9idzLaUL2iX5DQ')
81+
82+let L = Address(base58'3N6q7sCGSSLBUXDdjBdYGTJbZGZfhhh8cNg')
83+
84+let M = Address(base58'3N77kfPbQyjXWpDALX3xjKw3iEGMWEctV37')
85+
86+let N = valueOrErrorMessage(getInteger(K, r), "Empty kBasePeriod")
87+
88+let O = valueOrErrorMessage(getInteger(K, t), "Empty kStartHeight")
89+
90+let P = valueOrErrorMessage(getInteger(K, s), "Empty kPeriodLength")
91+
92+let Q = ((N + ((height - O) / P)) + 3)
93+
94+let R = base58'8UrfDVd5GreeUwm7uPk7eYz1eMv376kzR52C6sANPkwS'
95+
96+let S = 270000
97+
98+let T = getBooleanValue(this, c)
99+
100+let U = getStringValue(this, d)
101+
102+let V = getStringValue(this, e)
103+
104+let W = if ((U == "WAVES"))
105+    then unit
106+    else fromBase58String(U)
107+
108+let X = if ((V == "WAVES"))
109+    then unit
110+    else fromBase58String(V)
111+
112+let Y = {
113+    let B = W
114+    if ($isInstanceOf(B, "ByteVector"))
115+        then {
116+            let Z = B
117+            value(assetInfo(Z)).name
118+            }
119+        else if ($isInstanceOf(B, "Unit"))
120+            then {
121+                let aa = B
122+                "WAVES"
123+                }
124+            else throw("Match error")
125+    }
126+
127+let ab = {
128+    let B = X
129+    if ($isInstanceOf(B, "ByteVector"))
130+        then {
131+            let Z = B
132+            value(assetInfo(Z)).name
133+            }
134+        else if ($isInstanceOf(B, "Unit"))
135+            then {
136+                let aa = B
137+                "WAVES"
138+                }
139+            else throw("Match error")
140+    }
141+
142+let ac = getIntegerValue(this, f)
143+
144+let ad = getIntegerValue(this, g)
145+
146+let ae = fromBase58String(getStringValue(this, j))
147+
148+let af = getIntegerValue(this, k)
149+
150+let ag = 3000
151+
152+let ah = 1200
153+
154+let ai = 1000000
155+
156+let aj = 1000
157+
158+let ak = 100000000
159+
160+let al = 1000
161+
162+let am = 8
163+
164+func an (ao) = {
165+    let B = ao
166+    if ($isInstanceOf(B, "ByteVector"))
167+        then {
168+            let Z = B
169+            assetBalance(this, Z)
170+            }
171+        else if ($isInstanceOf(B, "Unit"))
172+            then {
173+                let aa = B
174+                wavesBalance(this).available
175+                }
176+            else throw("Match error")
177+    }
178+
179+
180+let ap = {
181+    let B = getInteger(L, ((("rpd_balance_" + toBase58String(R)) + "_") + toString(this)))
182+    if ($isInstanceOf(B, "Int"))
183+        then {
184+            let aq = B
185+            aq
186+            }
187+        else if ($isInstanceOf(B, "Unit"))
188+            then {
189+                let D = B
190+                0
191+                }
192+            else throw("Match error")
193+    }
194+
195+let ar = getIntegerValue(this, h)
196+
197+let as = getIntegerValue(this, i)
198+
199+let at = (ac - (if ((W == R))
200+    then ap
201+    else 0))
202+
203+let au = (ad - (if ((X == R))
204+    then ap
205+    else 0))
206+
207+let av = (an(W) + (if ((W == R))
208+    then ap
209+    else 0))
210+
211+let aw = (an(X) + (if ((X == R))
212+    then ap
213+    else 0))
214+
215+let ax = if ((av >= ac))
216+    then (aw >= ad)
217+    else false
218+
219+func ay (ao) = {
220+    let B = ao
221+    if ($isInstanceOf(B, "ByteVector"))
222+        then {
223+            let Z = B
224+            let az = toBase58String(Z)
225+            let aA = valueOrErrorMessage(assetInfo(Z), (("Asset " + az) + " doesn't exist"))
226+            $Tuple3(az, aA.name, aA.decimals)
227+            }
228+        else if ($isInstanceOf(B, "Unit"))
229+            then {
230+                let aa = B
231+                $Tuple3("WAVES", "WAVES", 8)
232+                }
233+            else throw("Match error")
234+    }
235+
236+
237+func aB (aC) = if ((aC == "WAVES"))
238+    then $Tuple3("WAVES", "WAVES", 8)
239+    else {
240+        let az = aC
241+        let Z = fromBase58String(aC)
242+        let aA = valueOrErrorMessage(assetInfo(Z), (("Asset " + az) + " doesn't exist"))
243+        $Tuple3(az, aA.name, aA.decimals)
244+        }
245+
246+
247+func aD (aE) = [BooleanEntry(c, false), StringEntry(n, aE)]
248+
249+
250+func aF (aG,ao) = if ((ao == R))
251+    then {
252+        let aH = (aG - S)
253+        if ((0 >= aH))
254+            then throw((((("Insufficient amount " + toString(aG)) + " to deduct staking fee ") + toString(S)) + " USD-N"))
255+            else aH
256+        }
257+    else aG
258+
259+
260+func aI (aG,aJ,aK) = throw((((((((("Insufficient DApp balance to pay " + toString(aG)) + " ") + aK) + " due to staking. Available: ") + toString(aJ)) + " ") + aK) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
261+
262+
263+func aL (aM,aN) = throw((((((((((((((((("Insufficient DApp balance to pay " + toString(aM)) + " ") + Y) + " and ") + toString(aN)) + " ") + ab) + " due to staking. Available: ") + toString(at)) + " ") + Y) + " and ") + toString(au)) + " ") + ab) + ". Please contact support in Telegram: https://t.me/swopfisupport"))
264+
265+
266+func aO () = aD(((((((((((((((("Suspicious state. Actual balances: " + toString(av)) + " ") + Y) + ", ") + toString(aw)) + " ") + ab) + ". State: ") + toString(ac)) + " ") + Y) + ", ") + toString(ad)) + " ") + ab))
267+
268+
269+@Callable(aP)
270+func init (aQ) = {
271+    let aR = $Tuple2(aP.payments[0].amount, aP.payments[0].assetId)
272+    let aS = aR._1
273+    let aT = aR._2
274+    let aU = $Tuple2(aP.payments[1].amount, aP.payments[1].assetId)
275+    let aV = aU._1
276+    let aW = aU._2
277+    let aX = ay(aT)
278+    let aY = aX._1
279+    let aZ = aX._2
280+    let ba = aX._3
281+    let bb = ay(aW)
282+    let bc = bb._1
283+    let bd = bb._2
284+    let be = bb._3
285+    if (!(containsElement([E, F, G, I], aP.callerPublicKey)))
286+        then throw("Only admin can call this function")
287+        else if (isDefined(getBoolean(this, c)))
288+            then throw("DApp is already active")
289+            else if ((aT == aW))
290+                then throw("Assets must be different")
291+                else {
292+                    let bf = ((("s" + take(aZ, 7)) + "_") + take(bd, 7))
293+                    let bg = ((((("ShareToken of SwopFi protocol for " + aZ) + " and ") + bd) + " at address ") + toString(this))
294+                    let bh = ((ba + be) / 2)
295+                    let bi = fraction(pow(aS, ba, 5, 1, ba, DOWN), pow(aV, be, 5, 1, be, DOWN), pow(10, 0, bh, 0, 0, DOWN))
296+                    let bj = Issue(bf, bg, bi, bh, true)
297+                    let bk = calculateAssetId(bj)
298+                    let bl = [StringEntry(b, a), BooleanEntry(c, true), StringEntry(d, aY), StringEntry(e, bc), IntegerEntry(f, aS), IntegerEntry(g, aV), IntegerEntry(l, ag), IntegerEntry(m, ai), bj, StringEntry(j, toBase58String(bk)), IntegerEntry(k, bi), ScriptTransfer(aP.caller, bi, bk)]
299+                    if (aQ)
300+                        then (bl ++ [BooleanEntry(o, aQ), IntegerEntry(p, (O + (Q * P)))])
301+                        else bl
302+                    }
303+    }
304+
305+
306+
307+@Callable(aP)
308+func initWithInitRatio (bm,bn,U,V,aQ) = {
309+    let bo = aB(U)
310+    let aY = bo._1
311+    let aZ = bo._2
312+    let ba = bo._3
313+    let bp = aB(V)
314+    let bc = bp._1
315+    let bd = bp._2
316+    let be = bp._3
317+    if (!(containsElement([E, F, G, I], aP.callerPublicKey)))
318+        then throw("Only admin can call this function")
319+        else if (isDefined(getBoolean(this, c)))
320+            then throw("DApp is already active")
321+            else if ((U == V))
322+                then throw("Assets must be different")
323+                else {
324+                    let bf = ((("s" + take(aZ, 7)) + "_") + take(bd, 7))
325+                    let bg = ((((("ShareToken of SwopFi protocol for " + aZ) + " and ") + bd) + " at address ") + toString(this))
326+                    let bh = ((ba + be) / 2)
327+                    let bi = 0
328+                    let bj = Issue(bf, bg, bi, bh, true)
329+                    let bk = calculateAssetId(bj)
330+                    let bl = [StringEntry(b, a), BooleanEntry(c, true), StringEntry(d, aY), StringEntry(e, bc), IntegerEntry(h, bm), IntegerEntry(i, bn), IntegerEntry(f, 0), IntegerEntry(g, 0), IntegerEntry(l, ag), IntegerEntry(m, ai), bj, StringEntry(j, toBase58String(bk)), IntegerEntry(k, bi)]
331+                    if (aQ)
332+                        then (bl ++ [BooleanEntry(o, aQ), IntegerEntry(p, (O + (Q * P)))])
333+                        else bl
334+                    }
335+    }
336+
337+
338+
339+@Callable(aP)
340+func keepLimitForFirstHarvest (bq) = if (!(T))
341+    then throw("DApp is inactive at this moment")
342+    else if (!(containsElement([E, F, G, I], aP.callerPublicKey)))
343+        then throw("Only admin can call this function")
344+        else [IntegerEntry(q, bq)]
345+
346+
347+
348+@Callable(aP)
349+func replenishWithTwoTokens (br) = {
350+    let aT = aP.payments[0].assetId
351+    let aW = aP.payments[1].assetId
352+    let aS = aF(aP.payments[0].amount, aT)
353+    let aV = aF(aP.payments[1].amount, aW)
354+    if (if ((ac == 0))
355+        then (ad == 0)
356+        else false)
357+        then {
358+            let bs = ay(aT)
359+            let aY = bs._1
360+            let aZ = bs._2
361+            let ba = bs._3
362+            let bt = ay(aW)
363+            let bc = bt._1
364+            let bd = bt._2
365+            let be = bt._3
366+            let bu = fraction(fraction(ar, ak, aS), aj, fraction(as, ak, aV))
367+            if ((aT == aW))
368+                then throw("Assets must be different")
369+                else {
370+                    let bh = ((ba + be) / 2)
371+                    let bi = fraction(pow(aS, ba, 5, 1, ba, DOWN), pow(aV, be, 5, 1, be, DOWN), pow(10, 0, bh, 0, 0, DOWN))
372+                    if (!(T))
373+                        then throw("DApp is inactive at this moment")
374+                        else if (if ((0 > br))
375+                            then true
376+                            else (br > al))
377+                            then throw(((("Slippage tolerance must be between 0 and " + toString(al)) + " inclusively. Actual: ") + toString(br)))
378+                            else if ((size(aP.payments) != 2))
379+                                then throw("Two attached assets expected")
380+                                else if (if ((((aj * (al - br)) / al) > bu))
381+                                    then true
382+                                    else (bu > ((aj * (al + br)) / al)))
383+                                    then throw("Incorrect assets amount: amounts must have the contract ratio")
384+                                    else if (if ((aT != W))
385+                                        then true
386+                                        else (aW != X))
387+                                        then throw(((("Incorrect assets attached. Expected: " + U) + " and ") + V))
388+                                        else if ((bi == 0))
389+                                            then throw("Too small amount to replenish")
390+                                            else if (!(ax))
391+                                                then ([ScriptTransfer(aP.caller, aS, aT), ScriptTransfer(aP.caller, aV, aW)] ++ aO())
392+                                                else [Reissue(ae, bi, true), IntegerEntry(f, aS), IntegerEntry(g, aV), IntegerEntry(k, bi), ScriptTransfer(aP.caller, bi, ae)]
393+                    }
394+            }
395+        else {
396+            let bu = fraction(fraction(ac, ak, aS), aj, fraction(ad, ak, aV))
397+            let bv = fraction(aS, ak, ac)
398+            let bw = fraction(aV, ak, ad)
399+            let bx = fraction(min([bv, bw]), af, ak)
400+            if (!(T))
401+                then throw("DApp is inactive at this moment")
402+                else if (if ((0 > br))
403+                    then true
404+                    else (br > al))
405+                    then throw(((("Slippage tolerance must be between 0 and " + toString(al)) + " inclusively. Actual: ") + toString(br)))
406+                    else if ((size(aP.payments) != 2))
407+                        then throw("Two attached assets expected")
408+                        else if (if ((aT != W))
409+                            then true
410+                            else (aW != X))
411+                            then throw(((("Incorrect assets attached. Expected: " + U) + " and ") + V))
412+                            else if (if ((((aj * (al - br)) / al) > bu))
413+                                then true
414+                                else (bu > ((aj * (al + br)) / al)))
415+                                then throw("Incorrect assets amount: amounts must have the contract ratio")
416+                                else if ((bx == 0))
417+                                    then throw("Too small amount to replenish")
418+                                    else if (!(ax))
419+                                        then ([ScriptTransfer(aP.caller, aS, aT), ScriptTransfer(aP.caller, aV, aW)] ++ aO())
420+                                        else [IntegerEntry(f, (ac + aS)), IntegerEntry(g, (ad + aV)), IntegerEntry(k, (af + bx)), Reissue(ae, bx, true), ScriptTransfer(aP.caller, bx, ae)]
421+            }
422+    }
423+
424+
425+
426+@Callable(aP)
427+func withdraw () = {
428+    let by = $Tuple2(aP.payments[0].amount, aP.payments[0].assetId)
429+    let bz = by._1
430+    let bA = by._2
431+    let bB = aF(fraction(bz, ac, af), W)
432+    let bC = aF(fraction(bz, ad, af), X)
433+    if (!(T))
434+        then throw("DApp is inactive at this moment")
435+        else if ((size(aP.payments) != 1))
436+            then throw("One attached payment expected")
437+            else if ((bA != ae))
438+                then throw(("Incorrect asset attached. Expected: " + toBase58String(ae)))
439+                else if (!(ax))
440+                    then ([ScriptTransfer(aP.caller, bz, bA)] ++ aO())
441+                    else if (if ((bB > at))
442+                        then true
443+                        else (bC > au))
444+                        then aL(bB, bC)
445+                        else [IntegerEntry(f, (ac - bB)), IntegerEntry(g, (ad - bC)), IntegerEntry(k, (af - bz)), Burn(ae, bz), ScriptTransfer(aP.caller, bB, W), ScriptTransfer(aP.caller, bC, X)]
446+    }
447+
448+
449+
450+@Callable(aP)
451+func exchange (bD) = {
452+    let bE = $Tuple2(aP.payments[0].amount, aP.payments[0].assetId)
453+    let bz = bE._1
454+    let bA = bE._2
455+    func bF (bG,bH) =     {
456+        let bI = fraction(bH, bz, (bz + bG))
457+        let bJ = fraction(bI, (ai - ag), ai)
458+        let bK = fraction(bI, ah, ai)
459+        if ((bD > bJ))
460+            then throw(((("Calculated amount to receive " + toString(bJ)) + " is less than specified minimum ") + toString(bD)))
461+            else $Tuple3(bI, bJ, bK)
462+        }
463+
464+    if (!(T))
465+        then throw("DApp is inactive at this moment")
466+        else if (if ((ac == 0))
467+            then true
468+            else (ad == 0))
469+            then throw("Can't exchange with zero balance")
470+            else if ((0 >= bD))
471+                then throw(("Minimal amount to receive must be positive. Actual: " + toString(bD)))
472+                else if ((size(aP.payments) != 1))
473+                    then throw("One attached payment expected")
474+                    else if (!(ax))
475+                        then ([ScriptTransfer(aP.caller, bz, bA)] ++ aO())
476+                        else if ((bA == W))
477+                            then {
478+                                let bL = X
479+                                let bM = bF(ac, ad)
480+                                let bI = bM._1
481+                                let bJ = bM._2
482+                                let bK = bM._3
483+                                let bN = (ac + bz)
484+                                let bO = ((ad - bJ) - bK)
485+                                if (if (if ((W == R))
486+                                    then (ap >= bN)
487+                                    else false)
488+                                    then true
489+                                    else if ((X == R))
490+                                        then (ap >= bO)
491+                                        else false)
492+                                    then aI(bJ, au, ab)
493+                                    else [IntegerEntry(f, bN), IntegerEntry(g, bO), ScriptTransfer(aP.caller, bJ, bL), ScriptTransfer(J, bK, bL)]
494+                                }
495+                            else if ((bA == X))
496+                                then {
497+                                    let bL = W
498+                                    let bP = bF(ad, ac)
499+                                    let bI = bP._1
500+                                    let bJ = bP._2
501+                                    let bK = bP._3
502+                                    let bN = ((ac - bJ) - bK)
503+                                    let bO = (ad + bz)
504+                                    if (if (if ((W == R))
505+                                        then (ap >= bN)
506+                                        else false)
507+                                        then true
508+                                        else if ((X == R))
509+                                            then (ap >= bO)
510+                                            else false)
511+                                        then aI(bJ, at, Y)
512+                                        else [IntegerEntry(f, bN), IntegerEntry(g, bO), ScriptTransfer(aP.caller, bJ, bL), ScriptTransfer(J, bK, bL)]
513+                                    }
514+                                else throw(((("Incorrect asset attached. Expected: " + U) + " or ") + V))
515+    }
516+
517+
518+
519+@Callable(aP)
520+func shutdown () = if (!(T))
521+    then throw(("DApp is already suspended. Cause: " + valueOrElse(getString(this, n), "the cause wasn't specified")))
522+    else if (!(containsElement([E, F, G, H], aP.callerPublicKey)))
523+        then throw("Only admin can call this function")
524+        else aD("Paused by admin")
525+
526+
527+
528+@Callable(aP)
529+func activate () = if (T)
530+    then throw("DApp is already active")
531+    else if (!(containsElement([E, F, G, H], aP.callerPublicKey)))
532+        then throw("Only admin can call this function")
533+        else [BooleanEntry(c, true), DeleteEntry(n)]
534+
535+
536+
537+@Callable(aP)
538+func takeIntoAccountExtraFunds (bQ) = {
539+    let bR = (av - ac)
540+    let bS = (aw - ad)
541+    let bT = (bR - (if ((W == unit))
542+        then bQ
543+        else 0))
544+    let bU = (bS - (if ((X == unit))
545+        then bQ
546+        else 0))
547+    if (!(T))
548+        then throw("DApp is inactive at this moment")
549+        else if ((aP.caller != this))
550+            then throw("Only the DApp itself can call this function")
551+            else if ((0 > bQ))
552+                then throw(("Argument 'amountLeave' cannot be negative. Actual: " + toString(bQ)))
553+                else if (if ((0 > bR))
554+                    then true
555+                    else (0 > bS))
556+                    then aD("Enroll amount negative")
557+                    else if (if ((0 > bT))
558+                        then true
559+                        else (0 > bU))
560+                        then throw("Too large amountLeave")
561+                        else [IntegerEntry(f, (ac + bT)), IntegerEntry(g, (ad + bU)), IntegerEntry(("last_income_" + U), bT), IntegerEntry(("last_income_" + V), bU)]
562+    }
563+
564+
565+@Verifier(bV)
566+func bW () = {
567+    let B = bV
568+    if ($isInstanceOf(B, "InvokeScriptTransaction"))
569+        then {
570+            let bX = B
571+            let bY = if ((bX.dApp == this))
572+                then (bX.function == "takeIntoAccountExtraFunds")
573+                else false
574+            let bZ = if ((bX.dApp == L))
575+                then if (if (if ((bX.function == "lockNeutrino"))
576+                    then (size(bX.payments) == 1)
577+                    else false)
578+                    then (bX.payments[0].assetId == R)
579+                    else false)
580+                    then true
581+                    else if ((bX.function == "unlockNeutrino"))
582+                        then (size(bX.payments) == 0)
583+                        else false
584+                else false
585+            let ca = if (if (if ((bX.dApp == M))
586+                then (bX.function == "exchange")
587+                else false)
588+                then (W == R)
589+                else false)
590+                then true
591+                else if ((X == R))
592+                    then (bX.payments[0].assetId == R)
593+                    else false
594+            let cb = if (if (if (sigVerify(bV.bodyBytes, bV.proofs[0], E))
595+                then true
596+                else sigVerify(bV.bodyBytes, bV.proofs[0], F))
597+                then true
598+                else sigVerify(bV.bodyBytes, bV.proofs[0], G))
599+                then true
600+                else sigVerify(bV.bodyBytes, bV.proofs[0], I)
601+            if (if (if (bY)
602+                then true
603+                else bZ)
604+                then true
605+                else ca)
606+                then cb
607+                else false
608+            }
609+        else {
610+            let cc = if (sigVerify(bV.bodyBytes, bV.proofs[0], E))
611+                then 1
612+                else 0
613+            let cd = if (sigVerify(bV.bodyBytes, bV.proofs[1], F))
614+                then 1
615+                else 0
616+            let ce = if (sigVerify(bV.bodyBytes, bV.proofs[2], G))
617+                then 1
618+                else 0
619+            (((cc + cd) + ce) >= 2)
620+            }
621+    }
622+
github/deemru/w8io/026f985 
32.08 ms ◑