@morpho-org/blue-sdk 1.0.0-integ-650.0

package/lib/market/MarketUtils.d.ts

@@ -0,0 +1,232 @@
+import { RoundingDirection } from "../maths";
+import { BigIntish, MarketId } from "../types";
+import { MarketParams } from "./MarketConfig";
+/**
+ * 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: MarketParams): 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 rate at which interest accrued on average for suppliers on the corresponding market,
+     * since the last time the market was updated (scaled by WAD).
+     * @param borrowRate The average borrow rate since the last market update (scaled by WAD).
+     * @param market The market state.
+     */
+    function getSupplyRate(borrowRate: BigIntish, { utilization, fee }: {
+        utilization: BigIntish;
+        fee: BigIntish;
+    }): bigint;
+    /**
+     * Returns the Annual Percentage Yield (APY) from an average rate, as calculated in Morpho Blue.
+     * @param rate The average rate to convert to APY (scaled by WAD).
+     */
+    function getApy(rate: BigIntish): bigint;
+    /**
+     * 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;
+    function getCollateralValue(collateral: BigIntish, { price }: {
+        price: BigIntish;
+    }): bigint;
+    function getMaxBorrowAssets(collateral: BigIntish, market: {
+        price: BigIntish;
+    }, { lltv }: {
+        lltv: BigIntish;
+    }): bigint;
+    function getMaxBorrowableAssets({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price: BigIntish;
+    }, marketConfig: {
+        lltv: BigIntish;
+    }): bigint;
+    function getLiquidationSeizedAssets(repaidShares: BigIntish, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price: BigIntish;
+    }, config: {
+        lltv: BigIntish;
+    }): bigint;
+    function getLiquidationRepaidShares(seizedAssets: BigIntish, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price: BigIntish;
+    }, config: {
+        lltv: BigIntish;
+    }): bigint;
+    function getSeizableCollateral(position: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price: BigIntish;
+    }, config: {
+        lltv: BigIntish;
+    }): bigint;
+    function getWithdrawableCollateral({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price: BigIntish;
+    }, { lltv }: {
+        lltv: BigIntish;
+    }): bigint;
+    function isHealthy({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price: BigIntish;
+    }, marketConfig: {
+        lltv: BigIntish;
+    }): boolean;
+    /**
+     * 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 user is not a borrower
+     */
+    function getLiquidationPrice({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+    }, marketConfig: {
+        lltv: BigIntish;
+    }): bigint | null;
+    /**
+     * Returns the price deviation required for the given borrow position to be unhealthy (scaled by WAD).
+     * @param position The borrow position to consider.
+     */
+    function getPriceVariationToLiquidation(position: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price: BigIntish;
+    }, marketConfig: {
+        lltv: BigIntish;
+    }): bigint | null;
+    function getHealthFactor({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price: BigIntish;
+    }, marketConfig: {
+        lltv: BigIntish;
+    }): bigint | null;
+    function getLtv({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price: BigIntish;
+    }): bigint | null;
+    function getBorrowCapacityUsage(position: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price: BigIntish;
+    }, marketConfig: {
+        lltv: BigIntish;
+    }): bigint | null;
+    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/market/MarketUtils.js

