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

package/__tests__/protocol-v2.test.ts

@@ -33,7 +33,6 @@ import EVMSignTypedData from '../src/api/evm/EVMSignTypedData';
 import EVMSignMessageEIP712 from '../src/api/evm/EVMSignMessageEIP712';
 import FirmwareUpdateV3 from '../src/api/FirmwareUpdateV3';
 import FirmwareUpdateV4, { assertProtocolV2ReconnectIdentity } from '../src/api/FirmwareUpdateV4';
-import GetDeviceInfo from '../src/api/GetDeviceInfo';
 import GetPassphraseState from '../src/api/GetPassphraseState';
 import GetOnekeyFeatures from '../src/api/GetOnekeyFeatures';
 import { batchGetPublickeys } from '../src/api/helpers/batchGetPublickeys';
@@ -73,7 +72,6 @@ import {
 import { runMethodWithUnlockRetry } from '../src/protocols/protocol-v2/unlockRetry';
 import { BaseMethod } from '../src/api/BaseMethod';
 import {
-  buildProfileFromProtocolV2,
   buildProtocolV1FeaturesPayload,
   buildProtocolV2FeaturesPayload,
 } from '../src/deviceProfile';
@@ -301,6 +299,8 @@ const descriptor = {
  */
 function stubDevice<T extends Record<string, any>>(device: T): T {
   const d = device as any;
+  d.updateState ??= jest.fn();
+  d.markProtocolV2Reboot ??= jest.fn();
   d.isProtocolV2 ??= () => d.originalDescriptor?.protocolType === 'V2';
   d.getProtocol ??= () => (d.isProtocolV2() ? 'V2' : 'V1');
   d.getCurrentDeviceType ??= () => getDeviceType(d.features);
@@ -337,6 +337,13 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
     });
     return d.features;
   };
+  d.updateFeaturesPatch ??= (patch: Record<string, unknown>) => {
+    d.features = {
+      ...d.features,
+      ...Object.fromEntries(Object.entries(patch).filter(([, value]) => value !== undefined)),
+    };
+    return d.features;
+  };
   return device;
 }
 
