hardhat 3.2.0 → 3.4.0

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/accounts/local-accounts.ts

@@ -5,6 +5,8 @@ import type {
 } from "../../../../../../types/providers.js";
 import type { RequestHandler } from "../../types.js";
 import type { RpcTransactionRequest } from "@nomicfoundation/hardhat-zod-utils/rpc";
+import type * as MicroEthSignerT from "micro-eth-signer";
+import type * as MicroEthSignerTypedDataT from "micro-eth-signer/typed-data";
 
 import {
   assertHardhatInvariant,
@@ -27,27 +29,29 @@ import {
   rpcTransactionRequest,
   validateParams,
 } from "@nomicfoundation/hardhat-zod-utils/rpc";
-import { addr, Transaction } from "micro-eth-signer";
-import { signTyped } from "micro-eth-signer/typed-data";
-import * as typed from "micro-eth-signer/typed-data";
+
+// micro-eth-signer is known to be slow to load, so we lazy load it
+let microEthSigner: typeof MicroEthSignerT | undefined;
+let microEthSignerTypedData: typeof MicroEthSignerTypedDataT | undefined;
 
 import { getRequestParams } from "../../../json-rpc.js";
 import { ChainId } from "../chain-id/chain-id.js";
 
-/**
- * This handler takes a long time to load. Currently, it is only used in the handlers array,
- * where it is imported dynamically, and in the HDWalletHandler, which itself is only loaded
- * dynamically.
- * If we ever need to import this handler elsewhere, we should either import it dynamically
- * or import some of the dependencies of this handler dynamically.
- * It has been identified that micro-eth-signer is one of the most expensive dependencies here.
- * See https://github.com/NomicFoundation/hardhat/pull/6481 for more details.
- */
-
 const EXTRA_ENTROPY = false;
 export class LocalAccountsHandler extends ChainId implements RequestHandler {
-  readonly #addressToPrivateKey: Map<string, Uint8Array> = new Map();
-  readonly #addresses: string[] = [];
+  readonly #methods: ReadonlySet<string> = new Set([
+    "eth_accounts",
+    "eth_requestAccounts",
+    "eth_sign",
+    "personal_sign",
+    "eth_signTypedData_v4",
+    "eth_sendTransaction",
+  ]);
+
+  readonly #localAccountsHexPrivateKeys: string[];
+
+  #addressToPrivateKey: Map<string, Uint8Array> | undefined;
+  #addresses: string[] | undefined;
 
   constructor(
     provider: EthereumProvider,
@@ -55,12 +59,20 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
   ) {
     super(provider);
 
-    this.#initializePrivateKeys(localAccountsHexPrivateKeys);
+    this.#localAccountsHexPrivateKeys = localAccountsHexPrivateKeys;
+  }
+
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
   }
 
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
+      return jsonRpcRequest;
+    }
+
     const response = await this.#resolveRequest(jsonRpcRequest);
     if (response !== null) {
       return response;
@@ -71,6 +83,28 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
     return jsonRpcRequest;
   }
 
+  async #getAddressesAndPrivateKeysMap(): Promise<{
+    addresses: string[];
+    addressToPrivateKey: Map<string, Uint8Array>;
+  }> {
+    if (
+      this.#addresses === undefined ||
+      this.#addressToPrivateKey === undefined
+    ) {
+      const { addresses, addressToPrivateKey } =
+        await this.#initializeAddressesFromPrivateKeys(
+          this.#localAccountsHexPrivateKeys,
+        );
+      this.#addresses = addresses;
+      this.#addressToPrivateKey = addressToPrivateKey;
+    }
+
+    return {
+      addresses: this.#addresses,
+      addressToPrivateKey: this.#addressToPrivateKey,
+    };
+  }
+
   async #resolveRequest(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcResponse | null> {
@@ -78,9 +112,8 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
       jsonRpcRequest.method === "eth_accounts" ||
       jsonRpcRequest.method === "eth_requestAccounts"
     ) {
-      return this.#createJsonRpcResponse(jsonRpcRequest.id, [
-        ...this.#addresses,
-      ]);
+      const { addresses } = await this.#getAddressesAndPrivateKeysMap();
+      return this.#createJsonRpcResponse(jsonRpcRequest.id, [...addresses]);
     }
 
     const params = getRequestParams(jsonRpcRequest);
