tx · Dqrdruvx4MmzEGy78Z8EFAKvhELD8H1BxwgCGpKZK1BC

3MyM6UZg9qXSpDxpZ6tc2XFfvndZHi22TqK:  -0.04400000 Waves

2023.06.28 14:57 [2642473] smart account 3MyM6UZg9qXSpDxpZ6tc2XFfvndZHi22TqK > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "Dqrdruvx4MmzEGy78Z8EFAKvhELD8H1BxwgCGpKZK1BC",
    "fee": 4400000,
    "feeAssetId": null,
    "timestamp": 1687953505904,
    "version": 2,
    "chainId": 84,
    "sender": "3MyM6UZg9qXSpDxpZ6tc2XFfvndZHi22TqK",
    "senderPublicKey": "961roB8rgPYYCiFpr96acNdDcgXUwDLeGnDC9ivvzn3M",
    "proofs": [
        "5gUYy3YGbG7rHJjuJGhUXVrmsogP6JtvVhkfo3iYgnSC16vmAFUkgcqANNXAjwhG9THX8KTFANV8aFpShW7ugsmv"
    ],
    "script": "base64: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",
    "height": 2642473,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: none
Next: 8ct2dyYDfnmWiHhEwzHdhCTT3x4r5uRTwiJpg9yhWF4P

Full: 

