@onekeyfe/hd-core 1.2.2-alpha.100 → 1.2.2-alpha.11

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

@@ -11,6 +11,13 @@ import {
   getProtocolV2WalletSession,
 } from '../src/protocols/protocol-v2/walletSession';
 
+const STANDARD_SEED_DOMAINS = [DeviceSessionSeedDomain.SeedDomain_Standard];
+const CARDANO_SEED_DOMAINS = [
+  DeviceSessionSeedDomain.SeedDomain_Standard,
+  DeviceSessionSeedDomain.SeedDomain_Cardano,
+];
+const standardSessionGet = {};
+
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
@@ -19,12 +26,16 @@ jest.mock('../src/data/config', () => ({
 const createDevice = ({
   passphraseProtection = true,
   unlockedAttachPin = false,
+  refreshedUnlocked = true,
+  refreshedPassphraseProtection = passphraseProtection,
   refreshedUnlockedAttachPin = unlockedAttachPin,
   typedCall = jest.fn(),
   promptPassphrase = jest.fn(),
 }: {
   passphraseProtection?: boolean;
   unlockedAttachPin?: boolean;
+  refreshedUnlocked?: boolean;
+  refreshedPassphraseProtection?: boolean;
   refreshedUnlockedAttachPin?: boolean;
   typedCall?: jest.Mock;
   promptPassphrase?: jest.Mock;
@@ -43,11 +54,11 @@ const createDevice = ({
           return {
             message: {
               device_id: 'device-1',
-              unlocked: true,
+              unlocked: refreshedUnlocked,
               attach_to_pin_enabled: unlockedAttachPin,
               unlocked_attach_pin: refreshedUnlockedAttachPin,
               unlocked_by_attach_to_pin: refreshedUnlockedAttachPin,
-              passphrase_enabled: passphraseProtection,
+              passphrase_enabled: refreshedPassphraseProtection,
             },
           };
         }
@@ -88,6 +99,8 @@ const createDevice = ({
     unlockDevice: jest.fn(),
     updateProtocolV2Status: jest.fn((status: Record<string, unknown>) => {
       device.features.unlocked = status.unlocked ?? device.features.unlocked;
+      device.features.passphraseProtection =
+        status.passphrase_enabled ?? device.features.passphraseProtection;
       device.features.attachToPinEnabled =
         status.attach_to_pin_enabled ?? device.features.attachToPinEnabled;
       device.features.unlockedAttachPin =
@@ -142,13 +155,12 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: '',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
-  test('opens the standard wallet directly when passphrase is disabled', async () => {
+  test('opens the already-unlocked standard wallet without repeating Main PIN when passphrase is disabled', async () => {
     const typedCall = jest.fn((request: string) => {
       if (request === 'ProtocolInfoRequest') {
         return { message: { version: 2 } };
@@ -167,14 +179,139 @@ describe('openWalletSession', () => {
 
     await getProtocolV2WalletSession(device as any, { onlyMainPin: true });
 
+    expect(device.unlockDevice).not.toHaveBeenCalled();
     expect(typedCall).not.toHaveBeenCalledWith(
       'DeviceSessionAskPassphrase',
       'Success',
       expect.anything()
     );
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
+  });
+
+  test('refreshes stale wallet status before accepting an only-Main-PIN session', async () => {
+    let attachPinSelected = true;
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'standard-session',
+          },
+        };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({
+      passphraseProtection: false,
+      unlockedAttachPin: false,
+      typedCall,
+    });
+    device.commands.typedCall.mockImplementation((request: string, ...args: unknown[]) => {
+      if (request === 'DeviceStatusGet') {
+        return {
+          message: {
+            device_id: 'device-1',
+            unlocked: true,
+            attach_to_pin_enabled: true,
+            unlocked_attach_pin: attachPinSelected,
+            unlocked_by_attach_to_pin: attachPinSelected,
+            passphrase_enabled: true,
+          },
+        };
+      }
+      return typedCall(request, ...args);
+    });
+    device.unlockDevice.mockImplementation(() => {
+      attachPinSelected = false;
+      device.features.unlockedAttachPin = false;
+      return Promise.resolve(device.features);
+    });
+
+    await expect(
+      getProtocolV2WalletSession(device as any, { onlyMainPin: true })
+    ).resolves.toMatchObject({
+      unlockedAttachPin: false,
+    });
+
+    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'wallet-session-coordinator',
+      reason: 'open-wallet',
+      deviceOnly: true,
+    });
+  });
+
+  test('still requires Main PIN when a cached standard session resolves to another wallet', async () => {
+    let sessionGetCount = 0;
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionGet') {
+        sessionGetCount += 1;
+        return {
+          message: {
+            btc_test_address:
+              sessionGetCount === 1 ? 'unexpected-wallet-state' : 'cached-standard-state',
+            session_id:
+              sessionGetCount === 1 ? 'unexpected-wallet-session' : 'cached-standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({ passphraseProtection: false, typedCall });
+    device.getStandardInternalState = jest.fn(() => ({
+      passphraseState: 'cached-standard-state',
+      sessionId: 'cached-standard-session',
+    }));
+    device.clearStandardInternalState = jest.fn();
+
+    await expect(
+      getProtocolV2WalletSession(device as any, { onlyMainPin: true })
+    ).resolves.toMatchObject({
+      passphraseState: 'cached-standard-state',
+      newSession: 'cached-standard-session',
+    });
+
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
+      source: 'wallet-session-coordinator',
+      reason: 'session-recovery',
+      deviceOnly: true,
+    });
+    expect(sessionGetCount).toBe(2);
+  });
+
+  test('reuses a Main PIN selected by the current preflight when passphrase is disabled', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({ passphraseProtection: false, typedCall });
+
+    await getProtocolV2WalletSession(device as any, {
+      onlyMainPin: true,
+      mainPinSelected: true,
     });
+
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
   test('does not treat an Attach PIN DeviceStatus as the Main wallet', async () => {
@@ -195,8 +332,7 @@ describe('openWalletSession', () => {
       }
       throw new Error(`Unexpected request: ${request}`);
     });
-    const device = createDevice({ typedCall });
-    device.features.unlockedAttachPin = true;
+    const device = createDevice({ refreshedUnlockedAttachPin: true, typedCall });
 
     await getProtocolV2WalletSession(device as any, { onlyMainPin: true });
 
@@ -301,10 +437,14 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(
+      3,
+      'DeviceSessionGet',
+      'DeviceSession',
+      standardSessionGet
+    );
   });
 
   test('keeps Legacy Protocol V1 getPassphraseState parameterless', async () => {
@@ -421,10 +561,14 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(
+      3,
+      'DeviceSessionGet',
+      'DeviceSession',
+      standardSessionGet
+    );
   });
 
   test('refreshes Pro2 status and unlocks before selecting a hidden wallet when locked', async () => {
@@ -698,9 +842,11 @@ describe('openWalletSession', () => {
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(device.commands.typedCall).toHaveBeenCalledWith(
+      'DeviceSessionGet',
+      'DeviceSession',
+      standardSessionGet
+    );
     expect(device.commands.typedCall).not.toHaveBeenCalledWith(
       'DeviceSessionAskPassphrase',
       'Success',
@@ -796,10 +942,9 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
     expect(promptPassphrase).toHaveBeenCalled();
     expect(deviceWalletSessionStore.get('device-1', 'new-hidden-state')).toBe('new-hidden-session');
   });
@@ -871,7 +1016,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
       btc_test_address: 'hidden-state',
-      seed_domains: [],
+      ...standardSessionGet,
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -1054,10 +1199,9 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: '',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
   });
@@ -1077,7 +1221,7 @@ describe('openWalletSession', () => {
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'standard' },
     });
     method.init();
-    const device = createDevice({ typedCall });
+    const device = createDevice({ refreshedUnlocked: false, typedCall });
     device.features.unlocked = false;
     device.getDeviceState = jest
       .fn()
@@ -1114,7 +1258,70 @@ describe('openWalletSession', () => {
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
   });
 
+  test('does not restrict a locked hidden-wallet selection to the Main PIN', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'hidden-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    const device = createDevice({ typedCall, promptPassphrase });
+    device.features.unlocked = false;
+    device.getDeviceState = jest
+      .fn()
+      .mockResolvedValueOnce({
+        identity: { deviceId: undefined },
+        status: { unlocked: false, passphraseProtection: true },
+      })
+      .mockResolvedValueOnce({
+        identity: { deviceId: 'device-1' },
+        status: {
+          unlocked: true,
+          passphraseProtection: true,
+          unlockedAttachPin: false,
+        },
+      })
+      .mockResolvedValueOnce({
+        identity: { deviceId: 'device-1' },
+        status: {
+          unlocked: true,
+          passphraseProtection: true,
+          unlockedAttachPin: false,
+        },
+      });
+    device.unlockDevice = jest.fn().mockImplementation(() => {
+      device.features.unlocked = true;
+      return Promise.resolve(device.features);
+    });
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'hidden-state',
+    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Any, {
+      source: 'unlock-coordinator',
+      reason: 'device-locked',
+      deviceOnly: true,
+      method: 'openWalletSession',
+    });
+    expect(device.unlockDevice).not.toHaveBeenCalledWith(
+      DeviceSessionPinType.Main,
+      expect.anything()
+    );
+  });
+
   test('switches from Attach PIN to Main PIN before opening the standard wallet', async () => {
+    let attachPinSelected = true;
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
@@ -1131,6 +1338,21 @@ describe('openWalletSession', () => {
     method.init();
     const device = createDevice({ typedCall });
     device.features.unlockedAttachPin = true;
+    device.commands.typedCall.mockImplementation((request: string, ...args: unknown[]) => {
+      if (request === 'DeviceStatusGet') {
+        return {
+          message: {
+            device_id: 'device-1',
+            unlocked: true,
+            attach_to_pin_enabled: true,
+            unlocked_attach_pin: attachPinSelected,
+            unlocked_by_attach_to_pin: attachPinSelected,
+            passphrase_enabled: true,
+          },
+        };
+      }
+      return typedCall(request, ...args);
+    });
     device.getDeviceState = jest
       .fn()
       .mockResolvedValueOnce({
@@ -1150,6 +1372,7 @@ describe('openWalletSession', () => {
         },
       });
     device.unlockDevice = jest.fn().mockImplementation(() => {
+      attachPinSelected = false;
       device.features.unlockedAttachPin = false;
       return Promise.resolve(device.features);
     });
@@ -1164,9 +1387,7 @@ describe('openWalletSession', () => {
       reason: 'open-wallet',
       deviceOnly: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
   test('selects a hidden wallet without exposing the internal device session', async () => {
@@ -1199,15 +1420,45 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
     expect(promptPassphrase).toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
   });
 
+  test('reuses the fresh unlock and wallet-selection statuses', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'hidden-state',
+          session_id: 'hidden-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    method.protocolV2UnlockContext = {
+      preflightCompleted: true,
+      preflightStatusRefreshed: true,
+    };
+    const device = createDevice({ typedCall, promptPassphrase });
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'hidden-state',
+    });
+
+    expect(device.getDeviceState.mock.calls).toEqual([[], []]);
+  });
+
   test('gets the prepared session after host passphrase entry', async () => {
     const typedCall = jest
       .fn()
@@ -1230,10 +1481,9 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
   test('selects an on-device passphrase wallet with an explicit on_device request', async () => {
@@ -1278,10 +1528,14 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       on_device: true,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(
+      3,
+      'DeviceSessionGet',
+      'DeviceSession',
+      standardSessionGet
+    );
     expect(device.createProtocolV2UiPhaseMetadata).toHaveBeenNthCalledWith(
       2,
       'passphrase-on-device',
@@ -1332,10 +1586,14 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(
+      3,
+      'DeviceSessionGet',
+      'DeviceSession',
+      standardSessionGet
+    );
   });
 
   test('normalizes a Unicode Host passphrase before sending it to Pro2 firmware', async () => {
@@ -1357,6 +1615,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'cafe\u0301',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
   });
 
@@ -1380,6 +1639,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase,
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
   });
 
@@ -1415,9 +1675,7 @@ describe('openWalletSession', () => {
     expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin, {
       emitUiEvent: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
   test('uses the complete Attach PIN wire flow without a main PIN unlock', async () => {
@@ -1446,7 +1704,7 @@ describe('openWalletSession', () => {
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
       ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.AttachToPin }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
-      ['DeviceSessionGet', 'DeviceSession', { seed_domains: [] }],
+      ['DeviceSessionGet', 'DeviceSession', standardSessionGet],
     ]);
     expect(device.commands.typedCall).not.toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
       type: DeviceSessionPinType.Main,
@@ -1658,7 +1916,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
       btc_test_address: 'hidden-state',
-      seed_domains: [],
+      ...standardSessionGet,
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -1718,7 +1976,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
       btc_test_address: 'hidden-state',
-      seed_domains: [],
+      ...standardSessionGet,
     });
     const sessionGetCall = typedCall.mock.calls.findIndex(
       ([requestName]) => requestName === 'DeviceSessionGet'
@@ -1816,23 +2074,28 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'expired-session',
       btc_test_address: 'hidden-state',
-      seed_domains: [],
+      ...standardSessionGet,
     });
     expect(promptPassphrase).toHaveBeenCalledTimes(1);
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
   });
 
-  test('selects the expected hidden wallet when Protocol V2 has no cached session', async () => {
+  test('recovers the current Attach PIN wallet when the cached session is invalid', async () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockRejectedValueOnce(
+        Object.assign(new Error('Invalid session'), {
+          errorCode: HardwareErrorCode.WalletSessionInvalid,
+        })
+      )
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'hidden-state',
-          session_id: 'new-session',
+          session_id: 'renewed-session',
         },
       });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
+    const promptPassphrase = jest.fn();
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
@@ -1843,7 +2106,9 @@ describe('openWalletSession', () => {
       },
     });
     method.init();
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
+    deviceWalletSessionStore.set('device-1', 'hidden-state', 'expired-session');
+    const device = createDevice({ unlockedAttachPin: true, typedCall, promptPassphrase });
+    method.device = device as any;
 
     await expect(method.run()).resolves.toEqual({
       protocol: 'V2',
@@ -1852,48 +2117,495 @@ describe('openWalletSession', () => {
       passphraseState: 'hidden-state',
       resumed: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      btc_test_address: 'hidden-state',
-      seed_domains: [],
-    });
+    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet')).toEqual([
+      [
+        'DeviceSessionGet',
+        'DeviceSession',
+        {
+          session_id: 'expired-session',
+          btc_test_address: 'hidden-state',
+        },
+      ],
+      ['DeviceSessionGet', 'DeviceSession', {}],
+    ]);
     expect(promptPassphrase).not.toHaveBeenCalled();
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('new-session');
+    expect(device.lockDevice).not.toHaveBeenCalled();
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
   });
 
-  test.each([false, true])('keeps deriveCardano API compatibility: %s', async deriveCardano => {
+  test('selects the expected hidden wallet when Protocol V2 has no cached session', async () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: {} })
       .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',
         connectId: 'connect-id',
-        mode: 'select-hidden',
-        deriveCardano,
-      },
-    });
+        mode: 'resume-hidden',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-state',
+      },
+    });
     method.init();
-    method.device = createDevice({
+    method.device = createDevice({ typedCall, promptPassphrase }) as any;
+
+    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',
+      ...standardSessionGet,
+    });
+    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('new-session');
+  });
+
+  test.each([false, true])(
+    'openWalletSession does not thread CommonParams.deriveCardano: %s',
+    async deriveCardano => {
+      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('DeviceSessionAskPassphrase', 'Success', {
+        passphrase: 'host hidden wallet',
+        on_device: false,
+        seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
+      });
+      expect(typedCall).toHaveBeenCalledWith(
+        'DeviceSessionGet',
+        'DeviceSession',
+        standardSessionGet
+      );
+    }
+  );
+
+  test('requests Cardano seed domains when a V2 session rebuild has Cardano intent', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'hidden-state',
+            session_id: 'new-session',
+            seed_domains: [
+              DeviceSessionSeedDomain.SeedDomain_Standard,
+              DeviceSessionSeedDomain.SeedDomain_Cardano,
+            ],
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({
       typedCall,
       promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
-    }) as any;
+    });
 
-    await expect(method.run()).resolves.toMatchObject({
-      walletType: 'hidden',
+    await expect(
+      getProtocolV2WalletSession(device as any, {
+        forceWalletSelection: true,
+        deriveCardano: true,
+      })
+    ).resolves.toMatchObject({
       passphraseState: 'hidden-state',
+      newSession: 'new-session',
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+      passphrase: 'host hidden wallet',
+      on_device: false,
+      seed_domains: CARDANO_SEED_DOMAINS,
     });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
+  });
+
+  test('asks Cardano seed domains after Get reports a Standard-only session', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        const hasCardanoAsk = typedCall.mock.calls.some(
+          call =>
+            call[0] === 'DeviceSessionAskPassphrase' &&
+            Array.isArray(call[2]?.seed_domains) &&
+            call[2].seed_domains.includes(DeviceSessionSeedDomain.SeedDomain_Cardano)
+        );
+        return {
+          message: {
+            btc_test_address: 'hidden-state',
+            session_id: 'new-session',
+            seed_domains: hasCardanoAsk
+              ? [
+                  DeviceSessionSeedDomain.SeedDomain_Standard,
+                  DeviceSessionSeedDomain.SeedDomain_Cardano,
+                ]
+              : [DeviceSessionSeedDomain.SeedDomain_Standard],
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
+    });
+    device.passphraseState = 'hidden-state';
+    deviceWalletSessionStore.set('device-1', 'hidden-state', 'cached-session');
+
+    await getProtocolV2WalletSession(device as any, {
+      expectedPassphraseState: 'hidden-state',
+      deriveCardano: true,
+    });
+
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'cached-session',
+      btc_test_address: 'hidden-state',
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+      passphrase: 'host hidden wallet',
+      on_device: false,
       seed_domains: [
         DeviceSessionSeedDomain.SeedDomain_Standard,
-        ...(deriveCardano ? [DeviceSessionSeedDomain.SeedDomain_Cardano] : []),
+        DeviceSessionSeedDomain.SeedDomain_Cardano,
       ],
     });
   });