@@ -96,10 +129,20 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
             );
           }
 
-          const privateKey = this.#getPrivateKeyForAddress(address);
+          if (microEthSignerTypedData === undefined) {
+            microEthSignerTypedData = await import(
+              "micro-eth-signer/typed-data"
+            );
+          }
+
+          const privateKey = await this.#getPrivateKeyForAddress(address);
           return this.#createJsonRpcResponse(
             jsonRpcRequest.id,
-            typed.personal.sign(data, privateKey, EXTRA_ENTROPY),
+            microEthSignerTypedData.personal.sign(
+              data,
+              privateKey,
+              EXTRA_ENTROPY,
+            ),
           );
         }
       }
@@ -116,10 +159,20 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
             );
           }
 
-          const privateKey = this.#getPrivateKeyForAddress(address);
+          if (microEthSignerTypedData === undefined) {
+            microEthSignerTypedData = await import(
+              "micro-eth-signer/typed-data"
+            );
+          }
+
+          const privateKey = await this.#getPrivateKeyForAddress(address);
           return this.#createJsonRpcResponse(
             jsonRpcRequest.id,
-            typed.personal.sign(data, privateKey, EXTRA_ENTROPY),
+            microEthSignerTypedData.personal.sign(
+              data,
+              privateKey,
+              EXTRA_ENTROPY,
+            ),
           );
         }
       }
@@ -146,11 +199,19 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
       }
 
       // if we don't manage the address, the method is forwarded
-      const privateKey = this.#getPrivateKeyForAddressOrNull(address);
+      const privateKey = await this.#getPrivateKeyForAddressOrNull(address);
       if (privateKey !== null) {
+        if (microEthSignerTypedData === undefined) {
+          microEthSignerTypedData = await import("micro-eth-signer/typed-data");
+        }
+
         return this.#createJsonRpcResponse(
           jsonRpcRequest.id,
-          signTyped(typedMessage, privateKey, EXTRA_ENTROPY),
+          microEthSignerTypedData.signTyped(
+            typedMessage,
+            privateKey,
+            EXTRA_ENTROPY,
+          ),
         );
       }
     }
@@ -220,7 +281,7 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
         txRequest.nonce = await this.#getNonce(txRequest.from);
       }
 
-      const privateKey = this.#getPrivateKeyForAddress(txRequest.from);
+      const privateKey = await this.#getPrivateKeyForAddress(txRequest.from);
 
       const chainId = await this.getChainId();
 
@@ -235,20 +296,32 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
     }
   }
 
-  #initializePrivateKeys(localAccountsHexPrivateKeys: string[]) {
+  async #initializeAddressesFromPrivateKeys(
+    localAccountsHexPrivateKeys: string[],
+  ) {
+    if (microEthSigner === undefined) {
+      microEthSigner = await import("micro-eth-signer");
+    }
+
     const privateKeys: Uint8Array[] = localAccountsHexPrivateKeys.map((h) =>
       hexStringToBytes(h),
     );
 
+    const addresses = [];
+    const addressToPrivateKey = new Map<string, Uint8Array>();
     for (const pk of privateKeys) {
-      const address = addr.fromPrivateKey(pk).toLowerCase();
-      this.#addressToPrivateKey.set(address, pk);
-      this.#addresses.push(address);
+      const address = microEthSigner.addr.fromPrivateKey(pk).toLowerCase();
+      addressToPrivateKey.set(address, pk);
+      addresses.push(address);
     }
+
+    return { addresses, addressToPrivateKey };
   }
 