@@ -368,8 +375,7 @@ async function requestProtocolV2Features({
   descriptor?: unknown;
 }) {
   const deviceInfo = await requestProtocolV2DeviceInfo({ commands });
-  const deviceStatus = await requestProtocolV2DeviceStatus({ commands });
-  return buildProtocolV2FeaturesPayload({ deviceInfo, deviceStatus });
+  return buildProtocolV2FeaturesPayload({ deviceInfo });
 }
 
 describe('Protocol V2 feature adapter', () => {
@@ -389,6 +395,26 @@ describe('Protocol V2 feature adapter', () => {
     expect(features.passphrase_protection).toBeUndefined();
   });
 
+  test('preserves the last trusted passphrase setting while the device is locked', () => {
+    const features = buildProtocolV2FeaturesPayload({
+      deviceInfo: {
+        hw: { serial_no: 'P2-LOCKED' },
+      },
+      deviceStatus: {
+        unlocked: false,
+        passphrase_enabled: false,
+      },
+      previous: {
+        ...buildProtocolV2FeaturesPayload({
+          deviceInfo: { hw: { serial_no: 'P2-LOCKED' } },
+        }),
+        passphraseProtection: true,
+      },
+    });
+
+    expect(features.passphraseProtection).toBe(true);
+  });
+
   test('builds dynamic features from DeviceStatus when DeviceInfo has no nested status', () => {
     const deviceInfo: ProtocolV2DeviceInfo = {
       protocol_version: 1,
@@ -563,13 +589,9 @@ describe('Protocol V2 feature adapter', () => {
       },
     };
     const features = normalizeProtocolV2Features(descriptor as any, deviceInfo);
-    const profile = buildProfileFromProtocolV2({ deviceInfo });
-
     expect(features.mode).toBe('bootloader');
     expect(features.bootloaderMode).toBe(true);
     expect(features.initialized).toBeNull();
-    expect(profile.status.mode).toBe('bootloader');
-    expect(profile.status.bootloaderMode).toBe(true);
   });
 
   test('marks current romloader-shaped Protocol V2 DeviceInfo as romloader mode', () => {
@@ -588,14 +610,9 @@ describe('Protocol V2 feature adapter', () => {
       },
     };
     const features = normalizeProtocolV2Features(descriptor as any, deviceInfo);
-    const profile = buildProfileFromProtocolV2({ deviceInfo });
-
     expect(features.mode).toBe('romloader');
     expect(features.bootloaderMode).toBe(false);
     expect(features.boardVersion).toBe('1.0.0');
-    expect(profile.status.mode).toBe('romloader');
-    expect(profile.status.bootloaderMode).toBe(false);
-    expect(profile.versions.board).toBe('1.0.0');
   });
 
   test('keeps the Protocol V2 main wallet on the default empty-passphrase context', async () => {
@@ -627,14 +644,17 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
   });
 
-  test('uses the default main wallet context when Protocol V2 passphrase protection is disabled', async () => {
+  test('keeps Protocol V2 on the standard wallet when 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 };
+    const promptPassphrase = jest
+      .fn()
+      .mockResolvedValue({ passphrase: 'hidden-wallet-with-disabled-flag' });
+    (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(getProtocolV2WalletSession(device)).resolves.toEqual({
       passphraseState: undefined,
@@ -642,10 +662,51 @@ describe('Protocol V2 feature adapter', () => {
       unlockedAttachPin: false,
     });
 
+    expect(promptPassphrase).not.toHaveBeenCalled();
     expect(typedCall).not.toHaveBeenCalled();
   });
 
-  test('unlocks before deciding that Protocol V2 uses the default main wallet context', async () => {
+  test('preserves cached settings only while Protocol V2 physical identity stays the same', () => {
+    const previous = {
+      ...normalizeProtocolV2Features(descriptor as any, {
+        hw: { serial_no: 'PR2-SAME' },
+      }),
+      deviceId: 'wallet-device-id',
+      label: 'Renamed Pro 2',
+      autoLockDelayMs: 60_000,
+      experimentalFeatures: true,
+      passphraseProtection: true,
+      attachToPinEnabled: true,
+    };
+
+    const refreshed = buildProtocolV2FeaturesPayload({
+      deviceInfo: { hw: { serial_no: 'PR2-SAME' } },
+      previous,
+    });
+    expect(refreshed).toMatchObject({
+      deviceId: 'wallet-device-id',
+      label: 'Renamed Pro 2',
+      autoLockDelayMs: 60_000,
+      experimentalFeatures: true,
+      passphraseProtection: true,
+      attachToPinEnabled: true,
+    });
+
+    const replacedDevice = buildProtocolV2FeaturesPayload({
+      deviceInfo: { hw: { serial_no: 'PR2-OTHER' } },
+      previous,
+    });
+    expect(replacedDevice).toMatchObject({
+      deviceId: null,
+      label: null,
+      autoLockDelayMs: null,
+      experimentalFeatures: null,
+      passphraseProtection: null,
+      attachToPinEnabled: null,
+    });
+  });
+
+  test('uses refreshed passphrase status after unlocking before selecting a Protocol V2 wallet', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
@@ -656,8 +717,23 @@ describe('Protocol V2 feature adapter', () => {
         },
       }
     );
-    const typedCall = jest.fn();
-    const promptPassphrase = jest.fn();
+    const typedCall = jest.fn().mockImplementation((request: string) => {
+      if (request === 'DeviceSessionOpen') {
+        return Promise.resolve({
+          message: {
+            btc_test_address: 'state-after-unlock',
+            session_id: 'session-after-unlock',
+          },
+        });
+      }
+      if (request === 'DeviceStatusGet') {
+        return Promise.resolve({
+          message: { passphrase_enabled: false, unlocked: true },
+        });
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden-after-unlock' });
     const unlockDevice = jest.spyOn(device, 'unlockDevice').mockImplementation(() => {
       (device as any).features = {
         ...(device as any).features,
@@ -874,11 +950,10 @@ describe('Protocol V2 feature adapter', () => {
     expect(() => method.init()).toThrow();
   });
 
-  test('routes raw status and session methods through CoreApi', async () => {
+  test('routes public onboarding 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.deviceSessionOpen('connect-id', {
       retryCount: 1,
@@ -886,16 +961,11 @@ describe('Protocol V2 feature adapter', () => {
     });
 
     expect(call).toHaveBeenNthCalledWith(1, {
-      method: 'deviceStatusGet',
-      connectId: 'connect-id',
-      retryCount: 1,
-    });
-    expect(call).toHaveBeenNthCalledWith(2, {
       method: 'deviceGetOnboardingStatus',
       connectId: 'connect-id',
       retryCount: 1,
     });
-    expect(call).toHaveBeenNthCalledWith(3, {
+    expect(call).toHaveBeenNthCalledWith(2, {
       method: 'deviceSessionOpen',
       connectId: 'connect-id',
       retryCount: 1,
@@ -1190,6 +1260,8 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(device.features?.mode).toBe('bootloader');
     expect(device.features?.bootloaderMode).toBe(true);
+    expect(device.features?.initialized).toBeNull();
+    expect(device.features?.unlocked).toBeNull();
     expect(device.features?.raw?.protocolV2DeviceStatus).toBeUndefined();
   });
 
@@ -1281,6 +1353,40 @@ describe('Protocol V2 feature adapter', () => {
     expect(getFeatures).not.toHaveBeenCalled();
   });
 
+  test('uses the Pro2 standard wallet without passphraseState when passphrase is disabled', async () => {
+    const features = {
+      deviceId: 'pro2-device-id',
+      deviceType: 'pro2',
+      firmwareVersion: '9.9.9',
+      passphraseProtection: false,
+      unlocked: true,
+    };
+    const typedCall = jest.fn();
+    const updateInternalState = jest.fn();
+    const method = new GetPassphraseState({
+      payload: {
+        method: 'getPassphraseState',
+        connectId: 'connect-id',
+      },
+    });
+    method.device = stubDevice({
+      originalDescriptor: { ...descriptor, protocolType: 'V2' },
+      features,
+      commands: {
+        typedCall,
+        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'mock-hidden-wallet' }),
+      },
+      updateInternalState,
+      getCurrentDeviceType: () => 'pro2',
+      getCurrentDeviceId: () => 'pro2-device-id',
+      getCurrentPassphraseProtection: () => false,
+    }) as any;
+
+    await expect(method.run()).resolves.toBeUndefined();
+    expect(typedCall).not.toHaveBeenCalled();
+    expect(updateInternalState).not.toHaveBeenCalled();
+  });
+
   test('honors initSession when getting Pro2 passphrase state', async () => {
     const features = {
       deviceId: 'pro2-device-id',
@@ -1378,9 +1484,13 @@ describe('Protocol V2 feature adapter', () => {
         hw: { serial_no: 'PR2SERIAL' },
       }
     );
-    (device as any).features.firmwareVersion = '4.15.0';
-    (device as any).features.passphraseProtection = true;
-    (device as any).features.unlocked = true;
+    device.updateState(
+      {
+        versions: { firmware: '4.15.0' },
+        status: { passphraseProtection: true, unlocked: true },
+      },
+      'compatibility'
+    );
     (device as any).commands = {
       typedCall,
       promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-auto-secret' }),
@@ -1541,6 +1651,8 @@ describe('Protocol V2 feature adapter', () => {
       uuid: 'CACHED-SERIAL',
       deviceId: null,
       bleName: 'Cached BLE',
+      name: 'Cached BLE',
+      displayName: 'Cached Label',
       label: 'Cached Label',
       deviceType: 'pro2',
     });
@@ -1569,22 +1681,13 @@ 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' },
-          },
-        })
-        .mockResolvedValueOnce({
-          type: 'DeviceStatus',
-          message: {
-            device_id: 'PRO2-STATUS-ID',
-            init_states: true,
-            passphrase_enabled: true,
-          },
-        }),
+      typedCall: jest.fn().mockResolvedValueOnce({
+        type: 'DeviceInfo',
+        message: {
+          hw: { serial_no: 'PR2SERIAL' },
+          fw: { application: { version: '1.2.3' } },
+        },
+      }),
     };
 
     const features = await requestProtocolV2Features({
@@ -1592,12 +1695,12 @@ describe('Protocol V2 feature adapter', () => {
       descriptor: descriptor as any,
     });
 
-    expect(features.deviceId).toBe('PRO2-STATUS-ID');
-    expect(features.initialized).toBe(true);
+    expect(features.deviceId).toBeNull();
+    expect(features.initialized).toBeNull();
     expect(features.passphraseProtection).toBeNull();
-    expect(commands.typedCall).toHaveBeenCalledTimes(2);
-    expect(commands.typedCall).toHaveBeenNthCalledWith(
-      1,
+    expect(features.bootloaderMode).toBe(false);
+    expect(commands.typedCall).toHaveBeenCalledTimes(1);
+    expect(commands.typedCall).toHaveBeenCalledWith(
       'DeviceInfoGet',
       'DeviceInfo',
       {
@@ -1613,7 +1716,6 @@ 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 () => {
@@ -1629,266 +1731,6 @@ describe('Protocol V2 feature adapter', () => {
     ).rejects.toThrow('DeviceInfo not supported');
   });
 
-  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',
-            },
-          },
-          coprocessor: {
-            application: {
-              version: '8.9.10',
-            },
-            bt_adv_name: 'Raw Pro2 BLE',
-          },
-        },
-      })
-      .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: {
-        method: 'getDeviceInfo',
-        scope: 'basic',
-        refresh: true,
-      },
-    });
-    method.init();
-    (method as any).device = stubDevice({
-      originalDescriptor: { ...descriptor, protocolType: 'V2' },
-      features: {
-        ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-        device_id: 'CACHED-ID',
-        serial_no: 'CACHED-SERIAL',
-        label: 'Cached Pro2',
-        onekey_firmware_version: '1.2.3',
-        onekey_ble_version: '2.3.4',
-      },
-      commands: { typedCall },
-      _updateFeatures: jest.fn(),
-    });
-
-    const result = await method.run();
-
-    expect(typedCall).toHaveBeenCalledWith(
-      'DeviceInfoGet',
-      'DeviceInfo',
-      {
-        targets: {
-          hw: true,
-          fw: true,
-          coprocessor: true,
-        },
-        types: {
-          version: true,
-          specific: true,
-        },
-      },
-      { timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS }
-    );
-    expect(result).toMatchObject({
-      protocol: 'V2',
-      deviceType: 'pro2',
-      deviceId: 'PRO2-BASIC-ID',
-      serialNo: 'PR2SERIAL',
-      label: null,
-      bleName: 'Raw Pro2 BLE',
-      status: {
-        initialized: true,
-        unlockedAttachPin: true,
-        passphraseProtection: true,
-      },
-      versions: {
-        firmware: '5.6.7',
-        ble: '8.9.10',
-      },
-    });
-  });
-
-  test('does not fill Protocol V2 DeviceProfile from cached V1-shaped fields', async () => {
-    const typedCall = jest.fn().mockResolvedValueOnce({
-      type: 'DeviceInfo',
-      message: {
-        status: {
-          init_states: true,
-        },
-      },
-    });
-    const method = new GetDeviceInfo({
-      id: 1,
-      payload: {
-        method: 'getDeviceInfo',
-        scope: 'basic',
-      },
-    });
-    method.init();
-    (method as any).device = stubDevice({
-      originalDescriptor: { ...descriptor, protocolType: 'V2' },
-      features: {
-        ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-        device_id: 'STALE-ID',
-        serial_no: 'STALE-SERIAL',
-        label: 'Stale Pro2',
-        ble_name: 'Stale BLE',
-        passphrase_protection: true,
-        onekey_firmware_version: '1.2.3',
-        onekey_ble_version: '2.3.4',
-      },
-      commands: { typedCall },
-    });
-
-    const result = await method.run();
-
-    expect(result).toMatchObject({
-      protocol: 'V2',
-      // 身份字段不得取自缓存的 V1-shaped features（STALE-ID / STALE-SERIAL），
-      // hw.serial_no 缺失时也不回退 descriptor.path。
-      deviceId: '',
-      serialNo: '',
-      label: null,
-      bleName: null,
-      status: {
-        passphraseProtection: null,
-        noBackup: null,
-      },
-      versions: {
-        firmware: null,
-        ble: null,
-      },
-    });
-  });
-
-  test('reads full Protocol V2 device info only for verify scope', async () => {
-    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: {
-        method: 'getDeviceInfo',
-        scope: 'verify',
-      },
-    });
-    method.init();
-    (method as any).device = stubDevice({
-      originalDescriptor: { ...descriptor, protocolType: 'V2' },
-      features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-      commands: { typedCall },
-      _updateFeatures: jest.fn(),
-    });
-
-    await method.run();
-
-    expect(typedCall).toHaveBeenCalledWith(
-      'DeviceInfoGet',
-      'DeviceInfo',
-      {
-        targets: {
-          hw: true,
-          fw: true,
-          coprocessor: true,
-          se1: true,
-          se2: true,
-          se3: true,
-          se4: true,
-        },
-        types: {
-          version: true,
-          build_id: true,
-          hash: true,
-          specific: true,
-        },
-      },
-      { timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS }
-    );
-  });
-
-  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' },
-          },
-        },
-      })
-      .mockResolvedValueOnce({
-        type: 'DeviceStatus',
-        message: { init_states: true },
-      });
-    const method = new GetDeviceInfo({
-      id: 1,
-      payload: {
-        method: 'getDeviceInfo',
-        scope: 'versions',
-      },
-    });
-    method.init();
-    (method as any).device = stubDevice({
-      originalDescriptor: { ...descriptor, protocolType: 'V2' },
-      features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-      commands: { typedCall },
-    });
-
-    const result = await method.run();
-
-    expect(typedCall).toHaveBeenCalledWith(
-      'DeviceInfoGet',
-      'DeviceInfo',
-      {
-        targets: {
-          hw: true,
-          fw: true,
-          coprocessor: true,
-          se1: true,
-          se2: true,
-          se3: true,
-          se4: true,
-        },
-        types: {
-          version: true,
-          specific: true,
-        },
-      },
-      { timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS }
-    );
-    expect(result.versions).toMatchObject({
-      se01: '1.0.1',
-      se01Boot: '1.0.0',
-      se02: '2.0.1',
-      se02Boot: '2.0.0',
-    });
-    expect(result).not.toHaveProperty('verify');
-  });
-
   test('does not inherit Pro or Pro model fallback ranges for Protocol V2 devices', () => {
     const features = normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any);
     const checkedTypes: string[] = [];
@@ -2007,68 +1849,38 @@ describe('Protocol V2 feature adapter', () => {
     });
   });
 
-  test('does not call V1 OnekeyGetFeatures for Protocol V2 devices', async () => {
+  test('rejects legacy getOnekeyFeatures for Protocol V2 devices', async () => {
     const method = new GetOnekeyFeatures({
       id: 1,
       payload: {
         method: 'getOnekeyFeatures',
       },
     });
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceInfo',
-      message: {
-        protocol_version: 1,
-        hw: { serial_no: 'PR2SERIAL' },
-        fw: { application: { version: '1.2.3', build_id: 'app-build' } },
-        coprocessor: { bt_adv_name: 'Pro2 BLE' },
-        status: { init_states: true },
-      },
-    });
+    const typedCall = jest.fn();
 
     (method as any).device = stubDevice({
       originalDescriptor: { protocolType: 'V2' },
       commands: { typedCall },
     });
 
-    const message = await method.run();
-
-    // V2 走 DeviceInfoGet 完整请求（含 SE 与 hash/build_id），而不是 V1 OnekeyGetFeatures
-    expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledWith(
-      'DeviceInfoGet',
-      'DeviceInfo',
-      expect.objectContaining({
-        targets: expect.objectContaining({ se1: true, se2: true, se3: true, se4: true }),
-        types: expect.objectContaining({ build_id: true, hash: true }),
-      }),
-      expect.anything()
-    );
-    expect(message).toEqual({ onekey_device_type: 'PRO2' });
-    expect(message).not.toHaveProperty('label');
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: expect.any(Number),
+    });
+    expect(typedCall).not.toHaveBeenCalled();
   });
 
-  test('reuses cached Protocol V2 features on later runs without polling device status', async () => {
+  test('initializes and reuses Protocol V2 features from DeviceInfo only', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
     } as any);
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({
-        type: 'DeviceInfo',
-        message: {
-          hw: { serial_no: 'PR2SERIAL' },
-          fw: { application: { version: '1.2.3' } },
-        },
-      })
-      .mockResolvedValueOnce({
-        type: 'DeviceStatus',
-        message: {
-          device_id: 'PRO2-REFRESH-ID',
-          unlocked: true,
-          passphrase_enabled: true,
-        },
-      });
+    const typedCall = jest.fn().mockResolvedValueOnce({
+      type: 'DeviceInfo',
+      message: {
+        hw: { serial_no: 'PR2SERIAL' },
+        fw: { application: { version: '1.2.3' } },
+      },
+    });
 
     (device as any).commands = { typedCall };
 
@@ -2076,18 +1888,17 @@ describe('Protocol V2 feature adapter', () => {
     await device.initialize();
 
     expect(device.features).toMatchObject({
-      deviceId: 'PRO2-REFRESH-ID',
+      deviceId: null,
       firmwareVersion: '1.2.3',
-      passphraseProtection: true,
+      passphraseProtection: null,
       label: null,
     });
     expect((device as any).profile).toBeUndefined();
-    expect(device.features?.passphraseProtection).toBe(true);
+    expect(device.features?.passphraseProtection).toBeNull();
     expect(device.features?.label).toBeNull();
     expect(device.features?.firmwareVersion).toBe('1.2.3');
-    expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenNthCalledWith(
-      1,
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
       'DeviceInfoGet',
       'DeviceInfo',
       {
@@ -2105,10 +1916,9 @@ 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 () => {
+  test('recognizes bootloader DeviceInfo without requesting device status', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
@@ -2119,23 +1929,124 @@ describe('Protocol V2 feature adapter', () => {
         type: 'DeviceInfo',
         message: {
           hw: { serial_no: 'PR2SERIAL' },
-          fw: { application: { version: '1.2.3' } },
+          fw: { bootloader: { version: '0.2.0' } },
         },
       })
       .mockResolvedValueOnce({
         type: 'DeviceStatus',
-        message: { init_states: true },
-      })
+        message: {
+          device_id: 'UNEXPECTED-SEPARATE-STATUS',
+        },
+      });
+
+    (device as any).commands = { typedCall };
+
+    await device.initialize();
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
+      'DeviceInfoGet',
+      'DeviceInfo',
+      expect.not.objectContaining({
+        targets: expect.objectContaining({ status: true }),
+      }),
+      expect.anything()
+    );
+    expect(device.features).toMatchObject({
+      deviceId: null,
+      bootloaderMode: true,
+      initialized: null,
+    });
+  });
+
+  test('does not probe DeviceStatusGet while firmware device is still in bootloader mode', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn().mockImplementation((request: string) => {
+      if (request === 'DeviceStatusGet') {
+        throw new Error('bootloader must not receive DeviceStatusGet');
+      }
+      return Promise.resolve({
+        type: 'DeviceInfo',
+        message: {
+          hw: { serial_no: 'PR2BOOT' },
+          fw: { bootloader: { version: '0.2.0' } },
+          se1: {},
+        },
+      });
+    });
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      updateProtocolV2Features: jest.fn(),
+    });
+
+    await expect((method as any).probeProtocolV2NormalMode()).resolves.toBe(false);
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
+      'DeviceInfoGet',
+      'DeviceInfo',
+      expect.not.objectContaining({
+        targets: expect.objectContaining({ status: true }),
+      }),
+      expect.anything()
+    );
+  });
+
+  test('does not probe DeviceStatusGet while firmware device is still in romloader mode', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn().mockImplementation((request: string) => {
+      if (request === 'DeviceStatusGet') {
+        throw new Error('romloader must not receive DeviceStatusGet');
+      }
+      return Promise.resolve({
+        type: 'DeviceInfo',
+        message: {
+          hw: { serial_no: 'PR2ROM' },
+          fw: {
+            romloader: { version: '0.1.0' },
+            bootloader: { version: '0.2.0' },
+          },
+        },
+      });
+    });
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+      updateProtocolV2Features: jest.fn(),
+    });
+
+    await expect((method as any).probeProtocolV2NormalMode()).resolves.toBe(false);
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test('refreshes Protocol V2 features without falling back to V1 GetFeatures', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest
+      .fn()
       .mockResolvedValueOnce({
         type: 'DeviceInfo',
         message: {
           hw: { serial_no: 'PR2SERIAL' },
-          fw: { application: { version: '1.2.4' } },
+          fw: { application: { version: '1.2.3' } },
         },
       })
       .mockResolvedValueOnce({
-        type: 'DeviceStatus',
-        message: { init_states: true, unlocked: true, passphrase_enabled: true },
+        type: 'DeviceInfo',
+        message: {
+          hw: { serial_no: 'PR2SERIAL' },
+          fw: { application: { version: '1.2.4' } },
+        },
       });
 
     (device as any).commands = { typedCall };
@@ -2146,17 +2057,17 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.features).toMatchObject({
       deviceId: null,
       firmwareVersion: '1.2.4',
-      passphraseProtection: true,
+      passphraseProtection: null,
     });
     expect(features).toMatchObject({
       deviceType: 'pro2',
       serialNo: 'PR2SERIAL',
       firmwareVersion: '1.2.4',
-      passphraseProtection: true,
+      passphraseProtection: null,
     });
