@morpho-org/blue-sdk 1.0.1 → 1.0.2

package/src/market/Market.ts

@@ -0,0 +1,479 @@
+import { BigNumberish, Provider, ZeroAddress, toBigInt } from "ethers";
+import {
+  AdaptiveCurveIrm__factory,
+  BlueOracle__factory,
+  MorphoBlue__factory,
+} from "ethers-types";
+import { ViewOverrides } from "ethers-types/dist/common";
+
+import { getChainAddresses } from "../addresses";
+import { ChainId, ChainUtils } from "../chain";
+import { InvalidInterestAccrualError } from "../errors";
+import { AdaptiveCurveIrmLib, RoundingDirection } from "../maths";
+import { MarketId } from "../types";
+
+import { MarketConfig } from "./MarketConfig";
+import { MarketUtils } from "./MarketUtils";
+
+export enum CapacityLimitReason {
+  liquidity = "Liquidity",
+  balance = "Balance",
+  position = "Position",
+  collateral = "Collateral",
+  cap = "Cap",
+}
+
+export interface CapacityLimit {
+  value: bigint;
+  limiter: CapacityLimitReason;
+}
+
+export interface MaxPositionCapacities {
+  supply: CapacityLimit;
+  withdraw: CapacityLimit;
+  borrow: CapacityLimit;
+  repay: CapacityLimit;
+  supplyCollateral: CapacityLimit;
+  withdrawCollateral: CapacityLimit;
+}
+
+export interface InputMarket {
+  config: MarketConfig;
+  totalSupplyAssets: BigNumberish;
+  totalBorrowAssets: BigNumberish;
+  totalSupplyShares: BigNumberish;
+  totalBorrowShares: BigNumberish;
+  lastUpdate: BigNumberish;
+  fee: BigNumberish;
+  price: BigNumberish;
+  rateAtTarget?: BigNumberish;
+}
+
+export class Market implements InputMarket {
+  static async fetchFromId(
+    id: MarketId,
+    runner: { provider: Provider },
+    {
+      chainId,
+      overrides = {},
+    }: { chainId?: ChainId; overrides?: ViewOverrides } = {}
+  ) {
+    chainId ??= ChainUtils.parseSupportedChainId(
+      (await runner.provider.getNetwork()).chainId
+    );
+    const config = await MarketConfig.fetch(id, runner, chainId);
+
+    return Market.fetchFromConfig(config, runner, { chainId, overrides });
+  }
+
+  static async fetchFromConfig(
+    config: MarketConfig,
+    runner: { provider: Provider },
+    {
+      chainId,
+      overrides = {},
+    }: { chainId?: ChainId; overrides?: ViewOverrides } = {}
+  ) {
+    chainId ??= ChainUtils.parseSupportedChainId(
+      (await runner.provider.getNetwork()).chainId
+    );
+    const { morpho, adaptiveCurveIrm } = getChainAddresses(chainId);
+
+    const [
+      {
+        totalSupplyAssets,
+        totalSupplyShares,
+        totalBorrowShares,
+        totalBorrowAssets,
+        lastUpdate,
+        fee,
+      },
+      price,
+      rateAtTarget,
+    ] = await Promise.all([
+      MorphoBlue__factory.connect(morpho, runner).market(config.id, overrides),
+      config.oracle !== ZeroAddress
+        ? BlueOracle__factory.connect(config.oracle, runner).price(overrides)
+        : 0n,
+      config.irm === adaptiveCurveIrm
+        ? await AdaptiveCurveIrm__factory.connect(
+            config.irm,
+            runner
+          ).rateAtTarget(config.id, overrides)
+        : undefined,
+    ]);
+
+    return new Market({
+      config,
+      totalSupplyAssets,
+      totalBorrowAssets,
+      totalSupplyShares,
+      totalBorrowShares,
+      lastUpdate,
+      fee,
+      price,
+      rateAtTarget,
+    });
+  }
+
+  /**
+   * The market's config.
+   */
+  public readonly config: MarketConfig;
+
+  /**
+   * The amount of loan assets supplied in total on the market.
+   */
+  public totalSupplyAssets: bigint;
+  /**
+   * The amount of loan assets supplied in total on the market.
+   */
+  public totalBorrowAssets: bigint;
+  /**
+   * The amount of loan assets supplied in total on the market.
+   */
+  public totalSupplyShares: bigint;
+  /**
+   * The amount of loan assets supplied in total on the market.
+   */
+  public totalBorrowShares: bigint;
+
+  /**
+   * The block timestamp (in __seconds__) when the interest was last accrued.
+   */
+  public lastUpdate: bigint;
+  /**
+   * The fee percentage of the market, scaled by WAD.
+   */
+  public fee: bigint;
+
+  /**
+   * The price as returned by the market's oracle.
+   */
+  public price: bigint;
+
+  /**
+   * If the market uses the Adaptive Curve IRM, the rate at target utilization.
+   * Undefined otherwise.
+   */
+  public rateAtTarget?: bigint;
+
+  constructor({
+    config,
+    totalSupplyAssets,
+    totalBorrowAssets,
+    totalSupplyShares,
+    totalBorrowShares,
+    lastUpdate,
+    fee,
+    price,
+    rateAtTarget,
+  }: InputMarket) {
+    this.config = config;
+    this.totalSupplyAssets = toBigInt(totalSupplyAssets);
+    this.totalBorrowAssets = toBigInt(totalBorrowAssets);
+    this.totalSupplyShares = toBigInt(totalSupplyShares);
+    this.totalBorrowShares = toBigInt(totalBorrowShares);
+    this.lastUpdate = toBigInt(lastUpdate);
+    this.fee = toBigInt(fee);
+    this.price = toBigInt(price);
+
+    if (rateAtTarget != null) this.rateAtTarget = toBigInt(rateAtTarget);
+  }
+
+  get id() {
+    return this.config.id;
+  }
+
+  get isIdle() {
+    return this.config.collateralToken === ZeroAddress;
+  }
+
+  /**
+   * @warning Cannot be used to calculate the liquidity available inside a callback,
+   * because the balance of Blue may be lower than the market's liquidity due to assets being transferred out prior to the callback.
+   */
+  get liquidity() {
+    return this.totalSupplyAssets - this.totalBorrowAssets;
+  }
+
+  get utilization() {
+    return MarketUtils.getUtilization(this);
+  }
+
+  get apyAtTarget() {
+    if (this.rateAtTarget == null) return;
+
+    return MarketUtils.getApy(this.rateAtTarget);
+  }
+
+  get supplyRate() {
+    return MarketUtils.getSupplyRate(this.borrowRate, this);
+  }
+
+  get borrowRate() {
+    if (this.rateAtTarget == null) return 0n;
+
+    return AdaptiveCurveIrmLib.getBorrowRate(
+      this.utilization,
+      this.rateAtTarget,
+      0n
+    ).avgBorrowRate;
+  }
+
+  get supplyApy() {
+    return MarketUtils.getApy(this.supplyRate);
+  }
+
+  get borrowApy() {
+    return MarketUtils.getApy(this.borrowRate);
+  }
+
+  public accrueInterest(timestamp: BigNumberish) {
+    timestamp = toBigInt(timestamp);
+
+    const elapsed = timestamp - this.lastUpdate;
+    if (elapsed < 0n)
+      throw new InvalidInterestAccrualError(
+        this.id,
+        timestamp,
+        this.lastUpdate
+      );
+
+    let borrowRate = 0n;
+    let { rateAtTarget } = this;
+    if (this.rateAtTarget != null) {
+      const { avgBorrowRate, endRateAtTarget } =
+        AdaptiveCurveIrmLib.getBorrowRate(
+          this.utilization,
+          this.rateAtTarget,
+          elapsed
+        );
+
+      borrowRate = avgBorrowRate;
+      rateAtTarget = endRateAtTarget;
+    }
+
+    const { interest, feeShares } = MarketUtils.getAccruedInterest(
+      borrowRate,
+      this,
+      elapsed
+    );
+
+    return new Market({
+      ...this,
+      totalSupplyAssets: this.totalSupplyAssets + interest,
+      totalBorrowAssets: this.totalBorrowAssets + interest,
+      totalSupplyShares: this.totalSupplyShares + feeShares,
+      lastUpdate: timestamp,
+      rateAtTarget,
+    });
+  }
+
+  public getLiquidityToUtilization(utilization: BigNumberish) {
+    return MarketUtils.getLiquidityToUtilization(this, utilization);
+  }
+
+  public getCollateralValue(collateral: BigNumberish) {
+    return MarketUtils.getCollateralValue(collateral, this);
+  }
+
+  public getMaxBorrowAssets(collateral: BigNumberish) {
+    return MarketUtils.getMaxBorrowAssets(collateral, this, this.config);
+  }
+
+  public getMaxBorrowableAssets(position: {
+    collateral: BigNumberish;
+    borrowShares: BigNumberish;
+  }) {
+    return MarketUtils.getMaxBorrowableAssets(position, this, this.config);
+  }
+
+  public getLiquidationSeizedAssets(repaidShares: BigNumberish) {
+    return MarketUtils.getLiquidationSeizedAssets(
+      repaidShares,
+      this,
+      this.config
+    );
+  }
+
+  public getLiquidationRepaidShares(seizedAssets: BigNumberish) {
+    return MarketUtils.getLiquidationRepaidShares(
+      seizedAssets,
+      this,
+      this.config
+    );
+  }
+
+  public getSeizableCollateral(position: {
+    collateral: BigNumberish;
+    borrowShares: BigNumberish;
+  }) {
+    return MarketUtils.getSeizableCollateral(position, this, this.config);
+  }
+
+  public getWithdrawableCollateral(position: {
+    collateral: BigNumberish;
+    borrowShares: BigNumberish;
+  }) {
+    return MarketUtils.getWithdrawableCollateral(position, this, this.config);
+  }
+
+  public isHealthy(position: {
+    collateral: BigNumberish;
+    borrowShares: BigNumberish;
+  }) {
+    return MarketUtils.isHealthy(position, this, this.config);
+  }
+
+  public getLiquidationPrice(position: {
+    collateral: BigNumberish;
+    borrowShares: BigNumberish;
+  }) {
+    return MarketUtils.getLiquidationPrice(position, this, this.config);
+  }
+
+  public getPriceVariationToLiquidation(position: {
+    collateral: BigNumberish;
+    borrowShares: BigNumberish;
+  }) {
+    return MarketUtils.getPriceVariationToLiquidation(
+      position,
+      this,
+      this.config
+    );
+  }
+
+  public getHealthFactor(position: {
+    collateral: BigNumberish;
+    borrowShares: BigNumberish;
+  }) {
+    return MarketUtils.getHealthFactor(position, this, this.config);
+  }
+
+  public getLtv(position: {
+    collateral: BigNumberish;
+    borrowShares: BigNumberish;
+  }) {
+    return MarketUtils.getLtv(position, this);
+  }
+
+  public getBorrowCapacityUsage(position: {
+    collateral: BigNumberish;
+    borrowShares: BigNumberish;
+  }) {
+    return MarketUtils.getBorrowCapacityUsage(position, this, this.config);
+  }
+
+  public toSupplyAssets(shares: BigNumberish, rounding?: RoundingDirection) {
+    return MarketUtils.toSupplyAssets(shares, this, rounding);
+  }
+
+  public toSupplyShares(assets: BigNumberish, rounding?: RoundingDirection) {
+    return MarketUtils.toSupplyShares(assets, this, rounding);
+  }
+
+  public toBorrowAssets(shares: BigNumberish, rounding?: RoundingDirection) {
+    return MarketUtils.toBorrowAssets(shares, this, rounding);
+  }
+
+  public toBorrowShares(assets: BigNumberish, rounding?: RoundingDirection) {
+    return MarketUtils.toBorrowShares(assets, this, rounding);
+  }
+
+  public getBorrowCapacityLimit(collateral: bigint): CapacityLimit {
+    const maxBorrowableAssets = this.getMaxBorrowAssets(collateral);
+    const { liquidity } = this;
+
+    if (maxBorrowableAssets > liquidity)
+      return {
+        value: liquidity,
+        limiter: CapacityLimitReason.liquidity,
+      };
+
+    return {
+      value: maxBorrowableAssets,
+      limiter: CapacityLimitReason.collateral,
+    };
+  }
+
+  public getRepayCapacityLimit(
+    borrowShares: bigint,
+    loanTokenBalance: bigint
+  ): CapacityLimit {
+    const borrowAssets = this.toBorrowAssets(borrowShares);
+
+    if (borrowAssets > loanTokenBalance)
+      return {
+        value: loanTokenBalance,
+        limiter: CapacityLimitReason.balance,
+      };
+
+    return {
+      value: borrowAssets,
+      limiter: CapacityLimitReason.position,
+    };
+  }
+
+  public getWithdrawCapacityLimit(supplyShares: bigint): CapacityLimit {
+    const supplyAssets = this.toSupplyAssets(supplyShares);
+    const { liquidity } = this;
+
+    if (supplyAssets > liquidity)
+      return {
+        value: liquidity,
+        limiter: CapacityLimitReason.liquidity,
+      };
+
+    return {
+      value: supplyAssets,
+      limiter: CapacityLimitReason.position,
+    };
+  }
+
+  public getWithdrawCollateralCapacityLimit(position: {
+    collateral: bigint;
+    borrowShares: bigint;
+  }): CapacityLimit {
+    const withdrawableCollateral = this.getWithdrawableCollateral(position);
+
+    if (position.collateral > withdrawableCollateral)
+      return {
+        value: withdrawableCollateral,
+        limiter: CapacityLimitReason.collateral,
+      };
+
+    return {
+      value: position.collateral,
+      limiter: CapacityLimitReason.position,
+    };
+  }
+
+  public getMaxCapacities(
+    position: {
+      collateral: bigint;
+      supplyShares: bigint;
+      borrowShares: bigint;
+    },
+    loanTokenBalance: bigint,
+    collateralTokenBalance: bigint
+  ): MaxPositionCapacities {
+    return {
+      supply: {
+        value: loanTokenBalance,
+        limiter: CapacityLimitReason.balance,
+      },
+      withdraw: this.getWithdrawCapacityLimit(position.supplyShares),
+      borrow: this.getBorrowCapacityLimit(position.collateral),
+      repay: this.getRepayCapacityLimit(
+        position.borrowShares,
+        loanTokenBalance
+      ),
+      supplyCollateral: {
+        value: collateralTokenBalance,
+        limiter: CapacityLimitReason.balance,
+      },
+      withdrawCollateral: this.getWithdrawCollateralCapacityLimit(position),
+    };
+  }
+}

