@onekeyfe/hd-core 1.2.0-alpha.16 → 1.2.0-alpha.18

package/__tests__/protocol-v2.test.ts

@@ -1,5 +1,5 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceRebootType } from '@onekeyfe/hd-transport';
+import { DeviceRebootType, DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import * as firmwareBinaryApi from '../src/api/firmware/getBinary';
 import DnxGetAddress from '../src/api/dynex/DnxGetAddress';
@@ -15,11 +15,16 @@ import DeviceGetFirmwareUpdateStatus from '../src/api/protocol-v2/DeviceGetFirmw
 import DeviceGetOnboardingStatus from '../src/api/protocol-v2/DeviceGetOnboardingStatus';
 import DeviceInfoGet from '../src/api/protocol-v2/DeviceInfoGet';
 import DeviceReboot from '../src/api/protocol-v2/DeviceReboot';
+import DeviceCancel from '../src/api/device/DeviceCancel';
+import DeviceChangePin from '../src/api/device/DeviceChangePin';
+import DeviceLock from '../src/api/device/DeviceLock';
+import DeviceUnlock from '../src/api/device/DeviceUnlock';
+import DeviceWipe from '../src/api/device/DeviceWipe';
 import DeviceSettingsGet from '../src/api/protocol-v2/DeviceSettingsGet';
 import DeviceSettingsPageShow from '../src/api/protocol-v2/DeviceSettingsPageShow';
 import DeviceSettingsSet from '../src/api/protocol-v2/DeviceSettingsSet';
 import DeviceUploadWallpaper from '../src/api/protocol-v2/DeviceUploadWallpaper';
-import DeviceSessionGet from '../src/api/protocol-v2/DeviceSessionGet';
+import DeviceSessionOpen from '../src/api/protocol-v2/DeviceSessionOpen';
 import DeviceStatusGet from '../src/api/protocol-v2/DeviceStatusGet';
 import FilesystemFormat from '../src/api/protocol-v2/FilesystemFormat';
 import FilesystemPermissionFix from '../src/api/protocol-v2/FilesystemPermissionFix';
@@ -53,16 +58,20 @@ import { getBitcoinForkVersionRange } from '../src/api/btc/helpers/versionLimit'
 import { DataManager } from '../src/data-manager';
 import { createCoreApi } from '../src/inject';
 import { Device, preloadSessionCache } from '../src/device/Device';
+import { DevicePool } from '../src/device/DevicePool';
+import { DEVICE } from '../src/events/device';
 import { UI_REQUEST } from '../src/events/ui-request';
 import {
   PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
   requestProtocolV2DeviceInfo,
+  requestProtocolV2DeviceStatus,
 } from '../src/protocols/protocol-v2/features';
 import {
   getProtocolV2WalletSession,
   refreshProtocolV2DeviceStatus,
 } from '../src/protocols/protocol-v2/walletSession';
 import { runMethodWithUnlockRetry } from '../src/protocols/protocol-v2/unlockRetry';
+import { BaseMethod } from '../src/api/BaseMethod';
 import {
   buildProfileFromProtocolV2,
   buildProtocolV1FeaturesPayload,
@@ -84,6 +93,7 @@ import {
 
 import type { DeviceCommands } from '../src/device/DeviceCommands';
 import type { Features } from '../src/types';
+import type { DeviceStatus } from '@onekeyfe/hd-transport';
 import type { ProtocolV2DeviceInfo } from '../src/protocols/protocol-v2/features';
 
 jest.mock('../src/data/config', () => ({
@@ -118,11 +128,11 @@ describe('DeviceUploadWallpaper', () => {
     expect(method.requireProtocolV2).toBe(true);
     expect(method.unlockPolicy).toBe('retry-on-locked');
     expect(typedCall).toHaveBeenNthCalledWith(1, 'FilesystemDirMake', 'Success', {
-      path: 'vol0:/wallpapers/user',
+      path: 'vol1:/wallpapers',
     });
     const fileWriteCall = typedCall.mock.calls.find(call => call[0] === 'FilesystemFileWrite');
     expect(fileWriteCall?.[2]).toMatchObject({
-      file: { path: expect.stringMatching(/^vol0:\/wallpapers\/user\/wallpaper-[a-f0-9]+\.bin$/) },
+      file: { path: expect.stringMatching(/^vol1:\/wallpapers\/wallpaper-[a-f0-9]+\.bin$/) },
       overwrite: true,
       append: false,
     });
@@ -206,6 +216,9 @@ describe('UploadPortfolio', () => {
     const result = await method.run();
 
     expect(method.unlockPolicy).toBe('retry-on-locked');
+    expect(method.protocolV2UiMode).toBe('none');
+    expect(method.protocolV2UiInteraction).toBeUndefined();
+    expect(method.payload.emitProgress).toBe(false);
     expect(typedCall).toHaveBeenNthCalledWith(
       1,
       'FilesystemFileWrite',
@@ -305,8 +318,23 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
     if (range) return range;
     return getMethodVersionRange(d.features, fn);
   };
-  d.updateProtocolV2Features ??= (deviceInfo?: ProtocolV2DeviceInfo) => {
-    d.features = buildProtocolV2FeaturesPayload(deviceInfo, d.features);
+  d.updateProtocolV2Features ??= (
+    deviceInfo?: ProtocolV2DeviceInfo,
+    deviceStatus?: DeviceStatus
+  ) => {
+    d.features = buildProtocolV2FeaturesPayload({
+      deviceInfo,
+      deviceStatus: deviceStatus ?? deviceInfo?.status,
+      previous: d.features,
+    });
+    return d.features;
+  };
+  d.updateProtocolV2Status ??= (deviceStatus: DeviceStatus) => {
+    d.features = buildProtocolV2FeaturesPayload({
+      deviceInfo: d.features?.raw?.protocolV2DeviceInfo,
+      deviceStatus,
+      previous: d.features,
+    });
     return d.features;
   };
   return device;
@@ -314,7 +342,10 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
 
 // 直接复用生产映射函数，避免测试内副本与实现漂移（之前的手抄副本已缺失 se boot 字段）
 function normalizeProtocolV2Features(_descriptor: unknown, deviceInfo?: ProtocolV2DeviceInfo) {
-  return buildProtocolV2FeaturesPayload(deviceInfo);
+  return buildProtocolV2FeaturesPayload({
+    deviceInfo,
+    deviceStatus: deviceInfo?.status,
+  });
 }
 
 const protocolV2BootloaderDeviceInfo: ProtocolV2DeviceInfo = {
@@ -337,10 +368,64 @@ async function requestProtocolV2Features({
   descriptor?: unknown;
 }) {
   const deviceInfo = await requestProtocolV2DeviceInfo({ commands });
-  return normalizeProtocolV2Features(inputDescriptor ?? descriptor, deviceInfo);
+  const deviceStatus = await requestProtocolV2DeviceStatus({ commands });
+  return buildProtocolV2FeaturesPayload({ deviceInfo, deviceStatus });
 }
 
 describe('Protocol V2 feature adapter', () => {
+  test('treats passphrase status as unknown until the Protocol V2 device is unlocked', () => {
+    const features = buildProtocolV2FeaturesPayload({
+      deviceInfo: {
+        hw: { serial_no: 'P2-LOCKED' },
+      },
+      deviceStatus: {
+        unlocked: false,
+        passphrase_enabled: true,
+      },
+    });
+
+    expect(features.unlocked).toBe(false);
+    expect(features.passphraseProtection).toBeNull();
+    expect(features.passphrase_protection).toBeUndefined();
+  });
+
+  test('builds dynamic features from DeviceStatus when DeviceInfo has no nested status', () => {
+    const deviceInfo: ProtocolV2DeviceInfo = {
+      protocol_version: 1,
+      hw: { serial_no: 'P2-STATIC' },
+      fw: { application: { version: '1.0.0' } },
+      coprocessor: { bt_adv_name: 'Pro2 STATIC' },
+    };
+    const deviceStatus: DeviceStatus = {
+      device_id: 'P2-DYNAMIC',
+      unlocked: true,
+      init_states: true,
+      backup_required: false,
+      passphrase_enabled: true,
+      attach_to_pin_enabled: true,
+      unlocked_by_attach_to_pin: true,
+    };
+
+    const features = buildProtocolV2FeaturesPayload({
+      deviceInfo,
+      deviceStatus,
+    });
+
+    expect(features).toMatchObject({
+      deviceId: 'P2-DYNAMIC',
+      serialNo: 'P2-STATIC',
+      bleName: 'Pro2 STATIC',
+      initialized: true,
+      unlocked: true,
+      passphraseProtection: true,
+      attachToPinEnabled: true,
+      unlockedAttachPin: true,
+    });
+    expect(features.raw?.protocolV2DeviceInfo).toEqual(deviceInfo);
+    expect(features.raw?.protocolV2DeviceStatus).toEqual(deviceStatus);
+    expect(features.raw?.protocolV2DeviceInfo?.status).toBeUndefined();
+  });
+
   test('keeps legacy snake_case feature fields for existing SDK consumers', () => {
     const protocolV1 = buildProtocolV1FeaturesPayload({
       device_id: 'v1-device',
@@ -350,14 +435,16 @@ describe('Protocol V2 feature adapter', () => {
       unlocked: true,
     } as any);
     const protocolV2 = buildProtocolV2FeaturesPayload({
-      hw: { serial_no: 'P2-001' },
-      coprocessor: { bt_adv_name: 'Pro 2 BLE' },
-      status: {
+      deviceInfo: {
+        hw: { serial_no: 'P2-001' },
+        coprocessor: { bt_adv_name: 'Pro 2 BLE' },
+      },
+      deviceStatus: {
         device_id: 'v2-device',
         unlocked: true,
         passphrase_enabled: true,
       },
-    } as any);
+    });
 
     expect(protocolV1).toMatchObject({
       device_id: 'v1-device',
@@ -511,7 +598,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(profile.versions.board).toBe('1.0.0');
   });
 
-  test('uses DeviceSessionGet for Protocol V2 passphrase sessions', async () => {
+  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;
@@ -527,34 +614,164 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).features = features;
     (device as any).commands = commands;
 
-    await getPassphraseState(device, {
-      expectPassphraseState: 'state-1',
-    });
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
-
     await expect(
       getPassphraseState(device, {
-        expectPassphraseState: 'state-2',
-      })
-    ).rejects.toEqual(
-      expect.objectContaining({
-        errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
+        onlyMainPin: true,
       })
+    ).resolves.toEqual({
+      passphraseState: undefined,
+      newSession: undefined,
+      unlockedAttachPin: false,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+    expect(device.getInternalState()).toBeUndefined();
+  });
+
+  test('uses the default main wallet context when Protocol V2 passphrase protection is disabled', async () => {
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      { status: { passphrase_enabled: false, unlocked: true } }
+    );
+    const typedCall = jest.fn();
+    (device as any).commands = { typedCall };
+
+    await expect(getProtocolV2WalletSession(device)).resolves.toEqual({
+      passphraseState: undefined,
+      newSession: undefined,
+      unlockedAttachPin: false,
+    });
+
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  test('unlocks before deciding that Protocol V2 uses the default main wallet context', async () => {
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          unlocked: false,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    const typedCall = jest.fn();
+    const promptPassphrase = jest.fn();
+    const unlockDevice = jest.spyOn(device, 'unlockDevice').mockImplementation(() => {
+      (device as any).features = {
+        ...(device as any).features,
+        unlocked: true,
+        passphraseProtection: false,
+      };
+      return (device as any).features;
+    });
+    (device as any).commands = { typedCall, promptPassphrase };
+
+    await expect(getProtocolV2WalletSession(device)).resolves.toEqual({
+      passphraseState: undefined,
+      newSession: undefined,
+      unlockedAttachPin: false,
+    });
+
+    expect(unlockDevice).toHaveBeenCalledTimes(1);
+    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  test('onlyMainPin takes precedence over a cached hidden-wallet state', async () => {
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      { status: { device_id: 'main-wallet-device', passphrase_enabled: true, unlocked: true } }
     );
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    device.passphraseState = 'hidden-state';
+    preloadSessionCache('main-wallet-device', 'hidden-state', 'hidden-session');
+    const typedCall = jest.fn();
+    (device as any).commands = { typedCall };
 
     await getPassphraseState(device, {
       onlyMainPin: true,
     });
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).not.toHaveBeenCalled();
+    expect(device.getInternalState()).toBe('hidden-session');
+  });
+
+  test.each([
+    {
+      name: 'Host Passphrase',
+      response: { passphrase: 'hidden\u00e9 secret' },
+      select: { host_passphrase: { passphrase: 'hidden\u0065\u0301 secret' } },
+      event: undefined,
+    },
+    {
+      name: '设备 Passphrase',
+      response: { passphraseOnDevice: true },
+      select: { passphrase_on_device: {} },
+      event: DEVICE.PASSPHRASE_ON_DEVICE,
+    },
+    {
+      name: 'Attach PIN',
+      response: { attachPinOnDevice: true },
+      select: { attach_pin_on_device: {} },
+      event: DEVICE.ATTACH_PIN_ON_DEVICE,
+    },
+  ])('maps $name selection to DeviceSessionOpen', async ({ response, select, event }) => {
+    const device = Device.fromDescriptor({
+      id: 'select-device',
+      path: 'select-path',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: 'select-device-id',
+          unlocked: true,
+          passphrase_enabled: true,
+          attach_to_pin_enabled: true,
+        },
+      }
+    );
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceSession',
+      message: { session_id: 'hidden-session', btc_test_address: 'hidden-state' },
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue(response);
+    (device as any).commands = { typedCall, promptPassphrase };
+    const emit = jest.spyOn(device, 'emit');
+
+    await expect(getProtocolV2WalletSession(device)).resolves.toMatchObject({
+      newSession: 'hidden-session',
+      passphraseState: 'hidden-state',
+    });
+
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      expect.objectContaining({
+        source: 'wallet-session-coordinator',
+        reason: 'open-wallet',
+        existsAttachPinUser: true,
+      }),
+      { cancelDeviceOnReject: false }
+    );
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      select,
+    });
+    if (event) {
+      expect(emit).toHaveBeenCalledWith(
+        event,
+        device,
+        expect.objectContaining({ source: 'wallet-session-coordinator' })
+      );
+    }
   });
 
-  test('deviceStatusGet returns raw DeviceStatus without updating features', async () => {
+  test('deviceStatusGet returns raw DeviceStatus and updates dynamic features', async () => {
     const typedCall = jest.fn().mockResolvedValue({
       type: 'DeviceStatus',
       message: { device_id: 'device-1', unlocked: true },
     });
-    const updateProtocolV2Features = jest.fn();
+    const updateProtocolV2Status = jest.fn();
     const method = new DeviceStatusGet({
       payload: { method: 'deviceStatusGet', connectId: 'connect-id' },
     });
@@ -562,18 +779,27 @@ describe('Protocol V2 feature adapter', () => {
     method.device = stubDevice({
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       commands: { typedCall },
-      updateProtocolV2Features,
+      updateProtocolV2Status,
     }) as any;
 
     await expect(method.run()).resolves.toEqual({ device_id: 'device-1', unlocked: true });
     expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
-    expect(updateProtocolV2Features).not.toHaveBeenCalled();
+    expect(updateProtocolV2Status).toHaveBeenCalledWith({
+      device_id: 'device-1',
+      unlocked: true,
+    });
   });
 
-  test('deviceGetOnboardingStatus returns the real Protocol V2 onboarding stage', async () => {
+  test('deviceGetOnboardingStatus returns the current Protocol V2 onboarding status', async () => {
     const typedCall = jest.fn().mockResolvedValue({
       type: 'DevOnboardingStatus',
-      message: { stage: 2, status_code: 3, detail_code: 4 },
+      message: {
+        step: 4,
+        phase: 4,
+        setup: { kind: 1, method: 0 },
+        pin_set: true,
+        wallet_initialized: false,
+      },
     });
     const method = new DeviceGetOnboardingStatus({
       payload: {
@@ -588,24 +814,27 @@ describe('Protocol V2 feature adapter', () => {
     }) as any;
 
     await expect(method.run()).resolves.toEqual({
-      stage: 2,
-      status_code: 3,
-      detail_code: 4,
+      step: 4,
+      phase: 4,
+      setup: { kind: 1, method: 0 },
+      pin_set: true,
+      wallet_initialized: false,
     });
     expect(typedCall).toHaveBeenCalledWith('DevGetOnboardingStatus', 'DevOnboardingStatus', {});
     expect(method.requireProtocolV2).toBe(true);
   });
 
-  test('deviceSessionGet sends an empty request and does not mutate wallet cache', async () => {
+  test('deviceSessionOpen sends the explicit wallet selection and does not mutate wallet cache', async () => {
     const typedCall = jest.fn().mockResolvedValue({
       type: 'DeviceSession',
       message: { session_id: 'new-session', btc_test_address: 'state-a' },
     });
     const updateInternalState = jest.fn();
-    const method = new DeviceSessionGet({
+    const method = new DeviceSessionOpen({
       payload: {
-        method: 'deviceSessionGet',
+        method: 'deviceSessionOpen',
         connectId: 'connect-id',
+        select: { host_passphrase: { passphrase: 'hidden secret' } },
       },
     });
     method.init();
@@ -619,17 +848,42 @@ describe('Protocol V2 feature adapter', () => {
       session_id: 'new-session',
       btc_test_address: 'state-a',
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      select: { host_passphrase: { passphrase: 'hidden secret' } },
+    });
     expect(updateInternalState).not.toHaveBeenCalled();
   });
 
+  test.each([
+    { payload: {}, reason: 'missing mode' },
+    { payload: { resume: { session_id: '' } }, reason: 'empty resume session' },
+    { payload: { select: { wallet_type: 0 } }, reason: 'removed standard wallet selection' },
+    {
+      payload: { select: { host_passphrase: { passphrase: 'secret' }, passphrase_on_device: {} } },
+      reason: 'multiple hidden wallet access modes',
+    },
+  ])('rejects invalid deviceSessionOpen payload: $reason', ({ payload }) => {
+    const method = new DeviceSessionOpen({
+      payload: {
+        method: 'deviceSessionOpen',
+        connectId: 'connect-id',
+        ...payload,
+      } as any,
+    });
+
+    expect(() => method.init()).toThrow();
+  });
+
   test('routes raw status and session methods through CoreApi', async () => {
     const call = jest.fn().mockResolvedValue({ success: true, payload: {} });
     const api = createCoreApi(call as any);
 
     await api.deviceStatusGet('connect-id', { retryCount: 1 });
     await api.deviceGetOnboardingStatus('connect-id', { retryCount: 1 });
-    await api.deviceSessionGet('connect-id', { retryCount: 1 });
+    await api.deviceSessionOpen('connect-id', {
+      retryCount: 1,
+      select: { passphrase_on_device: {} },
+    });
 
     expect(call).toHaveBeenNthCalledWith(1, {
       method: 'deviceStatusGet',
@@ -642,9 +896,10 @@ describe('Protocol V2 feature adapter', () => {
       retryCount: 1,
     });
     expect(call).toHaveBeenNthCalledWith(3, {
-      method: 'deviceSessionGet',
+      method: 'deviceSessionOpen',
       connectId: 'connect-id',
       retryCount: 1,
+      select: { passphrase_on_device: {} },
     });
   });
 
@@ -677,8 +932,8 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'session-b',
     });
 
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'session-a',
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      resume: { session_id: 'session-a' },
     });
     expect(device.getInternalState()).toBe('session-b');
   });
@@ -700,9 +955,9 @@ describe('Protocol V2 feature adapter', () => {
     });
     (device as any).commands = { typedCall };
 
-    await getProtocolV2WalletSession(device);
+    await getProtocolV2WalletSession(device, { onlyMainPin: true });
 
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).not.toHaveBeenCalled();
     expect(device.getInternalState()).toBeUndefined();
   });
 
@@ -731,15 +986,24 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceSession',
         message: { session_id: 'session-b', btc_test_address: 'state-a' },
       });
-    (device as any).commands = { typedCall };
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'state-a-secret' });
+    (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(getProtocolV2WalletSession(device)).resolves.toMatchObject({
       passphraseState: 'state-a',
       newSession: 'session-b',
     });
     expect(typedCall.mock.calls).toEqual([
-      ['DeviceSessionGet', 'DeviceSession', { session_id: 'session-a' }],
-      ['DeviceSessionGet', 'DeviceSession', {}],
+      ['DeviceSessionOpen', 'DeviceSession', { resume: { session_id: 'session-a' } }],
+      [
+        'DeviceSessionOpen',
+        'DeviceSession',
+        {
+          select: {
+            host_passphrase: { passphrase: 'state-a-secret' },
+          },
+        },
+      ],
     ]);
     expect(device.getInternalState()).toBe('session-b');
   });
@@ -763,10 +1027,23 @@ describe('Protocol V2 feature adapter', () => {
     const typedCall = jest
       .fn()
       .mockRejectedValue(new Error('Failure_ProcessError,Failure_InvalidSession'));
-    (device as any).commands = { typedCall };
+    (device as any).commands = {
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'new-secret' }),
+    };
 
     await expect(getProtocolV2WalletSession(device)).rejects.toThrow('Failure_InvalidSession');
-    expect(typedCall.mock.calls).toEqual([['DeviceSessionGet', 'DeviceSession', {}]]);
+    expect(typedCall.mock.calls).toEqual([
+      [
+        'DeviceSessionOpen',
+        'DeviceSession',
+        {
+          select: {
+            host_passphrase: { passphrase: 'new-secret' },
+          },
+        },
+      ],
+    ]);
   });
 
   test('rejects a mismatched Pro2 wallet state and clears the selected cache entry', async () => {
@@ -804,7 +1081,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
   });
 
-  test('unlocks and retries DeviceSessionGet when the Pro2 wallet session is locked', async () => {
+  test('unlocks and retries DeviceSessionOpen when hidden-wallet selection is locked', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-4',
       path: 'cache-path-4',
@@ -812,7 +1089,7 @@ describe('Protocol V2 feature adapter', () => {
     } as any);
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
-      { status: { device_id: 'stable-device-4', unlocked: false } }
+      { status: { device_id: 'stable-device-4', unlocked: true, passphrase_enabled: true } }
     );
     const lockedError = Object.assign(new Error('Device is locked'), {
       errorCode: HardwareErrorCode.DeviceLocked,
@@ -823,7 +1100,10 @@ describe('Protocol V2 feature adapter', () => {
       .mockResolvedValueOnce({
         message: { session_id: 'session-after-unlock', btc_test_address: '' },
       });
-    (device as any).commands = { typedCall };
+    (device as any).commands = {
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'hidden secret' }),
+    };
     const unlockDevice = jest.spyOn(device, 'unlockDevice').mockResolvedValue(undefined as any);
 
     await expect(getProtocolV2WalletSession(device)).resolves.toMatchObject({
@@ -887,6 +1167,32 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
   });
 
+  test('drops stale normal status when firmware reconnect supplies bootloader DeviceInfo', () => {
+    const device = Device.fromDescriptor({
+      id: 'firmware-reconnect-device',
+      path: 'firmware-reconnect-path',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = buildProtocolV2FeaturesPayload({
+      deviceInfo: {
+        protocol_version: 1,
+        hw: { serial_no: 'PR9999999999' },
+        fw: { application: { version: '1.0.0' } },
+      },
+      deviceStatus: {
+        device_id: 'firmware-reconnect-id',
+        init_states: true,
+        unlocked: false,
+      } as any,
+    });
+
+    (device as any).updateProtocolV2Features(protocolV2BootloaderDeviceInfo, null);
+
+    expect(device.features?.mode).toBe('bootloader');
+    expect(device.features?.bootloaderMode).toBe(true);
+    expect(device.features?.raw?.protocolV2DeviceStatus).toBeUndefined();
+  });
+
   test('returns passphrase state string for existing Pro devices', async () => {
     const features = {
       deviceId: 'pro-device-id',
@@ -914,7 +1220,10 @@ describe('Protocol V2 feature adapter', () => {
     method.device = stubDevice({
       originalDescriptor: { ...descriptor, protocolType: 'V1' },
       features,
-      commands: { typedCall },
+      commands: {
+        typedCall,
+        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-pro2-secret' }),
+      },
       updateInternalState,
       getCurrentDeviceId: () => 'pro-device-id',
       getCurrentPassphraseProtection: () => true,
@@ -957,7 +1266,10 @@ describe('Protocol V2 feature adapter', () => {
     method.device = stubDevice({
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features,
-      commands: { typedCall },
+      commands: {
+        typedCall,
+        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-pro2-new-secret' }),
+      },
       updateInternalState,
       getFeatures,
       getCurrentDeviceType: () => 'pro2',
@@ -996,7 +1308,10 @@ describe('Protocol V2 feature adapter', () => {
     method.device = stubDevice({
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features,
-      commands: { typedCall },
+      commands: {
+        typedCall,
+        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-pro2-new-secret' }),
+      },
       clearInternalState,
       updateInternalState,
       getCurrentDeviceId: () => 'pro2-device-id',
@@ -1032,7 +1347,10 @@ describe('Protocol V2 feature adapter', () => {
       }),
       unlocked: true,
     };
-    (device as any).commands = { typedCall };
+    (device as any).commands = {
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-profile-secret' }),
+    };
 
     await getPassphraseStateWithRefreshDeviceInfo(device);
 
@@ -1063,7 +1381,10 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).features.firmwareVersion = '4.15.0';
     (device as any).features.passphraseProtection = true;
     (device as any).features.unlocked = true;
-    (device as any).commands = { typedCall };
+    (device as any).commands = {
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-auto-secret' }),
+    };
 
     await expect(getPassphraseStateWithRefreshDeviceInfo(device)).resolves.toMatchObject({
       passphraseState: 'state-auto',
@@ -1076,7 +1397,11 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
     device.passphraseState = 'state-auto';
     expect(device.getInternalState()).toBe('session-auto');
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      select: {
+        host_passphrase: { passphrase: 'state-auto-secret' },
+      },
+    });
   });
 
   test('does not mark Pro2 passphrase enabled from a main PIN session alone', async () => {
@@ -1095,6 +1420,7 @@ describe('Protocol V2 feature adapter', () => {
       } as any,
       {
         status: {
+          unlocked: true,
           passphrase_enabled: false,
         },
       }
@@ -1107,13 +1433,13 @@ describe('Protocol V2 feature adapter', () => {
       getPassphraseStateWithRefreshDeviceInfo(device, { onlyMainPin: true })
     ).resolves.toMatchObject({
       passphraseState: undefined,
-      newSession: 'main-pin-session',
+      newSession: undefined,
     });
 
     expect(device.features?.passphraseProtection).toBe(false);
     expect(device.features?.sessionId).toBeNull();
     expect(device.getInternalState()).toBeUndefined();
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).not.toHaveBeenCalled();
   });
 
   test('does not let skipPassphraseCheck hide Pro2 passphrase state mismatch', async () => {
@@ -1132,7 +1458,11 @@ describe('Protocol V2 feature adapter', () => {
     } as any);
     (device as any).features.firmwareVersion = '4.15.0';
     (device as any).features.passphraseProtection = true;
-    (device as any).commands = { typedCall };
+    (device as any).features.unlocked = true;
+    (device as any).commands = {
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'expected-secret' }),
+    };
 
     await expect(device.checkPassphraseStateSafety('expected-state', false, true)).rejects.toEqual(
       expect.objectContaining({
@@ -1141,7 +1471,11 @@ describe('Protocol V2 feature adapter', () => {
     );
 
     expect(device.getInternalState()).toBeUndefined();
-    expect(typedCall).toHaveBeenNthCalledWith(1, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenNthCalledWith(1, 'DeviceSessionOpen', 'DeviceSession', {
+      select: {
+        host_passphrase: { passphrase: 'expected-secret' },
+      },
+    });
   });
 
   test('marks fallback features as unavailable when DeviceInfo is missing', () => {
@@ -1235,17 +1569,22 @@ describe('Protocol V2 feature adapter', () => {
 
   test('initializes Protocol V2 features from lightweight DeviceInfoGet', async () => {
     const commands = {
-      typedCall: jest.fn().mockResolvedValueOnce({
-        type: 'DeviceInfo',
-        message: {
-          hw: { serial_no: 'PR2SERIAL' },
-          status: {
+      typedCall: jest
+        .fn()
+        .mockResolvedValueOnce({
+          type: 'DeviceInfo',
+          message: {
+            hw: { serial_no: 'PR2SERIAL' },
+          },
+        })
+        .mockResolvedValueOnce({
+          type: 'DeviceStatus',
+          message: {
             device_id: 'PRO2-STATUS-ID',
             init_states: true,
             passphrase_enabled: true,
           },
-        },
-      }),
+        }),
     };
 
     const features = await requestProtocolV2Features({
@@ -1255,8 +1594,8 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(features.deviceId).toBe('PRO2-STATUS-ID');
     expect(features.initialized).toBe(true);
-    expect(features.passphraseProtection).toBe(true);
-    expect(commands.typedCall).toHaveBeenCalledTimes(1);
+    expect(features.passphraseProtection).toBeNull();
+    expect(commands.typedCall).toHaveBeenCalledTimes(2);
     expect(commands.typedCall).toHaveBeenNthCalledWith(
       1,
       'DeviceInfoGet',
@@ -1266,7 +1605,6 @@ describe('Protocol V2 feature adapter', () => {
           hw: true,
           fw: true,
           coprocessor: true,
-          status: true,
         },
         types: {
           version: true,
@@ -1275,6 +1613,7 @@ describe('Protocol V2 feature adapter', () => {
       },
       { timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS }
     );
+    expect(commands.typedCall).toHaveBeenNthCalledWith(2, 'DeviceStatusGet', 'DeviceStatus', {});
   });
 
   test('fails initialization when Protocol V2 DeviceInfoGet fails', async () => {
@@ -1291,29 +1630,34 @@ describe('Protocol V2 feature adapter', () => {
   });
 
   test('refreshes Protocol V2 basic device info with the lightweight request', async () => {
-    const typedCall = jest.fn().mockResolvedValueOnce({
-      type: 'DeviceInfo',
-      message: {
-        hw: { serial_no: 'PR2SERIAL' },
-        fw: {
-          application: {
-            version: '5.6.7',
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceInfo',
+        message: {
+          hw: { serial_no: 'PR2SERIAL' },
+          fw: {
+            application: {
+              version: '5.6.7',
+            },
           },
-        },
-        coprocessor: {
-          application: {
-            version: '8.9.10',
+          coprocessor: {
+            application: {
+              version: '8.9.10',
+            },
+            bt_adv_name: 'Raw Pro2 BLE',
           },
-          bt_adv_name: 'Raw Pro2 BLE',
         },
-        status: {
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: {
           device_id: 'PRO2-BASIC-ID',
           unlocked_by_attach_to_pin: true,
           init_states: true,
           passphrase_enabled: true,
         },
-      },
-    });
+      });
     const method = new GetDeviceInfo({
       id: 1,
       payload: {
@@ -1347,7 +1691,6 @@ describe('Protocol V2 feature adapter', () => {
           hw: true,
           fw: true,
           coprocessor: true,
-          status: true,
         },
         types: {
           version: true,
@@ -1429,13 +1772,16 @@ describe('Protocol V2 feature adapter', () => {
   });
 
   test('reads full Protocol V2 device info only for verify scope', async () => {
-    const typedCall = jest.fn().mockResolvedValueOnce({
-      type: 'DeviceInfo',
-      message: {
-        hw: { serial_no: 'PR2SERIAL' },
-        status: { init_states: true },
-      },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceInfo',
+        message: { hw: { serial_no: 'PR2SERIAL' } },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true },
+      });
     const method = new GetDeviceInfo({
       id: 1,
       payload: {
@@ -1465,7 +1811,6 @@ describe('Protocol V2 feature adapter', () => {
           se2: true,
           se3: true,
           se4: true,
-          status: true,
         },
         types: {
           version: true,
@@ -1479,21 +1824,26 @@ describe('Protocol V2 feature adapter', () => {
   });
 
   test('reads Protocol V2 SE version fields for versions scope', async () => {
-    const typedCall = jest.fn().mockResolvedValueOnce({
-      type: 'DeviceInfo',
-      message: {
-        hw: { serial_no: 'PR2SERIAL' },
-        se1: {
-          application: { version: '1.0.1' },
-          bootloader: { version: '1.0.0' },
-        },
-        se2: {
-          application: { version: '2.0.1' },
-          bootloader: { version: '2.0.0' },
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceInfo',
+        message: {
+          hw: { serial_no: 'PR2SERIAL' },
+          se1: {
+            application: { version: '1.0.1' },
+            bootloader: { version: '1.0.0' },
+          },
+          se2: {
+            application: { version: '2.0.1' },
+            bootloader: { version: '2.0.0' },
+          },
         },
-        status: { init_states: true },
-      },
-    });
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true },
+      });
     const method = new GetDeviceInfo({
       id: 1,
       payload: {
@@ -1522,7 +1872,6 @@ describe('Protocol V2 feature adapter', () => {
           se2: true,
           se3: true,
           se4: true,
-          status: true,
         },
         types: {
           version: true,
@@ -1698,7 +2047,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(message).not.toHaveProperty('label');
   });
 
-  test('refreshes cached Protocol V2 features with a lightweight status request on later runs', async () => {
+  test('reuses cached Protocol V2 features on later runs without polling device status', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
@@ -1710,21 +2059,14 @@ describe('Protocol V2 feature adapter', () => {
         message: {
           hw: { serial_no: 'PR2SERIAL' },
           fw: { application: { version: '1.2.3' } },
-          status: {
-            device_id: 'PRO2-REFRESH-ID',
-            passphrase_enabled: true,
-          },
         },
       })
-      // 第二次 run 的轻量 status 刷新：设备端 label / init_states 等可能已变化
       .mockResolvedValueOnce({
-        type: 'DeviceInfo',
+        type: 'DeviceStatus',
         message: {
-          hw: { serial_no: 'PR2SERIAL' },
-          status: {
-            device_id: 'PRO2-REFRESH-ID',
-            passphrase_enabled: false,
-          },
+          device_id: 'PRO2-REFRESH-ID',
+          unlocked: true,
+          passphrase_enabled: true,
         },
       });
 
@@ -1736,46 +2078,23 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.features).toMatchObject({
       deviceId: 'PRO2-REFRESH-ID',
       firmwareVersion: '1.2.3',
-      passphraseProtection: false,
-      label: null,
-    });
-    expect((device as any).profile).toBeUndefined();
-    // status 字段被第二次刷新更新
-    expect(device.features?.passphraseProtection).toBe(false);
-    expect(device.features?.label).toBeNull();
-    // 轻量刷新不含 fw target，已有版本信息按字段级合并保留
-    expect(device.features?.firmwareVersion).toBe('1.2.3');
-    expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenNthCalledWith(
-      1,
-      'DeviceInfoGet',
-      'DeviceInfo',
-      {
-        targets: {
-          hw: true,
-          fw: true,
-          coprocessor: true,
-          status: true,
-        },
-        types: {
-          version: true,
-          specific: true,
-        },
-      },
-      {
-        timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
-      }
-    );
-    // 第二次为 status-only 轻量请求（hw/coprocessor 仅用于身份字段，避免顶层覆盖清空）
+      passphraseProtection: true,
+      label: null,
+    });
+    expect((device as any).profile).toBeUndefined();
+    expect(device.features?.passphraseProtection).toBe(true);
+    expect(device.features?.label).toBeNull();
+    expect(device.features?.firmwareVersion).toBe('1.2.3');
+    expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenNthCalledWith(
-      2,
+      1,
       'DeviceInfoGet',
       'DeviceInfo',
       {
         targets: {
           hw: true,
+          fw: true,
           coprocessor: true,
-          status: true,
         },
         types: {
           version: true,
@@ -1786,6 +2105,7 @@ describe('Protocol V2 feature adapter', () => {
         timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
       }
     );
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceStatusGet', 'DeviceStatus', {});
   });
 
   test('refreshes Protocol V2 features without falling back to V1 GetFeatures', async () => {
@@ -1800,16 +2120,22 @@ describe('Protocol V2 feature adapter', () => {
         message: {
           hw: { serial_no: 'PR2SERIAL' },
           fw: { application: { version: '1.2.3' } },
-          status: { init_states: true },
         },
       })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true },
+      })
       .mockResolvedValueOnce({
         type: 'DeviceInfo',
         message: {
           hw: { serial_no: 'PR2SERIAL' },
           fw: { application: { version: '1.2.4' } },
-          status: { init_states: true, passphrase_enabled: true },
         },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true, unlocked: true, passphrase_enabled: true },
       });
 
     (device as any).commands = { typedCall };
@@ -1828,9 +2154,9 @@ describe('Protocol V2 feature adapter', () => {
       firmwareVersion: '1.2.4',
       passphraseProtection: true,
     });
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(4);
     expect(typedCall).toHaveBeenNthCalledWith(
-      2,
+      3,
       'DeviceInfoGet',
       'DeviceInfo',
       {
@@ -1838,7 +2164,6 @@ describe('Protocol V2 feature adapter', () => {
           hw: true,
           fw: true,
           coprocessor: true,
-          status: true,
         },
         types: {
           version: true,
@@ -1934,7 +2259,7 @@ describe('Protocol V2 feature adapter', () => {
     const features = await device.unlockDevice();
 
     expect(typedCall.mock.calls).toEqual([
-      ['DeviceSessionAskPin', 'Success'],
+      ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
     ]);
     expect(typedCall).not.toHaveBeenCalledWith('GetAddress', 'Address', expect.anything());
@@ -1946,7 +2271,7 @@ describe('Protocol V2 feature adapter', () => {
       unlockedAttachPin: true,
       passphraseProtection: true,
     });
-    expect(features.raw?.protocolV2DeviceInfo?.status).toMatchObject({
+    expect(features.raw?.protocolV2DeviceStatus).toMatchObject({
       unlocked: true,
       unlocked_by_attach_to_pin: true,
       passphrase_enabled: true,
@@ -1987,7 +2312,7 @@ describe('Protocol V2 feature adapter', () => {
     await device.unlockDevice();
 
     expect(typedCall.mock.calls).toEqual([
-      ['DeviceSessionAskPin', 'Success'],
+      ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
     ]);
     expect((device as any).profile).toBeUndefined();
@@ -2016,9 +2341,11 @@ describe('Protocol V2 feature adapter', () => {
       })
     );
     expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall.mock.calls).toEqual([['DeviceSessionAskPin', 'Success']]);
+    expect(typedCall.mock.calls).toEqual([
+      ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
+    ]);
     expect(typedCall).not.toHaveBeenCalledWith(
-      'DeviceSessionGet',
+      'DeviceSessionOpen',
       'DeviceSession',
       expect.anything()
     );
@@ -2506,7 +2833,6 @@ describe('Protocol V2 firmware update targets', () => {
           se2: true,
           se3: true,
           se4: true,
-          status: true,
         },
         types: {
           version: true,
@@ -2634,6 +2960,7 @@ describe('Protocol V2 firmware update targets', () => {
       });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
     (method as any).device.getCommands = () => ({ typedCall });
+    (method as any).protocolV2ExpectedDeviceId = '8693920D7CA90CEC4A88353D';
 
     await (method as any).waitForProtocolV2BootloaderMode(60 * 1000, 0);
 
@@ -2641,6 +2968,47 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall).toHaveBeenCalledTimes(1);
   });
 
+  test('does not run generic initialize during Protocol V2 USB firmware reconnect', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const commands = { disposed: true, mainId: '' };
+    const initialize = jest.fn().mockResolvedValue(undefined);
+    const device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
+      features: { bootloaderMode: false, capabilities: [] },
+      deviceConnector: {
+        enumerate: jest.fn().mockResolvedValue({
+          descriptors: [{ id: 'usb-id', path: 'usb-path', protocolType: 'V2' }],
+        }),
+      },
+      updateFromCache: jest.fn(),
+      acquire: jest.fn().mockResolvedValue(undefined),
+      initialize,
+      commands,
+      getCommands: () => commands,
+      mainId: 'usb-path',
+    });
+    const cachedDevice = { getConnectId: () => 'usb-path' };
+    const getDevices = jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({
+      devices: {},
+      deviceList: [cachedDevice],
+    } as any);
+    (method as any).device = device;
+
+    try {
+      await (method as any).reconnectProtocolV2Device();
+    } finally {
+      getDevices.mockRestore();
+    }
+
+    expect(device.acquire).toHaveBeenCalledWith('V2', { throwOnRunPromiseError: true });
+    expect(initialize).not.toHaveBeenCalled();
+  });
+
   test('reboots Protocol V2 firmware flow back to normal after install status is finished', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -2754,7 +3122,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postTipMessage).toHaveBeenCalledWith('FirmwareUpdating');
   });
 
-  test('continues Protocol V2 install polling through temporary expected V2 probe failures', async () => {
+  test('retries final device readiness through temporary Protocol V2 probe failures', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -2762,7 +3130,7 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     const typedCall = jest.fn().mockImplementation((name: string) => {
-      if (name === 'DeviceFirmwareUpdateStatusGet') {
+      if (name === 'DeviceStatusGet') {
         const callCount = typedCall.mock.calls.filter(call => call[0] === name).length;
         if (callCount === 1) {
           return Promise.reject(
@@ -2772,24 +3140,28 @@ describe('Protocol V2 firmware update targets', () => {
           );
         }
         return Promise.resolve({
-          type: 'DeviceFirmwareUpdateStatus',
-          message: {
-            records: [{ target_id: 6, status: 2 }],
-          },
+          type: 'DeviceStatus',
+          message: { device_id: 'PRO2-DEVICE-ID', init_states: true },
         });
       }
       if (name === 'DeviceInfoGet') {
-        return Promise.reject(new Error('DeviceInfo not ready'));
-      }
-      if (name === 'Ping') {
-        return Promise.resolve({ type: 'Success', message: { message: 'ready' } });
+        return Promise.resolve({
+          type: 'DeviceInfo',
+          message: { hw: { serial_no: 'PR9999999999' } },
+        });
       }
       return Promise.reject(new Error(`unexpected call ${name}`));
     });
     const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    const updateProtocolV2Features = jest.fn(() => ({
+      deviceId: 'PRO2-DEVICE-ID',
+      bootloaderMode: false,
+      mode: 'normal',
+    }));
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
+      updateProtocolV2Features,
     });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
     method.postProgressMessage = jest.fn();
@@ -2798,16 +3170,67 @@ describe('Protocol V2 firmware update targets', () => {
       { target_id: 6, path: 'vol1:ble-firmware.bin' },
     ]);
 
-    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(2);
     expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-      'DeviceFirmwareUpdateStatusGet',
+      'DeviceStatusGet',
+      'DeviceStatusGet',
+      'DeviceInfoGet',
+    ]);
+  });
+
+  test('retries final device readiness after the USB handle is no longer acquired', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn().mockImplementation((name: string) => {
+      if (name === 'DeviceStatusGet') {
+        const callCount = typedCall.mock.calls.filter(call => call[0] === name).length;
+        if (callCount === 1) {
+          return Promise.reject(new Error('Device not acquired: PR9999999999'));
+        }
+        return Promise.resolve({
+          type: 'DeviceStatus',
+          message: { device_id: 'PRO2-DEVICE-ID', init_states: true },
+        });
+      }
+      if (name === 'DeviceInfoGet') {
+        return Promise.resolve({
+          type: 'DeviceInfo',
+          message: { hw: { serial_no: 'PR9999999999' } },
+        });
+      }
+      return Promise.reject(new Error(`unexpected call ${name}`));
+    });
+    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    const updateProtocolV2Features = jest.fn(() => ({
+      deviceId: 'PRO2-DEVICE-ID',
+      bootloaderMode: false,
+      mode: 'normal',
+    }));
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      updateProtocolV2Features,
+    });
+    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+    method.postProgressMessage = jest.fn();
+
+    await (method as any).waitForProtocolV2FirmwareUpdateComplete([
+      { target_id: 3, path: 'vol0:/bootloader.bin' },
+    ]);
+
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(2);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceStatusGet',
+      'DeviceStatusGet',
       'DeviceInfoGet',
-      'Ping',
-      'DeviceFirmwareUpdateStatusGet',
     ]);
   });
 
-  test('treats Protocol V2 normal mode after reconnect as firmware update complete', async () => {
+  test('treats DeviceStatusGet and DeviceInfoGet readiness as firmware update complete', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -2815,8 +3238,14 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     const typedCall = jest.fn().mockImplementation((name: string) => {
-      if (name === 'DeviceFirmwareUpdateStatusGet') {
-        return Promise.reject(new Error('Device disconnected'));
+      if (name === 'DeviceStatusGet') {
+        return Promise.resolve({
+          type: 'DeviceStatus',
+          message: {
+            device_id: 'PRO2-DEVICE-ID',
+            init_states: true,
+          },
+        });
       }
       if (name === 'DeviceInfoGet') {
         return Promise.resolve({
@@ -2827,19 +3256,17 @@ describe('Protocol V2 firmware update targets', () => {
               bootloader: { version: '9.9.9' },
               application: { version: '9.9.9' },
             },
-            status: {
-              device_id: 'PRO2-DEVICE-ID',
-              init_states: true,
-            },
           },
         });
       }
       return Promise.reject(new Error(`unexpected call ${name}`));
     });
     const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
-    const updateProtocolV2Features = jest.fn((deviceInfo: ProtocolV2DeviceInfo) =>
-      normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, deviceInfo)
-    );
+    const updateProtocolV2Features = jest.fn(() => ({
+      deviceId: 'PRO2-DEVICE-ID',
+      bootloaderMode: false,
+      mode: 'normal',
+    }));
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
@@ -2849,18 +3276,35 @@ describe('Protocol V2 firmware update targets', () => {
     method.postProgressMessage = jest.fn();
 
     await expect(
-      (method as any).waitForProtocolV2FirmwareUpdateComplete([
-        { target_id: 3, path: 'vol1:bootloader.bin' },
-        { target_id: 4, path: 'vol1:application_p1.bin' },
-      ])
+      (method as any).waitForProtocolV2FirmwareUpdateComplete(
+        [
+          { target_id: 3, path: 'vol1:bootloader.bin' },
+          { target_id: 4, path: 'vol1:application_p1.bin' },
+        ],
+        {
+          type: 'DeviceFirmwareUpdateStatus',
+          message: {
+            records: [
+              { target_id: 3, status: 2 },
+              { target_id: 4, status: 2 },
+            ],
+          },
+        }
+      )
     ).resolves.toBeUndefined();
 
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
     expect(updateProtocolV2Features).toHaveBeenCalledTimes(1);
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+    expect(updateProtocolV2Features).toHaveBeenCalledWith(
+      expect.objectContaining({ hw: { serial_no: 'PR9999999999' } }),
+      expect.objectContaining({ device_id: 'PRO2-DEVICE-ID' })
+    );
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceStatusGet', 'DeviceInfoGet']);
+    expect(typedCall).not.toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
-      'DeviceInfoGet',
-    ]);
+      expect.anything(),
+      expect.anything()
+    );
   });
 
   test('uses SDK decoded enum names for Protocol V2 install polling', () => {
@@ -3995,6 +4439,64 @@ describe('Protocol V2 firmware reconnect identity', () => {
       assertProtocolV2ReconnectIdentity('expected-device', 'expected-device')
     ).not.toThrow();
   });
+
+  test('allows bootloader reconnect without wallet device id after USB identity is selected', () => {
+    expect(() =>
+      assertProtocolV2ReconnectIdentity('expected-device', undefined, {
+        allowMissingActual: true,
+      })
+    ).not.toThrow();
+    expect(() =>
+      assertProtocolV2ReconnectIdentity('expected-device', 'other-device', {
+        allowMissingActual: true,
+      })
+    ).toThrow('identity mismatch');
+  });
+});
+
+describe('Protocol V2 explicit USB device selection', () => {
+  beforeEach(() => {
+    DevicePool.resetState();
+    jest.restoreAllMocks();
+  });
+
+  test('only initializes the descriptor matching an explicit connectId', async () => {
+    const zeroDescriptor = {
+      path: '000000000000000000000000',
+      id: '000000000000000000000000',
+    } as any;
+    const pro2Descriptor = {
+      path: 'PR9999999999',
+      id: 'PR9999999999',
+    } as any;
+    const pro2Device = {
+      getConnectId: () => 'PR9999999999',
+      originalDescriptor: pro2Descriptor,
+      updateDescriptor: jest.fn(),
+    } as any;
+    const zeroDevice = {
+      getConnectId: () => '000000000000000000000000',
+      originalDescriptor: zeroDescriptor,
+      updateDescriptor: jest.fn(),
+    } as any;
+
+    const createDevice = jest
+      .spyOn(DevicePool as any, '_createDevice')
+      .mockImplementation((descriptor: { path: string }) =>
+        Promise.resolve(descriptor.path === pro2Descriptor.path ? pro2Device : zeroDevice)
+      );
+    const checkDevicePool = jest
+      .spyOn(DevicePool as any, '_checkDevicePool')
+      .mockResolvedValue(undefined);
+
+    const result = await DevicePool.getDevices([zeroDescriptor, pro2Descriptor], 'PR9999999999');
+
+    expect(createDevice).toHaveBeenCalledTimes(1);
+    expect(createDevice).toHaveBeenCalledWith(pro2Descriptor, undefined);
+    expect(checkDevicePool).toHaveBeenCalledWith(undefined, 'PR9999999999');
+    expect(result.deviceList).toEqual([pro2Device]);
+    expect(result.devices).toEqual({ PR9999999999: pro2Device });
+  });
 });
 
 describe('Protocol V2 reboot methods', () => {
@@ -4024,10 +4526,43 @@ describe('Protocol V2 protected method execution', () => {
       errorCode: HardwareErrorCode.DeviceLocked,
     });
 
+  test('uses locked retry by default for SDK business methods', () => {
+    class TestBusinessMethod extends BaseMethod {
+      init() {}
+
+      run() {
+        return Promise.resolve({});
+      }
+    }
+
+    const method = new TestBusinessMethod({
+      id: 1,
+      payload: { method: 'testBusinessMethod' },
+    } as any);
+
+    expect(method.unlockPolicy).toBe('retry-on-locked');
+  });
+
+  test.each([
+    ['deviceLock', DeviceLock],
+    ['deviceUnlock', DeviceUnlock],
+    ['deviceCancel', DeviceCancel],
+  ])('does not auto-retry the %s control method', (_name, MethodClass) => {
+    const method = new MethodClass({
+      id: 1,
+      payload: { method: _name },
+    } as any);
+    method.init();
+
+    expect(method.unlockPolicy).toBe('none');
+  });
+
   test('unlocks and retries an opted-in Protocol V2 method once', async () => {
     const calls: string[] = [];
     const method = {
+      name: 'testBusinessMethod',
       unlockPolicy: 'retry-on-locked',
+      protocolV2UiInteraction: { reason: 'settings-page' },
       run: jest
         .fn()
         .mockImplementationOnce(() => {
@@ -4046,11 +4581,87 @@ describe('Protocol V2 protected method execution', () => {
         return Promise.resolve();
       }),
     };
+    const uiCoordinator = {
+      enterMethodInteraction: jest.fn(() => calls.push('method-prompt')),
+      enterUnlockInteraction: jest.fn(() => calls.push('unlock-prompt')),
+      resumeMethodInteraction: jest.fn(() => calls.push('method-prompt')),
+    };
+
+    await expect(
+      runMethodWithUnlockRetry(method as any, device as any, uiCoordinator as any)
+    ).resolves.toEqual({ message: 'ok' });
+    expect(calls).toEqual([
+      'method-prompt',
+      'run-1',
+      'unlock-prompt',
+      'unlock',
+      'method-prompt',
+      'run-2',
+    ]);
+  });
+
+  test('unlocks before showing the method interaction when cached status is locked', async () => {
+    const calls: string[] = [];
+    const method = {
+      name: 'deviceSettingsPageShow',
+      unlockPolicy: 'retry-on-locked',
+      protocolV2UiInteraction: { reason: 'settings-page' },
+      run: jest.fn(() => {
+        calls.push('run');
+        return Promise.resolve({ message: 'ok' });
+      }),
+    };
+    const device = {
+      features: { unlocked: false },
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn(() => {
+        calls.push('unlock');
+        return Promise.resolve();
+      }),
+    };
+    const uiCoordinator = {
+      enterMethodInteraction: jest.fn(() => calls.push('method-prompt')),
+      enterUnlockInteraction: jest.fn(() => calls.push('unlock-prompt')),
+      resumeMethodInteraction: jest.fn(() => calls.push('method-prompt')),
+    };
+
+    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(method.run).toHaveBeenCalledTimes(1);
+    expect(uiCoordinator.enterMethodInteraction).toHaveBeenCalledTimes(1);
+    expect(uiCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
+  });
+
+  test('infers a signing interaction before running a Protocol V2 business method', async () => {
+    const method = {
+      name: 'evmSignMessage',
+      params: { message: 'not-exposed-in-event' },
+      payload: {},
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn().mockResolvedValue({ signature: 'test' }),
+    };
+    const device = {
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn(),
+    };
+    const uiCoordinator = {
+      enterMethodInteraction: jest.fn(),
+      enterUnlockInteraction: jest.fn(),
+      resumeMethodInteraction: jest.fn(),
+    };
+
+    await runMethodWithUnlockRetry(method as any, device as any, uiCoordinator as any);
 
-    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
-      message: 'ok',
+    expect(uiCoordinator.enterMethodInteraction).toHaveBeenCalledWith({
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'signing-confirmation',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      operation: 'evmSignMessage',
     });
-    expect(calls).toEqual(['run-1', 'unlock', 'run-2']);
   });
 
   test('does not unlock a Protocol V1 device or a method without the policy', async () => {
@@ -4074,6 +4685,35 @@ describe('Protocol V2 protected method execution', () => {
     }
   });
 
+  test('keeps auto unlock but suppresses all synthesized UI for eventless methods', async () => {
+    const method = {
+      name: 'uploadPortfolio',
+      unlockPolicy: 'retry-on-locked',
+      protocolV2UiMode: 'none',
+      run: jest
+        .fn()
+        .mockRejectedValueOnce(deviceLockedError())
+        .mockResolvedValueOnce({ message: 'ok' }),
+    };
+    const device = {
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn().mockResolvedValue(undefined),
+    };
+    const uiCoordinator = {
+      enterMethodInteraction: jest.fn(),
+      enterUnlockInteraction: jest.fn(),
+      resumeMethodInteraction: jest.fn(),
+    };
+
+    await expect(
+      runMethodWithUnlockRetry(method as any, device as any, uiCoordinator as any)
+    ).resolves.toEqual({ message: 'ok' });
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(uiCoordinator.enterMethodInteraction).not.toHaveBeenCalled();
+    expect(uiCoordinator.enterUnlockInteraction).not.toHaveBeenCalled();
+    expect(uiCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
+  });
+
   test('does not retry when unlock fails or when the retry is still locked', async () => {
     const initialError = deviceLockedError();
     const unlockError = new Error('PIN cancelled');
@@ -4085,11 +4725,22 @@ describe('Protocol V2 protected method execution', () => {
       isProtocolV2: () => true,
       unlockDevice: jest.fn().mockRejectedValue(unlockError),
     };
+    const unlockFailCoordinator = {
+      enterMethodInteraction: jest.fn(),
+      enterUnlockInteraction: jest.fn(),
+      resumeMethodInteraction: jest.fn(),
+    };
 
     await expect(
-      runMethodWithUnlockRetry(unlockFailMethod as any, unlockFailDevice as any)
+      runMethodWithUnlockRetry(
+        unlockFailMethod as any,
+        unlockFailDevice as any,
+        unlockFailCoordinator as any
+      )
     ).rejects.toBe(unlockError);
     expect(unlockFailMethod.run).toHaveBeenCalledTimes(1);
+    expect(unlockFailCoordinator.enterUnlockInteraction).toHaveBeenCalledTimes(1);
+    expect(unlockFailCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
 
     const retryError = deviceLockedError();
     const retryFailMethod = {
@@ -4100,16 +4751,121 @@ describe('Protocol V2 protected method execution', () => {
       isProtocolV2: () => true,
       unlockDevice: jest.fn().mockResolvedValue(undefined),
     };
+    const retryFailCoordinator = {
+      enterMethodInteraction: jest.fn(),
+      enterUnlockInteraction: jest.fn(),
+      resumeMethodInteraction: jest.fn(),
+    };
 
     await expect(
-      runMethodWithUnlockRetry(retryFailMethod as any, retryFailDevice as any)
+      runMethodWithUnlockRetry(
+        retryFailMethod as any,
+        retryFailDevice as any,
+        retryFailCoordinator as any
+      )
     ).rejects.toBe(retryError);
     expect(retryFailMethod.run).toHaveBeenCalledTimes(2);
     expect(retryFailDevice.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(retryFailCoordinator.enterUnlockInteraction).toHaveBeenCalledTimes(1);
+    expect(retryFailCoordinator.resumeMethodInteraction).toHaveBeenCalledTimes(1);
   });
 });
 
 describe('Protocol V2 current low-level methods', () => {
+  test('routes device wipe to the Pro2 reset page until the operation completes', async () => {
+    const v1TypedCall = jest.fn().mockResolvedValue({ message: { message: 'wiped' } });
+    const v1Method = new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } });
+    v1Method.init();
+    (v1Method as any).device = stubDevice({
+      isProtocolV2: () => false,
+      commands: { typedCall: v1TypedCall },
+    });
+
+    await v1Method.run();
+    expect(v1TypedCall).toHaveBeenCalledWith('WipeDevice', 'Success');
+
+    const v2TypedCall = jest.fn().mockResolvedValue({ message: { message: 'accepted' } });
+    const v2Method = new DeviceWipe({ id: 2, payload: { method: 'deviceWipe' } });
+    v2Method.init();
+    (v2Method as any).device = stubDevice({
+      isProtocolV2: () => true,
+      commands: { typedCall: v2TypedCall },
+    });
+
+    await expect(v2Method.run()).resolves.toEqual({ message: 'accepted' });
+    expect(v2TypedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
+      page: DeviceSettingsPage.DeviceReset,
+    });
+    expect(v2Method.protocolV2UiInteraction).toEqual({
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'device-management',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      page: DeviceSettingsPage.DeviceReset,
+      operation: 'wipe-device',
+    });
+  });
+
+  test('routes Change PIN by protocol and waits for the Pro2 operation result', async () => {
+    const v1TypedCall = jest.fn().mockResolvedValue({ message: { message: 'ok' } });
+    const v1Method = new DeviceChangePin({
+      id: 1,
+      payload: { method: 'deviceChangePin', remove: false },
+    });
+    v1Method.init();
+    (v1Method as any).device = stubDevice({
+      isProtocolV2: () => false,
+      commands: { typedCall: v1TypedCall },
+    });
+
+    await v1Method.run();
+
+    expect(v1TypedCall).toHaveBeenCalledWith('ChangePin', 'Success', { remove: false });
+
+    const v2TypedCall = jest.fn().mockResolvedValue({ message: { message: 'accepted' } });
+    const v2Method = new DeviceChangePin({
+      id: 2,
+      payload: { method: 'deviceChangePin', remove: false },
+    });
+    v2Method.init();
+    (v2Method as any).device = stubDevice({
+      isProtocolV2: () => true,
+      commands: { typedCall: v2TypedCall },
+    });
+
+    await expect(v2Method.run()).resolves.toEqual({ message: 'accepted' });
+    expect(v2TypedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
+      page: DeviceSettingsPage.DevicePinChange,
+    });
+    expect(v2Method.protocolV2UiInteraction).toEqual({
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'change-pin',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      page: DeviceSettingsPage.DevicePinChange,
+    });
+  });
+
+  test('rejects removing a PIN through the Pro2 page-only Change PIN flow', async () => {
+    const typedCall = jest.fn();
+    const method = new DeviceChangePin({
+      id: 1,
+      payload: { method: 'deviceChangePin', remove: true },
+    });
+    method.init();
+    (method as any).device = stubDevice({
+      isProtocolV2: () => true,
+      commands: { typedCall },
+    });
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
   test('sends ProtocolInfoRequest from protocolInfoRequest', async () => {
     const typedCall = jest.fn().mockResolvedValue({ message: { version: 1 } });
     const method = new ProtocolInfoRequest({
@@ -4200,6 +4956,44 @@ describe('Protocol V2 current low-level methods', () => {
         brightness: 80,
       },
     });
+    expect(method.protocolV2UiInteraction).toEqual({
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'device-management',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      operation: 'change-label',
+    });
+  });
+
+  test('keeps silent Protocol V2 device settings eventless', () => {
+    const method = new DeviceSettingsSet({
+      id: 1,
+      payload: {
+        method: 'deviceSettingsSet',
+        settings: { brightness: 80 },
+      },
+    });
+    method.init();
+
+    expect(method.protocolV2UiInteraction).toBeUndefined();
+  });
+
+  test('marks explicit Protocol V2 unlock as an on-device PIN interaction', () => {
+    const method = new DeviceUnlock({
+      id: 1,
+      payload: { method: 'deviceUnlock' },
+    });
+    method.init();
+
+    expect(method.protocolV2UiInteraction).toEqual({
+      request: 'pin',
+      source: 'method-lifecycle',
+      reason: 'device-unlock',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      operation: 'unlock-device',
+    });
   });
 
   test('opens non-passphrase Protocol V2 settings pages', async () => {
@@ -4221,6 +5015,14 @@ describe('Protocol V2 current low-level methods', () => {
       page: 3,
       field_name: 'airgap_mode',
     });
+    expect(method.protocolV2UiInteraction).toEqual({
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'settings-page',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      page: DeviceSettingsPage.DeviceAirgap,
+    });
   });
 
   test('opens the Protocol V2 passphrase settings page', async () => {
@@ -4364,7 +5166,7 @@ describe('Protocol V2 raw device info method', () => {
       'DeviceInfoGet',
       'DeviceInfo',
       {
-        targets: { hw: true, fw: true, coprocessor: true, status: true },
+        targets: { hw: true, fw: true, coprocessor: true },
         types: { version: true, specific: true },
       },
       { timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS }