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

package/src/internal/contracts.ts

@@ -1,89 +1,65 @@
 import type {
-  EthereumProvider,
-  HardhatRuntimeEnvironment,
-} from "hardhat/types";
-import type { Abi, Address, Hex } from "viem";
-import type {
+  ContractReturnType,
   DeployContractConfig,
   GetContractAtConfig,
-  GetContractReturnType,
   GetTransactionReturnType,
+  Libraries,
   PublicClient,
   SendDeploymentTransactionConfig,
   WalletClient,
-} from "../types";
+} from "../types.js";
+import type { PrefixedHexString } from "@nomicfoundation/hardhat-utils/hex";
+import type { ArtifactManager } from "hardhat/types/artifacts";
+import type { EthereumProvider } from "hardhat/types/providers";
+import type { Abi as ViemAbi, Address as ViemAddress } from "viem";
 
-import { Libraries, resolveBytecodeWithLinkedLibraries } from "./bytecode";
-import { getPublicClient, getWalletClients } from "./clients";
-import {
-  DefaultWalletClientNotFoundError,
-  DeployContractError,
-  HardhatViemError,
-  InvalidConfirmationsError,
-} from "./errors";
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+import { toBigInt } from "@nomicfoundation/hardhat-utils/bigint";
+import { resolveLinkedBytecode } from "@nomicfoundation/hardhat-utils/bytecode";
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
+import { getContractAddress, getContract } from "viem";
 
