@nomicfoundation/hardhat-viem 1.0.0

package/src/index.ts

@@ -0,0 +1,42 @@
+import { extendEnvironment } from "hardhat/config";
+
+import {
+  getPublicClient,
+  getWalletClients,
+  getWalletClient,
+  getTestClient,
+} from "./internal/clients";
+import {
+  deployContract,
+  sendDeploymentTransaction,
+  getContractAt,
+} from "./internal/contracts";
+import "./internal/type-extensions";
+import "./internal/tasks";
+
+extendEnvironment((hre) => {
+  const { provider } = hre.network;
+
+  hre.viem = {
+    getPublicClient: (publicClientConfig) =>
+      getPublicClient(provider, publicClientConfig),
+
+    getWalletClients: (walletClientConfig) =>
+      getWalletClients(provider, walletClientConfig),
+
+    getWalletClient: (address, walletClientConfig) =>
+      getWalletClient(provider, address, walletClientConfig),
+
+    getTestClient: (testClientConfig) =>
+      getTestClient(provider, testClientConfig),
+
+    deployContract: (contractName, constructorArgs, config) =>
+      deployContract(hre, contractName, constructorArgs, config),
+
+    sendDeploymentTransaction: (contractName, constructorArgs, config) =>
+      sendDeploymentTransaction(hre, contractName, constructorArgs, config),
+
+    getContractAt: (contractName, address, config) =>
+      getContractAt(hre, contractName, address, config),
+  };
+});

package/src/internal/accounts.ts

@@ -0,0 +1,9 @@
+import type { EthereumProvider } from "hardhat/types";
+import type { Address } from "viem";
+
+import memoize from "lodash.memoize";
+
+export const getAccounts = memoize(
+  async (provider: EthereumProvider): Promise<Address[]> =>
+    provider.send("eth_accounts")
+);

package/src/internal/chains.ts

