hardhat 3.2.0 → 3.3.0

package/src/internal/builtin-plugins/network-manager/edr/utils/trace-output.ts

@@ -0,0 +1,137 @@
+import type { Response } from "@nomicfoundation/edr";
+
+import chalk from "chalk";
+import debug from "debug";
+
+import { formatTraces } from "./trace-formatters.js";
+
+const log = debug("hardhat:core:hardhat-network:provider");
+
+// Rotating palette for per-connection coloring of trace headers.
+const LABEL_COLORS: Array<(text: string) => string> = [
+  chalk.cyan,
+  chalk.magenta,
+  chalk.blueBright,
+  chalk.yellowBright,
+  chalk.cyanBright,
+  chalk.magentaBright,
+];
+
+// Keyed by `network name` (not connection label) so the map stays bounded
+// by the number of distinct networks, not the number of connections.
+const networkColorMap = new Map<string, (text: string) => string>();
+
+// These methods run a simulation before the actual transaction. We skip
+// their traces on success to avoid duplicates, but still show them on
+// failure since the real transaction won't be sent.
+const TRACE_SUPPRESSED_METHODS = new Set(["eth_estimateGas"]);
+
+// Bounded set: receipt-polling deduplication only needs a small window.
+// Once the cap is reached the set is cleared so memory stays bounded
+// in long-running nodes.
+const TRACED_TX_HASHES_CAP = 1024;
+
+/**
+ * Manages trace output formatting, deduplication, and coloring for a single
+ * provider connection.
+ */
+export class TraceOutputManager {
+  readonly #printLineFn: (line: string) => void;
+  readonly #connectionLabel: string;
+  readonly #labelColor: (text: string) => string;
+  readonly #verbosity: number;
+  readonly #tracedTxHashes = new Set<string>();
+
+  constructor(
+    printLineFn: (line: string) => void,
+    connectionId: number,
+    networkName: string,
+    verbosity: number,
+  ) {
+    this.#printLineFn = printLineFn;
+    this.#connectionLabel = `connection #${connectionId} (${networkName})`;
+    this.#labelColor = this.#colorForNetwork(networkName);
+    this.#verbosity = verbosity;
+  }
+
+  /**
+   * Output call traces from an EDR response, applying deduplication and
+   * suppression rules based on the verbosity level.
+   */
+  public outputCallTraces(
+    edrResponse: Response,
+    method: string,
+    txHash: string | undefined,
+    failed: boolean,
+  ): void {
+    try {
+      // At verbosity < 5, suppress simulation-only methods on success and
+      // deduplicate traces for the same transaction. At verbosity >= 5
+      // (#showAllTraces), every RPC call with traces is shown.
+
+      if (this.#verbosity < 5) {
+        // Skip successful simulation-only methods, their trace will appear
+        // again in the subsequent eth_sendTransaction. Failed simulations
+        // are shown because the sendTransaction may never happen.
+        if (!failed && TRACE_SUPPRESSED_METHODS.has(method)) {
+          return;
+        }
+
+        // Dedup: skip if we already traced this transaction.
+        // Prevents the same tx appearing multiple times from receipt polling.
+        if (txHash !== undefined && this.#tracedTxHashes.has(txHash)) {
+          return;
+        }
+      }
+
+      const rawTraces = edrResponse.callTraces();
+
+      // EDR returns duplicate traces for eth_estimateGas, take only the first.
+      const callTraces =
+        TRACE_SUPPRESSED_METHODS.has(method) && rawTraces.length > 1
+          ? [rawTraces[0]]
+          : rawTraces;
+
+      if (callTraces.length === 0) {
+        return;
+      }
+
+      if (txHash !== undefined) {
+        if (this.#tracedTxHashes.size >= TRACED_TX_HASHES_CAP) {
+          this.#tracedTxHashes.clear();
+        }
+
+        this.#tracedTxHashes.add(txHash);
+      }
+
+      const coloredLabel = this.#labelColor(this.#connectionLabel);
+      const prefix = callTraces.length > 1 ? "Traces from" : "Trace from";
+      const coloredPrefix = this.#labelColor(prefix);
+      const styledMethod = failed ? chalk.red(method) : chalk.dim(method);
+      const header = `${coloredPrefix} ${coloredLabel}: ${styledMethod}`;
+
+      this.#printLineFn(`${header}\n${formatTraces(callTraces, "  ", chalk)}`);
+    } catch (e) {
+      log("Failed to get call traces: %O", e);
+    }
+  }
+
+  /**
+   * Clear the dedup set (e.g. on snapshot revert so replayed txs are traced again).
+   */
+  public clearTracedHashes(): void {
+    this.#tracedTxHashes.clear();
+  }
+
+  #colorForNetwork(networkName: string): (text: string) => string {
+    let color = networkColorMap.get(networkName);
+
+    if (color === undefined) {
+      const index = networkColorMap.size % LABEL_COLORS.length;
+      color = LABEL_COLORS[index];
+      networkColorMap.set(networkName, color);
+    }
+
+    return color;
+  }
+}

