hardhat 3.0.5 → 3.0.7

package/src/internal/builtin-plugins/network-manager/network-manager.ts

@@ -2,36 +2,40 @@ import type { CoverageConfig } from "./edr/types/coverage.js";
 import type { ArtifactManager } from "../../../types/artifacts.js";
 import type {
   ChainDescriptorsConfig,
+  HardhatUserConfig,
   NetworkConfig,
   NetworkConfigOverride,
-  NetworkUserConfig,
 } from "../../../types/config.js";
 import type { HookManager } from "../../../types/hooks.js";
 import type {
   ChainType,
   DefaultChainType,
+  JsonRpcServer,
   NetworkConnection,
   NetworkConnectionParams,
   NetworkManager,
 } from "../../../types/network.js";
+import type { HardhatPlugin } from "../../../types/plugins.js";
 import type {
   EthereumProvider,
   JsonRpcRequest,
   JsonRpcResponse,
 } from "../../../types/providers.js";
 
-import { HardhatError } from "@nomicfoundation/hardhat-errors";
-import { readBinaryFile } from "@nomicfoundation/hardhat-utils/fs";
+import {
+  HardhatError,
+  assertHardhatInvariant,
+} from "@nomicfoundation/hardhat-errors";
+import { exists, readBinaryFile } from "@nomicfoundation/hardhat-utils/fs";
 import { deepMerge } from "@nomicfoundation/hardhat-utils/lang";
 
-import { resolveConfigurationVariable } from "../../core/configuration-variables.js";
+import { resolveUserConfigToHardhatConfig } from "../../core/hre.js";
 import { isSupportedChainType } from "../../edr/chain-type.js";
+import { JsonRpcServerImplementation } from "../node/json-rpc/server.js";
 
-import { resolveEdrNetwork, resolveHttpNetwork } from "./config-resolution.js";
 import { EdrProvider } from "./edr/edr-provider.js";
 import { HttpProvider } from "./http-provider.js";
 import { NetworkConnectionImplementation } from "./network-connection.js";
