@morpho-org/blue-sdk 1.0.0

package/src/market/MarketUtils.ts

@@ -0,0 +1,467 @@
+import {
+  AbiCoder,
+  BigNumberish,
+  MaxUint256,
+  keccak256,
+  toBigInt,
+} from "ethers";
+import { MarketParamsStruct } from "ethers-types/dist/protocols/morpho/blue/MorphoBlue";
+
+import {
+  LIQUIDATION_CURSOR,
+  MAX_LIQUIDATION_INCENTIVE_FACTOR,
+  ORACLE_PRICE_SCALE,
+  SECONDS_PER_YEAR,
+} from "../constants";
+import { MathLib, MathUtils, RoundingDirection, SharesMath } from "../maths";
+import { MarketId } from "../types";
+
+export namespace MarketUtils {
+  export function getMarketId(market: MarketParamsStruct) {
+    const encodedMarket = AbiCoder.defaultAbiCoder().encode(
+      ["address", "address", "address", "address", "uint256"],
+      [
+        market.loanToken,
+        market.collateralToken,
+        market.oracle,
+        market.irm,
+        market.lltv,
+      ]
+    );
+
+    return keccak256(encodedMarket) as MarketId;
+  }
+
+  export function getLiquidationIncentiveFactor({
+    lltv,
+  }: {
+    lltv: BigNumberish;
+  }) {
+    return MathLib.min(
+      MAX_LIQUIDATION_INCENTIVE_FACTOR,
+      MathLib.wDivDown(
+        MathLib.WAD,
+        MathLib.WAD -
+          MathLib.wMulDown(LIQUIDATION_CURSOR, MathLib.WAD - toBigInt(lltv))
+      )
+    );
+  }
+
+  export function getUtilization({
+    totalSupplyAssets,
+    totalBorrowAssets,
+  }: {
+    totalSupplyAssets: BigNumberish;
+    totalBorrowAssets: BigNumberish;
+  }) {
+    totalSupplyAssets = toBigInt(totalSupplyAssets);
+
+    if (totalSupplyAssets === 0n) return 0n;
+
+    return MathLib.wDivDown(totalBorrowAssets, totalSupplyAssets);
+  }
+
+  export function getSupplyRate(
+    borrowRate: BigNumberish,
+    { utilization, fee }: { utilization: BigNumberish; fee: BigNumberish }
+  ) {
+    const borrowRateWithoutFees = MathLib.wMulUp(borrowRate, utilization);
+
+    return MathLib.wMulUp(borrowRateWithoutFees, MathLib.WAD - toBigInt(fee));
+  }
+
+  export function getApy(rate: BigNumberish) {
+    return MathLib.wTaylorCompounded(rate, SECONDS_PER_YEAR);
+  }
+
+  export function getAccruedInterest(
+    borrowRate: BigNumberish,
+    {
+      totalSupplyAssets,
+      totalBorrowAssets,
+      totalSupplyShares,
+      fee,
+    }: {
+      totalSupplyAssets: BigNumberish;
+      totalBorrowAssets: BigNumberish;
+      totalSupplyShares: BigNumberish;
+      fee: BigNumberish;
+    },
+    elapsed = 0n
+  ) {
+    const interest = MathLib.wMulDown(
+      totalBorrowAssets,
+      MathLib.wTaylorCompounded(borrowRate, elapsed)
+    );
+
+    const feeAmount = MathLib.wMulDown(interest, fee);
+    const feeShares = toSupplyShares(
+      feeAmount,
+      {
+        totalSupplyAssets: toBigInt(totalSupplyAssets) - feeAmount,
+        totalSupplyShares,
+      },
+      "Down"
+    );
+
+    return { interest, feeShares };
+  }
+
+  export function getLiquidityToUtilization(
+    {
+      totalSupplyAssets,
+      totalBorrowAssets,
+    }: {
+      totalSupplyAssets: BigNumberish;
+      totalBorrowAssets: BigNumberish;
+    },
+    utilization: BigNumberish
+  ) {
+    utilization = toBigInt(utilization);
+    totalSupplyAssets = toBigInt(totalSupplyAssets);
+    totalBorrowAssets = toBigInt(totalBorrowAssets);
+
+    if (utilization === 0n) {
+      if (totalBorrowAssets === 0n) return totalSupplyAssets;
+
+      return 0n;
+    }
+
+    return MathUtils.zeroFloorSub(
+      totalSupplyAssets,
+      MathLib.wDivUp(totalBorrowAssets, utilization)
+    );
+  }
+
+  export function getCollateralPower(
+    collateral: BigNumberish,
+    { lltv }: { lltv: BigNumberish }
+  ) {
+    return MathLib.wMulDown(collateral, lltv);
+  }
+
+  export function getCollateralValue(
+    collateral: BigNumberish,
+    { price }: { price: BigNumberish }
+  ) {
+    return MathLib.mulDivDown(collateral, price, ORACLE_PRICE_SCALE);
+  }
+
+  export function getMaxBorrowAssets(
+    collateral: BigNumberish,
+    market: { price: BigNumberish },
+    { lltv }: { lltv: BigNumberish }
+  ) {
+    return MathLib.wMulDown(getCollateralValue(collateral, market), lltv);
+  }
+
+  export function getMaxBorrowableAssets(
+    {
+      collateral,
+      borrowShares,
+    }: { collateral: BigNumberish; borrowShares: BigNumberish },
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+      price: BigNumberish;
+    },
+    marketConfig: { lltv: BigNumberish }
+  ) {
+    return MathUtils.zeroFloorSub(
+      getMaxBorrowAssets(collateral, market, marketConfig),
+      toBorrowAssets(borrowShares, market)
+    );
+  }
+
+  export function getLiquidationSeizedAssets(
+    repaidShares: BigNumberish,
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+      price: BigNumberish;
+    },
+    config: { lltv: BigNumberish }
+  ) {
+    market.price = toBigInt(market.price);
+
+    if (market.price === 0n) return 0n;
+
+    return MathLib.mulDivDown(
+      MathLib.wMulDown(
+        toBorrowAssets(repaidShares, market, "Down"),
+        getLiquidationIncentiveFactor(config)
+      ),
+      ORACLE_PRICE_SCALE,
+      market.price
+    );
+  }
+
+  export function getLiquidationRepaidShares(
+    seizedAssets: BigNumberish,
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+      price: BigNumberish;
+    },
+    config: { lltv: BigNumberish }
+  ) {
+    return toBorrowShares(
+      MathLib.wDivUp(
+        MathLib.mulDivUp(seizedAssets, market.price, ORACLE_PRICE_SCALE),
+        getLiquidationIncentiveFactor(config)
+      ),
+      market,
+      "Up"
+    );
+  }
+
+  export function getSeizableCollateral(
+    position: { collateral: BigNumberish; borrowShares: BigNumberish },
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+      price: BigNumberish;
+    },
+    config: { lltv: BigNumberish }
+  ) {
+    market.price = toBigInt(market.price);
+
+    if (market.price === 0n || isHealthy(position, market, config)) return 0n;
+
+    return MathLib.min(
+      position.collateral,
+      getLiquidationSeizedAssets(position.borrowShares, market, config)
+    );
+  }
+
+  export function getWithdrawableCollateral(
+    {
+      collateral,
+      borrowShares,
+    }: { collateral: BigNumberish; borrowShares: BigNumberish },
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+      price: BigNumberish;
+    },
+    { lltv }: { lltv: BigNumberish }
+  ) {
+    market.price = toBigInt(market.price);
+
+    if (market.price === 0n) return 0n;
+
+    return MathUtils.zeroFloorSub(
+      toBigInt(collateral),
+      MathLib.wDivUp(
+        MathLib.mulDivUp(
+          toBorrowAssets(borrowShares, market),
+          ORACLE_PRICE_SCALE,
+          market.price
+        ),
+        lltv
+      )
+    );
+  }
+
+  export function isHealthy(
+    {
+      collateral,
+      borrowShares,
+    }: { collateral: BigNumberish; borrowShares: BigNumberish },
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+      price: BigNumberish;
+    },
+    marketConfig: { lltv: BigNumberish }
+  ) {
+    return (
+      getMaxBorrowAssets(collateral, market, marketConfig) >=
+      toBorrowAssets(borrowShares, market)
+    );
+  }
+
+  /**
+   * 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
+   */
+  export function getLiquidationPrice(
+    {
+      collateral,
+      borrowShares,
+    }: { collateral: BigNumberish; borrowShares: BigNumberish },
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+    },
+    marketConfig: { lltv: BigNumberish }
+  ) {
+    borrowShares = toBigInt(borrowShares);
+    market.totalBorrowShares = toBigInt(market.totalBorrowShares);
+
+    if (borrowShares === 0n || market.totalBorrowShares === 0n) return null;
+
+    const collateralPower = getCollateralPower(collateral, marketConfig);
+    if (collateralPower === 0n) return MaxUint256;
+
+    const borrowAssets = toBorrowAssets(borrowShares, market);
+
+    return MathLib.mulDivUp(borrowAssets, ORACLE_PRICE_SCALE, collateralPower);
+  }
+
+  export function getPriceVariationToLiquidation(
+    position: { collateral: BigNumberish; borrowShares: BigNumberish },
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+      price: BigNumberish;
+    },
+    marketConfig: { lltv: BigNumberish }
+  ) {
+    market.price = toBigInt(market.price);
+
+    const liquidationPrice = getLiquidationPrice(
+      position,
+      market,
+      marketConfig
+    );
+    if (market.price === 0n || liquidationPrice == null) return null;
+
+    return MathLib.WAD - MathLib.wDivUp(liquidationPrice, market.price);
+  }
+
+  export function getHealthFactor(
+    {
+      collateral,
+      borrowShares,
+    }: { collateral: BigNumberish; borrowShares: BigNumberish },
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+      price: BigNumberish;
+    },
+    marketConfig: { lltv: BigNumberish }
+  ) {
+    borrowShares = toBigInt(borrowShares);
+    market.totalBorrowShares = toBigInt(market.totalBorrowShares);
+
+    if (borrowShares === 0n || market.totalBorrowShares === 0n) return null;
+
+    const borrowAssets = toBorrowAssets(borrowShares, market);
+    if (borrowAssets === 0n) return MaxUint256;
+
+    const maxBorrowAssets = getMaxBorrowAssets(
+      collateral,
+      market,
+      marketConfig
+    );
+
+    return MathLib.wDivDown(maxBorrowAssets, borrowAssets);
+  }
+
+  export function getLtv(
+    {
+      collateral,
+      borrowShares,
+    }: { collateral: BigNumberish; borrowShares: BigNumberish },
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+      price: BigNumberish;
+    }
+  ) {
+    borrowShares = toBigInt(borrowShares);
+    market.totalBorrowShares = toBigInt(market.totalBorrowShares);
+
+    if (borrowShares === 0n || market.totalBorrowShares === 0n) return null;
+
+    const collateralValue = getCollateralValue(collateral, market);
+    if (collateralValue === 0n) return MaxUint256;
+
+    return MathLib.wDivUp(
+      toBorrowAssets(borrowShares, market),
+      collateralValue
+    );
+  }
+
+  export function getBorrowCapacityUsage(
+    position: { collateral: BigNumberish; borrowShares: BigNumberish },
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+      price: BigNumberish;
+    },
+    marketConfig: { lltv: BigNumberish }
+  ) {
+    const hf = getHealthFactor(position, market, marketConfig);
+    if (hf === null) return null;
+    if (hf === 0n) return MaxUint256;
+
+    return MathLib.wDivUp(MathLib.WAD, hf);
+  }
+
+  export function toSupplyAssets(
+    shares: BigNumberish,
+    market: {
+      totalSupplyAssets: BigNumberish;
+      totalSupplyShares: BigNumberish;
+    },
+    rounding: RoundingDirection = "Down"
+  ) {
+    return SharesMath.toAssets(
+      shares,
+      market.totalSupplyAssets,
+      market.totalSupplyShares,
+      rounding
+    );
+  }
+
+  export function toSupplyShares(
+    assets: BigNumberish,
+    market: {
+      totalSupplyAssets: BigNumberish;
+      totalSupplyShares: BigNumberish;
+    },
+    rounding: RoundingDirection = "Up"
+  ) {
+    return SharesMath.toShares(
+      assets,
+      market.totalSupplyAssets,
+      market.totalSupplyShares,
+      rounding
+    );
+  }
+
+  export function toBorrowAssets(
+    shares: BigNumberish,
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+    },
+    rounding: RoundingDirection = "Up"
+  ) {
+    return SharesMath.toAssets(
+      shares,
+      market.totalBorrowAssets,
+      market.totalBorrowShares,
+      rounding
+    );
+  }
+
+  export function toBorrowShares(
+    assets: BigNumberish,
+    market: {
+      totalBorrowAssets: BigNumberish;
+      totalBorrowShares: BigNumberish;
+    },
+    rounding: RoundingDirection = "Down"
+  ) {
+    return SharesMath.toShares(
+      assets,
+      market.totalBorrowAssets,
+      market.totalBorrowShares,
+      rounding
+    );
+  }
+}

