@morpho-org/blue-sdk 1.0.3 → 1.0.4

package/lib/market/MarketConfig.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketConfig = void 0;
+const ethers_1 = require("ethers");
+const ethers_types_1 = require("ethers-types");
+const addresses_1 = require("../addresses");
+const chain_1 = require("../chain");
+const errors_1 = require("../errors");
+const MarketUtils_1 = require("./MarketUtils");
+class MarketConfig {
+    static get(id) {
+        const marketConfig = MarketConfig._CACHE[id];
+        if (!marketConfig)
+            throw new errors_1.UnknownMarketConfigError(id);
+        return marketConfig;
+    }
+    static async fetch(id, runner, chainId) {
+        let config = (0, errors_1._try)(() => MarketConfig.get(id), errors_1.UnknownMarketConfigError);
+        if (!config) {
+            chainId ?? (chainId = chain_1.ChainUtils.parseSupportedChainId((await runner.provider.getNetwork()).chainId));
+            const { morpho } = (0, addresses_1.getChainAddresses)(chainId);
+            config = new MarketConfig(
+            // Always fetch at latest block because config is immutable.
+            await ethers_types_1.MorphoBlue__factory.connect(morpho, runner).idToMarketParams(id));
+        }
+        return config;
+    }
+    static idle(token) {
+        return new MarketConfig({
+            collateralToken: ethers_1.ZeroAddress,
+            loanToken: token,
+            oracle: ethers_1.ZeroAddress,
+            irm: ethers_1.ZeroAddress,
+            lltv: 0n,
+        });
+    }
+    constructor({ collateralToken, loanToken, oracle, irm, lltv }) {
+        this.collateralToken = collateralToken;
+        this.loanToken = loanToken;
+        this.oracle = oracle;
+        this.irm = irm;
+        this.lltv = (0, ethers_1.toBigInt)(lltv);
+        MarketConfig._CACHE[this.id] = this;
+    }
+    /**
+     * The market's hex-encoded id, defined as the hash of the market's params.
+     */
+    get id() {
+        return MarketUtils_1.MarketUtils.getMarketId(this);
+    }
+    get liquidationIncentiveFactor() {
+        return MarketUtils_1.MarketUtils.getLiquidationIncentiveFactor(this);
+    }
+}
+exports.MarketConfig = MarketConfig;
+MarketConfig._CACHE = {};

package/lib/market/MarketUtils.d.ts

