@onekeyfe/hd-core 1.2.0-alpha.22 → 1.2.0-alpha.24

package/__tests__/protocol-v2.test.ts

@@ -1,5 +1,5 @@
-import { EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { DeviceRebootType, DeviceSettingsPage } from '@onekeyfe/hd-transport';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceRebootType, DeviceSessionPinType, DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import * as firmwareBinaryApi from '../src/api/firmware/getBinary';
 import DnxGetAddress from '../src/api/dynex/DnxGetAddress';
@@ -83,7 +83,6 @@ import {
   isMethodVersionRangeUnsupported,
 } from '../src/utils';
 import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
-import { openFirmwareByteSource } from '../src/api/firmware/FirmwareArtifactSource';
 import {
   getPassphraseState,
   getPassphraseStateWithRefreshDeviceInfo,
@@ -98,6 +97,14 @@ jest.mock('../src/data/config', () => ({
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
+const createWalletSessionTypedCall = (implementation = jest.fn()) =>
+  jest.fn((request: string, ...args: unknown[]) => {
+    if (request === 'ProtocolInfoRequest') {
+      return Promise.resolve({ message: { version: 2 } });
+    }
+    return implementation(request, ...args);
+  });
+
 describe('DeviceUploadWallpaper', () => {
   test('encodes, uploads and applies a Pro2 wallpaper', async () => {
     const rgba = new Uint8Array(604 * 1024 * 4).fill(255);
@@ -690,13 +697,15 @@ describe('Protocol V2 feature adapter', () => {
     const features = normalizeProtocolV2Features(descriptor as any);
     features.firmwareVersion = '1.2.3';
     features.passphraseProtection = true;
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        btc_test_address: 'state-1',
-        session_id: 'session-1',
-      },
-    });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'state-1',
+          session_id: 'session-1',
+        },
+      })
+    );
     const commands = { typedCall } as unknown as DeviceCommands;
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = features;
@@ -724,13 +733,15 @@ describe('Protocol V2 feature adapter', () => {
       { ...descriptor, protocolType: 'V2' } as any,
       { status: { passphrase_enabled: false, unlocked: true } }
     );
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        btc_test_address: 'main-wallet-state',
-        session_id: 'main-wallet-session',
-      },
-    });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'main-wallet-state',
+          session_id: 'main-wallet-session',
+        },
+      })
+    );
     const promptPassphrase = jest
       .fn()
       .mockResolvedValue({ passphrase: 'hidden-wallet-with-disabled-flag' });
@@ -800,17 +811,16 @@ describe('Protocol V2 feature adapter', () => {
         },
       }
     );
-    const typedCall = jest.fn().mockImplementation((request: string) => {
-      if (request === 'ProtocolInfoRequest') {
-        return Promise.resolve({ message: { version: 2 } });
-      }
-      if (request === 'DeviceStatusGet') {
-        return Promise.resolve({
-          message: { passphrase_enabled: false, unlocked: true },
-        });
-      }
-      throw new Error(`Unexpected request: ${request}`);
-    });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockImplementation((request: string) => {
+        if (request === 'DeviceStatusGet') {
+          return Promise.resolve({
+            message: { passphrase_enabled: false, unlocked: true },
+          });
+        }
+        throw new Error(`Unexpected request: ${request}`);
+      })
+    );
     const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden-after-unlock' });
     const unlockDevice = jest.spyOn(device, 'unlockDevice').mockImplementation(() => {
       (device as any).features = {
@@ -844,13 +854,15 @@ describe('Protocol V2 feature adapter', () => {
     );
     device.passphraseState = 'hidden-state';
     preloadSessionCache('main-wallet-device', 'hidden-state', 'hidden-session');
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        btc_test_address: 'main-wallet-state',
-        session_id: 'main-wallet-session',
-      },
-    });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'main-wallet-state',
+          session_id: 'main-wallet-session',
+        },
+      })
+    );
     (device as any).commands = { typedCall };
 
     await expect(
@@ -885,11 +897,13 @@ describe('Protocol V2 feature adapter', () => {
         },
       }
     );
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: { session_id: 'hidden-session', btc_test_address: 'hidden-state' },
-    });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden secret' });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: { session_id: 'hidden-session', btc_test_address: 'hidden-state' },
+      })
+    );
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
     (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(getProtocolV2WalletSession(device)).resolves.toMatchObject({
@@ -898,9 +912,8 @@ describe('Protocol V2 feature adapter', () => {
     });
 
     expect(promptPassphrase).toHaveBeenCalled();
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { host_passphrase: { passphrase: 'hidden secret' } },
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('deviceStatusGet returns raw DeviceStatus and updates dynamic features', async () => {
@@ -993,10 +1006,12 @@ describe('Protocol V2 feature adapter', () => {
     );
     device.passphraseState = 'state-a';
     preloadSessionCache('stable-device-1', 'state-a', 'session-a');
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: { session_id: 'session-b', btc_test_address: 'state-a' },
-    });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: { session_id: 'session-b', btc_test_address: 'state-a' },
+      })
+    );
     (device as any).commands = { typedCall };
 
     await expect(getProtocolV2WalletSession(device)).resolves.toMatchObject({
@@ -1004,8 +1019,8 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'session-b',
     });
 
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      resume: { session_id: 'session-a' },
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
+      session_id: 'session-a',
     });
     expect(device.getInternalState()).toBe('session-b');
   });