package/src/market/index.ts

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

package/src/maths/AdaptiveCurveIrmLib.ts

@@ -0,0 +1,143 @@
+import { parseUnits } from "ethers";
+
+import { SECONDS_PER_YEAR } from "../constants";
+
+import { MathLib } from "./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.
+ */
+export namespace AdaptiveCurveIrmLib {
+  export const CURVE_STEEPNESS = parseUnits("4");
+  export const TARGET_UTILIZATION = parseUnits("0.9");
+  export const INITIAL_RATE_AT_TARGET = parseUnits("0.04") / SECONDS_PER_YEAR;
+  export const ADJUSTMENT_SPEED = parseUnits("50") / SECONDS_PER_YEAR;
+  export const MIN_RATE_AT_TARGET = parseUnits("0.001") / SECONDS_PER_YEAR;
+  export const MAX_RATE_AT_TARGET = parseUnits("2") / SECONDS_PER_YEAR;
+
+  /**
+   * ln(2), scaled by WAD.
+   */
+  export const LN_2_INT = 693147180559945309n;
+
+  /**
+   * ln(1e-18), scaled by WAD.
+   */
+  export const LN_WEI_INT = -41_446531673892822312n;
+
+  /**
+   * 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).
+   */
+  export const WEXP_UPPER_BOUND = 93_859467695000404319n;
+
+  /**
+   * The value of wExp(`WEXP_UPPER_BOUND`).
+   */
+  export const WEXP_UPPER_VALUE =
+    57716089161558943949701069502944508345128_422502756744429568n;
+
+  /**
+   * Returns an approximation of exp(x) used by the Adaptive Curve IRM.
+   * @param x
+   */
+  export function wExp(x: bigint) {
+    // If x < ln(1e-18) then exp(x) < 1e-18 so it is rounded to zero.
+    if (x < LN_WEI_INT) return 0n;
+    // `wExp` is clipped to avoid overflowing when multiplied with 1 ether.
+    if (x >= WEXP_UPPER_BOUND) return 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 ? -(LN_2_INT / 2n) : LN_2_INT / 2n;
+    const q = (x + roundingAdjustment) / LN_2_INT;
+    const r = x - q * 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;
+  }
+
+  export function getBorrowRate(
+    startUtilization: bigint,
+    startRateAtTarget: bigint,
+    elapsed: bigint
+  ) {
+    const errNormFactor =
+      startUtilization > TARGET_UTILIZATION
+        ? MathLib.WAD - TARGET_UTILIZATION
+        : TARGET_UTILIZATION;
+    const err = MathLib.wDivDown(
+      startUtilization - TARGET_UTILIZATION,
+      errNormFactor
+    );
+
+    let avgRateAtTarget;
+    let endRateAtTarget;
+
+    if (startRateAtTarget === 0n) {
+      // First interaction.
+      avgRateAtTarget = INITIAL_RATE_AT_TARGET;
+      endRateAtTarget = 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(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: bigint) =>
+          MathLib.min(
+            MathLib.max(
+              MathLib.wMulDown(startRateAtTarget, wExp(linearAdaptation)),
+              MIN_RATE_AT_TARGET
+            ),
+            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, CURVE_STEEPNESS)
+        : 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,
+    };
+  }
+}