@morpho-org/blue-sdk 1.0.0

package/src/token/Token.ts

@@ -0,0 +1,83 @@
+import { BigNumberish, parseUnits } from "ethers";
+
+import { MathLib, RoundingDirection } from "../maths";
+import { Address } from "../types";
+
+export interface InputToken {
+  address: Address;
+  decimals: number;
+  symbol: string;
+  name?: string;
+}
+
+export class Token implements InputToken {
+  /**
+   * The token's address.
+   */
+  public readonly address: Address;
+
+  /**
+   * The token's number of decimals.
+   */
+  public readonly decimals: number;
+
+  /**
+   * The token's symbol.
+   */
+  public readonly symbol: string;
+
+  /**
+   * The name of the token (defaults to the symbol).
+   */
+  public readonly name: string;
+
+  constructor({ address, decimals, symbol, name }: InputToken) {
+    this.address = address;
+    this.decimals = decimals;
+    this.symbol = symbol;
+    this.name = name ?? symbol;
+  }
+}
+
+export class TokenWithPrice extends Token {
+  /**
+   * Price of the token in USD (scaled by WAD).
+   */
+  public price?: bigint;
+
+  constructor(token: InputToken, price?: bigint) {
+    super(token);
+
+    this.price = price;
+  }
+
+  /**
+   * Quotes an amount in USD (scaled by WAD) in this token.
+   * @param amount The amount of USD to quote.
+   */
+  fromUsd(amount: BigNumberish, rounding: RoundingDirection = "Down") {
+    if (this.price == null) return null;
+
+    return MathLib.mulDiv(
+      amount,
+      parseUnits("1", this.decimals),
+      this.price,
+      rounding
+    );
+  }
+
+  /**
+   * Quotes an amount of tokens in USD (scaled by WAD).
+   * @param amount The amount of tokens to quote.
+   */
+  toUsd(amount: BigNumberish, rounding: RoundingDirection = "Down") {
+    if (this.price == null) return null;
+
+    return MathLib.mulDiv(
+      amount,
+      this.price,
+      parseUnits("1", this.decimals),
+      rounding
+    );
+  }
+}

package/src/token/TokenNamespace.ts

@@ -0,0 +1,76 @@
+import { Provider } from "ethers";
+import { WStEth__factory } from "ethers-types";
+import { ViewOverrides } from "ethers-types/dist/common";
+
+import {
+  NATIVE_ADDRESS,
+  getChainAddresses,
+  getUnwrappedToken,
+} from "../addresses";
+import { ChainId, ChainUtils } from "../chain";
+import { Address } from "../types";
+
+import { ERC20Metadata__factory } from "./ERC20Metadata";
+import { Token as TokenClass } from "./Token";
+import { ConstantWrappedToken, ExchangeRateWrappedToken } from "./WrappedToken";
+
+export class Token extends TokenClass {}
+
+export { TokenWithPrice } from "./Token";
+
+export namespace Token {
+  export function native(chainId: ChainId) {
+    const currency = ChainUtils.chainMetadata[chainId].nativeCurrency;
+
+    return new Token({ ...currency, address: NATIVE_ADDRESS });
+  }
+
+  export async function fetch(
+    address: Address,
+    runner: { provider: Provider },
+    {
+      chainId,
+      overrides = {},
+    }: { chainId?: ChainId; overrides?: ViewOverrides } = {}
+  ) {
+    chainId ??= ChainUtils.parseSupportedChainId(
+      (await runner.provider.getNetwork()).chainId
+    );
+    if (address === NATIVE_ADDRESS) return Token.native(chainId);
+
+    const erc20 = ERC20Metadata__factory.connect(address, chainId, runner);
+
+    const [decimals, symbol, name] = await Promise.all([
+      erc20.decimals(overrides),
+      erc20.symbol(overrides),
+      erc20.name(overrides),
+    ]);
+
+    const token = {
+      address,
+      decimals: parseInt(decimals.toString()),
+      symbol,
+      name,
+    };
+
+    const { wstEth, stEth } = getChainAddresses(chainId);
+
+    switch (address) {
+      case wstEth: {
+        if (stEth) {
+          const wstEthToken = WStEth__factory.connect(wstEth!, runner);
+          const stEthPerWstEth = await wstEthToken.stEthPerToken(overrides);
+          return new ExchangeRateWrappedToken(token, stEth, stEthPerWstEth);
+        }
+        break;
+      }
+    }
+
+    const unwrapToken = getUnwrappedToken(address, chainId);
+    if (unwrapToken) {
+      return new ConstantWrappedToken(token, unwrapToken, token.decimals); //TODO fetch underlying token's decimals if it can be different form token's decimals
+    }
+
+    return new Token(token);
+  }
+}

