@morpho-org/blue-sdk 1.0.3 → 1.0.4

package/src/chain/chain.utils.ts

@@ -1,44 +0,0 @@
-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/constants.ts

@@ -1,18 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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/safeGetAddress.ts

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

package/src/ethers/safeParseUnits.ts

@@ -1,29 +0,0 @@
-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

@@ -1,172 +0,0 @@
-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;
-};

package/src/helpers/format/format.test.ts

@@ -1,340 +0,0 @@
-import { format } from "./format";
-
-describe("format", () => {
-  const number = 12345.6789;
-  const bigint = 123456789n;
-  const decimals = 4;
-
-  describe("hex", () => {
-    describe("should properly format number in hex format", () => {
-      it("without option", () => {
-        expect(format.hex.of(number)).toEqual((123456789).toString(16));
-      });
-    });
-    describe("should properly format bigint in hex format", () => {
-      it("without option", () => {
-        expect(format.hex.of(bigint, decimals)).toEqual(
-          (123456789).toString(16)
-        );
-      });
-    });
-  });
-
-  describe("number", () => {
-    describe("should properly format number in number format", () => {
-      it("without option", () => {
-        expect(format.number.of(number)).toEqual("12345.6789");
-      });
-      it("with digits", () => {
-        expect(format.number.digits(2).of(number)).toEqual("12345.67");
-      });
-      it("with min", () => {
-        expect(format.number.min(20000).of(number)).toEqual("< 20000.0000");
-      });
-      it("with max", () => {
-        expect(format.number.max(10000).of(number)).toEqual("> 10000.0000");
-      });
-      it("with sign", () => {
-        expect(format.number.sign().of(number)).toEqual("+12345.6789");
-      });
-      it("with unit", () => {
-        expect(format.number.unit("$").of(number)).toEqual("$12345.6789");
-      });
-      it("without trailing zeros", () => {
-        expect(format.number.digits(6).of(number)).toEqual("12345.678900");
-        expect(format.number.digits(6).removeTrailingZero().of(number)).toEqual(
-          "12345.6789"
-        );
-      });
-      it("with locale", () => {
-        expect(format.number.locale("fr-FR").of(number)).toEqual("12345,6789");
-      });
-    });
-    describe("should properly format bigint in number format", () => {
-      it("without option", () => {
-        expect(format.number.of(bigint, decimals)).toEqual("12345.6789");
-      });
-      it("with digits", () => {
-        expect(format.number.digits(2).of(bigint, decimals)).toEqual(
-          "12345.67"
-        );
-      });
-      it("with min", () => {
-        expect(format.number.min(20000).of(bigint, decimals)).toEqual(
-          "< 20000.0000"
-        );
-      });
-      it("with max", () => {
-        expect(format.number.max(10000).of(bigint, decimals)).toEqual(
-          "> 10000.0000"
-        );
-      });
-      it("with sign", () => {
-        expect(format.number.sign().of(bigint, decimals)).toEqual(
-          "+12345.6789"
-        );
-      });
-      it("with unit", () => {
-        expect(format.number.unit("$").of(bigint, decimals)).toEqual(
-          "$12345.6789"
-        );
-      });
-      it("without trailing zeros", () => {
-        expect(format.number.digits(6).of(bigint, decimals)).toEqual(
-          "12345.678900"
-        );
-        expect(
-          format.number.digits(6).removeTrailingZero().of(bigint, decimals)
-        ).toEqual("12345.6789");
-      });
-      it("with locale", () => {
-        expect(format.number.locale("fr-FR").of(bigint, decimals)).toEqual(
-          "12345,6789"
-        );
-      });
-    });
-  });
-
-  describe("short", () => {
-    describe("should properly format number in short format", () => {
-      it("without option", () => {
-        expect(format.short.of(number)).toEqual("12.3456789k");
-      });
-      it("with digits", () => {
-        expect(format.short.digits(2).of(number)).toEqual("12.34k");
-      });
-      it("with min", () => {
-        expect(format.short.min(20000).of(number)).toEqual("< 20.0000000k");
-      });
-      it("with max", () => {
-        expect(format.short.max(10000).of(number)).toEqual("> 10.0000000k");
-      });
-      it("with sign", () => {
-        expect(format.short.sign().of(number)).toEqual("+12.3456789k");
-      });
-      it("with unit", () => {
-        expect(format.short.unit("€").of(number)).toEqual("12.3456789k €");
-      });
-      it("without trailing zeros", () => {
-        expect(format.short.digits(8).of(number)).toEqual("12.34567890k");
-        expect(format.short.digits(8).removeTrailingZero().of(number)).toEqual(
-          "12.3456789k"
-        );
-      });
-      it("with small numbers with commas", () => {
-        expect(format.short.smallValuesWithCommas().of(number / 10)).toEqual(
-          "1,234.56789"
-        );
-      });
-      it("with locale", () => {
-        expect(format.short.locale("fr-FR").of(number)).toEqual("12,3456789k");
-      });
-    });
-    describe("should properly format bigint in short format", () => {
-      it("without option", () => {
-        expect(format.short.of(bigint, decimals)).toEqual("12.3456789k");
-      });
-      it("with digits", () => {
-        expect(format.short.digits(2).of(bigint, decimals)).toEqual("12.34k");
-      });
-      it("with min", () => {
-        expect(format.short.min(20000).of(bigint, decimals)).toEqual(
-          "< 20.0000000k"
-        );
-      });
-      it("with max", () => {
-        expect(format.short.max(10000).of(bigint, decimals)).toEqual(
-          "> 10.0000000k"
-        );
-      });
-      it("with sign", () => {
-        expect(format.short.sign().of(bigint, decimals)).toEqual(
-          "+12.3456789k"
-        );
-      });
-      it("with unit", () => {
-        expect(format.short.unit("€").of(bigint, decimals)).toEqual(
-          "12.3456789k €"
-        );
-      });
-      it("without trailing zeros", () => {
-        expect(format.short.digits(8).of(bigint, decimals)).toEqual(
-          "12.34567890k"
-        );
-        expect(
-          format.short.digits(8).removeTrailingZero().of(bigint, decimals)
-        ).toEqual("12.3456789k");
-      });
-      it("with locale", () => {
-        expect(format.short.locale("fr-FR").of(bigint, decimals)).toEqual(
-          "12,3456789k"
-        );
-      });
-      it("with small numbers with commas", () => {
-        expect(
-          format.short.smallValuesWithCommas().of(bigint, decimals + 1)
-        ).toEqual("1,234.56789");
-      });
-      it("with small numbers with commas with locale", () => {
-        expect(
-          format.short
-            .smallValuesWithCommas()
-            .locale("fr-FR")
-            .of(bigint, decimals + 1)
-          // the correct space in fr-FR is narrow no-break space (U+202F)
-        ).toEqual("1\u202F234,56789");
-      });
-    });
-  });
-
-  describe("commas", () => {
-    describe("should properly format number in commas format", () => {
-      it("without option", () => {
-        expect(format.commas.of(number)).toEqual("12,345.6789");
-      });
-      it("with digits", () => {
-        expect(format.commas.digits(2).of(number)).toEqual("12,345.67");
-      });
-      it("with min", () => {
-        expect(format.commas.min(20000).of(number)).toEqual("< 20,000.0000");
-      });
-      it("with max", () => {
-        expect(format.commas.max(10000).of(number)).toEqual("> 10,000.0000");
-      });
-      it("with sign", () => {
-        expect(format.commas.sign().of(number)).toEqual("+12,345.6789");
-      });
-      it("with unit", () => {
-        expect(format.commas.unit("ETH").of(number)).toEqual("12,345.6789 ETH");
-      });
-      it("without trailing zeros", () => {
-        expect(format.commas.digits(6).of(number)).toEqual("12,345.678900");
-        expect(format.commas.digits(6).removeTrailingZero().of(number)).toEqual(
-          "12,345.6789"
-        );
-      });
-      it("with locale", () => {
-        expect(format.commas.locale("fr-FR").of(number)).toEqual(
-          "12\u202F345,6789"
-        );
-      });
-    });
-    describe("should properly format bigint in commas format", () => {
-      it("without option", () => {
-        expect(format.commas.of(bigint, decimals)).toEqual("12,345.6789");
-      });
-      it("with digits", () => {
-        expect(format.commas.digits(2).of(bigint, decimals)).toEqual(
-          "12,345.67"
-        );
-      });
-      it("with min", () => {
-        expect(format.commas.min(20000).of(bigint, decimals)).toEqual(
-          "< 20,000.0000"
-        );
-      });
-      it("with max", () => {
-        expect(format.commas.max(10000).of(bigint, decimals)).toEqual(
-          "> 10,000.0000"
-        );
-      });
-      it("with sign", () => {
-        expect(format.commas.sign().of(bigint, decimals)).toEqual(
-          "+12,345.6789"
-        );
-      });
-      it("with unit", () => {
-        expect(format.commas.unit("ETH").of(bigint, decimals)).toEqual(
-          "12,345.6789 ETH"
-        );
-      });
-      it("without trailing zeros", () => {
-        expect(format.commas.digits(6).of(bigint, decimals)).toEqual(
-          "12,345.678900"
-        );
-        expect(
-          format.commas.digits(6).removeTrailingZero().of(bigint, decimals)
-        ).toEqual("12,345.6789");
-      });
-      it("with locale", () => {
-        // the correct space in fr-FR is narrow no-break space (U+202F)
-        expect(format.commas.locale("fr-FR").of(bigint, decimals)).toEqual(
-          "12\u202F345,6789"
-        );
-      });
-    });
-  });
-
-  describe("percent", () => {
-    describe("should properly format number in percent format", () => {
-      it("without option", () => {
-        expect(format.percent.of(number)).toEqual("1234567.8900");
-      });
-      it("with digits", () => {
-        expect(format.percent.digits(1).of(number)).toEqual("1234567.8");
-      });
-      it("with min", () => {
-        expect(format.percent.min(20000).of(number)).toEqual("< 2000000.0000");
-      });
-      it("with max", () => {
-        expect(format.percent.max(10000).of(number)).toEqual("> 1000000.0000");
-      });
-      it("with sign", () => {
-        expect(format.percent.sign().of(number)).toEqual("+1234567.8900");
-      });
-      it("with unit", () => {
-        expect(format.percent.unit("%").of(number)).toEqual("1234567.8900%");
-      });
-      it("without trailing zeros", () => {
-        expect(format.percent.removeTrailingZero().of(number)).toEqual(
-          "1234567.89"
-        );
-      });
-      it("with locale", () => {
-        expect(format.percent.locale("fr-FR").of(number)).toEqual(
-          "1234567,8900"
-        );
-      });
-    });
-    describe("should properly format bigint in percent format", () => {
-      it("without option", () => {
-        expect(format.percent.of(bigint, decimals)).toEqual("1234567.8900");
-      });
-      it("with digits", () => {
-        expect(format.percent.digits(1).of(bigint, decimals)).toEqual(
-          "1234567.8"
-        );
-      });
-      it("with min", () => {
-        expect(format.percent.min(20000).of(bigint, decimals)).toEqual(
-          "< 2000000.0000"
-        );
-      });
-      it("with max", () => {
-        expect(format.percent.max(10000).of(bigint, decimals)).toEqual(
-          "> 1000000.0000"
-        );
-      });
-      it("with sign", () => {
-        expect(format.percent.sign().of(bigint, decimals)).toEqual(
-          "+1234567.8900"
-        );
-      });
-      it("with unit", () => {
-        expect(format.percent.unit("%").of(bigint, decimals)).toEqual(
-          "1234567.8900%"
-        );
-      });
-      it("without trailing zeros", () => {
-        expect(
-          format.percent.removeTrailingZero().of(bigint, decimals)
-        ).toEqual("1234567.89");
-      });
-      it("with locale", () => {
-        expect(format.percent.locale("fr-FR").of(bigint, decimals)).toEqual(
-          "1234567,8900"
-        );
-      });
-    });
-  });
-});