hardhat 3.4.0 → 3.4.1

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

@@ -6,11 +6,11 @@ export function readSourceFileFactory(
   hooks: HookManager,
 ): (absPath: string) => Promise<string> {
   return async (factoryAbsPath: string) => {
-    return hooks.runHandlerChain(
+    return await hooks.runHandlerChain(
       "solidity",
       "readSourceFile",
       [factoryAbsPath],
-      async (_context, absPath) => readUtf8File(absPath),
+      async (_context, absPath) => await readUtf8File(absPath),
     );
   };
 }

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

@@ -133,8 +133,8 @@ export class ResolverImplementation implements Resolver {
   public async resolveProjectFile(
     absoluteFilePath: string,
   ): Promise<Result<ProjectResolvedFile, ProjectRootResolutionError>> {
-    return this.#mutex.exclusiveRun(async () => {
-      return this.#resolveProjectFile(absoluteFilePath);
+    return await this.#mutex.exclusiveRun(async () => {
+      return await this.#resolveProjectFile(absoluteFilePath);
     });
   }
 
@@ -146,8 +146,8 @@ export class ResolverImplementation implements Resolver {
       NpmRootResolutionError
     >
   > {
-    return this.#mutex.exclusiveRun(async () => {
-      return this.#resolveNpmDependencyFileAsRoot(npmModule);
+    return await this.#mutex.exclusiveRun(async () => {
+      return await this.#resolveNpmDependencyFileAsRoot(npmModule);
     });
   }
 
@@ -160,8 +160,8 @@ export class ResolverImplementation implements Resolver {
       ImportResolutionError
     >
   > {
-    return this.#mutex.exclusiveRun(async () =>
-      this.#resolveImport(from, importPath),
+    return await this.#mutex.exclusiveRun(
+      async () => await this.#resolveImport(from, importPath),
     );
   }
 
@@ -495,7 +495,7 @@ export class ResolverImplementation implements Resolver {
         };
       }
 
-      return this.#resolveRelativeImport({
+      return await this.#resolveRelativeImport({
         from,
         importPath,
         directImport,
@@ -504,7 +504,7 @@ export class ResolverImplementation implements Resolver {
       if (bestUserRemapping !== undefined) {
         // If the import isn't relative, and there's a user remapping, we
         // prioritize that.
-        return this.#resolveUserRemappedImport({
+        return await this.#resolveUserRemappedImport({
           from,
           importPath,
           directImport,
@@ -576,7 +576,7 @@ export class ResolverImplementation implements Resolver {
 
     const relativeFsPath = sourceNamePathToFsPath(relativeSourceNamePath);
 
-    return this.#commonImportResolution({
+    return await this.#commonImportResolution({
       from,
       importPath,
       npmPackage: from.package,
@@ -639,7 +639,7 @@ export class ResolverImplementation implements Resolver {
 
     const relativeFsPath = sourceNamePathToFsPath(relativeSourceNamePath);
 
-    return this.#commonImportResolution({
+    return await this.#commonImportResolution({
       from,
       importPath,
       npmPackage: targetNpmPackage,
@@ -796,7 +796,7 @@ export class ResolverImplementation implements Resolver {
     const relativePath = resolvedSubpath ?? subpath;
     const relativeFsPathWithinPackage = sourceNamePathToFsPath(relativePath);
 
-    return this.#commonImportResolution({
+    return await this.#commonImportResolution({
       from,
       importPath,
       npmPackage: dependency,

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

@@ -457,7 +457,7 @@ export class RemappedNpmPackagesGraphImplementation
       npmPackage.version,
       npmPackage.rootFsPath,
       async (_packageName, _packageVersion, packagePath) =>
-        this.#defaultReadPackageRemappings(packagePath),
+        await this.#defaultReadPackageRemappings(packagePath),
     );
 
     return this.#parseAndDeduplicateRemappings(npmPackage, allRemappings);

package/src/internal/builtin-plugins/solidity/hook-handlers/config.ts

@@ -20,7 +20,7 @@ export default async (): Promise<Partial<ConfigHooks>> => {
         resolveConfigurationVariable,
       );
 
-      return resolveSolidityUserConfig(userConfig, resolvedConfig);
+      return await resolveSolidityUserConfig(userConfig, resolvedConfig);
     },
     validateResolvedConfig: async (resolvedConfig) =>
       validateSolidityConfig(resolvedConfig),

package/src/internal/builtin-plugins/solidity/hook-handlers/hre.ts

@@ -38,12 +38,12 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     options: { scope?: BuildScope } = {},
   ): Promise<string[]> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.getRootFilePaths(options);
+    return await buildSystem.getRootFilePaths(options);
   }
 
   public async getScope(fsPath: string): Promise<BuildScope> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.getScope(fsPath);
+    return await buildSystem.getScope(fsPath);
   }
 
   public isSuccessfulBuildResult(
@@ -59,7 +59,7 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     options?: BuildOptions,
   ): Promise<CompilationJobCreationError | Map<string, FileBuildResult>> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.build(rootFiles, options);