-async function getContractAbiAndBytecode(
-  artifacts: HardhatRuntimeEnvironment["artifacts"],
-  contractName: string,
-  libraries: Libraries<Address>
-) {
-  const artifact = await artifacts.readArtifact(contractName);
-  const bytecode = await resolveBytecodeWithLinkedLibraries(
-    artifact,
-    libraries
-  );
+import { getDefaultWalletClient, getPublicClient } from "./clients.js";
 
-  return {
-    abi: artifact.abi,
-    bytecode,
-  };
-}
-
-export async function deployContract(
-  { artifacts, network }: HardhatRuntimeEnvironment,
-  contractName: string,
-  constructorArgs: any[] = [],
-  config: DeployContractConfig = {}
-): Promise<GetContractReturnType> {
+export async function deployContract<ContractName extends string>(
+  provider: EthereumProvider,
+  artifactManager: ArtifactManager,
+  contractName: ContractName,
+  constructorArgs: unknown[] = [],
+  deployContractConfig: DeployContractConfig = {},
+): Promise<ContractReturnType<ContractName>> {
   const {
     client,
-    confirmations,
+    confirmations = 1,
     libraries = {},
     ...deployContractParameters
-  } = config;
+  } = deployContractConfig;
+
+  if (confirmations < 0) {
+    throw new HardhatError(HardhatError.ERRORS.VIEM.INVALID_CONFIRMATIONS, {
+      error: "Confirmations must be greather than 0.",
+    });
+  }
+  if (confirmations === 0) {
+    throw new HardhatError(HardhatError.ERRORS.VIEM.INVALID_CONFIRMATIONS, {
+      error:
+        "deployContract does not support 0 confirmations. Use sendDeploymentTransaction if you want to handle the deployment transaction yourself.",
+    });
+  }
+
   const [publicClient, walletClient, { abi, bytecode }] = await Promise.all([
-    client?.public ?? getPublicClient(network.provider),
-    client?.wallet ?? getDefaultWalletClient(network.provider, network.name),
-    getContractAbiAndBytecode(artifacts, contractName, libraries),
+    client?.public ?? getPublicClient(provider, "l1"),
+    client?.wallet ?? getDefaultWalletClient(provider, "l1"),
+    getContractAbiAndBytecode(artifactManager, contractName, libraries),
   ]);
 
-  return innerDeployContract(
-    publicClient,
-    walletClient,
-    abi,
-    bytecode,
-    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;
+  let deploymentTxHash: PrefixedHexString;
   // 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,
+      abi,
+      bytecode,
       args: constructorArgs,
       ...deployContractParameters,
       maxFeePerGas: undefined,
@@ -91,21 +67,14 @@ export async function innerDeployContract(
     });
   } else {
     deploymentTxHash = await walletClient.deployContract({
-      abi: contractAbi,
-      bytecode: contractBytecode,
+      abi,
+      bytecode,
       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,
@@ -115,63 +84,51 @@ export async function innerDeployContract(
     const transaction = await publicClient.getTransaction({
       hash: deploymentTxHash,
     });
-    throw new DeployContractError(deploymentTxHash, transaction.blockNumber);
+    throw new HardhatError(HardhatError.ERRORS.VIEM.DEPLOY_CONTRACT_ERROR, {
+      txHash: deploymentTxHash,
+      blockNumber: transaction.blockNumber,
+    });
   }
 
-  const contract = await innerGetContractAt(
+  const contract = createContractInstance(
+    contractName,
     publicClient,
     walletClient,
-    contractAbi,
-    contractAddress
+    abi,
+    contractAddress,
   );
 
   return contract;
 }
 
-export async function sendDeploymentTransaction(
-  { artifacts, network }: HardhatRuntimeEnvironment,
-  contractName: string,
-  constructorArgs: any[] = [],
-  config: SendDeploymentTransactionConfig = {}
+export async function sendDeploymentTransaction<ContractName extends string>(
+  provider: EthereumProvider,
+  artifactManager: ArtifactManager,
+  contractName: ContractName,
+  constructorArgs: unknown[] = [],
+  sendDeploymentTransactionConfig: SendDeploymentTransactionConfig = {},
 ): Promise<{
-  contract: GetContractReturnType;
+  contract: ContractReturnType<ContractName>;
   deploymentTransaction: GetTransactionReturnType;
 }> {
-  const { client, libraries = {}, ...deployContractParameters } = config;
+  const {
+    client,
+    libraries = {},
+    ...deployContractParameters
+  } = sendDeploymentTransactionConfig;
   const [publicClient, walletClient, { abi, bytecode }] = await Promise.all([
-    client?.public ?? getPublicClient(network.provider),
-    client?.wallet ?? getDefaultWalletClient(network.provider, network.name),
-    getContractAbiAndBytecode(artifacts, contractName, libraries),
+    client?.public ?? getPublicClient(provider, "l1"),
+    client?.wallet ?? getDefaultWalletClient(provider, "l1"),
+    getContractAbiAndBytecode(artifactManager, contractName, libraries),
   ]);
 
-  return innerSendDeploymentTransaction(
-    publicClient,
-    walletClient,
-    abi,
-    bytecode,
-    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;
+  let deploymentTxHash: PrefixedHexString;
   // 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,
+      abi,
+      bytecode,
       args: constructorArgs,
       ...deployContractParameters,
       maxFeePerGas: undefined,
@@ -179,8 +136,8 @@ async function innerSendDeploymentTransaction(
     });
   } else {
     deploymentTxHash = await walletClient.deployContract({
-      abi: contractAbi,
-      bytecode: contractBytecode,
+      abi,
+      bytecode,
       args: constructorArgs,
       ...deployContractParameters,
       gasPrice: undefined,
@@ -191,71 +148,90 @@ async function innerSendDeploymentTransaction(
     hash: deploymentTxHash,
   });
 
-  const { getContractAddress } = await import("viem");
   const contractAddress = getContractAddress({
     from: walletClient.account.address,
-    nonce: BigInt(deploymentTx.nonce),
+    nonce: toBigInt(deploymentTx.nonce),
   });
 
-  const contract = await innerGetContractAt(
+  const contract = createContractInstance(
+    contractName,
     publicClient,
     walletClient,
-    contractAbi,
-    contractAddress
+    abi,
+    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([
-    config.client?.public ?? getPublicClient(network.provider),
-    config.client?.wallet ??
-      getDefaultWalletClient(network.provider, network.name),
-    artifacts.readArtifact(contractName),
+export async function getContractAt<ContractName extends string>(
+  provider: EthereumProvider,
+  artifactManager: ArtifactManager,
+  contractName: ContractName,
+  address: ViemAddress,
+  getContractAtConfig: GetContractAtConfig = {},
+): Promise<ContractReturnType<ContractName>> {
+  const [publicClient, walletClient, artifact] = await Promise.all([
+    getContractAtConfig.client?.public ?? getPublicClient(provider, "l1"),
+    getContractAtConfig.client?.wallet ??
+      getDefaultWalletClient(provider, "l1"),
+    artifactManager.readArtifact(contractName),
   ]);
 
-  return innerGetContractAt(
+  return createContractInstance(
+    contractName,
     publicClient,
     walletClient,
-    contractArtifact.abi,
-    address
+    artifact.abi,
+    address,
   );
 }
 
-async function innerGetContractAt(
+function createContractInstance<ContractName extends string>(
+  _contractName: ContractName,
   publicClient: PublicClient,
   walletClient: WalletClient,
-  contractAbi: Abi,
-  address: Address
-): Promise<GetContractReturnType> {
-  const viem = await import("viem");
-  const contract = viem.getContract({
+  abi: ViemAbi,
+  address: ViemAddress,
+): ContractReturnType<ContractName> {
+  const contract = getContract({
     address,
     client: {
       public: publicClient,
       wallet: walletClient,
     },
-    abi: contractAbi,
+    abi,
   });
 
-  return contract;
+  /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  -- Cast it as TS can't infer the type of the contract */
+  return contract as ContractReturnType<ContractName>;
 }
 
-async function getDefaultWalletClient(
-  provider: EthereumProvider,
-  networkName: string
-): Promise<WalletClient> {
-  const [defaultWalletClient] = await getWalletClients(provider);
-
-  if (defaultWalletClient === undefined) {
-    throw new DefaultWalletClientNotFoundError(networkName);
+async function getContractAbiAndBytecode(
+  artifacts: ArtifactManager,
+  contractName: string,
+  libraries: Libraries,
+) {
+  const artifact = await artifacts.readArtifact(contractName);
+  let bytecode;
+  try {
+    bytecode = resolveLinkedBytecode(artifact, libraries);
+  } catch (error) {
+    ensureError(error);
+
+    throw new HardhatError(
+      HardhatError.ERRORS.VIEM.LINKING_CONTRACT_ERROR,
+      {
+        contractName,
+        error: error.message,
+      },
+      error,
+    );
   }
 
-  return defaultWalletClient;
+  return {
+    abi: artifact.abi,
+    bytecode,
+  };
 }

package/src/internal/hook-handlers/network.ts

@@ -0,0 +1,27 @@
+import type { HookContext, NetworkHooks } from "hardhat/types/hooks";
+import type { ChainType, NetworkConnection } from "hardhat/types/network";
+
+import { initializeViem } from "../initialization.js";
+
+export default async (): Promise<Partial<NetworkHooks>> => {
+  const handlers: Partial<NetworkHooks> = {
+    async newConnection<ChainTypeT extends ChainType | string>(
+      context: HookContext,
+      next: (
+        nextContext: HookContext,
+      ) => Promise<NetworkConnection<ChainTypeT>>,
+    ) {
+      const connection: NetworkConnection<ChainTypeT> = await next(context);
+
+      connection.viem = initializeViem(
+        connection.chainType,
+        connection.provider,
+        context.artifacts,
+      );
+
+      return connection;
+    },
+  };
+
+  return handlers;
+};

package/src/internal/initialization.ts

@@ -0,0 +1,67 @@
+import type { HardhatViemHelpers } from "../types.js";
+import type { ArtifactManager } from "hardhat/types/artifacts";
+import type { ChainType } from "hardhat/types/network";
+import type { EthereumProvider } from "hardhat/types/providers";
+
+import {
+  getPublicClient,
+  getWalletClients,
+  getWalletClient,
+  getTestClient,
+} from "./clients.js";
+import {
+  deployContract,
+  getContractAt,
+  sendDeploymentTransaction,
+} from "./contracts.js";
+
+export function initializeViem<ChainTypeT extends ChainType | string>(
+  chainType: ChainTypeT,
+  provider: EthereumProvider,
+  artifactManager: ArtifactManager,
+): HardhatViemHelpers<ChainTypeT> {
+  return {
+    getPublicClient: (publicClientConfig) =>
+      getPublicClient(provider, chainType, publicClientConfig),
+
+    getWalletClients: (walletClientConfig) =>
+      getWalletClients(provider, chainType, walletClientConfig),
+
+    getWalletClient: (address, walletClientConfig) =>
+      getWalletClient(provider, chainType, address, walletClientConfig),
+
+    getTestClient: (testClientConfig) =>
+      getTestClient(provider, chainType, testClientConfig),
+
+    deployContract: (contractName, constructorArgs, deployContractConfig) =>
+      deployContract(
+        provider,
+        artifactManager,
+        contractName,
+        constructorArgs,
+        deployContractConfig,
+      ),
+
+    sendDeploymentTransaction: (
+      contractName,
+      constructorArgs,
+      sendDeploymentTransactionConfig,
+    ) =>
+      sendDeploymentTransaction(
+        provider,
+        artifactManager,
+        contractName,
+        constructorArgs,
+        sendDeploymentTransactionConfig,
+      ),
+
+    getContractAt: (contractName, address, getContractAtConfig) =>
+      getContractAt(
+        provider,
+        artifactManager,
+        contractName,
+        address,
+        getContractAtConfig,
+      ),
+  };
+}

package/src/type-extensions.ts

@@ -0,0 +1,10 @@
+import type { HardhatViemHelpers } from "./types.js";
+
+import "hardhat/types/network";
+declare module "hardhat/types/network" {
+  interface NetworkConnection<
+    ChainTypeT extends ChainType | string = DefaultChainType,
+  > {
+    viem: HardhatViemHelpers<ChainTypeT>;
+  }
+}