@morpho-org/blue-sdk 1.0.1 → 1.0.2

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@morpho-org/blue-sdk",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "author": "Morpho Association <contact@morpho.org>",
   "license": "MIT",
   "main": "src/index.ts",
   "files": [
-    "lib"
+    "src"
   ],
   "scripts": {
     "prepublish": "yarn build",
@@ -15,21 +15,25 @@
     "test:blue-sdk": "yarn test"
   },
   "dependencies": {
-    "@morpho-org/morpho-ts": "1.0.1",
+    "@morpho-org/morpho-ts": "1.0.2",
     "ethers": "^6.12.1",
     "ethers-multicall-provider": "^6.3.0",
     "ethers-types": "^3.15.1",
     "rxjs": "^7.8.1"
   },
   "devDependencies": {
-    "@morpho-org/morpho-test": "1.0.1",
+    "@morpho-org/morpho-test": "1.0.2",
     "@types/jest": "^29.5.12",
     "jest": "^29.6.2",
     "ts-jest": "^29.1.1",
     "typescript": "^5.4.5"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "main": "lib/index.js",
+    "files": [
+      "lib"
+    ]
   },
   "jest": {
     "verbose": true,
@@ -50,5 +54,5 @@
     ],
     "preset": "ts-jest"
   },
-  "gitHead": "474aa49a57a91da7d47a0bf666b5fccede4d395e"
+  "gitHead": "d8e67d7bf53582572306f0c11761163208129ff1"
 }

package/src/addresses.ts

