test: add coverage for resolveAccountAddress

Author: baptiste-marchand

packages/snap/src/handlers/KeyringHandler.test.ts

@@ -14,8 +14,9 @@ import type {
   KeyringResponse,
   Transaction as KeyringTransaction,
   KeyringRequest,
+  KeyringAccount,
 } from '@metamask/keyring-api';
-import { BtcAccountType, BtcScope } from '@metamask/keyring-api';
+import { BtcAccountType, BtcMethod, BtcScope } from '@metamask/keyring-api';
 import { mock } from 'jest-mock-extended';
 import { assert } from 'superstruct';
 
@@ -844,4 +845,112 @@ describe('KeyringHandler', () => {
       expect(result).toStrictEqual(expectedResponse);
     });
   });
+
+  describe('resolveAccountAddress', () => {
+    const mockKeyringAccount1 = mock<KeyringAccount>({
+      id: 'account-1',
+      address: 'test123',
+      scopes: [BtcScope.Regtest],
+    });
+    const mockKeyringAccount2 = mock<KeyringAccount>({
+      id: 'account-2',
+      address: 'test456',
+      scopes: [BtcScope.Regtest],
+    });
+
+    beforeEach(() => {
+      mockAccounts.list.mockResolvedValue([mockAccount]);
+    });
+
+    it('resolves account address successfully', async () => {
+      const request = {
+        id: '1',
+        jsonrpc: '2.0' as const,
+        method: BtcMethod.SignPsbt,
+        params: {
+          account: { address: 'test123' },
+          psbt: 'psbt',
+        },
+      };
+      const requestWithoutCommonHeader = {
+        method: request.method,
+        params: request.params,
+      };
+
+      // mockAccounts.list.mockResolvedValue([mockAccount]);
+      jest
+        .spyOn(handler, 'listAccounts')
+        .mockResolvedValueOnce([mockKeyringAccount1, mockKeyringAccount2]);
+      mockKeyringRequest.resolveAccountAddress.mockReturnValue(
+        'bip122:000000000019d6689c085ae165831e93:test123',
+      );
+
+      const result = await handler.resolveAccountAddress(
+        BtcScope.Regtest,
+        request,
+      );
+
+      expect(handler.listAccounts).toHaveBeenCalled();
+      expect(mockKeyringRequest.resolveAccountAddress).toHaveBeenCalledWith(
+        [mockKeyringAccount1, mockKeyringAccount2],
+        BtcScope.Regtest,
+        requestWithoutCommonHeader,
+      );
+      expect(result).toStrictEqual({
+        address: 'bip122:000000000019d6689c085ae165831e93:test123',
+      });
+    });
+
+    it('returns null on error', async () => {
+      const request = {
+        id: '1',
+        jsonrpc: '2.0' as const,
+        method: BtcMethod.SignPsbt,
+        params: {
+          account: { address: 'notfound' },
+          psbt: 'psbt',
+        },
+      };
+
+      jest
+        .spyOn(handler, 'listAccounts')
+        .mockImplementation()
+        .mockResolvedValue([mockKeyringAccount1, mockKeyringAccount2]);
+      mockKeyringRequest.resolveAccountAddress.mockImplementation(() => {
+        throw new Error('Account not found');
+      });
+
+      const result = await handler.resolveAccountAddress(
+        BtcScope.Regtest,
+        request,
+      );
+
+      expect(result).toBeNull();
+    });
+
+    it('returns null when request validation fails', async () => {
+      const invalidRequest = {
+        id: '1',
+        jsonrpc: '2.0' as const,
+        method: 'invalid',
+        params: {},
+      };
+
+      jest
+        .spyOn(handler, 'listAccounts')
+        .mockImplementation()
+        .mockResolvedValue([mockKeyringAccount1, mockKeyringAccount2]);
+
+      jest.mocked(assert).mockImplementationOnce(() => {
+        throw new Error('Invalid request');
+      });
+
+      const result = await handler.resolveAccountAddress(
+        BtcScope.Regtest,
+        invalidRequest,
+      );
+
+      expect(result).toBeNull();
+    });
+  });
 });

