hardhat 3.1.12 → 3.3.0

package/src/internal/builtin-plugins/solidity-test/inline-config/validation.ts

@@ -0,0 +1,122 @@
+import type { RawInlineOverride } from "./types.js";
+
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+
+import { KEY_TYPES } from "./constants.js";
+import { getFunctionFqn } from "./helpers.js";
+
+/**
+ * Validates a list of raw inline overrides, checking for:
+ * - Valid keys
+ * - No duplicate keys for the same function
+ * - Values of the expected type (numbers must be non-negative integers, booleans
+ *   must be "true" or "false")
+ *
+ * Throws a HardhatError if any validation fails.
+ */
+export function validateInlineOverrides(overrides: RawInlineOverride[]): void {
+  const seen = new Set<string>();
+
+  for (const {
+    inputSourceName,
+    contractName,
+    functionName,
+    functionSelector,
+    rawKey,
+    rawValue,
+    key,
+  } of overrides) {
+    const functionFqn = getFunctionFqn(
+      inputSourceName,
+      contractName,
+      functionName,
+    );
+
+    // Validate key
+    if (!Object.hasOwn(KEY_TYPES, key)) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_KEY,
+        {
+          key: rawKey,
+          validKeys: Object.keys(KEY_TYPES).join(", "),
+          functionFqn,
+        },
+      );
+    }
+
+    // Validate key matches test type
+    const dotIndex = key.indexOf(".");
+    if (dotIndex !== -1) {
+      const keyCategory = key.slice(0, dotIndex);
+      const isFuzzTest = functionName.startsWith("test");
+      const isInvariantTest = functionName.startsWith("invariant");
+
+      if (
+        (isFuzzTest && keyCategory === "invariant") ||
+        (isInvariantTest && keyCategory === "fuzz")
+      ) {
+        const testType = isFuzzTest ? "fuzz" : "invariant";
+        const validPrefix = isFuzzTest ? "fuzz." : "invariant.";
+        const validKeys = Object.keys(KEY_TYPES)
+          .filter((k) => k.startsWith(validPrefix) || !k.includes("."))
+          .join(", ");
+
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_KEY_FOR_TEST_TYPE,
+          {
+            key: rawKey,
+            functionFqn,
+            testType,
+            validKeys,
+          },
+        );
+      }
+    }
+
+    // Check for duplicates (include selector to allow same key on overloaded functions)
+    const functionId =
+      functionSelector !== undefined
+        ? `${functionFqn}#${functionSelector}`
+        : functionFqn;
+    const dedupeKey = `${functionId}-${key}`;
+    if (seen.has(dedupeKey)) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_DUPLICATE_KEY,
+        { key: rawKey, functionFqn },
+      );
+    }
+    seen.add(dedupeKey);
+
+    // Validate value type
+    const expectedType = KEY_TYPES[key];
+    if (expectedType === "number") {
+      if (
+        !/^(0|[1-9]\d*)$/.test(rawValue) ||
+        !Number.isSafeInteger(Number(rawValue))
+      ) {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_VALUE,
+          {
+            value: rawValue,
+            key: rawKey,
+            expectedType: "non-negative integer",
+            functionFqn,
+          },
+        );
+      }
+    } else {
+      const lowerValue = rawValue.toLowerCase();
+      if (lowerValue !== "true" && lowerValue !== "false") {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_VALUE,
+          {
+            value: rawValue,
+            key: rawKey,
+            expectedType: "boolean",
+            functionFqn,
+          },
+        );
+      }
+    }
+  }
+}

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

@@ -3,6 +3,7 @@ import type {
   TestReporterResult,
   TestStatus,
 } from "./types.js";
+import type { Colorizer } from "../../utils/colorizer.js";
 import type { TestResult } from "@nomicfoundation/edr";
 
 import { bytesToHexString } from "@nomicfoundation/hardhat-utils/hex";
@@ -11,12 +12,9 @@ import chalk from "chalk";
 import { sendErrorTelemetry } from "../../cli/telemetry/sentry/reporter.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";
 
