hardhat 3.3.0 → 3.4.0

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

@@ -38,24 +38,26 @@ export default async (): Promise<Partial<NetworkHooks>> => {
         nextJsonRpcRequest: JsonRpcRequest,
       ) => Promise<JsonRpcResponse>,
     ) {
-      const requestHandlers = await initializationMutex.exclusiveRun(
-        async () => {
-          let handlersPerConnection =
-            requestHandlersPerConnection.get(networkConnection);
+      let requestHandlers = requestHandlersPerConnection.get(networkConnection);
 
-          if (handlersPerConnection === undefined) {
-            handlersPerConnection =
-              await createHandlersArray(networkConnection);
+      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);
 
-            requestHandlersPerConnection.set(
-              networkConnection,
-              handlersPerConnection,
-            );
+          if (handlersPerConnectionAfterWaiting !== undefined) {
+            return handlersPerConnectionAfterWaiting;
           }
 
-          return handlersPerConnection;
-        },
-      );
+          const result = await createHandlersArray(networkConnection);
+
+          requestHandlersPerConnection.set(networkConnection, result);
+
+          return result;
+        });
+      }
 
       // We previously cloned here, but the performance impact is significant.
       // TODO: ensure the passed in request is not mutated by adapting the
@@ -63,6 +65,10 @@ export default async (): Promise<Partial<NetworkHooks>> => {
       let updatedRequest = jsonRpcRequest;
 
       for (const handler of requestHandlers) {
+        if (!handler.isSupportedMethod(updatedRequest)) {
+          continue;
+        }
+
         const newRequestOrResponse = await handler.handle(updatedRequest);
 
         if (isJsonRpcResponse(newRequestOrResponse)) {

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";
@@ -59,10 +60,18 @@ export class NetworkManagerImplementation implements NetworkManager {
   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,
     defaultChainType: DefaultChainType,
@@ -87,9 +96,7 @@ export class NetworkManagerImplementation implements NetworkManager {
     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;
@@ -117,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,
   >(
@@ -129,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,
@@ -138,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,
@@ -287,9 +362,7 @@ 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,
           contractDecoder: this.#contractDecoder,
@@ -387,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' })`,
         },
       );
     }
@@ -474,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);
   }

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/accounts/local-accounts.ts

@@ -39,6 +39,15 @@ import { ChainId } from "../chain-id/chain-id.js";
 
 const EXTRA_ENTROPY = false;
 export class LocalAccountsHandler extends ChainId implements RequestHandler {
+  readonly #methods: ReadonlySet<string> = new Set([
+    "eth_accounts",
+    "eth_requestAccounts",
+    "eth_sign",
+    "personal_sign",
+    "eth_signTypedData_v4",
+    "eth_sendTransaction",
+  ]);
+
   readonly #localAccountsHexPrivateKeys: string[];
 
   #addressToPrivateKey: Map<string, Uint8Array> | undefined;
@@ -53,6 +62,27 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
     this.#localAccountsHexPrivateKeys = localAccountsHexPrivateKeys;
   }
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
+  public async handle(
+    jsonRpcRequest: JsonRpcRequest,
+  ): Promise<JsonRpcRequest | JsonRpcResponse> {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
+      return jsonRpcRequest;
+    }
+
+    const response = await this.#resolveRequest(jsonRpcRequest);
+    if (response !== null) {
+      return response;
+    }
+
+    await this.#modifyRequest(jsonRpcRequest);
+
+    return jsonRpcRequest;
+  }
+
   async #getAddressesAndPrivateKeysMap(): Promise<{
     addresses: string[];
     addressToPrivateKey: Map<string, Uint8Array>;
@@ -75,19 +105,6 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
     };
   }
 
-  public async handle(
-    jsonRpcRequest: JsonRpcRequest,
-  ): Promise<JsonRpcRequest | JsonRpcResponse> {
-    const response = await this.#resolveRequest(jsonRpcRequest);
-    if (response !== null) {
-      return response;
-    }
-
-    await this.#modifyRequest(jsonRpcRequest);
-
-    return jsonRpcRequest;
-  }
-
   async #resolveRequest(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcResponse | null> {

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/accounts/sender.ts

@@ -17,35 +17,43 @@ import { getRequestParams } from "../../../json-rpc.js";
  * The class also provides a mechanism to retrieve the sender account, which must be implemented by subclasses.
  */
 export abstract class SenderHandler implements RequestHandler {
+  readonly #methods: ReadonlySet<string> = new Set([
+    "eth_sendTransaction",
+    "eth_call",
+    "eth_estimateGas",
+  ]);
+
   protected readonly provider: EthereumProvider;
 
   constructor(provider: EthereumProvider) {
     this.provider = provider;
   }
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
+      return jsonRpcRequest;
+    }
+
     const method = jsonRpcRequest.method;
     const params = getRequestParams(jsonRpcRequest);
 