@@ -0,0 +1,165 @@
+import { BigNumberish } from "ethers";
+import { MarketParamsStruct } from "ethers-types/dist/protocols/morpho/blue/MorphoBlue";
+import { RoundingDirection } from "../maths";
+import { MarketId } from "../types";
+export declare namespace MarketUtils {
+    function getMarketId(market: MarketParamsStruct): MarketId;
+    function getLiquidationIncentiveFactor({ lltv, }: {
+        lltv: BigNumberish;
+    }): bigint;
+    function getUtilization({ totalSupplyAssets, totalBorrowAssets, }: {
+        totalSupplyAssets: BigNumberish;
+        totalBorrowAssets: BigNumberish;
+    }): bigint;
+    function getSupplyRate(borrowRate: BigNumberish, { utilization, fee }: {
+        utilization: BigNumberish;
+        fee: BigNumberish;
+    }): bigint;
+    function getApy(rate: BigNumberish): bigint;
+    function getAccruedInterest(borrowRate: BigNumberish, { totalSupplyAssets, totalBorrowAssets, totalSupplyShares, fee, }: {
+        totalSupplyAssets: BigNumberish;
+        totalBorrowAssets: BigNumberish;
+        totalSupplyShares: BigNumberish;
+        fee: BigNumberish;
+    }, elapsed?: bigint): {
+        interest: bigint;
+        feeShares: bigint;
+    };
+    function getLiquidityToUtilization({ totalSupplyAssets, totalBorrowAssets, }: {
+        totalSupplyAssets: BigNumberish;
+        totalBorrowAssets: BigNumberish;
+    }, utilization: BigNumberish): bigint;
+    function getCollateralPower(collateral: BigNumberish, { lltv }: {
+        lltv: BigNumberish;
+    }): bigint;
+    function getCollateralValue(collateral: BigNumberish, { price }: {
+        price: BigNumberish;
+    }): bigint;
+    function getMaxBorrowAssets(collateral: BigNumberish, market: {
+        price: BigNumberish;
+    }, { lltv }: {
+        lltv: BigNumberish;
+    }): bigint;
+    function getMaxBorrowableAssets({ collateral, borrowShares, }: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+        price: BigNumberish;
+    }, marketConfig: {
+        lltv: BigNumberish;
+    }): bigint;
+    function getLiquidationSeizedAssets(repaidShares: BigNumberish, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+        price: BigNumberish;
+    }, config: {
+        lltv: BigNumberish;
+    }): bigint;
+    function getLiquidationRepaidShares(seizedAssets: BigNumberish, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+        price: BigNumberish;
+    }, config: {
+        lltv: BigNumberish;
+    }): bigint;
+    function getSeizableCollateral(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+        price: BigNumberish;
+    }, config: {
+        lltv: BigNumberish;
+    }): bigint;
+    function getWithdrawableCollateral({ collateral, borrowShares, }: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+        price: BigNumberish;
+    }, { lltv }: {
+        lltv: BigNumberish;
+    }): bigint;
+    function isHealthy({ collateral, borrowShares, }: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+        price: BigNumberish;
+    }, marketConfig: {
+        lltv: BigNumberish;
+    }): 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: BigNumberish;
+        borrowShares: BigNumberish;
+    }, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+    }, marketConfig: {
+        lltv: BigNumberish;
+    }): bigint | null;
+    function getPriceVariationToLiquidation(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+        price: BigNumberish;
+    }, marketConfig: {
+        lltv: BigNumberish;
+    }): bigint | null;
+    function getHealthFactor({ collateral, borrowShares, }: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+        price: BigNumberish;
+    }, marketConfig: {
+        lltv: BigNumberish;
+    }): bigint | null;
+    function getLtv({ collateral, borrowShares, }: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+        price: BigNumberish;
+    }): bigint | null;
+    function getBorrowCapacityUsage(position: {
+        collateral: BigNumberish;
+        borrowShares: BigNumberish;
+    }, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+        price: BigNumberish;
+    }, marketConfig: {
+        lltv: BigNumberish;
+    }): bigint | null;
+    function toSupplyAssets(shares: BigNumberish, market: {
+        totalSupplyAssets: BigNumberish;
+        totalSupplyShares: BigNumberish;
+    }, rounding?: RoundingDirection): bigint;
+    function toSupplyShares(assets: BigNumberish, market: {
+        totalSupplyAssets: BigNumberish;
+        totalSupplyShares: BigNumberish;
+    }, rounding?: RoundingDirection): bigint;
+    function toBorrowAssets(shares: BigNumberish, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+    }, rounding?: RoundingDirection): bigint;
+    function toBorrowShares(assets: BigNumberish, market: {
+        totalBorrowAssets: BigNumberish;
+        totalBorrowShares: BigNumberish;
+    }, rounding?: RoundingDirection): bigint;
+}