-    expect(typedCall).toHaveBeenCalledTimes(4);
+    expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenNthCalledWith(
-      3,
+      2,
       'DeviceInfoGet',
       'DeviceInfo',
       {
@@ -2231,16 +2142,6 @@ describe('Protocol V2 feature adapter', () => {
           message: { message: 'ok' },
         };
       }
-      if (requestType === 'DeviceStatusGet') {
-        return {
-          type: 'DeviceStatus',
-          message: {
-            unlocked: true,
-            unlocked_by_attach_to_pin: true,
-            passphrase_enabled: true,
-          },
-        };
-      }
       throw new Error(`Unexpected request: ${requestType}`);
     });
 
@@ -2260,7 +2161,6 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(typedCall.mock.calls).toEqual([
       ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
-      ['DeviceStatusGet', 'DeviceStatus', {}],
     ]);
     expect(typedCall).not.toHaveBeenCalledWith('GetAddress', 'Address', expect.anything());
     expect(typedCall).not.toHaveBeenCalledWith('GetFeatures', 'Features', {});
@@ -2268,17 +2168,10 @@ describe('Protocol V2 feature adapter', () => {
       deviceType: 'pro2',
       firmwareVersion: '1.2.3',
       unlocked: true,
-      unlockedAttachPin: true,
-      passphraseProtection: true,
-    });
-    expect(features.raw?.protocolV2DeviceStatus).toMatchObject({
-      unlocked: true,
-      unlocked_by_attach_to_pin: true,
-      passphrase_enabled: true,
     });
   });
 