@@ -0,0 +1,261 @@
+import { ChainId } from "./chain";
+import { UnsupportedChainIdError } from "./errors";
+import { Address } from "./types";
+
+/** Address used to replicate an erc20-behaviour for native token.
+ *
+ * NB: data might differ from expected onchain native token data
+ */
+export const NATIVE_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+
+export const addresses = {
+  [ChainId.EthGoerliTestnet]: {
+    morpho: "0x64c7044050Ba0431252df24fEd4d9635a275CB41",
+    permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+    bundler: "0xCFFbEEAFCD79Fd68FD56Dbc31A419f290A2Fe9e0",
+    urd: "0x820755E757a590683dc43115290eb1Cb20a60405",
+    wNative: "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6",
+    stEth: "0x1643E812aE58766192Cf7D2Cf9567dF2C37e9B7F",
+    wstEth: "0x6320cD32aA674d2898A68ec82e869385Fc5f7E2f",
+    rEth: "0x178E141a0E3b34152f73Ff610437A7bf9B83267A",
+    sDai: "0xD8134205b0328F5676aaeFb3B2a0DC15f4029d8C",
+    dai: "0x11fE4B6AE13d2a6055C8D9cF65c55bac32B5d844",
+    usdc: "0x62bD2A599664D421132d7C54AB4DbE3233f4f0Ae",
+    usdt: "0x576e379FA7B899b4De1E251e935B31543Df3e954",
+  },
+  [ChainId.EthMainnet]: {
+    morpho: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+    adaptiveCurveIrm: "0x870aC11D48B15DB9a138Cf899d20F13F79Ba00BC",
+    publicAllocator: "0xfd32fA2ca22c76dD6E550706Ad913FC6CE91c75D",
+    permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+    bundler: "0x4095F064B8d3c3548A3bebfd0Bbfd04750E30077",
+    aaveV3OptimizerBundler: "0x16F38d2E764E7BeBF625a8E995b34968226D2F9c",
+    aaveV2Bundler: "0xb3dCc75DB379925edFd3007511A8CE0cB4aa8e76",
+    aaveV3Bundler: "0x98ccB155E86bb478d514a827d16f58c6912f9BDC",
+    morphoToken: "0x9994E35Db50125E0DF82e4c2dde62496CE330999",
+    rEth: "0xae78736Cd615f374D3085123A210448E74Fc6393",
+    sDai: "0x83F20F44975D03b1b09e64809B757c47f942BEeA",
+    dai: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+    mkr: "0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2",
+    wstEth: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+    wNative: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    stEth: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
+    USDe: "0x4c9EDD5852cd905f086C759E8383e09bff1E68B3",
+    sUSDe: "0x9D39A5DE30e57443BfF2A8307A4256c8797A3497",
+    bIB01: "0xCA30c93B02514f86d5C86a6e375E3A330B435Fb5",
+    // If we want to change the wbIB01 address, we have to check if the new one has simple permit or not.
+    // Currently, wbIB01 is considered to have simple permit.
+    wbIB01: "0xcA2A7068e551d5C4482eb34880b194E4b945712F",
+    bC3M: "0x2F123cF3F37CE3328CC9B5b8415f9EC5109b45e7",
+    // If we want to change the wbC3M address, we have to check if the new one has simple permit or not.
+    // Currently, wbC3M is considered to have simple permit.
+    wbC3M: "0x95D7337d43340E2721960Dc402D9b9117f0d81a2",
+    usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    usdt: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    wbtc: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+    sWise: "0x48C3399719B582dD63eB5AADf12A40B4C3f52FA2",
+    osEth: "0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38",
+    weEth: "0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee",
+    ezEth: "0xbf5495Efe5DB9ce00f80364C8B423567e58d2110",
+    pyUsd: "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8",
+    crvUsd: "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E",
+    morphoOperator: "0x640428D38189B11B844dAEBDBAAbbdfbd8aE0143",
+    butterfly: "0xc55126051B22eBb829D00368f4B12Bde432de5Da",
+    marketRewardsProgramRegistry: "0x5148bF15bb722E1854F66430Bc9FeD0E9FDaCE7D",
+    timeBoundedUrd: "0x330eefa8a787552DC5cAd3C3cA644844B1E61Ddb",
+    rsEth: "0xA1290d69c65A6Fe4DF752f95823fae25cB99e5A7",
+
+    /* Curve tokens */
+    "stkcvxcrvUSDTWBTCWETH-morpho":
+      "0xb0Ce26C88e4e7DCa51968b6047f44646f5064278",
+    crvUSDTWBTCWETH: "0xf5f5B97624542D72A9E06f04804Bf81baA15e2B4",
+
+    "stkcvxcrvUSDCWBTCWETH-morpho":
+      "0x0ea1a65A2c255f24Ee8D81eA6AaC54Decd9d269e",
+    crvUSDCWBTCWETH: "0x7F86Bf177Dd4F3494b841a37e810A34dD56c829B",
+
+    "stkcvxcrvCRVUSDTBTCWSTETH-morpho":
+      "0x3ce8Ec9f3d89aD0A2DdbCC3FDB8991BD241Fc82E",
+    crvCRVUSDTBTCWSTETH: "0x2889302a794dA87fBF1D6Db415C1492194663D13",
+
+    "stkcvxTryLSD-morpho": "0x6BA072F0d22806F2C52e9792AF47f2D59103BEBE",
+    tryLSD: "0x2570f1bD5D2735314FC102eb12Fc1aFe9e6E7193",
+
+    "stkcvxcrvUSDETHCRV-morpho": "0xAc904BAfBb5FB04Deb2b6198FdCEedE75a78Ce5a",
+    crvUSDETHCRV: "0x4eBdF703948ddCEA3B11f675B4D1Fba9d2414A14",
+  },
+  [ChainId.BaseMainnet]: {
+    morpho: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+    permit2: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+    bundler: "0xb5D342521EB5b983aE6a6324A4D9eac87C9D1987",
+    wNative: "0x4200000000000000000000000000000000000006",
+    adaptiveCurveIrm: "0x46415998764C29aB2a25CbeA6254146D50D22687",
+    publicAllocator: "0xA090dD1a701408Df1d4d0B85b716c87565f90467",
+
+    /* Tokens */
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    cbEth: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22",
+  },
+} as const;
+
+interface ChainAddresses {
+  morpho: Address;
+  permit2: Address;
+  bundler: Address;
+  wNative: Address;
+  adaptiveCurveIrm?: Address;
+  publicAllocator?: Address;
+  morphoToken?: Address;
+  wstEth?: Address;
+  stEth?: Address;
+  dai?: Address;
+  mkr?: Address;
+  rEth?: Address;
+  sDai?: Address;
+  usdc?: Address;
+  usdt?: Address;
+  bIB01?: Address;
+  wbIB01?: Address;
+  bC3M?: Address;
+  wbC3M?: Address;
+  wbtc?: Address;
+  sWise?: Address;
+  osEth?: Address;
+  weEth?: Address;
+  ezEth?: Address;
+  pyUsd?: Address;
+  sUSDe?: Address;
+  USDe?: Address;
+  marketRewardsProgramRegistry?: Address;
+  timeBoundedUrd?: Address;
+  rsEth?: Address;
+  crvUsd?: Address;
+  morphoOperator?: Address;
+  butterfly?: Address;
+  aaveV3OptimizerBundler?: Address;
+  aaveV2Bundler?: Address;
+  aaveV3Bundler?: Address;
+
+  /* Curve tokens */
+  "stkcvxcrvUSDTWBTCWETH-morpho"?: Address;
+  crvUSDTWBTCWETH?: Address;
+  "stkcvxcrvUSDCWBTCWETH-morpho"?: Address;
+  crvUSDCWBTCWETH?: Address;
+  "stkcvxcrvCRVUSDTBTCWSTETH-morpho"?: Address;
+  crvCRVUSDTBTCWSTETH?: Address;
+  "stkcvxTryLSD-morpho"?: Address;
+  tryLSD?: Address;
+  "stkcvxcrvUSDETHCRV-morpho"?: Address;
+  crvUSDETHCRV?: Address;
+}
+
+export type AddressLabel = keyof (typeof addresses)[ChainId];
+
+export default addresses as {
+  [n in ChainId]: ChainAddresses;
+};
+
+export const getChainAddresses = (chainId: number): ChainAddresses => {
+  const chainAddresses = addresses[chainId as ChainId];
+
+  if (!chainAddresses) throw new UnsupportedChainIdError(chainId);
+
+  return chainAddresses;
+};
+
+export const wrapping: {
+  [n in ChainId]: {
+    [unwrapped: string]: string;
+  };
+} = {
+  [ChainId.EthGoerliTestnet]: {
+    [NATIVE_ADDRESS]: addresses[ChainId.EthGoerliTestnet].wNative,
+    [addresses[ChainId.EthGoerliTestnet].stEth]:
+      addresses[ChainId.EthGoerliTestnet].wstEth,
+  },
+  [ChainId.EthMainnet]: {
+    [addresses[ChainId.EthMainnet].bIB01]: addresses[ChainId.EthMainnet].wbIB01,
+    [addresses[ChainId.EthMainnet].bC3M]: addresses[ChainId.EthMainnet].wbC3M,
+    [NATIVE_ADDRESS]: addresses[ChainId.EthMainnet].wNative,
+    [addresses[ChainId.EthMainnet].stEth]: addresses[ChainId.EthMainnet].wstEth,
+    [addresses[ChainId.EthMainnet].crvUSDTWBTCWETH]:
+      addresses[ChainId.EthMainnet]["stkcvxcrvUSDTWBTCWETH-morpho"],
+    [addresses[ChainId.EthMainnet].crvUSDCWBTCWETH]:
+      addresses[ChainId.EthMainnet]["stkcvxcrvUSDCWBTCWETH-morpho"],
+    [addresses[ChainId.EthMainnet].crvCRVUSDTBTCWSTETH]:
+      addresses[ChainId.EthMainnet]["stkcvxcrvCRVUSDTBTCWSTETH-morpho"],
+    [addresses[ChainId.EthMainnet].tryLSD]:
+      addresses[ChainId.EthMainnet]["stkcvxTryLSD-morpho"],
+    [addresses[ChainId.EthMainnet].crvUSDETHCRV]:
+      addresses[ChainId.EthMainnet]["stkcvxcrvUSDETHCRV-morpho"],
+  },
+  [ChainId.BaseMainnet]: {
+    [NATIVE_ADDRESS]: addresses[ChainId.BaseMainnet].wNative,
+  },
+};
+
+export const reverseWrapping = Object.fromEntries(
+  Object.entries(wrapping).map(([n, chainWrapping]) => [
+    n,
+    Object.fromEntries(
+      Object.entries(chainWrapping)
+        .map((w) => [...w].reverse())
+        .filter(([add, wAdd]) => !!add && !!wAdd)
+    ),
+  ])
+) as typeof wrapping;
+
+export function getUnwrappedToken(wrappedToken: Address, chainId: ChainId) {
+  return reverseWrapping[chainId][wrappedToken];
+}
+
+export function getWrappedToken(unWrappedToken: Address, chainId: ChainId) {
+  return wrapping[chainId][unWrappedToken];
+}
+
+export const erc20WrapperTokens: {
+  [id in ChainId]: Set<Address>;
+} = {
+  [ChainId.EthMainnet]: new Set([
+    addresses[ChainId.EthMainnet].wbIB01,
+    addresses[ChainId.EthMainnet].wbC3M,
+  ]),
+  [ChainId.EthGoerliTestnet]: new Set(),
+  [ChainId.BaseMainnet]: new Set(),
+};
+
+export const wrappedBackedTokens: {
+  [id in ChainId]: Set<Address>;
+} = {
+  [ChainId.EthMainnet]: new Set([
+    addresses[ChainId.EthMainnet].wbIB01,
+    addresses[ChainId.EthMainnet].wbC3M,
+  ]),
+  [ChainId.EthGoerliTestnet]: new Set(),
+  [ChainId.BaseMainnet]: new Set(),
+};
+
+export const getWrappedBackedTokens = (chainId: number) => {
+  const tokens = wrappedBackedTokens[chainId as ChainId];
+
+  if (!tokens) throw new UnsupportedChainIdError(chainId);
+
+  return tokens;
+};
+
+/** /!\  These tokens can not be listed in `erc20WrapperTokens` because the following specs are different:
+ * - calling `depositFor` supplies on blue instead of minting wrapped token to the user
+ */
+export const convexWrapperTokens: {
+  [id in ChainId]: Set<Address>;
+} = {
+  [ChainId.EthMainnet]: new Set([
+    addresses[ChainId.EthMainnet]["stkcvxcrvUSDTWBTCWETH-morpho"],
+    addresses[ChainId.EthMainnet]["stkcvxcrvUSDCWBTCWETH-morpho"],
+    addresses[ChainId.EthMainnet]["stkcvxcrvCRVUSDTBTCWSTETH-morpho"],
+    addresses[ChainId.EthMainnet]["stkcvxTryLSD-morpho"],
+    addresses[ChainId.EthMainnet]["stkcvxcrvUSDETHCRV-morpho"],
+  ]),
+  [ChainId.EthGoerliTestnet]: new Set(),
+  [ChainId.BaseMainnet]: new Set(),
+};

