hardhat 3.1.9 → 3.1.11

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

@@ -8,7 +8,7 @@ import type { TableItem } from "@nomicfoundation/hardhat-utils/format";
 
 import path from "node:path";
 
-import { divider, formatTable } from "@nomicfoundation/hardhat-utils/format";
+import { formatTable } from "@nomicfoundation/hardhat-utils/format";
 import {
   ensureDir,
   getAllFilesMatching,
@@ -433,55 +433,60 @@ export class CoverageManagerImplementation implements CoverageManager {
 
     const rows: TableItem[] = [];
 
-    rows.push([chalk.bold("Coverage Report")]);
-    rows.push(divider);
+    rows.push({
+      type: "title",
+      text: chalk.bold("Coverage Report"),
+    });
 
-    rows.push(
-      ["File Path", "Line %", "Statement %", "Uncovered Lines"].map((s) =>
-        chalk.yellow(s),
+    rows.push({
+      type: "section-header",
+      text: chalk.bold("File Coverage"),
+    });
+
+    rows.push({
+      type: "header",
+      cells: ["File Path", "Line %", "Statement %", "Uncovered Lines"].map(
+        (s) => chalk.yellow(s),
       ),
-    );
+    });
 
-    const bodyRows = Object.entries(report).map(
-      ([
-        relativePath,
-        {
-          executedStatementsCount,
-          unexecutedStatementsCount,
-          lineExecutionCounts,
-          executedLinesCount,
-          unexecutedLines,
-        },
-      ]) => {
-        const lineCoverage =
-          lineExecutionCounts.size === 0
-            ? 0
-            : (executedLinesCount * 100.0) / lineExecutionCounts.size;
-        const statementCoverage =
-          executedStatementsCount === 0
-            ? 0
-            : (executedStatementsCount * 100.0) /
-              (executedStatementsCount + unexecutedStatementsCount);
-
-        totalExecutedLines += executedLinesCount;
-        totalExecutableLines += lineExecutionCounts.size;
-
-        totalExecutedStatements += executedStatementsCount;
-        totalExecutableStatements +=
-          executedStatementsCount + unexecutedStatementsCount;
-
-        const row: string[] = [
+    for (const [
+      relativePath,
+      {
+        executedStatementsCount,
+        unexecutedStatementsCount,
+        lineExecutionCounts,
+        executedLinesCount,
+        unexecutedLines,
+      },
+    ] of Object.entries(report)) {
+      const lineCoverage =
+        lineExecutionCounts.size === 0
+          ? 0
+          : (executedLinesCount * 100.0) / lineExecutionCounts.size;
+      const statementCoverage =
+        executedStatementsCount === 0
+          ? 0
+          : (executedStatementsCount * 100.0) /
+            (executedStatementsCount + unexecutedStatementsCount);
+
+      totalExecutedLines += executedLinesCount;
+      totalExecutableLines += lineExecutionCounts.size;
+
+      totalExecutedStatements += executedStatementsCount;
+      totalExecutableStatements +=
+        executedStatementsCount + unexecutedStatementsCount;
+
+      rows.push({
+        type: "row",
+        cells: [
           this.formatRelativePath(relativePath),
           this.formatCoverage(lineCoverage),
           this.formatCoverage(statementCoverage),
           this.formatLines(unexecutedLines),
-        ];
-
-        return row;
-      },
-    );
-
-    rows.push(...bodyRows);
+        ],
+      });
+    }
 
     const totalLineCoverage =
       totalExecutableLines === 0
@@ -492,13 +497,15 @@ export class CoverageManagerImplementation implements CoverageManager {
         ? 0
         : (totalExecutedStatements * 100.0) / totalExecutableStatements;
 
-    rows.push(divider);
-    rows.push([
-      chalk.yellow("Total"),
-      this.formatCoverage(totalLineCoverage),
-      this.formatCoverage(totalStatementCoverage),
-      "",
-    ]);
+    rows.push({
+      type: "header",
+      cells: [
+        chalk.yellow("Total"),
+        this.formatCoverage(totalLineCoverage),
+        this.formatCoverage(totalStatementCoverage),
+        "",
+      ],
+    });
 
     return formatTable(rows);
   }

package/src/internal/builtin-plugins/coverage/helpers.ts

@@ -1,50 +1,32 @@
 import path from "node:path";
 
-import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
-
-import { HardhatRuntimeEnvironmentImplementation } from "../../core/hre.js";
+import {
+  testRunDone,
+  testRunStart,
+  testWorkerDone,
+} from "./hook-handlers/test.js";
 
 export function getCoveragePath(rootPath: string): string {
   return path.join(rootPath, "coverage");
 }
 
 /**
- * NOTE: The following helpers interact with the global HRE instance only;
- * This is OK because:
- * - They are intended for the internal use only. They are exposed via the
- *   internal public API only.
- * - We know the HRE has been initialized by the time they are used.
+ * The following helpers are kept for backward compatibility with older versions
+ * of test runner plugins (hardhat-mocha, hardhat-node-test-runner) that import
+ * from "hardhat/internal/coverage".
  */
 
 export async function markTestRunStart(id: string): Promise<void> {
   const { default: hre } = await import("../../../index.js");
-  if (hre.globalOptions.coverage === true) {
-    assertHardhatInvariant(
-      hre instanceof HardhatRuntimeEnvironmentImplementation,
-      "Expected HRE to be an instance of HardhatRuntimeEnvironmentImplementation",
-    );
-    await hre._coverage.clearData(id);
-  }
+  await testRunStart(hre, id);
 }
 
 export async function markTestWorkerDone(id: string): Promise<void> {
   const { default: hre } = await import("../../../index.js");
-  if (hre.globalOptions.coverage === true) {
-    assertHardhatInvariant(
-      hre instanceof HardhatRuntimeEnvironmentImplementation,
-      "Expected HRE to be an instance of HardhatRuntimeEnvironmentImplementation",
-    );
-    await hre._coverage.saveData(id);
-  }
+  await testWorkerDone(hre, id);
 }
 
 export async function markTestRunDone(id: string): Promise<void> {
   const { default: hre } = await import("../../../index.js");
-  if (hre.globalOptions.coverage === true) {
-    assertHardhatInvariant(
-      hre instanceof HardhatRuntimeEnvironmentImplementation,
-      "Expected HRE to be an instance of HardhatRuntimeEnvironmentImplementation",
-    );
-    await hre._coverage.report(id);
-  }
+  await testRunDone(hre, id);
 }

package/src/internal/builtin-plugins/coverage/hook-handlers/test.ts

@@ -0,0 +1,68 @@
+import type { HookContext, TestHooks } from "../../../../types/hooks.js";
+
+import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
+import { isObject } from "@nomicfoundation/hardhat-utils/lang";
+
+import { CoverageManagerImplementation } from "../coverage-manager.js";
+
+export default async (): Promise<Partial<TestHooks>> => ({
+  onTestRunStart: async (context, id, next) => {
+    await next(context, id);
+    await testRunStart(context, id);
+  },
+
+  onTestWorkerDone: async (context, id, next) => {
+    await next(context, id);
+    await testWorkerDone(context, id);
+  },
+
+  onTestRunDone: async (context, id, next) => {
+    await next(context, id);
+    await testRunDone(context, id);
+  },
+});
+
+export async function testRunStart(
+  context: HookContext,
+  id: string,
+): Promise<void> {
+  if (context.globalOptions.coverage === true) {
+    assertHardhatInvariant(
+      "_coverage" in context &&
+        isObject(context._coverage) &&
+        context._coverage instanceof CoverageManagerImplementation,
+      "Expected HookContext#_coverage to be an instance of CoverageManagerImplementation",
+    );
+    await context._coverage.clearData(id);
+  }
+}
+
+export async function testWorkerDone(
+  context: HookContext,
+  id: string,
+): Promise<void> {
+  if (context.globalOptions.coverage === true) {
+    assertHardhatInvariant(
+      "_coverage" in context &&
+        isObject(context._coverage) &&
+        context._coverage instanceof CoverageManagerImplementation,
+      "Expected HookContext#_coverage to be an instance of CoverageManagerImplementation",
+    );
+    await context._coverage.saveData(id);
+  }
+}
+
+export async function testRunDone(
+  context: HookContext,
+  id: string,
+): Promise<void> {
+  if (context.globalOptions.coverage === true) {
+    assertHardhatInvariant(
+      "_coverage" in context &&
+        isObject(context._coverage) &&
+        context._coverage instanceof CoverageManagerImplementation,
+      "Expected HookContext#_coverage to be an instance of CoverageManagerImplementation",
+    );
+    await context._coverage.report(id);
+  }
+}

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

@@ -17,6 +17,7 @@ const hardhatPlugin: HardhatPlugin = {
     clean: () => import("./hook-handlers/clean.js"),
     hre: () => import("./hook-handlers/hre.js"),
     solidity: () => import("./hook-handlers/solidity.js"),
+    test: () => import("./hook-handlers/test.js"),
   },
   npmPackage: "hardhat",
 };

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

@@ -64,6 +64,7 @@ const flattenAction: NewTaskActionFunction<FlattenActionArguments> = async (
     rootPaths.toSorted(), // We sort them to have a deterministic order
     config.paths.root,
     readSourceFileFactory(hooks),
+    hooks,
   );
 
   let flattened = "";

package/src/internal/builtin-plugins/gas-analytics/gas-analytics-manager.ts

@@ -1,10 +1,10 @@
 import type { GasAnalyticsManager, GasMeasurement } from "./types.js";
-import type { TableItemV2 } from "@nomicfoundation/hardhat-utils/format";
+import type { TableItem } from "@nomicfoundation/hardhat-utils/format";
 
 import crypto from "node:crypto";
 import path from "node:path";
 
-import { formatTableV2 } from "@nomicfoundation/hardhat-utils/format";
+import { formatTable } from "@nomicfoundation/hardhat-utils/format";
 import {
   ensureDir,
   getAllFilesMatching,
@@ -209,7 +209,7 @@ export class GasAnalyticsManagerImplementation implements GasAnalyticsManager {
   public _generateGasStatsReport(
     gasStatsByContract: GasStatsByContract,
   ): string {
-    const rows: TableItemV2[] = [];
+    const rows: TableItem[] = [];
 
     if (gasStatsByContract.size > 0) {
       rows.push({ type: "title", text: chalk.bold("Gas Usage Statistics") });
@@ -279,7 +279,7 @@ export class GasAnalyticsManagerImplementation implements GasAnalyticsManager {
       }
     }
 
-    return formatTableV2(rows);
+    return formatTable(rows);
   }
 }
 

package/src/internal/builtin-plugins/gas-analytics/helpers.ts

@@ -1,44 +1,26 @@
-import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
-
-import { HardhatRuntimeEnvironmentImplementation } from "../../core/hre.js";
+import {
+  testRunDone,
+  testRunStart,
+  testWorkerDone,
+} from "./hook-handlers/test.js";
 
 /**
- * NOTE: The following helpers interact with the global HRE instance only;
- * This is OK because:
- * - They are intended for the internal use only. They are exposed via the
- *   internal public API only.
- * - We know the HRE has been initialized by the time they are used.
+ * The following helpers are kept for backward compatibility with older versions
+ * of test runner plugins (hardhat-mocha, hardhat-node-test-runner) that import
+ * from "hardhat/internal/gas-analytics".
  */
 
 export async function markTestRunStart(id: string): Promise<void> {
   const { default: hre } = await import("../../../index.js");
-  if (hre.globalOptions.gasStats === true) {
-    assertHardhatInvariant(
-      hre instanceof HardhatRuntimeEnvironmentImplementation,
-      "Expected HRE to be an instance of HardhatRuntimeEnvironmentImplementation",
-    );
-    await hre._gasAnalytics.clearGasMeasurements(id);
-  }
+  await testRunStart(hre, id);
 }
 
 export async function markTestWorkerDone(id: string): Promise<void> {
   const { default: hre } = await import("../../../index.js");
-  if (hre.globalOptions.gasStats === true) {
-    assertHardhatInvariant(
-      hre instanceof HardhatRuntimeEnvironmentImplementation,
-      "Expected HRE to be an instance of HardhatRuntimeEnvironmentImplementation",
-    );
-    await hre._gasAnalytics.saveGasMeasurements(id);
-  }
+  await testWorkerDone(hre, id);
 }
 
 export async function markTestRunDone(id: string): Promise<void> {
   const { default: hre } = await import("../../../index.js");
-  if (hre.globalOptions.gasStats === true) {
-    assertHardhatInvariant(
-      hre instanceof HardhatRuntimeEnvironmentImplementation,
-      "Expected HRE to be an instance of HardhatRuntimeEnvironmentImplementation",
-    );
-    await hre._gasAnalytics.reportGasStats(id);
-  }
+  await testRunDone(hre, id);
 }

package/src/internal/builtin-plugins/gas-analytics/hook-handlers/test.ts

@@ -0,0 +1,68 @@
+import type { HookContext, TestHooks } from "../../../../types/hooks.js";
+
+import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
+import { isObject } from "@nomicfoundation/hardhat-utils/lang";
+
+import { GasAnalyticsManagerImplementation } from "../gas-analytics-manager.js";
+
+export default async (): Promise<Partial<TestHooks>> => ({
+  onTestRunStart: async (context, id, next) => {
+    await next(context, id);
+    await testRunStart(context, id);
+  },
+
+  onTestWorkerDone: async (context, id, next) => {
+    await next(context, id);
+    await testWorkerDone(context, id);
+  },
+
+  onTestRunDone: async (context, id, next) => {
+    await next(context, id);
+    await testRunDone(context, id);
+  },
+});
+
+export async function testRunStart(
+  context: HookContext,
+  id: string,
+): Promise<void> {
+  if (context.globalOptions.gasStats === true) {
+    assertHardhatInvariant(
+      "_gasAnalytics" in context &&
+        isObject(context._gasAnalytics) &&
+        context._gasAnalytics instanceof GasAnalyticsManagerImplementation,
+      "Expected HookContext#_gasAnalytics to be an instance of GasAnalyticsManagerImplementation",
+    );
+    await context._gasAnalytics.clearGasMeasurements(id);
+  }
+}
+
+export async function testWorkerDone(
+  context: HookContext,
+  id: string,
+): Promise<void> {
+  if (context.globalOptions.gasStats === true) {
+    assertHardhatInvariant(
+      "_gasAnalytics" in context &&
+        isObject(context._gasAnalytics) &&
+        context._gasAnalytics instanceof GasAnalyticsManagerImplementation,
+      "Expected HookContext#_gasAnalytics to be an instance of GasAnalyticsManagerImplementation",
+    );
+    await context._gasAnalytics.saveGasMeasurements(id);
+  }
+}
+
+export async function testRunDone(
+  context: HookContext,
+  id: string,
+): Promise<void> {
+  if (context.globalOptions.gasStats === true) {
+    assertHardhatInvariant(
+      "_gasAnalytics" in context &&
+        isObject(context._gasAnalytics) &&
+        context._gasAnalytics instanceof GasAnalyticsManagerImplementation,
+      "Expected HookContext#_gasAnalytics to be an instance of GasAnalyticsManagerImplementation",
+    );
+    await context._gasAnalytics.reportGasStats(id);
+  }
+}

package/src/internal/builtin-plugins/gas-analytics/index.ts

@@ -16,6 +16,7 @@ const hardhatPlugin: HardhatPlugin = {
   ],
   hookHandlers: {
     hre: () => import("./hook-handlers/hre.js"),
+    test: () => import("./hook-handlers/test.js"),
   },
   npmPackage: "hardhat",
 };

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

@@ -1,4 +1,3 @@
-import type { SolidityStackTrace } from "./stack-traces/solidity-stack-trace.js";
 import type { CoverageConfig } from "./types/coverage.js";
 import type { LoggerConfig } from "./types/logger.js";
 import type {
@@ -63,14 +62,10 @@ import {
 
 import { EdrProviderStackTraceGenerationError } from "./stack-traces/stack-trace-generation-errors.js";
 import { createSolidityErrorWithStackTrace } from "./stack-traces/stack-trace-solidity-errors.js";
-import {
-  isDebugTraceResult,
-  isEdrProviderErrorData,
-} from "./type-validation.js";
+import { isEdrProviderErrorData } from "./type-validation.js";
 import { clientVersion } from "./utils/client-version.js";
 import { ConsoleLogger } from "./utils/console-logger.js";
 import {
-  edrRpcDebugTraceToHardhat,
   hardhatMiningIntervalToEdrMiningInterval,
   hardhatMempoolOrderToEdrMineOrdering,
   hardhatHardforkToEdrSpecId,
@@ -289,15 +284,6 @@ export class EdrProvider extends BaseProvider {
         "Invalid client version response",
       );
       return clientVersion(jsonRpcResponse.result);
-    } else if (
-      jsonRpcRequest.method === "debug_traceTransaction" ||
-      jsonRpcRequest.method === "debug_traceCall"
-    ) {
-      assertHardhatInvariant(
-        isDebugTraceResult(jsonRpcResponse.result),
-        "Invalid debug trace response",
-      );
-      return edrRpcDebugTraceToHardhat(jsonRpcResponse.result);
     } else {
       return jsonRpcResponse.result;
     }
@@ -339,18 +325,9 @@ export class EdrProvider extends BaseProvider {
       const responseError = jsonRpcResponse.error;
       let error;
 
-      let stackTrace: SolidityStackTrace | null = null;
-      try {
-        stackTrace = edrResponse.stackTrace();
-      } catch (e) {
-        if (e instanceof Error) {
-          await sendErrorTelemetry(new EdrProviderStackTraceGenerationError(e));
-        }
-
-        log("Failed to get stack trace: %O", e);
-      }
+      const stackTrace = edrResponse.stackTrace();
 
-      if (stackTrace !== null) {
+      if (stackTrace?.kind === "StackTrace") {
         // If we have a stack trace, we know that the json rpc response data
         // is an object with the data and transactionHash fields
         assertHardhatInvariant(
@@ -360,11 +337,27 @@ export class EdrProvider extends BaseProvider {
 
         error = createSolidityErrorWithStackTrace(
           responseError.message,
-          stackTrace,
+          stackTrace.entries,
           responseError.data.data,
           responseError.data.transactionHash,
         );
       } else {
+        if (stackTrace !== null) {
+          if (stackTrace.kind === "UnexpectedError") {
+            await sendErrorTelemetry(
+              new EdrProviderStackTraceGenerationError(stackTrace.errorMessage),
+            );
+            log(`Failed to get stack trace: ${stackTrace.errorMessage}`);
+          } else {
+            const errHeuristicFailed =
+              "Heuristic failed to generate stack trace";
+            await sendErrorTelemetry(
+              new EdrProviderStackTraceGenerationError(errHeuristicFailed),
+            );
+            log(`Failed to get stack trace: ${errHeuristicFailed}`);
+          }
+        }
+
         error =
           responseError.code === InvalidArgumentsError.CODE
             ? new InvalidArgumentsError(responseError.message)
@@ -373,7 +366,7 @@ export class EdrProvider extends BaseProvider {
       }
 
       /* eslint-disable-next-line no-restricted-syntax -- we may throw
-      non-Hardaht errors inside of an EthereumProvider */
+      non-Hardhat errors inside of an EthereumProvider */
       throw error;
     }
 

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

@@ -3,8 +3,11 @@ import { CustomError } from "@nomicfoundation/hardhat-utils/error";
 abstract class StackTraceGenerationError extends CustomError {}
 
 export class EdrProviderStackTraceGenerationError extends StackTraceGenerationError {
-  constructor(error: Error) {
-    super("Failed to generate stack trace for the EDR provider", error);
+  constructor(message: string) {
+    super(
+      "Failed to generate stack trace for the EDR provider",
+      new Error(message),
+    );
   }
 }
 

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

@@ -1,18 +1,5 @@
-import type { DebugTraceResult } from "@nomicfoundation/edr";
-
 import { isObject } from "@nomicfoundation/hardhat-utils/lang";
 
-export function isDebugTraceResult(
-  result: unknown,
-): result is DebugTraceResult {
-  return (
-    isObject(result) &&
-    "pass" in result &&
-    "gasUsed" in result &&
-    "structLogs" in result
-  );
-}
-
 interface EdrProviderErrorData {
   data: string;
   transactionHash?: string;

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

@@ -9,10 +9,8 @@ import type {
 } from "../../../../../types/config.js";
 import type { ChainType } from "../../../../../types/network.js";
 import type { GasMeasurement } from "../../../gas-analytics/types.js";
-import type { RpcDebugTraceOutput, RpcStructLog } from "../types/output.js";
 import type {
   IntervalRange,
-  DebugTraceResult,
   ChainOverride,
   ForkConfig,
   GasReport,
@@ -51,7 +49,6 @@ import {
   HOLOCENE,
   ISTHMUS,
 } from "@nomicfoundation/edr";
-import { getUnprefixedHexString } from "@nomicfoundation/hardhat-utils/hex";
 
 import {
   GENERIC_CHAIN_TYPE,
@@ -274,67 +271,6 @@ export function hardhatMempoolOrderToEdrMineOrdering(
   }
 }
 
-// TODO: EDR should handle this conversion. This is a temporary solution.
-export function edrRpcDebugTraceToHardhat(
-  debugTraceResult: DebugTraceResult,
-): RpcDebugTraceOutput {
-  const structLogs = debugTraceResult.structLogs.map((log) => {
-    const result: RpcStructLog = {
-      depth: Number(log.depth),
-      gas: Number(log.gas),
-      gasCost: Number(log.gasCost),
-      op: log.opName,
-      pc: Number(log.pc),
-    };
-
-    if (log.memory !== undefined) {
-      result.memory = log.memory;
-    }
-
-    if (log.stack !== undefined) {
-      // Remove 0x prefix which is required by EIP-3155, but not expected by Hardhat.
-      result.stack = log.stack.map(getUnprefixedHexString);
-    }
-
-    if (log.storage !== undefined) {
-      result.storage = Object.fromEntries(
-        Object.entries(log.storage).map(([key, value]) => [
-          getUnprefixedHexString(key),
-          getUnprefixedHexString(value),
-        ]),
-      );
-    }
-
-    if (log.error !== undefined) {
-      result.error = {
-        message: log.error,
-      };
-    }
-
-    return result;
-  });
-
-  // REVM trace adds initial STOP that Hardhat doesn't expect
-  // TODO: double check with EDR team that this is still the case
-  if (structLogs.length > 0 && structLogs[0].op === "STOP") {
-    structLogs.shift();
-  }
-
-  /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
-  debugTraceResult.output is a string, but it's typed as Buffer in Edr */
-  let returnValue = (debugTraceResult.output as unknown as string) ?? "0x";
-  if (returnValue === "0x") {
-    returnValue = "";
-  }
-
-  return {
-    failed: !debugTraceResult.pass,
-    gas: Number(debugTraceResult.gasUsed),
-    returnValue,
-    structLogs,
-  };
-}
-
 export async function hardhatAccountsToEdrOwnedAccounts(
   accounts: EdrNetworkAccountsConfig,
 ): Promise<Array<{ secretKey: string; balance: bigint }>> {