tx · DYXTumUDpiQ7DBKRzeV2ka9Sbh7JiA6H1EtYZgcJXaeV

3MwJ2NrGqvopF1TgXDv8nvnn885bh2Hh6Va:  -0.03200000 Waves

2022.05.23 11:30 [2064097] smart account 3MwJ2NrGqvopF1TgXDv8nvnn885bh2Hh6Va > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DYXTumUDpiQ7DBKRzeV2ka9Sbh7JiA6H1EtYZgcJXaeV",
    "fee": 3200000,
    "feeAssetId": null,
    "timestamp": 1653294718535,
    "version": 2,
    "chainId": 84,
    "sender": "3MwJ2NrGqvopF1TgXDv8nvnn885bh2Hh6Va",
    "senderPublicKey": "CjuHHe8eQNhKx6YsXYugam6uBeo2mV6qyaqDqVqHwQir",
    "proofs": [
        "3jjkiSc9kr2M3YSm94ei9sYHGtLRA8TWVPXAwToNL7L5z4faFBrctpPyi1L52jYqK4GJVTARgoRgzL4thGbYiPvS"
    ],
    "script": "base64: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",
    "height": 2064097,
    "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_positionOpenNotional"
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_maintenanceMarginRatio"
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_quouteAssetReserve"
37+
38+let r = "k_baseAssetReserve"
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'3N4iLFDovVKhYoUVjNTiDSeaQHDjCmXUZcm')
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) = [IntegerEntry(b, cp)]
346+
347+
348+func cr (cp) = [ScriptTransfer(B, cp, y)]
349+
350+
351+@Callable(cp)
352+func initialize (aG,aH,bT,bQ,bR,bS,bU) = if (if (if (if (if (if (if (if ((0 >= aG))
353+    then true
354+    else (0 >= aH))
355+    then true
356+    else (0 >= bT))
357+    then true
358+    else (0 >= bQ))
359+    then true
360+    else (0 >= bR))
361+    then true
362+    else (0 >= bS))
363+    then true
364+    else (cp.caller != w))
365+    then true
366+    else az())
367+    then throw("Invalid initialize parameters")
368+    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)])
369+
370+
371+
372+@Callable(cp)
373+func decreasePosition (cs,cl,ct,cu) = if (if (if (if (if (if ((cs != C))
374+    then (cs != D)
375+    else false)
376+    then true
377+    else (0 >= cl))
378+    then true
379+    else if (((1 * G) > ct))
380+        then true
381+        else (ct > (3 * G)))
382+    then true
383+    else !(az()))
384+    then true
385+    else !(Q(I(G, ct), aa(), true)))
386+    then throw("Invalid decreasePosition parameters")
387+    else {
388+        let cv = ao(toString(cp.caller))
389+        let cw = cv._1
390+        let cx = cv._2
391+        let cy = cv._3
392+        let cz = cv._4
393+        let cA = (cw == 0)
394+        let cB = if ((cw > 0))
395+            then (cs == C)
396+            else (cs == D)
397+        let cC = if (!(cA))
398+            then cB
399+            else false
400+        let cD = (cs == C)
401+        let cE = if (if (cA)
402+            then true
403+            else cC)
404+            then throw("Use increasePosition to open new or increase position")
405+            else {
406+                let cF = L(cl, ct)
407+                let cG = bl(toString(cp.caller))
408+                let cH = cG._1
409+                let bu = cG._2
410+                if ((cH > cF))
411+                    then {
412+                        let cI = aE(cD, cF)
413+                        let bF = cI._1
414+                        let aI = cI._2
415+                        let aJ = cI._3
416+                        let bL = cI._4
417+                        let bM = cI._5
418+                        let bN = cI._6
419+                        let cJ = M(bF)
420+                        if (if ((cu != 0))
421+                            then (cu > cJ)
422+                            else false)
423+                            then throw(((("Too little basse asset exchanged, got " + toString(cJ)) + " expected ") + toString(cu)))
424+                            else {
425+                                let bG = if ((cw != 0))
426+                                    then I(L(bu, cJ), cw)
427+                                    else 0
428+                                let cK = aS(cw, cx, cz, bG)
429+                                let bb = cK._1
430+                                let bc = cK._2
431+                                let aY = cK._3
432+                                let cL = cK._4
433+                                let bJ = cF
434+                                let cM = (bu - bG)
435+                                let cN = if ((cw > 0))
436+                                    then ((cH - bJ) - cM)
437+                                    else ((cM + cH) - bJ)
438+                                $Tuple10((cw + bF), bb, M(cN), cL, aJ, aI, bL, bM, bN, (ah() - cF))
439+                                }
440+                        }
441+                    else throw("Close position first")
442+                }
443+        let cO = cE._1
444+        let cP = cE._2
445+        let cQ = cE._3
446+        let cR = cE._4
447+        let aJ = cE._5
448+        let aI = cE._6
449+        let bL = cE._7
450+        let bM = cE._8
451+        let bN = cE._9
452+        let bO = cE._10
453+        (bZ(toString(cp.caller), cO, cP, cQ, cR) ++ ce(aI, aJ, bL, bM, bN, bO))
454+        }
455+
456+
457+
458+@Callable(cp)
459+func increasePosition (cs,ct,cu) = {
460+    let cS = cp.payments[0].amount
461+    if (if (if (if (if (if (if ((cs != C))
462+        then (cs != D)
463+        else false)
464+        then true
465+        else (0 >= cS))
466+        then true
467+        else if (((1 * G) > ct))
468+            then true
469+            else (ct > (3 * G)))
470+        then true
471+        else !(az()))
472+        then true
473+        else (cp.payments[0].assetId != y))
474+        then true
475+        else !(Q(I(G, ct), aa(), true)))
476+        then throw("Invalid increasePosition parameters")
477+        else {
478+            let cT = L(cS, Z())
479+            let cl = (cS - cT)
480+            let cU = ao(toString(cp.caller))
481+            let cw = cU._1
482+            let cx = cU._2
483+            let cy = cU._3
484+            let cz = cU._4
485+            let cA = (cw == 0)
486+            let cB = if ((cw > 0))
487+                then (cs == C)
488+                else (cs == D)
489+            let cC = if (!(cA))
490+                then cB
491+                else false
492+            let cD = (cs == C)
493+            let cV = if (if (cA)
494+                then true
495+                else cC)
496+                then {
497+                    let cF = L(cl, ct)
498+                    let cW = aE(cD, cF)
499+                    let aL = cW._1
500+                    let aI = cW._2
501+                    let aJ = cW._3
502+                    let bL = cW._4
503+                    let bM = cW._5
504+                    let bN = cW._6
505+                    if (if ((cu != 0))
506+                        then (cu > M(aL))
507+                        else false)
508+                        then throw(((("Limit error: " + toString(M(aL))) + " < ") + toString(cu)))
509+                        else {
510+                            let cO = (cw + aL)
511+                            let cX = I(cF, ct)
512+                            let cY = aS(cw, cx, cz, cX)
513+                            let bb = cY._1
514+                            let br = cY._2
515+                            let bs = cY._3
516+                            let cL = cY._4
517+                            $Tuple10(cO, bb, (cy + cF), cL, aJ, aI, bL, bM, bN, (ah() + cF))
518+                            }
519+                    }
520+                else {
521+                    let cF = L(cl, ct)
522+                    let cZ = bl(toString(cp.caller))
523+                    let cH = cZ._1
524+                    let bu = cZ._2
525+                    if ((cH > cF))
526+                        then throw("Use decreasePosition to decrease position size")
527+                        else throw("Close position first")
528+                    }
529+            let cO = cV._1
530+            let cP = cV._2
531+            let cQ = cV._3
532+            let cR = cV._4
533+            let aJ = cV._5
534+            let aI = cV._6
535+            let bL = cV._7
536+            let bM = cV._8
537+            let bN = cV._9
538+            let bO = cV._10
539+            let da = invoke(z, "lockNeutrino", nil, [AttachedPayment(y, cl)])
540+            if ((da == da))
541+                then (((bZ(toString(cp.caller), cO, cP, cQ, cR) ++ ce(aI, aJ, bL, bM, bN, bO)) ++ cr(cT)) ++ cq((X() + cl)))
542+                else throw("Strict value is not equal to itself.")
543+            }
544+    }
545+
546+
547+
548+@Callable(cp)
549+func addMargin () = {
550+    let cS = cp.payments[0].amount
551+    if (if ((cp.payments[0].assetId != y))
552+        then true
553+        else !(at(toString(cp.caller))))
554+        then throw("Invalid addMargin parameters")
555+        else {
556+            let cT = L(cS, Z())
557+            let cl = (cS - cT)
558+            let db = ao(toString(cp.caller))
559+            let cw = db._1
560+            let cx = db._2
561+            let cy = db._3
562+            let cz = db._4
563+            let da = invoke(z, "lockNeutrino", nil, [AttachedPayment(y, cl)])
564+            if ((da == da))
565+                then ((bZ(toString(cp.caller), cw, (cx + cp.payments[0].amount), cy, cz) ++ cr(cT)) ++ cq((X() + cl)))
566+                else throw("Strict value is not equal to itself.")
567+            }
568+    }
569+
570+
571+
572+@Callable(cp)
573+func removeMargin (cl) = if (if ((0 >= cl))
574+    then true
575+    else !(at(toString(cp.caller))))
576+    then throw("Invalid removeMargin parameters")
577+    else {
578+        let dc = ao(toString(cp.caller))
579+        let cw = dc._1
580+        let cx = dc._2
581+        let cy = dc._3
582+        let cz = dc._4
583+        let dd = -(cl)
584+        let de = aS(cw, cx, cz, dd)
585+        let bb = de._1
586+        let bc = de._2
587+        let br = de._3
588+        let df = de._4
589+        if ((bc != 0))
590+            then throw("Invalid added margin amount")
591+            else {
592+                let dg = invoke(z, "unlockNeutrino", [cl, toBase58String(y)], nil)
593+                if ((dg == dg))
594+                    then ((bZ(toString(cp.caller), cw, bb, cy, df) ++ ck(cp.caller, cl)) ++ cq((X() - cl)))
595+                    else throw("Strict value is not equal to itself.")
596+                }
597+        }
598+
599+
600+
601+@Callable(cp)
602+func closePosition () = if (!(at(toString(cp.caller))))
603+    then throw("Invalid closePosition parameters")
604+    else {
605+        let dh = bB(toString(cp.caller))
606+        let br = dh._1
607+        let bc = dh._2
608+        let bG = dh._3
609+        let bH = dh._4
610+        let bK = dh._5
611+        let aJ = dh._6
612+        let bL = dh._7
613+        let bM = dh._8
614+        let bN = dh._9
615+        let bO = dh._10
616+        if ((bc > 0))
617+            then throw("Unable to close position with bad debt")
618+            else {
619+                let di = M(bH)
620+                let dg = invoke(z, "unlockNeutrino", [di, toBase58String(y)], nil)
621+                if ((dg == dg))
622+                    then (((cj(toString(cp.caller)) ++ ce(bK, aJ, bL, bM, bN, bO)) ++ ck(cp.caller, di)) ++ cq((X() - di)))
623+                    else throw("Strict value is not equal to itself.")
624+                }
625+        }
626+
627+
628+
629+@Callable(cp)
630+func liquidate (au) = if (if (!(Q(bx(au), am(), false)))
631+    then true
632+    else !(az()))
633+    then throw("Unable to liquidate")
634+    else {
635+        let dj = bB(au)
636+        let br = dj._1
637+        let bc = dj._2
638+        let bs = dj._3
639+        let bH = dj._4
640+        let bK = dj._5
641+        let aJ = dj._6
642+        let bL = dj._7
643+        let bM = dj._8
644+        let bN = dj._9
645+        let bO = dj._10
646+        let bJ = dj._11
647+        let dk = (L(bJ, an()) / 2)
648+        let dl = if ((dk > bH))
649+            then $Tuple3((dk - bH), bH, ((bc + dk) - bH))
650+            else $Tuple3(0, (bH - dk), bc)
651+        let dm = dl._1
652+        let bb = dl._2
653+        let dn = dl._3
654+        ((cj(au) ++ ce(bK, aJ, bL, bM, bN, bO)) ++ ck(cp.caller, dk))
655+        }
656+
657+
658+
659+@Callable(cp)
660+func payFunding () = {
661+    let do = ai()
662+    if (if ((do > lastBlock.timestamp))
663+        then true
664+        else !(az()))
665+        then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(do)))
666+        else {
667+            let dp = bv()
668+            let dq = bw()
669+            let dr = (dq - dp)
670+            let ds = I(L(dr, ak()), H)
671+            let dt = ae()
672+            let du = L(ds, dt)
673+            let dv = M(du)
674+            if ((0 > du))
675+                then (co((Y() - dv)) ++ cq((X() + dv)))
676+                else ((co((Y() + dv)) ++ cq((X() - dv))) ++ bV(0, (do + al()), (ag() + ds), I(ds, dp)))
677+            }
678+    }
679+
680+
681+
682+@Callable(cp)
683+func addInsuranceFunds () = {
684+    let cl = cp.payments[0].amount
685+    if (if (if (!(az()))
686+        then true
687+        else (cp.payments[0].assetId != y))
688+        then true
689+        else (cp.caller != w))
690+        then throw("Invalid addInsuranceFunds params")
691+        else {
692+            let da = invoke(z, "lockNeutrino", nil, [AttachedPayment(y, cl)])
693+            if ((da == da))
694+                then co((Y() + cl))
695+                else throw("Strict value is not equal to itself.")
696+            }
697+    }
698+
699+
700+
701+@Callable(cp)
702+func withdrawInsuranceFunds (cl) = if (if (if (!(az()))
703+    then true
704+    else (cl > Y()))
705+    then true
706+    else (cp.caller != w))
707+    then throw("Invalid withdrawInsuranceFunds params")
708+    else {
709+        let dg = invoke(z, "unlockNeutrino", [cl, toBase58String(y)], nil)
710+        if ((dg == dg))
711+            then (co((Y() - cl)) ++ ck(cp.caller, cl))
712+            else throw("Strict value is not equal to itself.")
713+        }
714+
715+
716+@Verifier(dw)
717+func dx () = sigVerify(dw.bodyBytes, dw.proofs[0], dw.senderPublicKey)
718+
github/deemru/w8io/169f3d6 
36.32 ms ◑