@onekeyfe/hd-core 1.2.0-alpha.169 → 1.2.0-alpha.170

package/__tests__/firmware-update/firmware-update-v4-install-poll.test.ts

@@ -14,7 +14,7 @@ describe('FirmwareUpdateV4 install polling', () => {
     jest.restoreAllMocks();
   });
 
-  test('uses Stage, an empty write-only Request, then status polling', async () => {
+  test('uses Stage, waits for the empty Request response, then polls status', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -26,10 +26,7 @@ describe('FirmwareUpdateV4 install polling', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ type: 'Success', message: {} })
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: { records: [] },
-      })
+      .mockResolvedValueOnce({ type: 'Success', message: {} })
       .mockResolvedValueOnce({
         type: 'DeviceFirmwareUpdateStatus',
         message: {
@@ -42,10 +39,9 @@ describe('FirmwareUpdateV4 install polling', () => {
           ],
         },
       });
-    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
 
     method.device = {
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-ble' }),
       setCancelableAction: jest.fn(),
@@ -68,9 +64,12 @@ describe('FirmwareUpdateV4 install polling', () => {
     await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets);
 
     expect(typedCall.mock.calls[0]).toEqual(['DeviceFirmwareUpdateStage', 'Success', { targets }]);
-    expect(call).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', {});
-    expect(typedCall.mock.calls[1]?.[0]).toBe('DeviceFirmwareUpdateStatusGet');
-    expect(call.mock.invocationCallOrder[0]).toBeLessThan(typedCall.mock.invocationCallOrder[2]);
+    expect(typedCall.mock.calls[1]).toEqual(['DeviceFirmwareUpdateRequest', 'Success', {}]);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
+    expect(typedCall.mock.calls[2]?.[0]).toBe('DeviceFirmwareUpdateStatusGet');
+    expect(typedCall.mock.invocationCallOrder[1]).toBeLessThan(
+      typedCall.mock.invocationCallOrder[2]
+    );
   });
 
   test('does not send Request when Stage is rejected', async () => {
@@ -83,10 +82,9 @@ describe('FirmwareUpdateV4 install polling', () => {
     });
     const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
     const typedCall = jest.fn().mockRejectedValue(new Error('stage rejected'));
-    const call = jest.fn();
 
     method.device = {
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
     } as unknown as Device;
 
     await expect(
@@ -97,7 +95,55 @@ describe('FirmwareUpdateV4 install polling', () => {
       ).protocolV2StartFirmwareUpdate({ targets })
     ).rejects.toThrow('stage rejected');
 
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not enter install state when the device cancels the Request', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        connectId: 'pro2-usb',
+      },
+    });
+    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
+    const actionCancelledError = ERRORS.TypedError(HardwareErrorCode.ActionCancelled);
+    const typedCall = jest.fn().mockImplementation((type: string) => {
+      if (type === 'DeviceFirmwareUpdateRequest') {
+        return Promise.reject(actionCancelledError);
+      }
+      if (type === 'DeviceFirmwareUpdateStatusGet') {
+        return Promise.resolve({ type: 'Success', message: {} });
+      }
+      return Promise.resolve({ type: 'Success', message: {} });
+    });
+    const call = jest.fn().mockResolvedValue({
+      type: 'Failure',
+      message: { code: 'Failure_ActionCancelled' },
+    });
+
+    method.device = {
+      getCommands: () => ({ typedCall, call }),
+      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-usb' }),
+      setCancelableAction: jest.fn(),
+    } as unknown as Device;
+    method.postMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    await expect(
+      (
+        method as unknown as {
+          protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
+        }
+      ).protocolV2StartFirmwareUpdate({ targets })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.ActionCancelled,
+    });
+
+    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
     expect(call).not.toHaveBeenCalled();
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
   test('does not hide an explicit workflow cancellation during status polling', async () => {

package/__tests__/protocol-v2-resources.test.ts

@@ -109,6 +109,11 @@ describe('Pro2 resource configuration', () => {
     expect(
       isProtocolV2ResourceArchiveEntryName('bundles/firmware_logo-pro2-prod_resource-signed.okpkg')
     ).toBe(true);
+    expect(
+      isProtocolV2ResourceArchiveEntryName(
+        'pro2-prod_resource/bundles/firmware_logo-pro2-prod_resource-signed.okpkg'
+      )
+    ).toBe(true);
     expect(
       isProtocolV2ResourceArchiveEntryName(
         '__MACOSX/pro2-prod_resource 2/bundles/._firmware_logo-pro2-prod_resource-signed.okpkg'
@@ -119,6 +124,8 @@ describe('Pro2 resource configuration', () => {
         'bundles/._firmware_logo-pro2-prod_resource-signed.okpkg'
       )
     ).toBe(false);
+    expect(isProtocolV2ResourceArchiveEntryName('pro2-prod_resource/manifest.json')).toBe(false);
+    expect(isProtocolV2ResourceArchiveEntryName('pro2-prod_resource/.DS_Store')).toBe(false);
   });
 
   test('reads the version, hashes, and direct device path from a RESC package', () => {

package/__tests__/protocol-v2.test.ts

@@ -4925,6 +4925,59 @@ 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('scans and reacquires the same BLE peripheral without probing during install recovery', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4945,7 +4998,7 @@ describe('Protocol V2 firmware update targets', () => {
       getCommands: () => commands,
     });
 
-    await (method as any).reconnectProtocolV2Device({ skipBleProtocolProbe: true });
+    await (method as any).reconnectProtocolV2Device({ skipProtocolProbe: true });
 
     expect(enumerate).toHaveBeenCalledTimes(1);
     expect(acquire).toHaveBeenCalledWith('ble-id', null, true, 'V2', undefined, undefined, true);
@@ -5372,7 +5425,6 @@ describe('Protocol V2 firmware update targets', () => {
     });
     const targets = [{ target_id: 4, path: 'vol1:firmware.bin' }];
     const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
-    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
     const cancelDevice = jest.fn().mockResolvedValue(undefined);
     let cancelableAction: (() => Promise<unknown>) | undefined;
     const interaction = {
@@ -5385,7 +5437,7 @@ describe('Protocol V2 firmware update targets', () => {
     };
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call, cancelDevice }),
+      getCommands: () => ({ typedCall, cancelDevice }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(interaction),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
       setCancelableAction: jest.fn(action => {
@@ -5414,13 +5466,18 @@ describe('Protocol V2 firmware update targets', () => {
         interaction,
       },
     });
-    expect(call).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', {});
-    expect(typedCall.mock.invocationCallOrder[0]).toBeLessThan(call.mock.invocationCallOrder[0]);
+    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
+    const requestCallIndex = typedCall.mock.calls.findIndex(
+      ([type]) => type === 'DeviceFirmwareUpdateRequest'
+    );
+    expect(typedCall.mock.invocationCallOrder[0]).toBeLessThan(
+      typedCall.mock.invocationCallOrder[requestCallIndex]
+    );
     expect((method.postMessage as jest.Mock).mock.invocationCallOrder[0]).toBeLessThan(
-      call.mock.invocationCallOrder[0]
+      typedCall.mock.invocationCallOrder[requestCallIndex]
     );
     expect(method.postTipMessage).not.toHaveBeenCalled();
-    expect(method.postProgressMessage).not.toHaveBeenCalled();
+    expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
     await cancelableAction?.();
     expect(cancelDevice).toHaveBeenCalledTimes(1);
   });
@@ -5433,10 +5490,9 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     const typedCall = jest.fn().mockRejectedValue(new Error('stage failed'));
-    const call = jest.fn();
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
     });
     method.postMessage = jest.fn();
     method.postTipMessage = jest.fn();
@@ -5448,24 +5504,28 @@ describe('Protocol V2 firmware update targets', () => {
       })
     ).rejects.toThrow('stage failed');
 
-    expect(call).not.toHaveBeenCalled();
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
     expect(method.postMessage).not.toHaveBeenCalled();
     expect(method.postTipMessage).not.toHaveBeenCalled();
     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: {
         method: 'firmwareUpdateV4',
       },
     });
-    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
-    const call = jest.fn().mockRejectedValue(new Error('write failed'));
+    const typedCall = jest.fn().mockImplementation((type: string) => {
+      if (type === 'DeviceFirmwareUpdateRequest') {
+        return Promise.reject(new Error('request failed'));
+      }
+      return Promise.resolve({ type: 'Success', message: {} });
+    });
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
     });
