@morpho-org/blue-sdk 5.16.0 → 5.17.0

package/lib/esm/market/Market.js

@@ -0,0 +1,576 @@
+import { Time, ZERO_ADDRESS } from "@morpho-org/morpho-ts";
+import { BlueErrors } from "../errors.js";
+import { AdaptiveCurveIrmLib, MathLib, } from "../math/index.js";
+import { CapacityLimitReason } from "../utils.js";
+import { MarketParams } from "./MarketParams.js";
+import { MarketUtils } from "./MarketUtils.js";
+/**
+ * Represents a lending market on Morpho Blue.
+ */
+export class Market {
+    /**
+     * The market's params.
+     */
+    params;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalSupplyAssets;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalBorrowAssets;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalSupplyShares;
+    /**
+     * The amount of loan assets supplied in total on the market.
+     */
+    totalBorrowShares;
+    /**
+     * The block timestamp (in __seconds__) when the interest was last accrued.
+     */
+    lastUpdate;
+    /**
+     * The fee percentage of the market, scaled by WAD.
+     */
+    fee;
+    /**
+     * The price as returned by the market's oracle.
+     * `undefined` if the oracle is undefined or reverts.
+     */
+    price;
+    /**
+     * If the market uses the Adaptive Curve IRM, the rate at target utilization.
+     * Undefined otherwise.
+     */
+    rateAtTarget;
+    constructor({ params, totalSupplyAssets, totalBorrowAssets, totalSupplyShares, totalBorrowShares, lastUpdate, fee, price, rateAtTarget, }) {
+        this.params =
+            params instanceof MarketParams ? params : new MarketParams(params);
+        this.totalSupplyAssets = totalSupplyAssets;
+        this.totalBorrowAssets = totalBorrowAssets;
+        this.totalSupplyShares = totalSupplyShares;
+        this.totalBorrowShares = totalBorrowShares;
+        this.lastUpdate = lastUpdate;
+        this.fee = fee;
+        this.price = price;
+        if (rateAtTarget != null)
+            this.rateAtTarget = rateAtTarget;
+    }
+    /**
+     * The market's hex-encoded id, defined as the hash of the market params.
+     */
+    get id() {
+        return this.params.id;
+    }
+    /**
+     * Whether the market satisfies the canonical definition of an idle market (i.e. collateral token is the zero address).
+     */
+    get isIdle() {
+        return this.params.collateralToken === ZERO_ADDRESS;
+    }
+    /**
+     * @warning Cannot be used to calculate the liquidity available inside a callback,
+     * because the balance of Blue may be lower than the market's liquidity due to assets being transferred out prior to the callback.
+     */
+    get liquidity() {
+        return this.totalSupplyAssets - this.totalBorrowAssets;
+    }
+    /**
+     * The market's utilization rate (scaled by WAD).
+     */
+    get utilization() {
+        return MarketUtils.getUtilization(this);
+    }
+    /**
+     * The market's Annual Percentage Yield (APY) at the IRM's target utilization rate, if applicable.
+     */
+    get apyAtTarget() {
+        if (this.rateAtTarget == null)
+            return;
+        return MarketUtils.rateToApy(this.rateAtTarget);
+    }
+    /**
+     * Returns the instantaneous rate at which interest accrues for borrowers of this market,
+     * if `accrueInterest` was called immediately onchain (scaled by WAD).
+     *
+     * Even if `accrueInterest` is called immediately onchain,
+     * the instantaneous rate only corresponds to an intermediary value used to calculate
+     * the actual average rate experienced by borrowers of this market.
+     *
+     * If interested in the instantaneous rate experienced by existing market actors at a specific timestamp,
+     * use `getEndBorrowRate(timestamp)`, `getBorrowApy(timestamp)`, or `getSupplyApy(timestamp)` instead.
+     */
+    get endBorrowRate() {
+        return this.getAccrualBorrowRates().endBorrowRate;
+    }
+    /**
+     * Returns the average rate at which interest _would_ accrue from `lastUpdate`
+     * till now, if `accrueInterest` was called immediately onchain (scaled by WAD).
+     * If `accrueInterest` was just called, the average rate equals the instantaneous rate,
+     * so it is equivalent to `getBorrowRate(lastUpdate)`.
+     *
+     * In most cases, `accrueInterest` will not be called immediately onchain,
+     * so the average rate is only an intermediary value.
+     *
+     * If interested in the average rate experienced by existing market actors at a specific timestamp,
+     * use `getAvgBorrowRate(timestamp)`, `getAvgBorrowApy(timestamp)`, or `getAvgSupplyApy(timestamp)` instead.
+     */
+    get avgBorrowRate() {
+        return this.getAccrualBorrowRates().avgBorrowRate;
+    }
+    /**
+     * The market's current, instantaneous supply-side Annual Percentage Yield (APY).
+     * If interested in the APY at a specific timestamp, use `getSupplyApy(timestamp)` instead.
+     */
+    get supplyApy() {
+        return this.getSupplyApy();
+    }
+    /**
+     * The market's current, instantaneous borrow-side Annual Percentage Yield (APY).
+     * If interested in the APY at a specific timestamp, use `getBorrowApy(timestamp)` instead.
+     */
+    get borrowApy() {
+        return this.getBorrowApy();
+    }
+    /**
+     * Returns the instantaneous rate at which interest accrues for borrowers of this market,
+     * at the given timestamp, if the state remains unchanged (not accrued) (scaled by WAD).
+     * It is fundamentally different from the rate at which interest is paid by borrowers to lenders in the case of an interest accrual,
+     * as in the case of the AdaptiveCurveIRM, the (approximated) average rate since the last update is used instead.
+     * @param timestamp The timestamp at which to calculate the borrow rate.
+     * Must be greater than or equal to `lastUpdate`.
+     * Defaults to `Time.timestamp()` (returns the current borrow rate).
+     */
+    getEndBorrowRate(timestamp = Time.timestamp()) {
+        return this.getAccrualBorrowRates(timestamp).endBorrowRate;
+    }
+    /**
+     * Returns the average rate at which interest _would_ accrue for borrowers of this market,
+     * if `accrueInterest` was called at the given timestamp (scaled by WAD).
+     * @param timestamp The timestamp at which to calculate the average borrow rate.
+     * Must be greater than or equal to `lastUpdate`.
+     * Defaults to `Time.timestamp()` (returns the current average borrow rate).
+     */
+    getAvgBorrowRate(timestamp = Time.timestamp()) {
+        return this.getAccrualBorrowRates(timestamp).avgBorrowRate;
+    }
+    /**
+     * Returns the rates that _would_ apply to interest accrual for borrowers of this market,
+     * if `accrueInterest` was called at the given timestamp (scaled by WAD).
+     * @param timestamp The timestamp at which to calculate the accrual borrow rate.
+     * Must be greater than or equal to `lastUpdate`.
+     * Defaults to `Time.timestamp()` (returns the current accrual borrow rate).
+     */
+    getAccrualBorrowRates(timestamp = Time.timestamp()) {
+        timestamp = BigInt(timestamp);
+        const elapsed = timestamp - this.lastUpdate;
+        if (elapsed < 0n)
+            throw new BlueErrors.InvalidInterestAccrual(this.id, timestamp, this.lastUpdate);
+        if (this.rateAtTarget == null)
+            return {
+                elapsed,
+                avgBorrowRate: 0n,
+                endBorrowRate: 0n,
+            };
+        return {
+            elapsed,
+            ...AdaptiveCurveIrmLib.getBorrowRate(this.utilization, this.rateAtTarget, elapsed),
+        };
+    }
+    /**
+     * The market's instantaneous borrow-side Annual Percentage Yield (APY) at the given timestamp,
+     * if the state remains unchanged (not accrued).
+     * @param timestamp The timestamp at which to calculate the borrow APY.
+     * Must be greater than or equal to `lastUpdate`.
+     * Defaults to `Time.timestamp()` (returns the current borrow APY).
+     */
+    getBorrowApy(timestamp = Time.timestamp()) {
+        const borrowRate = this.getEndBorrowRate(timestamp);
+        return MarketUtils.rateToApy(borrowRate);
+    }
+    /**
+     * The market's instantaneous supply-side Annual Percentage Yield (APY) at the given timestamp,
+     * if the state remains unchanged (not accrued).
+     * @param timestamp The timestamp at which to calculate the supply APY.
+     * Must be greater than or equal to `lastUpdate`.
+     * Defaults to `Time.timestamp()` (returns the current supply APY).
+     */
+    getSupplyApy(timestamp = Time.timestamp()) {
+        const borrowRate = this.getEndBorrowRate(timestamp);
+        return MarketUtils.rateToApy(MathLib.wMulUp(MathLib.wMulDown(borrowRate, this.utilization), MathLib.WAD - this.fee));
+    }
+    /**
+     * The market's experienced borrow-side Annual Percentage Yield (APY),
+     * if interest was to be accrued at the given timestamp.
+     * @param timestamp The timestamp at which to calculate the borrow APY.
+     * Must be greater than or equal to `lastUpdate`.
+     * Defaults to `Time.timestamp()` (returns the current borrow APY).
+     */
+    getAvgBorrowApy(timestamp = Time.timestamp()) {
+        const borrowRate = this.getAvgBorrowRate(timestamp);
+        return MarketUtils.rateToApy(borrowRate);
+    }
+    /**
+     * Returns the average rate at which interest _would_ accrue for suppliers of this market,
+     * if `accrueInterest` was called at the given timestamp (scaled by WAD).
+     * @param timestamp The timestamp at which to calculate the average supply rate.
+     * Must be greater than or equal to `lastUpdate`.
+     * Defaults to `Time.timestamp()` (returns the current average supply rate).
+     */
+    getAvgSupplyRate(timestamp = Time.timestamp()) {
+        const borrowRate = this.getAvgBorrowRate(timestamp);
+        return MathLib.wMulUp(MathLib.wMulDown(borrowRate, this.utilization), MathLib.WAD - this.fee);
+    }
+    /**
+     * The market's experienced supply-side Annual Percentage Yield (APY),
+     * if interest was to be accrued at the given timestamp.
+     * @param timestamp The timestamp at which to calculate the supply APY.
+     * Must be greater than or equal to `lastUpdate`.
+     * Defaults to `Time.timestamp()` (returns the current supply APY).
+     */
+    getAvgSupplyApy(timestamp = Time.timestamp()) {
+        return MarketUtils.rateToApy(this.getAvgSupplyRate(timestamp));
+    }
+    /**
+     * Returns a new market derived from this market, whose interest has been accrued up to the given timestamp.
+     * @param timestamp The timestamp at which to accrue interest.
+     * Must be greater than or equal to `lastUpdate`.
+     * Defaults to `lastUpdate` (returns a copy of the market).
+     */
+    accrueInterest(timestamp = this.lastUpdate) {
+        timestamp = BigInt(timestamp);
+        const { elapsed, avgBorrowRate, endRateAtTarget } = this.getAccrualBorrowRates(timestamp);
+        const { interest, feeShares } = MarketUtils.getAccruedInterest(avgBorrowRate, this, elapsed);
+        return new Market({
+            ...this,
+            totalSupplyAssets: this.totalSupplyAssets + interest,
+            totalBorrowAssets: this.totalBorrowAssets + interest,
+            totalSupplyShares: this.totalSupplyShares + feeShares,
+            lastUpdate: timestamp,
+            rateAtTarget: endRateAtTarget,
+        });
+    }
+    supply(assets, shares, timestamp) {
+        if ((assets === 0n) === (shares === 0n))
+            throw new BlueErrors.InconsistentInput(assets, shares);
+        const market = this.accrueInterest(timestamp);
+        if (shares === 0n)
+            shares = market.toSupplyShares(assets, "Down");
+        else
+            assets = market.toSupplyAssets(shares, "Up");
+        market.totalSupplyAssets += assets;
+        market.totalSupplyShares += shares;
+        return { market, assets, shares };
+    }
+    withdraw(assets, shares, timestamp) {
+        if ((assets === 0n) === (shares === 0n))
+            throw new BlueErrors.InconsistentInput(assets, shares);
+        const market = this.accrueInterest(timestamp);
+        if (shares === 0n)
+            shares = market.toSupplyShares(assets, "Up");
+        else
+            assets = market.toSupplyAssets(shares, "Down");
+        market.totalSupplyAssets -= assets;
+        market.totalSupplyShares -= shares;
+        if (market.totalBorrowAssets > market.totalSupplyAssets)
+            throw new BlueErrors.InsufficientLiquidity(market.id);
+        return { market, assets, shares };
+    }
+    borrow(assets, shares, timestamp) {
+        if ((assets === 0n) === (shares === 0n))
+            throw new BlueErrors.InconsistentInput(assets, shares);
+        const market = this.accrueInterest(timestamp);
+        if (shares === 0n)
+            shares = market.toBorrowShares(assets, "Up");
+        else
+            assets = market.toBorrowAssets(shares, "Down");
+        market.totalBorrowAssets += assets;
+        market.totalBorrowShares += shares;
+        if (market.totalBorrowAssets > market.totalSupplyAssets)
+            throw new BlueErrors.InsufficientLiquidity(market.id);
+        return { market, assets, shares };
+    }
+    repay(assets, shares, timestamp) {
+        if ((assets === 0n) === (shares === 0n))
+            throw new BlueErrors.InconsistentInput(assets, shares);
+        const market = this.accrueInterest(timestamp);
+        if (shares === 0n)
+            shares = market.toBorrowShares(assets, "Down");
+        else
+            assets = market.toBorrowAssets(shares, "Up");
+        market.totalBorrowAssets -= assets;
+        market.totalBorrowShares -= shares;
+        return { market, assets, shares };
+    }
+    /**
+     * Converts a given amount of supply shares into supply loan assets.
+     * @param shares The amount of shares to convert.
+     * @param rounding The rounding direction to use (defaults to "Down").
+     */
+    toSupplyAssets(shares, rounding) {
+        return MarketUtils.toSupplyAssets(shares, this, rounding);
+    }
+    /**
+     * Converts a given amount of supply loan assets into supply shares.
+     * @param shares The amount of assets to convert.
+     * @param rounding The rounding direction to use (defaults to "Up").
+     */
+    toSupplyShares(assets, rounding) {
+        return MarketUtils.toSupplyShares(assets, this, rounding);
+    }
+    /**
+     * Converts a given amount of borrow shares into borrow loan assets.
+     * @param shares The amount of shares to convert.
+     * @param rounding The rounding direction to use (defaults to "Up").
+     */
+    toBorrowAssets(shares, rounding) {
+        return MarketUtils.toBorrowAssets(shares, this, rounding);
+    }
+    /**
+     * Converts a given amount of borrow loan assets into borrow shares.
+     * @param shares The amount of assets to convert.
+     * @param rounding The rounding direction to use (defaults to "Down").
+     */
+    toBorrowShares(assets, rounding) {
+        return MarketUtils.toBorrowShares(assets, this, rounding);
+    }
+    /**
+     * Returns the smallest volume to supply until the market gets the closest to the given utilization rate.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    getSupplyToUtilization(utilization) {
+        return MarketUtils.getSupplyToUtilization(this, utilization);
+    }
+    /**
+     * Returns the liquidity available to withdraw until the market gets the closest to the given utilization rate.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    getWithdrawToUtilization(utilization) {
+        return MarketUtils.getWithdrawToUtilization(this, utilization);
+    }
+    /**
+     * Returns the liquidity available to borrow until the market gets the closest to the given utilization rate.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    getBorrowToUtilization(utilization) {
+        return MarketUtils.getBorrowToUtilization(this, utilization);
+    }
+    /**
+     * Returns the smallest volume to repay until the market gets the closest to the given utilization rate.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    getRepayToUtilization(utilization) {
+        return MarketUtils.getRepayToUtilization(this, utilization);
+    }
+    /**
+     * Returns the value of a given amount of collateral quoted in loan assets.
+     * `undefined` iff the market's oracle is undefined or reverts.
+     * @param collateral The amount of collateral to quote.
+     */
+    getCollateralValue(collateral) {
+        return MarketUtils.getCollateralValue(collateral, this);
+    }
+    /**
+     * Returns the maximum debt allowed given a certain amount of collateral.
+     * `undefined` iff the market's oracle is undefined or reverts.
+     * To calculate the amount of loan assets that can be borrowed, use `getMaxBorrowableAssets`.
+     * @param collateral The amount of collateral to consider.
+     */
+    getMaxBorrowAssets(collateral, { maxLtv = this.params.lltv } = {}) {
+        return MarketUtils.getMaxBorrowAssets(collateral, this, {
+            lltv: MathLib.min(maxLtv, this.params.lltv),
+        });
+    }
+    /**
+     * Returns the maximum amount of loan assets that can be borrowed given a certain borrow position.
+     * `undefined` iff the market's oracle is undefined or reverts.
+     * @param position The borrow position to consider.
+     */
+    getMaxBorrowableAssets(position) {
+        return MarketUtils.getMaxBorrowableAssets(position, this, this.params);
+    }
+    /**
+     * Returns the amount of collateral that would be seized in a liquidation given a certain amount of repaid shares.
+     * `undefined` iff the market's oracle is undefined or reverts.
+     * @param repaidShares The amount of shares hypothetically repaid.
+     */
+    getLiquidationSeizedAssets(repaidShares) {
+        return MarketUtils.getLiquidationSeizedAssets(repaidShares, this, this.params);
+    }
+    /**
+     * Returns the amount of borrow shares that would be repaid in a liquidation given a certain amount of seized collateral.
+     * `undefined` iff the market's oracle is undefined or reverts.
+     * @param seizedAssets The amount of collateral hypothetically seized.
+     */
+    getLiquidationRepaidShares(seizedAssets) {
+        return MarketUtils.getLiquidationRepaidShares(seizedAssets, this, this.params);
+    }
+    /**
+     * Returns the maximum amount of collateral that is worth being seized in a liquidation given a certain borrow position.
+     * `undefined` iff the market's oracle is undefined or reverts.
+     * @param position The borrow position to consider.
+     */
+    getSeizableCollateral(position) {
+        return MarketUtils.getSeizableCollateral(position, this, this.params);
+    }
+    /**
+     * Returns the amount of collateral that can be withdrawn given a certain borrow position.
+     * `undefined` iff the market's oracle is undefined or reverts.
+     * @param position The borrow position to consider.
+     */
+    getWithdrawableCollateral(position, { maxLtv = this.params.lltv } = {}) {
+        return MarketUtils.getWithdrawableCollateral(position, this, {
+            lltv: MathLib.min(maxLtv, this.params.lltv),
+        });
+    }
+    /**
+     * Returns whether a given borrow position is healthy.
+     * `undefined` iff the market's oracle is undefined or reverts.
+     * @param position The borrow position to check.
+     */
+    isHealthy(position) {
+        return MarketUtils.isHealthy(position, this, this.params);
+    }
+    /**
+     * Returns the liquidation price of a given borrow position.
+     * @param position The borrow position to consider.
+     */
+    getLiquidationPrice(position) {
+        return MarketUtils.getLiquidationPrice(position, this, this.params);
+    }
+    /**
+     * Returns the price variation required for the given position to reach its liquidation threshold (scaled by WAD).
+     * Negative when healthy (the price needs to drop x%), positive when unhealthy (the price needs to soar x%).
+     * Returns `undefined` iff the market's price is undefined.
+     * Returns null if the position is not a borrow.
+     * @param position The borrow position to consider.
+     */
+    getPriceVariationToLiquidationPrice(position) {
+        return MarketUtils.getPriceVariationToLiquidationPrice(position, this, this.params);
+    }
+    /**
+     * Returns the health factor of a given borrow position (scaled by WAD).
+     * @param position The borrow position to consider.
+     */
+    getHealthFactor(position) {
+        return MarketUtils.getHealthFactor(position, this, this.params);
+    }
+    /**
+     * Returns the loan-to-value ratio of a given borrow position (scaled by WAD).
+     * @param position The borrow position to consider.
+     */
+    getLtv(position) {
+        return MarketUtils.getLtv(position, this);
+    }
+    /**
+     * Returns the usage ratio of the maximum borrow capacity given a certain borrow position (scaled by WAD).
+     * @param position The borrow position to consider.
+     */
+    getBorrowCapacityUsage(position) {
+        return MarketUtils.getBorrowCapacityUsage(position, this, this.params);
+    }
+    /**
+     * Returns the maximum amount of loan assets that can be borrowed given a certain borrow position
+     * and the reason for the limit.
+     * Returns `undefined` iff the market's price is undefined.
+     * @param position The borrow position to consider.
+     */
+    getBorrowCapacityLimit({ collateral, borrowShares = 0n, }, options) {
+        const maxBorrowAssets = this.getMaxBorrowAssets(collateral, options);
+        if (maxBorrowAssets == null)
+            return;
+        // handle edge cases when the user is liquidatable (maxBorrow < borrow)
+        const maxBorrowableAssets = MathLib.zeroFloorSub(maxBorrowAssets, this.toBorrowAssets(borrowShares));
+        const { liquidity } = this;
+        if (maxBorrowableAssets > liquidity)
+            return {
+                value: liquidity,
+                limiter: CapacityLimitReason.liquidity,
+            };
+        return {
+            value: maxBorrowableAssets,
+            limiter: CapacityLimitReason.collateral,
+        };
+    }
+    /**
+     * Returns the maximum amount of loan assets that can be repaid given a certain borrow position
+     * and a balance of loan assets, and the reason for the limit.
+     * @param position The borrow position to consider.
+     */
+    getRepayCapacityLimit(borrowShares, loanTokenBalance) {
+        const borrowAssets = this.toBorrowAssets(borrowShares);
+        if (borrowAssets > loanTokenBalance)
+            return {
+                value: loanTokenBalance,
+                limiter: CapacityLimitReason.balance,
+            };
+        return {
+            value: borrowAssets,
+            limiter: CapacityLimitReason.position,
+        };
+    }
+    /**
+     * Returns the maximum amount of loan assets that can be withdrawn given a certain supply position
+     * and a balance of loan assets, and the reason for the limit.
+     * @param position The supply position to consider.
+     */
+    getWithdrawCapacityLimit({ supplyShares, }) {
+        const supplyAssets = this.toSupplyAssets(supplyShares);
+        const { liquidity } = this;
+        if (supplyAssets > liquidity)
+            return {
+                value: liquidity,
+                limiter: CapacityLimitReason.liquidity,
+            };
+        return {
+            value: supplyAssets,
+            limiter: CapacityLimitReason.position,
+        };
+    }
+    /**
+     * Returns the maximum amount of collateral assets that can be withdrawn given a certain borrow position
+     * and the reason for the limit.
+     * Returns `undefined` iff the market's price is undefined.
+     * @param position The borrow position to consider.
+     */
+    getWithdrawCollateralCapacityLimit(position, options) {
+        const withdrawableCollateral = this.getWithdrawableCollateral(position, options);
+        if (withdrawableCollateral == null)
+            return;
+        if (position.collateral > withdrawableCollateral)
+            return {
+                value: withdrawableCollateral,
+                limiter: CapacityLimitReason.collateral,
+            };
+        return {
+            value: position.collateral,
+            limiter: CapacityLimitReason.position,
+        };
+    }
+    /**
+     * Returns the maximum capacity for all interactions with Morpho Blue given a certain position
+     * and loan and collateral balances.
+     * @param position The position to consider.
+     * @param loanTokenBalance The balance of loan assets.
+     * @param collateralTokenBalance The balance of collateral assets.
+     */
+    getMaxCapacities(position, loanTokenBalance, collateralTokenBalance, options) {
+        return {
+            supply: {
+                value: loanTokenBalance,
+                limiter: CapacityLimitReason.balance,
+            },
+            withdraw: this.getWithdrawCapacityLimit(position),
+            borrow: this.getBorrowCapacityLimit(position, options?.borrow),
+            repay: this.getRepayCapacityLimit(position.borrowShares, loanTokenBalance),
+            supplyCollateral: {
+                value: collateralTokenBalance,
+                limiter: CapacityLimitReason.balance,
+            },
+            withdrawCollateral: this.getWithdrawCollateralCapacityLimit(position, options?.withdrawCollateral),
+        };
+    }
+}

