hardhat 3.4.0 → 3.4.2

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

@@ -195,7 +195,7 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
 
     const downloadPath = this.#getCompilerBinaryPathFromBuild(build);
 
-    return exists(downloadPath);
+    return await exists(downloadPath);
   }
 
   public async downloadCompiler(version: string): Promise<boolean> {
@@ -208,7 +208,7 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
       path.join(this.#compilersDir, `compiler-download-${version}`),
     );
 
-    return mutex.use(async () => {
+    return await mutex.use(async () => {
       const isCompilerDownloaded = await this.isCompilerDownloaded(version);
 
       if (isCompilerDownloaded === true) {
@@ -240,7 +240,7 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
         }
       }
 
-      return this.#postProcessCompilerDownload(build, downloadPath);
+      return await this.#postProcessCompilerDownload(build, downloadPath);
     });
   }
 
@@ -295,7 +295,7 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
   }
 
   async #readCompilerList(listPath: string): Promise<CompilerList> {
-    return readJsonFile(listPath);
+    return await readJsonFile(listPath);
   }
 
   #getCompilerDownloadPathFromBuild(build: CompilerBuild): string {

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

@@ -124,10 +124,10 @@ export async function getCompiler(
 ): Promise<Compiler> {
   if (compilerPath !== undefined) {
     // If a compiler path is provided, it means the user is using a custom compiler
-    return getCompilerFromPath(version, compilerPath);
+    return await getCompilerFromPath(version, compilerPath);
   } else {
     // Otherwise we get or download the compiler for the specific version
-    return getCompilerFromVersion(version, { preferWasm });
+    return await getCompilerFromVersion(version, { preferWasm });
   }
 }
 

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