@@ -5477,9 +5537,9 @@ 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(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
@@ -5491,11 +5551,15 @@ describe('Protocol V2 firmware update targets', () => {
         method: 'firmwareUpdateV4',
       },
     });
-    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
-    const call = jest.fn().mockRejectedValue(new Error('React Native BLE transport released'));
+    const typedCall = jest.fn().mockImplementation((type: string) => {
+      if (type === 'DeviceFirmwareUpdateRequest') {
+        return Promise.reject(new Error('React Native BLE transport released'));
+      }
+      return Promise.resolve({ type: 'Success', message: {} });
+    });
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
     });
@@ -5508,7 +5572,7 @@ describe('Protocol V2 firmware update targets', () => {
       })
     ).resolves.toBeUndefined();
 
-    expect(call).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
     expect((method as any).protocolV2InstallNeedsBleReconnect).toBe(true);
   });
 
@@ -5562,7 +5626,7 @@ describe('Protocol V2 firmware update targets', () => {
         setTimeoutSpy.mockRestore();
       }
 
-      expect(reconnectProtocolV2Device).toHaveBeenCalledWith({ skipBleProtocolProbe: true });
+      expect(reconnectProtocolV2Device).toHaveBeenCalledWith({ skipProtocolProbe: true });
       expect(verifyProtocolV2ReconnectIdentity).not.toHaveBeenCalled();
       expect(typedCall.mock.calls.map(callArgs => callArgs[0])).toEqual([
         'DeviceFirmwareUpdateStatusGet',
@@ -5813,76 +5877,40 @@ describe('Protocol V2 firmware update targets', () => {
     expect(typedCall).toHaveBeenCalledTimes(3);
   });
 
-  test('ignores a mixed stale failure snapshot until ordered current records replace it', async () => {
+  test('ignores leftover failed records while another leftover target is still pending', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const targets = [
-      { target_id: 3, path: 'vol0:/bootloader.bin' },
-      { target_id: 4, path: 'vol0:/application_p1.bin' },
-      { target_id: 7, path: 'vol0:/se01.bin' },
-      { target_id: 8, path: 'vol0:/se02.bin' },
-    ];
-    const staleRecords = [
-      {
-        target_id: 'FW_MGMT_TARGET_BOOTLOADER',
-        status: 'FW_MGMT_UPDATER_TASK_STATUS_PENDING',
-        payload_version: 0,
-        path: 'vol0:/bootloader.bin',
-      },
-      {
-        target_id: 'FW_MGMT_TARGET_APPLICATION_P1',
-        status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
-        payload_version: 0x010000,
-        path: 'vol0:/application_p1.bin',
-      },
-      {
-        target_id: 'FW_MGMT_TARGET_SE01',
-        status: 'FW_MGMT_UPDATER_TASK_STATUS_FAILED_VERIFY',
-        payload_version: 0,
-        path: 'vol0:/se01.bin',
-      },
-      {
-        target_id: 'FW_MGMT_TARGET_SE02',
-        status: 'FW_MGMT_UPDATER_TASK_STATUS_FAILED_VERIFY',
-        payload_version: 0,
-        path: 'vol0:/se02.bin',
-      },
-    ];
     const typedCall = jest
       .fn()
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: { records: staleRecords },
-      })
       .mockResolvedValueOnce({
         type: 'DeviceFirmwareUpdateStatus',
         message: {
-          records: targets.map(target => ({ ...target, status: 0, payload_version: 0 })),
+          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: [
-            { ...targets[0], status: 0, payload_version: 0 },
-            { ...targets[1], status: 1, payload_version: 0 },
-            { ...targets[2], status: 0, payload_version: 0 },
-            { ...targets[3], status: 0, payload_version: 0 },
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 0, path: 'vol0:/application_p1.bin' },
           ],
         },
       })
       .mockResolvedValueOnce({
         type: 'DeviceFirmwareUpdateStatus',
         message: {
-          records: targets.map(target => ({
-            ...target,
-            status: 2,
-            payload_version: 0x010000,
-          })),
+          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(((
@@ -5897,54 +5925,57 @@ describe('Protocol V2 firmware update targets', () => {
     });
     (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
     (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
-    (method as any).protocolV2InstallStatusBaseline = staleRecords;
     method.postProgressMessage = jest.fn();
 
     try {
-      await expect(
-        (method as any).waitForProtocolV2FirmwareUpdateComplete(targets, true)
-      ).resolves.toBeUndefined();
+      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(4);
+    expect(typedCall).toHaveBeenCalledTimes(3);
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('reports a failed target after the current records replace the stale baseline', async () => {
+  test('reports failed only after that target was live in the current install', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    const targets = [
-      { target_id: 4, path: 'vol0:/application_p1.bin' },
-      { target_id: 7, path: 'vol0:/se01.bin' },
-    ];
-    const staleRecords = [
-      { ...targets[0], status: 2, payload_version: 0x010000 },
-      { ...targets[1], status: 6, payload_version: 0 },
-    ];
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({
         type: 'DeviceFirmwareUpdateStatus',
-        message: { records: staleRecords },
+        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: targets.map(target => ({ ...target, status: 0, payload_version: 0 })),
+          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: [
-            { ...targets[0], status: 2, payload_version: 0x010000 },
-            { ...targets[1], status: 6, payload_version: 0 },
+            { target_id: 3, status: 0, path: 'vol0:/bootloader.bin' },
+            { target_id: 4, status: 3, path: 'vol0:/application_p1.bin' },
           ],
         },
       });
@@ -5960,14 +5991,19 @@ describe('Protocol V2 firmware update targets', () => {
     });
     (method as any).reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
     (method as any).verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(undefined);
-    (method as any).protocolV2InstallStatusBaseline = staleRecords;
 
     try {
       await expect(
-        (method as any).waitForProtocolV2FirmwareUpdateComplete(targets, true)
+        (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,
-        params: { firmwareUpdateCode: 'FirmwareInstallFailed' },
+        message: 'Protocol V2 firmware install failed',
       });
     } finally {
       setTimeoutSpy.mockRestore();
@@ -6119,6 +6155,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).protocolV2InstallRequestConfirmed = 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],
@@ -8987,24 +9071,25 @@ 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 until the empty Request responds, then enters install', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    let resolveWrite: ((value: unknown) => void) | undefined;
-    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
-    const call = jest.fn().mockImplementation(
-      () =>
-        new Promise(resolve => {
-          resolveWrite = resolve;
-        })
-    );
+    let resolveRequest: ((value: unknown) => void) | undefined;
+    const typedCall = jest.fn().mockImplementation((type: string) => {
+      if (type === 'DeviceFirmwareUpdateRequest') {
+        return new Promise(resolve => {
+          resolveRequest = resolve;
+        });
+      }
+      return Promise.resolve({ type: 'Success', message: {} });
+    });
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
     });
@@ -9024,17 +9109,17 @@ describe('Protocol V2 firmware update targets', () => {
       'Success',
       { targets: [{ target_id: 4, path: 'vol1:firmware.bin' }] },
     ]);
-    expect(call).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
 
-    resolveWrite?.({ type: 'WriteCompleted', message: {} });
+    resolveRequest?.({ type: 'Success', message: {} });
     await startPromise;
     expect(method.postTipMessage).not.toHaveBeenCalled();
-    expect(method.postProgressMessage).not.toHaveBeenCalled();
+    expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
   });
 
-  test('sends an empty Protocol V2 firmware install request and waits for its response', async () => {
+  test('returns after the empty Protocol V2 firmware install request responds', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -9045,10 +9130,9 @@ describe('Protocol V2 firmware update targets', () => {
       type: 'Success',
       message: { message: 'accepted' },
     });
-    const call = jest.fn().mockResolvedValue({ type: 'WriteCompleted', message: {} });
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
     });
@@ -9061,8 +9145,9 @@ describe('Protocol V2 firmware update targets', () => {
     });
 
     expect(typedCall.mock.calls[0][0]).toBe('DeviceFirmwareUpdateStage');
-    expect(call).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
     expect(method.postTipMessage).not.toHaveBeenCalled();
+    expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
   });
 });
 

package/dist/api/FirmwareUpdateV4.d.ts

@@ -17,8 +17,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     private protocolV2LatestFinalFeatures?;
     private protocolV2LatestFinalDeviceInfo?;
     private protocolV2InstallBaselineVersions;
-    private protocolV2InstallStatusBaseline?;
     private protocolV2InstallNeedsBleReconnect;
+    private protocolV2InstallRequestConfirmed;
     private protocolV2LastRuntimeProbeFeatures?;
     private protocolV2LastTransferProgress?;
     private protocolV2LastTransferProgressAt;
@@ -78,6 +78,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     private protocolV2SourceUpdateProcess;
     private getProtocolV2InstallItemStagingPath;
     private verifyProtocolV2StagedFile;
+    private collectProtocolV2LiveTargetIds;
     private assertProtocolV2TargetStatus;
     private getProtocolV2MissingTargetIds;
     private getProtocolV2ObservableTargetVersions;