@morpho-org/blue-sdk 5.16.0 → 5.18.0

package/lib/esm/market/MarketParams.js

@@ -0,0 +1,91 @@
+import { ZERO_ADDRESS } from "@morpho-org/morpho-ts";
+import { InvalidMarketParamsError, UnknownMarketParamsError, } from "../errors.js";
+import { decodeAbiParameters } from "viem";
+import { MarketUtils } from "./MarketUtils.js";
+export const marketParamsAbi = {
+    type: "tuple",
+    components: [
+        { type: "address", name: "loanToken" },
+        { type: "address", name: "collateralToken" },
+        { type: "address", name: "oracle" },
+        { type: "address", name: "irm" },
+        { type: "uint256", name: "lltv" },
+    ],
+};
+/**
+ * Represents a market's configuration (also called market params).
+ */
+export class MarketParams {
+    static _CACHE = {};
+    /**
+     * Returns the previously cached market config for the given id, if any.
+     * @throws {UnknownMarketParamsError} If no market config is cached.
+     */
+    static get(id) {
+        const marketParams = MarketParams._CACHE[id];
+        if (!marketParams)
+            throw new UnknownMarketParamsError(id);
+        return marketParams;
+    }
+    /**
+     * Returns the canonical idle market configuration for the given loan token.
+     */
+    static idle(token) {
+        return new MarketParams({
+            collateralToken: ZERO_ADDRESS,
+            loanToken: token,
+            oracle: ZERO_ADDRESS,
+            irm: ZERO_ADDRESS,
+            lltv: 0n,
+        });
+    }
+    static fromHex(data) {
+        try {
+            const [marketParams] = decodeAbiParameters([marketParamsAbi], data);
+            return new MarketParams(marketParams);
+        }
+        catch {
+            throw new InvalidMarketParamsError(data);
+        }
+    }
+    /**
+     * The market's collateral token address.
+     */
+    collateralToken;
+    /**
+     * The market's loan token address.
+     */
+    loanToken;
+    /**
+     * The market's oracle address.
+     */
+    oracle;
+    /**
+     * The market's interest rate model address.
+     */
+    irm;
+    /**
+     * The market's liquidation Loan-To-Value (scaled by WAD).
+     */
+    lltv;
+    /**
+     * The market's hex-encoded id, defined as the hash of the market params.
+     */
+    id; // Cached because params are readonly.
+    /**
+     * The market's liquidation incentive factor.
+     */
+    liquidationIncentiveFactor; // Cached because lltv is readonly.
+    constructor(params) {
+        const { collateralToken, loanToken, oracle, irm, lltv } = params;
+        this.collateralToken = collateralToken;
+        this.loanToken = loanToken;
+        this.oracle = oracle;
+        this.irm = irm;
+        this.lltv = BigInt(lltv);
+        this.id = MarketUtils.getMarketId(params);
+        this.liquidationIncentiveFactor =
+            MarketUtils.getLiquidationIncentiveFactor(params);
+        MarketParams._CACHE[this.id] = this;
+    }
+}

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