package/src/chain/chain.constants.ts

@@ -0,0 +1,235 @@
+import { ChainMetadata, ChainId } from "./chain.types";
+
+export const BLUE_AVAILABLE_CHAINS = [ChainId.EthMainnet, ChainId.BaseMainnet];
+
+export const CHAIN_METADATA: Record<ChainId, ChainMetadata> = {
+  [ChainId.EthMainnet]: {
+    name: "Ethereum",
+    id: ChainId.EthMainnet,
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    defaultRpcUrl:
+      "https://mainnet.infura.io/V3/84842078b09946638c03157f83405213",
+    explorerUrl: "https://etherscan.io",
+    isTestnet: false,
+    shortName: "ETH",
+    logoSrc: "https://cdn.morpho.org/assets/chains/eth.svg",
+    identifier: "mainnet",
+  },
+  [ChainId.EthGoerliTestnet]: {
+    name: "Ethereum Goerli Testnet",
+    id: ChainId.EthGoerliTestnet,
+    nativeCurrency: { name: "Goerli Ether", symbol: "ETH", decimals: 18 },
+    defaultRpcUrl:
+      "https://goerli.infura.io/V3/84842078b09946638c03157f83405213",
+    explorerUrl: "https://goerli.etherscan.io",
+    isTestnet: true,
+    shortName: "Goerli",
+    logoSrc: "https://cdn.morpho.org/assets/chains/eth.svg",
+    identifier: "goerli",
+  },
+  [ChainId.BaseMainnet]: {
+    name: "Base",
+    id: ChainId.BaseMainnet,
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    defaultRpcUrl: "https://rpc.baseprotocol.org",
+    explorerUrl: "https://basescan.org",
+    isTestnet: false,
+    shortName: "Base",
+    logoSrc: "https://cdn.morpho.org/assets/chains/base.png",
+    identifier: "base",
+  },
+  // [ChainId.PolygonMainnet]: {
+  //   name: "Polygon Mainnet",
+  //   id: ChainId.PolygonMainnet,
+  //   nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18n },
+  //   defaultRpcUrl: "https://rpc-mainnet.maticvigil.com",
+  //   explorerUrl: "https://polygonscan.com",
+  //   isTestnet: false,
+  //   shortName: "Polygon",
+  // },
+  // [ChainId.MumbaiTestnet]: {
+  //   name: "Mumbai Testnet",
+  //   id: ChainId.MumbaiTestnet,
+  //   nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18n },
+  //   defaultRpcUrl: "https://rpc-mumbai.maticvigil.com",
+  //   explorerUrl: "https://mumbai.polygonscan.com",
+  //   isTestnet: true,
+  //   shortName: "Mumbai",
+  // },
+
+  /* see https://chainid.network/chains.json */
+
+  // [ChainId.PolygonMainnet]: {
+  //   name: "Polygon Mainnet",
+  //   id: ChainId.PolygonMainnet,
+  //   nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18n },
+  //   defaultRpcUrl: "https://rpc-mainnet.maticvigil.com",
+  //   explorerUrl: "https://polygonscan.com",
+  //   isTestnet: false,
+  //   shortName: "Polygon",
+  // },
+  // [ChainId.MumbaiTestnet]: {
+  //   name: "Mumbai Testnet",
+  //   id: ChainId.MumbaiTestnet,
+  //   nativeCurrency: { name: "MATIC", symbol: "MATIC", decimals: 18n },
+  //   defaultRpcUrl: "https://rpc-mumbai.maticvigil.com",
+  //   explorerUrl: "https://mumbai.polygonscan.com",
+  //   isTestnet: true,
+  //   shortName: "Mumbai",
+  // },
+  // [ChainId.OptimismMainnet]: {
+  //   name: "Optimism Mainnet",
+  //   id: ChainId.OptimismMainnet,
+  //   baseCurrency: "ETH",
+  //   defaultRpcUrl: "https://mainnet.optimism.io",
+  //   explorerUrl: "https://optimistic.etherscan.io",
+  //   isTestnet: false,
+  // },
+  // [ChainId.BscMainnet]: {
+  //   name: "Binance Smart Chain Mainnet",
+  //   id: ChainId.BscMainnet,
+  //   baseCurrency: "BNB",
+  //   defaultRpcUrl: "https://bsc-dataseed.binance.org",
+  //   explorerUrl: "https://bscscan.com",
+  //   isTestnet: false,
+  // },
+  // [ChainId.ArbitrumMainnet]: {
+  //   name: "Arbitrum Mainnet",
+  //   id: ChainId.ArbitrumMainnet,
+  //   baseCurrency: "ETH",
+  //   defaultRpcUrl: "https://arb1.arbitrum.io/rpc",
+  //   explorerUrl: "https://arbiscan.io",
+  //   isTestnet: false,
+  // },
+  // [ChainId.ArbitrumTestnet]: {
+  //   name: "Arbitrum Testnet",
+  //   id: ChainId.ArbitrumTestnet,
+  //   baseCurrency: "ETH",
+  //   defaultRpcUrl: "https://rinkeby.arbitrum.io/rpc",
+  //   explorerUrl: "https://rinkeby-explorer.arbitrum.io",
+  //   isTestnet: true,
+  // },
+  // [ChainId.GnosisChain]: {
+  //   name: "Gnosis Chain",
+  //   id: ChainId.GnosisChain,
+  //   baseCurrency: "XDAI",
+  //   defaultRpcUrl: "https://rpc.xdaichain.com",
+  //   explorerUrl: "https://gnosis.blockscout.com",
+  //   isTestnet: false,
+  // },
+  // [ChainId.FantomMainnet]: {
+  //   name: "Fantom Mainnet",
+  //   id: ChainId.FantomMainnet,
+  //   baseCurrency: "FTM",
+  //   defaultRpcUrl: "https://rpcapi.fantom.network",
+  //   explorerUrl: "https://ftmscan.com",
+  //   isTestnet: false,
+  // },
+  // [ChainId.FantomTestnet]: {
+  //   name: "Fantom Testnet",
+  //   id: ChainId.FantomTestnet,
+  //   baseCurrency: "FTM",
+  //   defaultRpcUrl: "https://rpc.testnet.fantom.network",
+  //   explorerUrl: "https://explorer.testnet.fantom.network",
+  //   isTestnet: true,
+  // },
+  // [ChainId.HarmonyMainnet]: {
+  //   name: "Harmony Mainnet",
+  //   id: ChainId.HarmonyMainnet,
+  //   baseCurrency: "ONE",
+  //   defaultRpcUrl: "https://api.harmony.one",
+  //   explorerUrl: "https://explorer.harmony.one",
+  //   isTestnet: false,
+  // },
+  // [ChainId.HarmonyTestnet]: {
+  //   name: "Harmony Testnet",
+  //   id: ChainId.HarmonyTestnet,
+  //   baseCurrency: "ONE",
+  //   defaultRpcUrl: "https://api.s0.b.hmny.io",
+  //   explorerUrl: "https://explorer.testnet.harmony.one",
+  //   isTestnet: true,
+  // },
+  // [ChainId.BscTestnet]: {
+  //   name: "Binance Smart Chain Testnet",
+  //   id: ChainId.BscTestnet,
+  //   baseCurrency: "BNB",
+  //   defaultRpcUrl: "https://data-seed-prebsc-1-s1.binance.org:8545",
+  //   explorerUrl: "https://testnet.bscscan.com",
+  //   isTestnet: true,
+  // },
+  // [ChainId.OptimismTestnet]: {
+  //   name: "Optimism Testnet",
+  //   id: ChainId.OptimismTestnet,
+  //   baseCurrency: "ETH",
+  //   defaultRpcUrl: "https://kovan.optimism.io",
+  //   explorerUrl: "https://kovan-optimistic.etherscan.io",
+  //   isTestnet: true,
+  // },
+  // [ChainId.EthRopstenTestnet]: {
+  //   name: "Ethereum Ropsten Testnet",
+  //   id: ChainId.EthRopstenTestnet,
+  //   baseCurrency: "ETH",
+  //   defaultRpcUrl:
+  //     "https://ropsten.infura.io/V4/84842078b09946638c03157f83405213",
+  //   explorerUrl: "https://ropsten.etherscan.io",
+  //   isTestnet: true,
+  // },
+  // [ChainId.EthRinkebyTestnet]: {
+  //   name: "Ethereum Rinkeby Testnet",
+  //   id: ChainId.EthRinkebyTestnet,
+  //   baseCurrency: "ETH",
+  //   defaultRpcUrl:
+  //     "https://rinkeby.infura.io/V4/84842078b09946638c03157f83405213",
+  //   explorerUrl: "https://rinkeby.etherscan.io",
+  //   isTestnet: true,
+  // },
+  // [ChainId.EthKovanTestnet]: {
+  //   name: "Ethereum Kovan Testnet",
+  //   id: ChainId.EthKovanTestnet,
+  //   baseCurrency: "ETH",
+  //   defaultRpcUrl:
+  //     "https://kovan.infura.io/V4/84842078b09946638c03157f83405213",
+  //   explorerUrl: "https://kovan.etherscan.io",
+  //   isTestnet: true,
+  // },
+  // [ChainId.BaseGoerliTestnet]: {
+  //   name: "Base Goerli Testnet",
+  //   id: ChainId.BaseGoerliTestnet,
+  //   baseCurrency: "ETH",
+  //   defaultRpcUrl: "https://rpc-goerli.baseprotocol.org",
+  //   explorerUrl: "https://goerli.basescan.org",
+  //   isTestnet: true,
+  // },
+  // [ChainId.GnosisChainTestnet]: {
+  //   name: "Gnosis Chain Testnet",
+  //   id: ChainId.GnosisChainTestnet,
+  //   baseCurrency: "XDAI",
+  //   defaultRpcUrl: "https://rpc.chiado.gnosis.gateway.fm",
+  //   explorerUrl: "https://gnosis-chiado.blockscout.com/",
+  //   isTestnet: true,
+  // },
+  // [ChainId.AvalancheMainnet]: {
+  //   name: "Avalanche Mainnet",
+  //   id: ChainId.AvalancheMainnet,
+  //   baseCurrency: "AVAX",
+  //   defaultRpcUrl: "https://api.avax.network/ext/bc/C/rpc",
+  //   explorerUrl: "https://cchain.explorer.avax.network",
+  //   isTestnet: false,
+  // },
+  // [ChainId.AvalancheFujiTestnet]: {
+  //   name: "Avalanche Fuji Testnet",
+  //   id: ChainId.AvalancheFujiTestnet,
+  //   baseCurrency: "AVAX",
+  //   defaultRpcUrl: "https://api.avax-test.network/ext/bc/C/rpc",
+  //   explorerUrl: "https://cchain.explorer.avax-test.network",
+  //   isTestnet: true,
+  // },
+  // [ChainId.MoonbaseAlphaTestnet]: {
+  //   name: "Moonbase Alpha Testnet",
+  //   id: ChainId.MoonbaseAlphaTestnet,
+  //   baseCurrency: "DEV",
+  //   defaultRpcUrl: "https://rpc.testnet.moonbeam.network",
+  //   explorerUrl: "https://moonbase-blockscout.testnet.moonbeam.network",
+  //   isTestnet: true,
+  // },
+};

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;
+  }
+}