hardhat 3.0.6 → 3.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hardhat",
-  "version": "3.0.6",
+  "version": "3.0.8",
   "description": "Hardhat is an extensible developer tool that helps smart contract developers increase productivity by reliably bringing together the tools they want.",
   "homepage": "https://github.com/nomicfoundation/hardhat/tree/v-next/v-next/hardhat",
   "repository": {
@@ -70,14 +70,15 @@
     "@nomicfoundation/hardhat-test-utils": "^2.0.1"
   },
   "dependencies": {
-    "@nomicfoundation/edr": "0.12.0-next.5",
-    "@nomicfoundation/hardhat-errors": "^3.0.2",
-    "@nomicfoundation/hardhat-utils": "^3.0.2",
+    "@nomicfoundation/edr": "0.12.0-next.7",
+    "@nomicfoundation/hardhat-errors": "^3.0.3",
+    "@nomicfoundation/hardhat-utils": "^3.0.3",
     "@nomicfoundation/hardhat-zod-utils": "^3.0.1",
     "@nomicfoundation/solidity-analyzer": "^0.1.1",
     "@sentry/core": "^9.4.0",
     "adm-zip": "^0.4.16",
     "chalk": "^5.3.0",
+    "chokidar": "^4.0.3",
     "debug": "^4.3.2",
     "enquirer": "^2.3.0",
     "ethereum-cryptography": "^2.2.1",

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

@@ -30,9 +30,8 @@ export default async (): Promise<Partial<SolidityHooks>> => ({
   ) => {
     // NOTE: We do not want to instrument the test project files as we don't
     // want to report coverage for them.
-    const isTestSource =
-      fsPath.startsWith(context.config.paths.tests.solidity) ||
-      fsPath.endsWith(".t.sol");
+
+    const isTestSource = (await context.solidity.getScope(fsPath)) === "tests";
 
     if (context.globalOptions.coverage && !isTestSource) {
       try {

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

@@ -30,6 +30,7 @@ import {
   opHardforkFromString,
   l1GenesisState,
   l1HardforkFromString,
+  ContractDecoder,
 } from "@nomicfoundation/edr";
 import {
   assertHardhatInvariant,
@@ -174,6 +175,8 @@ export class EdrProvider extends BaseProvider {
     // We need to catch errors here, as the provider creation can panic unexpectedly,
     // and we want to make sure such a crash is propagated as a ProviderError.
     try {
+      const contractDecoder = ContractDecoder.withContracts(tracingConfig);
+
       const context = await getGlobalEdrContext();
       const provider = await context.createProvider(
         hardhatChainTypeToEdrChainType(networkConfig.chainType),
@@ -200,7 +203,7 @@ export class EdrProvider extends BaseProvider {
             edrProvider.onSubscriptionEvent(event);
           },
         },
-        tracingConfig,
+        contractDecoder,
       );
 
       edrProvider = new EdrProvider(provider, jsonRpcRequestWrapper);
@@ -301,6 +304,22 @@ export class EdrProvider extends BaseProvider {
     this.#provider = undefined;
   }
 
+  public async addCompilationResult(
+    solcVersion: string,
+    compilerInput: any,
+    compilerOutput: any,
+  ): Promise<void> {
+    if (this.#provider === undefined) {
+      throw new HardhatError(HardhatError.ERRORS.CORE.NETWORK.PROVIDER_CLOSED);
+    }
+
+    await this.#provider.addCompilationResult(
+      solcVersion,
+      compilerInput,
+      compilerOutput,
+    );
+  }
+
   async #handleEdrResponse(
     edrResponse: Response,
   ): Promise<SuccessfulJsonRpcResponse> {

package/src/internal/builtin-plugins/network-manager/hook-handlers/hre.ts

@@ -1,4 +1,8 @@
-import type { HardhatRuntimeEnvironmentHooks } from "../../../../types/hooks.js";
+import type {
+  HardhatRuntimeEnvironmentHooks,
+  HookContext,
+} from "../../../../types/hooks.js";
+import type { HardhatRuntimeEnvironment } from "../../../../types/hre.js";
 import type { NetworkManager } from "../../../../types/network.js";
 
 import { DEFAULT_NETWORK_NAME } from "../../../constants.js";
@@ -7,30 +11,44 @@ export default async (): Promise<Partial<HardhatRuntimeEnvironmentHooks>> => ({
   created: async (context, hre) => {
     let networkManager: NetworkManager | undefined;
 
-    const userConfigNetworks = hre.userConfig.networks;
-
     hre.network = {
       async connect(networkConnectionParams) {
-        const { NetworkManagerImplementation } = await import(
-          "../network-manager.js"
-        );
-
         if (networkManager === undefined) {
-          networkManager = new NetworkManagerImplementation(
-            hre.globalOptions.network !== undefined
-              ? hre.globalOptions.network
-              : DEFAULT_NETWORK_NAME,
-            hre.config.defaultChainType,
-            hre.config.networks,
-            context.hooks,
-            context.artifacts,
-            userConfigNetworks,
-            hre.config.chainDescriptors,
-          );
+          networkManager = await createNetworkManager(hre, context);
         }
 
         return networkManager.connect(networkConnectionParams);
       },
+      async createServer(...params) {
+        if (networkManager === undefined) {
+          networkManager = await createNetworkManager(hre, context);
+        }
+
+        return networkManager.createServer(...params);
+      },
     };
   },
 });
+
+async function createNetworkManager(
+  hre: HardhatRuntimeEnvironment,
+  context: HookContext,
+): Promise<NetworkManager> {
+  const { NetworkManagerImplementation } = await import(
+    "../network-manager.js"
+  );
+
+  return new NetworkManagerImplementation(
+    hre.globalOptions.network !== undefined
+      ? hre.globalOptions.network
+      : DEFAULT_NETWORK_NAME,
+    hre.config.defaultChainType,
+    hre.config.networks,
+    context.hooks,
+    context.artifacts,
+    hre.userConfig,
+    hre.config.chainDescriptors,
+    hre.globalOptions.config,
+    hre.config.paths.root,
+  );
+}

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

@@ -23,7 +23,7 @@ export default async (): Promise<Partial<NetworkHooks>> => {
   const requestHandlersPerConnection: WeakMap<
     NetworkConnection<ChainType | string>,
     RequestHandler[]
-  > = new Map();
+  > = new WeakMap();
 
   const initializationMutex = new AsyncMutex();
 

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

@@ -346,7 +346,7 @@ function refineEdrNetworkUserConfig(
     }
 
     const resolvedHardfork = hardfork ?? getCurrentHardfork(chainType);
-    if (chainType === L1_CHAIN_TYPE || chainType === GENERIC_CHAIN_TYPE) {
+    if (chainType === L1_CHAIN_TYPE) {
       if (hardforkGte(resolvedHardfork, L1HardforkName.LONDON, chainType)) {
         if (minGasPrice !== undefined) {
           ctx.addIssue({
@@ -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);
     });