refactor: Use messenger for majority of Snaps RPC methods (#29970)

<!--
Please submit this PR as a draft initially.

Do not mark it as "Ready for review" until this PR meets the canonical
Definition of Ready For Review in `docs/readme/ready-for-review.md`.

In short: the template must be materially complete (not just section
titles
present), all status checks must be currently passing, and the only
expected
follow-up commits must be reviewer-driven.
-->

## **Description**

This PR completes a refactor to use the messenger to replace the
majority of the method hooks used by Snaps RPC methods. This lets
consolidate implementations across both clients and reduces the
maintenance burden. There should be no functional difference to the
user.

## **Changelog**

<!--
If this PR is not End-User-Facing and should not show up in the
CHANGELOG, you can choose to either:
1. Write `CHANGELOG entry: null`
2. Label with `no-changelog`

If this PR is End-User-Facing, please write a short User-Facing
description in the past tense like:
`CHANGELOG entry: Added a new tab for users to see their NFTs`
`CHANGELOG entry: Fixed a bug that was causing some NFTs to flicker`

(This helps the Release Engineer do their job more quickly and
accurately)
-->

CHANGELOG entry: null

## **Related issues**

https://consensyssoftware.atlassian.net/browse/WPC-995


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Medium Risk**
> Refactors Snaps RPC/permission wiring to rely on messenger calls and
updates Snap-related package versions, which could subtly change
authorization/unlock behavior or break Snap RPC methods if messenger
action contracts differ.
> 
> **Overview**
> Refactors `snapMethodMiddlewareBuilder` and Snap permission
specifications to remove direct `Engine.context` hook usage and instead
rely on `controllerMessenger`/`initMessenger` (`waitUntil`, `call`) for
unlock state, keyring creation, and other Snap RPC hooks.
> 
> Updates `permissionControllerInit` to stop injecting a
`KeyringController` client into Snap permission specs, removes the
legacy `getMnemonic` helper/tests, and adjusts Snap/BackgroundBridge
tests to mock the newer messenger APIs (e.g., `delegate`).
> 
> Bumps `@metamask/snaps-controllers`, `@metamask/snaps-rpc-methods`,
and `@metamask/snaps-sdk` to newer versions.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
cecac79. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: FrederikBolding

app/core/BackgroundBridge/BackgroundBridge.js

@@ -671,7 +671,6 @@ export class BackgroundBridge extends EventEmitter {
     if (!this.isMMSDK && !this.isWalletConnect) {
       engine.push(
         snapMethodMiddlewareBuilder(
-          Engine.context,
           Engine.controllerMessenger,
           this.url,
           // We assume that origins connecting through the BackgroundBridge are websites

app/core/BackgroundBridge/BackgroundBridge.test.js

@@ -43,6 +43,7 @@ jest.mock('../Engine', () => ({
     subscribe: jest.fn(),
     tryUnsubscribe: jest.fn(),
     unsubscribe: jest.fn(),
+    delegate: jest.fn(),
   },
   context: {
     AccountsController: {

app/core/Engine/controllers/permission-controller-init.ts

@@ -30,16 +30,7 @@ export const permissionControllerInit: MessengerClientInitFunction<
   >,
   PermissionControllerMessenger,
   PermissionControllerInitMessenger
-> = ({
-  controllerMessenger,
-  initMessenger,
-  persistedState,
-  getMessengerClient,
-}) => {
-  ///: BEGIN:ONLY_INCLUDE_IF(snaps)
-  const keyringController = getMessengerClient('KeyringController');
-  ///: END:ONLY_INCLUDE_IF
-
+> = ({ controllerMessenger, initMessenger, persistedState }) => {
   const controller = new PermissionController({
     messenger: controllerMessenger,
     state: persistedState.PermissionController,
@@ -65,9 +56,7 @@ export const permissionControllerInit: MessengerClientInitFunction<
     permissionSpecifications: {
       ...getPermissionSpecifications(),
       ///: BEGIN:ONLY_INCLUDE_IF(snaps)
-      ...getSnapPermissionSpecifications(initMessenger, {
-        addNewKeyring: keyringController.addNewKeyring.bind(keyringController),
-      }),
+      ...getSnapPermissionSpecifications(initMessenger),
       ///: END:ONLY_INCLUDE_IF
     },
     unrestrictedMethods,

app/core/Snaps/SnapBridge.test.ts

@@ -1,7 +1,6 @@
 import { SnapId } from '@metamask/snaps-sdk';
-import { Json, JsonRpcRequest, PendingJsonRpcResponse } from '@metamask/utils';
+import { Json } from '@metamask/utils';
 import ObjectMultiplex from '@metamask/object-multiplex';
-import { JsonRpcEngineNextCallback } from '@metamask/json-rpc-engine';
 // eslint-disable-next-line import-x/no-nodejs-modules
 import { Duplex } from 'stream';
 import SnapBridge from './SnapBridge';
@@ -31,6 +30,16 @@ jest.mock('../Engine/Engine', () => ({
         ];
       }
     }),
+    delegate: jest.fn().mockImplementation((options) => {
+      options.messenger.call = jest.fn().mockImplementation((action) => {
+        if (action === 'KeyringController:getState') {
+          return {
+            isUnlocked: true,
+            keyrings: [],
+          };
+        }
+      });
+    }),
   },
   context: {
     AccountsController: {
@@ -61,9 +70,6 @@ jest.mock('../Engine/Engine', () => ({
         },
       ]),
     },
-    ApprovalController: {
-      addAndShowApprovalRequest: jest.fn(),
-    },
     SelectedNetworkController: {
       getProviderAndBlockTracker: jest.fn().mockReturnValue({
         blockTracker: {},

app/core/Snaps/SnapBridge.ts

@@ -177,7 +177,6 @@ export default class SnapBridge {
 
     engine.push(
       snapMethodMiddlewareBuilder(
-        context,
         controllerMessenger,
         this.#snapId,
         SubjectType.Snap,

app/core/Snaps/SnapsMethodMiddleware.ts

@@ -1,48 +1,21 @@
 ///: BEGIN:ONLY_INCLUDE_IF(snaps)
 import { createSnapsMethodMiddleware } from '@metamask/snaps-rpc-methods';
-import {
-  RequestedPermissions,
-  SubjectType,
-} from '@metamask/permission-controller';
-import { SnapRpcHookArgs } from '@metamask/snaps-utils';
-import { RestrictedMethods } from '../Permissions/constants';
+import { SubjectType } from '@metamask/permission-controller';
+import { Json } from '@metamask/utils';
+import { captureException } from '@sentry/react-native';
+import { AppState } from 'react-native';
+import { getVersion } from 'react-native-device-info';
+
 import { keyringSnapPermissionsBuilder } from '../SnapKeyring/keyringSnapsPermissions';
-import { SnapId } from '@metamask/snaps-sdk';
 import { RootExtendedMessenger, EngineContext } from '../Engine';
-import { handleSnapRequest } from './utils';
-import { captureException } from '@sentry/react-native';
-import {
-  CronjobControllerCancelAction,
-  CronjobControllerGetAction,
-  SnapControllerClearSnapStateAction,
-  SnapControllerGetPermittedSnapsAction,
-  SnapControllerGetSnapAction,
-  SnapControllerGetSnapFileAction,
-  SnapControllerGetSnapStateAction,
-  SnapControllerInstallSnapsAction,
-  SnapControllerUpdateSnapStateAction,
-  SnapInterfaceControllerCreateInterfaceAction,
-  SnapInterfaceControllerResolveInterfaceAction,
-  SnapInterfaceControllerUpdateInterfaceAction,
-  SnapInterfaceControllerUpdateInterfaceStateAction,
-  WebSocketServiceOpenAction,
-  WebSocketServiceCloseAction,
-  WebSocketServiceGetAllAction,
-  WebSocketServiceSendMessageAction,
-} from '../Engine/controllers/snaps/constants';
-import { KeyringTypes } from '@metamask/keyring-controller';
 import { analytics } from '../../util/analytics/analytics';
 import { AnalyticsEventBuilder } from '../../util/analytics/AnalyticsEventBuilder';
-import { Json } from '@metamask/utils';
-import { CronjobControllerScheduleAction } from '@metamask/snaps-controllers';
 import { endTrace, trace } from '../../util/trace';
-import { AppState } from 'react-native';
-import { getVersion } from 'react-native-device-info';
 
 export const trackSnapEvent = (eventPayload: {
   event: string;
-  properties: Record<string, Json>;
-  sensitiveProperties: Record<string, Json>;
+  properties?: Record<string, Json>;
+  sensitiveProperties?: Record<string, Json>;
 }) => {
   analytics.trackEvent(
     AnalyticsEventBuilder.createEventBuilder(eventPayload.event)
@@ -52,222 +25,43 @@ export const trackSnapEvent = (eventPayload: {
   );
 };
 
-export function getSnapIdFromRequest(
-  request: Record<string, unknown>,
-): SnapId | null {
-  const { snapId } = request;
-  return typeof snapId === 'string' ? (snapId as SnapId) : null;
-}
-// Snaps middleware
-/*
-    from extension https://github.dev/MetaMask/metamask-extension/blob/1d5e8a78400d7aaaf2b3cbdb30cff9399061df34/app/scripts/metamask-controller.js#L3830-L3861
-    */
 const snapMethodMiddlewareBuilder = (
-  engineContext: EngineContext,
   controllerMessenger: RootExtendedMessenger,
   origin: string,
   subjectType: SubjectType,
 ) =>
-  createSnapsMethodMiddleware(subjectType === SubjectType.Snap, {
-    getUnlockPromise: () => {
-      if (engineContext.KeyringController.isUnlocked()) {
-        return Promise.resolve();
-      }
-      return new Promise<void>((resolve) => {
-        controllerMessenger.subscribeOnceIf(
-          'KeyringController:unlock',
-          resolve,
-          () => true,
-        );
-      });
-    },
-    getSnaps: controllerMessenger.call.bind(
-      controllerMessenger,
-      SnapControllerGetPermittedSnapsAction,
-      origin,
-    ),
-    requestPermissions: async (requestedPermissions: RequestedPermissions) =>
-      await engineContext.PermissionController.requestPermissions(
-        { origin },
-        requestedPermissions,
-      ),
-    getPermissions: engineContext.PermissionController.getPermissions.bind(
-      engineContext.PermissionController,
-      origin,
-    ),
-    hasPermission: engineContext.PermissionController.hasPermission.bind(
-      engineContext.PermissionController,
-      origin,
-    ),
-    getAllowedKeyringMethods: keyringSnapPermissionsBuilder(origin),
-    getSnapFile: controllerMessenger.call.bind(
-      controllerMessenger,
-      SnapControllerGetSnapFileAction,
-      origin as SnapId,
-    ),
-    installSnaps: controllerMessenger.call.bind(
-      controllerMessenger,
-      SnapControllerInstallSnapsAction,
-      origin,
-    ),
-    invokeSnap: engineContext.PermissionController.executeRestrictedMethod.bind(
-      engineContext.PermissionController,
-      origin,
-      RestrictedMethods.wallet_snap,
-    ),
-    createInterface: controllerMessenger.call.bind(
-      controllerMessenger,
-      SnapInterfaceControllerCreateInterfaceAction,
-      origin as SnapId,
-    ),
-    updateInterface: controllerMessenger.call.bind(
-      controllerMessenger,
-      SnapInterfaceControllerUpdateInterfaceAction,
-      origin as SnapId,
-    ),
-    getInterfaceContext: (id: string) =>
-      controllerMessenger.call(
-        'SnapInterfaceController:getInterface',
-        origin as SnapId,
-        id,
-      ).context,
-    getInterfaceState: (id: string) =>
-      controllerMessenger.call(
-        'SnapInterfaceController:getInterfaceState',
-        origin as SnapId,
-        id,
-      ),
-    resolveInterface: controllerMessenger.call.bind(
-      controllerMessenger,
-      SnapInterfaceControllerResolveInterfaceAction,
-      origin as SnapId,
-    ),
-    getSnap: controllerMessenger.call.bind(
-      controllerMessenger,
-      SnapControllerGetSnapAction,
-    ),
-    trackError: (error: Error) => captureException(error),
-    trackEvent: trackSnapEvent,
-    openWebSocket: controllerMessenger.call.bind(
-      controllerMessenger,
-      WebSocketServiceOpenAction,
-      origin as SnapId,
-    ),
-    closeWebSocket: controllerMessenger.call.bind(
-      controllerMessenger,
-      WebSocketServiceCloseAction,
-      origin as SnapId,
-    ),
-    sendWebSocketMessage: controllerMessenger.call.bind(
-      controllerMessenger,
-      WebSocketServiceSendMessageAction,
-      origin as SnapId,
-    ),
-    getWebSockets: controllerMessenger.call.bind(
-      controllerMessenger,
-      WebSocketServiceGetAllAction,
-      origin as SnapId,
-    ),
-    updateInterfaceState: controllerMessenger.call.bind(
-      controllerMessenger,
-      SnapInterfaceControllerUpdateInterfaceStateAction,
-      origin as SnapId,
-    ),
-    handleSnapRpcRequest: async (request: Omit<SnapRpcHookArgs, 'origin'>) => {
-      const snapId = getSnapIdFromRequest(request);
-
-      if (!snapId) {
-        throw new Error(
-          'snapMethodMiddlewareBuilder handleSnapRpcRequest: Invalid snap request: snapId not found',
-        );
-      }
-
-      return await handleSnapRequest(controllerMessenger, {
-        snapId,
-        origin,
-        handler: request.handler,
-        request: request.request,
-      });
-    },
-    requestUserApproval:
-      engineContext.ApprovalController.addAndShowApprovalRequest.bind(
-        engineContext.ApprovalController,
-      ),
-    getIsActive: () =>
-      AppState.currentState === 'active' &&
-      engineContext.KeyringController.isUnlocked(),
-    getIsLocked: () => !engineContext.KeyringController.isUnlocked(),
-    getVersion: () => {
-      const baseVersion = getVersion();
-      const buildType = process.env.METAMASK_BUILD_TYPE;
+  createSnapsMethodMiddleware(
+    subjectType === SubjectType.Snap,
+    {
+      getUnlockPromise: async () => {
+        if (controllerMessenger.call('KeyringController:isUnlocked')) {
+          return;
+        }
+        await controllerMessenger.waitUntil('KeyringController:unlock');
+      },
+      getAllowedKeyringMethods: keyringSnapPermissionsBuilder(origin),
+      trackError: (error: Error) => captureException(error),
+      trackEvent: trackSnapEvent,
+      getIsActive: () =>
+        AppState.currentState === 'active' &&
+        controllerMessenger.call('KeyringController:isUnlocked'),
+      getVersion: () => {
+        const baseVersion = getVersion();
+        const buildType = process.env.METAMASK_BUILD_TYPE;
 
-      if (buildType === 'main' || buildType === 'qa') {
-        return baseVersion;
-      }
+        if (buildType === 'main' || buildType === 'qa') {
+          return baseVersion;
+        }
 
-      return `${baseVersion}-${buildType}.0`;
+        return `${baseVersion}-${buildType}.0`;
+      },
+      // @ts-expect-error Type 'string' is not assignable to type 'TraceName'.
+      startTrace: trace,
+      // @ts-expect-error Type 'string' is not assignable to type 'TraceName'.
+      endTrace,
     },
-    getEntropySources: () => {
-      const state = controllerMessenger.call('KeyringController:getState');
-
-      return state.keyrings
-        .map((keyring, index) => {
-          if (keyring.type === KeyringTypes.hd) {
-            return {
-              id: keyring.metadata.id,
-              name: keyring.metadata.name,
-              type: 'mnemonic',
-              primary: index === 0,
-            };
-          }
-
-          return null;
-        })
-        .filter(Boolean);
-    },
-    clearSnapState: controllerMessenger.call.bind(
-      controllerMessenger,
-      SnapControllerClearSnapStateAction,
-      origin as SnapId,
-    ),
-    getSnapState: controllerMessenger.call.bind(
-      controllerMessenger,
-      SnapControllerGetSnapStateAction,
-      origin as SnapId,
-    ),
-    updateSnapState: controllerMessenger.call.bind(
-      controllerMessenger,
-      SnapControllerUpdateSnapStateAction,
-      origin as SnapId,
-    ),
-    scheduleBackgroundEvent: (
-      event: Parameters<CronjobControllerScheduleAction['handler']>[0],
-    ) =>
-      controllerMessenger.call('CronjobController:schedule', {
-        ...event,
-        snapId: origin as SnapId,
-      }),
-    cancelBackgroundEvent: controllerMessenger.call.bind(
-      controllerMessenger,
-      CronjobControllerCancelAction,
-      origin as SnapId,
-    ),
-    getBackgroundEvents: controllerMessenger.call.bind(
-      controllerMessenger,
-      CronjobControllerGetAction,
-      origin as SnapId,
-    ),
-    getNetworkConfigurationByChainId: controllerMessenger.call.bind(
-      controllerMessenger,
-      'NetworkController:getNetworkConfigurationByChainId',
-    ),
-    getNetworkClientById: controllerMessenger.call.bind(
-      controllerMessenger,
-      'NetworkController:getNetworkClientById',
-    ),
-    startTrace: trace,
-    endTrace,
-  });
+    controllerMessenger,
+  );
 
 export default snapMethodMiddlewareBuilder;
 ///: END:ONLY_INCLUDE_IF