hardhat 3.1.12 → 3.3.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,20 @@ 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 #localAccountsHexPrivateKeys: string[];
+
+  #addressToPrivateKey: Map<string, Uint8Array> | undefined;
+  #addresses: string[] | undefined;
 
   constructor(
     provider: EthereumProvider,
@@ -55,7 +50,29 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
   ) {
     super(provider);
 
-    this.#initializePrivateKeys(localAccountsHexPrivateKeys);
+    this.#localAccountsHexPrivateKeys = localAccountsHexPrivateKeys;
+  }
+
+  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,
+    };
   }
 
   public async handle(
@@ -78,9 +95,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 +112,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 +142,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 +182,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 +264,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 +279,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 +318,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 +347,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-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/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);

package/src/internal/builtin-plugins/node/json-rpc/handler.ts

@@ -250,6 +250,12 @@ const _readWsRequest = (msg: string): JsonRpcRequest | JsonRpcRequest[] => {
 };
 
 const _handleError = (error: Error): JsonRpcResponse => {
+  // Extract revert data from the original error before potentially wrapping it.
+  // Non-ProviderError errors (e.g. SolidityError) carry .data and .transactionHash
+  // that would be lost when wrapped in InternalError below.
+  const txHash = extractTxHash(error);
+  const returnData = extractReturnData(error);
+
   // In case of non-hardhat error, treat it as internal and associate the appropriate error code.
   if (!ProviderError.isProviderError(error)) {
     error = new InternalError(undefined, error);
@@ -266,8 +272,8 @@ const _handleError = (error: Error): JsonRpcResponse => {
       message: error.message,
       data: {
         message: error.message,
-        txHash: extractTxHash(error),
-        data: extractReturnData(error),
+        txHash,
+        data: returnData,
       },
     },
   };

package/src/internal/builtin-plugins/solidity/build-system/artifacts.ts

@@ -1,4 +1,4 @@
-import type { Artifact, BuildInfo } from "../../../../types/artifacts.js";
+import type { Artifact } from "../../../../types/artifacts.js";
 import type { CompilationJob } from "../../../../types/solidity/compilation-job.js";
 import type {
   CompilerOutput,
@@ -107,11 +107,16 @@ declare module "hardhat/types/artifacts" {
 export async function getBuildInfo(
   compilationJob: CompilationJob,
 ): Promise<SolidityBuildInfo> {
-  const buildInfo: Required<BuildInfo> = {
+  // Defaulting to "solc" is safe here: if it's already "solc" or undefined,
+  // this doesn't alter the build info id.
+  const compilerType = compilationJob.solcConfig.type ?? "solc";
+
+  const buildInfo: SolidityBuildInfo = {
     _format: "hh3-sol-build-info-1",
     id: await compilationJob.getBuildId(),
     solcVersion: compilationJob.solcConfig.version,
     solcLongVersion: compilationJob.solcLongVersion,
+    compilerType,
     userSourceNameMap:
       compilationJob.dependencyGraph.getRootsUserSourceNameMap(),
     input: await compilationJob.getSolcInput(),