tx · CpCL6K9PHDTUaYAMzRtLaF7TDy8nnHvFMHKBCnx7N953

3Myy5WAmTTRosypUGxdmNzL6VmFUe63qTca:  -0.03400000 Waves

2022.06.15 21:34 [2097861] smart account 3Myy5WAmTTRosypUGxdmNzL6VmFUe63qTca > SELF 0.00000000 Waves

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

github/deemru/w8io/169f3d6 
69.64 ms