tx · GfwCVHcqSonWqAw5iAhtpRQLAuWt55D6N7n6uH6jeFPK

3Mp4WatZzHNtYW4JAm5vvtRCmnkKmqbFFsF:  -0.03200000 Waves

2022.05.23 11:56 [2064122] smart account 3Mp4WatZzHNtYW4JAm5vvtRCmnkKmqbFFsF > SELF 0.00000000 Waves

{ "type": 13, "id": "GfwCVHcqSonWqAw5iAhtpRQLAuWt55D6N7n6uH6jeFPK", "fee": 3200000, "feeAssetId": null, "timestamp": 1653296264658, "version": 2, "chainId": 84, "sender": "3Mp4WatZzHNtYW4JAm5vvtRCmnkKmqbFFsF", "senderPublicKey": "3Ct61ciyTWAurVnqkawNteS6Kg2wdGLyvPDRZGPagYni", "proofs": [ "27DkaogRuXn56hH1C4tdhSNZE8mxvPr4kfsXxixupyNvyk1tTb9USZASQWt5APLmmLUn3UksZEYrt4crrM2CagGu" ], "script": "base64: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", "height": 2064122, "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 = "price"
5+
6+let b = "k_balance"
7+
8+let c = "k_positionSize"
9+
10+let d = "k_positionMargin"
11+
12+let e = "k_pon"
13+
14+let f = "k_positionFraction"
15+
16+let g = "k_initialized"
17+
18+let h = "k_fee"
19+
20+let i = "k_fundingPeriod"
21+
22+let j = "k_initMarginRatio"
23+
24+let k = "k_mmr"
25+
26+let l = "k_liquidationFeeRatio"
27+
28+let m = "k_insurance"
29+
30+let n = "k_latestPremiumFraction"
31+
32+let o = "k_nextFundingBlockMinTimestamp"
33+
34+let p = "k_fundingRate"
35+
36+let q = "k_qtAstR"
37+
38+let r = "k_bsAstR"
39+
40+let s = "k_baseAssetDelta"
41+
42+let t = "k_totalPositionSize"
43+
44+let u = "k_cumulativeNotional"
45+
46+let v = "k_openInteresetNotional"
47+
48+let w = Address(base58'3N4RABjANLWJyQAf8kvxUZk82UALxFbR9FM')
49+
50+let x = base58'A6ZtwikNTr19YpC1t6HnNGCBJF6GTx62DhEkJpgpzpmL'
51+
52+let y = base58'HezsdQuRDtzksAYUy97gfhKy7Z1NW2uXYSHA3bgqenNZ'
53+
54+let z = Address(base58'3N9LkJahTMx41wGhSxLS42prCZtRCp4dhTs')
55+
56+let A = Address(base58'3N4NS7d4Jo9a6F14LiFUKKYVdUkkf2eP4Zx')
57+
58+let B = Address(base58'3MseEJNEHkYhvcHre6Mann1F8e27S1qptdg')
59+
60+let C = 1
61+
62+let D = 2
63+
64+let E = 60
65+
66+let F = 1000
67+
68+let G = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
69+
70+let H = (86400 * G)
71+
72+func I (J,K) = fraction(J, G, K, HALFEVEN)
73+
74+
75+func L (J,K) = fraction(J, K, G, HALFEVEN)
76+
77+
78+func M (J) = if ((J > 0))
79+ then J
80+ else -(J)
81+
82+
83+func N (O,P) = ((O + "_") + P)
84+
85+
86+func Q (R,S,T) = {
87+ let U = (R - S)
88+ if (if (T)
89+ then (0 > U)
90+ else false)
91+ then throw("Invalid margin")
92+ else if (if (!(T))
93+ then (U >= 0)
94+ else false)
95+ then throw("Invalid margin")
96+ else true
97+ }
98+
99+
100+func V (W) = valueOrErrorMessage(getInteger(this, W), ("no value for " + W))
101+
102+
103+func X () = V(b)
104+
105+
106+func Y () = V(m)
107+
108+
109+func Z () = V(h)
110+
111+
112+func aa () = V(j)
113+
114+
115+func ab () = V(q)
116+
117+
118+func ac () = V(r)
119+
120+
121+func ad () = V(s)
122+
123+
124+func ae () = V(t)
125+
126+
127+func af () = V(u)
128+
129+
130+func ag () = V(n)
131+
132+
133+func ah () = V(v)
134+
135+
136+func ai () = V(o)
137+
138+
139+func aj () = V(i)
140+
141+
142+func ak () = (aj() * G)
143+
144+
145+func al () = (aj() * F)
146+
147+
148+func am () = V(k)
149+
150+
151+func an () = V(l)
152+
153+
154+func ao (ap) = {
155+ let aq = getInteger(this, N(c, ap))
156+ let ar = aq
157+ if ($isInstanceOf(ar, "Int"))
158+ then {
159+ let as = ar
160+ $Tuple4(as, getIntegerValue(this, N(d, ap)), getIntegerValue(this, N(e, ap)), getIntegerValue(this, N(f, ap)))
161+ }
162+ else $Tuple4(0, 0, 0, 0)
163+ }
164+
165+
166+func at (au) = {
167+ let av = ao(au)
168+ let as = av._1
169+ let aw = av._2
170+ let ax = av._3
171+ let ay = av._4
172+ if ((as == 0))
173+ then throw("No open position")
174+ else true
175+ }
176+
177+
178+func az () = valueOrElse(getBoolean(this, g), false)
179+
180+
181+func aA (aB,aC,aD) = if (aB)
182+ then $Tuple5((ab() + aC), (ac() - aD), (ad() - aD), (ae() + aD), (af() + aC))
183+ else $Tuple5((ab() - aC), (ac() + aD), (ad() + aD), (ae() - aD), (af() - aC))
184+
185+
186+func aE (aB,aF) = {
187+ let aG = ab()
188+ let aH = ac()
189+ let W = L(aG, aH)
190+ let aI = if (aB)
191+ then (aG + aF)
192+ else (aG - aF)
193+ let aJ = I(W, aI)
194+ let aK = M((aJ - aH))
195+ let aL = if (aB)
196+ then aK
197+ else -(aK)
198+ let aM = aA(aB, aF, aK)
199+ let aN = aM._1
200+ let aO = aM._2
201+ let aP = aM._3
202+ let aQ = aM._4
203+ let aR = aM._5
204+ $Tuple6(aL, aN, aO, aP, aQ, aR)
205+ }
206+
207+
208+func aS (aT,aU,aV,aW) = {
209+ let aX = ag()
210+ let aY = if ((aT != 0))
211+ then L((aX - aV), aT)
212+ else 0
213+ let aZ = ((aW - aY) + aU)
214+ let ba = if ((0 > aZ))
215+ then $Tuple2(0, M(aZ))
216+ else $Tuple2(M(aZ), 0)
217+ let bb = ba._1
218+ let bc = ba._2
219+ $Tuple4(bb, bc, aY, aX)
220+ }
221+
222+
223+func bd (be,aD,bf,bg) = if ((aD == 0))
224+ then throw("Invalid base asset amount")
225+ else {
226+ let W = L(bf, bg)
227+ let bh = if (be)
228+ then (bg + aD)
229+ else (bg - aD)
230+ let bi = I(W, bh)
231+ let bj = M((bi - bf))
232+ let bk = aA(!(be), bj, aD)
233+ let aN = bk._1
234+ let aO = bk._2
235+ let aP = bk._3
236+ let aQ = bk._4
237+ let aR = bk._5
238+ $Tuple6(bj, aN, aO, aP, aQ, aR)
239+ }
240+
241+
242+func bl (au) = {
243+ let bm = ao(au)
244+ let as = bm._1
245+ let aw = bm._2
246+ let ax = bm._3
247+ let ay = bm._4
248+ let bn = M(as)
249+ if ((bn == 0))
250+ then throw("Invalid position size")
251+ else {
252+ let bo = (0 > as)
253+ let bp = bd(!(bo), bn, ab(), ac())
254+ let bq = bp._1
255+ let br = bp._2
256+ let bs = bp._3
257+ let bt = bp._4
258+ let bu = if (bo)
259+ then (ax - bq)
260+ else (bq - ax)
261+ $Tuple2(bq, bu)
262+ }
263+ }
264+
265+
266+func bv () = getIntegerValue(A, a)
267+
268+
269+func bw () = I(ab(), ac())
270+
271+
272+func bx (au) = {
273+ let by = ao(au)
274+ let as = by._1
275+ let aw = by._2
276+ let ax = by._3
277+ let ay = by._4
278+ let bz = bl(au)
279+ let bq = bz._1
280+ let bu = bz._2
281+ let bA = aS(as, aw, ay, bu)
282+ let bb = bA._1
283+ let bc = bA._2
284+ I((bb - bc), bq)
285+ }
286+
287+
288+func bB (au) = {
289+ let bC = ao(au)
290+ let as = bC._1
291+ let aw = bC._2
292+ let ax = bC._3
293+ let ay = bC._4
294+ let bD = bl(au)
295+ let br = bD._1
296+ let bu = bD._2
297+ let bE = aS(as, aw, ay, bu)
298+ let bb = bE._1
299+ let bc = bE._2
300+ let bs = bE._3
301+ let bF = -(as)
302+ let bG = bu
303+ let bH = -(bb)
304+ let bI = bd((as > 0), M(as), ab(), ac())
305+ let bJ = bI._1
306+ let bK = bI._2
307+ let aJ = bI._3
308+ let bL = bI._4
309+ let bM = bI._5
310+ let bN = bI._6
311+ let bO = (ah() - ax)
312+ $Tuple11(bF, bc, bG, bH, bK, aJ, bL, bM, bN, bO, bJ)
313+ }
314+
315+
316+func bP (bQ,bR,bS,bT,bU) = [IntegerEntry(j, bQ), IntegerEntry(k, bR), IntegerEntry(l, bS), IntegerEntry(i, bT), IntegerEntry(h, bU)]
317+
318+
319+func bV (bW,bX,aX,bY) = [IntegerEntry(s, bW), IntegerEntry(o, bX), IntegerEntry(n, aX), IntegerEntry(p, bY)]
320+
321+
322+func bZ (P,ca,cb,cc,cd) = [IntegerEntry(N(c, P), ca), IntegerEntry(N(d, P), cb), IntegerEntry(N(e, P), cc), IntegerEntry(N(f, P), cd)]
323+
324+
325+func ce (aG,aH,cf,cg,ch,ci) = [IntegerEntry(q, aG), IntegerEntry(r, aH), IntegerEntry(s, cf), IntegerEntry(t, cg), IntegerEntry(u, ch), IntegerEntry(v, ci)]
326+
327+
328+func cj (P) = [DeleteEntry(N(c, P)), DeleteEntry(N(d, P)), DeleteEntry(N(e, P)), DeleteEntry(N(f, P))]
329+
330+
331+func ck (P,cl) = {
332+ let cm = assetBalance(this, y)
333+ if ((cl > cm))
334+ then throw(((("Unable to withdraw " + toString(cl)) + " from contract balance ") + toString(cm)))
335+ else [ScriptTransfer(P, cl, y)]
336+ }
337+
338+
339+func cn () = [StringEntry("ADMIN_ADDRESS", toString(w)), StringEntry("USDN", toBase58String(y)), StringEntry("USDN_STAKING", toString(z)), StringEntry("ORACLE", toString(A))]
340+
341+
342+func co (cp) = [IntegerEntry(m, cp)]
343+
344+
345+func cq (cp) = if ((0 > cp))
346+ then throw("Balance")
347+ else [IntegerEntry(b, cp)]
348+
349+
350+func cr (cp) = [ScriptTransfer(B, cp, y)]
351+
352+
353+@Callable(cp)
354+func initialize (aG,aH,bT,bQ,bR,bS,bU) = if (if (if (if (if (if (if (if ((0 >= aG))
355+ then true
356+ else (0 >= aH))
357+ then true
358+ else (0 >= bT))
359+ then true
360+ else (0 >= bQ))
361+ then true
362+ else (0 >= bR))
363+ then true
364+ else (0 >= bS))
365+ then true
366+ else (cp.caller != w))
367+ then true
368+ else az())
369+ then throw("Invalid initialize parameters")
370+ else ((((((ce(aG, aH, 0, 0, 0, 0) ++ bP(bQ, bR, bS, bT, bU)) ++ bV(0, (lastBlock.timestamp + bT), 0, 0)) ++ co(0)) ++ cq(0)) ++ cn()) ++ [BooleanEntry(g, true)])
371+
372+
373+
374+@Callable(cp)
375+func decreasePosition (cs,cl,ct,cu) = if (if (if (if (if (if ((cs != C))
376+ then (cs != D)
377+ else false)
378+ then true
379+ else (0 >= cl))
380+ then true
381+ else if (((1 * G) > ct))
382+ then true
383+ else (ct > (3 * G)))
384+ then true
385+ else !(az()))
386+ then true
387+ else !(Q(I(G, ct), aa(), true)))
388+ then throw("Invalid decreasePosition parameters")
389+ else {
390+ let cv = ao(toString(cp.caller))
391+ let cw = cv._1
392+ let cx = cv._2
393+ let cy = cv._3
394+ let cz = cv._4
395+ let cA = (cw == 0)
396+ let cB = if ((cw > 0))
397+ then (cs == C)
398+ else (cs == D)
399+ let cC = if (!(cA))
400+ then cB
401+ else false
402+ let cD = (cs == C)
403+ let cE = if (if (cA)
404+ then true
405+ else cC)
406+ then throw("Use increasePosition to open new or increase position")
407+ else {
408+ let cF = L(cl, ct)
409+ let cG = bl(toString(cp.caller))
410+ let cH = cG._1
411+ let bu = cG._2
412+ if ((cH > cF))
413+ then {
414+ let cI = aE(cD, cF)
415+ let bF = cI._1
416+ let aI = cI._2
417+ let aJ = cI._3
418+ let bL = cI._4
419+ let bM = cI._5
420+ let bN = cI._6
421+ let cJ = M(bF)
422+ if (if ((cu != 0))
423+ then (cu > cJ)
424+ else false)
425+ then throw(((("Too little basse asset exchanged, got " + toString(cJ)) + " expected ") + toString(cu)))
426+ else {
427+ let bG = if ((cw != 0))
428+ then I(L(bu, cJ), cw)
429+ else 0
430+ let cK = aS(cw, cx, cz, bG)
431+ let bb = cK._1
432+ let bc = cK._2
433+ let aY = cK._3
434+ let cL = cK._4
435+ let bJ = cF
436+ let cM = (bu - bG)
437+ let cN = if ((cw > 0))
438+ then ((cH - bJ) - cM)
439+ else ((cM + cH) - bJ)
440+ $Tuple10((cw + bF), bb, M(cN), cL, aJ, aI, bL, bM, bN, (ah() - cF))
441+ }
442+ }
443+ else throw("Close position first")
444+ }
445+ let cO = cE._1
446+ let cP = cE._2
447+ let cQ = cE._3
448+ let cR = cE._4
449+ let aJ = cE._5
450+ let aI = cE._6
451+ let bL = cE._7
452+ let bM = cE._8
453+ let bN = cE._9
454+ let bO = cE._10
455+ (bZ(toString(cp.caller), cO, cP, cQ, cR) ++ ce(aI, aJ, bL, bM, bN, bO))
456+ }
457+
458+
459+
460+@Callable(cp)
461+func increasePosition (cs,ct,cu) = {
462+ let cS = cp.payments[0].amount
463+ if (if (if (if (if (if (if ((cs != C))
464+ then (cs != D)
465+ else false)
466+ then true
467+ else (0 >= cS))
468+ then true
469+ else if (((1 * G) > ct))
470+ then true
471+ else (ct > (3 * G)))
472+ then true
473+ else !(az()))
474+ then true
475+ else (cp.payments[0].assetId != y))
476+ then true
477+ else !(Q(I(G, ct), aa(), true)))
478+ then throw("Invalid increasePosition parameters")
479+ else {
480+ let cT = L(cS, Z())
481+ let cl = (cS - cT)
482+ let cU = ao(toString(cp.caller))
483+ let cw = cU._1
484+ let cx = cU._2
485+ let cy = cU._3
486+ let cz = cU._4
487+ let cA = (cw == 0)
488+ let cB = if ((cw > 0))
489+ then (cs == C)
490+ else (cs == D)
491+ let cC = if (!(cA))
492+ then cB
493+ else false
494+ let cD = (cs == C)
495+ let cV = if (if (cA)
496+ then true
497+ else cC)
498+ then {
499+ let cF = L(cl, ct)
500+ let cW = aE(cD, cF)
501+ let aL = cW._1
502+ let aI = cW._2
503+ let aJ = cW._3
504+ let bL = cW._4
505+ let bM = cW._5
506+ let bN = cW._6
507+ if (if ((cu != 0))
508+ then (cu > M(aL))
509+ else false)
510+ then throw(((("Limit error: " + toString(M(aL))) + " < ") + toString(cu)))
511+ else {
512+ let cO = (cw + aL)
513+ let cX = I(cF, ct)
514+ let cY = aS(cw, cx, cz, cX)
515+ let bb = cY._1
516+ let br = cY._2
517+ let bs = cY._3
518+ let cL = cY._4
519+ $Tuple10(cO, bb, (cy + cF), cL, aJ, aI, bL, bM, bN, (ah() + cF))
520+ }
521+ }
522+ else {
523+ let cF = L(cl, ct)
524+ let cZ = bl(toString(cp.caller))
525+ let cH = cZ._1
526+ let bu = cZ._2
527+ if ((cH > cF))
528+ then throw("Use decreasePosition to decrease position size")
529+ else throw("Close position first")
530+ }
531+ let cO = cV._1
532+ let cP = cV._2
533+ let cQ = cV._3
534+ let cR = cV._4
535+ let aJ = cV._5
536+ let aI = cV._6
537+ let bL = cV._7
538+ let bM = cV._8
539+ let bN = cV._9
540+ let bO = cV._10
541+ let da = invoke(z, "lockNeutrino", nil, [AttachedPayment(y, cl)])
542+ if ((da == da))
543+ then (((bZ(toString(cp.caller), cO, cP, cQ, cR) ++ ce(aI, aJ, bL, bM, bN, bO)) ++ cr(cT)) ++ cq((X() + cl)))
544+ else throw("Strict value is not equal to itself.")
545+ }
546+ }
547+
548+
549+
550+@Callable(cp)
551+func addMargin () = {
552+ let cS = cp.payments[0].amount
553+ if (if ((cp.payments[0].assetId != y))
554+ then true
555+ else !(at(toString(cp.caller))))
556+ then throw("Invalid addMargin parameters")
557+ else {
558+ let cT = L(cS, Z())
559+ let cl = (cS - cT)
560+ let db = ao(toString(cp.caller))
561+ let cw = db._1
562+ let cx = db._2
563+ let cy = db._3
564+ let cz = db._4
565+ let da = invoke(z, "lockNeutrino", nil, [AttachedPayment(y, cl)])
566+ if ((da == da))
567+ then ((bZ(toString(cp.caller), cw, (cx + cp.payments[0].amount), cy, cz) ++ cr(cT)) ++ cq((X() + cl)))
568+ else throw("Strict value is not equal to itself.")
569+ }
570+ }
571+
572+
573+
574+@Callable(cp)
575+func removeMargin (cl) = if (if ((0 >= cl))
576+ then true
577+ else !(at(toString(cp.caller))))
578+ then throw("Invalid removeMargin parameters")
579+ else {
580+ let dc = ao(toString(cp.caller))
581+ let cw = dc._1
582+ let cx = dc._2
583+ let cy = dc._3
584+ let cz = dc._4
585+ let dd = -(cl)
586+ let de = aS(cw, cx, cz, dd)
587+ let bb = de._1
588+ let bc = de._2
589+ let br = de._3
590+ let df = de._4
591+ if ((bc != 0))
592+ then throw("Invalid added margin amount")
593+ else {
594+ let dg = invoke(z, "unlockNeutrino", [cl, toBase58String(y)], nil)
595+ if ((dg == dg))
596+ then ((bZ(toString(cp.caller), cw, bb, cy, df) ++ ck(cp.caller, cl)) ++ cq((X() - cl)))
597+ else throw("Strict value is not equal to itself.")
598+ }
599+ }
600+
601+
602+
603+@Callable(cp)
604+func closePosition () = if (!(at(toString(cp.caller))))
605+ then throw("Invalid closePosition parameters")
606+ else {
607+ let dh = bB(toString(cp.caller))
608+ let br = dh._1
609+ let bc = dh._2
610+ let bG = dh._3
611+ let bH = dh._4
612+ let bK = dh._5
613+ let aJ = dh._6
614+ let bL = dh._7
615+ let bM = dh._8
616+ let bN = dh._9
617+ let bO = dh._10
618+ if ((bc > 0))
619+ then throw("Unable to close position with bad debt")
620+ else {
621+ let di = M(bH)
622+ let dg = invoke(z, "unlockNeutrino", [di, toBase58String(y)], nil)
623+ if ((dg == dg))
624+ then {
625+ let dj = (X() - di)
626+ let dk = if ((0 > dj))
627+ then $Tuple2(0, (Y() - M(dj)))
628+ else $Tuple2(dj, Y())
629+ let dl = dk._1
630+ let dm = dk._2
631+ ((((cj(toString(cp.caller)) ++ ce(bK, aJ, bL, bM, bN, bO)) ++ ck(cp.caller, di)) ++ cq(dl)) ++ co(dm))
632+ }
633+ else throw("Strict value is not equal to itself.")
634+ }
635+ }
636+
637+
638+
639+@Callable(cp)
640+func liquidate (au) = if (if (!(Q(bx(au), am(), false)))
641+ then true
642+ else !(az()))
643+ then throw("Unable to liquidate")
644+ else {
645+ let dn = bB(au)
646+ let br = dn._1
647+ let bc = dn._2
648+ let bs = dn._3
649+ let bH = dn._4
650+ let bK = dn._5
651+ let aJ = dn._6
652+ let bL = dn._7
653+ let bM = dn._8
654+ let bN = dn._9
655+ let bO = dn._10
656+ let bJ = dn._11
657+ let do = (L(bJ, an()) / 2)
658+ let dp = if ((do > bH))
659+ then $Tuple3((do - bH), bH, ((bc + do) - bH))
660+ else $Tuple3(0, (bH - do), bc)
661+ let dq = dp._1
662+ let bb = dp._2
663+ let dr = dp._3
664+ ((cj(au) ++ ce(bK, aJ, bL, bM, bN, bO)) ++ ck(cp.caller, do))
665+ }
666+
667+
668+
669+@Callable(cp)
670+func payFunding () = {
671+ let ds = ai()
672+ if (if ((ds > lastBlock.timestamp))
673+ then true
674+ else !(az()))
675+ then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(ds)))
676+ else {
677+ let dt = bv()
678+ let du = bw()
679+ let dv = (du - dt)
680+ let dw = I(L(dv, ak()), H)
681+ let dx = ae()
682+ let dy = L(dw, dx)
683+ let dz = M(dy)
684+ if ((0 > dy))
685+ then (co((Y() - dz)) ++ cq((X() + dz)))
686+ else ((co((Y() + dz)) ++ cq((X() - dz))) ++ bV(0, (ds + al()), (ag() + dw), I(dw, dt)))
687+ }
688+ }
689+
690+
691+
692+@Callable(cp)
693+func addInsrFunds () = {
694+ let cl = cp.payments[0].amount
695+ if (if (if (!(az()))
696+ then true
697+ else (cp.payments[0].assetId != y))
698+ then true
699+ else (cp.caller != w))
700+ then throw("")
701+ else {
702+ let da = invoke(z, "lockNeutrino", nil, [AttachedPayment(y, cl)])
703+ if ((da == da))
704+ then co((Y() + cl))
705+ else throw("Strict value is not equal to itself.")
706+ }
707+ }
708+
709+
710+
711+@Callable(cp)
712+func withdrawInsrFunds (cl) = if (if (if (!(az()))
713+ then true
714+ else (cl > Y()))
715+ then true
716+ else (cp.caller != w))
717+ then throw("")
718+ else {
719+ let dg = invoke(z, "unlockNeutrino", [cl, toBase58String(y)], nil)
720+ if ((dg == dg))
721+ then (co((Y() - cl)) ++ ck(cp.caller, cl))
722+ else throw("Strict value is not equal to itself.")
723+ }
724+
725+
726+@Verifier(dA)
727+func dB () = sigVerify(dA.bodyBytes, dA.proofs[0], x)
728+

github/deemru/w8io/169f3d6 
46.67 ms