@onekeyfe/hd-core 1.2.2-alpha.100 → 1.2.2-alpha.11

package/__tests__/protocol-v2.test.ts

@@ -7,6 +7,7 @@ import { encode as encodeJpeg } from 'jpeg-js';
 import {
   DeviceRebootType,
   DeviceSessionPinType,
+  DeviceSessionSeedDomain,
   DeviceSettingsPage,
   DeviceType,
 } from '@onekeyfe/hd-transport';
@@ -254,6 +255,97 @@ describe('DeviceUploadWallpaper', () => {
     });
   });
 
+  test('uploads and applies the fixed wallpaper package on firmware 1.0.1', async () => {
+    const getSettingsSpy = jest
+      .spyOn(DataManager, 'getSettings')
+      .mockReturnValue('react-native' as any);
+    const typedCall = jest.fn().mockImplementation((request, _response, params) => {
+      if (request === 'FilesystemDirMake') return { message: {} };
+      if (request === 'FilesystemFileWrite') {
+        const file = params.file as { data: Uint8Array; offset: number };
+        return { message: { processed_byte: file.offset + file.data.byteLength } };
+      }
+      if (request === 'DeviceSettingsSet') {
+        return { message: { message: 'wallpaper applied' } };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = new DeviceUploadWallpaper({
+      id: 1,
+      payload: {
+        method: 'deviceUploadWallpaper',
+        jpegBase64: createJpegBase64(604, 1024),
+        fileName: 'ignored-on-package-firmware.bin',
+      },
+    });
+    const device = stubWallpaperDevice({
+      commands: { typedCall },
+      state: { versions: { firmware: '1.0.1' } },
+      getCurrentFirmwareVersionString: jest.fn(() => '1.0.1'),
+    });
+    (method as any).device = device;
+    method.postMessage = jest.fn();
+
+    let result;
+    try {
+      method.init();
+      result = await method.run();
+    } finally {
+      getSettingsSpy.mockRestore();
+    }
+
+    const fileWrites = typedCall.mock.calls.filter(call => call[0] === 'FilesystemFileWrite');
+    expect(new Set(fileWrites.map(call => call[2].file.path))).toEqual(
+      new Set(['vol1:/wallpapers/wallpaper.okpkg'])
+    );
+    expect(fileWrites[0][2].file.data.subarray(0, 4)).toEqual(
+      new Uint8Array([0x4f, 0x4b, 0x50, 0x50])
+    );
+    expect(fileWrites[0][2].file.data).toHaveLength(1960);
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSettingsSet', 'Success', {
+      settings: { wallpaper_path: 'vol1:/wallpapers/wallpaper.okpkg' },
+    });
+    expect(result).toMatchObject({
+      path: 'vol1:/wallpapers/wallpaper.okpkg',
+      colorFormat: 'RGB565',
+      message: 'wallpaper applied',
+    });
+  });
+
+  test('keeps the legacy wallpaper path on a 1.0.1 prerelease', async () => {
+    const typedCall = jest.fn().mockImplementation((request, _response, params) => {
+      if (request === 'FilesystemDirMake') return { message: {} };
+      if (request === 'FilesystemFileWrite') {
+        const file = params.file as { data: Uint8Array; offset: number };
+        return { message: { processed_byte: file.offset + file.data.byteLength } };
+      }
+      if (request === 'DeviceSettingsSet') return { message: {} };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = new DeviceUploadWallpaper({
+      id: 1,
+      payload: {
+        method: 'deviceUploadWallpaper',
+        jpegBase64: createJpegBase64(604, 1024),
+        fileName: 'prerelease-wallpaper.bin',
+      },
+    });
+    const device = stubWallpaperDevice({
+      commands: { typedCall },
+      state: { versions: { firmware: '1.0.1-beta.1' } },
+    });
+    (method as any).device = device;
+
+    method.init();
+    const result = await method.run();
+
+    expect(result.path).toBe('vol1:/wallpapers/prerelease-wallpaper.bin');
+    const fileWrites = typedCall.mock.calls.filter(call => call[0] === 'FilesystemFileWrite');
+    expect(new Set(fileWrites.map(call => call[2].file.path))).toEqual(
+      new Set(['vol1:/wallpapers/prerelease-wallpaper.bin'])
+    );
+  });
+
   test('文件上传失败时不修改 wallpaper_path', async () => {
     const typedCall = jest.fn().mockImplementation(request => {
       if (request === 'FilesystemDirMake') return { message: {} };
@@ -1022,6 +1114,7 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'session-1',
       unlockedAttachPin: false,
       resumed: false,
+      walletStatusRefreshed: true,
     });
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
@@ -1032,10 +1125,9 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: '',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     device.passphraseState = 'state-1';
     expect(device.getInternalState()).toBe('session-1');
   });
@@ -1088,13 +1180,10 @@ describe('Protocol V2 feature adapter', () => {
     expect(
       typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionAskPassphrase')
     ).toHaveLength(1);
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'standard-session',
       btc_test_address: 'standard-state',
-      seed_domains: [],
     });
     expect(deviceWalletSessionStore.getStandard(deviceId)).toEqual({
       passphraseState: 'standard-state',
@@ -1285,6 +1374,7 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'main-wallet-session',
       unlockedAttachPin: undefined,
       resumed: false,
+      walletStatusRefreshed: true,
     });
 
     expect(promptPassphrase).toHaveBeenCalled();
@@ -1371,6 +1461,7 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'hidden-after-unlock-session',
       unlockedAttachPin: undefined,
       resumed: false,
+      walletStatusRefreshed: true,
     });
 
     expect(unlockDevice).not.toHaveBeenCalled();
@@ -1457,10 +1548,9 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('deviceStatusGet returns raw DeviceStatus and updates dynamic features', async () => {
@@ -1569,7 +1659,6 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'session-a',
       btc_test_address: 'state-a',
-      seed_domains: [],
     });
     expect(device.getInternalState()).toBe('session-b');
   });
