@morpho-org/blue-sdk 1.0.0

package/src/chain/chain.test.ts

@@ -0,0 +1,51 @@
+import { entries, keys, values } from "@morpho-org/morpho-ts";
+
+import { ChainId } from "./chain.types";
+import { ChainUtils } from "./chain.utils";
+
+describe("Network", () => {
+  it("Should have all data for all networks", () => {
+    const chainIdLength = ChainUtils.getAllChainIds().length;
+    const chainMetadataLength = keys(ChainUtils.chainMetadata).length;
+
+    expect(chainIdLength).toEqual(chainMetadataLength);
+  });
+
+  it("Should have consistent chainIds", () => {
+    entries(ChainUtils.chainMetadata).forEach(([chainId, { id }]) => {
+      expect(+chainId).toEqual(id);
+    });
+  });
+
+  it("Should have Testnet in the name for testnet chains", () => {
+    Object.values(ChainUtils.chainMetadata)
+      .filter(({ isTestnet }) => isTestnet)
+      .forEach(({ name }) => {
+        expect(name).toMatch(/Testnet/);
+      });
+  });
+  it("Should convert correctly a chainId to hexChainId", () => {
+    expect(
+      ChainUtils.toHexChainId(ChainUtils.ChainId.EthGoerliTestnet)
+    ).toEqual("0x5");
+    expect(ChainUtils.toHexChainId(ChainUtils.ChainId.BaseMainnet)).toEqual(
+      "0x2105"
+    );
+  });
+
+  it("Should return all testnets", () => {
+    expect(ChainUtils.getTestnets()).toEqual(
+      values(ChainUtils.chainMetadata)
+        .filter(({ isTestnet }) => isTestnet)
+        .map(({ id }) => id)
+    );
+  });
+  it("Should return all networks", () => {
+    expect(ChainUtils.getAllChainIds()).toEqual(
+      values(ChainUtils.chainMetadata).map(({ id }) => id)
+    );
+    expect(
+      ChainUtils.getAllChainLabels().map((label) => ChainId[label])
+    ).toEqual(ChainUtils.getAllChainIds());
+  });
+});

package/src/chain/chain.types.ts

@@ -0,0 +1,42 @@
+export enum ChainId {
+  EthMainnet = 1,
+  EthGoerliTestnet = 5,
+  BaseMainnet = 8453,
+  // PolygonMainnet = 137,
+  // MumbaiTestnet = 80001,
+  // OptimismMainnet = 10,
+  // BscMainnet = 56,
+  // ArbitrumMainnet = 42161,
+  // ArbitrumTestnet = 421611,
+  // GnosisChain = 100,
+  // FantomMainnet = 250,
+  // FantomTestnet = 4002,
+  // HarmonyMainnet = 128,
+  // HarmonyTestnet = 1666600000,
+  // BscTestnet = 97,
+  // OptimismTestnet = 69,
+  // EthRopstenTestnet = 3,
+  // EthRinkebyTestnet = 4,
+  // EthKovanTestnet = 42,
+  // GnosisChainTestnet = 10200,
+  // AvalancheMainnet = 43114,
+  // AvalancheFujiTestnet = 43113,
+  // MoonbaseAlphaTestnet = 1287,
+  // BaseGoerliTestnet = 84531,
+}
+
+export interface ChainMetadata {
+  readonly name: string;
+  readonly id: ChainId;
+  readonly defaultRpcUrl: string;
+  readonly explorerUrl: string;
+  readonly nativeCurrency: {
+    readonly name: string;
+    readonly symbol: string;
+    readonly decimals: number;
+  };
+  readonly isTestnet: boolean;
+  readonly shortName: string;
+  readonly identifier: string;
+  readonly logoSrc: string;
+}

package/src/chain/chain.utils.ts