+    return await buildSystem.build(rootFiles, options);
   }
 
   public async getCompilationJobs(
@@ -67,7 +67,7 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     options?: GetCompilationJobsOptions,
   ): Promise<CompilationJobCreationError | GetCompilationJobsResult> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.getCompilationJobs(rootFiles, options);
+    return await buildSystem.getCompilationJobs(rootFiles, options);
   }
 
   public async runCompilationJob(
@@ -75,7 +75,7 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     options?: RunCompilationJobOptions,
   ): Promise<RunCompilationJobResult> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.runCompilationJob(compilationJob, options);
+    return await buildSystem.runCompilationJob(compilationJob, options);
   }
 
   public async remapCompilerError(
@@ -84,7 +84,7 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     shouldShortenPaths?: boolean,
   ): Promise<CompilerOutputError> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.remapCompilerError(
+    return await buildSystem.remapCompilerError(
       compilationJob,
       error,
       shouldShortenPaths,
@@ -97,7 +97,11 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     options: { scope?: BuildScope } = {},
   ): Promise<EmitArtifactsResult> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.emitArtifacts(compilationJob, compilerOutput, options);
+    return await buildSystem.emitArtifacts(
+      compilationJob,
+      compilerOutput,
+      options,
+    );
   }
 
   public async cleanupArtifacts(
@@ -105,7 +109,7 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     options: { scope?: BuildScope } = {},
   ): Promise<void> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.cleanupArtifacts(rootFilePaths, options);
+    return await buildSystem.cleanupArtifacts(rootFilePaths, options);
   }
 
   public async compileBuildInfo(
@@ -113,12 +117,12 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     options?: CompileBuildInfoOptions,
   ): Promise<CompilerOutput> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.compileBuildInfo(buildInfo, options);
+    return await buildSystem.compileBuildInfo(buildInfo, options);
   }
 
   public async getArtifactsDirectory(scope: BuildScope): Promise<string> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.getArtifactsDirectory(scope);
+    return await buildSystem.getArtifactsDirectory(scope);
   }
 
   async #getBuildSystem(): Promise<SolidityBuildSystem> {

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

@@ -32,7 +32,7 @@ const buildTask = task("build", "Build project")
     name: "noContracts",
     description: "Skip solidity contracts compilation",
   })