@@ -1643,7 +1732,6 @@ describe('Protocol V2 feature adapter', () => {
         {
           session_id: 'session-a',
           btc_test_address: 'state-a',
-          seed_domains: [],
         },
       ],
     ]);
@@ -1690,10 +1778,14 @@ describe('Protocol V2 feature adapter', () => {
       [
         'DeviceSessionAskPassphrase',
         'Success',
-        { passphrase: 'host hidden wallet', on_device: false },
+        {
+          passphrase: 'host hidden wallet',
+          on_device: false,
+          seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
+        },
       ],
       ['DeviceStatusGet', 'DeviceStatus', {}],
-      ['DeviceSessionGet', 'DeviceSession', { seed_domains: [] }],
+      ['DeviceSessionGet', 'DeviceSession', {}],
     ]);
   });
 
@@ -1855,7 +1947,6 @@ describe('Protocol V2 feature adapter', () => {
       expect(promptPassphrase).not.toHaveBeenCalled();
       expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
         btc_test_address: 'expected-state',
-        seed_domains: [],
       });
       expect(typedCall).toHaveBeenCalledWith('LockDevice', 'Success', {});
       expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet')).toHaveLength(1);
@@ -2153,7 +2244,7 @@ describe('Protocol V2 feature adapter', () => {
       firmwareVersion: '4.15.0',
       passphraseProtection: true,
       sessionId: 'feature-session',
-      unlockedAttachPin: true,
+      unlockedAttachPin: false,
     };
     const typedCall = jest
       .fn()
@@ -2246,7 +2337,6 @@ describe('Protocol V2 feature adapter', () => {
     ).resolves.toMatchObject({ passphraseState: 'expected-state' });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       btc_test_address: 'expected-state',
-      seed_domains: [],
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -2320,7 +2410,6 @@ describe('Protocol V2 feature adapter', () => {
         {
           session_id: 'session-pro2-app',
           btc_test_address: 'state-pro2-app',
-          seed_domains: [],
         },
       ],
     ]);
@@ -2510,10 +2599,9 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('does not mark Pro2 passphrase enabled from a main PIN session alone', async () => {
@@ -2593,16 +2681,14 @@ describe('Protocol V2 feature adapter', () => {
     expect(device.getInternalState()).toBeUndefined();
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       btc_test_address: 'expected-state',
-      seed_domains: [],
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('fails closed instead of switching to Main PIN during a standard-wallet safety check', async () => {
@@ -2700,20 +2786,19 @@ describe('Protocol V2 feature adapter', () => {
     await expect(
       device.checkPassphraseStateSafety('stale-hidden-state', true, false)
     ).resolves.toBe(true);
-    expect(typedCall).toHaveBeenCalledTimes(5);
+    expect(typedCall).toHaveBeenCalledTimes(6);
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: '',
       on_device: false,
+      seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceStatusGet', 'DeviceStatus', {});
     expect(typedCall.mock.calls.filter(([request]) => request === 'DeviceStatusGet')).toHaveLength(
-      2
+      3
     );
     expect(typedCall).not.toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', expect.anything());
   });
@@ -4820,6 +4905,23 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall.mock.calls.map(call => call[0])).toEqual(['DeviceInfoGet']);
   });
 
+  test('stops V4 bootloader reconnect polling on a stale BLE bond', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const staleBondError = ERRORS.TypedError(HardwareErrorCode.BlePeerRemovedPairingInformation);
+    const reconnectProtocolV2Device = jest.fn().mockRejectedValue(staleBondError);
+    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+
+    await expect((method as any).waitForProtocolV2BootloaderMode(60_000, 0)).rejects.toBe(
+      staleBondError
+    );
+    expect(reconnectProtocolV2Device).toHaveBeenCalledTimes(1);
+  });
+
   test('polls again when Protocol V2 bootloader serial is temporarily unavailable', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4901,6 +5003,87 @@ describe('Protocol V2 firmware update targets', () => {
     expect(initialize).not.toHaveBeenCalled();
   });
 
+  test('reacquires the same WebUSB device without a protocol probe during install recovery', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const acquire = jest.fn().mockResolvedValue('usb-path');
+    const enumerate = jest.fn().mockResolvedValue({
+      descriptors: [
+        { id: 'other-usb', path: 'other-usb', protocolType: 'V2' },
+        { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
+      ],
+    });
+    const commands = { disposed: true, mainId: '' };
+    const device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'usb-path', protocolType: 'V2' },
+      deviceConnector: { acquire, enumerate },
+      updateDescriptor: jest.fn(),
+      acquire: jest.fn(),
+      commands,
+      getCommands: () => commands,
+      mainId: 'old-usb-path',
+    });
+    const getDevices = jest.spyOn(DevicePool, 'getDevices');
+    const isBrowserWebUsb = jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(false);
+    const isDesktopWebUsb = jest.spyOn(DataManager, 'isDesktopWebUsb').mockReturnValue(true);
+    (method as any).device = device;
+    (method as any).protocolV2ExpectedPath = 'usb-path';
+
+    try {
+      await (method as any).reconnectProtocolV2Device({ skipProtocolProbe: true });
+    } finally {
+      getDevices.mockRestore();
+      isBrowserWebUsb.mockRestore();
+      isDesktopWebUsb.mockRestore();
+    }
+
+    expect(getDevices).not.toHaveBeenCalled();
+    expect(acquire).toHaveBeenCalledWith(
+      'usb-path',
+      null,
+      undefined,
+      'V2',
+      undefined,
+      undefined,
+      true
+    );
+    expect(device.acquire).not.toHaveBeenCalled();
+    expect(commands.disposed).toBe(false);
+    expect(commands.mainId).toBe('usb-path');
+  });
+
+  test('reacquires the same BLE peripheral by id without scanning during install recovery', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
+    const enumerate = jest.fn().mockResolvedValue({
+      descriptors: [{ id: 'ble-id', name: 'OneKey Pro 2', protocolType: 'V2' }],
+    });
+    const commands = { disposed: true, mainId: '' };
+    (method as any).isBleReconnect = jest.fn(() => true);
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'ble-id', path: 'ble-path', protocolType: 'V2' },
+      deviceConnector: { acquire, enumerate },
+      commands,
+      getCommands: () => commands,
+    });
+
+    await (method as any).reconnectProtocolV2Device({ skipProtocolProbe: true });
+
+    expect(enumerate).not.toHaveBeenCalled();
+    expect(acquire).toHaveBeenCalledWith('ble-id', null, true, 'V2', undefined, undefined, true);
+    expect(commands.disposed).toBe(false);
+    expect(commands.mainId).toBe('ble-id');
+  });
+
   test('selects the matching physical device from multiple Protocol V2 USB reconnect candidates', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -5290,6 +5473,108 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
+  test('treats a typed BLE disconnect during Protocol V2 normal reboot as expected', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValue(ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected));
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    await expect((method as any).protocolV2Reboot(DeviceRebootType.Normal)).resolves.toEqual({
+      message: 'Device rebooted successfully',
+    });
+    expect((method as any).device.markProtocolV2Reboot).toHaveBeenCalledWith(
+      DeviceRebootType.Normal
+    );
+  });
+
+  test('uses a short timeout and continues after a BLE reboot response timeout', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValue(
+        ERRORS.TypedError(
+          HardwareErrorCode.BleTimeoutError,
+          'Lowlevel response timeout after 5000ms for DeviceReboot'
+        )
+      );
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    await expect((method as any).protocolV2Reboot(DeviceRebootType.Normal)).resolves.toEqual({
+      message: 'Device rebooted successfully',
+    });
+    expect(typedCall).toHaveBeenCalledWith(
+      'DeviceReboot',
+      'Success',
+      { reboot_type: DeviceRebootType.Normal },
+      { timeoutMs: 5000 }
+    );
+    expect((method as any).device.markProtocolV2Reboot).toHaveBeenCalledWith(
+      DeviceRebootType.Normal
+    );
+  });
+
+  test('continues after a USB Protocol V2 reboot response timeout', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const timeoutError = Object.assign(
+      new Error('Protocol V2 response timeout after 5000ms for DeviceReboot'),
+      { code: 'response-timeout' }
+    );
+    const typedCall = jest.fn().mockRejectedValue(timeoutError);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    await expect((method as any).protocolV2Reboot(DeviceRebootType.Normal)).resolves.toEqual({
+      message: 'Device rebooted successfully',
+    });
+    expect((method as any).device.markProtocolV2Reboot).toHaveBeenCalledWith(
+      DeviceRebootType.Normal
+    );
+  });
+
+  test('propagates non-transport errors from a Protocol V2 reboot', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const rebootError = new Error('Device rejected reboot');
+    const typedCall = jest.fn().mockRejectedValue(rebootError);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+
+    await expect((method as any).protocolV2Reboot(DeviceRebootType.Normal)).rejects.toBe(
+      rebootError
+    );
+    expect((method as any).device.markProtocolV2Reboot).not.toHaveBeenCalled();
+  });
+
   test('treats Android BLE transport release during Protocol V2 reboot as expected', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -5365,7 +5650,11 @@ describe('Protocol V2 firmware update targets', () => {
     expect(call).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateRequest',
       {},
-      { returnAfterWrite: true }
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
     );
     expect(typedCall.mock.invocationCallOrder[0]).toBeLessThan(call.mock.invocationCallOrder[0]);
     expect((method.postMessage as jest.Mock).mock.invocationCallOrder[0]).toBeLessThan(
@@ -5374,7 +5663,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
     await cancelableAction?.();
-    expect(cancelDevice).toHaveBeenCalledTimes(1);
+    expect(cancelDevice).not.toHaveBeenCalled();
   });
 
   test('does not send the install request when Protocol V2 staging fails', async () => {
@@ -5406,7 +5695,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
-  test('does not enter install state when writing the empty request fails', async () => {
+  test('does not enter install state when the empty request fails', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5414,7 +5703,7 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
-    const call = jest.fn().mockRejectedValue(new Error('write failed'));
+    const call = jest.fn().mockRejectedValue(new Error('request failed'));
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall, call }),
@@ -5429,46 +5718,151 @@ describe('Protocol V2 firmware update targets', () => {
       (method as any).protocolV2StartFirmwareUpdate({
         targets: [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
       })
-    ).rejects.toThrow('write failed');
+    ).rejects.toThrow('request failed');
 
-    expect(call).toHaveBeenCalledTimes(1);
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
+    );
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
-  test('polls only firmware status while Protocol V2 bootloader is installing', async () => {
+  test('continues to install polling when the empty request releases BLE transport', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: { records: [{ target_id: 4, status: 1 }] },
-      })
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: { records: [{ target_id: 4, status: 2 }] },
-      });
-    const reconnectProtocolV2Device = jest.fn();
-    const verifyProtocolV2ReconnectIdentity = jest.fn();
+    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
+    const call = jest.fn().mockRejectedValue(new Error('React Native BLE transport released'));
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall }),
+      getCommands: () => ({ typedCall, call }),
+      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
     });
