hardhat 3.2.0 → 3.4.0

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

@@ -9,10 +9,10 @@ import type {
 } from "../../../../types/providers.js";
 import type { RequestHandler } from "../request-handlers/types.js";
 
-import { deepClone } from "@nomicfoundation/hardhat-utils/lang";
 import { AsyncMutex } from "@nomicfoundation/hardhat-utils/synchronization";
 
 import { isJsonRpcResponse } from "../json-rpc.js";
+import { createHandlersArray } from "../request-handlers/handlers-array.js";
 
 export default async (): Promise<Partial<NetworkHooks>> => {
   // This map is essential for managing multiple network connections in Hardhat V3.
@@ -38,44 +38,47 @@ export default async (): Promise<Partial<NetworkHooks>> => {
         nextJsonRpcRequest: JsonRpcRequest,
       ) => Promise<JsonRpcResponse>,
     ) {
-      const { createHandlersArray } = await import(
-        "../request-handlers/handlers-array.js"
-      );
+      let requestHandlers = requestHandlersPerConnection.get(networkConnection);
 
-      const requestHandlers = await initializationMutex.exclusiveRun(
-        async () => {
-          let handlersPerConnection =
+      if (requestHandlers === undefined) {
+        requestHandlers = await initializationMutex.exclusiveRun(async () => {
+          // We check again in case another execution of this function
+          // initialized the handlers while we were waiting for the mutex.
+          const handlersPerConnectionAfterWaiting =
             requestHandlersPerConnection.get(networkConnection);
 
-          if (handlersPerConnection === undefined) {
-            handlersPerConnection =
-              await createHandlersArray(networkConnection);
-
-            requestHandlersPerConnection.set(
-              networkConnection,
-              handlersPerConnection,
-            );
+          if (handlersPerConnectionAfterWaiting !== undefined) {
+            return handlersPerConnectionAfterWaiting;
           }
 
-          return handlersPerConnection;
-        },
-      );
+          const result = await createHandlersArray(networkConnection);
+
+          requestHandlersPerConnection.set(networkConnection, result);
+
+          return result;
+        });
+      }
 
-      // We clone the request to avoid interfering with other hook handlers that
-      // might be using the original request.
-      let request = await deepClone(jsonRpcRequest);
+      // We previously cloned here, but the performance impact is significant.
+      // TODO: ensure the passed in request is not mutated by adapting the
+      // handlers being applied here. See https://github.com/NomicFoundation/hardhat/issues/8090
+      let updatedRequest = jsonRpcRequest;
 
       for (const handler of requestHandlers) {
-        const newRequestOrResponse = await handler.handle(request);
+        if (!handler.isSupportedMethod(updatedRequest)) {
+          continue;
+        }
+
+        const newRequestOrResponse = await handler.handle(updatedRequest);
 
         if (isJsonRpcResponse(newRequestOrResponse)) {
           return newRequestOrResponse;
         }
 
-        request = newRequestOrResponse;
+        updatedRequest = newRequestOrResponse;
       }
 
-      return next(context, networkConnection, request);
+      return next(context, networkConnection, updatedRequest);
     },
 
     async closeConnection<ChainTypeT extends ChainType | string>(

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

@@ -161,6 +161,7 @@ export class HttpProvider extends BaseProvider {
   }
 
   public async close(): Promise<void> {
+    this.removeAllListeners();
     if (this.#dispatcher !== undefined) {
       // See https://github.com/nodejs/undici/discussions/3522#discussioncomment-10498734
       await this.#dispatcher.close();

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

@@ -12,6 +12,7 @@ import type {
   DefaultChainType,
   JsonRpcServer,
   NetworkConnection,
+  CachedNetworkConnectionParams,
   NetworkConnectionParams,
   NetworkManager,
 } from "../../../types/network.js";
@@ -21,7 +22,7 @@ import type {
   JsonRpcRequest,
   JsonRpcResponse,
 } from "../../../types/providers.js";
-import type { GasReportConfig } from "@nomicfoundation/edr";
+import type { ContractDecoder, GasReportConfig } from "@nomicfoundation/edr";
 
 import {
   HardhatError,
@@ -29,6 +30,7 @@ import {
 } from "@nomicfoundation/hardhat-errors";
 import { exists, readBinaryFile } from "@nomicfoundation/hardhat-utils/fs";
 import { deepMerge } from "@nomicfoundation/hardhat-utils/lang";
+import { AsyncMutex } from "@nomicfoundation/hardhat-utils/synchronization";
 
 import { resolveUserConfigToHardhatConfig } from "../../core/hre.js";
 import { isSupportedChainType } from "../../edr/chain-type.js";
@@ -37,6 +39,7 @@ import { JsonRpcServerImplementation } from "../node/json-rpc/server.js";
 import { EdrProvider } from "./edr/edr-provider.js";
 import { getHardforks } from "./edr/types/hardfork.js";
 import { edrGasReportToHardhatGasMeasurements } from "./edr/utils/convert-to-edr.js";
+import { verbosityToIncludeTraces } from "./edr/utils/trace-formatters.js";
 import { HttpProvider } from "./http-provider.js";
 import { NetworkConnectionImplementation } from "./network-connection.js";
 
@@ -55,8 +58,19 @@ export class NetworkManagerImplementation implements NetworkManager {
   readonly #chainDescriptors: Readonly<ChainDescriptorsConfig>;
   readonly #userProvidedConfigPath: Readonly<string | undefined>;
   readonly #projectRoot: string;
+  readonly #verbosity: number;
+
+  #connectCalled = false;
 
   #nextConnectionId = 0;
+  readonly #contractDecoderMutex = new AsyncMutex();
+  #contractDecoder: ContractDecoder | undefined;
+
+  readonly #getOrCreateMutex = new AsyncMutex();
+  readonly #getOrCreateCache = new Map<
+    string,
+    Map<string, NetworkConnection<ChainType | string>>
+  >();
 
   constructor(
     defaultNetwork: string,
@@ -68,6 +82,7 @@ export class NetworkManagerImplementation implements NetworkManager {
     chainDescriptors: ChainDescriptorsConfig,
     userProvidedConfigPath: string | undefined,
     projectRoot: string,
+    verbosity: number,
   ) {
     this.#defaultNetwork = defaultNetwork;
     this.#defaultChainType = defaultChainType;
@@ -78,11 +93,10 @@ export class NetworkManagerImplementation implements NetworkManager {
     this.#chainDescriptors = chainDescriptors;
     this.#userProvidedConfigPath = userProvidedConfigPath;
     this.#projectRoot = projectRoot;
+    this.#verbosity = verbosity;
   }
 
-  public async connect<
-    ChainTypeT extends ChainType | string = DefaultChainType,
-  >(
+  public async create<ChainTypeT extends ChainType | string = DefaultChainType>(
     networkOrParams?: NetworkConnectionParams<ChainTypeT> | string,
   ): Promise<NetworkConnection<ChainTypeT>> {
     let networkName: string | undefined;
@@ -110,6 +124,80 @@ export class NetworkManagerImplementation implements NetworkManager {
     return networkConnection as NetworkConnection<ChainTypeT>;
   }
 
+  public async connect<
+    ChainTypeT extends ChainType | string = DefaultChainType,
+  >(
+    networkOrParams?: NetworkConnectionParams<ChainTypeT> | string,
+  ): Promise<NetworkConnection<ChainTypeT>> {
+    this.#connectCalled = true;
+
+    return this.create(networkOrParams);
+  }
+
+  public async getOrCreate<
+    ChainTypeT extends ChainType | string = DefaultChainType,
+  >(
+    networkOrParams?: CachedNetworkConnectionParams<ChainTypeT> | string,
+  ): Promise<NetworkConnection<ChainTypeT>> {
+    let network: string | undefined;
+    let chainType: ChainTypeT | undefined;
+
+    if (typeof networkOrParams === "string") {
+      network = networkOrParams;
+    } else if (networkOrParams !== undefined) {
+      network = networkOrParams.network;
+      chainType = networkOrParams.chainType;
+
+      if ("override" in networkOrParams) {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.NETWORK.INVALID_CONFIG_OVERRIDE,
+          {
+            errors: "\t* Config overrides are not supported by getOrCreate.",
+          },
+        );
+      }
+    }
+
+    const { resolvedNetworkName, resolvedChainType } =
+      this.#resolveNetworkAndChainType(network, chainType);
+
+    const cached = this.#getOrCreateCache
+      .get(resolvedNetworkName)
+      ?.get(resolvedChainType);
+    if (cached !== undefined) {
+      /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      -- Cast is safe: the cache keys guarantee the chain type matches */
+      return cached as NetworkConnection<ChainTypeT>;
+    }
+
+    return this.#getOrCreateMutex.exclusiveRun(async () => {
+      // Double-check after acquiring the mutex — another call may have
+      // populated the cache while we were waiting.
+      const cachedAfterWaiting = this.#getOrCreateCache
+        .get(resolvedNetworkName)
+        ?.get(resolvedChainType);
+      if (cachedAfterWaiting !== undefined) {
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        -- Cast is safe: the cache keys guarantee the chain type matches */
+        return cachedAfterWaiting as NetworkConnection<ChainTypeT>;
+      }
+
+      const connection = await this.create({
+        network: resolvedNetworkName,
+        chainType: resolvedChainType,
+      });
+
+      let networkCache = this.#getOrCreateCache.get(resolvedNetworkName);
+      if (networkCache === undefined) {
+        networkCache = new Map();
+        this.#getOrCreateCache.set(resolvedNetworkName, networkCache);
+      }
+      networkCache.set(resolvedChainType, connection);
+
+      return connection;
+    });
+  }
+
   public async createServer<
     ChainTypeT extends ChainType | string = DefaultChainType,
   >(
@@ -122,7 +210,7 @@ export class NetworkManagerImplementation implements NetworkManager {
     const insideDocker = await exists("/.dockerenv");
     const hostname = _hostname ?? (insideDocker ? "0.0.0.0" : "127.0.0.1");
 
-    const { provider } = await this.connect(networkOrParams);
+    const { provider } = await this.create(networkOrParams);
 
     return new JsonRpcServerImplementation({
       hostname,
@@ -131,30 +219,24 @@ export class NetworkManagerImplementation implements NetworkManager {
     });
   }
 
+  /**
+   * Returns whether the deprecated `connect` method has been called on this
+   * instance. It is not on the public NetworkManager interface as it is only
+   * used by the CLI to print a deprecation warning at exit.
+   *
+   * @returns whether the deprecated `connect` method has ever been called
+   */
+  public wasConnectCalled(): boolean {
+    return this.#connectCalled;
+  }
+
   async #initializeNetworkConnection<ChainTypeT extends ChainType | string>(
     networkName?: string,
     chainType?: ChainTypeT,
     networkConfigOverride?: NetworkConfigOverride,
   ): Promise<NetworkConnection<ChainTypeT>> {
-    const resolvedNetworkName = networkName ?? this.#defaultNetwork;
-    const existingNetworkConfig = this.#networkConfigs[resolvedNetworkName];
-
-    if (existingNetworkConfig === undefined) {
-      throw new HardhatError(
-        HardhatError.ERRORS.CORE.NETWORK.NETWORK_NOT_FOUND,
-        {
-          networkName: resolvedNetworkName,
-        },
-      );
-    }
-
-    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
-     * Type assertion is safe: defaultChainType ensures non-undefined, and the
-     * resolved value will be ChainTypeT (if provided) or a fallback that
-     * satisfies the ChainType | string constraint */
-    const resolvedChainType = (chainType ??
-      existingNetworkConfig.chainType ??
-      this.#defaultChainType) as ChainTypeT;
+    const { resolvedNetworkName, resolvedChainType } =
+      this.#resolveNetworkAndChainType(networkName, chainType);
 
     const resolvedNetworkConfig = await this.#resolveNetworkConfig(
       resolvedNetworkName,
@@ -233,6 +315,42 @@ export class NetworkManagerImplementation implements NetworkManager {
           };
         }
 
+        // We load the build infos and their outputs to create a contract
+        // decoder when the first provider is created. Successive providers will
+        // reuse the same decoder as a performance optimization.
+        //
+        // The trade-off here is that if you create an EDR provider, then
+        // compile new contracts, and create a new provider, the new contracts
+        // won't be loaded.
+        //
+        // Even without this optimization, we already had the problem of new
+        // contracts not being visible to existing providers.
+        //
+        // In practice, most workflows compile everything before creating
+        // any network connection.
+        if (this.#contractDecoder === undefined) {
+          // We want to ensure that only one contract decoder is created so we
+          // protect the initialization with a mutex.
+          await this.#contractDecoderMutex.exclusiveRun(async () => {
+            // We check again if the decoder is undefined because another async
+            // execution context could have already initialized it while we were
+            // waiting for the mutex.
+            if (this.#contractDecoder === undefined) {
+              this.#contractDecoder = await EdrProvider.createContractDecoder({
+                buildInfos: await this.#getBuildInfosAndOutputsAsBuffers(),
+                ignoreContracts: false,
+              });
+            }
+          });
+        }
+
+        assertHardhatInvariant(
+          this.#contractDecoder !== undefined,
+          "Contract decoder should have been initialized before creating the provider",
+        );
+
+        const includeCallTraces = verbosityToIncludeTraces(this.#verbosity);
+
         return EdrProvider.create({
           chainDescriptors: this.#chainDescriptors,
           // The resolvedNetworkConfig can have its chainType set to `undefined`
@@ -244,17 +362,16 @@ export class NetworkManagerImplementation implements NetworkManager {
             allowUnlimitedContractSize: shouldEnableCoverage
               ? true
               : resolvedNetworkConfig.allowUnlimitedContractSize,
-            /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
-            This case is safe because we have a check above */
-            chainType: resolvedChainType as ChainType,
+            chainType: resolvedChainType,
           },
           jsonRpcRequestWrapper,
-          tracingConfig: {
-            buildInfos: await this.#getBuildInfosAndOutputsAsBuffers(),
-            ignoreContracts: false,
-          },
+          contractDecoder: this.#contractDecoder,
           coverageConfig,
           gasReportConfig,
+          includeCallTraces,
+          connectionId: networkConnection.id,
+          networkName: networkConnection.networkName,
+          verbosity: this.#verbosity,
         });
       }
 
@@ -298,17 +415,32 @@ export class NetworkManagerImplementation implements NetworkManager {
    */
   async #resolveNetworkConfig<ChainTypeT extends ChainType | string>(
     resolvedNetworkName: string,
-    networkConfigOverride: NetworkConfigOverride | undefined = {},
+    networkConfigOverride: NetworkConfigOverride = {},
     resolvedChainType: ChainTypeT,
   ): Promise<NetworkConfig> {
     const existingNetworkConfig = this.#networkConfigs[resolvedNetworkName];
-    if (
-      Object.keys(networkConfigOverride).length === 0 &&
-      resolvedChainType === existingNetworkConfig.chainType
-    ) {
+
+    const hasNoOverrides = Object.keys(networkConfigOverride).length === 0;
+    const isChainTypeUnchanged =
+      resolvedChainType === existingNetworkConfig.chainType;
+    const isChainTypeDefault =
+      existingNetworkConfig.chainType === undefined &&
+      resolvedChainType === this.#defaultChainType;
+
+    if (hasNoOverrides && isChainTypeUnchanged) {
       return existingNetworkConfig;
     }
 
+    if (hasNoOverrides && isChainTypeDefault) {
+      return {
+        ...existingNetworkConfig,
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
+          TypeScript can't follow this case, but we are just providing the
+          default */
+        chainType: resolvedChainType as ChainType,
+      };
+    }
+
     if (
       "type" in networkConfigOverride &&
       networkConfigOverride.type !== existingNetworkConfig.type
@@ -328,7 +460,7 @@ export class NetworkManagerImplementation implements NetworkManager {
       throw new HardhatError(
         HardhatError.ERRORS.CORE.NETWORK.INVALID_CONFIG_OVERRIDE,
         {
-          errors: `\t* The chainType cannot be specified in config overrides. Pass it at the top level instead: hre.network.connect({ chainType: 'op' })`,
+          errors: `\t* The chainType cannot be specified in config overrides. Pass it at the top level instead: hre.network.create({ chainType: 'op' })`,
         },
       );
     }
@@ -357,6 +489,20 @@ export class NetworkManagerImplementation implements NetworkManager {
     );
 
     if (!configResolutionResult.success) {
+      if (configResolutionResult.configValidationErrors !== undefined) {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.NETWORK.INVALID_CONFIG_OVERRIDE,
+          {
+            errors: `\t${configResolutionResult.configValidationErrors
+              .map(
+                (error) =>
+                  `* Error in resolved config ${error.path.join(".")}: ${error.message}`,
+              )
+              .join("\n\t")}`,
+          },
+        );
+      }
+
       throw new HardhatError(
         HardhatError.ERRORS.CORE.NETWORK.INVALID_CONFIG_OVERRIDE,
         {
@@ -401,6 +547,36 @@ export class NetworkManagerImplementation implements NetworkManager {
     return resolvedNetworkConfigOverride;
   }
 
+  #resolveNetworkAndChainType<
+    ChainTypeT extends ChainType | string = DefaultChainType,
+  >(
+    network: string | undefined,
+    chainType: ChainTypeT | undefined,
+  ): { resolvedNetworkName: string; resolvedChainType: ChainTypeT } {
+    const resolvedNetworkName = network ?? this.#defaultNetwork;
+    const existingNetworkConfig = this.#networkConfigs[resolvedNetworkName];
+
+    if (existingNetworkConfig === undefined) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.NETWORK.NETWORK_NOT_FOUND,
+        {
+          networkName: resolvedNetworkName,
+        },
+      );
+    }
+
+    const resolvedChainType =
+      chainType ?? existingNetworkConfig.chainType ?? this.#defaultChainType;
+
+    return {
+      resolvedNetworkName,
+      /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      -- The cast is safe because the fallback values are valid chain
+      types that match the caller's expected type at runtime. */
+      resolvedChainType: resolvedChainType as ChainTypeT,
+    };
+  }
+
   async #getBuildInfosAndOutputsAsBuffers(): Promise<
     Array<{ buildInfo: Uint8Array; output: Uint8Array }>
   > {

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/accounts/hd-wallet-handler.ts

@@ -27,6 +27,7 @@ export class HDWalletHandler extends LocalAccountsHandler {
 
     return new HDWalletHandler(provider, privateKeys);
   }
+
   private constructor(provider: EthereumProvider, privateKeys: string[]) {
     super(provider, privateKeys);
   }