@nomicfoundation/hardhat-viem 2.0.5 → 3.0.0-next.0

package/src/internal/accounts.ts

@@ -1,9 +1,22 @@
-import type { EthereumProvider } from "hardhat/types";
-import type { Address } from "viem";
+import type { EthereumProvider } from "hardhat/types/providers";
+import type { Address as ViemAddress } from "viem";
 
-import memoize from "lodash.memoize";
+const accountsCache = new WeakMap<EthereumProvider, ViemAddress[]>();
 
-export const getAccounts = memoize(
-  async (provider: EthereumProvider): Promise<Address[]> =>
-    provider.send("eth_accounts")
-);
+export async function getAccounts(
+  provider: EthereumProvider,
+): Promise<ViemAddress[]> {
+  const cachedAccounts = accountsCache.get(provider);
+  if (cachedAccounts !== undefined) {
+    return cachedAccounts;
+  }
+
+  /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  -- We know that the provider is going to return an array of accounts */
+  const accounts = (await provider.request({
+    method: "eth_accounts",
+  })) as ViemAddress[];
+  accountsCache.set(provider, accounts);
+
+  return accounts;
+}

package/src/internal/chains.ts

@@ -1,95 +1,155 @@
-import type { EthereumProvider } from "hardhat/types";
-import type { Chain } from "viem";
-import type { TestClientMode } from "../types";
-
-import memoize from "lodash.memoize";
+import type { TestClientMode } from "../types.js";
+import type { ChainType } from "hardhat/types/network";
+import type { EthereumProvider } from "hardhat/types/providers";
+import type { Chain as ViemChain } from "viem";
 
 import {
-  UnknownDevelopmentNetworkError,
-  NetworkNotFoundError,
-  MultipleMatchingNetworksError,
-} from "./errors";
+  assertHardhatInvariant,
+  HardhatError,
+} from "@nomicfoundation/hardhat-errors";
+import { extractChain } from "viem";
+import * as chainsModule from "viem/chains";
+import { hardhat, anvil, optimism } from "viem/chains";
 