-    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
-    (method as any).verifyProtocolV2ReconnectIdentity = verifyProtocolV2ReconnectIdentity;
-    method.postProgressMessage = jest.fn();
-    method.postTipMessage = jest.fn();
-
-    await (method as any).waitForProtocolV2FirmwareUpdateComplete([
-      { target_id: 4, path: 'vol0:/application_p1.bin' },
-    ]);
+    (method as any).isBleReconnect = jest.fn(() => true);
+    method.postMessage = jest.fn();
 
-    expect(reconnectProtocolV2Device).not.toHaveBeenCalled();
+    await expect(
+      (method as any).protocolV2StartFirmwareUpdate({
+        targets: [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
+      })
+    ).resolves.toBeUndefined();
+
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
+    );
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
+    expect((method as any).protocolV2InstallNeedsReconnect).toBe(true);
+    expect((method as any).protocolV2InstallDisconnectObserved).toBe(true);
+  });
+
+  test.each([
+    { name: 'bootloader', targetId: 3, path: 'vol0:/bootloader.bin' },
+    { name: 'application', targetId: 4, path: 'vol0:/application_p1.bin' },
+    { name: 'secure element', targetId: 7, path: 'vol0:/se01.bin' },
+  ])(
+    'reconnects a released BLE install link before polling $name status without DeviceInfo',
+    async ({ targetId, path }) => {
+      const method = new FirmwareUpdateV4({
+        id: 1,
+        payload: {
+          method: 'firmwareUpdateV4',
+        },
+      });
+      const targets = [{ target_id: targetId, path }];
+      const typedCall = jest
+        .fn()
+        .mockResolvedValueOnce({
+          type: 'DeviceFirmwareUpdateStatus',
+          message: { records: [{ ...targets[0], status: 1, payload_version: 0 }] },
+        })
+        .mockResolvedValueOnce({
+          type: 'DeviceFirmwareUpdateStatus',
+          message: { records: [{ ...targets[0], status: 2, payload_version: 0x010000 }] },
+        });
+      const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+      const verifyProtocolV2ReconnectIdentity = jest.fn();
+      const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+        callback: () => void
+      ) => {
+        callback();
+        return 0 as any;
+      }) as typeof setTimeout);
+
+      (method as any).device = stubDevice({
+        getCommands: () => ({ typedCall }),
+      });
+      (method as any).isBleReconnect = jest.fn(() => true);
+      (method as any).protocolV2InstallNeedsReconnect = true;
+      (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+      (method as any).verifyProtocolV2ReconnectIdentity = verifyProtocolV2ReconnectIdentity;
+      method.postProgressMessage = jest.fn();
+
+      try {
+        await expect(
+          (method as any).waitForProtocolV2FirmwareUpdateComplete(targets, true)
+        ).resolves.toBeUndefined();
+      } finally {
+        setTimeoutSpy.mockRestore();
+      }
+
+      expect(reconnectProtocolV2Device).toHaveBeenCalledWith({ skipProtocolProbe: true });
+      expect(verifyProtocolV2ReconnectIdentity).not.toHaveBeenCalled();
+      expect(typedCall.mock.calls.map(callArgs => callArgs[0])).toEqual([
+        'DeviceFirmwareUpdateStatusGet',
+        'DeviceFirmwareUpdateStatusGet',
+      ]);
+    }
+  );
+
+  test('polls only firmware status while Protocol V2 bootloader is installing', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 1 }] },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [{ target_id: 4, status: 2 }] },
+      });
+    const reconnectProtocolV2Device = jest.fn();
+    const verifyProtocolV2ReconnectIdentity = jest.fn();
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
+    (method as any).verifyProtocolV2ReconnectIdentity = verifyProtocolV2ReconnectIdentity;
+    method.postProgressMessage = jest.fn();
+    method.postTipMessage = jest.fn();
+
+    await (method as any).waitForProtocolV2FirmwareUpdateComplete([
+      { target_id: 4, path: 'vol0:/application_p1.bin' },
+    ]);
+
+    expect(reconnectProtocolV2Device).not.toHaveBeenCalled();
     expect(verifyProtocolV2ReconnectIdentity).not.toHaveBeenCalled();
     expect(typedCall.mock.calls.map(call => call[0])).toEqual([
       'DeviceFirmwareUpdateStatusGet',
@@ -5479,7 +5873,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('keeps polling after install ACK until the target finishes', async () => {
+  test('keeps polling after an empty status response until the target finishes', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5488,7 +5882,10 @@ describe('Protocol V2 firmware update targets', () => {
     });
     const typedCall = jest
       .fn()
-      .mockResolvedValueOnce({ type: 'Success', message: {} })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [] },
+      })
       .mockResolvedValueOnce({
         type: 'DeviceFirmwareUpdateStatus',
         message: { records: [] },
@@ -5630,6 +6027,38 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
+  test('does not count a stale finished target when only another target was live', () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const assertProtocolV2TargetStatus = (method as any).assertProtocolV2TargetStatus.bind(method);
+    const expectedTargetIds = new Set([3, 4]);
+    const expectedPaths = new Map([
+      [3, 'vol0:/bootloader.bin'],
+      [4, 'vol0:/application_p1.bin'],
+    ]);
+    const liveTargetIds = new Set([4]);
+    method.postProgressMessage = jest.fn();
+
+    const completed = assertProtocolV2TargetStatus(
+      [
+        { target_id: 3, status: 2, path: 'vol0:/bootloader.bin' },
+        { target_id: 4, status: 2, path: 'vol0:/application_p1.bin' },
+      ],
+      expectedTargetIds,
+      expectedPaths,
+      liveTargetIds
+    );
+
+    expect(completed).toBe(false);
+    expect((method as any).protocolV2CompletedTargetIds).toEqual(new Set([4]));
+    expect(method.postProgressMessage).toHaveBeenCalledWith(50, 'installingFirmware');
+    expect(method.postProgressMessage).not.toHaveBeenCalledWith(100, 'installingFirmware');
+  });
+
   test('ignores stale failed records until the current install starts', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -5678,6 +6107,141 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall).toHaveBeenCalledTimes(3);
   });
 
+  test('ignores leftover failed records while another leftover target is still pending', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 3, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 0, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 2, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 2, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      });
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await (method as any).waitForProtocolV2FirmwareUpdateComplete(
+        [
+          { target_id: 3, path: 'vol0:/bootloader.bin' },
+          { target_id: 4, path: 'vol0:/application_p1.bin' },
+        ],
+        true
+      );
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(typedCall).toHaveBeenCalledTimes(3);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+  });
+
+  test('reports failed only after that target was live in the current install', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 3, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 0, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 3, path: 'vol0:/application_p1.bin' },
+          ],
+        },
+      });
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
+
+    try {
+      await expect(
+        (method as any).waitForProtocolV2FirmwareUpdateComplete(
+          [
+            { target_id: 3, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, path: 'vol0:/application_p1.bin' },
+          ],
+          true
+        )
+      ).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.FirmwareError,
+        message: 'Protocol V2 firmware install failed',
+      });
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect(typedCall).toHaveBeenCalledTimes(3);
+  });
+
   test('waits five minutes before rejecting normal mode without install evidence', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -5784,7 +6348,6 @@ describe('Protocol V2 firmware update targets', () => {
     });
     const typedCall = jest
       .fn()
-      .mockResolvedValueOnce({ type: 'Success', message: {} })
       .mockRejectedValueOnce(new Error('Pro2 is rebooting'))
       .mockResolvedValueOnce({
         type: 'DeviceFirmwareUpdateStatus',
@@ -5801,6 +6364,7 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
     });
+    (method as any).protocolV2InstallTerminalSuccessObserved = true;
     (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
     (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
     (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
@@ -5821,6 +6385,54 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
+  test('uses the confirmed install request as evidence after the same device returns', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValueOnce(new Error('The USB device was disconnected'))
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [] },
+      });
+    const deviceInfo = { hw: { serial_no: 'PRO2-PHYSICAL-1' } };
+    const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation(((
+      callback: () => void
+    ) => {
+      callback();
+      return 0 as any;
+    }) as typeof setTimeout);
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).protocolV2InstallTerminalSuccessObserved = true;
+    (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
+    (method as any).probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
+    method.postProgressMessage = jest.fn();
+
+    try {
+      await expect(
+        (method as any).waitForProtocolV2FirmwareUpdateComplete(
+          [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
+          true
+        )
+      ).resolves.toBeUndefined();
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+
+    expect((method as any).reconnectProtocolV2Device).toHaveBeenCalledWith({
+      skipProtocolProbe: true,
+    });
+    expect(method.postProgressMessage).toHaveBeenLastCalledWith(100, 'installingFirmware');
+  });
+
   test.each([
     [{ mode: 'normal', bootloaderMode: false }, true],
     [{ mode: 'notInitialized', bootloaderMode: false }, true],
@@ -6183,7 +6795,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(reconnectProtocolV2Device).not.toHaveBeenCalled();
     expect(typedCall).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
-      ['DeviceFirmwareUpdateStatus', 'Success'],
+      'DeviceFirmwareUpdateStatus',
       expect.anything(),
       expect.anything()
     );
@@ -6465,10 +7077,12 @@ describe('Protocol V2 firmware update targets', () => {
     });
     expect(typedCall).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
-      ['DeviceFirmwareUpdateStatus', 'Success'],
+      'DeviceFirmwareUpdateStatus',
       {
         fields: {
           status: true,
+          progress_percent: true,
+          phase_info: true,
           payload_version: true,
           path: true,
         },
@@ -6570,7 +7184,14 @@ describe('Protocol V2 firmware update targets', () => {
       true
     );
     expect((method as any).exitProtocolV2BootloaderToNormal).not.toHaveBeenCalled();
-    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'transferData');
+    expect(method.postProgressMessage).toHaveBeenCalledWith(
+      100,
+      'transferData',
+      expect.objectContaining({
+        transferredBytes: 5,
+        totalBytes: 5,
+      })
+    );
     expect((method as any).completeProtocolV2FinalVerification).toHaveBeenCalledTimes(1);
   });
 
@@ -6644,7 +7265,14 @@ describe('Protocol V2 firmware update targets', () => {
       expect.objectContaining({ processedSize: 2, totalSize: 3 })
     );
     expect(method.postProgressMessage).toHaveBeenCalledTimes(1);
-    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'transferData');
+    expect(method.postProgressMessage).toHaveBeenCalledWith(
+      100,
+      'transferData',
+      expect.objectContaining({
+        transferredBytes: 3,
+        totalBytes: 3,
+      })
+    );
     expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledTimes(1);
     expect((method as any).protocolV2StartFirmwareUpdate).toHaveBeenCalledWith({
       targets: [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
@@ -7964,26 +8592,43 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).verifyProtocolV2StagedFile = jest.fn().mockResolvedValue(undefined);
     (method as any).protocolV2StartFirmwareUpdate = jest.fn();
     (method as any).waitForProtocolV2FirmwareUpdateComplete = jest.fn();
+    const dateNowSpy = jest
+      .spyOn(Date, 'now')
+      .mockReturnValueOnce(1_000)
+      .mockReturnValueOnce(5_000);
 
-    await (method as any).executeProtocolV2SourceUpdate({
-      installSources: [],
-      resourceSources: [
-        {
-          name: 'images.okpkg',
-          source: {
-            size: 3,
-            readAt: jest.fn(),
-            close: jest.fn(),
+    try {
+      await (method as any).executeProtocolV2SourceUpdate({
+        installSources: [],
+        resourceSources: [
+          {
+            name: 'images.okpkg',
+            source: {
+              size: 3,
+              readAt: jest.fn(),
+              close: jest.fn(),
+            },
+            devicePath: 'vol0:/bundles/images/images.okpkg',
           },
-          devicePath: 'vol0:/bundles/images/images.okpkg',
-        },
-      ],
-    });
+        ],
+      });
+    } finally {
+      dateNowSpy.mockRestore();
+    }
 
     expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenCalledTimes(1);
     expect((method as any).protocolV2SourceUpdateProcess).toHaveBeenCalledWith(
-      expect.objectContaining({ filePath: 'vol0:/bundles/images/images.okpkg' })
+      expect.objectContaining({
+        filePath: 'vol0:/bundles/images/images.okpkg',
+        transferStartedAt: 1_000,
+      })
     );
+    expect(method.postProgressMessage).toHaveBeenLastCalledWith(100, 'transferData', {
+      transferredBytes: 3,
+      totalBytes: 3,
+      rateBytesPerSecond: 1,
+      elapsedMs: 4_000,
+    });
     expect((method as any).verifyProtocolV2StagedFile).toHaveBeenCalledWith(
       'vol0:/bundles/images/images.okpkg',
       3
@@ -8183,6 +8828,114 @@ describe('Protocol V2 firmware update targets', () => {
     });
   });
 
+  test('does not retry or wrap a stale BLE bond during a V4 file transfer', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const staleBondError = ERRORS.TypedError(HardwareErrorCode.BlePeerRemovedPairingInformation);
+    (method as any).fileWriteChunk = jest.fn().mockRejectedValue(staleBondError);
+    const recoverProtocolV2FileTransfer = jest.fn();
+    (method as any).recoverProtocolV2FileTransfer = recoverProtocolV2FileTransfer;
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array([1]).buffer,
+    });
+
+    try {
+      await expect(
+        (method as any).protocolV2SourceUpdateProcess({
+          source,
+          filePath: 'vol1:firmware.bin',
+          processedSize: 0,
+          totalSize: 1,
+        })
+      ).rejects.toBe(staleBondError);
+    } finally {
+      await source?.close();
+    }
+    expect(recoverProtocolV2FileTransfer).not.toHaveBeenCalled();
+  });
+
+  test('does not recover or wrap a cancelled V4 file transfer', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const abortController = new AbortController();
+    method.abortSignal = abortController.signal;
+    (method as any).fileWriteChunk = jest.fn().mockImplementation(() => {
+      abortController.abort();
+      return Promise.reject(new Error('transport disposed'));
+    });
+    const recoverProtocolV2FileTransfer = jest.fn();
+    (method as any).recoverProtocolV2FileTransfer = recoverProtocolV2FileTransfer;
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array([1]).buffer,
+    });
+
+    try {
+      await expect(
+        (method as any).protocolV2SourceUpdateProcess({
+          source,
+          filePath: 'vol1:firmware.bin',
+          processedSize: 0,
+          totalSize: 1,
+        })
+      ).rejects.toMatchObject({ errorCode: HardwareErrorCode.CallQueueActionCancelled });
+    } finally {
+      await source?.close();
+    }
+    expect(recoverProtocolV2FileTransfer).not.toHaveBeenCalled();
+  });
+
+  test('keeps public transfer bytes monotonic when a V4 file retry restarts at zero', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    let writeCount = 0;
+    (method as any).fileWriteChunk = jest.fn(
+      (_path: string, _size: number, offset: number, data: Uint8Array) => {
+        writeCount += 1;
+        if (writeCount === 3) {
+          return Promise.reject(new Error('transport timeout'));
+        }
+        return Promise.resolve({
+          message: { processed_byte: offset + data.byteLength },
+        });
+      }
+    );
+    (method as any).getProtocolV2FirmwareChunkSize = jest.fn().mockReturnValue(1000);
+    (method as any).recoverProtocolV2FileTransfer = jest.fn().mockResolvedValue(undefined);
+    method.postProgressMessage = jest.fn();
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(3000).buffer,
+    });
+
+    try {
+      await (method as any).protocolV2SourceUpdateProcess({
+        source,
+        filePath: 'vol1:firmware.bin',
+        processedSize: 0,
+        totalSize: 3000,
+      });
+    } finally {
+      await source?.close();
+    }
+
+    const transferredBytes = (method.postProgressMessage as jest.Mock).mock.calls.map(
+      ([, , metrics]) => metrics.transferredBytes
+    );
+    expect(transferredBytes).toEqual([1000, 2000, 3000]);
+    expect((method as any).recoverProtocolV2FileTransfer).toHaveBeenCalledTimes(1);
+  });
+
   test('throttles repeated transfer progress while preserving file completion', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -8541,6 +9294,42 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall).toHaveBeenCalledTimes(6);
   });
 