@@ -0,0 +1,263 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketUtils = void 0;
+const keccak256_1 = __importDefault(require("keccak256"));
+const constants_1 = require("../constants");
+const maths_1 = require("../maths");
+/**
+ * Namespace of utility functions to ease market-related calculations.
+ */
+var MarketUtils;
+(function (MarketUtils) {
+    /**
+     * Returns the id of a market based on its params.
+     * @param market The market params.
+     */
+    function getMarketId(market) {
+        return `0x${(0, keccak256_1.default)("0x" +
+            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")).toString("hex")}`;
+    }
+    MarketUtils.getMarketId = getMarketId;
+    /**
+     * Returns the liquidation incentive factor for a given market params.
+     * @param config The market params.
+     */
+    function getLiquidationIncentiveFactor({ lltv }) {
+        return maths_1.MathLib.min(constants_1.MAX_LIQUIDATION_INCENTIVE_FACTOR, maths_1.MathLib.wDivDown(maths_1.MathLib.WAD, maths_1.MathLib.WAD -
+            maths_1.MathLib.wMulDown(constants_1.LIQUIDATION_CURSOR, maths_1.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 maths_1.MathLib.MAX_UINT_256;
+            return 0n;
+        }
+        return maths_1.MathLib.wDivDown(totalBorrowAssets, totalSupplyAssets);
+    }
+    MarketUtils.getUtilization = getUtilization;
+    /**
+     * Returns the rate at which interest accrued on average for suppliers on the corresponding market,
+     * since the last time the market was updated (scaled by WAD).
+     * @param borrowRate The average borrow rate since the last market update (scaled by WAD).
+     * @param market The market state.
+     */
+    function getSupplyRate(borrowRate, { utilization, fee }) {
+        const borrowRateWithoutFees = maths_1.MathLib.wMulUp(borrowRate, utilization);
+        return maths_1.MathLib.wMulUp(borrowRateWithoutFees, maths_1.MathLib.WAD - BigInt(fee));
+    }
+    MarketUtils.getSupplyRate = getSupplyRate;
+    /**
+     * Returns the Annual Percentage Yield (APY) from an average rate, as calculated in Morpho Blue.
+     * @param rate The average rate to convert to APY (scaled by WAD).
+     */
+    function getApy(rate) {
+        return maths_1.MathLib.wTaylorCompounded(rate, constants_1.SECONDS_PER_YEAR);
+    }
+    MarketUtils.getApy = getApy;
+    /**
+     * 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 = maths_1.MathLib.wMulDown(totalBorrowAssets, maths_1.MathLib.wTaylorCompounded(borrowRate, elapsed));
+        const feeAmount = maths_1.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 maths_1.MathLib.MAX_UINT_256;
+        }
+        return maths_1.MathLib.zeroFloorSub(maths_1.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 maths_1.MathLib.zeroFloorSub(totalSupplyAssets, maths_1.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 maths_1.MathLib.zeroFloorSub(maths_1.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 maths_1.MathLib.zeroFloorSub(totalBorrowAssets, maths_1.MathLib.wMulDown(totalSupplyAssets, utilization));
+    }
+    MarketUtils.getRepayToUtilization = getRepayToUtilization;
+    function getCollateralPower(collateral, { lltv }) {
+        return maths_1.MathLib.wMulDown(collateral, lltv);
+    }
+    MarketUtils.getCollateralPower = getCollateralPower;
+    function getCollateralValue(collateral, { price }) {
+        return maths_1.MathLib.mulDivDown(collateral, price, constants_1.ORACLE_PRICE_SCALE);
+    }
+    MarketUtils.getCollateralValue = getCollateralValue;
+    function getMaxBorrowAssets(collateral, market, { lltv }) {
+        return maths_1.MathLib.wMulDown(getCollateralValue(collateral, market), lltv);
+    }
+    MarketUtils.getMaxBorrowAssets = getMaxBorrowAssets;
+    function getMaxBorrowableAssets({ collateral, borrowShares, }, market, marketConfig) {
+        return maths_1.MathLib.zeroFloorSub(getMaxBorrowAssets(collateral, market, marketConfig), toBorrowAssets(borrowShares, market));
+    }
+    MarketUtils.getMaxBorrowableAssets = getMaxBorrowableAssets;
+    function getLiquidationSeizedAssets(repaidShares, market, config) {
+        market.price = BigInt(market.price);
+        if (market.price === 0n)
+            return 0n;
+        return maths_1.MathLib.mulDivDown(maths_1.MathLib.wMulDown(toBorrowAssets(repaidShares, market, "Down"), getLiquidationIncentiveFactor(config)), constants_1.ORACLE_PRICE_SCALE, market.price);
+    }
+    MarketUtils.getLiquidationSeizedAssets = getLiquidationSeizedAssets;
+    function getLiquidationRepaidShares(seizedAssets, market, config) {
+        return toBorrowShares(maths_1.MathLib.wDivUp(maths_1.MathLib.mulDivUp(seizedAssets, market.price, constants_1.ORACLE_PRICE_SCALE), getLiquidationIncentiveFactor(config)), market, "Up");
+    }
+    MarketUtils.getLiquidationRepaidShares = getLiquidationRepaidShares;
+    function getSeizableCollateral(position, market, config) {
+        market.price = BigInt(market.price);
+        if (market.price === 0n || isHealthy(position, market, config))
+            return 0n;
+        return maths_1.MathLib.min(position.collateral, getLiquidationSeizedAssets(position.borrowShares, market, config));
+    }
+    MarketUtils.getSeizableCollateral = getSeizableCollateral;
+    function getWithdrawableCollateral({ collateral, borrowShares, }, market, { lltv }) {
+        market.price = BigInt(market.price);
+        if (market.price === 0n)
+            return 0n;
+        return maths_1.MathLib.zeroFloorSub(collateral, maths_1.MathLib.wDivUp(maths_1.MathLib.mulDivUp(toBorrowAssets(borrowShares, market), constants_1.ORACLE_PRICE_SCALE, market.price), lltv));
+    }
+    MarketUtils.getWithdrawableCollateral = getWithdrawableCollateral;
+    function isHealthy({ collateral, borrowShares, }, market, marketConfig) {
+        return (getMaxBorrowAssets(collateral, market, marketConfig) >=
+            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 user is not a borrower
+     */
+    function getLiquidationPrice({ collateral, borrowShares, }, market, marketConfig) {
+        borrowShares = BigInt(borrowShares);
+        market.totalBorrowShares = BigInt(market.totalBorrowShares);
+        if (borrowShares === 0n || market.totalBorrowShares === 0n)
+            return null;
+        const collateralPower = getCollateralPower(collateral, marketConfig);
+        if (collateralPower === 0n)
+            return maths_1.MathLib.MAX_UINT_256;
+        const borrowAssets = toBorrowAssets(borrowShares, market);
+        return maths_1.MathLib.mulDivUp(borrowAssets, constants_1.ORACLE_PRICE_SCALE, collateralPower);
+    }
+    MarketUtils.getLiquidationPrice = getLiquidationPrice;
+    /**
+     * Returns the price deviation required for the given borrow position to be unhealthy (scaled by WAD).
+     * @param position The borrow position to consider.
+     */
+    function getPriceVariationToLiquidation(position, market, marketConfig) {
+        market.price = BigInt(market.price);
+        if (market.price === 0n)
+            return null;
+        const liquidationPrice = getLiquidationPrice(position, market, marketConfig);
+        if (liquidationPrice == null)
+            return null;
+        return maths_1.MathLib.WAD - maths_1.MathLib.wDivUp(liquidationPrice, market.price);
+    }
+    MarketUtils.getPriceVariationToLiquidation = getPriceVariationToLiquidation;
+    function getHealthFactor({ collateral, borrowShares, }, market, marketConfig) {
+        borrowShares = BigInt(borrowShares);
+        market.totalBorrowShares = BigInt(market.totalBorrowShares);
+        if (borrowShares === 0n || market.totalBorrowShares === 0n)
+            return null;
+        const borrowAssets = toBorrowAssets(borrowShares, market);
+        if (borrowAssets === 0n)
+            return maths_1.MathLib.MAX_UINT_256;
+        const maxBorrowAssets = getMaxBorrowAssets(collateral, market, marketConfig);
+        return maths_1.MathLib.wDivDown(maxBorrowAssets, borrowAssets);
+    }
+    MarketUtils.getHealthFactor = getHealthFactor;
+    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 === 0n)
+            return maths_1.MathLib.MAX_UINT_256;
+        return maths_1.MathLib.wDivUp(toBorrowAssets(borrowShares, market), collateralValue);
+    }
+    MarketUtils.getLtv = getLtv;
+    function getBorrowCapacityUsage(position, market, marketConfig) {
+        const hf = getHealthFactor(position, market, marketConfig);
+        if (hf === null)
+            return null;
+        if (hf === 0n)
+            return maths_1.MathLib.MAX_UINT_256;
+        return maths_1.MathLib.wDivUp(maths_1.MathLib.WAD, hf);
+    }
+    MarketUtils.getBorrowCapacityUsage = getBorrowCapacityUsage;
+    function toSupplyAssets(shares, market, rounding = "Down") {
+        return maths_1.SharesMath.toAssets(shares, market.totalSupplyAssets, market.totalSupplyShares, rounding);
+    }
+    MarketUtils.toSupplyAssets = toSupplyAssets;
+    function toSupplyShares(assets, market, rounding = "Up") {
+        return maths_1.SharesMath.toShares(assets, market.totalSupplyAssets, market.totalSupplyShares, rounding);
+    }
+    MarketUtils.toSupplyShares = toSupplyShares;
+    function toBorrowAssets(shares, market, rounding = "Up") {
+        return maths_1.SharesMath.toAssets(shares, market.totalBorrowAssets, market.totalBorrowShares, rounding);
+    }
+    MarketUtils.toBorrowAssets = toBorrowAssets;
+    function toBorrowShares(assets, market, rounding = "Down") {
+        return maths_1.SharesMath.toShares(assets, market.totalBorrowAssets, market.totalBorrowShares, rounding);
+    }
+    MarketUtils.toBorrowShares = toBorrowShares;
+})(MarketUtils || (exports.MarketUtils = MarketUtils = {}));

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