@@ -6,7 +6,7 @@ async function readStream(
 ): Promise<string> {
   stream.setEncoding(encoding);
 
-  return new Promise((resolve, reject) => {
+  return await new Promise((resolve, reject) => {
     let data = "";
 
     stream.on("data", (chunk) => (data += chunk.toString(encoding)));

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

@@ -33,7 +33,7 @@ export async function buildDependencyGraph(
       "readNpmPackageRemappings",
       [packageName, packageVersion, packagePath],
       async (_context, name, version, path) =>
-        defaultBehavior(name, version, path),
+        await defaultBehavior(name, version, path),
     );
 
   const resolver = await ResolverImplementation.create(

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

@@ -21,7 +21,14 @@ import type {
   CompilerOutputError,
 } from "../../../../types/solidity/compiler-io.js";
 import type { SolidityBuildInfo } from "../../../../types/solidity.js";
-import type { SolidityBuildSystemOptions } from "../build-system/build-system.js";
+import type {
+  SolidityBuildSystemOptions,
+  SolidityBuildSystemImplementation as SolidityBuildSystemImplementationT,
+} from "../build-system/build-system.js";
+
+let SolidityBuildSystemImplementation:
+  | typeof SolidityBuildSystemImplementationT
+  | undefined;
 
 class LazySolidityBuildSystem implements SolidityBuildSystem {
   readonly #hooks: HookManager;
@@ -38,12 +45,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 +66,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 +74,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 +82,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 +91,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 +104,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 +116,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,18 +124,20 @@ 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> {
-    const { SolidityBuildSystemImplementation } = await import(
-      "../build-system/build-system.js"
-    );
+    if (SolidityBuildSystemImplementation === undefined) {
+      const buildSystemModule = await import("../build-system/build-system.js");
+      SolidityBuildSystemImplementation =
+        buildSystemModule.SolidityBuildSystemImplementation;
+    }
 
     if (this.#buildSystem === undefined) {
       this.#buildSystem = new SolidityBuildSystemImplementation(

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/solidity-test/task-action.ts

@@ -27,7 +27,7 @@ import { getFullyQualifiedName } from "../../../utils/contract-names.js";
 import { errorResult, successfulResult } from "../../../utils/result.js";
 import { isSupportedChainType } from "../../edr/chain-type.js";
 import { ArtifactManagerImplementation } from "../artifacts/artifact-manager.js";
-import { getCoverageManager } from "../coverage/helpers.js";
+import { getCoverageManager } from "../coverage/helpers/accessors.js";
 import { getGasAnalyticsManager } from "../gas-analytics/helpers/accessors.js";
 import { edrGasReportToHardhatGasMeasurements } from "../network-manager/edr/utils/convert-to-edr.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/builtin-plugins/test/task-action.ts

@@ -16,7 +16,7 @@ import {
   isResult,
   successfulResult,
 } from "../../../utils/result.js";
-import { getCoverageManager } from "../coverage/helpers.js";
+import { getCoverageManager } from "../coverage/helpers/accessors.js";
 import { getGasAnalyticsManager } from "../gas-analytics/helpers/accessors.js";
 
 interface TestActionArguments {

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

@@ -12,7 +12,6 @@ import {
   copy,
   ensureDir,
   exists,
-  getAllFilesMatching,
   isDirectory,
   mkdir,
   readJsonFile,
@@ -31,7 +30,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,
@@ -435,17 +434,36 @@ export async function copyProjectFiles(
   template: Template,
   force?: boolean,
 ): Promise<void> {
-  // Find all the files in the workspace that would have been overwritten by the template files
-  const matchingRelativeWorkspacePaths = await getAllFilesMatching(
-    workspace,
-    (file) => {
-      const relativeWorkspacePath = path.relative(workspace, file);
-      const relativeTemplatePath = relativeWorkspaceToTemplatePath(
-        relativeWorkspacePath,
-      );
-      return template.files.includes(relativeTemplatePath);
-    },
-  ).then((files) => files.map((f) => path.relative(workspace, f)));
+  // Find all the paths in the template that clash with an existing one in the
+  // workspace
+  const matchingRelativeWorkspacePaths = (
+    await Promise.all(
+      template.files.map(async (relativeTemplatePath) => {
+        const relativeWorkspacePath =
+          relativeTemplateToWorkspacePath(relativeTemplatePath);
+
+        const absoluteWorkspacePath = path.join(
+          workspace,
+          relativeWorkspacePath,
+        );
+
+        if (!(await exists(absoluteWorkspacePath))) {
+          return undefined;
+        }
+
+        // We ignore directories in this clash detection
+        if (await isDirectory(absoluteWorkspacePath)) {
+          return undefined;
+        }
+
+        return relativeWorkspacePath;
+      }),
+    )
+  ).filter((relativeWorkspacePath) => relativeWorkspacePath !== undefined);
+
+  const matchingRelativeWorkspacePathsSet = new Set(
+    matchingRelativeWorkspacePaths,
+  );
 
   // Ask the user for permission to overwrite existing files if needed
   if (matchingRelativeWorkspacePaths.length !== 0) {
@@ -461,7 +479,7 @@ export async function copyProjectFiles(
 
     if (
       force === false &&
-      matchingRelativeWorkspacePaths.includes(relativeWorkspacePath)
+      matchingRelativeWorkspacePathsSet.has(relativeWorkspacePath)
     ) {
       continue;
     }

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

@@ -5,7 +5,7 @@ import {
   exists,
   getAllFilesMatching,
   isDirectory,
-  readdir,
+  readdirOrEmpty,
   readJsonFile,
 } from "@nomicfoundation/hardhat-utils/fs";
 import {
@@ -40,11 +40,7 @@ export async function getTemplates(
   const packageRoot = await findClosestPackageRoot(import.meta.url);
   const pathToTemplates = path.join(packageRoot, "templates", templatesDir);
 
-  if (!(await exists(pathToTemplates))) {
-    return [];
-  }
-
-  const pathsToTemplates = await readdir(pathToTemplates);
+  const pathsToTemplates = await readdirOrEmpty(pathToTemplates);
   pathsToTemplates.sort();
 
   const templates = await Promise.all(
@@ -65,27 +61,26 @@ export async function getTemplates(
 
       const packageJson: PackageJson =
         await readJsonFile<PackageJson>(pathToPackageJson);
-      const files = await getAllFilesMatching(pathToTemplate, (f) => {
-        // Ignore the package.json file because it is handled separately
-        if (f === pathToPackageJson) {
-          return false;
-        }
-        // .gitignore files are expected to be called gitignore in the templates
-        // because npm ignores .gitignore files during npm pack (see https://github.com/npm/npm/issues/3763)
-        if (path.basename(f) === ".gitignore") {
-          return false;
-        }
-        // We should ignore all the files according to the .gitignore rules
-        // However, for simplicity, we just ignore the node_modules folder
-        // If we needed to implement a more complex ignore logic, we could
-        // use recently introduced glob from node:fs/promises
-        if (
-          path.relative(pathToTemplate, f).split(path.sep)[0] === "node_modules"
-        ) {
-          return false;
-        }
-        return true;
-      }).then((fs) => fs.map((f) => path.relative(pathToTemplate, f)));
+
+      const matchingFiles = await getAllFilesMatching(
+        pathToTemplate,
+        (f) => {
+          // Ignore the package.json file because it is handled separately
+          if (f === pathToPackageJson) {
+            return false;
+          }
+
+          // .gitignore files are expected to be called gitignore in the templates
+          // because npm ignores .gitignore files during npm pack (see https://github.com/npm/npm/issues/3763)
+          if (path.basename(f) === ".gitignore") {
+            return false;
+          }
+          return true;
+        },
+        (dir) => path.basename(dir) !== "node_modules",
+      );
+
+      const files = matchingFiles.map((f) => path.relative(pathToTemplate, f));
 
       return {
         name,

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