@onekeyfe/hd-core 1.2.0-alpha.34 → 1.2.0-alpha.36

package/__tests__/open-wallet-session.test.ts

@@ -1,10 +1,11 @@
 import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+import { DeviceSessionPinType, DeviceSessionSeedDomain } from '@onekeyfe/hd-transport';
 
 import GetPassphraseState from '../src/api/GetPassphraseState';
 import OpenWalletSession from '../src/api/OpenWalletSession';
 import { Device } from '../src/device/Device';
 import { deviceWalletSessionStore } from '../src/device/DeviceWalletSessionStore';
+import { ensureProtocolV2WalletSessionUnlocked } from '../src/protocols/protocol-v2/walletSession';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -43,6 +44,11 @@ const createDevice = ({
       }),
       promptPassphrase,
     },
+    ensureProtocolV2RuntimeContext: jest.fn(() =>
+      device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+        eventless_wallet_session: true,
+      })
+    ),
     getDeviceState: jest.fn().mockResolvedValue({
       identity: { deviceId: 'device-1' },
       status: { passphraseProtection },
@@ -82,6 +88,50 @@ describe('openWalletSession', () => {
     deviceWalletSessionStore.clear();
   });
 
+  test('unlocks a locked Protocol V2 device before restoring a wallet session', async () => {
+    const device = {
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: false } }),
+      },
+      isBootloader: jest.fn().mockReturnValue(false),
+      isProtocolV2: jest.fn().mockReturnValue(true),
+      isRomloader: jest.fn().mockReturnValue(false),
+      state: { status: { unlocked: false } },
+      unlockDevice: jest.fn().mockResolvedValue(undefined),
+      updateProtocolV2Status: jest.fn(function updateProtocolV2Status(
+        this: { state: { status: { unlocked: boolean } } },
+        status: { unlocked?: boolean }
+      ) {
+        this.state.status.unlocked = status.unlocked ?? this.state.status.unlocked;
+      }),
+    };
+
+    await expect(ensureProtocolV2WalletSessionUnlocked(device as any)).resolves.toBe(true);
+    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'unlock-coordinator',
+      reason: 'device-locked',
+      deviceOnly: true,
+    });
+  });
+
+  test('does not request PIN when wallet-session recovery finds the device unlocked', async () => {
+    const device = {
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: true } }),
+      },
+      isBootloader: jest.fn().mockReturnValue(false),
+      isProtocolV2: jest.fn().mockReturnValue(true),
+      isRomloader: jest.fn().mockReturnValue(false),
+      state: { status: { unlocked: true } },
+      unlockDevice: jest.fn(),
+      updateProtocolV2Status: jest.fn(),
+    };
+
+    await expect(ensureProtocolV2WalletSessionUnlocked(device as any)).resolves.toBe(false);
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+  });
+
   test.each([{ useEmptyPassphrase: true }, { initSession: true }, {}])(
     'requires the explicit mode in the new public API: %p',
     legacyParams => {
@@ -108,7 +158,7 @@ describe('openWalletSession', () => {
           session_id: 'pro2-wallet-session',
         },
       });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new GetPassphraseState({
       payload: {
         method: 'getPassphraseState',
@@ -130,7 +180,8 @@ describe('openWalletSession', () => {
       { cancelDeviceOnReject: false }
     );
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
-      on_device: true,
+      passphrase: 'host hidden wallet',
+      on_device: false,
     });
     expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
   });
@@ -208,7 +259,7 @@ describe('openWalletSession', () => {
       protocol: 'V1',
       walletType: 'standard',
       deviceId: 'device-1',
-      passphraseState: 'main-wallet-state',
+      passphraseState: null,
       resumed: false,
     });
     expect(method.payload.useEmptyPassphrase).toBe(true);
@@ -229,7 +280,7 @@ describe('openWalletSession', () => {
           session_id: 'hidden-session',
         },
       });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
@@ -247,11 +298,47 @@ describe('openWalletSession', () => {
     });
     expect(promptPassphrase).toHaveBeenCalled();
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
-      on_device: true,
+      passphrase: 'host hidden wallet',
+      on_device: false,
     });
     expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
