tx · L5SoiyqaBnBmd79w3Fn6waFsEbGnBzxDB1gu2zKMs9s

3N6JDcxYe6XSWJTLkn2MAZK3wDyobHB7ikB:  -0.01000000 Waves

2022.05.11 19:58 [2047272] smart account 3N6JDcxYe6XSWJTLkn2MAZK3wDyobHB7ikB > SELF 0.00000000 Waves

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