+  test('preserves the underlying transport error code after firmware transfer retries', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest
+      .fn()
+      .mockRejectedValue(ERRORS.TypedError(HardwareErrorCode.BleTimeoutError, 'response timeout'));
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    method.postProgressMessage = jest.fn();
+    method.postTipMessage = jest.fn();
+    (method as any).recoverProtocolV2FileTransfer = jest.fn().mockResolvedValue(undefined);
+
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array([1, 2, 3]).buffer,
+    });
+    await expect(
+      (method as any).protocolV2SourceUpdateProcess({
+        source,
+        filePath: 'vol0:/firmware.bin',
+        processedSize: 0,
+        totalSize: 3,
+      })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.EmmcFileWriteFirmwareError,
+      params: { causeCode: HardwareErrorCode.BleTimeoutError },
+    });
+    await source?.close();
+    expect(typedCall).toHaveBeenCalledTimes(3);
+  });
+
   // TODO(#850/#855): PR #855 added resume-on-retry and per-chunk retry on the
   // writeProtocolV2File path. PR #850 replaced that path with FirmwareByteSource
   // streaming (protocolV2SourceUpdateProcess), which restarts a failed transfer from
@@ -8689,26 +9478,28 @@ describe('Protocol V2 firmware update targets', () => {
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([1960, 1]);
   });
 
