Get some tests running

Author: FrederikBolding

packages/snaps-controllers/src/interface/SnapInterfaceController.test.tsx

@@ -1617,7 +1617,7 @@ describe('SnapInterfaceController', () => {
 
       // TODO: Either fix this lint violation or explain why it's necessary to
       //  ignore.
-
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
       rootMessenger.call(
         'SnapInterfaceController:resolveInterface',
         MOCK_SNAP_ID,

packages/snaps-controllers/src/test-utils/controller.ts

@@ -8,7 +8,7 @@ import {
   generateSalt,
   isVaultUpdated,
 } from '@metamask/browser-passworder';
-import type { Messenger } from '@metamask/messenger';
+import { Messenger } from '@metamask/messenger';
 import type {
   PermissionConstraint,
   SubjectPermissions,
@@ -465,27 +465,17 @@ export const getSnapControllerMessenger = (
     typeof getControllerMessenger
   > = getControllerMessenger(),
 ) => {
-  const snapControllerMessenger = messenger.getRestricted<
+  const snapControllerMessenger = new Messenger<
     'SnapController',
-    SnapControllerActions['type'] | AllowedActions['type'],
-    SnapControllerEvents['type'] | AllowedEvents['type']
+    SnapControllerActions | AllowedActions,
+    SnapControllerEvents | AllowedEvents
   >({
-    name: 'SnapController',
-    allowedEvents: [
-      'ExecutionService:unhandledError',
-      'ExecutionService:outboundRequest',
-      'ExecutionService:outboundResponse',
-      'SnapController:snapAdded',
-      'SnapController:snapBlocked',
-      'SnapController:snapInstalled',
-      'SnapController:snapUninstalled',
-      'SnapController:snapUnblocked',
-      'SnapController:snapUpdated',
-      'SnapController:stateChange',
-      'SnapController:snapRolledback',
-      'KeyringController:lock',
-    ],
-    allowedActions: [
+    namespace: 'SnapController',
+    parent: messenger,
+  });
+
+  messenger.delegate({
+    actions: [
       'ApprovalController:addRequest',
       'ApprovalController:updateRequestState',
       'ExecutionService:executeSnap',
@@ -505,35 +495,22 @@ export const getSnapControllerMessenger = (
       'PermissionController:getSubjectNames',
       'PhishingController:testOrigin',
       'SelectedNetworkController:getNetworkClientIdForDomain',
-      'SnapController:get',
-      'SnapController:handleRequest',
-      'SnapController:getSnapState',
-      'SnapController:has',
-      'SnapController:updateSnapState',
-      'SnapController:clearSnapState',
-      'SnapController:updateBlockedSnaps',
-      'SnapController:enable',
-      'SnapController:disable',
-      'SnapController:remove',
-      'SnapController:getAll',
-      'SnapController:getRunnableSnaps',
-      'SnapController:getPermitted',
-      'SnapController:install',
-      'SnapController:incrementActiveReferences',
-      'SnapController:decrementActiveReferences',
-      'SnapController:getRegistryMetadata',
       'SubjectMetadataController:getSubjectMetadata',
       'SubjectMetadataController:addSubjectMetadata',
       'SnapsRegistry:get',
       'SnapsRegistry:getMetadata',
       'SnapsRegistry:update',
-      'SnapController:disconnectOrigin',
-      'SnapController:revokeDynamicPermissions',
-      'SnapController:getFile',
       'SnapsRegistry:resolveVersion',
       'SnapInterfaceController:createInterface',
       'SnapInterfaceController:getInterface',
     ],
+    events: [
+      'ExecutionService:unhandledError',
+      'ExecutionService:outboundRequest',
+      'ExecutionService:outboundResponse',
+      'KeyringController:lock',
+    ],
+    messenger: snapControllerMessenger,
   });
 
   jest.spyOn(snapControllerMessenger, 'call');
@@ -685,20 +662,17 @@ export const getRestrictedCronjobControllerMessenger = (
   > = getRootCronjobControllerMessenger(),
   mocked = true,
 ) => {
-  const cronjobControllerMessenger = messenger.getRestricted<
+  const cronjobControllerMessenger = new Messenger<
     'CronjobController',
-    CronjobControllerActions['type'] | AllowedActions['type'],
-    CronjobControllerEvents['type'] | AllowedEvents['type']
+    CronjobControllerActions | AllowedActions,
+    CronjobControllerEvents | AllowedEvents
   >({
-    name: 'CronjobController',
-    allowedEvents: [
-      'SnapController:snapInstalled',
-      'SnapController:snapUpdated',
-      'SnapController:snapUninstalled',
-      'SnapController:snapEnabled',
-      'SnapController:snapDisabled',
-    ],
-    allowedActions: [
+    namespace: 'CronjobController',
+    parent: messenger,
+  });
+
+  messenger.delegate({
+    actions: [
       'PermissionController:hasPermission',
       'PermissionController:getPermissions',
       'SnapController:getAll',
@@ -707,6 +681,14 @@ export const getRestrictedCronjobControllerMessenger = (
       'CronjobController:cancelBackgroundEvent',
       'CronjobController:getBackgroundEvents',
     ],
+    events: [
+      'SnapController:snapInstalled',
+      'SnapController:snapUpdated',
+      'SnapController:snapUninstalled',
+      'SnapController:snapEnabled',
+      'SnapController:snapDisabled',
+    ],
+    messenger: cronjobControllerMessenger,
   });
 
   if (mocked) {
@@ -751,22 +733,11 @@ export const getRestrictedSnapsRegistryControllerMessenger = (
     typeof getRootSnapsRegistryControllerMessenger
   > = getRootSnapsRegistryControllerMessenger(),
 ) => {
-  const controllerMessenger = messenger.getRestricted<
+  return new Messenger<
     'SnapsRegistry',
-    SnapsRegistryActions['type'],
-    SnapsRegistryEvents['type']
-  >({
-    name: 'SnapsRegistry',
-    allowedEvents: [],
-    allowedActions: [
-      'SnapsRegistry:get',
-      'SnapsRegistry:getMetadata',
-      'SnapsRegistry:update',
-      'SnapsRegistry:resolveVersion',
-    ],
-  });
-
-  return controllerMessenger;
+    SnapsRegistryActions,
+    SnapsRegistryEvents
+  >({ namespace: 'SnapsRegistry', parent: messenger });
 };
 
 // Mock controller messenger for Interface Controller
@@ -787,13 +758,14 @@ export const getRestrictedSnapInterfaceControllerMessenger = (
   > = getRootSnapInterfaceControllerMessenger(),
   mocked = true,
 ) => {
-  const snapInterfaceControllerMessenger = messenger.getRestricted<
+  const snapInterfaceControllerMessenger = new Messenger<
     'SnapInterfaceController',
-    SnapInterfaceControllerAllowedActions['type'],
-    SnapInterfaceControllerEvents['type']
-  >({
-    name: 'SnapInterfaceController',
-    allowedActions: [
+    SnapInterfaceControllerAllowedActions,
+    SnapInterfaceControllerEvents
+  >({ namespace: 'SnapInterfaceController', parent: messenger });
+
+  messenger.delegate({
+    actions: [
       'PhishingController:testOrigin',
       'ApprovalController:hasRequest',
       'ApprovalController:acceptRequest',
@@ -803,10 +775,8 @@ export const getRestrictedSnapInterfaceControllerMessenger = (
       'AccountsController:getSelectedMultichainAccount',
       'AccountsController:listMultichainAccounts',
     ],
-    allowedEvents: [
-      'NotificationServicesController:notificationsListUpdated',
-      'SnapInterfaceController:stateChange',
-    ],
+    events: ['NotificationServicesController:notificationsListUpdated'],
+    messenger: snapInterfaceControllerMessenger,
   });
 
   if (mocked) {
@@ -888,23 +858,28 @@ export const getRestrictedSnapInsightsControllerMessenger = (
     typeof getRootSnapInsightsControllerMessenger
   > = getRootSnapInsightsControllerMessenger(),
 ) => {
-  const controllerMessenger = messenger.getRestricted<
+  const controllerMessenger = new Messenger<
     'SnapInsightsController',
-    SnapInsightsControllerAllowedActions['type'],
-    SnapInsightsControllerAllowedEvents['type']
+    SnapInsightsControllerAllowedActions,
+    SnapInsightsControllerAllowedEvents
   >({
-    name: 'SnapInsightsController',
-    allowedEvents: [
-      'TransactionController:unapprovedTransactionAdded',
-      'TransactionController:transactionStatusUpdated',
-      'SignatureController:stateChange',
-    ],
-    allowedActions: [
+    namespace: 'SnapInsightsController',
+    parent: messenger,
+  });
+
+  messenger.delegate({
+    actions: [
       'PermissionController:getPermissions',
       'SnapController:getAll',
       'SnapController:handleRequest',
       'SnapInterfaceController:deleteInterface',
     ],
+    events: [
+      'TransactionController:unapprovedTransactionAdded',
+      'TransactionController:transactionStatusUpdated',
+      'SignatureController:stateChange',
+    ],
+    messenger: controllerMessenger,
   });
 
   return controllerMessenger;
@@ -917,15 +892,7 @@ export const getRestrictedSnapInsightsControllerMessenger = (
  * @returns A promise that resolves when the state change event is emitted.
  */
 export async function waitForStateChange(
-  messenger:
-    | Messenger<any, SnapControllerStateChangeEvent>
-    | Messenger<
-        'SnapController',
-        any,
-        SnapControllerStateChangeEvent,
-        any,
-        'SnapController:stateChange'
-      >,
+  messenger: Messenger<'SnapController', any, SnapControllerStateChangeEvent>,
 ) {
   return new Promise<void>((resolve) => {
     messenger.subscribe('SnapController:stateChange', () => {
@@ -951,18 +918,19 @@ export const getRestrictedMultichainRouterMessenger = (
     typeof getRootMultichainRouterMessenger
   > = getRootMultichainRouterMessenger(),
 ) => {
-  const controllerMessenger = messenger.getRestricted<
+  const controllerMessenger = new Messenger<
     'MultichainRouter',
-    MultichainRouterAllowedActions['type']
-  >({
-    name: 'MultichainRouter',
-    allowedEvents: [],
-    allowedActions: [
+    MultichainRouterAllowedActions
+  >({ namespace: 'MultichainRouter', parent: messenger });
+
+  messenger.delegate({
+    actions: [
       'PermissionController:getPermissions',
       'SnapController:getAll',
       'SnapController:handleRequest',
       'AccountsController:listMultichainAccounts',
     ],
+    messenger: controllerMessenger,
   });
 
   return controllerMessenger;
@@ -985,18 +953,20 @@ export const getRestrictedWebSocketServiceMessenger = (
     typeof getRootWebSocketServiceMessenger
   > = getRootWebSocketServiceMessenger(),
 ) => {
-  const controllerMessenger = messenger.getRestricted<
+  const controllerMessenger = new Messenger<
     'WebSocketService',
-    WebSocketServiceAllowedActions['type'],
-    WebSocketServiceEvents['type']
-  >({
-    name: 'WebSocketService',
-    allowedEvents: [
+    WebSocketServiceAllowedActions,
+    WebSocketServiceEvents
+  >({ namespace: 'WebSocketService', parent: messenger });
+
+  messenger.delegate({
+    actions: ['SnapController:handleRequest'],
+    events: [
       'SnapController:snapInstalled',
       'SnapController:snapUpdated',
       'SnapController:snapUninstalled',
     ],
-    allowedActions: ['SnapController:handleRequest'],
+    messenger: controllerMessenger,
   });
 
   return controllerMessenger;

packages/snaps-controllers/src/test-utils/execution-environment.ts

@@ -1,5 +1,6 @@
 import { JsonRpcEngine } from '@metamask/json-rpc-engine';
 import { createEngineStream } from '@metamask/json-rpc-middleware-stream';
+import { Messenger } from '@metamask/messenger';
 import { logError, type SnapRpcHookArgs } from '@metamask/snaps-utils';
 import type { MockControllerMessenger } from '@metamask/snaps-utils/test-utils';
 import { pipeline } from 'readable-stream';
@@ -20,20 +21,12 @@ export const getNodeEESMessenger = (
     ExecutionServiceEvents
   >,
 ) =>
-  messenger.getRestricted({
-    name: 'ExecutionService',
-    allowedEvents: [
-      'ExecutionService:unhandledError',
-      'ExecutionService:outboundRequest',
-      'ExecutionService:outboundResponse',
-    ],
-    allowedActions: [
-      'ExecutionService:executeSnap',
-      'ExecutionService:handleRpcRequest',
-      'ExecutionService:terminateAllSnaps',
-      'ExecutionService:terminateSnap',
-    ],
-  });
+  new Messenger<
+    'ExecutionService',
+    ExecutionServiceActions,
+    ExecutionServiceEvents,
+    any
+  >({ namespace: 'ExecutionService', parent: messenger });
 
 export const getNodeEES = (
   messenger: ReturnType<typeof getNodeEESMessenger>,

packages/snaps-controllers/src/test-utils/service.ts

@@ -1,6 +1,6 @@
-import { Messenger } from '@metamask/base-controller/next';
 import { JsonRpcEngine } from '@metamask/json-rpc-engine';
 import { createEngineStream } from '@metamask/json-rpc-middleware-stream';
+import { Messenger } from '@metamask/messenger';
 import { logError } from '@metamask/snaps-utils';
 import { pipeline } from 'readable-stream';
 import type { Duplex } from 'readable-stream';
@@ -18,18 +18,12 @@ export const createService = <
     'messenger' | 'setupSnapProvider'
   >,
 ) => {
-  const messenger = new Messenger<never, ErrorMessageEvent>();
-
-  const restrictedMessenger = messenger.getRestricted<
-    'ExecutionService',
-    never,
-    ErrorMessageEvent['type']
-  >({
-    name: 'ExecutionService',
-  });
+  const messenger = new Messenger<'ExecutionService', never, ErrorMessageEvent>(
+    { namespace: 'ExecutionService' },
+  );
 
   const service = new ServiceClass({
-    messenger: restrictedMessenger,
+    messenger,
     setupSnapProvider: (_snapId: string, rpcStream: Duplex) => {
       const mux = setupMultiplex(rpcStream, 'foo');
       const stream = mux.createStream('metamask-provider');
@@ -54,6 +48,6 @@ export const createService = <
 
   return {
     service,
-    messenger: restrictedMessenger,
+    messenger,
   };
 };

packages/snaps-rpc-methods/package.json

@@ -68,6 +68,7 @@
     "@lavamoat/allow-scripts": "^3.3.4",
     "@metamask/auto-changelog": "^5.0.2",
     "@metamask/json-rpc-engine": "^10.0.2",
+    "@metamask/messenger": "^0.1.0",
     "@swc/core": "1.11.31",
     "@swc/jest": "^0.2.38",
     "@ts-bridge/cli": "^0.6.1",