tx · hHiZhAT2K2ipcfgNS7wnzXJKGgipbBMrB7VwcbJmxu3

3N9uh45Po5Z6xGAe6QLtSLYD27ZRCssedKX:  -0.03200000 Waves

2022.05.24 09:57 [2065440] smart account 3N9uh45Po5Z6xGAe6QLtSLYD27ZRCssedKX > SELF 0.00000000 Waves

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