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

package/__tests__/protocol-v2.test.ts

@@ -1,4 +1,4 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EFirmwareType, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { DeviceRebootType, DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import * as firmwareBinaryApi from '../src/api/firmware/getBinary';
@@ -83,6 +83,7 @@ import {
   isMethodVersionRangeUnsupported,
 } from '../src/utils';
 import { getDeviceFirmwareVersion } from '../src/utils/deviceVersionUtils';
+import { openFirmwareByteSource } from '../src/api/firmware/FirmwareArtifactSource';
 import {
   getPassphraseState,
   getPassphraseStateWithRefreshDeviceInfo,
@@ -122,7 +123,7 @@ describe('DeviceUploadWallpaper', () => {
     const result = await method.run();
 
     expect(method.requireProtocolV2).toBe(true);
-    expect(method.unlockPolicy).toBe('retry-on-locked');
+    expect(method.unlockPolicy).toBe('unlock-before-run');
     expect(typedCall).toHaveBeenNthCalledWith(1, 'FilesystemDirMake', 'Success', {
       path: 'vol1:/wallpapers',
     });
@@ -211,7 +212,7 @@ describe('UploadPortfolio', () => {
     method.init();
     const result = await method.run();
 
-    expect(method.unlockPolicy).toBe('retry-on-locked');
+    expect(method.unlockPolicy).toBe('unlock-before-run');
     expect(method.protocolV2UiMode).toBe('none');
     expect(method.protocolV2UiInteraction).toBeUndefined();
     expect(method.payload.emitProgress).toBe(false);
@@ -711,7 +712,9 @@ describe('Protocol V2 feature adapter', () => {
       unlockedAttachPin: false,
       resumed: false,
     });
-    expect(typedCall).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
     expect(device.getInternalState()).toBeUndefined();
   });
 
@@ -721,7 +724,13 @@ describe('Protocol V2 feature adapter', () => {
       { ...descriptor, protocolType: 'V2' } as any,
       { status: { passphrase_enabled: false, unlocked: true } }
     );
-    const typedCall = jest.fn();
+    const typedCall = 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' });
@@ -735,7 +744,9 @@ describe('Protocol V2 feature adapter', () => {
     });
 
     expect(promptPassphrase).not.toHaveBeenCalled();
-    expect(typedCall).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
   });
 
   test('preserves cached settings only while Protocol V2 physical identity stays the same', () => {
@@ -790,13 +801,8 @@ describe('Protocol V2 feature adapter', () => {
       }
     );
     const typedCall = jest.fn().mockImplementation((request: string) => {
-      if (request === 'DeviceSessionGet') {
-        return Promise.resolve({
-          message: {
-            btc_test_address: 'state-after-unlock',
-            session_id: 'session-after-unlock',
-          },
-        });
+      if (request === 'ProtocolInfoRequest') {
+        return Promise.resolve({ message: { version: 2 } });
       }
       if (request === 'DeviceStatusGet') {
         return Promise.resolve({
@@ -825,7 +831,9 @@ describe('Protocol V2 feature adapter', () => {
 
     expect(unlockDevice).toHaveBeenCalledTimes(1);
     expect(promptPassphrase).not.toHaveBeenCalled();
-    expect(typedCall).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
   });
 
   test('onlyMainPin takes precedence over a cached hidden-wallet state', async () => {
@@ -836,14 +844,28 @@ describe('Protocol V2 feature adapter', () => {
     );
     device.passphraseState = 'hidden-state';
     preloadSessionCache('main-wallet-device', 'hidden-state', 'hidden-session');
-    const typedCall = jest.fn();
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceSession',
+      message: {
+        btc_test_address: 'main-wallet-state',
+        session_id: 'main-wallet-session',
+      },
+    });
     (device as any).commands = { typedCall };
 
-    await getPassphraseState(device, {
-      onlyMainPin: true,
+    await expect(
+      getPassphraseState(device, {
+        onlyMainPin: true,
+      })
+    ).resolves.toMatchObject({
+      passphraseState: undefined,
+      newSession: undefined,
     });
-    expect(typedCall).not.toHaveBeenCalled();
-    expect(device.getInternalState()).toBe('hidden-session');
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
+    expect(device.passphraseState).toBeUndefined();
+    expect(device.getInternalState()).toBeUndefined();
   });
 
   test('gets the wallet session selected by the Protocol V2 device', async () => {
@@ -867,7 +889,7 @@ describe('Protocol V2 feature adapter', () => {
       type: 'DeviceSession',
       message: { session_id: 'hidden-session', btc_test_address: 'hidden-state' },
     });
-    const promptPassphrase = jest.fn();
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'hidden secret' });
     (device as any).commands = { typedCall, promptPassphrase };
 
     await expect(getProtocolV2WalletSession(device)).resolves.toMatchObject({
@@ -875,8 +897,10 @@ describe('Protocol V2 feature adapter', () => {
       passphraseState: 'hidden-state',
     });
 
-    expect(promptPassphrase).not.toHaveBeenCalled();
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(promptPassphrase).toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      select: { host_passphrase: { passphrase: 'hidden secret' } },
+    });
   });
 
   test('deviceStatusGet returns raw DeviceStatus and updates dynamic features', async () => {
@@ -980,8 +1004,8 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'session-b',
     });
 
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'session-a',
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      resume: { session_id: 'session-a' },
     });
     expect(device.getInternalState()).toBe('session-b');
   });
@@ -999,13 +1023,18 @@ describe('Protocol V2 feature adapter', () => {
     preloadSessionCache('stable-device-2', 'state-a', 'session-a');
     const typedCall = jest.fn().mockResolvedValue({
       type: 'DeviceSession',
-      message: { session_id: 'main-session' },
+      message: {
+        session_id: 'main-session',
+        btc_test_address: 'main-wallet-state',
+      },
     });
     (device as any).commands = { typedCall };
 
     await getProtocolV2WalletSession(device, { onlyMainPin: true });
 
-    expect(typedCall).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
     expect(device.getInternalState()).toBeUndefined();
   });
 
@@ -1027,11 +1056,14 @@ describe('Protocol V2 feature adapter', () => {
     );
     device.passphraseState = 'state-a';
     preloadSessionCache('stable-device-3', 'state-a', 'session-a');
-    const typedCall = jest.fn().mockRejectedValue(
-      Object.assign(new Error('SE request failed'), {
-        errorCode: HardwareErrorCode.RuntimeError,
-      })
-    );
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockRejectedValue(
+        Object.assign(new Error('SE request failed'), {
+          errorCode: HardwareErrorCode.RuntimeError,
+        })
+      );
     const promptPassphrase = jest.fn();
     (device as any).commands = { typedCall, promptPassphrase };
 
@@ -1039,7 +1071,8 @@ describe('Protocol V2 feature adapter', () => {
       errorCode: HardwareErrorCode.RuntimeError,
     });
     expect(typedCall.mock.calls).toEqual([
-      ['DeviceSessionGet', 'DeviceSession', { session_id: 'session-a' }],
+      ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
+      ['DeviceSessionOpen', 'DeviceSession', { resume: { session_id: 'session-a' } }],
     ]);
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.getInternalState()).toBeUndefined();
@@ -1061,11 +1094,14 @@ describe('Protocol V2 feature adapter', () => {
         },
       }
     );
-    const typedCall = jest.fn().mockRejectedValue(
-      Object.assign(new Error('Invalid session'), {
-        errorCode: HardwareErrorCode.WalletSessionInvalid,
-      })
-    );
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockRejectedValue(
+        Object.assign(new Error('Invalid session'), {
+          errorCode: HardwareErrorCode.WalletSessionInvalid,
+        })
+      );
     (device as any).commands = {
       typedCall,
       promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'new-secret' }),
@@ -1074,7 +1110,14 @@ describe('Protocol V2 feature adapter', () => {
     await expect(getProtocolV2WalletSession(device)).rejects.toMatchObject({
       errorCode: HardwareErrorCode.WalletSessionInvalid,
     });
-    expect(typedCall.mock.calls).toEqual([['DeviceSessionGet', 'DeviceSession', {}]]);
+    expect(typedCall.mock.calls).toEqual([
+      ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
+      [
+        'DeviceSessionOpen',
+        'DeviceSession',
+        { select: { host_passphrase: { passphrase: 'new-secret' } } },
+      ],
+    ]);
   });
 
   test('rejects a mismatched Pro2 wallet state and clears the selected cache entry', async () => {
@@ -1112,7 +1155,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
   });
 
-  test('unlocks and retries DeviceSessionGet when wallet selection is locked', async () => {
+  test('unlocks and retries DeviceSessionOpen when wallet selection is locked', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-4',
       path: 'cache-path-4',
@@ -1127,6 +1170,7 @@ describe('Protocol V2 feature adapter', () => {
     });
     const typedCall = jest
       .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
       .mockRejectedValueOnce(lockedError)
       .mockResolvedValueOnce({
         message: {
@@ -1145,7 +1189,7 @@ describe('Protocol V2 feature adapter', () => {
       passphraseState: 'state-after-unlock',
     });
     expect(unlockDevice).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenCalledTimes(3);
   });
 
   test('does not request a Pro2 wallet session before features are initialized', async () => {
@@ -1262,6 +1306,7 @@ describe('Protocol V2 feature adapter', () => {
         promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'state-pro2-secret' }),
       },
       updateInternalState,
+      getInternalState: () => 'feature-session',
       getCurrentDeviceId: () => 'pro-device-id',
       getCurrentPassphraseProtection: () => true,
     }) as any;
@@ -1472,7 +1517,9 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
     device.passphraseState = 'state-auto';
     expect(device.getInternalState()).toBe('session-auto');
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionOpen', 'DeviceSession', {
+      select: { host_passphrase: { passphrase: 'state-auto-secret' } },
+    });
   });
 
   test('does not mark Pro2 passphrase enabled from a main PIN session alone', async () => {
@@ -1481,6 +1528,7 @@ describe('Protocol V2 feature adapter', () => {
       type: 'DeviceSession',
       message: {
         session_id: 'main-pin-session',
+        btc_test_address: 'main-wallet-state',
       },
     });
 
@@ -1510,7 +1558,9 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.features?.passphraseProtection).toBe(false);
     expect(device.features?.sessionId).toBeNull();
     expect(device.getInternalState()).toBeUndefined();
-    expect(typedCall).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
   });
 
   test('does not let skipPassphraseCheck hide Pro2 passphrase state mismatch', async () => {
@@ -1542,12 +1592,20 @@ describe('Protocol V2 feature adapter', () => {
     );
 
     expect(device.getInternalState()).toBeUndefined();
-    expect(typedCall).toHaveBeenNthCalledWith(1, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionOpen', 'DeviceSession', {
+      select: { host_passphrase: { passphrase: 'expected-secret' } },
+    });
   });
 
   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();
+    const typedCall = 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,
@@ -1567,7 +1625,10 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.checkPassphraseStateSafety('stale-hidden-state', true, false)
     ).resolves.toBe(true);
-    expect(typedCall).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
   });
 
   test('marks fallback features as unavailable when DeviceInfo is missing', () => {
@@ -2226,7 +2287,7 @@ describe('Protocol V2 feature adapter', () => {
       ['DeviceSessionAskPin', 'Success', undefined, { timeoutMs: 120_000 }],
     ]);
     expect(typedCall).not.toHaveBeenCalledWith(
-      'DeviceSessionGet',
+      'DeviceSessionOpen',
       'DeviceSession',
       expect.anything()
     );
@@ -2669,6 +2730,7 @@ describe('Protocol V2 firmware update targets', () => {
         return Promise.resolve({
           type: 'DeviceInfo',
           message: {
+            hw: { serial_no: 'BLE-PRO2-SERIAL' },
             fw: {
               bootloader: { version: '0.0.0' },
               application: { version: '0.0.0' },
@@ -2689,6 +2751,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
     const commands = { typedCall };
 
+    (method as any).protocolV2ExpectedSerialNumber = 'BLE-PRO2-SERIAL';
     (method as any).isBleReconnect = jest.fn(() => true);
     (method as any).device = stubDevice({
       originalDescriptor: { id: 'ble-id', path: 'ble-path', protocolType: 'V2' },
@@ -2737,7 +2800,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
-  test('enters Protocol V2 bootloader before upload', async () => {
+  test('delegates Protocol V2 mode transition to the phase executor', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -2750,6 +2813,7 @@ describe('Protocol V2 firmware update targets', () => {
       originalDescriptor: { id: 'ble-id', path: 'ble-path', protocolType: 'V2' },
       features: { capabilities: [] },
     });
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
     (method as any).prepareBootloaderBinary = jest.fn().mockReturnValue(null);
     (method as any).collectExplicitTargetBinaries = jest.fn().mockReturnValue([
       {
@@ -2771,7 +2835,7 @@ describe('Protocol V2 firmware update targets', () => {
 
     await method.run();
 
-    expect((method as any).enterProtocolV2BootloaderMode).toHaveBeenCalledTimes(1);
+    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
     expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
       fwBinaryMap: [
         {
@@ -2815,6 +2879,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
     (method as any).device.getCommands = () => ({ typedCall });
+    (method as any).protocolV2ExpectedSerialNumber = 'PR9999999999';
     method.postTipMessage = jest.fn();
 
     await (method as any).enterProtocolV2BootloaderMode();
@@ -2880,7 +2945,7 @@ describe('Protocol V2 firmware update targets', () => {
       });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
     (method as any).device.getCommands = () => ({ typedCall });
-    (method as any).protocolV2ExpectedDeviceId = '8693920D7CA90CEC4A88353D';
+    (method as any).protocolV2ExpectedSerialNumber = 'PR9999999999';
 
     await (method as any).waitForProtocolV2BootloaderMode(60 * 1000, 0);
 
@@ -2999,7 +3064,7 @@ describe('Protocol V2 firmware update targets', () => {
         fw: { application: { version: '1.0.0' } },
       },
     });
-    (method as any).protocolV2ExpectedDeviceId = 'expected-device';
+    (method as any).protocolV2ExpectedSerialNumber = 'expected-serial';
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
@@ -3025,6 +3090,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postTipMessage = jest.fn();
     (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2Reboot = jest.fn().mockResolvedValue({
       message: 'Device rebooted successfully',
     });
@@ -3088,9 +3154,9 @@ describe('Protocol V2 firmware update targets', () => {
     const typedCall = jest
       .fn()
       .mockRejectedValue(
-        new DOMException(
-          "Failed to execute 'open' on 'USBDevice': The device was disconnected",
-          'NotFoundError'
+        Object.assign(
+          new Error("Failed to execute 'open' on 'USBDevice': The device was disconnected"),
+          { name: 'NotFoundError' }
         )
       );
 
@@ -3161,6 +3227,7 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => ({ typedCall }),
     });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
     method.postProgressMessage = jest.fn();
 
     await (method as any).waitForProtocolV2FirmwareUpdateComplete([
@@ -3177,7 +3244,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('accepts a missing firmware status handler as an app reboot signal', async () => {
+  test('does not treat a missing firmware status handler as install completion', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -3193,14 +3260,42 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => ({ typedCall }),
     });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
     method.postProgressMessage = jest.fn();
 
-    await (method as any).waitForProtocolV2FirmwareUpdateComplete([
-      { target_id: 4, path: 'vol0:/application_p1.bin' },
-    ]);
+    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']);
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceFirmwareUpdateStatusGet',
+      'DeviceInfoGet',
+    ]);
+  });
+
+  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');
   });
 
   test('polls target status after update ACK and finishes when all targets complete', async () => {
@@ -3225,6 +3320,7 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => ({ typedCall }),
     });
     (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
     method.postProgressMessage = jest.fn();
 
     await expect(
@@ -3342,6 +3438,7 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => ({ typedCall }),
     });
     (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
     (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(false);
 
     await expect(
@@ -3377,10 +3474,14 @@ describe('Protocol V2 firmware update targets', () => {
     const writtenPaths: string[] = [];
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockImplementation(params => {
+    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockImplementation(params => {
       writtenPaths.push(params.filePath);
-      return Number(params.processedSize ?? 0) + Number(params.payload.byteLength);
+      return Number(params.processedSize ?? 0) + Number(params.source.size);
     });
+    (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
@@ -3420,10 +3521,12 @@ describe('Protocol V2 firmware update targets', () => {
       'vol0:/coprocessor.bin',
       1
     );
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(1);
-    expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
+    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, {
       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' },
@@ -3433,7 +3536,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect((method as any).waitForProtocolV2FirmwareUpdateComplete).toHaveBeenCalled();
   });
 
-  test('announces one transfer when syncing resource bundles and staging firmware', async () => {
+  test('announces separate resource and component transfer phases', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -3443,11 +3546,14 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest
+    (method as any).protocolV2SourceUpdateProcess = jest
       .fn()
       .mockImplementation(params =>
-        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.payload.byteLength))
+        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.source.size))
       );
+    (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
@@ -3467,21 +3573,22 @@ describe('Protocol V2 firmware update targets', () => {
         {
           fileName: 'application_p1.bin',
           binary: new Uint8Array([3]).buffer,
-          targetId: 3,
+          targetId: 4,
         },
       ],
     });
 
-    expect(method.postTipMessage).toHaveBeenCalledTimes(2);
+    expect(method.postTipMessage).toHaveBeenCalledTimes(3);
     expect(method.postTipMessage).toHaveBeenNthCalledWith(1, 'StartTransferData');
-    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'ConfirmOnDevice');
-    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenNthCalledWith(
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(2, 'StartTransferData');
+    expect(method.postTipMessage).toHaveBeenNthCalledWith(3, 'ConfirmOnDevice');
+    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenNthCalledWith(
       1,
-      expect.objectContaining({ processedSize: 0, totalSize: 3 })
+      expect.objectContaining({ processedSize: 0, totalSize: 2 })
     );
-    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenNthCalledWith(
+    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenNthCalledWith(
       2,
-      expect.objectContaining({ processedSize: 2, totalSize: 3 })
+      expect.objectContaining({ processedSize: 0, totalSize: 1 })
     );
   });
 
@@ -3495,7 +3602,8 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).protocolV2SourceUpdateProcess = jest.fn().mockResolvedValue(3);
+    (method as any).enterProtocolV2BootloaderMode = jest.fn().mockResolvedValue(undefined);
     (method as any).device = stubDevice({
       getCommands: () => ({
         typedCall: jest.fn().mockResolvedValue({
@@ -3541,11 +3649,14 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest
+    (method as any).protocolV2SourceUpdateProcess = jest
       .fn()
       .mockImplementation(params =>
-        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.payload.byteLength))
+        Promise.resolve(Number(params.processedSize ?? 0) + Number(params.source.size))
       );
+    (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
@@ -3725,7 +3836,7 @@ describe('Protocol V2 firmware update targets', () => {
           {
             name: 'images',
             url: 'https://example.com/images.okpkg',
-            devicePath: 'vol0:/resource/images/images.okpkg',
+            devicePath: 'VOL0:/resource/images/images.okpkg',
             version: [2, 0, 0],
             payloadHash: 'ab'.repeat(64),
             headerHash: 'cd'.repeat(64),
@@ -3760,6 +3871,58 @@ describe('Protocol V2 firmware update targets', () => {
     getFirmwareLatestReleaseSpy.mockRestore();
   });
 
+  test('rejects remote RESC bundle paths before download or bootloader entry', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        targetsToUpdate: ['resource'],
+      },
+    });
+    method.init();
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+
+    const getSysResourceBinarySpy = jest.spyOn(firmwareBinaryApi, 'getSysResourceBinary');
+    const getFirmwareLatestReleaseSpy = jest
+      .spyOn(DataManager, 'getFirmwareLatestRelease')
+      .mockReturnValue({
+        required: false,
+        version: [1, 0, 0],
+        url: '',
+        resourceBundles: [
+          {
+            name: 'images',
+            url: 'https://example.com/images.okpkg',
+            devicePath: 'vol0:/resource/../images.okpkg',
+          },
+        ],
+        fingerprint: '',
+        changelog: {
+          'zh-CN': '',
+          'en-US': '',
+        },
+      });
+
+    (method as any).device = stubDevice({
+      originalDescriptor: { protocolType: 'V2' },
+      features: { deviceType: 'pro2', firmwareVersion: '1.0.0', capabilities: [] },
+    });
+    (method as any).prepareRemoteProtocolV2Binaries = jest.fn().mockResolvedValue({
+      bootloaderBinary: null,
+      fwBinaryMap: [],
+    });
+    (method as any).enterProtocolV2BootloaderMode = jest.fn();
+    method.postTipMessage = jest.fn();
+
+    await expect(method.run()).rejects.toThrow('resourceBundles[0].devicePath');
+    expect(getSysResourceBinarySpy).not.toHaveBeenCalled();
+    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
+
+    getSysResourceBinarySpy.mockRestore();
+    getFirmwareLatestReleaseSpy.mockRestore();
+  });
+
   test('downloads and validates remote RESC bundles before entering bootloader', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -3770,6 +3933,7 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     method.init();
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
 
     const order: string[] = [];
     const resourceBinary = new Uint8Array([1, 2, 3]).buffer;
@@ -3789,7 +3953,7 @@ describe('Protocol V2 firmware update targets', () => {
           {
             name: 'images',
             url: 'https://example.com/images.okpkg',
-            devicePath: 'vol0:/resource/images/images.okpkg',
+            devicePath: '  VOL0:/resource/images/images.okpkg  ',
           },
         ],
         fingerprint: '',
@@ -3811,7 +3975,9 @@ describe('Protocol V2 firmware update targets', () => {
       order.push('bootloader');
       return Promise.resolve(true);
     });
-    (method as any).executeProtocolV2Update = jest.fn().mockResolvedValue(undefined);
+    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).exitProtocolV2BootloaderToNormal = jest.fn().mockResolvedValue(undefined);
     (method as any).waitForProtocolV2FinalFeatures = jest.fn().mockResolvedValue({
       bootloaderVersion: '1.0.0',
@@ -3823,7 +3989,7 @@ describe('Protocol V2 firmware update targets', () => {
     await method.run();
 
     expect(order).toEqual(['download', 'bootloader']);
-    expect((method as any).executeProtocolV2Update).toHaveBeenCalledWith({
+    expect(executeProtocolV2UpdateSpy).toHaveBeenCalledWith({
       bootloaderBinary: null,
       fwBinaryMap: [],
       resourceBundles: [
@@ -3836,6 +4002,7 @@ describe('Protocol V2 firmware update targets', () => {
       ],
     });
 
+    executeProtocolV2UpdateSpy.mockRestore();
     getSysResourceBinarySpy.mockRestore();
     getFirmwareLatestReleaseSpy.mockRestore();
   });
@@ -3850,6 +4017,7 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     method.init();
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
 
     const getSysResourceBinarySpy = jest
       .spyOn(firmwareBinaryApi, 'getSysResourceBinary')
@@ -3961,6 +4129,7 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     method.init();
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
 
     const remoteBinaries = {
       bootloaderBinary: new Uint8Array([1]).buffer,
@@ -4007,6 +4176,7 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     method.init();
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
 
     (method as any).device = stubDevice({
       originalDescriptor: { protocolType: 'V2' },
@@ -4042,12 +4212,13 @@ describe('Protocol V2 firmware update targets', () => {
         resourceBundleFiles: [
           {
             binary: resourceBundle,
-            devicePath: 'vol0:/resource/images/images.okpkg',
+            devicePath: '  VOL0:/resource/images/images.okpkg  ',
           },
         ],
       },
     });
     method.init();
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
 
     (method as any).device = stubDevice({
       originalDescriptor: { protocolType: 'V2' },
@@ -4080,6 +4251,36 @@ describe('Protocol V2 firmware update targets', () => {
     );
   });
 
+  test('rejects manual RESC bundle paths before bootloader entry', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        platform: 'web',
+        resourceBundleFiles: [
+          {
+            binary: new Uint8Array([1, 2, 3]).buffer,
+            devicePath: 'vol2:/resource/images/images.okpkg',
+          },
+        ],
+      },
+    });
+    method.init();
+    (method as any).captureProtocolV2PhysicalIdentity = jest.fn().mockResolvedValue(undefined);
+
+    (method as any).device = stubDevice({
+      originalDescriptor: { protocolType: 'V2' },
+      features: { deviceType: 'pro2', firmwareVersion: '0.0.0', capabilities: [] },
+    });
+    (method as any).prepareRemoteProtocolV2Binaries = jest.fn();
+    (method as any).enterProtocolV2BootloaderMode = jest.fn();
+    method.postTipMessage = jest.fn();
+
+    await expect(method.run()).rejects.toThrow('resourceBundleFiles[0].devicePath');
+    expect((method as any).prepareRemoteProtocolV2Binaries).not.toHaveBeenCalled();
+    expect((method as any).enterProtocolV2BootloaderMode).not.toHaveBeenCalled();
+  });
+
   test('syncs resource bundles without sending a firmware install request', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4090,7 +4291,10 @@ describe('Protocol V2 firmware update targets', () => {
 
     method.postTipMessage = jest.fn();
     method.postProgressMessage = jest.fn();
-    (method as any).protocolV2CommonUpdateProcess = jest.fn().mockResolvedValue(3);
+    (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).protocolV2StartFirmwareUpdate = jest.fn();
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest.fn();
 
@@ -4106,7 +4310,7 @@ describe('Protocol V2 firmware update targets', () => {
       fwBinaryMap: [],
     });
 
-    expect((method as any).protocolV2CommonUpdateProcess).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenCalledTimes(1);
     expect((method as any).protocolV2StartFirmwareUpdate).not.toHaveBeenCalled();
     expect((method as any).waitForProtocolV2FirmwareUpdateComplete).not.toHaveBeenCalled();
   });
@@ -4137,12 +4341,19 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postProgressMessage = jest.fn();
 
-    await (method as any).protocolV2CommonUpdateProcess({
-      payload: new Uint8Array(4097).buffer,
-      filePath: 'vol1:firmware.bin',
-      processedSize: 0,
-      totalSize: 4097,
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(4097).buffer,
     });
+    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]);
@@ -4193,12 +4404,16 @@ describe('Protocol V2 firmware update targets', () => {
     method.postProgressMessage = jest.fn();
 
     try {
-      await (method as any).protocolV2CommonUpdateProcess({
-        payload: new Uint8Array(8001).buffer,
+      const source = await openFirmwareByteSource({
+        binary: new Uint8Array(8001).buffer,
+      });
+      await (method as any).protocolV2SourceUpdateProcess({
+        source,
         filePath: 'vol0:/firmware.bin',
         processedSize: 0,
         totalSize: 8001,
       });
+      await source?.close();
     } finally {
       setTimeoutSpy.mockRestore();
     }
@@ -4230,16 +4445,21 @@ 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).protocolV2WriteWholeFile({
-        payload: new Uint8Array(4097).buffer,
+      (method as any).protocolV2SourceUpdateProcess({
+        source,
         filePath: 'vol0:/firmware.bin',
         processedSize: 0,
         totalSize: 4097,
       })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.EmmcFileWriteFirmwareError });
-    expect(typedCall).toHaveBeenCalledTimes(2);
+    await source?.close();
+    expect(typedCall).toHaveBeenCalledTimes(6);
   });
 
   test('caps native BLE firmware upload chunks below the WebUSB limit', async () => {
@@ -4272,12 +4492,19 @@ describe('Protocol V2 firmware update targets', () => {
     });
     method.postProgressMessage = jest.fn();
 
-    await (method as any).protocolV2CommonUpdateProcess({
-      payload: new Uint8Array(1801).buffer,
-      filePath: 'vol1:ble-firmware.bin',
-      processedSize: 0,
-      totalSize: 1801,
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(1801).buffer,
     });
+    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]);
@@ -4394,9 +4621,9 @@ describe('Protocol V2 firmware update method', () => {
     const typedCall = jest
       .fn()
       .mockRejectedValue(
-        new DOMException(
-          "Failed to execute 'open' on 'USBDevice': The device was disconnected",
-          'NotFoundError'
+        Object.assign(
+          new Error("Failed to execute 'open' on 'USBDevice': The device was disconnected"),
+          { name: 'NotFoundError' }
         )
       );
 
@@ -4561,29 +4788,64 @@ describe('Protocol V2 firmware update method', () => {
 });
 
 describe('Protocol V2 firmware reconnect identity', () => {
-  test('rejects a different device before firmware transfer resumes', () => {
-    expect(() => assertProtocolV2ReconnectIdentity('expected-device', 'other-device')).toThrow(
+  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', () => {
+    expect(() => assertProtocolV2ReconnectIdentity('expected-serial', 'other-serial')).toThrow(
       'identity mismatch'
     );
-    expect(() => assertProtocolV2ReconnectIdentity('expected-device', undefined)).toThrow(
+    expect(() => assertProtocolV2ReconnectIdentity('expected-serial', undefined)).toThrow(
       'identity unavailable'
     );
     expect(() =>
-      assertProtocolV2ReconnectIdentity('expected-device', 'expected-device')
+      assertProtocolV2ReconnectIdentity('expected-serial', 'expected-serial')
     ).not.toThrow();
+    expect(() => assertProtocolV2ReconnectIdentity(undefined, 'actual-serial')).toThrow(
+      'identity unavailable'
+    );
   });
 
-  test('allows bootloader reconnect without wallet device id after USB identity is selected', () => {
-    expect(() =>
-      assertProtocolV2ReconnectIdentity('expected-device', undefined, {
-        allowMissingActual: true,
-      })
-    ).not.toThrow();
-    expect(() =>
-      assertProtocolV2ReconnectIdentity('expected-device', 'other-device', {
-        allowMissingActual: true,
-      })
-    ).toThrow('identity mismatch');
+  test('captures physical identity from active DeviceInfo instead of wallet deviceId', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'DeviceInfo',
+      message: {
+        protocol_version: 1,
+        hw: { serial_no: 'PRO2-PHYSICAL-1' },
+      },
+    });
+    (method as any).device = stubDevice({
+      features: { deviceId: 'wallet-derived-id' },
+      getCommands: () => ({ typedCall }),
+    });
+
+    await (method as any).captureProtocolV2PhysicalIdentity();
+
+    expect((method as any).protocolV2ExpectedSerialNumber).toBe('PRO2-PHYSICAL-1');
+    expect(typedCall).toHaveBeenCalledWith(
+      'DeviceInfoGet',
+      'DeviceInfo',
+      expect.objectContaining({ targets: expect.objectContaining({ hw: true }) }),
+      { timeoutMs: 5000 }
+    );
   });
 });
 
@@ -4661,7 +4923,7 @@ describe('Protocol V2 protected method execution', () => {
       errorCode: HardwareErrorCode.DeviceLocked,
     });
 
-  test('uses locked retry by default for SDK business methods', () => {
+  test('does not replay SDK methods unless they are explicitly classified as retry-safe', () => {
     class TestBusinessMethod extends BaseMethod {
       init() {}
 
@@ -4675,7 +4937,7 @@ describe('Protocol V2 protected method execution', () => {
       payload: { method: 'testBusinessMethod' },
     } as any);
 
-    expect(method.unlockPolicy).toBe('retry-on-locked');
+    expect(method.unlockPolicy).toBe('none');
   });
 
   test.each([
@@ -4770,7 +5032,7 @@ describe('Protocol V2 protected method execution', () => {
     const calls: string[] = [];
     const method = {
       name: 'deviceSettingsPageShow',
-      unlockPolicy: 'retry-on-locked',
+      unlockPolicy: 'unlock-before-run',
       protocolV2UiInteraction: { reason: 'settings-page' },
       run: jest.fn(() => {
         calls.push('run');
@@ -4854,14 +5116,12 @@ describe('Protocol V2 protected method execution', () => {
   test('keeps auto unlock but suppresses all synthesized UI for eventless methods', async () => {
     const method = {
       name: 'uploadPortfolio',
-      unlockPolicy: 'retry-on-locked',
+      unlockPolicy: 'unlock-before-run',
       protocolV2UiMode: 'none',
-      run: jest
-        .fn()
-        .mockRejectedValueOnce(deviceLockedError())
-        .mockResolvedValueOnce({ message: 'ok' }),
+      run: jest.fn().mockResolvedValue({ message: 'ok' }),
     };
     const device = {
+      features: { unlocked: false },
       isProtocolV2: () => true,
       unlockDevice: jest.fn().mockResolvedValue(undefined),
     };
@@ -4880,6 +5140,24 @@ describe('Protocol V2 protected method execution', () => {
     expect(uiCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
   });
 
+  test('does not replay a state-changing method after a locked response', async () => {
+    const error = deviceLockedError();
+    const method = {
+      name: 'uploadPortfolio',
+      unlockPolicy: 'unlock-before-run',
+      run: jest.fn().mockRejectedValue(error),
+    };
+    const device = {
+      features: { unlocked: true },
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn(),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).rejects.toBe(error);
+    expect(method.run).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+  });
+
   test('does not retry when unlock fails or when the retry is still locked', async () => {
     const initialError = deviceLockedError();
     const unlockError = new Error('PIN cancelled');
@@ -4959,7 +5237,7 @@ describe('Protocol V2 current low-level methods', () => {
     });
 
     await expect(v2Method.run()).resolves.toEqual({ message: 'accepted' });
-    expect(v2Method.unlockPolicy).toBe('retry-on-locked');
+    expect(v2Method.unlockPolicy).toBe('unlock-before-run');
     expect(v2TypedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
       page: DeviceSettingsPage.DeviceReset,
     });
@@ -5002,7 +5280,7 @@ describe('Protocol V2 current low-level methods', () => {
     });
 
     await expect(v2Method.run()).resolves.toEqual({ message: 'accepted' });
-    expect(v2Method.unlockPolicy).toBe('retry-on-locked');
+    expect(v2Method.unlockPolicy).toBe('unlock-before-run');
     expect(v2TypedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
       page: DeviceSettingsPage.DevicePinChange,
     });
@@ -5103,32 +5381,24 @@ describe('Protocol V2 current low-level methods', () => {
     });
   });
 
-  test('returns canonical public state after explicit device unlock', async () => {
+  test('preserves the legacy Features response after explicit device unlock', async () => {
     const method = new DeviceUnlock({
       id: 1,
       payload: { method: 'deviceUnlock' },
     });
     method.init();
 
-    const state = {
-      schemaVersion: 1,
-      revision: 2,
-      updatedAt: 1,
+    const features = {
       protocol: 'V2',
-      protocolVersion: 1,
-      identity: {},
-      status: { unlocked: true },
-      settings: {},
-      versions: {},
-      capabilities: [],
+      unlocked: true,
+      sessionId: null,
+      session_id: null,
     };
-    const unlockDevice = jest.fn().mockResolvedValue({ raw: { protocolV2DeviceStatus: {} } });
-    const getDeviceState = jest.fn().mockResolvedValue(state);
-    (method as any).device = { unlockDevice, getDeviceState };
+    const unlockDevice = jest.fn().mockResolvedValue(features);
+    (method as any).device = { unlockDevice };
 
-    await expect(method.run()).resolves.toBe(state);
+    await expect(method.run()).resolves.toBe(features);
     expect(unlockDevice).toHaveBeenCalledTimes(1);
-    expect(getDeviceState).toHaveBeenCalledWith();
   });
 
   test.each([
@@ -5169,7 +5439,7 @@ describe('Protocol V2 current low-level methods', () => {
 
     method.init();
 
-    expect(method.unlockPolicy).toBe('retry-on-locked');
+    expect(method.unlockPolicy).toBe('unlock-before-run');
   });
 
   test('unlocks before opening Protocol V2 settings pages through the unified method', () => {
@@ -5180,7 +5450,7 @@ describe('Protocol V2 current low-level methods', () => {
 
     method.init();
 
-    expect(method.unlockPolicy).toBe('retry-on-locked');
+    expect(method.unlockPolicy).toBe('unlock-before-run');
   });
 
   test('keeps firmwareUpdateV4 unlock-before-reboot behavior explicit', () => {
@@ -5191,7 +5461,7 @@ describe('Protocol V2 current low-level methods', () => {
 
     method.init();
 
-    expect(method.unlockPolicy).toBe('retry-on-locked');
+    expect(method.unlockPolicy).toBe('unlock-before-run');
   });
 
   test('sends FilesystemPermissionFix from filesystemPermissionFix', async () => {