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,18 @@
   "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",
+    "@metamask/rpc-errors": "^6.2.1",
     "@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/provider-from-engine.test.ts

@@ -1,5 +1,5 @@
 import { JsonRpcEngine } from '@metamask/json-rpc-engine';
-import { promisify } from 'util';
+import { providerErrors } from '@metamask/rpc-errors';
 
 import { providerFromEngine } from './provider-from-engine';
 
@@ -11,33 +11,36 @@ describe('providerFromEngine', () => {
       end();
     });
     const provider = providerFromEngine(engine);
-    const promisifiedSendAsync = promisify(provider.sendAsync);
     const exampleRequest = {
       id: 1,
       jsonrpc: '2.0' as const,
       method: 'test',
     };
 
-    const response = await promisifiedSendAsync(exampleRequest);
+    const response = await provider.request(exampleRequest);
 
-    expect(response.result).toBe(42);
+    expect(response).toBe(42);
   });
 
   it('handle a failed request', async () => {
     const engine = new JsonRpcEngine();
-    engine.push((_req, _res, _next, _end) => {
-      throw new Error('Test error');
+    engine.push((_req, _res, _next, end) => {
+      end(
+        providerErrors.custom({
+          code: 1001,
+          message: 'Test error',
+        }),
+      );
     });
     const provider = providerFromEngine(engine);
-    const promisifiedSendAsync = promisify(provider.sendAsync);
     const exampleRequest = {
       id: 1,
       jsonrpc: '2.0' as const,
       method: 'test',
     };
 
-    await expect(async () =>
-      promisifiedSendAsync(exampleRequest),
-    ).rejects.toThrow('Test error');
+    await expect(async () => provider.request(exampleRequest)).rejects.toThrow(
+      'Test error',
+    );
   });
 });

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

@@ -1,5 +1,5 @@
 import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
-import { promisify } from 'util';
+import { providerErrors } from '@metamask/rpc-errors';
 
 import { providerFromMiddleware } from './provider-from-middleware';
 
@@ -12,32 +12,34 @@ describe('providerFromMiddleware', () => {
       end();
     };
     const provider = providerFromMiddleware(middleware);
-    const promisifiedSendAsync = promisify(provider.sendAsync);
     const exampleRequest = {
       id: 1,
       jsonrpc: '2.0' as const,
       method: 'test',
     };
 
-    const response = await promisifiedSendAsync(exampleRequest);
+    const response = await provider.request(exampleRequest);
 
-    expect(response.result).toBe(42);
+    expect(response).toBe(42);
   });
 
   it('handle a failed request', async () => {
-    const middleware = () => {
-      throw new Error('Test error');
-    };
-    const provider = providerFromMiddleware(middleware);
-    const promisifiedSendAsync = promisify(provider.sendAsync);
+    const provider = providerFromMiddleware((_req, _res, _next, end) => {
+      end(
+        providerErrors.custom({
+          code: 1001,
+          message: 'Test error',
+        }),
+      );
+    });
     const exampleRequest = {
       id: 1,
       jsonrpc: '2.0' as const,
       method: 'test',
     };
 
-    await expect(async () =>
-      promisifiedSendAsync(exampleRequest),
-    ).rejects.toThrow('Test error');
+    await expect(async () => provider.request(exampleRequest)).rejects.toThrow(
+      'Test error',
+    );
   });
 });

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

@@ -1,7 +1,35 @@
+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 { providerErrors } from '@metamask/rpc-errors';
+import { type Json } 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 +58,92 @@ 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).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).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).toBe(42);
+    });
+
+    it('handles a failed request', async () => {
+      const engine = new JsonRpcEngine();
+      engine.push((_req, _res, _next, end) => {
+        end(
+          providerErrors.custom({
+            code: 1001,
+            message: 'Test error',
+          }),
+        );
+      });
+      const provider = new SafeEventEmitterProvider({ engine });
+      const exampleRequest = {
+        id: 1,
+        jsonrpc: '2.0' as const,
+        method: 'test',
+      };
+
+      await expect(async () =>
+        provider.request(exampleRequest),
+      ).rejects.toThrow('Test error');
+    });
+  });
+
   describe('sendAsync', () => {
     it('handles a successful request', async () => {
       const engine = new JsonRpcEngine();
@@ -122,3 +236,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: {},
+    });
+  });
+});