@@ -0,0 +1,44 @@
+import { values } from "@morpho-org/morpho-ts";
+
+import { UnsupportedChainIdError } from "../errors";
+
+import { BLUE_AVAILABLE_CHAINS, CHAIN_METADATA } from "./chain.constants";
+import {
+  ChainId as _ChainId,
+  ChainMetadata as _ChainMetadata,
+} from "./chain.types";
+
+export namespace ChainUtils {
+  export const blueAvailableChains = BLUE_AVAILABLE_CHAINS;
+  export const chainMetadata = CHAIN_METADATA;
+
+  export interface ChainMetadata extends _ChainMetadata {}
+  export import ChainId = _ChainId;
+
+  export const toHexChainId = (chainId: ChainId) => {
+    return `0x${chainId.toString(16)}`;
+  };
+
+  export const getAllChainIds = () =>
+    values(ChainId).filter((value) => typeof value === "number");
+
+  export const getAllChainLabels = () =>
+    Object.values(ChainId).filter(
+      (value) => typeof value === "string"
+    ) as (keyof typeof ChainId)[];
+
+  export const getTestnets = () =>
+    getAllChainIds().filter((chainId) => CHAIN_METADATA[chainId].isTestnet);
+
+  export function isSupported(chainId: number): chainId is ChainId {
+    return blueAvailableChains.includes(chainId as ChainId);
+  }
+
+  export function parseSupportedChainId(candidate: any): ChainId {
+    const chainId = parseInt(candidate);
+
+    if (!isSupported(chainId)) throw new UnsupportedChainIdError(candidate);
+
+    return chainId;
+  }
+}

package/src/chain/index.ts

@@ -0,0 +1,2 @@
+export * from "./chain.utils";
+export * from "./chain.types";

package/src/constants.ts

@@ -0,0 +1,18 @@
+import { parseUnits, parseEther } from "ethers";
+
+import { Time } from "@morpho-org/morpho-ts";
+
+export const LIQUIDATION_CURSOR = parseEther("0.3");
+
+export const MAX_LIQUIDATION_INCENTIVE_FACTOR = parseEther("1.15");
+
+export const ORACLE_PRICE_OFFSET = 36;
+export const ORACLE_PRICE_SCALE = parseUnits("1", ORACLE_PRICE_OFFSET);
+
+export const MAX_FEE = parseEther("0.25"); // 25%
+
+export const DEFAULT_SLIPPAGE_TOLERANCE = parseEther("0.0003"); // 0.03%
+
+export const DEFAULT_TARGET_UTILIZATION = parseEther("0.92"); // 92%
+
+export const SECONDS_PER_YEAR = Time.s.from.y(1n);

package/src/errors.ts

@@ -0,0 +1,75 @@
+import { Address, MarketId } from "./types";
+
+export class UnknownDataError extends Error {}
+
+export class UnknownTokenError extends UnknownDataError {
+  constructor(public readonly address: Address) {
+    super(`unknown token ${address}`);
+  }
+}
+
+export class UnknownTokenPriceError extends UnknownDataError {
+  constructor(public readonly address: Address) {
+    super(`unknown price of token ${address}`);
+  }
+}
+
+export class UnknownMarketConfigError extends UnknownDataError {
+  constructor(public readonly marketId: MarketId) {
+    super(`unknown config for market ${marketId}`);
+  }
+}
+
+export class UnknownVaultConfigError extends UnknownDataError {
+  constructor(public readonly vault: Address) {
+    super(`unknown config for vault ${vault}`);
+  }
+}
+
+export class UnsupportedChainIdError extends Error {
+  constructor(public readonly chainId: number) {
+    super(`unsupported chain ${chainId}`);
+  }
+}
+
+export class InvalidInterestAccrualError extends UnknownDataError {
+  constructor(
+    public readonly marketId: MarketId,
+    public readonly timestamp: bigint,
+    public readonly lastUpdate: bigint
+  ) {
+    super(
+      `invalid interest accrual on market ${marketId}: accrual timestamp ${timestamp} can't be prior to last update ${lastUpdate}`
+    );
+  }
+}
+
+export class InvalidSignatureError extends Error {
+  constructor(
+    public readonly hash: string,
+    public readonly signer: Address,
+    public readonly recovered: Address
+  ) {
+    super(
+      `invalid signature for hash ${hash}: expected ${signer}, recovered ${recovered}`
+    );
+  }
+}
+
+export type ErrorClass = new (...args: any[]) => Error;
+export function _try<T>(
+  accessor: () => T,
+  ...errorClasses: ErrorClass[]
+): T | undefined {
+  try {
+    return accessor();
+  } catch (error) {
+    if (
+      errorClasses.length === 0 ||
+      errorClasses.some((errorClass) => error instanceof errorClass)
+    )
+      return;
+
+    throw error;
+  }
+}

