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 SF_POOL = "SF"
5+
6+let WX_POOL = "WX"
7+
8+let CAP_FEE_NO_LOAN = "capNoLoan"
9+
10+let CAP_FEE_LOAN = "capLoan"
11+
12+let STOPLOSS_FEE_NO_LOAN = "stopLossNoLoan"
13+
14+let STOPLOSS_LOAN = "stopLossLoan"
15+
16+let LOAN_FEE = "loan"
17+
18+let NO_LOAN_FEE = "noLoan"
19+
20+let NO_FEE = "noFee"
21+
22+let SCALE8 = 100000000
23+
24+let SCALE10 = 10000000000
25+
26+let SCALE16 = toBigInt(10000000000000000)
27+
28+let FEE_SCALE6 = 1000000
29+
30+let kSFPoolAAssetBalance = "A_asset_balance"
31+
32+let kSFPoolBAssetBalance = "B_asset_balance"
33+
34+let kSFPoolAAssetId = "A_asset_id"
35+
36+let kSFPoolBAssetId = "B_asset_id"
37+
38+let kSFPoolShareId = "share_asset_id"
39+
40+let kSFPoolShareSupply = "share_asset_supply"
41+
42+let kSFPoolFee = "commission"
43+
44+let kUserPosition = "_user_position"
45+
46+let kUserPositionPool = "_user_position_pool"
47+
48+let kUserBorrowAmount = "_user_position_borrow_amount"
49+
50+let kUserBorrowAssetId = "_user_position_borrow_asset_id"
51+
52+let kUserPositionNum = "_user_position_number"
53+
54+let kUserPositionInterest = "_user_position_interest"
55+
56+let kPoolTotal = "_pool_total"
57+
58+let kPoolTotalLoan = "_pool_total_loan"
59+
60+let kPoolInterestLoan = "_pool_interest_loan"
61+
62+let kPoolInterestNoLoan = "_pool_interest_no_loan"
63+
64+let kPoolCanBorrow = "_pool_can_borrow"
65+
66+let kAxlyInFeeWithoutLoan = "_axly_fee_without_loan"
67+
68+let kAxlyInFeeWithLoan = "_axly_fee_with_loan"
69+
70+let kAxlyNoLoanCapFee = "_axly_fee_cap_with_loan"
71+
72+let kAxlyWithLoanCapFee = "_axly_fee_cap_no_loan"
73+
74+let kAxlyStopLossNoLoanFee = "_axly_fee_stoploss_with_loan"
75+
76+let kAxlyStopLossLoanFee = "_axly_fee_stoploss_no_loan"
77+
78+let kRequestId = "_request_id"
79+
80+let kRequestIter = "requests_iter"
81+
82+let kPool = "pool_"
83+
84+let kSharePool = "_pool_share_id"
85+
86+let kPoolCapChange = "_pool_cap_change"
87+
88+let kTokenLastPrice = "last_price"
89+
90+let kUserStopLoss = "_stop_loss"
91+
92+let kMoneyBox = "axly_money_box"
93+
94+let kSFFarmingAddr = "swopfi_farming_addr"
95+
96+let kLendService = "lend_service_addr"
97+
98+let kAdminCallPK = "admin_call_pub_key"
99+
100+let kPriceOracle = "price_oracle"
101+
102+let kExContract = "exchange_contract"
103+
104+let kWxSwapContract = "wx_swap_contract"
105+
106+let kSwopId = "swop_id"
107+
108+let kWxId = "wx_id"
109+
110+let moneyBox = Address(fromBase58String(valueOrErrorMessage(getString(this, kMoneyBox), "No axly moneyBox address")))
111+
112+let exContract = Address(fromBase58String(valueOrErrorMessage(getString(this, kExContract), "No exchange contract address")))
113+
114+let priceOracleAddr = Address(fromBase58String(valueOrErrorMessage(getString(this, kPriceOracle), "No price oracle address")))
115+
116+let wxSwapContract = Address(fromBase58String(valueOrErrorMessage(getString(this, kWxSwapContract), "No wx swap address")))
117+
118+let SWOPID = fromBase58String(valueOrErrorMessage(getString(this, kSwopId), "No swop id"))
119+
120+let WXID = fromBase58String(valueOrErrorMessage(getString(this, kWxId), "No wx id"))
121+
122+func getLendSrvAddr () = Address(fromBase58String(valueOrErrorMessage(getString(this, kLendService), "Can't get lend service addr")))
123+
124+
125+func getAdminCallAddr () = addressFromPublicKey(fromBase58String(valueOrErrorMessage(getString(this, kAdminCallPK), "Can't get admin addr")))
126+
127+
128+func isAdminCall (i) = if ((i.caller == getAdminCallAddr()))
129+    then unit
130+    else throw("Only admin can call this function")
131+
132+
133+func isSelfCall (i) = if ((i.caller == this))
134+    then unit
135+    else throw("Only contract itself can call this function")
136+
137+
138+func isLandCall (i) = if ((i.caller == getLendSrvAddr()))
139+    then unit
140+    else throw("Only land contract can call this function")
141+
142+
143+func accountBalance (assetId) = match assetId {
144+    case id: ByteVector => 
145+        assetBalance(this, id)
146+    case waves: Unit => 
147+        wavesBalance(this).available
148+    case _ => 
149+        throw("Match error")
150+}
151+
152+
153+func getSFPoolData (poolAddr) = $Tuple5(valueOrErrorMessage(getString(poolAddr, kSFPoolAAssetId), "Can't get pool A asset id"), valueOrErrorMessage(getString(poolAddr, kSFPoolBAssetId), "Can't get pool B asset id"), valueOrErrorMessage(getInteger(poolAddr, kSFPoolAAssetBalance), "Can't get pool A asset balance"), valueOrErrorMessage(getInteger(poolAddr, kSFPoolBAssetBalance), "Can't get pool B asset balance"), valueOrErrorMessage(getString(poolAddr, kSFPoolShareId), "Can't get share asset id"))
154+
155+
156+func getWXPoolData (poolAddr) = {
157+    let cfg = {
158+        let @ = invoke(poolAddr, "getPoolConfigWrapperREADONLY", nil, nil)
159+        if ($isInstanceOf(@, "List[Any]"))
160+            then @
161+            else throw(($getType(@) + " couldn't be cast to List[Any]"))
162+        }
163+    if ((cfg == cfg))
164+        then {
165+            let aId = valueOrErrorMessage({
166+                let @ = cfg[4]
167+                if ($isInstanceOf(@, "String"))
168+                    then @
169+                    else unit
170+                }, "Can't get pool A asset id")
171+            let bId = valueOrErrorMessage({
172+                let @ = cfg[5]
173+                if ($isInstanceOf(@, "String"))
174+                    then @
175+                    else unit
176+                }, "Can't get pool B asset id")
177+            let shareId = valueOrErrorMessage({
178+                let @ = cfg[3]
179+                if ($isInstanceOf(@, "String"))
180+                    then @
181+                    else unit
182+                }, "Can't get pool LP asset id")
183+            let balA = {
184+                let @ = invoke(poolAddr, "getAccBalanceWrapperREADONLY", [aId], nil)
185+                if ($isInstanceOf(@, "Int"))
186+                    then @
187+                    else throw(($getType(@) + " couldn't be cast to Int"))
188+                }
189+            if ((balA == balA))
190+                then {
191+                    let balB = {
192+                        let @ = invoke(poolAddr, "getAccBalanceWrapperREADONLY", [bId], nil)
193+                        if ($isInstanceOf(@, "Int"))
194+                            then @
195+                            else throw(($getType(@) + " couldn't be cast to Int"))
196+                        }
197+                    if ((balB == balB))
198+                        then $Tuple5(aId, bId, balA, balB, shareId)
199+                        else throw("Strict value is not equal to itself.")
200+                    }
201+                else throw("Strict value is not equal to itself.")
202+            }
203+        else throw("Strict value is not equal to itself.")
204+    }
205+
206+
207+func getPoolData (poolAddr,type) = if ((type == SF_POOL))
208+    then getSFPoolData(poolAddr)
209+    else if ((type == WX_POOL))
210+        then getWXPoolData(poolAddr)
211+        else throw("Wrong pool type")
212+
213+
214+func getShareSupply (poolAddr,type,shareId) = if ((type == SF_POOL))
215+    then valueOrErrorMessage(getInteger(poolAddr, kSFPoolShareSupply), "Can't get share asset supply")
216+    else if ((type == WX_POOL))
217+        then valueOrErrorMessage(assetInfo(fromBase58String(shareId)), "Wrong ShareId").quantity
218+        else throw("Wrong pool type")
219+
220+
221+func getPoolTotalShare (pool) = valueOrElse(getInteger(this, (pool + kPoolTotal)), 0)
222+
223+
224+func getPoolTotalShareWithLoan (pool) = valueOrElse(getInteger(this, (pool + kPoolTotalLoan)), 0)
225+
226+
227+func getNewUserPositionNumber (user) = (valueOrElse(getInteger(this, (user + kUserPositionNum)), 0) + 1)
228+
229+
230+func getAxlyFee (pool,feeType) = if ((feeType == CAP_FEE_LOAN))
231+    then getIntegerValue(this, (pool + kAxlyWithLoanCapFee))
232+    else if ((feeType == CAP_FEE_NO_LOAN))
233+        then getIntegerValue(this, (pool + kAxlyNoLoanCapFee))
234+        else if ((feeType == LOAN_FEE))
235+            then getIntegerValue(this, (pool + kAxlyInFeeWithLoan))
236+            else if ((feeType == NO_LOAN_FEE))
237+                then getIntegerValue(this, (pool + kAxlyInFeeWithoutLoan))
238+                else if ((feeType == NO_FEE))
239+                    then 0
240+                    else throw("Wrong fee type")
241+
242+
243+func getSFFarmingAddr () = Address(fromBase58String(valueOrErrorMessage(getString(this, kSFFarmingAddr), "Can't get swopfi farming addr")))
244+
245+
246+func getWXFarmingAddr (poolAddr) = {
247+    let fContract = Address(fromBase58String(valueOrErrorMessage(getString(poolAddr, "%s__factoryContract"), "Can't get WX factory contract addr")))
248+    let factroyCfg = split(valueOrErrorMessage(getString(fContract, "%s__factoryConfig"), "Can't get WX factory cfg"), "__")
249+    Address(fromBase58String(factroyCfg[1]))
250+    }
251+
252+
253+func assetIdToStr (assetId) = match assetId {
254+    case id: ByteVector => 
255+        toBase58String(id)
256+    case waves: Unit => 
257+        "WAVES"
258+    case _ => 
259+        throw("Not Asset id")
260+}
261+
262+
263+func assetIdFromStr (assetId) = if ((assetId == "WAVES"))
264+    then unit
265+    else fromBase58String(assetId)
266+
267+
268+func getAssetDecimals (assetId) = if ((assetId == "WAVES"))
269+    then 8
270+    else     match assetInfo(fromBase58String(assetId)) {
271+        case asset: Asset => 
272+            asset.decimals
273+        case _ => 
274+            throw("Can't find asset")
275+    }
276+
277+
278+func getAssetPrecition (assetId) = pow(10, 0, getAssetDecimals(assetId), 0, 0, DOWN)
279+
280+
281+func getAssetsPrice (assetIds) = {
282+    func getPrices (a,assetId) =     {
283+        let assetPrice = (        let @ = invoke(priceOracleAddr, "getTWAP60", [assetId, false], nil)
284+        if ($isInstanceOf(@, "(Int, Int)"))
285+            then @
286+            else throw(($getType(@) + " couldn't be cast to (Int, Int)")))._2
287+        (a :+ assetPrice)
288+        }
289+
290+    let $l = assetIds
291+    let $s = size($l)
292+    let $acc0 = nil
293+    func $f0_1 ($a,$i) =     if (($i >= $s))
294+        then $a
295+        else getPrices($a, $l[$i])
296+
297+    func $f0_2 ($a,$i) =     if (($i >= $s))
298+        then $a
299+        else throw("List size exceeds 50")
300+
301+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 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)
302+    }
303+
304+
305+func getSharePrice (shareId) = {
306+    let pool = valueOrErrorMessage(getString(this, (shareId + kSharePool)), "Can't find pool addr by share id")
307+    let poolAddr = Address(fromBase58String(pool))
308+    let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Pool is not inited")
309+    let $t090179082 = getPoolData(poolAddr, pType)
310+    let aId = $t090179082._1
311+    let bId = $t090179082._2
312+    let aBalance = $t090179082._3
313+    let bBalance = $t090179082._4
314+    let dPriceA = (    let @ = invoke(priceOracleAddr, "getTWAP60", [aId, false], nil)
315+    if ($isInstanceOf(@, "(Int, Int)"))
316+        then @
317+        else throw(($getType(@) + " couldn't be cast to (Int, Int)")))._2
318+    let dPriceB = (    let @ = invoke(priceOracleAddr, "getTWAP60", [bId, false], nil)
319+    if ($isInstanceOf(@, "(Int, Int)"))
320+        then @
321+        else throw(($getType(@) + " couldn't be cast to (Int, Int)")))._2
322+    let shareSupply = getShareSupply(poolAddr, pType, shareId)
323+    let APrecision = pow(10, 0, getAssetDecimals(aId), 0, 0, DOWN)
324+    let BPrecision = pow(10, 0, getAssetDecimals(bId), 0, 0, DOWN)
325+    let sharePrecision = pow(10, 0, getAssetDecimals(shareId), 0, 0, DOWN)
326+    let sum = (fraction(aBalance, dPriceA, APrecision) + fraction(bBalance, dPriceB, BPrecision))
327+    fraction(sum, sharePrecision, shareSupply)
328+    }
329+
330+
331+func getSharePrices (shareIds) = {
332+    func getPrices (a,shareId) =     (a :+ getSharePrice(shareId))
333+
334+    let $l = shareIds
335+    let $s = size($l)
336+    let $acc0 = nil
337+    func $f0_1 ($a,$i) =     if (($i >= $s))
338+        then $a
339+        else getPrices($a, $l[$i])
340+
341+    func $f0_2 ($a,$i) =     if (($i >= $s))
342+        then $a
343+        else throw("List size exceeds 20")
344+
345+    $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
346+    }
347+
348+
349+func getCursEntries (aId,bId,shareId) = {
350+    let assetsPrices = getAssetsPrice([aId, bId])
351+    let sharePrice = getSharePrice(shareId)
352+    let prices = [toString(assetsPrices[0]), toString(assetsPrices[1]), toString(sharePrice)]
353+[StringEntry(kTokenLastPrice, makeString(prices, ","))]
354+    }
355+
356+
357+func calcReplenishByTwoTokens (pType,poolAddr,pmtA,aId,pmtB,bId,balA,balB) = if ((pType == SF_POOL))
358+    then {
359+        let repl = {
360+            let @ = invoke(poolAddr, "callFunction", ["calcLPReplenishTwoTokensREADONLY", [toString(pmtA), toString(pmtB)]], nil)
361+            if ($isInstanceOf(@, "List[Any]"))
362+                then @
363+                else throw(($getType(@) + " couldn't be cast to List[Any]"))
364+            }
365+        if ((repl == repl))
366+            then $Tuple5({
367+                let @ = repl[3]
368+                if ($isInstanceOf(@, "Int"))
369+                    then @
370+                    else throw(($getType(@) + " couldn't be cast to Int"))
371+                }, {
372+                let @ = repl[4]
373+                if ($isInstanceOf(@, "Int"))
374+                    then @
375+                    else throw(($getType(@) + " couldn't be cast to Int"))
376+                }, {
377+                let @ = repl[1]
378+                if ($isInstanceOf(@, "Int"))
379+                    then @
380+                    else throw(($getType(@) + " couldn't be cast to Int"))
381+                }, assetIdToStr(repl[2]), {
382+                let @ = repl[0]
383+                if ($isInstanceOf(@, "Int"))
384+                    then @
385+                    else throw(($getType(@) + " couldn't be cast to Int"))
386+                })
387+            else throw("Strict value is not equal to itself.")
388+        }
389+    else {
390+        let $t01061210862 = $Tuple2(split({
391+            let @ = invoke(poolAddr, "evaluatePutByAmountAssetREADONLY", [pmtA], nil)
392+            if ($isInstanceOf(@, "String"))
393+                then @
394+                else throw(($getType(@) + " couldn't be cast to String"))
395+            }, "__"), split({
396+            let @ = invoke(poolAddr, "evaluatePutByPriceAssetREADONLY", [pmtB], nil)
397+            if ($isInstanceOf(@, "String"))
398+                then @
399+                else throw(($getType(@) + " couldn't be cast to String"))
400+            }, "__"))
401+        if (($t01061210862 == $t01061210862))
402+            then {
403+                let evalPutInB = $t01061210862._2
404+                let evalPutInA = $t01061210862._1
405+                let lpInA = parseIntValue(evalPutInA[1])
406+                let lpInB = parseIntValue(evalPutInB[1])
407+                if ((lpInB > lpInA))
408+                    then {
409+                        let pmt = parseIntValue(evalPutInA[8])
410+                        $Tuple5(pmtA, pmt, (pmtB - pmt), bId, lpInB)
411+                        }
412+                    else {
413+                        let pmt = parseIntValue(evalPutInA[8])
414+                        $Tuple5(pmt, pmtB, (pmtA - pmt), aId, lpInA)
415+                        }
416+                }
417+            else throw("Strict value is not equal to itself.")
418+        }
419+
420+
421+func replenishTwoTokensByType (poolAddr,pType,pmtA,aId,pmtB,bId) = {
422+    let payments = [AttachedPayment(assetIdFromStr(aId), pmtA), AttachedPayment(assetIdFromStr(bId), pmtB)]
423+    if ((pType == SF_POOL))
424+        then invoke(poolAddr, "callFunction", ["replenishWithTwoTokens", ["false", "0"]], payments)
425+        else invoke(poolAddr, "put", [1000000, false], payments)
426+    }
427+
428+
429+func replenishOneTokenByType (poolAddr,pType,pmt,pmtId) = {
430+    let payments = [AttachedPayment(assetIdFromStr(pmtId), pmt)]
431+    if ((pType == SF_POOL))
432+        then invoke(poolAddr, "callFunction", ["replenishWithOneToken", ["0", "false", "0"]], payments)
433+        else invoke(poolAddr, "putOneTkn", [0, false], payments)
434+    }
435+
436+
437+func stakeLP (pool,pType,shareId,amount) = {
438+    let payments = [AttachedPayment(fromBase58String(shareId), amount)]
439+    if ((pType == SF_POOL))
440+        then invoke(getSFFarmingAddr(), "lockShareTokens", [pool, 0], payments)
441+        else invoke(getWXFarmingAddr(addressFromStringValue(pool)), "stake", nil, payments)
442+    }
443+
444+
445+func unstakeLP (pool,pType,shareId,amount) = {
446+    let $t01234712704 = if ((pType == SF_POOL))
447+        then $Tuple3(getSFFarmingAddr(), "withdrawShareTokens", [pool, amount])
448+        else if ((pType == WX_POOL))
449+            then $Tuple3(getWXFarmingAddr(Address(fromBase58String(pool))), "unstake", [shareId, amount])
450+            else throw("Wrong pool type")
451+    let farmAddr = $t01234712704._1
452+    let fName = $t01234712704._2
453+    let params = $t01234712704._3
454+    let inv = invoke(farmAddr, fName, params, nil)
455+    if ((inv == inv))
456+        then amount
457+        else throw("Strict value is not equal to itself.")
458+    }
459+
460+
461+func calcAmountToPaySF (pool,assetIdA,assetIdB,balA,balB,amountTokenToGet,assetTokenToGet) = {
462+    let poolAddr = Address(fromBase58String(pool))
463+    let feeScale6 = 1000000
464+    let fee = getIntegerValue(poolAddr, kSFPoolFee)
465+    let amntGetNoFee = fraction(amountTokenToGet, feeScale6, (feeScale6 - fee))
466+    let $t01311713405 = if ((assetTokenToGet == assetIdA))
467+        then {
468+            let amountToPay = fraction(amntGetNoFee, balB, (balA - amntGetNoFee))
469+            $Tuple2(amountToPay, assetIdB)
470+            }
471+        else {
472+            let amountToPay = fraction(amntGetNoFee, balA, (balB - amntGetNoFee))
473+            $Tuple2(amountToPay, assetIdA)
474+            }
475+    let amountToPay = $t01311713405._1
476+    let assetToPay = $t01311713405._2
477+    $Tuple2(assetToPay, amountToPay)
478+    }
479+
480+
481+func calcAmountToPayWX (pool,assetIdA,assetIdB,balA,balB,amountTokenToGet,assetTokenToGet) = {
482+    let prFee = getIntegerValue(wxSwapContract, "%s__protocolFee")
483+    let pFee = getIntegerValue(wxSwapContract, "%s__poolFee")
484+    let feeScale = toBigInt(100000000)
485+    let $t01374414052 = if ((assetTokenToGet == assetIdA))
486+        then {
487+            let amountToPay = fraction(amountTokenToGet, balB, (balA - amountTokenToGet))
488+            $Tuple2(amountToPay, assetIdB)
489+            }
490+        else {
491+            let amountToPay = fraction(amountTokenToGet, balA, (balB - amountTokenToGet))
492+            $Tuple2(amountToPay, assetIdA)
493+            }
494+    let amountToPay = $t01374414052._1
495+    let assetToPay = $t01374414052._2
496+    let amountToPayWithFee = toInt(fraction(toBigInt(amountToPay), feeScale, (feeScale - toBigInt((prFee + pFee))), CEILING))
497+    $Tuple2(assetToPay, fraction(amountToPayWithFee, 102, 100))
498+    }
499+
500+
501+func exchangeDirectly (type,pool,assetIdA,assetIdB,balA,balB,amountTokenToGet,assetTokenToGet) = if ((type == SF_POOL))
502+    then {
503+        let $t01441514537 = calcAmountToPaySF(pool, assetIdA, assetIdB, balA, balB, amountTokenToGet, assetTokenToGet)
504+        let assetToPay = $t01441514537._1
505+        let amountToPay = $t01441514537._2
506+        invoke(addressFromStringValue(pool), "callFunction", ["exchange", [toString(amountTokenToGet)]], [AttachedPayment(assetIdFromStr(assetToPay), amountToPay)])
507+        }
508+    else {
509+        let $t01471214834 = calcAmountToPayWX(pool, assetIdA, assetIdB, balA, balB, amountTokenToGet, assetTokenToGet)
510+        let assetToPay = $t01471214834._1
511+        let amountToPay = $t01471214834._2
512+        invoke(wxSwapContract, "swap", [amountTokenToGet, assetTokenToGet, toString(this)], [AttachedPayment(assetIdFromStr(assetToPay), amountToPay)])
513+        }
514+
515+
516+func calcReplenishLPVirt (pType,pool,pmtA,aId,pmtB,bId,balA,balB) = {
517+    let poolAddr = addressFromStringValue(pool)
518+    if ((pType == SF_POOL))
519+        then {
520+            let inv = {
521+                let @ = invoke(poolAddr, "callFunction", ["calcLPReplenishDiffPropREADONLY", [toString(pmtA), toString(pmtB), "0"]], nil)
522+                if ($isInstanceOf(@, "List[Any]"))
523+                    then @
524+                    else throw(($getType(@) + " couldn't be cast to List[Any]"))
525+                }
526+            if ((inv == inv))
527+                then $Tuple2({
528+                    let @ = inv[0]
529+                    if ($isInstanceOf(@, "Int"))
530+                        then @
531+                        else throw(($getType(@) + " couldn't be cast to Int"))
532+                    }, {
533+                    let @ = inv[1]
534+                    if ($isInstanceOf(@, "Int"))
535+                        then @
536+                        else throw(($getType(@) + " couldn't be cast to Int"))
537+                    })
538+                else throw("Strict value is not equal to itself.")
539+            }
540+        else if ((pType == WX_POOL))
541+            then {
542+                let $t01543715778 = if (if ((pmtA > 0))
543+                    then (pmtB > 0)
544+                    else false)
545+                    then {
546+                        let $t01551815644 = calcReplenishByTwoTokens(pType, poolAddr, pmtA, aId, pmtB, bId, balA, balB)
547+                        let pmtInA = $t01551815644._1
548+                        let pmtInB = $t01551815644._2
549+                        let change = $t01551815644._3
550+                        let changeId = $t01551815644._4
551+                        let lpAmount = $t01551815644._5
552+                        $Tuple3(change, changeId, lpAmount)
553+                        }
554+                    else if ((pmtA > 0))
555+                        then $Tuple3(pmtA, aId, 0)
556+                        else $Tuple3(pmtB, bId, 0)
557+                let change = $t01543715778._1
558+                let changeId = $t01543715778._2
559+                let lpTwo = $t01543715778._3
560+                let $t01578516001 = if ((change > 0))
561+                    then {
562+                        let inv = {
563+                            let @ = invoke(poolAddr, "putOneTknREADONLY", [changeId, change], nil)
564+                            if ($isInstanceOf(@, "(Int, Int, Int)"))
565+                                then @
566+                                else throw(($getType(@) + " couldn't be cast to (Int, Int, Int)"))
567+                            }
568+                        if ((inv == inv))
569+                            then $Tuple2(inv._1, inv._3)
570+                            else throw("Strict value is not equal to itself.")
571+                        }
572+                    else $Tuple2(0, 0)
573+                let lpOne = $t01578516001._1
574+                let loss = $t01578516001._2
575+                $Tuple2((lpTwo + lpOne), loss)
576+                }
577+            else throw("Wrong pool type")
578+    }
579+
580+
581+func calcWithdrawLPVirt (pType,pool,lpAmount,shareId,aId,bId,balA,balB,borrowAmount,borrowAssetId) = {
582+    let poolAddr = addressFromStringValue(pool)
583+    let $t01629516795 = if ((pType == SF_POOL))
584+        then {
585+            let inv = {
586+                let @ = invoke(poolAddr, "callFunction", ["withdrawREADONLY", [toString(lpAmount), toString(balA), toString(balB)]], nil)
587+                if ($isInstanceOf(@, "List[Any]"))
588+                    then @
589+                    else throw(($getType(@) + " couldn't be cast to List[Any]"))
590+                }
591+            if ((inv == inv))
592+                then $Tuple2({
593+                    let @ = inv[0]
594+                    if ($isInstanceOf(@, "Int"))
595+                        then @
596+                        else throw(($getType(@) + " couldn't be cast to Int"))
597+                    }, {
598+                    let @ = inv[1]
599+                    if ($isInstanceOf(@, "Int"))
600+                        then @
601+                        else throw(($getType(@) + " couldn't be cast to Int"))
602+                    })
603+                else throw("Strict value is not equal to itself.")
604+            }
605+        else if ((pType == WX_POOL))
606+            then {
607+                let get = split({
608+                    let @ = invoke(poolAddr, "evaluateGetREADONLY", [shareId, lpAmount], nil)
609+                    if ($isInstanceOf(@, "String"))
610+                        then @
611+                        else throw(($getType(@) + " couldn't be cast to String"))
612+                    }, "__")
613+                if ((get == get))
614+                    then $Tuple2(parseIntValue(get[1]), parseIntValue(get[2]))
615+                    else throw("Strict value is not equal to itself.")
616+                }
617+            else throw("Wrong pool type")
618+    let getAmountA = $t01629516795._1
619+    let getAmountB = $t01629516795._2
620+    if ((borrowAmount > 0))
621+        then {
622+            let amountToGetEx = if (if ((borrowAssetId == aId))
623+                then (borrowAmount > getAmountA)
624+                else false)
625+                then (borrowAmount - getAmountA)
626+                else if (if ((borrowAssetId == bId))
627+                    then (borrowAmount > getAmountB)
628+                    else false)
629+                    then (borrowAmount - getAmountB)
630+                    else 0
631+            let $t01707317376 = if ((amountToGetEx > 0))
632+                then if ((pType == SF_POOL))
633+                    then calcAmountToPaySF(pool, aId, bId, balA, balB, amountToGetEx, borrowAssetId)
634+                    else calcAmountToPayWX(pool, aId, bId, balA, balB, amountToGetEx, borrowAssetId)
635+                else $Tuple2("", 0)
636+            let assetToPay = $t01707317376._1
637+            let amountToPay = $t01707317376._2
638+            if ((borrowAssetId == aId))
639+                then $Tuple2(((getAmountA + amountToGetEx) - borrowAmount), (getAmountB - amountToPay))
640+                else $Tuple2((getAmountA - amountToPay), ((getAmountB + amountToGetEx) - borrowAmount))
641+            }
642+        else $Tuple2(getAmountA, getAmountB)
643+    }
644+
645+
646+func claimFarmed (type,pool) = if ((type == SF_POOL))
647+    then {
648+        let balBefore = accountBalance(SWOPID)
649+        if ((balBefore == balBefore))
650+            then {
651+                let inv = invoke(getSFFarmingAddr(), "claim", [pool], nil)
652+                if ((inv == inv))
653+                    then {
654+                        let balAfter = accountBalance(SWOPID)
655+                        $Tuple2((balAfter - balBefore), SWOPID)
656+                        }
657+                    else throw("Strict value is not equal to itself.")
658+                }
659+            else throw("Strict value is not equal to itself.")
660+        }
661+    else if ((type == WX_POOL))
662+        then {
663+            let balBefore = accountBalance(WXID)
664+            if ((balBefore == balBefore))
665+                then {
666+                    let inv = invoke(getWXFarmingAddr(Address(fromBase58String(pool))), "claimWX", [pool], nil)
667+                    if ((inv == inv))
668+                        then {
669+                            let balAfter = accountBalance(WXID)
670+                            $Tuple2((balAfter - balBefore), WXID)
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 throw("Wrong pool type")
677+
678+
679+func replenishByType (pType,pool,feeType,pmtA,aId,pmtB,bId,balA,balB,LPId) = {
680+    let lpBalanceBefore = accountBalance(fromBase58String(LPId))
681+    if ((lpBalanceBefore == lpBalanceBefore))
682+        then {
683+            let poolAddr = addressFromStringValue(pool)
684+            let $t01857318989 = if (if ((pmtA > 0))
685+                then (pmtB > 0)
686+                else false)
687+                then {
688+                    let $t01863918755 = calcReplenishByTwoTokens(pType, poolAddr, pmtA, aId, pmtB, bId, balA, balB)
689+                    let pmtInA = $t01863918755._1
690+                    let pmtInB = $t01863918755._2
691+                    let change = $t01863918755._3
692+                    let changeId = $t01863918755._4
693+                    let inv = replenishTwoTokensByType(poolAddr, pType, pmtInA, aId, pmtInB, bId)
694+                    if ((inv == inv))
695+                        then $Tuple2(change, changeId)
696+                        else throw("Strict value is not equal to itself.")
697+                    }
698+                else if ((pmtA > 0))
699+                    then $Tuple2(pmtA, aId)
700+                    else if ((pmtB > 0))
701+                        then $Tuple2(pmtB, bId)
702+                        else throw("pmts must be > 0")
703+            let change = $t01857318989._1
704+            let changeId = $t01857318989._2
705+            let inv = if ((change > 0))
706+                then replenishOneTokenByType(poolAddr, pType, change, changeId)
707+                else nil
708+            if ((inv == inv))
709+                then {
710+                    let lpBalanceAfter = accountBalance(fromBase58String(LPId))
711+                    let totalStaked = (lpBalanceAfter - lpBalanceBefore)
712+                    let axlyFeeAmount = fraction(totalStaked, getAxlyFee(pool, feeType), FEE_SCALE6)
713+                    let userShareForStake = (totalStaked - axlyFeeAmount)
714+                    if ((0 >= userShareForStake))
715+                        then throw("amount of staked sharetokens must be > 0")
716+                        else {
717+                            let invLP = stakeLP(pool, pType, LPId, userShareForStake)
718+                            if ((invLP == invLP))
719+                                then $Tuple2(userShareForStake, axlyFeeAmount)
720+                                else throw("Strict value is not equal to itself.")
721+                            }
722+                    }
723+                else throw("Strict value is not equal to itself.")
724+            }
725+        else throw("Strict value is not equal to itself.")
726+    }
727+
728+
729+func replenishEntries (pool,user,stakedAmount,axlyFeeAmount,posNum,shareId,type,withLoan) = {
730+    let totalAmount = getPoolTotalShare(pool)
731+    let totalAmountLoan = getPoolTotalShareWithLoan(pool)
732+    let $t01984720085 = if (withLoan)
733+        then $Tuple2(getIntegerValue(this, (pool + kPoolInterestLoan)), (totalAmountLoan + stakedAmount))
734+        else $Tuple2(getIntegerValue(this, (pool + kPoolInterestNoLoan)), totalAmountLoan)
735+    let curPoolInterest = $t01984720085._1
736+    let totalStakedWithLoan = $t01984720085._2
737+[IntegerEntry((pool + kPoolTotal), (totalAmount + stakedAmount)), IntegerEntry((pool + kPoolTotalLoan), totalStakedWithLoan), IntegerEntry((((((pool + "_") + user) + "_") + toString(posNum)) + kUserPosition), stakedAmount), IntegerEntry((((((pool + "_") + user) + "_") + toString(posNum)) + kUserPositionInterest), curPoolInterest), StringEntry((((user + "_") + toString(posNum)) + kUserPositionPool), pool), IntegerEntry((user + kUserPositionNum), posNum), ScriptTransfer(moneyBox, axlyFeeAmount, fromBase58String(shareId))]
738+    }
739+
740+
741+func exchangeKeeper (toToken,pmtAmount,pmtAsset,amountsIn,addresses,assetsToReceive,estReceived,slippageTolerance,minReceived,options) = {
742+    let tokenBalanceBefore = accountBalance(assetIdFromStr(toToken))
743+    if ((tokenBalanceBefore == tokenBalanceBefore))
744+        then {
745+            let inv = invoke(exContract, "swap", [amountsIn, addresses, assetsToReceive, estReceived, slippageTolerance, minReceived, options], [AttachedPayment(pmtAsset, pmtAmount)])
746+            if ((inv == inv))
747+                then (accountBalance(assetIdFromStr(toToken)) - tokenBalanceBefore)
748+                else throw("Strict value is not equal to itself.")
749+            }
750+        else throw("Strict value is not equal to itself.")
751+    }
752+
753+
754+func exchangePuzzle (toToken,pmtAmount,pmtAsset,routesStr,minToReceive,options) = {
755+    let tokenBalanceBefore = accountBalance(assetIdFromStr(toToken))
756+    if ((tokenBalanceBefore == tokenBalanceBefore))
757+        then {
758+            let inv = invoke(exContract, "puzzleSwap", [routesStr, minToReceive, options], [AttachedPayment(pmtAsset, pmtAmount)])
759+            if ((inv == inv))
760+                then (accountBalance(assetIdFromStr(toToken)) - tokenBalanceBefore)
761+                else throw("Strict value is not equal to itself.")
762+            }
763+        else throw("Strict value is not equal to itself.")
764+    }
765+
766+
767+func exchangeSwopFi (toToken,pmtAmount,pmtAsset,exchangers,exchangersType,args1,args2,routingAssetsKeys,minAmountToReceive,options) = {
768+    let tokenBalanceBefore = accountBalance(assetIdFromStr(toToken))
769+    if ((tokenBalanceBefore == tokenBalanceBefore))
770+        then {
771+            let inv = invoke(exContract, "swopfiSwap", [exchangers, exchangersType, args1, args2, routingAssetsKeys, minAmountToReceive, options], [AttachedPayment(pmtAsset, pmtAmount)])
772+            if ((inv == inv))
773+                then (accountBalance(assetIdFromStr(toToken)) - tokenBalanceBefore)
774+                else throw("Strict value is not equal to itself.")
775+            }
776+        else throw("Strict value is not equal to itself.")
777+    }
778+
779+
780+func capitalize (pool,pType,tokenId,tokenAmount) = {
781+    let poolAddr = Address(fromBase58String(pool))
782+    let $t02243622502 = getPoolData(poolAddr, pType)
783+    let AId = $t02243622502._1
784+    let BId = $t02243622502._2
785+    let balA = $t02243622502._3
786+    let balB = $t02243622502._4
787+    let shareId = $t02243622502._5
788+    if (if ((tokenId != AId))
789+        then (tokenId != BId)
790+        else false)
791+        then throw("Wrong asset")
792+        else {
793+            let $t02258722667 = if ((tokenId == AId))
794+                then $Tuple2(tokenAmount, 0)
795+                else $Tuple2(0, tokenAmount)
796+            let pmtA = $t02258722667._1
797+            let pmtB = $t02258722667._2
798+            let $t02267022774 = replenishByType(pType, pool, NO_FEE, pmtA, AId, pmtB, BId, balA, balB, shareId)
799+            let stakedAmount = $t02267022774._1
800+            let nf = $t02267022774._2
801+            let curPoolInterestLoan = valueOrElse(getInteger(this, (pool + kPoolInterestLoan)), 0)
802+            let curPoolInterestNoLoan = valueOrElse(getInteger(this, (pool + kPoolInterestNoLoan)), 0)
803+            let totalShareAmount = getPoolTotalShare(pool)
804+            let totalShareAmountWithLoan = getPoolTotalShareWithLoan(pool)
805+            let loanPercent = fraction(totalShareAmountWithLoan, SCALE8, totalShareAmount)
806+            let stakedLoan = fraction(stakedAmount, loanPercent, SCALE8)
807+            let stakedNoLoan = (stakedAmount - stakedLoan)
808+            let newInterestLoan = if ((totalShareAmountWithLoan > 0))
809+                then (curPoolInterestLoan + fraction(stakedLoan, SCALE10, totalShareAmountWithLoan))
810+                else 0
811+            let newInterestNoLoan = if (((totalShareAmount - totalShareAmountWithLoan) > 0))
812+                then (curPoolInterestNoLoan + fraction(stakedNoLoan, SCALE10, (totalShareAmount - totalShareAmountWithLoan)))
813+                else 0
814+            let axlyFeeLoan = fraction(stakedLoan, getAxlyFee(pool, CAP_FEE_LOAN), FEE_SCALE6)
815+            let axlyFeeNoLoan = fraction(stakedNoLoan, getAxlyFee(pool, CAP_FEE_NO_LOAN), FEE_SCALE6)
816+            let axlyFee = unstakeLP(pool, pType, shareId, (axlyFeeLoan + axlyFeeNoLoan))
817+            if ((axlyFee == axlyFee))
818+                then ([IntegerEntry((pool + kPoolInterestLoan), newInterestLoan), IntegerEntry((pool + kPoolInterestNoLoan), newInterestNoLoan), IntegerEntry((pool + kPoolTotal), ((totalShareAmount + stakedAmount) - axlyFee)), IntegerEntry((pool + kPoolTotalLoan), ((totalShareAmountWithLoan + stakedLoan) - axlyFeeLoan)), ScriptTransfer(moneyBox, (axlyFeeLoan + axlyFeeNoLoan), fromBase58String(shareId))] ++ getCursEntries(AId, BId, shareId))
819+                else throw("Strict value is not equal to itself.")
820+            }
821+    }
822+
823+
824+func withdrawAmountCalc (pool,userCanWithdraw,debt,borrowAsset) = {
825+    let poolAddr = Address(fromBase58String(pool))
826+    let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Unknown pool")
827+    let $t02454224618 = getPoolData(poolAddr, pType)
828+    let assetIdA = $t02454224618._1
829+    let assetIdB = $t02454224618._2
830+    let balA = $t02454224618._3
831+    let balB = $t02454224618._4
832+    let shareId = $t02454224618._5
833+    let cBalABefore = accountBalance(assetIdFromStr(assetIdA))
834+    if ((cBalABefore == cBalABefore))
835+        then {
836+            let cBalBBefore = accountBalance(assetIdFromStr(assetIdB))
837+            if ((cBalBBefore == cBalBBefore))
838+                then {
839+                    let inv = if ((pType == SF_POOL))
840+                        then invoke(poolAddr, "callFunction", ["withdraw", [toString(userCanWithdraw)]], nil)
841+                        else {
842+                            let inv = unstakeLP(pool, pType, shareId, userCanWithdraw)
843+                            if ((inv == inv))
844+                                then invoke(poolAddr, "get", nil, [AttachedPayment(assetIdFromStr(shareId), userCanWithdraw)])
845+                                else throw("Strict value is not equal to itself.")
846+                            }
847+                    if ((inv == inv))
848+                        then {
849+                            let cBalAAfter = accountBalance(assetIdFromStr(assetIdA))
850+                            let cBalBAfter = accountBalance(assetIdFromStr(assetIdB))
851+                            let $t02518125270 = $Tuple2((cBalAAfter - cBalABefore), (cBalBAfter - cBalBBefore))
852+                            let tokensAmountA = $t02518125270._1
853+                            let tokensAmountB = $t02518125270._2
854+                            let $t02527326093 = if ((debt > 0))
855+                                then {
856+                                    let amountToGetEx = if (if ((borrowAsset == assetIdA))
857+                                        then (debt > tokensAmountA)
858+                                        else false)
859+                                        then (debt - tokensAmountA)
860+                                        else if (if ((borrowAsset == assetIdB))
861+                                            then (debt > tokensAmountB)
862+                                            else false)
863+                                            then (debt - tokensAmountB)
864+                                            else 0
865+                                    let exInv = if ((amountToGetEx > 0))
866+                                        then exchangeDirectly(pType, pool, assetIdA, assetIdB, balA, balB, amountToGetEx, borrowAsset)
867+                                        else 0
868+                                    if ((exInv == exInv))
869+                                        then {
870+                                            let cBalAAfterRepay = accountBalance(assetIdFromStr(assetIdA))
871+                                            let cBalBAfterRepay = accountBalance(assetIdFromStr(assetIdB))
872+                                            if ((borrowAsset == assetIdA))
873+                                                then $Tuple2(((cBalAAfterRepay - cBalABefore) - debt), (cBalBAfterRepay - cBalBBefore))
874+                                                else $Tuple2((cBalAAfterRepay - cBalABefore), ((cBalBAfterRepay - cBalBBefore) - debt))
875+                                            }
876+                                        else throw("Strict value is not equal to itself.")
877+                                    }
878+                                else $Tuple2(tokensAmountA, tokensAmountB)
879+                            let toUserA = $t02527326093._1
880+                            let toUserB = $t02527326093._2
881+                            $Tuple7(toUserA, assetIdA, toUserB, assetIdB, cBalAAfter, cBalBAfter, shareId)
882+                            }
883+                        else throw("Strict value is not equal to itself.")
884+                    }
885+                else throw("Strict value is not equal to itself.")
886+            }
887+        else throw("Strict value is not equal to itself.")
888+    }
889+
890+
891+func userCanWithdrawShareCalc (user,pool,posId,borrowed) = {
892+    let pAmount = valueOrErrorMessage(getInteger(this, (((((pool + "_") + user) + "_") + posId) + kUserPosition)), "Unknown position")
893+    let userInterest = getIntegerValue(this, (((((pool + "_") + user) + "_") + posId) + kUserPositionInterest))
894+    let poolInterest = if (borrowed)
895+        then getIntegerValue(this, (pool + kPoolInterestLoan))
896+        else getIntegerValue(this, (pool + kPoolInterestNoLoan))
897+    (pAmount + fraction(pAmount, (poolInterest - userInterest), SCALE10))
898+    }
899+
900+
901+func withdrawToUser (user,pool,posId,stopLoss) = {
902+    let pAmount = valueOrErrorMessage(getInteger(this, (((((pool + "_") + user) + "_") + posId) + kUserPosition)), "Unknown position")
903+    let borrowAmount = valueOrElse(getInteger(this, (((((pool + "_") + user) + "_") + posId) + kUserBorrowAmount)), 0)
904+    let userCanWithdraw = userCanWithdrawShareCalc(user, pool, posId, (borrowAmount > 0))
905+    let poolTotalShare = getPoolTotalShare(pool)
906+    let userAddr = Address(fromBase58String(user))
907+    let borrowAsset = valueOrElse(getString(this, (((((pool + "_") + user) + "_") + posId) + kUserBorrowAssetId)), "")
908+    let debt = if ((borrowAmount > 0))
909+        then {
910+            let @ = invoke(getLendSrvAddr(), "getAssetDebt", [false, ((user + "_") + posId), borrowAsset], nil)
911+            if ($isInstanceOf(@, "Int"))
912+                then @
913+                else throw(($getType(@) + " couldn't be cast to Int"))
914+            }
915+        else 0
916+    let $t02748127634 = withdrawAmountCalc(pool, userCanWithdraw, debt, borrowAsset)
917+    if (($t02748127634 == $t02748127634))
918+        then {
919+            let shareId = $t02748127634._7
920+            let cBalBAfter = $t02748127634._6
921+            let cBalAAfter = $t02748127634._5
922+            let assetIdB = $t02748127634._4
923+            let toUserAmountB = $t02748127634._3
924+            let assetIdA = $t02748127634._2
925+            let toUserAmountA = $t02748127634._1
926+            let closeDbtInv = if ((debt > 0))
927+                then invoke(getLendSrvAddr(), "repayFor", [((user + "_") + posId)], [AttachedPayment(assetIdFromStr(borrowAsset), debt)])
928+                else 0
929+            if ((closeDbtInv == closeDbtInv))
930+                then ([DeleteEntry((((((pool + "_") + user) + "_") + posId) + kUserPosition)), DeleteEntry((((((pool + "_") + user) + "_") + posId) + kUserPositionInterest)), IntegerEntry((pool + kPoolTotal), (poolTotalShare - userCanWithdraw)), ScriptTransfer(userAddr, toUserAmountA, assetIdFromStr(assetIdA)), ScriptTransfer(userAddr, toUserAmountB, assetIdFromStr(assetIdB))] ++ getCursEntries(assetIdA, assetIdB, shareId))
931+                else throw("Strict value is not equal to itself.")
932+            }
933+        else throw("Strict value is not equal to itself.")
934+    }
935+
936+
937+func parseRequest (requestId) = {
938+    let request = split(valueOrErrorMessage(getString(this, (requestId + kRequestId)), ("No request with id " + requestId)), ",")
939+    let user = request[0]
940+    let pool = request[1]
941+    let pmtA = parseIntValue(request[2])
942+    let AId = request[3]
943+    let pmtB = parseIntValue(request[4])
944+    let BId = request[5]
945+    let balA = parseIntValue(request[6])
946+    let balB = parseIntValue(request[7])
947+    let shareId = request[8]
948+    let bwAsset = request[9]
949+    let bwAmount = parseIntValue(request[10])
950+    $Tuple11(user, pool, pmtA, AId, pmtB, BId, balA, balB, shareId, bwAsset, bwAmount)
951+    }
952+
953+
954+func calcBorrowAmount (pmtA,pmtB,aId,bId,leverage,borrowId) = {
955+    let dPriceA = (    let @ = invoke(priceOracleAddr, "getTWAP60", [aId, false], nil)
956+    if ($isInstanceOf(@, "(Int, Int)"))
957+        then @
958+        else throw(($getType(@) + " couldn't be cast to (Int, Int)")))._2
959+    let dPriceB = (    let @ = invoke(priceOracleAddr, "getTWAP60", [bId, false], nil)
960+    if ($isInstanceOf(@, "(Int, Int)"))
961+        then @
962+        else throw(($getType(@) + " couldn't be cast to (Int, Int)")))._2
963+    let decPrA = pow(10, 0, getAssetDecimals(aId), 0, 0, DOWN)
964+    let decPrB = pow(10, 0, getAssetDecimals(bId), 0, 0, DOWN)
965+    let paydInDollar = (fraction(dPriceA, pmtA, decPrA) + fraction(dPriceB, pmtB, decPrB))
966+    let $t02932029417 = if ((borrowId == aId))
967+        then $Tuple2(dPriceA, decPrA)
968+        else $Tuple2(dPriceB, decPrB)
969+    let borrowPrice = $t02932029417._1
970+    let borrowDecPr = $t02932029417._2
971+    fraction(fraction(paydInDollar, (leverage - 100), 100), borrowDecPr, borrowPrice)
972+    }
973+
974+
975+@Callable(i)
976+func calcPriceImpactEVALONLY (pool,leverage,borrowId,pmtA,pmtB) = if (if ((100 > leverage))
977+    then true
978+    else (leverage > 300))
979+    then throw("Leverage can't be <100 and >300")
980+    else {
981+        let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Pool is not inited")
982+        let $t02983529925 = getPoolData(Address(fromBase58String(pool)), pType)
983+        let AId = $t02983529925._1
984+        let BId = $t02983529925._2
985+        let balA = $t02983529925._3
986+        let balB = $t02983529925._4
987+        let shareId = $t02983529925._5
988+        let borrowAmount = if ((leverage > 100))
989+            then calcBorrowAmount(pmtA, pmtB, AId, BId, leverage, borrowId)
990+            else 0
991+        let $t03006030167 = if ((borrowId == AId))
992+            then $Tuple2((pmtA + borrowAmount), pmtB)
993+            else $Tuple2(pmtA, (pmtB + borrowAmount))
994+        let payInA = $t03006030167._1
995+        let payInB = $t03006030167._2
996+        let $t03017030263 = calcReplenishLPVirt(pType, pool, payInA, AId, payInB, BId, balA, balB)
997+        let lpAmount = $t03017030263._1
998+        let loss = $t03017030263._2
999+        let impactMod = if ((0 > loss))
1000+            then (loss * -1)
1001+            else loss
1002+        $Tuple2(nil, [impactMod])
1003+        }
1004+
1005+
1006+
1007+@Callable(i)
1008+func getShareAssetPriceREADONLY (shareId) = {
1009+    let sharePrices = getSharePrice(shareId)
1010+    $Tuple2(nil, sharePrices)
1011+    }
1012+
1013+
1014+
1015+@Callable(i)
1016+func getUserPositionShareAmountREADONLY (user,posNum) = {
1017+    let pool = valueOrErrorMessage(getString(this, (((user + "_") + posNum) + kUserPositionPool)), "Unknown position")
1018+    let borrowAmount = getIntegerValue(this, (((((pool + "_") + user) + "_") + posNum) + kUserBorrowAmount))
1019+    let userCanWithdraw = userCanWithdrawShareCalc(user, pool, posNum, (borrowAmount > 0))
1020+    $Tuple2(nil, userCanWithdraw)
1021+    }
1022+
1023+
1024+
1025+@Callable(i)
1026+func getUserPositionInDollarsREADONLY (user,pools,posNum) = {
1027+    func userPos (a,pool) =     {
1028+        let $t03107631110 = a
1029+        let totalPos = $t03107631110._1
1030+        let posDebt = $t03107631110._2
1031+        let index = $t03107631110._3
1032+        let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Pool is not inited")
1033+        let $t03120231292 = getPoolData(Address(fromBase58String(pool)), pType)
1034+        let AId = $t03120231292._1
1035+        let BId = $t03120231292._2
1036+        let balA = $t03120231292._3
1037+        let balB = $t03120231292._4
1038+        let shareId = $t03120231292._5
1039+        let borrowAmount = valueOrElse(getInteger(this, (((((pool + "_") + user) + "_") + posNum[index]) + kUserBorrowAmount)), 0)
1040+        let userCanWithdraw = userCanWithdrawShareCalc(user, pool, posNum[index], (borrowAmount > 0))
1041+        let sharePrices = getSharePrice(shareId)
1042+        let decPrShare = pow(10, 0, getAssetDecimals(shareId), 0, 0, DOWN)
1043+        let shareD = fraction(userCanWithdraw, sharePrices, decPrShare)
1044+        if ((borrowAmount == 0))
1045+            then $Tuple3((totalPos :+ shareD), (posDebt :+ 0), (index + 1))
1046+            else {
1047+                let borrowAsset = getStringValue(this, (((((pool + "_") + user) + "_") + posNum[index]) + kUserBorrowAssetId))
1048+                let debt = {
1049+                    let @ = invoke(getLendSrvAddr(), "getAssetDebt", [false, ((user + "_") + posNum[index]), borrowAsset], nil)
1050+                    if ($isInstanceOf(@, "Int"))
1051+                        then @
1052+                        else throw(($getType(@) + " couldn't be cast to Int"))
1053+                    }
1054+                let borrowAssetPrice = (                let @ = invoke(priceOracleAddr, "getTWAP60", [borrowAsset, false], nil)
1055+                if ($isInstanceOf(@, "(Int, Int)"))
1056+                    then @
1057+                    else throw(($getType(@) + " couldn't be cast to (Int, Int)")))._1
1058+                let decPrBorrowId = pow(10, 0, getAssetDecimals(borrowAsset), 0, 0, DOWN)
1059+                let debtD = fraction(debt, borrowAssetPrice, decPrBorrowId)
1060+                $Tuple3((totalPos :+ shareD), (posDebt :+ debtD), (index + 1))
1061+                }
1062+        }
1063+
1064+    let $t03233532390 = {
1065+        let $l = pools
1066+        let $s = size($l)
1067+        let $acc0 = $Tuple3(nil, nil, 0)
1068+        func $f0_1 ($a,$i) =         if (($i >= $s))
1069+            then $a
1070+            else userPos($a, $l[$i])
1071+
1072+        func $f0_2 ($a,$i) =         if (($i >= $s))
1073+            then $a
1074+            else throw("List size exceeds 20")
1075+
1076+        $f0_2($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($f0_1($acc0, 0), 1), 2), 3), 4), 5), 6), 7), 8), 9), 10), 11), 12), 13), 14), 15), 16), 17), 18), 19), 20)
1077+        }
1078+    let pos = $t03233532390._1
1079+    let debt = $t03233532390._2
1080+    $Tuple2(nil, $Tuple2(pos, debt))
1081+    }
1082+
1083+
1084+
1085+@Callable(i)
1086+func replenish (pool,leverage,borrowId) = if (if ((100 > leverage))
1087+    then true
1088+    else (leverage > 300))
1089+    then throw("Leverage can't be <100 and >300")
1090+    else if (if (!(getBooleanValue(this, (pool + kPoolCanBorrow))))
1091+        then (leverage > 100)
1092+        else false)
1093+        then throw("You can't borrow in this pool")
1094+        else {
1095+            let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Pool is not inited")
1096+            let $t03283032920 = getPoolData(Address(fromBase58String(pool)), pType)
1097+            let AId = $t03283032920._1
1098+            let BId = $t03283032920._2
1099+            let balA = $t03283032920._3
1100+            let balB = $t03283032920._4
1101+            let shareId = $t03283032920._5
1102+            let $t03292333560 = if ((size(i.payments) == 2))
1103+                then if ((assetIdToStr(i.payments[0].assetId) != AId))
1104+                    then throw("Wrong payment asset A")
1105+                    else if ((assetIdToStr(i.payments[1].assetId) != BId))
1106+                        then throw("Wrong payment asset B")
1107+                        else $Tuple4(i.payments[0].amount, AId, i.payments[1].amount, BId)
1108+                else if ((size(i.payments) == 1))
1109+                    then if ((assetIdToStr(i.payments[0].assetId) == AId))
1110+                        then $Tuple4(i.payments[0].amount, AId, 0, BId)
1111+                        else if ((assetIdToStr(i.payments[0].assetId) == BId))
1112+                            then $Tuple4(0, AId, i.payments[0].amount, BId)
1113+                            else throw("Wrong payment")
1114+                    else throw("One or two payments expected")
1115+            let pmtA = $t03292333560._1
1116+            let pmtAssetA = $t03292333560._2
1117+            let pmtB = $t03292333560._3
1118+            let pmtAssetB = $t03292333560._4
1119+            let newPosNum = getNewUserPositionNumber(toString(i.caller))
1120+            if ((leverage > 100))
1121+                then {
1122+                    let borrowAmount = calcBorrowAmount(pmtA, pmtB, pmtAssetA, pmtAssetB, leverage, borrowId)
1123+                    let request = makeString([toString(i.caller), pool, toString(pmtA), pmtAssetA, toString(pmtB), pmtAssetB, toString(balA), toString(balB), shareId, borrowId, toString(borrowAmount)], ",")
1124+                    let newRequestId = {
1125+                        let @ = invoke(this, "createNewRequest", [request], nil)
1126+                        if ($isInstanceOf(@, "Int"))
1127+                            then @
1128+                            else throw(($getType(@) + " couldn't be cast to Int"))
1129+                        }
1130+                    if ((newRequestId == newRequestId))
1131+                        then {
1132+                            let args = [((toString(i.caller) + "_") + toString(newPosNum)), shareId, borrowId, borrowAmount, toString(this), "replenishFromLand", toString(valueOrErrorMessage(newRequestId, "Can't create new request"))]
1133+                            let inv = reentrantInvoke(getLendSrvAddr(), "flashPosition", args, nil)
1134+                            if ((inv == inv))
1135+                                then nil
1136+                                else throw("Strict value is not equal to itself.")
1137+                            }
1138+                        else throw("Strict value is not equal to itself.")
1139+                    }
1140+                else {
1141+                    let $t03448834600 = replenishByType(pType, pool, NO_LOAN_FEE, pmtA, AId, pmtB, BId, balA, balB, shareId)
1142+                    let userStaked = $t03448834600._1
1143+                    let axlyFee = $t03448834600._2
1144+                    (replenishEntries(pool, toString(i.caller), userStaked, axlyFee, newPosNum, shareId, pType, false) ++ getCursEntries(AId, BId, shareId))
1145+                    }
1146+            }
1147+
1148+
1149+
1150+@Callable(i)
1151+func withdraw (pool,posId) = withdrawToUser(toString(i.caller), pool, toString(posId), false)
1152+
1153+
1154+
1155+@Callable(i)
1156+func createUpdateStopLoss (posId,poolId,assetId,price) = {
1157+    let tokenOraclePrice = (    let @ = invoke(priceOracleAddr, "getTWAP60", [assetId, false], nil)
1158+    if ($isInstanceOf(@, "(Int, Int)"))
1159+        then @
1160+        else throw(($getType(@) + " couldn't be cast to (Int, Int)")))._1
1161+    if (!(isDefined(getInteger(this, (((((poolId + "_") + toString(i.caller)) + "_") + toString(posId)) + kUserPosition)))))
1162+        then throw("There are no user position")
1163+        else if ((0 >= price))
1164+            then throw("Price must be greater than 0")
1165+            else if ((price > tokenOraclePrice))
1166+                then throw("Price must be less than current token price")
1167+                else [IntegerEntry((((((((toString(i.caller) + "_") + toString(posId)) + "_") + poolId) + "_") + assetId) + kUserStopLoss), price)]
1168+    }
1169+
1170+
1171+
1172+@Callable(i)
1173+func deleteStopLoss (posId,poolId,assetId) = if (!(isDefined(getInteger(this, (((((((toString(i.caller) + "_") + toString(posId)) + "_") + poolId) + "_") + assetId) + kUserStopLoss)))))
1174+    then throw("No entry")
1175+    else [DeleteEntry((((((((toString(i.caller) + "_") + toString(posId)) + "_") + poolId) + "_") + assetId) + kUserStopLoss))]
1176+
1177+
1178+
1179+@Callable(i)
1180+func init (moneyBoxAddr,sfFarmingAddr,lendAddr,priceOracleAddr,keeperExContract,wxSwapContract,swopAssetId,wxAssetId,adminPubKey) = if (isDefined(getString(kMoneyBox)))
1181+    then throw("Already inited")
1182+    else [StringEntry(kMoneyBox, moneyBoxAddr), StringEntry(kSFFarmingAddr, sfFarmingAddr), StringEntry(kLendService, lendAddr), StringEntry(kPriceOracle, priceOracleAddr), StringEntry(kExContract, keeperExContract), StringEntry(kWxSwapContract, wxSwapContract), StringEntry(kSwopId, swopAssetId), StringEntry(kWxId, wxAssetId), StringEntry(kAdminCallPK, adminPubKey)]
1183+
1184+
1185+
1186+@Callable(i)
1187+func createNewRequest (params) = valueOrElse(isSelfCall(i), {
1188+    let newRequestId = (valueOrElse(getInteger(this, kRequestIter), 0) + 1)
1189+    $Tuple2([StringEntry((toString(newRequestId) + kRequestId), params), IntegerEntry(kRequestIter, newRequestId)], newRequestId)
1190+    })
1191+
1192+
1193+
1194+@Callable(i)
1195+func replenishFromLand (requestId) = valueOrElse(isLandCall(i), {
1196+    let $t03708037184 = parseRequest(requestId)
1197+    let user = $t03708037184._1
1198+    let pool = $t03708037184._2
1199+    let pmtA = $t03708037184._3
1200+    let AId = $t03708037184._4
1201+    let pmtB = $t03708037184._5
1202+    let BId = $t03708037184._6
1203+    let balA = $t03708037184._7
1204+    let balB = $t03708037184._8
1205+    let shareId = $t03708037184._9
1206+    let bwAsset = $t03708037184._10
1207+    let bwAmount = $t03708037184._11
1208+    if ((size(i.payments) != 1))
1209+        then throw("Wrong payment size")
1210+        else if (if ((assetIdToStr(i.payments[0].assetId) != bwAsset))
1211+            then true
1212+            else (i.payments[0].amount != bwAmount))
1213+            then throw("Wrong payment")
1214+            else {
1215+                let $t03737437498 = if ((AId == bwAsset))
1216+                    then $Tuple2((pmtA + i.payments[0].amount), pmtB)
1217+                    else $Tuple2(pmtA, (pmtB + i.payments[0].amount))
1218+                let pmtAllA = $t03737437498._1
1219+                let pmtAllB = $t03737437498._2
1220+                let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Unknown pool")
1221+                let $t03758037695 = replenishByType(pType, pool, LOAN_FEE, pmtAllA, AId, pmtAllB, BId, balA, balB, shareId)
1222+                let userStaked = $t03758037695._1
1223+                let axlyFee = $t03758037695._2
1224+                let posNum = getNewUserPositionNumber(user)
1225+                let borrowEntries = [IntegerEntry((((((pool + "_") + user) + "_") + toString(posNum)) + kUserBorrowAmount), bwAmount), StringEntry((((((pool + "_") + user) + "_") + toString(posNum)) + kUserBorrowAssetId), bwAsset)]
1226+                let entries = replenishEntries(pool, user, userStaked, axlyFee, posNum, shareId, pType, true)
1227+                $Tuple2((((entries ++ getCursEntries(AId, BId, shareId)) ++ borrowEntries) :+ DeleteEntry((requestId + kRequestId))), userStaked)
1228+                }
1229+    })
1230+
1231+
1232+
1233+@Callable(i)
1234+func liquidate (user,posId,liquidateAmount) = valueOrElse(isLandCall(i), {
1235+    let pool = valueOrErrorMessage(getString(this, (((user + "_") + posId) + kUserPositionPool)), "no position")
1236+    let pType = valueOrErrorMessage(getString(this, (kPool + pool)), "Pool is not inited")
1237+    let $t03847438564 = getPoolData(Address(fromBase58String(pool)), pType)
1238+    let AId = $t03847438564._1
1239+    let BId = $t03847438564._2
1240+    let balA = $t03847438564._3
1241+    let balB = $t03847438564._4
1242+    let shareId = $t03847438564._5
1243+    let amount = unstakeLP(pool, pType, shareId, liquidateAmount)
1244+    let borrowAmount = getIntegerValue(this, (((((pool + "_") + user) + "_") + posId) + kUserBorrowAmount))
1245+    let borrowAsset = getStringValue(this, (((((pool + "_") + user) + "_") + posId) + kUserBorrowAssetId))
1246+    let userCanWithdraw = userCanWithdrawShareCalc(user, pool, posId, (borrowAmount > 0))
1247+    if ((borrowAmount == 0))
1248+        then throw("You can't liquidate position without borrow")
1249+        else [IntegerEntry((((((pool + "_") + user) + "_") + posId) + kUserPositionInterest), getIntegerValue(this, (pool + kPoolInterestLoan))), IntegerEntry((pool + kPoolTotalLoan), (getPoolTotalShareWithLoan(pool) - liquidateAmount)), IntegerEntry((pool + kPoolTotal), (getPoolTotalShare(pool) - liquidateAmount)), IntegerEntry((((((pool + "_") + user) + "_") + posId) + kUserPosition), (userCanWithdraw - liquidateAmount)), ScriptTransfer(i.caller, amount, fromBase58String(shareId))]
1250+    })
1251+
1252+
1253+
1254+@Callable(i)
1255+func stopLoss (user,posId,pool,assetId) = valueOrElse(isAdminCall(i), {
1256+    let tokenOraclePrice = (    let @ = invoke(priceOracleAddr, "getTWAP60", [assetId, false], nil)
1257+    if ($isInstanceOf(@, "(Int, Int)"))
1258+        then @
1259+        else throw(($getType(@) + " couldn't be cast to (Int, Int)")))._1
1260+    if (!(isDefined(getInteger(this, (((((((user + "_") + toString(posId)) + "_") + pool) + "_") + assetId) + kUserStopLoss)))))
1261+        then throw("No entry")
1262+        else (withdrawToUser(toString(i.caller), pool, toString(posId), true) :+ DeleteEntry((((((((user + "_") + toString(posId)) + "_") + pool) + "_") + assetId) + kUserStopLoss)))
1263+    })
1264+
1265+
1266+
1267+@Callable(i)
1268+func capitalizeExKeeper (pool,type,tokenToId,amountToExchange,claim,amountsIn,addresses,assetsToReceive,estReceived,slippageTolerance,minReceived,options) = valueOrElse(isAdminCall(i), {
1269+    let $t04035040544 = if (claim)
1270+        then claimFarmed(type, pool)
1271+        else {
1272+            let claimedAsset = if ((type == SF_POOL))
1273+                then SWOPID
1274+                else WXID
1275+            $Tuple2(amountToExchange, claimedAsset)
1276+            }
1277+    let claimedAmount = $t04035040544._1
1278+    let claimedAsset = $t04035040544._2
1279+    let exchangedAmount = exchangeKeeper(tokenToId, amountToExchange, claimedAsset, amountsIn, addresses, assetsToReceive, estReceived, slippageTolerance, minReceived, options)
1280+    let change = (claimedAmount - amountToExchange)
1281+    let changeEntry = if ((change > 0))
1282+        then [IntegerEntry((pool + kPoolCapChange), (change + valueOrElse(getInteger(this, (pool + kPoolCapChange)), 0)))]
1283+        else nil
1284+    (capitalize(pool, type, tokenToId, exchangedAmount) ++ changeEntry)
1285+    })
1286+
1287+
1288+
1289+@Callable(i)
1290+func capitalizeExPuzzle (pool,type,tokenToId,amountToExchange,claim,routesStr,minToReceive,options) = valueOrElse(isAdminCall(i), {
1291+    let $t04122941423 = if (claim)
1292+        then claimFarmed(type, pool)
1293+        else {
1294+            let claimedAsset = if ((type == SF_POOL))
1295+                then SWOPID
1296+                else WXID
1297+            $Tuple2(amountToExchange, claimedAsset)
1298+            }
1299+    let claimedAmount = $t04122941423._1
1300+    let claimedAsset = $t04122941423._2
1301+    let exchangedAmount = exchangePuzzle(tokenToId, amountToExchange, claimedAsset, routesStr, minToReceive, options)
1302+    let change = (claimedAmount - amountToExchange)
1303+    let changeEntry = if ((change > 0))
1304+        then [IntegerEntry((pool + kPoolCapChange), (change + valueOrElse(getInteger(this, (pool + kPoolCapChange)), 0)))]
1305+        else nil
1306+    (capitalize(pool, type, tokenToId, exchangedAmount) ++ changeEntry)
1307+    })
1308+
1309+
1310+
1311+@Callable(i)
1312+func capitalizeExSwopFi (pool,type,tokenToId,amountToExchange,claim,exchangers,exchangersType,args1,args2,routingAssetsKeys,minAmountToReceive,options) = valueOrElse(isAdminCall(i), {
1313+    let $t04217442368 = if (claim)
1314+        then claimFarmed(type, pool)
1315+        else {
1316+            let claimedAsset = if ((type == SF_POOL))
1317+                then SWOPID
1318+                else WXID
1319+            $Tuple2(amountToExchange, claimedAsset)
1320+            }
1321+    let claimedAmount = $t04217442368._1
1322+    let claimedAsset = $t04217442368._2
1323+    let exchangedAmount = exchangeSwopFi(tokenToId, amountToExchange, claimedAsset, exchangers, exchangersType, args1, args2, routingAssetsKeys, minAmountToReceive, options)
1324+    let change = (claimedAmount - amountToExchange)
1325+    let changeEntry = if ((change > 0))
1326+        then [IntegerEntry((pool + kPoolCapChange), (change + valueOrElse(getInteger(this, (pool + kPoolCapChange)), 0)))]
1327+        else nil
1328+    (capitalize(pool, type, tokenToId, exchangedAmount) ++ changeEntry)
1329+    })
1330+
1331+
1332+
1333+@Callable(i)
1334+func initNewPool (type,poolAddr,inFeeNoLoan,inFeeLoan,capFeeNoLoan,capFeeWithLoan,stoplossFeeNoLoan,stoplossFeeWithLoan,canBorrow) = valueOrElse(isAdminCall(i), if (if ((type != SF_POOL))
1335+    then (type != WX_POOL)
1336+    else false)
1337+    then throw("Wrong type")
1338+    else {
1339+        let $t04310943203 = getPoolData(Address(fromBase58String(poolAddr)), type)
1340+        let aId = $t04310943203._1
1341+        let bId = $t04310943203._2
1342+        let aBal = $t04310943203._3
1343+        let bBal = $t04310943203._4
1344+        let shareId = $t04310943203._5
1345+[IntegerEntry((poolAddr + kAxlyInFeeWithoutLoan), inFeeNoLoan), IntegerEntry((poolAddr + kAxlyInFeeWithLoan), inFeeLoan), IntegerEntry((poolAddr + kAxlyNoLoanCapFee), capFeeNoLoan), IntegerEntry((poolAddr + kAxlyWithLoanCapFee), capFeeWithLoan), IntegerEntry((poolAddr + kAxlyStopLossNoLoanFee), stoplossFeeNoLoan), IntegerEntry((poolAddr + kAxlyStopLossLoanFee), stoplossFeeWithLoan), IntegerEntry((poolAddr + kPoolInterestLoan), 0), IntegerEntry((poolAddr + kPoolInterestNoLoan), 0), StringEntry((kPool + poolAddr), type), StringEntry((shareId + kSharePool), poolAddr), BooleanEntry((poolAddr + kPoolCanBorrow), canBorrow)]
1346+        })
1347+
1348+
1349+@Verifier(tx)
1350+func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
1351+
github/deemru/w8io/169f3d6 
167.32 ms ◑