@morpho-org/blue-sdk 2.0.0-next.1 → 2.0.0-next.11

package/lib/market/MarketUtils.d.ts

@@ -0,0 +1,233 @@
+import { type RoundingDirection } from "../math/index.js";
+import type { BigIntish, MarketId } from "../types.js";
+import type { InputMarketParams } 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: InputMarketParams): 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;
+    }, marketParams: {
+        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;
+    }, marketParams: {
+        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 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 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;
+    function getHealthFactor({ collateral, borrowShares, }: {
+        collateral: BigIntish;
+        borrowShares: BigIntish;
+    }, market: {
+        totalBorrowAssets: BigIntish;
+        totalBorrowShares: BigIntish;
+        price: BigIntish;
+    }, marketParams: {
+        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;
+    }, marketParams: {
+        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,257 @@
+import keccak256 from "keccak256";
+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${keccak256(`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 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 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 = MathLib.wMulUp(borrowRate, utilization);
+        return MathLib.wMulUp(borrowRateWithoutFees, 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 MathLib.wTaylorCompounded(rate, 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 = 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;
+    function getCollateralValue(collateral, { price }) {
+        return MathLib.mulDivDown(collateral, price, ORACLE_PRICE_SCALE);
+    }
+    MarketUtils.getCollateralValue = getCollateralValue;
+    function getMaxBorrowAssets(collateral, market, { lltv }) {
+        return MathLib.wMulDown(getCollateralValue(collateral, market), lltv);
+    }
+    MarketUtils.getMaxBorrowAssets = getMaxBorrowAssets;
+    function getMaxBorrowableAssets({ collateral, borrowShares, }, market, marketParams) {
+        return MathLib.zeroFloorSub(getMaxBorrowAssets(collateral, market, marketParams), toBorrowAssets(borrowShares, market));
+    }
+    MarketUtils.getMaxBorrowableAssets = getMaxBorrowableAssets;
+    function getLiquidationSeizedAssets(repaidShares, market, config) {
+        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;
+    function getLiquidationRepaidShares(seizedAssets, market, config) {
+        return toBorrowShares(MathLib.wDivUp(MathLib.mulDivUp(seizedAssets, market.price, 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 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 MathLib.zeroFloorSub(collateral, MathLib.wDivUp(MathLib.mulDivUp(toBorrowAssets(borrowShares, market), ORACLE_PRICE_SCALE, market.price), lltv));
+    }
+    MarketUtils.getWithdrawableCollateral = getWithdrawableCollateral;
+    function isHealthy({ collateral, borrowShares, }, market, marketParams) {
+        return (getMaxBorrowAssets(collateral, market, marketParams) >=
+            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 null if the position is not a borrow.
+     */
+    function getPriceVariationToLiquidationPrice(position, market, marketParams) {
+        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;
+    function getHealthFactor({ collateral, borrowShares, }, market, marketParams) {
+        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 MathLib.MAX_UINT_256;
+        const maxBorrowAssets = getMaxBorrowAssets(collateral, market, marketParams);
+        return 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 MathLib.MAX_UINT_256;
+        return MathLib.wDivUp(toBorrowAssets(borrowShares, market), collateralValue);
+    }
+    MarketUtils.getLtv = getLtv;
+    function getBorrowCapacityUsage(position, market, marketParams) {
+        const hf = getHealthFactor(position, market, marketParams);
+        if (hf === null)
+            return null;
+        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/market/index.d.ts

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

package/lib/market/index.js

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

package/lib/math/AdaptiveCurveIrmLib.d.ts

@@ -0,0 +1,39 @@
+import type { BigIntish } from "../types.js";
+/**
+ * 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;
+}

package/lib/math/AdaptiveCurveIrmLib.js

@@ -0,0 +1,131 @@
+import { SECONDS_PER_YEAR } from "../constants.js";
+import { MathLib } from "./MathLib.js";
+/**
+ * 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 var AdaptiveCurveIrmLib;
+(function (AdaptiveCurveIrmLib) {
+    AdaptiveCurveIrmLib.CURVE_STEEPNESS = 4000000000000000000n;
+    AdaptiveCurveIrmLib.TARGET_UTILIZATION = 900000000000000000n;
+    AdaptiveCurveIrmLib.INITIAL_RATE_AT_TARGET = 40000000000000000n / SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.ADJUSTMENT_SPEED = 50000000000000000000n / SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.MIN_RATE_AT_TARGET = 1000000000000000n / SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.MAX_RATE_AT_TARGET = 2000000000000000000n / SECONDS_PER_YEAR;
+    /**
+     * ln(2), scaled by WAD.
+     */
+    AdaptiveCurveIrmLib.LN_2_INT = 693147180559945309n;
+    /**
+     * ln(1e-18), scaled by WAD.
+     */
+    AdaptiveCurveIrmLib.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).
+     */
+    AdaptiveCurveIrmLib.WEXP_UPPER_BOUND = 93859467695000404319n;
+    /**
+     * The value of wExp(`WEXP_UPPER_BOUND`).
+     */
+    AdaptiveCurveIrmLib.WEXP_UPPER_VALUE = 57716089161558943949701069502944508345128422502756744429568n;
+    /**
+     * Returns an approximation of exp(x) used by the Adaptive Curve IRM.
+     * @param x
+     */
+    function wExp(x) {
+        x = BigInt(x);
+        // If x < ln(1e-18) then exp(x) < 1e-18 so it is rounded to zero.
+        if (x < AdaptiveCurveIrmLib.LN_WEI_INT)
+            return 0n;
+        // `wExp` is clipped to avoid overflowing when multiplied with 1 ether.
+        if (x >= AdaptiveCurveIrmLib.WEXP_UPPER_BOUND)
+            return AdaptiveCurveIrmLib.WEXP_UPPER_VALUE;
+        // Decompose x as x = q * ln(2) + r with q an integer and -ln(2)/2 <= r <= ln(2)/2.
+        // q = x / ln(2) rounded half toward zero.
+        const roundingAdjustment = x < 0n ? -(AdaptiveCurveIrmLib.LN_2_INT / 2n) : AdaptiveCurveIrmLib.LN_2_INT / 2n;
+        const q = (x + roundingAdjustment) / AdaptiveCurveIrmLib.LN_2_INT;
+        const r = x - q * AdaptiveCurveIrmLib.LN_2_INT;
+        // Compute e^r with a 2nd-order Taylor polynomial.
+        const expR = MathLib.WAD + r + (r * r) / MathLib.WAD / 2n;
+        // Return e^x = 2^q * e^r.
+        if (q === 0n)
+            return expR << q;
+        return expR >> -q;
+    }
+    AdaptiveCurveIrmLib.wExp = wExp;
+    function getBorrowRate(startUtilization, startRateAtTarget, elapsed) {
+        startUtilization = BigInt(startUtilization);
+        startRateAtTarget = BigInt(startRateAtTarget);
+        elapsed = BigInt(elapsed);
+        const errNormFactor = startUtilization > AdaptiveCurveIrmLib.TARGET_UTILIZATION
+            ? MathLib.WAD - AdaptiveCurveIrmLib.TARGET_UTILIZATION
+            : AdaptiveCurveIrmLib.TARGET_UTILIZATION;
+        const err = MathLib.wDivDown(startUtilization - AdaptiveCurveIrmLib.TARGET_UTILIZATION, errNormFactor);
+        let avgRateAtTarget;
+        let endRateAtTarget;
+        if (startRateAtTarget === 0n) {
+            // First interaction.
+            avgRateAtTarget = AdaptiveCurveIrmLib.INITIAL_RATE_AT_TARGET;
+            endRateAtTarget = AdaptiveCurveIrmLib.INITIAL_RATE_AT_TARGET;
+        }
+        else {
+            // The speed is assumed constant between two updates, but it is in fact not constant because of interest.
+            // So the rate is always underestimated.
+            const speed = MathLib.wMulDown(AdaptiveCurveIrmLib.ADJUSTMENT_SPEED, err);
+            const linearAdaptation = speed * elapsed;
+            if (linearAdaptation === 0n) {
+                // If linearAdaptation == 0, avgRateAtTarget = endRateAtTarget = startRateAtTarget;
+                avgRateAtTarget = startRateAtTarget;
+                endRateAtTarget = startRateAtTarget;
+            }
+            else {
+                // Non negative because MIN_RATE_AT_TARGET > 0.
+                const _newRateAtTarget = (linearAdaptation) => MathLib.min(MathLib.max(MathLib.wMulDown(startRateAtTarget, wExp(linearAdaptation)), AdaptiveCurveIrmLib.MIN_RATE_AT_TARGET), AdaptiveCurveIrmLib.MAX_RATE_AT_TARGET);
+                // Formula of the average rate that should be returned to Morpho Blue:
+                // avg = 1/T * ∫_0^T curve(startRateAtTarget*exp(speed*x), err) dx
+                // The integral is approximated with the trapezoidal rule:
+                // avg ~= 1/T * Σ_i=1^N [curve(f((i-1) * T/N), err) + curve(f(i * T/N), err)] / 2 * T/N
+                // Where f(x) = startRateAtTarget*exp(speed*x)
+                // avg ~= Σ_i=1^N [curve(f((i-1) * T/N), err) + curve(f(i * T/N), err)] / (2 * N)
+                // As curve is linear in its first argument:
+                // avg ~= curve([Σ_i=1^N [f((i-1) * T/N) + f(i * T/N)] / (2 * N), err)
+                // avg ~= curve([(f(0) + f(T))/2 + Σ_i=1^(N-1) f(i * T/N)] / N, err)
+                // avg ~= curve([(startRateAtTarget + endRateAtTarget)/2 + Σ_i=1^(N-1) f(i * T/N)] / N, err)
+                // With N = 2:
+                // avg ~= curve([(startRateAtTarget + endRateAtTarget)/2 + startRateAtTarget*exp(speed*T/2)] / 2, err)
+                // avg ~= curve([startRateAtTarget + endRateAtTarget + 2*startRateAtTarget*exp(speed*T/2)] / 4, err)
+                endRateAtTarget = _newRateAtTarget(linearAdaptation);
+                avgRateAtTarget =
+                    (startRateAtTarget +
+                        endRateAtTarget +
+                        2n * _newRateAtTarget(linearAdaptation / 2n)) /
+                        4n;
+            }
+        }
+        // Non negative because 1 - 1/C >= 0, C - 1 >= 0.
+        const coeff = err < 0
+            ? MathLib.WAD - MathLib.wDivDown(MathLib.WAD, AdaptiveCurveIrmLib.CURVE_STEEPNESS)
+            : AdaptiveCurveIrmLib.CURVE_STEEPNESS - MathLib.WAD;
+        // Non negative if avgRateAtTarget >= 0 because if err < 0, coeff <= 1.
+        return {
+            avgBorrowRate: MathLib.wMulDown(MathLib.wMulDown(coeff, err) + MathLib.WAD, avgRateAtTarget),
+            endRateAtTarget,
+        };
+    }
+    AdaptiveCurveIrmLib.getBorrowRate = getBorrowRate;
+    function getUtilizationAtBorrowRate(borrowRate, rateAtTarget) {
+        borrowRate = BigInt(borrowRate);
+        rateAtTarget = BigInt(rateAtTarget);
+        if (borrowRate >= rateAtTarget) {
+            const maxBorrowRate = MathLib.wMulDown(rateAtTarget, AdaptiveCurveIrmLib.CURVE_STEEPNESS);
+            const diffToMaxBorrowRate = maxBorrowRate - rateAtTarget;
+            if (diffToMaxBorrowRate === 0n)
+                return MathLib.WAD;
+            return MathLib.min(MathLib.WAD, AdaptiveCurveIrmLib.TARGET_UTILIZATION +
+                MathLib.mulDivDown(MathLib.WAD - AdaptiveCurveIrmLib.TARGET_UTILIZATION, borrowRate - rateAtTarget, diffToMaxBorrowRate));
+        }
+        const minBorrowRate = MathLib.wDivDown(rateAtTarget, AdaptiveCurveIrmLib.CURVE_STEEPNESS);
+        return MathLib.max(0n, MathLib.mulDivDown(AdaptiveCurveIrmLib.TARGET_UTILIZATION, borrowRate - minBorrowRate, rateAtTarget - minBorrowRate));
+    }
+    AdaptiveCurveIrmLib.getUtilizationAtBorrowRate = getUtilizationAtBorrowRate;
+})(AdaptiveCurveIrmLib || (AdaptiveCurveIrmLib = {}));