tx · DkrajyVuHSZoq41ZYhY7Z5okBAj1mYq3nSf2cftwnWHr

3MvRWw2FPEimFCTGtK7qY9uAJbM7XJ4ZfJS:  -0.04300000 Waves

2023.06.21 17:06 [2632502] smart account 3MvRWw2FPEimFCTGtK7qY9uAJbM7XJ4ZfJS > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "DkrajyVuHSZoq41ZYhY7Z5okBAj1mYq3nSf2cftwnWHr",
    "fee": 4300000,
    "feeAssetId": null,
    "timestamp": 1687356423353,
    "version": 2,
    "chainId": 84,
    "sender": "3MvRWw2FPEimFCTGtK7qY9uAJbM7XJ4ZfJS",
    "senderPublicKey": "HP8sssVq1866F7CaPQJwgFrt6fsqhQjKwM84cL1wjD2a",
    "proofs": [
        "5dufCh6fAKJdj2sRCT4vzhfJ3BBMymFo5tq4nhMVF8HqaCQdS4aukQMkhnfkMC9fwoQa9YVH7xXc9jQupa4fzMrx"
    ],
    "script": "base64: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",
    "height": 2632502,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 8EyLgHdrs3HwReaftE8W4z247DBBXvAfVHo3s6k8FjgU
Next: 4Fk7bYx6xdHRcB3w32CBpszvhVbawza5M9qHPY7eyDc9

Diff: 

