hardhat 3.0.6 → 3.0.8

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

@@ -24,6 +24,14 @@ const buildTask = task("build", "Build project")
     description: "An optional list of files to compile",
     defaultValue: [],
   })
+  .addFlag({
+    name: "noTests",
+    description: "Skip solidity tests compilation",
+  })
+  .addFlag({
+    name: "noContracts",
+    description: "Skip solidity contracts compilation",
+  })
   .setAction(async () => import("./tasks/build.js"))
   .build();
 

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

@@ -1,3 +1,5 @@
+import type { HardhatRuntimeEnvironment } from "../../../../types/hre.js";
+import type { BuildScope } from "../../../../types/solidity.js";
 import type { NewTaskActionFunction } from "../../../../types/tasks.js";
 
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
@@ -5,27 +7,65 @@ import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 import { throwIfSolidityBuildFailed } from "../build-results.js";
 import { isNpmRootPath } from "../build-system/root-paths-utils.js";
 
-interface CompileActionArguments {
+interface BuildActionArguments {
   force: boolean;
   files: string[];
   quiet: boolean;
   defaultBuildProfile: string | undefined;
+  noTests: boolean;
+  noContracts: boolean;
 }
 
-const buildAction: NewTaskActionFunction<CompileActionArguments> = async (
-  { force, files, quiet, defaultBuildProfile },
-  { solidity, globalOptions },
+const buildAction: NewTaskActionFunction<BuildActionArguments> = async (
+  args: BuildActionArguments,
+  hre,
 ) => {
-  const rootPaths =
-    files.length === 0
-      ? await solidity.getRootFilePaths()
-      : files.map((file) => {
-          if (isNpmRootPath(file)) {
-            return file;
-          }
+  const contractRootPaths = [];
+  const testRootPaths = [];
 
-          return resolveFromRoot(process.cwd(), file);
-        });
+  if (args.noContracts === false) {
+    contractRootPaths.push(...(await buildForScope("contracts", args, hre)));
+  }
+
+  if (args.noTests === false) {
+    testRootPaths.push(...(await buildForScope("tests", args, hre)));
+  }
+
+  return { contractRootPaths, testRootPaths };
+};
+
+async function buildForScope(
+  scope: BuildScope,
+  { force, files, quiet, defaultBuildProfile }: BuildActionArguments,
+  { solidity, globalOptions }: HardhatRuntimeEnvironment,
+) {
+  // If no specific files are passed, it means a full compilation, i.e. all source files
+  const isFullCompilation = files.length === 0;
+
+  const rootPaths = [];
+
+  if (isFullCompilation) {
+    rootPaths.push(...(await solidity.getRootFilePaths({ scope })));
+  } else {
+    for (const file of files) {
+      if (isNpmRootPath(file)) {
+        rootPaths.push(file);
+      }
+
+      const rootPath = resolveFromRoot(process.cwd(), file);
+
+      if ((await solidity.getScope(rootPath)) !== scope) {
+        continue;
+      }
+
+      rootPaths.push(rootPath);
+    }
+
+    // If a file list has been passed but none match this scope, we don't run the build
+    if (rootPaths.length === 0) {
+      return [];
+    }
+  }
 
   const buildProfile = globalOptions.buildProfile ?? defaultBuildProfile;
 
@@ -33,14 +73,17 @@ const buildAction: NewTaskActionFunction<CompileActionArguments> = async (
     force,
     buildProfile,
     quiet,
+    scope,
   });
 
   throwIfSolidityBuildFailed(results);
 
   // If we recompiled the entire project we cleanup the artifacts
-  if (files.length === 0) {
-    await solidity.cleanupArtifacts(rootPaths);
+  if (isFullCompilation) {
+    await solidity.cleanupArtifacts(rootPaths, { scope });
   }
-};
+
+  return rootPaths;
+}
 
 export default buildAction;

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

@@ -1,6 +1,14 @@
 import type { HardhatUserConfig } from "../../../config.js";
-import type { HardhatConfig } from "../../../types/config.js";
+import type {
+  ConfigurationVariableResolver,
+  HardhatConfig,
+  ResolvedConfigurationVariable,
+} from "../../../types/config.js";
 import type { HardhatUserConfigValidationError } from "../../../types/hooks.js";
+import type {
+  SolidityTestForkingConfig,
+  SolidityTestUserConfig,
+} from "../../../types/test.js";
 
 import path from "node:path";
 
@@ -8,6 +16,8 @@ import { isObject } from "@nomicfoundation/hardhat-utils/lang";
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 import {
   conditionalUnionType,
+  sensitiveStringSchema,
+  sensitiveUrlSchema,
   validateUserConfigZodType,
 } from "@nomicfoundation/hardhat-zod-utils";
 import { z } from "zod";
@@ -49,9 +59,9 @@ const solidityTestUserConfigType = z.object({
     .optional(),
   forking: z
     .object({
-      url: z.string().optional(),
+      url: z.optional(sensitiveUrlSchema),
       blockNumber: z.bigint().optional(),
-      rpcEndpoints: z.record(z.string()).optional(),
+      rpcEndpoints: z.record(sensitiveStringSchema).optional(),
     })
     .optional(),
   invariant: z
@@ -88,6 +98,32 @@ const userConfigType = z.object({
     .optional(),
 });
 
+export function resolveSolidityTestForkingConfig(
+  forkingUserConfig: SolidityTestUserConfig["forking"],
+  resolveConfigurationVariable: ConfigurationVariableResolver,
+): SolidityTestForkingConfig | undefined {
+  if (forkingUserConfig === undefined) {
+    return undefined;
+  }
+
+  const resolvedRpcEndpoints: Record<string, ResolvedConfigurationVariable> =
+    {};
+  if (forkingUserConfig.rpcEndpoints !== undefined) {
+    for (const [name, url] of Object.entries(forkingUserConfig.rpcEndpoints)) {
+      resolvedRpcEndpoints[name] = resolveConfigurationVariable(url);
+    }
+  }
+
+  return {
+    ...forkingUserConfig,
+    url:
+      forkingUserConfig.url !== undefined
+        ? resolveConfigurationVariable(forkingUserConfig.url)
+        : undefined,
+    rpcEndpoints: resolvedRpcEndpoints,
+  };
+}
+
 export function validateSolidityTestUserConfig(
   userConfig: unknown,
 ): HardhatUserConfigValidationError[] {
@@ -97,6 +133,7 @@ export function validateSolidityTestUserConfig(
 export async function resolveSolidityTestUserConfig(
   userConfig: HardhatUserConfig,
   resolvedConfig: HardhatConfig,
+  resolveConfigurationVariable: ConfigurationVariableResolver,
 ): Promise<HardhatConfig> {
   let testsPath = userConfig.paths?.tests;
 
@@ -106,9 +143,15 @@ export async function resolveSolidityTestUserConfig(
 
   const defaultRpcCachePath = path.join(resolvedConfig.paths.cache, "edr");
 
+  const resolvedForking = resolveSolidityTestForkingConfig(
+    userConfig.test?.solidity?.forking,
+    resolveConfigurationVariable,
+  );
+
   const solidityTest = {
     rpcCachePath: defaultRpcCachePath,
     ...userConfig.test?.solidity,
+    forking: resolvedForking,
   };
 
   return {

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

@@ -34,14 +34,14 @@ export function solidityTestConfigToRunOptions(
   return config;
 }
 
-export function solidityTestConfigToSolidityTestRunnerConfigArgs(
+export async function solidityTestConfigToSolidityTestRunnerConfigArgs(
   chainType: ChainType,
   projectRoot: string,
   config: SolidityTestConfig,
   verbosity: number,
   observability?: ObservabilityConfig,
   testPattern?: string,
-): SolidityTestRunnerConfigArgs {
+): Promise<SolidityTestRunnerConfigArgs> {
   const fsPermissions: PathPermission[] | undefined = [
     config.fsPermissions?.readWriteFile?.map((p) => ({
       access: FsAccessPermission.ReadWriteFile,
@@ -98,9 +98,22 @@ export function solidityTestConfigToSolidityTestRunnerConfigArgs(
 
   const blockDifficulty = config.prevRandao;
 
-  const ethRpcUrl = config.forking?.url;
+  let ethRpcUrl: string | undefined;
+  if (config.forking?.url !== undefined) {
+    ethRpcUrl = await config.forking.url.get();
+  }
+
   const forkBlockNumber = config.forking?.blockNumber;
-  const rpcEndpoints = config.forking?.rpcEndpoints;
+
+  let rpcEndpoints: Record<string, string> | undefined;
+  if (config.forking?.rpcEndpoints !== undefined) {
+    rpcEndpoints = {};
+    for (const [name, configValue] of Object.entries(
+      config.forking.rpcEndpoints,
+    )) {
+      rpcEndpoints[name] = await configValue.get();
+    }
+  }
 
   return {
     projectRoot,

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

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

package/src/internal/builtin-plugins/solidity-test/task-action.ts

@@ -1,6 +1,5 @@
 import type { RunOptions } from "./runner.js";
 import type { TestEvent } from "./types.js";
-import type { BuildOptions } from "../../../types/solidity/build-system.js";
 import type { NewTaskActionFunction } from "../../../types/tasks.js";
 import type {
   ObservabilityConfig,
@@ -14,18 +13,17 @@ import {
   assertHardhatInvariant,
   HardhatError,
 } from "@nomicfoundation/hardhat-errors";
-import { getAllFilesMatching } from "@nomicfoundation/hardhat-utils/fs";
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 import { createNonClosingWriter } from "@nomicfoundation/hardhat-utils/stream";
 
 import { HardhatRuntimeEnvironmentImplementation } from "../../core/hre.js";
 import { isSupportedChainType } from "../../edr/chain-type.js";
+import { ArtifactManagerImplementation } from "../artifacts/artifact-manager.js";
 import {
   markTestRunDone,
   markTestRunStart,
   markTestWorkerDone,
 } from "../coverage/helpers.js";
-import { throwIfSolidityBuildFailed } from "../solidity/build-results.js";
 
 import { getEdrArtifacts, getBuildInfos } from "./edr-artifacts.js";
 import {
@@ -49,8 +47,6 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   { testFiles, chainType, grep, noCompile, verbosity },
   hre,
 ) => {
-  let rootFilePaths: string[];
-
   if (!isSupportedChainType(chainType)) {
     throw new HardhatError(
       HardhatError.ERRORS.CORE.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
@@ -62,48 +58,25 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
     );
   }
 
-  // NOTE: We run the compile task first to ensure all the artifacts for them are generated
-  // Then, we compile just the test sources. We don't do it in one go because the user
-  // is likely to use different compilation options for the tests and the sources.
-  if (noCompile === false) {
-    await hre.tasks.getTask("compile").run();
-  }
+  // Run the compile task for test files
 
-  if (testFiles.length > 0) {
-    rootFilePaths = testFiles.map((f) =>
-      resolveFromRoot(hre.config.paths.root, f),
-    );
-  } else {
-    // NOTE: A test file is either a file with a `.sol` extension in the `tests.solidity`
-    // directory or a file with a `.t.sol` extension in the `sources.solidity` directory
-    rootFilePaths = (
-      await Promise.all([
-        getAllFilesMatching(hre.config.paths.tests.solidity, (f) =>
-          f.endsWith(".sol"),
-        ),
-        ...hre.config.paths.sources.solidity.map(async (dir) => {
-          return getAllFilesMatching(dir, (f) => f.endsWith(".t.sol"));
-        }),
-      ])
-    ).flat(1);
-  }
-  // NOTE: We remove duplicates in case there is an intersection between
-  // the tests.solidity paths and the sources paths
-  rootFilePaths = Array.from(new Set(rootFilePaths));
-
-  // NOTE: We are not skipping the test compilation even if the noCompile flag is set
-  // because the user cannot run test compilation outside of the test task yet.
-  // TODO: Allow users to run test compilation outside of the test task.
-  const buildOptions: BuildOptions = {
-    force: false,
-    buildProfile: hre.globalOptions.buildProfile ?? "default",
-    quiet: true,
-  };
-  const results = await hre.solidity.build(rootFilePaths, buildOptions);
-  throwIfSolidityBuildFailed(results);
+  const { testRootPaths }: { testRootPaths: string[] } = await hre.tasks
+    .getTask("compile")
+    .run({
+      quiet: true,
+      force: false,
+      files: testFiles,
+      noContracts: noCompile,
+    });
+
+  const artifactsDirectory = await hre.solidity.getArtifactsDirectory("tests");
+
+  const artifactsManager = new ArtifactManagerImplementation(
+    artifactsDirectory,
+  );
 
-  const buildInfos = await getBuildInfos(hre.artifacts);
-  const edrArtifacts = await getEdrArtifacts(hre.artifacts);
+  const buildInfos = await getBuildInfos(artifactsManager);
+  const edrArtifacts = await getEdrArtifacts(artifactsManager);
 
   const sourceNameToUserSourceName = new Map(
     edrArtifacts.map(({ userSourceName, edrAtifact }) => [
@@ -114,7 +87,7 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
 
   edrArtifacts.forEach(({ userSourceName, edrAtifact }) => {
     if (
-      rootFilePaths.includes(
+      testRootPaths.includes(
         resolveFromRoot(hre.config.paths.root, userSourceName),
       ) &&
       isTestSuiteArtifact(edrAtifact)
@@ -125,7 +98,7 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
 
   const testSuiteIds = edrArtifacts
     .filter(({ userSourceName }) =>
-      rootFilePaths.includes(
+      testRootPaths.includes(
         resolveFromRoot(hre.config.paths.root, userSourceName),
       ),
     )
@@ -160,7 +133,7 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   }
 
   const config: SolidityTestRunnerConfigArgs =
-    solidityTestConfigToSolidityTestRunnerConfigArgs(
+    await solidityTestConfigToSolidityTestRunnerConfigArgs(
       chainType,
       hre.config.paths.root,
       solidityTestConfig,

package/src/internal/builtin-plugins/solidity-test/type-extensions.ts

@@ -1,4 +1,8 @@
 import "../../../types/config.js";
+import type {
+  SensitiveString,
+  ResolvedConfigurationVariable,
+} from "../../../types/config.js";
 
 declare module "../../../types/config.js" {
   export interface TestPathsUserConfig {
@@ -11,7 +15,7 @@ declare module "../../../types/config.js" {
 }
 
 declare module "../../../types/test.js" {
-  export interface SolidityTestUserConfig {
+  export interface SolidityTestConfigBase {
     timeout?: number;
     fsPermissions?: {
       readWriteFile?: string[];
@@ -33,12 +37,6 @@ declare module "../../../types/test.js" {
     prevRandao?: bigint;
     blockGasLimit?: bigint | false;
 
-    forking?: {
-      url?: string;
-      blockNumber?: bigint;
-      rpcEndpoints?: Record<string, string>;
-    };
-
     fuzz?: {
       failurePersistDir?: string;
       failurePersistFile?: string;
@@ -62,13 +60,29 @@ declare module "../../../types/test.js" {
     };
   }
 
+  export interface SolidityTestForkingUserConfig {
+    url?: SensitiveString;
+    blockNumber?: bigint;
+    rpcEndpoints?: Record<string, SensitiveString>;
+  }
+
+  export interface SolidityTestUserConfig extends SolidityTestConfigBase {
+    forking?: SolidityTestForkingUserConfig;
+  }
+
   export interface HardhatTestUserConfig {
     solidity?: SolidityTestUserConfig;
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface -- This could be an extension point
-  export interface SolidityTestConfig extends SolidityTestUserConfig {}
+  export interface SolidityTestForkingConfig {
+    url?: ResolvedConfigurationVariable;
+    blockNumber?: bigint;
+    rpcEndpoints?: Record<string, ResolvedConfigurationVariable>;
+  }
 
+  export interface SolidityTestConfig extends SolidityTestConfigBase {
+    forking?: SolidityTestForkingConfig;
+  }
   export interface HardhatTestConfig {
     solidity: SolidityTestConfig;
   }

package/src/internal/core/hook-manager.ts

@@ -13,6 +13,7 @@ import type { HardhatPlugin } from "../../types/plugins.js";
 import type { LastParameter, Return } from "../../types/utils.js";
 
 import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 import { AsyncMutex } from "@nomicfoundation/hardhat-utils/synchronization";
 
 import { detectPluginNpmDependencyProblems } from "./plugins/detect-plugin-npm-dependency-problems.js";
@@ -297,7 +298,14 @@ export class HookManagerImplementation implements HookManager {
           try {
             factory = (await hookHandlerCategoryFactory()).default;
           } catch (error) {
-            await detectPluginNpmDependencyProblems(this.#projectRoot, plugin);
+            ensureError(error);
+
+            await detectPluginNpmDependencyProblems(
+              this.#projectRoot,
+              plugin,
+              error,
+            );
+
             throw error;
           }
 

package/src/internal/core/hre.ts

@@ -12,7 +12,11 @@ import type {
   GlobalOptions,
   GlobalOptionDefinitions,
 } from "../../types/global-options.js";
-import type { HookContext, HookManager } from "../../types/hooks.js";
+import type {
+  HardhatUserConfigValidationError,
+  HookContext,
+  HookManager,
+} from "../../types/hooks.js";
 import type { HardhatRuntimeEnvironment } from "../../types/hre.js";
 import type { NetworkManager } from "../../types/network.js";
 import type { HardhatPlugin } from "../../types/plugins.js";
@@ -25,6 +29,8 @@ import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import { findClosestPackageRoot } from "@nomicfoundation/hardhat-utils/package";
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 
+import { getEdrVersion, getHardhatVersion } from "../utils/package.js";
+
 import { validateUserConfig } from "./config-validation.js";
 import { resolveConfigurationVariable } from "./configuration-variables.js";
 import {
@@ -62,26 +68,31 @@ export class HardhatRuntimeEnvironmentImplementation
       unsafeOptions?.resolvedPlugins ??
       (await resolvePluginList(resolvedProjectRoot, inputUserConfig.plugins));
 
+    const [hardhatVersion, edrVersion] = await Promise.all([
+      getHardhatVersion(),
+      getEdrVersion(),
+    ]);
+
+    const versions = {
+      hardhat: hardhatVersion,
+      edr: edrVersion,
+    };
     const hooks = new HookManagerImplementation(
       resolvedProjectRoot,
       resolvedPlugins,
     );
 
-    // extend user config:
-    const extendedUserConfig = await runUserConfigExtensions(
-      hooks,
+    const configResolutionResult = await resolveUserConfigToHardhatConfig(
       inputUserConfig,
-    );
-
-    // validate config
-    const userConfigValidationErrors = await validateUserConfig(
       hooks,
-      extendedUserConfig,
+      resolvedProjectRoot,
+      userProvidedGlobalOptions.config,
+      resolvedPlugins,
     );
 
-    if (userConfigValidationErrors.length > 0) {
+    if (!configResolutionResult.success) {
       throw new HardhatError(HardhatError.ERRORS.CORE.GENERAL.INVALID_CONFIG, {
-        errors: `\t${userConfigValidationErrors
+        errors: `\t${configResolutionResult.userConfigValidationErrors
           .map(
             (error) =>
               `* Config error in config.${error.path.join(".")}: ${error.message}`,
@@ -90,26 +101,7 @@ export class HardhatRuntimeEnvironmentImplementation
       });
     }
 
-    // Resolve config
-
-    const resolvedConfig = await resolveUserConfig(
-      resolvedProjectRoot,
-      userProvidedGlobalOptions.config,
-      hooks,
-      resolvedPlugins,
-      extendedUserConfig,
-    );
-
-    // We override the plugins and the project root, as we want to prevent
-    // the plugins from changing them
-    const config: HardhatConfig = {
-      ...resolvedConfig,
-      paths: {
-        ...resolvedConfig.paths,
-        root: resolvedProjectRoot,
-      },
-      plugins: resolvedPlugins,
-    };
+    const { config, extendedUserConfig } = configResolutionResult;
 
     const globalOptionDefinitions =
       unsafeOptions?.globalOptionDefinitions ??
@@ -122,7 +114,6 @@ export class HardhatRuntimeEnvironmentImplementation
 
     // Set the HookContext in the hook manager so that non-config hooks can
     // use it
-
     const interruptions = new UserInterruptionManagerImplementation(hooks);
 
     const hre = new HardhatRuntimeEnvironmentImplementation(
@@ -131,6 +122,7 @@ export class HardhatRuntimeEnvironmentImplementation
       hooks,
       interruptions,
       globalOptions,
+      versions,
       globalOptionDefinitions,
     );
 
@@ -160,6 +152,10 @@ export class HardhatRuntimeEnvironmentImplementation
     public readonly hooks: HookManager,
     public readonly interruptions: UserInterruptionManager,
     public readonly globalOptions: GlobalOptions,
+    public readonly versions: {
+      readonly hardhat: string;
+      readonly edr: string;
+    },
     globalOptionDefinitions: GlobalOptionDefinitions,
   ) {
     this.tasks = new TaskManagerImplementation(this, globalOptionDefinitions);
@@ -180,6 +176,80 @@ export async function resolveProjectRoot(
   return findClosestPackageRoot(absolutePathWithinProject ?? process.cwd());
 }
 
+/**
+ * Runs the provided Hardhat user config through the resolution process,
+ * invoking relevant plugin hooks (both internal and external) to extend
+ * and transform the config into a full HardhatConfig.
+ *
+ * @param hooks - The HookManager used to run config extension and validation
+ * hooks.
+ * @param inputUserConfig - The initial user provided Hardhat config object.
+ * @param resolvedProjectRoot - The project root path.
+ * @param userProvidedConfigPath - The user provided Hardhat config file path.
+ * @param resolvedPlugins - The list of plugins, we do not want the plugins
+ * overwriting them so we re-add them to the final HardhatConfig.
+ * @returns Either an object containing the resolved HardhatConfig and the
+ * extended version of the user config, or a list of validation errors.
+ */
+export async function resolveUserConfigToHardhatConfig(
+  inputUserConfig: HardhatUserConfig,
+  hooks: HookManager,
+  resolvedProjectRoot: string,
+  userProvidedConfigPath: string | undefined,
+  resolvedPlugins: HardhatPlugin[],
+): Promise<
+  | {
+      success: true;
+      config: HardhatConfig;
+      extendedUserConfig: HardhatUserConfig;
+    }
+  | {
+      success: false;
+      userConfigValidationErrors: HardhatUserConfigValidationError[];
+    }
+> {
+  // extend user config:
+  const extendedUserConfig = await runUserConfigExtensions(
+    hooks,
+    inputUserConfig,
+  );
+
+  // validate config
+  const userConfigValidationErrors = await validateUserConfig(
+    hooks,
+    extendedUserConfig,
+  );
+
+  if (userConfigValidationErrors.length > 0) {
+    return {
+      success: false,
+      userConfigValidationErrors,
+    };
+  }
+
+  // Resolve config
+  const resolvedConfig = await resolveUserConfig(
+    resolvedProjectRoot,
+    userProvidedConfigPath,
+    hooks,
+    resolvedPlugins,
+    extendedUserConfig,
+  );
+
+  // We override the plugins and the project root, as we want to prevent
+  // the plugins from changing them
+  const config: HardhatConfig = {
+    ...resolvedConfig,
+    paths: {
+      ...resolvedConfig.paths,
+      root: resolvedProjectRoot,
+    },
+    plugins: resolvedPlugins,
+  };
+
+  return { success: true, config, extendedUserConfig };
+}
+
 async function runUserConfigExtensions(
   hooks: HookManager,
   config: HardhatUserConfig,