package/src/ethers/ethers.test.ts

@@ -0,0 +1,17 @@
+import { safeParseNumber } from "./safeParseUnits";
+
+describe("safeParseNumber", () => {
+  it("should parse excessively small number", () => {
+    expect(safeParseNumber(0.000000000000000000000000000000042, 18)).toEqual(
+      0n
+    );
+  });
+
+  it("should parse excessively large number", () => {
+    expect(
+      safeParseNumber(4200000000000000000000000000000000000, 18).toString()
+    ).toEqual(
+      4200000000000000000000000000000000000000000000000000000n.toString()
+    );
+  });
+});

package/src/ethers/index.ts

@@ -0,0 +1,2 @@
+export * from "./safeGetAddress";
+export * from "./safeParseUnits";

package/src/ethers/safeGetAddress.ts

@@ -0,0 +1,4 @@
+import { getAddress } from "ethers";
+
+export const safeGetAddress = (address: string) =>
+  getAddress(address.toLowerCase());

package/src/ethers/safeParseUnits.ts

@@ -0,0 +1,29 @@
+import { parseUnits } from "ethers";
+
+export const safeParseUnits = (strValue: string, decimals = 18) => {
+  if (!/[-+]?[0-9]*\.?[0-9]+/.test(strValue))
+    throw new Error("invalid number: " + strValue);
+
+  let [whole, dec = ""] = strValue.split(".");
+
+  dec = dec.slice(0, decimals);
+
+  return parseUnits(
+    [whole || "0", dec].filter((v) => v.length > 0).join("."),
+    decimals
+  );
+};
+
+// Alternative to Number.toFixed that doesn't use scientific notation for excessively small or large numbers
+function toFixed(x: number, decimals: number) {
+  return new Intl.NumberFormat("en-US", {
+    style: "decimal",
+    useGrouping: false,
+    maximumFractionDigits: decimals,
+    minimumFractionDigits: decimals,
+  }).format(x);
+}
+
+export function safeParseNumber(value: number, decimals = 18) {
+  return safeParseUnits(toFixed(value, decimals), decimals);
+}

package/src/evm.ts

