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

package/__tests__/protocol-v2.test.ts

@@ -61,14 +61,19 @@ import { createCoreApi } from '../src/inject';
 import { Device, preloadSessionCache } from '../src/device/Device';
 import { deviceWalletSessionStore } from '../src/device/DeviceWalletSessionStore';
 import { DevicePool } from '../src/device/DevicePool';
+import { DEVICE } from '../src/events';
 import { UI_REQUEST } from '../src/events/ui-request';
 import {
   PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
+  PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE,
   type ProtocolV2DeviceInfo,
   type ProtocolV2RuntimeMode,
   getProtocolV2RuntimeMode,
+  parseProtocolV2BuildFingerprint,
   requestProtocolV2DeviceInfo,
   requestProtocolV2DeviceStatus,
+  requestProtocolV2ProtocolInfo,
+  supportsProtocolV2Message,
 } from '../src/protocols/protocol-v2/features';
 import {
   getProtocolV2WalletSession,
@@ -95,7 +100,7 @@ import {
 
 import type { DeviceCommands } from '../src/device/DeviceCommands';
 import type { Features } from '../src/types';
-import type { DeviceStatus } from '@onekeyfe/hd-transport';
+import type { DeviceStatus, ProtocolInfo } from '@onekeyfe/hd-transport';
 
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
@@ -143,7 +148,7 @@ describe('DeviceUploadWallpaper', () => {
     const result = await method.run();
 
     expect(method.getSupportedProtocols()).toEqual(['V2']);
-    expect(method.unlockPolicy).toBe('unlock-before-run');
+    expect(method.unlockPolicy).toBe('none');
     expect(typedCall).toHaveBeenNthCalledWith(1, 'FilesystemDirMake', 'Success', {
       path: 'vol1:/wallpapers',
     });
@@ -347,6 +352,24 @@ const descriptor = {
   path: 'usb-path',
 };
 
+const protocolV2ApplicationInfo = {
+  version: 1,
+  build_fingerprint: 'application__1.2.3__abcdef0__PROD__RELEASE',
+  supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
+};
+
+const protocolV2BootloaderInfo = {
+  version: 1,
+  build_fingerprint: 'bootloader__0.2.0__abcdef0__PROD__RELEASE',
+  supported_messages: [],
+};
+
+const protocolV2RomloaderInfo = {
+  version: 1,
+  build_fingerprint: 'romloader__1.0.0__abcdef0__PROD__RELEASE',
+  supported_messages: [],
+};
+
 /**
  * Add Device protocol and getCurrent* accessors to plain-object stubs.
  * Defaults match Device.ts and never replace an existing member such as jest.fn().
@@ -356,6 +379,8 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
   d.updateState ??= jest.fn();
   d.markProtocolV2Reboot ??= jest.fn();
   d.isProtocolV2 ??= () => d.originalDescriptor?.protocolType === 'V2';
+  d.isBootloader ??= () => d.features?.mode === 'bootloader';
+  d.isRomloader ??= () => d.features?.mode === 'romloader';
   d.getProtocol ??= () => (d.isProtocolV2() ? 'V2' : 'V1');
   d.getCurrentDeviceType ??= () => getDeviceType(d.features);
   d.getCurrentFirmwareType ??= () => getFirmwareType(d.features);
@@ -375,7 +400,8 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
   d.updateProtocolV2Features ??= (
     deviceInfo?: ProtocolV2DeviceInfo,
     deviceStatus?: DeviceStatus,
-    runtimeMode?: ProtocolV2RuntimeMode
+    runtimeMode?: ProtocolV2RuntimeMode,
+    protocolInfo?: ProtocolInfo
   ) => {
     d.features = buildProtocolV2FeaturesPayload({
       deviceInfo,
@@ -383,44 +409,37 @@ function stubDevice<T extends Record<string, any>>(device: T): T {
       previous: d.features,
       runtimeMode: runtimeMode ?? (deviceStatus ? 'normal' : undefined),
     });
+    if (protocolInfo) {
+      d.features.raw = {
+        ...d.features.raw,
+        protocolV2ProtocolInfo: protocolInfo,
+      };
+    }
     return d.features;
   };
+  d.ensureProtocolV2RuntimeContext ??= (timeoutMs?: number) =>
+    requestProtocolV2ProtocolInfo({
+      commands: d.getCommands?.() ?? d.commands,
+      timeoutMs,
+    });
   d.probeProtocolV2RuntimeState ??= async (
     deviceInfo: ProtocolV2DeviceInfo,
     timeoutMs?: number
   ) => {
-    try {
-      const response = await d
-        .getCommands()
-        .typedCall(
-          'DeviceStatusGet',
-          'DeviceStatus',
-          {},
-          timeoutMs === undefined ? undefined : { timeoutMs }
-        );
-      const features = d.updateProtocolV2Features(deviceInfo, response.message, 'normal');
-      return (
-        features ??
-        buildProtocolV2FeaturesPayload({
-          deviceInfo,
-          deviceStatus: response.message,
-          previous: d.features,
-          runtimeMode: 'normal',
-        })
-      );
-    } catch {
-      const runtimeMode = getProtocolV2RuntimeMode({
-        deviceInfo,
-        deviceStatusAvailable: false,
-      });
-      const features = d.updateProtocolV2Features(deviceInfo, null, runtimeMode);
-      if (features?.mode === runtimeMode) return features;
-      return buildProtocolV2FeaturesPayload({
-        deviceInfo,
-        previous: d.features,
-        runtimeMode,
-      });
+    const protocolInfo = await d.ensureProtocolV2RuntimeContext(timeoutMs);
+    const runtimeMode = getProtocolV2RuntimeMode(protocolInfo);
+    if (runtimeMode === 'bootloader' || runtimeMode === 'romloader') {
+      return d.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
+    }
+    if (!supportsProtocolV2Message(protocolInfo, PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE)) {
+      if (!runtimeMode) throw new Error('Unknown Protocol V2 runtime mode');
+      return d.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
     }
+    const deviceStatus = await requestProtocolV2DeviceStatus({
+      commands: d.getCommands(),
+      timeoutMs,
+    });
+    return d.updateProtocolV2Features(deviceInfo, deviceStatus, 'normal', protocolInfo);
   };
   d.updateProtocolV2Status ??= (deviceStatus: DeviceStatus) => {
     d.features = buildProtocolV2FeaturesPayload({
@@ -680,7 +699,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(features.bleEnabled).toBeNull();
   });
 
-  test('marks Protocol V2 DeviceInfo as bootloader when DeviceStatusGet fails', () => {
+  test('parses bootloader runtime mode from ProtocolInfo build fingerprint', () => {
     const deviceInfo = {
       protocol_version: 1,
       hw: {
@@ -693,10 +712,7 @@ describe('Protocol V2 feature adapter', () => {
       },
       se1: {},
     };
-    const runtimeMode = getProtocolV2RuntimeMode({
-      deviceInfo: deviceInfo as ProtocolV2DeviceInfo,
-      deviceStatusAvailable: false,
-    });
+    const runtimeMode = getProtocolV2RuntimeMode(protocolV2BootloaderInfo);
     const features = normalizeProtocolV2Features(
       descriptor as any,
       deviceInfo as ProtocolV2DeviceInfo,
@@ -718,7 +734,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(features.bootloaderMode).toBe(false);
   });
 
-  test('temporarily treats romloader metadata as bootloader when DeviceStatusGet fails', () => {
+  test('keeps romloader distinct from bootloader using ProtocolInfo build fingerprint', () => {
     const deviceInfo = {
       protocol_version: 1,
       hw: {
@@ -733,20 +749,28 @@ describe('Protocol V2 feature adapter', () => {
         },
       },
     };
-    const runtimeMode = getProtocolV2RuntimeMode({
-      deviceInfo: deviceInfo as ProtocolV2DeviceInfo,
-      deviceStatusAvailable: false,
-    });
+    const runtimeMode = getProtocolV2RuntimeMode(protocolV2RomloaderInfo);
     const features = normalizeProtocolV2Features(
       descriptor as any,
       deviceInfo as ProtocolV2DeviceInfo,
       runtimeMode
     );
-    expect(features.mode).toBe('bootloader');
+    expect(features.mode).toBe('romloader');
     expect(features.bootloaderMode).toBe(true);
     expect(features.boardVersion).toBe('1.0.0');
   });
 
+  test('rejects malformed Protocol V2 build fingerprints', () => {
+    expect(parseProtocolV2BuildFingerprint('application__1.2.3')).toBeNull();
+    expect(
+      getProtocolV2RuntimeMode({
+        version: 1,
+        build_fingerprint: 'unknown__1.2.3__abcdef0__PROD__RELEASE',
+        supported_messages: [],
+      })
+    ).toBeUndefined();
+  });
+
   test('keeps the Protocol V2 main wallet on the default empty-passphrase context', async () => {
     const features = normalizeProtocolV2Features(descriptor as any);
     features.firmwareVersion = '1.2.3';
@@ -783,7 +807,7 @@ describe('Protocol V2 feature adapter', () => {
     ).resolves.toEqual({
       passphraseState: 'state-1',
       newSession: 'session-1',
-      unlockedAttachPin: undefined,
+      unlockedAttachPin: false,
       resumed: false,
     });
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
@@ -844,6 +868,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'standard-session',
+      btc_test_address: 'standard-state',
     });
     expect(deviceWalletSessionStore.getStandard(deviceId)).toEqual({
       passphraseState: 'standard-state',
@@ -908,7 +933,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(deviceWalletSessionStore.get(deviceId, 'hidden-state')).toBe('hidden-session');
   });
 
-  test('opens Main PIN directly instead of resuming a standard session while locked', async () => {
+  test('propagates DeviceLocked instead of retrying a cached standard session', async () => {
     const deviceId = 'standard-locked-device';
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = normalizeProtocolV2Features(
@@ -950,14 +975,11 @@ describe('Protocol V2 feature adapter', () => {
     });
     (device as any).commands = { typedCall };
 
-    await expect(getProtocolV2WalletSession(device, { onlyMainPin: true })).resolves.toMatchObject({
-      newSession: 'cached-standard-session',
-      resumed: true,
+    await expect(getProtocolV2WalletSession(device, { onlyMainPin: true })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceLocked,
     });
-    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet')).toHaveLength(2);
-    expect(deviceWalletSessionStore.getStandard(deviceId)?.sessionId).toBe(
-      'cached-standard-session'
-    );
+    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet')).toHaveLength(1);
+    expect(deviceWalletSessionStore.getStandard(deviceId)).toBeUndefined();
   });
 
   test('recovers a mismatched cached standard wallet without deleting hidden sessions', async () => {
@@ -1083,7 +1105,7 @@ describe('Protocol V2 feature adapter', () => {
     });
   });
 
-  test('uses refreshed passphrase status after unlocking before selecting a Protocol V2 wallet', async () => {
+  test('does not implicitly unlock inside the Protocol V2 wallet-session coordinator', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
@@ -1094,13 +1116,9 @@ describe('Protocol V2 feature adapter', () => {
         },
       }
     );
-    const lockedError = Object.assign(new Error('Device is locked'), {
-      errorCode: HardwareErrorCode.DeviceLocked,
-    });
     const typedCall = createWalletSessionTypedCall(
       jest
         .fn()
-        .mockRejectedValueOnce(lockedError)
         .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
         .mockResolvedValueOnce({
           message: {
@@ -1127,7 +1145,7 @@ describe('Protocol V2 feature adapter', () => {
       resumed: false,
     });
 
-    expect(unlockDevice).toHaveBeenCalledTimes(1);
+    expect(unlockDevice).not.toHaveBeenCalled();
     expect(promptPassphrase).toHaveBeenCalled();
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
@@ -1199,7 +1217,7 @@ describe('Protocol V2 feature adapter', () => {
         throw new Error(`Unexpected request: ${request}`);
       })
     );
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(getProtocolV2WalletSession(device)).resolves.toMatchObject({
@@ -1209,7 +1227,8 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(promptPassphrase).toHaveBeenCalled();
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
-      on_device: true,
+      passphrase: 'host hidden wallet',
+      on_device: false,
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
@@ -1240,7 +1259,7 @@ describe('Protocol V2 feature adapter', () => {
 
   test('deviceGetOnboardingStatus returns the current Protocol V2 onboarding status', async () => {
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'DevOnboardingStatus',
+      type: 'OnboardingStatus',
       message: {
         step: 4,
         phase: 4,
@@ -1268,7 +1287,7 @@ describe('Protocol V2 feature adapter', () => {
       pin_set: true,
       wallet_initialized: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DevGetOnboardingStatus', 'DevOnboardingStatus', {});
+    expect(typedCall).toHaveBeenCalledWith('OnboardingStatusGet', 'OnboardingStatus', {});
     expect(method.getSupportedProtocols()).toEqual(['V2']);
   });
 
@@ -1319,6 +1338,7 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'session-a',
+      btc_test_address: 'state-a',
     });
     expect(device.getInternalState()).toBe('session-b');
   });
@@ -1386,7 +1406,11 @@ describe('Protocol V2 feature adapter', () => {
     });
     expect(typedCall.mock.calls).toEqual([
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
-      ['DeviceSessionGet', 'DeviceSession', { session_id: 'session-a' }],
+      [
+        'DeviceSessionGet',
+        'DeviceSession',
+        { session_id: 'session-a', btc_test_address: 'state-a' },
+      ],
     ]);
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.getInternalState()).toBeUndefined();
@@ -1420,7 +1444,7 @@ describe('Protocol V2 feature adapter', () => {
     );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
 
     await expect(getProtocolV2WalletSession(device)).rejects.toMatchObject({
@@ -1428,7 +1452,11 @@ describe('Protocol V2 feature adapter', () => {
     });
     expect(typedCall.mock.calls).toEqual([
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
-      ['DeviceSessionAskPassphrase', 'Success', { on_device: true }],
+      [
+        'DeviceSessionAskPassphrase',
+        'Success',
+        { passphrase: 'host hidden wallet', on_device: false },
+      ],
       ['DeviceStatusGet', 'DeviceStatus', {}],
       ['DeviceSessionGet', 'DeviceSession', {}],
     ]);
@@ -1469,7 +1497,7 @@ describe('Protocol V2 feature adapter', () => {
         throw new Error(`Unexpected request: ${request}`);
       })
     );
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(
@@ -1522,7 +1550,7 @@ describe('Protocol V2 feature adapter', () => {
     );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
 
     await expect(
@@ -1533,6 +1561,72 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
   });
 
+  test.each([false, true])(
+    'rejects a different Attach PIN wallet when Pro2 lock failure is %s',
+    async lockFails => {
+      const deviceId = 'attach-mismatch-device';
+      const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+      (device as any).features = normalizeProtocolV2Features(
+        { ...descriptor, protocolType: 'V2' } as any,
+        {
+          status: {
+            device_id: deviceId,
+            unlocked: true,
+            passphrase_enabled: true,
+            attach_to_pin_enabled: true,
+            unlocked_by_attach_to_pin: false,
+          },
+        }
+      );
+      device.passphraseState = 'expected-state';
+
+      const typedCall = jest.fn((request: string) => {
+        if (request === 'ProtocolInfoRequest') return { message: { version: 2 } };
+        if (request === 'DeviceSessionAskPin') return { message: { message: 'PIN verified' } };
+        if (request === 'DeviceStatusGet') {
+          return {
+            message: {
+              device_id: deviceId,
+              unlocked: true,
+              passphrase_enabled: true,
+              attach_to_pin_enabled: true,
+              unlocked_by_attach_to_pin: true,
+            },
+          };
+        }
+        if (request === 'DeviceSessionGet') {
+          return {
+            message: {
+              btc_test_address: 'wrong-attach-state',
+              session_id: 'wrong-attach-session',
+            },
+          };
+        }
+        if (request === 'LockDevice') {
+          if (lockFails) throw new Error('Lock unsupported');
+          return { message: { message: 'Device locked' } };
+        }
+        throw new Error(`Unexpected request: ${request}`);
+      });
+      const promptPassphrase = jest.fn().mockResolvedValue({ attachPinOnDevice: true });
+      (device as any).commands = { typedCall, promptPassphrase };
+
+      await expect(
+        getProtocolV2WalletSession(device, { expectedPassphraseState: 'expected-state' })
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.DeviceCheckUnlockTypeError,
+      });
+
+      expect(promptPassphrase).not.toHaveBeenCalled();
+      expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+        btc_test_address: 'expected-state',
+      });
+      expect(typedCall).toHaveBeenCalledWith('LockDevice', 'Success', {});
+      expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet')).toHaveLength(1);
+      expect(device.getInternalState()).toBeUndefined();
+    }
+  );
+
   test('recovers an expired Attach PIN wallet through the unified wallet selector', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-attach-recovery',
@@ -1589,11 +1683,21 @@ describe('Protocol V2 feature adapter', () => {
       }),
       { cancelDeviceOnReject: false }
     );
-    expect(unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin);
+    expect(unlockDevice).toHaveBeenCalledWith(
+      DeviceSessionPinType.AttachToPin,
+      expect.objectContaining({
+        emitUiEvent: false,
+        interaction: expect.objectContaining({
+          phase: 'pin',
+          transition: 'start',
+          protocol: 'V2',
+        }),
+      })
+    );
     expect(device.getInternalState()).toBe('new-attach-session');
   });
 
-  test('unlocks and retries DeviceSessionAskPassphrase when wallet selection is locked', async () => {
+  test('propagates DeviceLocked without retrying DeviceSessionAskPassphrase', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-4',
       path: 'cache-path-4',
@@ -1620,16 +1724,61 @@ describe('Protocol V2 feature adapter', () => {
     );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
     const unlockDevice = jest.spyOn(device, 'unlockDevice').mockResolvedValue(undefined as any);
 
+    await expect(getProtocolV2WalletSession(device)).rejects.toBe(lockedError);
+    expect(unlockDevice).not.toHaveBeenCalled();
+    expect(
+      typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionAskPassphrase')
+    ).toHaveLength(1);
+  });
+
+  test('does not act on cached lock state inside the wallet-session coordinator', async () => {
+    const calls: string[] = [];
+    const device = Device.fromDescriptor({
+      id: 'cache-device-pre-unlock',
+      path: 'cache-path-pre-unlock',
+      protocolType: 'V2',
+    } as any);
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      { status: { device_id: 'stable-device-pre-unlock', unlocked: false } }
+    );
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn((request: string) => {
+        if (request === 'DeviceSessionAskPassphrase') {
+          calls.push('ask-passphrase');
+          return Promise.resolve({ message: { message: 'Passphrase prepared' } });
+        }
+        if (request === 'DeviceSessionGet') {
+          calls.push('get-session');
+          return Promise.resolve({
+            message: {
+              session_id: 'session-after-pre-unlock',
+              btc_test_address: 'state-after-pre-unlock',
+            },
+          });
+        }
+        throw new Error(`Unexpected request: ${request}`);
+      })
+    );
+    (device as any).commands = {
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+    };
+    const unlockDevice = jest.spyOn(device, 'unlockDevice');
+
     await expect(getProtocolV2WalletSession(device)).resolves.toMatchObject({
-      newSession: 'session-after-unlock',
-      passphraseState: 'state-after-unlock',
+      newSession: 'session-after-pre-unlock',
+      passphraseState: 'state-after-pre-unlock',
     });
-    expect(unlockDevice).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledTimes(5);
+    expect(unlockDevice).not.toHaveBeenCalled();
+    expect(
+      typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionAskPassphrase')
+    ).toHaveLength(1);
+    expect(calls).toEqual(['ask-passphrase', 'get-session']);
   });
 
   test('does not request a Pro2 wallet session before features are initialized', async () => {
@@ -1772,6 +1921,7 @@ describe('Protocol V2 feature adapter', () => {
     };
     const typedCall = jest
       .fn()
+      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
       .mockResolvedValueOnce({ message: { version: 2 } })
       .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
       .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
@@ -1784,7 +1934,7 @@ describe('Protocol V2 feature adapter', () => {
       });
     const updateInternalState = jest.fn();
     const getFeatures = jest.fn().mockResolvedValue(features);
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const method = new GetPassphraseState({
       payload: {
         method: 'getPassphraseState',
@@ -1827,19 +1977,17 @@ describe('Protocol V2 feature adapter', () => {
     expect(getFeatures).not.toHaveBeenCalled();
   });
 
-  test('marks an interactive cache miss as a wallet-session recovery', async () => {
+  test('uses the cached wallet address when the local session is missing', async () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
-      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'expected-state',
           session_id: 'recovered-session',
         },
       });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
     const device = stubDevice({
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       passphraseState: 'expected-state',
@@ -1860,16 +2008,10 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       getProtocolV2WalletSession(device, { expectedPassphraseState: 'expected-state' })
     ).resolves.toMatchObject({ passphraseState: 'expected-state' });
-    expect(promptPassphrase).toHaveBeenCalledWith(
-      {
-        existsAttachPinUser: false,
-        deviceOnly: false,
-        source: 'wallet-session-coordinator',
-        reason: 'session-recovery',
-        expectedPassphraseState: 'expected-state',
-      },
-      { cancelDeviceOnReject: false }
-    );
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      btc_test_address: 'expected-state',
+    });
+    expect(promptPassphrase).not.toHaveBeenCalled();
   });
 
   test('reuses the Pro2 session opened by legacy getPassphraseState on the next App call', async () => {
@@ -1914,7 +2056,7 @@ describe('Protocol V2 feature adapter', () => {
     );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
 
     const method = new GetPassphraseState({
@@ -1935,8 +2077,11 @@ describe('Protocol V2 feature adapter', () => {
       true
     );
     expect(typedCall.mock.calls).toEqual([
-      ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
-      ['DeviceSessionGet', 'DeviceSession', { session_id: 'session-pro2-app' }],
+      [
+        'DeviceSessionGet',
+        'DeviceSession',
+        { session_id: 'session-pro2-app', btc_test_address: 'state-pro2-app' },
+      ],
     ]);
   });
 
@@ -1970,7 +2115,7 @@ describe('Protocol V2 feature adapter', () => {
       features,
       commands: {
         typedCall,
-        promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
       },
       updateInternalState,
       getCurrentDeviceType: () => 'pro2',
@@ -1998,6 +2143,7 @@ describe('Protocol V2 feature adapter', () => {
     };
     const typedCall = jest
       .fn()
+      .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
       .mockResolvedValueOnce({ message: { version: 2 } })
       .mockResolvedValueOnce({ message: { message: 'Passphrase prepared' } })
       .mockResolvedValueOnce({ message: { unlocked: true, unlocked_attach_pin: false } })
@@ -2023,7 +2169,7 @@ describe('Protocol V2 feature adapter', () => {
       passphraseState: 'state-pro2-old',
       commands: {
         typedCall,
-        promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
       },
       emit: jest.fn(),
       clearInternalState,
@@ -2066,7 +2212,7 @@ describe('Protocol V2 feature adapter', () => {
     };
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
 
     await getPassphraseStateWithRefreshDeviceInfo(device);
@@ -2106,7 +2252,7 @@ describe('Protocol V2 feature adapter', () => {
     );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
 
     await expect(getPassphraseStateWithRefreshDeviceInfo(device)).resolves.toMatchObject({
@@ -2121,7 +2267,8 @@ describe('Protocol V2 feature adapter', () => {
     device.passphraseState = 'state-auto';
     expect(device.getInternalState()).toBe('session-auto');
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
-      on_device: true,
+      passphrase: 'host hidden wallet',
+      on_device: false,
     });
     expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
@@ -2191,7 +2338,7 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).features.unlocked = true;
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
     };
 
     await expect(device.checkPassphraseStateSafety('expected-state', false, true)).rejects.toEqual(
@@ -2201,11 +2348,15 @@ describe('Protocol V2 feature adapter', () => {
     );
 
     expect(device.getInternalState()).toBeUndefined();
-    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
-      on_device: true,
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      btc_test_address: 'expected-state',
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceStatusGet', 'DeviceStatus', {});
-    expect(typedCall).toHaveBeenNthCalledWith(4, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+      passphrase: 'host hidden wallet',
+      on_device: false,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('useEmptyPassphrase ignores a stale hidden-wallet state during Protocol V2 safety check', async () => {
@@ -2242,6 +2393,9 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
+      type: DeviceSessionPinType.Main,
+    });
   });
 
   test('marks fallback features as unavailable when DeviceInfo is missing', () => {
@@ -2564,6 +2718,10 @@ describe('Protocol V2 feature adapter', () => {
           fw: { application: { version: '1.2.3' } },
         },
       })
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2ApplicationInfo,
+      })
       .mockResolvedValueOnce({
         type: 'DeviceStatus',
         message: { init_states: true, unlocked: true },
@@ -2584,7 +2742,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.features?.passphraseProtection).toBeNull();
     expect(device.features?.label).toBeNull();
     expect(device.features?.firmwareVersion).toBe('1.2.3');
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(3);
     expect(typedCall).toHaveBeenNthCalledWith(
       1,
       'DeviceInfoGet',
@@ -2608,10 +2766,13 @@ describe('Protocol V2 feature adapter', () => {
         timeoutMs: PROTOCOL_V2_DEVICE_INFO_TIMEOUT_MS,
       }
     );
-    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceStatusGet', 'DeviceStatus', {});
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceStatusGet', 'DeviceStatus', {});
   });
 
-  test('recognizes bootloader when DeviceStatusGet fails', async () => {
+  test('recognizes bootloader from ProtocolInfo without calling DeviceStatusGet', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
@@ -2626,7 +2787,10 @@ describe('Protocol V2 feature adapter', () => {
           se1: {},
         },
       })
-      .mockRejectedValueOnce(new Error('DeviceStatusGet unsupported in bootloader'));
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2BootloaderInfo,
+      });
 
     (device as any).commands = { typedCall };
 
@@ -2642,23 +2806,221 @@ describe('Protocol V2 feature adapter', () => {
       }),
       expect.anything()
     );
-    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceStatusGet', 'DeviceStatus', {});
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
     expect(device.features).toMatchObject({
       deviceId: null,
       bootloaderMode: true,
+      mode: 'bootloader',
       initialized: null,
     });
+    expect(device.isBootloader()).toBe(true);
+    expect(device.isRomloader()).toBe(false);
   });
 
-  test('does not reinterpret a state update error as DeviceStatusGet failure', async () => {
+  test('recognizes romloader from ProtocolInfo without calling DeviceStatusGet', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
     } as any);
     const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceStatus',
-      message: { init_states: true, unlocked: true },
+      type: 'ProtocolInfo',
+      message: protocolV2RomloaderInfo,
+    });
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState({
+      hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
+      fw: { romloader: { version: '1.0.0' } },
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.features).toMatchObject({
+      mode: 'romloader',
+      bootloaderMode: true,
+      initialized: null,
+    });
+    expect(device.isBootloader()).toBe(false);
+    expect(device.isRomloader()).toBe(true);
+  });
+
+  test('rejects Protocol V2 romloader mode for non-Pro2 devices', async () => {
+    const device = Device.fromDescriptor({
+      path: 'pro-v2-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'ProtocolInfo',
+      message: protocolV2RomloaderInfo,
+    });
+    (device as any).commands = { typedCall };
+
+    await expect(
+      device.probeProtocolV2RuntimeState({
+        hw: { Device_type: DeviceType.PRO, serial_no: 'PRO-SERIAL' },
+        fw: { romloader: { version: '1.0.0' } },
+      })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceInitializeFailed });
+
+    expect(device.isRomloader()).not.toBe(true);
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test('keeps application mode without calling an unadvertised DeviceStatusGet', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const protocolInfo = {
+      ...protocolV2ApplicationInfo,
+      supported_messages: [],
+    };
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'ProtocolInfo',
+      message: protocolInfo,
+    });
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState({
+      hw: { serial_no: 'PR2SERIAL' },
+      fw: { application: { version: '1.2.3' } },
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.features).toMatchObject({
+      mode: 'normal',
+      bootloaderMode: false,
+      initialized: null,
+    });
+  });
+
+  test('uses advertised DeviceStatusGet as compatibility fallback for an unknown fingerprint', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const protocolInfo = {
+      ...protocolV2ApplicationInfo,
+      build_fingerprint: 'legacy-fingerprint',
+    };
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'ProtocolInfo', message: protocolInfo })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true, unlocked: true },
+      });
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState({
+      hw: { serial_no: 'PR2SERIAL' },
+      fw: { application: { version: '1.2.3' } },
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(device.features).toMatchObject({
+      mode: 'normal',
+      initialized: true,
+      unlocked: true,
+    });
+  });
+
+  test('maps an explicit unsupported DeviceStatusGet response to bootloader for an unknown fingerprint', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const protocolInfo = {
+      ...protocolV2ApplicationInfo,
+      build_fingerprint: 'legacy-fingerprint',
+    };
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'ProtocolInfo', message: protocolInfo })
+      .mockRejectedValueOnce(new Error('Failure_UnexpectedMessage,Unknown message'));
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState({
+      hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
+      fw: { bootloader: { version: '0.2.0' } },
+    });
+
+    expect(device.features).toMatchObject({
+      mode: 'bootloader',
+      bootloaderMode: true,
+      initialized: null,
     });
+  });
+
+  test('propagates DeviceStatusGet link failures instead of mapping them to bootloader', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const protocolInfo = {
+      ...protocolV2ApplicationInfo,
+      build_fingerprint: 'legacy-fingerprint',
+    };
+    const linkError = new Error('Protocol V2 CRC mismatch');
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'ProtocolInfo', message: protocolInfo })
+      .mockRejectedValueOnce(linkError);
+    (device as any).commands = { typedCall };
+
+    await expect(
+      device.probeProtocolV2RuntimeState({
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
+        fw: { application: { version: '1.2.3' } },
+      })
+    ).rejects.toBe(linkError);
+
+    expect(device.features).toBeUndefined();
+  });
+
+  test('fails safely when runtime fingerprint and capabilities are both unknown', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'ProtocolInfo',
+      message: {
+        version: 1,
+        build_fingerprint: 'legacy-fingerprint',
+        supported_messages: [],
+      },
+    });
+    (device as any).commands = { typedCall };
+
+    await expect(
+      device.probeProtocolV2RuntimeState({
+        hw: { serial_no: 'PR2SERIAL' },
+        fw: { application: { version: '1.2.3' } },
+      })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceInitializeFailed });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not reinterpret a state update error as runtime detection failure', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2ApplicationInfo,
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true, unlocked: true },
+      });
     const updateProtocolV2Features = jest
       .spyOn(device, 'updateProtocolV2Features')
       .mockImplementation(() => {
@@ -2673,12 +3035,13 @@ describe('Protocol V2 feature adapter', () => {
       })
     ).rejects.toThrow('state update failed');
 
-    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledTimes(2);
     expect(updateProtocolV2Features).toHaveBeenCalledTimes(1);
     expect(updateProtocolV2Features).toHaveBeenCalledWith(
       expect.anything(),
       expect.objectContaining({ init_states: true }),
-      'normal'
+      'normal',
+      protocolV2ApplicationInfo
     );
   });
 
@@ -2696,6 +3059,10 @@ describe('Protocol V2 feature adapter', () => {
           fw: { application: { version: '1.2.3' } },
         },
       })
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2ApplicationInfo,
+      })
       .mockResolvedValueOnce({
         type: 'DeviceStatus',
         message: { init_states: true, unlocked: true },
@@ -2728,9 +3095,9 @@ describe('Protocol V2 feature adapter', () => {
       firmwareVersion: '1.2.4',
       passphraseProtection: null,
     });
-    expect(typedCall).toHaveBeenCalledTimes(4);
+    expect(typedCall).toHaveBeenCalledTimes(5);
     expect(typedCall).toHaveBeenNthCalledWith(
-      3,
+      4,
       'DeviceInfoGet',
       'DeviceInfo',
       {
@@ -2755,14 +3122,23 @@ describe('Protocol V2 feature adapter', () => {
 
   test('keeps Protocol V2 features available for method internals such as evmSignTypedData', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
-    const typedCall = jest.fn().mockResolvedValueOnce({
-      type: 'DeviceInfo',
-      message: {
-        hw: { serial_no: 'PR2SERIAL' },
-        fw: { application: { version: '1.2.4' } },
-        status: { init_states: true, passphrase_enabled: true },
-      },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceInfo',
+        message: {
+          hw: { serial_no: 'PR2SERIAL' },
+          fw: { application: { version: '1.2.4' } },
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: protocolV2ApplicationInfo,
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true, passphrase_enabled: true },
+      });
     (device as any).commands = { typedCall };
 
     await device.initialize();
@@ -2833,9 +3209,23 @@ describe('Protocol V2 feature adapter', () => {
         status: { init_states: true },
       }
     );
+    const pinOnDevice = jest.fn();
+    device.on(DEVICE.PIN_ON_DEVICE, pinOnDevice);
 
     const features = await device.unlockDevice();
 
+    expect(pinOnDevice).toHaveBeenCalledWith(
+      device,
+      DeviceSessionPinType.Main,
+      expect.objectContaining({
+        source: 'unlock-coordinator',
+        reason: 'device-unlock',
+        deviceOnly: true,
+      })
+    );
+    expect(pinOnDevice.mock.invocationCallOrder[0]).toBeLessThan(
+      typedCall.mock.invocationCallOrder[0]
+    );
     expect(typedCall.mock.calls).toEqual([
       ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.Main }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
@@ -2881,9 +3271,12 @@ describe('Protocol V2 feature adapter', () => {
       throw new Error(`Unexpected request: ${requestType}`);
     });
     (device as any).commands = { typedCall };
+    const pinOnDevice = jest.fn();
+    device.on(DEVICE.PIN_ON_DEVICE, pinOnDevice);
 
-    await device.unlockDevice();
+    await device.unlockDevice(DeviceSessionPinType.Main, { emitUiEvent: false });
 
+    expect(pinOnDevice).not.toHaveBeenCalled();
     expect(typedCall.mock.calls).toEqual([
       ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.Main }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
@@ -3362,6 +3755,12 @@ describe('Protocol V2 firmware update targets', () => {
           message: { init_states: true, unlocked: true },
         });
       }
+      if (name === 'ProtocolInfoRequest') {
+        return Promise.resolve({
+          type: 'ProtocolInfo',
+          message: protocolV2ApplicationInfo,
+        });
+      }
       return Promise.reject(new Error(`unexpected call ${name}`));
     });
     const commands = { typedCall };
@@ -3406,7 +3805,12 @@ describe('Protocol V2 firmware update targets', () => {
       },
       { timeoutMs: 5000 }
     );
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(3);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceInfoGet',
+      'ProtocolInfoRequest',
+      'DeviceStatusGet',
+    ]);
     expect(typedCall).not.toHaveBeenCalledWith('Initialize', 'Features', {});
     expect(versions).toEqual({
       bootloaderVersion: '0.0.0',
@@ -3486,7 +3890,13 @@ describe('Protocol V2 firmware update targets', () => {
           message: protocolV2BootloaderDeviceInfo,
         });
       }
-      return Promise.reject(new Error('DeviceStatusGet unavailable in bootloader'));
+      if (requestType === 'ProtocolInfoRequest') {
+        return Promise.resolve({
+          type: 'ProtocolInfo',
+          message: protocolV2BootloaderInfo,
+        });
+      }
+      return Promise.reject(new Error(`unexpected call ${requestType}`));
     });
     const reconnectProtocolV2Device = jest.fn().mockImplementation(() => {
       (method as any).device.isBootloader = () => true;
@@ -3513,10 +3923,17 @@ describe('Protocol V2 firmware update targets', () => {
         method: 'firmwareUpdateV4',
       },
     });
+    const isRomloader = jest.fn(() => true);
     (method as any).device = stubDevice({
       originalDescriptor: { id: 'usb-id', path: 'romloader-path', protocolType: 'V2' },
-      features: { mode: 'romloader', bootloaderMode: false, capabilities: [] },
+      features: {
+        deviceType: 'pro2',
+        mode: 'romloader',
+        bootloaderMode: false,
+        capabilities: [],
+      },
       isBootloader: () => false,
+      isRomloader,
     });
     (method as any).protocolV2Reboot = jest
       .fn()
@@ -3525,10 +3942,52 @@ describe('Protocol V2 firmware update targets', () => {
 
     await expect((method as any).enterProtocolV2BootloaderMode()).resolves.toBe(false);
 
+    expect(isRomloader).toHaveBeenCalledTimes(1);
     expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
     expect(method.postTipMessage).not.toHaveBeenCalledWith('AutoRebootToBootloader');
   });
 
+  test('starts Protocol V2 firmware transfer directly from romloader mode', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        coprocessorBinary: new Uint8Array([1]).buffer,
+      },
+    });
+    method.init();
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'romloader-path', protocolType: 'V2' },
+      features: {
+        deviceType: 'pro2',
+        firmwareVersion: '0.0.0',
+        mode: 'romloader',
+        bootloaderMode: true,
+        capabilities: [],
+      },
+    });
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+    (method as any).protocolV2Reboot = jest.fn();
+    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
+    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
+    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
+      bootloaderVersion: '1.0.0',
+      bleVersion: '0.0.0',
+      firmwareVersion: '1.0.0',
+    });
+    method.postTipMessage = jest.fn();
+
+    await method.run();
+
+    expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
+    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
+      bootloaderBinary: null,
+      fwBinaryMap: [{ fileName: 'coprocessor.bin', binary: expect.anything(), targetId: 6 }],
+    });
+    expect(method.postTipMessage).not.toHaveBeenCalledWith('AutoRebootToBootloader');
+  });
+
   test('polls until Protocol V2 bootloader descriptor is ready after reboot', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -3548,7 +4007,13 @@ describe('Protocol V2 firmware update targets', () => {
           message: protocolV2BootloaderDeviceInfo,
         });
       }
-      return Promise.reject(new Error('DeviceStatusGet unavailable in bootloader'));
+      if (requestType === 'ProtocolInfoRequest') {
+        return Promise.resolve({
+          type: 'ProtocolInfo',
+          message: protocolV2BootloaderInfo,
+        });
+      }
+      return Promise.reject(new Error(`unexpected call ${requestType}`));
     });
     const reconnectProtocolV2Device = jest
       .fn()
@@ -3565,8 +4030,11 @@ describe('Protocol V2 firmware update targets', () => {
     await (method as any).waitForProtocolV2BootloaderMode(60 * 1000, 0);
 
     expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(3);
-    expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceInfoGet']);
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceInfoGet',
+      'ProtocolInfoRequest',
+    ]);
   });
 
   test('does not run generic initialize during Protocol V2 USB firmware reconnect', async () => {
@@ -4027,6 +4495,19 @@ describe('Protocol V2 firmware update targets', () => {
       )
     ).toBe(true);
 
+    (method.postProgressMessage as jest.Mock).mockClear();
+    expect(
+      (method as any).assertProtocolV2TargetStatus(
+        [
+          { target_id: 4, status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED' },
+          { target_id: 4, status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED' },
+        ],
+        new Set([4, 10])
+      )
+    ).toBe(false);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(50, 'installingFirmware');
+    expect(method.postProgressMessage).not.toHaveBeenCalledWith(100, 'installingFirmware');
+
     expect(
       (method as any).assertProtocolV2TargetStatus([{ target_id: 4, status: 1 }], expectedTargetIds)
     ).toBe(false);
@@ -4632,7 +5113,7 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
 
     const order: string[] = [];
-    const resourceBinary = new Uint8Array([1, 2, 3]).buffer;
+    const resourceBinary = buildOkppHeader().buffer as ArrayBuffer;
     const getSysResourceBinarySpy = jest
       .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
       .mockImplementation(() => {
@@ -4700,6 +5181,31 @@ describe('Protocol V2 firmware update targets', () => {
     getFirmwareLatestReleaseSpy.mockRestore();
   });
 
+  test('rejects a remote RESC bundle without an OKPP header when metadata is absent', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const getSysResourceBinarySpy = jest
+      .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
+      .mockResolvedValue({ binary: new Uint8Array([1, 2, 3]).buffer });
+
+    await expect(
+      (method as any).prefetchProtocolV2ResourceBundles([
+        {
+          name: 'images',
+          binary: new ArrayBuffer(0),
+          devicePath: 'vol0:/resource/images/images.okpkg',
+          url: 'https://example.com/images.okpkg',
+        },
+      ])
+    ).rejects.toThrow('Invalid Protocol V2 RESC bundle header: images');
+
+    getSysResourceBinarySpy.mockRestore();
+  });
+
   test('rejects an empty remote RESC bundle before entering bootloader', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -5768,7 +6274,10 @@ describe('Protocol V2 protected method execution', () => {
       }
       if (requestType === 'DeviceSessionGet') {
         calls.push('resume-hidden-session');
-        expect(request).toEqual({ session_id: 'hidden-session' });
+        expect(request).toEqual({
+          session_id: 'hidden-session',
+          btc_test_address: 'hidden-state',
+        });
         return Promise.resolve({
           message: {
             session_id: 'hidden-session',
@@ -5782,6 +6291,10 @@ describe('Protocol V2 protected method execution', () => {
       features: { unlocked: true, passphraseProtection: true },
       passphraseState: 'hidden-state',
       commands: { typedCall },
+      ensureProtocolV2RuntimeContext: () =>
+        typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+          eventless_wallet_session: true,
+        }).then(response => response.message),
       isProtocolV2: () => true,
       unlockDevice: jest.fn(() => {
         calls.push('unlock');
@@ -5830,6 +6343,10 @@ describe('Protocol V2 protected method execution', () => {
       features: { unlocked: true, passphraseProtection: true },
       passphraseState: 'hidden-state',
       commands: { typedCall },
+      ensureProtocolV2RuntimeContext: () =>
+        typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+          eventless_wallet_session: true,
+        }).then(response => response.message),
       isProtocolV2: () => true,
       unlockDevice: jest.fn().mockResolvedValue(undefined),
       getCurrentPassphraseProtection: () => true,
@@ -5865,7 +6382,10 @@ describe('Protocol V2 protected method execution', () => {
       }
       if (requestType === 'DeviceSessionGet') {
         calls.push('resume-hidden-session');
-        expect(request).toEqual({ session_id: 'hidden-session' });
+        expect(request).toEqual({
+          session_id: 'hidden-session',
+          btc_test_address: 'hidden-state',
+        });
         return Promise.resolve({
           message: {
             session_id: 'hidden-session',
@@ -5884,6 +6404,10 @@ describe('Protocol V2 protected method execution', () => {
       features,
       passphraseState: 'hidden-state',
       commands: { typedCall },
+      ensureProtocolV2RuntimeContext: () =>
+        typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+          eventless_wallet_session: true,
+        }).then(response => response.message),
       isProtocolV2: () => true,
       unlockDevice: jest.fn(() => {
         calls.push('unlock-main');
@@ -5901,7 +6425,12 @@ describe('Protocol V2 protected method execution', () => {
     await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
       message: 'ok',
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith();
+    expect(device.unlockDevice).toHaveBeenCalledWith(undefined, {
+      source: 'unlock-coordinator',
+      reason: 'device-locked',
+      deviceOnly: true,
+      method: 'evmSignMessage',
+    });
     expect(calls).toEqual([
       'unlock-main',
       'negotiate-session',
@@ -5933,7 +6462,7 @@ describe('Protocol V2 protected method execution', () => {
     expect(method.run).toHaveBeenCalledTimes(1);
   });
 
-  test('unlocks before showing the method interaction when cached status is locked', async () => {
+  test('refreshes status and unlocks before a protected Protocol V2 method', async () => {
     const calls: string[] = [];
     const method = {
       name: 'deviceSettingsPageShow',
@@ -5944,11 +6473,23 @@ describe('Protocol V2 protected method execution', () => {
         return Promise.resolve({ message: 'ok' });
       }),
     };
+    const features = { unlocked: true };
     const device = {
-      features: { unlocked: false },
+      features,
+      commands: {
+        typedCall: jest.fn(() => {
+          calls.push('refresh-status');
+          return Promise.resolve({ message: { unlocked: false } });
+        }),
+      },
       isProtocolV2: () => true,
+      updateProtocolV2Status: jest.fn((status: { unlocked?: boolean }) => {
+        features.unlocked = status.unlocked ?? features.unlocked;
+        return features;
+      }),
       unlockDevice: jest.fn(() => {
         calls.push('unlock');
+        features.unlocked = true;
         return Promise.resolve();
       }),
     };
@@ -5961,12 +6502,66 @@ describe('Protocol V2 protected method execution', () => {
     await expect(
       runMethodWithUnlockRetry(method as any, device as any, uiCoordinator as any)
     ).resolves.toEqual({ message: 'ok' });
-    expect(calls).toEqual(['unlock-prompt', 'unlock', 'method-prompt', 'run']);
+    expect(calls).toEqual(['refresh-status', 'unlock-prompt', 'unlock', 'method-prompt', 'run']);
+    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
     expect(method.run).toHaveBeenCalledTimes(1);
     expect(uiCoordinator.enterMethodInteraction).toHaveBeenCalledTimes(1);
     expect(uiCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
   });
 
+  test('uses refreshed unlocked status instead of a stale locked cache', async () => {
+    const features = { unlocked: false };
+    const method = {
+      name: 'deviceSettings',
+      unlockPolicy: 'unlock-before-run',
+      run: jest.fn().mockResolvedValue({ message: 'ok' }),
+    };
+    const device = {
+      features,
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: true } }),
+      },
+      isProtocolV2: () => true,
+      updateProtocolV2Status: jest.fn((status: { unlocked?: boolean }) => {
+        features.unlocked = status.unlocked ?? features.unlocked;
+        return features;
+      }),
+      unlockDevice: jest.fn(),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+      message: 'ok',
+    });
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+    expect(method.run).toHaveBeenCalledTimes(1);
+  });
+
+  test.each(['bootloader', 'romloader'] as const)(
+    'skips DeviceStatus and unlock in Protocol V2 %s mode',
+    async mode => {
+      const method = {
+        name: 'firmwareUpdateV4',
+        unlockPolicy: 'unlock-before-run',
+        run: jest.fn().mockResolvedValue({ message: 'updating' }),
+      };
+      const device = {
+        features: { unlocked: false },
+        commands: { typedCall: jest.fn() },
+        isProtocolV2: () => true,
+        isBootloader: () => mode === 'bootloader',
+        isRomloader: () => mode === 'romloader',
+        unlockDevice: jest.fn(),
+      };
+
+      await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+        message: 'updating',
+      });
+      expect(device.commands.typedCall).not.toHaveBeenCalled();
+      expect(device.unlockDevice).not.toHaveBeenCalled();
+      expect(method.run).toHaveBeenCalledTimes(1);
+    }
+  );
+
   test('infers a signing interaction before running a Protocol V2 business method', async () => {
     const method = {
       name: 'evmSignMessage',
@@ -6045,6 +6640,38 @@ describe('Protocol V2 protected method execution', () => {
     expect(uiCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
   });
 
+  test('keeps the PIN prompt when an eventless method actually unlocks the device', async () => {
+    const lockedError = deviceLockedError();
+    const method = {
+      name: 'backgroundRead',
+      unlockPolicy: 'retry-on-locked',
+      protocolV2UiMode: 'none',
+      run: jest.fn().mockRejectedValueOnce(lockedError).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).toHaveBeenCalledWith(undefined, {
+      source: 'unlock-coordinator',
+      reason: 'device-locked',
+      deviceOnly: true,
+      method: 'backgroundRead',
+    });
+    expect(uiCoordinator.enterMethodInteraction).not.toHaveBeenCalled();
+    expect(uiCoordinator.enterUnlockInteraction).not.toHaveBeenCalled();
+    expect(uiCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
+  });
+
   test('does not unlock or replay a lock-free state-changing method after a locked response', async () => {
     const error = deviceLockedError();
     const method = {
@@ -6249,7 +6876,9 @@ describe('Protocol V2 current low-level methods', () => {
 
     await method.run();
 
-    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {});
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
   });
 
   test('sends DeviceFactoryInfoSet and DeviceFactoryInfoGet', async () => {