refactor: Migrate create-network-client

Author: rekmarks

packages/eth-json-rpc-middleware/src/providerAsMiddleware.test.ts

@@ -1,4 +1,4 @@
-import type { SafeEventEmitterProvider } from '@metamask/eth-json-rpc-provider';
+import type { InternalProvider } from '@metamask/eth-json-rpc-provider';
 import { JsonRpcEngine } from '@metamask/json-rpc-engine';
 import { JsonRpcEngineV2 } from '@metamask/json-rpc-engine/v2';
 import type { Json } from '@metamask/utils';
@@ -10,10 +10,10 @@ import {
 } from './providerAsMiddleware';
 import { createRequest } from '../test/util/helpers';
 
-const createMockProvider = (result: Json): SafeEventEmitterProvider =>
+const createMockProvider = (result: Json): InternalProvider =>
   ({
     request: jest.fn().mockResolvedValue(result),
-  }) as unknown as SafeEventEmitterProvider;
+  }) as unknown as InternalProvider;
 
 describe('providerAsMiddleware', () => {
   it('forwards requests to the provider and returns the result', async () => {

packages/network-controller/src/NetworkController.ts

@@ -2446,6 +2446,8 @@ export class NetworkController extends BaseController<
    *
    * In-progress requests will not be aborted.
    */
+  // We're intentionally changing the signature of an extended method.
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
   async destroy() {
     await this.#blockTrackerProxy?.destroy();
   }

packages/network-controller/src/create-network-client.ts

@@ -12,18 +12,19 @@ import {
   createFetchMiddleware,
   createRetryOnEmptyMiddleware,
 } from '@metamask/eth-json-rpc-middleware';
+import { InternalProvider } from '@metamask/eth-json-rpc-provider';
+import { providerFromMiddlewareV2 } from '@metamask/eth-json-rpc-provider';
+import { asV2Middleware } from '@metamask/json-rpc-engine';
 import {
-  InternalProvider,
-  providerFromMiddleware,
-} from '@metamask/eth-json-rpc-provider';
-import {
-  createAsyncMiddleware,
   createScaffoldMiddleware,
-  JsonRpcEngine,
-  mergeMiddleware,
-} from '@metamask/json-rpc-engine';
-import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
-import type { Hex, Json, JsonRpcParams } from '@metamask/utils';
+  JsonRpcEngineV2,
+  JsonRpcServer,
+} from '@metamask/json-rpc-engine/v2';
+import type {
+  JsonRpcMiddleware,
+  MiddlewareContext,
+} from '@metamask/json-rpc-engine/v2';
+import type { Hex, Json, JsonRpcRequest } from '@metamask/utils';
 import type { Logger } from 'loglevel';
 
 import type { NetworkControllerMessenger } from './NetworkController';
@@ -49,6 +50,12 @@ export type NetworkClient = {
   destroy: () => void;
 };
 
+type RpcApiMiddleware = JsonRpcMiddleware<
+  JsonRpcRequest,
+  Json,
+  MiddlewareContext<{ origin: string }>
+>;
+
 /**
  * Create a JSON RPC network client for a specific network.
  *
@@ -136,17 +143,21 @@ export function createNetworkClient({
     });
   });
 
-  const rpcApiMiddleware =
-    configuration.type === NetworkClientType.Infura
-      ? createInfuraMiddleware({
-          rpcService: rpcServiceChain,
-          options: {
-            source: 'metamask',
-          },
-        })
-      : createFetchMiddleware({ rpcService: rpcServiceChain });
+  let rpcApiMiddleware: RpcApiMiddleware;
+  if (configuration.type === NetworkClientType.Infura) {
+    rpcApiMiddleware = asV2Middleware(
+      createInfuraMiddleware({
+        rpcService: rpcServiceChain,
+        options: {
+          source: 'metamask',
+        },
+      }),
+    ) as unknown as RpcApiMiddleware;
+  } else {
+    rpcApiMiddleware = createFetchMiddleware({ rpcService: rpcServiceChain });
+  }
 
-  const rpcProvider = providerFromMiddleware(rpcApiMiddleware);
+  const rpcProvider = providerFromMiddlewareV2(rpcApiMiddleware);
 
   const blockTracker = createBlockTracker({
     networkClientType: configuration.type,
@@ -169,11 +180,9 @@ export function createNetworkClient({
           rpcApiMiddleware,
         });
 
-  const engine = new JsonRpcEngine();
-
-  engine.push(networkMiddleware);
-
-  const provider = new InternalProvider({ engine });
+  const provider = new InternalProvider({
+    server: new JsonRpcServer({ middleware: [networkMiddleware] }),
+  });
 
   const destroy = () => {
     // TODO: Either fix this lint violation or explain why it's necessary to ignore.
@@ -240,17 +249,19 @@ function createInfuraNetworkMiddleware({
   blockTracker: PollingBlockTracker;
   network: InfuraNetworkType;
   rpcProvider: InternalProvider;
-  rpcApiMiddleware: JsonRpcMiddleware<JsonRpcParams, Json>;
+  rpcApiMiddleware: RpcApiMiddleware;
 }) {
-  return mergeMiddleware([
-    createNetworkAndChainIdMiddleware({ network }),
-    createBlockCacheMiddleware({ blockTracker }),
-    createInflightCacheMiddleware(),
-    createBlockRefMiddleware({ blockTracker, provider: rpcProvider }),
-    createRetryOnEmptyMiddleware({ blockTracker, provider: rpcProvider }),
-    createBlockTrackerInspectorMiddleware({ blockTracker }),
-    rpcApiMiddleware,
-  ]);
+  return JsonRpcEngineV2.create({
+    middleware: [
+      createNetworkAndChainIdMiddleware({ network }),
+      createBlockCacheMiddleware({ blockTracker }),
+      createInflightCacheMiddleware(),
+      createBlockRefMiddleware({ blockTracker, provider: rpcProvider }),
+      createRetryOnEmptyMiddleware({ blockTracker, provider: rpcProvider }),
+      createBlockTrackerInspectorMiddleware({ blockTracker }),
+      rpcApiMiddleware,
+    ],
+  }).asMiddleware();
 }
 
 /**
@@ -272,11 +283,10 @@ function createNetworkAndChainIdMiddleware({
 
 const createChainIdMiddleware = (
   chainId: Hex,
-): JsonRpcMiddleware<JsonRpcParams, Json> => {
-  return (req, res, next, end) => {
-    if (req.method === 'eth_chainId') {
-      res.result = chainId;
-      return end();
+): JsonRpcMiddleware<JsonRpcRequest, Json> => {
+  return ({ request, next }) => {
+    if (request.method === 'eth_chainId') {
+      return chainId;
     }
     return next();
   };
@@ -298,21 +308,23 @@ function createCustomNetworkMiddleware({
 }: {
   blockTracker: PollingBlockTracker;
   chainId: Hex;
-  rpcApiMiddleware: JsonRpcMiddleware<JsonRpcParams, Json>;
-}): JsonRpcMiddleware<JsonRpcParams, Json> {
+  rpcApiMiddleware: RpcApiMiddleware;
+}) {
   const testMiddlewares = process.env.IN_TEST
     ? [createEstimateGasDelayTestMiddleware()]
     : [];
 
-  return mergeMiddleware([
-    ...testMiddlewares,
-    createChainIdMiddleware(chainId),
-    createBlockRefRewriteMiddleware({ blockTracker }),
-    createBlockCacheMiddleware({ blockTracker }),
-    createInflightCacheMiddleware(),
-    createBlockTrackerInspectorMiddleware({ blockTracker }),
-    rpcApiMiddleware,
-  ]);
+  return JsonRpcEngineV2.create({
+    middleware: [
+      ...testMiddlewares,
+      createChainIdMiddleware(chainId),
+      createBlockRefRewriteMiddleware({ blockTracker }),
+      createBlockCacheMiddleware({ blockTracker }),
+      createInflightCacheMiddleware(),
+      createBlockTrackerInspectorMiddleware({ blockTracker }),
+      rpcApiMiddleware,
+    ],
+  }).asMiddleware();
 }
 
 /**
@@ -321,11 +333,14 @@ function createCustomNetworkMiddleware({
  *
  * @returns The middleware for delaying gas estimation calls by 2 seconds when in test.
  */
-function createEstimateGasDelayTestMiddleware() {
-  return createAsyncMiddleware(async (req, _, next) => {
-    if (req.method === 'eth_estimateGas') {
+function createEstimateGasDelayTestMiddleware(): JsonRpcMiddleware<
+  JsonRpcRequest,
+  Json
+> {
+  return async ({ request, next }) => {
+    if (request.method === 'eth_estimateGas') {
       await new Promise((resolve) => setTimeout(resolve, SECOND * 2));
     }
     return next();
-  });
+  };
 }

packages/network-controller/tests/NetworkController.test.ts

@@ -16802,6 +16802,7 @@ async function waitForPublishedEvents<E extends NetworkControllerEvents>({
           if (interestingEventPayloads.length === expectedNumberOfEvents) {
             resolve(interestingEventPayloads);
           } else {
+            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
             reject(
               new Error(
                 `Expected to receive ${expectedNumberOfEvents} ${String(eventType)} event(s), but received ${