package/src/market/MarketConfig.ts

@@ -0,0 +1,108 @@
+import { Provider, ZeroAddress, toBigInt } from "ethers";
+import { MorphoBlue__factory } from "ethers-types";
+import { MarketParamsStruct } from "ethers-types/dist/protocols/morpho/blue/MorphoBlue";
+
+import { getChainAddresses } from "../addresses";
+import { ChainId, ChainUtils } from "../chain";
+import { UnknownMarketConfigError, _try } from "../errors";
+import { Address, MarketId } from "../types";
+
+import { MarketUtils } from "./MarketUtils";
+
+export interface MarketParams extends MarketParamsStruct {
+  loanToken: Address;
+  collateralToken: Address;
+  oracle: Address;
+  irm: Address;
+}
+
+export class MarketConfig implements MarketParams {
+  private static readonly _CACHE: Record<MarketId, MarketConfig> = {};
+
+  static get(id: MarketId) {
+    const marketConfig = MarketConfig._CACHE[id];
+
+    if (!marketConfig) throw new UnknownMarketConfigError(id);
+
+    return marketConfig;
+  }
+
+  static async fetch(
+    id: MarketId,
+    runner: { provider: Provider },
+    chainId?: ChainId
+  ) {
+    let config = _try(() => MarketConfig.get(id), UnknownMarketConfigError);
+
+    if (!config) {
+      chainId ??= ChainUtils.parseSupportedChainId(
+        (await runner.provider.getNetwork()).chainId
+      );
+
+      const { morpho } = getChainAddresses(chainId);
+
+      config = new MarketConfig(
+        // Always fetch at latest block because config is immutable.
+        await MorphoBlue__factory.connect(morpho, runner).idToMarketParams(id)
+      );
+    }
+
+    return config;
+  }
+
+  static idle(token: Address) {
+    return new MarketConfig({
+      collateralToken: ZeroAddress,
+      loanToken: token,
+      oracle: ZeroAddress,
+      irm: ZeroAddress,
+      lltv: 0n,
+    });
+  }
+
+  /**
+   * The market's collateral token address.
+   */
+  public readonly collateralToken: Address;
+
+  /**
+   * The market's loan token address.
+   */
+  public readonly loanToken: Address;
+
+  /**
+   * The market's oracle address.
+   */
+  public readonly oracle: Address;
+
+  /**
+   * The market's interest rate model address.
+   */
+  public readonly irm: Address;
+
+  /**
+   * The market's liquidation Loan-To-Value (scaled by WAD).
+   */
+  public readonly lltv: bigint;
+
+  constructor({ collateralToken, loanToken, oracle, irm, lltv }: MarketParams) {
+    this.collateralToken = collateralToken;
+    this.loanToken = loanToken;
+    this.oracle = oracle;
+    this.irm = irm;
+    this.lltv = 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.getMarketId(this);
+  }
+
+  get liquidationIncentiveFactor() {
+    return MarketUtils.getLiquidationIncentiveFactor(this);
+  }
+}

package/src/market/MarketUtils.test.ts

@@ -0,0 +1,25 @@
+import { parseEther } from "ethers";
+
+import { MarketUtils } from "./MarketUtils";
+
+const market = {
+  loanToken: "0x0000000000000000000000000000000000000001",
+  collateralToken: "0x0000000000000000000000000000000000000002",
+  oracle: "0x0000000000000000000000000000000000000003",
+  irm: "0x0000000000000000000000000000000000000004",
+  lltv: parseEther("0.86"),
+};
+
+describe("MarketUtils", () => {
+  it("should calculate the correct market id", () => {
+    expect(MarketUtils.getMarketId(market)).toEqual(
+      "0x625e29dff74826b71c1f4c74b208a896109cc8ac9910192ce2927a982b0809e6"
+    );
+  });
+
+  it("should calculate the correct liquidation incentive factor", () => {
+    expect(MarketUtils.getLiquidationIncentiveFactor(market)).toEqual(
+      1043841336116910229n
+    );
+  });
+});