packages/snap/src/handlers/KeyringRequestHandler.test.ts

@@ -1,5 +1,6 @@
 import type { Txid, Psbt, Amount, LocalOutput } from '@metamask/bitcoindevkit';
-import type { KeyringRequest } from '@metamask/keyring-api';
+import type { KeyringRequest, KeyringAccount } from '@metamask/keyring-api';
+import { BtcMethod, BtcScope } from '@metamask/keyring-api';
 import { mock } from 'jest-mock-extended';
 import { assert } from 'superstruct';
 
@@ -491,4 +492,130 @@ describe('KeyringRequestHandler', () => {
       });
     });
   });
+
+  describe('resolveAccountAddress', () => {
+    const mockAccount1 = mock<KeyringAccount>({
+      id: 'account-1',
+      address: 'test123',
+      scopes: [BtcScope.Regtest],
+    });
+    const mockAccount2 = mock<KeyringAccount>({
+      id: 'account-2',
+      address: 'test456',
+      scopes: [BtcScope.Regtest, BtcScope.Testnet],
+    });
+    const mockAccount3 = mock<KeyringAccount>({
+      id: 'account-3',
+      address: 'test789',
+      scopes: [BtcScope.Testnet],
+    });
+
+    it('resolves account address for SignPsbt', () => {
+      const request = {
+        method: BtcMethod.SignPsbt as const,
+        params: {
+          account: { address: 'test123' },
+          psbt: 'psbt',
+          options: { fill: false, broadcast: false },
+        },
+      };
+
+      const result = handler.resolveAccountAddress(
+        [mockAccount1, mockAccount2, mockAccount3],
+        BtcScope.Regtest,
+        request,
+      );
+
+      expect(result).toBe('bip122:regtest:test123');
+    });
+
+    it('resolves account address for SendTransfer', () => {
+      const request = {
+        method: BtcMethod.SendTransfer as const,
+        params: {
+          account: { address: 'test456' },
+          recipients: [{ address: 'recipient', amount: '1000' }],
+        },
+      };
+
+      const result = handler.resolveAccountAddress(
+        [mockAccount1, mockAccount2, mockAccount3],
+        BtcScope.Regtest,
+        request,
+      );
+
+      expect(result).toBe('bip122:regtest:test456');
+    });
+
+    it('resolves account address for SignMessage', () => {
+      const request = {
+        method: BtcMethod.SignMessage as const,
+        params: {
+          account: { address: 'test123' },
+          message: 'hello',
+        },
+      };
+
+      const result = handler.resolveAccountAddress(
+        [mockAccount1, mockAccount2, mockAccount3],
+        BtcScope.Regtest,
+        request,
+      );
+
+      expect(result).toBe('bip122:regtest:test123');
+    });
+
+    it('throws error if no accounts with scope', () => {
+      const request = {
+        method: BtcMethod.SignPsbt as const,
+        params: {
+          account: { address: 'test123' },
+          psbt: 'psbt',
+          options: { fill: false, broadcast: false },
+        },
+      };
+
+      expect(() =>
+        handler.resolveAccountAddress(
+          [mockAccount3],
+          BtcScope.Regtest,
+          request,
+        ),
+      ).toThrow('No accounts with this scope');
+    });
+
+    it('throws error if account address not found', () => {
+      const request = {
+        method: BtcMethod.SignPsbt as const,
+        params: {
+          account: { address: 'notfound' },
+          psbt: 'psbt',
+          options: { fill: false, broadcast: false },
+        },
+      };
+
+      expect(() =>
+        handler.resolveAccountAddress(
+          [mockAccount1, mockAccount2, mockAccount3],
+          BtcScope.Regtest,
+          request,
+        ),
+      ).toThrow('Account not found');
+    });
+
+    it('throws error for unsupported method', () => {
+      const request = {
+        method: 'unsupported' as BtcMethod,
+        params: {},
+      };
+
+      expect(() =>
+        handler.resolveAccountAddress(
+          [mockAccount1, mockAccount2, mockAccount3],
+          BtcScope.Regtest,
+          request as any,
+        ),
+      ).toThrow('Unsupported method');
+    });
+  });
 });