-  .setAction(async () => import("./tasks/build.js"))
+  .setAction(async () => await import("./tasks/build.js"))
   .build();
 
 const hardhatPlugin: HardhatPlugin = {

package/src/internal/builtin-plugins/solidity/solidity-hooks.ts

@@ -46,7 +46,7 @@ export async function getSolcCompilerForConfig(
   compilerConfig: SolidityCompilerConfig,
   buildProfilePreferWasm: boolean,
 ): Promise<Compiler> {
-  return getCompiler(compilerConfig.version, {
+  return await getCompiler(compilerConfig.version, {
     preferWasm: resolvePreferWasm(compilerConfig, buildProfilePreferWasm),
     compilerPath: compilerConfig.path,
   });

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

@@ -119,7 +119,7 @@ const buildAction: NewTaskActionFunction<BuildActionArguments> = async (
     return { contractRootPaths, testRootPaths };
   }
 
-  return runSolidityBuild({
+  return await runSolidityBuild({
     buildProfile,
     files,
     force: args.force,
@@ -208,7 +208,7 @@ async function runSolidityBuild({
     return { contractRootPaths, testRootPaths };
   }
 
-  return partitionRootPathsByScope(solidity, builtRootPaths);
+  return await partitionRootPathsByScope(solidity, builtRootPaths);
 }
 
 /**
@@ -237,7 +237,7 @@ async function getRootsToBuild({
   isFullBuild: boolean;
 }> {
   if (isUnifiedModeOrScope === true) {
-    return getRootsToBuildInUnifiedMode({
+    return await getRootsToBuildInUnifiedMode({
       files,
       noContracts,
       noTests,
@@ -245,7 +245,7 @@ async function getRootsToBuild({
     });
   }
 
-  return getRootsToBuildForScope({
+  return await getRootsToBuildForScope({
     files,
     scope: isUnifiedModeOrScope,
     solidity,

package/src/internal/builtin-plugins/solidity-test/edr-artifacts.ts

@@ -31,7 +31,7 @@ export async function getBuildInfosAndOutputs(
 ): Promise<BuildInfoAndOutput[]> {
   const buildInfoIds = await artifactManager.getAllBuildInfoIds();
 
-  return Promise.all(
+  return await Promise.all(
     Array.from(buildInfoIds).map(async (buildInfoId) => {
       const buildInfoPath = await artifactManager.getBuildInfoPath(buildInfoId);
       const buildInfoOutputPath =
@@ -76,7 +76,7 @@ export async function buildEdrArtifactsWithMetadata(
 
   const artifacts = await Promise.all(
     Array.from(fullyQualifiedNames).map(async (fullyQualifiedName) => {
-      return artifactManager.readArtifact(fullyQualifiedName);
+      return await artifactManager.readArtifact(fullyQualifiedName);
     }),
   );
 

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

@@ -19,7 +19,7 @@ export default async (): Promise<Partial<ConfigHooks>> => {
         resolveConfigurationVariable,
       );
 
-      return resolveSolidityTestUserConfig(
+      return await resolveSolidityTestUserConfig(
         userConfig,
         resolvedConfig,
         resolveConfigurationVariable,

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

@@ -15,7 +15,7 @@ export default async (): Promise<Partial<TestHooks>> => {
         return "solidity";
       }
 
-      return next(context, filePath);
+      return await next(context, filePath);
     },
   };
 

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

@@ -42,7 +42,7 @@ const hardhatPlugin: HardhatPlugin = {
         defaultValue: 0,
         hidden: true,
       })
-      .setAction(async () => import("./task-action.js"))
+      .setAction(async () => await import("./task-action.js"))
       .build(),
   ],
   dependencies: () => [

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

@@ -9,7 +9,7 @@ import type { TestResult } from "@nomicfoundation/edr";
 import { bytesToHexString } from "@nomicfoundation/hardhat-utils/hex";
 import chalk from "chalk";
 
-import { sendErrorTelemetry } from "../../cli/telemetry/sentry/reporter.js";
+import { sendErrorTelemetry } from "../../cli/telemetry/error-reporter/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";

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

@@ -14,7 +14,7 @@ const hardhatPlugin: HardhatPlugin = {
         name: "disable",
         description: "Disable telemetry",
       })
-      .setAction(async () => import("./task-action.js"))
+      .setAction(async () => await import("./task-action.js"))
       .build(),
   ],
   npmPackage: "hardhat",

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

@@ -14,7 +14,7 @@ export default async (): Promise<Partial<ConfigHooks>> => {
         resolveConfigurationVariable,
       );
 
-      return resolveTestUserConfig(userConfig, resolvedConfig);
+      return await resolveTestUserConfig(userConfig, resolvedConfig);
     },
   };
 

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

@@ -32,7 +32,7 @@ const hardhatPlugin: HardhatPlugin = {
         name: "noCompile",
         description: "Do not compile the project before running the tests",
       })
-      .setAction(async () => import("./task-action.js"))
+      .setAction(async () => await import("./task-action.js"))
       .build(),
   ],
   dependencies: () => [import("../solidity/index.js")],

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

@@ -31,7 +31,7 @@ import {
 } from "../../utils/package.js";
 import { BannerManager } from "../banner-manager.js";
 import { sendProjectTypeAnalytics } from "../telemetry/analytics/analytics.js";
-import { sendErrorTelemetry } from "../telemetry/sentry/reporter.js";
+import { sendErrorTelemetry } from "../telemetry/error-reporter/reporter.js";
 
 import {
   getDevDependenciesInstallationCommand,

package/src/internal/cli/main.ts

@@ -46,11 +46,11 @@ import { printErrorMessages } from "./error-handler.js";
 import { getGlobalHelpString } from "./help/get-global-help-string.js";
 import { getHelpString } from "./help/get-help-string.js";
 import { sendTaskAnalytics } from "./telemetry/analytics/analytics.js";
+import { setupGlobalUnhandledErrorHandlers } from "./telemetry/error-reporter/global-error-handlers.js";
 import {
   sendErrorTelemetry,
   setCliHardhatConfigPath,
-  setupErrorTelemetryIfEnabled,
-} from "./telemetry/sentry/reporter.js";
+} from "./telemetry/error-reporter/reporter.js";
 import { printVersionMessage } from "./version.js";
 
 export interface MainOptions {
@@ -64,7 +64,9 @@ export async function main(
   rawArguments: string[],
   options: MainOptions = {},
 ): Promise<void> {
-  await setupErrorTelemetryIfEnabled();
+  // We set up the global unhandled errors before running any functionality
+  setupGlobalUnhandledErrorHandlers();
+
   const print = options.print ?? console.log;
 
   const log = debug("hardhat:core:cli:main");

package/src/internal/cli/node-version.ts

@@ -1,5 +1,8 @@
 // NOTE: We don't use the `semver` package because it's slow to load, and this
 // is always run during the initialization of the CLI.
+//
+// NOTE: This file shouldn't import any non-builtin dependency, as it's imported
+// before enabling source maps support. TODO: Change chalk to util.styleText
 
 import chalk from "chalk";
 

package/src/internal/cli/telemetry/analytics/analytics.ts

@@ -60,7 +60,7 @@ export async function sendTaskAnalytics(taskId: string[]): Promise<boolean> {
     },
   };
 
-  return sendAnalytics(taskAnalyticsEvent);
+  return await sendAnalytics(taskAnalyticsEvent);
 }
 
 export async function sendProjectTypeAnalytics(
@@ -75,7 +75,7 @@ export async function sendProjectTypeAnalytics(
     },
   };
 
-  return sendAnalytics(initAnalyticsEvent);
+  return await sendAnalytics(initAnalyticsEvent);
 }
 
 // Return a boolean for testing purposes to confirm whether analytics were sent based on the consent value and not in CI environments

package/src/internal/cli/telemetry/error-reporter/global-error-handlers.ts

@@ -0,0 +1,64 @@
+import { isObject } from "@nomicfoundation/hardhat-utils/lang";
+import debug from "debug";
+
+import { sendErrorTelemetry } from "./reporter.js";
+
+const log = debug("hardhat:core:telemetry:global-error-handlers");
+
+function createUnhandledErrorListener(isPromiseRejection: boolean) {
+  const description = isPromiseRejection
+    ? "Unhandled promise rejection"
+    : "Uncaught exception";
+
+  const mechanismType = isPromiseRejection
+    ? "onunhandledrejection"
+    : "onuncaughtexception";
+
+  async function listener(error: Error | unknown) {
+    log(description, error);
+
+    const telemetryError =
+      error instanceof Error
+        ? error
+        : new Error(
+            isObject(error) &&
+            "message" in error &&
+            typeof error.message === "string"
+              ? error.message
+              : "Unknown error",
+            { cause: error },
+          );
+
+    try {
+      await sendErrorTelemetry(telemetryError, {
+        unhandled: true,
+        mechanismType,
+      });
+    } catch (telemetryErrorReportingError) {
+      log(
+        "Failed to send telemetry for unhandled error",
+        telemetryErrorReportingError,
+      );
+    }
+
+    console.error();
+    console.error(`${description}:`);
+    console.error();
+    console.error(error);
+
+    process.exit(1);
+  }
+
+  return listener;
+}
+
+/**
+ * Sets up global error handlers that report unhandled errors and promise
+ * rejections if authorized by the user.
+ */
+export function setupGlobalUnhandledErrorHandlers(): void {
+  log("Setting up global unhandled error handlers");
+
+  process.on("uncaughtException", createUnhandledErrorListener(false));
+  process.on("unhandledRejection", createUnhandledErrorListener(true));
+}

package/src/internal/cli/telemetry/error-reporter/reporter.ts

@@ -0,0 +1,49 @@
+import type * as SentryReporterT from "../sentry/reporter.js";
+
+// Sentry's reporter loads a large number of modules, so we only load it if
+// needed.
+let sentryReporterModule: typeof SentryReporterT | undefined;
+
+// We cache the `setCliHardhatConfigPath` to avoid loading the reporter just
+// for this setting. We load it and set the config path if needed.
+let cliHardhatConfigPath: string | undefined;
+
+/**
+ * Reports an error if telemetry is authorized by the user.
+ *
+ * While this function is async, it's expected to always complete quickly,
+ * delegating the actual reporting to a subprocess.
+ *
+ * @param error - The error to report.
+ * @param hint - Optional metadata describing how the error was captured, used
+ *   to tag the event in Sentry so unhandled crashes can be distinguished from
+ *   errors caught and reported by the CLI.
+ * @param hint.unhandled - Whether the error reached a global handler without
+ *   being caught (e.g. an uncaught exception or unhandled promise rejection).
+ *   Defaults to `false` (i.e. the error was handled).
+ * @param hint.mechanismType - The Sentry mechanism type, used as a tag on the
+ *   event. Common values are `"onuncaughtexception"`, `"onunhandledrejection"`,
+ *   `"instrument"`, and `"generic"`. Defaults to `"generic"`.
+ */
+export async function sendErrorTelemetry(
+  error: Error,
+  hint?: { unhandled?: boolean; mechanismType?: string },
+): Promise<void> {
+  if (sentryReporterModule === undefined) {
+    sentryReporterModule = await import("../sentry/reporter.js");
+  }
+
+  if (cliHardhatConfigPath !== undefined) {
+    sentryReporterModule.setCliHardhatConfigPath(cliHardhatConfigPath);
+  }
+
+  await sentryReporterModule.sendErrorTelemetry(error, hint);
+}
+
+/**
+ * Sets the config path used in the Hardhat CLI. This is used for better
+ * anonymization of errors.
+ */
+export function setCliHardhatConfigPath(configPath: string): void {
+  cliHardhatConfigPath = configPath;
+}

package/src/internal/cli/telemetry/sentry/anonymizer.ts

@@ -359,7 +359,7 @@ export class Anonymizer {
   async #anonymizeFrames(frames: StackFrame[]): Promise<StackFrame[]> {
     const anonymizedFrames = await Promise.all(
       frames.map(async (frame) => {
-        return this.#anonymizeFrame(frame);
+        return await this.#anonymizeFrame(frame);
       }),
     );
     return anonymizedFrames;

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

@@ -1,10 +1,6 @@
 /* This file is inspired by https://github.com/getsentry/sentry-javascript/blob/9.4.0/packages/node/src/sdk/index.ts */
 
-import type {
-  Client,
-  ServerRuntimeClientOptions,
-  Transport,
-} from "@sentry/core";
+import type { ServerRuntimeClientOptions, Transport } from "@sentry/core";
 
 import os from "node:os";
 import path from "node:path";
@@ -18,15 +14,12 @@ import {
   ServerRuntimeClient,
   stackParserFromStackParserOptions,
 } from "@sentry/core";
-import debug from "debug";
 
 import { GENERIC_SERVER_NAME } from "./constants.js";
 import { nodeContextIntegration } from "./vendor/integrations/context.js";
 import { contextLinesIntegration } from "./vendor/integrations/contextlines.js";
 import { createGetModuleFromFilename } from "./vendor/utils/module.js";
 
-const log = debug("hardhat:core:sentry:init");
-
 interface GlobalCustomSentryReporterOptions {
   /**
    * Sentry's DSN
@@ -49,12 +42,6 @@ interface GlobalCustomSentryReporterOptions {
    * See the transport module for the different options.
    */
   transport: Transport;
-
-  /**
-   * If `true`, the global unhandled rejection and uncaught exception handlers
-   * will be installed.
-   */
-  installGlobalHandlers?: boolean;
 }
 
 /**
@@ -72,12 +59,9 @@ interface GlobalCustomSentryReporterOptions {
  * The reason that this uses the global instance of sentry (by calling
  * initAndBind), is that using the client directly doesn't work with the linked
  * errors integration.
- *
- * Calling `init` also has an option to set global unhandled rejection and
- * uncaught exception handlers.
  */
 export function init(options: GlobalCustomSentryReporterOptions): void {
-  const client = initAndBind<ServerRuntimeClient, ServerRuntimeClientOptions>(
+  initAndBind<ServerRuntimeClient, ServerRuntimeClientOptions>(
     ServerRuntimeClient,
     {
       dsn: options.dsn,
@@ -113,48 +97,4 @@ export function init(options: GlobalCustomSentryReporterOptions): void {
       ),
     },
   );
-
-  setupGlobalUnhandledErrorHandlers(client);
-}
-
-function createUnhandledErrorListener(
-  client: Client,
-  isPromiseRejection: boolean,
-) {
-  const description = isPromiseRejection
-    ? "Unhandled promise rejection"
-    : "Uncaught exception";
-
-  async function listener(error: Error | unknown) {
-    log(description, error);
-
-    client.captureException(error, {
-      captureContext: {
-        level: "fatal",
-      },
-      mechanism: {
-        handled: false,
-        type: "onuncaughtexception",
-      },
-    });
-
-    await client.flush(100);
-    await client.close(100);
-
-    console.error();
-    console.error(`${description}:`);
-    console.error();
-    console.error(error);
-
-    process.exit(1);
-  }
-
-  return listener;
-}
-
-function setupGlobalUnhandledErrorHandlers(client: Client) {
-  log("Setting up global unhandled error handlers");
-
-  process.on("uncaughtException", createUnhandledErrorListener(client, false));
-  process.on("unhandledRejection", createUnhandledErrorListener(client, true));
 }