OldNewDifferences
1-# no script
1+{-# STDLIB_VERSION 6 #-}
2+{-# SCRIPT_TYPE ACCOUNT #-}
3+{-# CONTENT_TYPE DAPP #-}
4+let a = "SF"
5+
6+let b = "WX"
7+
8+let c = "capNoLoan"
9+
10+let d = "capLoan"
11+
12+let e = "stopLossNoLoan"
13+
14+let f = "stopLossLoan"
15+
16+let g = "loan"
17+
18+let h = "noLoan"
19+
20+let i = "noFee"
21+
22+let j = 100000000
23+
24+let k = 10000000000
25+
26+let l = toBigInt(10000000000000000)
27+
28+let m = 1000000
29+
30+let n = "A_asset_balance"
31+
32+let o = "B_asset_balance"
33+
34+let p = "A_asset_id"
35+
36+let q = "B_asset_id"
37+
38+let r = "share_asset_id"
39+
40+let s = "share_asset_supply"
41+
42+let t = "commission"
43+
44+let u = "_user_position"
45+
46+let v = "_user_position_pool"
47+
48+let w = "_user_position_borrow_amount"
49+
50+let x = "_user_position_borrow_asset_id"
51+
52+let y = "_user_position_number"
53+
54+let z = "_user_position_interest"
55+
56+let A = "_pool_total"
57+
58+let B = "_pool_total_loan"
59+
60+let C = "_pool_interest_loan"
61+
62+let D = "_pool_interest_no_loan"
63+
64+let E = "_pool_can_borrow"
65+
66+let F = "_axly_fee_without_loan"
67+
68+let G = "_axly_fee_with_loan"
69+
70+let H = "_axly_fee_cap_with_loan"
71+
72+let I = "_axly_fee_cap_no_loan"
73+
74+let J = "_axly_fee_stoploss_with_loan"
75+
76+let K = "_axly_fee_stoploss_no_loan"
77+
78+let L = "_request_id"
79+
80+let M = "requests_iter"
81+
82+let N = "pool_"
83+
84+let O = "_pool_share_id"
85+
86+let P = "_pool_cap_change"
87+
88+let Q = "last_price"
89+
90+let R = "_stop_loss"
91+
92+let S = "axly_money_box"
93+
94+let T = "swopfi_farming_addr"
95+
96+let U = "lend_service_addr"
97+
98+let V = "admin_call_pub_key"
99+
100+let W = "price_oracle"
101+
102+let X = "exchange_contract"
103+
104+let Y = "wx_swap_contract"
105+
106+let Z = "swop_id"
107+
108+let aa = "wx_id"
109+
110+let ab = Address(fromBase58String(valueOrErrorMessage(getString(this, S), "No axly moneyBox address")))
111+
112+let ac = Address(fromBase58String(valueOrErrorMessage(getString(this, X), "No exchange contract address")))
113+
114+let ad = Address(fromBase58String(valueOrErrorMessage(getString(this, W), "No price oracle address")))
115+
116+let ae = Address(fromBase58String(valueOrErrorMessage(getString(this, Y), "No wx swap address")))
117+
118+let af = fromBase58String(valueOrErrorMessage(getString(this, Z), "No swop id"))
119+
120+let ag = fromBase58String(valueOrErrorMessage(getString(this, aa), "No wx id"))
121+
122+func ah () = Address(fromBase58String(valueOrErrorMessage(getString(this, U), "Can't get lend service addr")))
123+
124+
125+func ai () = addressFromPublicKey(fromBase58String(valueOrErrorMessage(getString(this, V), "Can't get admin addr")))
126+
127+
128+func aj (ak) = if ((ak.caller == ai()))
129+    then unit
130+    else throw("Only admin can call this function")
131+
132+
133+func al (ak) = if ((ak.caller == this))
134+    then unit
135+    else throw("Only contract itself can call this function")
136+
137+
138+func am (ak) = if ((ak.caller == ah()))
139+    then unit
140+    else throw("Only land contract can call this function")
141+
142+
143+func an (ao) = {
144+    let ap = ao
145+    if ($isInstanceOf(ap, "ByteVector"))
146+        then {
147+            let aq = ap
148+            assetBalance(this, aq)
149+            }
150+        else if ($isInstanceOf(ap, "Unit"))
151+            then {
152+                let ar = ap
153+                wavesBalance(this).available
154+                }
155+            else throw("Match error")
156+    }
157+
158+
159+func as (at) = $Tuple5(valueOrErrorMessage(getString(at, p), "Can't get pool A asset id"), valueOrErrorMessage(getString(at, q), "Can't get pool B asset id"), valueOrErrorMessage(getInteger(at, n), "Can't get pool A asset balance"), valueOrErrorMessage(getInteger(at, o), "Can't get pool B asset balance"), valueOrErrorMessage(getString(at, r), "Can't get share asset id"))
160+
161+
162+func au (at) = {
163+    let av = {
164+        let aw = invoke(at, "getPoolConfigWrapperREADONLY", nil, nil)
165+        if ($isInstanceOf(aw, "List[Any]"))
166+            then aw
167+            else throw(($getType(aw) + " couldn't be cast to List[Any]"))
168+        }
169+    if ((av == av))
170+        then {
171+            let ax = valueOrErrorMessage({
172+                let aw = av[4]
173+                if ($isInstanceOf(aw, "String"))
174+                    then aw
175+                    else unit
176+                }, "Can't get pool A asset id")
177+            let ay = valueOrErrorMessage({
178+                let aw = av[5]
179+                if ($isInstanceOf(aw, "String"))
180+                    then aw
181+                    else unit
182+                }, "Can't get pool B asset id")
183+            let az = valueOrErrorMessage({
184+                let aw = av[3]
185+                if ($isInstanceOf(aw, "String"))
186+                    then aw
187+                    else unit
188+                }, "Can't get pool LP asset id")
189+            let aA = {
190+                let aw = invoke(at, "getAccBalanceWrapperREADONLY", [ax], nil)
191+                if ($isInstanceOf(aw, "Int"))
192+                    then aw
193+                    else throw(($getType(aw) + " couldn't be cast to Int"))
194+                }
195+            if ((aA == aA))
196+                then {
197+                    let aB = {
198+                        let aw = invoke(at, "getAccBalanceWrapperREADONLY", [ay], nil)
199+                        if ($isInstanceOf(aw, "Int"))
200+                            then aw
201+                            else throw(($getType(aw) + " couldn't be cast to Int"))
202+                        }
203+                    if ((aB == aB))
204+                        then $Tuple5(ax, ay, aA, aB, az)
205+                        else throw("Strict value is not equal to itself.")
206+                    }
207+                else throw("Strict value is not equal to itself.")
208+            }
209+        else throw("Strict value is not equal to itself.")
210+    }
211+
212+
213+func aC (at,aD) = if ((aD == a))
214+    then as(at)
215+    else if ((aD == b))
216+        then au(at)
217+        else throw("Wrong pool type")
218+
219+
220+func aE (at,aD,az) = if ((aD == a))
221+    then valueOrErrorMessage(getInteger(at, s), "Can't get share asset supply")
222+    else if ((aD == b))
223+        then valueOrErrorMessage(assetInfo(fromBase58String(az)), "Wrong ShareId").quantity
224+        else throw("Wrong pool type")
225+
226+
227+func aF (aG) = valueOrElse(getInteger(this, (aG + A)), 0)
228+
229+
230+func aH (aG) = valueOrElse(getInteger(this, (aG + B)), 0)
231+
232+
233+func aI (aJ) = (valueOrElse(getInteger(this, (aJ + y)), 0) + 1)
234+
235+
236+func aK (aG,aL) = if ((aL == d))
237+    then getIntegerValue(this, (aG + I))
238+    else if ((aL == c))
239+        then getIntegerValue(this, (aG + H))
240+        else if ((aL == g))
241+            then getIntegerValue(this, (aG + G))
242+            else if ((aL == h))
243+                then getIntegerValue(this, (aG + F))
244+                else if ((aL == i))
245+                    then 0
246+                    else throw("Wrong fee type")
247+
248+
249+func aM () = Address(fromBase58String(valueOrErrorMessage(getString(this, T), "Can't get swopfi farming addr")))
250+
251+
252+func aN (at) = {
253+    let aO = Address(fromBase58String(valueOrErrorMessage(getString(at, "%s__factoryContract"), "Can't get WX factory contract addr")))
254+    let aP = split(valueOrErrorMessage(getString(aO, "%s__factoryConfig"), "Can't get WX factory cfg"), "__")
255+    Address(fromBase58String(aP[1]))
256+    }
257+
258+
259+func aQ (ao) = {
260+    let ap = ao
261+    if ($isInstanceOf(ap, "ByteVector"))
262+        then {
263+            let aq = ap
264+            toBase58String(aq)
265+            }
266+        else if ($isInstanceOf(ap, "Unit"))
267+            then {
268+                let ar = ap
269+                "WAVES"
270+                }
271+            else throw("Not Asset id")
272+    }
273+
274+
275+func aR (ao) = if ((ao == "WAVES"))
276+    then unit
277+    else fromBase58String(ao)
278+
279+
280+func aS (ao) = if ((ao == "WAVES"))
281+    then 8
282+    else {
283+        let ap = assetInfo(fromBase58String(ao))
284+        if ($isInstanceOf(ap, "Asset"))
285+            then {
286+                let aT = ap
287+                aT.decimals
288+                }
289+            else throw("Can't find asset")
290+        }
291+
292+
293+func aU (ao) = pow(10, 0, aS(ao), 0, 0, DOWN)
294+
295+
296+func aV (aW) = {
297+    func aX (aY,ao) =     {
298+        let aZ = (        let aw = invoke(ad, "getTWAP60", [ao, false], nil)
299+        if ($isInstanceOf(aw, "(Int, Int)"))
300+            then aw
301+            else throw(($getType(aw) + " couldn't be cast to (Int, Int)")))._2
302+        (aY :+ aZ)
303+        }
304+
305+    let ba = aW
306+    let bb = size(ba)
307+    let bc = nil
308+    func bd (be,bf) =     if ((bf >= bb))
309+        then be
310+        else aX(be, ba[bf])
311+
312+    func bg (be,bf) =     if ((bf >= bb))
313+        then be
314+        else throw("List size exceeds 50")
315+
316+    bg(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bc, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20), 21), 22), 23), 24), 25), 26), 27), 28), 29), 30), 31), 32), 33), 34), 35), 36), 37), 38), 39), 40), 41), 42), 43), 44), 45), 46), 47), 48), 49), 50)
317+    }
318+
319+
320+func bh (az) = {
321+    let aG = valueOrErrorMessage(getString(this, (az + O)), "Can't find pool addr by share id")
322+    let at = Address(fromBase58String(aG))
323+    let bi = valueOrErrorMessage(getString(this, (N + aG)), "Pool is not inited")
324+    let bj = aC(at, bi)
325+    let ax = bj._1
326+    let ay = bj._2
327+    let bk = bj._3
328+    let bl = bj._4
329+    let bm = (    let aw = invoke(ad, "getTWAP60", [ax, false], nil)
330+    if ($isInstanceOf(aw, "(Int, Int)"))
331+        then aw
332+        else throw(($getType(aw) + " couldn't be cast to (Int, Int)")))._2
333+    let bn = (    let aw = invoke(ad, "getTWAP60", [ay, false], nil)
334+    if ($isInstanceOf(aw, "(Int, Int)"))
335+        then aw
336+        else throw(($getType(aw) + " couldn't be cast to (Int, Int)")))._2
337+    let bo = aE(at, bi, az)
338+    let bp = pow(10, 0, aS(ax), 0, 0, DOWN)
339+    let bq = pow(10, 0, aS(ay), 0, 0, DOWN)
340+    let br = pow(10, 0, aS(az), 0, 0, DOWN)
341+    let bs = (fraction(bk, bm, bp) + fraction(bl, bn, bq))
342+    fraction(bs, br, bo)
343+    }
344+
345+
346+func bt (bu) = {
347+    func aX (aY,az) =     (aY :+ bh(az))
348+
349+    let ba = bu
350+    let bb = size(ba)
351+    let bc = nil
352+    func bd (be,bf) =     if ((bf >= bb))
353+        then be
354+        else aX(be, ba[bf])
355+
356+    func bg (be,bf) =     if ((bf >= bb))
357+        then be
358+        else throw("List size exceeds 20")
359+
360+    bg(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bc, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
361+    }
362+
363+
364+func bv (ax,ay,az) = {
365+    let bw = aV([ax, ay])
366+    let bx = bh(az)
367+    let by = [toString(bw[0]), toString(bw[1]), toString(bx)]
368+[StringEntry(Q, makeString(by, ","))]
369+    }
370+
371+
372+func bz (bi,at,bA,ax,bB,ay,aA,aB) = if ((bi == a))
373+    then {
374+        let bC = {
375+            let aw = invoke(at, "callFunction", ["calcLPReplenishTwoTokensREADONLY", [toString(bA), toString(bB)]], nil)
376+            if ($isInstanceOf(aw, "List[Any]"))
377+                then aw
378+                else throw(($getType(aw) + " couldn't be cast to List[Any]"))
379+            }
380+        if ((bC == bC))
381+            then $Tuple5({
382+                let aw = bC[3]
383+                if ($isInstanceOf(aw, "Int"))
384+                    then aw
385+                    else throw(($getType(aw) + " couldn't be cast to Int"))
386+                }, {
387+                let aw = bC[4]
388+                if ($isInstanceOf(aw, "Int"))
389+                    then aw
390+                    else throw(($getType(aw) + " couldn't be cast to Int"))
391+                }, {
392+                let aw = bC[1]
393+                if ($isInstanceOf(aw, "Int"))
394+                    then aw
395+                    else throw(($getType(aw) + " couldn't be cast to Int"))
396+                }, aQ(bC[2]), {
397+                let aw = bC[0]
398+                if ($isInstanceOf(aw, "Int"))
399+                    then aw
400+                    else throw(($getType(aw) + " couldn't be cast to Int"))
401+                })
402+            else throw("Strict value is not equal to itself.")
403+        }
404+    else {
405+        let bD = $Tuple2(split({
406+            let aw = invoke(at, "evaluatePutByAmountAssetREADONLY", [bA], nil)
407+            if ($isInstanceOf(aw, "String"))
408+                then aw
409+                else throw(($getType(aw) + " couldn't be cast to String"))
410+            }, "__"), split({
411+            let aw = invoke(at, "evaluatePutByPriceAssetREADONLY", [bB], nil)
412+            if ($isInstanceOf(aw, "String"))
413+                then aw
414+                else throw(($getType(aw) + " couldn't be cast to String"))
415+            }, "__"))
416+        if ((bD == bD))
417+            then {
418+                let bE = bD._2
419+                let bF = bD._1
420+                let bG = parseIntValue(bF[1])
421+                let bH = parseIntValue(bE[1])
422+                if ((bH > bG))
423+                    then {
424+                        let bI = parseIntValue(bF[8])
425+                        $Tuple5(bA, bI, (bB - bI), ay, bH)
426+                        }
427+                    else {
428+                        let bI = parseIntValue(bF[8])
429+                        $Tuple5(bI, bB, (bA - bI), ax, bG)
430+                        }
431+                }
432+            else throw("Strict value is not equal to itself.")
433+        }
434+
435+
436+func bJ (at,bi,bA,ax,bB,ay) = {
437+    let bK = [AttachedPayment(aR(ax), bA), AttachedPayment(aR(ay), bB)]
438+    if ((bi == a))
439+        then invoke(at, "callFunction", ["replenishWithTwoTokens", ["false", "0"]], bK)
440+        else invoke(at, "put", [1000000, false], bK)
441+    }
442+
443+
444+func bL (at,bi,bI,bM) = {
445+    let bK = [AttachedPayment(aR(bM), bI)]
446+    if ((bi == a))
447+        then invoke(at, "callFunction", ["replenishWithOneToken", ["0", "false", "0"]], bK)
448+        else invoke(at, "putOneTkn", [0, false], bK)
449+    }
450+
451+
452+func bN (aG,bi,az,bO) = {
453+    let bK = [AttachedPayment(fromBase58String(az), bO)]
454+    if ((bi == a))
455+        then invoke(aM(), "lockShareTokens", [aG, 0], bK)
456+        else invoke(aN(addressFromStringValue(aG)), "stake", nil, bK)
457+    }
458+
459+
460+func bP (aG,bi,az,bO) = {
461+    let bQ = if ((bi == a))
462+        then $Tuple3(aM(), "withdrawShareTokens", [aG, bO])
463+        else if ((bi == b))
464+            then $Tuple3(aN(Address(fromBase58String(aG))), "unstake", [az, bO])
465+            else throw("Wrong pool type")
466+    let bR = bQ._1
467+    let bS = bQ._2
468+    let bT = bQ._3
469+    let bU = invoke(bR, bS, bT, nil)
470+    if ((bU == bU))
471+        then bO
472+        else throw("Strict value is not equal to itself.")
473+    }
474+
475+
476+func bV (aG,bW,bX,aA,aB,bY,bZ) = {
477+    let at = Address(fromBase58String(aG))
478+    let ca = 1000000
479+    let cb = getIntegerValue(at, t)
480+    let cc = fraction(bY, ca, (ca - cb))
481+    let cd = if ((bZ == bW))
482+        then {
483+            let ce = fraction(cc, aB, (aA - cc))
484+            $Tuple2(ce, bX)
485+            }
486+        else {
487+            let ce = fraction(cc, aA, (aB - cc))
488+            $Tuple2(ce, bW)
489+            }
490+    let ce = cd._1
491+    let cf = cd._2
492+    $Tuple2(cf, ce)
493+    }
494+
495+
496+func cg (aG,bW,bX,aA,aB,bY,bZ) = {
497+    let ch = getIntegerValue(ae, "%s__protocolFee")
498+    let ci = getIntegerValue(ae, "%s__poolFee")
499+    let cj = toBigInt(100000000)
500+    let ck = if ((bZ == bW))
501+        then {
502+            let ce = fraction(bY, aB, (aA - bY))
503+            $Tuple2(ce, bX)
504+            }
505+        else {
506+            let ce = fraction(bY, aA, (aB - bY))
507+            $Tuple2(ce, bW)
508+            }
509+    let ce = ck._1
510+    let cf = ck._2
511+    let cl = toInt(fraction(toBigInt(ce), cj, (cj - toBigInt((ch + ci))), CEILING))
512+    $Tuple2(cf, fraction(cl, 102, 100))
513+    }
514+
515+
516+func cm (aD,aG,bW,bX,aA,aB,bY,bZ) = if ((aD == a))
517+    then {
518+        let cn = bV(aG, bW, bX, aA, aB, bY, bZ)
519+        let cf = cn._1
520+        let ce = cn._2
521+        invoke(addressFromStringValue(aG), "callFunction", ["exchange", [toString(bY)]], [AttachedPayment(aR(cf), ce)])
522+        }
523+    else {
524+        let co = cg(aG, bW, bX, aA, aB, bY, bZ)
525+        let cf = co._1
526+        let ce = co._2
527+        invoke(ae, "swap", [bY, bZ, toString(this)], [AttachedPayment(aR(cf), ce)])
528+        }
529+
530+
531+func cp (bi,aG,bA,ax,bB,ay,aA,aB) = {
532+    let at = addressFromStringValue(aG)
533+    if ((bi == a))
534+        then {
535+            let bU = {
536+                let aw = invoke(at, "callFunction", ["calcLPReplenishDiffPropREADONLY", [toString(bA), toString(bB), "0"]], nil)
537+                if ($isInstanceOf(aw, "List[Any]"))
538+                    then aw
539+                    else throw(($getType(aw) + " couldn't be cast to List[Any]"))
540+                }
541+            if ((bU == bU))
542+                then $Tuple2({
543+                    let aw = bU[0]
544+                    if ($isInstanceOf(aw, "Int"))
545+                        then aw
546+                        else throw(($getType(aw) + " couldn't be cast to Int"))
547+                    }, {
548+                    let aw = bU[1]
549+                    if ($isInstanceOf(aw, "Int"))
550+                        then aw
551+                        else throw(($getType(aw) + " couldn't be cast to Int"))
552+                    })
553+                else throw("Strict value is not equal to itself.")
554+            }
555+        else if ((bi == b))
556+            then {
557+                let cq = if (if ((bA > 0))
558+                    then (bB > 0)
559+                    else false)
560+                    then {
561+                        let cr = bz(bi, at, bA, ax, bB, ay, aA, aB)
562+                        let cs = cr._1
563+                        let ct = cr._2
564+                        let cu = cr._3
565+                        let cv = cr._4
566+                        let cw = cr._5
567+                        $Tuple3(cu, cv, cw)
568+                        }
569+                    else if ((bA > 0))
570+                        then $Tuple3(bA, ax, 0)
571+                        else $Tuple3(bB, ay, 0)
572+                let cu = cq._1
573+                let cv = cq._2
574+                let cx = cq._3
575+                let cy = if ((cu > 0))
576+                    then {
577+                        let bU = {
578+                            let aw = invoke(at, "putOneTknREADONLY", [cv, cu], nil)
579+                            if ($isInstanceOf(aw, "(Int, Int, Int)"))
580+                                then aw
581+                                else throw(($getType(aw) + " couldn't be cast to (Int, Int, Int)"))
582+                            }
583+                        if ((bU == bU))
584+                            then $Tuple2(bU._1, bU._3)
585+                            else throw("Strict value is not equal to itself.")
586+                        }
587+                    else $Tuple2(0, 0)
588+                let cz = cy._1
589+                let cA = cy._2
590+                $Tuple2((cx + cz), cA)
591+                }
592+            else throw("Wrong pool type")
593+    }
594+
595+
596+func cB (bi,aG,cw,az,ax,ay,aA,aB,cC,cD) = {
597+    let at = addressFromStringValue(aG)
598+    let cE = if ((bi == a))
599+        then {
600+            let bU = {
601+                let aw = invoke(at, "callFunction", ["withdrawREADONLY", [toString(cw), toString(aA), toString(aB)]], nil)
602+                if ($isInstanceOf(aw, "List[Any]"))
603+                    then aw
604+                    else throw(($getType(aw) + " couldn't be cast to List[Any]"))
605+                }
606+            if ((bU == bU))
607+                then $Tuple2({
608+                    let aw = bU[0]
609+                    if ($isInstanceOf(aw, "Int"))
610+                        then aw
611+                        else throw(($getType(aw) + " couldn't be cast to Int"))
612+                    }, {
613+                    let aw = bU[1]
614+                    if ($isInstanceOf(aw, "Int"))
615+                        then aw
616+                        else throw(($getType(aw) + " couldn't be cast to Int"))
617+                    })
618+                else throw("Strict value is not equal to itself.")
619+            }
620+        else if ((bi == b))
621+            then {
622+                let cF = split({
623+                    let aw = invoke(at, "evaluateGetREADONLY", [az, cw], nil)
624+                    if ($isInstanceOf(aw, "String"))
625+                        then aw
626+                        else throw(($getType(aw) + " couldn't be cast to String"))
627+                    }, "__")
628+                if ((cF == cF))
629+                    then $Tuple2(parseIntValue(cF[1]), parseIntValue(cF[2]))
630+                    else throw("Strict value is not equal to itself.")
631+                }
632+            else throw("Wrong pool type")
633+    let cG = cE._1
634+    let cH = cE._2
635+    if ((cC > 0))
636+        then {
637+            let cI = if (if ((cD == ax))
638+                then (cC > cG)
639+                else false)
640+                then (cC - cG)
641+                else if (if ((cD == ay))
642+                    then (cC > cH)
643+                    else false)
644+                    then (cC - cH)
645+                    else 0
646+            let cJ = if ((cI > 0))
647+                then if ((bi == a))
648+                    then bV(aG, ax, ay, aA, aB, cI, cD)
649+                    else cg(aG, ax, ay, aA, aB, cI, cD)
650+                else $Tuple2("", 0)
651+            let cf = cJ._1
652+            let ce = cJ._2
653+            if ((cD == ax))
654+                then $Tuple2(((cG + cI) - cC), (cH - ce))
655+                else $Tuple2((cG - ce), ((cH + cI) - cC))
656+            }
657+        else $Tuple2(cG, cH)
658+    }
659+
660+
661+func cK (aD,aG) = if ((aD == a))
662+    then {
663+        let cL = an(af)
664+        if ((cL == cL))
665+            then {
666+                let bU = invoke(aM(), "claim", [aG], nil)
667+                if ((bU == bU))
668+                    then {
669+                        let cM = an(af)
670+                        $Tuple2((cM - cL), af)
671+                        }
672+                    else throw("Strict value is not equal to itself.")
673+                }
674+            else throw("Strict value is not equal to itself.")
675+        }
676+    else if ((aD == b))
677+        then {
678+            let cL = an(ag)
679+            if ((cL == cL))
680+                then {
681+                    let bU = invoke(aN(Address(fromBase58String(aG))), "claimWX", [aG], nil)
682+                    if ((bU == bU))
683+                        then {
684+                            let cM = an(ag)
685+                            $Tuple2((cM - cL), ag)
686+                            }
687+                        else throw("Strict value is not equal to itself.")
688+                    }
689+                else throw("Strict value is not equal to itself.")
690+            }
691+        else throw("Wrong pool type")
692+
693+
694+func cN (bi,aG,aL,bA,ax,bB,ay,aA,aB,cO) = {
695+    let cP = an(fromBase58String(cO))
696+    if ((cP == cP))
697+        then {
698+            let at = addressFromStringValue(aG)
699+            let cQ = if (if ((bA > 0))
700+                then (bB > 0)
701+                else false)
702+                then {
703+                    let cR = bz(bi, at, bA, ax, bB, ay, aA, aB)
704+                    let cs = cR._1
705+                    let ct = cR._2
706+                    let cu = cR._3
707+                    let cv = cR._4
708+                    let bU = bJ(at, bi, cs, ax, ct, ay)
709+                    if ((bU == bU))
710+                        then $Tuple2(cu, cv)
711+                        else throw("Strict value is not equal to itself.")
712+                    }
713+                else if ((bA > 0))
714+                    then $Tuple2(bA, ax)
715+                    else if ((bB > 0))
716+                        then $Tuple2(bB, ay)
717+                        else throw("pmts must be > 0")
718+            let cu = cQ._1
719+            let cv = cQ._2
720+            let bU = if ((cu > 0))
721+                then bL(at, bi, cu, cv)
722+                else nil
723+            if ((bU == bU))
724+                then {
725+                    let cS = an(fromBase58String(cO))
726+                    let cT = (cS - cP)
727+                    let cU = fraction(cT, aK(aG, aL), m)
728+                    let cV = (cT - cU)
729+                    if ((0 >= cV))
730+                        then throw("amount of staked sharetokens must be > 0")
731+                        else {
732+                            let cW = bN(aG, bi, cO, cV)
733+                            if ((cW == cW))
734+                                then $Tuple2(cV, cU)
735+                                else throw("Strict value is not equal to itself.")
736+                            }
737+                    }
738+                else throw("Strict value is not equal to itself.")
739+            }
740+        else throw("Strict value is not equal to itself.")
741+    }
742+
743+
744+func cX (aG,aJ,cY,cU,cZ,az,aD,da) = {
745+    let db = aF(aG)
746+    let dc = aH(aG)
747+    let dd = if (da)
748+        then $Tuple2(getIntegerValue(this, (aG + C)), (dc + cY))
749+        else $Tuple2(getIntegerValue(this, (aG + D)), dc)
750+    let de = dd._1
751+    let df = dd._2
752+[IntegerEntry((aG + A), (db + cY)), IntegerEntry((aG + B), df), IntegerEntry((((((aG + "_") + aJ) + "_") + toString(cZ)) + u), cY), IntegerEntry((((((aG + "_") + aJ) + "_") + toString(cZ)) + z), de), StringEntry((((aJ + "_") + toString(cZ)) + v), aG), IntegerEntry((aJ + y), cZ), ScriptTransfer(ab, cU, fromBase58String(az))]
753+    }
754+
755+
756+func dg (dh,di,dj,dk,dl,dm,dn,do,dp,dq) = {
757+    let dr = an(aR(dh))
758+    if ((dr == dr))
759+        then {
760+            let bU = invoke(ac, "swap", [dk, dl, dm, dn, do, dp, dq], [AttachedPayment(dj, di)])
761+            if ((bU == bU))
762+                then (an(aR(dh)) - dr)
763+                else throw("Strict value is not equal to itself.")
764+            }
765+        else throw("Strict value is not equal to itself.")
766+    }
767+
768+
769+func ds (dh,di,dj,dt,du,dq) = {
770+    let dr = an(aR(dh))
771+    if ((dr == dr))
772+        then {
773+            let bU = invoke(ac, "puzzleSwap", [dt, du, dq], [AttachedPayment(dj, di)])
774+            if ((bU == bU))
775+                then (an(aR(dh)) - dr)
776+                else throw("Strict value is not equal to itself.")
777+            }
778+        else throw("Strict value is not equal to itself.")
779+    }
780+
781+
782+func dv (dh,di,dj,dw,dx,dy,dz,dA,dB,dq) = {
783+    let dr = an(aR(dh))
784+    if ((dr == dr))
785+        then {
786+            let bU = invoke(ac, "swopfiSwap", [dw, dx, dy, dz, dA, dB, dq], [AttachedPayment(dj, di)])
787+            if ((bU == bU))
788+                then (an(aR(dh)) - dr)
789+                else throw("Strict value is not equal to itself.")
790+            }
791+        else throw("Strict value is not equal to itself.")
792+    }
793+
794+
795+func dC (aG,bi,dD,dE) = {
796+    let at = Address(fromBase58String(aG))
797+    let dF = aC(at, bi)
798+    let dG = dF._1
799+    let dH = dF._2
800+    let aA = dF._3
801+    let aB = dF._4
802+    let az = dF._5
803+    if (if ((dD != dG))
804+        then (dD != dH)
805+        else false)
806+        then throw("Wrong asset")
807+        else {
808+            let dI = if ((dD == dG))
809+                then $Tuple2(dE, 0)
810+                else $Tuple2(0, dE)
811+            let bA = dI._1
812+            let bB = dI._2
813+            let dJ = cN(bi, aG, i, bA, dG, bB, dH, aA, aB, az)
814+            let cY = dJ._1
815+            let dK = dJ._2
816+            let dL = valueOrElse(getInteger(this, (aG + C)), 0)
817+            let dM = valueOrElse(getInteger(this, (aG + D)), 0)
818+            let dN = aF(aG)
819+            let dO = aH(aG)
820+            let dP = fraction(dO, j, dN)
821+            let dQ = fraction(cY, dP, j)
822+            let dR = (cY - dQ)
823+            let dS = if ((dO > 0))
824+                then (dL + fraction(dQ, k, dO))
825+                else 0
826+            let dT = if (((dN - dO) > 0))
827+                then (dM + fraction(dR, k, (dN - dO)))
828+                else 0
829+            let dU = fraction(dQ, aK(aG, d), m)
830+            let dV = fraction(dR, aK(aG, c), m)
831+            let dW = bP(aG, bi, az, (dU + dV))
832+            if ((dW == dW))
833+                then ([IntegerEntry((aG + C), dS), IntegerEntry((aG + D), dT), IntegerEntry((aG + A), ((dN + cY) - dW)), IntegerEntry((aG + B), ((dO + dQ) - dU)), ScriptTransfer(ab, (dU + dV), fromBase58String(az))] ++ bv(dG, dH, az))
834+                else throw("Strict value is not equal to itself.")
835+            }
836+    }
837+
838+
839+func dX (aG,dY,dZ,ea) = {
840+    let at = Address(fromBase58String(aG))
841+    let bi = valueOrErrorMessage(getString(this, (N + aG)), "Unknown pool")
842+    let eb = aC(at, bi)
843+    let bW = eb._1
844+    let bX = eb._2
845+    let aA = eb._3
846+    let aB = eb._4
847+    let az = eb._5
848+    let ec = an(aR(bW))
849+    if ((ec == ec))
850+        then {
851+            let ed = an(aR(bX))
852+            if ((ed == ed))
853+                then {
854+                    let bU = if ((bi == a))
855+                        then invoke(at, "callFunction", ["withdraw", [toString(dY)]], nil)
856+                        else {
857+                            let bU = bP(aG, bi, az, dY)
858+                            if ((bU == bU))
859+                                then invoke(at, "get", nil, [AttachedPayment(aR(az), dY)])
860+                                else throw("Strict value is not equal to itself.")
861+                            }
862+                    if ((bU == bU))
863+                        then {
864+                            let ee = an(aR(bW))
865+                            let ef = an(aR(bX))
866+                            let eg = $Tuple2((ee - ec), (ef - ed))
867+                            let eh = eg._1
868+                            let ei = eg._2
869+                            let ej = if ((dZ > 0))
870+                                then {
871+                                    let cI = if (if ((ea == bW))
872+                                        then (dZ > eh)
873+                                        else false)
874+                                        then (dZ - eh)
875+                                        else if (if ((ea == bX))
876+                                            then (dZ > ei)
877+                                            else false)
878+                                            then (dZ - ei)
879+                                            else 0
880+                                    let ek = if ((cI > 0))
881+                                        then cm(bi, aG, bW, bX, aA, aB, cI, ea)
882+                                        else 0
883+                                    if ((ek == ek))
884+                                        then {
885+                                            let el = an(aR(bW))
886+                                            let em = an(aR(bX))
887+                                            if ((ea == bW))
888+                                                then $Tuple2(((el - ec) - dZ), (em - ed))
889+                                                else $Tuple2((el - ec), ((em - ed) - dZ))
890+                                            }
891+                                        else throw("Strict value is not equal to itself.")
892+                                    }
893+                                else $Tuple2(eh, ei)
894+                            let en = ej._1
895+                            let eo = ej._2
896+                            $Tuple7(en, bW, eo, bX, ee, ef, az)
897+                            }
898+                        else throw("Strict value is not equal to itself.")
899+                    }
900+                else throw("Strict value is not equal to itself.")
901+            }
902+        else throw("Strict value is not equal to itself.")
903+    }
904+
905+
906+func ep (aJ,aG,eq,er) = {
907+    let es = valueOrErrorMessage(getInteger(this, (((((aG + "_") + aJ) + "_") + eq) + u)), "Unknown position")
908+    let et = getIntegerValue(this, (((((aG + "_") + aJ) + "_") + eq) + z))
909+    let eu = if (er)
910+        then getIntegerValue(this, (aG + C))
911+        else getIntegerValue(this, (aG + D))
912+    (es + fraction(es, (eu - et), k))
913+    }
914+
915+
916+func ev (aJ,aG,eq,ew) = {
917+    let es = valueOrErrorMessage(getInteger(this, (((((aG + "_") + aJ) + "_") + eq) + u)), "Unknown position")
918+    let cC = valueOrElse(getInteger(this, (((((aG + "_") + aJ) + "_") + eq) + w)), 0)
919+    let dY = ep(aJ, aG, eq, (cC > 0))
920+    let ex = aF(aG)
921+    let ey = Address(fromBase58String(aJ))
922+    let ea = valueOrElse(getString(this, (((((aG + "_") + aJ) + "_") + eq) + x)), "")
923+    let dZ = if ((cC > 0))
924+        then {
925+            let aw = invoke(ah(), "getAssetDebt", [false, ((aJ + "_") + eq), ea], nil)
926+            if ($isInstanceOf(aw, "Int"))
927+                then aw
928+                else throw(($getType(aw) + " couldn't be cast to Int"))
929+            }
930+        else 0
931+    let ez = dX(aG, dY, dZ, ea)
932+    if ((ez == ez))
933+        then {
934+            let az = ez._7
935+            let ef = ez._6
936+            let ee = ez._5
937+            let bX = ez._4
938+            let eA = ez._3
939+            let bW = ez._2
940+            let eB = ez._1
941+            let eC = if ((dZ > 0))
942+                then invoke(ah(), "repayFor", [((aJ + "_") + eq)], [AttachedPayment(aR(ea), dZ)])
943+                else 0
944+            if ((eC == eC))
945+                then ([DeleteEntry((((((aG + "_") + aJ) + "_") + eq) + u)), DeleteEntry((((((aG + "_") + aJ) + "_") + eq) + z)), IntegerEntry((aG + A), (ex - dY)), ScriptTransfer(ey, eB, aR(bW)), ScriptTransfer(ey, eA, aR(bX))] ++ bv(bW, bX, az))
946+                else throw("Strict value is not equal to itself.")
947+            }
948+        else throw("Strict value is not equal to itself.")
949+    }
950+
951+
952+func eD (eE) = {
953+    let eF = split(valueOrErrorMessage(getString(this, (eE + L)), ("No request with id " + eE)), ",")
954+    let aJ = eF[0]
955+    let aG = eF[1]
956+    let bA = parseIntValue(eF[2])
957+    let dG = eF[3]
958+    let bB = parseIntValue(eF[4])
959+    let dH = eF[5]
960+    let aA = parseIntValue(eF[6])
961+    let aB = parseIntValue(eF[7])
962+    let az = eF[8]
963+    let eG = eF[9]
964+    let eH = parseIntValue(eF[10])
965+    $Tuple11(aJ, aG, bA, dG, bB, dH, aA, aB, az, eG, eH)
966+    }
967+
968+
969+func eI (bA,bB,ax,ay,eJ,eK) = {
970+    let bm = (    let aw = invoke(ad, "getTWAP60", [ax, false], nil)
971+    if ($isInstanceOf(aw, "(Int, Int)"))
972+        then aw
973+        else throw(($getType(aw) + " couldn't be cast to (Int, Int)")))._2
974+    let bn = (    let aw = invoke(ad, "getTWAP60", [ay, false], nil)
975+    if ($isInstanceOf(aw, "(Int, Int)"))
976+        then aw
977+        else throw(($getType(aw) + " couldn't be cast to (Int, Int)")))._2
978+    let eL = pow(10, 0, aS(ax), 0, 0, DOWN)
979+    let eM = pow(10, 0, aS(ay), 0, 0, DOWN)
980+    let eN = (fraction(bm, bA, eL) + fraction(bn, bB, eM))
981+    let eO = if ((eK == ax))
982+        then $Tuple2(bm, eL)
983+        else $Tuple2(bn, eM)
984+    let eP = eO._1
985+    let eQ = eO._2
986+    fraction(fraction(eN, (eJ - 100), 100), eQ, eP)
987+    }
988+
989+
990+@Callable(ak)
991+func calcPriceImpactEVALONLY (aG,eJ,eK,bA,bB) = if (if ((100 > eJ))
992+    then true
993+    else (eJ > 300))
994+    then throw("Leverage can't be <100 and >300")
995+    else {
996+        let bi = valueOrErrorMessage(getString(this, (N + aG)), "Pool is not inited")
997+        let eR = aC(Address(fromBase58String(aG)), bi)
998+        let dG = eR._1
999+        let dH = eR._2
1000+        let aA = eR._3
1001+        let aB = eR._4
1002+        let az = eR._5
1003+        let cC = if ((eJ > 100))
1004+            then eI(bA, bB, dG, dH, eJ, eK)
1005+            else 0
1006+        let eS = if ((eK == dG))
1007+            then $Tuple2((bA + cC), bB)
1008+            else $Tuple2(bA, (bB + cC))
1009+        let eT = eS._1
1010+        let eU = eS._2
1011+        let eV = cp(bi, aG, eT, dG, eU, dH, aA, aB)
1012+        let cw = eV._1
1013+        let cA = eV._2
1014+        let eW = if ((0 > cA))
1015+            then (cA * -1)
1016+            else cA
1017+        $Tuple2(nil, [eW])
1018+        }
1019+
1020+
1021+
1022+@Callable(ak)
1023+func getShareAssetPriceREADONLY (az) = {
1024+    let eX = bh(az)
1025+    $Tuple2(nil, eX)
1026+    }
1027+
1028+
1029+
1030+@Callable(ak)
1031+func getUserPositionShareAmountREADONLY (aJ,cZ) = {
1032+    let aG = valueOrErrorMessage(getString(this, (((aJ + "_") + cZ) + v)), "Unknown position")
1033+    let cC = getIntegerValue(this, (((((aG + "_") + aJ) + "_") + cZ) + w))
1034+    let dY = ep(aJ, aG, cZ, (cC > 0))
1035+    $Tuple2(nil, dY)
1036+    }
1037+
1038+
1039+
1040+@Callable(ak)
1041+func getUserPositionInDollarsREADONLY (aJ,eY,cZ) = {
1042+    func eZ (aY,aG) =     {
1043+        let fa = aY
1044+        let fb = fa._1
1045+        let fc = fa._2
1046+        let fd = fa._3
1047+        let bi = valueOrErrorMessage(getString(this, (N + aG)), "Pool is not inited")
1048+        let fe = aC(Address(fromBase58String(aG)), bi)
1049+        let dG = fe._1
1050+        let dH = fe._2
1051+        let aA = fe._3
1052+        let aB = fe._4
1053+        let az = fe._5
1054+        let cC = valueOrElse(getInteger(this, (((((aG + "_") + aJ) + "_") + cZ[fd]) + w)), 0)
1055+        let dY = ep(aJ, aG, cZ[fd], (cC > 0))
1056+        let eX = bh(az)
1057+        let ff = pow(10, 0, aS(az), 0, 0, DOWN)
1058+        let fg = fraction(dY, eX, ff)
1059+        if ((cC == 0))
1060+            then $Tuple3((fb :+ fg), (fc :+ 0), (fd + 1))
1061+            else {
1062+                let ea = getStringValue(this, (((((aG + "_") + aJ) + "_") + cZ[fd]) + x))
1063+                let dZ = {
1064+                    let aw = invoke(ah(), "getAssetDebt", [false, ((aJ + "_") + cZ[fd]), ea], nil)
1065+                    if ($isInstanceOf(aw, "Int"))
1066+                        then aw
1067+                        else throw(($getType(aw) + " couldn't be cast to Int"))
1068+                    }
1069+                let fh = (                let aw = invoke(ad, "getTWAP60", [ea, false], nil)
1070+                if ($isInstanceOf(aw, "(Int, Int)"))
1071+                    then aw
1072+                    else throw(($getType(aw) + " couldn't be cast to (Int, Int)")))._1
1073+                let fi = pow(10, 0, aS(ea), 0, 0, DOWN)
1074+                let fj = fraction(dZ, fh, fi)
1075+                $Tuple3((fb :+ fg), (fc :+ fj), (fd + 1))
1076+                }
1077+        }
1078+
1079+    let fk = {
1080+        let ba = eY
1081+        let bb = size(ba)
1082+        let bc = $Tuple3(nil, nil, 0)
1083+        func bd (be,bf) =         if ((bf >= bb))
1084+            then be
1085+            else eZ(be, ba[bf])
1086+
1087+        func bg (be,bf) =         if ((bf >= bb))
1088+            then be
1089+            else throw("List size exceeds 20")
1090+
1091+        bg(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bd(bc, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
1092+        }
1093+    let fl = fk._1
1094+    let dZ = fk._2
1095+    $Tuple2(nil, $Tuple2(fl, dZ))
1096+    }
1097+
1098+
1099+
1100+@Callable(ak)
1101+func replenish (aG,eJ,eK) = if (if ((100 > eJ))
1102+    then true
1103+    else (eJ > 300))
1104+    then throw("Leverage can't be <100 and >300")
1105+    else if (if (!(getBooleanValue(this, (aG + E))))
1106+        then (eJ > 100)
1107+        else false)
1108+        then throw("You can't borrow in this pool")
1109+        else {
1110+            let bi = valueOrErrorMessage(getString(this, (N + aG)), "Pool is not inited")
1111+            let fm = aC(Address(fromBase58String(aG)), bi)
1112+            let dG = fm._1
1113+            let dH = fm._2
1114+            let aA = fm._3
1115+            let aB = fm._4
1116+            let az = fm._5
1117+            let fn = if ((size(ak.payments) == 2))
1118+                then if ((aQ(ak.payments[0].assetId) != dG))
1119+                    then throw("Wrong payment asset A")
1120+                    else if ((aQ(ak.payments[1].assetId) != dH))
1121+                        then throw("Wrong payment asset B")
1122+                        else $Tuple4(ak.payments[0].amount, dG, ak.payments[1].amount, dH)
1123+                else if ((size(ak.payments) == 1))
1124+                    then if ((aQ(ak.payments[0].assetId) == dG))
1125+                        then $Tuple4(ak.payments[0].amount, dG, 0, dH)
1126+                        else if ((aQ(ak.payments[0].assetId) == dH))
1127+                            then $Tuple4(0, dG, ak.payments[0].amount, dH)
1128+                            else throw("Wrong payment")
1129+                    else throw("One or two payments expected")
1130+            let bA = fn._1
1131+            let fo = fn._2
1132+            let bB = fn._3
1133+            let fp = fn._4
1134+            let fq = aI(toString(ak.caller))
1135+            if ((eJ > 100))
1136+                then {
1137+                    let cC = eI(bA, bB, fo, fp, eJ, eK)
1138+                    let eF = makeString([toString(ak.caller), aG, toString(bA), fo, toString(bB), fp, toString(aA), toString(aB), az, eK, toString(cC)], ",")
1139+                    let fr = {
1140+                        let aw = invoke(this, "createNewRequest", [eF], nil)
1141+                        if ($isInstanceOf(aw, "Int"))
1142+                            then aw
1143+                            else throw(($getType(aw) + " couldn't be cast to Int"))
1144+                        }
1145+                    if ((fr == fr))
1146+                        then {
1147+                            let fs = [((toString(ak.caller) + "_") + toString(fq)), az, eK, cC, toString(this), "replenishFromLand", toString(valueOrErrorMessage(fr, "Can't create new request"))]
1148+                            let bU = reentrantInvoke(ah(), "flashPosition", fs, nil)
1149+                            if ((bU == bU))
1150+                                then nil
1151+                                else throw("Strict value is not equal to itself.")
1152+                            }
1153+                        else throw("Strict value is not equal to itself.")
1154+                    }
1155+                else {
1156+                    let ft = cN(bi, aG, h, bA, dG, bB, dH, aA, aB, az)
1157+                    let fu = ft._1
1158+                    let dW = ft._2
1159+                    (cX(aG, toString(ak.caller), fu, dW, fq, az, bi, false) ++ bv(dG, dH, az))
1160+                    }
1161+            }
1162+
1163+
1164+
1165+@Callable(ak)
1166+func withdraw (aG,eq) = ev(toString(ak.caller), aG, toString(eq), false)
1167+
1168+
1169+
1170+@Callable(ak)
1171+func createUpdateStopLoss (eq,fv,ao,fw) = {
1172+    let fx = (    let aw = invoke(ad, "getTWAP60", [ao, false], nil)
1173+    if ($isInstanceOf(aw, "(Int, Int)"))
1174+        then aw
1175+        else throw(($getType(aw) + " couldn't be cast to (Int, Int)")))._1
1176+    if (!(isDefined(getInteger(this, (((((fv + "_") + toString(ak.caller)) + "_") + toString(eq)) + u)))))
1177+        then throw("There are no user position")
1178+        else if ((0 >= fw))
1179+            then throw("Price must be greater than 0")
1180+            else if ((fw > fx))
1181+                then throw("Price must be less than current token price")
1182+                else [IntegerEntry((((((((toString(ak.caller) + "_") + toString(eq)) + "_") + fv) + "_") + ao) + R), fw)]
1183+    }
1184+
1185+
1186+
1187+@Callable(ak)
1188+func deleteStopLoss (eq,fv,ao) = if (!(isDefined(getInteger(this, (((((((toString(ak.caller) + "_") + toString(eq)) + "_") + fv) + "_") + ao) + R)))))
1189+    then throw("No entry")
1190+    else [DeleteEntry((((((((toString(ak.caller) + "_") + toString(eq)) + "_") + fv) + "_") + ao) + R))]
1191+
1192+
1193+
1194+@Callable(ak)
1195+func init (fy,fz,fA,ad,fB,ae,fC,fD,fE) = if (isDefined(getString(S)))
1196+    then throw("Already inited")
1197+    else [StringEntry(S, fy), StringEntry(T, fz), StringEntry(U, fA), StringEntry(W, ad), StringEntry(X, fB), StringEntry(Y, ae), StringEntry(Z, fC), StringEntry(aa, fD), StringEntry(V, fE)]
1198+
1199+
1200+
1201+@Callable(ak)
1202+func createNewRequest (bT) = valueOrElse(al(ak), {
1203+    let fr = (valueOrElse(getInteger(this, M), 0) + 1)
1204+    $Tuple2([StringEntry((toString(fr) + L), bT), IntegerEntry(M, fr)], fr)
1205+    })
1206+
1207+
1208+
1209+@Callable(ak)
1210+func replenishFromLand (eE) = valueOrElse(am(ak), {
1211+    let fF = eD(eE)
1212+    let aJ = fF._1
1213+    let aG = fF._2
1214+    let bA = fF._3
1215+    let dG = fF._4
1216+    let bB = fF._5
1217+    let dH = fF._6
1218+    let aA = fF._7
1219+    let aB = fF._8
1220+    let az = fF._9
1221+    let eG = fF._10
1222+    let eH = fF._11
1223+    if ((size(ak.payments) != 1))
1224+        then throw("Wrong payment size")
1225+        else if (if ((aQ(ak.payments[0].assetId) != eG))
1226+            then true
1227+            else (ak.payments[0].amount != eH))
1228+            then throw("Wrong payment")
1229+            else {
1230+                let fG = if ((dG == eG))
1231+                    then $Tuple2((bA + ak.payments[0].amount), bB)
1232+                    else $Tuple2(bA, (bB + ak.payments[0].amount))
1233+                let fH = fG._1
1234+                let fI = fG._2
1235+                let bi = valueOrErrorMessage(getString(this, (N + aG)), "Unknown pool")
1236+                let fJ = cN(bi, aG, g, fH, dG, fI, dH, aA, aB, az)
1237+                let fu = fJ._1
1238+                let dW = fJ._2
1239+                let cZ = aI(aJ)
1240+                let fK = [IntegerEntry((((((aG + "_") + aJ) + "_") + toString(cZ)) + w), eH), StringEntry((((((aG + "_") + aJ) + "_") + toString(cZ)) + x), eG)]
1241+                let fL = cX(aG, aJ, fu, dW, cZ, az, bi, true)
1242+                $Tuple2((((fL ++ bv(dG, dH, az)) ++ fK) :+ DeleteEntry((eE + L))), fu)
1243+                }
1244+    })
1245+
1246+
1247+
1248+@Callable(ak)
1249+func liquidate (aJ,eq,fM) = valueOrElse(am(ak), {
1250+    let aG = valueOrErrorMessage(getString(this, (((aJ + "_") + eq) + v)), "no position")
1251+    let bi = valueOrErrorMessage(getString(this, (N + aG)), "Pool is not inited")
1252+    let fN = aC(Address(fromBase58String(aG)), bi)
1253+    let dG = fN._1
1254+    let dH = fN._2
1255+    let aA = fN._3
1256+    let aB = fN._4
1257+    let az = fN._5
1258+    let bO = bP(aG, bi, az, fM)
1259+    let cC = getIntegerValue(this, (((((aG + "_") + aJ) + "_") + eq) + w))
1260+    let ea = getStringValue(this, (((((aG + "_") + aJ) + "_") + eq) + x))
1261+    let dY = ep(aJ, aG, eq, (cC > 0))
1262+    if ((cC == 0))
1263+        then throw("You can't liquidate position without borrow")
1264+        else [IntegerEntry((((((aG + "_") + aJ) + "_") + eq) + z), getIntegerValue(this, (aG + C))), IntegerEntry((aG + B), (aH(aG) - fM)), IntegerEntry((aG + A), (aF(aG) - fM)), IntegerEntry((((((aG + "_") + aJ) + "_") + eq) + u), (dY - fM)), ScriptTransfer(ak.caller, bO, fromBase58String(az))]
1265+    })
1266+
1267+
1268+
1269+@Callable(ak)
1270+func stopLoss (aJ,eq,aG,ao) = valueOrElse(aj(ak), {
1271+    let fx = (    let aw = invoke(ad, "getTWAP60", [ao, false], nil)
1272+    if ($isInstanceOf(aw, "(Int, Int)"))
1273+        then aw
1274+        else throw(($getType(aw) + " couldn't be cast to (Int, Int)")))._1
1275+    if (!(isDefined(getInteger(this, (((((((aJ + "_") + toString(eq)) + "_") + aG) + "_") + ao) + R)))))
1276+        then throw("No entry")
1277+        else (ev(toString(ak.caller), aG, toString(eq), true) :+ DeleteEntry((((((((aJ + "_") + toString(eq)) + "_") + aG) + "_") + ao) + R)))
1278+    })
1279+
1280+
1281+
1282+@Callable(ak)
1283+func capitalizeExKeeper (aG,aD,fO,fP,fQ,dk,dl,dm,dn,do,dp,dq) = valueOrElse(aj(ak), {
1284+    let fR = if (fQ)
1285+        then cK(aD, aG)
1286+        else {
1287+            let fS = if ((aD == a))
1288+                then af
1289+                else ag
1290+            $Tuple2(fP, fS)
1291+            }
1292+    let fT = fR._1
1293+    let fS = fR._2
1294+    let fU = dg(fO, fP, fS, dk, dl, dm, dn, do, dp, dq)
1295+    let cu = (fT - fP)
1296+    let fV = if ((cu > 0))
1297+        then [IntegerEntry((aG + P), (cu + valueOrElse(getInteger(this, (aG + P)), 0)))]
1298+        else nil
1299+    (dC(aG, aD, fO, fU) ++ fV)
1300+    })
1301+
1302+
1303+
1304+@Callable(ak)
1305+func capitalizeExPuzzle (aG,aD,fO,fP,fQ,dt,du,dq) = valueOrElse(aj(ak), {
1306+    let fW = if (fQ)
1307+        then cK(aD, aG)
1308+        else {
1309+            let fS = if ((aD == a))
1310+                then af
1311+                else ag
1312+            $Tuple2(fP, fS)
1313+            }
1314+    let fT = fW._1
1315+    let fS = fW._2
1316+    let fU = ds(fO, fP, fS, dt, du, dq)
1317+    let cu = (fT - fP)
1318+    let fV = if ((cu > 0))
1319+        then [IntegerEntry((aG + P), (cu + valueOrElse(getInteger(this, (aG + P)), 0)))]
1320+        else nil
1321+    (dC(aG, aD, fO, fU) ++ fV)
1322+    })
1323+
1324+
1325+
1326+@Callable(ak)
1327+func capitalizeExSwopFi (aG,aD,fO,fP,fQ,dw,dx,dy,dz,dA,dB,dq) = valueOrElse(aj(ak), {
1328+    let fX = if (fQ)
1329+        then cK(aD, aG)
1330+        else {
1331+            let fS = if ((aD == a))
1332+                then af
1333+                else ag
1334+            $Tuple2(fP, fS)
1335+            }
1336+    let fT = fX._1
1337+    let fS = fX._2
1338+    let fU = dv(fO, fP, fS, dw, dx, dy, dz, dA, dB, dq)
1339+    let cu = (fT - fP)
1340+    let fV = if ((cu > 0))
1341+        then [IntegerEntry((aG + P), (cu + valueOrElse(getInteger(this, (aG + P)), 0)))]
1342+        else nil
1343+    (dC(aG, aD, fO, fU) ++ fV)
1344+    })
1345+
1346+
1347+
1348+@Callable(ak)
1349+func initNewPool (aD,at,fY,fZ,ga,gb,gc,gd,ge) = valueOrElse(aj(ak), if (if ((aD != a))
1350+    then (aD != b)
1351+    else false)
1352+    then throw("Wrong type")
1353+    else {
1354+        let gf = aC(Address(fromBase58String(at)), aD)
1355+        let ax = gf._1
1356+        let ay = gf._2
1357+        let gg = gf._3
1358+        let gh = gf._4
1359+        let az = gf._5
1360+[IntegerEntry((at + F), fY), IntegerEntry((at + G), fZ), IntegerEntry((at + H), ga), IntegerEntry((at + I), gb), IntegerEntry((at + J), gc), IntegerEntry((at + K), gd), IntegerEntry((at + C), 0), IntegerEntry((at + D), 0), StringEntry((N + at), aD), StringEntry((az + O), at), BooleanEntry((at + E), ge)]
1361+        })
1362+
1363+
1364+@Verifier(gi)
1365+func gj () = sigVerify(gi.bodyBytes, gi.proofs[0], gi.senderPublicKey)
1366+
github/deemru/w8io/169f3d6 
66.59 ms ◑