package/lib/market/MarketUtils.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketUtils = void 0;
+const ethers_1 = require("ethers");
+const constants_1 = require("../constants");
+const maths_1 = require("../maths");
+var MarketUtils;
+(function (MarketUtils) {
+    function getMarketId(market) {
+        const encodedMarket = ethers_1.AbiCoder.defaultAbiCoder().encode(["address", "address", "address", "address", "uint256"], [
+            market.loanToken,
+            market.collateralToken,
+            market.oracle,
+            market.irm,
+            market.lltv,
+        ]);
+        return (0, ethers_1.keccak256)(encodedMarket);
+    }
+    MarketUtils.getMarketId = getMarketId;
+    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 - (0, ethers_1.toBigInt)(lltv))));
+    }
+    MarketUtils.getLiquidationIncentiveFactor = getLiquidationIncentiveFactor;
+    function getUtilization({ totalSupplyAssets, totalBorrowAssets, }) {
+        totalSupplyAssets = (0, ethers_1.toBigInt)(totalSupplyAssets);
+        if (totalSupplyAssets === 0n)
+            return 0n;
+        return maths_1.MathLib.wDivDown(totalBorrowAssets, totalSupplyAssets);
+    }
+    MarketUtils.getUtilization = getUtilization;
+    function getSupplyRate(borrowRate, { utilization, fee }) {
+        const borrowRateWithoutFees = maths_1.MathLib.wMulUp(borrowRate, utilization);
+        return maths_1.MathLib.wMulUp(borrowRateWithoutFees, maths_1.MathLib.WAD - (0, ethers_1.toBigInt)(fee));
+    }
+    MarketUtils.getSupplyRate = getSupplyRate;
+    function getApy(rate) {
+        return maths_1.MathLib.wTaylorCompounded(rate, constants_1.SECONDS_PER_YEAR);
+    }
+    MarketUtils.getApy = getApy;
+    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: (0, ethers_1.toBigInt)(totalSupplyAssets) - feeAmount,
+            totalSupplyShares,
+        }, "Down");
+        return { interest, feeShares };
+    }
+    MarketUtils.getAccruedInterest = getAccruedInterest;
+    function getLiquidityToUtilization({ totalSupplyAssets, totalBorrowAssets, }, utilization) {
+        utilization = (0, ethers_1.toBigInt)(utilization);
+        totalSupplyAssets = (0, ethers_1.toBigInt)(totalSupplyAssets);
+        totalBorrowAssets = (0, ethers_1.toBigInt)(totalBorrowAssets);
+        if (utilization === 0n) {
+            if (totalBorrowAssets === 0n)
+                return totalSupplyAssets;
+            return 0n;
+        }
+        return maths_1.MathUtils.zeroFloorSub(totalSupplyAssets, maths_1.MathLib.wDivUp(totalBorrowAssets, utilization));
+    }
+    MarketUtils.getLiquidityToUtilization = getLiquidityToUtilization;
+    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.MathUtils.zeroFloorSub(getMaxBorrowAssets(collateral, market, marketConfig), toBorrowAssets(borrowShares, market));
+    }
+    MarketUtils.getMaxBorrowableAssets = getMaxBorrowableAssets;
+    function getLiquidationSeizedAssets(repaidShares, market, config) {
+        market.price = (0, ethers_1.toBigInt)(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 = (0, ethers_1.toBigInt)(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 = (0, ethers_1.toBigInt)(market.price);
+        if (market.price === 0n)
+            return 0n;
+        return maths_1.MathUtils.zeroFloorSub((0, ethers_1.toBigInt)(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 = (0, ethers_1.toBigInt)(borrowShares);
+        market.totalBorrowShares = (0, ethers_1.toBigInt)(market.totalBorrowShares);
+        if (borrowShares === 0n || market.totalBorrowShares === 0n)
+            return null;
+        const collateralPower = getCollateralPower(collateral, marketConfig);
+        if (collateralPower === 0n)
+            return ethers_1.MaxUint256;
+        const borrowAssets = toBorrowAssets(borrowShares, market);
+        return maths_1.MathLib.mulDivUp(borrowAssets, constants_1.ORACLE_PRICE_SCALE, collateralPower);
+    }
+    MarketUtils.getLiquidationPrice = getLiquidationPrice;
+    function getPriceVariationToLiquidation(position, market, marketConfig) {
+        market.price = (0, ethers_1.toBigInt)(market.price);
+        const liquidationPrice = getLiquidationPrice(position, market, marketConfig);
+        if (market.price === 0n || 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 = (0, ethers_1.toBigInt)(borrowShares);
+        market.totalBorrowShares = (0, ethers_1.toBigInt)(market.totalBorrowShares);
+        if (borrowShares === 0n || market.totalBorrowShares === 0n)
+            return null;
+        const borrowAssets = toBorrowAssets(borrowShares, market);
+        if (borrowAssets === 0n)
+            return ethers_1.MaxUint256;
+        const maxBorrowAssets = getMaxBorrowAssets(collateral, market, marketConfig);
+        return maths_1.MathLib.wDivDown(maxBorrowAssets, borrowAssets);
+    }
+    MarketUtils.getHealthFactor = getHealthFactor;
+    function getLtv({ collateral, borrowShares, }, market) {
+        borrowShares = (0, ethers_1.toBigInt)(borrowShares);
+        market.totalBorrowShares = (0, ethers_1.toBigInt)(market.totalBorrowShares);
+        if (borrowShares === 0n || market.totalBorrowShares === 0n)
+            return null;
+        const collateralValue = getCollateralValue(collateral, market);
+        if (collateralValue === 0n)
+            return ethers_1.MaxUint256;
+        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 ethers_1.MaxUint256;
+        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,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const MarketUtils_1 = require("./MarketUtils");
+const market = {
+    loanToken: "0x0000000000000000000000000000000000000001",
+    collateralToken: "0x0000000000000000000000000000000000000002",
+    oracle: "0x0000000000000000000000000000000000000003",
+    irm: "0x0000000000000000000000000000000000000004",
+    lltv: (0, ethers_1.parseEther)("0.86"),
+};
+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);
+    });
+});

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,37 @@
+/**
+ * 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: bigint;
+    const TARGET_UTILIZATION: bigint;
+    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: bigint): bigint;
+    function getBorrowRate(startUtilization: bigint, startRateAtTarget: bigint, elapsed: bigint): {
+        avgBorrowRate: bigint;
+        endRateAtTarget: bigint;
+    };
+}

package/lib/maths/AdaptiveCurveIrmLib.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdaptiveCurveIrmLib = void 0;
+const ethers_1 = require("ethers");
+const constants_1 = require("../constants");
+const MathLib_1 = require("./MathLib");
+/**
+ * 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.
+ */
+var AdaptiveCurveIrmLib;
+(function (AdaptiveCurveIrmLib) {
+    AdaptiveCurveIrmLib.CURVE_STEEPNESS = (0, ethers_1.parseUnits)("4");
+    AdaptiveCurveIrmLib.TARGET_UTILIZATION = (0, ethers_1.parseUnits)("0.9");
+    AdaptiveCurveIrmLib.INITIAL_RATE_AT_TARGET = (0, ethers_1.parseUnits)("0.04") / constants_1.SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.ADJUSTMENT_SPEED = (0, ethers_1.parseUnits)("50") / constants_1.SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.MIN_RATE_AT_TARGET = (0, ethers_1.parseUnits)("0.001") / constants_1.SECONDS_PER_YEAR;
+    AdaptiveCurveIrmLib.MAX_RATE_AT_TARGET = (0, ethers_1.parseUnits)("2") / constants_1.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) {
+        // 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_1.MathLib.WAD + r + (r * r) / MathLib_1.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) {
+        const errNormFactor = startUtilization > AdaptiveCurveIrmLib.TARGET_UTILIZATION
+            ? MathLib_1.MathLib.WAD - AdaptiveCurveIrmLib.TARGET_UTILIZATION
+            : AdaptiveCurveIrmLib.TARGET_UTILIZATION;
+        const err = MathLib_1.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_1.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_1.MathLib.min(MathLib_1.MathLib.max(MathLib_1.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_1.MathLib.WAD - MathLib_1.MathLib.wDivDown(MathLib_1.MathLib.WAD, AdaptiveCurveIrmLib.CURVE_STEEPNESS)
+            : AdaptiveCurveIrmLib.CURVE_STEEPNESS - MathLib_1.MathLib.WAD;
+        // Non negative if avgRateAtTarget >= 0 because if err < 0, coeff <= 1.
+        return {
+            avgBorrowRate: MathLib_1.MathLib.wMulDown(MathLib_1.MathLib.wMulDown(coeff, err) + MathLib_1.MathLib.WAD, avgRateAtTarget),
+            endRateAtTarget,
+        };
+    }
+    AdaptiveCurveIrmLib.getBorrowRate = getBorrowRate;
+})(AdaptiveCurveIrmLib || (exports.AdaptiveCurveIrmLib = AdaptiveCurveIrmLib = {}));