fix: Manually construct keyring_resolveAccountAddress request (#3822)

Manually construct `keyring_resolveAccountAddress` request to bypass
usage of `SnapKeyring`. This is required because the `SnapKeyring`
abstraction is only available when the wallet in unlocked.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Switches address resolution in `MultichainRouter` to call
`SnapController:handleRequest` with `HandlerType.OnKeyringRequest` and
`keyring_resolveAccountAddress`, avoiding dependence on `SnapKeyring`
during lock state.
> 
> - Removes `resolveAccountAddress` from `SnapKeyring` and related test
mocks/utilities
> - Adds result validation (`isObject`/`assert`) and parses returned
CAIP account ID
> - Updates tests to mock `SnapController:handleRequest` for keyring
address resolution and adjust expectations
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
d686e67. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: FrederikBolding

packages/snaps-controllers/src/multichain/MultichainRouter.test.ts

@@ -230,17 +230,25 @@ describe('MultichainRouter', () => {
     it('throws if address resolution fails', async () => {
       const rootMessenger = getRootMultichainRouterMessenger();
       const messenger = getRestrictedMultichainRouterMessenger(rootMessenger);
-      const withSnapKeyring = getMockWithSnapKeyring({
-        // Simulate the Snap returning a bogus address
-        resolveAccountAddress: jest.fn().mockResolvedValue({ address: 'foo' }),
-      });
+      const withSnapKeyring = getMockWithSnapKeyring();
 
       /* eslint-disable-next-line no-new */
       new MultichainRouter({
         messenger,
         withSnapKeyring,
       });
 
+      rootMessenger.registerActionHandler(
+        'SnapController:handleRequest',
+        async ({ handler }) => {
+          if (handler === HandlerType.OnKeyringRequest) {
+            // Simulate the Snap returning a bogus address
+            return { address: 'foo' };
+          }
+          throw new Error('Unmocked request');
+        },
+      );
+
       rootMessenger.registerActionHandler(
         'AccountsController:listMultichainAccounts',
         () => MOCK_SOLANA_ACCOUNTS,
@@ -271,20 +279,28 @@ describe('MultichainRouter', () => {
     it('throws if address resolution returns an address that isnt available', async () => {
       const rootMessenger = getRootMultichainRouterMessenger();
       const messenger = getRestrictedMultichainRouterMessenger(rootMessenger);
-      const withSnapKeyring = getMockWithSnapKeyring({
-        // Simulate the Snap returning an unconnected address
-        resolveAccountAddress: jest.fn().mockResolvedValue({
-          address:
-            'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:7S3P4HxJpyyigGzodYwHtCxZyUQe9JiBMHyRWXArAaKa',
-        }),
-      });
+      const withSnapKeyring = getMockWithSnapKeyring();
 
       /* eslint-disable-next-line no-new */
       new MultichainRouter({
         messenger,
         withSnapKeyring,
       });
 
+      rootMessenger.registerActionHandler(
+        'SnapController:handleRequest',
+        async ({ handler }) => {
+          if (handler === HandlerType.OnKeyringRequest) {
+            // Simulate the Snap returning an unconnected address
+            return {
+              address:
+                'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:7S3P4HxJpyyigGzodYwHtCxZyUQe9JiBMHyRWXArAaKa',
+            };
+          }
+          throw new Error('Unmocked request');
+        },
+      );
+
       rootMessenger.registerActionHandler(
         'AccountsController:listMultichainAccounts',
         () => MOCK_SOLANA_ACCOUNTS,
@@ -315,19 +331,27 @@ describe('MultichainRouter', () => {
     it(`throws if address resolution returns a lower case address that isn't available`, async () => {
       const rootMessenger = getRootMultichainRouterMessenger();
       const messenger = getRestrictedMultichainRouterMessenger(rootMessenger);
-      const withSnapKeyring = getMockWithSnapKeyring({
-        // Simulate the Snap returning an unconnected address
-        resolveAccountAddress: jest.fn().mockResolvedValue({
-          address: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:${MOCK_SOLANA_ACCOUNTS[0].address.toLowerCase()}`,
-        }),
-      });
+      const withSnapKeyring = getMockWithSnapKeyring();
 
       /* eslint-disable-next-line no-new */
       new MultichainRouter({
         messenger,
         withSnapKeyring,
       });
 
+      rootMessenger.registerActionHandler(
+        'SnapController:handleRequest',
+        async ({ handler }) => {
+          if (handler === HandlerType.OnKeyringRequest) {
+            // Simulate the Snap returning an unconnected address
+            return {
+              address: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp:${MOCK_SOLANA_ACCOUNTS[0].address.toLowerCase()}`,
+            };
+          }
+          throw new Error('Unmocked request');
+        },
+      );
+
       rootMessenger.registerActionHandler(
         'AccountsController:listMultichainAccounts',
         () => MOCK_SOLANA_ACCOUNTS,

packages/snaps-controllers/src/multichain/MultichainRouter.ts

@@ -16,6 +16,7 @@ import type {
 import {
   assert,
   hasProperty,
+  isObject,
   KnownCaipNamespace,
   parseCaipAccountId,
 } from '@metamask/utils';
@@ -52,11 +53,6 @@ type SnapKeyring = {
     params?: Json[] | Record<string, Json>;
     scope: CaipChainId;
   }) => Promise<Json>;
-  resolveAccountAddress: (
-    snapId: SnapId,
-    scope: CaipChainId,
-    request: Json,
-  ) => Promise<{ address: CaipAccountId } | null>;
 };
 
 // Expecting a bound function that calls KeyringController.withKeyring selecting the Snap keyring
@@ -137,7 +133,9 @@ export class MultichainRouter {
   /**
    * Attempts to resolve the account address to use for a given request by inspecting the request itself.
    *
-   * The request is sent to to an account Snap via the SnapKeyring that will attempt this resolution.
+   * The request is sent to to an account Snap that will attempt this resolution.
+   *
+   * We manually construct the request instead of using the SnapKeyring, as the keyring may not be available.
    *
    * @param snapId - The ID of the Snap to send the request to.
    * @param scope - The CAIP-2 scope for the request.
@@ -151,10 +149,25 @@ export class MultichainRouter {
     request: JsonRpcRequest,
   ) {
     try {
-      const result = await this.#withSnapKeyring(async ({ keyring }) =>
-        keyring.resolveAccountAddress(snapId, scope, request),
+      const result = await this.#messenger.call(
+        'SnapController:handleRequest',
+        {
+          snapId,
+          origin: 'metamask',
+          request: {
+            method: 'keyring_resolveAccountAddress',
+            params: {
+              request,
+              scope,
+            },
+          },
+          handler: HandlerType.OnKeyringRequest,
+        },
       );
-      const address = result?.address;
+
+      assert(result === null || isObject(result));
+
+      const address = result?.address as CaipAccountId;
       return address ? parseCaipAccountId(address).address : null;
     } catch {
       throw rpcErrors.internal();

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

@@ -94,9 +94,6 @@ export const MOCK_SOLANA_SNAP_PERMISSIONS: Record<
 
 type MockSnapKeyring = {
   submitRequest: (request: unknown) => Promise<Json>;
-  resolveAccountAddress: (
-    options: unknown,
-  ) => Promise<{ address: CaipAccountId } | null>;
 };
 
 type MockOperationCallback = ({
@@ -106,16 +103,14 @@ type MockOperationCallback = ({
 }) => Promise<any>;
 
 export const getMockWithSnapKeyring = (
-  { submitRequest = jest.fn(), resolveAccountAddress = jest.fn() } = {
+  { submitRequest = jest.fn() } = {
     submitRequest: jest.fn(),
-    resolveAccountAddress: jest.fn(),
   },
 ): WithSnapKeyringFunction => {
   return async (callback: MockOperationCallback) =>
     callback({
       keyring: {
         submitRequest,
-        resolveAccountAddress,
       },
     });
 };