@@ -0,0 +1,172 @@
+import {
+  TransactionRequest,
+  Signer,
+  parseUnits,
+  TransactionResponse,
+} from "ethers";
+
+import { ChainId } from "./chain";
+import { MathLib } from "./maths";
+import {
+  NotificationProducer,
+  NotificationStatus,
+  NotificationTopic,
+} from "./notifications";
+import { SignatureUtils } from "./signatures";
+import { SignatureMessage } from "./signatures/types";
+
+export interface NotificationOptions<Topic extends NotificationTopic> {
+  producer: NotificationProducer<Topic>;
+  id: string;
+  args: Record<PropertyKey, any>;
+}
+
+/**
+ * Sends a transaction via the provided signer, optionnally waiting for the corresponding transaction receipt.
+ * @param signer The signer to send the tx with.
+ * @param tx The transaction request.
+ * @param wait Whether to wait for the transaction receipt. Defaults to true.
+ * @param notificationOptions The optional notification options. Warning: if `wait` is set to true, the provided topic will never complete.
+ */
+export const sendTransactionWithProducer = async (
+  signer: Signer,
+  req: TransactionRequest,
+  defaultGasLimit?: bigint,
+  confirms = 1,
+  notificationOptions?: NotificationOptions<NotificationTopic.tx>
+) => {
+  let response: TransactionResponse | undefined;
+
+  try {
+    let gasLimit: bigint;
+    try {
+      gasLimit = MathLib.wMulUp(
+        await signer.estimateGas(req),
+        parseUnits("1.1")
+      );
+    } catch (error: any) {
+      if (defaultGasLimit == null) throw error;
+
+      gasLimit = defaultGasLimit;
+    }
+
+    const tx = { ...req, gasLimit };
+
+    notificationOptions?.producer.next({
+      id: notificationOptions.id,
+      status: NotificationStatus.signing,
+      context: { tx },
+    });
+
+    response = await signer.sendTransaction(tx);
+
+    notificationOptions?.producer.next({
+      id: notificationOptions.id,
+      status: NotificationStatus.pending,
+      context: { args: notificationOptions.args, tx, response },
+    });
+
+    const receipt = await response.wait(confirms);
+
+    notificationOptions?.producer.next({
+      id: notificationOptions.id,
+      status: NotificationStatus.success,
+      context: { args: notificationOptions.args, tx, response, receipt },
+    });
+  } catch (error: any) {
+    notificationOptions?.producer.next({
+      id: notificationOptions.id,
+      status: NotificationStatus.error,
+      context: { args: notificationOptions.args, tx: req, response, error },
+    });
+  }
+};
+
+/**
+ * Sends a transaction via the provided signer, optionnally waiting for the corresponding transaction receipt.
+ * @param signer The signer to send the tx with.
+ * @param tx The transaction request.
+ * @param wait Whether to wait for the transaction receipt. Defaults to true.
+ * @param topic The type of notifications to emit.
+ * @param args The optional notification arguments.
+ * @return The notification consumer which receives the transaction notifications.
+ */
+export const sendTransaction = (
+  signer: Signer,
+  tx: TransactionRequest,
+  defaultGasLimit?: bigint,
+  confirms?: number,
+  args: Record<PropertyKey, any> = {}
+) => {
+  const producer = new NotificationProducer(NotificationTopic.tx);
+
+  sendTransactionWithProducer(signer, tx, defaultGasLimit, confirms, {
+    producer,
+    id: Date.now().toString(),
+    args,
+  });
+
+  return producer.consumer;
+};
+
+export const signMessageWithProducer = async (
+  signer: Signer,
+  message: SignatureMessage,
+  notificationOptions?: NotificationOptions<NotificationTopic.signature>
+) => {
+  notificationOptions?.producer.next({
+    id: notificationOptions.id,
+    status: NotificationStatus.signing,
+  });
+
+  try {
+    const signature = await SignatureUtils.safeSignTypedData(
+      signer,
+      message.data.domain,
+      message.data.types,
+      message.data.value
+    );
+
+    SignatureUtils.verifySignature(
+      signature,
+      message.hash,
+      await signer.getAddress()
+    );
+
+    notificationOptions?.producer.next({
+      id: notificationOptions.id,
+      status: NotificationStatus.success,
+      context: { message, args: notificationOptions.args, signature },
+    });
+  } catch (error: any) {
+    notificationOptions?.producer.next({
+      id: notificationOptions.id,
+      status: NotificationStatus.error,
+      context: { message, args: notificationOptions.args, error },
+    });
+  }
+};
+
+/**
+ * Sends a signature request to the provided signer.
+ * @param signer The signer to send the approval with.
+ * @param args The approval parameters.
+ * @param encodeMessage The approval encoder to pass the approval parameters to get the approval transactions.
+ * @return The notification consumer which receives the transaction notifications.
+ */
+export const signMessage = <T extends object>(
+  signer: Signer,
+  args: T,
+  encodeMessage: (args: T, chainId: ChainId) => SignatureMessage,
+  chainId: ChainId
+) => {
+  const producer = new NotificationProducer(NotificationTopic.signature);
+
+  signMessageWithProducer(signer, encodeMessage(args, chainId), {
+    producer,
+    id: Date.now().toString(),
+    args,
+  });
+
+  return producer.consumer;
+};