@morpho-org/blue-sdk 1.0.0

package/src/signatures/index.ts

@@ -0,0 +1,18 @@
+import * as _Manager from "./manager";
+import * as _Permit from "./permit";
+import * as _Permit2 from "./permit2";
+import {
+  safeSignTypedData as _safeSignTypedData,
+  verifySignature as _verifySignature,
+  getMessage as _getMessage,
+} from "./utils";
+
+export namespace SignatureUtils {
+  export import Permit = _Permit;
+  export import Permit2 = _Permit2;
+  export import Manager = _Manager;
+
+  export const safeSignTypedData = _safeSignTypedData;
+  export const verifySignature = _verifySignature;
+  export const getMessage = _getMessage;
+}

package/src/signatures/manager.ts

@@ -0,0 +1,50 @@
+import { getChainAddresses } from "../addresses";
+import { ChainId } from "../chain";
+
+import { SignatureMessage } from "./types";
+import { getMessage } from "./utils";
+
+export interface ManagerApprovalSignatureArgs {
+  authorizer: string;
+  authorized: string;
+  isAuthorized: boolean;
+  nonce: bigint;
+  deadline: bigint;
+}
+
+export const getManagerApprovalMessage = (
+  args: ManagerApprovalSignatureArgs,
+  chainId: ChainId
+): SignatureMessage => {
+  const domain = {
+    chainId: chainId.toString(),
+    verifyingContract: getChainAddresses(chainId).morpho,
+  };
+
+  const types = {
+    Authorization: [
+      {
+        name: "authorizer",
+        type: "address",
+      },
+      {
+        name: "authorized",
+        type: "address",
+      },
+      {
+        name: "isAuthorized",
+        type: "bool",
+      },
+      {
+        name: "nonce",
+        type: "uint256",
+      },
+      {
+        name: "deadline",
+        type: "uint256",
+      },
+    ],
+  };
+
+  return getMessage(domain, types, args);
+};

package/src/signatures/permit.ts

@@ -0,0 +1,126 @@
+import { addresses, getChainAddresses } from "../addresses";
+import { ChainId } from "../chain";
+import { Token } from "../token";
+import { Address } from "../types";
+
+import { SignatureMessage } from "./types";
+import { getMessage } from "./utils";
+
+export interface PermitArgs {
+  erc20: Token;
+  owner: Address;
+  spender: Address;
+  allowance: bigint;
+  nonce: bigint;
+  deadline: bigint;
+}
+
+/**
+ * Permit signature for ERC20 tokens, following EIP-2612.
+ * Docs: https://eips.ethereum.org/EIPS/eip-2612
+ */
+export const getPermitMessage = (
+  { deadline, owner, nonce, spender, erc20, allowance }: PermitArgs,
+  chainId: ChainId
+): SignatureMessage => {
+  const { usdc, dai } = getChainAddresses(chainId);
+
+  const domain = {
+    name: erc20.name,
+    version: erc20.address === usdc ? "2" : "1",
+    chainId: chainId.toString(),
+    verifyingContract: erc20.address,
+  };
+
+  if (erc20.address === dai)
+    return getMessage(
+      domain,
+      {
+        Permit: [
+          {
+            name: "holder",
+            type: "address",
+          },
+          {
+            name: "spender",
+            type: "address",
+          },
+          {
+            name: "nonce",
+            type: "uint256",
+          },
+          {
+            name: "expiry",
+            type: "uint256",
+          },
+          {
+            name: "allowed",
+            type: "bool",
+          },
+        ],
+      },
+      {
+        holder: owner,
+        spender,
+        allowed: allowance > 0n,
+        nonce,
+        expiry: deadline,
+      }
+    );
+
+  const types = {
+    Permit: [
+      {
+        name: "owner",
+        type: "address",
+      },
+      {
+        name: "spender",
+        type: "address",
+      },
+      {
+        name: "value",
+        type: "uint256",
+      },
+      {
+        name: "nonce",
+        type: "uint256",
+      },
+      {
+        name: "deadline",
+        type: "uint256",
+      },
+    ],
+  };
+  const value = {
+    owner,
+    spender,
+    value: allowance,
+    nonce,
+    deadline,
+  };
+
+  return getMessage(domain, types, value);
+};
+
+export const WITH_SIMPLE_PERMIT: {
+  [id in ChainId]: (Address | undefined)[];
+} = {
+  [ChainId.EthMainnet]: [
+    addresses[ChainId.EthMainnet].wbIB01,
+    addresses[ChainId.EthMainnet].wbC3M,
+    addresses[ChainId.EthMainnet].wstEth,
+    addresses[ChainId.EthMainnet].sDai,
+    addresses[ChainId.EthMainnet].osEth,
+    addresses[ChainId.EthMainnet].usdc,
+    addresses[ChainId.EthMainnet].dai,
+  ],
+  [ChainId.EthGoerliTestnet]: [
+    "0x0aCd15Fb54034492c392596B56ED415bD07e70d7", // Fake DAI
+    "0xD8134205b0328F5676aaeFb3B2a0DC15f4029d8C", // Real sDAI
+  ],
+  [ChainId.BaseMainnet]: [addresses[ChainId.BaseMainnet].usdc],
+};
+
+export const hasSimplePermit = (chainId: ChainId, address: Address) =>
+  WITH_SIMPLE_PERMIT[chainId]?.includes(address);