-export async function getChain(provider: EthereumProvider): Promise<Chain> {
-  const chains: Record<string, Chain> = require("viem/chains");
-  const chainId = await getChainId(provider);
+/* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+-- TODO: this assertion should not be necessary */
+const chains = Object.values(chainsModule) as ViemChain[];
 
-  if (isDevelopmentNetwork(chainId)) {
-    if (await isHardhatNetwork(provider)) {
-      return chains.hardhat;
-    } else if (await isFoundryNetwork(provider)) {
-      return chains.foundry;
-    } else {
-      throw new UnknownDevelopmentNetworkError();
-    }
+const chainCache = new WeakMap<EthereumProvider, ViemChain>();
+const chainIdCache = new WeakMap<EthereumProvider, number>();
+const isHardhatNetworkCache = new WeakMap<EthereumProvider, boolean>();
+const isAnvilNetworkCache = new WeakMap<EthereumProvider, boolean>();
+
+const HARDHAT_METADATA_METHOD = "hardhat_metadata";
+const ANVIL_NODE_INFO_METHOD = "anvil_nodeInfo";
+
+export async function getChain(
+  provider: EthereumProvider,
+  chainType: ChainType | string,
+): Promise<ViemChain> {
+  const cachedChain = chainCache.get(provider);
+  if (cachedChain !== undefined) {
+    return cachedChain;
   }
 
-  const matchingChains = Object.values(chains).filter(
-    ({ id }) => id === chainId
-  );
+  const chainId = await getChainId(provider);
+
+  let chain = extractChain({
+    chains,
+    id: chainId,
+  });
 
-  if (matchingChains.length === 0) {
+  if ((await isDevelopmentNetwork(provider)) || chain === undefined) {
     if (await isHardhatNetwork(provider)) {
-      return {
-        ...chains.hardhat,
-        id: chainId,
-      };
-    } else if (await isFoundryNetwork(provider)) {
-      return {
-        ...chains.foundry,
+      // TODO: We shoud improve how we handle the chains for the different chain
+      // types, as this is both a hardhat and an optimism chain.
+      //
+      // We are currently creating our chain based off optimism's, but that's
+      // not always the correct behavior, as the user may be connecting to
+      // a different chain.
+      if (chainType === "optimism") {
+        chain = { ...optimism, id: chainId };
+      } else {
+        chain = {
+          ...hardhat,
+          id: chainId,
+        };
+      }
+    } else if (await isAnvilNetwork(provider)) {
+      chain = {
+        ...anvil,
         id: chainId,
       };
+    } else if (chain === undefined) {
+      // If the chain couldn't be found and we can't detect the development
+      // network we throw an error.
+      throw new HardhatError(HardhatError.ERRORS.VIEM.NETWORK_NOT_FOUND, {
+        chainId,
+      });
     } else {
-      throw new NetworkNotFoundError(chainId);
+      assertHardhatInvariant(
+        false,
+        "This should not happen, as we check in isDevelopmentNetwork that it's either hardhat or anvil",
+      );
     }
   }
 
-  if (matchingChains.length > 1) {
-    throw new MultipleMatchingNetworksError(chainId);
-  }
+  chainCache.set(provider, chain);
 
-  return matchingChains[0];
+  return chain;
 }
 
-export function isDevelopmentNetwork(chainId: number) {
-  return chainId === 31337;
+export async function getChainId(provider: EthereumProvider): Promise<number> {
+  const cachedChainId = chainIdCache.get(provider);
+  if (cachedChainId !== undefined) {
+    return cachedChainId;
+  }
+
+  const chainId = Number(await provider.request({ method: "eth_chainId" }));
+  chainIdCache.set(provider, chainId);
+
+  return chainId;
 }
 
-export async function getMode(
-  provider: EthereumProvider
-): Promise<TestClientMode> {
+export async function isDevelopmentNetwork(
+  provider: EthereumProvider,
+): Promise<boolean> {
   if (await isHardhatNetwork(provider)) {
-    return "hardhat";
-  } else if (await isFoundryNetwork(provider)) {
-    return "anvil";
-  } else {
-    throw new UnknownDevelopmentNetworkError();
+    return true;
+  }
+
+  if (await isAnvilNetwork(provider)) {
+    return true;
   }
+
+  return false;
 }
 
-const getChainId = memoize(async (provider: EthereumProvider) =>
-  Number(await provider.send("eth_chainId"))
-);
+export async function isHardhatNetwork(
+  provider: EthereumProvider,
+): Promise<boolean> {
+  const cachedIsHardhat = isHardhatNetworkCache.get(provider);
+  if (cachedIsHardhat !== undefined) {
+    return cachedIsHardhat;
+  }
+
+  const isHardhat = await isMethodSupported(provider, HARDHAT_METADATA_METHOD);
+  isHardhatNetworkCache.set(provider, isHardhat);
 
-const isHardhatNetwork = memoize(async (provider: EthereumProvider) =>
-  detectNetworkByMethodName(provider, NetworkMethod.HARDHAT_METADATA)
-);
+  return isHardhat;
+}
+
+export async function isAnvilNetwork(
+  provider: EthereumProvider,
+): Promise<boolean> {
+  const cachedIsAnvil = isAnvilNetworkCache.get(provider);
+  if (cachedIsAnvil !== undefined) {
+    return cachedIsAnvil;
+  }
 
-const isFoundryNetwork = memoize(async (provider: EthereumProvider) =>
-  detectNetworkByMethodName(provider, NetworkMethod.ANVIL_NODE_INFO)
-);
+  const isAnvil = await isMethodSupported(provider, ANVIL_NODE_INFO_METHOD);
+  isAnvilNetworkCache.set(provider, isAnvil);
 
-enum NetworkMethod {
-  HARDHAT_METADATA = "hardhat_metadata",
-  ANVIL_NODE_INFO = "anvil_nodeInfo",
+  return isAnvil;
 }
 
-async function detectNetworkByMethodName(
+export async function getMode(
   provider: EthereumProvider,
-  methodName: string
-) {
+): Promise<TestClientMode> {
+  if (await isHardhatNetwork(provider)) {
+    return "hardhat";
+  }
+  if (await isAnvilNetwork(provider)) {
+    return "anvil";
+  }
+  throw new HardhatError(
+    HardhatError.ERRORS.VIEM.UNSUPPORTED_DEVELOPMENT_NETWORK,
+  );
+}
+
+async function isMethodSupported(provider: EthereumProvider, method: string) {
   try {
-    await provider.send(methodName);
+    await provider.request({ method });
     return true;
   } catch {
     return false;

package/src/internal/clients.ts

@@ -1,176 +1,170 @@
-import type { EthereumProvider } from "hardhat/types";
 import type {
-  Address,
-  Chain,
-  PublicClientConfig,
-  WalletClientConfig,
-  TestClientConfig,
-} from "viem";
-import type {
-  PublicClient,
+  GetPublicClientReturnType,
+  GetWalletClientReturnType,
   TestClient,
-  TestClientMode,
-  WalletClient,
-} from "../types";
-
-async function getParameters<TConfig extends {} | undefined>(
-  chain: Chain,
-  config: TConfig
-) {
-  const { isDevelopmentNetwork } = await import("./chains");
-
-  const defaultParameters = isDevelopmentNetwork(chain.id)
-    ? { pollingInterval: 50, cacheTime: 0 }
-    : {};
+} from "../types.js";
+import type { ChainType } from "hardhat/types/network";
+import type { EthereumProvider } from "hardhat/types/providers";
+import type {
+  Address as ViemAddress,
+  PublicClientConfig as ViemPublicClientConfig,
+  TestClientConfig as ViemTestClientConfig,
+  WalletClientConfig as ViemWalletClientConfig,
+} from "viem";
 
-  const transportParameters = isDevelopmentNetwork(chain.id)
-    ? { retryCount: 0 }
-    : {};
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+import {
+  createPublicClient,
+  createWalletClient,
+  createTestClient,
+  custom as customTransport,
+} from "viem";
+import { publicActionsL2, walletActionsL2 } from "viem/op-stack";
 
-  return {
-    clientParameters: { ...defaultParameters, ...config },
-    transportParameters,
-  };
-}
+import { getAccounts } from "./accounts.js";
+import { getChain, getMode, isDevelopmentNetwork } from "./chains.js";
 
-/**
- * Get a PublicClient instance. This is a read-only client that can be used to
- * query the blockchain.
- *
- * @param provider The Ethereum provider used to connect to the blockchain.
- * @param publicClientConfig Optional configuration for the PublicClient instance. See the viem documentation for more information.
- * @returns A PublicClient instance.
- */
-export async function getPublicClient(
+export async function getPublicClient<ChainTypeT extends ChainType | string>(
   provider: EthereumProvider,
-  publicClientConfig?: Partial<PublicClientConfig>
-): Promise<PublicClient> {
-  const { getChain } = await import("./chains");
-  const chain = publicClientConfig?.chain ?? (await getChain(provider));
-  return innerGetPublicClient(provider, chain, publicClientConfig);
-}
-
-export async function innerGetPublicClient(
-  provider: EthereumProvider,
-  chain: Chain,
-  publicClientConfig?: Partial<PublicClientConfig>
-): Promise<PublicClient> {
-  const viem = await import("viem");
-  const { clientParameters, transportParameters } = await getParameters(
-    chain,
-    publicClientConfig
-  );
+  chainType: ChainTypeT,
+  publicClientConfig?: Partial<ViemPublicClientConfig>,
+): Promise<GetPublicClientReturnType<ChainTypeT>> {
+  const chain =
+    publicClientConfig?.chain ?? (await getChain(provider, chainType));
+  const parameters = {
+    ...(await getDefaultClientParameters(provider)),
+    ...publicClientConfig,
+  };
 
-  const publicClient = viem.createPublicClient({
+  let publicClient = createPublicClient({
     chain,
-    transport: viem.custom(provider, transportParameters),
-    ...clientParameters,
+    transport: customTransport(provider),
+    ...parameters,
   });
 
-  return publicClient;
-}
+  if (chainType === "optimism") {
+    publicClient = publicClient.extend(publicActionsL2());
+  }
 
-/**
- * Get a list of WalletClient instances. These are read-write clients that can
- * be used to send transactions to the blockchain. Each client is associated
- * with an account obtained from the provider using `eth_accounts`.
- *
- * @param provider The Ethereum provider used to connect to the blockchain.
- * @param walletClientConfig Optional configuration for the WalletClient instances. See the viem documentation for more information.
- * @returns A list of WalletClient instances.
- */
-export async function getWalletClients(
-  provider: EthereumProvider,
-  walletClientConfig?: Partial<WalletClientConfig>
-): Promise<WalletClient[]> {
-  const { getAccounts } = await import("./accounts");
-  const { getChain } = await import("./chains");
-  const chain = walletClientConfig?.chain ?? (await getChain(provider));
-  const accounts = await getAccounts(provider);
-  return innerGetWalletClients(provider, chain, accounts, walletClientConfig);
+  /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
+  We need to assert the type because TS gets confused with the conditional type */
+  return publicClient as GetPublicClientReturnType<ChainTypeT>;
 }
 
-export async function innerGetWalletClients(
+export async function getWalletClients<ChainTypeT extends ChainType | string>(
   provider: EthereumProvider,
-  chain: Chain,
-  accounts: Address[],
-  walletClientConfig?: Partial<WalletClientConfig>
-): Promise<WalletClient[]> {
-  const viem = await import("viem");
-  const { clientParameters, transportParameters } = await getParameters(
-    chain,
-    walletClientConfig
-  );
+  chainType: ChainTypeT,
+  walletClientConfig?: Partial<ViemWalletClientConfig>,
+): Promise<Array<GetWalletClientReturnType<ChainTypeT>>> {
+  const chain =
+    walletClientConfig?.chain ?? (await getChain(provider, chainType));
+  const accounts = await getAccounts(provider);
+  const parameters = {
+    ...(await getDefaultClientParameters(provider)),
+    ...walletClientConfig,
+  };
 
-  const walletClients = accounts.map((account) =>
-    viem.createWalletClient({
+  let walletClients = accounts.map((account) =>
+    createWalletClient({
       chain,
       account,
-      transport: viem.custom(provider, transportParameters),
-      ...clientParameters,
-    })
+      transport: customTransport(provider),
+      ...parameters,
+    }),
   );
 
-  return walletClients;
+  if (chainType === "optimism") {
+    walletClients = walletClients.map((walletClient) =>
+      walletClient.extend(walletActionsL2()),
+    );
+  }
+
+  /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
+  We need to assert the type because TS gets confused with the conditional type */
+  return walletClients as Array<GetWalletClientReturnType<ChainTypeT>>;
 }
 
-/**
- * Get a WalletClient instance for a specific address. This is a read-write
- * client that can be used to send transactions to the blockchain.
- *
- * @param provider The Ethereum provider used to connect to the blockchain.
- * @param address The public address of the account to use.
- * @param walletClientConfig Optional configuration for the WalletClient instance. See the viem documentation for more information.
- * @returns A WalletClient instance.
- */
-export async function getWalletClient(
+export async function getWalletClient<ChainTypeT extends ChainType | string>(
   provider: EthereumProvider,
-  address: Address,
-  walletClientConfig?: Partial<WalletClientConfig>
-): Promise<WalletClient> {
-  const { getChain } = await import("./chains");
-  const chain = walletClientConfig?.chain ?? (await getChain(provider));
-  return (
-    await innerGetWalletClients(provider, chain, [address], walletClientConfig)
-  )[0];
+  chainType: ChainTypeT,
+  address: ViemAddress,
+  walletClientConfig?: Partial<ViemWalletClientConfig>,
+): Promise<GetWalletClientReturnType<ChainTypeT>> {
+  const chain =
+    walletClientConfig?.chain ?? (await getChain(provider, chainType));
+  const parameters = {
+    ...(await getDefaultClientParameters(provider)),
+    ...walletClientConfig,
+  };
+
+  let walletClient = createWalletClient({
+    chain,
+    account: address,
+    transport: customTransport(provider),
+    ...parameters,
+  });
+
+  if (chainType === "optimism") {
+    walletClient = walletClient.extend(walletActionsL2());
+  }
+
+  /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
+  We need to assert the type because TS gets confused with the conditional type */
+  return walletClient as GetWalletClientReturnType<ChainTypeT>;
 }
 
-/**
- * Get a TestClient instance. This is a read-write client that can be used to
- * perform actions only available on test nodes such as hardhat or anvil.
- *
- * @param provider The Ethereum provider used to connect to the blockchain.
- * @param testClientConfig Optional configuration for the TestClient instance. See the viem documentation for more information.
- * @returns A TestClient instance.
- */
-export async function getTestClient(
+export async function getDefaultWalletClient<
+  ChainTypeT extends ChainType | string,
+>(
   provider: EthereumProvider,
-  testClientConfig?: Partial<TestClientConfig>
-): Promise<TestClient> {
-  const { getChain, getMode } = await import("./chains");
-  const chain = testClientConfig?.chain ?? (await getChain(provider));
-  const mode = await getMode(provider);
-  return innerGetTestClient(provider, chain, mode, testClientConfig);
+  chainType: ChainTypeT,
+  walletClientConfig?: Partial<ViemWalletClientConfig>,
+): Promise<GetWalletClientReturnType<ChainTypeT>> {
+  const chain =
+    walletClientConfig?.chain ?? (await getChain(provider, chainType));
+  const [defaultAccount] = await getAccounts(provider);
+
+  if (defaultAccount === undefined) {
+    throw new HardhatError(
+      HardhatError.ERRORS.VIEM.DEFAULT_WALLET_CLIENT_NOT_FOUND,
+      {
+        chainId: chain.id,
+      },
+    );
+  }
+
+  return getWalletClient(
+    provider,
+    chainType,
+    defaultAccount,
+    walletClientConfig,
+  );
 }
 
-export async function innerGetTestClient(
+export async function getTestClient<ChainTypeT extends ChainType | string>(
   provider: EthereumProvider,
-  chain: Chain,
-  mode: TestClientMode,
-  testClientConfig?: Partial<TestClientConfig>
+  chainType: ChainTypeT,
+  testClientConfig?: Partial<ViemTestClientConfig>,
 ): Promise<TestClient> {
-  const viem = await import("viem");
-  const { clientParameters, transportParameters } = await getParameters(
-    chain,
-    testClientConfig
-  );
+  const chain =
+    testClientConfig?.chain ?? (await getChain(provider, chainType));
+  const mode = await getMode(provider);
+  const parameters = { ...DEFAULT_CLIENT_PARAMETERS, ...testClientConfig };
 
-  const testClient = viem.createTestClient({
-    mode,
+  const testClient = createTestClient({
     chain,
-    transport: viem.custom(provider, transportParameters),
-    ...clientParameters,
+    mode,
+    transport: customTransport(provider),
+    ...parameters,
   });
 
   return testClient;
 }
+
+const DEFAULT_CLIENT_PARAMETERS = { pollingInterval: 50, cacheTime: 0 };
+
+async function getDefaultClientParameters(provider: EthereumProvider) {
+  return (await isDevelopmentNetwork(provider))
+    ? DEFAULT_CLIENT_PARAMETERS
+    : {};
+}