@onekeyfe/hd-core 1.2.0-alpha.33 → 1.2.0-alpha.35

package/__tests__/protocol-v2.test.ts

@@ -1,5 +1,10 @@
 import { EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceRebootType, DeviceSessionPinType, DeviceSettingsPage } from '@onekeyfe/hd-transport';
+import {
+  DeviceRebootType,
+  DeviceSessionPinType,
+  DeviceSettingsPage,
+  DeviceType,
+} from '@onekeyfe/hd-transport';
 
 import * as firmwareBinaryApi from '../src/api/firmware/getBinary';
 import DnxGetAddress from '../src/api/dynex/DnxGetAddress';
@@ -54,15 +59,20 @@ import { getBitcoinForkSupportedProtocols } from '../src/api/btc/helpers/version
 import { DataManager } from '../src/data-manager';
 import { createCoreApi } from '../src/inject';
 import { Device, preloadSessionCache } from '../src/device/Device';
+import { deviceWalletSessionStore } from '../src/device/DeviceWalletSessionStore';
 import { DevicePool } from '../src/device/DevicePool';
 import { UI_REQUEST } from '../src/events/ui-request';
 import {
   PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
+  PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE,
   type ProtocolV2DeviceInfo,
   type ProtocolV2RuntimeMode,
   getProtocolV2RuntimeMode,
+  parseProtocolV2BuildFingerprint,
   requestProtocolV2DeviceInfo,
+  requestProtocolV2ProtocolInfo,
   requestProtocolV2DeviceStatus,
+  supportsProtocolV2Message,
 } from '../src/protocols/protocol-v2/features';
 import {
   getProtocolV2WalletSession,
@@ -89,18 +99,26 @@ import {
 
 import type { DeviceCommands } from '../src/device/DeviceCommands';
 import type { Features } from '../src/types';
-import type { DeviceStatus } from '@onekeyfe/hd-transport';
+import type { DeviceStatus, ProtocolInfo } from '@onekeyfe/hd-transport';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
-const createWalletSessionTypedCall = (implementation = jest.fn()) =>
+const createWalletSessionTypedCall = (
+  implementation = jest.fn(),
+  status: Partial<DeviceStatus> = { passphrase_enabled: true }
+) =>
   jest.fn((request: string, ...args: unknown[]) => {
     if (request === 'ProtocolInfoRequest') {
       return Promise.resolve({ message: { version: 2 } });
     }
+    if (request === 'DeviceStatusGet') {
+      return Promise.resolve({
+        message: { unlocked: true, unlocked_attach_pin: false, ...status },
+      });
+    }
     return implementation(request, ...args);
   });
 
@@ -129,7 +147,7 @@ describe('DeviceUploadWallpaper', () => {
     const result = await method.run();
 
     expect(method.getSupportedProtocols()).toEqual(['V2']);
-    expect(method.unlockPolicy).toBe('unlock-before-run');
+    expect(method.unlockPolicy).toBe('none');
     expect(typedCall).toHaveBeenNthCalledWith(1, 'FilesystemDirMake', 'Success', {
       path: 'vol1:/wallpapers',
     });
@@ -333,6 +351,24 @@ const descriptor = {
   path: 'usb-path',
 };
 
+const protocolV2ApplicationInfo = {
+  version: 1,
+  build_fingerprint: 'application__1.2.3__abcdef0__PROD__RELEASE',
+  supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
+};
+
+const protocolV2BootloaderInfo = {
+  version: 1,
+  build_fingerprint: 'bootloader__0.2.0__abcdef0__PROD__RELEASE',
+  supported_messages: [],
+};
+
+const protocolV2RomloaderInfo = {
+  version: 1,
+  build_fingerprint: 'romloader__1.0.0__abcdef0__PROD__RELEASE',
+  supported_messages: [],
+};
+
 /**
  * Add Device protocol and getCurrent* accessors to plain-object stubs.
  * Defaults match Device.ts and never replace an existing member such as jest.fn().
@@ -342,6 +378,8 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
   d.updateState ??= jest.fn();
   d.markProtocolV2Reboot ??= jest.fn();
   d.isProtocolV2 ??= () => d.originalDescriptor?.protocolType === 'V2';
+  d.isBootloader ??= () => d.features?.mode === 'bootloader';
+  d.isRomloader ??= () => d.features?.mode === 'romloader';
   d.getProtocol ??= () => (d.isProtocolV2() ? 'V2' : 'V1');
   d.getCurrentDeviceType ??= () => getDeviceType(d.features);
   d.getCurrentFirmwareType ??= () => getFirmwareType(d.features);
@@ -361,7 +399,8 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
   d.updateProtocolV2Features ??= (
     deviceInfo?: ProtocolV2DeviceInfo,
     deviceStatus?: DeviceStatus,
-    runtimeMode?: ProtocolV2RuntimeMode
+    runtimeMode?: ProtocolV2RuntimeMode,
+    protocolInfo?: ProtocolInfo
   ) => {
     d.features = buildProtocolV2FeaturesPayload({
       deviceInfo,
@@ -369,44 +408,35 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
       previous: d.features,
       runtimeMode: runtimeMode ?? (deviceStatus ? 'normal' : undefined),
     });
+    if (protocolInfo) {
+      d.features.raw = {
+        ...d.features.raw,
+        protocolV2ProtocolInfo: protocolInfo,
+      };
+    }
     return d.features;
   };
   d.probeProtocolV2RuntimeState ??= async (
     deviceInfo: ProtocolV2DeviceInfo,
     timeoutMs?: number
   ) => {
-    try {
-      const response = await d
-        .getCommands()
-        .typedCall(
-          'DeviceStatusGet',
-          'DeviceStatus',
-          {},
-          timeoutMs === undefined ? undefined : { timeoutMs }
-        );
-      const features = d.updateProtocolV2Features(deviceInfo, response.message, 'normal');
-      return (
-        features ??
-        buildProtocolV2FeaturesPayload({
-          deviceInfo,
-          deviceStatus: response.message,
-          previous: d.features,
-          runtimeMode: 'normal',
-        })
-      );
-    } catch {
-      const runtimeMode = getProtocolV2RuntimeMode({
-        deviceInfo,
-        deviceStatusAvailable: false,
-      });
-      const features = d.updateProtocolV2Features(deviceInfo, null, runtimeMode);
-      if (features?.mode === runtimeMode) return features;
-      return buildProtocolV2FeaturesPayload({
-        deviceInfo,
-        previous: d.features,
-        runtimeMode,
-      });
+    const protocolInfo = await requestProtocolV2ProtocolInfo({
+      commands: d.getCommands(),
+      timeoutMs,
+    });
+    const runtimeMode = getProtocolV2RuntimeMode(protocolInfo);
+    if (runtimeMode === 'bootloader' || runtimeMode === 'romloader') {
+      return d.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
+    }
+    if (!supportsProtocolV2Message(protocolInfo, PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE)) {
+      if (!runtimeMode) throw new Error('Unknown Protocol V2 runtime mode');
+      return d.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
     }
+    const deviceStatus = await requestProtocolV2DeviceStatus({
+      commands: d.getCommands(),
+      timeoutMs,
+    });
+    return d.updateProtocolV2Features(deviceInfo, deviceStatus, 'normal', protocolInfo);
   };
   d.updateProtocolV2Status ??= (deviceStatus: DeviceStatus) => {
     d.features = buildProtocolV2FeaturesPayload({
@@ -464,6 +494,10 @@ async function requestProtocolV2Features({
 }
 
 describe('Protocol V2 feature adapter', () => {
+  beforeEach(() => {
+    deviceWalletSessionStore.clear();
+  });
+
   test('treats passphrase status as unknown until the Protocol V2 device is unlocked', () => {
     const features = buildProtocolV2FeaturesPayload({
       deviceInfo: {
@@ -575,6 +609,7 @@ describe('Protocol V2 feature adapter', () => {
     const features = normalizeProtocolV2Features(descriptor as any, {
       protocol_version: 1,
       hw: {
+        Device_type: DeviceType.PRO2,
         serial_no: 'PR2SERIAL',
       },
       fw: {
@@ -661,7 +696,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(features.bleEnabled).toBeNull();
   });
 
-  test('marks Protocol V2 DeviceInfo as bootloader when DeviceStatusGet fails', () => {
+  test('parses bootloader runtime mode from ProtocolInfo build fingerprint', () => {
     const deviceInfo = {
       protocol_version: 1,
       hw: {
@@ -674,10 +709,7 @@ describe('Protocol V2 feature adapter', () => {
       },
       se1: {},
     };
-    const runtimeMode = getProtocolV2RuntimeMode({
-      deviceInfo: deviceInfo as ProtocolV2DeviceInfo,
-      deviceStatusAvailable: false,
-    });
+    const runtimeMode = getProtocolV2RuntimeMode(protocolV2BootloaderInfo);
     const features = normalizeProtocolV2Features(
       descriptor as any,
       deviceInfo as ProtocolV2DeviceInfo,
@@ -699,7 +731,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(features.bootloaderMode).toBe(false);
   });
 
-  test('temporarily treats romloader metadata as bootloader when DeviceStatusGet fails', () => {
+  test('keeps romloader distinct from bootloader using ProtocolInfo build fingerprint', () => {
     const deviceInfo = {
       protocol_version: 1,
       hw: {
@@ -714,31 +746,50 @@ describe('Protocol V2 feature adapter', () => {
         },
       },
     };
-    const runtimeMode = getProtocolV2RuntimeMode({
-      deviceInfo: deviceInfo as ProtocolV2DeviceInfo,
-      deviceStatusAvailable: false,
-    });
+    const runtimeMode = getProtocolV2RuntimeMode(protocolV2RomloaderInfo);
     const features = normalizeProtocolV2Features(
       descriptor as any,
       deviceInfo as ProtocolV2DeviceInfo,
       runtimeMode
     );
-    expect(features.mode).toBe('bootloader');
+    expect(features.mode).toBe('romloader');
     expect(features.bootloaderMode).toBe(true);
     expect(features.boardVersion).toBe('1.0.0');
   });
 
+  test('rejects malformed Protocol V2 build fingerprints', () => {
+    expect(parseProtocolV2BuildFingerprint('application__1.2.3')).toBeNull();
+    expect(
+      getProtocolV2RuntimeMode({
+        version: 1,
+        build_fingerprint: 'unknown__1.2.3__abcdef0__PROD__RELEASE',
+        supported_messages: [],
+      })
+    ).toBeUndefined();
+  });
+
   test('keeps the Protocol V2 main wallet on the default empty-passphrase context', async () => {
     const features = normalizeProtocolV2Features(descriptor as any);
     features.firmwareVersion = '1.2.3';
     features.passphraseProtection = true;
     const typedCall = createWalletSessionTypedCall(
-      jest.fn().mockResolvedValue({
-        type: 'DeviceSession',
-        message: {
-          btc_test_address: 'state-1',
-          session_id: 'session-1',
-        },
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionAskPin') {
+          return { type: 'Success', message: { message: 'PIN verified' } };
+        }
+        if (request === 'DeviceStatusGet') {
+          return { type: 'DeviceStatus', message: { unlocked: true } };
+        }
+        if (request === 'DeviceSessionGet') {
+          return {
+            type: 'DeviceSession',
+            message: {
+              btc_test_address: 'state-1',
+              session_id: 'session-1',
+            },
+          };
+        }
+        throw new Error(`Unexpected request: ${request}`);
       })
     );
     const commands = { typedCall } as unknown as DeviceCommands;
@@ -751,18 +802,233 @@ describe('Protocol V2 feature adapter', () => {
         onlyMainPin: true,
       })
     ).resolves.toEqual({
-      passphraseState: undefined,
-      newSession: undefined,
-      unlockedAttachPin: false,
+      passphraseState: 'state-1',
+      newSession: 'session-1',
+      unlockedAttachPin: undefined,
       resumed: false,
     });
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(device.getInternalState()).toBeUndefined();
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
+      type: DeviceSessionPinType.Main,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    device.passphraseState = 'state-1';
+    expect(device.getInternalState()).toBe('session-1');
+  });
+
+  test('reuses the cached Protocol V2 standard wallet instead of asking Main PIN again', async () => {
+    const deviceId = 'standard-reuse-device';
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: deviceId,
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') return { message: { version: 2 } };
+      if (request === 'DeviceSessionAskPin') {
+        return { type: 'Success', message: { message: 'PIN verified' } };
+      }
+      if (request === 'DeviceStatusGet') {
+        return {
+          message: {
+            device_id: deviceId,
+            unlocked: true,
+            passphrase_enabled: true,
+          },
+        };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    (device as any).commands = { typedCall };
+
+    await getProtocolV2WalletSession(device, { onlyMainPin: true });
+    await getProtocolV2WalletSession(device, { onlyMainPin: true });
+
+    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionAskPin')).toHaveLength(1);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'standard-session',
+    });
+    expect(deviceWalletSessionStore.getStandard(deviceId)).toEqual({
+      passphraseState: 'standard-state',
+      sessionId: 'standard-session',
+    });
+  });
+
+  test('reopens the Protocol V2 standard wallet when the cached session resolves to another wallet', async () => {
+    const deviceId = 'standard-invalid-device';
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: deviceId,
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    deviceWalletSessionStore.set(deviceId, 'hidden-state', 'hidden-session');
+    deviceWalletSessionStore.setStandard(deviceId, 'old-standard-state', 'old-standard-session');
+
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'ProtocolInfoRequest') return { message: { version: 2 } };
+      if (request === 'DeviceSessionGet' && params.session_id) {
+        return {
+          message: {
+            btc_test_address: 'hidden-state',
+            session_id: 'hidden-session',
+          },
+        };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'old-standard-state',
+            session_id: 'new-standard-session',
+          },
+        };
+      }
+      if (request === 'DeviceSessionAskPin') {
+        return { type: 'Success', message: { message: 'PIN verified' } };
+      }
+      if (request === 'DeviceStatusGet') {
+        return { message: { device_id: deviceId, unlocked: true, passphrase_enabled: true } };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    (device as any).commands = { typedCall };
+
+    await expect(getProtocolV2WalletSession(device, { onlyMainPin: true })).resolves.toMatchObject({
+      passphraseState: 'old-standard-state',
+      newSession: 'new-standard-session',
+      resumed: false,
+    });
+    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionAskPin')).toHaveLength(1);
+    expect(deviceWalletSessionStore.getStandard(deviceId)).toEqual({
+      passphraseState: 'old-standard-state',
+      sessionId: 'new-standard-session',
+    });
+    expect(deviceWalletSessionStore.get(deviceId, 'hidden-state')).toBe('hidden-session');
   });
 
-  test('keeps Protocol V2 on the standard wallet when passphrase protection is disabled', async () => {
+  test('propagates DeviceLocked instead of retrying a cached standard session', async () => {
+    const deviceId = 'standard-locked-device';
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: deviceId,
+          unlocked: false,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    deviceWalletSessionStore.setStandard(deviceId, 'standard-state', 'cached-standard-session');
+
+    let sessionGetCalls = 0;
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') return { message: { version: 2 } };
+      if (request === 'DeviceSessionAskPin') {
+        return { type: 'Success', message: { message: 'PIN verified' } };
+      }
+      if (request === 'DeviceStatusGet') {
+        return { message: { device_id: deviceId, unlocked: true, passphrase_enabled: true } };
+      }
+      if (request === 'DeviceSessionGet') {
+        sessionGetCalls += 1;
+        if (sessionGetCalls === 1) {
+          throw Object.assign(new Error('Device is locked'), {
+            errorCode: HardwareErrorCode.DeviceLocked,
+          });
+        }
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'cached-standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    (device as any).commands = { typedCall };
+
+    await expect(getProtocolV2WalletSession(device, { onlyMainPin: true })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceLocked,
+    });
+    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet')).toHaveLength(1);
+    expect(deviceWalletSessionStore.getStandard(deviceId)).toBeUndefined();
+  });
+
+  test('recovers a mismatched cached standard wallet without deleting hidden sessions', async () => {
+    const deviceId = 'standard-mismatch-device';
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: deviceId,
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    deviceWalletSessionStore.set(deviceId, 'hidden-state', 'hidden-session');
+    deviceWalletSessionStore.setStandard(deviceId, 'standard-state', 'standard-session');
+    let sessionGetCalls = 0;
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') return { message: { version: 2 } };
+      if (request === 'DeviceSessionAskPin') return { message: { message: 'PIN verified' } };
+      if (request === 'DeviceStatusGet') {
+        return { message: { device_id: deviceId, unlocked: true, passphrase_enabled: true } };
+      }
+      if (request === 'DeviceSessionGet') {
+        sessionGetCalls += 1;
+        return {
+          message: {
+            btc_test_address: sessionGetCalls === 1 ? 'unexpected-wallet-state' : 'standard-state',
+            session_id: sessionGetCalls === 1 ? 'unexpected-session' : 'renewed-standard-session',
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    (device as any).commands = { typedCall };
+
+    await expect(getProtocolV2WalletSession(device, { onlyMainPin: true })).resolves.toMatchObject({
+      passphraseState: 'standard-state',
+      newSession: 'renewed-standard-session',
+      resumed: false,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
+      type: DeviceSessionPinType.Main,
+    });
+    expect(deviceWalletSessionStore.getStandard(deviceId)).toEqual({
+      passphraseState: 'standard-state',
+      sessionId: 'renewed-standard-session',
+    });
+    expect(deviceWalletSessionStore.get(deviceId, 'hidden-state')).toBe('hidden-session');
+  });
+
+  test('selects a Protocol V2 wallet explicitly even when passphrase protection was disabled', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
@@ -783,13 +1049,13 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(getProtocolV2WalletSession(device)).resolves.toEqual({
-      passphraseState: undefined,
-      newSession: undefined,
-      unlockedAttachPin: false,
+      passphraseState: 'main-wallet-state',
+      newSession: 'main-wallet-session',
+      unlockedAttachPin: undefined,
       resumed: false,
     });
 
-    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(promptPassphrase).toHaveBeenCalled();
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
@@ -835,7 +1101,7 @@ describe('Protocol V2 feature adapter', () => {
     });
   });
 
-  test('uses refreshed passphrase status after unlocking before selecting a Protocol V2 wallet', async () => {
+  test('does not implicitly unlock inside the Protocol V2 wallet-session coordinator', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
@@ -847,14 +1113,15 @@ describe('Protocol V2 feature adapter', () => {
       }
     );
     const typedCall = createWalletSessionTypedCall(
-      jest.fn().mockImplementation((request: string) => {
-        if (request === 'DeviceStatusGet') {
-          return Promise.resolve({
-            message: { passphrase_enabled: false, unlocked: true },
-          });
-        }
-        throw new Error(`Unexpected request: ${request}`);
-      })
+      jest
+        .fn()
+        .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
+        .mockResolvedValueOnce({
+          message: {
+            btc_test_address: 'hidden-after-unlock-state',
+            session_id: 'hidden-after-unlock-session',
+          },
+        })
     );
     const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden-after-unlock' });
     const unlockDevice = jest.spyOn(device, 'unlockDevice').mockImplementation(() => {
@@ -868,14 +1135,14 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(getProtocolV2WalletSession(device)).resolves.toEqual({
-      passphraseState: undefined,
-      newSession: undefined,
-      unlockedAttachPin: false,
+      passphraseState: 'hidden-after-unlock-state',
+      newSession: 'hidden-after-unlock-session',
+      unlockedAttachPin: undefined,
       resumed: false,
     });
 
-    expect(unlockDevice).toHaveBeenCalledTimes(1);
-    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(unlockDevice).not.toHaveBeenCalled();
+    expect(promptPassphrase).toHaveBeenCalled();
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
@@ -905,8 +1172,8 @@ describe('Protocol V2 feature adapter', () => {
         onlyMainPin: true,
       })
     ).resolves.toMatchObject({
-      passphraseState: undefined,
-      newSession: undefined,
+      passphraseState: 'main-wallet-state',
+      newSession: 'main-wallet-session',
     });
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
@@ -933,12 +1200,20 @@ describe('Protocol V2 feature adapter', () => {
       }
     );
     const typedCall = createWalletSessionTypedCall(
-      jest.fn().mockResolvedValue({
-        type: 'DeviceSession',
-        message: { session_id: 'hidden-session', btc_test_address: 'hidden-state' },
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionAskPassphrase') {
+          return { type: 'Success', message: { message: 'Passphrase prepared' } };
+        }
+        if (request === 'DeviceSessionGet') {
+          return {
+            type: 'DeviceSession',
+            message: { session_id: 'hidden-session', btc_test_address: 'hidden-state' },
+          };
+        }
+        throw new Error(`Unexpected request: ${request}`);
       })
     );
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(getProtocolV2WalletSession(device)).resolves.toMatchObject({
@@ -948,7 +1223,8 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(promptPassphrase).toHaveBeenCalled();
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
-      on_device: true,
+      passphrase: 'host hidden wallet',
+      on_device: false,
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
@@ -979,7 +1255,7 @@ describe('Protocol V2 feature adapter', () => {
 
   test('deviceGetOnboardingStatus returns the current Protocol V2 onboarding status', async () => {
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'DevOnboardingStatus',
+      type: 'OnboardingStatus',
       message: {
         step: 4,
         phase: 4,
@@ -1007,7 +1283,7 @@ describe('Protocol V2 feature adapter', () => {
       pin_set: true,
       wallet_initialized: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DevGetOnboardingStatus', 'DevOnboardingStatus', {});
+    expect(typedCall).toHaveBeenCalledWith('OnboardingStatusGet', 'OnboardingStatus', {});
     expect(method.getSupportedProtocols()).toEqual(['V2']);
   });
 
@@ -1148,15 +1424,18 @@ describe('Protocol V2 feature adapter', () => {
       }
     );
     const typedCall = createWalletSessionTypedCall(
-      jest.fn().mockRejectedValue(
-        Object.assign(new Error('Invalid session'), {
-          errorCode: HardwareErrorCode.WalletSessionInvalid,
-        })
-      )
+      jest
+        .fn()
+        .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
+        .mockRejectedValueOnce(
+          Object.assign(new Error('Invalid session'), {
+            errorCode: HardwareErrorCode.WalletSessionInvalid,
+          })
+        )
     );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
 
     await expect(getProtocolV2WalletSession(device)).rejects.toMatchObject({
@@ -1164,11 +1443,17 @@ describe('Protocol V2 feature adapter', () => {
     });
     expect(typedCall.mock.calls).toEqual([
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
-      ['DeviceSessionAskPassphrase', 'Success', { on_device: true }],
+      [
+        'DeviceSessionAskPassphrase',
+        'Success',
+        { passphrase: 'host hidden wallet', on_device: false },
+      ],
+      ['DeviceStatusGet', 'DeviceStatus', {}],
+      ['DeviceSessionGet', 'DeviceSession', {}],
     ]);
   });
 
-  test('rejects a mismatched Pro2 wallet state and clears the selected cache entry', async () => {
+  test('reselects a hidden wallet when the cached Pro2 session resolves to another wallet', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-mismatch',
       path: 'cache-path-mismatch',
@@ -1186,26 +1471,148 @@ describe('Protocol V2 feature adapter', () => {
     );
     device.passphraseState = 'state-a';
     preloadSessionCache('stable-device-mismatch', 'state-a', 'session-a');
-    (device as any).commands = {
-      typedCall: createWalletSessionTypedCall(
-        jest.fn().mockResolvedValue({
-          type: 'DeviceSession',
-          message: { session_id: 'session-b', btc_test_address: 'state-b' },
-        })
-      ),
-    };
+    let sessionGetCalls = 0;
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionAskPassphrase') return { message: { message: 'prepared' } };
+        if (request === 'DeviceSessionGet') {
+          sessionGetCalls += 1;
+          return {
+            type: 'DeviceSession',
+            message:
+              sessionGetCalls === 1
+                ? { session_id: 'session-b', btc_test_address: 'state-b' }
+                : { session_id: 'session-a-new', btc_test_address: 'state-a' },
+          };
+        }
+        throw new Error(`Unexpected request: ${request}`);
+      })
+    );
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
+    (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(
       getPassphraseStateWithRefreshDeviceInfo(device, { expectPassphraseState: 'state-a' })
-    ).rejects.toEqual(
+    ).resolves.toMatchObject({
+      passphraseState: 'state-a',
+      newSession: 'session-a-new',
+      resumed: false,
+    });
+    expect(promptPassphrase).toHaveBeenCalledWith(
       expect.objectContaining({
-        errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
+        source: 'wallet-session-coordinator',
+        reason: 'session-recovery',
+        expectedPassphraseState: 'state-a',
+      }),
+      { cancelDeviceOnReject: false }
+    );
+    expect(device.getInternalState()).toBe('session-a-new');
+  });
+
+  test('rejects a hidden wallet when one recovery still returns the wrong state', async () => {
+    const device = Device.fromDescriptor({
+      id: 'cache-device-final-mismatch',
+      path: 'cache-path-final-mismatch',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: 'stable-device-final-mismatch',
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    device.passphraseState = 'state-a';
+    preloadSessionCache('stable-device-final-mismatch', 'state-a', 'session-a');
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionAskPassphrase') return { message: { message: 'prepared' } };
+        if (request === 'DeviceSessionGet') {
+          return {
+            type: 'DeviceSession',
+            message: { session_id: 'wrong-session', btc_test_address: 'wrong-state' },
+          };
+        }
+        throw new Error(`Unexpected request: ${request}`);
       })
     );
+    (device as any).commands = {
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
+    };
+
+    await expect(
+      getPassphraseStateWithRefreshDeviceInfo(device, { expectPassphraseState: 'state-a' })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
+    });
     expect(device.getInternalState()).toBeUndefined();
   });
 
-  test('unlocks and retries DeviceSessionAskPassphrase when wallet selection is locked', async () => {
+  test('recovers an expired Attach PIN wallet through the unified wallet selector', async () => {
+    const device = Device.fromDescriptor({
+      id: 'cache-device-attach-recovery',
+      path: 'cache-path-attach-recovery',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: 'stable-device-attach-recovery',
+          unlocked: true,
+          passphrase_enabled: true,
+          attach_to_pin_enabled: true,
+        },
+      }
+    );
+    device.passphraseState = 'attach-state';
+    preloadSessionCache('stable-device-attach-recovery', 'attach-state', 'expired-attach-session');
+    let sessionGetCalls = 0;
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionGet') {
+          sessionGetCalls += 1;
+          return {
+            type: 'DeviceSession',
+            message:
+              sessionGetCalls === 1
+                ? { session_id: 'current-standard-session', btc_test_address: 'standard-state' }
+                : { session_id: 'new-attach-session', btc_test_address: 'attach-state' },
+          };
+        }
+        throw new Error(`Unexpected request: ${request}`);
+      })
+    );
+    const promptPassphrase = jest.fn().mockResolvedValue({ attachPinOnDevice: true });
+    (device as any).commands = { typedCall, promptPassphrase };
+    const unlockDevice = jest
+      .spyOn(device, 'unlockDevice')
+      .mockResolvedValue(device.features as any);
+
+    await expect(
+      getProtocolV2WalletSession(device, { expectedPassphraseState: 'attach-state' })
+    ).resolves.toMatchObject({
+      passphraseState: 'attach-state',
+      newSession: 'new-attach-session',
+      resumed: false,
+    });
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: 'session-recovery',
+        expectedPassphraseState: 'attach-state',
+        existsAttachPinUser: true,
+      }),
+      { cancelDeviceOnReject: false }
+    );
+    expect(unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin);
+    expect(device.getInternalState()).toBe('new-attach-session');
+  });
+
+  test('propagates DeviceLocked without retrying DeviceSessionAskPassphrase', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-4',
       path: 'cache-path-4',
@@ -1222,7 +1629,7 @@ describe('Protocol V2 feature adapter', () => {
       jest
         .fn()
         .mockRejectedValueOnce(lockedError)
-        .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+        .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
         .mockResolvedValueOnce({
           message: {
             session_id: 'session-after-unlock',
@@ -1232,16 +1639,61 @@ describe('Protocol V2 feature adapter', () => {
     );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
     const unlockDevice = jest.spyOn(device, 'unlockDevice').mockResolvedValue(undefined as any);
 
+    await expect(getProtocolV2WalletSession(device)).rejects.toBe(lockedError);
+    expect(unlockDevice).not.toHaveBeenCalled();
+    expect(
+      typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionAskPassphrase')
+    ).toHaveLength(1);
+  });
+
+  test('does not act on cached lock state inside the wallet-session coordinator', async () => {
+    const calls: string[] = [];
+    const device = Device.fromDescriptor({
+      id: 'cache-device-pre-unlock',
+      path: 'cache-path-pre-unlock',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      { status: { device_id: 'stable-device-pre-unlock', unlocked: false } }
+    );
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionAskPassphrase') {
+          calls.push('ask-passphrase');
+          return Promise.resolve({ message: { message: 'Passphrase prepared' } });
+        }
+        if (request === 'DeviceSessionGet') {
+          calls.push('get-session');
+          return Promise.resolve({
+            message: {
+              session_id: 'session-after-pre-unlock',
+              btc_test_address: 'state-after-pre-unlock',
+            },
+          });
+        }
+        throw new Error(`Unexpected request: ${request}`);
+      })
+    );
+    (device as any).commands = {
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+    };
+    const unlockDevice = jest.spyOn(device, 'unlockDevice');
+
     await expect(getProtocolV2WalletSession(device)).resolves.toMatchObject({
-      newSession: 'session-after-unlock',
-      passphraseState: 'state-after-unlock',
+      newSession: 'session-after-pre-unlock',
+      passphraseState: 'state-after-pre-unlock',
     });
-    expect(unlockDevice).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledTimes(4);
+    expect(unlockDevice).not.toHaveBeenCalled();
+    expect(
+      typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionAskPassphrase')
+    ).toHaveLength(1);
+    expect(calls).toEqual(['ask-passphrase', 'get-session']);
   });
 
   test('does not request a Pro2 wallet session before features are initialized', async () => {
@@ -1384,8 +1836,10 @@ describe('Protocol V2 feature adapter', () => {
     };
     const typedCall = jest
       .fn()
+      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
+      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
       .mockResolvedValueOnce({
         type: 'DeviceSession',
         message: {
@@ -1395,7 +1849,7 @@ describe('Protocol V2 feature adapter', () => {
       });
     const updateInternalState = jest.fn();
     const getFeatures = jest.fn().mockResolvedValue(features);
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new GetPassphraseState({
       payload: {
         method: 'getPassphraseState',
@@ -1438,6 +1892,51 @@ describe('Protocol V2 feature adapter', () => {
     expect(getFeatures).not.toHaveBeenCalled();
   });
 
+  test('marks an interactive cache miss as a wallet-session recovery', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
+      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'expected-state',
+          session_id: 'recovered-session',
+        },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
+    const device = stubDevice({
+      originalDescriptor: { ...descriptor, protocolType: 'V2' },
+      passphraseState: 'expected-state',
+      features: {
+        unlocked: true,
+        passphraseProtection: true,
+        attachToPinEnabled: false,
+      },
+      commands: { typedCall, promptPassphrase },
+      getInternalState: jest.fn().mockReturnValue(undefined),
+      getCurrentDeviceId: () => 'pro2-device-id',
+      getCurrentPassphraseProtection: () => true,
+      updateInternalState: jest.fn(),
+      clearInternalState: jest.fn(),
+      emit: jest.fn(),
+    }) as any;
+
+    await expect(
+      getProtocolV2WalletSession(device, { expectedPassphraseState: 'expected-state' })
+    ).resolves.toMatchObject({ passphraseState: 'expected-state' });
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      {
+        existsAttachPinUser: false,
+        deviceOnly: false,
+        source: 'wallet-session-coordinator',
+        reason: 'session-recovery',
+        expectedPassphraseState: 'expected-state',
+      },
+      { cancelDeviceOnReject: false }
+    );
+  });
+
   test('reuses the Pro2 session opened by legacy getPassphraseState on the next App call', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     const typedCall = jest.fn().mockImplementation((request: string) => {
@@ -1445,7 +1944,16 @@ describe('Protocol V2 feature adapter', () => {
         return Promise.resolve({ message: { version: 2 } });
       }
       if (request === 'DeviceSessionAskPassphrase') {
-        return Promise.resolve({ message: { message: 'passphrase prepared' } });
+        return Promise.resolve({
+          type: 'Success',
+          message: { message: 'Passphrase prepared' },
+        });
+      }
+      if (request === 'DeviceStatusGet') {
+        return Promise.resolve({
+          type: 'DeviceStatus',
+          message: { unlocked: true, unlocked_attach_pin: false, passphrase_enabled: true },
+        });
       }
       if (request === 'DeviceSessionGet') {
         return Promise.resolve({
@@ -1471,7 +1979,7 @@ describe('Protocol V2 feature adapter', () => {
     );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
 
     const method = new GetPassphraseState({
@@ -1497,7 +2005,7 @@ describe('Protocol V2 feature adapter', () => {
     ]);
   });
 
-  test('uses the Pro2 standard wallet without passphraseState when passphrase is disabled', async () => {
+  test('returns the Pro2 standard-wallet passphraseState when passphrase is disabled', async () => {
     const features = {
       deviceId: 'pro2-device-id',
       deviceType: 'pro2',
@@ -1505,7 +2013,15 @@ describe('Protocol V2 feature adapter', () => {
       passphraseProtection: false,
       unlocked: true,
     };
-    const typedCall = createWalletSessionTypedCall();
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'main-wallet-state',
+          session_id: 'main-wallet-session',
+        },
+      })
+    );
     const updateInternalState = jest.fn();
     const method = new GetPassphraseState({
       payload: {
@@ -1514,24 +2030,26 @@ describe('Protocol V2 feature adapter', () => {
         useEmptyPassphrase: true,
       },
     });
-    method.device = stubDevice({
+    const device = stubDevice({
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features,
       commands: {
         typedCall,
-        promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
       },
       updateInternalState,
       getCurrentDeviceType: () => 'pro2',
       getCurrentDeviceId: () => 'pro2-device-id',
       getCurrentPassphraseProtection: () => false,
     }) as any;
+    device.unlockDevice = jest.fn().mockResolvedValue(features);
+    method.device = device;
 
-    await expect(method.run()).resolves.toBeUndefined();
+    await expect(method.run()).resolves.toBe('main-wallet-state');
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(updateInternalState).not.toHaveBeenCalled();
+    expect(updateInternalState).toHaveBeenCalled();
   });
 
   test('honors initSession when getting Pro2 passphrase state', async () => {
@@ -1545,8 +2063,10 @@ describe('Protocol V2 feature adapter', () => {
     };
     const typedCall = jest
       .fn()
+      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
+      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
       .mockResolvedValueOnce({
         type: 'DeviceSession',
         message: {
@@ -1569,7 +2089,7 @@ describe('Protocol V2 feature adapter', () => {
       passphraseState: 'state-pro2-old',
       commands: {
         typedCall,
-        promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
       },
       emit: jest.fn(),
       clearInternalState,
@@ -1612,7 +2132,7 @@ describe('Protocol V2 feature adapter', () => {
     };
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
 
     await getPassphraseStateWithRefreshDeviceInfo(device);
@@ -1652,7 +2172,7 @@ describe('Protocol V2 feature adapter', () => {
     );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
 
     await expect(getPassphraseStateWithRefreshDeviceInfo(device)).resolves.toMatchObject({
@@ -1666,6 +2186,10 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
     device.passphraseState = 'state-auto';
     expect(device.getInternalState()).toBe('session-auto');
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
+      passphrase: 'host hidden wallet',
+      on_device: false,
+    });
     expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
@@ -1678,7 +2202,8 @@ describe('Protocol V2 feature adapter', () => {
           session_id: 'main-pin-session',
           btc_test_address: 'main-wallet-state',
         },
-      })
+      }),
+      { passphrase_enabled: false }
     );
 
     (device as any).features = normalizeProtocolV2Features(
@@ -1700,8 +2225,8 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       getPassphraseStateWithRefreshDeviceInfo(device, { onlyMainPin: true })
     ).resolves.toMatchObject({
-      passphraseState: undefined,
-      newSession: undefined,
+      passphraseState: 'main-wallet-state',
+      newSession: 'main-pin-session',
     });
 
     expect(device.features?.passphraseProtection).toBe(false);
@@ -1733,7 +2258,7 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).features.unlocked = true;
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
 
     await expect(device.checkPassphraseStateSafety('expected-state', false, true)).rejects.toEqual(
@@ -1744,8 +2269,11 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(device.getInternalState()).toBeUndefined();
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
-      on_device: true,
+      passphrase: 'host hidden wallet',
+      on_device: false,
     });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceStatusGet', 'DeviceStatus', {});
+    expect(typedCall).toHaveBeenNthCalledWith(4, 'DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('useEmptyPassphrase ignores a stale hidden-wallet state during Protocol V2 safety check', async () => {
@@ -1778,7 +2306,7 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.checkPassphraseStateSafety('stale-hidden-state', true, false)
     ).resolves.toBe(true);
-    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledTimes(4);
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
@@ -1836,7 +2364,9 @@ describe('Protocol V2 feature adapter', () => {
   test('uses Protocol V2 features directly when profile is absent', () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = {
-      ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
+      ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
+        hw: { Device_type: DeviceType.PRO2 },
+      }),
       serialNo: 'CACHED-SERIAL',
       label: 'Cached Label',
       bleName: 'Cached BLE',
@@ -1845,6 +2375,7 @@ describe('Protocol V2 feature adapter', () => {
 
     const message = device.toMessageObject();
     expect(message).toMatchObject({
+      connectProtocol: 'V2',
       serialNo: 'CACHED-SERIAL',
       uuid: 'CACHED-SERIAL',
       deviceId: null,
@@ -1916,7 +2447,7 @@ describe('Protocol V2 feature adapter', () => {
       typedCall: jest.fn().mockResolvedValueOnce({
         type: 'DeviceInfo',
         message: {
-          hw: { serial_no: 'PR2SERIAL' },
+          hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
           fw: { application: { version: '1.2.3' } },
         },
       }),
@@ -2097,10 +2628,14 @@ describe('Protocol V2 feature adapter', () => {
       .mockResolvedValueOnce({
         type: 'DeviceInfo',
         message: {
-          hw: { serial_no: 'PR2SERIAL' },
+          hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
           fw: { application: { version: '1.2.3' } },
         },
       })
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2ApplicationInfo,
+      })
       .mockResolvedValueOnce({
         type: 'DeviceStatus',
         message: { init_states: true, unlocked: true },
@@ -2121,7 +2656,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.features?.passphraseProtection).toBeNull();
     expect(device.features?.label).toBeNull();
     expect(device.features?.firmwareVersion).toBe('1.2.3');
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(3);
     expect(typedCall).toHaveBeenNthCalledWith(
       1,
       'DeviceInfoGet',
@@ -2145,10 +2680,11 @@ describe('Protocol V2 feature adapter', () => {
         timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
       }
     );
-    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceStatusGet', 'DeviceStatus', {});
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'ProtocolInfoRequest', 'ProtocolInfo', {});
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceStatusGet', 'DeviceStatus', {});
   });
 
-  test('recognizes bootloader when DeviceStatusGet fails', async () => {
+  test('recognizes bootloader from ProtocolInfo without calling DeviceStatusGet', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
@@ -2163,7 +2699,10 @@ describe('Protocol V2 feature adapter', () => {
           se1: {},
         },
       })
-      .mockRejectedValueOnce(new Error('DeviceStatusGet unsupported in bootloader'));
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2BootloaderInfo,
+      });
 
     (device as any).commands = { typedCall };
 
@@ -2179,23 +2718,166 @@ describe('Protocol V2 feature adapter', () => {
       }),
       expect.anything()
     );
-    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceStatusGet', 'DeviceStatus', {});
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'ProtocolInfoRequest', 'ProtocolInfo', {});
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
     expect(device.features).toMatchObject({
       deviceId: null,
       bootloaderMode: true,
+      mode: 'bootloader',
       initialized: null,
     });
+    expect(device.isBootloader()).toBe(true);
+    expect(device.isRomloader()).toBe(false);
   });
 
-  test('does not reinterpret a state update error as DeviceStatusGet failure', async () => {
+  test('recognizes romloader from ProtocolInfo without calling DeviceStatusGet', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
     } as any);
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceStatus',
-      message: { init_states: true, unlocked: true },
+      type: 'ProtocolInfo',
+      message: protocolV2RomloaderInfo,
+    });
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState({
+      hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
+      fw: { romloader: { version: '1.0.0' } },
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.features).toMatchObject({
+      mode: 'romloader',
+      bootloaderMode: true,
+      initialized: null,
+    });
+    expect(device.isBootloader()).toBe(false);
+    expect(device.isRomloader()).toBe(true);
+  });
+
+  test('rejects Protocol V2 romloader mode for non-Pro2 devices', async () => {
+    const device = Device.fromDescriptor({
+      path: 'pro-v2-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'ProtocolInfo',
+      message: protocolV2RomloaderInfo,
     });
+    (device as any).commands = { typedCall };
+
+    await expect(
+      device.probeProtocolV2RuntimeState({
+        hw: { Device_type: DeviceType.PRO, serial_no: 'PRO-SERIAL' },
+        fw: { romloader: { version: '1.0.0' } },
+      })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceInitializeFailed });
+
+    expect(device.isRomloader()).not.toBe(true);
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test('keeps application mode without calling an unadvertised DeviceStatusGet', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const protocolInfo = {
+      ...protocolV2ApplicationInfo,
+      supported_messages: [],
+    };
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'ProtocolInfo',
+      message: protocolInfo,
+    });
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState({
+      hw: { serial_no: 'PR2SERIAL' },
+      fw: { application: { version: '1.2.3' } },
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.features).toMatchObject({
+      mode: 'normal',
+      bootloaderMode: false,
+      initialized: null,
+    });
+  });
+
+  test('uses advertised DeviceStatusGet as compatibility fallback for an unknown fingerprint', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const protocolInfo = {
+      ...protocolV2ApplicationInfo,
+      build_fingerprint: 'legacy-fingerprint',
+    };
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'ProtocolInfo', message: protocolInfo })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true, unlocked: true },
+      });
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState({
+      hw: { serial_no: 'PR2SERIAL' },
+      fw: { application: { version: '1.2.3' } },
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(device.features).toMatchObject({
+      mode: 'normal',
+      initialized: true,
+      unlocked: true,
+    });
+  });
+
+  test('fails safely when runtime fingerprint and capabilities are both unknown', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'ProtocolInfo',
+      message: {
+        version: 1,
+        build_fingerprint: 'legacy-fingerprint',
+        supported_messages: [],
+      },
+    });
+    (device as any).commands = { typedCall };
+
+    await expect(
+      device.probeProtocolV2RuntimeState({
+        hw: { serial_no: 'PR2SERIAL' },
+        fw: { application: { version: '1.2.3' } },
+      })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceInitializeFailed });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not reinterpret a state update error as runtime detection failure', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2ApplicationInfo,
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true, unlocked: true },
+      });
     const updateProtocolV2Features = jest
       .spyOn(device, 'updateProtocolV2Features')
       .mockImplementation(() => {
@@ -2210,12 +2892,13 @@ describe('Protocol V2 feature adapter', () => {
       })
     ).rejects.toThrow('state update failed');
 
-    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledTimes(2);
     expect(updateProtocolV2Features).toHaveBeenCalledTimes(1);
     expect(updateProtocolV2Features).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({ init_states: true }),
-      'normal'
+      'normal',
+      protocolV2ApplicationInfo
     );
   });
 
@@ -2229,10 +2912,14 @@ describe('Protocol V2 feature adapter', () => {
       .mockResolvedValueOnce({
         type: 'DeviceInfo',
         message: {
-          hw: { serial_no: 'PR2SERIAL' },
+          hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
           fw: { application: { version: '1.2.3' } },
         },
       })
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2ApplicationInfo,
+      })
       .mockResolvedValueOnce({
         type: 'DeviceStatus',
         message: { init_states: true, unlocked: true },
@@ -2240,10 +2927,14 @@ describe('Protocol V2 feature adapter', () => {
       .mockResolvedValueOnce({
         type: 'DeviceInfo',
         message: {
-          hw: { serial_no: 'PR2SERIAL' },
+          hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
           fw: { application: { version: '1.2.4' } },
         },
       })
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2ApplicationInfo,
+      })
       .mockResolvedValueOnce({
         type: 'DeviceStatus',
         message: { init_states: true, unlocked: true },
@@ -2265,9 +2956,9 @@ describe('Protocol V2 feature adapter', () => {
       firmwareVersion: '1.2.4',
       passphraseProtection: null,
     });
-    expect(typedCall).toHaveBeenCalledTimes(4);
+    expect(typedCall).toHaveBeenCalledTimes(6);
     expect(typedCall).toHaveBeenNthCalledWith(
-      3,
+      4,
       'DeviceInfoGet',
       'DeviceInfo',
       {
@@ -2292,14 +2983,23 @@ describe('Protocol V2 feature adapter', () => {
 
   test('keeps Protocol V2 features available for method internals such as evmSignTypedData', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
-    const typedCall = jest.fn().mockResolvedValueOnce({
-      type: 'DeviceInfo',
-      message: {
-        hw: { serial_no: 'PR2SERIAL' },
-        fw: { application: { version: '1.2.4' } },
-        status: { init_states: true, passphrase_enabled: true },
-      },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceInfo',
+        message: {
+          hw: { serial_no: 'PR2SERIAL' },
+          fw: { application: { version: '1.2.4' } },
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2ApplicationInfo,
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true, passphrase_enabled: true },
+      });
     (device as any).commands = { typedCall };
 
     await device.initialize();
@@ -2343,7 +3043,7 @@ describe('Protocol V2 feature adapter', () => {
       if (requestType === 'DeviceSessionAskPin') {
         return {
           type: 'Success',
-          message: { message: 'ok' },
+          message: { message: 'PIN verified' },
         };
       }
       if (requestType === 'DeviceStatusGet') {
@@ -2365,7 +3065,7 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
       {
-        hw: { serial_no: 'PR2SERIAL' },
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
         fw: { application: { version: '1.2.3' } },
         status: { init_states: true },
       }
@@ -2400,7 +3100,7 @@ describe('Protocol V2 feature adapter', () => {
       if (requestType === 'DeviceSessionAskPin') {
         return {
           type: 'Success',
-          message: { message: 'ok' },
+          message: { message: 'PIN verified' },
         };
       }
       if (requestType === 'DeviceStatusGet') {
@@ -2899,6 +3599,12 @@ describe('Protocol V2 firmware update targets', () => {
           message: { init_states: true, unlocked: true },
         });
       }
+      if (name === 'ProtocolInfoRequest') {
+        return Promise.resolve({
+          type: 'ProtocolInfo',
+          message: protocolV2ApplicationInfo,
+        });
+      }
       return Promise.reject(new Error(`unexpected call ${name}`));
     });
     const commands = { typedCall };
@@ -2943,7 +3649,12 @@ describe('Protocol V2 firmware update targets', () => {
       },
       { timeoutMs: 5000 }
     );
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(3);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceInfoGet',
+      'ProtocolInfoRequest',
+      'DeviceStatusGet',
+    ]);
     expect(typedCall).not.toHaveBeenCalledWith('Initialize', 'Features', {});
     expect(versions).toEqual({
       bootloaderVersion: '0.0.0',
@@ -3023,7 +3734,13 @@ describe('Protocol V2 firmware update targets', () => {
           message: protocolV2BootloaderDeviceInfo,
         });
       }
-      return Promise.reject(new Error('DeviceStatusGet unavailable in bootloader'));
+      if (requestType === 'ProtocolInfoRequest') {
+        return Promise.resolve({
+          type: 'ProtocolInfo',
+          message: protocolV2BootloaderInfo,
+        });
+      }
+      return Promise.reject(new Error(`unexpected call ${requestType}`));
     });
     const reconnectProtocolV2Device = jest.fn().mockImplementation(() => {
       (method as any).device.isBootloader = () => true;
@@ -3050,10 +3767,17 @@ describe('Protocol V2 firmware update targets', () => {
         method: 'firmwareUpdateV4',
       },
     });
+    const isRomloader = jest.fn(() => true);
     (method as any).device = stubDevice({
       originalDescriptor: { id: 'usb-id', path: 'romloader-path', protocolType: 'V2' },
-      features: { mode: 'romloader', bootloaderMode: false, capabilities: [] },
+      features: {
+        deviceType: 'pro2',
+        mode: 'romloader',
+        bootloaderMode: false,
+        capabilities: [],
+      },
       isBootloader: () => false,
+      isRomloader,
     });
     (method as any).protocolV2Reboot = jest
       .fn()
@@ -3062,7 +3786,49 @@ describe('Protocol V2 firmware update targets', () => {
 
     await expect((method as any).enterProtocolV2BootloaderMode()).resolves.toBe(false);
 
+    expect(isRomloader).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
+    expect(method.postTipMessage).not.toHaveBeenCalledWith('AutoRebootToBootloader');
+  });
+
+  test('starts Protocol V2 firmware transfer directly from romloader mode', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        coprocessorBinary: new Uint8Array([1]).buffer,
+      },
+    });
+    method.init();
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'romloader-path', protocolType: 'V2' },
+      features: {
+        deviceType: 'pro2',
+        firmwareVersion: '0.0.0',
+        mode: 'romloader',
+        bootloaderMode: true,
+        capabilities: [],
+      },
+    });
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+    (method as any).protocolV2Reboot = jest.fn();
+    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
+      bootloaderVersion: '1.0.0',
+      bleVersion: '0.0.0',
+      firmwareVersion: '1.0.0',
+    });
+    method.postTipMessage = jest.fn();
+
+    await method.run();
+
     expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
+    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
+      bootloaderBinary: null,
+      fwBinaryMap: [{ fileName: 'coprocessor.bin', binary: expect.anything(), targetId: 6 }],
+    });
     expect(method.postTipMessage).not.toHaveBeenCalledWith('AutoRebootToBootloader');
   });
 
@@ -3085,7 +3851,13 @@ describe('Protocol V2 firmware update targets', () => {
           message: protocolV2BootloaderDeviceInfo,
         });
       }
-      return Promise.reject(new Error('DeviceStatusGet unavailable in bootloader'));
+      if (requestType === 'ProtocolInfoRequest') {
+        return Promise.resolve({
+          type: 'ProtocolInfo',
+          message: protocolV2BootloaderInfo,
+        });
+      }
+      return Promise.reject(new Error(`unexpected call ${requestType}`));
     });
     const reconnectProtocolV2Device = jest
       .fn()
@@ -3102,8 +3874,11 @@ describe('Protocol V2 firmware update targets', () => {
     await (method as any).waitForProtocolV2BootloaderMode(60 * 1000, 0);
 
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(3);
-    expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceInfoGet']);
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceInfoGet',
+      'ProtocolInfoRequest',
+    ]);
   });
 
   test('does not run generic initialize during Protocol V2 USB firmware reconnect', async () => {
@@ -3396,7 +4171,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('accepts a missing firmware status handler as an app reboot signal', async () => {
+  test('accepts a missing firmware status handler only after confirming normal mode', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -3412,7 +4187,9 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => ({ typedCall }),
     });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
-    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
+    (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
     method.postProgressMessage = jest.fn();
 
     await (method as any).waitForProtocolV2FirmwareUpdateComplete([
@@ -3421,6 +4198,70 @@ describe('Protocol V2 firmware update targets', () => {
 
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
     expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceFirmwareUpdateStatusGet']);
+    expect((method as any).probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
+  });
+
+  test.each([
+    [{ mode: 'normal', bootloaderMode: false }, true],
+    [{ mode: 'bootloader', bootloaderMode: true }, false],
+  ])('derives firmware completion from the runtime-state probe: %o', async (features, expected) => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    const probeProtocolV2RuntimeState = jest.fn().mockResolvedValue(features);
+    (method as any).device = stubDevice({ probeProtocolV2RuntimeState });
+
+    await expect((method as any).probeProtocolV2NormalMode(deviceInfo)).resolves.toBe(expected);
+    expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000);
+  });
+
+  test('keeps polling when the firmware status handler is missing in loader mode', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValueOnce(new Error('Failure: Handler not registered for this message'))
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 2 }] },
+      });
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
+    (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(false);
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await (method as any).waitForProtocolV2FirmwareUpdateComplete([
+        { target_id: 4, path: 'vol0:/application_p1.bin' },
+      ]);
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceFirmwareUpdateStatusGet',
+      'DeviceFirmwareUpdateStatusGet',
+    ]);
+    expect((method as any).probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
   });
 
   test('polls target status after update ACK and finishes when all targets complete', async () => {
@@ -3926,6 +4767,62 @@ describe('Protocol V2 firmware update targets', () => {
     getFirmwareLatestReleaseSpy.mockRestore();
   });
 
+  test('ignores an unsupported remote ROMLOADER component when installing selected targets', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        targetsToUpdate: ['app_v1'],
+      },
+    });
+    method.init();
+    const applicationBinary = new Uint8Array([1]).buffer;
+    const downloadRemoteComponent = jest.fn().mockResolvedValue({
+      fileName: 'application_p1.bin',
+      binary: applicationBinary,
+      targetId: 4,
+      kind: 'firmware',
+    });
+    (method as any).downloadRemoteProtocolV2Component = downloadRemoteComponent;
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        installOrder: ['romloader', 'applicationP1'],
+        components: {
+          romloader: {
+            target: 'ROMLOADER',
+            url: 'https://example.com/romloader.bin',
+          },
+          applicationP1: {
+            target: 'APPLICATION_P1',
+            url: 'https://example.com/application-p1.bin',
+          },
+        },
+        fingerprint: '',
+        changelog: { 'zh-CN': '', 'en-US': '' },
+      });
+
+    const remoteBinaries = await (method as any).prepareRemoteProtocolV2Binaries('universal', {
+      deviceType: 'pro2',
+      firmwareVersion: '0.0.0',
+    });
+
+    expect(downloadRemoteComponent).toHaveBeenCalledTimes(1);
+    expect(downloadRemoteComponent).toHaveBeenCalledWith(
+      'applicationP1',
+      expect.objectContaining({ target: 'APPLICATION_P1' })
+    );
+    expect(remoteBinaries.fwBinaryMap).toEqual([
+      { fileName: 'application_p1.bin', binary: applicationBinary, targetId: 4 },
+    ]);
+
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
   test('maps remote Pro2 resource bundles to direct-write descriptors', () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4496,8 +5393,14 @@ describe('Protocol V2 firmware update targets', () => {
       return 0 as any;
     }) as typeof setTimeout);
 
+    const initialize = jest.fn().mockResolvedValue(undefined);
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
+      initialize,
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue({
+      hw: { serial_no: 'PRO2-PHYSICAL-1' },
     });
     method.postProgressMessage = jest.fn();
 
@@ -4513,6 +5416,9 @@ describe('Protocol V2 firmware update targets', () => {
     }
 
     expect(writeOffsets).toEqual([0, 4000, 0, 4000, 8000]);
+    expect((method as any).reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+    expect((method as any).verifyProtocolV2ReconnectIdentity).toHaveBeenCalledTimes(1);
+    expect(initialize).toHaveBeenCalledTimes(1);
   });
 
   test('rejects a chunk-relative processed_byte during firmware staging', async () => {
@@ -5213,6 +6119,45 @@ describe('Protocol V2 protected method execution', () => {
     ]);
   });
 
+  test('does not replay a business method when the hidden-wallet session cannot be restored after unlock', async () => {
+    const initialError = deviceLockedError();
+    const restoreError = new Error('Invalid wallet session');
+    const method = {
+      name: 'evmSignMessage',
+      payload: { passphraseState: 'hidden-state' },
+      useDevicePassphraseState: true,
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn().mockRejectedValueOnce(initialError),
+    };
+    const typedCall = jest.fn((requestType: string) => {
+      if (requestType === 'ProtocolInfoRequest') {
+        return Promise.resolve({ message: { version: 2 } });
+      }
+      if (requestType === 'DeviceSessionGet') {
+        return Promise.reject(restoreError);
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const device = {
+      features: { unlocked: true, passphraseProtection: true },
+      passphraseState: 'hidden-state',
+      commands: { typedCall },
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn().mockResolvedValue(undefined),
+      getCurrentPassphraseProtection: () => true,
+      getInternalState: () => 'hidden-session',
+      clearInternalState: jest.fn(),
+      getCurrentDeviceId: () => 'wallet-device-id',
+      updateInternalState: jest.fn(),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).rejects.toBe(restoreError);
+    expect(method.run).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.clearInternalState).toHaveBeenCalledTimes(1);
+    expect(device.updateInternalState).not.toHaveBeenCalled();
+  });
+
   test('restores the expected hidden-wallet session after pre-unlock without selecting Attach PIN', async () => {
     const calls: string[] = [];
     const method = {
@@ -5300,7 +6245,7 @@ describe('Protocol V2 protected method execution', () => {
     expect(method.run).toHaveBeenCalledTimes(1);
   });
 
-  test('unlocks before showing the method interaction when cached status is locked', async () => {
+  test('refreshes status and unlocks before a protected Protocol V2 method', async () => {
     const calls: string[] = [];
     const method = {
       name: 'deviceSettingsPageShow',
@@ -5311,11 +6256,23 @@ describe('Protocol V2 protected method execution', () => {
         return Promise.resolve({ message: 'ok' });
       }),
     };
+    const features = { unlocked: true };
     const device = {
-      features: { unlocked: false },
+      features,
+      commands: {
+        typedCall: jest.fn(() => {
+          calls.push('refresh-status');
+          return Promise.resolve({ message: { unlocked: false } });
+        }),
+      },
       isProtocolV2: () => true,
+      updateProtocolV2Status: jest.fn((status: { unlocked?: boolean }) => {
+        features.unlocked = status.unlocked ?? features.unlocked;
+        return features;
+      }),
       unlockDevice: jest.fn(() => {
         calls.push('unlock');
+        features.unlocked = true;
         return Promise.resolve();
       }),
     };
@@ -5328,12 +6285,66 @@ describe('Protocol V2 protected method execution', () => {
     await expect(
       runMethodWithUnlockRetry(method as any, device as any, uiCoordinator as any)
     ).resolves.toEqual({ message: 'ok' });
-    expect(calls).toEqual(['unlock-prompt', 'unlock', 'method-prompt', 'run']);
+    expect(calls).toEqual(['refresh-status', 'unlock-prompt', 'unlock', 'method-prompt', 'run']);
+    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
     expect(method.run).toHaveBeenCalledTimes(1);
     expect(uiCoordinator.enterMethodInteraction).toHaveBeenCalledTimes(1);
     expect(uiCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
   });
 
+  test('uses refreshed unlocked status instead of a stale locked cache', async () => {
+    const features = { unlocked: false };
+    const method = {
+      name: 'deviceSettings',
+      unlockPolicy: 'unlock-before-run',
+      run: jest.fn().mockResolvedValue({ message: 'ok' }),
+    };
+    const device = {
+      features,
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: true } }),
+      },
+      isProtocolV2: () => true,
+      updateProtocolV2Status: jest.fn((status: { unlocked?: boolean }) => {
+        features.unlocked = status.unlocked ?? features.unlocked;
+        return features;
+      }),
+      unlockDevice: jest.fn(),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+      message: 'ok',
+    });
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+    expect(method.run).toHaveBeenCalledTimes(1);
+  });
+
+  test.each(['bootloader', 'romloader'] as const)(
+    'skips DeviceStatus and unlock in Protocol V2 %s mode',
+    async mode => {
+      const method = {
+        name: 'firmwareUpdateV4',
+        unlockPolicy: 'unlock-before-run',
+        run: jest.fn().mockResolvedValue({ message: 'updating' }),
+      };
+      const device = {
+        features: { unlocked: false },
+        commands: { typedCall: jest.fn() },
+        isProtocolV2: () => true,
+        isBootloader: () => mode === 'bootloader',
+        isRomloader: () => mode === 'romloader',
+        unlockDevice: jest.fn(),
+      };
+
+      await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+        message: 'updating',
+      });
+      expect(device.commands.typedCall).not.toHaveBeenCalled();
+      expect(device.unlockDevice).not.toHaveBeenCalled();
+      expect(method.run).toHaveBeenCalledTimes(1);
+    }
+  );
+
   test('infers a signing interaction before running a Protocol V2 business method', async () => {
     const method = {
       name: 'evmSignMessage',