-import { validateNetworkConfigOverride } from "./type-validation.js";
 
 export type JsonRpcRequestWrapperFunction = (
   request: JsonRpcRequest,
@@ -44,8 +48,10 @@ export class NetworkManagerImplementation implements NetworkManager {
   readonly #networkConfigs: Readonly<Record<string, Readonly<NetworkConfig>>>;
   readonly #hookManager: Readonly<HookManager>;
   readonly #artifactsManager: Readonly<ArtifactManager>;
-  readonly #userConfigNetworks: Readonly<Record<string, NetworkUserConfig>>;
+  readonly #userConfig: Readonly<HardhatUserConfig>;
   readonly #chainDescriptors: Readonly<ChainDescriptorsConfig>;
+  readonly #userProvidedConfigPath: Readonly<string | undefined>;
+  readonly #projectRoot: string;
 
   #nextConnectionId = 0;
 
@@ -55,16 +61,20 @@ export class NetworkManagerImplementation implements NetworkManager {
     networkConfigs: Record<string, NetworkConfig>,
     hookManager: HookManager,
     artifactsManager: ArtifactManager,
-    userConfigNetworks: Record<string, NetworkUserConfig> | undefined,
+    userConfig: HardhatUserConfig,
     chainDescriptors: ChainDescriptorsConfig,
+    userProvidedConfigPath: string | undefined,
+    projectRoot: string,
   ) {
     this.#defaultNetwork = defaultNetwork;
     this.#defaultChainType = defaultChainType;
     this.#networkConfigs = networkConfigs;
     this.#hookManager = hookManager;
     this.#artifactsManager = artifactsManager;
-    this.#userConfigNetworks = userConfigNetworks ?? {};
+    this.#userConfig = userConfig;
     this.#chainDescriptors = chainDescriptors;
+    this.#userProvidedConfigPath = userProvidedConfigPath;
+    this.#projectRoot = projectRoot;
   }
 
   public async connect<
@@ -97,6 +107,23 @@ export class NetworkManagerImplementation implements NetworkManager {
     return networkConnection as NetworkConnection<ChainTypeT>;
   }
 
+  public async createServer(
+    networkOrParams: NetworkConnectionParams | string = "default",
+    _hostname?: string,
+    port?: number,
+  ): Promise<JsonRpcServer> {
+    const insideDocker = await exists("/.dockerenv");
+    const hostname = _hostname ?? (insideDocker ? "0.0.0.0" : "127.0.0.1");
+
+    const { provider } = await this.connect(networkOrParams);
+
+    return new JsonRpcServerImplementation({
+      hostname,
+      port,
+      provider,
+    });
+  }
+
   async #initializeNetworkConnection<ChainTypeT extends ChainType | string>(
     networkName?: string,
     chainType?: ChainTypeT,
@@ -113,57 +140,10 @@ export class NetworkManagerImplementation implements NetworkManager {
       );
     }
 
-    let resolvedNetworkConfigOverride: NetworkConfig | undefined;
-    if (networkConfigOverride !== undefined) {
-      if (
-        "type" in networkConfigOverride &&
-        networkConfigOverride.type !==
-          this.#networkConfigs[resolvedNetworkName].type
-      ) {
-        throw new HardhatError(
-          HardhatError.ERRORS.CORE.NETWORK.INVALID_CONFIG_OVERRIDE,
-          {
-            errors: `\t* The type of the network cannot be changed.`,
-          },
-        );
-      }
-
-      const newConfig = deepMerge(
-        this.#userConfigNetworks[resolvedNetworkName],
-        networkConfigOverride,
-      );
-
-      // As normalizeNetworkConfigOverride is not type-safe, we validate the
-      // normalized network config override immediately after normalizing it.
-      const validationErrors = await validateNetworkConfigOverride(newConfig);
-      if (validationErrors.length > 0) {
-        throw new HardhatError(
-          HardhatError.ERRORS.CORE.NETWORK.INVALID_CONFIG_OVERRIDE,
-          {
-            errors: `\t${validationErrors
-              .map((error) =>
-                error.path.length > 0
-                  ? `* Error in ${error.path.join(".")}: ${error.message}`
-                  : `* ${error.message}`,
-              )
-              .join("\n\t")}`,
-          },
-        );
-      }
-
-      resolvedNetworkConfigOverride =
-        newConfig.type === "http"
-          ? resolveHttpNetwork(newConfig, (strOrConfigVar) =>
-              resolveConfigurationVariable(this.#hookManager, strOrConfigVar),
-            )
-          : resolveEdrNetwork(newConfig, "", (strOrConfigVar) =>
-              resolveConfigurationVariable(this.#hookManager, strOrConfigVar),
-            );
-    }
-
-    const resolvedNetworkConfig =
-      resolvedNetworkConfigOverride ??
-      this.#networkConfigs[resolvedNetworkName];
+    const resolvedNetworkConfig = await this.#resolveNetworkConfig(
+      resolvedNetworkName,
+      networkConfigOverride,
+    );
 
     /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     -- Cast to ChainTypeT because we know it's valid */
@@ -293,6 +273,88 @@ export class NetworkManagerImplementation implements NetworkManager {
     );
   }
 
+  /**
+   * Resolve the network connection configuration settings for the network name
+   * and taking into account any configuration overrides.
+   *
+   * @param resolvedNetworkName the network name for selecting the appropriate network config
+   * @param networkConfigOverride any network config options to override the
+   *   defaults for the named network
+   * @returns a valid network configuration including any config additions from
+   *   plugins
+   */
+  async #resolveNetworkConfig(
+    resolvedNetworkName: string,
+    networkConfigOverride: NetworkConfigOverride | undefined,
+  ): Promise<NetworkConfig> {
+    if (networkConfigOverride === undefined) {
+      return this.#networkConfigs[resolvedNetworkName];
+    }
+
+    if (
+      "type" in networkConfigOverride &&
+      networkConfigOverride.type !==
+        this.#networkConfigs[resolvedNetworkName].type
+    ) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.NETWORK.INVALID_CONFIG_OVERRIDE,
+        {
+          errors: `\t* The type of the network cannot be changed.`,
+        },
+      );
+    }
+
+    const newConfig = deepMerge(this.#userConfig, {
+      networks: {
+        [resolvedNetworkName]: networkConfigOverride,
+      },
+    });
+
+    // This is safe, the plugins used in resolution are registered
+    // with the hook handler, this property is only used for
+    // ensuring the original plugins are available at the end
+    // of resolution.
+    const resolvedPlugins: HardhatPlugin[] = [];
+
+    const configResolutionResult = await resolveUserConfigToHardhatConfig(
+      newConfig,
+      this.#hookManager,
+      this.#projectRoot,
+      this.#userProvidedConfigPath,
+      resolvedPlugins,
+    );
+
+    if (!configResolutionResult.success) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.NETWORK.INVALID_CONFIG_OVERRIDE,
+        {
+          errors: `\t${configResolutionResult.userConfigValidationErrors
+            .map((error) => {
+              const path = this.#normaliseErrorPathToNetworkConfig(
+                error.path,
+                resolvedNetworkName,
+              );
+
+              return path.length > 0
+                ? `* Error in ${path.join(".")}: ${error.message}`
+                : `* ${error.message}`;
+            })
+            .join("\n\t")}`,
+        },
+      );
+    }
+
+    const resolvedNetworkConfigOverride =
+      configResolutionResult.config.networks[resolvedNetworkName];
+
+    assertHardhatInvariant(
+      resolvedNetworkConfigOverride !== undefined,
+      "The overridden network config should translate through the hook resolution of user config",
+    );
+
+    return resolvedNetworkConfigOverride;
+  }
+
   async #getBuildInfosAndOutputsAsBuffers(): Promise<
     Array<{ buildInfo: Uint8Array; output: Uint8Array }>
   > {
@@ -315,4 +377,19 @@ export class NetworkManagerImplementation implements NetworkManager {
 
     return results;
   }
+
+  #normaliseErrorPathToNetworkConfig(
+    path: Array<string | number>,
+    resolvedNetworkName: string,
+  ): Array<string | number> {
+    if (path[0] !== undefined && path[0] === "networks") {
+      path = path.slice(1);
+    }
+
+    if (path[0] !== undefined && path[0] === resolvedNetworkName) {
+      path = path.slice(1);
+    }
+
+    return path;
+  }
 }