package/src/token/WrappedToken.ts

@@ -0,0 +1,142 @@
+import { formatUnits } from "ethers";
+
+import { safeParseUnits } from "../ethers";
+import { MathLib, RoundingDirection, SharesMath } from "../maths";
+import { Address } from "../types";
+import { Vault } from "../vault";
+
+import { InputToken, Token } from "./Token";
+
+export abstract class WrappedToken extends Token {
+  protected abstract _wrap(amount: bigint, rounding: RoundingDirection): bigint;
+  protected abstract _unwrap(
+    amount: bigint,
+    rounding: RoundingDirection
+  ): bigint;
+
+  protected _noSlippage = false;
+
+  constructor(token: InputToken, readonly underlying: Address) {
+    super(token);
+  }
+
+  /** The expected amount when wrapping `unwrappedAmount` */
+  toWrappedExactAmountIn(
+    unwrappedAmount: bigint,
+    slippage = 0n,
+    rounding: RoundingDirection = "Down"
+  ) {
+    const wrappedAmount = this._wrap(unwrappedAmount, rounding);
+    if (this._noSlippage) return wrappedAmount;
+    return MathLib.wMul(wrappedAmount, MathLib.WAD - slippage, "Down");
+  }
+
+  /** The amount of unwrappedTokens that should be wrapped to receive `wrappedAmount` */
+  toWrappedExactAmountOut(
+    wrappedAmount: bigint,
+    slippage = 0n,
+    rounding: RoundingDirection = "Up"
+  ) {
+    const wAmountTarget = this._noSlippage
+      ? wrappedAmount
+      : MathLib.wDiv(wrappedAmount, MathLib.WAD - slippage, rounding);
+    return this._unwrap(wAmountTarget, rounding);
+  }
+
+  /** The expected amount when unwrapping `wrappedAmount` */
+  toUnwrappedExactAmountIn(
+    wrappedAmount: bigint,
+    slippage = 0n,
+    rounding: RoundingDirection = "Down"
+  ) {
+    const unwrappedAmount = this._unwrap(wrappedAmount, rounding);
+    if (this._noSlippage) return unwrappedAmount;
+    return MathLib.wMul(unwrappedAmount, MathLib.WAD - slippage, "Up");
+  }
+
+  /** The amount of wrappedTokens that should be unwrapped to receive `unwrappedAmount` */
+  toUnwrappedExactAmountOut(
+    unwrappedAmount: bigint,
+    slippage = 0n,
+    rounding: RoundingDirection = "Up"
+  ) {
+    const unwrappedAmountToTarget = this._noSlippage
+      ? unwrappedAmount
+      : MathLib.wDiv(unwrappedAmount, MathLib.WAD - slippage, rounding);
+    return this._wrap(unwrappedAmountToTarget, rounding);
+  }
+}
+
+export class ConstantWrappedToken extends WrappedToken {
+  protected _noSlippage = true;
+
+  constructor(
+    token: InputToken,
+    readonly underlying: Address,
+    private readonly _underlyingDecimals = 18
+  ) {
+    super(token, underlying);
+  }
+
+  protected _wrap(amount: bigint) {
+    return safeParseUnits(
+      formatUnits(amount, this._underlyingDecimals),
+      this.decimals
+    );
+  }
+  protected _unwrap(amount: bigint) {
+    return safeParseUnits(
+      formatUnits(amount, this.decimals),
+      this._underlyingDecimals
+    );
+  }
+}
+
+export class ExchangeRateWrappedToken extends WrappedToken {
+  protected _wrap(amount: bigint, rounding: RoundingDirection) {
+    return MathLib.wDiv(amount, this.wrappedTokenExchangeRate, rounding);
+  }
+  protected _unwrap(amount: bigint, rounding: RoundingDirection) {
+    return MathLib.wMul(amount, this.wrappedTokenExchangeRate, rounding);
+  }
+
+  constructor(
+    token: InputToken,
+    readonly underlying: Address,
+    public wrappedTokenExchangeRate: bigint
+  ) {
+    super(token, underlying);
+  }
+}
+
+export class VaultToken extends WrappedToken {
+  protected _wrap(amount: bigint, rounding: RoundingDirection) {
+    return SharesMath.toShares(
+      amount,
+      this.totalAssets,
+      this.totalSupply,
+      rounding
+    );
+  }
+  protected _unwrap(amount: bigint, rounding: RoundingDirection) {
+    return SharesMath.toAssets(
+      amount,
+      this.totalAssets,
+      this.totalSupply,
+      rounding
+    );
+  }
+
+  public totalAssets: bigint;
+  public totalSupply: bigint;
+
+  constructor(
+    token: InputToken,
+    readonly underlying: Address,
+    { totalAssets, totalSupply }: Pick<Vault, "totalAssets" | "totalSupply">
+  ) {
+    super(token, underlying);
+    this.totalAssets = totalAssets;
+    this.totalSupply = totalSupply;
+  }
+}