package/src/signatures/permit2.ts

@@ -0,0 +1,120 @@
+import { getChainAddresses } from "../addresses";
+import { ChainId } from "../chain";
+import { MathLib } from "../maths";
+import { Address } from "../types";
+
+import { SignatureMessage } from "./types";
+import { getMessage } from "./utils";
+
+export interface Permit2Args {
+  erc20: Address;
+  allowance: bigint;
+  nonce: bigint;
+  deadline: bigint;
+  spender: Address;
+  expiration?: bigint;
+}
+
+export interface Permit2TransferFromArgs {
+  erc20: Address;
+  allowance: bigint;
+  spender: Address;
+  nonce: bigint;
+  deadline: bigint;
+}
+
+export const getPermit2TransferFromMessage = (
+  args: Permit2TransferFromArgs,
+  chainId: ChainId
+) => {
+  const domain = {
+    name: "Permit2",
+    chainId: chainId.toString(),
+    verifyingContract: getChainAddresses(chainId).permit2,
+  };
+  const types = {
+    PermitTransferFrom: [
+      { name: "permitted", type: "TokenPermissions" },
+      { name: "spender", type: "address" },
+      { name: "nonce", type: "uint256" },
+      { name: "deadline", type: "uint256" },
+    ],
+    TokenPermissions: [
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" },
+    ],
+  };
+  const value = {
+    permitted: {
+      token: args.erc20,
+      amount: MathLib.min(args.allowance, MathLib.MAX_UINT_160),
+    },
+    spender: args.spender,
+    nonce: args.nonce,
+    deadline: args.deadline,
+  };
+
+  return getMessage(domain, types, value);
+};
+
+export const getPermit2Message = (
+  args: Permit2Args,
+  chainId: ChainId
+): SignatureMessage => {
+  const domain = {
+    name: "Permit2",
+    chainId: chainId.toString(),
+    verifyingContract: getChainAddresses(chainId).permit2,
+  };
+  const types = {
+    PermitSingle: [
+      {
+        name: "details",
+        type: "PermitDetails",
+      },
+      {
+        name: "spender",
+        type: "address",
+      },
+      {
+        name: "sigDeadline",
+        type: "uint256",
+      },
+    ],
+    PermitDetails: [
+      {
+        name: "token",
+        type: "address",
+      },
+      {
+        name: "amount",
+        type: "uint160",
+      },
+      {
+        name: "expiration",
+        type: "uint48",
+      },
+      {
+        name: "nonce",
+        type: "uint48",
+      },
+    ],
+  };
+  const value = {
+    details: {
+      token: args.erc20,
+      amount: MathLib.min(args.allowance, MathLib.MAX_UINT_160),
+      // Use an unlimited expiration because it most
+      // closely mimics how a standard approval works.
+      expiration: MathLib.min(
+        args.expiration ?? MathLib.MAX_UINT_48,
+        MathLib.MAX_UINT_48
+      ),
+      nonce: args.nonce,
+    },
+    spender: args.spender,
+    sigDeadline: args.deadline,
+  };
+
+  return getMessage(domain, types, value);
+};

package/src/signatures/types.ts

@@ -0,0 +1,18 @@
+import { TypedDataDomain } from "ethers";
+
+export interface SignatureData {
+  domain: TypedDataDomain;
+  types: Record<
+    string,
+    {
+      name: string;
+      type: string;
+    }[]
+  >;
+  value: object;
+}
+
+export interface SignatureMessage {
+  hash: string;
+  data: SignatureData;
+}

package/src/signatures/utils.ts