@@ -0,0 +1,91 @@
+import type { EthereumProvider } from "hardhat/types";
+import type { Chain } from "viem";
+import type { TestClientMode } from "../types";
+
+import memoize from "lodash.memoize";
+
+import {
+  UnknownDevelopmentNetworkError,
+  NetworkNotFoundError,
+  MultipleMatchingNetworksError,
+} from "./errors";
+
+export async function getChain(provider: EthereumProvider): Promise<Chain> {
+  const chains: Record<string, Chain> = require("viem/chains");
+  const chainId = await getChainId(provider);
+
+  if (isDevelopmentNetwork(chainId)) {
+    if (await isHardhatNetwork(provider)) {
+      return chains.hardhat;
+    } else if (await isFoundryNetwork(provider)) {
+      return chains.foundry;
+    } else {
+      throw new UnknownDevelopmentNetworkError();
+    }
+  }
+
+  const matchingChains = Object.values(chains).filter(
+    ({ id }) => id === chainId
+  );
+
+  if (matchingChains.length === 0) {
+    if (await isHardhatNetwork(provider)) {
+      return chains.hardhat;
+    } else if (await isFoundryNetwork(provider)) {
+      return chains.foundry;
+    } else {
+      throw new NetworkNotFoundError(chainId);
+    }
+  }
+
+  if (matchingChains.length > 1) {
+    throw new MultipleMatchingNetworksError(chainId);
+  }
+
+  return matchingChains[0];
+}
+
+export function isDevelopmentNetwork(chainId: number) {
+  return chainId === 31337;
+}
+
+export async function getMode(
+  provider: EthereumProvider
+): Promise<TestClientMode> {
+  if (await isHardhatNetwork(provider)) {
+    return "hardhat";
+  } else if (await isFoundryNetwork(provider)) {
+    return "anvil";
+  } else {
+    throw new UnknownDevelopmentNetworkError();
+  }
+}
+
+const getChainId = memoize(async (provider: EthereumProvider) =>
+  Number(await provider.send("eth_chainId"))
+);
+
+const isHardhatNetwork = memoize(async (provider: EthereumProvider) =>
+  detectNetworkByMethodName(provider, NetworkMethod.HARDHAT_METADATA)
+);
+
+const isFoundryNetwork = memoize(async (provider: EthereumProvider) =>
+  detectNetworkByMethodName(provider, NetworkMethod.ANVIL_NODE_INFO)
+);
+
+enum NetworkMethod {
+  HARDHAT_METADATA = "hardhat_metadata",
+  ANVIL_NODE_INFO = "anvil_nodeInfo",
+}
+
+async function detectNetworkByMethodName(
+  provider: EthereumProvider,
+  methodName: string
+) {
+  try {
+    await provider.send(methodName);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/internal/clients.ts

@@ -0,0 +1,152 @@
+import type { EthereumProvider } from "hardhat/types";
+import type {
+  Address,
+  Chain,
+  PublicClientConfig,
+  WalletClientConfig,
+  TestClientConfig,
+} from "viem";
+import type {
+  PublicClient,
+  TestClient,
+  TestClientMode,
+  WalletClient,
+} from "../types";
+
+import { getChain, getMode, isDevelopmentNetwork } from "./chains";
+import { getAccounts } from "./accounts";
+
+/**
+ * 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(
+  provider: EthereumProvider,
+  publicClientConfig?: Partial<PublicClientConfig>
+): Promise<PublicClient> {
+  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 defaultParameters = isDevelopmentNetwork(chain.id)
+    ? { pollingInterval: 50, cacheTime: 0 }
+    : {};
+  const parameters = { ...defaultParameters, ...publicClientConfig };
+
+  const publicClient = viem.createPublicClient({
+    chain,
+    transport: viem.custom(provider),
+    ...parameters,
+  });
+
+  return publicClient;
+}
+
+/**
+ * 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 a 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 chain = walletClientConfig?.chain ?? (await getChain(provider));
+  const accounts = await getAccounts(provider);
+  return innerGetWalletClients(provider, chain, accounts, walletClientConfig);
+}
+
+export async function innerGetWalletClients(
+  provider: EthereumProvider,
+  chain: Chain,
+  accounts: Address[],
+  walletClientConfig?: Partial<WalletClientConfig>
+): Promise<WalletClient[]> {
+  const viem = await import("viem");
+  const defaultParameters = isDevelopmentNetwork(chain.id)
+    ? { pollingInterval: 50, cacheTime: 0 }
+    : {};
+  const parameters = { ...defaultParameters, ...walletClientConfig };
+
+  const walletClients = accounts.map((account) =>
+    viem.createWalletClient({
+      chain,
+      account,
+      transport: viem.custom(provider),
+      ...parameters,
+    })
+  );
+
+  return walletClients;
+}
+
+/**
+ * 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(
+  provider: EthereumProvider,
+  address: Address,
+  walletClientConfig?: Partial<WalletClientConfig>
+): Promise<WalletClient> {
+  const chain = walletClientConfig?.chain ?? (await getChain(provider));
+  return (
+    await innerGetWalletClients(provider, chain, [address], walletClientConfig)
+  )[0];
+}
+
+/**
+ * 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(
+  provider: EthereumProvider,
+  testClientConfig?: Partial<TestClientConfig>
+): Promise<TestClient> {
+  const chain = testClientConfig?.chain ?? (await getChain(provider));
+  const mode = await getMode(provider);
+  return innerGetTestClient(provider, chain, mode, testClientConfig);
+}
+
+export async function innerGetTestClient(
+  provider: EthereumProvider,
+  chain: Chain,
+  mode: TestClientMode,
+  testClientConfig?: Partial<TestClientConfig>
+): Promise<TestClient> {
+  const viem = await import("viem");
+  const defaultParameters = { pollingInterval: 50, cacheTime: 0 };
+  const parameters = { ...defaultParameters, ...testClientConfig };
+
+  const testClient = viem.createTestClient({
+    mode,
+    chain,
+    transport: viem.custom(provider),
+    ...parameters,
+  });
+
+  return testClient;
+}

package/src/internal/contracts.ts

@@ -0,0 +1,243 @@
+import type {
+  EthereumProvider,
+  HardhatRuntimeEnvironment,
+} from "hardhat/types";
+import type { Abi, Address, Hex } from "viem";
+import type {
+  DeployContractConfig,
+  GetContractAtConfig,
+  GetContractReturnType,
+  GetTransactionReturnType,
+  PublicClient,
+  SendDeploymentTransactionConfig,
+  WalletClient,
+} from "../types";
+
+import { getPublicClient, getWalletClients } from "./clients";
+import {
+  DefaultWalletClientNotFoundError,
+  DeployContractError,
+  HardhatViemError,
+  InvalidConfirmationsError,
+} from "./errors";
+
+export async function deployContract(
+  { artifacts, network }: HardhatRuntimeEnvironment,
+  contractName: string,
+  constructorArgs: any[] = [],
+  config: DeployContractConfig = {}
+): Promise<GetContractReturnType> {
+  const {
+    walletClient: configWalletClient,
+    confirmations,
+    ...deployContractParameters
+  } = config;
+  const [publicClient, walletClient, contractArtifact] = await Promise.all([
+    getPublicClient(network.provider),
+    configWalletClient ??
+      getDefaultWalletClient(network.provider, network.name),
+    artifacts.readArtifact(contractName),
+  ]);
+
+  return innerDeployContract(
+    publicClient,
+    walletClient,
+    contractArtifact.abi,
+    contractArtifact.bytecode as Hex,
+    constructorArgs,
+    deployContractParameters,
+    confirmations
+  );
+}
+
+export async function innerDeployContract(
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  contractAbi: Abi,
+  contractBytecode: Hex,
+  constructorArgs: any[],
+  deployContractParameters: DeployContractConfig = {},
+  confirmations: number = 1
+): Promise<GetContractReturnType> {
+  let deploymentTxHash: Hex;
+  // If gasPrice is defined, then maxFeePerGas and maxPriorityFeePerGas
+  // must be undefined because it's a legaxy tx.
+  if (deployContractParameters.gasPrice !== undefined) {
+    deploymentTxHash = await walletClient.deployContract({
+      abi: contractAbi,
+      bytecode: contractBytecode,
+      args: constructorArgs,
+      ...deployContractParameters,
+      maxFeePerGas: undefined,
+      maxPriorityFeePerGas: undefined,
+    });
+  } else {
+    deploymentTxHash = await walletClient.deployContract({
+      abi: contractAbi,
+      bytecode: contractBytecode,
+      args: constructorArgs,
+      ...deployContractParameters,
+      gasPrice: undefined,
+    });
+  }
+
+  if (confirmations < 0) {
+    throw new HardhatViemError("Confirmations must be greater than 0.");
+  }
+  if (confirmations === 0) {
+    throw new InvalidConfirmationsError();
+  }
+
+  const { contractAddress } = await publicClient.waitForTransactionReceipt({
+    hash: deploymentTxHash,
+    confirmations,
+  });
+
+  if (contractAddress === null) {
+    const transaction = await publicClient.getTransaction({
+      hash: deploymentTxHash,
+    });
+    throw new DeployContractError(deploymentTxHash, transaction.blockNumber);
+  }
+
+  const contract = await innerGetContractAt(
+    publicClient,
+    walletClient,
+    contractAbi,
+    contractAddress
+  );
+
+  return contract;
+}
+
+export async function sendDeploymentTransaction(
+  { artifacts, network }: HardhatRuntimeEnvironment,
+  contractName: string,
+  constructorArgs: any[] = [],
+  config: SendDeploymentTransactionConfig = {}
+): Promise<{
+  contract: GetContractReturnType;
+  deploymentTransaction: GetTransactionReturnType;
+}> {
+  const { walletClient: configWalletClient, ...deployContractParameters } =
+    config;
+  const [publicClient, walletClient, contractArtifact] = await Promise.all([
+    getPublicClient(network.provider),
+    configWalletClient ??
+      getDefaultWalletClient(network.provider, network.name),
+    artifacts.readArtifact(contractName),
+  ]);
+
+  return innerSendDeploymentTransaction(
+    publicClient,
+    walletClient,
+    contractArtifact.abi,
+    contractArtifact.bytecode as Hex,
+    constructorArgs,
+    deployContractParameters
+  );
+}
+
+async function innerSendDeploymentTransaction(
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  contractAbi: Abi,
+  contractBytecode: Hex,
+  constructorArgs: any[],
+  deployContractParameters: SendDeploymentTransactionConfig = {}
+): Promise<{
+  contract: GetContractReturnType;
+  deploymentTransaction: GetTransactionReturnType;
+}> {
+  let deploymentTxHash: Hex;
+  // If gasPrice is defined, then maxFeePerGas and maxPriorityFeePerGas
+  // must be undefined because it's a legaxy tx.
+  if (deployContractParameters.gasPrice !== undefined) {
+    deploymentTxHash = await walletClient.deployContract({
+      abi: contractAbi,
+      bytecode: contractBytecode,
+      args: constructorArgs,
+      ...deployContractParameters,
+      maxFeePerGas: undefined,
+      maxPriorityFeePerGas: undefined,
+    });
+  } else {
+    deploymentTxHash = await walletClient.deployContract({
+      abi: contractAbi,
+      bytecode: contractBytecode,
+      args: constructorArgs,
+      ...deployContractParameters,
+      gasPrice: undefined,
+    });
+  }
+
+  const deploymentTx = await publicClient.getTransaction({
+    hash: deploymentTxHash,
+  });
+
+  const { getContractAddress } = await import("viem");
+  const contractAddress = getContractAddress({
+    from: walletClient.account.address,
+    nonce: BigInt(deploymentTx.nonce),
+  });
+
+  const contract = await innerGetContractAt(
+    publicClient,
+    walletClient,
+    contractAbi,
+    contractAddress
+  );
+
+  return { contract, deploymentTransaction: deploymentTx };
+}
+
+export async function getContractAt(
+  { artifacts, network }: HardhatRuntimeEnvironment,
+  contractName: string,
+  address: Address,
+  config: GetContractAtConfig = {}
+): Promise<GetContractReturnType> {
+  const [publicClient, walletClient, contractArtifact] = await Promise.all([
+    getPublicClient(network.provider),
+    config.walletClient ??
+      getDefaultWalletClient(network.provider, network.name),
+    artifacts.readArtifact(contractName),
+  ]);
+
+  return innerGetContractAt(
+    publicClient,
+    walletClient,
+    contractArtifact.abi,
+    address
+  );
+}
+
+async function innerGetContractAt(
+  publicClient: PublicClient,
+  walletClient: WalletClient,
+  contractAbi: Abi,
+  address: Address
+): Promise<GetContractReturnType> {
+  const viem = await import("viem");
+  const contract = viem.getContract({
+    address,
+    publicClient,
+    walletClient,
+    abi: contractAbi,
+  });
+
+  return contract;
+}
+
+async function getDefaultWalletClient(
+  provider: EthereumProvider,
+  networkName: string
+): Promise<WalletClient> {
+  const [defaultWalletClient] = await getWalletClients(provider);
+
+  if (defaultWalletClient === undefined) {
+    throw new DefaultWalletClientNotFoundError(networkName);
+  }
+
+  return defaultWalletClient;
+}

package/src/internal/errors.ts

@@ -0,0 +1,76 @@
+import { NomicLabsHardhatPluginError } from "hardhat/plugins";
+
+export class HardhatViemError extends NomicLabsHardhatPluginError {
+  constructor(message: string, parent?: Error) {
+    super("@nomicfoundation/hardhat-viem", message, parent);
+  }
+}
+
+export class UnknownDevelopmentNetworkError extends HardhatViemError {
+  constructor() {
+    super(`The chain id corresponds to a development network but we couldn't detect which one.
+Please report this issue if you're using Hardhat or Foundry.`);
+  }
+}
+
+export class NetworkNotFoundError extends HardhatViemError {
+  constructor(chainId: number) {
+    super(
+      `No network with chain id ${chainId} found. You can override the chain by passing it as a parameter to the client getter:
+
+import { someChain } from "viem/chains";
+const client = await hre.viem.getPublicClient({
+  chain: someChain,
+  ...
+});
+
+You can find a list of supported networks here: https://viem.sh/docs/clients/chains.html`
+    );
+  }
+}
+
+export class MultipleMatchingNetworksError extends HardhatViemError {
+  constructor(chainId: number) {
+    super(
+      `Multiple networks with chain id ${chainId} found. You can override the chain by passing it as a parameter to the client getter:
+
+import { someChain } from "viem/chains";
+const client = await hre.viem.getPublicClient({
+  chain: someChain,
+  ...
+});
+
+You can find a list of supported networks here: https://viem.sh/docs/clients/chains.html`
+    );
+  }
+}
+
+export class DefaultWalletClientNotFoundError extends HardhatViemError {
+  constructor(networkName: string) {
+    super(
+      `Default wallet client not found. This can happen if no accounts were configured for this network (network: '${networkName}').
+
+Alternatively, you can set a custom wallet client by passing it as a parameter in the deployContract function:
+
+const walletClient = await hre.viem.getWalletClient(address);
+const contractA = await hre.viem.deployContract("A", [], { walletClient });
+const contractB = await hre.viem.getContractAt("B", address, { walletClient });`
+    );
+  }
+}
+
+export class InvalidConfirmationsError extends HardhatViemError {
+  constructor() {
+    super(
+      "deployContract does not support 0 confirmations. Use sendDeploymentTransaction if you want to handle the deployment transaction yourself."
+    );
+  }
+}
+
+export class DeployContractError extends HardhatViemError {
+  constructor(txHash: string, blockNumber: bigint) {
+    super(
+      `The deployment transaction '${txHash}' was mined in block '${blockNumber}' but its receipt doesn't contain a contract address`
+    );
+  }
+}