hardhat 3.4.0 → 3.4.2

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

@@ -1,7 +1,14 @@
 // 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.
+//
+// EXCEPTION: we share `getRuntimeInfo` with the rest of the codebase instead
+// of duplicating it. The helper has no transitive dependencies, so the risk of
+// an unreadable stack trace from its import graph is negligible.
 
-import chalk from "chalk";
+import { getRuntimeInfo } from "@nomicfoundation/hardhat-utils/runtime";
 
 export const MIN_SUPPORTED_NODE_VERSION: number[] = [22, 10, 0];
 
@@ -12,10 +19,6 @@ export function isNodeVersionSupported(): boolean {
     const minor = parseInt(minorStr, 10);
     const patch = parseInt(patchStr, 10);
 
-    if (major % 2 === 1) {
-      return false;
-    }
-
     if (major < MIN_SUPPORTED_NODE_VERSION[0]) {
       return false;
     } else if (major > MIN_SUPPORTED_NODE_VERSION[0]) {
@@ -39,12 +42,20 @@ export function isNodeVersionSupported(): boolean {
   return true;
 }
 
-export function printNodeJsVersionWarningIfNecessary(): void {
+export function exitIfNodeVersionNotSupported(): void {
+  // Only enforce the Node.js version when we're actually running on Node.js.
+  // Bun and Deno emulate `process.versions.node`, so checking it there would
+  // incorrectly reject users on those runtimes.
+  if (getRuntimeInfo()?.runtime !== "node") {
+    return;
+  }
+
   if (!isNodeVersionSupported()) {
-    console.log(
-      chalk.bold(`\n${chalk.yellow("WARNING:")} You are using Node.js ${process.versions.node} which is not supported by Hardhat.
-Please upgrade to ${MIN_SUPPORTED_NODE_VERSION.join(".")} or a later LTS version (even major version number)\n`),
+    console.error(
+      `\nERROR: You are using Node.js ${process.versions.node} which is not supported by Hardhat.\n` +
+        `Please upgrade to Node.js ${MIN_SUPPORTED_NODE_VERSION.join(".")} or later.\n`,
     );
-    return;
+
+    process.exit(1);
   }
 }

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));
 }

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

@@ -19,15 +19,16 @@ const log = debug("hardhat:cli:telemetry:sentry:reporter");
 export const SENTRY_DSN =
   "https://572b03708e298427cc72fc26dac1e8b2@o385026.ingest.us.sentry.io/4508780138856448"; // PROD
 
-// TODO: This could be done in a more elegant way, but for now, we just
-// initialize the entire reporter so that it sets the global error handlers.
-export async function setupErrorTelemetryIfEnabled(): Promise<void> {
-  await Reporter.getInstance(true);
-}
-
-export async function sendErrorTelemetry(error: Error): Promise<boolean> {
+/**
+ * @deprecated Use packages/hardhat/src/internal/cli/telemetry/error-reporter/reporter.ts
+ *   instead.
+ */
+export async function sendErrorTelemetry(
+  error: Error,
+  hint?: { unhandled?: boolean; mechanismType?: string },
+): Promise<boolean> {
   const instance = await Reporter.getInstance();
-  return instance.reportErrorViaSubprocess(error);
+  return await instance.reportErrorViaSubprocess(error, hint);
 }
 
 export function setCliHardhatConfigPath(configPath: string): void {
@@ -57,9 +58,7 @@ class Reporter {
     this.#hardhatConfigPath = configPath;
   }
 
-  public static async getInstance(
-    shouldSetupErrorHandlers = false,
-  ): Promise<Reporter> {
+  public static async getInstance(): Promise<Reporter> {
     if (this.#instance !== undefined) {
       return this.#instance;
     }
@@ -94,7 +93,6 @@ class Reporter {
       ),
       release,
       environment,
-      installGlobalHandlers: shouldSetupErrorHandlers,
     });
 
     setExtra("nodeVersion", process.version);
@@ -108,17 +106,31 @@ class Reporter {
     this.#instance = undefined;
   }
 
-  public async reportErrorViaSubprocess(error: Error): Promise<boolean> {
+  public async reportErrorViaSubprocess(
+    error: Error,
+    hint?: { unhandled?: boolean; mechanismType?: string },
+  ): Promise<boolean> {
     if (!(await this.#shouldBeReported(error))) {
       log("Error not send: this type of error should not be reported");
       return false;
     }
 
-    const { captureException } = await import("@sentry/core");
+    const { captureException, flush } = await import("@sentry/core");
 
     log("Capturing exception");
 
-    captureException(error);
+    captureException(
+      error,
+      hint !== undefined
+        ? {
+            mechanism: {
+              type: hint.mechanismType ?? "generic",
+              handled: hint.unhandled !== true,
+            },
+          }
+        : undefined,
+    );
+    await flush();
 
     return true;
   }

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

@@ -139,7 +139,7 @@ export async function sendEnvelopeToSentryBackend(
   dsn: string,
   envelope: Envelope,
 ): Promise<TransportMakeRequestResponse> {
-  return sendSerializedEnvelopeToSentryBackend(
+  return await sendSerializedEnvelopeToSentryBackend(
     dsn,
     serializeEnvelope(envelope),
   );

package/src/internal/cli/telemetry/telemetry-permissions.ts

@@ -35,7 +35,7 @@ export async function isTelemetryAllowed(
     return process.env.HARDHAT_TEST_TELEMETRY_ENABLED === "true" ? true : false;
   }
 
-  return isTelemetryEnabled(telemetryConfigFilePath);
+  return await isTelemetryEnabled(telemetryConfigFilePath);
 }
 
 /**

package/src/internal/config-loading.ts

@@ -34,15 +34,15 @@ export async function resolveHardhatConfigPath(
   userProvidedPath?: string,
 ): Promise<string> {
   if (userProvidedPath !== undefined) {
-    return normalizeConfigPath(userProvidedPath);
+    return await normalizeConfigPath(userProvidedPath);
   }
 
   if (process.env.HARDHAT_CONFIG !== undefined) {
     log("Using config file path from the HARDHAT_CONFIG env var");
-    return normalizeConfigPath(process.env.HARDHAT_CONFIG);
+    return await normalizeConfigPath(process.env.HARDHAT_CONFIG);
   }
 
-  return findClosestHardhatConfig();
+  return await findClosestHardhatConfig();
 }
 
 /**

package/src/internal/core/configuration-variables.ts

@@ -118,24 +118,25 @@ export class LazyResolvedConfigurationVariable extends BaseResolvedConfiguration
     const mutex = LazyResolvedConfigurationVariable.#mutexes.get(this.#hooks);
     assertHardhatInvariant(mutex !== undefined, "Mutex must be defined");
 
-    return mutex.exclusiveRun(async () =>
-      this.#hooks.runHandlerChain(
-        "configurationVariables",
-        "fetchValue",
-        [this.#variable],
-        async (_context, v) => {
-          const value = process.env[v.name];
-
-          if (typeof value !== "string") {
-            throw new HardhatError(
-              HardhatError.ERRORS.CORE.GENERAL.ENV_VAR_NOT_FOUND,
-              { name: v.name },
-            );
-          }
-
-          return value;
-        },
-      ),
+    return await mutex.exclusiveRun(
+      async () =>
+        await this.#hooks.runHandlerChain(
+          "configurationVariables",
+          "fetchValue",
+          [this.#variable],
+          async (_context, v) => {
+            const value = process.env[v.name];
+
+            if (typeof value !== "string") {
+              throw new HardhatError(
+                HardhatError.ERRORS.CORE.GENERAL.ENV_VAR_NOT_FOUND,
+                { name: v.name },
+              );
+            }
+
+            return value;
+          },
+        ),
     );
   }
 }