-    if (
-      method === "eth_sendTransaction" ||
-      method === "eth_call" ||
-      method === "eth_estimateGas"
-    ) {
-      const [tx] = params;
-
-      if (isObject(tx) && tx.from === undefined) {
-        const senderAccount = await this.getSender();
-
-        if (senderAccount !== undefined) {
-          tx.from = senderAccount;
-        } else if (method === "eth_sendTransaction") {
-          throw new HardhatError(
-            HardhatError.ERRORS.CORE.NETWORK.NO_REMOTE_ACCOUNT_AVAILABLE,
-          );
-        }
+    const [tx] = params;
+
+    if (isObject(tx) && tx.from === undefined) {
+      const senderAccount = await this.getSender();
+
+      if (senderAccount !== undefined) {
+        tx.from = senderAccount;
+      } else if (method === "eth_sendTransaction") {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.NETWORK.NO_REMOTE_ACCOUNT_AVAILABLE,
+        );
       }
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/chain-id/chain-id-handler.ts

@@ -25,17 +25,25 @@ export class ChainIdValidatorHandler extends ChainId implements RequestHandler {
     this.#expectedChainId = expectedChainId;
   }
 
-  public async handle(
-    jsonRpcRequest: JsonRpcRequest,
-  ): Promise<JsonRpcRequest | JsonRpcResponse> {
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    if (this.#alreadyValidated) {
+      return false;
+    }
+
     if (
       jsonRpcRequest.method === "eth_chainId" ||
       jsonRpcRequest.method === "net_version"
     ) {
-      return jsonRpcRequest;
+      return false;
     }
 
-    if (this.#alreadyValidated) {
+    return true;
+  }
+
+  public async handle(
+    jsonRpcRequest: JsonRpcRequest,
+  ): Promise<JsonRpcRequest | JsonRpcResponse> {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
       return jsonRpcRequest;
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/gas/automatic-gas-handler.ts

@@ -25,6 +25,8 @@ export class AutomaticGasHandler
   extends MultipliedGasEstimation
   implements RequestHandler
 {
+  readonly #methods: ReadonlySet<string> = new Set(["eth_sendTransaction"]);
+
   constructor(
     provider: EthereumProvider,
     gasMultiplier: number = DEFAULT_GAS_MULTIPLIER,
@@ -32,10 +34,14 @@ export class AutomaticGasHandler
     super(provider, gasMultiplier);
   }
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
-    if (jsonRpcRequest.method !== "eth_sendTransaction") {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
       return jsonRpcRequest;
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/gas/automatic-gas-price-handler.ts

@@ -19,6 +19,8 @@ import { getRequestParams } from "../../../json-rpc.js";
  * It ensures that gas prices are set correctly.
  */
 export class AutomaticGasPriceHandler implements RequestHandler {
+  readonly #methods: ReadonlySet<string> = new Set(["eth_sendTransaction"]);
+
   readonly #provider: EthereumProvider;
 
   // We pay the max base fee that can be required if the next
@@ -36,10 +38,14 @@ export class AutomaticGasPriceHandler implements RequestHandler {
   #nodeHasFeeHistory?: boolean;
   #nodeSupportsEIP1559?: boolean;
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
-    if (jsonRpcRequest.method !== "eth_sendTransaction") {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
       return jsonRpcRequest;
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/gas/fixed-gas-handler.ts

@@ -14,16 +14,22 @@ import { getRequestParams } from "../../../json-rpc.js";
  * For `eth_sendTransaction` requests, it sets the gas field with the value provided via the class constructor, if it hasn't been specified already.
  */
 export class FixedGasHandler implements RequestHandler {
+  readonly #methods: ReadonlySet<string> = new Set(["eth_sendTransaction"]);
+
   readonly #gas: PrefixedHexString;
 
   constructor(gas: PrefixedHexString) {
     this.#gas = gas;
   }
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
-    if (jsonRpcRequest.method !== "eth_sendTransaction") {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
       return jsonRpcRequest;
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/gas/fixed-gas-price-handler.ts

@@ -14,16 +14,22 @@ import { getRequestParams } from "../../../json-rpc.js";
  * For `eth_sendTransaction` requests, it sets the gasPrice field with the value provided via the class constructor, if it hasn't been specified already.
  */
 export class FixedGasPriceHandler implements RequestHandler {
+  readonly #methods: ReadonlySet<string> = new Set(["eth_sendTransaction"]);
+
   readonly #gasPrice: PrefixedHexString;
 
   constructor(gasPrice: PrefixedHexString) {
     this.#gasPrice = gasPrice;
   }
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
-    if (jsonRpcRequest.method !== "eth_sendTransaction") {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
       return jsonRpcRequest;
     }
 

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

@@ -14,6 +14,16 @@ import type {
  *
  */
 export interface RequestHandler {
+  /**
+   * A guard to ensure the request is supported by the handler.
+   * If the handler does not support the request, then it can be safely
+   * skipped.
+   *
+   * @param jsonRpcRequest - The JSON-RPC request to check.
+   * @returns true if the method will be processed by the handler, false otherwise.
+   */
+  isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean;
+
   handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse>;

package/src/internal/builtin-plugins/network-manager/revert-error-code.ts

@@ -0,0 +1,2 @@
+// Error code used by geth/anvil for execution revert errors (e.g. Solidity reverts).
+export const REVERT_ERROR_CODE: number = 3;

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

@@ -147,7 +147,7 @@ declare module "../../../../types/config.js" {
   export interface EdrNetworkForkingUserConfig {
     enabled?: boolean;
     url: SensitiveString;
-    blockNumber?: number;
+    blockNumber?: number | bigint;
     httpHeaders?: Record<string, string>;
   }
 

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

@@ -45,6 +45,10 @@ const nonnegativeIntSchema = z.number().int().nonnegative();
 const nonnegativeBigIntSchema = z.bigint().nonnegative();
 
 const blockNumberSchema = nonnegativeIntSchema;
+const forkingBlockNumberSchema = unionType(
+  [z.number().int().nonnegative().safe(), z.bigint().nonnegative()],
+  "Expected a nonnegative safe int or a nonnegative bigint",
+);
 const chainIdSchema = nonnegativeIntSchema;
 
 const chainTypeUserConfigSchema = unionType(
@@ -267,7 +271,7 @@ const edrNetworkAccountsUserConfigSchema = conditionalUnionType(
 const edrNetworkForkingUserConfigSchema = z.object({
   enabled: z.optional(z.boolean()),
   url: sensitiveUrlSchema,
-  blockNumber: z.optional(blockNumberSchema),
+  blockNumber: z.optional(forkingBlockNumberSchema),
   httpHeaders: z.optional(z.record(z.string())),
 });
 

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

@@ -21,6 +21,7 @@ import {
   InvalidRequestError,
   ProviderError,
 } from "../../network-manager/provider-errors.js";
+import { REVERT_ERROR_CODE } from "../../network-manager/revert-error-code.js";
 
 export class JsonRpcHandler {
   readonly #provider: EthereumProvider;
@@ -256,8 +257,15 @@ const _handleError = (error: Error): JsonRpcResponse => {
   const txHash = extractTxHash(error);
   const returnData = extractReturnData(error);
 
-  // In case of non-hardhat error, treat it as internal and associate the appropriate error code.
-  if (!ProviderError.isProviderError(error)) {
+  // Check if this is a revert error (code 3) matching the geth/anvil convention.
+  const isRevertError =
+    "code" in error &&
+    typeof error.code === "number" &&
+    error.code === REVERT_ERROR_CODE;
+
+  // In case of non-hardhat error that is not a revert, treat it as internal
+  // and associate the appropriate error code.
+  if (!ProviderError.isProviderError(error) && !isRevertError) {
     error = new InternalError(undefined, error);
   }
 

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

@@ -106,10 +106,10 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
     );
   }
 
-  // NOTE: This is where we initialize the network; the connect method returns
+  // NOTE: This is where we initialize the network; the create method returns
   // a fully resolved networkConfig object which might be useful for display
   const { networkConfig, provider } =
-    await hre.network.connect(connectionParams);
+    await hre.network.create(connectionParams);
 
   assertHardhatInvariant(
     provider instanceof EdrProvider,

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

@@ -25,7 +25,8 @@ const runScriptWithHardhat: NewTaskActionFunction<RunActionArguments> = async (
   }
 
   if (!noCompile) {
-    await hre.tasks.getTask("build").run({ quiet: true, noTests: true });
+    const noTests = hre.config.solidity.splitTestsCompilation;
+    await hre.tasks.getTask("build").run({ quiet: true, noTests });
     console.log();
   }
 

package/src/internal/builtin-plugins/solidity/build-system/artifacts.ts

@@ -117,6 +117,9 @@ export async function getBuildInfo(
     solcVersion: compilationJob.solcConfig.version,
     solcLongVersion: compilationJob.solcLongVersion,
     compilerType,
+    ...(compilationJob.toolVersions !== undefined
+      ? { toolVersions: compilationJob.toolVersions }
+      : {}),
     userSourceNameMap:
       compilationJob.dependencyGraph.getRootsUserSourceNameMap(),
     input: await compilationJob.getSolcInput(),