tx · 2XGh3nwFEX6CpsfzkACdGSePxGqgyvi78qRkXDTq6WkB

3MwVJ4Ts5VcACP9Xo6TfGrpNoPjs2Nt6GMW:  -0.01000000 Waves

2022.05.23 09:33 [2063978] smart account 3MwVJ4Ts5VcACP9Xo6TfGrpNoPjs2Nt6GMW > SELF 0.00000000 Waves

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