OldNewDifferences
114114 func ad () = Address(fromBase58String(valueOrErrorMessage(getString(this, S), "Can't get lend service addr")))
115115 
116116 
117-func ae () = addressFromPublicKey(fromBase58String(valueOrErrorMessage(getString(this, T), "Can't get lend service addr")))
117+func ae () = addressFromPublicKey(fromBase58String(valueOrErrorMessage(getString(this, T), "Can't get admin addr")))
118118 
119119 
120120 func af (ag) = if ((ag.caller == ae()))

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 6 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
44 let a = "SF"
55 
66 let b = "WX"
77 
88 let c = "capNoLoan"
99 
1010 let d = "capLoan"
1111 
1212 let e = "stopLossNoLoan"
1313 
1414 let f = "stopLossLoan"
1515 
1616 let g = "loan"
1717 
1818 let h = "noLoan"
1919 
2020 let i = "noFee"
2121 
2222 let j = 100000000
2323 
2424 let k = 10000000000
2525 
2626 let l = 1000000
2727 
2828 let m = "A_asset_balance"
2929 
3030 let n = "B_asset_balance"
3131 
3232 let o = "A_asset_id"
3333 
3434 let p = "B_asset_id"
3535 
3636 let q = "share_asset_id"
3737 
3838 let r = "share_asset_supply"
3939 
4040 let s = "commission"
4141 
4242 let t = "_user_position"
4343 
4444 let u = "_user_position_pool"
4545 
4646 let v = "_user_position_borrow_amount"
4747 
4848 let w = "_user_position_borrow_asset_id"
4949 
5050 let x = "_user_position_number"
5151 
5252 let y = "_user_position_interest"
5353 
5454 let z = "_pool_total"
5555 
5656 let A = "_pool_total_loan"
5757 
5858 let B = "_pool_interest_loan"
5959 
6060 let C = "_pool_interest_no_loan"
6161 
6262 let D = "_axly_fee_without_loan"
6363 
6464 let E = "_axly_fee_with_loan"
6565 
6666 let F = "_axly_fee_cap_with_loan"
6767 
6868 let G = "_axly_fee_cap_no_loan"
6969 
7070 let H = "_axly_fee_stoploss_with_loan"
7171 
7272 let I = "_axly_fee_stoploss_no_loan"
7373 
7474 let J = "_request_id"
7575 
7676 let K = "requests_iter"
7777 
7878 let L = "pool_"
7979 
8080 let M = "_pool_share_id"
8181 
8282 let N = "_pool_cap_change"
8383 
8484 let O = "last_price"
8585 
8686 let P = "_stop_loss"
8787 
8888 let Q = "axly_money_box"
8989 
9090 let R = "swopfi_farming_addr"
9191 
9292 let S = "lend_service_addr"
9393 
9494 let T = "admin_call_pub_key"
9595 
9696 let U = "price_oracle"
9797 
9898 let V = "exchange_contract"
9999 
100100 let W = "wx_swap_contract"
101101 
102102 let X = Address(fromBase58String(valueOrErrorMessage(getString(this, Q), "No axly moneyBox address")))
103103 
104104 let Y = Address(fromBase58String(valueOrErrorMessage(getString(this, V), "No exchange contract address")))
105105 
106106 let Z = Address(fromBase58String(valueOrErrorMessage(getString(this, U), "No price oracle address")))
107107 
108108 let aa = Address(fromBase58String(valueOrErrorMessage(getString(this, W), "No wx swap address")))
109109 
110110 let ab = base58'4W19ndijcc2CsQa9HGW2dfXKTVXhnneWWttxXrtjPmEp'
111111 
112112 let ac = base58'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc'
113113 
114114 func ad () = Address(fromBase58String(valueOrErrorMessage(getString(this, S), "Can't get lend service addr")))
115115 
116116 
117-func ae () = addressFromPublicKey(fromBase58String(valueOrErrorMessage(getString(this, T), "Can't get lend service addr")))
117+func ae () = addressFromPublicKey(fromBase58String(valueOrErrorMessage(getString(this, T), "Can't get admin addr")))
118118 
119119 
120120 func af (ag) = if ((ag.caller == ae()))
121121     then unit
122122     else throw("Only admin can call this function")
123123 
124124 
125125 func ah (ag) = if ((ag.caller == this))
126126     then unit
127127     else throw("Only contract itself can call this function")
128128 
129129 
130130 func ai (ag) = if ((ag.caller == ad()))
131131     then unit
132132     else throw("Only land contract can call this function")
133133 
134134 
135135 func aj (ak) = {
136136     let al = ak
137137     if ($isInstanceOf(al, "ByteVector"))
138138         then {
139139             let am = al
140140             assetBalance(this, am)
141141             }
142142         else if ($isInstanceOf(al, "Unit"))
143143             then {
144144                 let an = al
145145                 wavesBalance(this).available
146146                 }
147147             else throw("Match error")
148148     }
149149 
150150 
151151 func ao (ap) = $Tuple5(valueOrErrorMessage(getString(ap, o), "Can't get pool A asset id"), valueOrErrorMessage(getString(ap, p), "Can't get pool B asset id"), valueOrErrorMessage(getInteger(ap, m), "Can't get pool A asset balance"), valueOrErrorMessage(getInteger(ap, n), "Can't get pool B asset balance"), valueOrErrorMessage(getString(ap, q), "Can't get share asset id"))
152152 
153153 
154154 func aq (ap) = {
155155     let ar = {
156156         let as = invoke(ap, "getPoolConfigWrapperREADONLY", nil, nil)
157157         if ($isInstanceOf(as, "List[Any]"))
158158             then as
159159             else throw(($getType(as) + " couldn't be cast to List[Any]"))
160160         }
161161     if ((ar == ar))
162162         then {
163163             let at = valueOrErrorMessage({
164164                 let as = ar[4]
165165                 if ($isInstanceOf(as, "String"))
166166                     then as
167167                     else unit
168168                 }, "Can't get pool A asset id")
169169             let au = valueOrErrorMessage({
170170                 let as = ar[5]
171171                 if ($isInstanceOf(as, "String"))
172172                     then as
173173                     else unit
174174                 }, "Can't get pool B asset id")
175175             let av = valueOrErrorMessage({
176176                 let as = ar[3]
177177                 if ($isInstanceOf(as, "String"))
178178                     then as
179179                     else unit
180180                 }, "Can't get pool LP asset id")
181181             let aw = {
182182                 let as = invoke(ap, "getAccBalanceWrapperREADONLY", [at], nil)
183183                 if ($isInstanceOf(as, "Int"))
184184                     then as
185185                     else throw(($getType(as) + " couldn't be cast to Int"))
186186                 }
187187             if ((aw == aw))
188188                 then {
189189                     let ax = {
190190                         let as = invoke(ap, "getAccBalanceWrapperREADONLY", [au], nil)
191191                         if ($isInstanceOf(as, "Int"))
192192                             then as
193193                             else throw(($getType(as) + " couldn't be cast to Int"))
194194                         }
195195                     if ((ax == ax))
196196                         then $Tuple5(at, au, aw, ax, av)
197197                         else throw("Strict value is not equal to itself.")
198198                     }
199199                 else throw("Strict value is not equal to itself.")
200200             }
201201         else throw("Strict value is not equal to itself.")
202202     }
203203 
204204 
205205 func ay (ap,az) = if ((az == a))
206206     then ao(ap)
207207     else if ((az == b))
208208         then aq(ap)
209209         else throw("Wrong pool type")
210210 
211211 
212212 func aA (ap,az,av) = if ((az == a))
213213     then valueOrErrorMessage(getInteger(ap, r), "Can't get share asset supply")
214214     else if ((az == b))
215215         then valueOrErrorMessage(assetInfo(fromBase58String(av)), "Wrong ShareId").quantity
216216         else throw("Wrong pool type")
217217 
218218 
219219 func aB (aC) = valueOrElse(getInteger(this, (aC + z)), 0)
220220 
221221 
222222 func aD (aC) = valueOrElse(getInteger(this, (aC + A)), 0)
223223 
224224 
225225 func aE (aF) = (valueOrElse(getInteger(this, (aF + x)), 0) + 1)
226226 
227227 
228228 func aG (aC,aH) = if ((aH == d))
229229     then getIntegerValue(this, (aC + G))
230230     else if ((aH == c))
231231         then getIntegerValue(this, (aC + F))
232232         else if ((aH == g))
233233             then getIntegerValue(this, (aC + E))
234234             else if ((aH == h))
235235                 then getIntegerValue(this, (aC + D))
236236                 else if ((aH == i))
237237                     then 0
238238                     else throw("Wrong fee type")
239239 
240240 
241241 func aI () = Address(fromBase58String(valueOrErrorMessage(getString(this, R), "Can't get swopfi farming addr")))
242242 
243243 
244244 func aJ (ap) = {
245245     let aK = Address(fromBase58String(valueOrErrorMessage(getString(ap, "%s__factoryContract"), "Can't get WX factory contract addr")))
246246     let aL = split(valueOrErrorMessage(getString(aK, "%s__factoryConfig"), "Can't get WX factory cfg"), "__")
247247     Address(fromBase58String(aL[1]))
248248     }
249249 
250250 
251251 func aM (ak) = {
252252     let al = ak
253253     if ($isInstanceOf(al, "ByteVector"))
254254         then {
255255             let am = al
256256             toBase58String(am)
257257             }
258258         else if ($isInstanceOf(al, "Unit"))
259259             then {
260260                 let an = al
261261                 "WAVES"
262262                 }
263263             else throw("Match error")
264264     }
265265 
266266 
267267 func aN (ak) = if ((ak == "WAVES"))
268268     then unit
269269     else fromBase58String(ak)
270270 
271271 
272272 func aO (ak) = if ((ak == "WAVES"))
273273     then 8
274274     else {
275275         let al = assetInfo(fromBase58String(ak))
276276         if ($isInstanceOf(al, "Asset"))
277277             then {
278278                 let aP = al
279279                 aP.decimals
280280                 }
281281             else throw("Can't find asset")
282282         }
283283 
284284 
285285 func aQ (ak) = pow(10, 0, aO(ak), 0, 0, DOWN)
286286 
287287 
288288 func aR (aS) = {
289289     func aT (aU,ak) =     {
290290         let aV = (        let as = invoke(Z, "getTWAP60", [ak, false], nil)
291291         if ($isInstanceOf(as, "(Int, Int)"))
292292             then as
293293             else throw(($getType(as) + " couldn't be cast to (Int, Int)")))._2
294294         (aU :+ aV)
295295         }
296296 
297297     let aW = aS
298298     let aX = size(aW)
299299     let aY = nil
300300     func aZ (ba,bb) =     if ((bb >= aX))
301301         then ba
302302         else aT(ba, aW[bb])
303303 
304304     func bc (ba,bb) =     if ((bb >= aX))
305305         then ba
306306         else throw("List size exceeds 50")
307307 
308308     bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 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)
309309     }
310310 
311311 
312312 func bd (av) = {
313313     let aC = valueOrErrorMessage(getString(this, (av + M)), "Can't find pool addr by share id")
314314     let ap = Address(fromBase58String(aC))
315315     let be = valueOrErrorMessage(getString(this, (L + aC)), "Pool is not inited")
316316     let bf = ay(ap, be)
317317     let at = bf._1
318318     let au = bf._2
319319     let bg = bf._3
320320     let bh = bf._4
321321     let bi = (    let as = invoke(Z, "getTWAP60", [at, false], nil)
322322     if ($isInstanceOf(as, "(Int, Int)"))
323323         then as
324324         else throw(($getType(as) + " couldn't be cast to (Int, Int)")))._2
325325     let bj = (    let as = invoke(Z, "getTWAP60", [au, false], nil)
326326     if ($isInstanceOf(as, "(Int, Int)"))
327327         then as
328328         else throw(($getType(as) + " couldn't be cast to (Int, Int)")))._2
329329     let bk = aA(ap, be, av)
330330     let bl = pow(10, 0, aO(at), 0, 0, DOWN)
331331     let bm = pow(10, 0, aO(au), 0, 0, DOWN)
332332     let bn = pow(10, 0, aO(av), 0, 0, DOWN)
333333     let bo = (fraction(bg, bi, bl) + fraction(bh, bj, bm))
334334     fraction(bo, bn, bk)
335335     }
336336 
337337 
338338 func bp (bq) = {
339339     func aT (aU,av) =     (aU :+ bd(av))
340340 
341341     let aW = bq
342342     let aX = size(aW)
343343     let aY = nil
344344     func aZ (ba,bb) =     if ((bb >= aX))
345345         then ba
346346         else aT(ba, aW[bb])
347347 
348348     func bc (ba,bb) =     if ((bb >= aX))
349349         then ba
350350         else throw("List size exceeds 20")
351351 
352352     bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
353353     }
354354 
355355 
356356 func br (at,au,av) = {
357357     let bs = aR([at, au])
358358     let bt = bd(av)
359359     let bu = [toString(bs[0]), toString(bs[1]), toString(bt)]
360360 [StringEntry(O, makeString(bu, ","))]
361361     }
362362 
363363 
364364 func bv (be,ap,bw,at,bx,au,aw,ax) = {
365365     let by = if ((be == a))
366366         then $Tuple2(nil, nil)
367367         else $Tuple2(split({
368368             let as = invoke(ap, "evaluatePutByAmountAssetREADONLY", [bw], nil)
369369             if ($isInstanceOf(as, "String"))
370370                 then as
371371                 else throw(($getType(as) + " couldn't be cast to String"))
372372             }, "__"), split({
373373             let as = invoke(ap, "evaluatePutByPriceAssetREADONLY", [bx], nil)
374374             if ($isInstanceOf(as, "String"))
375375                 then as
376376                 else throw(($getType(as) + " couldn't be cast to String"))
377377             }, "__"))
378378     if ((by == by))
379379         then {
380380             let bz = by._2
381381             let bA = by._1
382382             let bB = if ((be == a))
383383                 then $Tuple2(fraction(j, bw, aw), fraction(j, bx, ax))
384384                 else $Tuple2(parseIntValue(bA[1]), parseIntValue(bz[1]))
385385             let bC = bB._1
386386             let bD = bB._2
387387             let bE = if ((bD > bC))
388388                 then {
389389                     let bF = if ((be == a))
390390                         then fraction(ax, bC, j, CEILING)
391391                         else parseIntValue(bA[8])
392392                     $Tuple5(bw, bF, (bx - bF), au, bD)
393393                     }
394394                 else {
395395                     let bF = if ((be == a))
396396                         then fraction(aw, bD, j, CEILING)
397397                         else parseIntValue(bz[7])
398398                     $Tuple5(bF, bx, (bw - bF), at, bC)
399399                     }
400400             let bG = bE._1
401401             let bH = bE._2
402402             let bI = bE._3
403403             let bJ = bE._4
404404             let bK = bE._5
405405             $Tuple5(bG, bH, bI, bJ, bK)
406406             }
407407         else throw("Strict value is not equal to itself.")
408408     }
409409 
410410 
411411 func bL (ap,be,bw,at,bx,au) = {
412412     let bM = [AttachedPayment(aN(at), bw), AttachedPayment(aN(au), bx)]
413413     if ((be == a))
414414         then invoke(ap, "callFunction", ["replenishWithTwoTokens", ["false", "0"]], bM)
415415         else invoke(ap, "put", [1000000, false], bM)
416416     }
417417 
418418 
419419 func bN (ap,be,bF,bO) = {
420420     let bM = [AttachedPayment(aN(bO), bF)]
421421     if ((be == a))
422422         then invoke(ap, "callFunction", ["replenishWithOneToken", ["0", "false", "0"]], bM)
423423         else invoke(ap, "putOneTkn", [0, false], bM)
424424     }
425425 
426426 
427427 func bP (aC,be,av,bQ) = {
428428     let bM = [AttachedPayment(fromBase58String(av), bQ)]
429429     if ((be == a))
430430         then invoke(aI(), "lockShareTokens", [aC, 0], bM)
431431         else invoke(aJ(addressFromStringValue(aC)), "stake", nil, bM)
432432     }
433433 
434434 
435435 func bR (aC,be,av,bQ) = {
436436     let bS = if ((be == a))
437437         then $Tuple3(aI(), "withdrawShareTokens", [aC, bQ])
438438         else if ((be == b))
439439             then $Tuple3(aJ(Address(fromBase58String(aC))), "unstake", [av, bQ])
440440             else throw("Wrong pool type")
441441     let bT = bS._1
442442     let bU = bS._2
443443     let bV = bS._3
444444     let bW = invoke(bT, bU, bV, nil)
445445     if ((bW == bW))
446446         then bQ
447447         else throw("Strict value is not equal to itself.")
448448     }
449449 
450450 
451451 func bX (aC,bY,bZ,aw,ax,ca,cb) = {
452452     let ap = Address(fromBase58String(aC))
453453     let cc = 1000000
454454     let cd = getIntegerValue(ap, s)
455455     let ce = fraction(ca, cc, (cc - cd))
456456     let cf = if ((cb == bY))
457457         then {
458458             let cg = fraction(aw, ce, (ax - ce))
459459             $Tuple2(cg, bZ)
460460             }
461461         else {
462462             let cg = fraction(ax, ce, (aw - ce))
463463             $Tuple2(cg, bY)
464464             }
465465     let cg = cf._1
466466     let ch = cf._2
467467     $Tuple2(ch, cg)
468468     }
469469 
470470 
471471 func ci (aC,bY,bZ,aw,ax,ca,cb) = {
472472     let cj = getIntegerValue(aa, "%s__protocolFee")
473473     let ck = getIntegerValue(aa, "%s__poolFee")
474474     let cl = toBigInt(100000000)
475475     let cm = if ((cb == bY))
476476         then {
477477             let cg = fraction(aw, ca, (ax - ca))
478478             $Tuple2(cg, bZ)
479479             }
480480         else {
481481             let cg = fraction(ax, ca, (aw - ca))
482482             $Tuple2(cg, bY)
483483             }
484484     let cg = cm._1
485485     let ch = cm._2
486486     let cn = toInt(fraction(toBigInt(cg), cl, (cl - toBigInt((cj + ck)))))
487487     $Tuple2(ch, cn)
488488     }
489489 
490490 
491491 func co (az,aC,bY,bZ,aw,ax,ca,cb) = if ((az == a))
492492     then {
493493         let cp = bX(aC, bY, bZ, aw, ax, ca, cb)
494494         let ch = cp._1
495495         let cg = cp._2
496496         invoke(addressFromStringValue(aC), "callFunction", ["exchange", ["1"]], [AttachedPayment(aN(ch), cg)])
497497         }
498498     else {
499499         let cq = ci(aC, bY, bZ, aw, ax, ca, cb)
500500         let ch = cq._1
501501         let cg = cq._2
502502         invoke(aa, "swap", [1, cb, toString(this)], [AttachedPayment(aN(ch), cg)])
503503         }
504504 
505505 
506506 func cr (be,aC,bw,at,bx,au,aw,ax) = {
507507     let ap = addressFromStringValue(aC)
508508     if ((be == a))
509509         then {
510510             let bW = {
511511                 let as = invoke(ap, "callFunction", ["calcLPReplenishDiffPropREADONLY", [toString(bw), toString(bx), "0"]], nil)
512512                 if ($isInstanceOf(as, "List[Any]"))
513513                     then as
514514                     else throw(($getType(as) + " couldn't be cast to List[Any]"))
515515                 }
516516             if ((bW == bW))
517517                 then $Tuple2({
518518                     let as = bW[0]
519519                     if ($isInstanceOf(as, "Int"))
520520                         then as
521521                         else throw(($getType(as) + " couldn't be cast to Int"))
522522                     }, {
523523                     let as = bW[1]
524524                     if ($isInstanceOf(as, "Int"))
525525                         then as
526526                         else throw(($getType(as) + " couldn't be cast to Int"))
527527                     })
528528                 else throw("Strict value is not equal to itself.")
529529             }
530530         else if ((be == b))
531531             then {
532532                 let cs = if (if ((bw > 0))
533533                     then (bx > 0)
534534                     else false)
535535                     then {
536536                         let ct = bv(be, ap, bw, at, bx, au, aw, ax)
537537                         let bG = ct._1
538538                         let bH = ct._2
539539                         let bI = ct._3
540540                         let cu = ct._4
541541                         let cv = ct._5
542542                         $Tuple3(bI, cu, cv)
543543                         }
544544                     else if ((bw > 0))
545545                         then $Tuple3(bw, at, 0)
546546                         else $Tuple3(bx, au, 0)
547547                 let bI = cs._1
548548                 let cu = cs._2
549549                 let cw = cs._3
550550                 let cx = if ((bI > 0))
551551                     then {
552552                         let bW = {
553553                             let as = invoke(ap, "putOneTknREADONLY", [cu, bI], nil)
554554                             if ($isInstanceOf(as, "(Int, Int, Int)"))
555555                                 then as
556556                                 else throw(($getType(as) + " couldn't be cast to (Int, Int, Int)"))
557557                             }
558558                         if ((bW == bW))
559559                             then $Tuple2(bW._1, bW._3)
560560                             else throw("Strict value is not equal to itself.")
561561                         }
562562                     else $Tuple2(0, 0)
563563                 let cy = cx._1
564564                 let cz = cx._2
565565                 $Tuple2((cw + cy), cz)
566566                 }
567567             else throw("Wrong pool type")
568568     }
569569 
570570 
571571 func cA (be,aC,cv,av,at,au,aw,ax,cB,cC) = {
572572     let ap = addressFromStringValue(aC)
573573     let cD = if ((be == a))
574574         then {
575575             let bW = {
576576                 let as = invoke(ap, "callFunction", ["withdrawREADONLY", [toString(cv), toString(aw), toString(ax)]], nil)
577577                 if ($isInstanceOf(as, "List[Any]"))
578578                     then as
579579                     else throw(($getType(as) + " couldn't be cast to List[Any]"))
580580                 }
581581             if ((bW == bW))
582582                 then $Tuple2({
583583                     let as = bW[0]
584584                     if ($isInstanceOf(as, "Int"))
585585                         then as
586586                         else throw(($getType(as) + " couldn't be cast to Int"))
587587                     }, {
588588                     let as = bW[1]
589589                     if ($isInstanceOf(as, "Int"))
590590                         then as
591591                         else throw(($getType(as) + " couldn't be cast to Int"))
592592                     })
593593                 else throw("Strict value is not equal to itself.")
594594             }
595595         else if ((be == b))
596596             then {
597597                 let cE = split({
598598                     let as = invoke(ap, "evaluateGetREADONLY", [av, cv], nil)
599599                     if ($isInstanceOf(as, "String"))
600600                         then as
601601                         else throw(($getType(as) + " couldn't be cast to String"))
602602                     }, "__")
603603                 if ((cE == cE))
604604                     then $Tuple2(parseIntValue(cE[1]), parseIntValue(cE[2]))
605605                     else throw("Strict value is not equal to itself.")
606606                 }
607607             else throw("Wrong pool type")
608608     let cF = cD._1
609609     let cG = cD._2
610610     if ((cB > 0))
611611         then {
612612             let cH = if (if ((cC == at))
613613                 then (cB > cF)
614614                 else false)
615615                 then (cB - cF)
616616                 else if (if ((cC == au))
617617                     then (cB > cG)
618618                     else false)
619619                     then (cB - cG)
620620                     else 0
621621             let cI = if ((cH > 0))
622622                 then if ((be == a))
623623                     then bX(aC, at, au, aw, ax, cH, cC)
624624                     else ci(aC, at, au, aw, ax, cH, cC)
625625                 else $Tuple2("", 0)
626626             let ch = cI._1
627627             let cg = cI._2
628628             if ((cC == at))
629629                 then $Tuple2(((cF + cH) - cB), (cG - cg))
630630                 else $Tuple2((cF - cg), ((cG + cH) - cB))
631631             }
632632         else $Tuple2(cF, cG)
633633     }
634634 
635635 
636636 func cJ (az,aC) = if ((az == a))
637637     then {
638638         let cK = aj(ab)
639639         if ((cK == cK))
640640             then {
641641                 let bW = invoke(aI(), "claim", [aC], nil)
642642                 if ((bW == bW))
643643                     then {
644644                         let cL = aj(ab)
645645                         $Tuple2((cL - cK), ab)
646646                         }
647647                     else throw("Strict value is not equal to itself.")
648648                 }
649649             else throw("Strict value is not equal to itself.")
650650         }
651651     else if ((az == b))
652652         then {
653653             let cK = aj(ac)
654654             if ((cK == cK))
655655                 then {
656656                     let bW = invoke(aJ(Address(fromBase58String(aC))), "claimWX", [aC], nil)
657657                     if ((bW == bW))
658658                         then {
659659                             let cL = aj(ac)
660660                             $Tuple2((cL - cK), ac)
661661                             }
662662                         else throw("Strict value is not equal to itself.")
663663                     }
664664                 else throw("Strict value is not equal to itself.")
665665             }
666666         else throw("Wrong pool type")
667667 
668668 
669669 func cM (be,aC,aH,bw,at,bx,au,aw,ax,cN) = {
670670     let cO = aj(fromBase58String(cN))
671671     if ((cO == cO))
672672         then {
673673             let ap = addressFromStringValue(aC)
674674             let cP = if (if ((bw > 0))
675675                 then (bx > 0)
676676                 else false)
677677                 then {
678678                     let cQ = bv(be, ap, bw, at, bx, au, aw, ax)
679679                     let bG = cQ._1
680680                     let bH = cQ._2
681681                     let bI = cQ._3
682682                     let cu = cQ._4
683683                     let bW = bL(ap, be, bG, at, bH, au)
684684                     if ((bW == bW))
685685                         then $Tuple2(bI, cu)
686686                         else throw("Strict value is not equal to itself.")
687687                     }
688688                 else if ((bw > 0))
689689                     then $Tuple2(bw, at)
690690                     else if ((bx > 0))
691691                         then $Tuple2(bx, au)
692692                         else throw("pmts must be > 0")
693693             let bI = cP._1
694694             let cu = cP._2
695695             let bW = if ((bI > 0))
696696                 then bN(ap, be, bI, cu)
697697                 else nil
698698             if ((bW == bW))
699699                 then {
700700                     let cR = aj(fromBase58String(cN))
701701                     let cS = (cR - cO)
702702                     let cT = fraction(cS, aG(aC, aH), l)
703703                     let cU = (cS - cT)
704704                     if ((0 >= cU))
705705                         then throw("amount of staked sharetokens must be > 0")
706706                         else {
707707                             let cV = bP(aC, be, cN, cU)
708708                             if ((cV == cV))
709709                                 then $Tuple2(cU, cT)
710710                                 else throw("Strict value is not equal to itself.")
711711                             }
712712                     }
713713                 else throw("Strict value is not equal to itself.")
714714             }
715715         else throw("Strict value is not equal to itself.")
716716     }
717717 
718718 
719719 func cW (aC,aF,cX,cT,cY,av,az,cZ) = {
720720     let da = aB(aC)
721721     let db = aD(aC)
722722     let dc = if (cZ)
723723         then $Tuple2(getIntegerValue(this, (aC + B)), (db + cX))
724724         else $Tuple2(getIntegerValue(this, (aC + C)), db)
725725     let dd = dc._1
726726     let de = dc._2
727727 [IntegerEntry((aC + z), (da + cX)), IntegerEntry((aC + A), de), IntegerEntry((((((aC + "_") + aF) + "_") + toString(cY)) + t), cX), IntegerEntry((((((aC + "_") + aF) + "_") + toString(cY)) + y), dd), StringEntry((((aF + "_") + toString(cY)) + u), aC), IntegerEntry((aF + x), cY), ScriptTransfer(X, cT, fromBase58String(av))]
728728     }
729729 
730730 
731731 func df (dg,dh,di,dj,dk,dl,dm,dn,do,dp) = {
732732     let dq = aj(aN(dg))
733733     if ((dq == dq))
734734         then {
735735             let bW = invoke(Y, "swap", [dj, dk, dl, dm, dn, do, dp], [AttachedPayment(di, dh)])
736736             if ((bW == bW))
737737                 then (aj(aN(dg)) - dq)
738738                 else throw("Strict value is not equal to itself.")
739739             }
740740         else throw("Strict value is not equal to itself.")
741741     }
742742 
743743 
744744 func dr (dg,dh,di,ds,dt,dp) = {
745745     let dq = aj(aN(dg))
746746     if ((dq == dq))
747747         then {
748748             let bW = invoke(Y, "puzzleSwap", [ds, dt, dp], [AttachedPayment(di, dh)])
749749             if ((bW == bW))
750750                 then (aj(aN(dg)) - dq)
751751                 else throw("Strict value is not equal to itself.")
752752             }
753753         else throw("Strict value is not equal to itself.")
754754     }
755755 
756756 
757757 func du (dg,dh,di,dv,dw,dx,dy,dz,dA,dp) = {
758758     let dq = aj(aN(dg))
759759     if ((dq == dq))
760760         then {
761761             let bW = invoke(Y, "swopfiSwap", [dv, dw, dx, dy, dz, dA, dp], [AttachedPayment(di, dh)])
762762             if ((bW == bW))
763763                 then (aj(aN(dg)) - dq)
764764                 else throw("Strict value is not equal to itself.")
765765             }
766766         else throw("Strict value is not equal to itself.")
767767     }
768768 
769769 
770770 func dB (aC,be,dC,dD) = {
771771     let ap = Address(fromBase58String(aC))
772772     let dE = ay(ap, be)
773773     let dF = dE._1
774774     let dG = dE._2
775775     let aw = dE._3
776776     let ax = dE._4
777777     let av = dE._5
778778     if (if ((dC != dF))
779779         then (dC != dG)
780780         else false)
781781         then throw("Wrong asset")
782782         else {
783783             let dH = if ((dC == dF))
784784                 then $Tuple2(dD, 0)
785785                 else $Tuple2(0, dD)
786786             let bw = dH._1
787787             let bx = dH._2
788788             let dI = cM(be, aC, i, bw, dF, bx, dG, aw, ax, av)
789789             let cX = dI._1
790790             let dJ = dI._2
791791             let dK = valueOrElse(getInteger(this, (aC + B)), 0)
792792             let dL = valueOrElse(getInteger(this, (aC + C)), 0)
793793             let dM = aB(aC)
794794             let dN = aD(aC)
795795             let dO = fraction(dN, j, dM)
796796             let dP = fraction(cX, dO, j)
797797             let dQ = (cX - dP)
798798             let dR = if ((dN > 0))
799799                 then (dK + fraction(dP, k, dN))
800800                 else 0
801801             let dS = if (((dM - dN) > 0))
802802                 then (dL + fraction(dQ, k, (dM - dN)))
803803                 else 0
804804             let dT = fraction(dP, aG(aC, d), l)
805805             let dU = fraction(dQ, aG(aC, c), l)
806806             let dV = bR(aC, be, av, (dT + dU))
807807             if ((dV == dV))
808808                 then ([IntegerEntry((aC + B), dR), IntegerEntry((aC + C), dS), IntegerEntry((aC + z), ((dM + cX) - dV)), IntegerEntry((aC + A), ((dN + dP) - dT)), ScriptTransfer(X, (dT + dU), fromBase58String(av))] ++ br(dF, dG, av))
809809                 else throw("Strict value is not equal to itself.")
810810             }
811811     }
812812 
813813 
814814 func dW (aC,dX,dY,dZ) = {
815815     let ap = Address(fromBase58String(aC))
816816     let be = valueOrErrorMessage(getString(this, (L + aC)), "Unknown pool")
817817     let ea = ay(ap, be)
818818     let bY = ea._1
819819     let bZ = ea._2
820820     let aw = ea._3
821821     let ax = ea._4
822822     let av = ea._5
823823     let eb = aj(aN(bY))
824824     if ((eb == eb))
825825         then {
826826             let ec = aj(aN(bZ))
827827             if ((ec == ec))
828828                 then {
829829                     let bW = if ((be == a))
830830                         then invoke(ap, "callFunction", ["withdraw", [toString(dX)]], nil)
831831                         else {
832832                             let bW = bR(aC, be, av, dX)
833833                             if ((bW == bW))
834834                                 then invoke(ap, "get", nil, [AttachedPayment(aN(av), dX)])
835835                                 else throw("Strict value is not equal to itself.")
836836                             }
837837                     if ((bW == bW))
838838                         then {
839839                             let ed = aj(aN(bY))
840840                             let ee = aj(aN(bZ))
841841                             let ef = $Tuple2((ed - eb), (ee - ec))
842842                             let eg = ef._1
843843                             let eh = ef._2
844844                             let ei = if ((dY > 0))
845845                                 then {
846846                                     let cH = if (if ((dZ == bY))
847847                                         then (dY > eg)
848848                                         else false)
849849                                         then (dY - eg)
850850                                         else if (if ((dZ == bZ))
851851                                             then (dY > eh)
852852                                             else false)
853853                                             then (dY - eh)
854854                                             else 0
855855                                     let ej = if ((cH > 0))
856856                                         then co(be, aC, bY, bZ, aw, ax, cH, dZ)
857857                                         else 0
858858                                     if ((ej == ej))
859859                                         then {
860860                                             let ek = aj(aN(bY))
861861                                             let el = aj(aN(bZ))
862862                                             $Tuple2((ek - eb), (el - ec))
863863                                             }
864864                                         else throw("Strict value is not equal to itself.")
865865                                     }
866866                                 else $Tuple2(eg, eh)
867867                             let em = ei._1
868868                             let en = ei._2
869869                             $Tuple7(em, bY, en, bZ, ed, ee, av)
870870                             }
871871                         else throw("Strict value is not equal to itself.")
872872                     }
873873                 else throw("Strict value is not equal to itself.")
874874             }
875875         else throw("Strict value is not equal to itself.")
876876     }
877877 
878878 
879879 func eo (aF,aC,ep,eq) = {
880880     let er = valueOrErrorMessage(getInteger(this, (((((aC + "_") + aF) + "_") + ep) + t)), "Unknown position")
881881     let es = getIntegerValue(this, (((((aC + "_") + aF) + "_") + ep) + y))
882882     let et = if (eq)
883883         then getIntegerValue(this, (aC + B))
884884         else getIntegerValue(this, (aC + C))
885885     (er + fraction(er, (et - es), k))
886886     }
887887 
888888 
889889 func eu (aF,aC,ep,ev) = {
890890     let er = valueOrErrorMessage(getInteger(this, (((((aC + "_") + aF) + "_") + ep) + t)), "Unknown position")
891891     let es = getIntegerValue(this, (((((aC + "_") + aF) + "_") + ep) + y))
892892     let cB = valueOrElse(getInteger(this, (((((aC + "_") + aF) + "_") + ep) + v)), 0)
893893     let dX = eo(aF, aC, ep, (cB > 0))
894894     let ew = aB(aC)
895895     let ex = Address(fromBase58String(aF))
896896     let dZ = valueOrElse(getString(this, (((((aC + "_") + aF) + "_") + ep) + w)), "")
897897     let dY = if ((cB > 0))
898898         then {
899899             let as = invoke(ad(), "getAssetDebt", [false, ((aF + "_") + ep), dZ], nil)
900900             if ($isInstanceOf(as, "Int"))
901901                 then as
902902                 else throw(($getType(as) + " couldn't be cast to Int"))
903903             }
904904         else 0
905905     let ey = dW(aC, dX, dY, dZ)
906906     if ((ey == ey))
907907         then {
908908             let av = ey._7
909909             let ee = ey._6
910910             let ed = ey._5
911911             let bZ = ey._4
912912             let en = ey._3
913913             let bY = ey._2
914914             let em = ey._1
915915             let ez = if ((dY > 0))
916916                 then invoke(ad(), "repayFor", [((aF + "_") + ep)], [AttachedPayment(aN(dZ), dY)])
917917                 else 0
918918             if ((ez == ez))
919919                 then ([DeleteEntry((((((aC + "_") + aF) + "_") + ep) + t)), DeleteEntry((((((aC + "_") + aF) + "_") + ep) + y)), IntegerEntry((aC + z), (ew - dX)), ScriptTransfer(ex, em, aN(bY)), ScriptTransfer(ex, en, aN(bZ))] ++ br(bY, bZ, av))
920920                 else throw("Strict value is not equal to itself.")
921921             }
922922         else throw("Strict value is not equal to itself.")
923923     }
924924 
925925 
926926 func eA (eB) = {
927927     let eC = split(valueOrErrorMessage(getString(this, (eB + J)), ("No request with id " + eB)), ",")
928928     let aF = eC[0]
929929     let aC = eC[1]
930930     let bw = parseIntValue(eC[2])
931931     let dF = eC[3]
932932     let bx = parseIntValue(eC[4])
933933     let dG = eC[5]
934934     let aw = parseIntValue(eC[6])
935935     let ax = parseIntValue(eC[7])
936936     let av = eC[8]
937937     let eD = eC[9]
938938     let eE = parseIntValue(eC[10])
939939     $Tuple11(aF, aC, bw, dF, bx, dG, aw, ax, av, eD, eE)
940940     }
941941 
942942 
943943 func eF (bw,bx,at,au,eG,eH) = {
944944     let bi = (    let as = invoke(Z, "getTWAP60", [at, false], nil)
945945     if ($isInstanceOf(as, "(Int, Int)"))
946946         then as
947947         else throw(($getType(as) + " couldn't be cast to (Int, Int)")))._2
948948     let bj = (    let as = invoke(Z, "getTWAP60", [au, false], nil)
949949     if ($isInstanceOf(as, "(Int, Int)"))
950950         then as
951951         else throw(($getType(as) + " couldn't be cast to (Int, Int)")))._2
952952     let eI = pow(10, 0, aO(at), 0, 0, DOWN)
953953     let eJ = pow(10, 0, aO(au), 0, 0, DOWN)
954954     let eK = (fraction(bi, bw, eI) + fraction(bj, bx, eJ))
955955     let eL = if ((eH == at))
956956         then $Tuple2(bi, eI)
957957         else $Tuple2(bj, eJ)
958958     let eM = eL._1
959959     let eN = eL._2
960960     fraction(fraction(eK, (eG - 100), 100), eN, eM)
961961     }
962962 
963963 
964964 @Callable(ag)
965965 func calcPriceImpactEVALONLY (aC,eG,eH,bw,bx) = if (if ((100 > eG))
966966     then true
967967     else (eG > 300))
968968     then throw("Leverage can't be <100 and >300")
969969     else {
970970         let be = valueOrErrorMessage(getString(this, (L + aC)), "Pool is not inited")
971971         let eO = ay(Address(fromBase58String(aC)), be)
972972         let dF = eO._1
973973         let dG = eO._2
974974         let aw = eO._3
975975         let ax = eO._4
976976         let av = eO._5
977977         let cB = if ((eG > 100))
978978             then eF(bw, bx, dF, dG, eG, eH)
979979             else 0
980980         let eP = if ((eH == dF))
981981             then $Tuple2((bw + cB), bx)
982982             else $Tuple2(bw, (bx + cB))
983983         let eQ = eP._1
984984         let eR = eP._2
985985         let eS = cr(be, aC, eQ, dF, eR, dG, aw, ax)
986986         let cv = eS._1
987987         let cz = eS._2
988988         let eT = if ((0 > cz))
989989             then (cz * -1)
990990             else cz
991991         $Tuple2(nil, [eT])
992992         }
993993 
994994 
995995 
996996 @Callable(ag)
997997 func getShareAssetPriceREADONLY (av) = {
998998     let eU = bd(av)
999999     $Tuple2(nil, eU)
10001000     }
10011001 
10021002 
10031003 
10041004 @Callable(ag)
10051005 func getUserPositionShareAmountREADONLY (aF,cY) = {
10061006     let aC = valueOrErrorMessage(getString(this, (((aF + "_") + cY) + u)), "Unknown position")
10071007     let cB = getIntegerValue(this, (((((aC + "_") + aF) + "_") + cY) + v))
10081008     let dX = eo(aF, aC, cY, (cB > 0))
10091009     $Tuple2(nil, dX)
10101010     }
10111011 
10121012 
10131013 
10141014 @Callable(ag)
10151015 func getUserPositionInDollarsREADONLY (aF,eV,cY) = {
10161016     func eW (aU,aC) =     {
10171017         let eX = aU
10181018         let eY = eX._1
10191019         let eZ = eX._2
10201020         let fa = eX._3
10211021         let be = valueOrErrorMessage(getString(this, (L + aC)), "Pool is not inited")
10221022         let fb = ay(Address(fromBase58String(aC)), be)
10231023         let dF = fb._1
10241024         let dG = fb._2
10251025         let aw = fb._3
10261026         let ax = fb._4
10271027         let av = fb._5
10281028         let cB = valueOrElse(getInteger(this, (((((aC + "_") + aF) + "_") + cY[fa]) + v)), 0)
10291029         let dX = eo(aF, aC, cY[fa], (cB > 0))
10301030         let eU = bd(av)
10311031         let fc = pow(10, 0, aO(av), 0, 0, DOWN)
10321032         let fd = fraction(dX, eU, fc)
10331033         if ((cB == 0))
10341034             then $Tuple3((eY :+ fd), (eZ :+ 0), (fa + 1))
10351035             else {
10361036                 let dZ = getStringValue(this, (((((aC + "_") + aF) + "_") + cY[fa]) + w))
10371037                 let dY = {
10381038                     let as = invoke(ad(), "getAssetDebt", [false, ((aF + "_") + cY[fa]), dZ], nil)
10391039                     if ($isInstanceOf(as, "Int"))
10401040                         then as
10411041                         else throw(($getType(as) + " couldn't be cast to Int"))
10421042                     }
10431043                 let fe = (                let as = invoke(Z, "getTWAP60", [dZ, false], nil)
10441044                 if ($isInstanceOf(as, "(Int, Int)"))
10451045                     then as
10461046                     else throw(($getType(as) + " couldn't be cast to (Int, Int)")))._1
10471047                 let ff = pow(10, 0, aO(dZ), 0, 0, DOWN)
10481048                 let fg = fraction(dY, fe, ff)
10491049                 $Tuple3((eY :+ fd), (eZ :+ fg), (fa + 1))
10501050                 }
10511051         }
10521052 
10531053     let fh = {
10541054         let aW = eV
10551055         let aX = size(aW)
10561056         let aY = $Tuple3(nil, nil, 0)
10571057         func aZ (ba,bb) =         if ((bb >= aX))
10581058             then ba
10591059             else eW(ba, aW[bb])
10601060 
10611061         func bc (ba,bb) =         if ((bb >= aX))
10621062             then ba
10631063             else throw("List size exceeds 20")
10641064 
10651065         bc(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aZ(aY, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
10661066         }
10671067     let fi = fh._1
10681068     let dY = fh._2
10691069     $Tuple2(nil, $Tuple2(fi, dY))
10701070     }
10711071 
10721072 
10731073 
10741074 @Callable(ag)
10751075 func replenish (aC,eG,eH) = if (if ((100 > eG))
10761076     then true
10771077     else (eG > 300))
10781078     then throw("Leverage can't be <100 and >300")
10791079     else {
10801080         let be = valueOrErrorMessage(getString(this, (L + aC)), "Pool is not inited")
10811081         let fj = ay(Address(fromBase58String(aC)), be)
10821082         let dF = fj._1
10831083         let dG = fj._2
10841084         let aw = fj._3
10851085         let ax = fj._4
10861086         let av = fj._5
10871087         let fk = if ((size(ag.payments) == 2))
10881088             then if ((aM(ag.payments[0].assetId) != dF))
10891089                 then throw("Wrong payment asset A")
10901090                 else if ((aM(ag.payments[1].assetId) != dG))
10911091                     then throw("Wrong payment asset B")
10921092                     else $Tuple4(ag.payments[0].amount, dF, ag.payments[1].amount, dG)
10931093             else if ((size(ag.payments) == 1))
10941094                 then if ((aM(ag.payments[0].assetId) == dF))
10951095                     then $Tuple4(ag.payments[0].amount, dF, 0, dG)
10961096                     else if ((aM(ag.payments[0].assetId) == dG))
10971097                         then $Tuple4(0, dF, ag.payments[0].amount, dG)
10981098                         else throw("Wrong payment")
10991099                 else throw("One or two payments expected")
11001100         let bw = fk._1
11011101         let fl = fk._2
11021102         let bx = fk._3
11031103         let fm = fk._4
11041104         let fn = aE(toString(ag.caller))
11051105         if ((eG > 100))
11061106             then {
11071107                 let cB = eF(bw, bx, fl, fm, eG, eH)
11081108                 let eC = makeString([toString(ag.caller), aC, toString(bw), fl, toString(bx), fm, toString(aw), toString(ax), av, eH, toString(cB)], ",")
11091109                 let fo = {
11101110                     let as = invoke(this, "createNewRequest", [eC], nil)
11111111                     if ($isInstanceOf(as, "Int"))
11121112                         then as
11131113                         else throw(($getType(as) + " couldn't be cast to Int"))
11141114                     }
11151115                 if ((fo == fo))
11161116                     then {
11171117                         let fp = [((toString(ag.caller) + "_") + toString(fn)), av, eH, cB, toString(this), "replenishFromLand", toString(valueOrErrorMessage(fo, "Can't create new request"))]
11181118                         let bW = reentrantInvoke(ad(), "flashPosition", fp, nil)
11191119                         if ((bW == bW))
11201120                             then nil
11211121                             else throw("Strict value is not equal to itself.")
11221122                         }
11231123                     else throw("Strict value is not equal to itself.")
11241124                 }
11251125             else {
11261126                 let fq = cM(be, aC, h, bw, dF, bx, dG, aw, ax, av)
11271127                 let fr = fq._1
11281128                 let dV = fq._2
11291129                 (cW(aC, toString(ag.caller), fr, dV, fn, av, be, false) ++ br(dF, dG, av))
11301130                 }
11311131         }
11321132 
11331133 
11341134 
11351135 @Callable(ag)
11361136 func withdraw (aC,ep) = eu(toString(ag.caller), aC, toString(ep), false)
11371137 
11381138 
11391139 
11401140 @Callable(ag)
11411141 func createUpdateStopLoss (ep,fs,ak,ft) = {
11421142     let fu = (    let as = invoke(Z, "getTWAP60", [ak, false], nil)
11431143     if ($isInstanceOf(as, "(Int, Int)"))
11441144         then as
11451145         else throw(($getType(as) + " couldn't be cast to (Int, Int)")))._1
11461146     if (!(isDefined(getInteger(this, (((((fs + "_") + toString(ag.caller)) + "_") + toString(ep)) + t)))))
11471147         then throw("There are no user position")
11481148         else if ((0 >= ft))
11491149             then throw("Price must be greater than 0")
11501150             else if ((ft > fu))
11511151                 then throw("Price must be less than current token price")
11521152                 else [IntegerEntry((((((((toString(ag.caller) + "_") + toString(ep)) + "_") + fs) + "_") + ak) + P), ft)]
11531153     }
11541154 
11551155 
11561156 
11571157 @Callable(ag)
11581158 func deleteStopLoss (ep,fs,ak) = if (!(isDefined(getInteger(this, (((((((toString(ag.caller) + "_") + toString(ep)) + "_") + fs) + "_") + ak) + P)))))
11591159     then throw("No entry")
11601160     else [DeleteEntry((((((((toString(ag.caller) + "_") + toString(ep)) + "_") + fs) + "_") + ak) + P))]
11611161 
11621162 
11631163 
11641164 @Callable(ag)
11651165 func createNewRequest (bV) = valueOrElse(ah(ag), {
11661166     let fo = (valueOrElse(getInteger(this, K), 0) + 1)
11671167     $Tuple2([StringEntry((toString(fo) + J), bV), IntegerEntry(K, fo)], fo)
11681168     })
11691169 
11701170 
11711171 
11721172 @Callable(ag)
11731173 func replenishFromLand (eB) = valueOrElse(ai(ag), {
11741174     let fv = eA(eB)
11751175     let aF = fv._1
11761176     let aC = fv._2
11771177     let bw = fv._3
11781178     let dF = fv._4
11791179     let bx = fv._5
11801180     let dG = fv._6
11811181     let aw = fv._7
11821182     let ax = fv._8
11831183     let av = fv._9
11841184     let eD = fv._10
11851185     let eE = fv._11
11861186     if ((size(ag.payments) != 1))
11871187         then throw("Wrong payment size")
11881188         else if (if ((aM(ag.payments[0].assetId) != eD))
11891189             then true
11901190             else (ag.payments[0].amount != eE))
11911191             then throw("Wrong payment")
11921192             else {
11931193                 let fw = if ((dF == eD))
11941194                     then $Tuple2((bw + ag.payments[0].amount), bx)
11951195                     else $Tuple2(bw, (bx + ag.payments[0].amount))
11961196                 let fx = fw._1
11971197                 let fy = fw._2
11981198                 let be = valueOrErrorMessage(getString(this, (L + aC)), "Unknown pool")
11991199                 let fz = cM(be, aC, g, fx, dF, fy, dG, aw, ax, av)
12001200                 let fr = fz._1
12011201                 let dV = fz._2
12021202                 let cY = aE(aF)
12031203                 let fA = [IntegerEntry((((((aC + "_") + aF) + "_") + toString(cY)) + v), eE), StringEntry((((((aC + "_") + aF) + "_") + toString(cY)) + w), eD)]
12041204                 let fB = cW(aC, aF, fr, dV, cY, av, be, true)
12051205                 $Tuple2((((fB ++ br(dF, dG, av)) ++ fA) :+ DeleteEntry((eB + J))), fr)
12061206                 }
12071207     })
12081208 
12091209 
12101210 
12111211 @Callable(ag)
12121212 func liquidate (aF,ep,fC) = valueOrElse(ai(ag), {
12131213     let aC = valueOrErrorMessage(getString(this, (((aF + "_") + ep) + u)), "no position")
12141214     let be = valueOrErrorMessage(getString(this, (L + aC)), "Pool is not inited")
12151215     let fD = ay(Address(fromBase58String(aC)), be)
12161216     let dF = fD._1
12171217     let dG = fD._2
12181218     let aw = fD._3
12191219     let ax = fD._4
12201220     let av = fD._5
12211221     let bQ = bR(aC, be, av, fC)
12221222     let cB = getIntegerValue(this, (((((aC + "_") + aF) + "_") + ep) + v))
12231223     let dZ = getStringValue(this, (((((aC + "_") + aF) + "_") + ep) + w))
12241224     let dX = eo(aF, aC, ep, (cB > 0))
12251225     if ((cB == 0))
12261226         then throw("You can't liquidate position without borrow")
12271227         else [IntegerEntry((((((aC + "_") + aF) + "_") + ep) + y), getIntegerValue(this, (aC + B))), IntegerEntry((aC + A), (aD(aC) - fC)), IntegerEntry((aC + z), (aB(aC) - fC)), IntegerEntry((((((aC + "_") + aF) + "_") + ep) + t), (dX - fC)), ScriptTransfer(ag.caller, bQ, fromBase58String(av))]
12281228     })
12291229 
12301230 
12311231 
12321232 @Callable(ag)
12331233 func stopLoss (aF,ep,aC,ak) = valueOrElse(af(ag), {
12341234     let fu = (    let as = invoke(Z, "getTWAP60", [ak, false], nil)
12351235     if ($isInstanceOf(as, "(Int, Int)"))
12361236         then as
12371237         else throw(($getType(as) + " couldn't be cast to (Int, Int)")))._1
12381238     if (!(isDefined(getInteger(this, (((((((aF + "_") + toString(ep)) + "_") + aC) + "_") + ak) + P)))))
12391239         then throw("No entry")
12401240         else (eu(toString(ag.caller), aC, toString(ep), true) :+ DeleteEntry((((((((aF + "_") + toString(ep)) + "_") + aC) + "_") + ak) + P)))
12411241     })
12421242 
12431243 
12441244 
12451245 @Callable(ag)
12461246 func capitalizeExKeeper (aC,az,fE,fF,fG,dj,dk,dl,dm,dn,do,dp) = valueOrElse(af(ag), {
12471247     let fH = if (fG)
12481248         then cJ(az, aC)
12491249         else {
12501250             let fI = if ((az == a))
12511251                 then ab
12521252                 else ac
12531253             $Tuple2(fF, fI)
12541254             }
12551255     let fJ = fH._1
12561256     let fI = fH._2
12571257     let fK = df(fE, fF, fI, dj, dk, dl, dm, dn, do, dp)
12581258     let bI = (fJ - fF)
12591259     let fL = if ((bI > 0))
12601260         then [IntegerEntry((aC + N), (bI + valueOrElse(getInteger(this, (aC + N)), 0)))]
12611261         else nil
12621262     (dB(aC, az, fE, fK) ++ fL)
12631263     })
12641264 
12651265 
12661266 
12671267 @Callable(ag)
12681268 func capitalizeExPuzzle (aC,az,fE,fF,fG,ds,dt,dp) = valueOrElse(af(ag), {
12691269     let fM = if (fG)
12701270         then cJ(az, aC)
12711271         else {
12721272             let fI = if ((az == a))
12731273                 then ab
12741274                 else ac
12751275             $Tuple2(fF, fI)
12761276             }
12771277     let fJ = fM._1
12781278     let fI = fM._2
12791279     let fK = dr(fE, fF, fI, ds, dt, dp)
12801280     let bI = (fJ - fF)
12811281     let fL = if ((bI > 0))
12821282         then [IntegerEntry((aC + N), (bI + valueOrElse(getInteger(this, (aC + N)), 0)))]
12831283         else nil
12841284     (dB(aC, az, fE, fK) ++ fL)
12851285     })
12861286 
12871287 
12881288 
12891289 @Callable(ag)
12901290 func capitalizeExSwopFi (aC,az,fE,fF,fG,dv,dw,dx,dy,dz,dA,dp) = valueOrElse(af(ag), {
12911291     let fN = if (fG)
12921292         then cJ(az, aC)
12931293         else {
12941294             let fI = if ((az == a))
12951295                 then ab
12961296                 else ac
12971297             $Tuple2(fF, fI)
12981298             }
12991299     let fJ = fN._1
13001300     let fI = fN._2
13011301     let fK = du(fE, fF, fI, dv, dw, dx, dy, dz, dA, dp)
13021302     let bI = (fJ - fF)
13031303     let fL = if ((bI > 0))
13041304         then [IntegerEntry((aC + N), (bI + valueOrElse(getInteger(this, (aC + N)), 0)))]
13051305         else nil
13061306     (dB(aC, az, fE, fK) ++ fL)
13071307     })
13081308 
13091309 
13101310 
13111311 @Callable(ag)
13121312 func initNewPool (az,ap,fO,fP,fQ,fR,fS,fT) = valueOrElse(af(ag), if (if ((az != a))
13131313     then (az != b)
13141314     else false)
13151315     then throw("Wrong type")
13161316     else {
13171317         let fU = ay(Address(fromBase58String(ap)), az)
13181318         let at = fU._1
13191319         let au = fU._2
13201320         let fV = fU._3
13211321         let fW = fU._4
13221322         let av = fU._5
13231323 [IntegerEntry((ap + D), fO), IntegerEntry((ap + E), fP), IntegerEntry((ap + F), fQ), IntegerEntry((ap + G), fR), IntegerEntry((ap + H), fS), IntegerEntry((ap + I), fT), IntegerEntry((ap + B), 0), IntegerEntry((ap + C), 0), StringEntry((L + ap), az), StringEntry((av + M), ap)]
13241324         })
13251325 
13261326 
13271327 @Verifier(fX)
13281328 func fY () = sigVerify(fX.bodyBytes, fX.proofs[0], fX.senderPublicKey)
13291329 
github/deemru/w8io/169f3d6 
166.86 ms ◑