@@ -1021,13 +1036,15 @@ describe('Protocol V2 feature adapter', () => {
       { status: { device_id: 'stable-device-2', unlocked: true } }
     );
     preloadSessionCache('stable-device-2', 'state-a', 'session-a');
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        session_id: 'main-session',
-        btc_test_address: 'main-wallet-state',
-      },
-    });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: {
+          session_id: 'main-session',
+          btc_test_address: 'main-wallet-state',
+        },
+      })
+    );
     (device as any).commands = { typedCall };
 
     await getProtocolV2WalletSession(device, { onlyMainPin: true });
@@ -1056,14 +1073,13 @@ describe('Protocol V2 feature adapter', () => {
     );
     device.passphraseState = 'state-a';
     preloadSessionCache('stable-device-3', 'state-a', 'session-a');
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockRejectedValue(
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockRejectedValue(
         Object.assign(new Error('SE request failed'), {
           errorCode: HardwareErrorCode.RuntimeError,
         })
-      );
+      )
+    );
     const promptPassphrase = jest.fn();
     (device as any).commands = { typedCall, promptPassphrase };
 
@@ -1072,7 +1088,7 @@ describe('Protocol V2 feature adapter', () => {
     });
     expect(typedCall.mock.calls).toEqual([
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
-      ['DeviceSessionOpen', 'DeviceSession', { resume: { session_id: 'session-a' } }],
+      ['DeviceSessionGet', 'DeviceSession', { session_id: 'session-a' }],
     ]);
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.getInternalState()).toBeUndefined();
@@ -1094,17 +1110,16 @@ describe('Protocol V2 feature adapter', () => {
         },
       }
     );
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockRejectedValue(
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockRejectedValue(
         Object.assign(new Error('Invalid session'), {
           errorCode: HardwareErrorCode.WalletSessionInvalid,
         })
-      );
+      )
+    );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'new-secret' }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
     };
 
     await expect(getProtocolV2WalletSession(device)).rejects.toMatchObject({
@@ -1112,11 +1127,7 @@ describe('Protocol V2 feature adapter', () => {
     });
     expect(typedCall.mock.calls).toEqual([
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
-      [
-        'DeviceSessionOpen',
-        'DeviceSession',
-        { select: { host_passphrase: { passphrase: 'new-secret' } } },
-      ],
+      ['DeviceSessionAskPassphrase', 'Success', {}],
     ]);
   });
 