-  test('syncs Protocol V2 features passphrase state from DeviceStatus after unlock', async () => {
+  test('preserves cached Protocol V2 passphrase state without polling status after unlock', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
@@ -2295,16 +2188,6 @@ describe('Protocol V2 feature adapter', () => {
           message: { message: 'ok' },
         };
       }
-      if (requestType === 'DeviceStatusGet') {
-        return {
-          type: 'DeviceStatus',
-          message: {
-            unlocked: true,
-            unlocked_by_attach_to_pin: true,
-            passphrase_enabled: true,
-          },
-        };
-      }
       throw new Error(`Unexpected request: ${requestType}`);
     });
     (device as any).commands = { typedCall };
@@ -2313,12 +2196,11 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(typedCall.mock.calls).toEqual([
       ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
-      ['DeviceStatusGet', 'DeviceStatus', {}],
     ]);
     expect((device as any).profile).toBeUndefined();
     expect(device.features?.unlocked).toBe(true);
-    expect(device.features?.passphraseProtection).toBe(true);
-    expect(device.features?.unlockedAttachPin).toBe(true);
+    expect(device.features?.passphraseProtection).toBeNull();
+    expect(device.features?.unlockedAttachPin).toBeUndefined();
   });
 
   test('maps unsupported Protocol V2 DeviceSessionAskPin to DeviceNotSupportMethod', async () => {
@@ -2934,6 +2816,29 @@ describe('Protocol V2 firmware update targets', () => {
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
   });
 
+  test('keeps Protocol V2 romloader active before firmware transfer', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'romloader-path', protocolType: 'V2' },
+      features: { mode: 'romloader', bootloaderMode: false, capabilities: [] },
+      isBootloader: () => false,
+    });
+    (method as any).protocolV2Reboot = jest
+      .fn()
+      .mockRejectedValue(new Error('romloader rejected Bootloader reboot type'));
+    method.postTipMessage = jest.fn();
+
+    await expect((method as any).enterProtocolV2BootloaderMode()).resolves.toBe(false);
+
+    expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
+    expect(method.postTipMessage).not.toHaveBeenCalledWith('AutoRebootToBootloader');
+  });
+
   test('polls until Protocol V2 bootloader descriptor is ready after reboot', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -3147,7 +3052,10 @@ describe('Protocol V2 firmware update targets', () => {
       if (name === 'DeviceInfoGet') {
         return Promise.resolve({
           type: 'DeviceInfo',
-          message: { hw: { serial_no: 'PR9999999999' } },
+          message: {
+            hw: { serial_no: 'PR9999999999' },
+            fw: { application: { version: '9.9.9' } },
+          },
         });
       }
       return Promise.reject(new Error(`unexpected call ${name}`));
@@ -3172,9 +3080,10 @@ describe('Protocol V2 firmware update targets', () => {
 
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(2);
     expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-      'DeviceStatusGet',
+      'DeviceInfoGet',
       'DeviceStatusGet',
       'DeviceInfoGet',
+      'DeviceStatusGet',
     ]);
   });
 
@@ -3199,7 +3108,10 @@ describe('Protocol V2 firmware update targets', () => {
       if (name === 'DeviceInfoGet') {
         return Promise.resolve({
           type: 'DeviceInfo',
-          message: { hw: { serial_no: 'PR9999999999' } },
+          message: {
+            hw: { serial_no: 'PR9999999999' },
+            fw: { application: { version: '9.9.9' } },
+          },
         });
       }
       return Promise.reject(new Error(`unexpected call ${name}`));
@@ -3224,9 +3136,10 @@ describe('Protocol V2 firmware update targets', () => {
 
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(2);
     expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-      'DeviceStatusGet',
+      'DeviceInfoGet',
       'DeviceStatusGet',
       'DeviceInfoGet',
+      'DeviceStatusGet',
     ]);
   });
 
@@ -3299,7 +3212,7 @@ describe('Protocol V2 firmware update targets', () => {
       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.mock.calls.map(call => call[0])).toEqual(['DeviceInfoGet', 'DeviceStatusGet']);
     expect(typedCall).not.toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
       expect.anything(),
@@ -4510,13 +4423,15 @@ describe('Protocol V2 reboot methods', () => {
       },
     });
     method.init();
-    (method as any).device = stubDevice({ commands: { typedCall } });
+    const device = stubDevice({ commands: { typedCall } });
+    (method as any).device = device;
 
     await method.run();
 
     expect(typedCall).toHaveBeenCalledWith('DeviceReboot', 'Success', {
       reboot_type: 2,
     });
+    expect(device.markProtocolV2Reboot).toHaveBeenCalledWith(DeviceRebootType.Bootloader);
   });
 });
 