@@ -0,0 +1 @@
+export {};

package/lib/market/MarketUtils.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const maths_1 = require("../maths");
+const MarketUtils_1 = require("./MarketUtils");
+const market = {
+    loanToken: "0x0000000000000000000000000000000000000001",
+    collateralToken: "0x0000000000000000000000000000000000000002",
+    oracle: "0x0000000000000000000000000000000000000003",
+    irm: "0x0000000000000000000000000000000000000004",
+    lltv: 860000000000000000n,
+};
+describe("MarketUtils", () => {
+    it("should calculate the correct market id", () => {
+        expect(MarketUtils_1.MarketUtils.getMarketId(market)).toEqual("0x625e29dff74826b71c1f4c74b208a896109cc8ac9910192ce2927a982b0809e6");
+    });
+    it("should calculate the correct liquidation incentive factor", () => {
+        expect(MarketUtils_1.MarketUtils.getLiquidationIncentiveFactor(market)).toEqual(1043841336116910229n);
+    });
+    it("should calculate the supply volume to reach utilization", () => {
+        expect(MarketUtils_1.MarketUtils.getSupplyToUtilization({ totalSupplyAssets: maths_1.MathLib.WAD, totalBorrowAssets: maths_1.MathLib.WAD }, 900000000000000000n)).toEqual(111111111111111112n);
+        expect(MarketUtils_1.MarketUtils.getSupplyToUtilization({ totalSupplyAssets: maths_1.MathLib.WAD, totalBorrowAssets: 0n }, 900000000000000000n)).toEqual(0n);
+        expect(MarketUtils_1.MarketUtils.getSupplyToUtilization({ totalSupplyAssets: maths_1.MathLib.WAD, totalBorrowAssets: 0n }, 0n)).toEqual(0n);
+        expect(MarketUtils_1.MarketUtils.getSupplyToUtilization({ totalSupplyAssets: maths_1.MathLib.WAD, totalBorrowAssets: 1n }, 0n)).toEqual(maths_1.MathLib.MAX_UINT_256);
+    });
+    it("should calculate the withdraw volume to reach utilization", () => {
+        expect(MarketUtils_1.MarketUtils.getWithdrawToUtilization({ totalSupplyAssets: maths_1.MathLib.WAD, totalBorrowAssets: maths_1.MathLib.WAD }, 900000000000000000n)).toEqual(0n);
+        expect(MarketUtils_1.MarketUtils.getWithdrawToUtilization({ totalSupplyAssets: 2n * maths_1.MathLib.WAD, totalBorrowAssets: maths_1.MathLib.WAD }, 900000000000000000n)).toEqual(888888888888888888n);
+        expect(MarketUtils_1.MarketUtils.getWithdrawToUtilization({ totalSupplyAssets: maths_1.MathLib.WAD, totalBorrowAssets: 0n }, 900000000000000000n)).toEqual(maths_1.MathLib.WAD);
+    });
+    it("should calculate the borrow volume to reach utilization", () => {
+        expect(MarketUtils_1.MarketUtils.getBorrowToUtilization({ totalSupplyAssets: maths_1.MathLib.WAD, totalBorrowAssets: maths_1.MathLib.WAD }, 900000000000000000n)).toEqual(0n);
+        expect(MarketUtils_1.MarketUtils.getBorrowToUtilization({ totalSupplyAssets: maths_1.MathLib.WAD, totalBorrowAssets: 0n }, 900000000000000000n)).toEqual(900000000000000000n);
+    });
+    it("should calculate the repay volume to reach utilization", () => {
+        expect(MarketUtils_1.MarketUtils.getRepayToUtilization({ totalSupplyAssets: maths_1.MathLib.WAD, totalBorrowAssets: maths_1.MathLib.WAD }, 900000000000000000n)).toEqual(100000000000000000n);
+        expect(MarketUtils_1.MarketUtils.getRepayToUtilization({ totalSupplyAssets: maths_1.MathLib.WAD, totalBorrowAssets: 0n }, 900000000000000000n)).toEqual(0n);
+    });
+});

