hardhat 3.2.0 → 3.4.0

package/src/internal/builtin-plugins/network-manager/edr/genesis-state.ts

@@ -0,0 +1,179 @@
+import type {
+  EdrNetworkAccountsConfig,
+  EdrNetworkForkingConfig,
+} from "../../../../types/config.js";
+import type { ChainType } from "../../../../types/network.js";
+import type * as MicroEthSignerAddressT from "micro-eth-signer/address";
+
+import {
+  l1GenesisState,
+  l1HardforkFromString,
+  opGenesisState,
+  opHardforkFromString,
+  type AccountOverride,
+} from "@nomicfoundation/edr";
+import { AsyncMutex } from "@nomicfoundation/hardhat-utils/synchronization";
+import { hexToBytes } from "ethereum-cryptography/utils";
+
+import { OPTIMISM_CHAIN_TYPE } from "../../../constants.js";
+
+import { hardhatAccountsToEdrOwnedAccounts } from "./utils/convert-to-edr.js";
+
+// micro-eth-signer is known to be slow to load, so we lazy load it
+let microEthSignerAddress: typeof MicroEthSignerAddressT | undefined;
+
+const noForkingConfigCacheMarkerObject = {};
+
+/**
+ * We cache the genesis state and owned accounts because computing them can be
+ * expensive, especially when run multiple times for the same configuration
+ * (e.g. when creating many EDR connections to the same network config).
+ *
+ * We use mostly references as cache keys, which means that we can miss some
+ * cache hits if an equivalent config is used with a different reference, but
+ * in practice this should rarely happen, except when using network config
+ * overrides that generate the same config. These cases should be the minority
+ * within a test suite.
+ *
+ * Note: the main reason that we don't use the entire NetworkConfig as cache
+ * key is that EDR initialization path recreates the NetworkConfig object to
+ * override some properties like `allowUnlimitedContractSize`, leading to a
+ * different NetworkConfig reference, despite keeping the references of most
+ * of its properties (including the accounts and forking config) the same.
+ */
+const genesisStateAndAccountsCache: WeakMap<
+  EdrNetworkAccountsConfig,
+  WeakMap<
+    EdrNetworkForkingConfig | typeof noForkingConfigCacheMarkerObject,
+    Map<
+      ChainType,
+      Map<
+        string,
+        {
+          genesisState: Map<Uint8Array, AccountOverride>;
+          ownedAccounts: Array<{ secretKey: string; balance: bigint }>;
+        }
+      >
+    >
+  >
+> = new WeakMap();
+
+const genesisStateAndAccountsCacheMutex = new AsyncMutex();
+
+export async function getGenesisStateAndOwnedAccounts(
+  accountsConfig: EdrNetworkAccountsConfig,
+  forkingConfig: EdrNetworkForkingConfig | undefined,
+  chainType: ChainType,
+  specId: string,
+): Promise<{
+  genesisState: Map<Uint8Array, AccountOverride>;
+  ownedAccounts: Array<{ secretKey: string; balance: bigint }>;
+}> {
+  const cached = genesisStateAndAccountsCache
+    .get(accountsConfig)
+    ?.get(forkingConfig ?? noForkingConfigCacheMarkerObject)
+    ?.get(chainType)
+    ?.get(specId);
+
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  return genesisStateAndAccountsCacheMutex.exclusiveRun(async () => {
+    // We need to check again inside the mutex callback in case another async
+    // operation initialized it while we were waiting to acquire the mutex
+    const cachedAfterWaiting = genesisStateAndAccountsCache
+      .get(accountsConfig)
+      ?.get(forkingConfig ?? noForkingConfigCacheMarkerObject)
+      ?.get(chainType)
+      ?.get(specId);
+
+    if (cachedAfterWaiting !== undefined) {
+      return cachedAfterWaiting;
+    }
+
+    const result = await createGenesisStateAndOwnedAccounts(
+      accountsConfig,
+      forkingConfig,
+      chainType,
+      specId,
+    );
+
+    let secondLevelCacheMap = genesisStateAndAccountsCache.get(accountsConfig);
+    if (secondLevelCacheMap === undefined) {
+      secondLevelCacheMap = new WeakMap();
+      genesisStateAndAccountsCache.set(accountsConfig, secondLevelCacheMap);
+    }
+
+    const forkingConfigCacheKey =
+      forkingConfig ?? noForkingConfigCacheMarkerObject;
+    let thirdLevelCacheMap = secondLevelCacheMap.get(forkingConfigCacheKey);
+    if (thirdLevelCacheMap === undefined) {
+      thirdLevelCacheMap = new Map();
+      secondLevelCacheMap.set(forkingConfigCacheKey, thirdLevelCacheMap);
+    }
+
+    let fourthLevelCacheMap = thirdLevelCacheMap.get(chainType);
+    if (fourthLevelCacheMap === undefined) {
+      fourthLevelCacheMap = new Map();
+      thirdLevelCacheMap.set(chainType, fourthLevelCacheMap);
+    }
+
+    fourthLevelCacheMap.set(specId, result);
+
+    return result;
+  });
+}
+
+async function createGenesisStateAndOwnedAccounts(
+  accountsConfig: EdrNetworkAccountsConfig,
+  forkingConfig: EdrNetworkForkingConfig | undefined,
+  chainType: ChainType,
+  specId: string,
+): Promise<{
+  genesisState: Map<Uint8Array, AccountOverride>;
+  ownedAccounts: Array<{ secretKey: string; balance: bigint }>;
+}> {
+  if (microEthSignerAddress === undefined) {
+    microEthSignerAddress = await import("micro-eth-signer/address");
+  }
+
+  const { addr } = microEthSignerAddress;
+
+  const ownedAccounts = await hardhatAccountsToEdrOwnedAccounts(accountsConfig);
+
+  const genesisState: Map<Uint8Array, AccountOverride> = new Map(
+    ownedAccounts.map(({ secretKey, balance }) => {
+      const address = hexToBytes(addr.fromPrivateKey(secretKey));
+      const accountOverride: AccountOverride = {
+        address,
+        balance: BigInt(balance),
+        code: new Uint8Array(), // Empty account code, removing potential delegation code when forking
+      };
+
+      return [address, accountOverride];
+    }),
+  );
+
+  const chainGenesisState =
+    forkingConfig !== undefined
+      ? [] // TODO: Add support for overriding remote fork state when the local fork is different
+      : chainType === OPTIMISM_CHAIN_TYPE
+        ? opGenesisState(opHardforkFromString(specId))
+        : l1GenesisState(l1HardforkFromString(specId));
+
+  for (const account of chainGenesisState) {
+    const existingOverride = genesisState.get(account.address);
+    if (existingOverride !== undefined) {
+      // Favor the genesis state specified by the user
+      account.balance = account.balance ?? existingOverride.balance;
+      account.nonce = account.nonce ?? existingOverride.nonce;
+      account.code = account.code ?? existingOverride.code;
+      account.storage = account.storage ?? existingOverride.storage;
+    } else {
+      genesisState.set(account.address, account);
+    }
+  }
+
+  return { genesisState, ownedAccounts };
+}