+
+  test('uses empty AskPassphrase to add Cardano on an Attach PIN session', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        const askedCardano = typedCall.mock.calls.some(
+          call =>
+            call[0] === 'DeviceSessionAskPassphrase' &&
+            Array.isArray(call[2]?.seed_domains) &&
+            call[2].seed_domains.includes(DeviceSessionSeedDomain.SeedDomain_Cardano)
+        );
+        return {
+          message: {
+            btc_test_address: 'attach-state',
+            session_id: 'attach-session',
+            seed_domains: askedCardano ? CARDANO_SEED_DOMAINS : STANDARD_SEED_DOMAINS,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'should-not-ask' });
+    const device = createDevice({
+      typedCall,
+      promptPassphrase,
+      unlockedAttachPin: true,
+    });
+
+    await expect(
+      getProtocolV2WalletSession(device as any, {
+        readCurrentAttachPinSession: true,
+        deriveCardano: true,
+      })
+    ).resolves.toMatchObject({
+      passphraseState: 'attach-state',
+      newSession: 'attach-session',
+      unlockedAttachPin: true,
+    });
+    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+      passphrase: '',
+      on_device: false,
+      seed_domains: CARDANO_SEED_DOMAINS,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(
+      typedCall.mock.calls
+        .filter(call => call[0] === 'DeviceSessionGet')
+        .every(call => !('seed_domains' in (call[2] ?? {})))
+    ).toBe(true);
+  });
+
+  test('uses empty AskPassphrase after selecting Attach PIN for Cardano intent', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'attach-state',
+            session_id: 'attach-session',
+            seed_domains: CARDANO_SEED_DOMAINS,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue({ attachPinOnDevice: true });
+    const device = createDevice({ typedCall, promptPassphrase });
+    device.features.attachToPinEnabled = true;
+
+    await expect(
+      getProtocolV2WalletSession(device as any, {
+        forceWalletSelection: true,
+        deriveCardano: true,
+      })
+    ).resolves.toMatchObject({
+      passphraseState: 'attach-state',
+      newSession: 'attach-session',
+      unlockedAttachPin: true,
+    });
+    expect(promptPassphrase).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).toHaveBeenCalledWith(
+      DeviceSessionPinType.AttachToPin,
+      expect.objectContaining({ emitUiEvent: false })
+    );
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+      passphrase: '',
+      on_device: false,
+      seed_domains: CARDANO_SEED_DOMAINS,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(
+      typedCall.mock.calls
+        .filter(call => call[0] === 'DeviceSessionGet')
+        .every(call => !('seed_domains' in (call[2] ?? {})))
+    ).toBe(true);
+  });
+
+  test('still locks before a passphrase picker after Attach PIN Cardano empty Ask', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'attach-state',
+            session_id: 'attach-session',
+            seed_domains: CARDANO_SEED_DOMAINS,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'should-not-ask' });
+    const device = createDevice({
+      typedCall,
+      promptPassphrase,
+      unlockedAttachPin: true,
+    });
+
+    await getProtocolV2WalletSession(device as any, {
+      readCurrentAttachPinSession: true,
+      deriveCardano: true,
+    });
+    await expect(
+      getProtocolV2WalletSession(device as any, { forceWalletSelection: true })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceCheckUnlockTypeError,
+    });
+    expect(device.lockDevice).toHaveBeenCalled();
+    expect(promptPassphrase).not.toHaveBeenCalled();
+  });
+
+  test('uses a second Get for Cardano when passphrase protection is off', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionGet') {
+        const getCount = typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet').length;
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'standard-session',
+            seed_domains: getCount > 1 ? CARDANO_SEED_DOMAINS : STANDARD_SEED_DOMAINS,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({
+      typedCall,
+      passphraseProtection: false,
+    });
+
+    await expect(
+      getProtocolV2WalletSession(device as any, {
+        onlyMainPin: true,
+        deriveCardano: true,
+      })
+    ).resolves.toMatchObject({
+      passphraseState: 'standard-state',
+      newSession: 'standard-session',
+    });
+    expect(typedCall).not.toHaveBeenCalledWith(
+      'DeviceSessionAskPassphrase',
+      'Success',
+      expect.anything()
+    );
+    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet')).toHaveLength(2);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+  });
+
+  test('fails closed when Cardano fallback still lacks Cardano', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'hidden-state',
+            session_id: 'hidden-session',
+            seed_domains: STANDARD_SEED_DOMAINS,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
+    });
+    deviceWalletSessionStore.set('device-1', 'hidden-state', 'cached-session');
+
+    await expect(
+      getProtocolV2WalletSession(device as any, {
+        expectedPassphraseState: 'hidden-state',
+        deriveCardano: true,
+      })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.WalletSessionInvalid,
+    });
+    expect(device.clearInternalState).toHaveBeenCalled();
+  });
+
+  test('locks before selecting a passphrase wallet from an Attach PIN session', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceStatusGet') {
+        return {
+          message: {
+            device_id: 'device-1',
+            unlocked: true,
+            passphrase_enabled: true,
+            unlocked_by_attach_to_pin: true,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'should-not-ask' });
+    const device = createDevice({
+      typedCall,
+      promptPassphrase,
+      unlockedAttachPin: true,
+    });
+
+    await expect(
+      getProtocolV2WalletSession(device as any, { forceWalletSelection: true })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceCheckUnlockTypeError,
+    });
+    expect(device.lockDevice).toHaveBeenCalled();
+    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(typedCall).not.toHaveBeenCalledWith(
+      'DeviceSessionAskPassphrase',
+      'Success',
+      expect.anything()
+    );
+  });
+
+  test('asks Standard-only seed domains when deriveCardano is false', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'hidden-state',
+            session_id: 'new-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
+    });
+
+    await getProtocolV2WalletSession(device as any, {
+      forceWalletSelection: true,
+      deriveCardano: false,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+      passphrase: 'host hidden wallet',
+      on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
+    });
+  });
 });