@@ -1139,10 +1150,12 @@ describe('Protocol V2 feature adapter', () => {
     device.passphraseState = 'state-a';
     preloadSessionCache('stable-device-mismatch', 'state-a', 'session-a');
     (device as any).commands = {
-      typedCall: jest.fn().mockResolvedValue({
-        type: 'DeviceSession',
-        message: { session_id: 'session-b', btc_test_address: 'state-b' },
-      }),
+      typedCall: createWalletSessionTypedCall(
+        jest.fn().mockResolvedValue({
+          type: 'DeviceSession',
+          message: { session_id: 'session-b', btc_test_address: 'state-b' },
+        })
+      ),
     };
 
     await expect(
@@ -1155,7 +1168,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
   });
 
-  test('unlocks and retries DeviceSessionOpen when wallet selection is locked', async () => {
+  test('unlocks and retries DeviceSessionAskPassphrase when wallet selection is locked', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-4',
       path: 'cache-path-4',
@@ -1168,19 +1181,21 @@ describe('Protocol V2 feature adapter', () => {
     const lockedError = Object.assign(new Error('Device is locked'), {
       errorCode: HardwareErrorCode.DeviceLocked,
     });
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockRejectedValueOnce(lockedError)
-      .mockResolvedValueOnce({
-        message: {
-          session_id: 'session-after-unlock',
-          btc_test_address: 'state-after-unlock',
-        },
-      });
+    const typedCall = createWalletSessionTypedCall(
+      jest
+        .fn()
+        .mockRejectedValueOnce(lockedError)
+        .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+        .mockResolvedValueOnce({
+          message: {
+            session_id: 'session-after-unlock',
+            btc_test_address: 'state-after-unlock',
+          },
+        })
+    );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'hidden secret' }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
     };
     const unlockDevice = jest.spyOn(device, 'unlockDevice').mockResolvedValue(undefined as any);
 
@@ -1189,7 +1204,7 @@ describe('Protocol V2 feature adapter', () => {
       passphraseState: 'state-after-unlock',
     });
     expect(unlockDevice).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledTimes(3);
+    expect(typedCall).toHaveBeenCalledTimes(4);
   });
 
   test('does not request a Pro2 wallet session before features are initialized', async () => {
@@ -1321,24 +1336,29 @@ describe('Protocol V2 feature adapter', () => {
     );
   });
 
-  test('does not expose getPassphraseState on Pro2 devices', async () => {
+  test('maps the legacy getPassphraseState App flow to the Pro2 wallet session protocol', async () => {
     const features = {
-      deviceId: null,
+      deviceId: 'pro2-device-id',
       deviceType: 'pro2',
       firmwareVersion: '4.15.0',
       passphraseProtection: true,
       sessionId: 'feature-session',
       unlockedAttachPin: true,
     };
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        btc_test_address: 'state-pro2',
-        session_id: 'session-pro2',
-      },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'state-pro2',
+          session_id: 'session-pro2',
+        },
+      });
     const updateInternalState = jest.fn();
     const getFeatures = jest.fn().mockResolvedValue(features);
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
     const method = new GetPassphraseState({
       payload: {
         method: 'getPassphraseState',
@@ -1350,21 +1370,95 @@ describe('Protocol V2 feature adapter', () => {
       features,
       commands: {
         typedCall,
-        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-pro2-new-secret' }),
+        promptPassphrase,
       },
+      emit: jest.fn(),
       updateInternalState,
       getFeatures,
       getCurrentDeviceType: () => 'pro2',
-      getCurrentDeviceId: () => undefined,
+      getCurrentDeviceId: () => 'pro2-device-id',
       getCurrentPassphraseProtection: () => true,
     }) as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
-    });
+    await expect(method.run()).resolves.toBe('state-pro2');
+    expect(promptPassphrase).toHaveBeenCalledWith(
+      {
+        existsAttachPinUser: false,
+        source: 'wallet-session-coordinator',
+        reason: 'open-wallet',
+      },
+      { cancelDeviceOnReject: false }
+    );
+    expect(updateInternalState).toHaveBeenCalledWith(
+      true,
+      'state-pro2',
+      'pro2-device-id',
+      'session-pro2',
+      null
+    );
+    expect(JSON.stringify(typedCall.mock.calls)).not.toContain('legacy app secret');
     expect(getFeatures).not.toHaveBeenCalled();
   });
 
+  test('reuses the Pro2 session opened by legacy getPassphraseState on the next App call', async () => {
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    const typedCall = jest.fn().mockImplementation((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return Promise.resolve({ message: { version: 2 } });
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return Promise.resolve({ message: { message: 'passphrase prepared' } });
+      }
+      if (request === 'DeviceSessionGet') {
+        return Promise.resolve({
+          type: 'DeviceSession',
+          message: {
+            btc_test_address: 'state-pro2-app',
+            session_id: 'session-pro2-app',
+          },
+        });
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+
+    (device as any).features = normalizeProtocolV2Features(
+      { ...descriptor, protocolType: 'V2' } as any,
+      {
+        status: {
+          device_id: 'pro2-app-device-id',
+          unlocked: true,
+          passphrase_enabled: true,
+        },
+      }
+    );
+    (device as any).commands = {
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
+    };
+
+    const method = new GetPassphraseState({
+      payload: {
+        method: 'getPassphraseState',
+        connectId: 'connect-id',
+        initSession: true,
+      },
+    });
+    method.device = device;
+
+    await expect(method.run()).resolves.toBe('state-pro2-app');
+
+    await device.initialize({ passphraseState: 'state-pro2-app' });
+    typedCall.mockClear();
+
+    await expect(device.checkPassphraseStateSafety('state-pro2-app', false, false)).resolves.toBe(
+      true
+    );
+    expect(typedCall.mock.calls).toEqual([
+      ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
+      ['DeviceSessionGet', 'DeviceSession', { session_id: 'session-pro2-app' }],
+    ]);
+  });
+
   test('uses the Pro2 standard wallet without passphraseState when passphrase is disabled', async () => {
     const features = {
       deviceId: 'pro2-device-id',
@@ -1373,12 +1467,13 @@ describe('Protocol V2 feature adapter', () => {
       passphraseProtection: false,
       unlocked: true,
     };
-    const typedCall = jest.fn();
+    const typedCall = createWalletSessionTypedCall();
     const updateInternalState = jest.fn();
     const method = new GetPassphraseState({
       payload: {
         method: 'getPassphraseState',
         connectId: 'connect-id',
+        useEmptyPassphrase: true,
       },
     });
     method.device = stubDevice({
@@ -1386,7 +1481,7 @@ describe('Protocol V2 feature adapter', () => {
       features,
       commands: {
         typedCall,
-        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'mock-hidden-wallet' }),
+        promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
       },
       updateInternalState,
       getCurrentDeviceType: () => 'pro2',
@@ -1394,10 +1489,10 @@ describe('Protocol V2 feature adapter', () => {
       getCurrentPassphraseProtection: () => false,
     }) as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
+    await expect(method.run()).resolves.toBeUndefined();
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
     });
-    expect(typedCall).not.toHaveBeenCalled();
     expect(updateInternalState).not.toHaveBeenCalled();
   });
 
@@ -1410,12 +1505,17 @@ describe('Protocol V2 feature adapter', () => {
       sessionId: 'old-feature-session',
       unlockedAttachPin: false,
     };
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        btc_test_address: 'state-pro2-new',
-      },
-    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'state-pro2-new',
+          session_id: 'session-pro2-new',
+        },
+      });
     const clearInternalState = jest.fn();
     const updateInternalState = jest.fn();
     const method = new GetPassphraseState({
@@ -1428,32 +1528,41 @@ describe('Protocol V2 feature adapter', () => {
     method.device = stubDevice({
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features,
+      passphraseState: 'state-pro2-old',
       commands: {
         typedCall,
-        promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-pro2-new-secret' }),
+        promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
       },
+      emit: jest.fn(),
       clearInternalState,
       updateInternalState,
       getCurrentDeviceId: () => 'pro2-device-id',
       getCurrentPassphraseProtection: () => true,
     }) as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceNotSupportMethod,
-    });
-    expect(clearInternalState).not.toHaveBeenCalled();
-    expect(updateInternalState).not.toHaveBeenCalled();
+    await expect(method.run()).resolves.toBe('state-pro2-new');
+    expect(clearInternalState).toHaveBeenCalledTimes(1);
+    expect((method.device as any).passphraseState).toBeUndefined();
+    expect(updateInternalState).toHaveBeenCalledWith(
+      true,
+      'state-pro2-new',
+      'pro2-device-id',
+      'session-pro2-new',
+      null
+    );
   });
 
   test('stores Pro2 passphrase session cache without synthetic device id', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        btc_test_address: 'state-profile',
-        session_id: 'session-profile',
-      },
-    });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'state-profile',
+          session_id: 'session-profile',
+        },
+      })
+    );
 
     (device as any).features = {
       ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any, {
@@ -1465,7 +1574,7 @@ describe('Protocol V2 feature adapter', () => {
     };
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-profile-secret' }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
     };
 
     await getPassphraseStateWithRefreshDeviceInfo(device);
@@ -1477,13 +1586,15 @@ describe('Protocol V2 feature adapter', () => {
 
   test('stores Pro2 passphrase sessions without selecting them implicitly', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        btc_test_address: 'state-auto',
-        session_id: 'session-auto',
-      },
-    });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'state-auto',
+          session_id: 'session-auto',
+        },
+      })
+    );
 
     (device as any).features = normalizeProtocolV2Features(
       {
@@ -1503,7 +1614,7 @@ describe('Protocol V2 feature adapter', () => {
     );
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-auto-secret' }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
     };
 
     await expect(getPassphraseStateWithRefreshDeviceInfo(device)).resolves.toMatchObject({
@@ -1517,20 +1628,20 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
     device.passphraseState = 'state-auto';
     expect(device.getInternalState()).toBe('session-auto');
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionOpen', 'DeviceSession', {
-      select: { host_passphrase: { passphrase: 'state-auto-secret' } },
-    });
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('does not mark Pro2 passphrase enabled from a main PIN session alone', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        session_id: 'main-pin-session',
-        btc_test_address: 'main-wallet-state',
-      },
-    });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: {
+          session_id: 'main-pin-session',
+          btc_test_address: 'main-wallet-state',
+        },
+      })
+    );
 
     (device as any).features = normalizeProtocolV2Features(
       {
@@ -1565,13 +1676,15 @@ describe('Protocol V2 feature adapter', () => {
 
   test('does not let skipPassphraseCheck hide Pro2 passphrase state mismatch', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        btc_test_address: 'wrong-state',
-        session_id: 'wrong-session',
-      },
-    });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: {
+          btc_test_address: 'wrong-state',
+          session_id: 'wrong-session',
+        },
+      })
+    );
 
     (device as any).features = normalizeProtocolV2Features({
       ...descriptor,
@@ -1582,7 +1695,7 @@ describe('Protocol V2 feature adapter', () => {
     (device as any).features.unlocked = true;
     (device as any).commands = {
       typedCall,
-      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'expected-secret' }),
+      promptPassphrase: jest.fn().mockResolvedValue({ passphraseOnDevice: true }),
     };
 
     await expect(device.checkPassphraseStateSafety('expected-state', false, true)).rejects.toEqual(
@@ -1592,20 +1705,20 @@ describe('Protocol V2 feature adapter', () => {
     );
 
     expect(device.getInternalState()).toBeUndefined();
-    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionOpen', 'DeviceSession', {
-      select: { host_passphrase: { passphrase: 'expected-secret' } },
-    });
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {});
   });
 
   test('useEmptyPassphrase ignores a stale hidden-wallet state during Protocol V2 safety check', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'DeviceSession',
-      message: {
-        session_id: 'main-wallet-session',
-        btc_test_address: 'main-wallet-state',
-      },
-    });
+    const typedCall = createWalletSessionTypedCall(
+      jest.fn().mockResolvedValue({
+        type: 'DeviceSession',
+        message: {
+          session_id: 'main-wallet-session',
+          btc_test_address: 'main-wallet-state',
+        },
+      })
+    );
 
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
@@ -1696,7 +1809,7 @@ describe('Protocol V2 feature adapter', () => {
       uuid: 'CACHED-SERIAL',
       deviceId: null,
       bleName: 'Cached BLE',
-      name: 'Cached BLE',
+      name: 'Cached Label',
       label: 'Cached Label',
       deviceType: 'pro2',
     });
