@curvefi/llamalend-api 1.0.42 → 1.1.1

package/lib/lendMarkets/modules/leverageZapV2.js

@@ -0,0 +1,681 @@
+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, buildCalldataForLeverageZapV2, } from "../../utils.js";
+import BigNumber from "bignumber.js";
+/**
+ * LeverageZapV2 module for LendMarketTemplate
+ */
+export class LeverageZapV2Module {
+    constructor(market) {
+        this._getMarketId = () => Number(this.market.id.split("-").slice(-1)[0]);
+        // ============ CREATE LOAN METHODS ============
+        this.hasLeverage = () => {
+            return this.llamalend.constants.ALIASES.leverage_zap_v2 !== this.llamalend.constants.ZERO_ADDRESS &&
+                this._getMarketId() >= Number(this.llamalend.constants.ALIASES["leverage_markets_start_id"]);
+        };
+        this.leverageCreateLoanMaxRecvAllRanges = memoize((_a) => __awaiter(this, [_a], void 0, function* ({ userCollateral, userBorrowed, getExpected }) {
+            this._checkLeverageZap();
+            const _userCollateral = parseUnits(userCollateral, this.market.collateral_token.decimals);
+            const contract = this.llamalend.contracts[this.llamalend.constants.ALIASES.leverage_zap_v2].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.collateral_token.decimals);
+                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.addresses.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.borrowed_token.decimals));
+                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 getExpected(this.market.addresses.borrowed_token, this.market.addresses.collateral_token, _maxBorrowable[0], this.market.addresses.amm)).outAmount);
+                    const yBN = toBN(_y, this.market.collateral_token.decimals);
+                    pAvgBN = maxBorrowableBN[0].div(yBN);
+                }
+                maxLeverageCollateralBN = maxBorrowableBN.map((mb) => mb.div(pAvgBN));
+                _maxLeverageCollateral = maxLeverageCollateralBN.map((mlc) => fromBN(mlc, this.market.collateral_token.decimals));
+            }
+            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.borrowed_token.decimals),
+                    maxTotalCollateral: formatNumber(maxLeverageCollateralBN[j].plus(userEffectiveCollateralBN).toString(), this.market.collateral_token.decimals),
+                    userCollateral: formatNumber(userCollateral, this.market.collateral_token.decimals),
+                    collateralFromUserBorrowed: formatNumber(BN(userBorrowed).div(pAvgBN).toString(), this.market.collateral_token.decimals),
+                    collateralFromMaxDebt: formatNumber(maxLeverageCollateralBN[j].toString(), this.market.collateral_token.decimals),
+                    maxLeverage: maxLeverageCollateralBN[j].plus(userEffectiveCollateralBN).div(userEffectiveCollateralBN).toString(),
+                    avgPrice: pAvgBN.toString(),
+                };
+            }
+            return res;
+        }), {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this._leverageExpectedCollateral = (userCollateral, userBorrowed, debt, quote, user) => __awaiter(this, void 0, void 0, function* () {
+            const _userCollateral = parseUnits(userCollateral, this.market.collateral_token.decimals);
+            const _debt = parseUnits(debt, this.market.borrowed_token.decimals);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.borrowed_token.decimals);
+            // additionalCollateral = (userBorrowed / p) + leverageCollateral
+            const _additionalCollateral = BigInt(quote.outAmount);
+            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, _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.borrowed_token.decimals).div(toBN(_additionalCollateral, this.market.collateral_token.decimals)).toString();
+            return { _futureStateCollateral, _totalCollateral, _userCollateral, _collateralFromUserBorrowed, _collateralFromDebt, avgPrice };
+        });
+        this._leverageCalcN1 = memoize((userCollateral, userBorrowed, debt, range, quote, user) => __awaiter(this, void 0, void 0, function* () {
+            if (range > 0)
+                this.market._checkRange(range);
+            let _stateDebt = BigInt(0);
+            if (user) {
+                const { _debt, _borrowed, _N } = yield this.market._userState(user);
+                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, quote, user);
+            const _debt = _stateDebt + parseUnits(debt, this.market.borrowed_token.decimals);
+            return yield this.llamalend.contracts[this.market.addresses.controller].contract.calculate_debt_n1(_futureStateCollateral, _debt, range, this.llamalend.constantOptions);
+        }), {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this._leverageCalcN1AllRanges = memoize((userCollateral, userBorrowed, debt, maxN, quote) => __awaiter(this, void 0, void 0, function* () {
+            const { _futureStateCollateral } = yield this._leverageExpectedCollateral(userCollateral, userBorrowed, debt, quote);
+            const _debt = parseUnits(debt, this.market.borrowed_token.decimals);
+            const calls = [];
+            for (let N = this.market.minBands; N <= maxN; N++) {
+                calls.push(this.llamalend.contracts[this.market.addresses.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, quote) => {
+            this._checkLeverageZap();
+            const _stateCollateral = parseUnits(stateCollateral, this.market.collateral_token.decimals);
+            const _userCollateral = parseUnits(userCollateral, this.market.collateral_token.decimals);
+            let _borrowedExpected = BigInt(0);
+            let _borrowedFromStateCollateral = BigInt(0);
+            let _borrowedFromUserCollateral = BigInt(0);
+            if (_stateCollateral + _userCollateral > BigInt(0)) {
+                _borrowedExpected = BigInt(quote.outAmount);
+                _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.borrowed_token.decimals);
+            const avgPrice = toBN(_borrowedExpected, this.market.borrowed_token.decimals).div(toBN(_stateCollateral + _userCollateral, this.market.collateral_token.decimals)).toString();
+            return { _totalBorrowed, _borrowedFromStateCollateral, _borrowedFromUserCollateral, avgPrice };
+        };
+        this.leverageRepayExpectedBorrowed = (_a) => __awaiter(this, [_a], void 0, function* ({ stateCollateral, userCollateral, userBorrowed, quote }) {
+            this._checkLeverageZap();
+            const { _totalBorrowed, _borrowedFromStateCollateral, _borrowedFromUserCollateral, avgPrice } = this._leverageRepayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed, quote);
+            return {
+                totalBorrowed: formatUnits(_totalBorrowed, this.market.borrowed_token.decimals),
+                borrowedFromStateCollateral: formatUnits(_borrowedFromStateCollateral, this.market.borrowed_token.decimals),
+                borrowedFromUserCollateral: formatUnits(_borrowedFromUserCollateral, this.market.borrowed_token.decimals),
+                userBorrowed: formatNumber(userBorrowed, this.market.borrowed_token.decimals),
+                avgPrice,
+            };
+        });
+        this._leverageRepayBands = memoize((stateCollateral, userCollateral, userBorrowed, quote, address) => __awaiter(this, void 0, void 0, function* () {
+            address = _getAddress.call(this.llamalend, address);
+            if (!(yield this.leverageRepayIsAvailable({ stateCollateral, userCollateral, userBorrowed, quote, address })))
+                return [parseUnits(0, 0), parseUnits(0, 0)];
+            const _stateRepayCollateral = parseUnits(stateCollateral, this.market.collateral_token.decimals);
+            const { _collateral: _stateCollateral, _debt: _stateDebt, _N } = yield this.market._userState(address);
+            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, quote);
+            try {
+                _n1 = yield this.llamalend.contracts[this.market.addresses.controller].contract.calculate_debt_n1(_stateCollateral - _stateRepayCollateral, _stateDebt - _repayExpected, _N);
+                _n2 = _n1 + (_N - BigInt(1));
+                return [_n2, _n1];
+            }
+            catch (_a) {
+                return [_n2, _n1];
+            }
+        }), {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+    _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, A } = yield this.market.stats.parameters();
+            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(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, range, getExpected }) {
+            // 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.collateral_token.decimals);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.borrowed_token.decimals);
+            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_v2].contract;
+            for (let i = 0; i < 5; i++) {
+                maxBorrowablePrevBN = maxBorrowableBN;
+                _userEffectiveCollateral = _userCollateral + fromBN(BN(userBorrowed).div(pAvgBN), this.market.collateral_token.decimals);
+                let _maxBorrowable = yield contract.max_borrowable(this.market.addresses.controller, _userEffectiveCollateral, _maxLeverageCollateral, range, fromBN(pAvgBN));
+                _maxBorrowable = _maxBorrowable * BigInt(998) / BigInt(1000);
+                if (_maxBorrowable === BigInt(0))
+                    break;
+                maxBorrowableBN = toBN(_maxBorrowable, this.market.borrowed_token.decimals);
+                if (maxBorrowableBN.minus(maxBorrowablePrevBN).abs().div(maxBorrowablePrevBN).lt(0.0005)) {
+                    maxBorrowableBN = maxBorrowablePrevBN;
+                    break;
+                }
+                // additionalCollateral = (userBorrowed / p) + leverageCollateral
+                const _maxAdditionalCollateral = BigInt((yield getExpected(this.market.addresses.borrowed_token, this.market.addresses.collateral_token, _maxBorrowable + _userBorrowed, this.market.addresses.amm)).outAmount);
+                pAvgBN = maxBorrowableBN.plus(userBorrowed).div(toBN(_maxAdditionalCollateral, this.market.collateral_token.decimals));
+                _maxLeverageCollateral = _maxAdditionalCollateral - fromBN(BN(userBorrowed).div(pAvgBN), this.market.collateral_token.decimals);
+            }
+            const userEffectiveCollateralBN = maxBorrowableBN.gt(0) ? toBN(_userEffectiveCollateral, this.market.collateral_token.decimals) : BN(0);
+            const maxLeverageCollateralBN = toBN(_maxLeverageCollateral, this.market.collateral_token.decimals);
+            return {
+                maxDebt: formatNumber(maxBorrowableBN.toString(), this.market.borrowed_token.decimals),
+                maxTotalCollateral: formatNumber(maxLeverageCollateralBN.plus(userEffectiveCollateralBN).toString(), this.market.collateral_token.decimals),
+                userCollateral: formatNumber(userCollateral, this.market.collateral_token.decimals),
+                collateralFromUserBorrowed: formatNumber(BN(userBorrowed).div(pAvgBN).toString(), this.market.collateral_token.decimals),
+                collateralFromMaxDebt: formatNumber(maxLeverageCollateralBN.toString(), this.market.collateral_token.decimals),
+                maxLeverage: maxLeverageCollateralBN.plus(userEffectiveCollateralBN).div(userEffectiveCollateralBN).toString(),
+                avgPrice: pAvgBN.toString(),
+            };
+        });
+    }
+    leverageCreateLoanExpectedCollateral(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, debt, quote }) {
+            this._checkLeverageZap();
+            const { _totalCollateral, _userCollateral, _collateralFromUserBorrowed, _collateralFromDebt, avgPrice } = yield this._leverageExpectedCollateral(userCollateral, userBorrowed, debt, quote);
+            return {
+                totalCollateral: formatUnits(_totalCollateral, this.market.collateral_token.decimals),
+                userCollateral: formatUnits(_userCollateral, this.market.collateral_token.decimals),
+                collateralFromUserBorrowed: formatUnits(_collateralFromUserBorrowed, this.market.collateral_token.decimals),
+                collateralFromDebt: formatUnits(_collateralFromDebt, this.market.collateral_token.decimals),
+                leverage: toBN(_collateralFromDebt + _userCollateral + _collateralFromUserBorrowed, this.market.collateral_token.decimals)
+                    .div(toBN(_userCollateral + _collateralFromUserBorrowed, this.market.collateral_token.decimals)).toString(),
+                avgPrice,
+            };
+        });
+    }
+    leverageCreateLoanExpectedMetrics(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, debt, range, quote, healthIsFull = true }) {
+            this._checkLeverageZap();
+            const [_n2, _n1] = yield this._leverageBands(userCollateral, userBorrowed, debt, range, quote);
+            const prices = yield this.market._getPrices(_n2, _n1);
+            const health = yield this._leverageHealth(userCollateral, userBorrowed, debt, range, quote, healthIsFull);
+            return {
+                priceImpact: quote.priceImpact,
+                bands: [Number(_n2), Number(_n1)],
+                prices,
+                health,
+            };
+        });
+    }
+    leverageCreateLoanMaxRange(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, debt, getExpected }) {
+            this._checkLeverageZap();
+            const maxRecv = yield this.leverageCreateLoanMaxRecvAllRanges({ userCollateral, userBorrowed, getExpected });
+            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, quote, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _n1 = yield this._leverageCalcN1(userCollateral, userBorrowed, debt, range, quote, user);
+            if (range < 0) {
+                const { N } = yield this.market.userState(user);
+                range = Number(N);
+            }
+            const _n2 = _n1 + BigInt(range - 1);
+            return [_n2, _n1];
+        });
+    }
+    _leverageCreateLoanBandsAllRanges(userCollateral, userBorrowed, debt, getExpected, quote) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const maxN = yield this.leverageCreateLoanMaxRange({ userCollateral, userBorrowed, debt, getExpected });
+            const _n1_arr = yield this._leverageCalcN1AllRanges(userCollateral, userBorrowed, debt, maxN, quote);
+            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;
+        });
+    }
+    leverageCreateLoanBandsAllRanges(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, debt, getExpected, quote }) {
+            this._checkLeverageZap();
+            const _bands = yield this._leverageCreateLoanBandsAllRanges(userCollateral, userBorrowed, debt, getExpected, quote);
+            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;
+        });
+    }
+    leverageCreateLoanPricesAllRanges(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, debt, getExpected, quote }) {
+            this._checkLeverageZap();
+            const _bands = yield this._leverageCreateLoanBandsAllRanges(userCollateral, userBorrowed, debt, getExpected, quote);
+            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, quote_1, full_1) {
+        return __awaiter(this, arguments, void 0, function* (userCollateral, userBorrowed, dDebt, range, quote, full, user = this.llamalend.constants.ZERO_ADDRESS) {
+            if (range > 0)
+                this.market._checkRange(range);
+            const { _totalCollateral } = yield this._leverageExpectedCollateral(userCollateral, userBorrowed, dDebt, quote, user);
+            const { _borrowed, _N } = yield this.market._userState(user);
+            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.borrowed_token.decimals);
+            const contract = this.llamalend.contracts[this.market.addresses.controller].contract;
+            let _health = yield contract.health_calculator(user, _totalCollateral, _dDebt, full, range, this.llamalend.constantOptions);
+            _health = _health * BigInt(100);
+            return formatUnits(_health);
+        });
+    }
+    leverageCreateLoanIsApproved(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed }) {
+            this._checkLeverageZap();
+            const collateralAllowance = yield hasAllowance.call(this.llamalend, [this.market.collateral_token.address], [userCollateral], this.llamalend.signerAddress, this.market.addresses.controller);
+            const borrowedAllowance = yield hasAllowance.call(this.llamalend, [this.market.borrowed_token.address], [userBorrowed], this.llamalend.signerAddress, this.llamalend.constants.ALIASES.leverage_zap_v2);
+            return collateralAllowance && borrowedAllowance;
+        });
+    }
+    leverageCreateLoanApproveEstimateGas(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed }) {
+            this._checkLeverageZap();
+            const collateralGas = yield ensureAllowanceEstimateGas.call(this.llamalend, [this.market.collateral_token.address], [userCollateral], this.market.addresses.controller);
+            const borrowedGas = yield ensureAllowanceEstimateGas.call(this.llamalend, [this.market.borrowed_token.address], [userBorrowed], this.llamalend.constants.ALIASES.leverage_zap_v2);
+            if (Array.isArray(collateralGas) && Array.isArray(borrowedGas)) {
+                return [collateralGas[0] + borrowedGas[0], collateralGas[1] + borrowedGas[1]];
+            }
+            else {
+                return collateralGas + borrowedGas;
+            }
+        });
+    }
+    leverageCreateLoanApprove(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed }) {
+            this._checkLeverageZap();
+            const collateralApproveTx = yield ensureAllowance.call(this.llamalend, [this.market.collateral_token.address], [userCollateral], this.market.addresses.controller);
+            const borrowedApproveTx = yield ensureAllowance.call(this.llamalend, [this.market.borrowed_token.address], [userBorrowed], this.llamalend.constants.ALIASES.leverage_zap_v2);
+            return [...collateralApproveTx, ...borrowedApproveTx];
+        });
+    }
+    _leverageCreateLoan(userCollateral, userBorrowed, debt, range, router, calldata, estimateGas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.market.userLoanExists())
+                throw Error("Loan already created");
+            this.market._checkRange(range);
+            const _userCollateral = parseUnits(userCollateral, this.market.collateral_token.decimals);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.borrowed_token.decimals);
+            const _debt = parseUnits(debt, this.market.borrowed_token.decimals);
+            const zapCalldata = buildCalldataForLeverageZapV2(router, calldata);
+            const contract = this.llamalend.contracts[this.market.addresses.controller].contract;
+            const gas = yield contract.create_loan_extended.estimateGas(_userCollateral, _debt, range, this.llamalend.constants.ALIASES.leverage_zap_v2, [0, parseUnits(this._getMarketId(), 0), _userBorrowed], zapCalldata, 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_v2, [0, parseUnits(this._getMarketId(), 0), _userBorrowed], zapCalldata, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    leverageCreateLoanEstimateGas(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, debt, range, router, calldata }) {
+            this._checkLeverageZap();
+            if (!(yield this.leverageCreateLoanIsApproved({ userCollateral, userBorrowed })))
+                throw Error("Approval is needed for gas estimation");
+            return yield this._leverageCreateLoan(userCollateral, userBorrowed, debt, range, router, calldata, true);
+        });
+    }
+    leverageCreateLoan(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, debt, range, router, calldata }) {
+            this._checkLeverageZap();
+            yield this.leverageCreateLoanApprove({ userCollateral, userBorrowed });
+            return yield this._leverageCreateLoan(userCollateral, userBorrowed, debt, range, router, calldata, false);
+        });
+    }
+    // ---------------- LEVERAGE BORROW MORE ----------------
+    leverageBorrowMoreMaxRecv(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, getExpected, address = "" }) {
+            // max_borrowable = userCollateral / (1 / (k_effective * max_p_base) - 1 / p_avg)
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            const { _collateral: _stateCollateral, _borrowed: _stateBorrowed, _debt: _stateDebt, _N } = yield this.market._userState(address);
+            if (_stateBorrowed > BigInt(0))
+                throw Error(`User ${address} is already in liquidation mode`);
+            const _userCollateral = parseUnits(userCollateral, this.market.collateral_token.decimals);
+            const controllerContract = this.llamalend.contracts[this.market.addresses.controller].contract;
+            const _borrowedFromStateCollateral = (yield controllerContract.max_borrowable(_stateCollateral, _N, _stateDebt, this.llamalend.constantOptions)) - _stateDebt;
+            const _userBorrowed = _borrowedFromStateCollateral + parseUnits(userBorrowed, this.market.borrowed_token.decimals);
+            userBorrowed = formatUnits(_userBorrowed, this.market.borrowed_token.decimals);
+            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_v2].contract;
+            for (let i = 0; i < 5; i++) {
+                maxBorrowablePrevBN = maxBorrowableBN;
+                _userEffectiveCollateral = _userCollateral + fromBN(BN(userBorrowed).div(pAvgBN), this.market.collateral_token.decimals);
+                let _maxBorrowable = yield contract.max_borrowable(this.market.addresses.controller, _userEffectiveCollateral, _maxLeverageCollateral, _N, fromBN(pAvgBN));
+                _maxBorrowable = _maxBorrowable * BigInt(998) / BigInt(1000);
+                if (_maxBorrowable === BigInt(0))
+                    break;
+                maxBorrowableBN = toBN(_maxBorrowable, this.market.borrowed_token.decimals);
+                if (maxBorrowableBN.minus(maxBorrowablePrevBN).abs().div(maxBorrowablePrevBN).lt(0.0005)) {
+                    maxBorrowableBN = maxBorrowablePrevBN;
+                    break;
+                }
+                // additionalCollateral = (userBorrowed / p) + leverageCollateral
+                const _maxAdditionalCollateral = BigInt((yield getExpected(this.market.addresses.borrowed_token, this.market.addresses.collateral_token, _maxBorrowable + _userBorrowed, this.market.addresses.amm)).outAmount);
+                pAvgBN = maxBorrowableBN.plus(userBorrowed).div(toBN(_maxAdditionalCollateral, this.market.collateral_token.decimals));
+                _maxLeverageCollateral = _maxAdditionalCollateral - fromBN(BN(userBorrowed).div(pAvgBN), this.market.collateral_token.decimals);
+            }
+            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.borrowed_token.decimals),
+                maxTotalCollateral: formatUnits(_maxTotalCollateral, this.market.collateral_token.decimals),
+                userCollateral: formatNumber(userCollateral, this.market.collateral_token.decimals),
+                collateralFromUserBorrowed: formatNumber(BN(userBorrowed).div(pAvgBN).toString(), this.market.collateral_token.decimals),
+                collateralFromMaxDebt: formatUnits(_maxLeverageCollateral, this.market.collateral_token.decimals),
+                avgPrice: pAvgBN.toString(),
+            };
+        });
+    }
+    leverageBorrowMoreExpectedCollateral(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, dDebt, quote, address = "" }) {
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            const { _totalCollateral, _userCollateral, _collateralFromUserBorrowed, _collateralFromDebt, avgPrice } = yield this._leverageExpectedCollateral(userCollateral, userBorrowed, dDebt, quote, address);
+            return {
+                totalCollateral: formatUnits(_totalCollateral, this.market.collateral_token.decimals),
+                userCollateral: formatUnits(_userCollateral, this.market.collateral_token.decimals),
+                collateralFromUserBorrowed: formatUnits(_collateralFromUserBorrowed, this.market.collateral_token.decimals),
+                collateralFromDebt: formatUnits(_collateralFromDebt, this.market.collateral_token.decimals),
+                avgPrice,
+            };
+        });
+    }
+    leverageBorrowMoreExpectedMetrics(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, debt, quote, healthIsFull = true, address = "" }) {
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            const [_n2, _n1] = yield this._leverageBands(userCollateral, userBorrowed, debt, -1, quote, address);
+            const prices = yield this.market._getPrices(_n2, _n1);
+            const health = yield this._leverageHealth(userCollateral, userBorrowed, debt, -1, quote, healthIsFull, address);
+            return {
+                priceImpact: quote.priceImpact,
+                bands: [Number(_n2), Number(_n1)],
+                prices,
+                health,
+            };
+        });
+    }
+    _leverageBorrowMore(userCollateral, userBorrowed, debt, router, calldata, estimateGas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.market.userLoanExists()))
+                throw Error("Loan does not exist");
+            const _userCollateral = parseUnits(userCollateral, this.market.collateral_token.decimals);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.borrowed_token.decimals);
+            const _debt = parseUnits(debt, this.market.borrowed_token.decimals);
+            const zapCalldata = buildCalldataForLeverageZapV2(router, calldata);
+            const contract = this.llamalend.contracts[this.market.addresses.controller].contract;
+            const gas = yield contract.borrow_more_extended.estimateGas(_userCollateral, _debt, this.llamalend.constants.ALIASES.leverage_zap_v2, [0, parseUnits(this._getMarketId(), 0), _userBorrowed], zapCalldata, 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_v2, [0, parseUnits(this._getMarketId(), 0), _userBorrowed], zapCalldata, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    leverageBorrowMoreIsApproved(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed }) {
+            return yield this.leverageCreateLoanIsApproved({ userCollateral, userBorrowed });
+        });
+    }
+    leverageBorrowMoreApprove(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed }) {
+            return yield this.leverageCreateLoanApprove({ userCollateral, userBorrowed });
+        });
+    }
+    leverageBorrowMoreEstimateGas(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, debt, router, calldata }) {
+            this._checkLeverageZap();
+            if (!(yield this.leverageCreateLoanIsApproved({ userCollateral, userBorrowed })))
+                throw Error("Approval is needed for gas estimation");
+            return yield this._leverageBorrowMore(userCollateral, userBorrowed, debt, router, calldata, true);
+        });
+    }
+    leverageBorrowMore(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed, debt, router, calldata }) {
+            this._checkLeverageZap();
+            yield this.leverageCreateLoanApprove({ userCollateral, userBorrowed });
+            return yield this._leverageBorrowMore(userCollateral, userBorrowed, debt, router, calldata, false);
+        });
+    }
+    leverageRepayIsFull(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ stateCollateral, userCollateral, userBorrowed, quote, address = "" }) {
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            const { _borrowed: _stateBorrowed, _debt } = yield this.market._userState(address);
+            const { _totalBorrowed } = this._leverageRepayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed, quote);
+            return _stateBorrowed + _totalBorrowed > _debt;
+        });
+    }
+    leverageRepayIsAvailable(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ stateCollateral, userCollateral, userBorrowed, quote, address = "" }) {
+            // 0. const { collateral, stablecoin, debt } = await this.market.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, 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, quote, address });
+            return true;
+        });
+    }
+    leverageRepayExpectedMetrics(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ stateCollateral, userCollateral, userBorrowed, healthIsFull, quote, address }) {
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            const [_n2, _n1] = yield this._leverageRepayBands(stateCollateral, userCollateral, userBorrowed, quote, address);
+            const prices = yield this.market._getPrices(_n2, _n1);
+            const health = yield this._leverageRepayHealth(stateCollateral, userCollateral, userBorrowed, quote, healthIsFull, address);
+            const _stateCollateral = parseUnits(stateCollateral, this.market.collateral_token.decimals);
+            const _userCollateral = parseUnits(userCollateral, this.market.collateral_token.decimals);
+            const priceImpact = _stateCollateral + _userCollateral > BigInt(0) ? quote.priceImpact : 0;
+            return {
+                priceImpact,
+                bands: [Number(_n2), Number(_n1)],
+                prices,
+                health,
+            };
+        });
+    }
+    _leverageRepayHealth(stateCollateral_1, userCollateral_1, userBorrowed_1, quote_1) {
+        return __awaiter(this, arguments, void 0, function* (stateCollateral, userCollateral, userBorrowed, quote, full = true, address = "") {
+            this._checkLeverageZap();
+            address = _getAddress.call(this.llamalend, address);
+            const { _borrowed: _stateBorrowed, _debt, _N } = yield this.market._userState(address);
+            if (_stateBorrowed > BigInt(0))
+                return "0.0";
+            if (!(yield this.leverageRepayIsAvailable({ stateCollateral, userCollateral, userBorrowed, quote, address })))
+                return "0.0";
+            const { _totalBorrowed } = this._leverageRepayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed, quote);
+            const _dCollateral = parseUnits(stateCollateral, this.market.collateral_token.decimals) * BigInt(-1);
+            const _dDebt = _totalBorrowed * BigInt(-1);
+            if (_debt + _dDebt <= BigInt(0))
+                return "0.0";
+            const contract = this.llamalend.contracts[this.market.addresses.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(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed }) {
+            this._checkLeverageZap();
+            return yield hasAllowance.call(this.llamalend, [this.market.collateral_token.address, this.market.borrowed_token.address], [userCollateral, userBorrowed], this.llamalend.signerAddress, this.llamalend.constants.ALIASES.leverage_zap_v2);
+        });
+    }
+    leverageRepayApproveEstimateGas(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed }) {
+            this._checkLeverageZap();
+            return yield ensureAllowanceEstimateGas.call(this.llamalend, [this.market.collateral_token.address, this.market.borrowed_token.address], [userCollateral, userBorrowed], this.llamalend.constants.ALIASES.leverage_zap_v2);
+        });
+    }
+    leverageRepayApprove(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ userCollateral, userBorrowed }) {
+            this._checkLeverageZap();
+            return yield ensureAllowance.call(this.llamalend, [this.market.collateral_token.address, this.market.borrowed_token.address], [userCollateral, userBorrowed], this.llamalend.constants.ALIASES.leverage_zap_v2);
+        });
+    }
+    _leverageRepay(stateCollateral, userCollateral, userBorrowed, router, calldata, estimateGas) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!(yield this.market.userLoanExists()))
+                throw Error("Loan does not exist");
+            const _stateCollateral = parseUnits(stateCollateral, this.market.collateral_token.decimals);
+            const _userCollateral = parseUnits(userCollateral, this.market.collateral_token.decimals);
+            const _userBorrowed = parseUnits(userBorrowed, this.market.borrowed_token.decimals);
+            let zapCalldata = buildCalldataForLeverageZapV2(router, "0x");
+            if (_stateCollateral + _userCollateral > BigInt(0)) {
+                zapCalldata = buildCalldataForLeverageZapV2(router, calldata);
+            }
+            const contract = this.llamalend.contracts[this.market.addresses.controller].contract;
+            const gas = yield contract.repay_extended.estimateGas(this.llamalend.constants.ALIASES.leverage_zap_v2, [0, parseUnits(this._getMarketId(), 0), _userCollateral, _userBorrowed], zapCalldata);
+            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_v2, [0, parseUnits(this._getMarketId(), 0), _userCollateral, _userBorrowed], zapCalldata, Object.assign(Object.assign({}, this.llamalend.options), { gasLimit }))).hash;
+        });
+    }
+    leverageRepayEstimateGas(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ stateCollateral, userCollateral, userBorrowed, router, calldata }) {
+            this._checkLeverageZap();
+            if (!(yield this.leverageRepayIsApproved({ userCollateral, userBorrowed })))
+                throw Error("Approval is needed for gas estimation");
+            return yield this._leverageRepay(stateCollateral, userCollateral, userBorrowed, router, calldata, true);
+        });
+    }
+    leverageRepay(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ stateCollateral, userCollateral, userBorrowed, router, calldata }) {
+            this._checkLeverageZap();
+            yield this.leverageRepayApprove({ userCollateral, userBorrowed });
+            return yield this._leverageRepay(stateCollateral, userCollateral, userBorrowed, router, calldata, false);
+        });
+    }
+}