@curvefi/llamalend-api 1.1.10 → 2.0.1

package/lib/lendMarkets/modules/common/prices.d.ts

@@ -0,0 +1,19 @@
+import memoize from "memoizee";
+import type { LendMarketTemplate } from "../../LendMarketTemplate";
+import { IPrices } from "../../interfaces/common";
+export declare class PricesModule implements IPrices {
+    private market;
+    private llamalend;
+    constructor(market: LendMarketTemplate);
+    A: (() => Promise<string>) & memoize.Memoized<() => Promise<string>>;
+    basePrice: (() => Promise<string>) & memoize.Memoized<() => Promise<string>>;
+    oraclePrice: (() => Promise<string>) & memoize.Memoized<() => Promise<string>>;
+    oraclePriceBand(): Promise<number>;
+    price(): Promise<string>;
+    calcTickPrice(n: number): Promise<string>;
+    calcBandPrices(n: number): Promise<[string, string]>;
+    calcRangePct(range: number): Promise<string>;
+    getPrices(_n2: bigint, _n1: bigint): Promise<[string, string]>;
+    calcPrices(_n2: bigint, _n1: bigint): Promise<[string, string]>;
+    checkRange(range: number): void;
+}

package/lib/lendMarkets/modules/common/prices.js

@@ -0,0 +1,104 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import memoize from "memoizee";
+import { BN, formatUnits, _cutZeros, } from "../../../utils";
+export class PricesModule {
+    constructor(market) {
+        this.A = memoize(() => __awaiter(this, void 0, void 0, function* () {
+            const _A = yield this.llamalend.contracts[this.market.addresses.amm].contract.A(this.llamalend.constantOptions);
+            return formatUnits(_A, 0);
+        }), {
+            promise: true,
+            maxAge: 86400 * 1000, // 1d
+        });
+        this.basePrice = memoize(() => __awaiter(this, void 0, void 0, function* () {
+            const _price = yield this.llamalend.contracts[this.market.addresses.amm].contract.get_base_price(this.llamalend.constantOptions);
+            return formatUnits(_price);
+        }), {
+            promise: true,
+            maxAge: 86400 * 1000, // 1d
+        });
+        this.oraclePrice = memoize(() => __awaiter(this, void 0, void 0, function* () {
+            const _price = yield this.llamalend.contracts[this.market.addresses.amm].contract.price_oracle(this.llamalend.constantOptions);
+            return formatUnits(_price);
+        }), {
+            promise: true,
+            maxAge: 60 * 1000, // 1m
+        });
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+    oraclePriceBand() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const oraclePriceBN = BN(yield this.oraclePrice());
+            const basePriceBN = BN(yield this.basePrice());
+            const A_BN = BN(yield 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, currentTickPriceBN) => oraclePriceBN.lte(currentTickPriceBN) :
+                (oraclePriceBN, currentTickPriceBN) => 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;
+        });
+    }
+    price() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _price = yield this.llamalend.contracts[this.market.addresses.amm].contract.get_p(this.llamalend.constantOptions);
+            return formatUnits(_price);
+        });
+    }
+    calcTickPrice(n) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const basePrice = yield this.basePrice();
+            const basePriceBN = BN(basePrice);
+            const A_BN = BN(yield this.A());
+            return _cutZeros(basePriceBN.times(A_BN.minus(1).div(A_BN).pow(n)).toFixed(18));
+        });
+    }
+    calcBandPrices(n) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [yield this.calcTickPrice(n + 1), yield this.calcTickPrice(n)];
+        });
+    }
+    calcRangePct(range) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const A_BN = BN(yield 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);
+        });
+    }
+    getPrices(_n2, _n1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
+            return (yield this.llamalend.multicallProvider.all([
+                contract.p_oracle_down(_n2),
+                contract.p_oracle_up(_n1),
+            ])).map((_p) => formatUnits(_p));
+        });
+    }
+    calcPrices(_n2, _n1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return [yield this.calcTickPrice(Number(_n2) + 1), yield this.calcTickPrice(Number(_n1))];
+        });
+    }
+    checkRange(range) {
+        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/lib/lendMarkets/modules/common/statsBase.d.ts

@@ -0,0 +1,69 @@
+import memoize from "memoizee";
+import { TAmount } from "../../../interfaces";
+import type { LendMarketTemplate } from "../../LendMarketTemplate";
+import { Llamalend } from "../../../llamalend";
+export declare class StatsBaseModule {
+    protected market: LendMarketTemplate;
+    protected llamalend: Llamalend;
+    constructor(market: LendMarketTemplate);
+    statsParameters: (() => Promise<{
+        fee: string;
+        admin_fee: string;
+        liquidation_discount: string;
+        loan_discount: string;
+        base_price: string;
+        A: string;
+    }>) & memoize.Memoized<() => Promise<{
+        fee: string;
+        admin_fee: string;
+        liquidation_discount: string;
+        loan_discount: string;
+        base_price: string;
+        A: string;
+    }>>;
+    private _getRate;
+    private _getFutureRate;
+    statsRates(isGetter?: boolean, useAPI?: boolean): Promise<{
+        borrowApr: string;
+        lendApr: string;
+        borrowApy: string;
+        lendApy: string;
+    }>;
+    statsFutureRates(dReserves: TAmount, dDebt: TAmount, useAPI?: boolean): Promise<{
+        borrowApr: string;
+        lendApr: string;
+        borrowApy: string;
+        lendApy: string;
+    }>;
+    statsBalances(): Promise<[string, string]>;
+    statsBandsInfo: (() => Promise<{
+        activeBand: number;
+        maxBand: number;
+        minBand: number;
+        liquidationBand: number | null;
+    }>) & memoize.Memoized<() => Promise<{
+        activeBand: number;
+        maxBand: number;
+        minBand: number;
+        liquidationBand: number | null;
+    }>>;
+    statsBandBalances(n: number): Promise<{
+        borrowed: string;
+        collateral: string;
+    }>;
+    statsBandsBalances(): Promise<{
+        [index: number]: {
+            borrowed: string;
+            collateral: string;
+        };
+    }>;
+    statsTotalDebt(isGetter?: boolean, useAPI?: boolean): Promise<string>;
+    statsAmmBalances: (isGetter?: boolean, useAPI?: boolean) => Promise<{
+        borrowed: string;
+        collateral: string;
+    }>;
+    statsCapAndAvailable(isGetter?: boolean, useAPI?: boolean): Promise<{
+        cap: string;
+        available: string;
+    }>;
+}

package/lib/lendMarkets/modules/common/statsBase.js

@@ -0,0 +1,291 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import memoize from "memoizee";
+import { parseUnits, BN, toBN, formatUnits, formatNumber, } from "../../../utils";
+import { _getMarketsData } from "../../../external-api";
+import { cacheKey, cacheStats } from "../../../cache";
+export class StatsBaseModule {
+    constructor(market) {
+        this.statsParameters = memoize(() => __awaiter(this, void 0, void 0, function* () {
+            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] = yield this.llamalend.multicallProvider.all(calls);
+            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
+        });
+        this._getRate = (...args_1) => __awaiter(this, [...args_1], void 0, function* (isGetter = true) {
+            let _rate;
+            if (isGetter) {
+                _rate = cacheStats.get(cacheKey(this.market.addresses.amm, 'rate'));
+            }
+            else {
+                _rate = yield this.llamalend.contracts[this.market.addresses.amm].contract.rate(this.llamalend.constantOptions);
+                cacheStats.set(cacheKey(this.market.addresses.controller, 'rate'), _rate);
+            }
+            return _rate;
+        });
+        this._getFutureRate = (_dReserves, _dDebt) => __awaiter(this, void 0, void 0, function* () {
+            const mpContract = this.llamalend.contracts[this.market.addresses.monetary_policy].contract;
+            return yield mpContract.future_rate(this.market.addresses.controller, _dReserves, _dDebt);
+        });
+        this.statsBandsInfo = memoize(() => __awaiter(this, void 0, void 0, function* () {
+            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] = (yield this.llamalend.multicallProvider.all(calls)).map((_b) => Number(_b));
+            const { borrowed, collateral } = yield 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
+        });
+        this.statsAmmBalances = (...args_1) => __awaiter(this, [...args_1], void 0, function* (isGetter = true, useAPI = false) {
+            if (useAPI) {
+                const response = yield _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] = yield 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(),
+                };
+            }
+        });
+        this.market = market;
+        this.llamalend = market.getLlamalend();
+    }
+    statsRates() {
+        return __awaiter(this, arguments, void 0, function* (isGetter = true, useAPI = false) {
+            if (useAPI) {
+                const response = yield _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 = yield this._getRate(isGetter);
+                const borrowApr = toBN(_rate).times(365).times(86400).times(100).toString();
+                // borrowApy = e**(rate*365*86400) - 1
+                const borrowApy = String(((Math.pow(2.718281828459, (toBN(_rate).times(365).times(86400)).toNumber())) - 1) * 100);
+                let lendApr = "0";
+                let lendApy = "0";
+                const debt = yield this.statsTotalDebt(isGetter);
+                if (Number(debt) > 0) {
+                    const { cap } = yield 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(Math.pow(2.718281828459, (toBN(_rate).times(365).times(86400)).toNumber()));
+                    lendApy = debtInAYearBN.minus(debt).div(cap).times(100).toString();
+                }
+                return { borrowApr, lendApr, borrowApy, lendApy };
+            }
+        });
+    }
+    statsFutureRates(dReserves_1, dDebt_1) {
+        return __awaiter(this, arguments, void 0, function* (dReserves, dDebt, useAPI = true) {
+            const _dReserves = parseUnits(dReserves, this.market.borrowed_token.decimals);
+            const _dDebt = parseUnits(dDebt, this.market.borrowed_token.decimals);
+            const _rate = yield this._getFutureRate(_dReserves, _dDebt);
+            const borrowApr = toBN(_rate).times(365).times(86400).times(100).toString();
+            // borrowApy = e**(rate*365*86400) - 1
+            const borrowApy = String(((Math.pow(2.718281828459, (toBN(_rate).times(365).times(86400)).toNumber())) - 1) * 100);
+            let lendApr = "0";
+            let lendApy = "0";
+            const debt = Number(yield this.statsTotalDebt()) + Number(dDebt);
+            if (Number(debt) > 0) {
+                const cap = Number((yield 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(Math.pow(2.718281828459, (toBN(_rate).times(365).times(86400)).toNumber()));
+                lendApy = debtInAYearBN.minus(debt).div(cap).times(100).toString();
+            }
+            return { borrowApr, lendApr, borrowApy, lendApy };
+        });
+    }
+    statsBalances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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] = yield this.llamalend.multicallProvider.all(calls);
+            return [
+                formatUnits(_borrowedBalance - _borrowedAdminFees, this.market.borrowed_token.decimals),
+                formatUnits(_collateralBalance - _collateralAdminFees, this.market.collateral_token.decimals),
+            ];
+        });
+    }
+    statsBandBalances(n) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ammContract = this.llamalend.contracts[this.market.addresses.amm].multicallContract;
+            const calls = [];
+            calls.push(ammContract.bands_x(n), ammContract.bands_y(n));
+            const _balances = yield 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),
+            };
+        });
+    }
+    statsBandsBalances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { maxBand, minBand } = yield 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 = yield this.llamalend.multicallProvider.all(calls);
+            const bands = {};
+            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;
+        });
+    }
+    statsTotalDebt() {
+        return __awaiter(this, arguments, void 0, function* (isGetter = true, useAPI = true) {
+            if (useAPI) {
+                const response = yield _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 = yield 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);
+            }
+        });
+    }
+    statsCapAndAvailable() {
+        return __awaiter(this, arguments, void 0, function* (isGetter = true, useAPI = false) {
+            if (useAPI) {
+                const response = yield _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] = yield 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/lib/lendMarkets/modules/common/userPosition.d.ts

@@ -0,0 +1,46 @@
+import { IDict } from "../../../interfaces";
+import type { LendMarketTemplate } from "../../LendMarketTemplate";
+import { IUserPosition } from "../../interfaces/common";
+export declare class UserPositionModule implements IUserPosition {
+    private market;
+    private llamalend;
+    constructor(market: LendMarketTemplate);
+    userLoanExists(address?: string): Promise<boolean>;
+    private _userState;
+    userState(address?: string): Promise<{
+        collateral: string;
+        borrowed: string;
+        debt: string;
+        N: string;
+    }>;
+    userStateBigInt(address?: string): Promise<{
+        _collateral: bigint;
+        _borrowed: bigint;
+        _debt: bigint;
+        _N: bigint;
+    }>;
+    userHealth(full?: boolean, address?: string): Promise<string>;
+    private _userBands;
+    userBands(address?: string): Promise<number[]>;
+    userBandsBigInt(address?: string): Promise<bigint[]>;
+    userRange(address?: string): Promise<number>;
+    userPrices(address?: string): Promise<string[]>;
+    userLoss(userAddress?: string): Promise<{
+        deposited_collateral: string;
+        current_collateral_estimation: string;
+        loss: string;
+        loss_pct: string;
+    }>;
+    userBandsBalances(address?: string): Promise<IDict<{
+        collateral: string;
+        borrowed: string;
+    }>>;
+    currentLeverage(userAddress?: string): Promise<string>;
+    currentPnL(userAddress?: string): Promise<Record<string, string>>;
+    userBoost(address?: string): Promise<string>;
+    getCurrentLeverageParams(userAddress: string): Promise<{
+        stateCollateral: string;
+        totalDepositFromUser: string;
+    }>;
+    forceUpdateUserState(newTx: string, userAddress?: string): Promise<void>;
+}