@@ -0,0 +1,273 @@
+import { type RoundingDirection } from "../math/index.js";
+import type { BigIntish, MarketId } from "../types.js";
+import type { IMarketParams } from "./MarketParams.js";
+/**
+ * Namespace of utility functions to ease market-related calculations.
+ */
+export declare namespace MarketUtils {
+    /**
+     * Returns the id of a market based on its params.
+     * @param market The market params.
+     */
+    function getMarketId(market: IMarketParams): MarketId;
+    /**
+     * Returns the liquidation incentive factor for a given market params.
+     * @param config The market params.
+     */
+    function getLiquidationIncentiveFactor({ lltv }: {
+        lltv: BigIntish;
+    }): bigint;
+    /**
+     * Returns the market's utilization rate (scaled by WAD).
+     * @param market The market state.
+     */
+    function getUtilization({ totalSupplyAssets, totalBorrowAssets, }: {
+        totalSupplyAssets: BigIntish;
+        totalBorrowAssets: BigIntish;
+    }): bigint;
+    /**
+     * Returns the per-second rate continuously compounded over a year,
+     * as calculated in Morpho Blue assuming the market is frequently accrued onchain.
+     * @param rate The per-second rate to compound annually.
+     */
+    function rateToApy(rate: BigIntish): number;
+    /**
+     * Returns the interest accrued on both sides of the given market
+     * as well as the supply shares minted to the fee recipient.
+     * @param borrowRate The average borrow rate since the last market update (scaled by WAD).
+     * @param market The market state.
+     * @param elapsed The time elapsed since the last market update (in seconds).
+     */
+    function getAccruedInterest(borrowRate: BigIntish, { totalSupplyAssets, totalBorrowAssets, totalSupplyShares, fee, }: {
+        totalSupplyAssets: BigIntish;
+        totalBorrowAssets: BigIntish;
+        totalSupplyShares: BigIntish;
+        fee: BigIntish;
+    }, elapsed?: bigint): {
+        interest: bigint;
+        feeShares: bigint;
+    };
+    /**
+     * Returns the smallest volume to supply until the market gets the closest to the given utilization rate.
+     * @param market The market state.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    function getSupplyToUtilization(market: {
+        totalSupplyAssets: BigIntish;
+        totalBorrowAssets: BigIntish;
+    }, utilization: BigIntish): bigint;
+    /**
+     * Returns the liquidity available to withdraw until the market gets the closest to the given utilization rate.
+     * @param market The market state.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    function getWithdrawToUtilization({ totalSupplyAssets, totalBorrowAssets, }: {
+        totalSupplyAssets: BigIntish;
+        totalBorrowAssets: BigIntish;
+    }, utilization: BigIntish): bigint;
+    /**
+     * Returns the liquidity available to borrow until the market gets the closest to the given utilization rate.
+     * @param market The market state.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    function getBorrowToUtilization({ totalSupplyAssets, totalBorrowAssets, }: {
+        totalSupplyAssets: BigIntish;
+        totalBorrowAssets: BigIntish;
+    }, utilization: BigIntish): bigint;
+    /**
+     * Returns the smallest volume to repay until the market gets the closest to the given utilization rate.
+     * @param market The market state.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    function getRepayToUtilization({ totalSupplyAssets, totalBorrowAssets, }: {
+        totalSupplyAssets: BigIntish;
+        totalBorrowAssets: BigIntish;
+    }, utilization: BigIntish): bigint;
+    function getCollateralPower(collateral: BigIntish, { lltv }: {
+        lltv: BigIntish;
+    }): bigint;
+    /**
+     * Returns the value of a given amount of collateral quoted in loan assets.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getCollateralValue(collateral: BigIntish, { price }: {
+        price?: BigIntish;
+    }): bigint | undefined;
+    /**
+     * Returns the maximum debt allowed given a certain amount of collateral.
+     * Return `undefined` iff the market's price is undefined.
+     * To calculate the amount of loan assets that can be borrowed, use `getMaxBorrowableAssets`.
+     */
+    function getMaxBorrowAssets(collateral: BigIntish, market: {
+        price?: BigIntish;
+    }, { lltv }: {
+        lltv: BigIntish;
+    }): bigint | undefined;
+    /**
+     * Returns the maximum amount of loan assets that can be borrowed given a certain borrow position.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getMaxBorrowableAssets({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price?: BigIntish;
+    }, marketParams: {
+        lltv: BigIntish;
+    }): bigint | undefined;
+    /**
+     * Returns the amount of collateral that would be seized in a liquidation given a certain amount of repaid shares.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getLiquidationSeizedAssets(repaidShares: BigIntish, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price?: BigIntish;
+    }, config: {
+        lltv: BigIntish;
+    }): bigint | undefined;
+    /**
+     * Returns the amount of borrow shares that would be repaid in a liquidation given a certain amount of seized collateral.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getLiquidationRepaidShares(seizedAssets: BigIntish, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price?: BigIntish;
+    }, config: {
+        lltv: BigIntish;
+    }): bigint | undefined;
+    /**
+     * Returns the maximum amount of collateral that is worth being seized in a liquidation given a certain borrow position.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getSeizableCollateral(position: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price?: BigIntish;
+    }, config: {
+        lltv: BigIntish;
+    }): bigint | undefined;
+    /**
+     * Returns the amount of collateral that can be withdrawn given a certain borrow position.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getWithdrawableCollateral({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price?: BigIntish;
+    }, { lltv }: {
+        lltv: BigIntish;
+    }): bigint | undefined;
+    /**
+     * Returns whether a given borrow position is healthy.
+     * Return `undefined` iff the market's price is undefined.
+     * @param position The borrow position to check.
+     */
+    function isHealthy({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price?: BigIntish;
+    }, marketParams: {
+        lltv: BigIntish;
+    }): boolean | undefined;
+    /**
+     * Returns the price of the collateral quoted in the loan token (e.g. ETH/DAI)
+     * that set the user's position to be liquidatable.
+     * Returns null if the position is not a borrow.
+     */
+    function getLiquidationPrice({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+    }, marketParams: {
+        lltv: BigIntish;
+    }): bigint | null;
+    /**
+     * 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.
+     */
+    function getPriceVariationToLiquidationPrice(position: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price?: BigIntish;
+    }, marketParams: {
+        lltv: BigIntish;
+    }): bigint | null | undefined;
+    /**
+     * Returns the health factor of a given borrow position (scaled by WAD).
+     * If the debt is 0, health factor is `MaxUint256`.
+     * Returns `undefined` iff the market's price is undefined.
+     */
+    function getHealthFactor({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price?: BigIntish;
+    }, marketParams: {
+        lltv: BigIntish;
+    }): bigint | undefined;
+    /**
+     * Returns the loan-to-value ratio of a given borrow position (scaled by WAD).
+     * Returns `undefined` iff the market's price is undefined.
+     * Returns null if the position is not a borrow.
+     */
+    function getLtv({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price?: BigIntish;
+    }): bigint | null | undefined;
+    /**
+     * Returns the usage ratio of the maximum borrow capacity given a certain borrow position (scaled by WAD).
+     * Returns `undefined` iff the market's price is undefined.
+     */
+    function getBorrowCapacityUsage(position: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price?: BigIntish;
+    }, marketParams: {
+        lltv: BigIntish;
+    }): bigint | undefined;
+    function toSupplyAssets(shares: BigIntish, market: {
+        totalSupplyAssets: BigIntish;
+        totalSupplyShares: BigIntish;
+    }, rounding?: RoundingDirection): bigint;
+    function toSupplyShares(assets: BigIntish, market: {
+        totalSupplyAssets: BigIntish;
+        totalSupplyShares: BigIntish;
+    }, rounding?: RoundingDirection): bigint;
+    function toBorrowAssets(shares: BigIntish, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+    }, rounding?: RoundingDirection): bigint;
+    function toBorrowShares(assets: BigIntish, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+    }, rounding?: RoundingDirection): bigint;
+}

