tx · DGKmJkk6nPoj4EvLM4BrebX2YyjcycDPC47wYuP3b883

3N3pWUb2DHKzD4UAVcV4f1YZgqCCKY3zfSL:  -0.03400000 Waves

2022.06.16 11:47 [2098707] smart account 3N3pWUb2DHKzD4UAVcV4f1YZgqCCKY3zfSL > SELF 0.00000000 Waves

{ "type": 13, "id": "DGKmJkk6nPoj4EvLM4BrebX2YyjcycDPC47wYuP3b883", "fee": 3400000, "feeAssetId": null, "timestamp": 1655369253883, "version": 2, "chainId": 84, "sender": "3N3pWUb2DHKzD4UAVcV4f1YZgqCCKY3zfSL", "senderPublicKey": "ArztfL58jpiAigfZ8u5FrCjCvs6Kcb6Nycw4rrvcNUrL", "proofs": [ "5dmhi1NmgCHuDnQRoAYT9GWT4Gv7jbxfLdaPbZirHYZWnwBwGGeQwSFAcB9jpwcirYxJTVNivVCdy68EgVqdkdC9" ], "script": "base64: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", "height": 2098707, "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 ((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 aE())
393+ then throw("Invalid initialize parameters")
394+ 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)])
395+
396+
397+
398+@Callable(cA)
399+func decreasePosition (cF,cx,cG,cH) = if (if (if (if (if (if ((cF != K))
400+ then (cF != L)
401+ else false)
402+ then true
403+ else (0 >= cx))
404+ then true
405+ else if (((1 * O) > cG))
406+ then true
407+ else (cG > (3 * O)))
408+ then true
409+ else !(aE()))
410+ then true
411+ else !(aa(T(O, cG), aj(), true)))
412+ then throw("Invalid decreasePosition parameters")
413+ else {
414+ let cI = ax(toString(cA.caller))
415+ let cJ = cI._1
416+ let cK = cI._2
417+ let cL = cI._3
418+ let cM = cI._4
419+ let cN = (cJ == 0)
420+ let cO = if ((cJ > 0))
421+ then (cF == K)
422+ else (cF == L)
423+ let cP = if (!(cN))
424+ then cO
425+ else false
426+ let cQ = (cF == K)
427+ let cR = if (if (cN)
428+ then true
429+ else cP)
430+ then throw("Use increasePosition to open new or increase position")
431+ else {
432+ let cS = V(cx, cG)
433+ let cT = bs(toString(cA.caller))
434+ let cU = cT._1
435+ let bE = cT._2
436+ if ((cU > cS))
437+ then {
438+ let cV = aL(cQ, cS)
439+ let bR = cV._1
440+ let aP = cV._2
441+ let aQ = cV._3
442+ let bX = cV._4
443+ let bY = cV._5
444+ let bZ = cV._6
445+ let cW = W(bR)
446+ if (if ((cH != 0))
447+ then (cH > cW)
448+ else false)
449+ then throw(((("Too little basse asset exchanged, got " + toString(cW)) + " expected ") + toString(cH)))
450+ else {
451+ let bS = if ((cJ != 0))
452+ then T(V(bE, cW), cJ)
453+ else 0
454+ let cX = aZ(cJ, cK, cM, bS)
455+ let bi = cX._1
456+ let bj = cX._2
457+ let bf = cX._3
458+ let cY = cX._4
459+ let bV = cS
460+ let cZ = (bE - bS)
461+ let da = if ((cJ > 0))
462+ then ((cU - bV) - cZ)
463+ else ((cZ + cU) - bV)
464+ $Tuple10((cJ + bR), bi, W(da), cY, aQ, aP, bX, bY, bZ, (aq() - cS))
465+ }
466+ }
467+ else throw("Close position first")
468+ }
469+ let db = cR._1
470+ let dc = cR._2
471+ let dd = cR._3
472+ let de = cR._4
473+ let aQ = cR._5
474+ let aP = cR._6
475+ let bX = cR._7
476+ let bY = cR._8
477+ let bZ = cR._9
478+ let ca = cR._10
479+ (cl(toString(cA.caller), db, dc, dd, de) ++ cq(aP, aQ, bX, bY, bZ, ca))
480+ }
481+
482+
483+
484+@Callable(cA)
485+func increasePosition (cF,cG,cH) = {
486+ let df = cA.payments[0].amount
487+ if (if (if (if (if (if (if ((cF != K))
488+ then (cF != L)
489+ else false)
490+ then true
491+ else (0 >= df))
492+ then true
493+ else if (((1 * O) > cG))
494+ then true
495+ else (cG > (3 * O)))
496+ then true
497+ else !(aE()))
498+ then true
499+ else (cA.payments[0].assetId != G()))
500+ then true
501+ else !(aa(T(O, cG), aj(), true)))
502+ then throw("Invalid increasePosition parameters")
503+ else {
504+ let dg = V(df, ai())
505+ let cx = (df - dg)
506+ let dh = ax(toString(cA.caller))
507+ let cJ = dh._1
508+ let cK = dh._2
509+ let cL = dh._3
510+ let cM = dh._4
511+ let cN = (cJ == 0)
512+ let cO = if ((cJ > 0))
513+ then (cF == K)
514+ else (cF == L)
515+ let cP = if (!(cN))
516+ then cO
517+ else false
518+ let cQ = (cF == K)
519+ let di = if (if (cN)
520+ then true
521+ else cP)
522+ then {
523+ let cS = V(cx, cG)
524+ let dj = aL(cQ, cS)
525+ let aS = dj._1
526+ let aP = dj._2
527+ let aQ = dj._3
528+ let bX = dj._4
529+ let bY = dj._5
530+ let bZ = dj._6
531+ if (if ((cH != 0))
532+ then (cH > W(aS))
533+ else false)
534+ then throw(((("Limit error: " + toString(W(aS))) + " < ") + toString(cH)))
535+ else {
536+ let db = (cJ + aS)
537+ let dk = T(cS, cG)
538+ let dl = aZ(cJ, cK, cM, dk)
539+ let bi = dl._1
540+ let bB = dl._2
541+ let bC = dl._3
542+ let cY = dl._4
543+ $Tuple10(db, bi, (cL + cS), cY, aQ, aP, bX, bY, bZ, (aq() + cS))
544+ }
545+ }
546+ else {
547+ let cS = V(cx, cG)
548+ let dm = bs(toString(cA.caller))
549+ let cU = dm._1
550+ let bE = dm._2
551+ if ((cU > cS))
552+ then throw("Use decreasePosition to decrease position size")
553+ else throw("Close position first")
554+ }
555+ let db = di._1
556+ let dc = di._2
557+ let dd = di._3
558+ let de = di._4
559+ let aQ = di._5
560+ let aP = di._6
561+ let bX = di._7
562+ let bY = di._8
563+ let bZ = di._9
564+ let ca = di._10
565+ let dn = (dg / 2)
566+ let do = (dg - dn)
567+ let dp = invoke(H(), "lockNeutrinoSP", [toString(I()), Q], [AttachedPayment(G(), cx)])
568+ if ((dp == dp))
569+ then {
570+ let dq = invoke(J(), "deposit", nil, [AttachedPayment(G(), do)])
571+ if ((dq == dq))
572+ then (((cl(toString(cA.caller), db, dc, dd, de) ++ cq(aP, aQ, bX, bY, bZ, ca)) ++ cB(dn)) ++ cz((ah() + cx)))
573+ else throw("Strict value is not equal to itself.")
574+ }
575+ else throw("Strict value is not equal to itself.")
576+ }
577+ }
578+
579+
580+
581+@Callable(cA)
582+func addMargin () = {
583+ let df = cA.payments[0].amount
584+ if (if ((cA.payments[0].assetId != G()))
585+ then true
586+ else !(aC(toString(cA.caller))))
587+ then throw("Invalid addMargin parameters")
588+ else {
589+ let dg = V(df, ai())
590+ let cx = (df - dg)
591+ let dr = ax(toString(cA.caller))
592+ let cJ = dr._1
593+ let cK = dr._2
594+ let cL = dr._3
595+ let cM = dr._4
596+ let dn = (dg / 2)
597+ let do = (dg - dn)
598+ let dp = invoke(H(), "lockNeutrinoSP", [toString(I()), Q], [AttachedPayment(G(), cx)])
599+ if ((dp == dp))
600+ then {
601+ let dq = invoke(J(), "deposit", nil, [AttachedPayment(G(), do)])
602+ if ((dq == dq))
603+ then ((cl(toString(cA.caller), cJ, (cK + cA.payments[0].amount), cL, cM) ++ cB(dn)) ++ cz((ah() + cx)))
604+ else throw("Strict value is not equal to itself.")
605+ }
606+ else throw("Strict value is not equal to itself.")
607+ }
608+ }
609+
610+
611+
612+@Callable(cA)
613+func removeMargin (cx) = if (if ((0 >= cx))
614+ then true
615+ else !(aC(toString(cA.caller))))
616+ then throw("Invalid removeMargin parameters")
617+ else {
618+ let ds = ax(toString(cA.caller))
619+ let cJ = ds._1
620+ let cK = ds._2
621+ let cL = ds._3
622+ let cM = ds._4
623+ let dt = -(cx)
624+ let du = aZ(cJ, cK, cM, dt)
625+ let bi = du._1
626+ let bj = du._2
627+ let bB = du._3
628+ let dv = du._4
629+ if ((bj != 0))
630+ then throw("Invalid added margin amount")
631+ else {
632+ let dw = invoke(H(), "unlockNeutrino", [cx, toBase58String(G())], nil)
633+ if ((dw == dw))
634+ then ((cl(toString(cA.caller), cJ, bi, cL, dv) ++ cw(cA.caller, cx)) ++ cz((ah() - cx)))
635+ else throw("Strict value is not equal to itself.")
636+ }
637+ }
638+
639+
640+
641+@Callable(cA)
642+func closePosition () = if (!(aC(toString(cA.caller))))
643+ then throw("Invalid closePosition parameters")
644+ else {
645+ let dx = bN(toString(cA.caller))
646+ let bB = dx._1
647+ let bj = dx._2
648+ let bS = dx._3
649+ let bT = dx._4
650+ let bW = dx._5
651+ let aQ = dx._6
652+ let bX = dx._7
653+ let bY = dx._8
654+ let bZ = dx._9
655+ let ca = dx._10
656+ if ((bj > 0))
657+ then throw("Unable to close position with bad debt")
658+ else {
659+ let dy = W(bT)
660+ let dz = (ah() - dy)
661+ let dA = if ((0 > dz))
662+ then $Tuple2(0, W(dz))
663+ else $Tuple2(dz, 0)
664+ let dB = dA._1
665+ let dC = dA._2
666+ let dD = if ((dC > 0))
667+ then {
668+ let dE = invoke(J(), "withdraw", [dC], nil)
669+ if ((dE == dE))
670+ then nil
671+ else throw("Strict value is not equal to itself.")
672+ }
673+ else nil
674+ if ((dD == dD))
675+ then {
676+ let dw = invoke(H(), "unlockNeutrino", [(dy - dC), toBase58String(G())], nil)
677+ if ((dw == dw))
678+ then (((cv(toString(cA.caller)) ++ cq(bW, aQ, bX, bY, bZ, ca)) ++ cw(cA.caller, dy)) ++ cz(dB))
679+ else throw("Strict value is not equal to itself.")
680+ }
681+ else throw("Strict value is not equal to itself.")
682+ }
683+ }
684+
685+
686+
687+@Callable(cA)
688+func liquidate (aD) = if (if (!(aa(bJ(aD), av(), false)))
689+ then true
690+ else !(aE()))
691+ then throw("Unable to liquidate")
692+ else {
693+ let dF = bN(aD)
694+ let bB = dF._1
695+ let bj = dF._2
696+ let bC = dF._3
697+ let bT = dF._4
698+ let bW = dF._5
699+ let aQ = dF._6
700+ let bX = dF._7
701+ let bY = dF._8
702+ let bZ = dF._9
703+ let ca = dF._10
704+ let bV = dF._11
705+ let dG = (V(bV, aw()) / 2)
706+ let dH = if ((dG > bT))
707+ then $Tuple3((dG - bT), bT, ((bj + dG) - bT))
708+ else $Tuple3(0, (bT - dG), bj)
709+ let dI = dH._1
710+ let bi = dH._2
711+ let dJ = dH._3
712+ let dz = (ah() - dG)
713+ let dK = if ((0 > dz))
714+ then $Tuple2(0, W(dz))
715+ else $Tuple2(dz, 0)
716+ let dB = dK._1
717+ let dC = dK._2
718+ let dD = if ((dC > 0))
719+ then {
720+ let dE = invoke(J(), "withdraw", [dC], nil)
721+ if ((dE == dE))
722+ then nil
723+ else throw("Strict value is not equal to itself.")
724+ }
725+ else nil
726+ if ((dD == dD))
727+ then {
728+ let dw = invoke(H(), "unlockNeutrino", [(dG - dC), toBase58String(G())], nil)
729+ if ((dw == dw))
730+ then (((cv(aD) ++ cq(bW, aQ, bX, bY, bZ, ca)) ++ cw(cA.caller, dG)) ++ cz(dB))
731+ else throw("Strict value is not equal to itself.")
732+ }
733+ else throw("Strict value is not equal to itself.")
734+ }
735+
736+
737+
738+@Callable(cA)
739+func payFunding () = {
740+ let dL = ar()
741+ if (if ((dL > lastBlock.timestamp))
742+ then true
743+ else !(aE()))
744+ then throw(((("Invalid funding block timestamp: " + toString(lastBlock.timestamp)) + " < ") + toString(dL)))
745+ else {
746+ let dM = bF()
747+ let dN = bI()
748+ let dO = (dN - dM)
749+ let dP = T(V(dO, at()), P)
750+ let dQ = an()
751+ let dR = V(dP, dQ)
752+ let dS = W(dR)
753+ let dT = if ((0 > dR))
754+ then {
755+ let dE = invoke(J(), "withdraw", [dS], nil)
756+ if ((dE == dE))
757+ then {
758+ let dp = invoke(H(), "lockNeutrinoSP", [toString(I()), Q], [AttachedPayment(G(), dS)])
759+ if ((dp == dp))
760+ then cz((ah() + dS))
761+ else throw("Strict value is not equal to itself.")
762+ }
763+ else throw("Strict value is not equal to itself.")
764+ }
765+ else if ((dR != 0))
766+ then {
767+ let dw = invoke(H(), "unlockNeutrino", [dS, toBase58String(G())], nil)
768+ if ((dw == dw))
769+ then {
770+ let dq = invoke(J(), "deposit", nil, [AttachedPayment(G(), dS)])
771+ if ((dq == dq))
772+ then cz((ah() - dS))
773+ else throw("Strict value is not equal to itself.")
774+ }
775+ else throw("Strict value is not equal to itself.")
776+ }
777+ else cz((ah() - dS))
778+ (dT ++ ch(0, (dL + au()), (ap() + dP), T(dP, dM)))
779+ }
780+ }
781+
782+
783+
784+@Callable(cA)
785+func v_get (aD) = {
786+ let dU = bN(aD)
787+ let bB = dU._1
788+ let bC = dU._2
789+ let bD = dU._3
790+ let dV = dU._4
791+ throw((((R(bC) + R(bD)) + R(dV)) + R(bJ(aD))))
792+ }
793+
794+
795+@Verifier(dW)
796+func dX () = sigVerify(dW.bodyBytes, dW.proofs[0], F())
797+

github/deemru/w8io/026f985 
54.96 ms