package/lib/market/index.d.ts

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

package/lib/market/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./MarketUtils"), exports);
+__exportStar(require("./MarketConfig"), exports);
+__exportStar(require("./Market"), exports);

package/lib/maths/AdaptiveCurveIrmLib.d.ts

@@ -0,0 +1,39 @@
+import { BigIntish } from "../types";
+/**
+ * JS implementation of {@link https://github.com/morpho-org/morpho-blue-irm/blob/main/src/libraries/adaptive-curve/ExpLib.sol ExpLib} used by the Adaptive Curve IRM.
+ */
+export declare namespace AdaptiveCurveIrmLib {
+    const CURVE_STEEPNESS = 4000000000000000000n;
+    const TARGET_UTILIZATION = 900000000000000000n;
+    const INITIAL_RATE_AT_TARGET: bigint;
+    const ADJUSTMENT_SPEED: bigint;
+    const MIN_RATE_AT_TARGET: bigint;
+    const MAX_RATE_AT_TARGET: bigint;
+    /**
+     * ln(2), scaled by WAD.
+     */
+    const LN_2_INT = 693147180559945309n;
+    /**
+     * ln(1e-18), scaled by WAD.
+     */
+    const LN_WEI_INT = -41446531673892822312n;
+    /**
+     * Above this bound, `wExp` is clipped to avoid overflowing when multiplied with 1 ether.
+     * This upper bound corresponds to: ln(type(int256).max / 1e36) (scaled by WAD, floored).
+     */
+    const WEXP_UPPER_BOUND = 93859467695000404319n;
+    /**
+     * The value of wExp(`WEXP_UPPER_BOUND`).
+     */
+    const WEXP_UPPER_VALUE = 57716089161558943949701069502944508345128422502756744429568n;
+    /**
+     * Returns an approximation of exp(x) used by the Adaptive Curve IRM.
+     * @param x
+     */
+    function wExp(x: BigIntish): bigint;
+    function getBorrowRate(startUtilization: BigIntish, startRateAtTarget: BigIntish, elapsed: BigIntish): {
+        avgBorrowRate: bigint;
+        endRateAtTarget: bigint;
+    };
+    function getUtilizationAtBorrowRate(borrowRate: BigIntish, rateAtTarget: BigIntish): bigint;
+}