@@ -1705,6 +1818,39 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.hasUsePassphrase()).toBe(true);
   });
 
+  test('uses the BLE name as the Protocol V2 display label while preserving the raw label', () => {
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = {
+      ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
+      serialNo: 'PR9999999999',
+      label: null,
+      bleName: 'Pro2 6136',
+    };
+
+    expect(device.toMessageObject()).toMatchObject({
+      serialNo: 'PR9999999999',
+      bleName: 'Pro2 6136',
+      name: 'Pro2 6136',
+      label: 'Pro2 6136',
+    });
+    expect(device.features?.label).toBeNull();
+  });
+
+  test('prefers the real Protocol V2 label over the BLE name for display', () => {
+    const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
+    (device as any).features = {
+      ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
+      label: 'My Pro 2',
+      bleName: 'Pro2 6136',
+    };
+
+    expect(device.toMessageObject()).toMatchObject({
+      bleName: 'Pro2 6136',
+      name: 'My Pro 2',
+      label: 'My Pro 2',
+    });
+  });
+
   test('syncs Protocol V2 cached features without cached profile', () => {
     const cached = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (cached as any).features = {
@@ -2166,7 +2312,7 @@ describe('Protocol V2 feature adapter', () => {
     await expect(method.run()).resolves.toEqual({ address: '0x0', signature: '0x1' });
   });
 
-  test('unlocks Protocol V2 devices via DeviceSessionAskPin regardless of Pro-series version gates', async () => {
+  test('unlocks Protocol V2 devices with the main PIN regardless of Pro-series version gates', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
@@ -2206,7 +2352,7 @@ describe('Protocol V2 feature adapter', () => {
     const features = await device.unlockDevice();
 
     expect(typedCall.mock.calls).toEqual([
-      ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
+      ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.Main }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
     ]);
     expect(typedCall).not.toHaveBeenCalledWith('GetAddress', 'Address', expect.anything());
@@ -2254,7 +2400,7 @@ describe('Protocol V2 feature adapter', () => {
     await device.unlockDevice();
 
     expect(typedCall.mock.calls).toEqual([
-      ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
+      ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.Main }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
     ]);
     expect((device as any).profile).toBeUndefined();
@@ -2284,10 +2430,10 @@ describe('Protocol V2 feature adapter', () => {
     );
     expect(typedCall).toHaveBeenCalledTimes(1);
     expect(typedCall.mock.calls).toEqual([
-      ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
+      ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.Main }],
     ]);
     expect(typedCall).not.toHaveBeenCalledWith(
-      'DeviceSessionOpen',
+      'DeviceSessionGet',
       'DeviceSession',
       expect.anything()
     );
@@ -2800,7 +2946,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('delegates Protocol V2 mode transition to the phase executor', async () => {
+  test('enters Protocol V2 bootloader before upload', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -2835,7 +2981,7 @@ describe('Protocol V2 firmware update targets', () => {
 
     await method.run();
 
-    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
+    expect((method as any).enterProtocolV2BootloaderMode).toHaveBeenCalledTimes(1);
     expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
       fwBinaryMap: [
         {
@@ -3154,9 +3300,9 @@ describe('Protocol V2 firmware update targets', () => {
     const typedCall = jest
       .fn()
       .mockRejectedValue(
-        Object.assign(
-          new Error("Failed to execute 'open' on 'USBDevice': The device was disconnected"),
-          { name: 'NotFoundError' }
+        new DOMException(
+          "Failed to execute 'open' on 'USBDevice': The device was disconnected",
+          'NotFoundError'
         )
       );
 
@@ -3244,7 +3390,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('does not treat a missing firmware status handler as install completion', async () => {
+  test('accepts a missing firmware status handler as an app reboot signal', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -3263,39 +3409,12 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
     method.postProgressMessage = jest.fn();
 
-    await expect(
-      (method as any).waitForProtocolV2FirmwareUpdateComplete([
-        { target_id: 4, path: 'vol0:/application_p1.bin' },
-      ])
-    ).rejects.toThrow('Protocol V2 firmware install status is unavailable');
-
-    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-      'DeviceFirmwareUpdateStatusGet',
-      'DeviceInfoGet',
+    await (method as any).waitForProtocolV2FirmwareUpdateComplete([
+      { target_id: 4, path: 'vol0:/application_p1.bin' },
     ]);
-  });
-
-  test('rejects a finished target whose payload version conflicts with the plan', () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'desktop',
-        expectedTargetVersions: {
-          app_v1: '2.0.0',
-        },
-      },
-    });
-    method.init();
-    method.postProgressMessage = jest.fn();
 
-    expect(() =>
-      (method as any).assertProtocolV2TargetStatus(
-        [{ target_id: 4, status: 2, payload_version: 0x010000 }],
-        new Set([4])
-      )
-    ).toThrow('expected 131072');
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceFirmwareUpdateStatusGet']);
   });
 
   test('polls target status after update ACK and finishes when all targets complete', async () => {
@@ -3474,14 +3593,10 @@ describe('Protocol V2 firmware update targets', () => {
     const writtenPaths: string[] = [];
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockImplementation(params => {
+    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockImplementation(params => {
       writtenPaths.push(params.filePath);
-      return Number(params.processedSize ?? 0) + Number(params.source.size);
+      return Number(params.processedSize ?? 0) + Number(params.payload.byteLength);
     });
-    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
-    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
-    (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({});
-    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
@@ -3521,12 +3636,10 @@ describe('Protocol V2 firmware update targets', () => {
       'vol0:/coprocessor.bin',
       1
     );
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(2);
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenNthCalledWith(1, {
-      targets: [{ target_id: 3, path: 'vol0:/bootloader.bin' }],
-    });
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenNthCalledWith(2, {
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
       targets: [
+        { target_id: 3, path: 'vol0:/bootloader.bin' },
         { target_id: 6, path: 'vol0:/coprocessor.bin' },
         { target_id: 7, path: 'vol0:/se01.bin' },
         { target_id: 4, path: 'vol0:/application_p1.bin' },
@@ -3536,7 +3649,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect((method as any).waitForProtocolV2FirmwareUpdateComplete).toHaveBeenCalled();
   });
 
-  test('announces separate resource and component transfer phases', async () => {
+  test('announces one transfer when syncing resource bundles and staging firmware', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -3546,14 +3659,11 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2SourceUpdateProcess = jest
+    (method as any).protocolV2CommonUpdateProcess = jest
       .fn()
       .mockImplementation(params =>
-        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.source.size))
+        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.payload.byteLength))
       );
-    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
-    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
-    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
@@ -3573,22 +3683,21 @@ describe('Protocol V2 firmware update targets', () => {
         {
           fileName: 'application_p1.bin',
           binary: new Uint8Array([3]).buffer,
-          targetId: 4,
+          targetId: 3,
         },
       ],
     });
 
-    expect(method.postTipMessage).toHaveBeenCalledTimes(3);
+    expect(method.postTipMessage).toHaveBeenCalledTimes(2);
     expect(method.postTipMessage).toHaveBeenNthCalledWith(1, 'StartTransferData');
-    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'StartTransferData');
-    expect(method.postTipMessage).toHaveBeenNthCalledWith(3, 'ConfirmOnDevice');
-    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenNthCalledWith(
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'ConfirmOnDevice');
+    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenNthCalledWith(
       1,
-      expect.objectContaining({ processedSize: 0, totalSize: 2 })
+      expect.objectContaining({ processedSize: 0, totalSize: 3 })
     );
-    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenNthCalledWith(
+    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenNthCalledWith(
       2,
-      expect.objectContaining({ processedSize: 0, totalSize: 1 })
+      expect.objectContaining({ processedSize: 2, totalSize: 3 })
     );
   });
 
@@ -3602,8 +3711,7 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockResolvedValue(3);
-    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
+    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockResolvedValue(3);
     (method as any).device = stubDevice({
       getCommands: () => ({
         typedCall: jest.fn().mockResolvedValue({
@@ -3649,14 +3757,11 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2SourceUpdateProcess = jest
+    (method as any).protocolV2CommonUpdateProcess = jest
       .fn()
       .mockImplementation(params =>
-        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.source.size))
+        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.payload.byteLength))
       );
-    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
-    (method as any).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
-    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest
@@ -3975,9 +4080,7 @@ describe('Protocol V2 firmware update targets', () => {
       order.push('bootloader');
       return Promise.resolve(true);
     });
-    const executeProtocolV2UpdateSpy = jest.spyOn(method as any, 'executeProtocolV2Update');
-    (method as any).executeProtocolV2TransferPhase = jest.fn().mockResolvedValue(undefined);
-    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue(undefined);
+    (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',
@@ -3989,7 +4092,7 @@ describe('Protocol V2 firmware update targets', () => {
     await method.run();
 
     expect(order).toEqual(['download', 'bootloader']);
-    expect(executeProtocolV2UpdateSpy).toHaveBeenCalledWith({
+    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
       bootloaderBinary: null,
       fwBinaryMap: [],
       resourceBundles: [
@@ -4002,7 +4105,6 @@ describe('Protocol V2 firmware update targets', () => {
       ],
     });
 
-    executeProtocolV2UpdateSpy.mockRestore();
     getSysResourceBinarySpy.mockRestore();
     getFirmwareLatestReleaseSpy.mockRestore();
   });
@@ -4291,10 +4393,7 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockResolvedValue(3);
-    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
-    (method as any).completeProtocolV2FinalVerification = jest.fn().mockResolvedValue({});
-    (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
+    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockResolvedValue(3);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn();
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest.fn();
 
@@ -4310,7 +4409,7 @@ describe('Protocol V2 firmware update targets', () => {
       fwBinaryMap: [],
     });
 
-    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenCalledTimes(1);
     expect((method as any).protocolV2StartFirmwareUpdate).not.toHaveBeenCalled();
     expect((method as any).waitForProtocolV2FirmwareUpdateComplete).not.toHaveBeenCalled();
   });
@@ -4341,19 +4440,12 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postProgressMessage = jest.fn();
 
-    const source = await openFirmwareByteSource({
-      binary: new Uint8Array(4097).buffer,
+    await (method as any).protocolV2CommonUpdateProcess({
+      payload: new Uint8Array(4097).buffer,
+      filePath: 'vol1:firmware.bin',
+      processedSize: 0,
+      totalSize: 4097,
     });
-    try {
-      await (method as any).protocolV2SourceUpdateProcess({
-        source,
-        filePath: 'vol1:firmware.bin',
-        processedSize: 0,
-        totalSize: 4097,
-      });
-    } finally {
-      await source?.close();
-    }
 
     const writePayloads = typedCall.mock.calls.map(call => call[2]);
     expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 4000]);
@@ -4404,16 +4496,12 @@ describe('Protocol V2 firmware update targets', () => {
     method.postProgressMessage = jest.fn();
 
     try {
-      const source = await openFirmwareByteSource({
-        binary: new Uint8Array(8001).buffer,
-      });
-      await (method as any).protocolV2SourceUpdateProcess({
-        source,
+      await (method as any).protocolV2CommonUpdateProcess({
+        payload: new Uint8Array(8001).buffer,
         filePath: 'vol0:/firmware.bin',
         processedSize: 0,
         totalSize: 8001,
       });
-      await source?.close();
     } finally {
       setTimeoutSpy.mockRestore();
     }
@@ -4445,21 +4533,16 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postProgressMessage = jest.fn();
     method.postTipMessage = jest.fn();
-    (method as any).recoverProtocolV2FileTransfer = jest.fn().mockResolvedValue(undefined);
 
-    const source = await openFirmwareByteSource({
-      binary: new Uint8Array(4097).buffer,
-    });
     await expect(
-      (method as any).protocolV2SourceUpdateProcess({
-        source,
+      (method as any).protocolV2WriteWholeFile({
+        payload: new Uint8Array(4097).buffer,
         filePath: 'vol0:/firmware.bin',
         processedSize: 0,
         totalSize: 4097,
       })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.EmmcFileWriteFirmwareError });
-    await source?.close();
-    expect(typedCall).toHaveBeenCalledTimes(6);
+    expect(typedCall).toHaveBeenCalledTimes(2);
   });
 
   test('caps native BLE firmware upload chunks below the WebUSB limit', async () => {
@@ -4492,19 +4575,12 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postProgressMessage = jest.fn();
 
-    const source = await openFirmwareByteSource({
-      binary: new Uint8Array(1801).buffer,
+    await (method as any).protocolV2CommonUpdateProcess({
+      payload: new Uint8Array(1801).buffer,
+      filePath: 'vol1:ble-firmware.bin',
+      processedSize: 0,
+      totalSize: 1801,
     });
-    try {
-      await (method as any).protocolV2SourceUpdateProcess({
-        source,
-        filePath: 'vol1:ble-firmware.bin',
-        processedSize: 0,
-        totalSize: 1801,
-      });
-    } finally {
-      await source?.close();
-    }
 
     const writePayloads = typedCall.mock.calls.map(call => call[2]);
     expect(writePayloads.map(payload => payload.file.offset)).toEqual([0, 1800]);
@@ -4621,9 +4697,9 @@ describe('Protocol V2 firmware update method', () => {
     const typedCall = jest
       .fn()
       .mockRejectedValue(
-        Object.assign(
-          new Error("Failed to execute 'open' on 'USBDevice': The device was disconnected"),
-          { name: 'NotFoundError' }
+        new DOMException(
+          "Failed to execute 'open' on 'USBDevice': The device was disconnected",
+          'NotFoundError'
         )
       );
 
@@ -4788,33 +4864,24 @@ describe('Protocol V2 firmware update method', () => {
 });
 
 describe('Protocol V2 firmware reconnect identity', () => {
-  test('keeps the host plan identity as the V4 reconnect anchor', () => {
-    const method = new FirmwareUpdateV4({
-      id: 1,
-      payload: {
-        method: 'firmwareUpdateV4',
-        platform: 'native',
-        expectedDeviceId: 'persisted-device-id',
-      },
-    });
-
-    method.init();
-
-    expect((method as any).params.expectedDeviceId).toBe('persisted-device-id');
-  });
-
-  test('requires the same physical serial before firmware transfer resumes', () => {
+  test('rejects a different physical serial before firmware transfer resumes', () => {
     expect(() => assertProtocolV2ReconnectIdentity('expected-serial', 'other-serial')).toThrow(
       'identity mismatch'
     );
-    expect(() => assertProtocolV2ReconnectIdentity('expected-serial', undefined)).toThrow(
-      'identity unavailable'
-    );
     expect(() =>
       assertProtocolV2ReconnectIdentity('expected-serial', 'expected-serial')
     ).not.toThrow();
+  });
+
+  test('fails closed when the physical serial is unavailable', () => {
+    expect(() => assertProtocolV2ReconnectIdentity('expected-serial', undefined)).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotFound })
+    );
     expect(() => assertProtocolV2ReconnectIdentity(undefined, 'actual-serial')).toThrow(
-      'identity unavailable'
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotFound })
+    );
+    expect(() => assertProtocolV2ReconnectIdentity(undefined, undefined)).toThrow(
+      expect.objectContaining({ errorCode: HardwareErrorCode.DeviceNotFound })
     );
   });
 
@@ -4847,6 +4914,54 @@ describe('Protocol V2 firmware reconnect identity', () => {
       { timeoutMs: 5000 }
     );
   });
+
+  test('rejects firmware update startup when DeviceInfo has no physical serial', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: { method: 'firmwareUpdateV4' },
+    });
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceInfo',
+      message: { protocol_version: 1, hw: {} },
+    });
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    await expect((method as any).captureProtocolV2PhysicalIdentity()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceNotFound,
+    });
+  });
+
+  test('uses the BLE read limit when reading an existing firmware bundle header', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'native',
+        chunkSize: 1800,
+      },
+    });
+    method.init();
+    const readChunkLengths: number[] = [];
+    const typedCall = jest.fn((requestType: string, _responseType: string, request: any) => {
+      if (requestType === 'FilesystemPathInfoQuery') {
+        return Promise.resolve({ message: { exist: true, directory: false, size: 0x52a0 } });
+      }
+      if (requestType === 'FilesystemFileRead') {
+        readChunkLengths.push(request.chunk_len);
+        return Promise.resolve({ message: { data: new Uint8Array(request.chunk_len) } });
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    await expect((method as any).readProtocolV2DeviceFileHeader('bundle.okpp')).resolves.toBeNull();
+    expect(readChunkLengths.length).toBeGreaterThan(1);
+    expect(Math.max(...readChunkLengths)).toBe(900);
+  });
 });
 
 describe('Protocol V2 explicit USB device selection', () => {
@@ -5028,6 +5143,70 @@ describe('Protocol V2 protected method execution', () => {
     ]);
   });
 
+  test('restores the expected hidden-wallet session before retrying after unlock', async () => {
+    const calls: string[] = [];
+    const method = {
+      name: 'evmSignMessage',
+      payload: { passphraseState: 'hidden-state' },
+      useDevicePassphraseState: true,
+      unlockPolicy: 'retry-on-locked',
+      run: jest
+        .fn()
+        .mockImplementationOnce(() => {
+          calls.push('run-1');
+          return Promise.reject(deviceLockedError());
+        })
+        .mockImplementationOnce(() => {
+          calls.push('run-2');
+          return Promise.resolve({ message: 'ok' });
+        }),
+    };
+    const typedCall = jest.fn((requestType: string, _responseType: string, request: any) => {
+      if (requestType === 'ProtocolInfoRequest') {
+        calls.push('negotiate-session');
+        return Promise.resolve({ message: { version: 2 } });
+      }
+      if (requestType === 'DeviceSessionGet') {
+        calls.push('resume-hidden-session');
+        expect(request).toEqual({ session_id: 'hidden-session' });
+        return Promise.resolve({
+          message: {
+            session_id: 'hidden-session',
+            btc_test_address: 'hidden-state',
+          },
+        });
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const device = {
+      features: { unlocked: true, passphraseProtection: true },
+      passphraseState: 'hidden-state',
+      commands: { typedCall },
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn(() => {
+        calls.push('unlock');
+        return Promise.resolve();
+      }),
+      getCurrentPassphraseProtection: () => true,
+      getInternalState: () => 'hidden-session',
+      clearInternalState: jest.fn(),
+      getCurrentDeviceId: () => 'wallet-device-id',
+      updateInternalState: jest.fn(() => calls.push('validate-hidden-session')),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+      message: 'ok',
+    });
+    expect(calls).toEqual([
+      'run-1',
+      'unlock',
+      'negotiate-session',
+      'resume-hidden-session',
+      'validate-hidden-session',
+      'run-2',
+    ]);
+  });
+
   test('unlocks before showing the method interaction when cached status is locked', async () => {
     const calls: string[] = [];
     const method = {
@@ -5218,22 +5397,27 @@ describe('Protocol V2 protected method execution', () => {
 describe('Protocol V2 current low-level methods', () => {
   test('routes device wipe to the Pro2 reset page until the operation completes', async () => {
     const v1TypedCall = jest.fn().mockResolvedValue({ message: { message: 'wiped' } });
+    const v1InvalidateAfterWipe = jest.fn();
     const v1Method = new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } });
     v1Method.init();
     (v1Method as any).device = stubDevice({
       isProtocolV2: () => false,
       commands: { typedCall: v1TypedCall },
+      invalidateAfterWipe: v1InvalidateAfterWipe,
     });
 
     await v1Method.run();
     expect(v1TypedCall).toHaveBeenCalledWith('WipeDevice', 'Success');
+    expect(v1InvalidateAfterWipe).toHaveBeenCalledTimes(1);
 
     const v2TypedCall = jest.fn().mockResolvedValue({ message: { message: 'accepted' } });
+    const v2InvalidateAfterWipe = jest.fn();
     const v2Method = new DeviceWipe({ id: 2, payload: { method: 'deviceWipe' } });
     v2Method.init();
     (v2Method as any).device = stubDevice({
       isProtocolV2: () => true,
       commands: { typedCall: v2TypedCall },
+      invalidateAfterWipe: v2InvalidateAfterWipe,
     });
 
     await expect(v2Method.run()).resolves.toEqual({ message: 'accepted' });
@@ -5241,6 +5425,7 @@ describe('Protocol V2 current low-level methods', () => {
     expect(v2TypedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
       page: DeviceSettingsPage.DeviceReset,
     });
+    expect(v2InvalidateAfterWipe).toHaveBeenCalledTimes(1);
     expect(v2Method.protocolV2UiInteraction).toEqual({
       request: 'button',
       source: 'method-lifecycle',
@@ -5252,6 +5437,21 @@ describe('Protocol V2 current low-level methods', () => {
     });
   });
 
+  test('keeps the existing identity cache when device wipe fails', async () => {
+    const wipeError = new Error('wipe failed');
+    const invalidateAfterWipe = jest.fn();
+    const method = new DeviceWipe({ id: 1, payload: { method: 'deviceWipe' } });
+    method.init();
+    (method as any).device = stubDevice({
+      isProtocolV2: () => true,
+      commands: { typedCall: jest.fn().mockRejectedValue(wipeError) },
+      invalidateAfterWipe,
+    });
+
+    await expect(method.run()).rejects.toBe(wipeError);
+    expect(invalidateAfterWipe).not.toHaveBeenCalled();
+  });
+
   test('routes Change PIN by protocol and waits for the Pro2 operation result', async () => {
     const v1TypedCall = jest.fn().mockResolvedValue({ message: { message: 'ok' } });
     const v1Method = new DeviceChangePin({
@@ -5402,14 +5602,12 @@ describe('Protocol V2 current low-level methods', () => {
   });
 
   test.each([
-    ['label', { label: 'My Pro 2' }],
     ['language', { language: 'ja' }],
     ['brightness', { brightness: 80 }],
     ['haptic feedback', { hapticFeedback: true }],
     [
       'combined lock-free settings',
       {
-        label: 'My Pro 2',
         language: 'ja',
         brightness: 80,
         hapticFeedback: true,
@@ -5427,8 +5625,10 @@ describe('Protocol V2 current low-level methods', () => {
   });
 
   test.each([
+    ['label', { label: 'My Pro 2' }],
     ['auto lock', { autoLockDelayMs: 60_000 }],
     ['auto shutdown', { autoShutdownDelayMs: 120_000 }],
+    ['label mixed with lock-free settings', { label: 'My Pro 2', brightness: 80 }],
     ['mixed protected settings', { brightness: 80, autoLockDelayMs: 60_000 }],
     ['other protected settings', { usbLockEnabled: true }],
   ])('unlocks before changing unified Protocol V2 %s', (_name, settings) => {