package/src/token/index.ts

@@ -0,0 +1,2 @@
+export * from "./TokenNamespace";
+export * from "./WrappedToken";

package/src/types.ts

@@ -0,0 +1,37 @@
+import { isHexString } from "ethers";
+
+export type Hex64 = string & { __LENGTH__: 64 };
+
+/**
+ * The address of a Contract, or an EOA
+ */
+export type Address = string;
+
+/**
+ * The id of a market used on the Blue contract
+ */
+export type MarketId = `0x${Hex64}` & { __TYPE__: "marketId" };
+
+/**
+ * The possible transaction type on the Blue contract
+ */
+export enum TransactionType {
+  Supply = "Supply",
+  SupplyCollateral = "Supply Collateral",
+  Withdraw = "Withdraw",
+  WithdrawCollateral = "Withdraw Collateral",
+  Borrow = "Borrow",
+  Repay = "Repay",
+}
+
+export type Loadable<T> = T | undefined;
+export type Failable<T> = T | null;
+export type Fetchable<T> = Failable<Loadable<T>>;
+
+// TODO: replace with isDefined
+export function isFetched<T>(v: Fetchable<T>): v is T {
+  return v !== undefined && v !== null;
+}
+
+export const isMarketId = (value: any): value is MarketId =>
+  isHexString(value, 32);

package/src/user/User.ts

@@ -0,0 +1,32 @@
+import { Address } from "../types";
+
+export class User {
+  /**
+   * The user's address.
+   */
+  public readonly address: Address;
+
+  /**
+   * Whether the bundler is authorized to manage the user's position on Morpho Blue.
+   */
+  public isBundlerAuthorized: boolean;
+
+  /**
+   * The user's nonce on Morpho Blue.
+   */
+  public morphoNonce: bigint;
+
+  constructor({
+    address,
+    isBundlerAuthorized,
+    morphoNonce,
+  }: {
+    address: Address;
+    isBundlerAuthorized: boolean;
+    morphoNonce: bigint;
+  }) {
+    this.address = address;
+    this.isBundlerAuthorized = isBundlerAuthorized;
+    this.morphoNonce = morphoNonce;
+  }
+}

package/src/user/index.ts

@@ -0,0 +1,2 @@
+export * from "./user.types";
+export * from "./User";

package/src/user/user.types.ts

@@ -0,0 +1,23 @@
+import { Token } from "../token";
+
+export interface MaxBalanceDecomposition {
+  maxBalance: bigint;
+  decomposition: { base: BalanceDecompositionFragment } & {
+    [T in Exclude<PeripheralTokenType, "base">]?: BalanceDecompositionFragment;
+  };
+}
+
+export type PeripheralTokenType =
+  | "base"
+  | "wrapped"
+  | "erc4626"
+  | "wrapped-erc4626";
+export interface PeripheralToken {
+  token: Token;
+  type: PeripheralTokenType;
+}
+
+export interface BalanceDecompositionFragment extends PeripheralToken {
+  underlyingValue: bigint;
+  value: bigint;
+}