@@ -4557,6 +4472,20 @@ describe('Protocol V2 protected method execution', () => {
     expect(method.unlockPolicy).toBe('none');
   });
 
+  test.each([
+    ['deviceInfoGet', DeviceInfoGet],
+    ['deviceStatusGet', DeviceStatusGet],
+    ['deviceSettingsGet', DeviceSettingsGet],
+  ])('does not auto-unlock the read-only %s 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 = {
@@ -5045,9 +4974,19 @@ describe('Protocol V2 current low-level methods', () => {
     });
   });
 
-  test('marks Protocol V2 settings methods for unlock-on-locked retry', () => {
+  test('does not unlock before reading Protocol V2 device settings', () => {
+    const method = new DeviceSettingsGet({
+      id: 1,
+      payload: { method: 'deviceSettingsGet' },
+    });
+
+    method.init();
+
+    expect(method.unlockPolicy).toBe('none');
+  });
+
+  test('marks Protocol V2 settings mutations for unlock-on-locked retry', () => {
     const methods = [
-      new DeviceSettingsGet({ id: 1, payload: { method: 'deviceSettingsGet' } }),
       new DeviceSettingsSet({
         id: 2,
         payload: { method: 'deviceSettingsSet', settings: { brightness: 80 } },
@@ -5139,6 +5078,12 @@ describe('Protocol V2 raw device info method', () => {
   });
 
   test('rejects removed target/type names before transport call', () => {
+    expect(() =>
+      buildMethod({
+        targets: { hw: true, status: true },
+      })
+    ).toThrow('targets');
+
     expect(() =>
       buildMethod({
         targets: { hw: true, bt: true },