hardhat 3.3.0 → 3.4.1

package/src/internal/builtin-plugins/network-manager/edr/utils/convert-to-edr.ts

@@ -281,7 +281,7 @@ export async function hardhatAccountsToEdrOwnedAccounts(
     balance: account.balance,
   }));
 
-  return Promise.all(accountPromises);
+  return await Promise.all(accountPromises);
 }
 
 export async function normalizeEdrNetworkAccountsConfig(
@@ -404,7 +404,7 @@ export function edrGasReportToHardhatGasMeasurements(
           contractFqn,
           type: "deployment",
           gas: Number(deployment.gas),
-          size: Number(deployment.size),
+          runtimeSize: Number(deployment.runtimeSize),
         });
       }
     }
@@ -418,6 +418,7 @@ export function edrGasReportToHardhatGasMeasurements(
             type: "function",
             functionSig,
             gas: Number(call.gas),
+            proxyChain: call.proxyChain,
           });
         }
       }

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

@@ -12,21 +12,50 @@ export default async (): Promise<Partial<HardhatRuntimeEnvironmentHooks>> => ({
     let networkManager: NetworkManager | undefined;
 
     hre.network = {
+      async create(networkConnectionParams) {
+        if (networkManager === undefined) {
+          networkManager = await createNetworkManager(hre, context);
+        }
+
+        return await networkManager.create(networkConnectionParams);
+      },
+
       async connect(networkConnectionParams) {
         if (networkManager === undefined) {
           networkManager = await createNetworkManager(hre, context);
         }
 
-        return networkManager.connect(networkConnectionParams);
+        return await networkManager.connect(networkConnectionParams);
+      },
+
+      async getOrCreate(networkOrParams) {
+        if (networkManager === undefined) {
+          networkManager = await createNetworkManager(hre, context);
+        }
+
+        return await networkManager.getOrCreate(networkOrParams);
       },
+
       async createServer(...params) {
         if (networkManager === undefined) {
           networkManager = await createNetworkManager(hre, context);
         }
 
-        return networkManager.createServer(...params);
+        return await networkManager.createServer(...params);
       },
     };
+
+    // To avoid adding `wasConnectCalled` to the public interface of
+    // `NetworkManager`, we add this pass through method that is only
+    // called from the `main` function.
+    Object.defineProperty(hre.network, "wasConnectCalled", {
+      value: () =>
+        networkManager !== undefined &&
+        "wasConnectCalled" in networkManager &&
+        typeof networkManager.wasConnectCalled === "function" &&
+        networkManager.wasConnectCalled(),
+      enumerable: false,
+    });
   },
 });
 

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)) {
@@ -72,7 +78,7 @@ export default async (): Promise<Partial<NetworkHooks>> => {
         updatedRequest = newRequestOrResponse;
       }
 
-      return next(context, networkConnection, updatedRequest);
+      return await next(context, networkConnection, updatedRequest);
     },
 
     async closeConnection<ChainTypeT extends ChainType | string>(
@@ -87,7 +93,7 @@ export default async (): Promise<Partial<NetworkHooks>> => {
         requestHandlersPerConnection.delete(networkConnection);
       }
 
-      return next(context, networkConnection);
+      return await next(context, networkConnection);
     },
   };
 

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

@@ -224,7 +224,11 @@ export class HttpProvider extends BaseProvider {
           retryCount,
         );
         if (this.#shouldRetryRequest(retryAfterSeconds, retryCount)) {
-          return this.#retry(jsonRpcRequest, retryAfterSeconds, retryCount);
+          return await this.#retry(
+            jsonRpcRequest,
+            retryAfterSeconds,
+            retryCount,
+          );
         }
 
         // eslint-disable-next-line no-restricted-syntax -- allow throwing ProviderError
@@ -269,7 +273,7 @@ export class HttpProvider extends BaseProvider {
     retryCount: number,
   ) {
     await sleep(retryAfterSeconds);
-    return this.#fetchJsonRpcResponse(request, retryCount + 1);
+    return await this.#fetchJsonRpcResponse(request, retryCount + 1);
   }
 }
 

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;
@@ -109,7 +116,11 @@ export class NetworkManagerImplementation implements NetworkManager {
       "newConnection",
       [],
       async (_context) =>
-        this.#initializeNetworkConnection(networkName, chainType, override),
+        await this.#initializeNetworkConnection(
+          networkName,
+          chainType,
+          override,
+        ),
     );
 
     /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -117,6 +128,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 await 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 await 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 +214,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 +223,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,
@@ -185,7 +264,7 @@ export class NetworkManagerImplementation implements NetworkManager {
           "network",
           "onRequest",
           [networkConnection, request],
-          async (_context, _connection, req) => defaultBehavior(req),
+          async (_context, _connection, req) => await defaultBehavior(req),
         );
 
       if (resolvedNetworkConfig.type === "edr-simulated") {
@@ -276,7 +355,7 @@ export class NetworkManagerImplementation implements NetworkManager {
 
         const includeCallTraces = verbosityToIncludeTraces(this.#verbosity);
 
-        return EdrProvider.create({
+        return await EdrProvider.create({
           chainDescriptors: this.#chainDescriptors,
           // The resolvedNetworkConfig can have its chainType set to `undefined`
           // so we default to the default chain type here.
@@ -287,9 +366,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,
@@ -302,7 +379,7 @@ export class NetworkManagerImplementation implements NetworkManager {
         });
       }
 
-      return HttpProvider.create({
+      return await HttpProvider.create({
         url: await resolvedNetworkConfig.url.getUrl(),
         networkName: resolvedNetworkName,
         extraHeaders: resolvedNetworkConfig.httpHeaders,
@@ -311,7 +388,7 @@ export class NetworkManagerImplementation implements NetworkManager {
       });
     };
 
-    return NetworkConnectionImplementation.create(
+    return await NetworkConnectionImplementation.create(
       this.#nextConnectionId++,
       resolvedNetworkName,
       resolvedChainType,
@@ -387,7 +464,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 +551,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;
     }