-  test('keeps the confirmation UI active after Stage and the empty Request are written', async () => {
+  test('keeps confirmation active after the Request write until terminal Success arrives', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    let resolveWrite: ((value: unknown) => void) | undefined;
+    let onResponseAfterWrite:
+      | ((response: { type: string; message: Record<string, never> }) => void)
+      | undefined;
     const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
-    const call = jest.fn().mockImplementation(
-      () =>
-        new Promise(resolve => {
-          resolveWrite = resolve;
-        })
-    );
+    const call = jest.fn().mockImplementation((_type, _message, options) => {
+      onResponseAfterWrite = options.onResponseAfterWrite;
+      return Promise.resolve({ type: 'WriteCompleted', message: {} });
+    });
+    const clearCancelableAction = jest.fn();
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
+      clearCancelableAction,
     });
     method.postMessage = jest.fn();
     method.postProgressMessage = jest.fn();
@@ -8729,18 +9520,25 @@ describe('Protocol V2 firmware update targets', () => {
     expect(call).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateRequest',
       {},
-      { returnAfterWrite: true }
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
     );
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
+    expect(clearCancelableAction).not.toHaveBeenCalled();
 
-    resolveWrite?.({ type: 'WriteCompleted', message: {} });
     await startPromise;
+    onResponseAfterWrite?.({ type: 'Success', message: {} });
+    expect(clearCancelableAction).toHaveBeenCalledTimes(1);
+    expect((method as any).protocolV2InstallTerminalSuccessObserved).toBe(true);
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
-  test('sends an empty Protocol V2 firmware install request without waiting for its response', async () => {
+  test('returns after the empty Protocol V2 firmware install request is written', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -8751,10 +9549,13 @@ describe('Protocol V2 firmware update targets', () => {
       type: 'Success',
       message: { message: 'accepted' },
     });
-    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
+    const call = jest.fn().mockResolvedValue({
+      type: 'WriteCompleted',
+      message: {},
+    });
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
     });
@@ -8770,9 +9571,14 @@ describe('Protocol V2 firmware update targets', () => {
     expect(call).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateRequest',
       {},
-      { returnAfterWrite: true }
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
     );
     expect(method.postTipMessage).not.toHaveBeenCalled();
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 });
 
@@ -8955,7 +9761,16 @@ describe('Protocol V2 firmware update method', () => {
   test('passes firmware update status fields through to Protocol V2', async () => {
     const typedCall = jest.fn().mockResolvedValue({
       message: {
-        records: [{ target_id: 4, status: 2, payload_version: 1, path: 'vol1:application_p1.bin' }],
+        records: [
+          {
+            target_id: 4,
+            status: 1,
+            progress_percent: 42,
+            phase_info: { phase: 1, progress_percent: 60 },
+            payload_version: 1,
+            path: 'vol1:application_p1.bin',
+          },
+        ],
       },
     });
     const method = new DeviceGetFirmwareUpdateStatus({
@@ -8964,6 +9779,8 @@ describe('Protocol V2 firmware update method', () => {
         method: 'deviceGetFirmwareUpdateStatus',
         fields: {
           status: true,
+          progress_percent: true,
+          phase_info: true,
           payload_version: true,
           path: true,
         },
@@ -8975,7 +9792,16 @@ describe('Protocol V2 firmware update method', () => {
     });
 
     await expect(method.run()).resolves.toEqual({
-      records: [{ target_id: 4, status: 2, payload_version: 1, path: 'vol1:application_p1.bin' }],
+      records: [
+        {
+          target_id: 4,
+          status: 1,
+          progress_percent: 42,
+          phase_info: { phase: 1, progress_percent: 60 },
+          payload_version: 1,
+          path: 'vol1:application_p1.bin',
+        },
+      ],
     });
     expect(typedCall).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
@@ -8983,6 +9809,8 @@ describe('Protocol V2 firmware update method', () => {
       {
         fields: {
           status: true,
+          progress_percent: true,
+          phase_info: true,
           payload_version: true,
           path: true,
         },