package/src/internal/builtin-plugins/network-manager/type-validation.ts

@@ -404,8 +404,8 @@ const userConfigSchema = z.object({
 
 const networkConfigOverrideSchema = z
   .discriminatedUnion("type", [
-    httpNetworkUserConfigSchema.strict(),
-    edrNetworkUserConfigSchema.strict(),
+    httpNetworkUserConfigSchema.passthrough(),
+    edrNetworkUserConfigSchema.passthrough(),
   ])
   .superRefine(refineEdrNetworkUserConfig);
 

package/src/internal/builtin-plugins/node/artifacts/build-info-watcher.ts

@@ -0,0 +1,82 @@
+import type { FSWatcher } from "chokidar";
+
+import path from "node:path";
+
+import debug from "debug";
+
+export type BuildInfoWatcher = FSWatcher;
+export type BuildInfoHandler = (buildId: string) => Promise<void>;
+
+const log = debug("hardhat:core:tasks:node:artifacts");
+
+const STABILITY_THRESHOLD = 250;
+const POLL_INTERVAL = 50;
+
+/**
+ * `listener` is a callback function invoked when a new file is added to the
+ * build info directory. It processes the received event to check whether it is
+ * for a build info file.
+ *
+ * If so, it extracts the build id from it and triggers the provided handler
+ * with the extracted build id as an argument. Any errors encountered during
+ * handler execution are captured and logged.
+ *
+ * @param absolutePath - The absolute path of the file added to the build info directory.
+ *
+ * This function is exposed for testing purposes only.
+ */
+export async function listener(
+  handler: BuildInfoHandler,
+  absolutePath: string,
+): Promise<void> {
+  log(`Detected change in ${absolutePath}`);
+
+  const isBuildInfoFile =
+    absolutePath.endsWith(".json") && !absolutePath.endsWith(".output.json");
+
+  if (!isBuildInfoFile) {
+    log(`File ${absolutePath} is not a build info file`);
+    return;
+  }
+
+  const buildId = path.basename(absolutePath).replace(".json", "");
+
+  await handler(buildId).catch(async (error: unknown) => {
+    log(
+      `There was a problem executing the handler for build ${buildId}.`,
+      error,
+    );
+  });
+}
+
+/**
+ * `watchBuildInfo` is a function that creates a watch over provided build info
+ * directory. If it encounters a build info file being added, it will trigger
+ * the provided handler, passing the build id as an argument. This allows for
+ * further processing or actions to be taken upon completion of a build.
+ */
+export async function watchBuildInfo(
+  buildInfoDirPath: string,
+  handler: BuildInfoHandler,
+): Promise<BuildInfoWatcher> {
+  const { watch } = await import("chokidar");
+
+  // NOTE: Deleting the build info directory while it is being watched will
+  // effectively cause the watcher to stop working.
+  // NOTE: We use chokidar's `awaitWriteFinish` option because we are certain
+  // the build info file will be added after the build info output file.
+  const watcher = watch(buildInfoDirPath, {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: STABILITY_THRESHOLD,
+      pollInterval: POLL_INTERVAL,
+    },
+  });
+
+  // NOTE: We listen only to the "add" event because the contents of the build info
+  // files identified by a build id should be considered immutable under usual circumstances.
+  watcher.on("add", listener.bind(null, handler));
+
+  return watcher;
+}

package/src/internal/builtin-plugins/node/helpers.ts

@@ -1,9 +1,19 @@
+import type { BuildInfo } from "../../../types/artifacts.js";
 import type { EdrNetworkAccountsConfig } from "../../../types/config.js";
+import type { SolidityBuildInfoOutput } from "../../../types/solidity.js";
+import type { EdrProvider } from "../network-manager/edr/edr-provider.js";
 
+import path from "node:path";
+
+import {
+  readJsonFile,
+  readJsonFileAsStream,
+} from "@nomicfoundation/hardhat-utils/fs";
 import { hexStringToBytes } from "@nomicfoundation/hardhat-utils/hex";
 import chalk from "chalk";
 import { addr } from "micro-eth-signer";
 
+import { sendErrorTelemetry } from "../../cli/telemetry/sentry/reporter.js";
 import { isDefaultEdrNetworkHDAccountsConfig } from "../network-manager/edr/edr-provider.js";
 import { normalizeEdrNetworkAccountsConfig } from "../network-manager/edr/utils/convert-to-edr.js";
 
@@ -64,6 +74,60 @@ export async function formatEdrNetworkConfigAccounts(
   return formattedAccountsLines.join("\n");
 }
 
+/**
+ * Creates a handler function that will be called on buildInfo file creations
+ * (triggered from the compilation pipeline); the handler reads the build info
+ * file and uploads the key details into the EDR instance.
+ *
+ * @param buildInfoDirPath - The path (under artifacts) to the build info
+ * directory
+ * @param provider - The EDR provider being updated.
+ * @returns The handler function that is called with the buildId to upload.
+ */
+export function createBuildInfoUploadHandlerFrom(
+  buildInfoDirPath: string,
+  provider: EdrProvider,
+  log: debug.Debugger,
+): (buildId: string) => Promise<void> {
+  const buildInfoHandler = async (buildId: string) => {
+    try {
+      log(`Adding new compilation result for build ${buildId} to the node`);
+      const buildInfo: BuildInfo = await readJsonFile(
+        path.join(buildInfoDirPath, `${buildId}.json`),
+      );
+      const buildInfoOutput: SolidityBuildInfoOutput =
+        await readJsonFileAsStream(
+          path.join(buildInfoDirPath, `${buildId}.output.json`),
+        );
+
+      await provider.addCompilationResult(
+        buildInfo.solcVersion,
+        buildInfo.input,
+        buildInfoOutput.output,
+      );
+
+      log(`Added compiler result for ${buildId}`);
+    } catch (error) {
+      console.warn(
+        chalk.yellow(
+          `There was a problem adding the new compiler result for build ${buildId}.`,
+        ),
+      );
+
+      log(
+        "Last compilation result couldn't be added. Please report this to help us improve Hardhat.\n",
+        error,
+      );
+
+      if (error instanceof Error) {
+        await sendErrorTelemetry(error);
+      }
+    }
+  };
+
+  return buildInfoHandler;
+}
+
 // NOTE: This function is exported for testing purposes only
 export function getPublicPrivateKeysWarning(): string {
   return chalk.bold(

package/src/internal/builtin-plugins/node/json-rpc/server.ts

@@ -1,3 +1,4 @@
+import type { JsonRpcServer } from "../../../../types/network.js";
 import type { EthereumProvider } from "../../../../types/providers.js";
 import type { Server } from "node:http";
 import type { AddressInfo } from "node:net";
@@ -11,17 +12,9 @@ import { JsonRpcHandler } from "./handler.js";
 
 const log = debug("hardhat:core:tasks:node:json-rpc:server");
 
-export interface JsonRpcServer {
-  listen(): Promise<{ address: string; port: number }>;
-  waitUntilClosed(): Promise<void>;
-
-  close(): Promise<void>;
-}
-
 export interface JsonRpcServerConfig {
   hostname: string;
-  port: number;
-
+  port?: number;
   provider: EthereumProvider;
 }
 
@@ -56,7 +49,7 @@ export class JsonRpcServerImplementation implements JsonRpcServer {
     });
   };
 
-  public waitUntilClosed = async (): Promise<void> => {
+  public afterClosed = async (): Promise<void> => {
     const httpServerClosed = new Promise((resolve) => {
       this.#httpServer.once("close", resolve);
     });

package/src/internal/builtin-plugins/node/task-action.ts

@@ -1,19 +1,30 @@
 import type { EdrNetworkConfigOverride } from "../../../types/config.js";
 import type { NewTaskActionFunction } from "../../../types/tasks.js";
 
+import path from "node:path";
+
 import {
   assertHardhatInvariant,
   HardhatError,
 } from "@nomicfoundation/hardhat-errors";
-import { exists } from "@nomicfoundation/hardhat-utils/fs";
+import { ensureDir, exists } from "@nomicfoundation/hardhat-utils/fs";
 import chalk from "chalk";
+import debug from "debug";
 
 import { DEFAULT_NETWORK_NAME } from "../../constants.js";
 import { isSupportedChainType } from "../../edr/chain-type.js";
+import { BUILD_INFO_DIR_NAME } from "../artifacts/artifact-manager.js";
+import { EdrProvider } from "../network-manager/edr/edr-provider.js";
 
-import { formatEdrNetworkConfigAccounts } from "./helpers.js";
+import { watchBuildInfo } from "./artifacts/build-info-watcher.js";
+import {
+  createBuildInfoUploadHandlerFrom,
+  formatEdrNetworkConfigAccounts,
+} from "./helpers.js";
 import { JsonRpcServerImplementation } from "./json-rpc/server.js";
 
+const log = debug("hardhat:core:tasks:node");
+
 interface NodeActionArguments {
   hostname?: string;
   port: number;
@@ -94,6 +105,11 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
     override: networkConfigOverride,
   });
 
+  assertHardhatInvariant(
+    provider instanceof EdrProvider,
+    "Provider must be EdrProvider, since only edr networks are supported",
+  );
+
   // NOTE: We enable logging for the node
   await provider.request({
     method: "hardhat_setLoggingEnabled",
@@ -112,7 +128,7 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
     }
   }
 
-  const server: JsonRpcServerImplementation = new JsonRpcServerImplementation({
+  const server = new JsonRpcServerImplementation({
     hostname,
     port: args.port,
     provider,
@@ -128,7 +144,16 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
 
   console.log();
 
-  // TODO(https://github.com/NomicFoundation/hardhat/issues/6040): Add build info watcher here
+  const buildInfoDirPath = path.join(
+    hre.config.paths.artifacts,
+    BUILD_INFO_DIR_NAME,
+  );
+  await ensureDir(buildInfoDirPath);
+
+  const buildInfoWatcher = await watchBuildInfo(
+    buildInfoDirPath,
+    createBuildInfoUploadHandlerFrom(buildInfoDirPath, provider, log),
+  );
 
   // NOTE: Before creating the node, we check if the input network config is of type edr.
   // We only proceed if it is. Hence, we can assume that the output network config is of type edr as well.
@@ -139,7 +164,8 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
 
   console.log(await formatEdrNetworkConfigAccounts(networkConfig.accounts));
 
-  await server.waitUntilClosed();
+  await server.afterClosed();
+  await buildInfoWatcher.close();
 };
 
 export default nodeAction;