hardhat 3.1.12 → 3.3.0

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

@@ -0,0 +1,197 @@
+import type { Colorizer } from "../../../../utils/colorizer.js";
+import type {
+  LogTrace,
+  CallTrace,
+  DecodedTraceParameters,
+} from "@nomicfoundation/edr";
+
+import { LogKind, CallKind, IncludeTraces } from "@nomicfoundation/edr";
+import { bytesToHexString } from "@nomicfoundation/hardhat-utils/hex";
+
+type NestedArray<T> = Array<T | NestedArray<T>>;
+
+export function verbosityToIncludeTraces(verbosity: number): IncludeTraces {
+  if (verbosity >= 4) {
+    return IncludeTraces.All;
+  } else if (verbosity >= 3) {
+    return IncludeTraces.Failing;
+  }
+
+  return IncludeTraces.None;
+}
+
+export function formatTraces(
+  traces: CallTrace[],
+  prefix: string,
+  colorizer: Colorizer,
+): string {
+  const lines = traces.map((trace) => formatTrace(trace, colorizer));
+  const formattedTraces = formatNestedArray(lines, prefix);
+  // Remove the trailing newline
+  return formattedTraces.slice(0, -1);
+}
+
+function formatInputs(
+  inputs: DecodedTraceParameters | Uint8Array,
+  color?: (text: string) => string,
+): string | undefined {
+  if (inputs instanceof Uint8Array) {
+    return inputs.length > 0 ? bytesToHexString(inputs) : undefined;
+  } else {
+    const formattedName =
+      color !== undefined ? color(inputs.name) : inputs.name;
+    return `${formattedName}(${inputs.arguments.join(", ")})`;
+  }
+}
+
+function formatOutputs(outputs: string | Uint8Array): string | undefined {
+  if (outputs instanceof Uint8Array) {
+    return outputs.length > 0 ? bytesToHexString(outputs) : undefined;
+  } else {
+    return outputs;
+  }
+}
+
+function formatLog(log: LogTrace, colorizer: Colorizer): string[] {
+  const { parameters } = log;
+  const tag = colorizer.yellow("[event]");
+  const lines = [];
+
+  if (Array.isArray(parameters)) {
+    const hexValues = parameters.map((bytes) => bytesToHexString(bytes));
+    const topicCount = hexValues.length - 1;
+
+    for (let i = 0; i < topicCount; i++) {
+      const prefix = i === 0 ? `${tag} topic 0` : `        topic ${i}`;
+      lines.push(`${prefix}: ${colorizer.cyan(hexValues[i])}`);
+    }
+
+    if (hexValues.length > 0) {
+      const dataPrefix = topicCount > 0 ? "           data" : `${tag}    data`;
+      lines.push(
+        `${dataPrefix}: ${colorizer.cyan(hexValues[hexValues.length - 1])}`,
+      );
+    }
+  } else {
+    lines.push(
+      `${tag} ${parameters.name}(${colorizer.cyan(parameters.arguments.join(", "))})`,
+    );
+  }
+  return lines;
+}
+
+function formatTrace(
+  trace: CallTrace,
+  colorizer: Colorizer,
+): NestedArray<string> {
+  const {
+    success,
+    address,
+    contract,
+    inputs,
+    gasUsed,
+    value,
+    kind,
+    isCheatcode,
+    outputs,
+  } = trace;
+  let color;
+  if (isCheatcode) {
+    color = colorizer.blue;
+  } else if (success) {
+    color = colorizer.green;
+  } else {
+    color = colorizer.red;
+  }
+
+  const formattedInputs = formatInputs(inputs, color);
+  const formattedOutputs = formatOutputs(outputs);
+
+  let openingLine: string;
+  let closingLine: string | undefined;
+  if (kind === CallKind.Create) {
+    openingLine = `[${gasUsed}] ${colorizer.yellow("→ new")} ${contract ?? "<unknown>"}@${address}`;
+    // TODO: Uncomment this when the formattedInputs starts containing
+    // the address of where the contract was deployed instead of the code.
+    // if (formattedInputs !== undefined) {
+    //   openingLine = `${openingLine}@${formattedInputs}`;
+    // }
+  } else {
+    openingLine = `[${gasUsed}] ${color(contract ?? address)}`;
+    if (formattedInputs !== undefined) {
+      openingLine = `${openingLine}::${formattedInputs}`;
+    }
+    if (value !== 0n) {
+      openingLine = `${openingLine} {value: ${value}}`;
+    }
+    if (kind === CallKind.StaticCall) {
+      openingLine = `${openingLine} ${colorizer.yellow("[staticcall]")}`;
+    } else if (kind === CallKind.DelegateCall) {
+      openingLine = `${openingLine} ${colorizer.yellow("[delegatecall]")}`;
+    } else if (kind === CallKind.CallCode) {
+      openingLine = `${openingLine} ${colorizer.yellow("[callcode]")}`;
+    }
+  }
+  if (formattedOutputs !== undefined) {
+    if (
+      formattedOutputs === "EvmError: Revert" ||
+      formattedOutputs.startsWith("revert:")
+    ) {
+      closingLine = `${color("←")} ${color("[Revert]")} ${formattedOutputs}`;
+    } else {
+      closingLine = `${color("←")} ${formattedOutputs}`;
+    }
+  }
+
+  const lines = [];
+  lines.push(openingLine);
+  for (const child of trace.children) {
+    if (child.kind === LogKind.Log) {
+      lines.push(formatLog(child, colorizer));
+    } else {
+      lines.push(formatTrace(child, colorizer));
+    }
+  }
+  if (closingLine !== undefined) {
+    lines.push([closingLine]);
+  }
+  return lines;
+}
+
+function formatNestedArray(
+  data: NestedArray<string>,
+  prefix = "",
+  isTopLevel = true,
+): string {
+  let output = "";
+
+  for (let i = 0; i < data.length; i++) {
+    const item = data[i];
+
+    if (Array.isArray(item) && typeof item[0] === "string") {
+      const [label, ...children] = item;
+
+      if (isTopLevel) {
+        // Blank line between top-level traces
+        if (i > 0) {
+          output += "\n";
+        }
+
+        output += `${prefix}${label}\n`;
+        output += formatNestedArray(children, prefix, false);
+      } else {
+        const isLast = i === data.length - 1;
+        const connector = isLast ? "  └─ " : "  ├─ ";
+        const childPrefix = isLast ? "     " : "  │  ";
+        output += `${prefix}${connector}${label}\n`;
+        output += formatNestedArray(children, prefix + childPrefix, false);
+      }
+    } else if (typeof item === "string") {
+      const isLast = i === data.length - 1;
+      const connector = isLast ? "  └─ " : "  ├─ ";
+      output += `${prefix}${connector}${item}\n`;
+    }
+  }
+
+  return output;
+}

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<
@@ -110,11 +117,15 @@ export class NetworkManagerImplementation implements NetworkManager {
     return networkConnection as NetworkConnection<ChainTypeT>;
   }
 
