hardhat 3.12.0 → 3.14.0

package/src/internal/builtin-plugins/gas-analytics/snapshot-cheatcodes.ts

@@ -13,6 +13,7 @@ import {
   remove,
   writeJsonFile,
 } from "@nomicfoundation/hardhat-utils/fs";
+import { isObject } from "@nomicfoundation/hardhat-utils/lang";
 import { sanitizeFilename } from "@nomicfoundation/hardhat-utils/path";
 
 import {
@@ -20,10 +21,18 @@ import {
   parseFullyQualifiedName,
 } from "../../../utils/contract-names.js";
 
-import { formatSectionHeader, getUserFqn } from "./helpers/utils.js";
+import {
+  formatSectionHeader,
+  getUserFqn,
+  isWithinTolerance,
+} from "./helpers/utils.js";
 
 export const SNAPSHOT_CHEATCODES_DIR = "snapshots";
 
+// Snapshot cheatcode values are uint256 decimal strings, so a stored value
+// that doesn't match this can only come from a hand-edited or corrupted file.
+const SNAPSHOT_VALUE_REGEX = /^\d+$/;
+
 export interface RenamedSnapshotGroup {
   original: string;
   sanitized: string;
@@ -64,8 +73,11 @@ export interface SnapshotCheatcode {
 export interface SnapshotCheatcodeChange {
   group: string;
   name: string;
-  expected: number;
-  actual: number;
+  // Raw snapshot values: uint256 decimal strings, kept as strings because
+  // they can exceed Number.MAX_SAFE_INTEGER and coercing them to `number`
+  // would round them.
+  expected: string;
+  actual: string;
   source: string;
 }
 
@@ -73,6 +85,10 @@ export interface SnapshotCheatcodesComparison {
   added: SnapshotCheatcode[];
   removed: SnapshotCheatcode[];
   changed: SnapshotCheatcodeChange[];
+  // Diffs within the allowed tolerance: they don't fail the check. They are
+  // included in the result for programmatic inspection, but are not shown in
+  // the default console output.
+  tolerated: SnapshotCheatcodeChange[];
 }
 
 export interface SnapshotCheatcodesCheckResult {
@@ -262,9 +278,9 @@ export async function readSnapshotCheatcodes(
       const snapshotGroup = entry.slice(0, -5); // remove .json extension
       const snapshotCheatcodesPath = getSnapshotCheatcodesPath(basePath, entry);
 
-      let snapshot: Record<string, string>;
+      let parsedSnapshot: unknown;
       try {
-        snapshot = await readJsonFile(snapshotCheatcodesPath);
+        parsedSnapshot = await readJsonFile(snapshotCheatcodesPath);
       } catch (error) {
         ensureError(error);
         throw new HardhatError(
@@ -274,6 +290,39 @@ export async function readSnapshotCheatcodes(
         );
       }
 
+      if (!isObject(parsedSnapshot)) {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.SNAPSHOT_READ_ERROR,
+          {
+            snapshotsPath: snapshotCheatcodesPath,
+            error: `Invalid snapshot file: expected a JSON object, got ${JSON.stringify(parsedSnapshot)}`,
+          },
+        );
+      }
+
+      // Snapshot cheatcode values are always machine-generated uint256
+      // decimal strings (vm.snapshotValue/vm.snapshotGas*), so anything else
+      // can only come from a hand-edited or corrupted file. This also rejects
+      // hand-written unquoted JSON numbers (`100` instead of `"100"`).
+      const snapshot: Record<string, string> = {};
+      for (const [name, value] of Object.entries(parsedSnapshot)) {
+        if (
+          typeof value !== "string" ||
+          !SNAPSHOT_VALUE_REGEX.test(value) ||
+          BigInt(value) >= 2n ** 256n
+        ) {
+          throw new HardhatError(
+            HardhatError.ERRORS.CORE.SOLIDITY_TESTS.SNAPSHOT_READ_ERROR,
+            {
+              snapshotsPath: snapshotCheatcodesPath,
+              error: `Invalid value ${JSON.stringify(value)} for "${name}". Snapshot values must be uint256 decimal integer strings`,
+            },
+          );
+        }
+
+        snapshot[name] = value;
+      }
+
       snapshots.set(snapshotGroup, snapshot);
     }
   }
@@ -295,10 +344,12 @@ export function stringifySnapshotCheatcodes(
 export function compareSnapshotCheatcodes(
   previousSnapshotsMap: SnapshotCheatcodesMap,
   currentSnapshotsMap: SnapshotCheatcodesWithMetadataMap,
+  tolerance: number,
 ): SnapshotCheatcodesComparison {
   const added: SnapshotCheatcode[] = [];
   const removed: SnapshotCheatcode[] = [];
   const changed: SnapshotCheatcodeChange[] = [];
+  const tolerated: SnapshotCheatcodeChange[] = [];
   const seenPreviousEntries = new Set<string>();
 
   for (const [group, currentSnapshots] of currentSnapshotsMap) {
@@ -316,13 +367,29 @@ export function compareSnapshotCheatcodes(
         seenPreviousEntries.add(key);
         const previousValue = previousSnapshots[name];
         if (previousValue !== currentEntry.value) {
-          changed.push({
+          const change: SnapshotCheatcodeChange = {
             group,
             name,
-            expected: Number(previousValue),
-            actual: Number(currentEntry.value),
+            expected: previousValue,
+            actual: currentEntry.value,
             source: currentEntry.metadata.source,
-          });
+          };
+
+          // Values above 2^53 lose precision when coerced to `number`, but
+          // the resulting relative error (~1e-14%) is far below any usable
+          // tolerance, so it can't change the outcome of this check.
+          if (
+            tolerance > 0 &&
+            isWithinTolerance(
+              Number(previousValue),
+              Number(currentEntry.value),
+              tolerance,
+            )
+          ) {
+            tolerated.push(change);
+          } else {
+            changed.push(change);
+          }
         }
       }
     }
@@ -347,12 +414,14 @@ export function compareSnapshotCheatcodes(
     added: added.sort(sortByKey),
     removed: removed.sort(sortByKey),
     changed: changed.sort(sortByKey),
+    tolerated: tolerated.sort(sortByKey),
   };
 }
 
 export async function checkSnapshotCheatcodes(
   basePath: string,
   suiteResults: SuiteResult[],
+  tolerance: number,
 ): Promise<SnapshotCheatcodesCheckResult> {
   const { snapshotCheatcodes, renamedGroups } = sanitizeSnapshotCheatcodes(
     extractSnapshotCheatcodes(suiteResults),
@@ -372,6 +441,7 @@ export async function checkSnapshotCheatcodes(
           added: [],
           removed: [],
           changed: [],
+          tolerated: [],
         },
         noBaseline,
         renamedGroups,
@@ -384,6 +454,7 @@ export async function checkSnapshotCheatcodes(
   const comparison = compareSnapshotCheatcodes(
     previousSnapshotCheatcodes,
     snapshotCheatcodes,
+    tolerance,
   );
 
   return {
@@ -480,12 +551,19 @@ export function printSnapshotCheatcodeChanges(
     logger(`  ${change.group}#${change.name}`);
     logger(styleText("grey", `    (in ${change.source})`));
 
-    const diff = change.actual - change.expected;
+    logger(styleText("grey", `    Expected: ${change.expected}`));
+
+    // Snapshot values are uint256 decimal strings that can exceed 2^53, so
+    // the exact diff needs BigInt.
+    const diff = BigInt(change.actual) - BigInt(change.expected);
+
     const formattedDiff = diff > 0 ? `Δ+${diff}` : `Δ${diff}`;
 
     let gasChange = `${formattedDiff}`;
-    if (change.expected > 0) {
-      const percent = (diff / change.expected) * 100;
+
+    const expected = Number(change.expected);
+    if (expected > 0) {
+      const percent = (Number(diff) / expected) * 100;
       const formattedPercent =
         percent >= 0 ? `+${percent.toFixed(2)}%` : `${percent.toFixed(2)}%`;
       gasChange = `${formattedPercent}, ${formattedDiff}`;
@@ -495,7 +573,6 @@ export function printSnapshotCheatcodeChanges(
     const formattedGasChange =
       diff < 0 ? styleText("green", gasChange) : styleText("red", gasChange);
 
-    logger(styleText("grey", `    Expected: ${change.expected}`));
     logger(
       styleText("grey", `    Actual:   ${change.actual} (`) +
         formattedGasChange +

package/src/internal/builtin-plugins/gas-analytics/tasks/solidity-test/task-action.ts

@@ -31,6 +31,7 @@ import {
 interface GasAnalyticsTestActionArguments {
   snapshot: boolean;
   snapshotCheck: boolean;
+  tolerance: number;
   // Forwarded from the base `test solidity` task; used to detect scoped runs.
   grep?: string;
   grepExclude?: string;
@@ -50,6 +51,30 @@ export interface SnapshotCheckResult {
 const runSolidityTests: TaskOverrideActionFunction<
   GasAnalyticsTestActionArguments
 > = async (args, hre, runSuper) => {
+  // Validate the flags before runSuper: it runs the entire test suite, and a
+  // usage error should fail immediately, not after a potentially long run.
+  if (args.snapshot && args.snapshotCheck) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.SOLIDITY_TESTS.MUTUALLY_EXCLUSIVE_SNAPSHOT_FLAGS,
+    );
+  }
+
+  // Unreachable from the CLI (the FLOAT parser rejects negative/non-numeric
+  // values), but programmatic `task.run({ tolerance })` only validates
+  // `typeof === "number"`.
+  if (args.tolerance < 0 || !Number.isFinite(args.tolerance)) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INVALID_SNAPSHOT_TOLERANCE,
+      { value: args.tolerance },
+    );
+  }
+
+  if (args.tolerance !== 0 && !args.snapshotCheck) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.SOLIDITY_TESTS.SNAPSHOT_TOLERANCE_REQUIRES_CHECK,
+    );
+  }
+
   const superResult: Result<SolidityTestRunResult, SolidityTestRunResult> =
     await runSuper(args);
   const testsPassed = superResult.success;
@@ -59,12 +84,6 @@ const runSolidityTests: TaskOverrideActionFunction<
   const suiteResults = solidityTestRunResult.suiteResults;
   const rootPath = hre.config.paths.root;
 
-  if (args.snapshot && args.snapshotCheck) {
-    throw new HardhatError(
-      HardhatError.ERRORS.CORE.SOLIDITY_TESTS.MUTUALLY_EXCLUSIVE_SNAPSHOT_FLAGS,
-    );
-  }
-
   let snapshotCheckPassed = true;
   if (args.snapshot) {
     const snapshotResult = await handleSnapshot(
@@ -77,6 +96,7 @@ const runSolidityTests: TaskOverrideActionFunction<
     const snapshotCheckResult = await handleSnapshotCheck(
       rootPath,
       suiteResults,
+      args.tolerance,
     );
     logSnapshotCheckResult(
       snapshotCheckResult,
@@ -156,14 +176,17 @@ export function logSnapshotResult(
 export async function handleSnapshotCheck(
   basePath: string,
   suiteResults: SuiteResult[],
+  tolerance: number,
 ): Promise<SnapshotCheckResult> {
   const functionGasSnapshotsCheck = await checkFunctionGasSnapshots(
     basePath,
     suiteResults,
+    tolerance,
   );
   const snapshotCheatcodesCheck = await checkSnapshotCheatcodes(
     basePath,
     suiteResults,
+    tolerance,
   );
 
   return {

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

@@ -24,23 +24,6 @@ export const DEFAULT_CHAIN_DESCRIPTORS: ChainDescriptorsConfig = new Map([
       },
     },
   ],
-  // holesky testnet
-  [
-    17_000n,
-    {
-      name: "Holesky",
-      chainType: L1_CHAIN_TYPE,
-      blockExplorers: {
-        etherscan: {
-          url: "https://holesky.etherscan.io",
-        },
-        blockscout: {
-          url: "https://eth-holesky.blockscout.com",
-          apiUrl: "https://eth-holesky.blockscout.com/api",
-        },
-      },
-    },
-  ],
   // hoodi testnet
   [
     560_048n,

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

@@ -426,7 +426,11 @@ function refineEdrNetworkUserConfig(
       }
 
       const interval = network.mining?.interval;
-      if (typeof interval === "number" || Array.isArray(interval)) {
+      // A scalar `interval: 0` disables interval mining entirely, so this validation is not appropriate
+      if (
+        (typeof interval === "number" && interval !== 0) ||
+        Array.isArray(interval)
+      ) {
         const minInterval =
           typeof interval === "number" ? interval : Math.min(...interval);
         if (

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

@@ -58,6 +58,16 @@ import {
 
 const NPM_PACKAGES_WITH_SIMULATED_PACKAGE_EXPORTS = new Set(["forge-std"]);
 
+function isInputSourceNameWithinRoot(
+  inputSourceName: string,
+  inputSourceNameRoot: string,
+): boolean {
+  return (
+    inputSourceName === inputSourceNameRoot ||
+    inputSourceName.startsWith(`${inputSourceNameRoot}/`)
+  );
+}
+
 export class ResolverImplementation implements Resolver {
   readonly #projectRoot: string;
   readonly #npmPackageGraph: RemappedNpmPackagesGraphImplementation;
@@ -174,7 +184,13 @@ export class ResolverImplementation implements Resolver {
   async #resolveProjectFile(
     absoluteFilePath: string,
   ): Promise<Result<ProjectResolvedFile, ProjectRootResolutionError>> {
-    if (!absoluteFilePath.startsWith(this.#projectRoot)) {
+    const relativeFilePath = path.relative(this.#projectRoot, absoluteFilePath);
+
+    if (
+      relativeFilePath === ".." ||
+      relativeFilePath.startsWith(`..${path.sep}`) ||
+      path.isAbsolute(relativeFilePath)
+    ) {
       return {
         success: false,
         error: {
@@ -184,8 +200,6 @@ export class ResolverImplementation implements Resolver {
       };
     }
 
-    const relativeFilePath = path.relative(this.#projectRoot, absoluteFilePath);
-
     // We first check if the file has already been resolved.
     //
     // Note that it may have received the right path, but with the wrong
@@ -438,7 +452,12 @@ export class ResolverImplementation implements Resolver {
 
     if (isRelativeImport) {
       // If the import is relative, it shouldn't leave its package
-      if (!directImport.startsWith(from.package.inputSourceNameRoot)) {
+      if (
+        !isInputSourceNameWithinRoot(
+          directImport,
+          from.package.inputSourceNameRoot,
+        )
+      ) {
         return {
           success: false,
           error: {
@@ -451,7 +470,8 @@ export class ResolverImplementation implements Resolver {
 
       // It also shouldn't get into its package's node_modules
       if (
-        directImport.startsWith(
+        isInputSourceNameWithinRoot(
+          directImport,
           sourceNamePathJoin(from.package.inputSourceNameRoot, "node_modules"),
         )
       ) {

package/src/internal/builtin-plugins/solidity/type-extensions.ts

@@ -20,7 +20,7 @@ declare module "../../../types/config.js" {
    * The types of the values don't matter; we use `true` as a convention.
    *
    * By default, only "solc" is provided. Plugins can extend this via
-   * declaration merging to add new compiler types (e.g. "solx").
+   * declaration merging to add new compiler types (e.g. "slangSolx").
    */
   export interface SolidityCompilerTypeDefinitions {
     solc: true;
@@ -358,7 +358,7 @@ declare module "../../../types/hooks.js" {
     /**
      * Hook to obtain a Compiler instance for a given compiler configuration.
      * The default handler returns a solc compiler. Plugins can intercept to
-     * return their own compiler (e.g. SolxCompiler for type: "solx").
+     * return their own compiler (e.g. SlangSolxCompiler for type: "slangSolx").
      *
      * @param context The hook context.
      * @param compilerConfig The compiler configuration to get a compiler for.

package/src/internal/builtin-plugins/solidity-test/helpers.ts

@@ -22,7 +22,10 @@ import {
 import { toBigInt } from "@nomicfoundation/hardhat-utils/bigint";
 import { hexStringToBytes } from "@nomicfoundation/hardhat-utils/hex";
 
-import { DEFAULT_VERBOSITY, OPTIMISM_CHAIN_TYPE } from "../../constants.js";
+import {
+  ALWAYS_COLLECT_STACK_TRACES_VERBOSITY,
+  OPTIMISM_CHAIN_TYPE,
+} from "../../constants.js";
 import { resolveHardfork } from "../network-manager/config-resolution.js";
 import { hardhatHardforkToEdrSpecId } from "../network-manager/edr/utils/convert-to-edr.js";
 import { warnIfExperimentalHardfork } from "../network-manager/edr/utils/hardfork.js";
@@ -139,7 +142,8 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
     }
   }
 
-  const shouldAlwaysCollectStackTraces = verbosity > DEFAULT_VERBOSITY;
+  const shouldAlwaysCollectStackTraces =
+    verbosity >= ALWAYS_COLLECT_STACK_TRACES_VERBOSITY;
 
   return {
     projectRoot,

package/src/internal/builtin-plugins/solidity-test/reporter.ts

@@ -10,6 +10,7 @@ import { styleText } from "node:util";
 import { bytesToHexString } from "@nomicfoundation/hardhat-utils/hex";
 
 import { sendErrorTelemetry } from "../../cli/telemetry/error-reporter/reporter.js";
+import { ALWAYS_COLLECT_STACK_TRACES_VERBOSITY } from "../../constants.js";
 import { SolidityTestStackTraceGenerationError } from "../network-manager/edr/stack-traces/stack-trace-generation-errors.js";
 import { encodeStackTraceEntry } from "../network-manager/edr/stack-traces/stack-trace-solidity-errors.js";
 import { formatTraces } from "../network-manager/edr/utils/trace-formatters.js";
@@ -17,6 +18,8 @@ import { formatTraces } from "../network-manager/edr/utils/trace-formatters.js";
 import { formatArtifactId } from "./formatters.js";
 import { getMessageFromLastStackTraceEntry } from "./stack-trace-solidity-errors.js";
 
+const RERUN_VERBOSITY_HINT = `Try rerunning your tests with -${"v".repeat(ALWAYS_COLLECT_STACK_TRACES_VERBOSITY)} or above.`;
+
 class Indenter {
   #indentation: number;
 
@@ -305,17 +308,13 @@ export async function* testReporter(
             yield* output(
               indenter.t`Stack Trace Warning: ${colorize("grey", "The test is not safe to replay because a fork url without a fork block number was provided.")}\n`,
             );
-            yield* output(
-              indenter.t`Try rerunning your tests with -vvv or above.\n`,
-            );
+            yield* output(indenter.t`${RERUN_VERBOSITY_HINT}\n`);
           }
           if (stackTrace.impureCheatcodes.length > 0) {
             yield* output(
               indenter.t`Stack Trace Warning: ${colorize("grey", `The test is not safe to replay because it uses impure cheatcodes: ${stackTrace.impureCheatcodes.join(", ")}`)}\n`,
             );
-            yield* output(
-              indenter.t`Try rerunning your tests with -vvv or above.\n`,
-            );
+            yield* output(indenter.t`${RERUN_VERBOSITY_HINT}\n`);
           }
           break;
         case "HeuristicFailed":
@@ -334,7 +333,7 @@ export async function* testReporter(
           yield* output(indenter.t`Counterexample:\n`);
           indenter.inc();
           for (const [key, value] of Object.entries(counterexample)) {
-            const counterExampleDetails = `${key}: ${Buffer.isBuffer(value) ? bytesToHexString(value) : value}`;
+            const counterExampleDetails = `${key}: ${value instanceof Uint8Array ? bytesToHexString(value) : value}`;
             yield* output(
               indenter.t`${colorize("grey", counterExampleDetails)}\n`,
             );

package/src/internal/cli/{error-handler.ts → error-handling/error-handler.ts}

@@ -1,4 +1,4 @@
-import type * as ClassifierT from "./telemetry/error-classification/classifier.js";
+import type * as ClassifierT from "../telemetry/error-classification/classifier.js";
 
 import { styleText } from "node:util";
 
@@ -7,7 +7,9 @@ import {
   HardhatPluginError,
 } from "@nomicfoundation/hardhat-errors";
 
-import { HARDHAT_NAME, HARDHAT_WEBSITE_URL } from "../constants.js";
+import { HARDHAT_NAME, HARDHAT_WEBSITE_URL } from "../../constants.js";
+
+import { detectNativeBindingFailure } from "./native-binding-error.js";
 
 // The classifier may import many unrelated things top-level to do its job, so
 // we load it lazily.
@@ -165,9 +167,24 @@ async function getErrorWithCategory(error: Error): Promise<ErrorWithCategory> {
     };
   }
 
+  const nativeBindingFailure = detectNativeBindingFailure(error);
+  if (nativeBindingFailure !== undefined) {
+    return {
+      category: ErrorCategory.HARDHAT,
+      categorizedError: new HardhatError(
+        HardhatError.ERRORS.CORE.GENERAL.NATIVE_BINDING_LOAD_FAILED,
+        {
+          parentPackage: nativeBindingFailure.parentPackage,
+          missingPackage: nativeBindingFailure.missingPackage,
+        },
+        error,
+      ),
+    };
+  }
+
   if (classifierModule === undefined) {
     classifierModule =
-      await import("./telemetry/error-classification/classifier.js");
+      await import("../telemetry/error-classification/classifier.js");
   }
 
   // Pass `ignoreDevelopmentTimeFilter=true` so the migration footer also shows

package/src/internal/cli/error-handling/native-binding-error.ts

@@ -0,0 +1,78 @@
+/**
+ * The platform triple that napi-rs appends to the platform package name, e.g.
+ * `@nomicfoundation/edr-linux-x64-gnu`, `@scope/pkg-darwin-arm64`.
+ */
+const PLATFORM_SUFFIX_REGEX =
+  /-(?:android|darwin|freebsd|linux|win32)-(?:arm|arm64|ia32|x64|riscv64|ppc64|s390x)(?:-(?:gnu|musl|msvc|eabi|gnueabihf))?$/;
+
+/**
+ * Matches both the CJS (`Cannot find module 'x'`) and ESM
+ * (`Cannot find package 'x' imported from y`) forms.
+ */
+const MISSING_MODULE_REGEX = /Cannot find (?:module|package) '([^']+)'/g;
+
+/**
+ * The packages Hardhat itself ships a native binding for.
+ */
+const HARDHAT_NATIVE_BINDING_PACKAGES = [
+  "@nomicfoundation/edr",
+  "@nomicfoundation/solidity-analyzer",
+];
+
+export interface NativeBindingFailure {
+  /** The package whose loader failed, e.g. `@nomicfoundation/edr`. */
+  parentPackage: string;
+  /** The platform package that couldn't be found. */
+  missingPackage: string;
+}
+
+/**
+ * Detect whether a given error is a napi-rs native binding load failure.
+ *
+ * Packages like `@nomicfoundation/edr` and `@nomicfoundation/solidity-analyzer`
+ * ship one prebuilt binary per platform in a separate package, and their
+ * generated loader `require`s the one matching the current platform. When that
+ * package is missing from the installation the loader throws at import time, so
+ * the failure surfaces as an opaque `MODULE_NOT_FOUND` from deep inside
+ * `node_modules`.
+ */
+export function detectNativeBindingFailure(
+  error: Error,
+): NativeBindingFailure | undefined {
+  const chain = errorChain(error);
+
+  // Some link in the chain names the missing platform package.
+  for (const chainedError of chain) {
+    for (const match of chainedError.message.matchAll(MISSING_MODULE_REGEX)) {
+      const moduleName = match[1];
+
+      if (!PLATFORM_SUFFIX_REGEX.test(moduleName)) {
+        continue;
+      }
+
+      const parentPackage = moduleName.replace(PLATFORM_SUFFIX_REGEX, "");
+
+      if (!HARDHAT_NATIVE_BINDING_PACKAGES.includes(parentPackage)) {
+        continue;
+      }
+
+      return { missingPackage: moduleName, parentPackage };
+    }
+  }
+
+  return undefined;
+}
+
+function errorChain(error: Error): Error[] {
+  const chain: Error[] = [];
+  const seen = new Set<unknown>();
+  let current: unknown = error;
+
+  while (current instanceof Error && !seen.has(current)) {
+    seen.add(current);
+    chain.push(current);
+    current = current.cause;
+  }
+
+  return chain;
+}

package/src/internal/cli/hhu.ts

@@ -19,7 +19,7 @@ import { globalFlag } from "../core/config.js";
 import { TaskManagerImplementation } from "../core/tasks/task-manager.js";
 import { getHardhatVersion } from "../utils/package.js";
 
-import { printErrorMessages } from "./error-handler.js";
+import { printErrorMessages } from "./error-handling/error-handler.js";
 import { getGlobalHelpString } from "./help/get-global-help-string.js";
 import { getHelpString } from "./help/get-help-string.js";
 import {

package/src/internal/cli/main.ts

@@ -28,7 +28,7 @@ import { warnAboutUnusedLoadedPlugins } from "../core/plugins/unused-plugins-war
 import { setGlobalHardhatRuntimeEnvironment } from "../global-hre-instance.js";
 import { createHardhatRuntimeEnvironment } from "../hre-initialization.js";
 
-import { printErrorMessages } from "./error-handler.js";
+import { printErrorMessages } from "./error-handling/error-handler.js";
 import { getGlobalHelpString } from "./help/get-global-help-string.js";
 import { getHelpString } from "./help/get-help-string.js";
 import {

package/src/internal/constants.ts

@@ -11,3 +11,14 @@ export const OPTIMISM_CHAIN_TYPE = "op";
 export const DEFAULT_NETWORK_NAME = "default";
 
 export const DEFAULT_VERBOSITY = 2;
+
+/**
+ * The verbosity level (`-vvvvv`) at and above which stack traces are always
+ * collected. Below it, stack traces are produced by re-running the failing
+ * test with tracing enabled — much cheaper, but tests with non-deterministic
+ * side effects (impure cheatcodes, a fork pinned to `latest`) can't be
+ * replayed and report an `UnsafeToReplay` warning instead. Always-on
+ * collection records step traces for every test, which balloons memory on
+ * large suites, so it's reserved for the highest verbosity.
+ */
+export const ALWAYS_COLLECT_STACK_TRACES_VERBOSITY = 5;