tx · GsFGBYiA6j21X7eRX2DU3xpzBLRJK19xC6mgUcKWRSo2

3NCjEKpGqQeUCtmQYJRim5fVPndZeAJBvJi:  -0.03400000 Waves

2023.04.17 20:10 [2538845] smart account 3NCjEKpGqQeUCtmQYJRim5fVPndZeAJBvJi > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "GsFGBYiA6j21X7eRX2DU3xpzBLRJK19xC6mgUcKWRSo2",
    "fee": 3400000,
    "feeAssetId": null,
    "timestamp": 1681751520433,
    "version": 2,
    "chainId": 84,
    "sender": "3NCjEKpGqQeUCtmQYJRim5fVPndZeAJBvJi",
    "senderPublicKey": "8Fp5fYZo6qeYuVtZFYoTKcVoxVbL9DrxVXLvhvqtP3vW",
    "proofs": [
        "3z38JWtGcjufzXp84aNsRpJcsfyZxYg9RN3FZ9Gnfu72ZH5uKQo8myFoXE3FcDqetfqsYfmsBv4c17YsrtqteBSz"
    ],
    "script": "base64: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",
    "height": 2538845,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: none

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "k_coordinatorAddress"
5+
6+let b = "k_admin_address"
7+
8+let c = "k_quote_asset"
9+
10+let d = "k_amm"
11+
12+let e = "k_manager_address"
13+
14+let f = "k_positionSequence"
15+
16+let g = "k_positionSize"
17+
18+let h = "k_executedOrders"
19+
20+let i = "k_canceledOrders"
21+
22+let j = "k_order"
23+
24+let k = "k_orderReq"
25+
26+let l = "k_lastOrderId"
27+
28+let m = "k_traderOrderCnt"
29+
30+let n = "k_traderOrderIds"
31+
32+let o = "k_sender"
33+
34+let p = "k_initialized"
35+
36+let q = 1
37+
38+let r = 2
39+
40+let s = 3
41+
42+let t = 1
43+
44+let u = 2
45+
46+let v = 1
47+
48+let w = 2
49+
50+let x = 10
51+
52+let y = lastBlock.timestamp
53+
54+let z = (1 * (((((10 * 10) * 10) * 10) * 10) * 10))
55+
56+let A = (z / 200)
57+
58+func B (C) = if ((C > 0))
59+    then C
60+    else -(C)
61+
62+
63+func D (C,E) = fraction(C, z, E, HALFEVEN)
64+
65+
66+func F (C,E) = fraction(C, E, z, HALFEVEN)
67+
68+
69+func G (C,E) = if ((C > E))
70+    then E
71+    else C
72+
73+
74+func H (I,J) = ((I + "_") + J)
75+
76+
77+func K (L) = ((h + "_") + toString(L))
78+
79+
80+func M (L) = ((i + "_") + toString(L))
81+
82+
83+func N (L) = H(j, toString(L))
84+
85+
86+func O (L,P) = ((((k + "_") + toString(L)) + "_") + toString(P))
87+
88+
89+func Q (R,S) = ((((m + "_") + R) + "_") + S)
90+
91+
92+func T (R,S) = ((((n + "_") + R) + "_") + S)
93+
94+
95+func U () = valueOrErrorMessage(addressFromString(getStringValue(this, a)), "Coordinator not set")
96+
97+
98+func V () = fromBase58String(getStringValue(U(), c))
99+
100+
101+func W () = valueOrErrorMessage(addressFromString(getStringValue(U(), e)), "Manager not set")
102+
103+
104+func X (J) = valueOrElse(getBoolean(U(), H(d, J)), false)
105+
106+
107+func Y () = valueOrElse(getBoolean(this, p), false)
108+
109+
110+func Z (L) = if (valueOrElse(getBoolean(this, K(L)), false))
111+    then throw(("Order already executed: " + toString(L)))
112+    else if (valueOrElse(getBoolean(this, M(L)), false))
113+        then throw(("Order already cancelled: " + toString(L)))
114+        else true
115+
116+
117+func aa () = valueOrElse(getInteger(this, l), 0)
118+
119+
120+func ab (R,S) = {
121+    let ac = Q(R, S)
122+    valueOrElse(getInteger(this, ac), 0)
123+    }
124+
125+
126+func ad (R,S) = {
127+    let ac = T(R, S)
128+    let ae = valueOrElse(getString(this, ac), "")
129+    if ((ae == ""))
130+        then nil
131+        else split(ae, ",")
132+    }
133+
134+
135+func af (L,P) = {
136+    let ac = O(L, P)
137+    isDefined(getString(this, ac))
138+    }
139+
140+
141+func ag (L,P) = {
142+    let ac = O(L, P)
143+    let ah = valueOrErrorMessage(getString(this, ac), ("Not order request for key: " + ac))
144+    let ai = split(ah, ",")
145+    let aj = valueOrErrorMessage(parseInt(ai[0]), "Invalid orderId")
146+    let ak = ai[1]
147+    let al = ai[2]
148+    let am = valueOrErrorMessage(parseInt(ai[3]), "Invalid type")
149+    let an = valueOrErrorMessage(parseInt(ai[4]), "Invalid triggerPrice")
150+    let ao = valueOrErrorMessage(parseInt(ai[5]), "Invalid limitPrice")
151+    $Tuple6(aj, ak, al, am, an, ao)
152+    }
153+
154+
155+func ap (L) = {
156+    let aq = valueOrErrorMessage(getString(this, N(L)), ("Invalid order id: " + toString(L)))
157+    let ar = split(aq, ",")
158+    let ak = ar[0]
159+    let al = ar[1]
160+    let as = valueOrErrorMessage(parseInt(ar[2]), "Invalid amountIn")
161+    let at = valueOrErrorMessage(parseInt(ar[3]), "Invalid leverage")
162+    let am = valueOrErrorMessage(parseInt(ar[4]), "Invalid type")
163+    let an = valueOrErrorMessage(parseInt(ar[5]), "Invalid triggerPrice")
164+    let au = valueOrErrorMessage(parseInt(ar[6]), "Invalid paymentUsdn")
165+    let av = valueOrErrorMessage(parseInt(ar[7]), "Invalid side")
166+    let aw = ar[8]
167+    let ax = valueOrErrorMessage(parseInt(ar[9]), "Invalid positionId")
168+    let ao = valueOrErrorMessage(parseInt(ar[10]), "Invalid limitPrice")
169+    $Tuple11(ak, al, as, at, am, an, au, av, aw, ax, ao)
170+    }
171+
172+
173+func ay (R) = {
174+    let az = invoke(addressFromStringValue(R), "computeSpotPrice", nil, nil)
175+    if ((az == az))
176+        then {
177+            let aA = {
178+                let aB = az
179+                if ($isInstanceOf(aB, "Int"))
180+                    then {
181+                        let aC = aB
182+                        aC
183+                        }
184+                    else throw("Invalid computeSpotPrice result")
185+                }
186+            value(aA)
187+            }
188+        else throw("Strict value is not equal to itself.")
189+    }
190+
191+
192+func aD (R,S) = {
193+    let az = invoke(addressFromStringValue(R), "computeFeeForTraderWithArtifact", [S, ""], nil)
194+    if ((az == az))
195+        then {
196+            let aA = {
197+                let aB = az
198+                if ($isInstanceOf(aB, "(Int, Boolean)"))
199+                    then {
200+                        let aC = aB
201+                        aC._1
202+                        }
203+                    else throw("Invalid computeFeeForTraderWithArtifact result")
204+                }
205+            value(aA)
206+            }
207+        else throw("Strict value is not equal to itself.")
208+    }
209+
210+
211+func aE (aF,aG) = if (if ((aG == r))
212+    then true
213+    else (aG == q))
214+    then if ((aF == t))
215+        then u
216+        else t
217+    else aF
218+
219+
220+func aH (R,S,aI) = {
221+    let ak = addressFromStringValue(R)
222+    let aJ = ((S + "_") + toString(aI))
223+    let aK = H(g, aJ)
224+    valueOrElse(getInteger(ak, aK), 0)
225+    }
226+
227+
228+func aL (R,S,aI) = {
229+    let ak = addressFromStringValue(R)
230+    let aJ = ((S + "_") + toString(aI))
231+    let aM = H(f, aJ)
232+    valueOrElse(getInteger(ak, aM), 0)
233+    }
234+
235+
236+func aN (aO) = F(aO, A)
237+
238+
239+func aP (L,R,S,aQ,aR,P,aS,aT,aU,aV,aW,aX) = {
240+    let aq = makeString([R, S, toString(aQ), toString(aR), toString(P), toString(aS), toString(aT), toString(aU), aV, toString(aW), toString(aX)], ",")
241+[StringEntry(N(L), aq)]
242+    }
243+
244+
245+func aY (L,R,S,P,aS,aX) = {
246+    let aZ = makeString([toString(L), R, S, toString(P), toString(aS), toString(aX)], ",")
247+[StringEntry(O(L, P), aZ)]
248+    }
249+
250+
251+func ba (bb,R,S) = [StringEntry(T(R, S), bb)]
252+
253+
254+func bc (bd,L,R,S,be) = {
255+    let bf = if (be)
256+        then (bd :+ toString(L))
257+        else removeByIndex(bd, valueOrErrorMessage(indexOf(bd, toString(L)), ("No order with id: " + toString(L))))
258+    bf
259+    }
260+
261+
262+func bg (L,R,S,be) = {
263+    let bh = ad(R, S)
264+    let bf = bc(bh, L, R, S, be)
265+    let bi = makeString(bf, ",")
266+    ba(bi, R, S)
267+    }
268+
269+
270+func bj (R,S,bk) = if ((0 > bk))
271+    then throw(("Invalid order count: " + toString(bk)))
272+    else [IntegerEntry(Q(R, S), bk)]
273+
274+
275+func bl (bm) = [IntegerEntry(l, bm)]
276+
277+
278+func bn (L) = [BooleanEntry(H(h, toString(L)), true)]
279+
280+
281+func bo (L) = [BooleanEntry(H(i, toString(L)), true)]
282+
283+
284+func bp (R,S) = {
285+    let bq = aH(R, S, t)
286+    let br = if ((bq != 0))
287+        then aL(R, S, t)
288+        else 0
289+    let bs = aH(R, S, u)
290+    let bt = if ((bs != 0))
291+        then aL(R, S, u)
292+        else 0
293+[br, bt]
294+    }
295+
296+
297+@Callable(bu)
298+func cleanUpStaleOrders (R,S) = {
299+    let bv = ad(R, S)
300+    let bw = bp(R, S)
301+    func bx (by,L) =     {
302+        let bz = valueOrErrorMessage(parseInt(L), "Invalid order id")
303+        let bA = ap(bz)
304+        let bB = bA._1
305+        let bC = bA._2
306+        let bD = bA._3
307+        let bE = bA._4
308+        let P = bA._5
309+        let bF = bA._6
310+        let bG = bA._7
311+        let bH = bA._8
312+        let bI = bA._9
313+        let aW = bA._10
314+        let bJ = bA._11
315+        if (if (if (if ((P == q))
316+            then true
317+            else (P == r))
318+            then (bw[0] != aW)
319+            else false)
320+            then (bw[1] != aW)
321+            else false)
322+            then {
323+                let bK = bo(bz)
324+                let bL = bc(by._1, bz, R, S, false)
325+                $Tuple2(bL, (by._2 ++ bK))
326+                }
327+            else by
328+        }
329+
330+    let bM = {
331+        let bN = bv
332+        let bO = size(bN)
333+        let bP = $Tuple2(bv, nil)
334+        func bQ (bR,bS) =         if ((bS >= bO))
335+            then bR
336+            else bx(bR, bN[bS])
337+
338+        func bT (bR,bS) =         if ((bS >= bO))
339+            then bR
340+            else throw("List size exceeds 10")
341+
342+        bT(bQ(bQ(bQ(bQ(bQ(bQ(bQ(bQ(bQ(bQ(bP, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10)
343+        }
344+    let bU = bM._1
345+    let bV = bM._2
346+    ((bV ++ bj(R, S, size(bU))) ++ ba(makeString(bU, ","), R, S))
347+    }
348+
349+
350+
351+@Callable(bu)
352+func setContext (bW) = if ((bu.caller != this))
353+    then throw("Only self-call")
354+    else [StringEntry(o, bW)]
355+
356+
357+
358+@Callable(bu)
359+func resetContext () = if ((bu.caller != this))
360+    then throw("Only self-call")
361+    else [DeleteEntry(o)]
362+
363+
364+
365+@Callable(bu)
366+func initialize (bX) = if (if (Y())
367+    then true
368+    else (bu.caller != this))
369+    then throw("Unable to initialize")
370+    else [StringEntry(a, toString(addressFromStringValue(bX))), BooleanEntry(p, true)]
371+
372+
373+
374+@Callable(bu)
375+func createOrder (R,P,aS,aX,aQ,aR,aU,aV,bY,bZ,ca,cb) = {
376+    let S = toString(bu.caller)
377+    let cc = invoke(this, "cleanUpStaleOrders", [R, S], nil)
378+    if ((cc == cc))
379+        then if ((size(bu.payments) > 1))
380+            then throw("Invalid createOrder parameters: invalid payment count")
381+            else {
382+                let cd = if ((size(bu.payments) == 1))
383+                    then $Tuple2(toBase58String(valueOrErrorMessage(bu.payments[0].assetId, "Invalid asset id")), bu.payments[0].amount)
384+                    else $Tuple2("", 0)
385+                let ce = cd._1
386+                let cf = cd._2
387+                let cg = invoke(this, "internalCreateOrder", [S, R, P, aS, aX, aQ, aR, aU, aV, ce, cf], nil)
388+                if ((cg == cg))
389+                    then {
390+                        let aj = {
391+                            let aB = cg
392+                            if ($isInstanceOf(aB, "Int"))
393+                                then {
394+                                    let aC = aB
395+                                    aC
396+                                    }
397+                                else throw("Invalid ID of created order")
398+                            }
399+                        if ((P == s))
400+                            then {
401+                                let ch = if ((bY > 0))
402+                                    then {
403+                                        let ci = invoke(this, "internalCreateOrderRequest", [S, R, aj, q, bY, bZ], nil)
404+                                        if ((ci == ci))
405+                                            then nil
406+                                            else throw("Strict value is not equal to itself.")
407+                                        }
408+                                    else nil
409+                                let cj = if ((ca > 0))
410+                                    then {
411+                                        let ck = invoke(this, "internalCreateOrderRequest", [S, R, aj, r, ca, cb], nil)
412+                                        if ((ck == ck))
413+                                            then nil
414+                                            else throw("Strict value is not equal to itself.")
415+                                        }
416+                                    else nil
417+                                (ch ++ cj)
418+                                }
419+                            else nil
420+                        }
421+                    else throw("Strict value is not equal to itself.")
422+                }
423+        else throw("Strict value is not equal to itself.")
424+    }
425+
426+
427+
428+@Callable(bu)
429+func increasePositionWithStopLoss (R,aI,aR,cl,aV,bY,bZ,ca,cb) = {
430+    let S = toString(bu.caller)
431+    let cc = invoke(this, "cleanUpStaleOrders", [R, S], nil)
432+    if ((cc == cc))
433+        then if (if (!(Y()))
434+            then true
435+            else !(X(R)))
436+            then throw("Invalid increasePositionWithStopLoss parameters")
437+            else {
438+                let cm = aH(R, S, aI)
439+                if ((cm != 0))
440+                    then throw("Invalid increasePositionWithStopLoss parameters: only new position")
441+                    else {
442+                        let cn = invoke(this, "setContext", [S], nil)
443+                        if ((cn == cn))
444+                            then {
445+                                let co = invoke(addressFromStringValue(R), "increasePosition", [aI, aR, cl, aV], bu.payments)
446+                                if ((co == co))
447+                                    then {
448+                                        let cp = invoke(this, "resetContext", nil, nil)
449+                                        if ((cp == cp))
450+                                            then {
451+                                                let cq = aH(R, S, aI)
452+                                                if ((cq == cq))
453+                                                    then {
454+                                                        let as = B(cq)
455+                                                        let cr = if ((0 > cq))
456+                                                            then t
457+                                                            else u
458+                                                        let cs = if ((bY > 0))
459+                                                            then {
460+                                                                let cs = invoke(this, "internalCreateOrder", [S, R, q, bY, bZ, as, 0, cr, aV, "", 0], nil)
461+                                                                if ((cs == cs))
462+                                                                    then nil
463+                                                                    else throw("Strict value is not equal to itself.")
464+                                                                }
465+                                                            else nil
466+                                                        if ((cs == cs))
467+                                                            then {
468+                                                                let ct = if ((ca > 0))
469+                                                                    then {
470+                                                                        let ct = invoke(this, "internalCreateOrder", [S, R, r, ca, cb, as, 0, cr, aV, "", 0], nil)
471+                                                                        if ((ct == ct))
472+                                                                            then nil
473+                                                                            else throw("Strict value is not equal to itself.")
474+                                                                        }
475+                                                                    else nil
476+                                                                if ((ct == ct))
477+                                                                    then nil
478+                                                                    else throw("Strict value is not equal to itself.")
479+                                                                }
480+                                                            else throw("Strict value is not equal to itself.")
481+                                                        }
482+                                                    else throw("Strict value is not equal to itself.")
483+                                                }
484+                                            else throw("Strict value is not equal to itself.")
485+                                        }
486+                                    else throw("Strict value is not equal to itself.")
487+                                }
488+                            else throw("Strict value is not equal to itself.")
489+                        }
490+                }
491+        else throw("Strict value is not equal to itself.")
492+    }
493+
494+
495+
496+@Callable(bu)
497+func internalMarkOrderExecuted (R,S,L) = if (if (if (!(Y()))
498+    then true
499+    else !(X(R)))
500+    then true
501+    else !((bu.caller == this)))
502+    then throw("Invalid internalMarkOrderExecuted parameters")
503+    else {
504+        let cu = (ab(R, S) - 1)
505+        ((bj(R, S, cu) ++ bg(L, R, S, false)) ++ bn(L))
506+        }
507+
508+
509+
510+@Callable(bu)
511+func internalCreateOrderRequest (S,R,L,P,aS,aX) = if (if (if (if (if (!(Y()))
512+    then true
513+    else !(X(R)))
514+    then true
515+    else (0 >= aS))
516+    then true
517+    else (0 > aX))
518+    then true
519+    else !((bu.caller == this)))
520+    then throw("Invalid internalCreateOrderRequest parameters")
521+    else aY(L, R, S, P, aS, aX)
522+
523+
524+
525+@Callable(bu)
526+func internalCreateOrder (S,R,P,aS,aX,aQ,aR,aU,aV,cv,cw) = {
527+    let cx = toString(!(Y()))
528+    let cy = toString(!(X(R)))
529+    let cz = toString((0 >= aS))
530+    let cA = toString((0 > aX))
531+    let cB = toString((0 >= aQ))
532+    let cC = toString((0 > aR))
533+    let cD = toString(!(if ((aU == t))
534+        then true
535+        else (aU == u)))
536+    let cE = toString(!(if (if ((P == q))
537+        then true
538+        else (P == r))
539+        then true
540+        else (P == s)))
541+    let cF = toString(!((bu.caller == this)))
542+    let cG = makeString([cx, cy, cz, cA, cB, cC, cD, cE, cF], ",")
543+    if (if (if (if (if (if (if (if (if (!(Y()))
544+        then true
545+        else !(X(R)))
546+        then true
547+        else (0 >= aS))
548+        then true
549+        else (0 > aX))
550+        then true
551+        else (0 >= aQ))
552+        then true
553+        else (0 > aR))
554+        then true
555+        else !(if ((aU == t))
556+            then true
557+            else (aU == u)))
558+        then true
559+        else !(if (if ((P == q))
560+            then true
561+            else (P == r))
562+            then true
563+            else (P == s)))
564+        then true
565+        else !((bu.caller == this)))
566+        then throw(("Invalid internalCreateOrder parameters " + cG))
567+        else {
568+            let aj = (aa() + 1)
569+            let cH = aE(aU, P)
570+            let cu = (ab(R, S) + 1)
571+            let cm = aH(R, S, cH)
572+            let aI = if (if (if ((cm == 0))
573+                then true
574+                else if ((cm > 0))
575+                    then (aU == t)
576+                    else false)
577+                then true
578+                else if ((0 > cm))
579+                    then (aU == u)
580+                    else false)
581+                then v
582+                else w
583+            if (if ((cm == 0))
584+                then if ((P == q))
585+                    then true
586+                    else (P == r)
587+                else false)
588+                then throw("Can not create STOP/TAKE order: no position")
589+                else {
590+                    let cI = if ((aI == v))
591+                        then if (if ((cv != toBase58String(V())))
592+                            then true
593+                            else (cw != aQ))
594+                            then throw("Invalid createLimitOrder parameters: invalid payment")
595+                            else {
596+                                let cJ = invoke(W(), "deposit", nil, [AttachedPayment(V(), cw)])
597+                                if ((cJ == cJ))
598+                                    then cw
599+                                    else throw("Strict value is not equal to itself.")
600+                                }
601+                        else 0
602+                    if ((cI == cI))
603+                        then {
604+                            let ax = if ((cm != 0))
605+                                then aL(R, S, cH)
606+                                else 0
607+                            if (if (if ((P == q))
608+                                then true
609+                                else (P == r))
610+                                then (ax == 0)
611+                                else false)
612+                                then throw("STOP and TAKE order should be assigned to position with id != 0")
613+                                else if ((cu > x))
614+                                    then throw("Invalid createLimitOrder parameters: order count")
615+                                    else {
616+                                        let cK = (((aP(aj, R, S, aQ, aR, P, aS, cI, aU, aV, ax, aX) ++ bg(aj, R, S, true)) ++ bj(R, S, cu)) ++ bl(aj))
617+                                        $Tuple2(cK, aj)
618+                                        }
619+                            }
620+                        else throw("Strict value is not equal to itself.")
621+                    }
622+            }
623+    }
624+
625+
626+
627+@Callable(bu)
628+func cancelOrder (L) = {
629+    let cL = ap(L)
630+    let R = cL._1
631+    let S = cL._2
632+    let aQ = cL._3
633+    let aR = cL._4
634+    let P = cL._5
635+    let aS = cL._6
636+    let cM = cL._7
637+    let aU = cL._8
638+    let aV = cL._9
639+    let aW = cL._10
640+    let aX = cL._11
641+    if (if (if (!(Y()))
642+        then true
643+        else !(Z(L)))
644+        then true
645+        else !((toString(bu.caller) == S)))
646+        then throw("Invalid cancelOrder parameters")
647+        else {
648+            let cc = invoke(this, "cleanUpStaleOrders", [R, S], nil)
649+            if ((cc == cc))
650+                then {
651+                    let cu = (ab(R, S) - 1)
652+                    let cN = if ((cM > 0))
653+                        then {
654+                            let cO = invoke(W(), "withdraw", [toBase58String(V()), cM], nil)
655+                            if ((cO == cO))
656+                                then nil
657+                                else throw("Strict value is not equal to itself.")
658+                            }
659+                        else nil
660+                    if ((cN == cN))
661+                        then (((bo(L) ++ bg(L, R, S, false)) ++ bj(R, S, cu)) ++ (if ((cM > 0))
662+                            then [ScriptTransfer(bu.caller, cM, V())]
663+                            else nil))
664+                        else throw("Strict value is not equal to itself.")
665+                    }
666+                else throw("Strict value is not equal to itself.")
667+            }
668+    }
669+
670+
671+
672+@Callable(bu)
673+func executeOrder (L) = {
674+    let cP = ap(L)
675+    let R = cP._1
676+    let S = cP._2
677+    let aQ = cP._3
678+    let aR = cP._4
679+    let P = cP._5
680+    let aS = cP._6
681+    let cM = cP._7
682+    let aU = cP._8
683+    let aV = cP._9
684+    let aW = cP._10
685+    let aX = cP._11
686+    let cc = invoke(this, "cleanUpStaleOrders", [R, S], nil)
687+    if ((cc == cc))
688+        then {
689+            let cH = aE(aU, P)
690+            if (if (!(Y()))
691+                then true
692+                else !(Z(L)))
693+                then throw("Invalid executeOrder parameters")
694+                else {
695+                    let cm = aH(R, S, cH)
696+                    if ((cm == cm))
697+                        then {
698+                            let cQ = if ((cm != 0))
699+                                then aL(R, S, cH)
700+                                else 0
701+                            let cR = if ((P == q))
702+                                then {
703+                                    let cS = if ((cm > 0))
704+                                        then t
705+                                        else if ((0 > cm))
706+                                            then u
707+                                            else throw("Can not execute STOP order: no open position")
708+                                    let cT = ay(R)
709+                                    let cU = if ((aU == cS))
710+                                        then throw("Can not execute STOP order: reduce only")
711+                                        else if ((cQ != aW))
712+                                            then throw("Can not execute STOP order: position closed")
713+                                            else if ((cS == t))
714+                                                then (aS >= cT)
715+                                                else (cT >= aS)
716+                                    if (cU)
717+                                        then $Tuple3("closePosition", [G(aQ, B(cm)), cH, F(aX, B(cm)), false], nil)
718+                                        else throw("Can not execute STOP order: triggerPrice mismatch")
719+                                    }
720+                                else if ((P == r))
721+                                    then {
722+                                        let cS = if ((cm > 0))
723+                                            then t
724+                                            else if ((0 > cm))
725+                                                then u
726+                                                else throw("Can not execute STOP order: no open position")
727+                                        let cT = ay(R)
728+                                        let cU = if ((aU == cS))
729+                                            then throw("Can not execute TAKE order: reduce only")
730+                                            else if ((cQ != aW))
731+                                                then throw(((("Can not execute TAKE order: position closed " + toString(cQ)) + "!=") + toString(aW)))
732+                                                else if ((cS == t))
733+                                                    then (cT >= aS)
734+                                                    else (aS >= cT)
735+                                        if (cU)
736+                                            then $Tuple3("closePosition", [G(aQ, B(cm)), cH, F(aX, B(cm)), false], nil)
737+                                            else throw("Can not execute TAKE order: triggerPrice mismatch")
738+                                        }
739+                                    else if ((P == s))
740+                                        then {
741+                                            let cT = ay(R)
742+                                            let cV = if ((aX == 0))
743+                                                then aN(aS)
744+                                                else B((aS - aX))
745+                                            let cU = if ((cT >= (aS - cV)))
746+                                                then ((aS + cV) >= cT)
747+                                                else false
748+                                            if (cU)
749+                                                then {
750+                                                    let cW = (cM - F(cM, aD(R, S)))
751+                                                    $Tuple3("increasePosition", [aU, aR, if ((aX == 0))
752+                                                        then 0
753+                                                        else D(cW, aX), aV], [AttachedPayment(V(), cM)])
754+                                                    }
755+                                                else throw("Can not execute LIMIT order: triggerPrice mismatch")
756+                                            }
757+                                        else throw(("Invalid order type: " + toString(P)))
758+                            let cX = cR._1
759+                            let cY = cR._2
760+                            let cZ = cR._3
761+                            let cN = if ((size(cZ) == 1))
762+                                then {
763+                                    let cO = invoke(W(), "withdraw", [toBase58String(V()), cZ[0].amount], nil)
764+                                    if ((cO == cO))
765+                                        then nil
766+                                        else throw("Strict value is not equal to itself.")
767+                                    }
768+                                else nil
769+                            if ((cN == cN))
770+                                then {
771+                                    let cn = invoke(this, "setContext", [S], nil)
772+                                    if ((cn == cn))
773+                                        then {
774+                                            let co = invoke(addressFromStringValue(R), cX, cY, cZ)
775+                                            if ((co == co))
776+                                                then {
777+                                                    let cp = invoke(this, "resetContext", nil, nil)
778+                                                    if ((cp == cp))
779+                                                        then {
780+                                                            let da = if ((P == s))
781+                                                                then {
782+                                                                    let db = aH(R, S, cH)
783+                                                                    if ((db == db))
784+                                                                        then {
785+                                                                            let dc = aL(R, S, cH)
786+                                                                            if ((dc == dc))
787+                                                                                then {
788+                                                                                    let dd = (db - cm)
789+                                                                                    let de = if ((db > 0))
790+                                                                                        then u
791+                                                                                        else t
792+                                                                                    let df = if (af(L, r))
793+                                                                                        then {
794+                                                                                            let dg = ag(L, r)
795+                                                                                            let dh = dg._1
796+                                                                                            let di = dg._2
797+                                                                                            let dj = dg._3
798+                                                                                            let dk = dg._4
799+                                                                                            let dl = dg._5
800+                                                                                            let dm = dg._6
801+                                                                                            let cg = invoke(this, "internalCreateOrder", [dj, di, dk, dl, dm, dd, 0, de, "", "", 0], nil)
802+                                                                                            if ((cg == cg))
803+                                                                                                then nil
804+                                                                                                else throw("Strict value is not equal to itself.")
805+                                                                                            }
806+                                                                                        else nil
807+                                                                                    if ((df == df))
808+                                                                                        then {
809+                                                                                            let dn = if (af(L, q))
810+                                                                                                then {
811+                                                                                                    let do = ag(L, q)
812+                                                                                                    let dh = do._1
813+                                                                                                    let di = do._2
814+                                                                                                    let dj = do._3
815+                                                                                                    let dk = do._4
816+                                                                                                    let dl = do._5
817+                                                                                                    let dm = do._6
818+                                                                                                    let cg = invoke(this, "internalCreateOrder", [dj, di, dk, dl, dm, dd, 0, de, "", "", 0], nil)
819+                                                                                                    if ((cg == cg))
820+                                                                                                        then nil
821+                                                                                                        else throw("Strict value is not equal to itself.")
822+                                                                                                    }
823+                                                                                                else nil
824+                                                                                            if ((dn == dn))
825+                                                                                                then (df ++ dn)
826+                                                                                                else throw("Strict value is not equal to itself.")
827+                                                                                            }
828+                                                                                        else throw("Strict value is not equal to itself.")
829+                                                                                    }
830+                                                                                else throw("Strict value is not equal to itself.")
831+                                                                            }
832+                                                                        else throw("Strict value is not equal to itself.")
833+                                                                    }
834+                                                                else nil
835+                                                            if ((da == da))
836+                                                                then {
837+                                                                    let dp = invoke(this, "internalMarkOrderExecuted", [R, S, L], nil)
838+                                                                    if ((dp == dp))
839+                                                                        then nil
840+                                                                        else throw("Strict value is not equal to itself.")
841+                                                                    }
842+                                                                else throw("Strict value is not equal to itself.")
843+                                                            }
844+                                                        else throw("Strict value is not equal to itself.")
845+                                                    }
846+                                                else throw("Strict value is not equal to itself.")
847+                                            }
848+                                        else throw("Strict value is not equal to itself.")
849+                                    }
850+                                else throw("Strict value is not equal to itself.")
851+                            }
852+                        else throw("Strict value is not equal to itself.")
853+                    }
854+            }
855+        else throw("Strict value is not equal to itself.")
856+    }
857+
858+
859+
860+@Callable(bu)
861+func view_canExecuteOrder (L) = {
862+    let az = invoke(this, "executeOrder", [L], nil)
863+    if ((az == az))
864+        then throw("Success")
865+        else throw("Strict value is not equal to itself.")
866+    }
867+
868+
869+@Verifier(dq)
870+func dr () = {
871+    let ds = getString(this, a)
872+    if (isDefined(ds))
873+        then {
874+            let dt = getString(addressFromStringValue(value(ds)), b)
875+            if (isDefined(dt))
876+                then valueOrElse(getBoolean(addressFromStringValue(value(dt)), ((("status_" + toString(this)) + "_") + toBase58String(dq.id))), false)
877+                else throw("unable to verify: admin not set in coordinator")
878+            }
879+        else sigVerify(dq.bodyBytes, dq.proofs[0], dq.senderPublicKey)
880+    }
881+
github/deemru/w8io/169f3d6 
43.02 ms ◑