+  test('refreshes Pro2 status and unlocks before selecting a hidden wallet when locked', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state-after-preflight',
+          session_id: 'hidden-session-after-preflight',
+        },
+      });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    const device = createDevice({
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+    });
+    device.getDeviceState = jest.fn().mockResolvedValue({
+      identity: { deviceId: 'device-1' },
+      status: { unlocked: false, passphraseProtection: true },
+    });
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'hidden-state-after-preflight',
+    });
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice.mock.invocationCallOrder[0]).toBeLessThan(
+      typedCall.mock.invocationCallOrder[0]
+    );
+  });
+
   test('classifies the selected Pro2 wallet from the post-unlock device state', async () => {
     const typedCall = jest
       .fn()
@@ -263,7 +350,7 @@ describe('openWalletSession', () => {
           session_id: 'hidden-session-after-unlock',
         },
       });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
     });
@@ -275,10 +362,23 @@ describe('openWalletSession', () => {
     });
     device.features.unlocked = false;
     device.getCurrentPassphraseProtection = () => device.features.passphraseProtection;
-    device.unlockDevice = jest.fn().mockImplementation(() => {
-      device.features.unlocked = true;
-      device.features.passphraseProtection = true;
-      return Promise.resolve(device.features);
+    device.commands.typedCall = jest.fn((request: string, ...args: unknown[]) => {
+      if (request === 'DeviceStatusGet') {
+        return {
+          message: {
+            device_id: 'device-1',
+            unlocked: true,
+            passphrase_enabled: true,
+          },
+        };
+      }
+      return typedCall(request, ...args);
+    });
+    device.updateProtocolV2Status = jest.fn((status: Record<string, unknown>) => {
+      device.features.unlocked = status.unlocked ?? device.features.unlocked;
+      device.features.passphraseProtection =
+        status.passphrase_enabled ?? device.features.passphraseProtection;
+      return device.features;
     });
     method.device = device as any;
 
@@ -293,6 +393,35 @@ describe('openWalletSession', () => {
     expect(promptPassphrase).toHaveBeenCalledTimes(1);
   });
 
+  test('rejects a Pro2 standard-wallet fallback after selecting a hidden wallet', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'standard-wallet-state',
+          session_id: 'standard-wallet-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    const device = createDevice({
+      passphraseProtection: false,
+      typedCall,
+      promptPassphrase,
+    });
+    method.device = device as any;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceNotOpenedPassphrase,
+    });
+    expect(device.clearInternalState).toHaveBeenCalled();
+  });
+
   test('select-hidden starts a fresh hidden-wallet session on Protocol V2', async () => {
     const typedCall = jest
       .fn()
@@ -304,7 +433,7 @@ describe('openWalletSession', () => {
           session_id: 'new-hidden-session',
         },
       });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
@@ -326,7 +455,8 @@ describe('openWalletSession', () => {
       eventless_wallet_session: true,
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
-      on_device: true,
+      passphrase: 'host hidden wallet',
+      on_device: false,
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).toHaveBeenCalled();
@@ -344,7 +474,7 @@ describe('openWalletSession', () => {
           session_id: 'current-device-session',
         },
       });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
@@ -399,6 +529,7 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
+      btc_test_address: 'hidden-state',
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -569,14 +700,18 @@ describe('openWalletSession', () => {
       protocol: 'V2',
       walletType: 'standard',
       deviceId: 'device-1',
-      passphraseState: 'main-wallet-state',
+      passphraseState: null,
       resumed: false,
     });
     expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'wallet-session-coordinator',
+      reason: 'open-wallet',
+      deviceOnly: true,
+    });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
@@ -602,7 +737,7 @@ describe('openWalletSession', () => {
       .fn()
       .mockResolvedValueOnce({
         identity: { deviceId: undefined },
-        status: { passphraseProtection: true },
+        status: { unlocked: false, passphraseProtection: true },
       })
       .mockResolvedValueOnce({
         identity: { deviceId: 'device-1' },
@@ -618,10 +753,14 @@ describe('openWalletSession', () => {
       protocol: 'V2',
       walletType: 'standard',
       deviceId: 'device-1',
-      passphraseState: 'main-wallet-state',
+      passphraseState: null,
       resumed: false,
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'wallet-session-coordinator',
+      reason: 'open-wallet',
+      deviceOnly: true,
+    });
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
   });
 
@@ -641,6 +780,14 @@ describe('openWalletSession', () => {
     method.init();
     const device = createDevice({ typedCall });
     device.features.unlockedAttachPin = true;
+    device.getDeviceState = jest.fn().mockResolvedValue({
+      identity: { deviceId: 'device-1' },
+      status: {
+        unlocked: true,
+        unlockedAttachPin: true,
+        passphraseProtection: true,
+      },
+    });
     device.unlockDevice = jest.fn().mockImplementation(() => {
       device.features.unlockedAttachPin = false;
       return Promise.resolve(device.features);
@@ -649,9 +796,13 @@ describe('openWalletSession', () => {
 
     await expect(method.run()).resolves.toMatchObject({
       walletType: 'standard',
-      passphraseState: 'main-wallet-state',
+      passphraseState: null,
+    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'wallet-session-coordinator',
+      reason: 'open-wallet',
+      deviceOnly: true,
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
@@ -666,7 +817,7 @@ describe('openWalletSession', () => {
           session_id: 'hidden-session',
         },
       });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
     });
@@ -683,7 +834,8 @@ describe('openWalletSession', () => {
       resumed: false,
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
-      on_device: true,
+      passphrase: 'host hidden wallet',
+      on_device: false,
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).toHaveBeenCalled();
@@ -691,7 +843,7 @@ describe('openWalletSession', () => {
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
   });
 
-  test('gets the prepared session after on-device passphrase entry', async () => {
+  test('gets the prepared session after host passphrase entry', async () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
@@ -699,7 +851,7 @@ describe('openWalletSession', () => {
       .mockResolvedValueOnce({
         message: { btc_test_address: 'device-state', session_id: 'device-session' },
       });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
     });
@@ -711,11 +863,37 @@ describe('openWalletSession', () => {
       passphraseState: 'device-state',
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
-      on_device: true,
+      passphrase: 'host hidden wallet',
+      on_device: false,
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
+  test('selects an on-device passphrase wallet with an explicit on_device request', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: { btc_test_address: 'device-state', session_id: 'device-session' },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    method.device = createDevice({ typedCall, promptPassphrase }) as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'device-state',
+    });
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
+      on_device: true,
+    });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+  });
+
   test('forwards a host passphrase to Pro2 firmware', async () => {
     const typedCall = jest
       .fn()
@@ -832,7 +1010,9 @@ describe('openWalletSession', () => {
       },
       { cancelDeviceOnReject: false }
     );
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin, {
+      emitUiEvent: false,
+    });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
@@ -910,7 +1090,7 @@ describe('openWalletSession', () => {
         .fn()
         .mockResolvedValueOnce({ message: { version: 2 } })
         .mockRejectedValueOnce(new Error(message));
-      const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+      const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
       const method = new OpenWalletSession({
         payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
       });
@@ -963,7 +1143,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledTimes(1);
   });
 
-  test('unlocks and retries hidden-wallet preparation when the device is locked', async () => {
+  test('does not unlock or retry when wallet preparation reports a late DeviceLocked', async () => {
     const lockedError = { errorCode: HardwareErrorCode.DeviceLocked };
     const typedCall = jest
       .fn()
@@ -973,7 +1153,7 @@ describe('openWalletSession', () => {
       .mockResolvedValueOnce({
         message: { btc_test_address: 'hidden-state', session_id: 'hidden-session' },
       });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
     });
@@ -981,12 +1161,9 @@ describe('openWalletSession', () => {
     const device = createDevice({ typedCall, promptPassphrase });
     method.device = device as any;
 
-    await expect(method.run()).resolves.toMatchObject({
-      walletType: 'hidden',
-      passphraseState: 'hidden-state',
-    });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
-    expect(typedCall).toHaveBeenCalledTimes(4);
+    await expect(method.run()).rejects.toBe(lockedError);
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledTimes(2);
   });
 
   test('does not fall back when wallet preparation is rejected', async () => {
@@ -995,7 +1172,7 @@ describe('openWalletSession', () => {
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
       .mockRejectedValueOnce(invalidSessionError);
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
     });
@@ -1026,7 +1203,7 @@ describe('openWalletSession', () => {
         .mockResolvedValueOnce({ message: { version: 2 } })
         .mockResolvedValueOnce({ message: {} })
         .mockResolvedValueOnce({ message });
-      const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+      const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
       const method = new OpenWalletSession({
         payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
       });
@@ -1076,6 +1253,7 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
+      btc_test_address: 'hidden-state',
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -1107,7 +1285,7 @@ describe('openWalletSession', () => {
       .fn()
       .mockResolvedValueOnce({
         identity: { deviceId: undefined },
-        status: { passphraseProtection: true },
+        status: { unlocked: false, passphraseProtection: true },
       })
       .mockResolvedValueOnce({
         identity: { deviceId: 'device-1' },
@@ -1130,6 +1308,7 @@ describe('openWalletSession', () => {
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
+      btc_test_address: 'hidden-state',
     });
     const sessionGetCall = typedCall.mock.calls.findIndex(
       ([requestName]) => requestName === 'DeviceSessionGet'
@@ -1183,13 +1362,23 @@ describe('openWalletSession', () => {
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBeUndefined();
   });
 
-  test('does not fall back to wallet selection when a cached resume is invalid', async () => {
-    const typedCall = jest.fn().mockRejectedValue(
-      Object.assign(new Error('Invalid session'), {
-        errorCode: HardwareErrorCode.WalletSessionInvalid,
-      })
-    );
-    const promptPassphrase = jest.fn();
+  test('reselects the expected hidden wallet when a cached Protocol V2 session is invalid', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockRejectedValueOnce(
+        Object.assign(new Error('Invalid session'), {
+          errorCode: HardwareErrorCode.WalletSessionInvalid,
+        })
+      )
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'renewed-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
@@ -1203,15 +1392,32 @@ describe('openWalletSession', () => {
     deviceWalletSessionStore.set('device-1', 'hidden-state', 'expired-session');
     method.device = createDevice({ typedCall, promptPassphrase }) as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.WalletSessionInvalid,
+    await expect(method.run()).resolves.toEqual({
+      protocol: 'V2',
+      walletType: 'hidden',
+      deviceId: 'device-1',
+      passphraseState: 'hidden-state',
+      resumed: false,
     });
-    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'expired-session',
+      btc_test_address: 'hidden-state',
+    });
+    expect(promptPassphrase).toHaveBeenCalledTimes(1);
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
   });
 
-  test('rejects resume-hidden when the SDK store has no matching session', async () => {
-    const typedCall = jest.fn();
-    const promptPassphrase = jest.fn();
+  test('selects the expected hidden wallet when Protocol V2 has no cached session', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'new-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
@@ -1224,10 +1430,63 @@ describe('openWalletSession', () => {
     method.init();
     method.device = createDevice({ typedCall, promptPassphrase }) as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.WalletSessionInvalid,
+    await expect(method.run()).resolves.toEqual({
+      protocol: 'V2',
+      walletType: 'hidden',
+      deviceId: 'device-1',
+      passphraseState: 'hidden-state',
+      resumed: false,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      btc_test_address: 'hidden-state',
     });
-    expect(typedCall).not.toHaveBeenCalled();
     expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('new-session');
+  });
+
+  test.each([
+    {
+      deriveCardano: false,
+      seedDomains: [DeviceSessionSeedDomain.SeedDomain_Standard],
+    },
+    {
+      deriveCardano: true,
+      seedDomains: [
+        DeviceSessionSeedDomain.SeedDomain_Standard,
+        DeviceSessionSeedDomain.SeedDomain_Cardano,
+      ],
+    },
+  ])('requests the selected seed domains: $seedDomains', async ({ deriveCardano, seedDomains }) => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'new-session',
+        },
+      });
+    const method = new OpenWalletSession({
+      payload: {
+        method: 'openWalletSession',
+        connectId: 'connect-id',
+        mode: 'select-hidden',
+        deriveCardano,
+      },
+    });
+    method.init();
+    method.device = createDevice({
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
+    }) as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'hidden-state',
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      seed_domains: seedDomains,
+    });
   });
 });