@curvefi/llamalend-api 1.0.21 → 1.0.22-beta.2

package/src/mintMarkets/MintMarketTemplate.ts

@@ -1,6 +1,6 @@
 import memoize from "memoizee";
 import BigNumber from "bignumber.js";
-import { llamalend } from "../llamalend.js";
+import type { Llamalend } from "../llamalend.js";
 import {
     _getAddress,
     parseUnits,
@@ -25,6 +25,7 @@ import {_getUserCollateralCrvUsd} from "../external-api.js";
 
 
 export class MintMarketTemplate {
+    private llamalend: Llamalend;
     id: string;
     address: string;
     controller: string;
@@ -121,8 +122,9 @@ export class MintMarketTemplate {
         }
     }
 
-    constructor(id: string) {
-        const llammaData = llamalend.constants.LLAMMAS[id];
+    constructor(id: string, llamalend: Llamalend) {
+        this.llamalend = llamalend;
+        const llammaData = this.llamalend.constants.LLAMMAS[id];
 
         this.id = id;
         this.address = llammaData.amm_address;
@@ -135,7 +137,7 @@ export class MintMarketTemplate {
         this.collateralSymbol = llammaData.collateral_symbol;
         this.collateralDecimals = Number(llammaData.collateral_decimals);
         this.coins = ["crvUSD", llammaData.collateral_symbol];
-        this.coinAddresses = [llamalend.crvUsdAddress, llammaData.collateral_address];
+        this.coinAddresses = [this.llamalend.crvUsdAddress, llammaData.collateral_address];
         this.coinDecimals = [18, Number(llammaData.collateral_decimals)];
         this.minBands = llammaData.min_bands;
         this.maxBands = llammaData.max_bands;
@@ -225,20 +227,20 @@ export class MintMarketTemplate {
         liquidation_discount: string, // %
         loan_discount: string, // %
     }> => {
-        const llammaContract = llamalend.contracts[this.address].multicallContract;
-        const controllerContract = llamalend.contracts[this.controller].multicallContract;
-        const monetaryPolicyContract = llamalend.contracts[this.monetaryPolicy].multicallContract;
+        const llammaContract = this.llamalend.contracts[this.address].multicallContract;
+        const controllerContract = this.llamalend.contracts[this.controller].multicallContract;
+        const monetaryPolicyContract = this.llamalend.contracts[this.monetaryPolicy].multicallContract;
 
         const calls = [
             llammaContract.fee(),
             llammaContract.admin_fee(),
             llammaContract.rate(),
-            "rate(address)" in llamalend.contracts[this.monetaryPolicy].contract ? monetaryPolicyContract.rate(this.controller) : monetaryPolicyContract.rate(),
+            "rate(address)" in this.llamalend.contracts[this.monetaryPolicy].contract ? monetaryPolicyContract.rate(this.controller) : monetaryPolicyContract.rate(),
             controllerContract.liquidation_discount(),
             controllerContract.loan_discount(),
         ]
 
-        const [_fee, _admin_fee, _rate, _mp_rate, _liquidation_discount, _loan_discount]: bigint[] = await llamalend.multicallProvider.all(calls) as bigint[];
+        const [_fee, _admin_fee, _rate, _mp_rate, _liquidation_discount, _loan_discount]: bigint[] = await this.llamalend.multicallProvider.all(calls) as bigint[];
         const [fee, admin_fee, liquidation_discount, loan_discount] = [_fee, _admin_fee, _liquidation_discount, _loan_discount]
             .map((x) => formatUnits(x * BigInt(100)));
 
@@ -254,16 +256,16 @@ export class MintMarketTemplate {
     });
 
     private async statsBalances(): Promise<[string, string]> {
-        const crvusdContract = llamalend.contracts[llamalend.crvUsdAddress].multicallContract;
-        const collateralContract = llamalend.contracts[isEth(this.collateral) ? llamalend.constants.WETH : this.collateral].multicallContract;
-        const contract = llamalend.contracts[this.address].multicallContract;
+        const crvusdContract = this.llamalend.contracts[this.llamalend.crvUsdAddress].multicallContract;
+        const collateralContract = this.llamalend.contracts[isEth(this.collateral) ? this.llamalend.constants.WETH : this.collateral].multicallContract;
+        const contract = this.llamalend.contracts[this.address].multicallContract;
         const calls = [
             crvusdContract.balanceOf(this.address),
             collateralContract.balanceOf(this.address),
             contract.admin_fees_x(),
             contract.admin_fees_y(),
         ]
-        const [_crvusdBalance, _collateralBalance, _crvusdAdminFees, _collateralAdminFees]: bigint[] = await llamalend.multicallProvider.all(calls);
+        const [_crvusdBalance, _collateralBalance, _crvusdAdminFees, _collateralAdminFees]: bigint[] = await this.llamalend.multicallProvider.all(calls);
 
         return [
             formatUnits(_crvusdBalance - _crvusdAdminFees),
@@ -272,14 +274,14 @@ export class MintMarketTemplate {
     }
 
     private statsMaxMinBands = memoize(async (): Promise<[number, number]> => {
-        const llammaContract = llamalend.contracts[this.address].multicallContract;
+        const llammaContract = this.llamalend.contracts[this.address].multicallContract;
 
         const calls1 = [
             llammaContract.max_band(),
             llammaContract.min_band(),
         ]
 
-        return (await llamalend.multicallProvider.all(calls1) as BigNumber[]).map((_b) => Number(_b)) as [number, number];
+        return (await this.llamalend.multicallProvider.all(calls1) as BigNumber[]).map((_b) => Number(_b)) as [number, number];
     },
     {
         promise: true,
@@ -287,7 +289,7 @@ export class MintMarketTemplate {
     });
 
     private statsActiveBand = memoize(async (): Promise<number> => {
-        return Number((await llamalend.contracts[this.address].contract.active_band_with_skip()))
+        return Number((await this.llamalend.contracts[this.address].contract.active_band_with_skip()))
     },
     {
         promise: true,
@@ -302,11 +304,11 @@ export class MintMarketTemplate {
     }
 
     private async statsBandBalances(n: number): Promise<{ stablecoin: string, collateral: string }> {
-        const llammaContract = llamalend.contracts[this.address].multicallContract;
+        const llammaContract = this.llamalend.contracts[this.address].multicallContract;
         const calls = [];
         calls.push(llammaContract.bands_x(n), llammaContract.bands_y(n));
 
-        const _balances: bigint[] = await llamalend.multicallProvider.all(calls);
+        const _balances: bigint[] = await this.llamalend.multicallProvider.all(calls);
 
         return {
             stablecoin: formatUnits(_balances[0]),
@@ -317,13 +319,13 @@ export class MintMarketTemplate {
     private async statsBandsBalances(): Promise<{ [index: number]: { stablecoin: string, collateral: string } }> {
         const [max_band, min_band]: number[] = await this.statsMaxMinBands();
 
-        const llammaContract = llamalend.contracts[this.address].multicallContract;
+        const llammaContract = this.llamalend.contracts[this.address].multicallContract;
         const calls = [];
         for (let i = min_band; i <= max_band; i++) {
             calls.push(llammaContract.bands_x(i), llammaContract.bands_y(i));
         }
 
-        const _bands: bigint[] = await llamalend.multicallProvider.all(calls);
+        const _bands: bigint[] = await this.llamalend.multicallProvider.all(calls);
 
         const bands: { [index: number]: { stablecoin: string, collateral: string } } = {};
         for (let i = min_band; i <= max_band; i++) {
@@ -341,9 +343,9 @@ export class MintMarketTemplate {
     }
 
     private statsTotalSupply = memoize(async (): Promise<string> => {
-        const controllerContract = llamalend.contracts[this.controller].multicallContract;
+        const controllerContract = this.llamalend.contracts[this.controller].multicallContract;
         const calls = [controllerContract.minted(), controllerContract.redeemed()]
-        const [_minted, _redeemed]: bigint[] = await llamalend.multicallProvider.all(calls);
+        const [_minted, _redeemed]: bigint[] = await this.llamalend.multicallProvider.all(calls);
 
         return toBN(_minted).minus(toBN(_redeemed)).toString();
     },
@@ -353,7 +355,7 @@ export class MintMarketTemplate {
     });
 
     private statsTotalDebt = memoize(async (): Promise<string> => {
-        const debt = await llamalend.contracts[this.controller].contract.total_debt(llamalend.constantOptions);
+        const debt = await this.llamalend.contracts[this.controller].contract.total_debt(this.llamalend.constantOptions);
 
         return formatUnits(debt);
     },
@@ -363,10 +365,10 @@ export class MintMarketTemplate {
     });
 
     private statsTotalStablecoin = memoize(async (): Promise<string> => {
-        const stablecoinContract = llamalend.contracts[llamalend.crvUsdAddress].multicallContract;
-        const ammContract = llamalend.contracts[this.address].multicallContract;
+        const stablecoinContract = this.llamalend.contracts[this.llamalend.crvUsdAddress].multicallContract;
+        const ammContract = this.llamalend.contracts[this.address].multicallContract;
 
-        const [_balance, _fee]: bigint[] = await llamalend.multicallProvider.all([
+        const [_balance, _fee]: bigint[] = await this.llamalend.multicallProvider.all([
             stablecoinContract.balanceOf(this.address),
             ammContract.admin_fees_x(),
         ]);
@@ -379,10 +381,10 @@ export class MintMarketTemplate {
     });
 
     private statsTotalCollateral = memoize(async (): Promise<string> => {
-        const collateralContract = llamalend.contracts[isEth(this.collateral) ? llamalend.constants.WETH : this.collateral].multicallContract;
-        const ammContract = llamalend.contracts[this.address].multicallContract;
+        const collateralContract = this.llamalend.contracts[isEth(this.collateral) ? this.llamalend.constants.WETH : this.collateral].multicallContract;
+        const ammContract = this.llamalend.contracts[this.address].multicallContract;
 
-        const [_balance, _fee]: bigint[] = await llamalend.multicallProvider.all([
+        const [_balance, _fee]: bigint[] = await this.llamalend.multicallProvider.all([
             collateralContract.balanceOf(this.address),
             ammContract.admin_fees_y(),
         ]);
@@ -395,15 +397,15 @@ export class MintMarketTemplate {
     });
 
     private statsCapAndAvailable = memoize(async (): Promise<{ "cap": string, "available": string }> => {
-        const factoryContract = llamalend.contracts[llamalend.constants.FACTORY].multicallContract;
-        const crvusdContract = llamalend.contracts[llamalend.crvUsdAddress].multicallContract;
+        const factoryContract = this.llamalend.contracts[this.llamalend.constants.FACTORY].multicallContract;
+        const crvusdContract = this.llamalend.contracts[this.llamalend.crvUsdAddress].multicallContract;
 
-        const [_cap, _available]: bigint[] = await llamalend.multicallProvider.all([
+        const [_cap, _available]: bigint[] = await this.llamalend.multicallProvider.all([
             factoryContract.debt_ceiling(this.controller),
             crvusdContract.balanceOf(this.controller),
         ]);
 
-        return { "cap": llamalend.formatUnits(_cap), "available": llamalend.formatUnits(_available) }
+        return { "cap": this.llamalend.formatUnits(_cap), "available": this.llamalend.formatUnits(_available) }
     },
     {
         promise: true,
@@ -413,28 +415,28 @@ export class MintMarketTemplate {
     // ---------------------------------------
 
     public async loanExists(address = ""): Promise<boolean> {
-        address = _getAddress(address);
-        return  await llamalend.contracts[this.controller].contract.loan_exists(address, llamalend.constantOptions);
+        address = _getAddress.call(this.llamalend, address);
+        return  await this.llamalend.contracts[this.controller].contract.loan_exists(address, this.llamalend.constantOptions);
     }
 
     public async userDebt(address = ""): Promise<string> {
-        address = _getAddress(address);
-        const debt = await llamalend.contracts[this.controller].contract.debt(address, llamalend.constantOptions);
+        address = _getAddress.call(this.llamalend, address);
+        const debt = await this.llamalend.contracts[this.controller].contract.debt(address, this.llamalend.constantOptions);
 
         return formatUnits(debt);
     }
 
     public async userHealth(full = true, address = ""): Promise<string> {
-        address = _getAddress(address);
-        let _health = await llamalend.contracts[this.controller].contract.health(address, full, llamalend.constantOptions) as bigint;
+        address = _getAddress.call(this.llamalend, address);
+        let _health = await this.llamalend.contracts[this.controller].contract.health(address, full, this.llamalend.constantOptions) as bigint;
         _health = _health * BigInt(100);
 
         return formatUnits(_health);
     }
 
     public async userBands(address = ""): Promise<number[]> {
-        address = _getAddress(address);
-        const _bands = await llamalend.contracts[this.address].contract.read_user_tick_numbers(address, llamalend.constantOptions) as BigNumber[];
+        address = _getAddress.call(this.llamalend, address);
+        const _bands = await this.llamalend.contracts[this.address].contract.read_user_tick_numbers(address, this.llamalend.constantOptions) as BigNumber[];
 
         return _bands.map((_t) => Number(_t)).reverse();
     }
@@ -446,16 +448,16 @@ export class MintMarketTemplate {
     }
 
     public async userPrices(address = ""): Promise<string[]> {
-        address = _getAddress(address);
-        const _prices = await llamalend.contracts[this.controller].contract.user_prices(address, llamalend.constantOptions) as bigint[];
+        address = _getAddress.call(this.llamalend, address);
+        const _prices = await this.llamalend.contracts[this.controller].contract.user_prices(address, this.llamalend.constantOptions) as bigint[];
 
         return _prices.map((_p) =>formatUnits(_p)).reverse();
     }
 
     public async _userState(address = ""): Promise<{ _collateral: bigint, _stablecoin: bigint, _debt: bigint }> {
-        address = _getAddress(address);
-        const contract = llamalend.contracts[this.controller].contract;
-        const [_collateral, _stablecoin, _debt] = await contract.user_state(address, llamalend.constantOptions) as bigint[];
+        address = _getAddress.call(this.llamalend, address);
+        const contract = this.llamalend.contracts[this.controller].contract;
+        const [_collateral, _stablecoin, _debt] = await contract.user_state(address, this.llamalend.constantOptions) as bigint[];
 
         return { _collateral, _stablecoin, _debt }
     }
@@ -471,12 +473,12 @@ export class MintMarketTemplate {
     }
 
     public async userLoss(userAddress = ""): Promise<{ deposited_collateral: string, current_collateral_estimation: string, loss: string, loss_pct: string }> {
-        userAddress = _getAddress(userAddress);
+        userAddress = _getAddress.call(this.llamalend, userAddress);
         const [deposited_collateral, _current_collateral_estimation] = await Promise.all([
-            _getUserCollateralCrvUsd(llamalend.constants.NETWORK_NAME, this.controller, userAddress),
-            llamalend.contracts[this.address].contract.get_y_up(userAddress),
+            _getUserCollateralCrvUsd(this.llamalend.constants.NETWORK_NAME, this.controller, userAddress),
+            this.llamalend.contracts[this.address].contract.get_y_up(userAddress),
         ]);
-        const current_collateral_estimation = llamalend.formatUnits(_current_collateral_estimation, this.collateralDecimals);
+        const current_collateral_estimation = this.llamalend.formatUnits(_current_collateral_estimation, this.collateralDecimals);
 
         if (BN(deposited_collateral).lte(0)) {
             return {
@@ -501,9 +503,9 @@ export class MintMarketTemplate {
         const [n2, n1] = await this.userBands(address);
         if (n1 == 0 && n2 == 0) return {};
 
-        address = _getAddress(address);
-        const contract = llamalend.contracts[this.address].contract;
-        const [_stablecoins, _collaterals] = await contract.get_xy(address, llamalend.constantOptions) as [bigint[], bigint[]];
+        address = _getAddress.call(this.llamalend, address);
+        const contract = this.llamalend.contracts[this.address].contract;
+        const [_stablecoins, _collaterals] = await contract.get_xy(address, this.llamalend.constantOptions) as [bigint[], bigint[]];
 
         const res: IDict<{ stablecoin: string, collateral: string }> = {};
         for (let i = n1; i <= n2; i++) {
@@ -517,7 +519,7 @@ export class MintMarketTemplate {
     }
 
     public async oraclePrice(): Promise<string> {
-        const _price = await llamalend.contracts[this.address].contract.price_oracle(llamalend.constantOptions) as bigint;
+        const _price = await this.llamalend.contracts[this.address].contract.price_oracle(this.llamalend.constantOptions) as bigint;
         return formatUnits(_price);
     }
 
@@ -542,12 +544,12 @@ export class MintMarketTemplate {
     }
 
     public async price(): Promise<string> {
-        const _price = await llamalend.contracts[this.address].contract.get_p(llamalend.constantOptions) as bigint;
+        const _price = await this.llamalend.contracts[this.address].contract.get_p(this.llamalend.constantOptions) as bigint;
         return formatUnits(_price);
     }
 
     public basePrice = memoize(async(): Promise<string> => {
-        const _price = await llamalend.contracts[this.address].contract.get_base_price(llamalend.constantOptions) as bigint;
+        const _price = await this.llamalend.contracts[this.address].contract.get_base_price(this.llamalend.constantOptions) as bigint;
         return formatUnits(_price);
     },
     {
@@ -583,7 +585,7 @@ export class MintMarketTemplate {
     // ---------------- WALLET BALANCES ----------------
 
     private async walletBalances(address = ""): Promise<{ collateral: string, stablecoin: string }> {
-        const [collateral, stablecoin] = await getBalances([this.collateral, llamalend.crvUsdAddress], address);
+        const [collateral, stablecoin] = await getBalances.call(this.llamalend, [this.collateral, this.llamalend.crvUsdAddress], address);
         return { stablecoin, collateral }
     }
 
@@ -598,7 +600,7 @@ export class MintMarketTemplate {
         this._checkRange(range);
         const _collateral = parseUnits(collateral, this.collateralDecimals);
 
-        return formatUnits(await llamalend.contracts[this.controller].contract.max_borrowable(_collateral, range, llamalend.constantOptions));
+        return formatUnits(await this.llamalend.contracts[this.controller].contract.max_borrowable(_collateral, range, this.llamalend.constantOptions));
     }
 
     public createLoanMaxRecvAllRanges = memoize(async (collateral: number | string): Promise<{ [index: number]: string }> => {
@@ -606,9 +608,9 @@ export class MintMarketTemplate {
 
         const calls = [];
         for (let N = this.minBands; N <= this.maxBands; N++) {
-            calls.push(llamalend.contracts[this.controller].multicallContract.max_borrowable(_collateral, N));
+            calls.push(this.llamalend.contracts[this.controller].multicallContract.max_borrowable(_collateral, N));
         }
-        const _amounts = await llamalend.multicallProvider.all(calls) as bigint[];
+        const _amounts = await this.llamalend.multicallProvider.all(calls) as bigint[];
 
         const res: { [index: number]: string } = {};
         for (let N = this.minBands; N <= this.maxBands; N++) {
@@ -633,20 +635,20 @@ export class MintMarketTemplate {
 
     private async _calcN1(_collateral: bigint, _debt: bigint, range: number): Promise<bigint> {
         this._checkRange(range);
-        return await llamalend.contracts[this.controller].contract.calculate_debt_n1(_collateral, _debt, range, llamalend.constantOptions);
+        return await this.llamalend.contracts[this.controller].contract.calculate_debt_n1(_collateral, _debt, range, this.llamalend.constantOptions);
     }
 
     private async _calcN1AllRanges(_collateral: bigint, _debt: bigint, maxN: number): Promise<bigint[]> {
         const calls = [];
         for (let N = this.minBands; N <= maxN; N++) {
-            calls.push(llamalend.contracts[this.controller].multicallContract.calculate_debt_n1(_collateral, _debt, N));
+            calls.push(this.llamalend.contracts[this.controller].multicallContract.calculate_debt_n1(_collateral, _debt, N));
         }
-        return await llamalend.multicallProvider.all(calls) as bigint[];
+        return await this.llamalend.multicallProvider.all(calls) as bigint[];
     }
 
     private async _getPrices(_n2: bigint, _n1: bigint): Promise<string[]> {
-        const contract = llamalend.contracts[this.address].multicallContract;
-        return (await llamalend.multicallProvider.all([
+        const contract = this.llamalend.contracts[this.address].multicallContract;
+        return (await this.llamalend.multicallProvider.all([
             contract.p_oracle_down(_n2),
             contract.p_oracle_up(_n1),
         ]) as bigint[]).map((_p) => formatUnits(_p));
@@ -722,27 +724,27 @@ export class MintMarketTemplate {
     }
 
     public async createLoanHealth(collateral: number | string, debt: number | string, range: number, full = true, address = ""): Promise<string> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const _collateral = parseUnits(collateral, this.collateralDecimals);
         const _debt = parseUnits(debt);
 
-        const contract = llamalend.contracts[this.healthCalculator ?? this.controller].contract;
-        let _health = await contract.health_calculator(address, _collateral, _debt, full, range, llamalend.constantOptions) as bigint;
+        const contract = this.llamalend.contracts[this.healthCalculator ?? this.controller].contract;
+        let _health = await contract.health_calculator(address, _collateral, _debt, full, range, this.llamalend.constantOptions) as bigint;
         _health = _health * BigInt(100);
 
         return formatUnits(_health);
     }
 
     public async createLoanIsApproved(collateral: number | string): Promise<boolean> {
-        return await hasAllowance([this.collateral], [collateral], llamalend.signerAddress, this.controller);
+        return await hasAllowance.call(this.llamalend, [this.collateral], [collateral], this.llamalend.signerAddress, this.controller);
     }
 
     private async createLoanApproveEstimateGas (collateral: number | string): Promise<TGas> {
-        return await ensureAllowanceEstimateGas([this.collateral], [collateral], this.controller);
+        return await ensureAllowanceEstimateGas.call(this.llamalend, [this.collateral], [collateral], this.controller);
     }
 
     public async createLoanApprove(collateral: number | string): Promise<string[]> {
-        return await ensureAllowance([this.collateral], [collateral], this.controller);
+        return await ensureAllowance.call(this.llamalend, [this.collateral], [collateral], this.controller);
     }
 
     private async _createLoan(collateral: number | string, debt: number | string, range: number, estimateGas: boolean): Promise<string | TGas> {
@@ -751,14 +753,14 @@ export class MintMarketTemplate {
 
         const _collateral = parseUnits(collateral, this.collateralDecimals);
         const _debt = parseUnits(debt);
-        const contract = llamalend.contracts[this.controller].contract;
-        const value = isEth(this.collateral) ? _collateral : llamalend.parseUnits("0");
-        const gas = await contract.create_loan.estimateGas(_collateral, _debt, range, { ...llamalend.constantOptions, value });
+        const contract = this.llamalend.contracts[this.controller].contract;
+        const value = isEth(this.collateral) ? _collateral : this.llamalend.parseUnits("0");
+        const gas = await contract.create_loan.estimateGas(_collateral, _debt, range, { ...this.llamalend.constantOptions, value });
         if (estimateGas) return smartNumber(gas);
 
-        await llamalend.updateFeeData();
+        await this.llamalend.updateFeeData();
         const gasLimit = _mulBy1_3(DIGas(gas));
-        return (await contract.create_loan(_collateral, _debt, range, { ...llamalend.options, gasLimit, value })).hash
+        return (await contract.create_loan(_collateral, _debt, range, { ...this.llamalend.options, gasLimit, value })).hash
     }
 
     public async createLoanEstimateGas(collateral: number | string, debt: number | string, range: number): Promise<number> {
@@ -778,15 +780,15 @@ export class MintMarketTemplate {
         const N = await this.userRange();
         const _collateral = _currentCollateral + parseUnits(collateralAmount, this.collateralDecimals);
 
-        const contract = llamalend.contracts[this.controller].contract;
-        const _debt: bigint = await contract.max_borrowable(_collateral, N, llamalend.constantOptions);
+        const contract = this.llamalend.contracts[this.controller].contract;
+        const _debt: bigint = await contract.max_borrowable(_collateral, N, this.llamalend.constantOptions);
 
         return formatUnits(_debt - _currentDebt);
     }
 
     private async _borrowMoreBands(collateral: number | string, debt: number | string): Promise<[bigint, bigint]> {
         const { _collateral: _currentCollateral, _debt: _currentDebt } = await this._userState();
-        if (_currentDebt === BigInt(0)) throw Error(`Loan for ${llamalend.signerAddress} does not exist`);
+        if (_currentDebt === BigInt(0)) throw Error(`Loan for ${this.llamalend.signerAddress} does not exist`);
 
         const N = await this.userRange();
         const _collateral = _currentCollateral + parseUnits(collateral, this.collateralDecimals);
@@ -811,44 +813,44 @@ export class MintMarketTemplate {
     }
 
     public async borrowMoreHealth(collateral: number | string, debt: number | string, full = true, address = ""): Promise<string> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const _collateral = parseUnits(collateral, this.collateralDecimals);
         const _debt = parseUnits(debt);
 
-        const contract = llamalend.contracts[this.healthCalculator ?? this.controller].contract;
-        let _health = await contract.health_calculator(address, _collateral, _debt, full, 0, llamalend.constantOptions) as bigint;
+        const contract = this.llamalend.contracts[this.healthCalculator ?? this.controller].contract;
+        let _health = await contract.health_calculator(address, _collateral, _debt, full, 0, this.llamalend.constantOptions) as bigint;
         _health = _health * BigInt(100);
 
         return formatUnits(_health);
     }
 
     public async borrowMoreIsApproved(collateral: number | string): Promise<boolean> {
-        return await hasAllowance([this.collateral], [collateral], llamalend.signerAddress, this.controller);
+        return await hasAllowance.call(this.llamalend, [this.collateral], [collateral], this.llamalend.signerAddress, this.controller);
     }
 
     private async borrowMoreApproveEstimateGas (collateral: number | string): Promise<TGas> {
-        return await ensureAllowanceEstimateGas([this.collateral], [collateral], this.controller);
+        return await ensureAllowanceEstimateGas.call(this.llamalend, [this.collateral], [collateral], this.controller);
     }
 
     public async borrowMoreApprove(collateral: number | string): Promise<string[]> {
-        return await ensureAllowance([this.collateral], [collateral], this.controller);
+        return await ensureAllowance.call(this.llamalend, [this.collateral], [collateral], this.controller);
     }
 
     private async _borrowMore(collateral: number | string, debt: number | string, estimateGas: boolean): Promise<string | TGas> {
         const { stablecoin, debt: currentDebt } = await this.userState();
-        if (Number(currentDebt) === 0) throw Error(`Loan for ${llamalend.signerAddress} does not exist`);
-        if (Number(stablecoin) > 0) throw Error(`User ${llamalend.signerAddress} is already in liquidation mode`);
+        if (Number(currentDebt) === 0) throw Error(`Loan for ${this.llamalend.signerAddress} does not exist`);
+        if (Number(stablecoin) > 0) throw Error(`User ${this.llamalend.signerAddress} is already in liquidation mode`);
 
         const _collateral = parseUnits(collateral, this.collateralDecimals);
         const _debt = parseUnits(debt);
-        const contract = llamalend.contracts[this.controller].contract;
-        const value = isEth(this.collateral) ? _collateral : llamalend.parseUnits("0");
-        const gas = await contract.borrow_more.estimateGas(_collateral, _debt, { ...llamalend.constantOptions, value });
+        const contract = this.llamalend.contracts[this.controller].contract;
+        const value = isEth(this.collateral) ? _collateral : this.llamalend.parseUnits("0");
+        const gas = await contract.borrow_more.estimateGas(_collateral, _debt, { ...this.llamalend.constantOptions, value });
         if (estimateGas) return smartNumber(gas);
 
-        await llamalend.updateFeeData();
+        await this.llamalend.updateFeeData();
         const gasLimit = _mulBy1_3(DIGas(gas));
-        return (await contract.borrow_more(_collateral, _debt, { ...llamalend.options, gasLimit, value })).hash
+        return (await contract.borrow_more(_collateral, _debt, { ...this.llamalend.options, gasLimit, value })).hash
     }
 
     public async borrowMoreEstimateGas(collateral: number | string, debt: number | string): Promise<number> {
@@ -864,7 +866,7 @@ export class MintMarketTemplate {
     // ---------------- ADD COLLATERAL ----------------
 
     private async _addCollateralBands(collateral: number | string, address = ""): Promise<[bigint, bigint]> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const { _collateral: _currentCollateral, _debt: _currentDebt } = await this._userState(address);
         if (_currentDebt === BigInt(0)) throw Error(`Loan for ${address} does not exist`);
 
@@ -889,26 +891,26 @@ export class MintMarketTemplate {
     }
 
     public async addCollateralHealth(collateral: number | string, full = true, address = ""): Promise<string> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const _collateral = parseUnits(collateral, this.collateralDecimals);
 
-        const contract = llamalend.contracts[this.healthCalculator ?? this.controller].contract;
-        let _health = await contract.health_calculator(address, _collateral, 0, full, 0, llamalend.constantOptions) as bigint;
+        const contract = this.llamalend.contracts[this.healthCalculator ?? this.controller].contract;
+        let _health = await contract.health_calculator(address, _collateral, 0, full, 0, this.llamalend.constantOptions) as bigint;
         _health = _health * BigInt(100);
 
         return formatUnits(_health);
     }
 
     public async addCollateralIsApproved(collateral: number | string): Promise<boolean> {
-        return await hasAllowance([this.collateral], [collateral], llamalend.signerAddress, this.controller);
+        return await hasAllowance.call(this.llamalend, [this.collateral], [collateral], this.llamalend.signerAddress, this.controller);
     }
 
     private async addCollateralApproveEstimateGas (collateral: number | string): Promise<TGas> {
-        return await ensureAllowanceEstimateGas([this.collateral], [collateral], this.controller);
+        return await ensureAllowanceEstimateGas.call(this.llamalend, [this.collateral], [collateral], this.controller);
     }
 
     public async addCollateralApprove(collateral: number | string): Promise<string[]> {
-        return await ensureAllowance([this.collateral], [collateral], this.controller);
+        return await ensureAllowance.call(this.llamalend, [this.collateral], [collateral], this.controller);
     }
 
     private async _addCollateral(collateral: number | string, address: string, estimateGas: boolean): Promise<string | TGas> {
@@ -917,24 +919,24 @@ export class MintMarketTemplate {
         if (Number(stablecoin) > 0) throw Error(`User ${address} is already in liquidation mode`);
 
         const _collateral = parseUnits(collateral, this.collateralDecimals);
-        const contract = llamalend.contracts[this.controller].contract;
-        const value = isEth(this.collateral) ? _collateral : llamalend.parseUnits("0");
-        const gas = await contract.add_collateral.estimateGas(_collateral, address, { ...llamalend.constantOptions, value });
+        const contract = this.llamalend.contracts[this.controller].contract;
+        const value = isEth(this.collateral) ? _collateral : this.llamalend.parseUnits("0");
+        const gas = await contract.add_collateral.estimateGas(_collateral, address, { ...this.llamalend.constantOptions, value });
         if (estimateGas) return smartNumber(gas);
 
-        await llamalend.updateFeeData();
+        await this.llamalend.updateFeeData();
         const gasLimit = _mulBy1_3(DIGas(gas));
-        return (await contract.add_collateral(_collateral, address, { ...llamalend.options, gasLimit, value })).hash
+        return (await contract.add_collateral(_collateral, address, { ...this.llamalend.options, gasLimit, value })).hash
     }
 
     public async addCollateralEstimateGas(collateral: number | string, address = ""): Promise<number> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         if (!(await this.addCollateralIsApproved(collateral))) throw Error("Approval is needed for gas estimation");
         return await this._addCollateral(collateral, address, true) as number;
     }
 
     public async addCollateral(collateral: number | string, address = ""): Promise<string> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         await this.addCollateralApprove(collateral);
         return await this._addCollateral(collateral, address, false) as string;
     }
@@ -944,14 +946,14 @@ export class MintMarketTemplate {
     public async maxRemovable(): Promise<string> {
         const { _collateral: _currentCollateral, _debt: _currentDebt } = await this._userState();
         const N = await this.userRange();
-        const _requiredCollateral = await llamalend.contracts[this.controller].contract.min_collateral(_currentDebt, N, llamalend.constantOptions)
+        const _requiredCollateral = await this.llamalend.contracts[this.controller].contract.min_collateral(_currentDebt, N, this.llamalend.constantOptions)
 
         return formatUnits(_currentCollateral - _requiredCollateral, this.collateralDecimals);
     }
 
     private async _removeCollateralBands(collateral: number | string): Promise<[bigint, bigint]> {
         const { _collateral: _currentCollateral, _debt: _currentDebt } = await this._userState();
-        if (_currentDebt === BigInt(0)) throw Error(`Loan for ${llamalend.signerAddress} does not exist`);
+        if (_currentDebt === BigInt(0)) throw Error(`Loan for ${this.llamalend.signerAddress} does not exist`);
 
         const N = await this.userRange();
         const _collateral = _currentCollateral - parseUnits(collateral, this.collateralDecimals);
@@ -974,11 +976,11 @@ export class MintMarketTemplate {
     }
 
     public async removeCollateralHealth(collateral: number | string, full = true, address = ""): Promise<string> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const _collateral = parseUnits(collateral, this.collateralDecimals) * BigInt(-1);
 
-        const contract = llamalend.contracts[this.healthCalculator ?? this.controller].contract;
-        let _health = await contract.health_calculator(address, _collateral, 0, full, 0, llamalend.constantOptions) as bigint;
+        const contract = this.llamalend.contracts[this.healthCalculator ?? this.controller].contract;
+        let _health = await contract.health_calculator(address, _collateral, 0, full, 0, this.llamalend.constantOptions) as bigint;
         _health = _health * BigInt(100);
 
         return formatUnits(_health);
@@ -986,17 +988,17 @@ export class MintMarketTemplate {
 
     private async _removeCollateral(collateral: number | string, estimateGas: boolean): Promise<string | TGas> {
         const { stablecoin, debt: currentDebt } = await this.userState();
-        if (Number(currentDebt) === 0) throw Error(`Loan for ${llamalend.signerAddress} does not exist`);
-        if (Number(stablecoin) > 0) throw Error(`User ${llamalend.signerAddress} is already in liquidation mode`);
+        if (Number(currentDebt) === 0) throw Error(`Loan for ${this.llamalend.signerAddress} does not exist`);
+        if (Number(stablecoin) > 0) throw Error(`User ${this.llamalend.signerAddress} is already in liquidation mode`);
 
         const _collateral = parseUnits(collateral, this.collateralDecimals);
-        const contract = llamalend.contracts[this.controller].contract;
-        const gas = this.isDeleverageSupported ? await contract.remove_collateral.estimateGas(_collateral, llamalend.constantOptions) : await contract.remove_collateral.estimateGas(_collateral, isEth(this.collateral), llamalend.constantOptions);
+        const contract = this.llamalend.contracts[this.controller].contract;
+        const gas = this.isDeleverageSupported ? await contract.remove_collateral.estimateGas(_collateral, this.llamalend.constantOptions) : await contract.remove_collateral.estimateGas(_collateral, isEth(this.collateral), this.llamalend.constantOptions);
         if (estimateGas) return smartNumber(gas);
 
-        await llamalend.updateFeeData();
+        await this.llamalend.updateFeeData();
         const gasLimit = _mulBy1_3(DIGas(gas));
-        return (this.isDeleverageSupported ? await contract.remove_collateral(_collateral, { ...llamalend.options, gasLimit }) : await contract.remove_collateral(_collateral, isEth(this.collateral), { ...llamalend.options, gasLimit })).hash
+        return (this.isDeleverageSupported ? await contract.remove_collateral(_collateral, { ...this.llamalend.options, gasLimit }) : await contract.remove_collateral(_collateral, isEth(this.collateral), { ...this.llamalend.options, gasLimit })).hash
     }
 
     public async removeCollateralEstimateGas(collateral: number | string): Promise<number> {
@@ -1015,7 +1017,7 @@ export class MintMarketTemplate {
 
         const N = await this.userRange(address);
         const _debt = _currentDebt - parseUnits(debt);
-        const _n1 = _currentStablecoin === BigInt(0) ? await this._calcN1(_currentCollateral, _debt, N) : (await llamalend.contracts[this.address].contract.read_user_tick_numbers(address, llamalend.constantOptions) as bigint[])[0];
+        const _n1 = _currentStablecoin === BigInt(0) ? await this._calcN1(_currentCollateral, _debt, N) : (await this.llamalend.contracts[this.address].contract.read_user_tick_numbers(address, this.llamalend.constantOptions) as bigint[])[0];
         const _n2 = _n1 + BigInt(N - 1);
 
         return [_n2, _n1];
@@ -1034,44 +1036,44 @@ export class MintMarketTemplate {
     }
 
     public async repayIsApproved(debt: number | string): Promise<boolean> {
-        return await hasAllowance([llamalend.crvUsdAddress], [debt], llamalend.signerAddress, this.controller);
+        return await hasAllowance.call(this.llamalend, [this.llamalend.crvUsdAddress], [debt], this.llamalend.signerAddress, this.controller);
     }
 
     private async repayApproveEstimateGas (debt: number | string): Promise<TGas> {
-        return await ensureAllowanceEstimateGas([llamalend.crvUsdAddress], [debt], this.controller);
+        return await ensureAllowanceEstimateGas.call(this.llamalend, [this.llamalend.crvUsdAddress], [debt], this.controller);
     }
 
     public async repayApprove(debt: number | string): Promise<string[]> {
-        return await ensureAllowance([llamalend.crvUsdAddress], [debt], this.controller);
+        return await ensureAllowance.call(this.llamalend, [this.llamalend.crvUsdAddress], [debt], this.controller);
     }
 
     public async repayHealth(debt: number | string, full = true, address = ""): Promise<string> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const _debt = parseUnits(debt) * BigInt(-1);
 
-        const contract = llamalend.contracts[this.healthCalculator ?? this.controller].contract;
-        let _health = await contract.health_calculator(address, 0, _debt, full, 0, llamalend.constantOptions) as bigint;
+        const contract = this.llamalend.contracts[this.healthCalculator ?? this.controller].contract;
+        let _health = await contract.health_calculator(address, 0, _debt, full, 0, this.llamalend.constantOptions) as bigint;
         _health = _health * BigInt(100);
 
         return formatUnits(_health);
     }
 
     private async _repay(debt: number | string, address: string, estimateGas: boolean): Promise<string | TGas> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const { debt: currentDebt } = await this.userState(address);
         if (Number(currentDebt) === 0) throw Error(`Loan for ${address} does not exist`);
 
         const _debt = parseUnits(debt);
-        const contract = llamalend.contracts[this.controller].contract;
+        const contract = this.llamalend.contracts[this.controller].contract;
         const [, n1] = await this.userBands(address);
         const { stablecoin } = await this.userState(address);
         const n = (BN(stablecoin).gt(0)) ? MAX_ACTIVE_BAND : n1 - 1;  // In liquidation mode it doesn't matter if active band moves
-        const gas = this.isDeleverageSupported ? await contract.repay.estimateGas(_debt, address, n, llamalend.constantOptions) : await contract.repay.estimateGas(_debt, address, n, isEth(this.collateral), llamalend.constantOptions);
+        const gas = this.isDeleverageSupported ? await contract.repay.estimateGas(_debt, address, n, this.llamalend.constantOptions) : await contract.repay.estimateGas(_debt, address, n, isEth(this.collateral), this.llamalend.constantOptions);
         if (estimateGas) return smartNumber(gas);
 
-        await llamalend.updateFeeData();
+        await this.llamalend.updateFeeData();
         const gasLimit = _mulBy1_3(DIGas(gas));
-        return (this.isDeleverageSupported ? await contract.repay(_debt, address, n, { ...llamalend.options, gasLimit }) : await contract.repay(_debt, address, n, isEth(this.collateral), { ...llamalend.options, gasLimit })).hash
+        return (this.isDeleverageSupported ? await contract.repay(_debt, address, n, { ...this.llamalend.options, gasLimit }) : await contract.repay(_debt, address, n, isEth(this.collateral), { ...this.llamalend.options, gasLimit })).hash
     }
 
     public async repayEstimateGas(debt: number | string, address = ""): Promise<number> {
@@ -1087,38 +1089,38 @@ export class MintMarketTemplate {
     // ---------------- FULL REPAY ----------------
 
     private async _fullRepayAmount(address = ""): Promise<string> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const debt = await this.userDebt(address);
         return BN(debt).times(1.0001).toString();
     }
 
     public async fullRepayIsApproved(address = ""): Promise<boolean> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const fullRepayAmount = await this._fullRepayAmount(address);
         return await this.repayIsApproved(fullRepayAmount);
     }
 
     private async fullRepayApproveEstimateGas (address = ""): Promise<TGas> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const fullRepayAmount = await this._fullRepayAmount(address);
         return await this.repayApproveEstimateGas(fullRepayAmount);
     }
 
     public async fullRepayApprove(address = ""): Promise<string[]> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const fullRepayAmount = await this._fullRepayAmount(address);
         return await this.repayApprove(fullRepayAmount);
     }
 
     public async fullRepayEstimateGas(address = ""): Promise<number> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const fullRepayAmount = await this._fullRepayAmount(address);
         if (!(await this.repayIsApproved(fullRepayAmount))) throw Error("Approval is needed for gas estimation");
         return await this._repay(fullRepayAmount, address, true) as number;
     }
 
     public async fullRepay(address = ""): Promise<string> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const fullRepayAmount = await this._fullRepayAmount(address);
         await this.repayApprove(fullRepayAmount);
         return await this._repay(fullRepayAmount, address, false) as string;
@@ -1129,15 +1131,15 @@ export class MintMarketTemplate {
     public async maxSwappable(i: number, j: number): Promise<string> {
         if (!(i === 0 && j === 1) && !(i === 1 && j === 0)) throw Error("Wrong index");
         const inDecimals = this.coinDecimals[i];
-        const contract = llamalend.contracts[this.address].contract;
-        const [_inAmount, _outAmount] = await contract.get_dxdy(i, j, MAX_ALLOWANCE, llamalend.constantOptions) as bigint[];
+        const contract = this.llamalend.contracts[this.address].contract;
+        const [_inAmount, _outAmount] = await contract.get_dxdy(i, j, MAX_ALLOWANCE, this.llamalend.constantOptions) as bigint[];
         if (_outAmount === BigInt(0)) return "0";
 
         return formatUnits(_inAmount, inDecimals)
     }
 
     private async _swapExpected(i: number, j: number, _amount: bigint): Promise<bigint> {
-        return await llamalend.contracts[this.address].contract.get_dy(i, j, _amount, llamalend.constantOptions) as bigint;
+        return await this.llamalend.contracts[this.address].contract.get_dy(i, j, _amount, this.llamalend.constantOptions) as bigint;
     }
 
     public async swapExpected(i: number, j: number, amount: number | string): Promise<string> {
@@ -1153,7 +1155,7 @@ export class MintMarketTemplate {
         if (!(i === 0 && j === 1) && !(i === 1 && j === 0)) throw Error("Wrong index");
         const [inDecimals, outDecimals] = this.coinDecimals;
         const _amount = parseUnits(outAmount, outDecimals);
-        const _expected = await llamalend.contracts[this.address].contract.get_dx(i, j, _amount, llamalend.constantOptions) as bigint;
+        const _expected = await this.llamalend.contracts[this.address].contract.get_dx(i, j, _amount, this.llamalend.constantOptions) as bigint;
 
         return formatUnits(_expected, inDecimals)
     }
@@ -1194,19 +1196,19 @@ export class MintMarketTemplate {
     public async swapIsApproved(i: number, amount: number | string): Promise<boolean> {
         if (i !== 0 && i !== 1) throw Error("Wrong index");
 
-        return await hasAllowance([this.coinAddresses[i]], [amount], llamalend.signerAddress, this.address);
+        return await hasAllowance.call(this.llamalend, [this.coinAddresses[i]], [amount], this.llamalend.signerAddress, this.address);
     }
 
     private async swapApproveEstimateGas (i: number, amount: number | string): Promise<TGas> {
         if (i !== 0 && i !== 1) throw Error("Wrong index");
 
-        return await ensureAllowanceEstimateGas([this.coinAddresses[i]], [amount], this.address);
+        return await ensureAllowanceEstimateGas.call(this.llamalend, [this.coinAddresses[i]], [amount], this.address);
     }
 
     public async swapApprove(i: number, amount: number | string): Promise<string[]> {
         if (i !== 0 && i !== 1) throw Error("Wrong index");
 
-        return await ensureAllowance([this.coinAddresses[i]], [amount], this.address);
+        return await ensureAllowance.call(this.llamalend, [this.coinAddresses[i]], [amount], this.address);
     }
 
     private async _swap(i: number, j: number, amount: number | string, slippage: number, estimateGas: boolean): Promise<string | TGas> {
@@ -1217,13 +1219,13 @@ export class MintMarketTemplate {
         const _expected = await this._swapExpected(i, j, _amount);
         const minRecvAmountBN: BigNumber = toBN(_expected, outDecimals).times(100 - slippage).div(100);
         const _minRecvAmount = fromBN(minRecvAmountBN, outDecimals);
-        const contract = llamalend.contracts[this.address].contract;
-        const gas = await contract.exchange.estimateGas(i, j, _amount, _minRecvAmount, llamalend.constantOptions);
+        const contract = this.llamalend.contracts[this.address].contract;
+        const gas = await contract.exchange.estimateGas(i, j, _amount, _minRecvAmount, this.llamalend.constantOptions);
         if (estimateGas) return smartNumber(gas);
 
-        await llamalend.updateFeeData();
+        await this.llamalend.updateFeeData();
         const gasLimit = _mulBy1_3(DIGas(gas));
-        return (await contract.exchange(i, j, _amount, _minRecvAmount, { ...llamalend.options, gasLimit })).hash
+        return (await contract.exchange(i, j, _amount, _minRecvAmount, { ...this.llamalend.options, gasLimit })).hash
     }
 
     public async swapEstimateGas(i: number, j: number, amount: number | string, slippage = 0.1): Promise<number> {
@@ -1239,25 +1241,25 @@ export class MintMarketTemplate {
     // ---------------- LIQUIDATE ----------------
 
     public async tokensToLiquidate(address = ""): Promise<string> {
-        address = _getAddress(address);
-        const _tokens = await llamalend.contracts[this.controller].contract.tokens_to_liquidate(address, llamalend.constantOptions) as bigint;
+        address = _getAddress.call(this.llamalend, address);
+        const _tokens = await this.llamalend.contracts[this.controller].contract.tokens_to_liquidate(address, this.llamalend.constantOptions) as bigint;
 
         return formatUnits(_tokens)
     }
 
     public async liquidateIsApproved(address = ""): Promise<boolean> {
         const tokensToLiquidate = await this.tokensToLiquidate(address);
-        return await hasAllowance([llamalend.crvUsdAddress], [tokensToLiquidate], llamalend.signerAddress, this.controller);
+        return await hasAllowance.call(this.llamalend, [this.llamalend.crvUsdAddress], [tokensToLiquidate], this.llamalend.signerAddress, this.controller);
     }
 
     private async liquidateApproveEstimateGas (address = ""): Promise<TGas> {
         const tokensToLiquidate = await this.tokensToLiquidate(address);
-        return await ensureAllowanceEstimateGas([llamalend.crvUsdAddress], [tokensToLiquidate], this.controller);
+        return await ensureAllowanceEstimateGas.call(this.llamalend, [this.llamalend.crvUsdAddress], [tokensToLiquidate], this.controller);
     }
 
     public async liquidateApprove(address = ""): Promise<string[]> {
         const tokensToLiquidate = await this.tokensToLiquidate(address);
-        return await ensureAllowance([llamalend.crvUsdAddress], [tokensToLiquidate], this.controller);
+        return await ensureAllowance.call(this.llamalend, [this.llamalend.crvUsdAddress], [tokensToLiquidate], this.controller);
     }
 
     private async _liquidate(address: string, slippage: number, estimateGas: boolean): Promise<string | TGas> {
@@ -1269,13 +1271,13 @@ export class MintMarketTemplate {
 
         const minAmountBN: BigNumber = BN(stablecoin).times(100 - slippage).div(100);
         const _minAmount = fromBN(minAmountBN);
-        const contract = llamalend.contracts[this.controller].contract;
-        const gas = this.isDeleverageSupported ? (await contract.liquidate.estimateGas(address, _minAmount, llamalend.constantOptions)) : (await contract.liquidate.estimateGas(address, _minAmount, isEth(this.collateral), llamalend.constantOptions))
+        const contract = this.llamalend.contracts[this.controller].contract;
+        const gas = this.isDeleverageSupported ? (await contract.liquidate.estimateGas(address, _minAmount, this.llamalend.constantOptions)) : (await contract.liquidate.estimateGas(address, _minAmount, isEth(this.collateral), this.llamalend.constantOptions))
         if (estimateGas) return smartNumber(gas);
 
-        await llamalend.updateFeeData();
+        await this.llamalend.updateFeeData();
         const gasLimit = _mulBy1_3(DIGas(gas));
-        return (this.isDeleverageSupported ? await contract.liquidate(address, _minAmount, { ...llamalend.options, gasLimit }) : await contract.liquidate(address, _minAmount, isEth(this.collateral), { ...llamalend.options, gasLimit })).hash
+        return (this.isDeleverageSupported ? await contract.liquidate(address, _minAmount, { ...this.llamalend.options, gasLimit }) : await contract.liquidate(address, _minAmount, isEth(this.collateral), { ...this.llamalend.options, gasLimit })).hash
     }
 
     public async liquidateEstimateGas(address: string, slippage = 0.1): Promise<number> {
@@ -1304,12 +1306,12 @@ export class MintMarketTemplate {
 
     public async selfLiquidateEstimateGas(slippage = 0.1): Promise<number> {
         if (!(await this.selfLiquidateIsApproved())) throw Error("Approval is needed for gas estimation");
-        return await this._liquidate(llamalend.signerAddress, slippage, true) as number;
+        return await this._liquidate(this.llamalend.signerAddress, slippage, true) as number;
     }
 
     public async selfLiquidate(slippage = 0.1): Promise<string> {
         await this.selfLiquidateApprove();
-        return await this._liquidate(llamalend.signerAddress, slippage, false) as string;
+        return await this._liquidate(this.llamalend.signerAddress, slippage, false) as string;
     }
 
     // ---------------- CREATE LOAN WITH LEVERAGE ----------------
@@ -1334,15 +1336,15 @@ export class MintMarketTemplate {
         const _collateral = parseUnits(collateral, this.collateralDecimals);
         const calls = [];
         for (let i = 0; i < 5; i++) {
-            calls.push(llamalend.contracts[this.leverageZap].multicallContract.max_borrowable_and_collateral(_collateral, range, i));
+            calls.push(this.llamalend.contracts[this.leverageZap].multicallContract.max_borrowable_and_collateral(_collateral, range, i));
         }
-        const _res: bigint[][] = await llamalend.multicallProvider.all(calls);
+        const _res: bigint[][] = await this.llamalend.multicallProvider.all(calls);
         const _maxBorrowable = _res.map((r) => r[0] * BigInt(999) / BigInt(1000));
         const _maxCollateral = _res.map((r) => r[1] * BigInt(999) / BigInt(1000));
         const routeIdx = this._getBestIdx(_maxCollateral);
 
-        const maxBorrowable = llamalend.formatUnits(_maxBorrowable[routeIdx]);
-        const maxCollateral = llamalend.formatUnits(_maxCollateral[routeIdx], this.collateralDecimals);
+        const maxBorrowable = this.llamalend.formatUnits(_maxBorrowable[routeIdx]);
+        const maxCollateral = this.llamalend.formatUnits(_maxCollateral[routeIdx], this.collateralDecimals);
         return {
             maxBorrowable,
             maxCollateral,
@@ -1359,10 +1361,10 @@ export class MintMarketTemplate {
         const calls = [];
         for (let N = this.minBands; N <= this.maxBands; N++) {
             for (let i = 0; i < 5; i++) {
-                calls.push(llamalend.contracts[this.leverageZap].multicallContract.max_borrowable_and_collateral(_collateral, N, i));
+                calls.push(this.llamalend.contracts[this.leverageZap].multicallContract.max_borrowable_and_collateral(_collateral, N, i));
             }
         }
-        const _rawRes: bigint[][] = await llamalend.multicallProvider.all(calls);
+        const _rawRes: bigint[][] = await this.llamalend.multicallProvider.all(calls);
 
         const res: IDict<{ maxBorrowable: string, maxCollateral: string, leverage: string, routeIdx: number }> = {};
         for (let N = this.minBands; N <= this.maxBands; N++) {
@@ -1370,8 +1372,8 @@ export class MintMarketTemplate {
             const _maxBorrowable = _res.map((r) => r[0] * BigInt(999) / BigInt(1000));
             const _maxCollateral = _res.map((r) => r[1] * BigInt(999) / BigInt(1000));
             const routeIdx = this._getBestIdx(_maxCollateral);
-            const maxBorrowable = llamalend.formatUnits(_maxBorrowable[routeIdx]);
-            const maxCollateral = llamalend.formatUnits(_maxCollateral[routeIdx], this.collateralDecimals);
+            const maxBorrowable = this.llamalend.formatUnits(_maxBorrowable[routeIdx]);
+            const maxCollateral = this.llamalend.formatUnits(_maxCollateral[routeIdx], this.collateralDecimals);
             res[N] = {
                 maxBorrowable,
                 maxCollateral,
@@ -1393,14 +1395,14 @@ export class MintMarketTemplate {
 
         const calls = [];
         for (let N = this.minBands; N <= this.maxBands; N++) {
-            calls.push(llamalend.contracts[this.leverageZap].multicallContract.max_borrowable_and_collateral(_collateral, N, routeIdx));
+            calls.push(this.llamalend.contracts[this.leverageZap].multicallContract.max_borrowable_and_collateral(_collateral, N, routeIdx));
         }
-        const _res: bigint[][] = await llamalend.multicallProvider.all(calls);
+        const _res: bigint[][] = await this.llamalend.multicallProvider.all(calls);
 
         const res: IDict<{ maxBorrowable: string, maxCollateral: string, leverage: string }> = {};
         for (let N = this.minBands; N <= this.maxBands; N++) {
-            const maxBorrowable = llamalend.formatUnits(_res[N - this.minBands][0] * BigInt(999) / BigInt(1000));
-            const maxCollateral = llamalend.formatUnits(_res[N - this.minBands][1]* BigInt(999) / BigInt(1000), this.collateralDecimals);
+            const maxBorrowable = this.llamalend.formatUnits(_res[N - this.minBands][0] * BigInt(999) / BigInt(1000));
+            const maxCollateral = this.llamalend.formatUnits(_res[N - this.minBands][1]* BigInt(999) / BigInt(1000), this.collateralDecimals);
             res[N] = {
                 maxBorrowable,
                 maxCollateral,
@@ -1421,9 +1423,9 @@ export class MintMarketTemplate {
         const _debt = parseUnits(debt);
         const calls = [];
         for (let i = 0; i < 5; i++) {
-            calls.push(llamalend.contracts[this.leverageZap].multicallContract.get_collateral(_debt, i));
+            calls.push(this.llamalend.contracts[this.leverageZap].multicallContract.get_collateral(_debt, i));
         }
-        const _leverageCollateral: bigint[] = await llamalend.multicallProvider.all(calls);
+        const _leverageCollateral: bigint[] = await this.llamalend.multicallProvider.all(calls);
         const routeIdx = this._getBestIdx(_leverageCollateral);
 
         return { _collateral: _userCollateral + _leverageCollateral[routeIdx], routeIdx }
@@ -1443,14 +1445,14 @@ export class MintMarketTemplate {
         Promise<{ collateral: string, leverage: string, routeIdx: number }> {
         this._checkLeverageZap();
         const { _collateral, routeIdx } = await this._leverageCreateLoanCollateral(userCollateral, debt);
-        const collateral = llamalend.formatUnits(_collateral, this.collateralDecimals);
+        const collateral = this.llamalend.formatUnits(_collateral, this.collateralDecimals);
 
         return { collateral, leverage: BN(collateral).div(userCollateral).toFixed(4), routeIdx };
     }
 
     private async leverageGetRouteName(routeIdx: number): Promise<string> {
         this._checkLeverageZap();
-        return await llamalend.contracts[this.leverageZap].contract.route_names(routeIdx);
+        return await this.llamalend.contracts[this.leverageZap].contract.route_names(routeIdx);
     }
 
     private async leverageGetMaxRange(collateral: number | string, debt: number | string): Promise<number> {
@@ -1469,7 +1471,7 @@ export class MintMarketTemplate {
         const routeIdx = await this._getRouteIdx(collateral, debt);
         const _collateral = parseUnits(collateral, this.collateralDecimals);
         const _debt = parseUnits(debt);
-        return await llamalend.contracts[this.leverageZap].contract.calculate_debt_n1(_collateral, _debt, range, routeIdx, llamalend.constantOptions);
+        return await this.llamalend.contracts[this.leverageZap].contract.calculate_debt_n1(_collateral, _debt, range, routeIdx, this.llamalend.constantOptions);
     }
 
     private async _leverageCalcN1AllRanges(collateral: number | string, debt: number | string, maxN: number): Promise<bigint[]> {
@@ -1478,9 +1480,9 @@ export class MintMarketTemplate {
         const _debt = parseUnits(debt);
         const calls = [];
         for (let N = this.minBands; N <= maxN; N++) {
-            calls.push(llamalend.contracts[this.leverageZap].multicallContract.calculate_debt_n1(_collateral, _debt, N, routeIdx));
+            calls.push(this.llamalend.contracts[this.leverageZap].multicallContract.calculate_debt_n1(_collateral, _debt, N, routeIdx));
         }
-        return await llamalend.multicallProvider.all(calls) as bigint[];
+        return await this.llamalend.multicallProvider.all(calls) as bigint[];
     }
 
     private async _leverageCreateLoanBands(collateral: number | string, debt: number | string, range: number): Promise<[bigint, bigint]> {
@@ -1558,8 +1560,8 @@ export class MintMarketTemplate {
         const { _collateral } = await this._leverageCreateLoanCollateral(collateral, debt);
         const _debt = parseUnits(debt);
 
-        const contract = llamalend.contracts[this.healthCalculator ?? this.controller].contract;
-        let _health = await contract.health_calculator(address, _collateral, _debt, full, range, llamalend.constantOptions) as bigint;
+        const contract = this.llamalend.contracts[this.healthCalculator ?? this.controller].contract;
+        let _health = await contract.health_calculator(address, _collateral, _debt, full, range, this.llamalend.constantOptions) as bigint;
         _health = _health * BigInt(100);
 
         return formatUnits(_health);
@@ -1570,7 +1572,7 @@ export class MintMarketTemplate {
         const small_x_BN = BN(100);
         const { _collateral, routeIdx } = await this._leverageCreateLoanCollateral(collateral, debt);
         const _y = _collateral - parseUnits(collateral, this.collateralDecimals);
-        const _small_y = await llamalend.contracts[this.leverageZap].contract.get_collateral(fromBN(small_x_BN), routeIdx);
+        const _small_y = await this.llamalend.contracts[this.leverageZap].contract.get_collateral(fromBN(small_x_BN), routeIdx);
         const y_BN = toBN(_y, this.collateralDecimals);
         const small_y_BN = toBN(_small_y, this.collateralDecimals);
         const rateBN = y_BN.div(x_BN);
@@ -1586,24 +1588,24 @@ export class MintMarketTemplate {
 
         const _collateral = parseUnits(collateral, this.collateralDecimals);
         const _debt = parseUnits(debt);
-        const leverageContract = llamalend.contracts[this.leverageZap].contract;
+        const leverageContract = this.llamalend.contracts[this.leverageZap].contract;
         const routeIdx = await this._getRouteIdx(collateral, debt);
-        const _expected = await leverageContract.get_collateral_underlying(_debt, routeIdx, llamalend.constantOptions);
+        const _expected = await leverageContract.get_collateral_underlying(_debt, routeIdx, this.llamalend.constantOptions);
         const minRecvBN = toBN(_expected, this.collateralDecimals).times(100 - slippage).div(100);
         const _minRecv = fromBN(minRecvBN, this.collateralDecimals);
-        const contract = llamalend.contracts[this.controller].contract;
-        const value = isEth(this.collateral) ? _collateral : llamalend.parseUnits("0");
+        const contract = this.llamalend.contracts[this.controller].contract;
+        const value = isEth(this.collateral) ? _collateral : this.llamalend.parseUnits("0");
         const gas = await contract.create_loan_extended.estimateGas(
             _collateral,
             _debt,
             range,
             this.leverageZap,
             [routeIdx, _minRecv],
-            { ...llamalend.constantOptions, value }
+            { ...this.llamalend.constantOptions, value }
         );
         if (estimateGas) return smartNumber(gas);
 
-        await llamalend.updateFeeData();
+        await this.llamalend.updateFeeData();
         const gasLimit = _mulBy1_3(DIGas(gas));
         return (await contract.create_loan_extended(
             _collateral,
@@ -1611,7 +1613,7 @@ export class MintMarketTemplate {
             range,
             this.leverageZap,
             [routeIdx, _minRecv],
-            { ...llamalend.options, gasLimit, value }
+            { ...this.llamalend.options, gasLimit, value }
         )).hash
     }
 
@@ -1638,11 +1640,11 @@ export class MintMarketTemplate {
         const _collateral = parseUnits(collateral, this.collateralDecimals);
         const calls = [];
         for (let i = 0; i < 5; i++) {
-            calls.push(llamalend.contracts[this.deleverageZap].multicallContract.get_stablecoins(_collateral, i));
+            calls.push(this.llamalend.contracts[this.deleverageZap].multicallContract.get_stablecoins(_collateral, i));
         }
-        const _stablecoins_arr: bigint[] = await llamalend.multicallProvider.all(calls);
+        const _stablecoins_arr: bigint[] = await this.llamalend.multicallProvider.all(calls);
         const routeIdx = this._getBestIdx(_stablecoins_arr);
-        const stablecoins = llamalend.formatUnits(_stablecoins_arr[routeIdx]);
+        const stablecoins = this.llamalend.formatUnits(_stablecoins_arr[routeIdx]);
 
         return { stablecoins, routeIdx };
     },
@@ -1653,11 +1655,11 @@ export class MintMarketTemplate {
 
     private async deleverageGetRouteName(routeIdx: number): Promise<string> {
         this._checkDeleverageZap();
-        return await llamalend.contracts[this.deleverageZap].contract.route_names(routeIdx);
+        return await this.llamalend.contracts[this.deleverageZap].contract.route_names(routeIdx);
     }
 
     private async deleverageIsFullRepayment(deleverageCollateral: number | string, address = ""): Promise<boolean> {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const { stablecoin, debt } = await this.userState(address);
         const { stablecoins: deleverageStablecoins } = await this.deleverageRepayStablecoins(deleverageCollateral);
 
@@ -1673,7 +1675,7 @@ export class MintMarketTemplate {
         // There is no deleverage zap
         if (this.deleverageZap === "0x0000000000000000000000000000000000000000") return false;
 
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         const { collateral, stablecoin, debt } = await this.userState(address);
         // Loan does not exist
         if (BN(debt).eq(0)) return false;
@@ -1686,7 +1688,7 @@ export class MintMarketTemplate {
     }
 
     private _deleverageRepayBands = memoize( async (collateral: number | string, address: string): Promise<[bigint, bigint]> => {
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         if (!(await this.deleverageIsAvailable(collateral, address))) return [parseUnits(0, 0), parseUnits(0, 0)];
         const { routeIdx } = await this.deleverageRepayStablecoins(collateral);
         const { _debt: _currentDebt } = await this._userState(address);
@@ -1697,7 +1699,7 @@ export class MintMarketTemplate {
         let _n1 = parseUnits(0, 0);
         let _n2 = parseUnits(0, 0);
         try {
-            _n1 = await llamalend.contracts[this.deleverageZap].contract.calculate_debt_n1(_collateral, routeIdx, address);
+            _n1 = await this.llamalend.contracts[this.deleverageZap].contract.calculate_debt_n1(_collateral, routeIdx, address);
             _n2 = _n1 + BigInt(N - 1);
         } catch {
             console.log("Full repayment");
@@ -1726,7 +1728,7 @@ export class MintMarketTemplate {
 
     private async deleverageRepayHealth(collateral: number | string, full = true, address = ""): Promise<string> {
         this._checkDeleverageZap();
-        address = _getAddress(address);
+        address = _getAddress.call(this.llamalend, address);
         if (!(await this.deleverageIsAvailable(collateral, address))) return "0.0";
         const { _stablecoin, _debt } = await this._userState(address);
         const { stablecoins: deleverageStablecoins } = await this.deleverageRepayStablecoins(collateral);
@@ -1735,8 +1737,8 @@ export class MintMarketTemplate {
         const N = await this.userRange(address);
 
         if ((_debt + _d_debt) < 0) return "0.0";
-        const contract = llamalend.contracts[this.healthCalculator ?? this.controller].contract;
-        let _health = await contract.health_calculator(address, _d_collateral, _d_debt, full, N, llamalend.constantOptions) as bigint;
+        const contract = this.llamalend.contracts[this.healthCalculator ?? this.controller].contract;
+        let _health = await contract.health_calculator(address, _d_collateral, _d_debt, full, N, this.llamalend.constantOptions) as bigint;
         _health = _health * BigInt(100);
 
         return formatUnits(_health);
@@ -1747,7 +1749,7 @@ export class MintMarketTemplate {
         const small_x_BN = BN(0.001);
         const { stablecoins, routeIdx } = await this.deleverageRepayStablecoins(collateral);
         const _y = parseUnits(stablecoins);
-        const _small_y = await llamalend.contracts[this.deleverageZap].contract.get_stablecoins(fromBN(small_x_BN, this.collateralDecimals), routeIdx);
+        const _small_y = await this.llamalend.contracts[this.deleverageZap].contract.get_stablecoins(fromBN(small_x_BN, this.collateralDecimals), routeIdx);
         const y_BN = toBN(_y);
         const small_y_BN = toBN(_small_y);
         const rateBN = y_BN.div(x_BN);
@@ -1758,21 +1760,21 @@ export class MintMarketTemplate {
     }
 
     private async _deleverageRepay(collateral: number | string, slippage: number, estimateGas: boolean): Promise<string | TGas> {
-        const { debt: currentDebt } = await this.userState(llamalend.signerAddress);
-        if (Number(currentDebt) === 0) throw Error(`Loan for ${llamalend.signerAddress} does not exist`);
+        const { debt: currentDebt } = await this.userState(this.llamalend.signerAddress);
+        if (Number(currentDebt) === 0) throw Error(`Loan for ${this.llamalend.signerAddress} does not exist`);
 
         const { stablecoins, routeIdx } = await this.deleverageRepayStablecoins(collateral);
         const _collateral = parseUnits(collateral, this.collateralDecimals);
         const _debt = parseUnits(stablecoins);
         const minRecvBN = toBN(_debt).times(100 - slippage).div(100);
         const _minRecv = fromBN(minRecvBN);
-        const contract = llamalend.contracts[this.controller].contract;
-        const gas = await contract.repay_extended.estimateGas(this.deleverageZap, [routeIdx, _collateral, _minRecv], llamalend.constantOptions);
+        const contract = this.llamalend.contracts[this.controller].contract;
+        const gas = await contract.repay_extended.estimateGas(this.deleverageZap, [routeIdx, _collateral, _minRecv], this.llamalend.constantOptions);
         if (estimateGas) return smartNumber(gas);
 
-        await llamalend.updateFeeData();
+        await this.llamalend.updateFeeData();
         const gasLimit = _mulBy1_3(DIGas(gas));
-        return (await contract.repay_extended(this.deleverageZap, [routeIdx, _collateral, _minRecv], { ...llamalend.options, gasLimit })).hash
+        return (await contract.repay_extended(this.deleverageZap, [routeIdx, _collateral, _minRecv], { ...this.llamalend.options, gasLimit })).hash
     }
 
     private async deleverageRepayEstimateGas(collateral: number | string, slippage = 0.1): Promise<number> {