tx · ACrwuZXycUxW65u2eefaFmbsxDiK7DmvZDRaerZhZi23

3N9yKwGxd4NYR95yMjtGM8x77gbtge3re5e:  -0.01000000 Waves

2022.05.11 21:50 [2047379] smart account 3N9yKwGxd4NYR95yMjtGM8x77gbtge3re5e > SELF 0.00000000 Waves

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