-  #getPrivateKeyForAddress(address: Uint8Array): Uint8Array {
-    const pk = this.#addressToPrivateKey.get(bytesToHexString(address));
+  async #getPrivateKeyForAddress(address: Uint8Array): Promise<Uint8Array> {
+    const { addressToPrivateKey } = await this.#getAddressesAndPrivateKeysMap();
+
+    const pk = addressToPrivateKey.get(bytesToHexString(address));
 
     if (pk === undefined) {
       throw new HardhatError(
@@ -262,9 +335,11 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
     return pk;
   }
 
-  #getPrivateKeyForAddressOrNull(address: Uint8Array): Uint8Array | null {
+  async #getPrivateKeyForAddressOrNull(
+    address: Uint8Array,
+  ): Promise<Uint8Array | null> {
     try {
-      return this.#getPrivateKeyForAddress(address);
+      return await this.#getPrivateKeyForAddress(address);
     } catch {
       return null;
     }
@@ -289,6 +364,12 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
     chainId: number,
     privateKey: Uint8Array,
   ): Promise<Uint8Array> {
+    if (microEthSigner === undefined) {
+      microEthSigner = await import("micro-eth-signer");
+    }
+
+    const { addr, Transaction } = microEthSigner;
+
     const txData = {
       ...transactionRequest,
       gasLimit: transactionRequest.gas,

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/accounts/sender.ts

@@ -17,35 +17,43 @@ import { getRequestParams } from "../../../json-rpc.js";
  * The class also provides a mechanism to retrieve the sender account, which must be implemented by subclasses.
  */
 export abstract class SenderHandler implements RequestHandler {
+  readonly #methods: ReadonlySet<string> = new Set([
+    "eth_sendTransaction",
+    "eth_call",
+    "eth_estimateGas",
+  ]);
+
   protected readonly provider: EthereumProvider;
 
   constructor(provider: EthereumProvider) {
     this.provider = provider;
   }
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
+      return jsonRpcRequest;
+    }
+
     const method = jsonRpcRequest.method;
     const params = getRequestParams(jsonRpcRequest);
 
