BREAKING: Transaction Insight API

packages/controllers/jest.config.js

@@ -8,10 +8,10 @@ module.exports = {
   coveragePathIgnorePatterns: ['/node_modules/', '/mocks/', '/test/'],
   coverageThreshold: {
     global: {
-      branches: 82.53,
-      functions: 95.63,
-      lines: 93.84,
-      statements: 93.87,
+      branches: 82.31,
+      functions: 95.69,
+      lines: 93.79,
+      statements: 93.83,
     },
   },
   globals: {

packages/controllers/src/services/AbstractExecutionService.test.ts

@@ -1,4 +1,5 @@
 import { ControllerMessenger } from '@metamask/controllers';
+import { HandlerType } from '@metamask/snap-utils';
 import {
   ErrorMessageEvent,
   ExecutionServiceMessenger,
@@ -127,9 +128,13 @@ describe('AbstractExecutionService', () => {
 
     const snapId = 'TestSnap';
     await expect(
-      service.handleRpcRequest(snapId, 'foo.com', {
-        id: 6,
-        method: 'bar',
+      service.handleRpcRequest(snapId, {
+        origin: 'foo.com',
+        handler: HandlerType.OnRpcRequest,
+        request: {
+          id: 6,
+          method: 'bar',
+        },
       }),
     ).rejects.toThrow(
       `Snap execution service returned no RPC handler for running snap "${snapId}".`,

packages/controllers/src/services/AbstractExecutionService.ts

@@ -1,7 +1,12 @@
 import { Duplex } from 'stream';
 import ObjectMultiplex from '@metamask/object-multiplex';
-import { ErrorJSON, SnapExecutionData } from '@metamask/snap-types';
-import { SNAP_STREAM_NAMES } from '@metamask/execution-environments';
+import {
+  ErrorJSON,
+  SnapExecutionData,
+  SnapRpcHook,
+  SnapRpcHookArgs,
+} from '@metamask/snap-types';
+import { SNAP_STREAM_NAMES } from '@metamask/snap-utils';
 import {
   Duration,
   isJsonRpcRequest,
@@ -34,12 +39,6 @@ export type ExecutionServiceArgs = {
   terminationTimeout?: number;
 };
 
-// The snap is the callee
-export type SnapRpcHook = (
-  origin: string,
-  request: Record<string, unknown>,
-) => Promise<unknown>;
-
 export type JobStreams = {
   command: Duplex;
   rpc: Duplex;
@@ -93,8 +92,8 @@ export abstract class AbstractExecutionService<WorkerType>
   private registerMessageHandlers(): void {
     this._messenger.registerActionHandler(
       `${controllerName}:handleRpcRequest`,
-      (snapId: string, origin: string, _request: Record<string, unknown>) =>
-        this.handleRpcRequest(snapId, origin, _request),
+      (snapId: string, options: SnapRpcHookArgs) =>
+        this.handleRpcRequest(snapId, options),
     );
 
     this._messenger.registerActionHandler(
@@ -379,16 +378,14 @@ export abstract class AbstractExecutionService<WorkerType>
   }
 
   protected _createSnapHooks(snapId: string, workerId: string) {
-    const rpcHook = async (
-      origin: string,
-      request: Record<string, unknown>,
-    ) => {
+    const rpcHook = async ({ origin, handler, request }: SnapRpcHookArgs) => {
       return await this._command(workerId, {
         id: nanoid(),
         jsonrpc: '2.0',
         method: 'snapRpc',
         params: {
           origin,
+          handler,
           request,
           target: snapId,
         },
@@ -438,14 +435,12 @@ export abstract class AbstractExecutionService<WorkerType>
    * Handle RPC request.
    *
    * @param snapId - The ID of the recipient snap.
-   * @param origin - The origin of the RPC request.
-   * @param request - The JSON-RPC request object.
+   * @param options - Bag of options to pass to the RPC handler.
    * @returns Promise that can handle the request.
    */
   public async handleRpcRequest(
     snapId: string,
-    origin: string,
-    request: Record<string, unknown>,
+    options: SnapRpcHookArgs,
   ): Promise<unknown> {
     const rpcRequestHandler = await this.getRpcRequestHandler(snapId);
 
@@ -455,7 +450,7 @@ export abstract class AbstractExecutionService<WorkerType>
       );
     }
 
-    return rpcRequestHandler(origin, request);
+    return rpcRequestHandler(options);
   }
 }
 

packages/controllers/src/services/ExecutionService.ts

@@ -1,13 +1,18 @@
 import { RestrictedControllerMessenger } from '@metamask/controllers';
-import { SnapExecutionData, SnapId, ErrorJSON } from '@metamask/snap-types';
+import { SnapId } from '@metamask/snap-utils';
+import {
+  SnapExecutionData,
+  ErrorJSON,
+  SnapRpcHookArgs,
+} from '@metamask/snap-types';
 
 type TerminateSnap = (snapId: string) => Promise<void>;
 type TerminateAll = () => Promise<void>;
 type ExecuteSnap = (snapData: SnapExecutionData) => Promise<unknown>;
+
 type HandleRpcRequest = (
   snapId: string,
-  origin: string,
-  _request: Record<string, unknown>,
+  options: SnapRpcHookArgs,
 ) => Promise<unknown>;
 
 export interface ExecutionService {

packages/controllers/src/services/iframe/IframeExecutionService.test.ts

@@ -1,8 +1,8 @@
-import assert from 'assert';
 import { ControllerMessenger } from '@metamask/controllers';
 import { JsonRpcEngine } from 'json-rpc-engine';
 import { createEngineStream } from 'json-rpc-middleware-stream';
 import pump from 'pump';
+import { HandlerType } from '@metamask/snap-utils';
 import { ErrorMessageEvent } from '../ExecutionService';
 import { setupMultiplex } from '../AbstractExecutionService';
 import { IframeExecutionService } from './IframeExecutionService';
@@ -178,18 +178,16 @@ describe('IframeExecutionService', () => {
 
     expect(executeResult).toBe('OK');
 
-    const result = await iframeExecutionService.handleRpcRequest(
-      snapId,
-      'foo',
-      {
+    const result = await iframeExecutionService.handleRpcRequest(snapId, {
+      origin: 'foo',
+      handler: HandlerType.OnRpcRequest,
+      request: {
         jsonrpc: '2.0',
         id: 1,
         method: 'foobar',
         params: [],
       },
-    );
-
-    assert(result !== undefined);
+    });
 
     expect(result).toBe(blockNumber);
 

packages/controllers/src/services/iframe/test/server.ts

@@ -16,12 +16,8 @@ export async function start(port = PORT) {
       reject(new Error(`Invalid port: "${port}"`));
     }
 
-    const executionEnvPath = require.resolve(
-      '@metamask/execution-environments',
-    );
-    const bundlePath = path.resolve(
-      executionEnvPath,
-      '../../__test__/iframe-test/bundle.js',
+    const bundlePath = require.resolve(
+      '@metamask/execution-environments/__test__/iframe-test/bundle.js',
     );
     const publicPath = path.resolve(bundlePath, '../');
 

packages/controllers/src/services/node/NodeProcessExecutionService.test.ts

@@ -1,12 +1,15 @@
 import { ControllerMessenger } from '@metamask/controllers';
-import { ErrorJSON, SnapId } from '@metamask/snap-types';
+import { ErrorJSON } from '@metamask/snap-types';
+import { HandlerType, SnapId } from '@metamask/snap-utils';
 import { JsonRpcEngine } from 'json-rpc-engine';
 import { createEngineStream } from 'json-rpc-middleware-stream';
 import pump from 'pump';
 import { ErrorMessageEvent } from '../ExecutionService';
 import { setupMultiplex } from '../AbstractExecutionService';
 import { NodeProcessExecutionService } from './NodeProcessExecutionService';
 
+const ON_RPC_REQUEST = HandlerType.OnRpcRequest;
+
 describe('NodeProcessExecutionService', () => {
   it('can boot', async () => {
     const controllerMessenger = new ControllerMessenger<
@@ -119,11 +122,15 @@ describe('NodeProcessExecutionService', () => {
     });
 
     await expect(
-      service.handleRpcRequest(snapId, 'fooOrigin', {
-        jsonrpc: '2.0',
-        method: 'foo',
-        params: {},
-        id: 1,
+      service.handleRpcRequest(snapId, {
+        origin: 'fooOrigin',
+        handler: ON_RPC_REQUEST,
+        request: {
+          jsonrpc: '2.0',
+          method: 'foo',
+          params: {},
+          id: 1,
+        },
       }),
     ).rejects.toThrow('foobar');
     await service.terminateAllSnaps();
@@ -177,14 +184,18 @@ describe('NodeProcessExecutionService', () => {
       );
     });
 
-    const result = await service.handleRpcRequest(snapId, 'fooOrigin', {
-      jsonrpc: '2.0',
-      method: '',
-      params: {},
-      id: 1,
-    });
-
-    expect(result).toBe('foo');
+    expect(
+      await service.handleRpcRequest(snapId, {
+        origin: 'fooOrigin',
+        handler: ON_RPC_REQUEST,
+        request: {
+          jsonrpc: '2.0',
+          method: '',
+          params: {},
+          id: 1,
+        },
+      }),
+    ).toBe('foo');
 
     // eslint-disable-next-line jest/prefer-strict-equal
     expect(await unhandledErrorPromise).toEqual({
@@ -245,11 +256,15 @@ describe('NodeProcessExecutionService', () => {
 
     expect(executeResult).toBe('OK');
 
-    const result = await service.handleRpcRequest(snapId, 'foo', {
-      jsonrpc: '2.0',
-      id: 1,
-      method: 'foobar',
-      params: [],
+    const result = await service.handleRpcRequest(snapId, {
+      origin: 'foo',
+      handler: ON_RPC_REQUEST,
+      request: {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'foobar',
+        params: [],
+      },
     });
 
     expect(result).toBe(blockNumber);

packages/controllers/src/services/node/NodeThreadExecutionService.test.ts

@@ -1,12 +1,15 @@
 import { ControllerMessenger } from '@metamask/controllers';
-import { ErrorJSON, SnapId } from '@metamask/snap-types';
+import { ErrorJSON } from '@metamask/snap-types';
+import { HandlerType, SnapId } from '@metamask/snap-utils';
 import { JsonRpcEngine } from 'json-rpc-engine';
 import { createEngineStream } from 'json-rpc-middleware-stream';
 import pump from 'pump';
 import { ErrorMessageEvent } from '../ExecutionService';
 import { setupMultiplex } from '../AbstractExecutionService';
 import { NodeThreadExecutionService } from './NodeThreadExecutionService';
 
+const ON_RPC_REQUEST = HandlerType.OnRpcRequest;
+
 describe('NodeThreadExecutionService', () => {
   it('can boot', async () => {
     const controllerMessenger = new ControllerMessenger<
@@ -119,11 +122,15 @@ describe('NodeThreadExecutionService', () => {
     });
 
     await expect(
-      service.handleRpcRequest(snapId, 'fooOrigin', {
-        jsonrpc: '2.0',
-        method: 'foo',
-        params: {},
-        id: 1,
+      service.handleRpcRequest(snapId, {
+        origin: 'fooOrigin',
+        handler: ON_RPC_REQUEST,
+        request: {
+          jsonrpc: '2.0',
+          method: 'foo',
+          params: {},
+          id: 1,
+        },
       }),
     ).rejects.toThrow('foobar');
     await service.terminateAllSnaps();
@@ -177,14 +184,18 @@ describe('NodeThreadExecutionService', () => {
       );
     });
 
-    const result = await service.handleRpcRequest(snapId, 'fooOrigin', {
-      jsonrpc: '2.0',
-      method: '',
-      params: {},
-      id: 1,
-    });
-
-    expect(result).toBe('foo');
+    expect(
+      await service.handleRpcRequest(snapId, {
+        origin: 'fooOrigin',
+        handler: ON_RPC_REQUEST,
+        request: {
+          jsonrpc: '2.0',
+          method: '',
+          params: {},
+          id: 1,
+        },
+      }),
+    ).toBe('foo');
 
     // eslint-disable-next-line jest/prefer-strict-equal
     expect(await unhandledErrorPromise).toEqual({
@@ -245,11 +256,15 @@ describe('NodeThreadExecutionService', () => {
 
     expect(executeResult).toBe('OK');
 
-    const result = await service.handleRpcRequest(snapId, 'foo', {
-      jsonrpc: '2.0',
-      id: 1,
-      method: 'foobar',
-      params: [],
+    const result = await service.handleRpcRequest(snapId, {
+      origin: 'foo',
+      handler: ON_RPC_REQUEST,
+      request: {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'foobar',
+        params: [],
+      },
     });
 
     expect(result).toBe(blockNumber);