hardhat 3.0.5 → 3.0.7

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,

package/src/internal/core/plugins/resolve-plugin-list.ts

@@ -28,7 +28,7 @@ async function reverseTopologicalSort(
   plugins: HardhatPlugin[],
 ): Promise<HardhatPlugin[]> {
   const visitedPlugins: Map<string, HardhatPlugin> = new Map();
-  const result: HardhatPlugin[] = [];
+  const resolvedPlugins: HardhatPlugin[] = [];
 
   async function dfs(plugin: HardhatPlugin) {
     const visited = visitedPlugins.get(plugin.id);
@@ -69,12 +69,66 @@ async function reverseTopologicalSort(
       }
     }
 
-    result.push(plugin);
+    resolvedPlugins.push(plugin);
   }
 
   for (const plugin of plugins) {
     await dfs(plugin);
   }
 
-  return result;
+  // Resolve conditional dependencies iteratively
+  let lastResolvedCount = -1;
+
+  while (resolvedPlugins.length !== lastResolvedCount) {
+    lastResolvedCount = resolvedPlugins.length;
+
+    for (const plugin of resolvedPlugins) {
+      if (plugin.conditionalDependencies === undefined) {
+        continue;
+      }
+
+      for (const conditionalDependency of plugin.conditionalDependencies) {
+        // Check all condition plugins are installed
+        let conditionModules;
+        try {
+          conditionModules = await Promise.all(
+            conditionalDependency.condition(),
+          );
+        } catch (_error) {
+          continue;
+        }
+
+        // Check all condition plugins are loaded
+        if (
+          conditionModules.some(
+            (conditionPlugin) =>
+              !resolvedPlugins.includes(conditionPlugin.default),
+          )
+        ) {
+          continue;
+        }
+
+        // Load the conditional dependency
+        let pluginModule;
+        try {
+          pluginModule = await conditionalDependency.plugin();
+        } catch (error) {
+          ensureError(error);
+          await detectPluginNpmDependencyProblems(projectRoot, plugin);
+
+          throw new HardhatError(
+            HardhatError.ERRORS.CORE.PLUGINS.PLUGIN_DEPENDENCY_FAILED_LOAD,
+            {
+              pluginId: plugin.id,
+            },
+            error,
+          );
+        }
+
+        await dfs(pluginModule.default);
+      }
+    }
+  }
+
+  return resolvedPlugins;
 }

package/src/internal/utils/package.ts

@@ -1,9 +1,16 @@
 import type { PackageJson } from "@nomicfoundation/hardhat-utils/package";
 
-import { readClosestPackageJson } from "@nomicfoundation/hardhat-utils/package";
+import { readFile } from "node:fs/promises";
+
+import {
+  findClosestPackageRoot,
+  findDependencyPackageJson,
+  readClosestPackageJson,
+} from "@nomicfoundation/hardhat-utils/package";
 
 let cachedHardhatVersion: string | undefined;
 let cachedLatestHardhatVersion: string | undefined;