package/lib/esm/market/MarketParams.d.ts

@@ -0,0 +1,74 @@
+import type { Address, BigIntish, MarketId } from "../types.js";
+import { type Hex } from "viem";
+export interface IMarketParams {
+    loanToken: Address;
+    collateralToken: Address;
+    oracle: Address;
+    irm: Address;
+    lltv: BigIntish;
+}
+export type InputMarketParams = Pick<MarketParams, "loanToken" | "collateralToken" | "oracle" | "irm" | "lltv">;
+export declare const marketParamsAbi: {
+    readonly type: "tuple";
+    readonly components: readonly [{
+        readonly type: "address";
+        readonly name: "loanToken";
+    }, {
+        readonly type: "address";
+        readonly name: "collateralToken";
+    }, {
+        readonly type: "address";
+        readonly name: "oracle";
+    }, {
+        readonly type: "address";
+        readonly name: "irm";
+    }, {
+        readonly type: "uint256";
+        readonly name: "lltv";
+    }];
+};
+/**
+ * Represents a market's configuration (also called market params).
+ */
+export declare class MarketParams implements IMarketParams {
+    private static readonly _CACHE;
+    /**
+     * Returns the previously cached market config for the given id, if any.
+     * @throws {UnknownMarketParamsError} If no market config is cached.
+     */
+    static get(id: MarketId): MarketParams;
+    /**
+     * Returns the canonical idle market configuration for the given loan token.
+     */
+    static idle(token: Address): MarketParams;
+    static fromHex(data: Hex): MarketParams;
+    /**
+     * The market's collateral token address.
+     */
+    readonly collateralToken: Address;
+    /**
+     * The market's loan token address.
+     */
+    readonly loanToken: Address;
+    /**
+     * The market's oracle address.
+     */
+    readonly oracle: Address;
+    /**
+     * The market's interest rate model address.
+     */
+    readonly irm: Address;
+    /**
+     * The market's liquidation Loan-To-Value (scaled by WAD).
+     */
+    readonly lltv: bigint;
+    /**
+     * The market's hex-encoded id, defined as the hash of the market params.
+     */
+    readonly id: MarketId;
+    /**
+     * The market's liquidation incentive factor.
+     */
+    readonly liquidationIncentiveFactor: bigint;
+    constructor(params: IMarketParams);
+}