@curvefi/llamalend-api 1.1.9 → 2.0.0

package/src/lendMarkets/modules/common/prices.ts

@@ -0,0 +1,111 @@
+import memoize from "memoizee";
+import type { LendMarketTemplate } from "../../LendMarketTemplate";
+import {
+    BN,
+    formatUnits,
+    _cutZeros,
+} from "../../../utils";
+import {Llamalend} from "../../../llamalend";
+import BigNumber from "bignumber.js";
+import {IPrices} from "../../interfaces/common";
+
+
+export class PricesModule implements IPrices {
+    private market: LendMarketTemplate;
+    private llamalend: Llamalend;
+
+    constructor(market: LendMarketTemplate) {
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+
+    public A = memoize(async(): Promise<string> => {
+        const _A = await this.llamalend.contracts[this.market.addresses.amm].contract.A(this.llamalend.constantOptions) as bigint;
+        return formatUnits(_A, 0);
+    },
+    {
+        promise: true,
+        maxAge: 86400 * 1000, // 1d
+    });
+
+    public basePrice = memoize(async(): Promise<string> => {
+        const _price = await this.llamalend.contracts[this.market.addresses.amm].contract.get_base_price(this.llamalend.constantOptions) as bigint;
+        return formatUnits(_price);
+    },
+    {
+        promise: true,
+        maxAge: 86400 * 1000, // 1d
+    });
+
+    public oraclePrice = memoize(async (): Promise<string> => {
+        const _price = await this.llamalend.contracts[this.market.addresses.amm].contract.price_oracle(this.llamalend.constantOptions) as bigint;
+        return formatUnits(_price);
+    },
+    {
+        promise: true,
+        maxAge: 60 * 1000, // 1m
+    });
+
+    public async oraclePriceBand(): Promise<number> {
+        const oraclePriceBN = BN(await this.oraclePrice());
+        const basePriceBN = BN(await this.basePrice());
+        const A_BN = BN(await this.A());
+        const multiplier = oraclePriceBN.lte(basePriceBN) ? A_BN.minus(1).div(A_BN) : A_BN.div(A_BN.minus(1));
+        const term = oraclePriceBN.lte(basePriceBN) ? 1 : -1;
+        const compareFunc = oraclePriceBN.lte(basePriceBN) ?
+            (oraclePriceBN: BigNumber, currentTickPriceBN: BigNumber) => oraclePriceBN.lte(currentTickPriceBN) :
+            (oraclePriceBN: BigNumber, currentTickPriceBN: BigNumber) => oraclePriceBN.gt(currentTickPriceBN);
+
+        let band = 0;
+        let currentTickPriceBN = oraclePriceBN.lte(basePriceBN) ? basePriceBN.times(multiplier) : basePriceBN;
+        while (compareFunc(oraclePriceBN, currentTickPriceBN)) {
+            currentTickPriceBN = currentTickPriceBN.times(multiplier);
+            band += term;
+        }
+
+        return band;
+    }
+
+    public async price(): Promise<string> {
+        const _price = await this.llamalend.contracts[this.market.addresses.amm].contract.get_p(this.llamalend.constantOptions) as bigint;
+        return formatUnits(_price);
+    }
+
+    public async calcTickPrice(n: number): Promise<string> {
+        const basePrice = await this.basePrice();
+        const basePriceBN = BN(basePrice);
+        const A_BN = BN(await this.A());
+
+        return _cutZeros(basePriceBN.times(A_BN.minus(1).div(A_BN).pow(n)).toFixed(18))
+    }
+
+    public async calcBandPrices(n: number): Promise<[string, string]> {
+        return [await this.calcTickPrice(n + 1), await this.calcTickPrice(n)]
+    }
+
+    public async calcRangePct(range: number): Promise<string> {
+        const A_BN = BN(await this.A());
+        const startBN = BN(1);
+        const endBN = A_BN.minus(1).div(A_BN).pow(range);
+
+        return startBN.minus(endBN).times(100).toFixed(6)
+    }
+
+    public async getPrices(_n2: bigint, _n1: bigint): Promise<[string,string]> {
+        const contract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
+        return (await this.llamalend.multicallProvider.all([
+            contract.p_oracle_down(_n2),
+            contract.p_oracle_up(_n1),
+        ]) as bigint[]).map((_p) => formatUnits(_p)) as [string,string];
+    }
+
+
+    public async calcPrices(_n2: bigint, _n1: bigint): Promise<[string, string]> {
+        return [await this.calcTickPrice(Number(_n2) + 1), await this.calcTickPrice(Number(_n1))];
+    }
+
+    public checkRange(range: number): void {
+        if (range < this.market.minBands) throw Error(`range must be >= ${this.market.minBands}`);
+        if (range > this.market.maxBands) throw Error(`range must be <= ${this.market.maxBands}`);
+    }
+}

package/src/lendMarkets/modules/common/statsBase.ts

@@ -0,0 +1,313 @@
+import memoize from "memoizee";
+import {TAmount} from "../../../interfaces";
+import type { LendMarketTemplate } from "../../LendMarketTemplate";
+import {
+    parseUnits,
+    BN,
+    toBN,
+    formatUnits,
+    formatNumber,
+} from "../../../utils";
+import {Llamalend} from "../../../llamalend";
+import {_getMarketsData} from "../../../external-api";
+import {cacheKey, cacheStats} from "../../../cache";
+
+export class StatsBaseModule {
+    protected market: LendMarketTemplate;
+    protected llamalend: Llamalend;
+
+    constructor(market: LendMarketTemplate) {
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+
+    public statsParameters = memoize(async (): Promise<{
+        fee: string, // %
+        admin_fee: string, // %
+        liquidation_discount: string, // %
+        loan_discount: string, // %
+        base_price: string,
+        A: string,
+    }> => {
+        const llammaContract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
+        const controllerContract = this.llamalend.contracts[this.market.addresses.controller].multicallContract;
+
+        const calls = [
+            llammaContract.fee(),
+            llammaContract.admin_fee(), // TODO: removed
+            controllerContract.liquidation_discount(),
+            controllerContract.loan_discount(),
+            llammaContract.get_base_price(),
+            llammaContract.A(),
+        ]
+
+        const [_fee, _admin_fee, _liquidation_discount, _loan_discount, _base_price, _A]: bigint[] = await this.llamalend.multicallProvider.all(calls) as bigint[];
+        const A = formatUnits(_A, 0)
+        const base_price = formatUnits(_base_price)
+        const [fee, admin_fee, liquidation_discount, loan_discount] = [_fee, _admin_fee, _liquidation_discount, _loan_discount]
+            .map((_x) => formatUnits(_x * BigInt(100)));
+
+        return { fee, admin_fee, liquidation_discount, loan_discount, base_price, A }
+    }, {
+        promise: true,
+        maxAge: 5 * 60 * 1000, // 5m
+    });
+
+    private _getRate = async (isGetter = true): Promise<bigint> => {
+        let _rate;
+        if(isGetter) {
+            _rate = cacheStats.get(cacheKey(this.market.addresses.amm, 'rate'));
+        } else {
+            _rate = await this.llamalend.contracts[this.market.addresses.amm].contract.rate(this.llamalend.constantOptions);
+            cacheStats.set(cacheKey(this.market.addresses.controller, 'rate'), _rate);
+        }
+        return _rate;
+    }
+
+    private _getFutureRate = async (_dReserves: bigint, _dDebt: bigint): Promise<bigint> => {
+        const mpContract = this.llamalend.contracts[this.market.addresses.monetary_policy].contract;
+        return await mpContract.future_rate(this.market.addresses.controller, _dReserves, _dDebt);
+    }
+
+    public async statsRates(isGetter = true, useAPI = false): Promise<{borrowApr: string, lendApr: string, borrowApy: string, lendApy: string}> {
+        if(useAPI) {
+            const response = await _getMarketsData(this.llamalend.constants.NETWORK_NAME);
+
+            const market = response.lendingVaultData.find((item) => item.address.toLowerCase() === this.market.addresses.vault.toLowerCase())
+
+            if(market) {
+                return {
+                    borrowApr: (market.rates.borrowApr * 100).toString(),
+                    lendApr: (market.rates.lendApr * 100).toString(),
+                    borrowApy: (market.rates.borrowApy * 100).toString(),
+                    lendApy: (market.rates.lendApy * 100).toString(),
+                }
+            } else {
+                throw new Error('Market not found in API')
+            }
+        } else {
+            const _rate = await this._getRate(isGetter);
+            const borrowApr =  toBN(_rate).times(365).times(86400).times(100).toString();
+            // borrowApy = e**(rate*365*86400) - 1
+            const borrowApy = String(((2.718281828459 ** (toBN(_rate).times(365).times(86400)).toNumber()) - 1) * 100);
+            let lendApr = "0";
+            let lendApy = "0";
+            const debt = await this.statsTotalDebt(isGetter);
+            if (Number(debt) > 0) {
+                const { cap } = await this.statsCapAndAvailable(isGetter);
+                lendApr = toBN(_rate).times(365).times(86400).times(debt).div(cap).times(100).toString();
+                // lendApy = (debt * e**(rate*365*86400) - debt) / cap
+                const debtInAYearBN = BN(debt).times(2.718281828459 ** (toBN(_rate).times(365).times(86400)).toNumber());
+                lendApy = debtInAYearBN.minus(debt).div(cap).times(100).toString();
+            }
+
+            return { borrowApr, lendApr, borrowApy, lendApy }
+        }
+    }
+
+    public async statsFutureRates(dReserves: TAmount, dDebt: TAmount, useAPI = true): Promise<{borrowApr: string, lendApr: string, borrowApy: string, lendApy: string}> {
+        const _dReserves = parseUnits(dReserves, this.market.borrowed_token.decimals);
+        const _dDebt = parseUnits(dDebt, this.market.borrowed_token.decimals);
+        const _rate = await this._getFutureRate(_dReserves, _dDebt);
+        const borrowApr =  toBN(_rate).times(365).times(86400).times(100).toString();
+        // borrowApy = e**(rate*365*86400) - 1
+        const borrowApy = String(((2.718281828459 ** (toBN(_rate).times(365).times(86400)).toNumber()) - 1) * 100);
+        let lendApr = "0";
+        let lendApy = "0";
+        const debt = Number(await this.statsTotalDebt()) + Number(dDebt);
+        if (Number(debt) > 0) {
+            const cap = Number((await this.statsCapAndAvailable(true, useAPI)).cap) + Number(dReserves);
+            lendApr = toBN(_rate).times(365).times(86400).times(debt).div(cap).times(100).toString();
+            // lendApy = (debt * e**(rate*365*86400) - debt) / cap
+            const debtInAYearBN = BN(debt).times(2.718281828459 ** (toBN(_rate).times(365).times(86400)).toNumber());
+            lendApy = debtInAYearBN.minus(debt).div(cap).times(100).toString();
+        }
+
+        return { borrowApr, lendApr, borrowApy, lendApy }
+    }
+
+    public async statsBalances(): Promise<[string, string]> {
+        const borrowedContract = this.llamalend.contracts[this.market.borrowed_token.address].multicallContract;
+        const collateralContract = this.llamalend.contracts[this.market.collateral_token.address].multicallContract;
+        const ammContract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
+        const calls = [
+            borrowedContract.balanceOf(this.market.addresses.amm),
+            collateralContract.balanceOf(this.market.addresses.amm),
+            ammContract.admin_fees_x(), // TODO: always 0
+            ammContract.admin_fees_y(), // TODO: always 0
+        ]
+        const [_borrowedBalance, _collateralBalance, _borrowedAdminFees, _collateralAdminFees]: bigint[] = await this.llamalend.multicallProvider.all(calls);
+
+        return [
+            formatUnits(_borrowedBalance - _borrowedAdminFees, this.market.borrowed_token.decimals),
+            formatUnits(_collateralBalance - _collateralAdminFees, this.market.collateral_token.decimals),
+        ];
+    }
+
+    public statsBandsInfo = memoize(async (): Promise<{ activeBand: number, maxBand: number, minBand: number, liquidationBand: number | null }> => {
+        const ammContract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
+        const calls = [
+            ammContract.active_band_with_skip(),
+            ammContract.max_band(),
+            ammContract.min_band(),
+        ]
+
+        const [activeBand, maxBand, minBand] = (await this.llamalend.multicallProvider.all(calls) as bigint[]).map((_b) => Number(_b));
+        const { borrowed, collateral } = await this.statsBandBalances(activeBand);
+        let liquidationBand = null;
+        if (Number(borrowed) > 0 && Number(collateral) > 0) liquidationBand = activeBand;
+        return { activeBand, maxBand, minBand, liquidationBand }
+    },
+    {
+        promise: true,
+        maxAge: 60 * 1000, // 1m
+    });
+
+    public async statsBandBalances(n: number): Promise<{ borrowed: string, collateral: string }> {
+        const ammContract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
+        const calls = [];
+        calls.push(ammContract.bands_x(n), ammContract.bands_y(n));
+        const _balances: bigint[] = await this.llamalend.multicallProvider.all(calls);
+
+        // bands_x and bands_y always return amounts with 18 decimals
+        return {
+            borrowed: formatNumber(formatUnits(_balances[0]), this.market.borrowed_token.decimals),
+            collateral: formatNumber(formatUnits(_balances[1]), this.market.collateral_token.decimals),
+        }
+    }
+
+    public async statsBandsBalances(): Promise<{ [index: number]: { borrowed: string, collateral: string } }> {
+        const { maxBand, minBand } = await this.statsBandsInfo();
+
+        const ammContract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
+        const calls = [];
+        for (let i = minBand; i <= maxBand; i++) {
+            calls.push(ammContract.bands_x(i), ammContract.bands_y(i));
+        }
+
+        const _bands: bigint[] = await this.llamalend.multicallProvider.all(calls);
+
+        const bands: { [index: number]: { borrowed: string, collateral: string } } = {};
+        for (let i = minBand; i <= maxBand; i++) {
+            const _i = i - minBand
+            // bands_x and bands_y always return amounts with 18 decimals
+            bands[i] = {
+                borrowed: formatNumber(formatUnits(_bands[2 * _i]), this.market.borrowed_token.decimals),
+                collateral: formatNumber(formatUnits(_bands[(2 * _i) + 1]), this.market.collateral_token.decimals),
+            }
+        }
+
+        return bands
+    }
+
+    public async statsTotalDebt(isGetter = true, useAPI = true): Promise<string> {
+        if(useAPI) {
+            const response = await _getMarketsData(this.llamalend.constants.NETWORK_NAME);
+
+            const market = response.lendingVaultData.find((item) => item.address.toLowerCase() === this.market.addresses.vault.toLowerCase())
+
+            if(market) {
+                return market.borrowed.total.toString();
+            } else {
+                throw new Error('Market not found in API')
+            }
+        } else {
+            let _debt;
+            if(isGetter) {
+                _debt = cacheStats.get(cacheKey(this.market.addresses.controller, 'total_debt'));
+            } else {
+                _debt = await this.llamalend.contracts[this.market.addresses.controller].contract.total_debt(this.llamalend.constantOptions);
+                cacheStats.set(cacheKey(this.market.addresses.controller, 'total_debt'), _debt);
+            }
+
+            return formatUnits(_debt, this.market.borrowed_token.decimals);
+        }
+    }
+
+    public statsAmmBalances = async (isGetter = true, useAPI = false): Promise<{ borrowed: string, collateral: string }> => {
+        if(useAPI) {
+            const response = await _getMarketsData(this.llamalend.constants.NETWORK_NAME);
+
+            const market = response.lendingVaultData.find((item) => item.address.toLowerCase() === this.market.addresses.vault.toLowerCase())
+
+            if(market) {
+                return {
+                    borrowed: market.ammBalances.ammBalanceBorrowed.toString(),
+                    collateral: market.ammBalances.ammBalanceCollateral.toString(),
+                }
+            } else {
+                throw new Error('Market not found in API')
+            }
+        } else {
+            const borrowedContract = this.llamalend.contracts[this.market.addresses.borrowed_token].multicallContract;
+            const collateralContract = this.llamalend.contracts[this.market.addresses.collateral_token].multicallContract;
+            const ammContract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
+
+            let _balance_x, _fee_x, _balance_y, _fee_y; // TODO: fees are always 0
+            if(isGetter) {
+                [_balance_x, _fee_x, _balance_y, _fee_y] = [
+                    cacheStats.get(cacheKey(this.market.addresses.borrowed_token, 'balanceOf', this.market.addresses.amm)),
+                    cacheStats.get(cacheKey(this.market.addresses.amm, 'admin_fees_x')),
+                    cacheStats.get(cacheKey(this.market.addresses.collateral_token, 'balanceOf', this.market.addresses.amm)),
+                    cacheStats.get(cacheKey(this.market.addresses.amm, 'admin_fees_y')),
+                ]
+            } else {
+                [_balance_x, _fee_x, _balance_y, _fee_y] = await this.llamalend.multicallProvider.all([
+                    borrowedContract.balanceOf(this.market.addresses.amm),
+                    ammContract.admin_fees_x(),
+                    collateralContract.balanceOf(this.market.addresses.amm),
+                    ammContract.admin_fees_y(),
+                ]);
+                cacheStats.set(cacheKey(this.market.addresses.borrowed_token, 'balanceOf', this.market.addresses.amm), _balance_x);
+                cacheStats.set(cacheKey(this.market.addresses.amm, 'admin_fees_x'), _fee_x);
+                cacheStats.set(cacheKey(this.market.addresses.collateral_token, 'balanceOf', this.market.addresses.amm), _balance_y);
+                cacheStats.set(cacheKey(this.market.addresses.amm, 'admin_fees_y'), _fee_y);
+            }
+
+            return {
+                borrowed: toBN(_balance_x, this.market.borrowed_token.decimals).minus(toBN(_fee_x, this.market.borrowed_token.decimals)).toString(),
+                collateral: toBN(_balance_y, this.market.collateral_token.decimals).minus(toBN(_fee_y, this.market.collateral_token.decimals)).toString(),
+            }
+        }
+    }
+
+    public async statsCapAndAvailable(isGetter = true, useAPI = false): Promise<{ cap: string, available: string }> {
+        if(useAPI) {
+            const response = await _getMarketsData(this.llamalend.constants.NETWORK_NAME);
+
+            const market = response.lendingVaultData.find((item) => item.address.toLowerCase() === this.market.addresses.vault.toLowerCase())
+
+            if(market) {
+                return {
+                    cap: market.totalSupplied.total.toString(),
+                    available: market.availableToBorrow.total.toString(),
+                }
+            } else {
+                throw new Error('Market not found in API')
+            }
+        } else {
+            const vaultContract = this.llamalend.contracts[this.market.addresses.vault].multicallContract;
+            const borrowedContract = this.llamalend.contracts[this.market.addresses.borrowed_token].multicallContract;
+
+            let _cap, _available;
+            if(isGetter) { // TODO: should call controller.available_balance() instead of borrowed_token.balanceOf(controller)
+                _cap = cacheStats.get(cacheKey(this.market.addresses.vault, 'totalAssets', this.market.addresses.controller));
+                _available = cacheStats.get(cacheKey(this.market.addresses.borrowed_token, 'balanceOf', this.market.addresses.controller));
+            } else {
+                [_cap, _available] =await this.llamalend.multicallProvider.all([
+                    vaultContract.totalAssets(this.market.addresses.controller),
+                    borrowedContract.balanceOf(this.market.addresses.controller),
+                ]);
+                cacheStats.set(cacheKey(this.market.addresses.vault, 'totalAssets', this.market.addresses.controller), _cap);
+                cacheStats.set(cacheKey(this.market.addresses.borrowed_token, 'balanceOf', this.market.addresses.controller), _available);
+            }
+
+            return {
+                cap: this.llamalend.formatUnits(_cap, this.market.borrowed_token.decimals),
+                available: this.llamalend.formatUnits(_available, this.market.borrowed_token.decimals),
+            }
+            // cap -> totalAssets
+            // add cap: controller.borrow_cap() // Display
+        }
+    }
+}

package/src/lendMarkets/modules/common/userPosition.ts

@@ -0,0 +1,243 @@
+import memoize from "memoizee";
+import {IDict} from "../../../interfaces";
+import type { LendMarketTemplate } from "../../LendMarketTemplate";
+import {
+    BN,
+    formatUnits,
+    _getAddress, toBN,
+} from "../../../utils";
+import {Llamalend} from "../../../llamalend";
+import {_getUserCollateral, _getUserCollateralForce} from "../../../external-api";
+import {IUserPosition} from "../../interfaces/common";
+
+export class UserPositionModule implements IUserPosition {
+    private market: LendMarketTemplate;
+    private llamalend: Llamalend;
+
+    constructor(market: LendMarketTemplate) {
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+
+    public async userLoanExists(address = ""): Promise<boolean> {
+        address = _getAddress.call(this.llamalend, address);
+        return  await this.llamalend.contracts[this.market.addresses.controller].contract.loan_exists(address, this.llamalend.constantOptions);
+    }
+
+    private _userState = memoize(async (address = ""): Promise<{ _collateral: bigint, _borrowed: bigint, _debt: bigint, _N: bigint }> => {
+        address = _getAddress.call(this.llamalend, address);
+        const contract = this.llamalend.contracts[this.market.addresses.controller].contract;
+        const [_collateral, _borrowed, _debt, _N] = await contract.user_state(address, this.llamalend.constantOptions) as bigint[];
+
+        return { _collateral, _borrowed, _debt, _N }
+    },
+    {
+        promise: true,
+        maxAge: 10 * 1000, // 10s
+    });
+
+    public async userState(address = ""): Promise<{ collateral: string, borrowed: string, debt: string, N: string }> {
+        const { _collateral, _borrowed, _debt, _N } = await this._userState(address);
+
+        return {
+            collateral: formatUnits(_collateral, this.market.collateral_token.decimals),
+            borrowed: formatUnits(_borrowed, this.market.borrowed_token.decimals),
+            debt: formatUnits(_debt, this.market.borrowed_token.decimals),
+            N: formatUnits(_N, 0),
+        };
+    }
+
+    public async userStateBigInt(address = ""): Promise<{ _collateral: bigint, _borrowed: bigint, _debt: bigint, _N: bigint }> {
+        return await this._userState(address);
+    }
+
+    public async userHealth(full = true, address = ""): Promise<string> {
+        address = _getAddress.call(this.llamalend, address);
+        let _health = await this.llamalend.contracts[this.market.addresses.controller].contract.health(address, full, this.llamalend.constantOptions) as bigint;
+        _health = _health * BigInt(100);
+
+        return formatUnits(_health);
+    }
+
+    private async _userBands(address: string): Promise<bigint[]> {
+        address = _getAddress.call(this.llamalend, address);
+        const _bands = await this.llamalend.contracts[this.market.addresses.amm].contract.read_user_tick_numbers(address, this.llamalend.constantOptions) as bigint[];
+
+        return Array.from(_bands).reverse();
+    }
+
+    public async userBands(address = ""): Promise<number[]> {
+        return (await this._userBands(address)).map((_t) => Number(_t));
+    }
+
+    public async userBandsBigInt(address = ""): Promise<bigint[]> {
+        return await this._userBands(address);
+    }
+
+    public async userRange(address = ""): Promise<number> {
+        const [n2, n1] = await this.userBands(address);
+        if (n1 == n2) return 0;
+        return n2 - n1 + 1;
+    }
+
+    public async userPrices(address = ""): Promise<string[]> {
+        address = _getAddress.call(this.llamalend, address);
+        const _prices = await this.llamalend.contracts[this.market.addresses.controller].contract.user_prices(address, this.llamalend.constantOptions) as bigint[];
+
+        return _prices.map((_p) => formatUnits(_p)).reverse();
+    }
+
+    public async userLoss(userAddress = ""): Promise<{ deposited_collateral: string, current_collateral_estimation: string, loss: string, loss_pct: string }> {
+        userAddress = _getAddress.call(this.llamalend, userAddress);
+        const [userCollateral, _current_collateral_estimation] = await Promise.all([
+            _getUserCollateral(this.llamalend.constants.NETWORK_NAME, this.market.addresses.controller, userAddress),
+            this.llamalend.contracts[this.market.addresses.amm].contract.get_y_up(userAddress),
+        ]);
+
+        const deposited_collateral = userCollateral.total_deposit_precise;
+
+        const current_collateral_estimation = this.llamalend.formatUnits(_current_collateral_estimation, this.market.collateral_token.decimals);
+        if (BN(deposited_collateral).lte(0)) {
+            return {
+                deposited_collateral,
+                current_collateral_estimation,
+                loss: "0.0",
+                loss_pct: "0.0",
+            };
+        }
+        const loss = BN(deposited_collateral).minus(current_collateral_estimation).toString()
+        const loss_pct = BN(loss).div(deposited_collateral).times(100).toString();
+
+        return {
+            deposited_collateral,
+            current_collateral_estimation,
+            loss,
+            loss_pct,
+        };
+    }
+
+    public async userBandsBalances(address = ""): Promise<IDict<{ collateral: string, borrowed: string }>> {
+        const [n2, n1] = await this.userBands(address);
+        if (n1 == 0 && n2 == 0) return {};
+
+        address = _getAddress.call(this.llamalend, address);
+        const contract = this.llamalend.contracts[this.market.addresses.amm].contract;
+        const [_borrowed, _collateral] = await contract.get_xy(address, this.llamalend.constantOptions) as [bigint[], bigint[]];
+
+        const res: IDict<{ borrowed: string, collateral: string }> = {};
+        for (let i = n1; i <= n2; i++) {
+            res[i] = {
+                collateral: formatUnits(_collateral[i - n1], this.market.collateral_token.decimals),
+                borrowed: formatUnits(_borrowed[i - n1], this.market.borrowed_token.decimals),
+            };
+        }
+
+        return res
+    }
+
+    public async currentLeverage(userAddress = ''): Promise<string> {
+        userAddress = _getAddress.call(this.llamalend, userAddress);
+        const [userCollateral, {collateral}] = await Promise.all([
+            _getUserCollateral(this.llamalend.constants.NETWORK_NAME, this.market.addresses.controller, userAddress),
+            this.userState(userAddress),
+        ]);
+
+        const total_deposit_from_user = userCollateral.total_deposit_from_user_precise;
+
+        return BN(collateral).div(total_deposit_from_user).toString();
+    }
+
+    public async currentPnL(userAddress = ''): Promise<Record<string, string>> {
+        userAddress = _getAddress.call(this.llamalend, userAddress);
+
+        const calls = [
+            this.llamalend.contracts[this.market.addresses.controller].multicallContract.user_state(userAddress, this.llamalend.constantOptions),
+            this.llamalend.contracts[this.market.addresses.amm].multicallContract.price_oracle(userAddress),
+        ];
+
+        const [userState, oraclePrice] = await this.llamalend.multicallProvider.all(calls) as  [bigint[],bigint];
+
+        if(!(userState || oraclePrice)) {
+            throw new Error('Multicall error')
+        }
+
+        const debt = userState[2];
+
+        const userCollateral = await _getUserCollateral(this.llamalend.constants.NETWORK_NAME, this.market.addresses.controller, userAddress);
+        const totalDepositUsdValueFull = userCollateral.total_deposit_usd_value;
+        const totalDepositUsdValueUser = userCollateral.total_deposit_from_user_usd_value;
+        const totalBorrowed = userCollateral.total_borrowed;
+
+        const oraclePriceFormatted = this.llamalend.formatUnits(oraclePrice, 18);
+        const debtFormatted = this.llamalend.formatUnits(debt, 18);
+
+        const {_collateral: AmmCollateral, _borrowed: AmmBorrowed} = await this._userState(userAddress)
+        const [AmmCollateralFormatted, AmmBorrowedFormatted] = [this.llamalend.formatUnits(AmmCollateral, this.market.collateral_token.decimals), this.llamalend.formatUnits(AmmBorrowed, this.market.borrowed_token.decimals)];
+
+        const a = BN(AmmCollateralFormatted).times(oraclePriceFormatted);
+        const b = BN(totalBorrowed).minus(debtFormatted)
+
+        const currentPosition = a.plus(AmmBorrowedFormatted).plus(b);
+
+        const currentProfit = currentPosition.minus(totalDepositUsdValueFull);
+
+        const percentage = currentProfit.div(totalDepositUsdValueUser).times(100);
+
+        return {
+            currentPosition: currentPosition.toFixed(this.market.borrowed_token.decimals).toString(),
+            deposited: totalDepositUsdValueUser.toString(),
+            currentProfit: currentProfit.toFixed(this.market.borrowed_token.decimals).toString(),
+            percentage: percentage.toFixed(2).toString(),
+        };
+    }
+
+    public async userBoost(address = ""): Promise<string> {
+        if (this.market.addresses.gauge === this.llamalend.constants.ZERO_ADDRESS) {
+            throw Error(`${this.market.name} doesn't have gauge`);
+        }
+        if (this.market.vault.rewardsOnly()) {
+            throw Error(`${this.market.name} has Rewards-Only Gauge. Use stats.rewardsApy instead`);
+        }
+        address = _getAddress.call(this.llamalend, address);
+
+        const gaugeContract = this.llamalend.contracts[this.market.addresses.gauge].multicallContract;
+        const [workingBalanceBN, balanceBN] = (await this.llamalend.multicallProvider.all([
+            gaugeContract.working_balances(address),
+            gaugeContract.balanceOf(address),
+        ]) as bigint[]).map((value: bigint) => toBN(value));
+
+        if (balanceBN.isZero()) {
+            return '1.0';
+        }
+
+        const boostBN = workingBalanceBN.div(0.4).div(balanceBN);
+        if (boostBN.lt(1)) return '1.0';
+        if (boostBN.gt(2.5)) return '2.5';
+
+        return boostBN.toFixed(4).replace(/([0-9])0+$/, '$1');
+    }
+
+    public async getCurrentLeverageParams(userAddress: string): Promise<{ stateCollateral: string, totalDepositFromUser: string }> {
+        const [userCollateralData, { collateral: stateCollateral }] = await Promise.all([
+            _getUserCollateral(this.llamalend.constants.NETWORK_NAME, this.market.addresses.controller, userAddress),
+            this.userState(userAddress),
+        ]);
+
+        return {
+            stateCollateral,
+            totalDepositFromUser: String(userCollateralData.total_deposit_from_user_precise),
+        };
+    }
+
+    public async forceUpdateUserState(newTx: string, userAddress?: string): Promise<void> {
+        const address = userAddress || this.llamalend.signerAddress;
+        if (!address) throw Error("Need to connect wallet or pass address into args");
+
+        await _getUserCollateralForce(
+            this.llamalend.constants.NETWORK_NAME,
+            this.market.addresses.controller,
+            address,
+            newTx
+        );
+    }
+}