@@ -0,0 +1,83 @@
+import {
+  Signature,
+  Signer,
+  TypedDataDomain,
+  TypedDataEncoder,
+  TypedDataField,
+  ZeroAddress,
+  recoverAddress,
+} from "ethers";
+
+import { InvalidSignatureError } from "../errors";
+import { Address } from "../types";
+
+import { SignatureMessage } from "./types";
+
+export async function safeSignTypedData(
+  signer: Signer,
+  domain: TypedDataDomain,
+  types: Record<string, TypedDataField[]>,
+  value: Record<string, any>
+) {
+  const populated = await TypedDataEncoder.resolveNames(
+    domain,
+    types,
+    value,
+    (name: string) => {
+      return signer.resolveName(name) as Promise<string>;
+    }
+  );
+
+  // Fix the chainId parsing issue
+  // Tracking of https://github.com/ethers-io/ethers.js/issues/4649
+  const initialPayload = TypedDataEncoder.getPayload(
+    populated.domain,
+    types,
+    populated.value
+  );
+  const provider = signer.provider;
+  const unsafeChainId = Number(initialPayload.domain.chainId);
+
+  if (provider && "send" in provider && Number.isSafeInteger(unsafeChainId)) {
+    const correctedPayload = {
+      ...initialPayload,
+      domain: {
+        ...initialPayload.domain,
+        chainId: unsafeChainId, // that is safe now
+      },
+    };
+    return Signature.from(
+      // @ts-ignore if send is defined in the provider, it accepts raw RPC call args
+      await signer.provider!.send("eth_signTypedData_v4", [
+        // Doing the same thing that inside of the signTypedData function.
+        await signer.getAddress().then((r) => r.toLowerCase()),
+        JSON.stringify(correctedPayload),
+      ])
+    );
+  }
+
+  return Signature.from(
+    await signer.signTypedData(populated.domain, types, populated.value)
+  );
+}
+
+export function verifySignature(
+  signature: Signature,
+  hash: string,
+  signerAddress: Address
+) {
+  const recoveredAddress = recoverAddress(hash, signature);
+
+  if (recoveredAddress === ZeroAddress || recoveredAddress !== signerAddress)
+    throw new InvalidSignatureError(hash, signerAddress, recoveredAddress);
+}
+
+export function getMessage(
+  domain: TypedDataDomain,
+  types: Record<string, TypedDataField[]>,
+  value: Record<string, any>
+): SignatureMessage {
+  const hash = TypedDataEncoder.hash(domain, types, value);
+
+  return { data: { domain, types, value }, hash };
+}

package/src/tests/mocks/markets.ts

@@ -0,0 +1,110 @@
+import { ZeroAddress, parseUnits } from "ethers";
+
+import { MarketConfig } from "../../market";
+
+export const MAINNET_MARKETS = {
+  eth_wstEth: new MarketConfig({
+    loanToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+    oracle: "0x2a01EB9496094dA03c4E364Def50f5aD1280AD72",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.945"),
+  }),
+  eth_rEth: new MarketConfig({
+    loanToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    collateralToken: "0xae78736Cd615f374D3085123A210448E74Fc6393",
+    oracle: "0x1b4A3F92e5Fffd1d35A98751c9FE4472483579bB",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.945"),
+  }),
+  usdt_wbtc: new MarketConfig({
+    loanToken: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    collateralToken: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+    oracle: "0x008bF4B1cDA0cc9f0e882E0697f036667652E1ef",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.86"),
+  }),
+  usdt_wstEth: new MarketConfig({
+    loanToken: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+    oracle: "0x95DB30fAb9A3754e42423000DF27732CB2396992",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.86"),
+  }),
+
+  usdc_wbtc: new MarketConfig({
+    // USDC(wBTC, 86%, Chainlink, AdaptiveCurve)
+    loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    collateralToken: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+    oracle: "0xDddd770BADd886dF3864029e4B377B5F6a2B6b83",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.86"),
+  }),
+  usdc_wstEth: new MarketConfig({
+    // USDC(wstETH, 86%, Chainlink, AdaptiveCurve)
+    loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    collateralToken: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+    oracle: "0x48F7E36EB6B826B2dF4B2E630B62Cd25e89E40e2",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.86"),
+  }),
+  usdc_sDai: new MarketConfig({
+    // USDC(wstETH, 86%, Chainlink, AdaptiveCurve)
+    loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    collateralToken: "0x83F20F44975D03b1b09e64809B757c47f942BEeA",
+    oracle: "0x6CAFE228eC0B0bC2D076577d56D35Fe704318f6d",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.965"),
+  }),
+  idle_usdc: new MarketConfig({
+    loanToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    collateralToken: ZeroAddress,
+    oracle: ZeroAddress,
+    irm: ZeroAddress,
+    lltv: 0n,
+  }),
+
+  crvUsd_stkcvxcrvUSDTWBTCWETH: new MarketConfig({
+    collateralToken: "0xb0Ce26C88e4e7DCa51968b6047f44646f5064278",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.86"),
+    loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+    oracle: "0x077Af6c2D4A75D4145d141F9e9421864C3940CB3",
+  }),
+  crvUsd_stkcvxcrvUSDCWBTCWETH: new MarketConfig({
+    collateralToken: "0x0ea1a65A2c255f24Ee8D81eA6AaC54Decd9d269e",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.86"),
+    loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+    oracle: "0xd2F7C3B2fC97cC7b6AfDd76D163394680EFc35b9",
+  }),
+  crvUsd_stkcvxcrvCRVUSDTBTCWSTETH: new MarketConfig({
+    collateralToken: "0x3ce8Ec9f3d89aD0A2DdbCC3FDB8991BD241Fc82E",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.86"),
+    loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+    oracle: "0xa9f7900476F43C45Ebf56cEa669B9c960C176112",
+  }),
+  crvUsd_stkcvxTryLSD: new MarketConfig({
+    collateralToken: "0x6BA072F0d22806F2C52e9792AF47f2D59103BEBE",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.86"),
+    loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+    oracle: "0x18B0d7311a97c5377445C80c768ab5201Bb27B5a",
+  }),
+  crvUsd_stkcvxcrvUSDETHCRV: new MarketConfig({
+    collateralToken: "0xAc904BAfBb5FB04Deb2b6198FdCEedE75a78Ce5a",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.86"),
+    loanToken: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+    oracle: "0xad7e157815df05029125B568E39d5402550d60bb",
+  }),
+
+  usda_re7Eth: new MarketConfig({
+    collateralToken: "0x78Fc2c2eD1A4cDb5402365934aE5648aDAd094d0",
+    irm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    lltv: parseUnits("0.86"),
+    loanToken: "0x0000206329b97DB379d5E1Bf586BbDB969C63274",
+    oracle: "0x76052A2A28fDCB8124f4686C63C68355b142de3B",
+  }),
+};