package/src/internal/builtin-plugins/network-manager/hook-handlers/hre.ts

@@ -50,5 +50,6 @@ async function createNetworkManager(
     hre.config.chainDescriptors,
     hre.globalOptions.config,
     hre.config.paths.root,
+    hre.globalOptions.verbosity,
   );
 }

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

@@ -9,10 +9,10 @@ import type {
 } from "../../../../types/providers.js";
 import type { RequestHandler } from "../request-handlers/types.js";
 
-import { deepClone } from "@nomicfoundation/hardhat-utils/lang";
 import { AsyncMutex } from "@nomicfoundation/hardhat-utils/synchronization";
 
 import { isJsonRpcResponse } from "../json-rpc.js";
+import { createHandlersArray } from "../request-handlers/handlers-array.js";
 
 export default async (): Promise<Partial<NetworkHooks>> => {
   // This map is essential for managing multiple network connections in Hardhat V3.
@@ -38,10 +38,6 @@ export default async (): Promise<Partial<NetworkHooks>> => {
         nextJsonRpcRequest: JsonRpcRequest,
       ) => Promise<JsonRpcResponse>,
     ) {
-      const { createHandlersArray } = await import(
-        "../request-handlers/handlers-array.js"
-      );
-
       const requestHandlers = await initializationMutex.exclusiveRun(
         async () => {
           let handlersPerConnection =
@@ -61,21 +57,22 @@ export default async (): Promise<Partial<NetworkHooks>> => {
         },
       );
 
-      // We clone the request to avoid interfering with other hook handlers that
-      // might be using the original request.
-      let request = await deepClone(jsonRpcRequest);
+      // We previously cloned here, but the performance impact is significant.
+      // TODO: ensure the passed in request is not mutated by adapting the
+      // handlers being applied here. See https://github.com/NomicFoundation/hardhat/issues/8090
+      let updatedRequest = jsonRpcRequest;
 
       for (const handler of requestHandlers) {
-        const newRequestOrResponse = await handler.handle(request);
+        const newRequestOrResponse = await handler.handle(updatedRequest);
 
         if (isJsonRpcResponse(newRequestOrResponse)) {
           return newRequestOrResponse;
         }
 
-        request = newRequestOrResponse;
+        updatedRequest = newRequestOrResponse;
       }
 
-      return next(context, networkConnection, request);
+      return next(context, networkConnection, updatedRequest);
     },
 
     async closeConnection<ChainTypeT extends ChainType | string>(

package/src/internal/builtin-plugins/network-manager/http-provider.ts

@@ -161,6 +161,7 @@ export class HttpProvider extends BaseProvider {
   }
 
   public async close(): Promise<void> {
+    this.removeAllListeners();
     if (this.#dispatcher !== undefined) {
       // See https://github.com/nodejs/undici/discussions/3522#discussioncomment-10498734
       await this.#dispatcher.close();

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

@@ -21,7 +21,7 @@ import type {
   JsonRpcRequest,
   JsonRpcResponse,
 } from "../../../types/providers.js";
-import type { GasReportConfig } from "@nomicfoundation/edr";
+import type { ContractDecoder, GasReportConfig } from "@nomicfoundation/edr";
 
 import {
   HardhatError,
@@ -29,6 +29,7 @@ import {
 } from "@nomicfoundation/hardhat-errors";
 import { exists, readBinaryFile } from "@nomicfoundation/hardhat-utils/fs";
 import { deepMerge } from "@nomicfoundation/hardhat-utils/lang";
+import { AsyncMutex } from "@nomicfoundation/hardhat-utils/synchronization";
 
 import { resolveUserConfigToHardhatConfig } from "../../core/hre.js";
 import { isSupportedChainType } from "../../edr/chain-type.js";
@@ -37,6 +38,7 @@ import { JsonRpcServerImplementation } from "../node/json-rpc/server.js";
 import { EdrProvider } from "./edr/edr-provider.js";
 import { getHardforks } from "./edr/types/hardfork.js";
 import { edrGasReportToHardhatGasMeasurements } from "./edr/utils/convert-to-edr.js";
+import { verbosityToIncludeTraces } from "./edr/utils/trace-formatters.js";
 import { HttpProvider } from "./http-provider.js";
 import { NetworkConnectionImplementation } from "./network-connection.js";
 
@@ -55,8 +57,11 @@ export class NetworkManagerImplementation implements NetworkManager {
   readonly #chainDescriptors: Readonly<ChainDescriptorsConfig>;
   readonly #userProvidedConfigPath: Readonly<string | undefined>;
   readonly #projectRoot: string;
+  readonly #verbosity: number;
 
   #nextConnectionId = 0;
+  readonly #contractDecoderMutex = new AsyncMutex();
+  #contractDecoder: ContractDecoder | undefined;
 
   constructor(
     defaultNetwork: string,
@@ -68,6 +73,7 @@ export class NetworkManagerImplementation implements NetworkManager {
     chainDescriptors: ChainDescriptorsConfig,
     userProvidedConfigPath: string | undefined,
     projectRoot: string,
+    verbosity: number,
   ) {
     this.#defaultNetwork = defaultNetwork;
     this.#defaultChainType = defaultChainType;
@@ -78,6 +84,7 @@ export class NetworkManagerImplementation implements NetworkManager {
     this.#chainDescriptors = chainDescriptors;
     this.#userProvidedConfigPath = userProvidedConfigPath;
     this.#projectRoot = projectRoot;
+    this.#verbosity = verbosity;
   }
 
   public async connect<
@@ -233,6 +240,42 @@ export class NetworkManagerImplementation implements NetworkManager {
           };
         }
 
+        // We load the build infos and their outputs to create a contract
+        // decoder when the first provider is created. Successive providers will
+        // reuse the same decoder as a performance optimization.
+        //
+        // The trade-off here is that if you create an EDR provider, then
+        // compile new contracts, and create a new provider, the new contracts
+        // won't be loaded.
+        //
+        // Even without this optimization, we already had the problem of new
+        // contracts not being visible to existing providers.
+        //
+        // In practice, most workflows compile everything before creating
+        // any network connection.
+        if (this.#contractDecoder === undefined) {
+          // We want to ensure that only one contract decoder is created so we
+          // protect the initialization with a mutex.
+          await this.#contractDecoderMutex.exclusiveRun(async () => {
+            // We check again if the decoder is undefined because another async
+            // execution context could have already initialized it while we were
+            // waiting for the mutex.
+            if (this.#contractDecoder === undefined) {
+              this.#contractDecoder = await EdrProvider.createContractDecoder({
+                buildInfos: await this.#getBuildInfosAndOutputsAsBuffers(),
+                ignoreContracts: false,
+              });
+            }
+          });
+        }
+
+        assertHardhatInvariant(
+          this.#contractDecoder !== undefined,
+          "Contract decoder should have been initialized before creating the provider",
+        );
+
+        const includeCallTraces = verbosityToIncludeTraces(this.#verbosity);
+
         return EdrProvider.create({
           chainDescriptors: this.#chainDescriptors,
           // The resolvedNetworkConfig can have its chainType set to `undefined`
@@ -249,12 +292,13 @@ export class NetworkManagerImplementation implements NetworkManager {
             chainType: resolvedChainType as ChainType,
           },
           jsonRpcRequestWrapper,
-          tracingConfig: {
-            buildInfos: await this.#getBuildInfosAndOutputsAsBuffers(),
-            ignoreContracts: false,
-          },
+          contractDecoder: this.#contractDecoder,
           coverageConfig,
           gasReportConfig,
+          includeCallTraces,
+          connectionId: networkConnection.id,
+          networkName: networkConnection.networkName,
+          verbosity: this.#verbosity,
         });
       }
 
@@ -298,17 +342,32 @@ export class NetworkManagerImplementation implements NetworkManager {
    */
   async #resolveNetworkConfig<ChainTypeT extends ChainType | string>(
     resolvedNetworkName: string,
-    networkConfigOverride: NetworkConfigOverride | undefined = {},
+    networkConfigOverride: NetworkConfigOverride = {},
     resolvedChainType: ChainTypeT,
   ): Promise<NetworkConfig> {
     const existingNetworkConfig = this.#networkConfigs[resolvedNetworkName];
-    if (
-      Object.keys(networkConfigOverride).length === 0 &&
-      resolvedChainType === existingNetworkConfig.chainType
-    ) {
+
+    const hasNoOverrides = Object.keys(networkConfigOverride).length === 0;
+    const isChainTypeUnchanged =
+      resolvedChainType === existingNetworkConfig.chainType;
+    const isChainTypeDefault =
+      existingNetworkConfig.chainType === undefined &&
+      resolvedChainType === this.#defaultChainType;
+
+    if (hasNoOverrides && isChainTypeUnchanged) {
       return existingNetworkConfig;
     }
 
+    if (hasNoOverrides && isChainTypeDefault) {
+      return {
+        ...existingNetworkConfig,
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
+          TypeScript can't follow this case, but we are just providing the
+          default */
+        chainType: resolvedChainType as ChainType,
+      };
+    }
+
     if (
       "type" in networkConfigOverride &&
       networkConfigOverride.type !== existingNetworkConfig.type
@@ -357,6 +416,20 @@ export class NetworkManagerImplementation implements NetworkManager {
     );
 
     if (!configResolutionResult.success) {
+      if (configResolutionResult.configValidationErrors !== undefined) {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.NETWORK.INVALID_CONFIG_OVERRIDE,
+          {
+            errors: `\t${configResolutionResult.configValidationErrors
+              .map(
+                (error) =>
+                  `* Error in resolved config ${error.path.join(".")}: ${error.message}`,
+              )
+              .join("\n\t")}`,
+          },
+        );
+      }
+
       throw new HardhatError(
         HardhatError.ERRORS.CORE.NETWORK.INVALID_CONFIG_OVERRIDE,
         {

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,