@curvefi/llamalend-api 1.0.22-beta.1 → 1.0.22

package/lib/mintMarkets/modules/leverageV2.js

@@ -0,0 +1,788 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import memoize from "memoizee";
+import { _getAddress, parseUnits, BN, toBN, fromBN, ensureAllowance, hasAllowance, ensureAllowanceEstimateGas, formatUnits, smartNumber, formatNumber, _mulBy1_3, DIGas, } from "../../utils.js";
+import { _getExpectedOdos, _getQuoteOdos, _assembleTxOdos } from "../../external-api.js";
+/**
+ * LeverageV2 module for MintMarketTemplate
+ */
+export class LeverageV2Module {
+    constructor(market) {
+        this.swapDataCache = {};
+        this._getMarketId = () => {
+            if (!this.market.isDeleverageSupported) {
+                throw Error('For old markets use deprecatedLeverage');
+            }
+            return this.market.index;
+        };
+        this.hasLeverage = () => {
+            return this.llamalend.constants.ALIASES.leverage_zap !== this.llamalend.constants.ZERO_ADDRESS && this.market.isDeleverageSupported;
+        };
+        this.leverageCreateLoanMaxRecvAllRanges = memoize((userCollateral, userBorrowed) => __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const _userCollateral = parseUnits(userCollateral, this.market.coinDecimals[1]);
+            const contract = this.llamalend.contracts[this.llamalend.constants.ALIASES.leverage_zap].multicallContract;
+            const oraclePriceBand = yield this.market.oraclePriceBand();
+            const pAvgApproxBN = BN(yield this.market.calcTickPrice(oraclePriceBand)); // upper tick of oracle price band
+            let pAvgBN = null;
+            const arrLength = this.market.maxBands - this.market.minBands + 1;
+            let maxLeverageCollateralBN = new Array(arrLength).fill(BN(0));
+            let _maxLeverageCollateral = new Array(arrLength).fill(BigInt(0));
+            let maxBorrowablePrevBN = new Array(arrLength).fill(BN(0));
+            let maxBorrowableBN = new Array(arrLength).fill(BN(0));
+            let _maxBorrowable = new Array(arrLength).fill(BigInt(0));
+            for (let i = 0; i < 5; i++) {
+                const pBN = pAvgBN !== null && pAvgBN !== void 0 ? pAvgBN : pAvgApproxBN;
+                maxBorrowablePrevBN = maxBorrowableBN;
+                const _userEffectiveCollateral = _userCollateral + fromBN(BN(userBorrowed).div(pBN), this.market.coinDecimals[1]);
+                const calls = [];
+                for (let N = this.market.minBands; N <= this.market.maxBands; N++) {
+                    const j = N - this.market.minBands;
+                    calls.push(contract.max_borrowable(this.market.controller, _userEffectiveCollateral, _maxLeverageCollateral[j], N, fromBN(pBN)));
+                }
+                _maxBorrowable = (yield this.llamalend.multicallProvider.all(calls)).map((_mb) => _mb * BigInt(998) / BigInt(1000));
+                maxBorrowableBN = _maxBorrowable.map((_mb) => toBN(_mb, this.market.coinDecimals[0]));
+                const deltaBN = maxBorrowableBN.map((mb, l) => mb.minus(maxBorrowablePrevBN[l]).abs().div(mb));
+                if (BigNumber.max(...deltaBN).lt(0.0005)) {
+                    maxBorrowableBN = maxBorrowablePrevBN;
+                    break;
+                }
+                if (pAvgBN === null) {
+                    const _y = BigInt(yield _getExpectedOdos.call(this.llamalend, this.market.coinAddresses[0], this.market.coinAddresses[1], _maxBorrowable[0], this.market.address));
+                    const yBN = toBN(_y, this.market.coinDecimals[1]);
+                    pAvgBN = maxBorrowableBN[0].div(yBN);
+                }
+                maxLeverageCollateralBN = maxBorrowableBN.map((mb) => mb.div(pAvgBN));
+                _maxLeverageCollateral = maxLeverageCollateralBN.map((mlc) => fromBN(mlc, this.market.coinDecimals[1]));
+            }
+            const userEffectiveCollateralBN = BN(userCollateral).plus(BN(userBorrowed).div(pAvgBN));
+            const res = {};
+            for (let N = this.market.minBands; N <= this.market.maxBands; N++) {
+                const j = N - this.market.minBands;
+                res[N] = {
+                    maxDebt: formatNumber(maxBorrowableBN[j].toString(), this.market.coinDecimals[0]),
+                    maxTotalCollateral: formatNumber(maxLeverageCollateralBN[j].plus(userEffectiveCollateralBN).toString(), this.market.coinDecimals[1]),
+                    userCollateral: formatNumber(userCollateral, this.market.coinDecimals[1]),
+                    collateralFromUserBorrowed: formatNumber(BN(userBorrowed).div(pAvgBN).toString(), this.market.coinDecimals[1]),
+                    collateralFromMaxDebt: formatNumber(maxLeverageCollateralBN[j].toString(), this.market.coinDecimals[1]),
+                    maxLeverage: maxLeverageCollateralBN[j].plus(userEffectiveCollateralBN).div(userEffectiveCollateralBN).toString(),
+                    avgPrice: pAvgBN.toString(),
+                };
+            }
+            return res;
+        }), {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this._setSwapDataToCache = (inputCoinAddress, outputCoinAddress, _amount, slippage) => __awaiter(this, void 0, void 0, function* () {
+            let swapData = yield _getQuoteOdos.call(this.llamalend, inputCoinAddress, outputCoinAddress, _amount, this.market.address, true, slippage);
+            while (swapData.pathId == null) {
+                swapData = yield _getQuoteOdos.call(this.llamalend, inputCoinAddress, outputCoinAddress, _amount, this.market.address, true, slippage);
+            }
+            const key = `${inputCoinAddress}-${_amount}`;
+            this.swapDataCache[key] = Object.assign(Object.assign({}, swapData), { slippage });
+        });
+        this._getSwapDataFromCache = (inputCoinAddress, _amount) => {
+            const key = `${inputCoinAddress}-${_amount}`;
+            if (!(key in this.swapDataCache))
+                throw Error("You must call corresponding `expected` method first " +
+                    "(leverage.createLoanExpectedCollateral, leverage.borrowMoreExpectedCollateral or leverage.repayExpectedBorrowed)");
+            return this.swapDataCache[key];
+        };
+        this._leverageExpectedCollateral = (userCollateral, userBorrowed, debt, user) => __awaiter(this, void 0, void 0, function* () {
+            const _userCollateral = parseUnits(userCollateral, this.market.coinDecimals[1]);
+            const _debt = parseUnits(debt, this.market.coinDecimals[0]);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            // additionalCollateral = (userBorrowed / p) + leverageCollateral
+            const _additionalCollateral = BigInt(this._getSwapDataFromCache(this.market.coinAddresses[0], _debt + _userBorrowed).outAmounts[0]);
+            const _collateralFromDebt = _debt * BigInt(Math.pow(10, 18)) / (_debt + _userBorrowed) * _additionalCollateral / BigInt(Math.pow(10, 18));
+            const _collateralFromUserBorrowed = _additionalCollateral - _collateralFromDebt;
+            let _stateCollateral = BigInt(0);
+            if (user) {
+                const { _collateral, _stablecoin: _borrowed } = yield this.market._userState(user);
+                if (_borrowed > BigInt(0))
+                    throw Error(`User ${user} is already in liquidation mode`);
+                _stateCollateral = _collateral;
+            }
+            const _totalCollateral = _userCollateral + _additionalCollateral;
+            const _futureStateCollateral = _stateCollateral + _totalCollateral;
+            const avgPrice = toBN(_debt + _userBorrowed, this.market.coinDecimals[0]).div(toBN(_additionalCollateral, this.market.coinDecimals[1])).toString();
+            return { _futureStateCollateral, _totalCollateral, _userCollateral, _collateralFromUserBorrowed, _collateralFromDebt, avgPrice };
+        });
+        this._leverageCalcN1 = memoize((userCollateral, userBorrowed, debt, range, user) => __awaiter(this, void 0, void 0, function* () {
+            if (range > 0)
+                this.market._checkRange(range);
+            let _stateDebt = BigInt(0);
+            if (user) {
+                const { _debt, _stablecoin: _borrowed } = yield this.market._userState(user);
+                const _N = yield this.market.userRange();
+                if (_borrowed > BigInt(0))
+                    throw Error(`User ${user} is already in liquidation mode`);
+                _stateDebt = _debt;
+                if (range < 0)
+                    range = Number(this.llamalend.formatUnits(_N, 0));
+            }
+            const { _futureStateCollateral } = yield this._leverageExpectedCollateral(userCollateral, userBorrowed, debt, user);
+            const _debt = _stateDebt + parseUnits(debt, this.market.coinDecimals[0]);
+            return yield this.llamalend.contracts[this.market.controller].contract.calculate_debt_n1(_futureStateCollateral, _debt, range, this.llamalend.constantOptions);
+        }), {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this._leverageCalcN1AllRanges = memoize((userCollateral, userBorrowed, debt, maxN) => __awaiter(this, void 0, void 0, function* () {
+            const { _futureStateCollateral } = yield this._leverageExpectedCollateral(userCollateral, userBorrowed, debt);
+            const _debt = parseUnits(debt, this.market.coinDecimals[0]);
+            const calls = [];
+            for (let N = this.market.minBands; N <= maxN; N++) {
+                calls.push(this.llamalend.contracts[this.market.controller].multicallContract.calculate_debt_n1(_futureStateCollateral, _debt, N));
+            }
+            return yield this.llamalend.multicallProvider.all(calls);
+        }), {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        // ---------------- LEVERAGE REPAY ----------------
+        this._leverageRepayExpectedBorrowed = (stateCollateral, userCollateral, userBorrowed) => {
+            this._checkLeverageZap();
+            const _stateCollateral = parseUnits(stateCollateral, this.market.coinDecimals[1]);
+            const _userCollateral = parseUnits(userCollateral, this.market.coinDecimals[1]);
+            let _borrowedExpected = BigInt(0);
+            let _borrowedFromStateCollateral = BigInt(0);
+            let _borrowedFromUserCollateral = BigInt(0);
+            if (_stateCollateral + _userCollateral > BigInt(0)) {
+                _borrowedExpected = BigInt(this._getSwapDataFromCache(this.market.coinAddresses[1], _stateCollateral + _userCollateral).outAmounts[0]);
+                _borrowedFromStateCollateral = _stateCollateral * BigInt(Math.pow(10, 18)) / (_stateCollateral + _userCollateral) * _borrowedExpected / BigInt(Math.pow(10, 18));
+                _borrowedFromUserCollateral = _borrowedExpected - _borrowedFromStateCollateral;
+            }
+            const _totalBorrowed = _borrowedExpected + parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            const avgPrice = toBN(_borrowedExpected, this.market.coinDecimals[0]).div(toBN(_stateCollateral + _userCollateral, this.market.coinDecimals[1])).toString();
+            return { _totalBorrowed, _borrowedFromStateCollateral, _borrowedFromUserCollateral, avgPrice };
+        };
+        this.leverageRepayExpectedBorrowed = (stateCollateral_1, userCollateral_1, userBorrowed_1, ...args_1) => __awaiter(this, [stateCollateral_1, userCollateral_1, userBorrowed_1, ...args_1], void 0, function* (stateCollateral, userCollateral, userBorrowed, slippage = 0.1) {
+            this._checkLeverageZap();
+            const _stateCollateral = parseUnits(stateCollateral, this.market.coinDecimals[1]);
+            const _userCollateral = parseUnits(userCollateral, this.market.coinDecimals[1]);
+            if (_stateCollateral + _userCollateral > BigInt(0)) {
+                yield this._setSwapDataToCache(this.market.coinAddresses[1], this.market.coinAddresses[0], _stateCollateral + _userCollateral, slippage);
+            }
+            const { _totalBorrowed, _borrowedFromStateCollateral, _borrowedFromUserCollateral, avgPrice } = this._leverageRepayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed);
+            return {
+                totalBorrowed: formatUnits(_totalBorrowed, this.market.coinDecimals[0]),
+                borrowedFromStateCollateral: formatUnits(_borrowedFromStateCollateral, this.market.coinDecimals[0]),
+                borrowedFromUserCollateral: formatUnits(_borrowedFromUserCollateral, this.market.coinDecimals[0]),
+                userBorrowed: formatNumber(userBorrowed, this.market.coinDecimals[0]),
+                avgPrice,
+            };
+        });
+        this._leverageRepayBands = memoize((stateCollateral, userCollateral, userBorrowed, address) => __awaiter(this, void 0, void 0, function* () {
+            address = _getAddress.call(this.llamalend, address);
+            if (!(yield this.leverageRepayIsAvailable(stateCollateral, userCollateral, userBorrowed, address)))
+                return [parseUnits(0, 0), parseUnits(0, 0)];
+            const _stateRepayCollateral = parseUnits(stateCollateral, this.market.coinDecimals[1]);
+            const { _collateral: _stateCollateral, _debt: _stateDebt } = yield this.market._userState(address);
+            const _N = yield this.market.userRange();
+            if (_stateDebt == BigInt(0))
+                throw Error(`Loan for ${address} does not exist`);
+            if (_stateCollateral < _stateRepayCollateral)
+                throw Error(`Can't use more collateral than user's position has (${_stateRepayCollateral}) > ${_stateCollateral})`);
+            let _n1 = parseUnits(0, 0);
+            let _n2 = parseUnits(0, 0);
+            const { _totalBorrowed: _repayExpected } = this._leverageRepayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed);
+            try {
+                _n1 = yield this.llamalend.contracts[this.market.controller].contract.calculate_debt_n1(_stateCollateral - _stateRepayCollateral, _stateDebt - _repayExpected, _N);
+                _n2 = _n1 + (BigInt(_N) - BigInt(1));
+            }
+            catch (_a) {
+                console.log("Full repayment");
+            }
+            return [_n2, _n1];
+        }), {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+    // ============ CREATE LOAN METHODS ============
+    // ---------------- LEVERAGE CREATE LOAN ----------------
+    userLoanExists() {
+        return __awaiter(this, arguments, void 0, function* (address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            return yield this.llamalend.contracts[this.market.controller].contract.loan_exists(address, this.llamalend.constantOptions);
+        });
+    }
+    _checkLeverageZap() {
+        if (!this.hasLeverage()) {
+            throw Error("This market does not support leverage");
+        }
+    }
+    _get_k_effective_BN(N) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // d_k_effective: uint256 = (1 - loan_discount) * sqrt((A-1)/A) / N
+            // k_effective = d_k_effective * sum_{0..N-1}(((A-1) / A)**k)
+            const { loan_discount } = yield this.market.statsParameters();
+            const A = this.market.A;
+            const A_BN = BN(A);
+            const A_ratio_BN = A_BN.minus(1).div(A_BN);
+            const d_k_effective_BN = BN(100).minus(loan_discount).div(100).times(A_ratio_BN.sqrt()).div(N);
+            let S = BN(0);
+            for (let n = 0; n < N; n++) {
+                S = S.plus(A_ratio_BN.pow(n));
+            }
+            return d_k_effective_BN.times(S);
+        });
+    }
+    maxLeverage(N) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // max_leverage = 1 / (k_effective - 1)
+            const k_effective_BN = yield this._get_k_effective_BN(N);
+            return BN(1).div(BN(1).minus(k_effective_BN)).toString();
+        });
+    }
+    leverageCreateLoanMaxRecv(userCollateral, userBorrowed, range) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // max_borrowable = userCollateral / (1 / (k_effective * max_p_base) - 1 / p_avg)
+            this._checkLeverageZap();
+            if (range > 0)
+                this.market._checkRange(range);
+            const _userCollateral = parseUnits(userCollateral, this.market.coinDecimals[1]);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            const oraclePriceBand = yield this.market.oraclePriceBand();
+            let pAvgBN = BN(yield this.market.calcTickPrice(oraclePriceBand)); // upper tick of oracle price band
+            let maxBorrowablePrevBN = BN(0);
+            let maxBorrowableBN = BN(0);
+            let _userEffectiveCollateral = BigInt(0);
+            let _maxLeverageCollateral = BigInt(0);
+            const contract = this.llamalend.contracts[this.llamalend.constants.ALIASES.leverage_zap].contract;
+            for (let i = 0; i < 5; i++) {
+                maxBorrowablePrevBN = maxBorrowableBN;
+                _userEffectiveCollateral = _userCollateral + fromBN(BN(userBorrowed).div(pAvgBN), this.market.coinDecimals[1]);
+                let _maxBorrowable = yield contract.max_borrowable(this.market.controller, _userEffectiveCollateral, _maxLeverageCollateral, range, fromBN(pAvgBN));
+                _maxBorrowable = _maxBorrowable * BigInt(998) / BigInt(1000);
+                if (_maxBorrowable === BigInt(0))
+                    break;
+                maxBorrowableBN = toBN(_maxBorrowable, this.market.coinDecimals[0]);
+                if (maxBorrowableBN.minus(maxBorrowablePrevBN).abs().div(maxBorrowablePrevBN).lt(0.0005)) {
+                    maxBorrowableBN = maxBorrowablePrevBN;
+                    break;
+                }
+                // additionalCollateral = (userBorrowed / p) + leverageCollateral
+                const _maxAdditionalCollateral = BigInt(yield _getExpectedOdos.call(this.llamalend, this.market.coinAddresses[0], this.market.coinAddresses[1], _maxBorrowable + _userBorrowed, this.market.address));
+                pAvgBN = maxBorrowableBN.plus(userBorrowed).div(toBN(_maxAdditionalCollateral, this.market.coinDecimals[1]));
+                _maxLeverageCollateral = _maxAdditionalCollateral - fromBN(BN(userBorrowed).div(pAvgBN), this.market.coinDecimals[1]);
+            }
+            const userEffectiveCollateralBN = maxBorrowableBN.gt(0) ? toBN(_userEffectiveCollateral, this.market.coinDecimals[1]) : BN(0);
+            const maxLeverageCollateralBN = toBN(_maxLeverageCollateral, this.market.coinDecimals[1]);
+            return {
+                maxDebt: formatNumber(maxBorrowableBN.toString(), this.market.coinDecimals[0]),
+                maxTotalCollateral: formatNumber(maxLeverageCollateralBN.plus(userEffectiveCollateralBN).toString(), this.market.coinDecimals[1]),
+                userCollateral: formatNumber(userCollateral, this.market.coinDecimals[1]),
+                collateralFromUserBorrowed: formatNumber(BN(userBorrowed).div(pAvgBN).toString(), this.market.coinDecimals[1]),
+                collateralFromMaxDebt: formatNumber(maxLeverageCollateralBN.toString(), this.market.coinDecimals[1]),
+                maxLeverage: maxLeverageCollateralBN.plus(userEffectiveCollateralBN).div(userEffectiveCollateralBN).toString(),
+                avgPrice: pAvgBN.toString(),
+            };
+        });
+    }
+    leverageCreateLoanExpectedCollateral(userCollateral_1, userBorrowed_1, debt_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, debt, slippage = 0.1) {
+            this._checkLeverageZap();
+            const _debt = parseUnits(debt, this.market.coinDecimals[0]);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            yield this._setSwapDataToCache(this.market.coinAddresses[0], this.market.coinAddresses[1], _debt + _userBorrowed, slippage);
+            const { _totalCollateral, _userCollateral, _collateralFromUserBorrowed, _collateralFromDebt, avgPrice } = yield this._leverageExpectedCollateral(userCollateral, userBorrowed, debt);
+            return {
+                totalCollateral: formatUnits(_totalCollateral, this.market.coinDecimals[1]),
+                userCollateral: formatUnits(_userCollateral, this.market.coinDecimals[1]),
+                collateralFromUserBorrowed: formatUnits(_collateralFromUserBorrowed, this.market.coinDecimals[1]),
+                collateralFromDebt: formatUnits(_collateralFromDebt, this.market.coinDecimals[1]),
+                leverage: toBN(_collateralFromDebt + _userCollateral + _collateralFromUserBorrowed, this.market.coinDecimals[1])
+                    .div(toBN(_userCollateral + _collateralFromUserBorrowed, this.market.coinDecimals[1])).toString(),
+                avgPrice,
+            };
+        });
+    }
+    leverageCreateLoanPriceImpact(userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const _debt = parseUnits(debt, this.market.coinDecimals[0]);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            return this._getSwapDataFromCache(this.market.coinAddresses[0], _debt + _userBorrowed).priceImpact.toString();
+        });
+    }
+    leverageCreateLoanMaxRange(userCollateral, userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const maxRecv = yield this.leverageCreateLoanMaxRecvAllRanges(userCollateral, userBorrowed);
+            for (let N = this.market.minBands; N <= this.market.maxBands; N++) {
+                if (BN(debt).gt(maxRecv[N].maxDebt))
+                    return N - 1;
+            }
+            return this.market.maxBands;
+        });
+    }
+    _leverageBands(userCollateral, userBorrowed, debt, range, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _n1 = yield this._leverageCalcN1(userCollateral, userBorrowed, debt, range, user);
+            if (range < 0) {
+                const N = yield this.market.userRange();
+                range = Number(N);
+            }
+            const _n2 = _n1 + BigInt(range - 1);
+            return [_n2, _n1];
+        });
+    }
+    _leverageCreateLoanBandsAllRanges(userCollateral, userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const maxN = yield this.leverageCreateLoanMaxRange(userCollateral, userBorrowed, debt);
+            const _n1_arr = yield this._leverageCalcN1AllRanges(userCollateral, userBorrowed, debt, maxN);
+            const _n2_arr = [];
+            for (let N = this.market.minBands; N <= maxN; N++) {
+                _n2_arr.push(_n1_arr[N - this.market.minBands] + BigInt(N - 1));
+            }
+            const _bands = {};
+            for (let N = this.market.minBands; N <= maxN; N++) {
+                _bands[N] = [_n2_arr[N - this.market.minBands], _n1_arr[N - this.market.minBands]];
+            }
+            return _bands;
+        });
+    }
+    leverageCreateLoanBands(userCollateral, userBorrowed, debt, range) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const [_n2, _n1] = yield this._leverageBands(userCollateral, userBorrowed, debt, range);
+            return [Number(_n2), Number(_n1)];
+        });
+    }
+    leverageCreateLoanBandsAllRanges(userCollateral, userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const _bands = yield this._leverageCreateLoanBandsAllRanges(userCollateral, userBorrowed, debt);
+            const bands = {};
+            for (let N = this.market.minBands; N <= this.market.maxBands; N++) {
+                if (_bands[N]) {
+                    bands[N] = _bands[N].map(Number);
+                }
+                else {
+                    bands[N] = null;
+                }
+            }
+            return bands;
+        });
+    }
+    leverageCreateLoanPrices(userCollateral, userBorrowed, debt, range) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const [_n2, _n1] = yield this._leverageBands(userCollateral, userBorrowed, debt, range);
+            return yield this.market._getPrices(_n2, _n1);
+        });
+    }
+    leverageCreateLoanPricesAllRanges(userCollateral, userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const _bands = yield this._leverageCreateLoanBandsAllRanges(userCollateral, userBorrowed, debt);
+            const prices = {};
+            for (let N = this.market.minBands; N <= this.market.maxBands; N++) {
+                if (_bands[N]) {
+                    prices[N] = yield this.market._calcPrices(..._bands[N]);
+                }
+                else {
+                    prices[N] = null;
+                }
+            }
+            return prices;
+        });
+    }
+    _leverageHealth(userCollateral_1, userBorrowed_1, dDebt_1, range_1, full_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, dDebt, range, full, user = this.llamalend.constants.ZERO_ADDRESS) {
+            if (range > 0)
+                this.market._checkRange(range);
+            const { _totalCollateral } = yield this._leverageExpectedCollateral(userCollateral, userBorrowed, dDebt, user);
+            const { _stablecoin: _borrowed } = yield this.market._userState(user);
+            const _N = yield this.market.userRange();
+            if (_borrowed > BigInt(0))
+                throw Error(`User ${user} is already in liquidation mode`);
+            if (range < 0)
+                range = Number(this.llamalend.formatUnits(_N, 0));
+            const _dDebt = parseUnits(dDebt, this.market.coinDecimals[0]);
+            const contract = this.llamalend.contracts[this.market.controller].contract;
+            let _health = yield contract.health_calculator(user, _totalCollateral, _dDebt, full, range, this.llamalend.constantOptions);
+            _health = _health * BigInt(100);
+            return formatUnits(_health);
+        });
+    }
+    leverageCreateLoanHealth(userCollateral_1, userBorrowed_1, debt_1, range_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, debt, range, full = true) {
+            this._checkLeverageZap();
+            return yield this._leverageHealth(userCollateral, userBorrowed, debt, range, full);
+        });
+    }
+    leverageCreateLoanIsApproved(userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const collateralAllowance = yield hasAllowance.call(this.llamalend, [this.market.coinAddresses[1]], [userCollateral], this.llamalend.signerAddress, this.market.controller);
+            const borrowedAllowance = yield hasAllowance.call(this.llamalend, [this.market.coinAddresses[0]], [userBorrowed], this.llamalend.signerAddress, this.llamalend.constants.ALIASES.leverage_zap);
+            return collateralAllowance && borrowedAllowance;
+        });
+    }
+    leverageCreateLoanApproveEstimateGas(userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const collateralGas = yield ensureAllowanceEstimateGas.call(this.llamalend, [this.market.coinAddresses[1]], [userCollateral], this.market.controller);
+            const borrowedGas = yield ensureAllowanceEstimateGas.call(this.llamalend, [this.market.coinAddresses[0]], [userBorrowed], this.llamalend.constants.ALIASES.leverage_zap);
+            if (Array.isArray(collateralGas) && Array.isArray(borrowedGas)) {
+                return [collateralGas[0] + borrowedGas[0], collateralGas[1] + borrowedGas[1]];
+            }
+            else {
+                return collateralGas + borrowedGas;
+            }
+        });
+    }
+    leverageCreateLoanApprove(userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const collateralApproveTx = yield ensureAllowance.call(this.llamalend, [this.market.coinAddresses[1]], [userCollateral], this.market.controller);
+            const borrowedApproveTx = yield ensureAllowance.call(this.llamalend, [this.market.coinAddresses[0]], [userBorrowed], this.llamalend.constants.ALIASES.leverage_zap);
+            return [...collateralApproveTx, ...borrowedApproveTx];
+        });
+    }
+    leverageCreateLoanRouteImage(userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const _userBorrowed = parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            const _debt = parseUnits(debt, this.market.coinDecimals[0]);
+            return this._getSwapDataFromCache(this.market.coinAddresses[0], _debt + _userBorrowed).pathVizImage;
+        });
+    }
+    _leverageCreateLoan(userCollateral, userBorrowed, debt, range, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.userLoanExists())
+                throw Error("Loan already created");
+            this.market._checkRange(range);
+            const _userCollateral = parseUnits(userCollateral, this.market.coinDecimals[1]);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            const _debt = parseUnits(debt, this.market.coinDecimals[0]);
+            const swapData = this._getSwapDataFromCache(this.market.coinAddresses[0], _debt + _userBorrowed);
+            if (slippage !== swapData.slippage)
+                throw Error(`You must call leverage.createLoanExpectedCollateral() with slippage=${slippage} first`);
+            const calldata = yield _assembleTxOdos.call(this.llamalend, swapData.pathId);
+            const contract = this.llamalend.contracts[this.market.controller].contract;
+            const gas = yield contract.create_loan_extended.estimateGas(_userCollateral, _debt, range, this.llamalend.constants.ALIASES.leverage_zap, [1, parseUnits(this._getMarketId(), 0), _userBorrowed], calldata, Object.assign({}, this.llamalend.constantOptions));
+            if (estimateGas)
+                return smartNumber(gas);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(gas));
+            return (yield contract.create_loan_extended(_userCollateral, _debt, range, this.llamalend.constants.ALIASES.leverage_zap, [1, parseUnits(this._getMarketId(), 0), _userBorrowed], calldata, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    leverageCreateLoanEstimateGas(userCollateral_1, userBorrowed_1, debt_1, range_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, debt, range, slippage = 0.1) {
+            this._checkLeverageZap();
+            if (!(yield this.leverageCreateLoanIsApproved(userCollateral, userBorrowed)))
+                throw Error("Approval is needed for gas estimation");
+            return yield this._leverageCreateLoan(userCollateral, userBorrowed, debt, range, slippage, true);
+        });
+    }
+    leverageCreateLoan(userCollateral_1, userBorrowed_1, debt_1, range_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, debt, range, slippage = 0.1) {
+            this._checkLeverageZap();
+            yield this.leverageCreateLoanApprove(userCollateral, userBorrowed);
+            return yield this._leverageCreateLoan(userCollateral, userBorrowed, debt, range, slippage, false);
+        });
+    }
+    // ---------------- LEVERAGE BORROW MORE ----------------
+    leverageBorrowMoreMaxRecv(userCollateral_1, userBorrowed_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, address = "") {
+            // max_borrowable = userCollateral / (1 / (k_effective * max_p_base) - 1 / p_avg)
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            const { _collateral: _stateCollateral, _stablecoin: _stateBorrowed, _debt: _stateDebt } = yield this.market._userState(address);
+            const _N = yield this.market.userRange();
+            if (_stateBorrowed > BigInt(0))
+                throw Error(`User ${address} is already in liquidation mode`);
+            const _userCollateral = parseUnits(userCollateral, this.market.coinDecimals[1]);
+            const controllerContract = this.llamalend.contracts[this.market.controller].contract;
+            const _borrowedFromStateCollateral = (yield controllerContract.max_borrowable(_stateCollateral, _N, _stateDebt, this.llamalend.constantOptions)) - _stateDebt;
+            const _userBorrowed = _borrowedFromStateCollateral + parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            userBorrowed = formatUnits(_userBorrowed, this.market.coinDecimals[0]);
+            const oraclePriceBand = yield this.market.oraclePriceBand();
+            let pAvgBN = BN(yield this.market.calcTickPrice(oraclePriceBand)); // upper tick of oracle price band
+            let maxBorrowablePrevBN = BN(0);
+            let maxBorrowableBN = BN(0);
+            let _userEffectiveCollateral = BigInt(0);
+            let _maxLeverageCollateral = BigInt(0);
+            const contract = this.llamalend.contracts[this.llamalend.constants.ALIASES.leverage_zap].contract;
+            for (let i = 0; i < 5; i++) {
+                maxBorrowablePrevBN = maxBorrowableBN;
+                _userEffectiveCollateral = _userCollateral + fromBN(BN(userBorrowed).div(pAvgBN), this.market.coinDecimals[1]);
+                let _maxBorrowable = yield contract.max_borrowable(this.market.controller, _userEffectiveCollateral, _maxLeverageCollateral, _N, fromBN(pAvgBN));
+                _maxBorrowable = _maxBorrowable * BigInt(998) / BigInt(1000);
+                if (_maxBorrowable === BigInt(0))
+                    break;
+                maxBorrowableBN = toBN(_maxBorrowable, this.market.coinDecimals[0]);
+                if (maxBorrowableBN.minus(maxBorrowablePrevBN).abs().div(maxBorrowablePrevBN).lt(0.0005)) {
+                    maxBorrowableBN = maxBorrowablePrevBN;
+                    break;
+                }
+                // additionalCollateral = (userBorrowed / p) + leverageCollateral
+                const _maxAdditionalCollateral = BigInt(yield _getExpectedOdos.call(this.llamalend, this.market.coinAddresses[0], this.market.coinAddresses[1], _maxBorrowable + _userBorrowed, this.market.address));
+                pAvgBN = maxBorrowableBN.plus(userBorrowed).div(toBN(_maxAdditionalCollateral, this.market.coinDecimals[1]));
+                _maxLeverageCollateral = _maxAdditionalCollateral - fromBN(BN(userBorrowed).div(pAvgBN), this.market.coinDecimals[1]);
+            }
+            if (maxBorrowableBN.eq(0))
+                _userEffectiveCollateral = BigInt(0);
+            const _maxTotalCollateral = _userEffectiveCollateral + _maxLeverageCollateral;
+            let _maxBorrowable = (yield controllerContract.max_borrowable(_stateCollateral + _maxTotalCollateral, _N, _stateDebt, this.llamalend.constantOptions)) - _stateDebt;
+            _maxBorrowable = _maxBorrowable * BigInt(998) / BigInt(1000);
+            return {
+                maxDebt: formatUnits(_maxBorrowable, this.market.coinDecimals[0]),
+                maxTotalCollateral: formatUnits(_maxTotalCollateral, this.market.coinDecimals[1]),
+                userCollateral: formatNumber(userCollateral, this.market.coinDecimals[1]),
+                collateralFromUserBorrowed: formatNumber(BN(userBorrowed).div(pAvgBN).toString(), this.market.coinDecimals[1]),
+                collateralFromMaxDebt: formatUnits(_maxLeverageCollateral, this.market.coinDecimals[1]),
+                avgPrice: pAvgBN.toString(),
+            };
+        });
+    }
+    leverageBorrowMoreExpectedCollateral(userCollateral_1, userBorrowed_1, dDebt_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, dDebt, slippage = 0.1, address = "") {
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            const _dDebt = parseUnits(dDebt, this.market.coinDecimals[0]);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            yield this._setSwapDataToCache(this.market.coinAddresses[0], this.market.coinAddresses[1], _dDebt + _userBorrowed, slippage);
+            const { _totalCollateral, _userCollateral, _collateralFromUserBorrowed, _collateralFromDebt, avgPrice } = yield this._leverageExpectedCollateral(userCollateral, userBorrowed, dDebt, address);
+            return {
+                totalCollateral: formatUnits(_totalCollateral, this.market.coinDecimals[1]),
+                userCollateral: formatUnits(_userCollateral, this.market.coinDecimals[1]),
+                collateralFromUserBorrowed: formatUnits(_collateralFromUserBorrowed, this.market.coinDecimals[1]),
+                collateralFromDebt: formatUnits(_collateralFromDebt, this.market.coinDecimals[1]),
+                avgPrice,
+            };
+        });
+    }
+    leverageBorrowMorePriceImpact(userBorrowed, dDebt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const _dDebt = parseUnits(dDebt, this.market.coinDecimals[0]);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            return this._getSwapDataFromCache(this.market.coinAddresses[0], _dDebt + _userBorrowed).priceImpact.toString();
+        });
+    }
+    leverageBorrowMoreBands(userCollateral_1, userBorrowed_1, dDebt_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, dDebt, address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            this._checkLeverageZap();
+            const [_n2, _n1] = yield this._leverageBands(userCollateral, userBorrowed, dDebt, -1, address);
+            return [Number(_n2), Number(_n1)];
+        });
+    }
+    leverageBorrowMorePrices(userCollateral_1, userBorrowed_1, dDebt_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, dDebt, address = "") {
+            address = _getAddress.call(this.llamalend, address);
+            this._checkLeverageZap();
+            const [_n2, _n1] = yield this._leverageBands(userCollateral, userBorrowed, dDebt, -1, address);
+            return yield this.market._getPrices(_n2, _n1);
+        });
+    }
+    leverageBorrowMoreHealth(userCollateral_1, userBorrowed_1, dDebt_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, dDebt, full = true, address = "") {
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            return yield this._leverageHealth(userCollateral, userBorrowed, dDebt, -1, full, address);
+        });
+    }
+    leverageBorrowMoreRouteImage(userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const _userBorrowed = parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            const _debt = parseUnits(debt, this.market.coinDecimals[0]);
+            return this._getSwapDataFromCache(this.market.coinAddresses[0], _debt + _userBorrowed).pathVizImage;
+        });
+    }
+    _leverageBorrowMore(userCollateral, userBorrowed, debt, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.userLoanExists()))
+                throw Error("Loan does not exist");
+            const _userCollateral = parseUnits(userCollateral, this.market.coinDecimals[1]);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            const _debt = parseUnits(debt, this.market.coinDecimals[0]);
+            const swapData = this._getSwapDataFromCache(this.market.coinAddresses[0], _debt + _userBorrowed);
+            if (slippage !== swapData.slippage)
+                throw Error(`You must call leverage.borrowMoreExpectedCollateral() with slippage=${slippage} first`);
+            const calldata = yield _assembleTxOdos.call(this.llamalend, swapData.pathId);
+            const contract = this.llamalend.contracts[this.market.controller].contract;
+            const gas = yield contract.borrow_more_extended.estimateGas(_userCollateral, _debt, this.llamalend.constants.ALIASES.leverage_zap, [1, parseUnits(this._getMarketId(), 0), _userBorrowed], calldata, Object.assign({}, this.llamalend.constantOptions));
+            if (estimateGas)
+                return smartNumber(gas);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(gas));
+            return (yield contract.borrow_more_extended(_userCollateral, _debt, this.llamalend.constants.ALIASES.leverage_zap, [1, parseUnits(this._getMarketId(), 0), _userBorrowed], calldata, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    leverageBorrowMoreEstimateGas(userCollateral_1, userBorrowed_1, debt_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, debt, slippage = 0.1) {
+            this._checkLeverageZap();
+            if (!(yield this.leverageCreateLoanIsApproved(userCollateral, userBorrowed)))
+                throw Error("Approval is needed for gas estimation");
+            return yield this._leverageBorrowMore(userCollateral, userBorrowed, debt, slippage, true);
+        });
+    }
+    leverageBorrowMore(userCollateral_1, userBorrowed_1, debt_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, debt, slippage = 0.1) {
+            this._checkLeverageZap();
+            yield this.leverageCreateLoanApprove(userCollateral, userBorrowed);
+            return yield this._leverageBorrowMore(userCollateral, userBorrowed, debt, slippage, false);
+        });
+    }
+    leverageRepayPriceImpact(stateCollateral, userCollateral) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const _stateCollateral = parseUnits(stateCollateral, this.market.coinDecimals[1]);
+            const _userCollateral = parseUnits(userCollateral, this.market.coinDecimals[1]);
+            if (_stateCollateral + _userCollateral > BigInt(0)) {
+                return this._getSwapDataFromCache(this.market.coinAddresses[1], _stateCollateral + _userCollateral).priceImpact.toString();
+            }
+            else {
+                return "0.0";
+            }
+        });
+    }
+    leverageRepayIsFull(stateCollateral_1, userCollateral_1, userBorrowed_1) {
+        return __awaiter(this, arguments, void 0, function* (stateCollateral, userCollateral, userBorrowed, address = "") {
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            const { _stablecoin: _stateBorrowed, _debt } = yield this.market._userState(address);
+            const { _totalBorrowed } = this._leverageRepayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed);
+            return _stateBorrowed + _totalBorrowed > _debt;
+        });
+    }
+    leverageRepayIsAvailable(stateCollateral_1, userCollateral_1, userBorrowed_1) {
+        return __awaiter(this, arguments, void 0, function* (stateCollateral, userCollateral, userBorrowed, address = "") {
+            // 0. const { collateral, stablecoin, debt } = await this.userState(address);
+            // 1. maxCollateral for deleverage is collateral from line above.
+            // 2. If user is underwater (stablecoin > 0), only full repayment is available:
+            //    await this.deleverageRepayStablecoins(deleverageCollateral) + stablecoin > debt
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            const { collateral, stablecoin: borrowed, debt } = yield this.market.userState(address);
+            // Loan does not exist
+            if (BN(debt).eq(0))
+                return false;
+            // Can't spend more than user has
+            if (BN(stateCollateral).gt(collateral))
+                return false;
+            // Only full repayment and closing the position is available if user is underwater+
+            if (BN(borrowed).gt(0))
+                return yield this.leverageRepayIsFull(stateCollateral, userCollateral, userBorrowed, address);
+            return true;
+        });
+    }
+    leverageRepayBands(stateCollateral_1, userCollateral_1, userBorrowed_1) {
+        return __awaiter(this, arguments, void 0, function* (stateCollateral, userCollateral, userBorrowed, address = "") {
+            this._checkLeverageZap();
+            const [_n2, _n1] = yield this._leverageRepayBands(stateCollateral, userCollateral, userBorrowed, address);
+            return [Number(_n2), Number(_n1)];
+        });
+    }
+    leverageRepayPrices(stateCollateral_1, userCollateral_1, userBorrowed_1) {
+        return __awaiter(this, arguments, void 0, function* (stateCollateral, userCollateral, userBorrowed, address = "") {
+            this._checkLeverageZap();
+            const [_n2, _n1] = yield this._leverageRepayBands(stateCollateral, userCollateral, userBorrowed, address);
+            return yield this.market._getPrices(_n2, _n1);
+        });
+    }
+    leverageRepayHealth(stateCollateral_1, userCollateral_1, userBorrowed_1) {
+        return __awaiter(this, arguments, void 0, function* (stateCollateral, userCollateral, userBorrowed, full = true, address = "") {
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            const { _stablecoin: _stateBorrowed, _debt } = yield this.market._userState(address);
+            const _N = yield this.market.userRange();
+            if (_stateBorrowed > BigInt(0))
+                return "0.0";
+            if (!(yield this.leverageRepayIsAvailable(stateCollateral, userCollateral, userBorrowed, address)))
+                return "0.0";
+            const { _totalBorrowed } = this._leverageRepayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed);
+            const _dCollateral = parseUnits(stateCollateral, this.market.coinDecimals[1]) * BigInt(-1);
+            const _dDebt = _totalBorrowed * BigInt(-1);
+            if (_debt + _dDebt <= BigInt(0))
+                return "0.0";
+            const contract = this.llamalend.contracts[this.market.controller].contract;
+            let _health = yield contract.health_calculator(address, _dCollateral, _dDebt, full, _N, this.llamalend.constantOptions);
+            _health = _health * BigInt(100);
+            return this.llamalend.formatUnits(_health);
+        });
+    }
+    leverageRepayIsApproved(userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            return yield hasAllowance.call(this.llamalend, [this.market.coinAddresses[1], this.market.coinAddresses[0]], [userCollateral, userBorrowed], this.llamalend.signerAddress, this.llamalend.constants.ALIASES.leverage_zap);
+        });
+    }
+    leverageRepayApproveEstimateGas(userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            return yield ensureAllowanceEstimateGas.call(this.llamalend, [this.market.coinAddresses[1], this.market.coinAddresses[0]], [userCollateral, userBorrowed], this.llamalend.constants.ALIASES.leverage_zap);
+        });
+    }
+    leverageRepayApprove(userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            return yield ensureAllowance.call(this.llamalend, [this.market.coinAddresses[1], this.market.coinAddresses[0]], [userCollateral, userBorrowed], this.llamalend.constants.ALIASES.leverage_zap);
+        });
+    }
+    leverageRepayRouteImage(stateCollateral, userCollateral) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._checkLeverageZap();
+            const _stateCollateral = parseUnits(stateCollateral, this.market.coinDecimals[1]);
+            const _userCollateral = parseUnits(userCollateral, this.market.coinDecimals[1]);
+            return this._getSwapDataFromCache(this.market.coinAddresses[1], _stateCollateral + _userCollateral).pathVizImage;
+        });
+    }
+    _leverageRepay(stateCollateral, userCollateral, userBorrowed, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.userLoanExists()))
+                throw Error("Loan does not exist");
+            const _stateCollateral = parseUnits(stateCollateral, this.market.coinDecimals[1]);
+            const _userCollateral = parseUnits(userCollateral, this.market.coinDecimals[1]);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.coinDecimals[0]);
+            let calldata = "0x";
+            if (_stateCollateral + _userCollateral > BigInt(0)) {
+                const swapData = this._getSwapDataFromCache(this.market.coinAddresses[1], _stateCollateral + _userCollateral);
+                if (slippage !== swapData.slippage)
+                    throw Error(`You must call leverage.repayExpectedBorrowed() with slippage=${slippage} first`);
+                calldata = yield _assembleTxOdos.call(this.llamalend, swapData.pathId);
+            }
+            console.log('params', [1, parseUnits(this._getMarketId(), 0), _userCollateral, _userBorrowed], calldata);
+            const contract = this.llamalend.contracts[this.market.controller].contract;
+            const gas = yield contract.repay_extended.estimateGas(this.llamalend.constants.ALIASES.leverage_zap, [1, parseUnits(this._getMarketId(), 0), _userCollateral, _userBorrowed], calldata);
+            if (estimateGas)
+                return smartNumber(gas);
+            yield this.llamalend.updateFeeData();
+            const gasLimit = _mulBy1_3(DIGas(gas));
+            return (yield contract.repay_extended(this.llamalend.constants.ALIASES.leverage_zap, [1, parseUnits(this._getMarketId(), 0), _userCollateral, _userBorrowed], calldata, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    leverageRepayEstimateGas(stateCollateral_1, userCollateral_1, userBorrowed_1) {
+        return __awaiter(this, arguments, void 0, function* (stateCollateral, userCollateral, userBorrowed, slippage = 0.1) {
+            this._checkLeverageZap();
+            if (!(yield this.leverageRepayIsApproved(userCollateral, userBorrowed)))
+                throw Error("Approval is needed for gas estimation");
+            return yield this._leverageRepay(stateCollateral, userCollateral, userBorrowed, slippage, true);
+        });
+    }
+    leverageRepay(stateCollateral_1, userCollateral_1, userBorrowed_1) {
+        return __awaiter(this, arguments, void 0, function* (stateCollateral, userCollateral, userBorrowed, slippage = 0.1) {
+            this._checkLeverageZap();
+            yield this.leverageRepayApprove(userCollateral, userBorrowed);
+            return yield this._leverageRepay(stateCollateral, userCollateral, userBorrowed, slippage, false);
+        });
+    }
+}