-    if (
-      method === "eth_sendTransaction" ||
-      method === "eth_call" ||
-      method === "eth_estimateGas"
-    ) {
-      const [tx] = params;
-
-      if (isObject(tx) && tx.from === undefined) {
-        const senderAccount = await this.getSender();
-
-        if (senderAccount !== undefined) {
-          tx.from = senderAccount;
-        } else if (method === "eth_sendTransaction") {
-          throw new HardhatError(
-            HardhatError.ERRORS.CORE.NETWORK.NO_REMOTE_ACCOUNT_AVAILABLE,
-          );
-        }
+    const [tx] = params;
+
+    if (isObject(tx) && tx.from === undefined) {
+      const senderAccount = await this.getSender();
+
+      if (senderAccount !== undefined) {
+        tx.from = senderAccount;
+      } else if (method === "eth_sendTransaction") {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.NETWORK.NO_REMOTE_ACCOUNT_AVAILABLE,
+        );
       }
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/chain-id/chain-id-handler.ts

@@ -25,17 +25,25 @@ export class ChainIdValidatorHandler extends ChainId implements RequestHandler {
     this.#expectedChainId = expectedChainId;
   }
 
-  public async handle(
-    jsonRpcRequest: JsonRpcRequest,
-  ): Promise<JsonRpcRequest | JsonRpcResponse> {
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    if (this.#alreadyValidated) {
+      return false;
+    }
+
     if (
       jsonRpcRequest.method === "eth_chainId" ||
       jsonRpcRequest.method === "net_version"
     ) {
-      return jsonRpcRequest;
+      return false;
     }
 
-    if (this.#alreadyValidated) {
+    return true;
+  }
+
+  public async handle(
+    jsonRpcRequest: JsonRpcRequest,
+  ): Promise<JsonRpcRequest | JsonRpcResponse> {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
       return jsonRpcRequest;
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/gas/automatic-gas-handler.ts

@@ -25,6 +25,8 @@ export class AutomaticGasHandler
   extends MultipliedGasEstimation
   implements RequestHandler
 {
+  readonly #methods: ReadonlySet<string> = new Set(["eth_sendTransaction"]);
+
   constructor(
     provider: EthereumProvider,
     gasMultiplier: number = DEFAULT_GAS_MULTIPLIER,
@@ -32,10 +34,14 @@ export class AutomaticGasHandler
     super(provider, gasMultiplier);
   }
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
-    if (jsonRpcRequest.method !== "eth_sendTransaction") {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
       return jsonRpcRequest;
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/gas/automatic-gas-price-handler.ts

@@ -19,6 +19,8 @@ import { getRequestParams } from "../../../json-rpc.js";
  * It ensures that gas prices are set correctly.
  */
 export class AutomaticGasPriceHandler implements RequestHandler {
+  readonly #methods: ReadonlySet<string> = new Set(["eth_sendTransaction"]);
+
   readonly #provider: EthereumProvider;
 
   // We pay the max base fee that can be required if the next
@@ -36,10 +38,14 @@ export class AutomaticGasPriceHandler implements RequestHandler {
   #nodeHasFeeHistory?: boolean;
   #nodeSupportsEIP1559?: boolean;
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
-    if (jsonRpcRequest.method !== "eth_sendTransaction") {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
       return jsonRpcRequest;
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/gas/fixed-gas-handler.ts

@@ -14,16 +14,22 @@ import { getRequestParams } from "../../../json-rpc.js";
  * For `eth_sendTransaction` requests, it sets the gas field with the value provided via the class constructor, if it hasn't been specified already.
  */
 export class FixedGasHandler implements RequestHandler {
+  readonly #methods: ReadonlySet<string> = new Set(["eth_sendTransaction"]);
+
   readonly #gas: PrefixedHexString;
 
   constructor(gas: PrefixedHexString) {
     this.#gas = gas;
   }
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
-    if (jsonRpcRequest.method !== "eth_sendTransaction") {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
       return jsonRpcRequest;
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/gas/fixed-gas-price-handler.ts

@@ -14,16 +14,22 @@ import { getRequestParams } from "../../../json-rpc.js";
  * For `eth_sendTransaction` requests, it sets the gasPrice field with the value provided via the class constructor, if it hasn't been specified already.
  */
 export class FixedGasPriceHandler implements RequestHandler {
+  readonly #methods: ReadonlySet<string> = new Set(["eth_sendTransaction"]);
+
   readonly #gasPrice: PrefixedHexString;
 
   constructor(gasPrice: PrefixedHexString) {
     this.#gasPrice = gasPrice;
   }
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
-    if (jsonRpcRequest.method !== "eth_sendTransaction") {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
       return jsonRpcRequest;
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers-array.ts

@@ -8,13 +8,20 @@ import { numberToHexString } from "@nomicfoundation/hardhat-utils/hex";
 
 import { isHttpNetworkHdAccountsConfig } from "../type-validation.js";
 
+import { AutomaticSenderHandler } from "./handlers/accounts/automatic-sender-handler.js";
+import { FixedSenderHandler } from "./handlers/accounts/fixed-sender-handler.js";
+import { HDWalletHandler } from "./handlers/accounts/hd-wallet-handler.js";
+import { LocalAccountsHandler } from "./handlers/accounts/local-accounts.js";
+import { ChainIdValidatorHandler } from "./handlers/chain-id/chain-id-handler.js";
+import { AutomaticGasHandler } from "./handlers/gas/automatic-gas-handler.js";
+import { AutomaticGasPriceHandler } from "./handlers/gas/automatic-gas-price-handler.js";
+import { FixedGasHandler } from "./handlers/gas/fixed-gas-handler.js";
+import { FixedGasPriceHandler } from "./handlers/gas/fixed-gas-price-handler.js";
+
 /**
  * This function returns an handlers array based on the values in the NetworkConnection and NetworkConfig.
  * The order of the handlers, if all are present, is: chain handler, gas handlers (gasPrice first, then gas), sender handler and accounts handler.
  * The order is important to get a correct result when the handlers are executed.
- * The handlers are imported dynamically because some might take a long time to load.
- * Out of the currently supported handlers, LocalAccountsHandler and, consequently, HDWalletHandler have been identified as the most expensive.
- * See https://github.com/NomicFoundation/hardhat/pull/6481 for more details.
  */
 export async function createHandlersArray<
   ChainTypeT extends ChainType | string,
@@ -24,9 +31,6 @@ export async function createHandlersArray<
   const networkConfig = networkConnection.networkConfig;
 
   if (networkConfig.type === "http" && networkConfig.chainId !== undefined) {
-    const { ChainIdValidatorHandler } = await import(
-      "./handlers/chain-id/chain-id-handler.js"
-    );
     requestHandlers.push(
       new ChainIdValidatorHandler(
         networkConnection.provider,
@@ -39,9 +43,6 @@ export async function createHandlersArray<
     networkConfig.gasPrice === undefined ||
     networkConfig.gasPrice === "auto"
   ) {
-    const { AutomaticGasPriceHandler } = await import(
-      "./handlers/gas/automatic-gas-price-handler.js"
-    );
     // If you use a hook handler that signs locally, you are required to
     // have all the transaction fields available, including the
     // gasPrice / maxFeePerGas & maxPriorityFeePerGas.
@@ -56,18 +57,12 @@ export async function createHandlersArray<
       new AutomaticGasPriceHandler(networkConnection.provider),
     );
   } else {
-    const { FixedGasPriceHandler } = await import(
-      "./handlers/gas/fixed-gas-price-handler.js"
-    );
     requestHandlers.push(
       new FixedGasPriceHandler(numberToHexString(networkConfig.gasPrice)),
     );
   }
 
   if (networkConfig.gas === undefined || networkConfig.gas === "auto") {
-    const { AutomaticGasHandler } = await import(
-      "./handlers/gas/automatic-gas-handler.js"
-    );
     requestHandlers.push(
       new AutomaticGasHandler(
         networkConnection.provider,
@@ -75,25 +70,16 @@ export async function createHandlersArray<
       ),
     );
   } else {
-    const { FixedGasHandler } = await import(
-      "./handlers/gas/fixed-gas-handler.js"
-    );
     requestHandlers.push(
       new FixedGasHandler(numberToHexString(networkConfig.gas)),
     );
   }
 
   if (networkConfig.from === undefined) {
-    const { AutomaticSenderHandler } = await import(
-      "./handlers/accounts/automatic-sender-handler.js"
-    );
     requestHandlers.push(
       new AutomaticSenderHandler(networkConnection.provider),
     );
   } else {
-    const { FixedSenderHandler } = await import(
-      "./handlers/accounts/fixed-sender-handler.js"
-    );
     requestHandlers.push(
       new FixedSenderHandler(networkConnection.provider, networkConfig.from),
     );
@@ -103,9 +89,6 @@ export async function createHandlersArray<
     const accounts = networkConfig.accounts;
 
     if (Array.isArray(accounts)) {
-      const { LocalAccountsHandler } = await import(
-        "./handlers/accounts/local-accounts.js"
-      );
       const resolvedAccounts = await Promise.all(
         accounts.map((acc) => acc.getHexString()),
       );
@@ -114,9 +97,6 @@ export async function createHandlersArray<
         new LocalAccountsHandler(networkConnection.provider, resolvedAccounts),
       );
     } else if (isHttpNetworkHdAccountsConfig(accounts)) {
-      const { HDWalletHandler } = await import(
-        "./handlers/accounts/hd-wallet-handler.js"
-      );
       const hdWalletHandler = await HDWalletHandler.create(
         networkConnection.provider,
         await accounts.mnemonic.get(),

package/src/internal/builtin-plugins/network-manager/request-handlers/types.ts

@@ -14,6 +14,16 @@ import type {
  *
  */
 export interface RequestHandler {
+  /**
+   * A guard to ensure the request is supported by the handler.
+   * If the handler does not support the request, then it can be safely
+   * skipped.
+   *
+   * @param jsonRpcRequest - The JSON-RPC request to check.
+   * @returns true if the method will be processed by the handler, false otherwise.
+   */
+  isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean;
+
   handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse>;

package/src/internal/builtin-plugins/network-manager/revert-error-code.ts

@@ -0,0 +1,2 @@
+// Error code used by geth/anvil for execution revert errors (e.g. Solidity reverts).
+export const REVERT_ERROR_CODE: number = 3;

package/src/internal/builtin-plugins/network-manager/type-extensions/config.ts

@@ -147,7 +147,7 @@ declare module "../../../../types/config.js" {
   export interface EdrNetworkForkingUserConfig {
     enabled?: boolean;
     url: SensitiveString;
-    blockNumber?: number;
+    blockNumber?: number | bigint;
     httpHeaders?: Record<string, string>;
   }
 

package/src/internal/builtin-plugins/network-manager/type-validation.ts

@@ -45,6 +45,10 @@ const nonnegativeIntSchema = z.number().int().nonnegative();
 const nonnegativeBigIntSchema = z.bigint().nonnegative();
 
 const blockNumberSchema = nonnegativeIntSchema;
+const forkingBlockNumberSchema = unionType(
+  [z.number().int().nonnegative().safe(), z.bigint().nonnegative()],
+  "Expected a nonnegative safe int or a nonnegative bigint",
+);
 const chainIdSchema = nonnegativeIntSchema;
 
 const chainTypeUserConfigSchema = unionType(
@@ -267,7 +271,7 @@ const edrNetworkAccountsUserConfigSchema = conditionalUnionType(
 const edrNetworkForkingUserConfigSchema = z.object({
   enabled: z.optional(z.boolean()),
   url: sensitiveUrlSchema,
-  blockNumber: z.optional(blockNumberSchema),
+  blockNumber: z.optional(forkingBlockNumberSchema),
   httpHeaders: z.optional(z.record(z.string())),
 });
 

package/src/internal/builtin-plugins/node/artifacts/build-info-watcher.ts

@@ -2,6 +2,7 @@ import type { FSWatcher } from "chokidar";
 
 import path from "node:path";
 
+import { watch } from "chokidar";
 import debug from "debug";
 
 export type BuildInfoWatcher = FSWatcher;
@@ -59,8 +60,6 @@ export async function watchBuildInfo(
   buildInfoDirPath: string,
   handler: BuildInfoHandler,
 ): Promise<BuildInfoWatcher> {
-  const { watch } = await import("chokidar");
-
   // NOTE: Deleting the build info directory while it is being watched will
   // effectively cause the watcher to stop working.
   // NOTE: We use chokidar's `awaitWriteFinish` option because we are certain

package/src/internal/builtin-plugins/node/helpers.ts

@@ -2,6 +2,7 @@ import type { BuildInfo } from "../../../types/artifacts.js";
 import type { EdrNetworkAccountsConfig } from "../../../types/config.js";
 import type { SolidityBuildInfoOutput } from "../../../types/solidity.js";
 import type { EdrProvider } from "../network-manager/edr/edr-provider.js";
+import type * as MicroEthSignerT from "micro-eth-signer";
 
 import path from "node:path";
 
@@ -11,7 +12,9 @@ import {
 } from "@nomicfoundation/hardhat-utils/fs";
 import { hexStringToBytes } from "@nomicfoundation/hardhat-utils/hex";
 import chalk from "chalk";
-import { addr } from "micro-eth-signer";
+
+// micro-eth-signer is known to be slow to load, so we lazy load it
+let microEthSigner: typeof MicroEthSignerT | undefined;
 
 import { sendErrorTelemetry } from "../../cli/telemetry/sentry/reporter.js";
 import { isDefaultEdrNetworkHDAccountsConfig } from "../network-manager/edr/edr-provider.js";
@@ -48,8 +51,12 @@ export async function formatEdrNetworkConfigAccounts(
     maxPrefixLength = privateKeyPrefix.length;
   }
 
+  if (microEthSigner === undefined) {
+    microEthSigner = await import("micro-eth-signer");
+  }
+
   for (const [index, account] of accounts.entries()) {
-    const address = addr
+    const address = microEthSigner.addr
       .fromPrivateKey(hexStringToBytes(await account.privateKey.getHexString()))
       .toLowerCase();
     const balance = (BigInt(account.balance) / 10n ** 18n).toString(10);