package/src/token/ERC20Metadata.ts

@@ -0,0 +1,124 @@
+import {
+  Contract,
+  ContractRunner,
+  Interface,
+  decodeBytes32String,
+  isHexString,
+} from "ethers";
+import { ERC20__factory } from "ethers-types";
+import { ERC20, ERC20Interface } from "ethers-types/dist/token/ERC20/ERC20";
+
+import addresses from "@morpho-org/blue-sdk/src/addresses";
+
+import { ChainId } from "../chain";
+
+export const isBytes32ERC20Metadata = (address: string, chainId: ChainId) => {
+  switch (chainId) {
+    case ChainId.EthMainnet:
+      return [addresses[ChainId.EthMainnet].mkr].includes(address);
+    default:
+      return false;
+  }
+};
+
+export const decodeString = (bytes32OrStr: string) => {
+  if (isHexString(bytes32OrStr, 32)) return decodeBytes32String(bytes32OrStr);
+
+  return bytes32OrStr;
+};
+
+const _bytes32ERC20Abi = [
+  ...ERC20__factory.abi.filter(
+    (fragment) =>
+      !("name" in fragment) ||
+      (fragment.name !== "name" && fragment.name !== "symbol")
+  ),
+  {
+    inputs: [],
+    name: "symbol",
+    outputs: [
+      {
+        name: "symbol",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+
+  {
+    inputs: [],
+    name: "name",
+    outputs: [
+      {
+        name: "name",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+export class Bytes32ERC20__factory {
+  static readonly abi = _bytes32ERC20Abi;
+
+  static createInterface() {
+    return new Interface(_bytes32ERC20Abi) as ERC20Interface;
+  }
+  static connect(address: string, runner?: ContractRunner | null) {
+    const erc20 = new Contract(
+      address,
+      _bytes32ERC20Abi,
+      runner
+    ) as unknown as ERC20;
+
+    const name = erc20.name.bind(erc20);
+    erc20.name = Object.assign(
+      (...args: Parameters<typeof name>) => name(...args).then(decodeString),
+      name
+    );
+
+    const symbol = erc20.symbol.bind(erc20);
+    erc20.symbol = Object.assign(
+      (...args: Parameters<typeof symbol>) =>
+        symbol(...args).then(decodeString),
+      symbol
+    );
+
+    return erc20;
+  }
+}
+
+export class ERC20Metadata__factory {
+  static connect(
+    address: string,
+    chainId: ChainId,
+    runner?: ContractRunner | null
+  ) {
+    if (isBytes32ERC20Metadata(address, chainId))
+      return Bytes32ERC20__factory.connect(address, runner);
+
+    const erc20 = ERC20__factory.connect(address, runner);
+
+    const name = erc20.name.bind(erc20);
+    erc20.name = Object.assign(
+      (...args: Parameters<typeof name>) =>
+        name(...args).catch(() =>
+          Bytes32ERC20__factory.connect(address, runner).name(...args)
+        ),
+      name
+    );
+
+    const symbol = erc20.symbol.bind(erc20);
+    erc20.symbol = Object.assign(
+      (...args: Parameters<typeof symbol>) =>
+        symbol(...args).catch(() =>
+          Bytes32ERC20__factory.connect(address, runner).symbol(...args)
+        ),
+      symbol
+    );
+
+    return erc20;
+  }
+}