refactor: Migrate create-network-client

Author: rekmarks

eslint-warning-thresholds.json

@@ -317,13 +317,6 @@
   "packages/name-controller/src/util.ts": {
     "jsdoc/require-returns": 1
   },
-  "packages/network-controller/src/NetworkController.ts": {
-    "@typescript-eslint/prefer-promise-reject-errors": 1
-  },
-  "packages/network-controller/tests/NetworkController.test.ts": {
-    "@typescript-eslint/no-unused-vars": 1,
-    "@typescript-eslint/prefer-promise-reject-errors": 1
-  },
   "packages/network-controller/tests/create-network-client.test.ts": {
     "import-x/order": 1
   },

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/eth-json-rpc-provider/src/internal-provider.ts

@@ -26,17 +26,28 @@ type Eip1193Request<Params extends JsonRpcParams> = {
   params?: Params;
 };
 
-type Options =
+/**
+ * The {@link JsonRpcMiddleware} constraint and default type for the {@link InternalProvider}.
+ * We care that the middleware can handle JSON-RPC requests, but do not care about the context,
+ * the validity of which is enforced by the {@link JsonRpcServer}.
+ */
+export type InternalProviderMiddleware = JsonRpcMiddleware<
+  JsonRpcRequest,
+  Json,
+  // Non-polluting `any` constraint.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  any
+>;
+
+type Options<Middleware extends InternalProviderMiddleware> =
   | {
       /**
        * @deprecated Use `rpcHandler` instead.
        */
       engine: JsonRpcEngine;
     }
   | {
-      rpcHandler:
-        | JsonRpcEngine
-        | JsonRpcServer<JsonRpcMiddleware<JsonRpcRequest>>;
+      rpcHandler: JsonRpcEngine | JsonRpcServer<Middleware>;
     };
 
 /**
@@ -45,10 +56,10 @@ type Options =
  * This provider loosely follows conventions that pre-date EIP-1193.
  * It is not compliant with any Ethereum provider standard.
  */