-import {
-  type Colorizer,
-  formatArtifactId,
-  formatTraces,
-} from "./formatters.js";
+import { formatArtifactId } from "./formatters.js";
 import { getMessageFromLastStackTraceEntry } from "./stack-trace-solidity-errors.js";
 
 class Indenter {
@@ -147,6 +145,8 @@ export async function* testReporter(
               suiteSuccessCount++;
               if (verbosity >= 5) {
                 printSetUpTraces = true;
+              }
+              if (verbosity >= 4) {
                 printExecutionTraces = true;
               }
               break;
@@ -184,7 +184,7 @@ export async function* testReporter(
               if (printSetUpTraces && functionName === "setUp") {
                 return true;
               }
-              if (printExecutionTraces && functionName !== "setUp()") {
+              if (printExecutionTraces && functionName !== "setUp") {
                 return true;
               }
               return false;

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

@@ -1,40 +1,42 @@
-import type { RunOptions } from "./runner.js";
+import type {
+  BuildInfoAndOutput,
+  EdrArtifactWithMetadata,
+} from "./edr-artifacts.js";
 import type { TestEvent } from "./types.js";
 import type { NewTaskActionFunction } from "../../../types/tasks.js";
 import type { TestRunResult } from "../../../types/test.js";
 import type { Result } from "../../../types/utils.js";
 import type {
-  Artifact as EdrArtifact,
-  BuildInfoAndOutput,
   ObservabilityConfig,
-  SolidityTestRunnerConfigArgs,
   TracingConfigWithBuffers,
   SuiteResult,
 } from "@nomicfoundation/edr";
 
 import { finished } from "node:stream/promises";
 
-import {
-  assertHardhatInvariant,
-  HardhatError,
-} from "@nomicfoundation/hardhat-errors";
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 import { createNonClosingWriter } from "@nomicfoundation/hardhat-utils/stream";
 
 import { getFullyQualifiedName } from "../../../utils/contract-names.js";
 import { errorResult, successfulResult } from "../../../utils/result.js";
-import { HardhatRuntimeEnvironmentImplementation } from "../../core/hre.js";
 import { isSupportedChainType } from "../../edr/chain-type.js";
 import { ArtifactManagerImplementation } from "../artifacts/artifact-manager.js";
+import { getCoverageManager } from "../coverage/helpers.js";
+import { getGasAnalyticsManager } from "../gas-analytics/helpers.js";
 import { edrGasReportToHardhatGasMeasurements } from "../network-manager/edr/utils/convert-to-edr.js";
 
-import { getEdrArtifacts, getBuildInfos } from "./edr-artifacts.js";
+import {
+  buildEdrArtifactsWithMetadata,
+  getBuildInfosAndOutputs,
+} from "./edr-artifacts.js";
 import {
   isTestSuiteArtifact,
   warnDeprecatedTestFail,
   solidityTestConfigToRunOptions,
   solidityTestConfigToSolidityTestRunnerConfigArgs,
 } from "./helpers.js";
+import { getTestFunctionOverrides } from "./inline-config/index.js";
 import { testReporter } from "./reporter.js";
 import { run } from "./runner.js";
 
@@ -43,7 +45,6 @@ interface TestActionArguments {
   chainType: string;
   grep?: string;
   noCompile: boolean;
-  verbosity: number;
   testSummaryIndex: number;
 }
 
@@ -52,17 +53,14 @@ export interface SolidityTestRunResult extends TestRunResult {
 }
 
 const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
-  { testFiles, chainType, grep, noCompile, verbosity, testSummaryIndex },
+  { testFiles, chainType, grep, noCompile, testSummaryIndex },
   hre,
 ): Promise<Result<SolidityTestRunResult, SolidityTestRunResult>> => {
-  assertHardhatInvariant(
-    hre instanceof HardhatRuntimeEnvironmentImplementation,
-    "Expected HRE to be an instance of HardhatRuntimeEnvironmentImplementation",
-  );
-
   // Set an environment variable that plugins can use to detect when a process is running tests
   process.env.HH_TEST = "true";
 
+  const verbosity = hre.globalOptions.verbosity;
+
   // Sets the NODE_ENV environment variable to "test" so the code can detect that tests are running
   // This is done by other JS/TS test frameworks like vitest
   process.env.NODE_ENV ??= "test";
@@ -95,26 +93,27 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   console.log();
 
   // EDR needs all artifacts (contracts + tests)
-  const edrArtifacts: Array<{
-    edrArtifact: EdrArtifact;
-    userSourceName: string;
-  }> = [];
-  const buildInfos: BuildInfoAndOutput[] = [];
+  const edrArtifactsWithMetadata: EdrArtifactWithMetadata[] = [];
+  const allBuildInfosAndOutputs: BuildInfoAndOutput[] = [];
   for (const scope of ["contracts", "tests"] as const) {
     const artifactsDir = await hre.solidity.getArtifactsDirectory(scope);
     const artifactManager = new ArtifactManagerImplementation(artifactsDir);
-    edrArtifacts.push(...(await getEdrArtifacts(artifactManager)));
-    buildInfos.push(...(await getBuildInfos(artifactManager)));
+    edrArtifactsWithMetadata.push(
+      ...(await buildEdrArtifactsWithMetadata(artifactManager)),
+    );
+    allBuildInfosAndOutputs.push(
+      ...(await getBuildInfosAndOutputs(artifactManager)),
+    );
   }
 
   const sourceNameToUserSourceName = new Map(
-    edrArtifacts.map(({ userSourceName, edrArtifact }) => [
+    edrArtifactsWithMetadata.map(({ userSourceName, edrArtifact }) => [
       edrArtifact.id.source,
       userSourceName,
     ]),
   );
 
-  edrArtifacts.forEach(({ userSourceName, edrArtifact }) => {
+  edrArtifactsWithMetadata.forEach(({ userSourceName, edrArtifact }) => {
     if (
       testRootPaths.includes(
         resolveFromRoot(hre.config.paths.root, userSourceName),
@@ -125,14 +124,17 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
     }
   });
 
-  const testSuiteIds = edrArtifacts
+  const testSuiteArtifacts = edrArtifactsWithMetadata
     .filter(({ userSourceName }) =>
       testRootPaths.includes(
         resolveFromRoot(hre.config.paths.root, userSourceName),
       ),
     )
-    .filter(({ edrArtifact }) => isTestSuiteArtifact(edrArtifact))
-    .map(({ edrArtifact }) => edrArtifact.id);
+    .filter(({ edrArtifact }) => isTestSuiteArtifact(edrArtifact));
+
+  const testSuiteIds = testSuiteArtifacts.map(
+    ({ edrArtifact }) => edrArtifact.id,
+  );
 
   console.log("Running Solidity tests");
   console.log();
@@ -143,6 +145,7 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   const solidityTestConfig = hre.config.test.solidity;
   let observabilityConfig: ObservabilityConfig | undefined;
   if (hre.globalOptions.coverage) {
+    const coverage = getCoverageManager(hre);
     observabilityConfig = {
       codeCoverage: {
         onCollectedCoverageCallback: async (coverageData: Uint8Array[]) => {
@@ -150,7 +153,7 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
             Buffer.from(tag).toString("hex"),
           );
 
-          await hre._coverage.addData(tags);
+          await coverage.addData(tags);
         },
       },
     };
@@ -166,7 +169,12 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
     }
   }
 
-  const testRunnerConfig: SolidityTestRunnerConfigArgs =
+  const testFunctionOverrides = getTestFunctionOverrides(
+    testSuiteArtifacts,
+    allBuildInfosAndOutputs,
+  );
+
+  const testRunnerConfig =
     await solidityTestConfigToSolidityTestRunnerConfigArgs({
       chainType,
       projectRoot: hre.config.paths.root,
@@ -175,14 +183,19 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
       verbosity,
       observability: observabilityConfig,
       testPattern: grep,
-      generateGasReport: hre.globalOptions.gasStats,
+      generateGasReport:
+        hre.globalOptions.gasStats ||
+        hre.globalOptions.gasStatsJson !== undefined,
+      testFunctionOverrides,
     });
   const tracingConfig: TracingConfigWithBuffers = {
-    buildInfos,
+    buildInfos: allBuildInfosAndOutputs.map(({ buildInfo, output }) => ({
+      buildInfo,
+      output,
+    })),
     ignoreContracts: false,
   };
-  const options: RunOptions =
-    solidityTestConfigToRunOptions(solidityTestConfig);
+  const runOptions = solidityTestConfigToRunOptions(solidityTestConfig);
 
   await hre.hooks.runHandlerChain(
     "test",
@@ -193,12 +206,12 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
 
   const runStream = run(
     chainType,
-    edrArtifacts.map(({ edrArtifact }) => edrArtifact),
+    edrArtifactsWithMetadata.map(({ edrArtifact }) => edrArtifact),
     testSuiteIds,
     testRunnerConfig,
     tracingConfig,
     sourceNameToUserSourceName,
-    options,
+    runOptions,
   );
 
   let failed = 0;
@@ -232,8 +245,9 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
           testContractFqns,
         );
 
+        const gasAnalytics = getGasAnalyticsManager(hre);
         for (const measurement of gasMeasurements) {
-          hre._gasAnalytics.addGasMeasurement(measurement);
+          gasAnalytics.addGasMeasurement(measurement);
         }
       }
     })

package/src/internal/builtin-plugins/test/index.ts

@@ -1,7 +1,6 @@
 import type { HardhatPlugin } from "../../../types/plugins.js";
 
 import { ArgumentType } from "../../../types/arguments.js";
-import { DEFAULT_VERBOSITY } from "../../constants.js";
 import { task } from "../../core/config.js";
 
 import "./type-extensions.js";
@@ -33,12 +32,6 @@ const hardhatPlugin: HardhatPlugin = {
         name: "noCompile",
         description: "Do not compile the project before running the tests",
       })
-      .addLevel({
-        name: "verbosity",
-        shortName: "v",
-        description: "Verbosity level of the test output",
-        defaultValue: DEFAULT_VERBOSITY,
-      })
       .setAction(async () => import("./task-action.js"))
       .build(),
   ],

package/src/internal/builtin-plugins/test/task-action.ts

@@ -7,10 +7,7 @@ import type {
 import type { TestSummary } from "../../../types/test.js";
 import type { Result } from "../../../types/utils.js";
 
-import {
-  assertHardhatInvariant,
-  HardhatError,
-} from "@nomicfoundation/hardhat-errors";
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import { isObject } from "@nomicfoundation/hardhat-utils/lang";
 import chalk, { type ChalkInstance } from "chalk";
 
@@ -19,14 +16,14 @@ import {
   isResult,
   successfulResult,
 } from "../../../utils/result.js";
-import { HardhatRuntimeEnvironmentImplementation } from "../../core/hre.js";
+import { getCoverageManager } from "../coverage/helpers.js";
+import { getGasAnalyticsManager } from "../gas-analytics/helpers.js";
 
 interface TestActionArguments {
   testFiles: string[];
   chainType: string;
   grep: string | undefined;
   noCompile: boolean;
-  verbosity: number;
 }
 
 // Old plugins may only return { failed, passed } without skipped/todo,
@@ -53,7 +50,7 @@ function isTestRunResult(
 }
 
 const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
-  { testFiles, chainType, grep, noCompile, verbosity, ...otherArgs },
+  { testFiles, chainType, grep, noCompile, ...otherArgs },
   hre,
 ): Promise<Result<void, void>> => {
   // If this code is executed, it means the user has not specified a test runner.
@@ -73,18 +70,22 @@ const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
   }
 
   if (hre.globalOptions.coverage === true) {
-    assertHardhatInvariant(
-      hre instanceof HardhatRuntimeEnvironmentImplementation,
-      "Expected HRE to be an instance of HardhatRuntimeEnvironmentImplementation",
-    );
-    hre._coverage.disableReport();
+    getCoverageManager(hre).disableReport();
+  }
+
+  if (
+    hre.globalOptions.gasStats === true ||
+    hre.globalOptions.gasStatsJson !== undefined
+  ) {
+    getGasAnalyticsManager(hre).disableReport();
   }
 
   const testSummaries: Record<string, TestSummary> = {};
+  const ranSubtaskIds: string[] = [];
 
   let failureIndex = 1;
   let hasFailures = false;
-  for (const subtask of thisTask.subtasks.values()) {
+  for (const [subtaskKey, subtask] of thisTask.subtasks.entries()) {
     const files = getTestFilesForSubtask(subtask, testFiles, subtasksToFiles);
 
     if (files === undefined) {
@@ -93,6 +94,8 @@ const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
       continue;
     }
 
+    ranSubtaskIds.push(subtaskKey);
+
     const args: TaskArguments = {
       testFiles: files,
       grep,
@@ -103,10 +106,6 @@ const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
       args.chainType = chainType;
     }
 
-    if (subtask.options.has("verbosity")) {
-      args.verbosity = verbosity;
-    }
-
     for (const [key, value] of Object.entries(otherArgs)) {
       if (subtask.options.has(key)) {
         args[key] = value;
@@ -228,16 +227,32 @@ const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
   console.log();
 
   if (hre.globalOptions.coverage === true) {
-    assertHardhatInvariant(
-      hre instanceof HardhatRuntimeEnvironmentImplementation,
-      "Expected HRE to be an instance of HardhatRuntimeEnvironmentImplementation",
-    );
-    const ids = Array.from(thisTask.subtasks.keys());
-    hre._coverage.enableReport();
-    await hre._coverage.report(...ids);
+    const coverage = getCoverageManager(hre);
+    coverage.enableReport();
+    await coverage.report(...ranSubtaskIds);
     console.log();
   }
 
+  if (
+    hre.globalOptions.gasStats === true ||
+    hre.globalOptions.gasStatsJson !== undefined
+  ) {
+    const gasAnalytics = getGasAnalyticsManager(hre);
+    gasAnalytics.enableReport();
+
+    if (hre.globalOptions.gasStats === true) {
+      await gasAnalytics.reportGasStats(...ranSubtaskIds);
+      console.log();
+    }
+
+    if (hre.globalOptions.gasStatsJson !== undefined) {
+      await gasAnalytics.writeGasStatsJson(
+        hre.globalOptions.gasStatsJson,
+        ...ranSubtaskIds,
+      );
+    }
+  }
+
   if (hasFailures) {
     console.error("Test run failed");
   }

package/src/internal/cli/help/get-help-string.ts

@@ -1,6 +1,8 @@
 import type { GlobalOptionDefinitions } from "../../../types/global-options.js";
 import type { Task } from "../../../types/tasks.js";
 
+import chalk from "chalk";
+
 import {
   GLOBAL_NAME_PADDING,
   parseOptions,
@@ -15,8 +17,6 @@ export async function getHelpString(
   task: Task,
   globalOptionDefinitions: GlobalOptionDefinitions,
 ): Promise<string> {
-  const { default: chalk } = await import("chalk");
-
   const { options, positionalArguments } = parseOptions(task);
 
   const subtasks = parseSubtasks(task);

package/src/internal/cli/init/init.ts

@@ -29,6 +29,7 @@ import {
   getHardhatVersion,
   getLatestHardhatVersion,
 } from "../../utils/package.js";
+import { BannerManager } from "../banner-manager.js";
 import { sendProjectTypeAnalytics } from "../telemetry/analytics/analytics.js";
 import { sendErrorTelemetry } from "../telemetry/sentry/reporter.js";
 
@@ -133,7 +134,6 @@ export async function initHardhat(options?: InitHardhatOptions): Promise<void> {
     showStarOnGitHubMessage();
 
     try {
-      const { BannerManager } = await import("../banner-manager.js");
       const bannerManager = await BannerManager.getInstance();
       await bannerManager.showBanner();
     } catch (bannerError) {

package/src/internal/cli/init/prompt.ts

@@ -3,14 +3,13 @@ import type { Template } from "./template.js";
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import { shortenPath } from "@nomicfoundation/hardhat-utils/path";
 import chalk from "chalk";
+import enquirer from "enquirer";
 
 export async function promptForHardhatVersion(): Promise<
   "hardhat-2" | "hardhat-3"
 > {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const hardhatVersionResponse = await enquirer.prompt<{
     hardhatVersion: "hardhat-2" | "hardhat-3";
   }>([
@@ -40,8 +39,6 @@ export async function promptForHardhatVersion(): Promise<
 export async function promptForWorkspace(): Promise<string> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const workspaceResponse = await enquirer.prompt<{ workspace: string }>([
     {
       name: "workspace",
@@ -59,8 +56,6 @@ export async function promptForMigrateToEsm(
 ): Promise<boolean> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const migrateToEsmResponse = await enquirer.prompt<{ migrateToEsm: boolean }>(
     [
       {
@@ -80,8 +75,6 @@ export async function promptForTemplate(
 ): Promise<string> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const templateResponse = await enquirer.prompt<{ template: string }>([
     {
       name: "template",
@@ -102,8 +95,6 @@ export async function promptForTemplate(
 export async function promptForForce(files: string[]): Promise<boolean> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const forceResponse = await enquirer.prompt<{ force: boolean }>([
     {
       name: "force",
@@ -121,8 +112,6 @@ export async function promptForInstall(
 ): Promise<boolean> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const installResponse = await enquirer.prompt<{ install: boolean }>([
     {
       name: "install",
@@ -140,8 +129,6 @@ export async function promptForUpdate(
 ): Promise<boolean> {
   ensureTTY();
 
-  const { default: enquirer } = await import("enquirer");
-
   const updateResponse = await enquirer.prompt<{ update: boolean }>([
     {
       name: "update",