feat: make SafeEventEmitterProvider compatible with eth req libraries

packages/assets-controllers/src/AssetsContractController.ts

@@ -198,7 +198,6 @@ export class AssetsContractController extends BaseControllerV1<
       throw new Error(MISSING_PROVIDER_ERROR);
     }
 
-    // @ts-expect-error TODO: remove this annotation once the `Eip1193Provider` class is released
     return new Web3Provider(provider);
   }
 

packages/eth-json-rpc-provider/package.json

@@ -48,12 +48,17 @@
   "dependencies": {
     "@metamask/json-rpc-engine": "^9.0.0",
     "@metamask/safe-event-emitter": "^3.0.0",
-    "@metamask/utils": "^8.3.0"
+    "@metamask/utils": "^8.3.0",
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
+    "@ethersproject/providers": "^5.7.0",
     "@metamask/auto-changelog": "^3.4.4",
+    "@metamask/eth-query": "^4.0.0",
+    "@metamask/ethjs-query": "^0.5.3",
     "@types/jest": "^27.4.1",
     "deepmerge": "^4.2.2",
+    "ethers": "^6.12.0",
     "jest": "^27.5.1",
     "jest-it-up": "^2.0.2",
     "ts-jest": "^27.1.4",

packages/eth-json-rpc-provider/src/index.ts

@@ -1,3 +1,6 @@
 export * from './provider-from-engine';
 export * from './provider-from-middleware';
-export { SafeEventEmitterProvider } from './safe-event-emitter-provider';
+export {
+  SafeEventEmitterProvider,
+  type Eip1193Request,
+} from './safe-event-emitter-provider';

packages/eth-json-rpc-provider/src/safe-event-emitter-provider.test.ts

@@ -1,7 +1,38 @@
+import { Web3Provider } from '@ethersproject/providers';
+import EthQuery from '@metamask/eth-query';
+import EthJsQuery from '@metamask/ethjs-query';
 import { JsonRpcEngine } from '@metamask/json-rpc-engine';
+import {
+  type JsonRpcSuccess,
+  type Json,
+  assertIsJsonRpcFailure,
+} from '@metamask/utils';
+import { BrowserProvider } from 'ethers';
 import { promisify } from 'util';
 
-import { SafeEventEmitterProvider } from './safe-event-emitter-provider';
+import {
+  SafeEventEmitterProvider,
+  convertEip1193RequestToJsonRpcRequest,
+} from './safe-event-emitter-provider';
+
+/**
+ * Creates a mock JSON-RPC engine that returns a predefined response for a specific method.
+ *
+ * @param method - The RPC method to mock.
+ * @param response - The response to return for the mocked method.
+ * @returns A JSON-RPC engine instance with the mocked method.
+ */
+function createMockEngine(method: string, response: Json) {
+  const engine = new JsonRpcEngine();
+  engine.push((req, res, next, end) => {
+    if (req.method === method) {
+      res.result = response;
+      return end();
+    }
+    return next();
+  });
+  return engine;
+}
 
 describe('SafeEventEmitterProvider', () => {
   describe('constructor', () => {
@@ -30,6 +61,88 @@ describe('SafeEventEmitterProvider', () => {
     });
   });
 
+  it('returns the correct block number with @metamask/eth-query', async () => {
+    const provider = new SafeEventEmitterProvider({
+      engine: createMockEngine('eth_blockNumber', 42),
+    });
+    const ethQuery = new EthQuery(provider);
+
+    ethQuery.sendAsync({ method: 'eth_blockNumber' }, (_error, response) => {
+      expect(response).toBe(42);
+    });
+  });
+
+  it('returns the correct block number with @metamask/ethjs-query', async () => {
+    const provider = new SafeEventEmitterProvider({
+      engine: createMockEngine('eth_blockNumber', 42),
+    });
+    const ethJsQuery = new EthJsQuery(provider);
+
+    const response = await ethJsQuery.blockNumber();
+
+    expect(response.toNumber()).toBe(42);
+  });
+
+  it('returns the correct block number with Web3Provider', async () => {
+    const provider = new SafeEventEmitterProvider({
+      engine: createMockEngine('eth_blockNumber', 42),
+    });
+    const web3Provider = new Web3Provider(provider);
+
+    const response = await web3Provider.send('eth_blockNumber', []);
+
+    expect(response.result).toBe(42);
+  });
+
+  it('returns the correct block number with BrowserProvider', async () => {
+    const provider = new SafeEventEmitterProvider({
+      engine: createMockEngine('eth_blockNumber', 42),
+    });
+    const browserProvider = new BrowserProvider(provider);
+
+    const response = await browserProvider.send('eth_blockNumber', []);
+
+    expect(response.result).toBe(42);
+  });
+
+  describe('request', () => {
+    it('handles a successful request', async () => {
+      const engine = new JsonRpcEngine();
+      engine.push((_req, res, _next, end) => {
+        res.result = 42;
+        end();
+      });
+      const provider = new SafeEventEmitterProvider({ engine });
+      const exampleRequest = {
+        id: 1,
+        jsonrpc: '2.0' as const,
+        method: 'test',
+      };
+
+      const response = await provider.request(exampleRequest);
+
+      expect((response as JsonRpcSuccess<Json>).result).toBe(42);
+    });
+
+    it('handles a failed request', async () => {
+      const engine = new JsonRpcEngine();
+      engine.push((_req, _res, _next, _end) => {
+        throw new Error('Test error');
+      });
+      const provider = new SafeEventEmitterProvider({ engine });
+      const exampleRequest = {
+        id: 1,
+        jsonrpc: '2.0' as const,
+        method: 'test',
+      };
+
+      const response = await provider.request(exampleRequest);
+
+      expect(response).toBeDefined();
+      assertIsJsonRpcFailure(response);
+    });
+  });
+
   describe('sendAsync', () => {
     it('handles a successful request', async () => {
       const engine = new JsonRpcEngine();
@@ -122,3 +235,90 @@ describe('SafeEventEmitterProvider', () => {
     });
   });
 });
+
+describe('convertEip1193RequestToJsonRpcRequest', () => {
+  it('generates a unique id if id is not provided', () => {
+    const eip1193Request = {
+      method: 'test',
+      params: { param1: 'value1', param2: 'value2' },
+    };
+
+    const jsonRpcRequest =
+      convertEip1193RequestToJsonRpcRequest(eip1193Request);
+
+    expect(jsonRpcRequest).toStrictEqual({
+      id: expect.any(String),
+      jsonrpc: '2.0',
+      method: 'test',
+      params: { param1: 'value1', param2: 'value2' },
+    });
+  });
+
+  it('uses the provided id if id is provided', () => {
+    const eip1193Request = {
+      id: '123',
+      method: 'test',
+      params: { param1: 'value1', param2: 'value2' },
+    };
+    const jsonRpcRequest =
+      convertEip1193RequestToJsonRpcRequest(eip1193Request);
+
+    expect(jsonRpcRequest).toStrictEqual({
+      id: '123',
+      jsonrpc: '2.0',
+      method: 'test',
+      params: { param1: 'value1', param2: 'value2' },
+    });
+  });
+
+  it('uses the default jsonrpc version if not provided', () => {
+    const eip1193Request = {
+      method: 'test',
+      params: { param1: 'value1', param2: 'value2' },
+    };
+
+    const jsonRpcRequest =
+      convertEip1193RequestToJsonRpcRequest(eip1193Request);
+
+    expect(jsonRpcRequest).toStrictEqual({
+      id: expect.any(String),
+      jsonrpc: '2.0',
+      method: 'test',
+      params: { param1: 'value1', param2: 'value2' },
+    });
+  });
+
+  it('uses the provided jsonrpc version if provided', () => {
+    const eip1193Request = {
+      jsonrpc: '2.0' as const,
+      method: 'test',
+      params: { param1: 'value1', param2: 'value2' },
+    };
+
+    const jsonRpcRequest =
+      convertEip1193RequestToJsonRpcRequest(eip1193Request);
+
+    expect(jsonRpcRequest).toStrictEqual({
+      id: expect.any(String),
+      jsonrpc: '2.0',
+      method: 'test',
+      params: { param1: 'value1', param2: 'value2' },
+    });
+  });
+
+  it('uses an empty object as params if not provided', () => {
+    const eip1193Request = {
+      method: 'test',
+    };
+
+    const jsonRpcRequest =
+      convertEip1193RequestToJsonRpcRequest(eip1193Request);
+
+    expect(jsonRpcRequest).toStrictEqual({
+      id: expect.any(String),
+      jsonrpc: '2.0',
+      method: 'test',
+      params: {},
+    });
+  });
+});

packages/eth-json-rpc-provider/src/safe-event-emitter-provider.ts

@@ -1,6 +1,48 @@
 import type { JsonRpcEngine } from '@metamask/json-rpc-engine';
 import SafeEventEmitter from '@metamask/safe-event-emitter';
-import type { JsonRpcRequest } from '@metamask/utils';
+import type {
+  Json,
+  JsonRpcId,
+  JsonRpcParams,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  JsonRpcVersion2,
+} from '@metamask/utils';
+import { v4 as uuidV4 } from 'uuid';
+
+/**
+ * A JSON-RPC request conforming to the EIP-1193 specification.
+ */
+export type Eip1193Request<Params extends JsonRpcParams> = {
+  id?: JsonRpcId;
+  jsonrpc?: JsonRpcVersion2;
+  method: string;
+  params?: Params;
+};
+
+/**
+ * Converts an EIP-1193 request to a JSON-RPC request.
+ *
+ * @param eip1193Request - The EIP-1193 request to convert.
+ * @returns The corresponding JSON-RPC request.
+ */
+export function convertEip1193RequestToJsonRpcRequest<
+  Params extends JsonRpcParams,
+>(eip1193Request: Eip1193Request<Params>) {
+  const {
+    id = uuidV4(),
+    jsonrpc = '2.0',
+    method,
+    params = {},
+  } = eip1193Request;
+  const jsonRpcRequest: JsonRpcRequest<Params | Record<never, never>> = {
+    id,
+    jsonrpc,
+    method,
+    params,
+  };
+  return jsonRpcRequest;
+}
 
 /**
  * An Ethereum provider.
@@ -31,37 +73,61 @@ export class SafeEventEmitterProvider extends SafeEventEmitter {
   /**
    * Send a provider request asynchronously.
    *
-   * @param req - The request to send.
+   * @param eip1193Request - The request to send.
+   * @returns The JSON-RPC response.
+   */
+  async request<Params extends JsonRpcParams, Result extends Json>(
+    eip1193Request: Eip1193Request<Params>,
+  ): Promise<JsonRpcResponse<Result>> {
+    const jsonRpcRequest =
+      convertEip1193RequestToJsonRpcRequest(eip1193Request);
+    return this.#engine.handle<Params | Record<never, never>, Result>(
+      jsonRpcRequest,
+    );
+  }
+
+  /**
+   * Send a provider request asynchronously.
+   *
+   * This method serves the same purpose as `request`. It only exists for
+   * legacy reasons.
+   *
+   * @param eip1193Request - The request to send.
    * @param callback - A function that is called upon the success or failure of the request.
+   * @deprecated Please use `request` instead.
    */
-  sendAsync = (
-    req: JsonRpcRequest,
+  sendAsync = <Params extends JsonRpcParams>(
+    eip1193Request: Eip1193Request<Params>,
     // TODO: Replace `any` with type
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     callback: (error: unknown, providerRes?: any) => void,
   ) => {
-    this.#engine.handle(req, callback);
+    const jsonRpcRequest =
+      convertEip1193RequestToJsonRpcRequest(eip1193Request);
+    this.#engine.handle(jsonRpcRequest, callback);
   };
 
   /**
    * Send a provider request asynchronously.
    *
-   * This method serves the same purpose as `sendAsync`. It only exists for
+   * This method serves the same purpose as `request`. It only exists for
    * legacy reasons.
    *
-   * @deprecated Use `sendAsync` instead.
-   * @param req - The request to send.
+   * @param eip1193Request - The request to send.
    * @param callback - A function that is called upon the success or failure of the request.
+   * @deprecated Please use `sendAsync` instead.
    */
-  send = (
-    req: JsonRpcRequest,
+  send = <Params extends JsonRpcParams>(
+    eip1193Request: Eip1193Request<Params>,
     // TODO: Replace `any` with type
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     callback: (error: unknown, providerRes?: any) => void,
   ) => {
     if (typeof callback !== 'function') {
       throw new Error('Must provide callback to "send" method.');
     }
-    this.#engine.handle(req, callback);
+    const jsonRpcRequest =
+      convertEip1193RequestToJsonRpcRequest(eip1193Request);
+    this.#engine.handle(jsonRpcRequest, callback);
   };
 }