hardhat 3.1.10 → 3.1.11

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 }>> {

package/src/internal/builtin-plugins/solidity/build-results.ts

@@ -2,6 +2,7 @@ import type {
   CompilationJobCreationError,
   FailedFileBuildResult,
   FileBuildResult,
+  SolidityBuildSystem,
 } from "../../../types/solidity.js";
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
@@ -22,9 +23,10 @@ type SuccessfulSolidityBuildResults = Map<
  * job failed.
  */
 export function throwIfSolidityBuildFailed(
+  solidity: SolidityBuildSystem,
   results: SolidityBuildResults,
 ): asserts results is SuccessfulSolidityBuildResults {
-  if ("reason" in results) {
+  if (!solidity.isSuccessfulBuildResult(results)) {
     throw new HardhatError(
       HardhatError.ERRORS.CORE.SOLIDITY.COMPILATION_JOB_CREATION_ERROR,
       {

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

@@ -208,6 +208,12 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
   }
 
+  public isSuccessfulBuildResult(
+    buildResult: CompilationJobCreationError | Map<string, FileBuildResult>,
+  ): buildResult is Map<string, FileBuildResult> {
+    return buildResult instanceof Map;
+  }
+
   public async build(
     rootFilePaths: string[],
     _options?: BuildOptions,
@@ -244,7 +250,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       options,
     );
 
-    if ("reason" in compilationJobsResult) {
+    if (!compilationJobsResult.success) {
       return compilationJobsResult;
     }
 
@@ -430,7 +436,6 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     const solcConfigSelector = new SolcConfigSelector(
       buildProfileName,
       buildProfile,
-      dependencyGraph,
     );
 
     let subgraphsWithConfig: Array<
@@ -446,11 +451,11 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       const configOrError =
         solcConfigSelector.selectBestSolcConfigForSingleRootGraph(subgraph);
 
-      if ("reason" in configOrError) {
+      if (!configOrError.success) {
         return configOrError;
       }
 
-      subgraphsWithConfig.push([configOrError, subgraph]);
+      subgraphsWithConfig.push([configOrError.config, subgraph]);
     }
 
     // get longVersion and isWasm from the compiler for each version
@@ -632,7 +637,12 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       }
     }
 
-    return { compilationJobsPerFile, indexedIndividualJobs, cacheHits };
+    return {
+      success: true,
+      compilationJobsPerFile,
+      indexedIndividualJobs,
+      cacheHits,
+    };
   }
 
   #getBuildProfile(buildProfileName: string = DEFAULT_BUILD_PROFILE) {

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

@@ -66,7 +66,7 @@ async function spawnCompile(
       );
 
       const stdoutPipeline = subprocess.stdout.pipe(stdoutWriteStream);
-      // NOTE: Compiler warnings are NOT written to stder, they are returned via
+      // NOTE: Compiler warnings are NOT written to stderr, they are returned via
       // the `errors` field of the CompilerOutput instead
       const stderrPipeline = subprocess.stderr.pipe(
         createNonClosingWriter(process.stderr),

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

@@ -25,7 +25,7 @@ export class DependencyGraphImplementation implements DependencyGraph {
 
   /**
    * Adds a root file to the graph. All the roots of the dependency graph must
-   * be added before any dependencry.
+   * be added before any dependency.
    *
    * @param userSourceName The source name used to identify the file, as it
    * would appear in the artifacts and used by the user. This is not always the

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

@@ -4,7 +4,6 @@ import type {
   Remapping,
   ResolvedNpmUserRemapping,
   ResolvedUserRemapping,
-  Result,
 } from "./types.js";
 import type {
   ImportResolutionError,
@@ -20,6 +19,7 @@ import type {
   ProjectResolvedFile,
   NpmPackageResolvedFile,
 } from "../../../../../types/solidity/resolved-file.js";
+import type { Result } from "../../../../../types/utils.js";
 
 import path from "node:path";
 

package/src/internal/builtin-plugins/solidity/build-system/resolver/remapped-npm-packages-graph.ts

@@ -7,13 +7,13 @@ import type {
   ResolvedUserRemapping,
   UnresolvedNpmUserRemapping,
   RemappedNpmPackagesGraphJson,
-  Result,
 } from "./types.js";
 import type {
   ResolvedFile,
   ResolvedNpmPackage,
   UserRemappingError,
 } from "../../../../../types/solidity.js";
+import type { Result } from "../../../../../types/utils.js";
 
 import path from "node:path";
 
@@ -37,6 +37,32 @@ import { UserRemappingType } from "./types.js";
 
 const HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT = "project";
 
+/**
+ * Returns a normalized version of the path if it refers to a node_modules in
+ * the root directory (i.e. node_modules/...), or a `node_modules` directory
+ * in a parent directory (i.e. ../../node_modules/...).
+ *
+ * Otherwise returns `undefined`.
+ *
+ * @param pathToNormalize The path to normalize.
+ * @returns The normalized path (node_modules/...), or `undefined`.
+ */
+export function getNormalizeNodeModulesPath(
+  pathToNormalize: string,
+): string | undefined {
+  if (pathToNormalize.startsWith("node_modules/")) {
+    return pathToNormalize;
+  }
+
+  const normalized = path.posix.normalize(pathToNormalize);
+
+  if (!/^(?:\.\.\/)*node_modules\//.test(normalized)) {
+    return undefined;
+  }
+
+  return normalized.substring(normalized.indexOf("node_modules/"));
+}
+
 export type RemappingsReaderFunction = (
   packageName: string,
   packageVersion: string,
@@ -559,7 +585,7 @@ export class RemappedNpmPackagesGraphImplementation
     const prefix = remapping.prefix.endsWith("/")
       ? remapping.prefix
       : remapping.prefix + "/";
-    const target = remapping.target.endsWith("/")
+    let target = remapping.target.endsWith("/")
       ? remapping.target
       : remapping.target + "/";
 
@@ -568,12 +594,13 @@ export class RemappedNpmPackagesGraphImplementation
       path.dirname(sourceOfTheRemapping),
     );
 
-    // If the remapping's target starts with `node_modules/`, we treat
-    // it as trying to load an npm dependency, otherwise we treat it as a local
+    // If the remapping's target starts with `node_modules/`, we treat it as
+    // trying to load an npm dependency, otherwise we treat it as a local
     // remapping.
+    const normalizedNodeModulesTarget = getNormalizeNodeModulesPath(target);
 
     // Local remapping case
-    if (!target.startsWith("node_modules/")) {
+    if (normalizedNodeModulesTarget === undefined) {
       return {
         success: true,
         value: {
@@ -593,6 +620,9 @@ export class RemappedNpmPackagesGraphImplementation
           source: sourceOfTheRemapping,
         },
       };
+    } else {
+      // We update the target to the normalized version
+      target = normalizedNodeModulesTarget;
     }
 
     // If we are here the remapping is a npm remapping.
@@ -600,7 +630,7 @@ export class RemappedNpmPackagesGraphImplementation
     const targetWithoutNodeModules = target.substring("node_modules/".length);
 
     // If after doing that the prefix and target are the same, we skip it
-    // so that it doesn't even go unnecesarly go through a user remapping.
+    // so that it doesn't even go unnecessarily go through a user remapping.
     if (prefix === targetWithoutNodeModules) {
       return { success: true, value: undefined };
     }

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

@@ -10,13 +10,7 @@ import type {
   ResolvedFile,
   ResolvedNpmPackage,
 } from "../../../../../types/solidity/resolved-file.js";
-
-/**
- * A result that can either have a value or an error.
- */
-export type Result<ValueT, ErrorT> =
-  | { readonly success: true; readonly value: ValueT }
-  | { readonly success: false; readonly error: ErrorT };
+import type { Result } from "../../../../../types/utils.js";
 
 /**
  * A solc remapping.
@@ -96,7 +90,7 @@ export type InstallationName = string;
 
 /**
  * This interface represents a graph of all the npm packages that the Hardhat
- * project uses, including the Hardhat projecct itself, and their remappings.
+ * project uses, including the Hardhat project itself, and their remappings.
  *
  * This class guarantees that there's a single instance of any npm package per
  * each version. That means that, even if you have multiple installations of
@@ -109,7 +103,7 @@ export type InstallationName = string;
  * than expected, because:
  *  - Processing a remapping may require loading a new npm package, and this
  *    interface ensures its uniqueness.
- *  - Loading an npm package requires processing its remappigns.
+ *  - Loading an npm package requires processing its remappings.
  *  - Selecting the best user remapping for an import can require processing it
  *    and loading its npm package.
  *

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

@@ -1,5 +1,5 @@
-import type { Result } from "./types.js";
 import type { ResolvedNpmPackage } from "../../../../../types/solidity.js";
+import type { Result } from "../../../../../types/utils.js";
 
 import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
 import { ensureError } from "@nomicfoundation/hardhat-utils/error";