package/src/internal/builtin-plugins/network-manager/edr/stack-traces/solidity-stack-trace.ts

@@ -25,10 +25,12 @@ import type {
   InternalFunctionCallStackEntry,
   ContractCallRunOutOfGasError,
   CheatcodeErrorStackTraceEntry,
+  CheatcodeErrorDetails,
 } from "@nomicfoundation/edr";
 
 import {
   StackTraceEntryType,
+  CheatcodeErrorCode,
   stackTraceEntryTypeToString,
   FALLBACK_FUNCTION_NAME,
   RECEIVE_FUNCTION_NAME,
@@ -42,6 +44,7 @@ import {
 export {
   SourceReference,
   StackTraceEntryType,
+  CheatcodeErrorCode,
   stackTraceEntryTypeToString,
   FALLBACK_FUNCTION_NAME,
   RECEIVE_FUNCTION_NAME,
@@ -77,6 +80,7 @@ export type {
   ContractTooLargeErrorStackTraceEntry,
   InternalFunctionCallStackEntry,
   ContractCallRunOutOfGasError,
+  CheatcodeErrorDetails,
 };
 
 export type SolidityStackTraceEntry =

package/src/internal/builtin-plugins/network-manager/edr/stack-traces/stack-trace-solidity-errors.ts

@@ -9,8 +9,11 @@ import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
 import { bytesToHexString } from "@nomicfoundation/hardhat-utils/bytes";
 import { panicErrorCodeToMessage } from "@nomicfoundation/hardhat-utils/panic-errors";
 
+import { REVERT_ERROR_CODE } from "../../revert-error-code.js";
+
 import {
   StackTraceEntryType,
+  CheatcodeErrorCode,
   CONSTRUCTOR_FUNCTION_NAME,
   PRECOMPILE_FUNCTION_NAME,
   UNKNOWN_FUNCTION_NAME,
@@ -266,9 +269,25 @@ function getMessageFromLastStackTraceEntry(
       return `VM Exception while processing transaction: ${panicMessage}`;
 
     case StackTraceEntryType.CUSTOM_ERROR:
-    case StackTraceEntryType.CHEATCODE_ERROR:
       return `VM Exception while processing transaction: ${stackTraceEntry.message}`;
 
+    case StackTraceEntryType.CHEATCODE_ERROR: {
+      let message = stackTraceEntry.message;
+
+      if (stackTraceEntry.details !== undefined) {
+        switch (stackTraceEntry.details.code) {
+          case CheatcodeErrorCode.UnsupportedCheatcode:
+            message = `Cheatcode '${stackTraceEntry.details.cheatcode}' is not supported by Hardhat.`;
+            break;
+          case CheatcodeErrorCode.MissingCheatcode:
+            message = `Cheatcode '${stackTraceEntry.details.cheatcode}' is not yet available in this version of Hardhat.`;
+            break;
+        }
+      }
+
+      return `VM Exception while processing transaction: ${message}`;
+    }
+
     case StackTraceEntryType.OTHER_EXECUTION_ERROR:
       // TODO: What if there was returnData?
       return `Transaction reverted and Hardhat couldn't infer the reason.`;
@@ -293,11 +312,15 @@ function getMessageFromLastStackTraceEntry(
 }
 
 /**
- * Note: This error class MUST NOT extend ProviderError, as libraries use the
- * code property to detect if they are dealing with a JSON-RPC error, and take
- * control of errors.
+ * Note: This error class does not extend ProviderError because it carries
+ * Solidity-specific data (stackTrace) that ProviderError does not model.
+ * It does carry `code = 3` to match the de facto standard used by geth and
+ * anvil for execution revert errors, allowing libraries like viem to
+ * properly detect and handle revert errors via the error cause chain.
  **/
 export class SolidityError extends Error {
+  public readonly code: number = REVERT_ERROR_CODE;
+
   constructor(
     message: string,
     public readonly stackTrace: SolidityStackTrace,
@@ -305,6 +328,7 @@ export class SolidityError extends Error {
     public readonly transactionHash?: string,
   ) {
     super(message);
+    this.name = "SolidityError";
 
     Object.defineProperty(this, Symbol.for("nodejs.util.inspect.custom"), {
       value: () =>

package/src/internal/builtin-plugins/network-manager/edr/utils/convert-to-edr.ts

@@ -404,7 +404,7 @@ export function edrGasReportToHardhatGasMeasurements(
           contractFqn,
           type: "deployment",
           gas: Number(deployment.gas),
-          size: Number(deployment.size),
+          runtimeSize: Number(deployment.runtimeSize),
         });
       }
     }
@@ -418,6 +418,7 @@ export function edrGasReportToHardhatGasMeasurements(
             type: "function",
             functionSig,
             gas: Number(call.gas),
+            proxyChain: call.proxyChain,
           });
         }
       }

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

@@ -12,6 +12,14 @@ export default async (): Promise<Partial<HardhatRuntimeEnvironmentHooks>> => ({
     let networkManager: NetworkManager | undefined;
 
     hre.network = {
+      async create(networkConnectionParams) {
+        if (networkManager === undefined) {
+          networkManager = await createNetworkManager(hre, context);
+        }
+
+        return networkManager.create(networkConnectionParams);
+      },
+
       async connect(networkConnectionParams) {
         if (networkManager === undefined) {
           networkManager = await createNetworkManager(hre, context);
@@ -19,6 +27,15 @@ export default async (): Promise<Partial<HardhatRuntimeEnvironmentHooks>> => ({
 
         return networkManager.connect(networkConnectionParams);
       },
+
+      async getOrCreate(networkOrParams) {
+        if (networkManager === undefined) {
+          networkManager = await createNetworkManager(hre, context);
+        }
+
+        return networkManager.getOrCreate(networkOrParams);
+      },
+
       async createServer(...params) {
         if (networkManager === undefined) {
           networkManager = await createNetworkManager(hre, context);
@@ -27,6 +44,18 @@ export default async (): Promise<Partial<HardhatRuntimeEnvironmentHooks>> => ({
         return networkManager.createServer(...params);
       },
     };
+
+    // To avoid adding `wasConnectCalled` to the public interface of
+    // `NetworkManager`, we add this pass through method that is only
+    // called from the `main` function.
+    Object.defineProperty(hre.network, "wasConnectCalled", {
+      value: () =>
+        networkManager !== undefined &&
+        "wasConnectCalled" in networkManager &&
+        typeof networkManager.wasConnectCalled === "function" &&
+        networkManager.wasConnectCalled(),
+      enumerable: false,
+    });
   },
 });
 
@@ -50,5 +79,6 @@ async function createNetworkManager(
     hre.config.chainDescriptors,
     hre.globalOptions.config,
     hre.config.paths.root,
+    hre.globalOptions.verbosity,
   );
 }