@curvefi/llamalend-api 1.0.2

package/lib/lendMarkets/LendMarketTemplate.js

@@ -0,0 +1,4682 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import memoize from "memoizee";
+import BigNumber from "bignumber.js";
+import { llamalend } from "../llamalend.js";
+import { _getAddress, parseUnits, BN, toBN, fromBN, getBalances, _ensureAllowance, ensureAllowance, hasAllowance, ensureAllowanceEstimateGas, _cutZeros, formatUnits, formatNumber, MAX_ALLOWANCE, MAX_ACTIVE_BAND, _mulBy1_3, _getUsdRate, DIGas, smartNumber, } from "../utils.js";
+import { _getExpectedOdos, _getQuoteOdos, _assembleTxOdos, _getUserCollateral, _getMarketsData } from "../external-api.js";
+import ERC20Abi from '../constants/abis/ERC20.json' assert { type: 'json' };
+import { cacheKey, cacheStats } from "../cache/index.js";
+var DAY = 86400;
+var WEEK = 7 * DAY;
+var LendMarketTemplate = /** @class */ (function () {
+    function LendMarketTemplate(id, marketData) {
+        var _this = this;
+        this.swapDataCache = {};
+        this._getMarketId = function () { return Number(_this.id.split("-").slice(-1)[0]); };
+        this._calcCrvApr = function (futureWorkingSupplyBN) {
+            if (futureWorkingSupplyBN === void 0) { futureWorkingSupplyBN = null; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var totalLiquidityUSD, inflationRateBN, workingSupplyBN, totalSupplyBN, gaugeContract, lpTokenContract, crvContract, currentWeek, _a, gaugeContract, lpTokenContract, gaugeControllerContract, weightBN, rateBN, crvPrice, baseApyBN, boostedApyBN;
+                var _c, _d;
+                return __generator(this, function (_e) {
+                    switch (_e.label) {
+                        case 0: return [4 /*yield*/, this.vaultTotalLiquidity()];
+                        case 1:
+                            totalLiquidityUSD = _e.sent();
+                            if (Number(totalLiquidityUSD) === 0)
+                                return [2 /*return*/, [0, 0]];
+                            if (!(llamalend.chainId !== 1)) return [3 /*break*/, 5];
+                            gaugeContract = llamalend.contracts[this.addresses.gauge].multicallContract;
+                            lpTokenContract = llamalend.contracts[this.addresses.vault].multicallContract;
+                            crvContract = llamalend.contracts[llamalend.constants.ALIASES.crv].contract;
+                            currentWeek = Math.floor(Date.now() / 1000 / WEEK);
+                            return [4 /*yield*/, llamalend.multicallProvider.all([
+                                    gaugeContract.inflation_rate(currentWeek),
+                                    gaugeContract.working_supply(),
+                                    lpTokenContract.totalSupply(),
+                                ])];
+                        case 2:
+                            _c = (_e.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _c[0], workingSupplyBN = _c[1], totalSupplyBN = _c[2];
+                            if (!inflationRateBN.eq(0)) return [3 /*break*/, 4];
+                            _a = toBN;
+                            return [4 /*yield*/, crvContract.balanceOf(this.addresses.gauge, llamalend.constantOptions)];
+                        case 3:
+                            inflationRateBN = _a.apply(void 0, [_e.sent()]).div(WEEK);
+                            _e.label = 4;
+                        case 4: return [3 /*break*/, 7];
+                        case 5:
+                            gaugeContract = llamalend.contracts[this.addresses.gauge].multicallContract;
+                            lpTokenContract = llamalend.contracts[this.addresses.vault].multicallContract;
+                            gaugeControllerContract = llamalend.contracts[llamalend.constants.ALIASES.gauge_controller].multicallContract;
+                            weightBN = void 0;
+                            return [4 /*yield*/, llamalend.multicallProvider.all([
+                                    gaugeContract.inflation_rate(),
+                                    gaugeControllerContract.gauge_relative_weight(this.addresses.gauge),
+                                    gaugeContract.working_supply(),
+                                    lpTokenContract.totalSupply(),
+                                ])];
+                        case 6:
+                            _d = (_e.sent()).map(function (value) { return toBN(value); }), inflationRateBN = _d[0], weightBN = _d[1], workingSupplyBN = _d[2], totalSupplyBN = _d[3];
+                            inflationRateBN = inflationRateBN.times(weightBN);
+                            _e.label = 7;
+                        case 7:
+                            if (inflationRateBN.eq(0))
+                                return [2 /*return*/, [0, 0]];
+                            if (futureWorkingSupplyBN !== null)
+                                workingSupplyBN = futureWorkingSupplyBN;
+                            rateBN = inflationRateBN.times(31536000).div(workingSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD)).times(0.4);
+                            return [4 /*yield*/, _getUsdRate(llamalend.constants.ALIASES.crv)];
+                        case 8:
+                            crvPrice = _e.sent();
+                            baseApyBN = rateBN.times(crvPrice);
+                            boostedApyBN = baseApyBN.times(2.5);
+                            return [2 /*return*/, [baseApyBN.times(100).toNumber(), boostedApyBN.times(100).toNumber()]];
+                    }
+                });
+            });
+        };
+        this.vaultRewardTokens = memoize(function (useApi) {
+            if (useApi === void 0) { useApi = true; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var gaugeContract, gaugeMulticallContract, rewardCount, _a, _c, _d, tokenCalls, i, tokens, tokenInfoCalls, _e, tokens_1, token, tokenMulticallContract, tokenInfo, i;
+                return __generator(this, function (_f) {
+                    switch (_f.label) {
+                        case 0:
+                            if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS)
+                                return [2 /*return*/, []
+                                    // if (useApi) {
+                                    //     const rewards = await _getRewardsFromApi();
+                                    //     if (!rewards[this.addresses.gauge]) return [];
+                                    //     rewards[this.addresses.gauge].forEach((r) => _setContracts(r.tokenAddress, ERC20Abi));
+                                    //     return rewards[this.addresses.gauge].map((r) => ({ token: r.tokenAddress, symbol: r.symbol, decimals: Number(r.decimals) }));
+                                    // }
+                                ];
+                            gaugeContract = llamalend.contracts[this.addresses.gauge].contract;
+                            gaugeMulticallContract = llamalend.contracts[this.addresses.gauge].multicallContract;
+                            _a = Number;
+                            _d = (_c = llamalend).formatUnits;
+                            return [4 /*yield*/, gaugeContract.reward_count(llamalend.constantOptions)];
+                        case 1:
+                            rewardCount = _a.apply(void 0, [_d.apply(_c, [_f.sent(), 0])]);
+                            tokenCalls = [];
+                            for (i = 0; i < rewardCount; i++) {
+                                tokenCalls.push(gaugeMulticallContract.reward_tokens(i));
+                            }
+                            return [4 /*yield*/, llamalend.multicallProvider.all(tokenCalls)];
+                        case 2:
+                            tokens = (_f.sent())
+                                .filter(function (addr) { return addr !== llamalend.constants.ZERO_ADDRESS; })
+                                .map(function (addr) { return addr.toLowerCase(); })
+                                .filter(function (addr) { return llamalend.chainId === 1 || addr !== llamalend.constants.COINS.crv; });
+                            tokenInfoCalls = [];
+                            for (_e = 0, tokens_1 = tokens; _e < tokens_1.length; _e++) {
+                                token = tokens_1[_e];
+                                llamalend.setContract(token, ERC20Abi);
+                                tokenMulticallContract = llamalend.contracts[token].multicallContract;
+                                tokenInfoCalls.push(tokenMulticallContract.symbol(), tokenMulticallContract.decimals());
+                            }
+                            return [4 /*yield*/, llamalend.multicallProvider.all(tokenInfoCalls)];
+                        case 3:
+                            tokenInfo = _f.sent();
+                            for (i = 0; i < tokens.length; i++) {
+                                llamalend.constants.DECIMALS[tokens[i]] = Number(tokenInfo[(i * 2) + 1]);
+                            }
+                            return [2 /*return*/, tokens.map(function (token, i) { return ({ token: token, symbol: tokenInfo[i * 2], decimals: Number(tokenInfo[(i * 2) + 1]) }); })];
+                    }
+                });
+            });
+        }, {
+            promise: true,
+            maxAge: 30 * 60 * 1000, // 30m
+        });
+        this.vaultRewardsApr = function (useApi) {
+            if (useApi === void 0) { useApi = true; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var response, market, apy, rewardTokens, _a, rewardTokens_1, rewardToken, gaugeContract, lpTokenContract, rewardContract, totalLiquidityUSD, rewardRate, _c, rewardData, _stakedSupply, _totalSupply, stakedSupplyBN, totalSupplyBN, inflationBN, periodFinish, baseApy;
+                var _this = this;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            if (!useApi) return [3 /*break*/, 2];
+                            return [4 /*yield*/, _getMarketsData(llamalend.constants.NETWORK_NAME)];
+                        case 1:
+                            response = _d.sent();
+                            market = response.lendingVaultData.find(function (item) { return item.address.toLowerCase() === _this.addresses.vault.toLowerCase(); });
+                            if (market) {
+                                return [2 /*return*/, market.gaugeRewards];
+                            }
+                            else {
+                                throw new Error('Market not found in API');
+                            }
+                            return [3 /*break*/, 10];
+                        case 2:
+                            if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS)
+                                return [2 /*return*/, []];
+                            apy = [];
+                            return [4 /*yield*/, this.vaultRewardTokens(false)];
+                        case 3:
+                            rewardTokens = _d.sent();
+                            _a = 0, rewardTokens_1 = rewardTokens;
+                            _d.label = 4;
+                        case 4:
+                            if (!(_a < rewardTokens_1.length)) return [3 /*break*/, 9];
+                            rewardToken = rewardTokens_1[_a];
+                            gaugeContract = llamalend.contracts[this.addresses.gauge].multicallContract;
+                            lpTokenContract = llamalend.contracts[this.addresses.vault].multicallContract;
+                            rewardContract = llamalend.contracts[this.addresses.gauge].multicallContract;
+                            return [4 /*yield*/, this.vaultTotalLiquidity()];
+                        case 5:
+                            totalLiquidityUSD = _d.sent();
+                            return [4 /*yield*/, _getUsdRate(rewardToken.token)];
+                        case 6:
+                            rewardRate = _d.sent();
+                            return [4 /*yield*/, llamalend.multicallProvider.all([
+                                    rewardContract.reward_data(rewardToken.token),
+                                    gaugeContract.totalSupply(),
+                                    lpTokenContract.totalSupply(),
+                                ])];
+                        case 7:
+                            _c = _d.sent(), rewardData = _c[0], _stakedSupply = _c[1], _totalSupply = _c[2];
+                            stakedSupplyBN = toBN(_stakedSupply);
+                            totalSupplyBN = toBN(_totalSupply);
+                            inflationBN = toBN(rewardData.rate, rewardToken.decimals);
+                            periodFinish = Number(llamalend.formatUnits(rewardData.period_finish, 0)) * 1000;
+                            baseApy = periodFinish > Date.now() ?
+                                inflationBN.times(31536000).times(rewardRate).div(stakedSupplyBN).times(totalSupplyBN).div(Number(totalLiquidityUSD)) :
+                                BN(0);
+                            apy.push({
+                                gaugeAddress: this.addresses.gauge,
+                                tokenAddress: rewardToken.token,
+                                symbol: rewardToken.symbol,
+                                apy: baseApy.times(100).toNumber(),
+                            });
+                            _d.label = 8;
+                        case 8:
+                            _a++;
+                            return [3 /*break*/, 4];
+                        case 9: return [2 /*return*/, apy];
+                        case 10: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        // ---------------- STATS ----------------
+        this.statsParameters = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var llammaContract, controllerContract, calls, _a, _fee, _admin_fee, _liquidation_discount, _loan_discount, _base_price, _A, A, base_price, _c, fee, admin_fee, liquidation_discount, loan_discount;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        llammaContract = llamalend.contracts[this.addresses.amm].multicallContract;
+                        controllerContract = llamalend.contracts[this.addresses.controller].multicallContract;
+                        calls = [
+                            llammaContract.fee(),
+                            llammaContract.admin_fee(),
+                            controllerContract.liquidation_discount(),
+                            controllerContract.loan_discount(),
+                            llammaContract.get_base_price(),
+                            llammaContract.A(),
+                        ];
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _a = _d.sent(), _fee = _a[0], _admin_fee = _a[1], _liquidation_discount = _a[2], _loan_discount = _a[3], _base_price = _a[4], _A = _a[5];
+                        A = formatUnits(_A, 0);
+                        base_price = formatUnits(_base_price);
+                        _c = [_fee, _admin_fee, _liquidation_discount, _loan_discount]
+                            .map(function (_x) { return formatUnits(_x * BigInt(100)); }), fee = _c[0], admin_fee = _c[1], liquidation_discount = _c[2], loan_discount = _c[3];
+                        return [2 /*return*/, { fee: fee, admin_fee: admin_fee, liquidation_discount: liquidation_discount, loan_discount: loan_discount, base_price: base_price, A: A }];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        this._getRate = function (isGetter) {
+            if (isGetter === void 0) { isGetter = true; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var _rate;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!isGetter) return [3 /*break*/, 1];
+                            _rate = cacheStats.get(cacheKey(this.addresses.amm, 'rate'));
+                            return [3 /*break*/, 3];
+                        case 1: return [4 /*yield*/, llamalend.contracts[this.addresses.amm].contract.rate(llamalend.constantOptions)];
+                        case 2:
+                            _rate = _a.sent();
+                            cacheStats.set(cacheKey(this.addresses.controller, 'rate'), _rate);
+                            _a.label = 3;
+                        case 3: return [2 /*return*/, _rate];
+                    }
+                });
+            });
+        };
+        this._getFutureRate = function (_dReserves, _dDebt) { return __awaiter(_this, void 0, void 0, function () {
+            var mpContract;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        mpContract = llamalend.contracts[this.addresses.monetary_policy].contract;
+                        return [4 /*yield*/, mpContract.future_rate(this.addresses.controller, _dReserves, _dDebt)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.statsBandsInfo = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var ammContract, calls, _a, activeBand, maxBand, minBand, _c, borrowed, collateral, liquidationBand;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        ammContract = llamalend.contracts[this.addresses.amm].multicallContract;
+                        calls = [
+                            ammContract.active_band(),
+                            ammContract.max_band(),
+                            ammContract.min_band(),
+                        ];
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _a = (_d.sent()).map(function (_b) { return Number(_b); }), activeBand = _a[0], maxBand = _a[1], minBand = _a[2];
+                        return [4 /*yield*/, this.statsBandBalances(activeBand)];
+                    case 2:
+                        _c = _d.sent(), borrowed = _c.borrowed, collateral = _c.collateral;
+                        liquidationBand = null;
+                        if (Number(borrowed) > 0 && Number(collateral) > 0)
+                            liquidationBand = activeBand;
+                        return [2 /*return*/, { activeBand: activeBand, maxBand: maxBand, minBand: minBand, liquidationBand: liquidationBand }];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this.statsAmmBalances = function (isGetter, useAPI) {
+            if (isGetter === void 0) { isGetter = true; }
+            if (useAPI === void 0) { useAPI = false; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var response, market, borrowedContract, collateralContract, ammContract, _balance_x, _fee_x, _balance_y, _fee_y;
+                var _a, _c;
+                var _this = this;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            if (!useAPI) return [3 /*break*/, 2];
+                            return [4 /*yield*/, _getMarketsData(llamalend.constants.NETWORK_NAME)];
+                        case 1:
+                            response = _d.sent();
+                            market = response.lendingVaultData.find(function (item) { return item.address.toLowerCase() === _this.addresses.vault.toLowerCase(); });
+                            if (market) {
+                                return [2 /*return*/, {
+                                        borrowed: market.ammBalances.ammBalanceBorrowed.toString(),
+                                        collateral: market.ammBalances.ammBalanceCollateral.toString(),
+                                    }];
+                            }
+                            else {
+                                throw new Error('Market not found in API');
+                            }
+                            return [3 /*break*/, 6];
+                        case 2:
+                            borrowedContract = llamalend.contracts[this.addresses.borrowed_token].multicallContract;
+                            collateralContract = llamalend.contracts[this.addresses.collateral_token].multicallContract;
+                            ammContract = llamalend.contracts[this.addresses.amm].multicallContract;
+                            _balance_x = void 0, _fee_x = void 0, _balance_y = void 0, _fee_y = void 0;
+                            if (!isGetter) return [3 /*break*/, 3];
+                            _a = [
+                                cacheStats.get(cacheKey(this.addresses.borrowed_token, 'balanceOf', this.addresses.amm)),
+                                cacheStats.get(cacheKey(this.addresses.amm, 'admin_fees_x')),
+                                cacheStats.get(cacheKey(this.addresses.collateral_token, 'balanceOf', this.addresses.amm)),
+                                cacheStats.get(cacheKey(this.addresses.amm, 'admin_fees_y')),
+                            ], _balance_x = _a[0], _fee_x = _a[1], _balance_y = _a[2], _fee_y = _a[3];
+                            return [3 /*break*/, 5];
+                        case 3: return [4 /*yield*/, llamalend.multicallProvider.all([
+                                borrowedContract.balanceOf(this.addresses.amm),
+                                ammContract.admin_fees_x(),
+                                collateralContract.balanceOf(this.addresses.amm),
+                                ammContract.admin_fees_y(),
+                            ])];
+                        case 4:
+                            _c = _d.sent(), _balance_x = _c[0], _fee_x = _c[1], _balance_y = _c[2], _fee_y = _c[3];
+                            cacheStats.set(cacheKey(this.addresses.borrowed_token, 'balanceOf', this.addresses.amm), _balance_x);
+                            cacheStats.set(cacheKey(this.addresses.amm, 'admin_fees_x'), _fee_x);
+                            cacheStats.set(cacheKey(this.addresses.collateral_token, 'balanceOf', this.addresses.amm), _balance_y);
+                            cacheStats.set(cacheKey(this.addresses.amm, 'admin_fees_y'), _fee_y);
+                            _d.label = 5;
+                        case 5: return [2 /*return*/, {
+                                borrowed: toBN(_balance_x, this.borrowed_token.decimals).minus(toBN(_fee_x, this.borrowed_token.decimals)).toString(),
+                                collateral: toBN(_balance_y, this.collateral_token.decimals).minus(toBN(_fee_y, this.collateral_token.decimals)).toString(),
+                            }];
+                        case 6: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        // ---------------- PRICES ----------------
+        this.A = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var _A;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, llamalend.contracts[this.addresses.amm].contract.A(llamalend.constantOptions)];
+                    case 1:
+                        _A = _a.sent();
+                        return [2 /*return*/, formatUnits(_A, 0)];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 86400 * 1000, // 1d
+        });
+        this.basePrice = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var _price;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, llamalend.contracts[this.addresses.amm].contract.get_base_price(llamalend.constantOptions)];
+                    case 1:
+                        _price = _a.sent();
+                        return [2 /*return*/, formatUnits(_price)];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 86400 * 1000, // 1d
+        });
+        this.oraclePrice = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var _price;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, llamalend.contracts[this.addresses.amm].contract.price_oracle(llamalend.constantOptions)];
+                    case 1:
+                        _price = _a.sent();
+                        return [2 /*return*/, formatUnits(_price)];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this._userState = memoize(function (address) {
+            if (address === void 0) { address = ""; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var contract, _a, _collateral, _borrowed, _debt, _N;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            address = _getAddress(address);
+                            contract = llamalend.contracts[this.addresses.controller].contract;
+                            return [4 /*yield*/, contract.user_state(address, llamalend.constantOptions)];
+                        case 1:
+                            _a = _c.sent(), _collateral = _a[0], _borrowed = _a[1], _debt = _a[2], _N = _a[3];
+                            return [2 /*return*/, { _collateral: _collateral, _borrowed: _borrowed, _debt: _debt, _N: _N }];
+                    }
+                });
+            });
+        }, {
+            promise: true,
+            maxAge: 10 * 1000, // 10s
+        });
+        this.createLoanMaxRecvAllRanges = memoize(function (collateral) { return __awaiter(_this, void 0, void 0, function () {
+            var _collateral, calls, N, _amounts, res, N;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _collateral = parseUnits(collateral, this.collateral_token.decimals);
+                        calls = [];
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            calls.push(llamalend.contracts[this.addresses.controller].multicallContract.max_borrowable(_collateral, N, 0));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _amounts = _a.sent();
+                        res = {};
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            res[N] = formatUnits(_amounts[N - this.minBands], this.borrowed_token.decimals);
+                        }
+                        return [2 /*return*/, res];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        // ---------------- LEVERAGE CREATE LOAN ----------------
+        this.hasLeverage = function () {
+            return llamalend.constants.ALIASES.leverage_zap !== llamalend.constants.ZERO_ADDRESS &&
+                _this._getMarketId() >= Number(llamalend.constants.ALIASES["leverage_markets_start_id"]);
+        };
+        this.leverageCreateLoanMaxRecvAllRanges = memoize(function (userCollateral, userBorrowed) { return __awaiter(_this, void 0, void 0, function () {
+            var _userCollateral, contract, oraclePriceBand, pAvgApproxBN, _a, pAvgBN, arrLength, maxLeverageCollateralBN, _maxLeverageCollateral, maxBorrowablePrevBN, maxBorrowableBN, _maxBorrowable, i, pBN, _userEffectiveCollateral, calls, N, j, deltaBN, _y, _c, yBN, userEffectiveCollateralBN, res, N, j;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        _userCollateral = parseUnits(userCollateral, this.collateral_token.decimals);
+                        contract = llamalend.contracts[llamalend.constants.ALIASES.leverage_zap].multicallContract;
+                        return [4 /*yield*/, this.oraclePriceBand()];
+                    case 1:
+                        oraclePriceBand = _d.sent();
+                        _a = BN;
+                        return [4 /*yield*/, this.calcTickPrice(oraclePriceBand)];
+                    case 2:
+                        pAvgApproxBN = _a.apply(void 0, [_d.sent()]);
+                        pAvgBN = null;
+                        arrLength = this.maxBands - this.minBands + 1;
+                        maxLeverageCollateralBN = new Array(arrLength).fill(BN(0));
+                        _maxLeverageCollateral = new Array(arrLength).fill(BigInt(0));
+                        maxBorrowablePrevBN = new Array(arrLength).fill(BN(0));
+                        maxBorrowableBN = new Array(arrLength).fill(BN(0));
+                        _maxBorrowable = new Array(arrLength).fill(BigInt(0));
+                        i = 0;
+                        _d.label = 3;
+                    case 3:
+                        if (!(i < 5)) return [3 /*break*/, 8];
+                        pBN = pAvgBN !== null && pAvgBN !== void 0 ? pAvgBN : pAvgApproxBN;
+                        maxBorrowablePrevBN = maxBorrowableBN;
+                        _userEffectiveCollateral = _userCollateral + fromBN(BN(userBorrowed).div(pBN), this.collateral_token.decimals);
+                        calls = [];
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            j = N - this.minBands;
+                            calls.push(contract.max_borrowable(this.addresses.controller, _userEffectiveCollateral, _maxLeverageCollateral[j], N, fromBN(pBN)));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 4:
+                        _maxBorrowable = (_d.sent()).map(function (_mb) { return _mb * BigInt(998) / BigInt(1000); });
+                        maxBorrowableBN = _maxBorrowable.map(function (_mb) { return toBN(_mb, _this.borrowed_token.decimals); });
+                        deltaBN = maxBorrowableBN.map(function (mb, l) { return mb.minus(maxBorrowablePrevBN[l]).abs().div(mb); });
+                        if (BigNumber.max.apply(BigNumber, deltaBN).lt(0.0005)) {
+                            maxBorrowableBN = maxBorrowablePrevBN;
+                            return [3 /*break*/, 8];
+                        }
+                        if (!(pAvgBN === null)) return [3 /*break*/, 6];
+                        _c = BigInt;
+                        return [4 /*yield*/, _getExpectedOdos(this.addresses.borrowed_token, this.addresses.collateral_token, _maxBorrowable[0], this.addresses.amm)];
+                    case 5:
+                        _y = _c.apply(void 0, [_d.sent()]);
+                        yBN = toBN(_y, this.collateral_token.decimals);
+                        pAvgBN = maxBorrowableBN[0].div(yBN);
+                        _d.label = 6;
+                    case 6:
+                        maxLeverageCollateralBN = maxBorrowableBN.map(function (mb) { return mb.div(pAvgBN); });
+                        _maxLeverageCollateral = maxLeverageCollateralBN.map(function (mlc) { return fromBN(mlc, _this.collateral_token.decimals); });
+                        _d.label = 7;
+                    case 7:
+                        i++;
+                        return [3 /*break*/, 3];
+                    case 8:
+                        userEffectiveCollateralBN = BN(userCollateral).plus(BN(userBorrowed).div(pAvgBN));
+                        res = {};
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            j = N - this.minBands;
+                            res[N] = {
+                                maxDebt: formatNumber(maxBorrowableBN[j].toString(), this.borrowed_token.decimals),
+                                maxTotalCollateral: formatNumber(maxLeverageCollateralBN[j].plus(userEffectiveCollateralBN).toString(), this.collateral_token.decimals),
+                                userCollateral: formatNumber(userCollateral, this.collateral_token.decimals),
+                                collateralFromUserBorrowed: formatNumber(BN(userBorrowed).div(pAvgBN).toString(), this.collateral_token.decimals),
+                                collateralFromMaxDebt: formatNumber(maxLeverageCollateralBN[j].toString(), this.collateral_token.decimals),
+                                maxLeverage: maxLeverageCollateralBN[j].plus(userEffectiveCollateralBN).div(userEffectiveCollateralBN).toString(),
+                                avgPrice: pAvgBN.toString(),
+                            };
+                        }
+                        return [2 /*return*/, res];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this._setSwapDataToCache = function (inputCoinAddress, outputCoinAddress, _amount, slippage) { return __awaiter(_this, void 0, void 0, function () {
+            var swapData, key;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, _getQuoteOdos(inputCoinAddress, outputCoinAddress, _amount, this.addresses.amm, true, slippage)];
+                    case 1:
+                        swapData = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (!(swapData.pathId == null)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, _getQuoteOdos(inputCoinAddress, outputCoinAddress, _amount, this.addresses.amm, true, slippage)];
+                    case 3:
+                        swapData = _a.sent();
+                        return [3 /*break*/, 2];
+                    case 4:
+                        key = "".concat(inputCoinAddress, "-").concat(_amount);
+                        this.swapDataCache[key] = __assign(__assign({}, swapData), { slippage: slippage });
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        this._getSwapDataFromCache = function (inputCoinAddress, _amount) {
+            var key = "".concat(inputCoinAddress, "-").concat(_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 = function (userCollateral, userBorrowed, debt, user) { return __awaiter(_this, void 0, void 0, function () {
+            var _userCollateral, _debt, _userBorrowed, _additionalCollateral, _collateralFromDebt, _collateralFromUserBorrowed, _stateCollateral, _a, _collateral, _borrowed, _totalCollateral, _futureStateCollateral, avgPrice;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _userCollateral = parseUnits(userCollateral, this.collateral_token.decimals);
+                        _debt = parseUnits(debt, this.borrowed_token.decimals);
+                        _userBorrowed = parseUnits(userBorrowed, this.borrowed_token.decimals);
+                        _additionalCollateral = BigInt(this._getSwapDataFromCache(this.addresses.borrowed_token, _debt + _userBorrowed).outAmounts[0]);
+                        _collateralFromDebt = _debt * BigInt(Math.pow(10, 18)) / (_debt + _userBorrowed) * _additionalCollateral / BigInt(Math.pow(10, 18));
+                        _collateralFromUserBorrowed = _additionalCollateral - _collateralFromDebt;
+                        _stateCollateral = BigInt(0);
+                        if (!user) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._userState(user)];
+                    case 1:
+                        _a = _c.sent(), _collateral = _a._collateral, _borrowed = _a._borrowed;
+                        if (_borrowed > BigInt(0))
+                            throw Error("User ".concat(user, " is already in liquidation mode"));
+                        _stateCollateral = _collateral;
+                        _c.label = 2;
+                    case 2:
+                        _totalCollateral = _userCollateral + _additionalCollateral;
+                        _futureStateCollateral = _stateCollateral + _totalCollateral;
+                        avgPrice = toBN(_debt + _userBorrowed, this.borrowed_token.decimals).div(toBN(_additionalCollateral, this.collateral_token.decimals)).toString();
+                        return [2 /*return*/, { _futureStateCollateral: _futureStateCollateral, _totalCollateral: _totalCollateral, _userCollateral: _userCollateral, _collateralFromUserBorrowed: _collateralFromUserBorrowed, _collateralFromDebt: _collateralFromDebt, avgPrice: avgPrice }];
+                }
+            });
+        }); };
+        this._leverageCalcN1 = memoize(function (userCollateral, userBorrowed, debt, range, user) { return __awaiter(_this, void 0, void 0, function () {
+            var _stateDebt, _a, _debt_1, _borrowed, _N, _futureStateCollateral, _debt;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (range > 0)
+                            this._checkRange(range);
+                        _stateDebt = BigInt(0);
+                        if (!user) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._userState(user)];
+                    case 1:
+                        _a = _c.sent(), _debt_1 = _a._debt, _borrowed = _a._borrowed, _N = _a._N;
+                        if (_borrowed > BigInt(0))
+                            throw Error("User ".concat(user, " is already in liquidation mode"));
+                        _stateDebt = _debt_1;
+                        if (range < 0)
+                            range = Number(llamalend.formatUnits(_N, 0));
+                        _c.label = 2;
+                    case 2: return [4 /*yield*/, this._leverageExpectedCollateral(userCollateral, userBorrowed, debt, user)];
+                    case 3:
+                        _futureStateCollateral = (_c.sent())._futureStateCollateral;
+                        _debt = _stateDebt + parseUnits(debt, this.borrowed_token.decimals);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.controller].contract.calculate_debt_n1(_futureStateCollateral, _debt, range, llamalend.constantOptions)];
+                    case 4: return [2 /*return*/, _c.sent()];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this._leverageCalcN1AllRanges = memoize(function (userCollateral, userBorrowed, debt, maxN) { return __awaiter(_this, void 0, void 0, function () {
+            var _futureStateCollateral, _debt, calls, N;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._leverageExpectedCollateral(userCollateral, userBorrowed, debt)];
+                    case 1:
+                        _futureStateCollateral = (_a.sent())._futureStateCollateral;
+                        _debt = parseUnits(debt, this.borrowed_token.decimals);
+                        calls = [];
+                        for (N = this.minBands; N <= maxN; N++) {
+                            calls.push(llamalend.contracts[this.addresses.controller].multicallContract.calculate_debt_n1(_futureStateCollateral, _debt, N));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        // ---------------- LEVERAGE REPAY ----------------
+        this._leverageRepayExpectedBorrowed = function (stateCollateral, userCollateral, userBorrowed) {
+            _this._checkLeverageZap();
+            var _stateCollateral = parseUnits(stateCollateral, _this.collateral_token.decimals);
+            var _userCollateral = parseUnits(userCollateral, _this.collateral_token.decimals);
+            var _borrowedExpected = BigInt(0);
+            var _borrowedFromStateCollateral = BigInt(0);
+            var _borrowedFromUserCollateral = BigInt(0);
+            if (_stateCollateral + _userCollateral > BigInt(0)) {
+                _borrowedExpected = BigInt(_this._getSwapDataFromCache(_this.addresses.collateral_token, _stateCollateral + _userCollateral).outAmounts[0]);
+                _borrowedFromStateCollateral = _stateCollateral * BigInt(Math.pow(10, 18)) / (_stateCollateral + _userCollateral) * _borrowedExpected / BigInt(Math.pow(10, 18));
+                _borrowedFromUserCollateral = _borrowedExpected - _borrowedFromStateCollateral;
+            }
+            var _totalBorrowed = _borrowedExpected + parseUnits(userBorrowed, _this.borrowed_token.decimals);
+            var avgPrice = toBN(_borrowedExpected, _this.borrowed_token.decimals).div(toBN(_stateCollateral + _userCollateral, _this.collateral_token.decimals)).toString();
+            return { _totalBorrowed: _totalBorrowed, _borrowedFromStateCollateral: _borrowedFromStateCollateral, _borrowedFromUserCollateral: _borrowedFromUserCollateral, avgPrice: avgPrice };
+        };
+        this.leverageRepayExpectedBorrowed = function (stateCollateral, userCollateral, userBorrowed, slippage) {
+            if (slippage === void 0) { slippage = 0.1; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var _stateCollateral, _userCollateral, _a, _totalBorrowed, _borrowedFromStateCollateral, _borrowedFromUserCollateral, avgPrice;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            this._checkLeverageZap();
+                            _stateCollateral = parseUnits(stateCollateral, this.collateral_token.decimals);
+                            _userCollateral = parseUnits(userCollateral, this.collateral_token.decimals);
+                            if (!(_stateCollateral + _userCollateral > BigInt(0))) return [3 /*break*/, 2];
+                            return [4 /*yield*/, this._setSwapDataToCache(this.addresses.collateral_token, this.addresses.borrowed_token, _stateCollateral + _userCollateral, slippage)];
+                        case 1:
+                            _c.sent();
+                            _c.label = 2;
+                        case 2:
+                            _a = this._leverageRepayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed), _totalBorrowed = _a._totalBorrowed, _borrowedFromStateCollateral = _a._borrowedFromStateCollateral, _borrowedFromUserCollateral = _a._borrowedFromUserCollateral, avgPrice = _a.avgPrice;
+                            return [2 /*return*/, {
+                                    totalBorrowed: formatUnits(_totalBorrowed, this.borrowed_token.decimals),
+                                    borrowedFromStateCollateral: formatUnits(_borrowedFromStateCollateral, this.borrowed_token.decimals),
+                                    borrowedFromUserCollateral: formatUnits(_borrowedFromUserCollateral, this.borrowed_token.decimals),
+                                    userBorrowed: formatNumber(userBorrowed, this.borrowed_token.decimals),
+                                    avgPrice: avgPrice,
+                                }];
+                    }
+                });
+            });
+        };
+        this._leverageRepayBands = memoize(function (stateCollateral, userCollateral, userBorrowed, address) { return __awaiter(_this, void 0, void 0, function () {
+            var _stateRepayCollateral, _a, _stateCollateral, _stateDebt, _N, _n1, _n2, _repayExpected, e_1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this.leverageRepayIsAvailable(stateCollateral, userCollateral, userBorrowed, address)];
+                    case 1:
+                        if (!(_c.sent()))
+                            return [2 /*return*/, [parseUnits(0, 0), parseUnits(0, 0)]];
+                        _stateRepayCollateral = parseUnits(stateCollateral, this.collateral_token.decimals);
+                        return [4 /*yield*/, this._userState(address)];
+                    case 2:
+                        _a = _c.sent(), _stateCollateral = _a._collateral, _stateDebt = _a._debt, _N = _a._N;
+                        if (_stateDebt == BigInt(0))
+                            throw Error("Loan for ".concat(address, " does not exist"));
+                        if (_stateCollateral < _stateRepayCollateral)
+                            throw Error("Can't use more collateral than user's position has (".concat(_stateRepayCollateral, ") > ").concat(_stateCollateral, ")"));
+                        _n1 = parseUnits(0, 0);
+                        _n2 = parseUnits(0, 0);
+                        _repayExpected = this._leverageRepayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed)._totalBorrowed;
+                        _c.label = 3;
+                    case 3:
+                        _c.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.controller].contract.calculate_debt_n1(_stateCollateral - _stateRepayCollateral, _stateDebt - _repayExpected, _N)];
+                    case 4:
+                        _n1 = _c.sent();
+                        _n2 = _n1 + (_N - BigInt(1));
+                        return [3 /*break*/, 6];
+                    case 5:
+                        e_1 = _c.sent();
+                        console.log("Full repayment");
+                        return [3 /*break*/, 6];
+                    case 6: return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        this.id = id;
+        this.name = marketData.name;
+        this.addresses = marketData.addresses;
+        this.borrowed_token = marketData.borrowed_token;
+        this.collateral_token = marketData.collateral_token;
+        this.coinDecimals = [this.borrowed_token.decimals, this.collateral_token.decimals];
+        this.coinAddresses = [this.borrowed_token.address, this.collateral_token.address];
+        this.defaultBands = 10;
+        this.minBands = 4;
+        this.maxBands = 50;
+        this.estimateGas = {
+            createLoanApprove: this.createLoanApproveEstimateGas.bind(this),
+            createLoan: this.createLoanEstimateGas.bind(this),
+            borrowMoreApprove: this.borrowMoreApproveEstimateGas.bind(this),
+            borrowMore: this.borrowMoreEstimateGas.bind(this),
+            addCollateralApprove: this.addCollateralApproveEstimateGas.bind(this),
+            addCollateral: this.addCollateralEstimateGas.bind(this),
+            removeCollateral: this.removeCollateralEstimateGas.bind(this),
+            repayApprove: this.repayApproveEstimateGas.bind(this),
+            repay: this.repayEstimateGas.bind(this),
+            fullRepayApprove: this.fullRepayApproveEstimateGas.bind(this),
+            fullRepay: this.fullRepayEstimateGas.bind(this),
+            swapApprove: this.swapApproveEstimateGas.bind(this),
+            swap: this.swapEstimateGas.bind(this),
+            liquidateApprove: this.liquidateApproveEstimateGas.bind(this),
+            liquidate: this.liquidateEstimateGas.bind(this),
+            selfLiquidateApprove: this.selfLiquidateApproveEstimateGas.bind(this),
+            selfLiquidate: this.selfLiquidateEstimateGas.bind(this),
+        };
+        this.stats = {
+            parameters: this.statsParameters.bind(this),
+            rates: this.statsRates.bind(this),
+            futureRates: this.statsFutureRates.bind(this),
+            balances: this.statsBalances.bind(this),
+            bandsInfo: this.statsBandsInfo.bind(this),
+            bandBalances: this.statsBandBalances.bind(this),
+            bandsBalances: this.statsBandsBalances.bind(this),
+            totalDebt: this.statsTotalDebt.bind(this),
+            ammBalances: this.statsAmmBalances.bind(this),
+            capAndAvailable: this.statsCapAndAvailable.bind(this),
+        };
+        this.wallet = {
+            balances: this.walletBalances.bind(this),
+        };
+        this.vault = {
+            maxDeposit: this.vaultMaxDeposit.bind(this),
+            previewDeposit: this.vaultPreviewDeposit.bind(this),
+            depositIsApproved: this.vaultDepositIsApproved.bind(this),
+            depositApprove: this.vaultDepositApprove.bind(this),
+            deposit: this.vaultDeposit.bind(this),
+            maxMint: this.vaultMaxMint.bind(this),
+            previewMint: this.vaultPreviewMint.bind(this),
+            mintIsApproved: this.vaultMintIsApproved.bind(this),
+            mintApprove: this.vaultMintApprove.bind(this),
+            mint: this.vaultMint.bind(this),
+            maxWithdraw: this.vaultMaxWithdraw.bind(this),
+            previewWithdraw: this.vaultPreviewWithdraw.bind(this),
+            withdraw: this.vaultWithdraw.bind(this),
+            maxRedeem: this.vaultMaxRedeem.bind(this),
+            previewRedeem: this.vaultPreviewRedeem.bind(this),
+            redeem: this.vaultRedeem.bind(this),
+            convertToShares: this.vaultConvertToShares.bind(this),
+            convertToAssets: this.vaultConvertToAssets.bind(this),
+            stakeIsApproved: this.vaultStakeIsApproved.bind(this),
+            stakeApprove: this.vaultStakeApprove.bind(this),
+            stake: this.vaultStake.bind(this),
+            unstake: this.vaultUnstake.bind(this),
+            rewardsOnly: this.vaultRewardsOnly.bind(this),
+            totalLiquidity: this.vaultTotalLiquidity.bind(this),
+            crvApr: this.vaultCrvApr.bind(this),
+            claimableCrv: this.vaultClaimableCrv.bind(this),
+            claimCrv: this.vaultClaimCrv.bind(this),
+            rewardTokens: this.vaultRewardTokens.bind(this),
+            rewardsApr: this.vaultRewardsApr.bind(this),
+            claimableRewards: this.vaultClaimableRewards.bind(this),
+            claimRewards: this.vaultClaimRewards.bind(this),
+            estimateGas: {
+                depositApprove: this.vaultDepositApproveEstimateGas.bind(this),
+                deposit: this.vaultDepositEstimateGas.bind(this),
+                mintApprove: this.vaultMintApproveEstimateGas.bind(this),
+                mint: this.vaultMintEstimateGas.bind(this),
+                withdraw: this.vaultWithdrawEstimateGas.bind(this),
+                redeem: this.vaultRedeemEstimateGas.bind(this),
+                stakeApprove: this.vaultStakeApproveEstimateGas.bind(this),
+                stake: this.vaultStakeEstimateGas.bind(this),
+                unstake: this.vaultUnstakeEstimateGas.bind(this),
+                claimCrv: this.vaultClaimCrvEstimateGas.bind(this),
+                claimRewards: this.vaultClaimRewardsEstimateGas.bind(this),
+            },
+        };
+        this.leverage = {
+            hasLeverage: this.hasLeverage.bind(this),
+            maxLeverage: this.maxLeverage.bind(this),
+            createLoanMaxRecv: this.leverageCreateLoanMaxRecv.bind(this),
+            createLoanMaxRecvAllRanges: this.leverageCreateLoanMaxRecvAllRanges.bind(this),
+            createLoanExpectedCollateral: this.leverageCreateLoanExpectedCollateral.bind(this),
+            createLoanPriceImpact: this.leverageCreateLoanPriceImpact.bind(this),
+            createLoanMaxRange: this.leverageCreateLoanMaxRange.bind(this),
+            createLoanBands: this.leverageCreateLoanBands.bind(this),
+            createLoanBandsAllRanges: this.leverageCreateLoanBandsAllRanges.bind(this),
+            createLoanPrices: this.leverageCreateLoanPrices.bind(this),
+            createLoanPricesAllRanges: this.leverageCreateLoanPricesAllRanges.bind(this),
+            createLoanHealth: this.leverageCreateLoanHealth.bind(this),
+            createLoanIsApproved: this.leverageCreateLoanIsApproved.bind(this),
+            createLoanApprove: this.leverageCreateLoanApprove.bind(this),
+            createLoanRouteImage: this.leverageCreateLoanRouteImage.bind(this),
+            createLoan: this.leverageCreateLoan.bind(this),
+            borrowMoreMaxRecv: this.leverageBorrowMoreMaxRecv.bind(this),
+            borrowMoreExpectedCollateral: this.leverageBorrowMoreExpectedCollateral.bind(this),
+            borrowMorePriceImpact: this.leverageBorrowMorePriceImpact.bind(this),
+            borrowMoreBands: this.leverageBorrowMoreBands.bind(this),
+            borrowMorePrices: this.leverageBorrowMorePrices.bind(this),
+            borrowMoreHealth: this.leverageBorrowMoreHealth.bind(this),
+            borrowMoreIsApproved: this.leverageCreateLoanIsApproved.bind(this),
+            borrowMoreApprove: this.leverageCreateLoanApprove.bind(this),
+            borrowMoreRouteImage: this.leverageBorrowMoreRouteImage.bind(this),
+            borrowMore: this.leverageBorrowMore.bind(this),
+            repayExpectedBorrowed: this.leverageRepayExpectedBorrowed.bind(this),
+            repayPriceImpact: this.leverageRepayPriceImpact.bind(this),
+            repayIsFull: this.leverageRepayIsFull.bind(this),
+            repayIsAvailable: this.leverageRepayIsAvailable.bind(this),
+            repayBands: this.leverageRepayBands.bind(this),
+            repayPrices: this.leverageRepayPrices.bind(this),
+            repayHealth: this.leverageRepayHealth.bind(this),
+            repayIsApproved: this.leverageRepayIsApproved.bind(this),
+            repayApprove: this.leverageRepayApprove.bind(this),
+            repayRouteImage: this.leverageRepayRouteImage.bind(this),
+            repay: this.leverageRepay.bind(this),
+            estimateGas: {
+                createLoanApprove: this.leverageCreateLoanApproveEstimateGas.bind(this),
+                createLoan: this.leverageCreateLoanEstimateGas.bind(this),
+                borrowMoreApprove: this.leverageCreateLoanApproveEstimateGas.bind(this),
+                borrowMore: this.leverageBorrowMoreEstimateGas.bind(this),
+                repayApprove: this.leverageRepayApproveEstimateGas.bind(this),
+                repay: this.leverageRepayEstimateGas.bind(this),
+            },
+        };
+    }
+    // ---------------- VAULT ----------------
+    LendMarketTemplate.prototype.vaultMaxDeposit = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _amount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.borrowed_token].contract.balanceOf(address)];
+                    case 1:
+                        _amount = _a.sent();
+                        return [2 /*return*/, formatUnits(_amount, this.borrowed_token.decimals)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultPreviewDeposit = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _amount, _shares;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _amount = parseUnits(amount, this.borrowed_token.decimals);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.previewDeposit(_amount)];
+                    case 1:
+                        _shares = _a.sent();
+                        return [2 /*return*/, formatUnits(_shares, 18)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultDepositIsApproved = function (borrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, hasAllowance([this.borrowed_token.address], [borrowed], llamalend.signerAddress, this.addresses.vault)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultDepositApproveEstimateGas = function (borrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowanceEstimateGas([this.borrowed_token.address], [borrowed], this.addresses.vault)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultDepositApprove = function (borrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowance([this.borrowed_token.address], [borrowed], this.addresses.vault)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._vaultDeposit = function (amount, estimateGas) {
+        if (estimateGas === void 0) { estimateGas = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _amount, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _amount = parseUnits(amount, this.borrowed_token.decimals);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.deposit.estimateGas(_amount, __assign({}, llamalend.constantOptions))];
+                    case 1:
+                        gas = _a.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 2:
+                        _a.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.deposit(_amount, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 3: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultDepositEstimateGas = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.vaultDepositIsApproved(amount)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._vaultDeposit(amount, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultDeposit = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.vaultDepositApprove(amount)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._vaultDeposit(amount, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultMaxMint = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _assetBalance, _shares;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.borrowed_token].contract.balanceOf(address)];
+                    case 1:
+                        _assetBalance = _a.sent();
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.convertToShares(_assetBalance)];
+                    case 2:
+                        _shares = _a.sent();
+                        return [2 /*return*/, formatUnits(_shares, 18)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultPreviewMint = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _amount, _assets;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _amount = parseUnits(amount, 18);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.previewMint(_amount)];
+                    case 1:
+                        _assets = _a.sent();
+                        return [2 /*return*/, formatUnits(_assets, this.borrowed_token.decimals)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultMintIsApproved = function (borrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, hasAllowance([this.borrowed_token.address], [borrowed], llamalend.signerAddress, this.addresses.vault)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultMintApproveEstimateGas = function (borrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowanceEstimateGas([this.borrowed_token.address], [borrowed], this.addresses.vault)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultMintApprove = function (borrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowance([this.borrowed_token.address], [borrowed], this.addresses.vault)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._vaultMint = function (amount, estimateGas) {
+        if (estimateGas === void 0) { estimateGas = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _amount, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _amount = parseUnits(amount, 18);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.mint.estimateGas(_amount, __assign({}, llamalend.constantOptions))];
+                    case 1:
+                        gas = _a.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 2:
+                        _a.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.mint(_amount, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 3: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultMintEstimateGas = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.vaultMintIsApproved(amount)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._vaultMint(amount, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultMint = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.vaultMintApprove(amount)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._vaultMint(amount, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultMaxWithdraw = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _assets;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.maxWithdraw(address)];
+                    case 1:
+                        _assets = _a.sent();
+                        return [2 /*return*/, formatUnits(_assets, this.borrowed_token.decimals)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultPreviewWithdraw = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _amount, _shares;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _amount = parseUnits(amount, this.borrowed_token.decimals);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.previewWithdraw(_amount)];
+                    case 1:
+                        _shares = _a.sent();
+                        return [2 /*return*/, formatUnits(_shares, 18)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._vaultWithdraw = function (amount, estimateGas) {
+        if (estimateGas === void 0) { estimateGas = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _amount, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _amount = parseUnits(amount, this.borrowed_token.decimals);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.withdraw.estimateGas(_amount, __assign({}, llamalend.constantOptions))];
+                    case 1:
+                        gas = _a.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 2:
+                        _a.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.withdraw(_amount, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 3: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultWithdrawEstimateGas = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._vaultWithdraw(amount, true)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultWithdraw = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._vaultWithdraw(amount, false)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultMaxRedeem = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _shares;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.maxRedeem(address)];
+                    case 1:
+                        _shares = _a.sent();
+                        return [2 /*return*/, formatUnits(_shares, 18)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultPreviewRedeem = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _amount, _assets;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _amount = parseUnits(amount, 18);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.previewRedeem(_amount)];
+                    case 1:
+                        _assets = _a.sent();
+                        return [2 /*return*/, formatUnits(_assets, this.borrowed_token.decimals)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._vaultRedeem = function (amount, estimateGas) {
+        if (estimateGas === void 0) { estimateGas = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _amount, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _amount = parseUnits(amount, 18);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.redeem.estimateGas(_amount, __assign({}, llamalend.constantOptions))];
+                    case 1:
+                        gas = _a.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 2:
+                        _a.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.redeem(_amount, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 3: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultRedeemEstimateGas = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._vaultRedeem(amount, true)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultRedeem = function (amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._vaultRedeem(amount, false)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // ---------------- VAULT UTILS ----------------
+    LendMarketTemplate.prototype.vaultConvertToShares = function (assets) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _assets, _shares;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _assets = parseUnits(assets, this.borrowed_token.decimals);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.convertToShares(_assets)];
+                    case 1:
+                        _shares = _a.sent();
+                        return [2 /*return*/, llamalend.formatUnits(_shares)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultConvertToAssets = function (shares) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _shares, _assets;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _shares = parseUnits(shares);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.vault].contract.convertToAssets(_shares)];
+                    case 1:
+                        _assets = _a.sent();
+                        return [2 /*return*/, llamalend.formatUnits(_assets, this.borrowed_token.decimals)];
+                }
+            });
+        });
+    };
+    // ---------------- VAULT STAKING ----------------
+    LendMarketTemplate.prototype.vaultStakeIsApproved = function (vaultShares) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS) {
+                            throw Error("stakeIsApproved method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        return [4 /*yield*/, hasAllowance([this.addresses.vault], [vaultShares], llamalend.signerAddress, this.addresses.gauge)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultStakeApproveEstimateGas = function (vaultShares) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS) {
+                            throw Error("stakeApproveEstimateGas method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        return [4 /*yield*/, ensureAllowanceEstimateGas([this.addresses.vault], [vaultShares], this.addresses.gauge)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultStakeApprove = function (vaultShares) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS) {
+                            throw Error("stakeApprove method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        return [4 /*yield*/, ensureAllowance([this.addresses.vault], [vaultShares], this.addresses.gauge)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultStakeEstimateGas = function (vaultShares) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _vaultShares, _a;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS) {
+                            throw Error("stakeEstimateGas method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        _vaultShares = parseUnits(vaultShares);
+                        _a = smartNumber;
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.gauge].contract.deposit.estimateGas(_vaultShares, llamalend.constantOptions)];
+                    case 1: return [2 /*return*/, _a.apply(void 0, [_c.sent()])];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultStake = function (vaultShares) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _vaultShares, gasLimit, _a, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS) {
+                            throw Error("stake method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        _vaultShares = parseUnits(vaultShares);
+                        return [4 /*yield*/, _ensureAllowance([this.addresses.vault], [_vaultShares], this.addresses.gauge)];
+                    case 1:
+                        _d.sent();
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 2:
+                        _d.sent();
+                        _a = _mulBy1_3;
+                        _c = DIGas;
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.gauge].contract.deposit.estimateGas(_vaultShares, llamalend.constantOptions)];
+                    case 3:
+                        gasLimit = _a.apply(void 0, [_c.apply(void 0, [_d.sent()])]);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.gauge].contract.deposit(_vaultShares, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 4: return [2 /*return*/, (_d.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultUnstakeEstimateGas = function (vaultShares) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _vaultShares, _a;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS) {
+                            throw Error("unstakeEstimateGas method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        _vaultShares = parseUnits(vaultShares);
+                        _a = smartNumber;
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.gauge].contract.withdraw.estimateGas(_vaultShares, llamalend.constantOptions)];
+                    case 1: return [2 /*return*/, _a.apply(void 0, [_c.sent()])];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultUnstake = function (vaultShares) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _vaultShares, gasLimit, _a, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS) {
+                            throw Error("unstake method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        _vaultShares = parseUnits(vaultShares);
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 1:
+                        _d.sent();
+                        _a = _mulBy1_3;
+                        _c = DIGas;
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.gauge].contract.withdraw.estimateGas(_vaultShares, llamalend.constantOptions)];
+                    case 2:
+                        gasLimit = _a.apply(void 0, [_c.apply(void 0, [(_d.sent())])]);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.gauge].contract.withdraw(_vaultShares, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 3: return [2 /*return*/, (_d.sent()).hash];
+                }
+            });
+        });
+    };
+    // ---------------- VAULT STAKING REWARDS ----------------
+    LendMarketTemplate.prototype.vaultRewardsOnly = function () {
+        if (llamalend.chainId === 2222 || llamalend.chainId === 324)
+            return true; // TODO remove this for Kava and ZkSync
+        if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS)
+            throw Error("".concat(this.name, " doesn't have gauge"));
+        var gaugeContract = llamalend.contracts[this.addresses.gauge].contract;
+        return !('inflation_rate()' in gaugeContract || 'inflation_rate(uint256)' in gaugeContract);
+    };
+    LendMarketTemplate.prototype.vaultTotalLiquidity = function (useAPI) {
+        if (useAPI === void 0) { useAPI = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var cap, price;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.statsCapAndAvailable(true, useAPI)];
+                    case 1:
+                        cap = (_a.sent()).cap;
+                        return [4 /*yield*/, _getUsdRate(this.addresses.borrowed_token)];
+                    case 2:
+                        price = _a.sent();
+                        return [2 /*return*/, BN(cap).times(price).toFixed(6)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultCrvApr = function (useApi) {
+        if (useApi === void 0) { useApi = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.vaultRewardsOnly())
+                            throw Error("".concat(this.name, " has Rewards-Only Gauge. Use stats.rewardsApy instead"));
+                        return [4 /*yield*/, this._calcCrvApr()];
+                    case 1: 
+                    // const isDisabledChain = [1313161554].includes(llamalend.chainId); // Disable Aurora
+                    // if (useApi && !isDisabledChain) {
+                    //     const crvAPYs = await _getCrvApyFromApi();
+                    //     const poolCrvApy = crvAPYs[this.addresses.gauge] ?? [0, 0];  // new pools might be missing
+                    //     return [poolCrvApy[0], poolCrvApy[1]];
+                    // }
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultClaimableCrv = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.vaultRewardsOnly())
+                            throw Error("".concat(this.name, " has Rewards-Only Gauge. Use claimableRewards instead"));
+                        address = address || llamalend.signerAddress;
+                        if (!address)
+                            throw Error("Need to connect wallet or pass address into args");
+                        _c = (_a = llamalend).formatUnits;
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.gauge].contract.claimable_tokens(address, llamalend.constantOptions)];
+                    case 1: return [2 /*return*/, _c.apply(_a, [_d.sent()])];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._vaultClaimCrv = function (estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var contract, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.vaultRewardsOnly())
+                            throw Error("".concat(this.name, " has Rewards-Only Gauge. Use claimRewards instead"));
+                        contract = llamalend.contracts[llamalend.constants.ALIASES.minter].contract;
+                        return [4 /*yield*/, contract.mint.estimateGas(this.addresses.gauge, llamalend.constantOptions)];
+                    case 1:
+                        gas = _a.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 2:
+                        _a.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.mint(this.addresses.gauge, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 3: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultClaimCrvEstimateGas = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._vaultClaimCrv(true)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultClaimCrv = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._vaultClaimCrv(false)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultClaimableRewards = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var gaugeContract, rewardTokens, rewards, _a, rewardTokens_2, rewardToken, _amount;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS) {
+                            throw Error("claimableRewards method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        address = address || llamalend.signerAddress;
+                        if (!address)
+                            throw Error("Need to connect wallet or pass address into args");
+                        gaugeContract = llamalend.contracts[this.addresses.gauge].contract;
+                        return [4 /*yield*/, this.vaultRewardTokens()];
+                    case 1:
+                        rewardTokens = _c.sent();
+                        rewards = [];
+                        _a = 0, rewardTokens_2 = rewardTokens;
+                        _c.label = 2;
+                    case 2:
+                        if (!(_a < rewardTokens_2.length)) return [3 /*break*/, 5];
+                        rewardToken = rewardTokens_2[_a];
+                        return [4 /*yield*/, gaugeContract.claimable_reward(address, rewardToken.token, llamalend.constantOptions)];
+                    case 3:
+                        _amount = _c.sent();
+                        rewards.push({
+                            token: rewardToken.token,
+                            symbol: rewardToken.symbol,
+                            amount: llamalend.formatUnits(_amount, rewardToken.decimals),
+                        });
+                        _c.label = 4;
+                    case 4:
+                        _a++;
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*return*/, rewards];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._vaultClaimRewards = function (estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var gaugeContract, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.addresses.gauge === llamalend.constants.ZERO_ADDRESS) {
+                            throw Error("claimRewards method doesn't exist for pool ".concat(this.name, " (id: ").concat(this.name, "). There is no gauge"));
+                        }
+                        gaugeContract = llamalend.contracts[this.addresses.gauge].contract;
+                        if (!("claim_rewards()" in gaugeContract))
+                            throw Error("".concat(this.name, " pool doesn't have such method"));
+                        return [4 /*yield*/, gaugeContract.claim_rewards.estimateGas(llamalend.constantOptions)];
+                    case 1:
+                        gas = _a.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 2:
+                        _a.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, gaugeContract.claim_rewards(__assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 3: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultClaimRewardsEstimateGas = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._vaultClaimRewards(true)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.vaultClaimRewards = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._vaultClaimRewards(false)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.statsRates = function (isGetter, useAPI) {
+        if (isGetter === void 0) { isGetter = true; }
+        if (useAPI === void 0) { useAPI = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var response, market, _rate, borrowApr, borrowApy, lendApr, lendApy, debt, cap, debtInAYearBN;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!useAPI) return [3 /*break*/, 2];
+                        return [4 /*yield*/, _getMarketsData(llamalend.constants.NETWORK_NAME)];
+                    case 1:
+                        response = _a.sent();
+                        market = response.lendingVaultData.find(function (item) { return item.address.toLowerCase() === _this.addresses.vault.toLowerCase(); });
+                        if (market) {
+                            return [2 /*return*/, {
+                                    borrowApr: (market.rates.borrowApr * 100).toString(),
+                                    lendApr: (market.rates.lendApr * 100).toString(),
+                                    borrowApy: (market.rates.borrowApy * 100).toString(),
+                                    lendApy: (market.rates.lendApy * 100).toString(),
+                                }];
+                        }
+                        else {
+                            throw new Error('Market not found in API');
+                        }
+                        return [3 /*break*/, 7];
+                    case 2: return [4 /*yield*/, this._getRate(isGetter)];
+                    case 3:
+                        _rate = _a.sent();
+                        borrowApr = toBN(_rate).times(365).times(86400).times(100).toString();
+                        borrowApy = String(((Math.pow(2.718281828459, (toBN(_rate).times(365).times(86400)).toNumber())) - 1) * 100);
+                        lendApr = "0";
+                        lendApy = "0";
+                        return [4 /*yield*/, this.statsTotalDebt(isGetter)];
+                    case 4:
+                        debt = _a.sent();
+                        if (!(Number(debt) > 0)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.statsCapAndAvailable(isGetter)];
+                    case 5:
+                        cap = (_a.sent()).cap;
+                        lendApr = toBN(_rate).times(365).times(86400).times(debt).div(cap).times(100).toString();
+                        debtInAYearBN = BN(debt).times(Math.pow(2.718281828459, (toBN(_rate).times(365).times(86400)).toNumber()));
+                        lendApy = debtInAYearBN.minus(debt).div(cap).times(100).toString();
+                        _a.label = 6;
+                    case 6: return [2 /*return*/, { borrowApr: borrowApr, lendApr: lendApr, borrowApy: borrowApy, lendApy: lendApy }];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.statsFutureRates = function (dReserves, dDebt, useAPI) {
+        if (useAPI === void 0) { useAPI = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _dReserves, _dDebt, _rate, borrowApr, borrowApy, lendApr, lendApy, debt, _a, cap, _c, debtInAYearBN;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _dReserves = parseUnits(dReserves, this.borrowed_token.decimals);
+                        _dDebt = parseUnits(dDebt, this.borrowed_token.decimals);
+                        return [4 /*yield*/, this._getFutureRate(_dReserves, _dDebt)];
+                    case 1:
+                        _rate = _d.sent();
+                        borrowApr = toBN(_rate).times(365).times(86400).times(100).toString();
+                        borrowApy = String(((Math.pow(2.718281828459, (toBN(_rate).times(365).times(86400)).toNumber())) - 1) * 100);
+                        lendApr = "0";
+                        lendApy = "0";
+                        _a = Number;
+                        return [4 /*yield*/, this.statsTotalDebt()];
+                    case 2:
+                        debt = _a.apply(void 0, [_d.sent()]) + Number(dDebt);
+                        if (!(Number(debt) > 0)) return [3 /*break*/, 4];
+                        _c = Number;
+                        return [4 /*yield*/, this.statsCapAndAvailable(true, useAPI)];
+                    case 3:
+                        cap = _c.apply(void 0, [(_d.sent()).cap]) + Number(dReserves);
+                        lendApr = toBN(_rate).times(365).times(86400).times(debt).div(cap).times(100).toString();
+                        debtInAYearBN = BN(debt).times(Math.pow(2.718281828459, (toBN(_rate).times(365).times(86400)).toNumber()));
+                        lendApy = debtInAYearBN.minus(debt).div(cap).times(100).toString();
+                        _d.label = 4;
+                    case 4: return [2 /*return*/, { borrowApr: borrowApr, lendApr: lendApr, borrowApy: borrowApy, lendApy: lendApy }];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.statsBalances = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var borrowedContract, collateralContract, ammContract, calls, _a, _borrowedBalance, _collateralBalance, _borrowedAdminFees, _collateralAdminFees;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        borrowedContract = llamalend.contracts[this.borrowed_token.address].multicallContract;
+                        collateralContract = llamalend.contracts[this.collateral_token.address].multicallContract;
+                        ammContract = llamalend.contracts[this.addresses.amm].multicallContract;
+                        calls = [
+                            borrowedContract.balanceOf(this.addresses.amm),
+                            collateralContract.balanceOf(this.addresses.amm),
+                            ammContract.admin_fees_x(),
+                            ammContract.admin_fees_y(),
+                        ];
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _a = _c.sent(), _borrowedBalance = _a[0], _collateralBalance = _a[1], _borrowedAdminFees = _a[2], _collateralAdminFees = _a[3];
+                        return [2 /*return*/, [
+                                formatUnits(_borrowedBalance - _borrowedAdminFees, this.borrowed_token.decimals),
+                                formatUnits(_collateralBalance - _collateralAdminFees, this.collateral_token.decimals),
+                            ]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.statsBandBalances = function (n) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ammContract, calls, _balances;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ammContract = llamalend.contracts[this.addresses.amm].multicallContract;
+                        calls = [];
+                        calls.push(ammContract.bands_x(n), ammContract.bands_y(n));
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _balances = _a.sent();
+                        // bands_x and bands_y always return amounts with 18 decimals
+                        return [2 /*return*/, {
+                                borrowed: formatNumber(formatUnits(_balances[0]), this.borrowed_token.decimals),
+                                collateral: formatNumber(formatUnits(_balances[1]), this.collateral_token.decimals),
+                            }];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.statsBandsBalances = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, maxBand, minBand, ammContract, calls, i, _bands, bands, i, _i;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.statsBandsInfo()];
+                    case 1:
+                        _a = _c.sent(), maxBand = _a.maxBand, minBand = _a.minBand;
+                        ammContract = llamalend.contracts[this.addresses.amm].multicallContract;
+                        calls = [];
+                        for (i = minBand; i <= maxBand; i++) {
+                            calls.push(ammContract.bands_x(i), ammContract.bands_y(i));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 2:
+                        _bands = _c.sent();
+                        bands = {};
+                        for (i = minBand; i <= maxBand; i++) {
+                            _i = i - minBand;
+                            // bands_x and bands_y always return amounts with 18 decimals
+                            bands[i] = {
+                                borrowed: formatNumber(formatUnits(_bands[2 * _i]), this.borrowed_token.decimals),
+                                collateral: formatNumber(formatUnits(_bands[(2 * _i) + 1]), this.collateral_token.decimals),
+                            };
+                        }
+                        return [2 /*return*/, bands];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.statsTotalDebt = function (isGetter, useAPI) {
+        if (isGetter === void 0) { isGetter = true; }
+        if (useAPI === void 0) { useAPI = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var response, market, _debt;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!useAPI) return [3 /*break*/, 2];
+                        return [4 /*yield*/, _getMarketsData(llamalend.constants.NETWORK_NAME)];
+                    case 1:
+                        response = _a.sent();
+                        market = response.lendingVaultData.find(function (item) { return item.address.toLowerCase() === _this.addresses.vault.toLowerCase(); });
+                        if (market) {
+                            return [2 /*return*/, market.borrowed.total.toString()];
+                        }
+                        else {
+                            throw new Error('Market not found in API');
+                        }
+                        return [3 /*break*/, 6];
+                    case 2:
+                        _debt = void 0;
+                        if (!isGetter) return [3 /*break*/, 3];
+                        _debt = cacheStats.get(cacheKey(this.addresses.controller, 'total_debt'));
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, llamalend.contracts[this.addresses.controller].contract.total_debt(llamalend.constantOptions)];
+                    case 4:
+                        _debt = _a.sent();
+                        cacheStats.set(cacheKey(this.addresses.controller, 'total_debt'), _debt);
+                        _a.label = 5;
+                    case 5: return [2 /*return*/, formatUnits(_debt, this.borrowed_token.decimals)];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.statsCapAndAvailable = function (isGetter, useAPI) {
+        if (isGetter === void 0) { isGetter = true; }
+        if (useAPI === void 0) { useAPI = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var response, market, vaultContract, borrowedContract, _cap, _available;
+            var _a;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!useAPI) return [3 /*break*/, 2];
+                        return [4 /*yield*/, _getMarketsData(llamalend.constants.NETWORK_NAME)];
+                    case 1:
+                        response = _c.sent();
+                        market = response.lendingVaultData.find(function (item) { return item.address.toLowerCase() === _this.addresses.vault.toLowerCase(); });
+                        if (market) {
+                            return [2 /*return*/, {
+                                    cap: market.totalSupplied.total.toString(),
+                                    available: market.availableToBorrow.total.toString(),
+                                }];
+                        }
+                        else {
+                            throw new Error('Market not found in API');
+                        }
+                        return [3 /*break*/, 6];
+                    case 2:
+                        vaultContract = llamalend.contracts[this.addresses.vault].multicallContract;
+                        borrowedContract = llamalend.contracts[this.addresses.borrowed_token].multicallContract;
+                        _cap = void 0, _available = void 0;
+                        if (!isGetter) return [3 /*break*/, 3];
+                        _cap = cacheStats.get(cacheKey(this.addresses.vault, 'totalAssets', this.addresses.controller));
+                        _available = cacheStats.get(cacheKey(this.addresses.borrowed_token, 'balanceOf', this.addresses.controller));
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, llamalend.multicallProvider.all([
+                            vaultContract.totalAssets(this.addresses.controller),
+                            borrowedContract.balanceOf(this.addresses.controller),
+                        ])];
+                    case 4:
+                        _a = _c.sent(), _cap = _a[0], _available = _a[1];
+                        cacheStats.set(cacheKey(this.addresses.vault, 'totalAssets', this.addresses.controller), _cap);
+                        cacheStats.set(cacheKey(this.addresses.borrowed_token, 'balanceOf', this.addresses.controller), _available);
+                        _c.label = 5;
+                    case 5: return [2 /*return*/, {
+                            cap: llamalend.formatUnits(_cap, this.borrowed_token.decimals),
+                            available: llamalend.formatUnits(_available, this.borrowed_token.decimals),
+                        }];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.oraclePriceBand = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var oraclePriceBN, _a, basePriceBN, _c, A_BN, _d, multiplier, term, compareFunc, band, currentTickPriceBN;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _a = BN;
+                        return [4 /*yield*/, this.oraclePrice()];
+                    case 1:
+                        oraclePriceBN = _a.apply(void 0, [_e.sent()]);
+                        _c = BN;
+                        return [4 /*yield*/, this.basePrice()];
+                    case 2:
+                        basePriceBN = _c.apply(void 0, [_e.sent()]);
+                        _d = BN;
+                        return [4 /*yield*/, this.A()];
+                    case 3:
+                        A_BN = _d.apply(void 0, [_e.sent()]);
+                        multiplier = oraclePriceBN.lte(basePriceBN) ? A_BN.minus(1).div(A_BN) : A_BN.div(A_BN.minus(1));
+                        term = oraclePriceBN.lte(basePriceBN) ? 1 : -1;
+                        compareFunc = oraclePriceBN.lte(basePriceBN) ?
+                            function (oraclePriceBN, currentTickPriceBN) { return oraclePriceBN.lte(currentTickPriceBN); } :
+                            function (oraclePriceBN, currentTickPriceBN) { return oraclePriceBN.gt(currentTickPriceBN); };
+                        band = 0;
+                        currentTickPriceBN = oraclePriceBN.lte(basePriceBN) ? basePriceBN.times(multiplier) : basePriceBN;
+                        while (compareFunc(oraclePriceBN, currentTickPriceBN)) {
+                            currentTickPriceBN = currentTickPriceBN.times(multiplier);
+                            band += term;
+                        }
+                        return [2 /*return*/, band];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.price = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _price;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, llamalend.contracts[this.addresses.amm].contract.get_p(llamalend.constantOptions)];
+                    case 1:
+                        _price = _a.sent();
+                        return [2 /*return*/, formatUnits(_price)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.calcTickPrice = function (n) {
+        return __awaiter(this, void 0, void 0, function () {
+            var basePrice, basePriceBN, A_BN, _a;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.basePrice()];
+                    case 1:
+                        basePrice = _c.sent();
+                        basePriceBN = BN(basePrice);
+                        _a = BN;
+                        return [4 /*yield*/, this.A()];
+                    case 2:
+                        A_BN = _a.apply(void 0, [_c.sent()]);
+                        return [2 /*return*/, _cutZeros(basePriceBN.times(A_BN.minus(1).div(A_BN).pow(n)).toFixed(18))];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.calcBandPrices = function (n) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.calcTickPrice(n + 1)];
+                    case 1:
+                        _a = [_c.sent()];
+                        return [4 /*yield*/, this.calcTickPrice(n)];
+                    case 2: return [2 /*return*/, _a.concat([_c.sent()])];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.calcRangePct = function (range) {
+        return __awaiter(this, void 0, void 0, function () {
+            var A_BN, _a, startBN, endBN;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = BN;
+                        return [4 /*yield*/, this.A()];
+                    case 1:
+                        A_BN = _a.apply(void 0, [_c.sent()]);
+                        startBN = BN(1);
+                        endBN = A_BN.minus(1).div(A_BN).pow(range);
+                        return [2 /*return*/, startBN.minus(endBN).times(100).toFixed(6)];
+                }
+            });
+        });
+    };
+    // ---------------- WALLET BALANCES ----------------
+    LendMarketTemplate.prototype.walletBalances = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, collateral, borrowed, vaultShares, _c, collateral, borrowed, vaultShares, gauge;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (!(this.addresses.gauge === llamalend.constants.ZERO_ADDRESS)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, getBalances([this.collateral_token.address, this.borrowed_token.address, this.addresses.vault], address)];
+                    case 1:
+                        _a = _d.sent(), collateral = _a[0], borrowed = _a[1], vaultShares = _a[2];
+                        return [2 /*return*/, { collateral: collateral, borrowed: borrowed, vaultShares: vaultShares, gauge: "0" }];
+                    case 2: return [4 /*yield*/, getBalances([this.collateral_token.address, this.borrowed_token.address, this.addresses.vault, this.addresses.gauge], address)];
+                    case 3:
+                        _c = _d.sent(), collateral = _c[0], borrowed = _c[1], vaultShares = _c[2], gauge = _c[3];
+                        return [2 /*return*/, { collateral: collateral, borrowed: borrowed, vaultShares: vaultShares, gauge: gauge }];
+                }
+            });
+        });
+    };
+    // ---------------- USER POSITION ----------------
+    LendMarketTemplate.prototype.userLoanExists = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.controller].contract.loan_exists(address, llamalend.constantOptions)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.userState = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _collateral, _borrowed, _debt, _N;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._userState(address)];
+                    case 1:
+                        _a = _c.sent(), _collateral = _a._collateral, _borrowed = _a._borrowed, _debt = _a._debt, _N = _a._N;
+                        return [2 /*return*/, {
+                                collateral: formatUnits(_collateral, this.collateral_token.decimals),
+                                borrowed: formatUnits(_borrowed, this.borrowed_token.decimals),
+                                debt: formatUnits(_debt, this.borrowed_token.decimals),
+                                N: formatUnits(_N, 0),
+                            }];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.userHealth = function (full, address) {
+        if (full === void 0) { full = true; }
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _health;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.controller].contract.health(address, full, llamalend.constantOptions)];
+                    case 1:
+                        _health = _a.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._userBands = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _bands;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.amm].contract.read_user_tick_numbers(address, llamalend.constantOptions)];
+                    case 1:
+                        _bands = _a.sent();
+                        return [2 /*return*/, Array.from(_bands).reverse()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.userBands = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._userBands(address)];
+                    case 1: return [2 /*return*/, (_a.sent()).map(function (_t) { return Number(_t); })];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.userRange = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, n2, n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.userBands(address)];
+                    case 1:
+                        _a = _c.sent(), n2 = _a[0], n1 = _a[1];
+                        if (n1 == n2)
+                            return [2 /*return*/, 0];
+                        return [2 /*return*/, n2 - n1 + 1];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.userPrices = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _prices;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.controller].contract.user_prices(address, llamalend.constantOptions)];
+                    case 1:
+                        _prices = _a.sent();
+                        return [2 /*return*/, _prices.map(function (_p) { return formatUnits(_p); }).reverse()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.userLoss = function (userAddress) {
+        if (userAddress === void 0) { userAddress = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, userCollateral, _current_collateral_estimation, deposited_collateral, current_collateral_estimation, loss, loss_pct;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        userAddress = _getAddress(userAddress);
+                        return [4 /*yield*/, Promise.all([
+                                _getUserCollateral(llamalend.constants.NETWORK_NAME, this.addresses.controller, userAddress),
+                                llamalend.contracts[this.addresses.amm].contract.get_y_up(userAddress),
+                            ])];
+                    case 1:
+                        _a = _c.sent(), userCollateral = _a[0], _current_collateral_estimation = _a[1];
+                        deposited_collateral = userCollateral.total_deposit_precise;
+                        current_collateral_estimation = llamalend.formatUnits(_current_collateral_estimation, this.collateral_token.decimals);
+                        if (BN(deposited_collateral).lte(0)) {
+                            return [2 /*return*/, {
+                                    deposited_collateral: deposited_collateral,
+                                    current_collateral_estimation: current_collateral_estimation,
+                                    loss: "0.0",
+                                    loss_pct: "0.0",
+                                }];
+                        }
+                        loss = BN(deposited_collateral).minus(current_collateral_estimation).toString();
+                        loss_pct = BN(loss).div(deposited_collateral).times(100).toString();
+                        return [2 /*return*/, {
+                                deposited_collateral: deposited_collateral,
+                                current_collateral_estimation: current_collateral_estimation,
+                                loss: loss,
+                                loss_pct: loss_pct,
+                            }];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.userBandsBalances = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, n2, n1, contract, _c, _borrowed, _collateral, res, i;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.userBands(address)];
+                    case 1:
+                        _a = _d.sent(), n2 = _a[0], n1 = _a[1];
+                        if (n1 == 0 && n2 == 0)
+                            return [2 /*return*/, {}];
+                        address = _getAddress(address);
+                        contract = llamalend.contracts[this.addresses.amm].contract;
+                        return [4 /*yield*/, contract.get_xy(address, llamalend.constantOptions)];
+                    case 2:
+                        _c = _d.sent(), _borrowed = _c[0], _collateral = _c[1];
+                        res = {};
+                        for (i = n1; i <= n2; i++) {
+                            res[i] = {
+                                collateral: formatUnits(_collateral[i - n1], this.collateral_token.decimals),
+                                borrowed: formatUnits(_borrowed[i - n1], this.borrowed_token.decimals),
+                            };
+                        }
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    // ---------------- CREATE LOAN ----------------
+    LendMarketTemplate.prototype._checkRange = function (range) {
+        if (range < this.minBands)
+            throw Error("range must be >= ".concat(this.minBands));
+        if (range > this.maxBands)
+            throw Error("range must be <= ".concat(this.maxBands));
+    };
+    LendMarketTemplate.prototype.createLoanMaxRecv = function (collateral, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _collateral, contract, _a;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkRange(range);
+                        _collateral = parseUnits(collateral, this.collateral_token.decimals);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        _a = formatUnits;
+                        return [4 /*yield*/, contract.max_borrowable(_collateral, range, 0, llamalend.constantOptions)];
+                    case 1: return [2 /*return*/, _a.apply(void 0, [_c.sent(), this.borrowed_token.decimals])];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.getMaxRange = function (collateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var maxRecv, N;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.createLoanMaxRecvAllRanges(collateral)];
+                    case 1:
+                        maxRecv = _a.sent();
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            if (BN(debt).gt(BN(maxRecv[N])))
+                                return [2 /*return*/, N - 1];
+                        }
+                        return [2 /*return*/, this.maxBands];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._calcN1 = function (_collateral, _debt, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkRange(range);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.controller].contract.calculate_debt_n1(_collateral, _debt, range, llamalend.constantOptions)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._calcN1AllRanges = function (_collateral, _debt, maxN) {
+        return __awaiter(this, void 0, void 0, function () {
+            var calls, N;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        calls = [];
+                        for (N = this.minBands; N <= maxN; N++) {
+                            calls.push(llamalend.contracts[this.addresses.controller].multicallContract.calculate_debt_n1(_collateral, _debt, N));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._getPrices = function (_n2, _n1) {
+        return __awaiter(this, void 0, void 0, function () {
+            var contract;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        contract = llamalend.contracts[this.addresses.amm].multicallContract;
+                        return [4 /*yield*/, llamalend.multicallProvider.all([
+                                contract.p_oracle_down(_n2),
+                                contract.p_oracle_up(_n1),
+                            ])];
+                    case 1: return [2 /*return*/, (_a.sent()).map(function (_p) { return formatUnits(_p); })];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._calcPrices = function (_n2, _n1) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.calcTickPrice(Number(_n2) + 1)];
+                    case 1:
+                        _a = [_c.sent()];
+                        return [4 /*yield*/, this.calcTickPrice(Number(_n1))];
+                    case 2: return [2 /*return*/, _a.concat([_c.sent()])];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._createLoanBands = function (collateral, debt, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _n1, _n2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._calcN1(parseUnits(collateral, this.collateral_token.decimals), parseUnits(debt, this.borrowed_token.decimals), range)];
+                    case 1:
+                        _n1 = _a.sent();
+                        _n2 = _n1 + BigInt(range - 1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._createLoanBandsAllRanges = function (collateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var maxN, _n1_arr, _n2_arr, N, res, N;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getMaxRange(collateral, debt)];
+                    case 1:
+                        maxN = _a.sent();
+                        return [4 /*yield*/, this._calcN1AllRanges(parseUnits(collateral, this.collateral_token.decimals), parseUnits(debt, this.borrowed_token.decimals), maxN)];
+                    case 2:
+                        _n1_arr = _a.sent();
+                        _n2_arr = [];
+                        for (N = this.minBands; N <= maxN; N++) {
+                            _n2_arr.push(_n1_arr[N - this.minBands] + BigInt(N - 1));
+                        }
+                        res = {};
+                        for (N = this.minBands; N <= maxN; N++) {
+                            res[N] = [_n2_arr[N - this.minBands], _n1_arr[N - this.minBands]];
+                        }
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.createLoanBands = function (collateral, debt, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._createLoanBands(collateral, debt, range)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [2 /*return*/, [Number(_n2), Number(_n1)]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.createLoanBandsAllRanges = function (collateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _bandsAllRanges, bandsAllRanges, N;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._createLoanBandsAllRanges(collateral, debt)];
+                    case 1:
+                        _bandsAllRanges = _a.sent();
+                        bandsAllRanges = {};
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            if (_bandsAllRanges[N]) {
+                                bandsAllRanges[N] = _bandsAllRanges[N].map(Number);
+                            }
+                            else {
+                                bandsAllRanges[N] = null;
+                            }
+                        }
+                        return [2 /*return*/, bandsAllRanges];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.createLoanPrices = function (collateral, debt, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._createLoanBands(collateral, debt, range)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [4 /*yield*/, this._getPrices(_n2, _n1)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.createLoanPricesAllRanges = function (collateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _bandsAllRanges, pricesAllRanges, N, _a, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this._createLoanBandsAllRanges(collateral, debt)];
+                    case 1:
+                        _bandsAllRanges = _d.sent();
+                        pricesAllRanges = {};
+                        N = this.minBands;
+                        _d.label = 2;
+                    case 2:
+                        if (!(N <= this.maxBands)) return [3 /*break*/, 6];
+                        if (!_bandsAllRanges[N]) return [3 /*break*/, 4];
+                        _a = pricesAllRanges;
+                        _c = N;
+                        return [4 /*yield*/, this._calcPrices.apply(this, _bandsAllRanges[N])];
+                    case 3:
+                        _a[_c] = _d.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        pricesAllRanges[N] = null;
+                        _d.label = 5;
+                    case 5:
+                        N++;
+                        return [3 /*break*/, 2];
+                    case 6: return [2 /*return*/, pricesAllRanges];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.createLoanHealth = function (collateral, debt, range, full) {
+        if (full === void 0) { full = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _collateral, _debt, contract, _health;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _collateral = parseUnits(collateral, this.collateral_token.decimals);
+                        _debt = parseUnits(debt, this.borrowed_token.decimals);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(llamalend.constants.ZERO_ADDRESS, _collateral, _debt, full, range, llamalend.constantOptions)];
+                    case 1:
+                        _health = _a.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.createLoanIsApproved = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, hasAllowance([this.collateral_token.address], [collateral], llamalend.signerAddress, this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.createLoanApproveEstimateGas = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowanceEstimateGas([this.collateral_token.address], [collateral], this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.createLoanApprove = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowance([this.collateral_token.address], [collateral], this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._createLoan = function (collateral, debt, range, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _collateral, _debt, contract, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.userLoanExists()];
+                    case 1:
+                        if (_a.sent())
+                            throw Error("Loan already created");
+                        this._checkRange(range);
+                        _collateral = parseUnits(collateral, this.collateral_token.decimals);
+                        _debt = parseUnits(debt, this.borrowed_token.decimals);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.create_loan.estimateGas(_collateral, _debt, range, __assign({}, llamalend.constantOptions))];
+                    case 2:
+                        gas = _a.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 3:
+                        _a.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.create_loan(_collateral, _debt, range, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 4: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.createLoanEstimateGas = function (collateral, debt, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.createLoanIsApproved(collateral)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._createLoan(collateral, debt, range, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.createLoan = function (collateral, debt, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.createLoanApprove(collateral)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._createLoan(collateral, debt, range, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // ---------------- BORROW MORE ----------------
+    LendMarketTemplate.prototype.borrowMoreMaxRecv = function (collateralAmount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _currentCollateral, _currentDebt, _N, _collateral, contract, _debt;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._userState()];
+                    case 1:
+                        _a = _c.sent(), _currentCollateral = _a._collateral, _currentDebt = _a._debt, _N = _a._N;
+                        _collateral = _currentCollateral + parseUnits(collateralAmount, this.collateral_token.decimals);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.max_borrowable(_collateral, _N, _currentDebt, llamalend.constantOptions)];
+                    case 2:
+                        _debt = _c.sent();
+                        return [2 /*return*/, formatUnits(_debt - _currentDebt, this.borrowed_token.decimals)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._borrowMoreBands = function (collateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _currentCollateral, _currentDebt, _N, _collateral, _debt, _n1, _n2;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._userState()];
+                    case 1:
+                        _a = _c.sent(), _currentCollateral = _a._collateral, _currentDebt = _a._debt, _N = _a._N;
+                        if (_currentDebt === BigInt(0))
+                            throw Error("Loan for ".concat(llamalend.signerAddress, " does not exist"));
+                        _collateral = _currentCollateral + parseUnits(collateral, this.collateral_token.decimals);
+                        _debt = _currentDebt + parseUnits(debt, this.borrowed_token.decimals);
+                        return [4 /*yield*/, this._calcN1(_collateral, _debt, Number(_N))];
+                    case 2:
+                        _n1 = _c.sent();
+                        _n2 = _n1 + _N - BigInt(1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.borrowMoreBands = function (collateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._borrowMoreBands(collateral, debt)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [2 /*return*/, [Number(_n2), Number(_n1)]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.borrowMorePrices = function (collateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._borrowMoreBands(collateral, debt)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [4 /*yield*/, this._getPrices(_n2, _n1)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.borrowMoreHealth = function (collateral, debt, full, address) {
+        if (full === void 0) { full = true; }
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _collateral, _debt, contract, _health;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        _collateral = parseUnits(collateral, this.collateral_token.decimals);
+                        _debt = parseUnits(debt, this.borrowed_token.decimals);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, _collateral, _debt, full, 0, llamalend.constantOptions)];
+                    case 1:
+                        _health = _a.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.borrowMoreIsApproved = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, hasAllowance([this.addresses.collateral_token], [collateral], llamalend.signerAddress, this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.borrowMoreApproveEstimateGas = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowanceEstimateGas([this.addresses.collateral_token], [collateral], this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.borrowMoreApprove = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowance([this.addresses.collateral_token], [collateral], this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._borrowMore = function (collateral, debt, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, borrowed, currentDebt, _collateral, _debt, contract, gas, gasLimit;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.userState()];
+                    case 1:
+                        _a = _c.sent(), borrowed = _a.borrowed, currentDebt = _a.debt;
+                        if (Number(currentDebt) === 0)
+                            throw Error("Loan for ".concat(llamalend.signerAddress, " does not exist"));
+                        if (Number(borrowed) > 0)
+                            throw Error("User ".concat(llamalend.signerAddress, " is already in liquidation mode"));
+                        _collateral = parseUnits(collateral, this.collateral_token.decimals);
+                        _debt = parseUnits(debt, this.borrowed_token.decimals);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.borrow_more.estimateGas(_collateral, _debt, __assign({}, llamalend.constantOptions))];
+                    case 2:
+                        gas = _c.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 3:
+                        _c.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.borrow_more(_collateral, _debt, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 4: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.borrowMoreEstimateGas = function (collateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.borrowMoreIsApproved(collateral)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._borrowMore(collateral, debt, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.borrowMore = function (collateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.borrowMoreApprove(collateral)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._borrowMore(collateral, debt, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // ---------------- ADD COLLATERAL ----------------
+    LendMarketTemplate.prototype._addCollateralBands = function (collateral, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _currentCollateral, _currentDebt, _N, _collateral, _n1, _n2;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this._userState(address)];
+                    case 1:
+                        _a = _c.sent(), _currentCollateral = _a._collateral, _currentDebt = _a._debt, _N = _a._N;
+                        if (_currentDebt === BigInt(0))
+                            throw Error("Loan for ".concat(address, " does not exist"));
+                        _collateral = _currentCollateral + parseUnits(collateral, this.collateral_token.decimals);
+                        return [4 /*yield*/, this._calcN1(_collateral, _currentDebt, Number(_N))];
+                    case 2:
+                        _n1 = _c.sent();
+                        _n2 = _n1 + _N - BigInt(1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.addCollateralBands = function (collateral, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._addCollateralBands(collateral, address)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [2 /*return*/, [Number(_n2), Number(_n1)]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.addCollateralPrices = function (collateral, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._addCollateralBands(collateral, address)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [4 /*yield*/, this._getPrices(_n2, _n1)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.addCollateralHealth = function (collateral, full, address) {
+        if (full === void 0) { full = true; }
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _collateral, contract, _health;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        _collateral = parseUnits(collateral, this.collateral_token.decimals);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, _collateral, 0, full, 0, llamalend.constantOptions)];
+                    case 1:
+                        _health = _a.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.addCollateralIsApproved = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, hasAllowance([this.addresses.collateral_token], [collateral], llamalend.signerAddress, this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.addCollateralApproveEstimateGas = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowanceEstimateGas([this.addresses.collateral_token], [collateral], this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.addCollateralApprove = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowance([this.addresses.collateral_token], [collateral], this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._addCollateral = function (collateral, address, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, borrowed, currentDebt, _collateral, contract, gas, gasLimit;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.userState(address)];
+                    case 1:
+                        _a = _c.sent(), borrowed = _a.borrowed, currentDebt = _a.debt;
+                        if (Number(currentDebt) === 0)
+                            throw Error("Loan for ".concat(address, " does not exist"));
+                        if (Number(borrowed) > 0)
+                            throw Error("User ".concat(address, " is already in liquidation mode"));
+                        _collateral = parseUnits(collateral, this.collateral_token.decimals);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.add_collateral.estimateGas(_collateral, address, __assign({}, llamalend.constantOptions))];
+                    case 2:
+                        gas = _c.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 3:
+                        _c.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.add_collateral(_collateral, address, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 4: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.addCollateralEstimateGas = function (collateral, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this.addCollateralIsApproved(collateral)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._addCollateral(collateral, address, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.addCollateral = function (collateral, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this.addCollateralApprove(collateral)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._addCollateral(collateral, address, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // ---------------- REMOVE COLLATERAL ----------------
+    LendMarketTemplate.prototype.maxRemovable = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _currentCollateral, _currentDebt, _N, _requiredCollateral;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._userState()];
+                    case 1:
+                        _a = _c.sent(), _currentCollateral = _a._collateral, _currentDebt = _a._debt, _N = _a._N;
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.controller].contract.min_collateral(_currentDebt, _N, llamalend.constantOptions)];
+                    case 2:
+                        _requiredCollateral = _c.sent();
+                        return [2 /*return*/, formatUnits(_currentCollateral - _requiredCollateral, this.collateral_token.decimals)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._removeCollateralBands = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _currentCollateral, _currentDebt, _N, _collateral, _n1, _n2;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._userState()];
+                    case 1:
+                        _a = _c.sent(), _currentCollateral = _a._collateral, _currentDebt = _a._debt, _N = _a._N;
+                        if (_currentDebt === BigInt(0))
+                            throw Error("Loan for ".concat(llamalend.signerAddress, " does not exist"));
+                        _collateral = _currentCollateral - parseUnits(collateral, this.collateral_token.decimals);
+                        return [4 /*yield*/, this._calcN1(_collateral, _currentDebt, Number(_N))];
+                    case 2:
+                        _n1 = _c.sent();
+                        _n2 = _n1 + _N - BigInt(1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.removeCollateralBands = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._removeCollateralBands(collateral)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [2 /*return*/, [Number(_n2), Number(_n1)]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.removeCollateralPrices = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._removeCollateralBands(collateral)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [4 /*yield*/, this._getPrices(_n2, _n1)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.removeCollateralHealth = function (collateral, full, address) {
+        if (full === void 0) { full = true; }
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _collateral, contract, _health;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        _collateral = parseUnits(collateral, this.collateral_token.decimals) * BigInt(-1);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, _collateral, 0, full, 0, llamalend.constantOptions)];
+                    case 1:
+                        _health = _a.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._removeCollateral = function (collateral, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, borrowed, currentDebt, _collateral, contract, gas, gasLimit;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.userState()];
+                    case 1:
+                        _a = _c.sent(), borrowed = _a.borrowed, currentDebt = _a.debt;
+                        if (Number(currentDebt) === 0)
+                            throw Error("Loan for ".concat(llamalend.signerAddress, " does not exist"));
+                        if (Number(borrowed) > 0)
+                            throw Error("User ".concat(llamalend.signerAddress, " is already in liquidation mode"));
+                        _collateral = parseUnits(collateral, this.collateral_token.decimals);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.remove_collateral.estimateGas(_collateral, llamalend.constantOptions)];
+                    case 2:
+                        gas = _c.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 3:
+                        _c.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.remove_collateral(_collateral, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 4: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.removeCollateralEstimateGas = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._removeCollateral(collateral, true)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.removeCollateral = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._removeCollateral(collateral, false)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // ---------------- REPAY ----------------
+    LendMarketTemplate.prototype._repayBands = function (debt, address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _currentCollateral, _borrowed, _currentDebt, _N, _debt, _n1, _n2;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._userState(address)];
+                    case 1:
+                        _a = _c.sent(), _currentCollateral = _a._collateral, _borrowed = _a._borrowed, _currentDebt = _a._debt, _N = _a._N;
+                        if (_currentDebt === BigInt(0))
+                            throw Error("Loan for ".concat(address, " does not exist"));
+                        if (!(_borrowed > BigInt(0))) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this._userBands(address)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                    case 3:
+                        _debt = _currentDebt - parseUnits(debt, this.borrowed_token.decimals);
+                        return [4 /*yield*/, this._calcN1(_currentCollateral, _debt, Number(_N))];
+                    case 4:
+                        _n1 = _c.sent();
+                        _n2 = _n1 + _N - BigInt(1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.repayBands = function (debt, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._repayBands(debt, address)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [2 /*return*/, [Number(_n2), Number(_n1)]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.repayPrices = function (debt, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._repayBands(debt, address)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [4 /*yield*/, this._getPrices(_n2, _n1)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.repayIsApproved = function (debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, hasAllowance([this.borrowed_token.address], [debt], llamalend.signerAddress, this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.repayApproveEstimateGas = function (debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowanceEstimateGas([this.borrowed_token.address], [debt], this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.repayApprove = function (debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ensureAllowance([this.borrowed_token.address], [debt], this.addresses.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.repayHealth = function (debt, full, address) {
+        if (full === void 0) { full = true; }
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _debt, contract, _health;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        _debt = parseUnits(debt) * BigInt(-1);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, 0, _debt, full, 0, llamalend.constantOptions)];
+                    case 1:
+                        _health = _a.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._repay = function (debt, address, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var currentDebt, _debt, contract, _a, _, n1, borrowed, n, gas, gasLimit;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this.userState(address)];
+                    case 1:
+                        currentDebt = (_c.sent()).debt;
+                        if (Number(currentDebt) === 0)
+                            throw Error("Loan for ".concat(address, " does not exist"));
+                        _debt = parseUnits(debt);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, this.userBands(address)];
+                    case 2:
+                        _a = _c.sent(), _ = _a[0], n1 = _a[1];
+                        return [4 /*yield*/, this.userState(address)];
+                    case 3:
+                        borrowed = (_c.sent()).borrowed;
+                        n = (BN(borrowed).gt(0)) ? MAX_ACTIVE_BAND : n1 - 1;
+                        return [4 /*yield*/, contract.repay.estimateGas(_debt, address, n, llamalend.constantOptions)];
+                    case 4:
+                        gas = _c.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 5:
+                        _c.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.repay(_debt, address, n, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 6: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.repayEstimateGas = function (debt, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.repayIsApproved(debt)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._repay(debt, address, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.repay = function (debt, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.repayApprove(debt)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._repay(debt, address, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // ---------------- FULL REPAY ----------------
+    LendMarketTemplate.prototype._fullRepayAmount = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var debt;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this.userState(address)];
+                    case 1:
+                        debt = (_a.sent()).debt;
+                        return [2 /*return*/, BN(debt).times(1.0001).toString()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.fullRepayIsApproved = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var fullRepayAmount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this._fullRepayAmount(address)];
+                    case 1:
+                        fullRepayAmount = _a.sent();
+                        return [4 /*yield*/, this.repayIsApproved(fullRepayAmount)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.fullRepayApproveEstimateGas = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var fullRepayAmount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this._fullRepayAmount(address)];
+                    case 1:
+                        fullRepayAmount = _a.sent();
+                        return [4 /*yield*/, this.repayApproveEstimateGas(fullRepayAmount)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.fullRepayApprove = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var fullRepayAmount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this._fullRepayAmount(address)];
+                    case 1:
+                        fullRepayAmount = _a.sent();
+                        return [4 /*yield*/, this.repayApprove(fullRepayAmount)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.fullRepayEstimateGas = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var fullRepayAmount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this._fullRepayAmount(address)];
+                    case 1:
+                        fullRepayAmount = _a.sent();
+                        return [4 /*yield*/, this.repayIsApproved(fullRepayAmount)];
+                    case 2:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._repay(fullRepayAmount, address, true)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.fullRepay = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var fullRepayAmount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this._fullRepayAmount(address)];
+                    case 1:
+                        fullRepayAmount = _a.sent();
+                        return [4 /*yield*/, this.repayApprove(fullRepayAmount)];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this._repay(fullRepayAmount, address, false)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // ---------------- SWAP ----------------
+    LendMarketTemplate.prototype.maxSwappable = function (i, j) {
+        return __awaiter(this, void 0, void 0, function () {
+            var inDecimals, contract, _a, _inAmount, _outAmount;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(i === 0 && j === 1) && !(i === 1 && j === 0))
+                            throw Error("Wrong index");
+                        inDecimals = this.coinDecimals[i];
+                        contract = llamalend.contracts[this.addresses.amm].contract;
+                        return [4 /*yield*/, contract.get_dxdy(i, j, MAX_ALLOWANCE, llamalend.constantOptions)];
+                    case 1:
+                        _a = _c.sent(), _inAmount = _a[0], _outAmount = _a[1];
+                        if (_outAmount === BigInt(0))
+                            return [2 /*return*/, "0"];
+                        return [2 /*return*/, formatUnits(_inAmount, inDecimals)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._swapExpected = function (i, j, _amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, llamalend.contracts[this.addresses.amm].contract.get_dy(i, j, _amount, llamalend.constantOptions)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.swapExpected = function (i, j, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, inDecimals, outDecimals, _amount, _expected;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(i === 0 && j === 1) && !(i === 1 && j === 0))
+                            throw Error("Wrong index");
+                        _a = this.coinDecimals, inDecimals = _a[0], outDecimals = _a[1];
+                        _amount = parseUnits(amount, inDecimals);
+                        return [4 /*yield*/, this._swapExpected(i, j, _amount)];
+                    case 1:
+                        _expected = _c.sent();
+                        return [2 /*return*/, formatUnits(_expected, outDecimals)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.swapRequired = function (i, j, outAmount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, inDecimals, outDecimals, _amount, _expected;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(i === 0 && j === 1) && !(i === 1 && j === 0))
+                            throw Error("Wrong index");
+                        _a = this.coinDecimals, inDecimals = _a[0], outDecimals = _a[1];
+                        _amount = parseUnits(outAmount, outDecimals);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.amm].contract.get_dx(i, j, _amount, llamalend.constantOptions)];
+                    case 1:
+                        _expected = _c.sent();
+                        return [2 /*return*/, formatUnits(_expected, inDecimals)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.swapPriceImpact = function (i, j, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, inDecimals, outDecimals, _amount, _output, target, amountIntBN, outputIntBN, k, smallAmountIntBN, _smallAmount, _smallOutput, amountBN, outputBN, smallAmountBN, smallOutputBN, rateBN, smallRateBN, slippageBN;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(i === 0 && j === 1) && !(i === 1 && j === 0))
+                            throw Error("Wrong index");
+                        _a = this.coinDecimals, inDecimals = _a[0], outDecimals = _a[1];
+                        _amount = parseUnits(amount, inDecimals);
+                        return [4 /*yield*/, this._swapExpected(i, j, _amount)];
+                    case 1:
+                        _output = _c.sent();
+                        target = BN(Math.pow(10, 15));
+                        amountIntBN = BN(amount).times(Math.pow(10, inDecimals));
+                        outputIntBN = toBN(_output, 0);
+                        k = BigNumber.min(BigNumber.max(target.div(amountIntBN), target.div(outputIntBN)), 0.2);
+                        smallAmountIntBN = BigNumber.min(amountIntBN.times(k), BN(Math.pow(10, inDecimals)));
+                        if (smallAmountIntBN.toFixed(0) === '0')
+                            return [2 /*return*/, '0'];
+                        _smallAmount = fromBN(smallAmountIntBN.div(Math.pow(10, inDecimals)), inDecimals);
+                        return [4 /*yield*/, this._swapExpected(i, j, _smallAmount)];
+                    case 2:
+                        _smallOutput = _c.sent();
+                        amountBN = BN(amount);
+                        outputBN = toBN(_output, outDecimals);
+                        smallAmountBN = toBN(_smallAmount, inDecimals);
+                        smallOutputBN = toBN(_smallOutput, outDecimals);
+                        rateBN = outputBN.div(amountBN);
+                        smallRateBN = smallOutputBN.div(smallAmountBN);
+                        if (rateBN.gt(smallRateBN))
+                            return [2 /*return*/, "0"];
+                        slippageBN = BN(1).minus(rateBN.div(smallRateBN)).times(100);
+                        return [2 /*return*/, _cutZeros(slippageBN.toFixed(6))];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.swapIsApproved = function (i, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (i !== 0 && i !== 1)
+                            throw Error("Wrong index");
+                        return [4 /*yield*/, hasAllowance([this.coinAddresses[i]], [amount], llamalend.signerAddress, this.addresses.amm)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.swapApproveEstimateGas = function (i, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (i !== 0 && i !== 1)
+                            throw Error("Wrong index");
+                        return [4 /*yield*/, ensureAllowanceEstimateGas([this.coinAddresses[i]], [amount], this.addresses.amm)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.swapApprove = function (i, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (i !== 0 && i !== 1)
+                            throw Error("Wrong index");
+                        return [4 /*yield*/, ensureAllowance([this.coinAddresses[i]], [amount], this.addresses.amm)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._swap = function (i, j, amount, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, inDecimals, outDecimals, _amount, _expected, minRecvAmountBN, _minRecvAmount, contract, gas, gasLimit;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(i === 0 && j === 1) && !(i === 1 && j === 0))
+                            throw Error("Wrong index");
+                        _a = [this.coinDecimals[i], this.coinDecimals[j]], inDecimals = _a[0], outDecimals = _a[1];
+                        _amount = parseUnits(amount, inDecimals);
+                        return [4 /*yield*/, this._swapExpected(i, j, _amount)];
+                    case 1:
+                        _expected = _c.sent();
+                        minRecvAmountBN = toBN(_expected, outDecimals).times(100 - slippage).div(100);
+                        _minRecvAmount = fromBN(minRecvAmountBN, outDecimals);
+                        contract = llamalend.contracts[this.addresses.amm].contract;
+                        return [4 /*yield*/, contract.exchange.estimateGas(i, j, _amount, _minRecvAmount, llamalend.constantOptions)];
+                    case 2:
+                        gas = _c.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 3:
+                        _c.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.exchange(i, j, _amount, _minRecvAmount, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 4: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.swapEstimateGas = function (i, j, amount, slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.swapIsApproved(i, amount)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._swap(i, j, amount, slippage, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.swap = function (i, j, amount, slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.swapApprove(i, amount)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._swap(i, j, amount, slippage, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // ---------------- LIQUIDATE ----------------
+    LendMarketTemplate.prototype.tokensToLiquidate = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _tokens;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, llamalend.contracts[this.addresses.controller].contract.tokens_to_liquidate(address, llamalend.constantOptions)];
+                    case 1:
+                        _tokens = _a.sent();
+                        return [2 /*return*/, formatUnits(_tokens, this.borrowed_token.decimals)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.liquidateIsApproved = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var tokensToLiquidate;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.tokensToLiquidate(address)];
+                    case 1:
+                        tokensToLiquidate = _a.sent();
+                        return [4 /*yield*/, hasAllowance([this.addresses.borrowed_token], [tokensToLiquidate], llamalend.signerAddress, this.addresses.controller)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.liquidateApproveEstimateGas = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var tokensToLiquidate;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.tokensToLiquidate(address)];
+                    case 1:
+                        tokensToLiquidate = _a.sent();
+                        return [4 /*yield*/, ensureAllowanceEstimateGas([this.addresses.borrowed_token], [tokensToLiquidate], this.addresses.controller)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.liquidateApprove = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var tokensToLiquidate;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.tokensToLiquidate(address)];
+                    case 1:
+                        tokensToLiquidate = _a.sent();
+                        return [4 /*yield*/, ensureAllowance([this.addresses.borrowed_token], [tokensToLiquidate], this.addresses.controller)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._liquidate = function (address, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, borrowed, currentDebt, minAmountBN, _minAmount, contract, gas, gasLimit;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.userState(address)];
+                    case 1:
+                        _a = _c.sent(), borrowed = _a.borrowed, currentDebt = _a.debt;
+                        if (slippage <= 0)
+                            throw Error("Slippage must be > 0");
+                        if (slippage > 100)
+                            throw Error("Slippage must be <= 100");
+                        if (Number(currentDebt) === 0)
+                            throw Error("Loan for ".concat(address, " does not exist"));
+                        if (Number(borrowed) === 0)
+                            throw Error("User ".concat(address, " is not in liquidation mode"));
+                        minAmountBN = BN(borrowed).times(100 - slippage).div(100);
+                        _minAmount = fromBN(minAmountBN);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.liquidate.estimateGas(address, _minAmount, llamalend.constantOptions)];
+                    case 2:
+                        gas = (_c.sent());
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 3:
+                        _c.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.liquidate(address, _minAmount, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 4: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.liquidateEstimateGas = function (address, slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.liquidateIsApproved(address)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._liquidate(address, slippage, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.liquidate = function (address, slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.liquidateApprove(address)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._liquidate(address, slippage, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // ---------------- SELF-LIQUIDATE ----------------
+    LendMarketTemplate.prototype.selfLiquidateIsApproved = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.liquidateIsApproved()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.selfLiquidateApproveEstimateGas = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.liquidateApproveEstimateGas()];
+            });
+        });
+    };
+    LendMarketTemplate.prototype.selfLiquidateApprove = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.liquidateApprove()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.selfLiquidateEstimateGas = function (slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.selfLiquidateIsApproved()];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._liquidate(llamalend.signerAddress, slippage, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.selfLiquidate = function (slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.selfLiquidateApprove()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._liquidate(llamalend.signerAddress, slippage, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._checkLeverageZap = function () {
+        if (!this.hasLeverage()) {
+            throw Error("This market does not support leverage");
+        }
+    };
+    LendMarketTemplate.prototype._get_k_effective_BN = function (N) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, loan_discount, A, A_BN, A_ratio_BN, d_k_effective_BN, S, n;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.statsParameters()];
+                    case 1:
+                        _a = _c.sent(), loan_discount = _a.loan_discount, A = _a.A;
+                        A_BN = BN(A);
+                        A_ratio_BN = A_BN.minus(1).div(A_BN);
+                        d_k_effective_BN = BN(100).minus(loan_discount).div(100).times(A_ratio_BN.sqrt()).div(N);
+                        S = BN(0);
+                        for (n = 0; n < N; n++) {
+                            S = S.plus(A_ratio_BN.pow(n));
+                        }
+                        return [2 /*return*/, d_k_effective_BN.times(S)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.maxLeverage = function (N) {
+        return __awaiter(this, void 0, void 0, function () {
+            var k_effective_BN;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._get_k_effective_BN(N)];
+                    case 1:
+                        k_effective_BN = _a.sent();
+                        return [2 /*return*/, BN(1).div(BN(1).minus(k_effective_BN)).toString()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanMaxRecv = function (userCollateral, userBorrowed, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _userCollateral, _userBorrowed, oraclePriceBand, pAvgBN, _a, maxBorrowablePrevBN, maxBorrowableBN, _userEffectiveCollateral, _maxLeverageCollateral, contract, i, _maxBorrowable, _maxAdditionalCollateral, _c, userEffectiveCollateralBN, maxLeverageCollateralBN;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        // max_borrowable = userCollateral / (1 / (k_effective * max_p_base) - 1 / p_avg)
+                        this._checkLeverageZap();
+                        if (range > 0)
+                            this._checkRange(range);
+                        _userCollateral = parseUnits(userCollateral, this.collateral_token.decimals);
+                        _userBorrowed = parseUnits(userBorrowed, this.borrowed_token.decimals);
+                        return [4 /*yield*/, this.oraclePriceBand()];
+                    case 1:
+                        oraclePriceBand = _d.sent();
+                        _a = BN;
+                        return [4 /*yield*/, this.calcTickPrice(oraclePriceBand)];
+                    case 2:
+                        pAvgBN = _a.apply(void 0, [_d.sent()]);
+                        maxBorrowablePrevBN = BN(0);
+                        maxBorrowableBN = BN(0);
+                        _userEffectiveCollateral = BigInt(0);
+                        _maxLeverageCollateral = BigInt(0);
+                        contract = llamalend.contracts[llamalend.constants.ALIASES.leverage_zap].contract;
+                        i = 0;
+                        _d.label = 3;
+                    case 3:
+                        if (!(i < 5)) return [3 /*break*/, 7];
+                        maxBorrowablePrevBN = maxBorrowableBN;
+                        _userEffectiveCollateral = _userCollateral + fromBN(BN(userBorrowed).div(pAvgBN), this.collateral_token.decimals);
+                        return [4 /*yield*/, contract.max_borrowable(this.addresses.controller, _userEffectiveCollateral, _maxLeverageCollateral, range, fromBN(pAvgBN))];
+                    case 4:
+                        _maxBorrowable = _d.sent();
+                        _maxBorrowable = _maxBorrowable * BigInt(998) / BigInt(1000);
+                        if (_maxBorrowable === BigInt(0))
+                            return [3 /*break*/, 7];
+                        maxBorrowableBN = toBN(_maxBorrowable, this.borrowed_token.decimals);
+                        if (maxBorrowableBN.minus(maxBorrowablePrevBN).abs().div(maxBorrowablePrevBN).lt(0.0005)) {
+                            maxBorrowableBN = maxBorrowablePrevBN;
+                            return [3 /*break*/, 7];
+                        }
+                        _c = BigInt;
+                        return [4 /*yield*/, _getExpectedOdos(this.addresses.borrowed_token, this.addresses.collateral_token, _maxBorrowable + _userBorrowed, this.addresses.amm)];
+                    case 5:
+                        _maxAdditionalCollateral = _c.apply(void 0, [_d.sent()]);
+                        pAvgBN = maxBorrowableBN.plus(userBorrowed).div(toBN(_maxAdditionalCollateral, this.collateral_token.decimals));
+                        _maxLeverageCollateral = _maxAdditionalCollateral - fromBN(BN(userBorrowed).div(pAvgBN), this.collateral_token.decimals);
+                        _d.label = 6;
+                    case 6:
+                        i++;
+                        return [3 /*break*/, 3];
+                    case 7:
+                        userEffectiveCollateralBN = maxBorrowableBN.gt(0) ? toBN(_userEffectiveCollateral, this.collateral_token.decimals) : BN(0);
+                        maxLeverageCollateralBN = toBN(_maxLeverageCollateral, this.collateral_token.decimals);
+                        return [2 /*return*/, {
+                                maxDebt: formatNumber(maxBorrowableBN.toString(), this.borrowed_token.decimals),
+                                maxTotalCollateral: formatNumber(maxLeverageCollateralBN.plus(userEffectiveCollateralBN).toString(), this.collateral_token.decimals),
+                                userCollateral: formatNumber(userCollateral, this.collateral_token.decimals),
+                                collateralFromUserBorrowed: formatNumber(BN(userBorrowed).div(pAvgBN).toString(), this.collateral_token.decimals),
+                                collateralFromMaxDebt: formatNumber(maxLeverageCollateralBN.toString(), this.collateral_token.decimals),
+                                maxLeverage: maxLeverageCollateralBN.plus(userEffectiveCollateralBN).div(userEffectiveCollateralBN).toString(),
+                                avgPrice: pAvgBN.toString(),
+                            }];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanExpectedCollateral = function (userCollateral, userBorrowed, debt, slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _debt, _userBorrowed, _a, _totalCollateral, _userCollateral, _collateralFromUserBorrowed, _collateralFromDebt, avgPrice;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        _debt = parseUnits(debt, this.borrowed_token.decimals);
+                        _userBorrowed = parseUnits(userBorrowed, this.borrowed_token.decimals);
+                        return [4 /*yield*/, this._setSwapDataToCache(this.addresses.borrowed_token, this.addresses.collateral_token, _debt + _userBorrowed, slippage)];
+                    case 1:
+                        _c.sent();
+                        return [4 /*yield*/, this._leverageExpectedCollateral(userCollateral, userBorrowed, debt)];
+                    case 2:
+                        _a = _c.sent(), _totalCollateral = _a._totalCollateral, _userCollateral = _a._userCollateral, _collateralFromUserBorrowed = _a._collateralFromUserBorrowed, _collateralFromDebt = _a._collateralFromDebt, avgPrice = _a.avgPrice;
+                        return [2 /*return*/, {
+                                totalCollateral: formatUnits(_totalCollateral, this.collateral_token.decimals),
+                                userCollateral: formatUnits(_userCollateral, this.collateral_token.decimals),
+                                collateralFromUserBorrowed: formatUnits(_collateralFromUserBorrowed, this.collateral_token.decimals),
+                                collateralFromDebt: formatUnits(_collateralFromDebt, this.collateral_token.decimals),
+                                leverage: toBN(_collateralFromDebt + _userCollateral + _collateralFromUserBorrowed, this.collateral_token.decimals)
+                                    .div(toBN(_userCollateral + _collateralFromUserBorrowed, this.collateral_token.decimals)).toString(),
+                                avgPrice: avgPrice,
+                            }];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanPriceImpact = function (userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _debt, _userBorrowed;
+            return __generator(this, function (_a) {
+                this._checkLeverageZap();
+                _debt = parseUnits(debt, this.borrowed_token.decimals);
+                _userBorrowed = parseUnits(userBorrowed, this.borrowed_token.decimals);
+                return [2 /*return*/, this._getSwapDataFromCache(this.addresses.borrowed_token, _debt + _userBorrowed).priceImpact.toString()];
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanMaxRange = function (userCollateral, userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var maxRecv, N;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this.leverageCreateLoanMaxRecvAllRanges(userCollateral, userBorrowed)];
+                    case 1:
+                        maxRecv = _a.sent();
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            if (BN(debt).gt(maxRecv[N].maxDebt))
+                                return [2 /*return*/, N - 1];
+                        }
+                        return [2 /*return*/, this.maxBands];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._leverageBands = function (userCollateral, userBorrowed, debt, range, user) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _n1, N, _n2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._leverageCalcN1(userCollateral, userBorrowed, debt, range, user)];
+                    case 1:
+                        _n1 = _a.sent();
+                        if (!(range < 0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.userState(user)];
+                    case 2:
+                        N = (_a.sent()).N;
+                        range = Number(N);
+                        _a.label = 3;
+                    case 3:
+                        _n2 = _n1 + BigInt(range - 1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._leverageCreateLoanBandsAllRanges = function (userCollateral, userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var maxN, _n1_arr, _n2_arr, N, _bands, N;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.leverageCreateLoanMaxRange(userCollateral, userBorrowed, debt)];
+                    case 1:
+                        maxN = _a.sent();
+                        return [4 /*yield*/, this._leverageCalcN1AllRanges(userCollateral, userBorrowed, debt, maxN)];
+                    case 2:
+                        _n1_arr = _a.sent();
+                        _n2_arr = [];
+                        for (N = this.minBands; N <= maxN; N++) {
+                            _n2_arr.push(_n1_arr[N - this.minBands] + BigInt(N - 1));
+                        }
+                        _bands = {};
+                        for (N = this.minBands; N <= maxN; N++) {
+                            _bands[N] = [_n2_arr[N - this.minBands], _n1_arr[N - this.minBands]];
+                        }
+                        return [2 /*return*/, _bands];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanBands = function (userCollateral, userBorrowed, debt, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageBands(userCollateral, userBorrowed, debt, range)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [2 /*return*/, [Number(_n2), Number(_n1)]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanBandsAllRanges = function (userCollateral, userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _bands, bands, N;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageCreateLoanBandsAllRanges(userCollateral, userBorrowed, debt)];
+                    case 1:
+                        _bands = _a.sent();
+                        bands = {};
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            if (_bands[N]) {
+                                bands[N] = _bands[N].map(Number);
+                            }
+                            else {
+                                bands[N] = null;
+                            }
+                        }
+                        return [2 /*return*/, bands];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanPrices = function (userCollateral, userBorrowed, debt, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageBands(userCollateral, userBorrowed, debt, range)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [4 /*yield*/, this._getPrices(_n2, _n1)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanPricesAllRanges = function (userCollateral, userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _bands, prices, N, _a, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageCreateLoanBandsAllRanges(userCollateral, userBorrowed, debt)];
+                    case 1:
+                        _bands = _d.sent();
+                        prices = {};
+                        N = this.minBands;
+                        _d.label = 2;
+                    case 2:
+                        if (!(N <= this.maxBands)) return [3 /*break*/, 6];
+                        if (!_bands[N]) return [3 /*break*/, 4];
+                        _a = prices;
+                        _c = N;
+                        return [4 /*yield*/, this._calcPrices.apply(this, _bands[N])];
+                    case 3:
+                        _a[_c] = _d.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        prices[N] = null;
+                        _d.label = 5;
+                    case 5:
+                        N++;
+                        return [3 /*break*/, 2];
+                    case 6: return [2 /*return*/, prices];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype._leverageHealth = function (userCollateral, userBorrowed, dDebt, range, full, user) {
+        if (user === void 0) { user = llamalend.constants.ZERO_ADDRESS; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _totalCollateral, _a, _borrowed, _N, _dDebt, contract, _health;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (range > 0)
+                            this._checkRange(range);
+                        return [4 /*yield*/, this._leverageExpectedCollateral(userCollateral, userBorrowed, dDebt, user)];
+                    case 1:
+                        _totalCollateral = (_c.sent())._totalCollateral;
+                        return [4 /*yield*/, this._userState(user)];
+                    case 2:
+                        _a = _c.sent(), _borrowed = _a._borrowed, _N = _a._N;
+                        if (_borrowed > BigInt(0))
+                            throw Error("User ".concat(user, " is already in liquidation mode"));
+                        if (range < 0)
+                            range = Number(llamalend.formatUnits(_N, 0));
+                        _dDebt = parseUnits(dDebt, this.borrowed_token.decimals);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(user, _totalCollateral, _dDebt, full, range, llamalend.constantOptions)];
+                    case 3:
+                        _health = _c.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanHealth = function (userCollateral, userBorrowed, debt, range, full) {
+        if (full === void 0) { full = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageHealth(userCollateral, userBorrowed, debt, range, full)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanIsApproved = function (userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            var collateralAllowance, borrowedAllowance;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, hasAllowance([this.collateral_token.address], [userCollateral], llamalend.signerAddress, this.addresses.controller)];
+                    case 1:
+                        collateralAllowance = _a.sent();
+                        return [4 /*yield*/, hasAllowance([this.borrowed_token.address], [userBorrowed], llamalend.signerAddress, llamalend.constants.ALIASES.leverage_zap)];
+                    case 2:
+                        borrowedAllowance = _a.sent();
+                        return [2 /*return*/, collateralAllowance && borrowedAllowance];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanApproveEstimateGas = function (userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            var collateralGas, borrowedGas;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, ensureAllowanceEstimateGas([this.collateral_token.address], [userCollateral], this.addresses.controller)];
+                    case 1:
+                        collateralGas = _a.sent();
+                        return [4 /*yield*/, ensureAllowanceEstimateGas([this.borrowed_token.address], [userBorrowed], llamalend.constants.ALIASES.leverage_zap)];
+                    case 2:
+                        borrowedGas = _a.sent();
+                        if (Array.isArray(collateralGas) && Array.isArray(borrowedGas)) {
+                            return [2 /*return*/, [collateralGas[0] + borrowedGas[0], collateralGas[1] + borrowedGas[1]]];
+                        }
+                        else {
+                            return [2 /*return*/, collateralGas + borrowedGas];
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanApprove = function (userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            var collateralApproveTx, borrowedApproveTx;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, ensureAllowance([this.collateral_token.address], [userCollateral], this.addresses.controller)];
+                    case 1:
+                        collateralApproveTx = _a.sent();
+                        return [4 /*yield*/, ensureAllowance([this.borrowed_token.address], [userBorrowed], llamalend.constants.ALIASES.leverage_zap)];
+                    case 2:
+                        borrowedApproveTx = _a.sent();
+                        return [2 /*return*/, __spreadArray(__spreadArray([], collateralApproveTx, true), borrowedApproveTx, true)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanRouteImage = function (userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _userBorrowed, _debt;
+            return __generator(this, function (_a) {
+                this._checkLeverageZap();
+                _userBorrowed = parseUnits(userBorrowed, this.borrowed_token.decimals);
+                _debt = parseUnits(debt, this.borrowed_token.decimals);
+                return [2 /*return*/, this._getSwapDataFromCache(this.addresses.borrowed_token, _debt + _userBorrowed).pathVizImage];
+            });
+        });
+    };
+    LendMarketTemplate.prototype._leverageCreateLoan = function (userCollateral, userBorrowed, debt, range, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _userCollateral, _userBorrowed, _debt, swapData, calldata, contract, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.userLoanExists()];
+                    case 1:
+                        if (_a.sent())
+                            throw Error("Loan already created");
+                        this._checkRange(range);
+                        _userCollateral = parseUnits(userCollateral, this.collateral_token.decimals);
+                        _userBorrowed = parseUnits(userBorrowed, this.borrowed_token.decimals);
+                        _debt = parseUnits(debt, this.borrowed_token.decimals);
+                        swapData = this._getSwapDataFromCache(this.addresses.borrowed_token, _debt + _userBorrowed);
+                        if (slippage !== swapData.slippage)
+                            throw Error("You must call leverage.createLoanExpectedCollateral() with slippage=".concat(slippage, " first"));
+                        return [4 /*yield*/, _assembleTxOdos(swapData.pathId)];
+                    case 2:
+                        calldata = _a.sent();
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.create_loan_extended.estimateGas(_userCollateral, _debt, range, llamalend.constants.ALIASES.leverage_zap, [0, parseUnits(this._getMarketId(), 0), _userBorrowed], calldata, __assign({}, llamalend.constantOptions))];
+                    case 3:
+                        gas = _a.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 4:
+                        _a.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.create_loan_extended(_userCollateral, _debt, range, llamalend.constants.ALIASES.leverage_zap, [0, parseUnits(this._getMarketId(), 0), _userBorrowed], calldata, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 5: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoanEstimateGas = function (userCollateral, userBorrowed, debt, range, slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this.leverageCreateLoanIsApproved(userCollateral, userBorrowed)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._leverageCreateLoan(userCollateral, userBorrowed, debt, range, slippage, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageCreateLoan = function (userCollateral, userBorrowed, debt, range, slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this.leverageCreateLoanApprove(userCollateral, userBorrowed)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._leverageCreateLoan(userCollateral, userBorrowed, debt, range, slippage, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // ---------------- LEVERAGE BORROW MORE ----------------
+    LendMarketTemplate.prototype.leverageBorrowMoreMaxRecv = function (userCollateral, userBorrowed, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _stateCollateral, _stateBorrowed, _stateDebt, _N, _userCollateral, controllerContract, _borrowedFromStateCollateral, _userBorrowed, oraclePriceBand, pAvgBN, _c, maxBorrowablePrevBN, maxBorrowableBN, _userEffectiveCollateral, _maxLeverageCollateral, contract, i, _maxBorrowable_1, _maxAdditionalCollateral, _d, _maxTotalCollateral, _maxBorrowable;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        // max_borrowable = userCollateral / (1 / (k_effective * max_p_base) - 1 / p_avg)
+                        this._checkLeverageZap();
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this._userState(address)];
+                    case 1:
+                        _a = _e.sent(), _stateCollateral = _a._collateral, _stateBorrowed = _a._borrowed, _stateDebt = _a._debt, _N = _a._N;
+                        if (_stateBorrowed > BigInt(0))
+                            throw Error("User ".concat(address, " is already in liquidation mode"));
+                        _userCollateral = parseUnits(userCollateral, this.collateral_token.decimals);
+                        controllerContract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, controllerContract.max_borrowable(_stateCollateral, _N, _stateDebt, llamalend.constantOptions)];
+                    case 2:
+                        _borrowedFromStateCollateral = (_e.sent()) - _stateDebt;
+                        _userBorrowed = _borrowedFromStateCollateral + parseUnits(userBorrowed, this.borrowed_token.decimals);
+                        userBorrowed = formatUnits(_userBorrowed, this.borrowed_token.decimals);
+                        return [4 /*yield*/, this.oraclePriceBand()];
+                    case 3:
+                        oraclePriceBand = _e.sent();
+                        _c = BN;
+                        return [4 /*yield*/, this.calcTickPrice(oraclePriceBand)];
+                    case 4:
+                        pAvgBN = _c.apply(void 0, [_e.sent()]);
+                        maxBorrowablePrevBN = BN(0);
+                        maxBorrowableBN = BN(0);
+                        _userEffectiveCollateral = BigInt(0);
+                        _maxLeverageCollateral = BigInt(0);
+                        contract = llamalend.contracts[llamalend.constants.ALIASES.leverage_zap].contract;
+                        i = 0;
+                        _e.label = 5;
+                    case 5:
+                        if (!(i < 5)) return [3 /*break*/, 9];
+                        maxBorrowablePrevBN = maxBorrowableBN;
+                        _userEffectiveCollateral = _userCollateral + fromBN(BN(userBorrowed).div(pAvgBN), this.collateral_token.decimals);
+                        return [4 /*yield*/, contract.max_borrowable(this.addresses.controller, _userEffectiveCollateral, _maxLeverageCollateral, _N, fromBN(pAvgBN))];
+                    case 6:
+                        _maxBorrowable_1 = _e.sent();
+                        _maxBorrowable_1 = _maxBorrowable_1 * BigInt(998) / BigInt(1000);
+                        if (_maxBorrowable_1 === BigInt(0))
+                            return [3 /*break*/, 9];
+                        maxBorrowableBN = toBN(_maxBorrowable_1, this.borrowed_token.decimals);
+                        if (maxBorrowableBN.minus(maxBorrowablePrevBN).abs().div(maxBorrowablePrevBN).lt(0.0005)) {
+                            maxBorrowableBN = maxBorrowablePrevBN;
+                            return [3 /*break*/, 9];
+                        }
+                        _d = BigInt;
+                        return [4 /*yield*/, _getExpectedOdos(this.addresses.borrowed_token, this.addresses.collateral_token, _maxBorrowable_1 + _userBorrowed, this.addresses.amm)];
+                    case 7:
+                        _maxAdditionalCollateral = _d.apply(void 0, [_e.sent()]);
+                        pAvgBN = maxBorrowableBN.plus(userBorrowed).div(toBN(_maxAdditionalCollateral, this.collateral_token.decimals));
+                        _maxLeverageCollateral = _maxAdditionalCollateral - fromBN(BN(userBorrowed).div(pAvgBN), this.collateral_token.decimals);
+                        _e.label = 8;
+                    case 8:
+                        i++;
+                        return [3 /*break*/, 5];
+                    case 9:
+                        if (maxBorrowableBN.eq(0))
+                            _userEffectiveCollateral = BigInt(0);
+                        _maxTotalCollateral = _userEffectiveCollateral + _maxLeverageCollateral;
+                        return [4 /*yield*/, controllerContract.max_borrowable(_stateCollateral + _maxTotalCollateral, _N, _stateDebt, llamalend.constantOptions)];
+                    case 10:
+                        _maxBorrowable = (_e.sent()) - _stateDebt;
+                        _maxBorrowable = _maxBorrowable * BigInt(998) / BigInt(1000);
+                        return [2 /*return*/, {
+                                maxDebt: formatUnits(_maxBorrowable, this.borrowed_token.decimals),
+                                maxTotalCollateral: formatUnits(_maxTotalCollateral, this.collateral_token.decimals),
+                                userCollateral: formatNumber(userCollateral, this.collateral_token.decimals),
+                                collateralFromUserBorrowed: formatNumber(BN(userBorrowed).div(pAvgBN).toString(), this.collateral_token.decimals),
+                                collateralFromMaxDebt: formatUnits(_maxLeverageCollateral, this.collateral_token.decimals),
+                                avgPrice: pAvgBN.toString(),
+                            }];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageBorrowMoreExpectedCollateral = function (userCollateral, userBorrowed, dDebt, slippage, address) {
+        if (slippage === void 0) { slippage = 0.1; }
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _dDebt, _userBorrowed, _a, _totalCollateral, _userCollateral, _collateralFromUserBorrowed, _collateralFromDebt, avgPrice;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        address = _getAddress(address);
+                        _dDebt = parseUnits(dDebt, this.borrowed_token.decimals);
+                        _userBorrowed = parseUnits(userBorrowed, this.borrowed_token.decimals);
+                        return [4 /*yield*/, this._setSwapDataToCache(this.addresses.borrowed_token, this.addresses.collateral_token, _dDebt + _userBorrowed, slippage)];
+                    case 1:
+                        _c.sent();
+                        return [4 /*yield*/, this._leverageExpectedCollateral(userCollateral, userBorrowed, dDebt, address)];
+                    case 2:
+                        _a = _c.sent(), _totalCollateral = _a._totalCollateral, _userCollateral = _a._userCollateral, _collateralFromUserBorrowed = _a._collateralFromUserBorrowed, _collateralFromDebt = _a._collateralFromDebt, avgPrice = _a.avgPrice;
+                        return [2 /*return*/, {
+                                totalCollateral: formatUnits(_totalCollateral, this.collateral_token.decimals),
+                                userCollateral: formatUnits(_userCollateral, this.collateral_token.decimals),
+                                collateralFromUserBorrowed: formatUnits(_collateralFromUserBorrowed, this.collateral_token.decimals),
+                                collateralFromDebt: formatUnits(_collateralFromDebt, this.collateral_token.decimals),
+                                avgPrice: avgPrice,
+                            }];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageBorrowMorePriceImpact = function (userBorrowed, dDebt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _dDebt, _userBorrowed;
+            return __generator(this, function (_a) {
+                this._checkLeverageZap();
+                _dDebt = parseUnits(dDebt, this.borrowed_token.decimals);
+                _userBorrowed = parseUnits(userBorrowed, this.borrowed_token.decimals);
+                return [2 /*return*/, this._getSwapDataFromCache(this.addresses.borrowed_token, _dDebt + _userBorrowed).priceImpact.toString()];
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageBorrowMoreBands = function (userCollateral, userBorrowed, dDebt, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageBands(userCollateral, userBorrowed, dDebt, -1, address)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [2 /*return*/, [Number(_n2), Number(_n1)]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageBorrowMorePrices = function (userCollateral, userBorrowed, dDebt, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageBands(userCollateral, userBorrowed, dDebt, -1, address)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [4 /*yield*/, this._getPrices(_n2, _n1)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageBorrowMoreHealth = function (userCollateral, userBorrowed, dDebt, full, address) {
+        if (full === void 0) { full = true; }
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this._leverageHealth(userCollateral, userBorrowed, dDebt, -1, full, address)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageBorrowMoreRouteImage = function (userBorrowed, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _userBorrowed, _debt;
+            return __generator(this, function (_a) {
+                this._checkLeverageZap();
+                _userBorrowed = parseUnits(userBorrowed, this.borrowed_token.decimals);
+                _debt = parseUnits(debt, this.borrowed_token.decimals);
+                return [2 /*return*/, this._getSwapDataFromCache(this.addresses.borrowed_token, _debt + _userBorrowed).pathVizImage];
+            });
+        });
+    };
+    LendMarketTemplate.prototype._leverageBorrowMore = function (userCollateral, userBorrowed, debt, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _userCollateral, _userBorrowed, _debt, swapData, calldata, contract, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.userLoanExists()];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Loan does not exist");
+                        _userCollateral = parseUnits(userCollateral, this.collateral_token.decimals);
+                        _userBorrowed = parseUnits(userBorrowed, this.borrowed_token.decimals);
+                        _debt = parseUnits(debt, this.borrowed_token.decimals);
+                        swapData = this._getSwapDataFromCache(this.addresses.borrowed_token, _debt + _userBorrowed);
+                        if (slippage !== swapData.slippage)
+                            throw Error("You must call leverage.borrowMoreExpectedCollateral() with slippage=".concat(slippage, " first"));
+                        return [4 /*yield*/, _assembleTxOdos(swapData.pathId)];
+                    case 2:
+                        calldata = _a.sent();
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.borrow_more_extended.estimateGas(_userCollateral, _debt, llamalend.constants.ALIASES.leverage_zap, [0, parseUnits(this._getMarketId(), 0), _userBorrowed], calldata, __assign({}, llamalend.constantOptions))];
+                    case 3:
+                        gas = _a.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 4:
+                        _a.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.borrow_more_extended(_userCollateral, _debt, llamalend.constants.ALIASES.leverage_zap, [0, parseUnits(this._getMarketId(), 0), _userBorrowed], calldata, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 5: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageBorrowMoreEstimateGas = function (userCollateral, userBorrowed, debt, slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this.leverageCreateLoanIsApproved(userCollateral, userBorrowed)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._leverageBorrowMore(userCollateral, userBorrowed, debt, slippage, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageBorrowMore = function (userCollateral, userBorrowed, debt, slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this.leverageCreateLoanApprove(userCollateral, userBorrowed)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._leverageBorrowMore(userCollateral, userBorrowed, debt, slippage, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepayPriceImpact = function (stateCollateral, userCollateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _stateCollateral, _userCollateral;
+            return __generator(this, function (_a) {
+                this._checkLeverageZap();
+                _stateCollateral = parseUnits(stateCollateral, this.collateral_token.decimals);
+                _userCollateral = parseUnits(userCollateral, this.collateral_token.decimals);
+                if (_stateCollateral + _userCollateral > BigInt(0)) {
+                    return [2 /*return*/, this._getSwapDataFromCache(this.addresses.collateral_token, _stateCollateral + _userCollateral).priceImpact.toString()];
+                }
+                else {
+                    return [2 /*return*/, "0.0"];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepayIsFull = function (stateCollateral, userCollateral, userBorrowed, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _stateBorrowed, _debt, _totalBorrowed;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this._userState(address)];
+                    case 1:
+                        _a = _c.sent(), _stateBorrowed = _a._borrowed, _debt = _a._debt;
+                        _totalBorrowed = this._leverageRepayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed)._totalBorrowed;
+                        return [2 /*return*/, _stateBorrowed + _totalBorrowed > _debt];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepayIsAvailable = function (stateCollateral, userCollateral, userBorrowed, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, collateral, borrowed, debt;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        // 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(address);
+                        return [4 /*yield*/, this.userState(address)];
+                    case 1:
+                        _a = _c.sent(), collateral = _a.collateral, borrowed = _a.borrowed, debt = _a.debt;
+                        // Loan does not exist
+                        if (BN(debt).eq(0))
+                            return [2 /*return*/, false];
+                        // Can't spend more than user has
+                        if (BN(stateCollateral).gt(collateral))
+                            return [2 /*return*/, false];
+                        if (!BN(borrowed).gt(0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.leverageRepayIsFull(stateCollateral, userCollateral, userBorrowed, address)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                    case 3: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepayBands = function (stateCollateral, userCollateral, userBorrowed, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageRepayBands(stateCollateral, userCollateral, userBorrowed, address)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [2 /*return*/, [Number(_n2), Number(_n1)]];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepayPrices = function (stateCollateral, userCollateral, userBorrowed, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _n2, _n1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageRepayBands(stateCollateral, userCollateral, userBorrowed, address)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [4 /*yield*/, this._getPrices(_n2, _n1)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepayHealth = function (stateCollateral, userCollateral, userBorrowed, full, address) {
+        if (full === void 0) { full = true; }
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _stateBorrowed, _debt, _N, _totalBorrowed, _dCollateral, _dDebt, contract, _health;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this._userState(address)];
+                    case 1:
+                        _a = _c.sent(), _stateBorrowed = _a._borrowed, _debt = _a._debt, _N = _a._N;
+                        if (_stateBorrowed > BigInt(0))
+                            return [2 /*return*/, "0.0"];
+                        return [4 /*yield*/, this.leverageRepayIsAvailable(stateCollateral, userCollateral, userBorrowed, address)];
+                    case 2:
+                        if (!(_c.sent()))
+                            return [2 /*return*/, "0.0"];
+                        _totalBorrowed = this._leverageRepayExpectedBorrowed(stateCollateral, userCollateral, userBorrowed)._totalBorrowed;
+                        _dCollateral = parseUnits(stateCollateral, this.collateral_token.decimals) * BigInt(-1);
+                        _dDebt = _totalBorrowed * BigInt(-1);
+                        if (_debt + _dDebt <= BigInt(0))
+                            return [2 /*return*/, "0.0"];
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, _dCollateral, _dDebt, full, _N, llamalend.constantOptions)];
+                    case 3:
+                        _health = _c.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, llamalend.formatUnits(_health)];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepayIsApproved = function (userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, hasAllowance([this.collateral_token.address, this.borrowed_token.address], [userCollateral, userBorrowed], llamalend.signerAddress, llamalend.constants.ALIASES.leverage_zap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepayApproveEstimateGas = function (userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, ensureAllowanceEstimateGas([this.collateral_token.address, this.borrowed_token.address], [userCollateral, userBorrowed], llamalend.constants.ALIASES.leverage_zap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepayApprove = function (userCollateral, userBorrowed) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, ensureAllowance([this.collateral_token.address, this.borrowed_token.address], [userCollateral, userBorrowed], llamalend.constants.ALIASES.leverage_zap)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepayRouteImage = function (stateCollateral, userCollateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _stateCollateral, _userCollateral;
+            return __generator(this, function (_a) {
+                this._checkLeverageZap();
+                _stateCollateral = parseUnits(stateCollateral, this.collateral_token.decimals);
+                _userCollateral = parseUnits(userCollateral, this.collateral_token.decimals);
+                return [2 /*return*/, this._getSwapDataFromCache(this.addresses.collateral_token, _stateCollateral + _userCollateral).pathVizImage];
+            });
+        });
+    };
+    LendMarketTemplate.prototype._leverageRepay = function (stateCollateral, userCollateral, userBorrowed, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _stateCollateral, _userCollateral, _userBorrowed, calldata, swapData, contract, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.userLoanExists()];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Loan does not exist");
+                        _stateCollateral = parseUnits(stateCollateral, this.collateral_token.decimals);
+                        _userCollateral = parseUnits(userCollateral, this.collateral_token.decimals);
+                        _userBorrowed = parseUnits(userBorrowed, this.borrowed_token.decimals);
+                        calldata = "0x";
+                        if (!(_stateCollateral + _userCollateral > BigInt(0))) return [3 /*break*/, 3];
+                        swapData = this._getSwapDataFromCache(this.addresses.collateral_token, _stateCollateral + _userCollateral);
+                        if (slippage !== swapData.slippage)
+                            throw Error("You must call leverage.repayExpectedBorrowed() with slippage=".concat(slippage, " first"));
+                        return [4 /*yield*/, _assembleTxOdos(swapData.pathId)];
+                    case 2:
+                        calldata = _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        console.log('params', [0, parseUnits(this._getMarketId(), 0), _userCollateral, _userBorrowed], calldata);
+                        contract = llamalend.contracts[this.addresses.controller].contract;
+                        return [4 /*yield*/, contract.repay_extended.estimateGas(llamalend.constants.ALIASES.leverage_zap, [0, parseUnits(this._getMarketId(), 0), _userCollateral, _userBorrowed], calldata)];
+                    case 4:
+                        gas = _a.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 5:
+                        _a.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.repay_extended(llamalend.constants.ALIASES.leverage_zap, [0, parseUnits(this._getMarketId(), 0), _userCollateral, _userBorrowed], calldata, __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 6: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepayEstimateGas = function (stateCollateral, userCollateral, userBorrowed, slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this.leverageRepayIsApproved(userCollateral, userBorrowed)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._leverageRepay(stateCollateral, userCollateral, userBorrowed, slippage, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.leverageRepay = function (stateCollateral, userCollateral, userBorrowed, slippage) {
+        if (slippage === void 0) { slippage = 0.1; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this.leverageRepayApprove(userCollateral, userBorrowed)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._leverageRepay(stateCollateral, userCollateral, userBorrowed, slippage, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.currentLeverage = function (userAddress) {
+        if (userAddress === void 0) { userAddress = ''; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, userCollateral, _current_collateral_estimation, total_deposit_from_user, current_collateral_estimation;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        userAddress = _getAddress(userAddress);
+                        return [4 /*yield*/, Promise.all([
+                                _getUserCollateral(llamalend.constants.NETWORK_NAME, this.addresses.controller, userAddress),
+                                llamalend.contracts[this.addresses.amm].contract.get_y_up(userAddress),
+                            ])];
+                    case 1:
+                        _a = _c.sent(), userCollateral = _a[0], _current_collateral_estimation = _a[1];
+                        total_deposit_from_user = userCollateral.total_deposit_from_user;
+                        current_collateral_estimation = llamalend.formatUnits(_current_collateral_estimation, this.collateral_token.decimals);
+                        return [2 /*return*/, BN(current_collateral_estimation).div(total_deposit_from_user).toString()];
+                }
+            });
+        });
+    };
+    LendMarketTemplate.prototype.currentPnL = function (userAddress) {
+        if (userAddress === void 0) { userAddress = ''; }
+        return __awaiter(this, void 0, void 0, function () {
+            var calls, _a, currentCollateralEstimation, userState, oraclePrice, debt, userCollateral, totalDepositUsdValue, currentCollateralEstimationFormatted, oraclePriceFormatted, debtFormatted, currentPosition, percentage;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        userAddress = _getAddress(userAddress);
+                        calls = [
+                            llamalend.contracts[this.addresses.amm].multicallContract.get_y_up(userAddress),
+                            llamalend.contracts[this.addresses.controller].multicallContract.user_state(userAddress, llamalend.constantOptions),
+                            llamalend.contracts[this.addresses.amm].multicallContract.price_oracle(userAddress),
+                        ];
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _a = _c.sent(), currentCollateralEstimation = _a[0], userState = _a[1], oraclePrice = _a[2];
+                        if (!(currentCollateralEstimation || userState || oraclePrice)) {
+                            throw new Error('Multicall error');
+                        }
+                        debt = userState[2];
+                        return [4 /*yield*/, _getUserCollateral(llamalend.constants.NETWORK_NAME, this.addresses.controller, userAddress)];
+                    case 2:
+                        userCollateral = _c.sent();
+                        totalDepositUsdValue = userCollateral.total_deposit_usd_value;
+                        currentCollateralEstimationFormatted = llamalend.formatUnits(currentCollateralEstimation, this.collateral_token.decimals);
+                        oraclePriceFormatted = llamalend.formatUnits(oraclePrice, 18);
+                        debtFormatted = llamalend.formatUnits(debt, 18);
+                        currentPosition = BN(currentCollateralEstimationFormatted)
+                            .times(oraclePriceFormatted)
+                            .minus(debtFormatted)
+                            .toFixed(this.collateral_token.decimals);
+                        percentage = BN(currentPosition)
+                            .div(totalDepositUsdValue)
+                            .minus(1)
+                            .times(100)
+                            .toString();
+                        return [2 /*return*/, {
+                                currentPosition: currentPosition,
+                                deposited: totalDepositUsdValue.toString(),
+                                percentage: percentage,
+                            }];
+                }
+            });
+        });
+    };
+    return LendMarketTemplate;
+}());
+export { LendMarketTemplate };