@curvefi/llamalend-api 1.0.2

package/lib/mintMarkets/MintMarketTemplate.js

@@ -0,0 +1,2998 @@
+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 };
+    }
+};
+import memoize from "memoizee";
+import BigNumber from "bignumber.js";
+import { llamalend } from "../llamalend.js";
+import { _getAddress, parseUnits, BN, toBN, fromBN, getBalances, ensureAllowance, hasAllowance, ensureAllowanceEstimateGas, isEth, _cutZeros, formatUnits, smartNumber, MAX_ALLOWANCE, MAX_ACTIVE_BAND, _mulBy1_3, DIGas, } from "../utils";
+import { _getUserCollateralCrvUsd } from "../external-api.js";
+var MintMarketTemplate = /** @class */ (function () {
+    function MintMarketTemplate(id) {
+        var _this = this;
+        // ---------------- STATS ----------------
+        this.statsParameters = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var llammaContract, controllerContract, monetaryPolicyContract, calls, _a, _fee, _admin_fee, _rate, _mp_rate, _liquidation_discount, _loan_discount, _c, fee, admin_fee, liquidation_discount, loan_discount, rate, future_rate;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        llammaContract = llamalend.contracts[this.address].multicallContract;
+                        controllerContract = llamalend.contracts[this.controller].multicallContract;
+                        monetaryPolicyContract = llamalend.contracts[this.monetaryPolicy].multicallContract;
+                        calls = [
+                            llammaContract.fee(),
+                            llammaContract.admin_fee(),
+                            llammaContract.rate(),
+                            "rate(address)" in llamalend.contracts[this.monetaryPolicy].contract ? monetaryPolicyContract.rate(this.controller) : monetaryPolicyContract.rate(),
+                            controllerContract.liquidation_discount(),
+                            controllerContract.loan_discount(),
+                        ];
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _a = _d.sent(), _fee = _a[0], _admin_fee = _a[1], _rate = _a[2], _mp_rate = _a[3], _liquidation_discount = _a[4], _loan_discount = _a[5];
+                        _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];
+                        rate = String(((Math.pow(2.718281828459, (toBN(_rate).times(365).times(86400)).toNumber())) - 1) * 100);
+                        future_rate = String(((Math.pow(2.718281828459, (toBN(_mp_rate).times(365).times(86400)).toNumber())) - 1) * 100);
+                        return [2 /*return*/, { fee: fee, admin_fee: admin_fee, rate: rate, future_rate: future_rate, liquidation_discount: liquidation_discount, loan_discount: loan_discount }];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        this.statsMaxMinBands = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var llammaContract, calls1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        llammaContract = llamalend.contracts[this.address].multicallContract;
+                        calls1 = [
+                            llammaContract.max_band(),
+                            llammaContract.min_band(),
+                        ];
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls1)];
+                    case 1: return [2 /*return*/, (_a.sent()).map(function (_b) { return _b.toNumber(); })];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this.statsActiveBand = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, llamalend.contracts[this.address].contract.active_band()];
+                    case 1: return [2 /*return*/, (_a.sent()).toNumber()];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this.statsTotalSupply = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var controllerContract, calls, _a, _minted, _redeemed;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        controllerContract = llamalend.contracts[this.controller].multicallContract;
+                        calls = [controllerContract.minted(), controllerContract.redeemed()];
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _a = _c.sent(), _minted = _a[0], _redeemed = _a[1];
+                        return [2 /*return*/, toBN(_minted).minus(toBN(_redeemed)).toString()];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this.statsTotalDebt = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var debt;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, llamalend.contracts[this.controller].contract.total_debt(llamalend.constantOptions)];
+                    case 1:
+                        debt = _a.sent();
+                        return [2 /*return*/, formatUnits(debt)];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this.statsTotalStablecoin = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var stablecoinContract, ammContract, _a, _balance, _fee;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        stablecoinContract = llamalend.contracts[llamalend.address].multicallContract;
+                        ammContract = llamalend.contracts[this.address].multicallContract;
+                        return [4 /*yield*/, llamalend.multicallProvider.all([
+                                stablecoinContract.balanceOf(this.address),
+                                ammContract.admin_fees_x(),
+                            ])];
+                    case 1:
+                        _a = _c.sent(), _balance = _a[0], _fee = _a[1];
+                        return [2 /*return*/, toBN(_balance).minus(toBN(_fee)).toString()];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this.statsTotalCollateral = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var collateralContract, ammContract, _a, _balance, _fee;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        collateralContract = llamalend.contracts[isEth(this.collateral) ? llamalend.constants.WETH : this.collateral].multicallContract;
+                        ammContract = llamalend.contracts[this.address].multicallContract;
+                        return [4 /*yield*/, llamalend.multicallProvider.all([
+                                collateralContract.balanceOf(this.address),
+                                ammContract.admin_fees_y(),
+                            ])];
+                    case 1:
+                        _a = _c.sent(), _balance = _a[0], _fee = _a[1];
+                        return [2 /*return*/, toBN(_balance, this.collateralDecimals).minus(toBN(_fee, this.collateralDecimals)).toString()];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this.statsCapAndAvailable = memoize(function () { return __awaiter(_this, void 0, void 0, function () {
+            var factoryContract, crvusdContract, _a, _cap, _available;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        factoryContract = llamalend.contracts[llamalend.constants.FACTORY].multicallContract;
+                        crvusdContract = llamalend.contracts[llamalend.address].multicallContract;
+                        return [4 /*yield*/, llamalend.multicallProvider.all([
+                                factoryContract.debt_ceiling(this.controller),
+                                crvusdContract.balanceOf(this.controller),
+                            ])];
+                    case 1:
+                        _a = _c.sent(), _cap = _a[0], _available = _a[1];
+                        return [2 /*return*/, { "cap": llamalend.formatUnits(_cap), "available": llamalend.formatUnits(_available) }];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        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.address].contract.get_base_price(llamalend.constantOptions)];
+                    case 1:
+                        _price = _a.sent();
+                        return [2 /*return*/, formatUnits(_price)];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        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.collateralDecimals);
+                        calls = [];
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            calls.push(llamalend.contracts[this.controller].multicallContract.max_borrowable(_collateral, N));
+                        }
+                        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]);
+                        }
+                        return [2 /*return*/, res];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        this.leverageCreateLoanMaxRecvAllRanges = memoize(function (collateral) { return __awaiter(_this, void 0, void 0, function () {
+            var _collateral, calls, N, i, _rawRes, res, N, _res, _maxBorrowable, _maxCollateral, routeIdx, maxBorrowable, maxCollateral;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        calls = [];
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            for (i = 0; i < 5; i++) {
+                                calls.push(llamalend.contracts[this.leverageZap].multicallContract.max_borrowable_and_collateral(_collateral, N, i));
+                            }
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _rawRes = _a.sent();
+                        res = {};
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            _res = _rawRes.splice(0, 5);
+                            _maxBorrowable = _res.map(function (r) { return r[0] * BigInt(999) / BigInt(1000); });
+                            _maxCollateral = _res.map(function (r) { return r[1] * BigInt(999) / BigInt(1000); });
+                            routeIdx = this._getBestIdx(_maxCollateral);
+                            maxBorrowable = llamalend.formatUnits(_maxBorrowable[routeIdx]);
+                            maxCollateral = llamalend.formatUnits(_maxCollateral[routeIdx], this.collateralDecimals);
+                            res[N] = {
+                                maxBorrowable: maxBorrowable,
+                                maxCollateral: maxCollateral,
+                                leverage: BN(maxCollateral).div(collateral).toFixed(4),
+                                routeIdx: routeIdx,
+                            };
+                        }
+                        return [2 /*return*/, res];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        this._leverageCreateLoanMaxRecvAllRanges2 = memoize(function (collateral, routeIdx) { return __awaiter(_this, void 0, void 0, function () {
+            var _collateral, calls, N, _res, res, N, maxBorrowable, maxCollateral;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        calls = [];
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            calls.push(llamalend.contracts[this.leverageZap].multicallContract.max_borrowable_and_collateral(_collateral, N, routeIdx));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _res = _a.sent();
+                        res = {};
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            maxBorrowable = llamalend.formatUnits(_res[N - this.minBands][0] * BigInt(999) / BigInt(1000));
+                            maxCollateral = llamalend.formatUnits(_res[N - this.minBands][1] * BigInt(999) / BigInt(1000), this.collateralDecimals);
+                            res[N] = {
+                                maxBorrowable: maxBorrowable,
+                                maxCollateral: maxCollateral,
+                                leverage: BN(maxCollateral).div(collateral).toFixed(4),
+                            };
+                        }
+                        return [2 /*return*/, res];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        this._leverageCreateLoanCollateral = memoize(function (userCollateral, debt) { return __awaiter(_this, void 0, void 0, function () {
+            var _userCollateral, _debt, calls, i, _leverageCollateral, routeIdx;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _userCollateral = parseUnits(userCollateral, this.collateralDecimals);
+                        _debt = parseUnits(debt);
+                        calls = [];
+                        for (i = 0; i < 5; i++) {
+                            calls.push(llamalend.contracts[this.leverageZap].multicallContract.get_collateral(_debt, i));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _leverageCollateral = _a.sent();
+                        routeIdx = this._getBestIdx(_leverageCollateral);
+                        return [2 /*return*/, { _collateral: _userCollateral + _leverageCollateral[routeIdx], routeIdx: routeIdx }];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        this.deleverageRepayStablecoins = memoize(function (collateral) { return __awaiter(_this, void 0, void 0, function () {
+            var _collateral, calls, i, _stablecoins_arr, routeIdx, stablecoins;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkDeleverageZap();
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        calls = [];
+                        for (i = 0; i < 5; i++) {
+                            calls.push(llamalend.contracts[this.deleverageZap].multicallContract.get_stablecoins(_collateral, i));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _stablecoins_arr = _a.sent();
+                        routeIdx = this._getBestIdx(_stablecoins_arr);
+                        stablecoins = llamalend.formatUnits(_stablecoins_arr[routeIdx]);
+                        return [2 /*return*/, { stablecoins: stablecoins, routeIdx: routeIdx }];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        this._deleverageRepayBands = memoize(function (collateral, address) { return __awaiter(_this, void 0, void 0, function () {
+            var routeIdx, _currentDebt, N, _collateral, _n1, _n2, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this.deleverageIsAvailable(collateral, address)];
+                    case 1:
+                        if (!(_a.sent()))
+                            return [2 /*return*/, [parseUnits(0, 0), parseUnits(0, 0)]];
+                        return [4 /*yield*/, this.deleverageRepayStablecoins(collateral)];
+                    case 2:
+                        routeIdx = (_a.sent()).routeIdx;
+                        return [4 /*yield*/, this._userState(address)];
+                    case 3:
+                        _currentDebt = (_a.sent())._debt;
+                        if (_currentDebt === BigInt(0))
+                            throw Error("Loan for ".concat(address, " does not exist"));
+                        return [4 /*yield*/, this.userRange(address)];
+                    case 4:
+                        N = _a.sent();
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        _n1 = parseUnits(0, 0);
+                        _n2 = parseUnits(0, 0);
+                        _a.label = 5;
+                    case 5:
+                        _a.trys.push([5, 7, , 8]);
+                        return [4 /*yield*/, llamalend.contracts[this.deleverageZap].contract.calculate_debt_n1(_collateral, routeIdx, address)];
+                    case 6:
+                        _n1 = _a.sent();
+                        _n2 = _n1 + BigInt(N - 1);
+                        return [3 /*break*/, 8];
+                    case 7:
+                        e_1 = _a.sent();
+                        console.log("Full repayment");
+                        return [3 /*break*/, 8];
+                    case 8: return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        }); }, {
+            promise: true,
+            maxAge: 5 * 60 * 1000, // 5m
+        });
+        var llammaData = llamalend.constants.LLAMMAS[id];
+        this.id = id;
+        this.address = llammaData.amm_address;
+        this.controller = llammaData.controller_address;
+        this.monetaryPolicy = llammaData.monetary_policy_address;
+        this.collateral = llammaData.collateral_address;
+        this.leverageZap = llammaData.leverage_zap;
+        this.deleverageZap = llammaData.deleverage_zap;
+        this.healthCalculator = llammaData.health_calculator_zap;
+        this.collateralSymbol = llammaData.collateral_symbol;
+        this.collateralDecimals = llammaData.collateral_decimals;
+        this.coins = ["crvUSD", llammaData.collateral_symbol];
+        this.coinAddresses = [llamalend.address, llammaData.collateral_address];
+        this.coinDecimals = [18, llammaData.collateral_decimals];
+        this.minBands = llammaData.min_bands;
+        this.maxBands = llammaData.max_bands;
+        this.defaultBands = llammaData.default_bands;
+        this.A = llammaData.A;
+        this.tickSpace = 1 / llammaData.A * 100;
+        this.estimateGas = {
+            createLoanApprove: this.createLoanApproveEstimateGas.bind(this),
+            createLoan: this.createLoanEstimateGas.bind(this),
+            addCollateralApprove: this.addCollateralApproveEstimateGas.bind(this),
+            addCollateral: this.addCollateralEstimateGas.bind(this),
+            borrowMoreApprove: this.borrowMoreApproveEstimateGas.bind(this),
+            borrowMore: this.borrowMoreEstimateGas.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),
+            balances: this.statsBalances.bind(this),
+            maxMinBands: this.statsMaxMinBands.bind(this),
+            activeBand: this.statsActiveBand.bind(this),
+            liquidatingBand: this.statsLiquidatingBand.bind(this),
+            bandBalances: this.statsBandBalances.bind(this),
+            bandsBalances: this.statsBandsBalances.bind(this),
+            totalSupply: this.statsTotalSupply.bind(this),
+            totalDebt: this.statsTotalDebt.bind(this),
+            totalStablecoin: this.statsTotalStablecoin.bind(this),
+            totalCollateral: this.statsTotalCollateral.bind(this),
+            capAndAvailable: this.statsCapAndAvailable.bind(this),
+        };
+        this.wallet = {
+            balances: this.walletBalances.bind(this),
+        };
+        this.leverage = {
+            createLoanMaxRecv: this.leverageCreateLoanMaxRecv.bind(this),
+            createLoanMaxRecvAllRanges: this.leverageCreateLoanMaxRecvAllRanges.bind(this),
+            createLoanCollateral: this.leverageCreateLoanCollateral.bind(this),
+            getRouteName: this.leverageGetRouteName.bind(this),
+            getMaxRange: this.leverageGetMaxRange.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.createLoanIsApproved.bind(this),
+            createLoanApprove: this.createLoanApprove.bind(this),
+            priceImpact: this.leveragePriceImpact.bind(this),
+            createLoan: this.leverageCreateLoan.bind(this),
+            estimateGas: {
+                createLoanApprove: this.createLoanApproveEstimateGas.bind(this),
+                createLoan: this.leverageCreateLoanEstimateGas.bind(this),
+            },
+        };
+        this.deleverage = {
+            repayStablecoins: this.deleverageRepayStablecoins.bind(this),
+            getRouteName: this.deleverageGetRouteName.bind(this),
+            isAvailable: this.deleverageIsAvailable.bind(this),
+            isFullRepayment: this.deleverageIsFullRepayment.bind(this),
+            repayBands: this.deleverageRepayBands.bind(this),
+            repayPrices: this.deleverageRepayPrices.bind(this),
+            repayHealth: this.deleverageRepayHealth.bind(this),
+            priceImpact: this.deleveragePriceImpact.bind(this),
+            repay: this.deleverageRepay.bind(this),
+            estimateGas: {
+                repay: this.deleverageRepayEstimateGas.bind(this),
+            },
+        };
+    }
+    MintMarketTemplate.prototype.statsBalances = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var crvusdContract, collateralContract, contract, calls, _a, _crvusdBalance, _collateralBalance, _crvusdAdminFees, _collateralAdminFees;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        crvusdContract = llamalend.contracts[llamalend.address].multicallContract;
+                        collateralContract = llamalend.contracts[isEth(this.collateral) ? llamalend.constants.WETH : this.collateral].multicallContract;
+                        contract = llamalend.contracts[this.address].multicallContract;
+                        calls = [
+                            crvusdContract.balanceOf(this.address),
+                            collateralContract.balanceOf(this.address),
+                            contract.admin_fees_x(),
+                            contract.admin_fees_y(),
+                        ];
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _a = _c.sent(), _crvusdBalance = _a[0], _collateralBalance = _a[1], _crvusdAdminFees = _a[2], _collateralAdminFees = _a[3];
+                        return [2 /*return*/, [
+                                formatUnits(_crvusdBalance - _crvusdAdminFees),
+                                formatUnits(_collateralBalance - _collateralAdminFees, this.collateralDecimals),
+                            ]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.statsLiquidatingBand = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var activeBand, _a, stablecoin, collateral;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.statsActiveBand()];
+                    case 1:
+                        activeBand = _c.sent();
+                        return [4 /*yield*/, this.statsBandBalances(activeBand)];
+                    case 2:
+                        _a = _c.sent(), stablecoin = _a.stablecoin, collateral = _a.collateral;
+                        if (Number(stablecoin) > 0 && Number(collateral) > 0)
+                            return [2 /*return*/, activeBand];
+                        return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.statsBandBalances = function (n) {
+        return __awaiter(this, void 0, void 0, function () {
+            var llammaContract, calls, _balances;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        llammaContract = llamalend.contracts[this.address].multicallContract;
+                        calls = [];
+                        calls.push(llammaContract.bands_x(n), llammaContract.bands_y(n));
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _balances = _a.sent();
+                        return [2 /*return*/, {
+                                stablecoin: formatUnits(_balances[0]),
+                                collateral: formatUnits(_balances[1], this.collateralDecimals),
+                            }];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.statsBandsBalances = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, max_band, min_band, llammaContract, calls, i, _bands, bands, i, _i, collateral;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.statsMaxMinBands()];
+                    case 1:
+                        _a = _c.sent(), max_band = _a[0], min_band = _a[1];
+                        llammaContract = llamalend.contracts[this.address].multicallContract;
+                        calls = [];
+                        for (i = min_band; i <= max_band; i++) {
+                            calls.push(llammaContract.bands_x(i), llammaContract.bands_y(i));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 2:
+                        _bands = _c.sent();
+                        bands = {};
+                        for (i = min_band; i <= max_band; i++) {
+                            _i = i - min_band;
+                            collateral = formatUnits(_bands[(2 * _i) + 1]);
+                            collateral = collateral.split(".")[0] + "." +
+                                (collateral.split(".")[1] || "0").slice(0, this.collateralDecimals);
+                            bands[i] = {
+                                stablecoin: formatUnits(_bands[2 * _i]),
+                                collateral: collateral,
+                            };
+                        }
+                        return [2 /*return*/, bands];
+                }
+            });
+        });
+    };
+    // ---------------------------------------
+    MintMarketTemplate.prototype.loanExists = 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.controller].contract.loan_exists(address, llamalend.constantOptions)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.userDebt = 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*/, llamalend.contracts[this.controller].contract.debt(address, llamalend.constantOptions)];
+                    case 1:
+                        debt = _a.sent();
+                        return [2 /*return*/, formatUnits(debt)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.controller].contract.health(address, full, llamalend.constantOptions)];
+                    case 1:
+                        _health = _a.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.userBands = function (address) {
+        if (address === void 0) { 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.address].contract.read_user_tick_numbers(address, llamalend.constantOptions)];
+                    case 1:
+                        _bands = _a.sent();
+                        return [2 /*return*/, _bands.map(function (_t) { return _t.toNumber(); }).reverse()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.controller].contract.user_prices(address, llamalend.constantOptions)];
+                    case 1:
+                        _prices = _a.sent();
+                        return [2 /*return*/, _prices.map(function (_p) { return formatUnits(_p); }).reverse()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._userState = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var contract, _a, _collateral, _stablecoin, _debt;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        contract = llamalend.contracts[this.controller].contract;
+                        return [4 /*yield*/, contract.user_state(address, llamalend.constantOptions)];
+                    case 1:
+                        _a = _c.sent(), _collateral = _a[0], _stablecoin = _a[1], _debt = _a[2];
+                        return [2 /*return*/, { _collateral: _collateral, _stablecoin: _stablecoin, _debt: _debt }];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.userState = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _collateral, _stablecoin, _debt;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._userState(address)];
+                    case 1:
+                        _a = _c.sent(), _collateral = _a._collateral, _stablecoin = _a._stablecoin, _debt = _a._debt;
+                        return [2 /*return*/, {
+                                collateral: formatUnits(_collateral, this.collateralDecimals),
+                                stablecoin: formatUnits(_stablecoin),
+                                debt: formatUnits(_debt),
+                            }];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.userLoss = function (userAddress) {
+        if (userAddress === void 0) { userAddress = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, deposited_collateral, _current_collateral_estimation, current_collateral_estimation, loss, loss_pct;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        userAddress = _getAddress(userAddress);
+                        return [4 /*yield*/, Promise.all([
+                                _getUserCollateralCrvUsd(llamalend.constants.NETWORK_NAME, this.controller, userAddress),
+                                llamalend.contracts[this.address].contract.get_y_up(userAddress),
+                            ])];
+                    case 1:
+                        _a = _c.sent(), deposited_collateral = _a[0], _current_collateral_estimation = _a[1];
+                        current_collateral_estimation = llamalend.formatUnits(_current_collateral_estimation, this.collateralDecimals);
+                        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,
+                            }];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.userBandsBalances = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, n2, n1, contract, _c, _stablecoins, _collaterals, 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.address].contract;
+                        return [4 /*yield*/, contract.get_xy(address, llamalend.constantOptions)];
+                    case 2:
+                        _c = _d.sent(), _stablecoins = _c[0], _collaterals = _c[1];
+                        res = {};
+                        for (i = n1; i <= n2; i++) {
+                            res[i] = {
+                                stablecoin: formatUnits(_stablecoins[i - n1], 18),
+                                collateral: formatUnits(_collaterals[i - n1], this.collateralDecimals),
+                            };
+                        }
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.oraclePrice = 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.address].contract.price_oracle(llamalend.constantOptions)];
+                    case 1:
+                        _price = _a.sent();
+                        return [2 /*return*/, formatUnits(_price)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.oraclePriceBand = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var oraclePriceBN, _a, basePriceBN, _c, A_BN, multiplier, term, compareFunc, band, currentTickPriceBN;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _a = BN;
+                        return [4 /*yield*/, this.oraclePrice()];
+                    case 1:
+                        oraclePriceBN = _a.apply(void 0, [_d.sent()]);
+                        _c = BN;
+                        return [4 /*yield*/, this.basePrice()];
+                    case 2:
+                        basePriceBN = _c.apply(void 0, [_d.sent()]);
+                        A_BN = BN(this.A);
+                        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];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.address].contract.get_p(llamalend.constantOptions)];
+                    case 1:
+                        _price = _a.sent();
+                        return [2 /*return*/, formatUnits(_price)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.calcTickPrice = function (n) {
+        return __awaiter(this, void 0, void 0, function () {
+            var basePrice, basePriceBN, A_BN;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.basePrice()];
+                    case 1:
+                        basePrice = _a.sent();
+                        basePriceBN = BN(basePrice);
+                        A_BN = BN(this.A);
+                        return [2 /*return*/, _cutZeros(basePriceBN.times(A_BN.minus(1).div(A_BN).pow(n)).toFixed(18))];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()])];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.calcRangePct = function (range) {
+        /**
+         * Calculates range in terms of price difference %
+         * @param  {number} range Number of bands in range
+         * @return {string}       Range in %
+         */
+        var A_BN = BN(this.A);
+        var startBN = BN(1);
+        var endBN = A_BN.minus(1).div(A_BN).pow(range);
+        return startBN.minus(endBN).times(100).toString();
+    };
+    // ---------------- WALLET BALANCES ----------------
+    MintMarketTemplate.prototype.walletBalances = function (address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, collateral, stablecoin;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, getBalances([this.collateral, llamalend.address], address)];
+                    case 1:
+                        _a = _c.sent(), collateral = _a[0], stablecoin = _a[1];
+                        return [2 /*return*/, { stablecoin: stablecoin, collateral: collateral }];
+                }
+            });
+        });
+    };
+    // ---------------- CREATE LOAN ----------------
+    MintMarketTemplate.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));
+    };
+    MintMarketTemplate.prototype.createLoanMaxRecv = function (collateral, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _collateral, _a;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkRange(range);
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        _a = formatUnits;
+                        return [4 /*yield*/, llamalend.contracts[this.controller].contract.max_borrowable(_collateral, range, llamalend.constantOptions)];
+                    case 1: return [2 /*return*/, _a.apply(void 0, [_c.sent()])];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.controller].contract.calculate_debt_n1(_collateral, _debt, range, llamalend.constantOptions)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.controller].multicallContract.calculate_debt_n1(_collateral, _debt, N));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.address].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); })];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()])];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.collateralDecimals), parseUnits(debt), range)];
+                    case 1:
+                        _n1 = _a.sent();
+                        _n2 = _n1 + BigInt(range - 1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.collateralDecimals), parseUnits(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));
+                        }
+                        res = {};
+                        for (N = this.minBands; N <= maxN; N++) {
+                            res[N] = [_n2_arr[N - this.minBands], _n1_arr[N - this.minBands]];
+                        }
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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)]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.createLoanHealth = function (collateral, debt, range, full, address) {
+        var _a;
+        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 (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        _debt = parseUnits(debt);
+                        contract = llamalend.contracts[(_a = this.healthCalculator) !== null && _a !== void 0 ? _a : this.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, _collateral, _debt, full, range, llamalend.constantOptions)];
+                    case 1:
+                        _health = _c.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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], [collateral], llamalend.signerAddress, this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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], [collateral], this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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], [collateral], this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._createLoan = function (collateral, debt, range, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _collateral, _debt, contract, value, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.loanExists()];
+                    case 1:
+                        if (_a.sent())
+                            throw Error("Loan already created");
+                        this._checkRange(range);
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        _debt = parseUnits(debt);
+                        contract = llamalend.contracts[this.controller].contract;
+                        value = isEth(this.collateral) ? _collateral : llamalend.parseUnits("0");
+                        return [4 /*yield*/, contract.create_loan.estimateGas(_collateral, _debt, range, __assign(__assign({}, llamalend.constantOptions), { value: value }))];
+                    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, value: value }))];
+                    case 4: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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 ----------------
+    MintMarketTemplate.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;
+                        return [4 /*yield*/, this.userRange()];
+                    case 2:
+                        N = _c.sent();
+                        _collateral = _currentCollateral + parseUnits(collateralAmount, this.collateralDecimals);
+                        contract = llamalend.contracts[this.controller].contract;
+                        return [4 /*yield*/, contract.max_borrowable(_collateral, N, llamalend.constantOptions)];
+                    case 3:
+                        _debt = _c.sent();
+                        return [2 /*return*/, formatUnits(_debt - _currentDebt)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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;
+                        if (_currentDebt === BigInt(0))
+                            throw Error("Loan for ".concat(llamalend.signerAddress, " does not exist"));
+                        return [4 /*yield*/, this.userRange()];
+                    case 2:
+                        N = _c.sent();
+                        _collateral = _currentCollateral + parseUnits(collateral, this.collateralDecimals);
+                        _debt = _currentDebt + parseUnits(debt);
+                        return [4 /*yield*/, this._calcN1(_collateral, _debt, N)];
+                    case 3:
+                        _n1 = _c.sent();
+                        _n2 = _n1 + BigInt(N - 1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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)]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.borrowMoreHealth = function (collateral, debt, full, address) {
+        var _a;
+        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 (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        _debt = parseUnits(debt);
+                        contract = llamalend.contracts[(_a = this.healthCalculator) !== null && _a !== void 0 ? _a : this.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, _collateral, _debt, full, 0, llamalend.constantOptions)];
+                    case 1:
+                        _health = _c.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.collateral], [collateral], llamalend.signerAddress, this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.collateral], [collateral], this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.collateral], [collateral], this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._borrowMore = function (collateral, debt, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, stablecoin, currentDebt, _collateral, _debt, contract, value, gas, gasLimit;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.userState()];
+                    case 1:
+                        _a = _c.sent(), stablecoin = _a.stablecoin, currentDebt = _a.debt;
+                        if (Number(currentDebt) === 0)
+                            throw Error("Loan for ".concat(llamalend.signerAddress, " does not exist"));
+                        if (Number(stablecoin) > 0)
+                            throw Error("User ".concat(llamalend.signerAddress, " is already in liquidation mode"));
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        _debt = parseUnits(debt);
+                        contract = llamalend.contracts[this.controller].contract;
+                        value = isEth(this.collateral) ? _collateral : llamalend.parseUnits("0");
+                        return [4 /*yield*/, contract.borrow_more.estimateGas(_collateral, _debt, __assign(__assign({}, llamalend.constantOptions), { value: value }))];
+                    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, value: value }))];
+                    case 4: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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 ----------------
+    MintMarketTemplate.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;
+                        if (_currentDebt === BigInt(0))
+                            throw Error("Loan for ".concat(address, " does not exist"));
+                        return [4 /*yield*/, this.userRange(address)];
+                    case 2:
+                        N = _c.sent();
+                        _collateral = _currentCollateral + parseUnits(collateral, this.collateralDecimals);
+                        return [4 /*yield*/, this._calcN1(_collateral, _currentDebt, N)];
+                    case 3:
+                        _n1 = _c.sent();
+                        _n2 = _n1 + BigInt(N - 1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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)]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.addCollateralHealth = function (collateral, full, address) {
+        var _a;
+        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 (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        contract = llamalend.contracts[(_a = this.healthCalculator) !== null && _a !== void 0 ? _a : this.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, _collateral, 0, full, 0, llamalend.constantOptions)];
+                    case 1:
+                        _health = _c.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.collateral], [collateral], llamalend.signerAddress, this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.collateral], [collateral], this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.collateral], [collateral], this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._addCollateral = function (collateral, address, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, stablecoin, currentDebt, _collateral, contract, value, gas, gasLimit;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.userState(address)];
+                    case 1:
+                        _a = _c.sent(), stablecoin = _a.stablecoin, currentDebt = _a.debt;
+                        if (Number(currentDebt) === 0)
+                            throw Error("Loan for ".concat(address, " does not exist"));
+                        if (Number(stablecoin) > 0)
+                            throw Error("User ".concat(address, " is already in liquidation mode"));
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        contract = llamalend.contracts[this.controller].contract;
+                        value = isEth(this.collateral) ? _collateral : llamalend.parseUnits("0");
+                        return [4 /*yield*/, contract.add_collateral.estimateGas(_collateral, address, __assign(__assign({}, llamalend.constantOptions), { value: value }))];
+                    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, value: value }))];
+                    case 4: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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 ----------------
+    MintMarketTemplate.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;
+                        return [4 /*yield*/, this.userRange()];
+                    case 2:
+                        N = _c.sent();
+                        return [4 /*yield*/, llamalend.contracts[this.controller].contract.min_collateral(_currentDebt, N, llamalend.constantOptions)];
+                    case 3:
+                        _requiredCollateral = _c.sent();
+                        return [2 /*return*/, formatUnits(_currentCollateral - _requiredCollateral, this.collateralDecimals)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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;
+                        if (_currentDebt === BigInt(0))
+                            throw Error("Loan for ".concat(llamalend.signerAddress, " does not exist"));
+                        return [4 /*yield*/, this.userRange()];
+                    case 2:
+                        N = _c.sent();
+                        _collateral = _currentCollateral - parseUnits(collateral, this.collateralDecimals);
+                        return [4 /*yield*/, this._calcN1(_collateral, _currentDebt, N)];
+                    case 3:
+                        _n1 = _c.sent();
+                        _n2 = _n1 + BigInt(N - 1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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)]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.removeCollateralHealth = function (collateral, full, address) {
+        var _a;
+        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 (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        _collateral = parseUnits(collateral, this.collateralDecimals) * BigInt(-1);
+                        contract = llamalend.contracts[(_a = this.healthCalculator) !== null && _a !== void 0 ? _a : this.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, _collateral, 0, full, 0, llamalend.constantOptions)];
+                    case 1:
+                        _health = _c.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._removeCollateral = function (collateral, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, stablecoin, 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(), stablecoin = _a.stablecoin, currentDebt = _a.debt;
+                        if (Number(currentDebt) === 0)
+                            throw Error("Loan for ".concat(llamalend.signerAddress, " does not exist"));
+                        if (Number(stablecoin) > 0)
+                            throw Error("User ".concat(llamalend.signerAddress, " is already in liquidation mode"));
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        contract = llamalend.contracts[this.controller].contract;
+                        return [4 /*yield*/, contract.remove_collateral.estimateGas(_collateral, isEth(this.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, isEth(this.collateral), __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 4: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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 ----------------
+    MintMarketTemplate.prototype._repayBands = function (debt, address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _currentCollateral, _currentDebt, _currentStablecoin, N, _debt, _n1, _c, _n2;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this._userState(address)];
+                    case 1:
+                        _a = _d.sent(), _currentCollateral = _a._collateral, _currentDebt = _a._debt, _currentStablecoin = _a._stablecoin;
+                        if (_currentDebt === BigInt(0))
+                            throw Error("Loan for ".concat(address, " does not exist"));
+                        return [4 /*yield*/, this.userRange(address)];
+                    case 2:
+                        N = _d.sent();
+                        _debt = _currentDebt - parseUnits(debt);
+                        if (!(_currentStablecoin === BigInt(0))) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this._calcN1(_currentCollateral, _debt, N)];
+                    case 3:
+                        _c = _d.sent();
+                        return [3 /*break*/, 6];
+                    case 4: return [4 /*yield*/, llamalend.contracts[this.address].contract.read_user_tick_numbers(address, llamalend.constantOptions)];
+                    case 5:
+                        _c = (_d.sent())[0];
+                        _d.label = 6;
+                    case 6:
+                        _n1 = _c;
+                        _n2 = _n1 + BigInt(N - 1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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)]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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([llamalend.address], [debt], llamalend.signerAddress, this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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([llamalend.address], [debt], this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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([llamalend.address], [debt], this.controller)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.repayHealth = function (debt, full, address) {
+        var _a;
+        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 (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        _debt = parseUnits(debt) * BigInt(-1);
+                        contract = llamalend.contracts[(_a = this.healthCalculator) !== null && _a !== void 0 ? _a : this.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, 0, _debt, full, 0, llamalend.constantOptions)];
+                    case 1:
+                        _health = _c.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._repay = function (debt, address, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var currentDebt, _debt, contract, _a, _, n1, stablecoin, 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.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:
+                        stablecoin = (_c.sent()).stablecoin;
+                        n = (BN(stablecoin).gt(0)) ? MAX_ACTIVE_BAND : n1 - 1;
+                        return [4 /*yield*/, contract.repay.estimateGas(_debt, address, n, isEth(this.collateral), 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, isEth(this.collateral), __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 6: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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 ----------------
+    MintMarketTemplate.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.userDebt(address)];
+                    case 1:
+                        debt = _a.sent();
+                        return [2 /*return*/, BN(debt).times(1.0001).toString()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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 ----------------
+    MintMarketTemplate.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.address].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)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.address].contract.get_dy(i, j, _amount, llamalend.constantOptions)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.address].contract.get_dx(i, j, _amount, llamalend.constantOptions)];
+                    case 1:
+                        _expected = _c.sent();
+                        return [2 /*return*/, formatUnits(_expected, inDecimals)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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))];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.address)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.address)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.address)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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.address].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];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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 ----------------
+    MintMarketTemplate.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.controller].contract.tokens_to_liquidate(address, llamalend.constantOptions)];
+                    case 1:
+                        _tokens = _a.sent();
+                        return [2 /*return*/, formatUnits(_tokens)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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([llamalend.address], [tokensToLiquidate], llamalend.signerAddress, this.controller)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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([llamalend.address], [tokensToLiquidate], this.controller)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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([llamalend.address], [tokensToLiquidate], this.controller)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._liquidate = function (address, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, stablecoin, 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(), stablecoin = _a.stablecoin, 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(stablecoin) === 0)
+                            throw Error("User ".concat(address, " is not in liquidation mode"));
+                        minAmountBN = BN(stablecoin).times(100 - slippage).div(100);
+                        _minAmount = fromBN(minAmountBN);
+                        contract = llamalend.contracts[this.controller].contract;
+                        return [4 /*yield*/, contract.liquidate.estimateGas(address, _minAmount, isEth(this.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.liquidate(address, _minAmount, isEth(this.collateral), __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 4: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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 ----------------
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.selfLiquidateApproveEstimateGas = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.liquidateApproveEstimateGas()];
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.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()];
+                }
+            });
+        });
+    };
+    // ---------------- CREATE LOAN WITH LEVERAGE ----------------
+    MintMarketTemplate.prototype._getBestIdx = function (_amounts) {
+        var bestIdx = 0;
+        for (var i = 1; i < 5; i++) {
+            if (_amounts[i] > _amounts[bestIdx])
+                bestIdx = i;
+        }
+        return bestIdx;
+    };
+    MintMarketTemplate.prototype._checkLeverageZap = function () {
+        if (this.leverageZap === "0x0000000000000000000000000000000000000000")
+            throw Error("There is no leverage for ".concat(this.id, " market"));
+    };
+    MintMarketTemplate.prototype.leverageCreateLoanMaxRecv = function (collateral, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _collateral, calls, i, _res, _maxBorrowable, _maxCollateral, routeIdx, maxBorrowable, maxCollateral;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        this._checkRange(range);
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        calls = [];
+                        for (i = 0; i < 5; i++) {
+                            calls.push(llamalend.contracts[this.leverageZap].multicallContract.max_borrowable_and_collateral(_collateral, range, i));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 1:
+                        _res = _a.sent();
+                        _maxBorrowable = _res.map(function (r) { return r[0] * BigInt(999) / BigInt(1000); });
+                        _maxCollateral = _res.map(function (r) { return r[1] * BigInt(999) / BigInt(1000); });
+                        routeIdx = this._getBestIdx(_maxCollateral);
+                        maxBorrowable = llamalend.formatUnits(_maxBorrowable[routeIdx]);
+                        maxCollateral = llamalend.formatUnits(_maxCollateral[routeIdx], this.collateralDecimals);
+                        return [2 /*return*/, {
+                                maxBorrowable: maxBorrowable,
+                                maxCollateral: maxCollateral,
+                                leverage: BN(maxCollateral).div(collateral).toFixed(4),
+                                routeIdx: routeIdx,
+                            }];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._getRouteIdx = function (userCollateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var routeIdx;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._leverageCreateLoanCollateral(userCollateral, debt)];
+                    case 1:
+                        routeIdx = (_a.sent()).routeIdx;
+                        return [2 /*return*/, routeIdx];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.leverageCreateLoanCollateral = function (userCollateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _collateral, routeIdx, collateral;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageCreateLoanCollateral(userCollateral, debt)];
+                    case 1:
+                        _a = _c.sent(), _collateral = _a._collateral, routeIdx = _a.routeIdx;
+                        collateral = llamalend.formatUnits(_collateral, this.collateralDecimals);
+                        return [2 /*return*/, { collateral: collateral, leverage: BN(collateral).div(userCollateral).toFixed(4), routeIdx: routeIdx }];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.leverageGetRouteName = function (routeIdx) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, llamalend.contracts[this.leverageZap].contract.route_names(routeIdx)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.leverageGetMaxRange = function (collateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var routeIdx, maxRecv, N;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._getRouteIdx(collateral, debt)];
+                    case 1:
+                        routeIdx = _a.sent();
+                        return [4 /*yield*/, this._leverageCreateLoanMaxRecvAllRanges2(collateral, routeIdx)];
+                    case 2:
+                        maxRecv = _a.sent();
+                        for (N = this.minBands; N <= this.maxBands; N++) {
+                            if (BN(debt).gt(BN(maxRecv[N].maxBorrowable)))
+                                return [2 /*return*/, N - 1];
+                        }
+                        return [2 /*return*/, this.maxBands];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._leverageCalcN1 = function (collateral, debt, range) {
+        return __awaiter(this, void 0, void 0, function () {
+            var routeIdx, _collateral, _debt;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkRange(range);
+                        return [4 /*yield*/, this._getRouteIdx(collateral, debt)];
+                    case 1:
+                        routeIdx = _a.sent();
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        _debt = parseUnits(debt);
+                        return [4 /*yield*/, llamalend.contracts[this.leverageZap].contract.calculate_debt_n1(_collateral, _debt, range, routeIdx, llamalend.constantOptions)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._leverageCalcN1AllRanges = function (collateral, debt, maxN) {
+        return __awaiter(this, void 0, void 0, function () {
+            var routeIdx, _collateral, _debt, calls, N;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._getRouteIdx(collateral, debt)];
+                    case 1:
+                        routeIdx = _a.sent();
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        _debt = parseUnits(debt);
+                        calls = [];
+                        for (N = this.minBands; N <= maxN; N++) {
+                            calls.push(llamalend.contracts[this.leverageZap].multicallContract.calculate_debt_n1(_collateral, _debt, N, routeIdx));
+                        }
+                        return [4 /*yield*/, llamalend.multicallProvider.all(calls)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._leverageCreateLoanBands = 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._leverageCalcN1(collateral, debt, range)];
+                    case 1:
+                        _n1 = _a.sent();
+                        _n2 = _n1 + BigInt(range - 1);
+                        return [2 /*return*/, [_n2, _n1]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._leverageCreateLoanBandsAllRanges = function (collateral, 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.leverageGetMaxRange(collateral, debt)];
+                    case 1:
+                        maxN = _a.sent();
+                        return [4 /*yield*/, this._leverageCalcN1AllRanges(collateral, 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];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.leverageCreateLoanBands = 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:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageCreateLoanBands(collateral, debt, range)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [2 /*return*/, [Number(_n2), Number(_n1)]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.leverageCreateLoanBandsAllRanges = function (collateral, 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(collateral, 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];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.leverageCreateLoanPrices = 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:
+                        this._checkLeverageZap();
+                        return [4 /*yield*/, this._leverageCreateLoanBands(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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.leverageCreateLoanPricesAllRanges = function (collateral, 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(collateral, 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];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.leverageCreateLoanHealth = function (collateral, debt, range, full) {
+        var _a;
+        if (full === void 0) { full = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var address, _collateral, _debt, contract, _health;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this._checkLeverageZap();
+                        address = "0x0000000000000000000000000000000000000000";
+                        return [4 /*yield*/, this._leverageCreateLoanCollateral(collateral, debt)];
+                    case 1:
+                        _collateral = (_c.sent())._collateral;
+                        _debt = parseUnits(debt);
+                        contract = llamalend.contracts[(_a = this.healthCalculator) !== null && _a !== void 0 ? _a : this.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, _collateral, _debt, full, range, llamalend.constantOptions)];
+                    case 2:
+                        _health = _c.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.leveragePriceImpact = function (collateral, debt) {
+        return __awaiter(this, void 0, void 0, function () {
+            var x_BN, small_x_BN, _a, _collateral, routeIdx, _y, _small_y, y_BN, small_y_BN, rateBN, smallRateBN;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        x_BN = BN(debt);
+                        small_x_BN = BN(100);
+                        return [4 /*yield*/, this._leverageCreateLoanCollateral(collateral, debt)];
+                    case 1:
+                        _a = _c.sent(), _collateral = _a._collateral, routeIdx = _a.routeIdx;
+                        _y = _collateral - parseUnits(collateral, this.collateralDecimals);
+                        return [4 /*yield*/, llamalend.contracts[this.leverageZap].contract.get_collateral(fromBN(small_x_BN), routeIdx)];
+                    case 2:
+                        _small_y = _c.sent();
+                        y_BN = toBN(_y, this.collateralDecimals);
+                        small_y_BN = toBN(_small_y, this.collateralDecimals);
+                        rateBN = y_BN.div(x_BN);
+                        smallRateBN = small_y_BN.div(small_x_BN);
+                        if (rateBN.gt(smallRateBN))
+                            return [2 /*return*/, "0.0"];
+                        return [2 /*return*/, BN(1).minus(rateBN.div(smallRateBN)).times(100).toFixed(4)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._leverageCreateLoan = function (collateral, debt, range, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _collateral, _debt, leverageContract, routeIdx, _expected, minRecvBN, _minRecv, contract, value, gas, gasLimit;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.loanExists()];
+                    case 1:
+                        if (_a.sent())
+                            throw Error("Loan already created");
+                        this._checkRange(range);
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        _debt = parseUnits(debt);
+                        leverageContract = llamalend.contracts[this.leverageZap].contract;
+                        return [4 /*yield*/, this._getRouteIdx(collateral, debt)];
+                    case 2:
+                        routeIdx = _a.sent();
+                        return [4 /*yield*/, leverageContract.get_collateral_underlying(_debt, routeIdx, llamalend.constantOptions)];
+                    case 3:
+                        _expected = _a.sent();
+                        minRecvBN = toBN(_expected, this.collateralDecimals).times(100 - slippage).div(100);
+                        _minRecv = fromBN(minRecvBN, this.collateralDecimals);
+                        contract = llamalend.contracts[this.controller].contract;
+                        value = isEth(this.collateral) ? _collateral : llamalend.parseUnits("0");
+                        return [4 /*yield*/, contract.create_loan_extended.estimateGas(_collateral, _debt, range, this.leverageZap, [routeIdx, _minRecv], __assign(__assign({}, llamalend.constantOptions), { value: value }))];
+                    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.create_loan_extended(_collateral, _debt, range, this.leverageZap, [routeIdx, _minRecv], __assign(__assign({}, llamalend.options), { gasLimit: gasLimit, value: value }))];
+                    case 6: return [2 /*return*/, (_a.sent()).hash];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.leverageCreateLoanEstimateGas = function (collateral, 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.createLoanIsApproved(collateral)];
+                    case 1:
+                        if (!(_a.sent()))
+                            throw Error("Approval is needed for gas estimation");
+                        return [4 /*yield*/, this._leverageCreateLoan(collateral, debt, range, slippage, true)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.leverageCreateLoan = function (collateral, 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.createLoanApprove(collateral)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._leverageCreateLoan(collateral, debt, range, slippage, false)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // ---------------- DELEVERAGE REPAY ----------------
+    MintMarketTemplate.prototype._checkDeleverageZap = function () {
+        if (this.deleverageZap === "0x0000000000000000000000000000000000000000")
+            throw Error("There is no deleverage for ".concat(this.id, " market"));
+    };
+    MintMarketTemplate.prototype.deleverageGetRouteName = function (routeIdx) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._checkDeleverageZap();
+                        return [4 /*yield*/, llamalend.contracts[this.deleverageZap].contract.route_names(routeIdx)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.deleverageIsFullRepayment = function (deleverageCollateral, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, stablecoin, debt, deleverageStablecoins;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this.userState(address)];
+                    case 1:
+                        _a = _c.sent(), stablecoin = _a.stablecoin, debt = _a.debt;
+                        return [4 /*yield*/, this.deleverageRepayStablecoins(deleverageCollateral)];
+                    case 2:
+                        deleverageStablecoins = (_c.sent()).stablecoins;
+                        return [2 /*return*/, BN(stablecoin).plus(deleverageStablecoins).gt(debt)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.deleverageIsAvailable = function (deleverageCollateral, address) {
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, collateral, stablecoin, 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 (0).
+                        // 2. If user is underwater (stablecoin > 0), only full repayment is available:
+                        //    await this.deleverageRepayStablecoins(deleverageCollateral) + stablecoin > debt
+                        // There is no deleverage zap
+                        if (this.deleverageZap === "0x0000000000000000000000000000000000000000")
+                            return [2 /*return*/, false];
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this.userState(address)];
+                    case 1:
+                        _a = _c.sent(), collateral = _a.collateral, stablecoin = _a.stablecoin, 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(deleverageCollateral).gt(collateral))
+                            return [2 /*return*/, false];
+                        if (!BN(stablecoin).gt(0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.deleverageIsFullRepayment(deleverageCollateral, address)];
+                    case 2: return [2 /*return*/, _c.sent()];
+                    case 3: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.deleverageRepayBands = 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:
+                        this._checkDeleverageZap();
+                        return [4 /*yield*/, this._deleverageRepayBands(collateral, address)];
+                    case 1:
+                        _a = _c.sent(), _n2 = _a[0], _n1 = _a[1];
+                        return [2 /*return*/, [Number(_n2), Number(_n1)]];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.deleverageRepayPrices = 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:
+                        this._checkDeleverageZap();
+                        return [4 /*yield*/, this._deleverageRepayBands(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()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.deleverageRepayHealth = function (collateral, full, address) {
+        var _a;
+        if (full === void 0) { full = true; }
+        if (address === void 0) { address = ""; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _c, _stablecoin, _debt, deleverageStablecoins, _d_collateral, _d_debt, N, contract, _health;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        this._checkDeleverageZap();
+                        address = _getAddress(address);
+                        return [4 /*yield*/, this.deleverageIsAvailable(collateral, address)];
+                    case 1:
+                        if (!(_d.sent()))
+                            return [2 /*return*/, "0.0"];
+                        return [4 /*yield*/, this._userState(address)];
+                    case 2:
+                        _c = _d.sent(), _stablecoin = _c._stablecoin, _debt = _c._debt;
+                        return [4 /*yield*/, this.deleverageRepayStablecoins(collateral)];
+                    case 3:
+                        deleverageStablecoins = (_d.sent()).stablecoins;
+                        _d_collateral = parseUnits(collateral, this.collateralDecimals) * BigInt(-1);
+                        _d_debt = (parseUnits(deleverageStablecoins) + _stablecoin) * BigInt(-1);
+                        return [4 /*yield*/, this.userRange(address)];
+                    case 4:
+                        N = _d.sent();
+                        if ((_debt + _d_debt) < 0)
+                            return [2 /*return*/, "0.0"];
+                        contract = llamalend.contracts[(_a = this.healthCalculator) !== null && _a !== void 0 ? _a : this.controller].contract;
+                        return [4 /*yield*/, contract.health_calculator(address, _d_collateral, _d_debt, full, N, llamalend.constantOptions)];
+                    case 5:
+                        _health = _d.sent();
+                        _health = _health * BigInt(100);
+                        return [2 /*return*/, formatUnits(_health)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.deleveragePriceImpact = function (collateral) {
+        return __awaiter(this, void 0, void 0, function () {
+            var x_BN, small_x_BN, _a, stablecoins, routeIdx, _y, _small_y, y_BN, small_y_BN, rateBN, smallRateBN;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        x_BN = BN(collateral);
+                        small_x_BN = BN(0.001);
+                        return [4 /*yield*/, this.deleverageRepayStablecoins(collateral)];
+                    case 1:
+                        _a = _c.sent(), stablecoins = _a.stablecoins, routeIdx = _a.routeIdx;
+                        _y = parseUnits(stablecoins);
+                        return [4 /*yield*/, llamalend.contracts[this.deleverageZap].contract.get_stablecoins(fromBN(small_x_BN, this.collateralDecimals), routeIdx)];
+                    case 2:
+                        _small_y = _c.sent();
+                        y_BN = toBN(_y);
+                        small_y_BN = toBN(_small_y);
+                        rateBN = y_BN.div(x_BN);
+                        smallRateBN = small_y_BN.div(small_x_BN);
+                        if (rateBN.gt(smallRateBN))
+                            return [2 /*return*/, "0.0"];
+                        return [2 /*return*/, BN(1).minus(rateBN.div(smallRateBN)).times(100).toFixed(4)];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype._deleverageRepay = function (collateral, slippage, estimateGas) {
+        return __awaiter(this, void 0, void 0, function () {
+            var currentDebt, _a, stablecoins, routeIdx, _collateral, _debt, minRecvBN, _minRecv, contract, gas, gasLimit;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.userState(llamalend.signerAddress)];
+                    case 1:
+                        currentDebt = (_c.sent()).debt;
+                        if (Number(currentDebt) === 0)
+                            throw Error("Loan for ".concat(llamalend.signerAddress, " does not exist"));
+                        return [4 /*yield*/, this.deleverageRepayStablecoins(collateral)];
+                    case 2:
+                        _a = _c.sent(), stablecoins = _a.stablecoins, routeIdx = _a.routeIdx;
+                        _collateral = parseUnits(collateral, this.collateralDecimals);
+                        _debt = parseUnits(stablecoins);
+                        minRecvBN = toBN(_debt).times(100 - slippage).div(100);
+                        _minRecv = fromBN(minRecvBN);
+                        contract = llamalend.contracts[this.controller].contract;
+                        return [4 /*yield*/, contract.repay_extended.estimateGas(this.deleverageZap, [routeIdx, _collateral, _minRecv], llamalend.constantOptions)];
+                    case 3:
+                        gas = _c.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        return [4 /*yield*/, llamalend.updateFeeData()];
+                    case 4:
+                        _c.sent();
+                        gasLimit = _mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.repay_extended(this.deleverageZap, [routeIdx, _collateral, _minRecv], __assign(__assign({}, llamalend.options), { gasLimit: gasLimit }))];
+                    case 5: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.deleverageRepayEstimateGas = function (collateral, 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._checkDeleverageZap();
+                        return [4 /*yield*/, this._deleverageRepay(collateral, slippage, true)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    MintMarketTemplate.prototype.deleverageRepay = function (collateral, 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._checkDeleverageZap();
+                        return [4 /*yield*/, this._deleverageRepay(collateral, slippage, false)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return MintMarketTemplate;
+}());
+export { MintMarketTemplate };