-export class InternalProvider {
-  readonly #rpcHandler:
-    | JsonRpcEngine
-    | JsonRpcServer<JsonRpcMiddleware<JsonRpcRequest>>;
+export class InternalProvider<
+  Middleware extends InternalProviderMiddleware = InternalProviderMiddleware,
+> {
+  readonly #rpcHandler: JsonRpcEngine | JsonRpcServer<Middleware>;
 
   /**
    * Construct a InternalProvider from a JSON-RPC server or legacy engine.
@@ -57,7 +68,7 @@ export class InternalProvider {
    * @param options.rpcHandler - The JSON-RPC server or engine used to process requests. Mutually exclusive with `engine`.
    * @param options.engine - The JSON-RPC engine used to process requests. Mutually exclusive with `rpcHandler`.
    */
-  constructor(options: Options) {
+  constructor(options: Options<Middleware>) {
     this.#rpcHandler =
       'rpcHandler' in options ? options.rpcHandler : options.engine;
   }

packages/eth-json-rpc-provider/src/provider-from-middleware.ts

@@ -1,9 +1,9 @@
 import { JsonRpcEngine } from '@metamask/json-rpc-engine';
 import type { JsonRpcMiddleware as LegacyJsonRpcMiddleware } from '@metamask/json-rpc-engine';
 import { JsonRpcServer } from '@metamask/json-rpc-engine/v2';
-import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine/v2';
-import type { Json, JsonRpcParams, JsonRpcRequest } from '@metamask/utils';
+import type { Json, JsonRpcParams } from '@metamask/utils';
 
+import type { InternalProviderMiddleware } from './internal-provider';
 import { InternalProvider } from './internal-provider';
 import { providerFromEngine } from './provider-from-engine';
 
@@ -31,7 +31,7 @@ export function providerFromMiddleware<
  * @returns An Ethereum provider.
  */
 export function providerFromMiddlewareV2<
-  Middleware extends JsonRpcMiddleware<JsonRpcRequest, Json>,
+  Middleware extends InternalProviderMiddleware,
 >(middleware: Middleware): InternalProvider {
   return new InternalProvider({
     rpcHandler: new JsonRpcServer({ middleware: [middleware] }),

packages/json-rpc-engine/src/v2/JsonRpcEngineV2.ts

@@ -91,11 +91,16 @@ type ContextOf<Middleware> =
     ? C
     : never;
 
-export type MergedContextOf<
-  // Non-polluting `any` constraint.
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Middleware extends JsonRpcMiddleware<any, any, any>,
-> = MergeContexts<ContextOf<Middleware>>;
+// Non-polluting `any` constraint.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type MiddlewareConstraint = JsonRpcMiddleware<
+  any,
+  ResultConstraint<any>,
+  MiddlewareContext<any>
+>;
+
+export type MergedContextOf<Middleware extends MiddlewareConstraint> =
+  MergeContexts<ContextOf<Middleware>>;
 
 const INVALID_ENGINE = Symbol('Invalid engine');
 

packages/json-rpc-engine/src/v2/JsonRpcServer.ts

@@ -11,16 +11,16 @@ import { hasProperty, isObject } from '@metamask/utils';
 import type {
   JsonRpcMiddleware,
   MergedContextOf,
+  MiddlewareConstraint,
   RequestOf,
-  ResultConstraint,
 } from './JsonRpcEngineV2';
 import { JsonRpcEngineV2 } from './JsonRpcEngineV2';
 import type { JsonRpcCall } from './utils';
 import { getUniqueId } from '../getUniqueId';
 
 type OnError = (error: unknown) => void;
 
-type Options<Middleware extends JsonRpcMiddleware> = {
+type Options<Middleware extends MiddlewareConstraint> = {
   onError?: OnError;
 } & (
   | {
@@ -58,14 +58,7 @@ const jsonrpc = '2.0' as const;
  * ```
  */
 export class JsonRpcServer<
-  Middleware extends JsonRpcMiddleware<
-    // Non-polluting `any` constraint.
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    any,
-    ResultConstraint<any>,
-    any
-    /* eslint-enable @typescript-eslint/no-explicit-any */
-  > = JsonRpcMiddleware,
+  Middleware extends MiddlewareConstraint = JsonRpcMiddleware,
 > {
   readonly #engine: JsonRpcEngineV2<
     RequestOf<Middleware>,
@@ -202,7 +195,7 @@ export class JsonRpcServer<
     }
 
     if (isRequest) {
-      (request as JsonRpcRequest).id = getUniqueId();
+      (request as JsonRpcRequest).id = String(getUniqueId());
     }
 
     return request;

packages/network-controller/src/NetworkController.ts

@@ -705,8 +705,6 @@ function getDefaultInfuraNetworkConfigurationsByChainId(): Record<
     }
 
     const rpcEndpointUrl =
-      // False positive - this is a string.
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
       `https://${infuraNetworkType}.infura.io/v3/{infuraProjectId}` as const;
 
     const networkConfiguration: NetworkConfiguration = {
@@ -1893,6 +1891,8 @@ export class NetworkController extends BaseController<
         { method: 'eth_getBlockByNumber', params: ['latest', false] },
         (error: unknown, block?: unknown) => {
           if (error) {
+            // We have no good reason to do this except long precedent.
+            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
             reject(error);
           } else {
             // TODO: Validate this type
@@ -2423,6 +2423,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,19 +12,19 @@ import {
   createFetchMiddleware,
   createRetryOnEmptyMiddleware,
 } from '@metamask/eth-json-rpc-middleware';
-import type { InternalProvider } from '@metamask/eth-json-rpc-provider';
+import { InternalProvider } from '@metamask/eth-json-rpc-provider';
+import { providerFromMiddlewareV2 } from '@metamask/eth-json-rpc-provider';
+import { asV2Middleware } from '@metamask/json-rpc-engine';
 import {
-  providerFromEngine,
-  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';
@@ -50,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.
  *
@@ -137,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,
@@ -170,11 +180,9 @@ export function createNetworkClient({
           rpcApiMiddleware,
         });
 
-  const engine = new JsonRpcEngine();
-
-  engine.push(networkMiddleware);
-
-  const provider = providerFromEngine(engine);
+  const provider = new InternalProvider({
+    rpcHandler: new JsonRpcServer({ middleware: [networkMiddleware] }),
+  });
 
   const destroy = () => {
     // TODO: Either fix this lint violation or explain why it's necessary to ignore.
@@ -241,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();
 }
 
 /**
@@ -273,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();
   };
@@ -299,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();
 }
 
 /**
@@ -322,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();
-  });
+  };
 }