-  public async createServer(
-    networkOrParams: NetworkConnectionParams | string = "default",
+  public async createServer<
+    ChainTypeT extends ChainType | string = DefaultChainType,
+  >(
+    networkOrParams?: NetworkConnectionParams<ChainTypeT> | string,
     _hostname?: string,
     port?: number,
   ): Promise<JsonRpcServer> {
+    this.#ensureNetworkOrParamsIsNotHttpNetworkConfig(networkOrParams);
+
     const insideDocker = await exists("/.dockerenv");
     const hostname = _hostname ?? (insideDocker ? "0.0.0.0" : "127.0.0.1");
 
@@ -229,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`
@@ -245,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,
         });
       }
 
@@ -294,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
@@ -353,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,
         {
@@ -434,4 +511,27 @@ export class NetworkManagerImplementation implements NetworkManager {
 
     return path;
   }
+
+  #ensureNetworkOrParamsIsNotHttpNetworkConfig(
+    networkOrParams?: NetworkConnectionParams<string> | string,
+  ) {
+    const networkName =
+      typeof networkOrParams === "string"
+        ? networkOrParams
+        : networkOrParams?.network ?? this.#defaultNetwork;
+
+    const networkConfig = this.#networkConfigs[networkName];
+
+    if (networkConfig === undefined || networkConfig.type === "edr-simulated") {
+      return;
+    }
+
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.NETWORK.CREATE_SERVER_UNSUPPORTED_NETWORK_TYPE,
+      {
+        networkName,
+        networkType: networkConfig.type,
+      },
+    );
+  }
 }