package/lib/esm/market/MarketUtils.js

@@ -0,0 +1,323 @@
+import { keccak_256 } from "@noble/hashes/sha3";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { formatEther } from "viem";
+import { LIQUIDATION_CURSOR, MAX_LIQUIDATION_INCENTIVE_FACTOR, ORACLE_PRICE_SCALE, SECONDS_PER_YEAR, } from "../constants.js";
+import { MathLib, SharesMath } from "../math/index.js";
+/**
+ * Namespace of utility functions to ease market-related calculations.
+ */
+export var MarketUtils;
+(function (MarketUtils) {
+    /**
+     * Returns the id of a market based on its params.
+     * @param market The market params.
+     */
+    function getMarketId(market) {
+        return `0x${bytesToHex(keccak_256(hexToBytes(`${market.loanToken.substring(2).toLowerCase().padStart(64, "0") +
+            market.collateralToken
+                .substring(2)
+                .toLowerCase()
+                .padStart(64, "0") +
+            market.oracle.substring(2).padStart(64, "0") +
+            market.irm.substring(2).toLowerCase().padStart(64, "0") +
+            BigInt(market.lltv).toString(16).padStart(64, "0")}`)))}`;
+    }
+    MarketUtils.getMarketId = getMarketId;
+    /**
+     * Returns the liquidation incentive factor for a given market params.
+     * @param config The market params.
+     */
+    function getLiquidationIncentiveFactor({ lltv }) {
+        return MathLib.min(MAX_LIQUIDATION_INCENTIVE_FACTOR, MathLib.wDivDown(MathLib.WAD, MathLib.WAD -
+            MathLib.wMulDown(LIQUIDATION_CURSOR, MathLib.WAD - BigInt(lltv))));
+    }
+    MarketUtils.getLiquidationIncentiveFactor = getLiquidationIncentiveFactor;
+    /**
+     * Returns the market's utilization rate (scaled by WAD).
+     * @param market The market state.
+     */
+    function getUtilization({ totalSupplyAssets, totalBorrowAssets, }) {
+        totalSupplyAssets = BigInt(totalSupplyAssets);
+        totalBorrowAssets = BigInt(totalBorrowAssets);
+        if (totalSupplyAssets === 0n) {
+            if (totalBorrowAssets > 0n)
+                return MathLib.MAX_UINT_256;
+            return 0n;
+        }
+        return MathLib.wDivDown(totalBorrowAssets, totalSupplyAssets);
+    }
+    MarketUtils.getUtilization = getUtilization;
+    /**
+     * Returns the per-second rate continuously compounded over a year,
+     * as calculated in Morpho Blue assuming the market is frequently accrued onchain.
+     * @param rate The per-second rate to compound annually.
+     */
+    function rateToApy(rate) {
+        return Math.expm1(+formatEther(BigInt(rate) * SECONDS_PER_YEAR));
+    }
+    MarketUtils.rateToApy = rateToApy;
+    /**
+     * Returns the interest accrued on both sides of the given market
+     * as well as the supply shares minted to the fee recipient.
+     * @param borrowRate The average borrow rate since the last market update (scaled by WAD).
+     * @param market The market state.
+     * @param elapsed The time elapsed since the last market update (in seconds).
+     */
+    function getAccruedInterest(borrowRate, { totalSupplyAssets, totalBorrowAssets, totalSupplyShares, fee, }, elapsed = 0n) {
+        const interest = MathLib.wMulDown(totalBorrowAssets, MathLib.wTaylorCompounded(borrowRate, elapsed));
+        const feeAmount = MathLib.wMulDown(interest, fee);
+        const feeShares = toSupplyShares(feeAmount, {
+            totalSupplyAssets: BigInt(totalSupplyAssets) - feeAmount,
+            totalSupplyShares,
+        }, "Down");
+        return { interest, feeShares };
+    }
+    MarketUtils.getAccruedInterest = getAccruedInterest;
+    /**
+     * Returns the smallest volume to supply until the market gets the closest to the given utilization rate.
+     * @param market The market state.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    function getSupplyToUtilization(market, utilization) {
+        utilization = BigInt(utilization);
+        if (utilization === 0n) {
+            if (getUtilization(market) === 0n)
+                return 0n;
+            return MathLib.MAX_UINT_256;
+        }
+        return MathLib.zeroFloorSub(MathLib.wDivUp(market.totalBorrowAssets, utilization), market.totalSupplyAssets);
+    }
+    MarketUtils.getSupplyToUtilization = getSupplyToUtilization;
+    /**
+     * Returns the liquidity available to withdraw until the market gets the closest to the given utilization rate.
+     * @param market The market state.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    function getWithdrawToUtilization({ totalSupplyAssets, totalBorrowAssets, }, utilization) {
+        utilization = BigInt(utilization);
+        totalSupplyAssets = BigInt(totalSupplyAssets);
+        totalBorrowAssets = BigInt(totalBorrowAssets);
+        if (utilization === 0n) {
+            if (totalBorrowAssets === 0n)
+                return totalSupplyAssets;
+            return 0n;
+        }
+        return MathLib.zeroFloorSub(totalSupplyAssets, MathLib.wDivUp(totalBorrowAssets, utilization));
+    }
+    MarketUtils.getWithdrawToUtilization = getWithdrawToUtilization;
+    /**
+     * Returns the liquidity available to borrow until the market gets the closest to the given utilization rate.
+     * @param market The market state.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    function getBorrowToUtilization({ totalSupplyAssets, totalBorrowAssets, }, utilization) {
+        return MathLib.zeroFloorSub(MathLib.wMulDown(totalSupplyAssets, utilization), totalBorrowAssets);
+    }
+    MarketUtils.getBorrowToUtilization = getBorrowToUtilization;
+    /**
+     * Returns the smallest volume to repay until the market gets the closest to the given utilization rate.
+     * @param market The market state.
+     * @param utilization The target utilization rate (scaled by WAD).
+     */
+    function getRepayToUtilization({ totalSupplyAssets, totalBorrowAssets, }, utilization) {
+        return MathLib.zeroFloorSub(totalBorrowAssets, MathLib.wMulDown(totalSupplyAssets, utilization));
+    }
+    MarketUtils.getRepayToUtilization = getRepayToUtilization;
+    function getCollateralPower(collateral, { lltv }) {
+        return MathLib.wMulDown(collateral, lltv);
+    }
+    MarketUtils.getCollateralPower = getCollateralPower;
+    /**
+     * Returns the value of a given amount of collateral quoted in loan assets.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getCollateralValue(collateral, { price }) {
+        if (price == null)
+            return;
+        return MathLib.mulDivDown(collateral, price, ORACLE_PRICE_SCALE);
+    }
+    MarketUtils.getCollateralValue = getCollateralValue;
+    /**
+     * Returns the maximum debt allowed given a certain amount of collateral.
+     * Return `undefined` iff the market's price is undefined.
+     * To calculate the amount of loan assets that can be borrowed, use `getMaxBorrowableAssets`.
+     */
+    function getMaxBorrowAssets(collateral, market, { lltv }) {
+        const collateralValue = getCollateralValue(collateral, market);
+        if (collateralValue == null)
+            return;
+        return MathLib.wMulDown(collateralValue, lltv);
+    }
+    MarketUtils.getMaxBorrowAssets = getMaxBorrowAssets;
+    /**
+     * Returns the maximum amount of loan assets that can be borrowed given a certain borrow position.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getMaxBorrowableAssets({ collateral, borrowShares, }, market, marketParams) {
+        const maxBorrowAssets = getMaxBorrowAssets(collateral, market, marketParams);
+        if (maxBorrowAssets == null)
+            return;
+        return MathLib.zeroFloorSub(maxBorrowAssets, toBorrowAssets(borrowShares, market));
+    }
+    MarketUtils.getMaxBorrowableAssets = getMaxBorrowableAssets;
+    /**
+     * Returns the amount of collateral that would be seized in a liquidation given a certain amount of repaid shares.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getLiquidationSeizedAssets(repaidShares, market, config) {
+        if (market.price == null)
+            return;
+        market.price = BigInt(market.price);
+        if (market.price === 0n)
+            return 0n;
+        return MathLib.mulDivDown(MathLib.wMulDown(toBorrowAssets(repaidShares, market, "Down"), getLiquidationIncentiveFactor(config)), ORACLE_PRICE_SCALE, market.price);
+    }
+    MarketUtils.getLiquidationSeizedAssets = getLiquidationSeizedAssets;
+    /**
+     * Returns the amount of borrow shares that would be repaid in a liquidation given a certain amount of seized collateral.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getLiquidationRepaidShares(seizedAssets, market, config) {
+        if (market.price == null)
+            return;
+        return toBorrowShares(MathLib.wDivUp(MathLib.mulDivUp(seizedAssets, market.price, ORACLE_PRICE_SCALE), getLiquidationIncentiveFactor(config)), market, "Up");
+    }
+    MarketUtils.getLiquidationRepaidShares = getLiquidationRepaidShares;
+    /**
+     * Returns the maximum amount of collateral that is worth being seized in a liquidation given a certain borrow position.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getSeizableCollateral(position, market, config) {
+        if (market.price == null)
+            return; // Must be checked before calling `isHealthy`.
+        market.price = BigInt(market.price);
+        if (market.price === 0n || isHealthy(position, market, config))
+            return 0n;
+        return MathLib.min(position.collateral, getLiquidationSeizedAssets(position.borrowShares, market, config));
+    }
+    MarketUtils.getSeizableCollateral = getSeizableCollateral;
+    /**
+     * Returns the amount of collateral that can be withdrawn given a certain borrow position.
+     * Return `undefined` iff the market's price is undefined.
+     */
+    function getWithdrawableCollateral({ collateral, borrowShares, }, market, { lltv }) {
+        if (market.price == null)
+            return;
+        market.price = BigInt(market.price);
+        if (market.price === 0n)
+            return 0n;
+        return MathLib.zeroFloorSub(collateral, MathLib.wDivUp(MathLib.mulDivUp(toBorrowAssets(borrowShares, market), ORACLE_PRICE_SCALE, market.price), lltv));
+    }
+    MarketUtils.getWithdrawableCollateral = getWithdrawableCollateral;
+    /**
+     * Returns whether a given borrow position is healthy.
+     * Return `undefined` iff the market's price is undefined.
+     * @param position The borrow position to check.
+     */
+    function isHealthy({ collateral, borrowShares, }, market, marketParams) {
+        const maxBorrowAssets = getMaxBorrowAssets(collateral, market, marketParams);
+        if (maxBorrowAssets == null)
+            return;
+        return maxBorrowAssets >= toBorrowAssets(borrowShares, market);
+    }
+    MarketUtils.isHealthy = isHealthy;
+    /**
+     * Returns the price of the collateral quoted in the loan token (e.g. ETH/DAI)
+     * that set the user's position to be liquidatable.
+     * Returns null if the position is not a borrow.
+     */
+    function getLiquidationPrice({ collateral, borrowShares, }, market, marketParams) {
+        borrowShares = BigInt(borrowShares);
+        market.totalBorrowShares = BigInt(market.totalBorrowShares);
+        if (borrowShares === 0n || market.totalBorrowShares === 0n)
+            return null;
+        const collateralPower = getCollateralPower(collateral, marketParams);
+        if (collateralPower === 0n)
+            return MathLib.MAX_UINT_256;
+        const borrowAssets = toBorrowAssets(borrowShares, market);
+        return MathLib.mulDivUp(borrowAssets, ORACLE_PRICE_SCALE, collateralPower);
+    }
+    MarketUtils.getLiquidationPrice = getLiquidationPrice;
+    /**
+     * 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.
+     */
+    function getPriceVariationToLiquidationPrice(position, market, marketParams) {
+        if (market.price == null)
+            return;
+        market.price = BigInt(market.price);
+        if (market.price === 0n)
+            return null;
+        const liquidationPrice = getLiquidationPrice(position, market, marketParams);
+        if (liquidationPrice == null)
+            return null;
+        return MathLib.wDivUp(liquidationPrice, market.price) - MathLib.WAD;
+    }
+    MarketUtils.getPriceVariationToLiquidationPrice = getPriceVariationToLiquidationPrice;
+    /**
+     * Returns the health factor of a given borrow position (scaled by WAD).
+     * If the debt is 0, health factor is `MaxUint256`.
+     * Returns `undefined` iff the market's price is undefined.
+     */
+    function getHealthFactor({ collateral, borrowShares, }, market, marketParams) {
+        const borrowAssets = toBorrowAssets(borrowShares, market);
+        if (borrowAssets === 0n)
+            return MathLib.MAX_UINT_256;
+        const maxBorrowAssets = getMaxBorrowAssets(collateral, market, marketParams);
+        if (maxBorrowAssets == null)
+            return;
+        return MathLib.wDivDown(maxBorrowAssets, borrowAssets);
+    }
+    MarketUtils.getHealthFactor = getHealthFactor;
+    /**
+     * Returns the loan-to-value ratio of a given borrow position (scaled by WAD).
+     * Returns `undefined` iff the market's price is undefined.
+     * Returns null if the position is not a borrow.
+     */
+    function getLtv({ collateral, borrowShares, }, market) {
+        borrowShares = BigInt(borrowShares);
+        market.totalBorrowShares = BigInt(market.totalBorrowShares);
+        if (borrowShares === 0n || market.totalBorrowShares === 0n)
+            return null;
+        const collateralValue = getCollateralValue(collateral, market);
+        if (collateralValue == null)
+            return;
+        if (collateralValue === 0n)
+            return MathLib.MAX_UINT_256;
+        return MathLib.wDivUp(toBorrowAssets(borrowShares, market), collateralValue);
+    }
+    MarketUtils.getLtv = getLtv;
+    /**
+     * Returns the usage ratio of the maximum borrow capacity given a certain borrow position (scaled by WAD).
+     * Returns `undefined` iff the market's price is undefined.
+     */
+    function getBorrowCapacityUsage(position, market, marketParams) {
+        const hf = getHealthFactor(position, market, marketParams);
+        if (hf === undefined)
+            return;
+        if (hf === null)
+            return 0n;
+        if (hf === 0n)
+            return MathLib.MAX_UINT_256;
+        return MathLib.wDivUp(MathLib.WAD, hf);
+    }
+    MarketUtils.getBorrowCapacityUsage = getBorrowCapacityUsage;
+    function toSupplyAssets(shares, market, rounding = "Down") {
+        return SharesMath.toAssets(shares, market.totalSupplyAssets, market.totalSupplyShares, rounding);
+    }
+    MarketUtils.toSupplyAssets = toSupplyAssets;
+    function toSupplyShares(assets, market, rounding = "Up") {
+        return SharesMath.toShares(assets, market.totalSupplyAssets, market.totalSupplyShares, rounding);
+    }
+    MarketUtils.toSupplyShares = toSupplyShares;
+    function toBorrowAssets(shares, market, rounding = "Up") {
+        return SharesMath.toAssets(shares, market.totalBorrowAssets, market.totalBorrowShares, rounding);
+    }
+    MarketUtils.toBorrowAssets = toBorrowAssets;
+    function toBorrowShares(assets, market, rounding = "Down") {
+        return SharesMath.toShares(assets, market.totalBorrowAssets, market.totalBorrowShares, rounding);
+    }
+    MarketUtils.toBorrowShares = toBorrowShares;
+})(MarketUtils || (MarketUtils = {}));

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

@@ -0,0 +1,3 @@
+export * from "./MarketUtils.js";
+export * from "./MarketParams.js";
+export * from "./Market.js";