+let cachedEdrVersion: string | undefined;
 
 export async function getHardhatVersion(): Promise<string> {
   if (cachedHardhatVersion !== undefined) {
@@ -19,6 +26,29 @@ export async function getHardhatVersion(): Promise<string> {
   return packageJson.version;
 }
 
+export async function getEdrVersion(): Promise<string> {
+  if (cachedEdrVersion !== undefined) {
+    return cachedEdrVersion;
+  }
+
+  const hardhatRoot = await findClosestPackageRoot(import.meta.url);
+
+  const edrPackageJsonPath = await findDependencyPackageJson(
+    hardhatRoot,
+    "@nomicfoundation/edr",
+  );
+
+  if (edrPackageJsonPath === undefined) {
+    return "";
+  }
+
+  const rawPackageJson = await readFile(edrPackageJsonPath, "utf-8");
+  const edrPackageJson: PackageJson = JSON.parse(rawPackageJson);
+  cachedEdrVersion = edrPackageJson.version;
+
+  return cachedEdrVersion;
+}
+
 export async function getLatestHardhatVersion(): Promise<string> {
   const { getRequest } = await import("@nomicfoundation/hardhat-utils/request");
 

package/src/types/hre.ts

@@ -11,6 +11,10 @@ export interface HardhatRuntimeEnvironment {
   readonly userConfig: HardhatUserConfig;
   readonly globalOptions: GlobalOptions;
   readonly interruptions: UserInterruptionManager;
+  readonly versions: {
+    readonly hardhat: string;
+    readonly edr: string;
+  };
   // These fields are defined using module agumentation despite being part of
   // Hardhat's core:
   // readonly hooks: HookManager;

package/src/types/network.ts

@@ -52,6 +52,21 @@ export interface NetworkManager {
   connect<ChainTypeT extends ChainType | string = DefaultChainType>(
     networkOrParams?: NetworkConnectionParams<ChainTypeT> | string,
   ): Promise<NetworkConnection<ChainTypeT>>;
+
+  /**
+   * Spawns an Ethereum JSON-RPC server listening on HTTP and Websocket.
+   *
+   * @param networkOrParams The network name or connection parameters.
+   * @param hostname Hostname to bind the server to. Defaults to localhost or 0.0.0.0 on docker.
+   * @param port Port to listen on. Defaults to a random available port.
+   *
+   * @return A `JsonRpcServer` instance that can be started with {@link JsonRpcServer.listen}.
+   */
+  createServer(
+    networkOrParams?: NetworkConnectionParams | string,
+    hostname?: string,
+    port?: number,
+  ): Promise<JsonRpcServer>;
 }
 
 export interface NetworkConnection<
@@ -65,3 +80,33 @@ export interface NetworkConnection<
 
   close(): Promise<void>;
 }
+
+/**
+ * An Ethereum JSON-RPC server that accepts connections via HTTP and websocket.
+ */
+export interface JsonRpcServer {
+  /**
+   * Starts the Ethereum JSON-RPC server.
+   *
+   * @returns returns the address and port the server is listening on.
+   */
+  listen(): Promise<{ address: string; port: number }>;
+
+  /**
+   * Closes the Ethereum JSON-RPC server.
+   *
+   * @returns A promise that resolves once shutdown is finished.
+   */
+  close(): Promise<void>;
+
+  /**
+   * Resolves once the Ethereum JSON-RPC server has been
+   * closed, including its underlying HTTP and Websocket sockets.
+   *
+   * Useful for awaiting a shutdown that was initiated elsewhere.
+   *
+   * @returns A promise that resolves once the server and
+   *   its sockets have been closed.
+   */
+  afterClosed(): Promise<void>;
+}

package/src/types/plugins.ts

@@ -39,6 +39,11 @@ export interface HardhatPlugin {
    */
   dependencies?: () => Array<Promise<{ default: HardhatPlugin }>>;
 
+  conditionalDependencies?: Array<{
+    condition: () => Array<Promise<{ default: HardhatPlugin }>>;
+    plugin: () => Promise<{ default: HardhatPlugin }>;
+  }>;
+
   /**
    * An object with the different hook handlers that this plugin defines.
    *

package/src/types/solidity/build-system.ts

@@ -38,18 +38,18 @@ export interface BuildOptions {
   concurrency?: number;
 
   /**
-   * An array of remappings provided by the user.
+   * If `true`, the build process doesn't print any output.
    */
-  userProvidedRemappings?: string[];
+  quiet?: boolean;
 
   /**
-   * If `true`, the build process doesn't print any output.
+   * Whether to compile contracts or tests. Defaults to contracts
    */
-  quiet?: boolean;
+  scope?: BuildScope;
 }
 
 /**
- * The options of the `getBuildInfos` method.
+ * The options of the `getCompilationJobs` method.
  *
  * Note that this option object includes a `quiet` property, as this process
  * may require downloading compilers, and potentially printing some output.
@@ -196,7 +196,12 @@ export interface SolidityBuildSystem {
    *
    * @returns An array of root file paths.
    */
-  getRootFilePaths(): Promise<string[]>;
+  getRootFilePaths(options?: { scope?: BuildScope }): Promise<string[]>;
+
+  /**
+   * Given the filesystem path for a source file, returns the build scope
+   */
+  getScope(fsPath: string): Promise<BuildScope>;
 
   /**
    * Builds the provided files, generating their compilation artifacts.
@@ -272,6 +277,7 @@ export interface SolidityBuildSystem {
   emitArtifacts(
     compilationJob: CompilationJob,
     compilerOutput: CompilerOutput,
+    options?: { scope?: BuildScope },
   ): Promise<EmitArtifactsResult>;
 
   /**
@@ -287,7 +293,10 @@ export interface SolidityBuildSystem {
 
    * @param rootFilePaths All the root files of the project.
    */
-  cleanupArtifacts(rootFilePaths: string[]): Promise<void>;
+  cleanupArtifacts(
+    rootFilePaths: string[],
+    options?: { scope?: BuildScope },
+  ): Promise<void>;
 
   /**
    * Compiles a build info, returning the output of the compilation, verbatim,
@@ -301,4 +310,11 @@ export interface SolidityBuildSystem {
     buildInfo: SolidityBuildInfo,
     options?: CompileBuildInfoOptions,
   ): Promise<CompilerOutput>;
+
+  /**
+   * Gets the artifacts directory for a given target (contracts/tests)
+   */
+  getArtifactsDirectory(scope: BuildScope): Promise<string>;
 }
+
+export type BuildScope = "contracts" | "tests";

package/templates/hardhat-3/01-node-test-runner-viem/package.json

@@ -5,7 +5,7 @@
   "description": "A TypeScript Hardhat project using Node Test Runner and Viem",
   "type": "module",
   "devDependencies": {
-    "hardhat": "workspace:^3.0.0",
+    "hardhat": "workspace:^3.0.7",
     "@nomicfoundation/hardhat-toolbox-viem": "workspace:^5.0.0",
     "@nomicfoundation/hardhat-ignition": "workspace:^3.0.0",
     "@types/node": "^22.8.5",
@@ -16,11 +16,11 @@
   "peerDependencies": {
     "@nomicfoundation/hardhat-ignition-viem": "workspace:^3.0.0",
     "@nomicfoundation/hardhat-keystore": "workspace:^3.0.0",
-    "@nomicfoundation/hardhat-network-helpers": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-network-helpers": "workspace:^3.0.1",
     "@nomicfoundation/hardhat-node-test-runner": "workspace:^3.0.0",
     "@nomicfoundation/hardhat-viem": "workspace:^3.0.0",
     "@nomicfoundation/hardhat-viem-assertions": "workspace:^3.0.0",
-    "@nomicfoundation/hardhat-verify": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-verify": "workspace:^3.0.3",
     "@nomicfoundation/ignition-core": "workspace:^3.0.0"
   }
 }

package/templates/hardhat-3/02-mocha-ethers/package.json

@@ -5,7 +5,7 @@
   "description": "A TypeScript Hardhat project using Mocha and Ethers.js",
   "type": "module",
   "devDependencies": {
-    "hardhat": "workspace:^3.0.0",
+    "hardhat": "workspace:^3.0.7",
     "@nomicfoundation/hardhat-toolbox-mocha-ethers": "workspace:^3.0.0",
     "@nomicfoundation/hardhat-ignition": "workspace:^3.0.0",
     "@types/chai": "^4.2.0",
@@ -19,15 +19,15 @@
     "typescript": "~5.8.0"
   },
   "peerDependencies": {
-    "@nomicfoundation/hardhat-ethers": "workspace:^4.0.0",
+    "@nomicfoundation/hardhat-ethers": "workspace:^4.0.2",
     "@nomicfoundation/hardhat-ethers-chai-matchers": "workspace:^3.0.0",
     "@nomicfoundation/hardhat-ignition": "workspace:^3.0.0",
     "@nomicfoundation/hardhat-ignition-ethers": "workspace:^3.0.0",
     "@nomicfoundation/hardhat-keystore": "workspace:^3.0.0",
     "@nomicfoundation/hardhat-mocha": "workspace:^3.0.0",
-    "@nomicfoundation/hardhat-network-helpers": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-network-helpers": "workspace:^3.0.1",
     "@nomicfoundation/hardhat-typechain": "workspace:^3.0.0",
-    "@nomicfoundation/hardhat-verify": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-verify": "workspace:^3.0.3",
     "@nomicfoundation/ignition-core": "workspace:^3.0.0"
   }
 }