@onekeyfe/hd-core 1.2.0-alpha.174 → 1.2.0-alpha.176

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

@@ -14,7 +14,7 @@ describe('FirmwareUpdateV4 install polling', () => {
     jest.restoreAllMocks();
   });
 
-  test('keeps USB on Stage, Request Success, then status polling', async () => {
+  test('writes the USB Request before polling current install status', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -26,7 +26,22 @@ describe('FirmwareUpdateV4 install polling', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ type: 'Success', message: {} })
-      .mockResolvedValueOnce({ type: 'Success', message: {} })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [] },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            {
+              target_id: 4,
+              status: 'FW_MGMT_UPDATER_TASK_STATUS_PENDING',
+              path: 'vol0:/application_p1.bin',
+            },
+          ],
+        },
+      })
       .mockResolvedValueOnce({
         type: 'DeviceFirmwareUpdateStatus',
         message: {
@@ -39,12 +54,17 @@ describe('FirmwareUpdateV4 install polling', () => {
           ],
         },
       });
+    const call = jest.fn().mockResolvedValue({
+      type: 'WriteCompleted',
+      message: {},
+    });
+    const setCancelableAction = jest.fn();
 
     method.device = {
-      getCommands: () => ({ typedCall }),
+      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-usb' }),
-      setCancelableAction: jest.fn(),
+      setCancelableAction,
       clearCancelableAction: jest.fn(),
     } as unknown as Device;
     method.postMessage = jest.fn();
@@ -53,7 +73,10 @@ describe('FirmwareUpdateV4 install polling', () => {
 
     const firmwareUpdate = method as unknown as {
       protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
-      waitForProtocolV2FirmwareUpdateComplete: (value: typeof targets) => Promise<void>;
+      waitForProtocolV2FirmwareUpdateComplete: (
+        value: typeof targets,
+        requireCurrentInstallStatus: boolean
+      ) => Promise<void>;
       reconnectProtocolV2Device: () => Promise<void>;
       verifyProtocolV2ReconnectIdentity: () => Promise<Record<string, never>>;
     };
@@ -62,15 +85,155 @@ describe('FirmwareUpdateV4 install polling', () => {
     (method as any).isBleReconnect = jest.fn(() => false);
 
     await firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
-    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets);
 
     expect(typedCall.mock.calls[0]).toEqual(['DeviceFirmwareUpdateStage', 'Success', { targets }]);
-    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]
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
     );
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
+
+    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
+
+    expect(typedCall.mock.calls[1]?.[0]).toBe('DeviceFirmwareUpdateStatusGet');
+    expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+    expect(call.mock.invocationCallOrder[0]).toBeLessThan(typedCall.mock.invocationCallOrder[1]);
+    expect(setCancelableAction).toHaveBeenCalledTimes(2);
+  });
+
+  test('accepts finished USB status after the Request terminal Success arrives', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        connectId: 'pro2-usb',
+      },
+    });
+    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Success', message: {} })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            {
+              target_id: 4,
+              status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+              path: 'vol0:/application_p1.bin',
+            },
+          ],
+        },
+      });
+    const call = jest.fn().mockResolvedValue({
+      type: 'WriteCompleted',
+      message: {},
+    });
+
+    method.device = {
+      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
+      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-usb' }),
+      setCancelableAction: jest.fn(),
+      clearCancelableAction: jest.fn(),
+    } as unknown as Device;
+    method.postMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    const firmwareUpdate = method as unknown as {
+      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
+      waitForProtocolV2FirmwareUpdateComplete: (
+        value: typeof targets,
+        requireCurrentInstallStatus: boolean
+      ) => Promise<void>;
+    };
+
+    await firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
+    const requestOptions = call.mock.calls[0]?.[2] as {
+      onResponseAfterWrite: (response: { type: 'Success'; message: Record<string, never> }) => void;
+    };
+    requestOptions.onResponseAfterWrite({ type: 'Success', message: {} });
+    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
+
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+  });
+
+  test('reconnects USB when the link is released while writing 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 typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ type: 'Success', message: {} })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            {
+              target_id: 4,
+              status: 'FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS',
+              path: 'vol0:/application_p1.bin',
+            },
+          ],
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            {
+              target_id: 4,
+              status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+              path: 'vol0:/application_p1.bin',
+            },
+          ],
+        },
+      });
+    const call = jest.fn().mockRejectedValue(new Error('device was disconnected'));
+
+    method.device = {
+      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
+      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
+      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-usb' }),
+      setCancelableAction: jest.fn(),
+      clearCancelableAction: jest.fn(),
+    } as unknown as Device;
+    method.postMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    const firmwareUpdate = method as unknown as {
+      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
+      waitForProtocolV2FirmwareUpdateComplete: (
+        value: typeof targets,
+        requireCurrentInstallStatus: boolean
+      ) => Promise<void>;
+      reconnectProtocolV2Device: (options: { skipProtocolProbe: boolean }) => Promise<void>;
+      verifyProtocolV2ReconnectIdentity: () => Promise<Record<string, never>>;
+    };
+    firmwareUpdate.reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    firmwareUpdate.verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue({});
+    (method as any).isBleReconnect = jest.fn(() => false);
+
+    await firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
+    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
+
+    expect(firmwareUpdate.reconnectProtocolV2Device).toHaveBeenCalledWith({
+      skipProtocolProbe: true,
+    });
+    expect(firmwareUpdate.verifyProtocolV2ReconnectIdentity).toHaveBeenCalledTimes(1);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
   test('writes the BLE Request and completes only from target status polling', async () => {
@@ -155,6 +318,67 @@ describe('FirmwareUpdateV4 install polling', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
+  test('confirms App mode when BLE status becomes empty after current install progress', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        connectId: 'pro2-ble',
+      },
+    });
+    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: {
+          records: [
+            {
+              target_id: 4,
+              status: 'FW_MGMT_UPDATER_TASK_STATUS_IN_PROGRESS',
+              path: 'vol0:/application_p1.bin',
+            },
+          ],
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceFirmwareUpdateStatus',
+        message: { records: [] },
+      });
+    const reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    const deviceInfo = {};
+    const verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue(deviceInfo);
+    const probeProtocolV2NormalMode = jest.fn().mockResolvedValue(true);
+
+    method.device = {
+      getCommands: () => ({ typedCall }),
+    } as unknown as Device;
+    method.postProgressMessage = jest.fn();
+
+    const firmwareUpdate = method as unknown as {
+      protocolV2InstallNeedsReconnect: boolean;
+      waitForProtocolV2FirmwareUpdateComplete: (
+        value: typeof targets,
+        requireCurrentInstallStatus: boolean
+      ) => Promise<void>;
+      reconnectProtocolV2Device: (options: { skipProtocolProbe: boolean }) => Promise<void>;
+      verifyProtocolV2ReconnectIdentity: () => Promise<typeof deviceInfo>;
+      probeProtocolV2NormalMode: (value: typeof deviceInfo) => Promise<boolean>;
+    };
+    firmwareUpdate.protocolV2InstallNeedsReconnect = true;
+    firmwareUpdate.reconnectProtocolV2Device = reconnectProtocolV2Device;
+    firmwareUpdate.verifyProtocolV2ReconnectIdentity = verifyProtocolV2ReconnectIdentity;
+    firmwareUpdate.probeProtocolV2NormalMode = probeProtocolV2NormalMode;
+    (method as any).isBleReconnect = jest.fn(() => true);
+
+    await firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true);
+
+    expect(reconnectProtocolV2Device).toHaveBeenCalledWith({ skipProtocolProbe: true });
+    expect(verifyProtocolV2ReconnectIdentity).toHaveBeenCalledTimes(1);
+    expect(probeProtocolV2NormalMode).toHaveBeenCalledWith(deviceInfo);
+    expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
+  });
+
   test('does not send Request when Stage is rejected', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -192,40 +416,46 @@ describe('FirmwareUpdateV4 install polling', () => {
     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.reject(actionCancelledError);
       }
       return Promise.resolve({ type: 'Success', message: {} });
     });
     const call = jest.fn().mockResolvedValue({
-      type: 'Failure',
-      message: { code: 'Failure_ActionCancelled' },
+      type: 'WriteCompleted',
+      message: {},
     });
 
     method.device = {
-      getCommands: () => ({ typedCall, call }),
+      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2-usb' }),
       setCancelableAction: jest.fn(),
+      clearCancelableAction: jest.fn(),
     } as unknown as Device;
     method.postMessage = jest.fn();
     method.postProgressMessage = jest.fn();
 
+    const firmwareUpdate = method as unknown as {
+      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
+      waitForProtocolV2FirmwareUpdateComplete: (
+        value: typeof targets,
+        requireCurrentInstallStatus: boolean
+      ) => Promise<void>;
+    };
+
+    await firmwareUpdate.protocolV2StartFirmwareUpdate({ targets });
     await expect(
-      (
-        method as unknown as {
-          protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<void>;
-        }
-      ).protocolV2StartFirmwareUpdate({ targets })
+      firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets, true)
     ).rejects.toMatchObject({
       errorCode: HardwareErrorCode.ActionCancelled,
     });
 
-    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
-    expect(call).not.toHaveBeenCalled();
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({ returnAfterWrite: true })
+    );
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 

package/__tests__/protocol-v2.test.ts

@@ -5401,6 +5401,7 @@ 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 = {
@@ -5413,7 +5414,7 @@ describe('Protocol V2 firmware update targets', () => {
     };
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, cancelDevice }),
+      getCommands: () => ({ typedCall, call, cancelDevice }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(interaction),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
       setCancelableAction: jest.fn(action => {
@@ -5442,18 +5443,21 @@ describe('Protocol V2 firmware update targets', () => {
         interaction,
       },
     });
-    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(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      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(
-      typedCall.mock.invocationCallOrder[requestCallIndex]
+      call.mock.invocationCallOrder[0]
     );
     expect(method.postTipMessage).not.toHaveBeenCalled();
-    expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
     await cancelableAction?.();
     expect(cancelDevice).toHaveBeenCalledTimes(1);
   });
@@ -5466,9 +5470,10 @@ 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 }),
+      getCommands: () => ({ typedCall, call }),
     });
     method.postMessage = jest.fn();
     method.postTipMessage = jest.fn();
@@ -5480,7 +5485,7 @@ describe('Protocol V2 firmware update targets', () => {
       })
     ).rejects.toThrow('stage failed');
 
-    expect(typedCall).not.toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
+    expect(call).not.toHaveBeenCalled();
     expect(method.postMessage).not.toHaveBeenCalled();
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
@@ -5493,15 +5498,11 @@ describe('Protocol V2 firmware update targets', () => {
         method: 'firmwareUpdateV4',
       },
     });
-    const typedCall = jest.fn().mockImplementation((type: string) => {
-      if (type === 'DeviceFirmwareUpdateRequest') {
-        return Promise.reject(new Error('request failed'));
-      }
-      return Promise.resolve({ type: 'Success', message: {} });
-    });
+    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
+    const call = jest.fn().mockRejectedValue(new Error('request failed'));
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall }),
+      getCommands: () => ({ typedCall, call }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
     });
@@ -5515,7 +5516,15 @@ describe('Protocol V2 firmware update targets', () => {
       })
     ).rejects.toThrow('request failed');
 
-    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
+    );
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
@@ -5554,7 +5563,7 @@ describe('Protocol V2 firmware update targets', () => {
       })
     );
     expect(typedCall).not.toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
-    expect((method as any).protocolV2InstallNeedsBleReconnect).toBe(true);
+    expect((method as any).protocolV2InstallNeedsReconnect).toBe(true);
   });
 
   test.each([
@@ -5594,7 +5603,7 @@ describe('Protocol V2 firmware update targets', () => {
         getCommands: () => ({ typedCall }),
       });
       (method as any).isBleReconnect = jest.fn(() => true);
-      (method as any).protocolV2InstallNeedsBleReconnect = true;
+      (method as any).protocolV2InstallNeedsReconnect = true;
       (method as any).reconnectProtocolV2Device = reconnectProtocolV2Device;
       (method as any).verifyProtocolV2ReconnectIdentity = verifyProtocolV2ReconnectIdentity;
       method.postProgressMessage = jest.fn();
@@ -6150,7 +6159,7 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
     });
-    (method as any).protocolV2InstallRequestConfirmed = true;
+    (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);
@@ -6196,7 +6205,7 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall }),
     });
-    (method as any).protocolV2InstallRequestConfirmed = true;
+    (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);
@@ -9087,27 +9096,28 @@ describe('Protocol V2 firmware update targets', () => {
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([1960, 1]);
   });
 
-  test('keeps confirmation active until the empty Request responds, then enters install', async () => {
+  test('keeps confirmation active after the Request write until terminal Success arrives', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    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: {} });
+    let onResponseAfterWrite:
+      | ((response: { type: string; message: Record<string, never> }) => void)
+      | undefined;
+    const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
+    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 }),
+      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();
@@ -9125,17 +9135,28 @@ describe('Protocol V2 firmware update targets', () => {
       'Success',
       { targets: [{ target_id: 4, path: 'vol1:firmware.bin' }] },
     ]);
-    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
+    );
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
+    expect(clearCancelableAction).not.toHaveBeenCalled();
 
-    resolveRequest?.({ type: 'Success', 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).toHaveBeenCalledWith(1, 'installingFirmware');
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
-  test('returns after the empty Protocol V2 firmware install request responds', async () => {
+  test('returns after the empty Protocol V2 firmware install request is written', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -9146,9 +9167,13 @@ 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 }),
+      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
     });
@@ -9161,9 +9186,17 @@ describe('Protocol V2 firmware update targets', () => {
     });
 
     expect(typedCall.mock.calls[0][0]).toBe('DeviceFirmwareUpdateStage');
-    expect(typedCall).toHaveBeenCalledWith('DeviceFirmwareUpdateRequest', 'Success', {});
+    expect(call).toHaveBeenCalledWith(
+      'DeviceFirmwareUpdateRequest',
+      {},
+      expect.objectContaining({
+        returnAfterWrite: true,
+        expectedTypes: ['Success'],
+        onResponseAfterWrite: expect.any(Function),
+      })
+    );
     expect(method.postTipMessage).not.toHaveBeenCalled();
-    expect(method.postProgressMessage).toHaveBeenCalledWith(1, 'installingFirmware');
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 });
 

package/dist/api/FirmwareUpdateV4.d.ts

@@ -17,8 +17,8 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     private protocolV2LatestFinalFeatures?;
     private protocolV2LatestFinalDeviceInfo?;
     private protocolV2InstallBaselineVersions;
-    private protocolV2InstallNeedsBleReconnect;
-    private protocolV2InstallRequestConfirmed;
+    private protocolV2InstallNeedsReconnect;
+    private protocolV2InstallTerminalSuccessObserved;
     private protocolV2LastRuntimeProbeFeatures?;
     private protocolV2LastTransferProgress?;
     private protocolV2LastTransferProgressAt;

package/dist/api/FirmwareUpdateV4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"FirmwareUpdateV4.d.ts","sourceRoot":"","sources":["../../src/api/FirmwareUpdateV4.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAkD,MAAM,qBAAqB,CAAC;AA0BlG,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AA+B/E,OAAO,KAAK,EAEV,sBAAsB,EAEvB,MAAM,6BAA6B,CAAC;AAoErC,wBAAgB,wCAAwC,CACtD,UAAU,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,EAC5C,MAAM,EAAE,sBAAsB,EAC9B,0BAA0B,UAAQ,QAiCnC;AAuSD,eAAO,MAAM,oCAAoC,WACvC,WAAW,GAAG,UAAU,eACnB,MAAM,GAAG,SAAS,YAKhC,CAAC;AAEF,eAAO,MAAM,iCAAiC,0BACrB,MAAM,uBACR,MAAM,iBACZ,MAAM,eACR,MAAM,SAsBpB,CAAC;AAUF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,wBAAwB,CAAC,sBAAsB,CAAC;IAC5F,OAAO,CAAC,8BAA8B,CAAC,CAAS;IAEhD,OAAO,CAAC,sBAAsB,CAAC,CAAS;IAExC,OAAO,CAAC,oCAAoC,CAAS;IAErD,qBAAqB;IAIrB,OAAO,CAAC,yBAAyB,CAA4B;IAE7D,OAAO,CAAC,2BAA2B,CAAS;IAE5C,OAAO,CAAC,iCAAiC,CAAS;IAElD,OAAO,CAAC,iCAAiC,CAA6B;IAEtE,OAAO,CAAC,4BAA4B,CAAqB;IAEzD,OAAO,CAAC,6BAA6B,CAAC,CAAW;IAEjD,OAAO,CAAC,+BAA+B,CAAC,CAAuB;IAE/D,OAAO,CAAC,iCAAiC,CAA6B;IAEtE,OAAO,CAAC,+BAA+B,CAAS;IAEhD,OAAO,CAAC,wCAAwC,CAAS;IAEzD,OAAO,CAAC,kCAAkC,CAAC,CAAW;IAEtD,OAAO,CAAC,8BAA8B,CAAC,CAAS;IAEhD,OAAO,CAAC,gCAAgC,CAAK;IAE7C,IAAI;IA6LJ,OAAO,CAAC,8BAA8B;IAwBhC,GAAG;;;;;YAKK,aAAa;YA0Ib,4BAA4B;YAkB5B,0BAA0B;YAY1B,8BAA8B;YAK9B,+BAA+B;YAqG/B,4BAA4B;YA+C5B,0CAA0C;YAkB1C,qCAAqC;YAoFrC,gCAAgC;YAgBhC,uCAAuC;YAmDvC,8BAA8B;IA8B5C,OAAO,CAAC,8BAA8B;IA0BtC,OAAO,CAAC,kCAAkC;IAc1C,OAAO,CAAC,gCAAgC;YAuD1B,2BAA2B;IAmBzC,OAAO,CAAC,yBAAyB;IAKjC,OAAO,CAAC,oCAAoC;IAY5C,OAAO,CAAC,4BAA4B;IAUpC,OAAO,CAAC,kCAAkC;IAS1C,OAAO,CAAC,8BAA8B;YAMxB,iCAAiC;YAOjC,iCAAiC;YAmBjC,iCAAiC;IAM/C,OAAO,CAAC,uBAAuB;IAI/B,OAAO,CAAC,mCAAmC;IAe3C,OAAO,CAAC,iCAAiC;IAWzC,OAAO,CAAC,2BAA2B;IAsBnC,OAAO,CAAC,yBAAyB;IAiBjC,OAAO,CAAC,wBAAwB;YAkBlB,iCAAiC;YA6CjC,uCAAuC;YA0CvC,+BAA+B;IAmF7C,OAAO,CAAC,6BAA6B;IAMrC,OAAO,CAAC,gCAAgC;YAM1B,8BAA8B;YAmD9B,kCAAkC;IA+BhD,OAAO,CAAC,0BAA0B;IAUlC,OAAO,CAAC,yBAAyB;YAcnB,4BAA4B;IAkBpC,6BAA6B;YAkBrB,+BAA+B;IAkD7C,OAAO,CAAC,6BAA6B;YAkCvB,6BAA6B;YA0B7B,0CAA0C;YA6B1C,uBAAuB;YAiCvB,8BAA8B;YAwE9B,6BAA6B;IA8E3C,OAAO,CAAC,mCAAmC;YAI7B,0BAA0B;IAaxC,OAAO,CAAC,8BAA8B;IAiBtC,OAAO,CAAC,4BAA4B;IA6IpC,OAAO,CAAC,6BAA6B;IAcrC,OAAO,CAAC,qCAAqC;IAyB7C,OAAO,CAAC,kCAAkC;IAgB1C,OAAO,CAAC,8CAA8C;YAIxC,uCAAuC;YAiPvC,gCAAgC;YAehC,yBAAyB;IASvC,OAAO,CAAC,2BAA2B;YAMrB,8BAA8B;IAQ5C,OAAO,CAAC,0BAA0B;YAkBpB,mCAAmC;YAWnC,qCAAqC;YAmDrC,yBAAyB;YAgGzB,8BAA8B;IAU5C,OAAO,CAAC,kCAAkC;YAQ5B,cAAc;YAuCd,6BAA6B;YAW7B,0BAA0B;YAoB1B,6BAA6B;YAoD7B,gBAAgB;IAiB9B,OAAO,CAAC,qBAAqB;CAM9B"}

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";AACA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAoClC,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAsB1C,OAAO,eAAe,MAAM,2BAA2B,CAAC;AAYxD,OAAO,KAAK,EAAE,eAAe,EAAyB,MAAM,UAAU,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAmD,MAAM,WAAW,CAAC;AAI9F,OAAO,KAAK,EACV,6BAA6B,EAG9B,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAWpD,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;AAmE7D,eAAO,MAAM,OAAO,YAAmB,WAAW,WAAW,WAAW,iBAoFvE,CAAC;AAwqBF,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,WAWpF;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,WAW/E;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,WAQlF;AAiVD,eAAO,MAAM,MAAM,YAAa,WAAW,cAAc,MAAM,SAuG9D,CAAC;AAmGF,eAAO,MAAM,qBAAqB,gFAejC,CAAC;AAiLF,MAAM,CAAC,OAAO,OAAO,IAAK,SAAQ,YAAY;IAC5C,OAAO,CAAC,cAAc,CAAoB;IAE1C,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC,OAAO,CAAC,YAAY,CAAsB;IAE1C,OAAO,CAAC,cAAc,CAAC,CAAgB;IAGvC,OAAO,CAAC,sBAAsB,CAAoC;IAElE,OAAO,CAAC,iBAAiB,CAAoB;;IAS7C,OAAO,CAAC,cAAc;IA6BhB,aAAa,CAAC,OAAO,EAAE,WAAW;IAuExC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YAOV,gBAAgB;CAiC/B;AAED,eAAO,MAAM,QAAQ,YAIpB,CAAC;AAEF,eAAO,MAAM,aAAa,uBAYzB,CAAC;AAMF,eAAO,MAAM,IAAI,aACL,eAAe,aACd,GAAG,WACL,6BAA6B,8BAiBvC,CAAC;AAEF,eAAO,MAAM,eAAe;SAKrB,eAAe,CAAC,KAAK,CAAC;eAChB,GAAG;;UASf,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":";AACA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAoClC,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAsB1C,OAAO,eAAe,MAAM,2BAA2B,CAAC;AAYxD,OAAO,KAAK,EAAE,eAAe,EAAyB,MAAM,UAAU,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAmD,MAAM,WAAW,CAAC;AAI9F,OAAO,KAAK,EACV,6BAA6B,EAG9B,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAWpD,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC;AAmE7D,eAAO,MAAM,OAAO,YAAmB,WAAW,WAAW,WAAW,iBAoFvE,CAAC;AAiqBF,wBAAgB,kCAAkC,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,WAWpF;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,WAW/E;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO,WAQlF;AA0PD,eAAO,MAAM,MAAM,YAAa,WAAW,cAAc,MAAM,SAuG9D,CAAC;AAmGF,eAAO,MAAM,qBAAqB,gFAejC,CAAC;AAiLF,MAAM,CAAC,OAAO,OAAO,IAAK,SAAQ,YAAY;IAC5C,OAAO,CAAC,cAAc,CAAoB;IAE1C,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC,OAAO,CAAC,YAAY,CAAsB;IAE1C,OAAO,CAAC,cAAc,CAAC,CAAgB;IAGvC,OAAO,CAAC,sBAAsB,CAAoC;IAElE,OAAO,CAAC,iBAAiB,CAAoB;;IAS7C,OAAO,CAAC,cAAc;IA6BhB,aAAa,CAAC,OAAO,EAAE,WAAW;IAuExC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YAOV,gBAAgB;CAiC/B;AAED,eAAO,MAAM,QAAQ,YAIpB,CAAC;AAEF,eAAO,MAAM,aAAa,uBAYzB,CAAC;AAMF,eAAO,MAAM,IAAI,aACL,eAAe,aACd,GAAG,WACL,6BAA6B,8BAiBvC,CAAC;AAEF,eAAO,MAAM,eAAe;SAKrB,eAAe,CAAC,KAAK,CAAC;eAChB,GAAG;;UASf,CAAC"}

package/dist/index.js

@@ -51982,8 +51982,8 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         this.protocolV2CompletedTargetVersions = new Map();
         this.protocolV2CompletedTargetIds = new Set();
         this.protocolV2InstallBaselineVersions = new Map();
-        this.protocolV2InstallNeedsBleReconnect = false;
-        this.protocolV2InstallRequestConfirmed = false;
+        this.protocolV2InstallNeedsReconnect = false;
+        this.protocolV2InstallTerminalSuccessObserved = false;
         this.protocolV2LastTransferProgressAt = 0;
     }
     getSupportedProtocols() {
@@ -53417,11 +53417,11 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
             const startTime = Date.now();
             let lastError;
-            let shouldReconnect = this.protocolV2InstallNeedsBleReconnect;
-            this.protocolV2InstallNeedsBleReconnect = false;
+            let shouldReconnect = this.protocolV2InstallNeedsReconnect;
+            this.protocolV2InstallNeedsReconnect = false;
             let deviceInfo;
             let bleInstallLinkReady = false;
-            let installEvidenceObserved = this.protocolV2InstallRequestConfirmed;
+            let installEvidenceObserved = this.protocolV2InstallTerminalSuccessObserved;
             let currentInstallStatusObserved = false;
             const liveTargetIds = new Set();
             while (Date.now() - startTime < PROTOCOL_V2_INSTALL_TIMEOUT) {
@@ -53436,7 +53436,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             : yield this.verifyProtocolV2ReconnectIdentity();
                         shouldReconnect = false;
                     }
-                    const currentDeviceInfo = deviceInfo;
+                    let currentDeviceInfo = deviceInfo;
                     try {
                         const statusResponse = yield this.device.getCommands().typedCall('DeviceFirmwareUpdateStatusGet', 'DeviceFirmwareUpdateStatus', {
                             fields: {
@@ -53445,7 +53445,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                                 path: true,
                             },
                         }, { timeoutMs: PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT });
-                        if (this.protocolV2InstallRequestConfirmed) {
+                        if (this.protocolV2InstallTerminalSuccessObserved) {
                             installEvidenceObserved = true;
                         }
                         const statusTargets = ((_a = statusResponse.message.records) !== null && _a !== void 0 ? _a : []);
@@ -53465,16 +53465,29 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                             const targetId = normalizeProtocolV2TargetId(target.target_id);
                             return targetId !== undefined && expectedTargetIds.has(targetId);
                         });
-                        const shouldVerifyTargetCompletion = !requireCurrentInstallStatus || currentInstallStatusObserved;
+                        const hasCurrentInstallEvidence = currentInstallStatusObserved || this.protocolV2InstallTerminalSuccessObserved;
+                        const shouldVerifyTargetCompletion = !requireCurrentInstallStatus || hasCurrentInstallEvidence;
                         if (shouldVerifyTargetCompletion &&
-                            this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths, requireCurrentInstallStatus ? liveTargetIds : undefined)) {
+                            this.assertProtocolV2TargetStatus(statusTargets, expectedTargetIds, expectedPaths, requireCurrentInstallStatus && !this.protocolV2InstallTerminalSuccessObserved
+                                ? liveTargetIds
+                                : undefined)) {
                             return;
                         }
+                        if (!hasCurrentInstallEvidence) {
+                            this.device.setCancelableAction(() => this.device.getCommands().cancelDevice());
+                        }
                         if (requireCurrentInstallStatus &&
-                            !currentInstallStatusObserved &&
+                            !hasCurrentInstallEvidence &&
                             matchingStatusTargets.length > 0) {
                             lastError = new Error('Protocol V2 firmware status is stale; waiting for the current install to start');
                         }
+                        if (statusTargets.length === 0 &&
+                            !currentDeviceInfo &&
+                            bleInstallLinkReady &&
+                            installEvidenceObserved) {
+                            currentDeviceInfo = yield this.verifyProtocolV2ReconnectIdentity();
+                            deviceInfo = currentDeviceInfo;
+                        }
                         if (statusTargets.length === 0 && currentDeviceInfo) {
                             const isNormalMode = yield this.probeProtocolV2NormalMode(currentDeviceInfo);
                             if (isNormalMode &&
@@ -53797,54 +53810,34 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     protocolV2StartFirmwareUpdate({ targets, }) {
         return __awaiter(this, void 0, void 0, function* () {
             this.protocolV2LastRuntimeProbeFeatures = undefined;
-            this.protocolV2InstallNeedsBleReconnect = false;
-            this.protocolV2InstallRequestConfirmed = false;
+            this.protocolV2InstallNeedsReconnect = false;
+            this.protocolV2InstallTerminalSuccessObserved = false;
             const commands = this.device.getCommands();
             yield commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
-            this.device.setCancelableAction(() => commands.cancelDevice());
+            this.device.setCancelableAction(() => this.device.getCommands().cancelDevice());
             const interaction = this.device.createProtocolV2UiPhaseMetadata('button', 'start');
             this.postMessage(createUiMessage(UI_REQUEST.REQUEST_BUTTON, Object.assign({ device: this.device.toMessageObject(), source: 'method-lifecycle', reason: 'firmware-update', completion: 'operation-completed', deviceOnly: true, operation: this.name }, (interaction ? { interaction } : {}))));
-            if (this.isBleReconnect()) {
-                try {
-                    yield commands.call('DeviceFirmwareUpdateRequest', {}, {
-                        returnAfterWrite: true,
-                        expectedTypes: ['Success'],
-                        onResponseAfterWrite: response => {
-                            if (response.type !== 'Success')
-                                return;
-                            this.protocolV2InstallRequestConfirmed = true;
-                            this.device.clearCancelableAction();
-                            this.postProgressMessage(1, 'installingFirmware');
-                            Log$7.log('[FirmwareUpdateV4] BLE firmware install confirmed by device response');
-                        },
-                    });
-                    Log$7.log('[FirmwareUpdateV4] BLE firmware install request written; continue with status polling');
-                }
-                catch (error) {
-                    this.throwIfAborted();
-                    if (!isProtocolV2DeviceDisconnectedError(error)) {
-                        throw error;
-                    }
-                    Log$7.log('[FirmwareUpdateV4] BLE transport released while writing install request; continue status polling');
-                    this.protocolV2InstallNeedsBleReconnect = true;
-                }
-                return;
-            }
             try {
-                yield commands.typedCall('DeviceFirmwareUpdateRequest', 'Success', {});
-                this.protocolV2InstallRequestConfirmed = true;
-                this.postProgressMessage(1, 'installingFirmware');
-                Log$7.log('[FirmwareUpdateV4] firmware install confirmed by device response');
+                yield commands.call('DeviceFirmwareUpdateRequest', {}, {
+                    returnAfterWrite: true,
+                    expectedTypes: ['Success'],
+                    onResponseAfterWrite: response => {
+                        if (response.type !== 'Success')
+                            return;
+                        this.protocolV2InstallTerminalSuccessObserved = true;
+                        this.device.clearCancelableAction();
+                        Log$7.log('[FirmwareUpdateV4] firmware install completed by device response');
+                    },
+                });
+                Log$7.log('[FirmwareUpdateV4] firmware install request written; continue with status polling');
             }
             catch (error) {
                 this.throwIfAborted();
                 if (!isProtocolV2DeviceDisconnectedError(error)) {
                     throw error;
                 }
-                Log$7.log('[FirmwareUpdateV4] BLE transport released after install request; continue status polling');
-                if (this.isBleReconnect()) {
-                    this.protocolV2InstallNeedsBleReconnect = true;
-                }
+                Log$7.log('[FirmwareUpdateV4] transport released while writing install request; continue status polling');
+                this.protocolV2InstallNeedsReconnect = true;
             }
         });
     }
@@ -65191,8 +65184,6 @@ const onCallDevice = (context, message, method) => __awaiter(void 0, void 0, voi
     if ((_g = method.payload) === null || _g === void 0 ? void 0 : _g.onlyConnectBleDevice) {
         preWarmCallbackTask === null || preWarmCallbackTask === void 0 ? void 0 : preWarmCallbackTask.resolve();
         Log.debug('Call API - only connect ble device: ', device === null || device === void 0 ? void 0 : device.mainId);
-        completeMethodRequestContext(method);
-        requestQueue.releaseTask(method.responseID);
         return createResponseMessage(method.responseID, true, null);
     }
     Log.debug('Call API - setDevice: ', device.mainId);
@@ -65568,31 +65559,7 @@ function isMissingDetectedProtocolV2Error(method, error) {
         typeof typedError.message === 'string' &&
         typedError.message.includes('Device protocol has not been detected'));
 }
-const BLE_ACQUIRE_DEADLINE_MS = 60 * 1000;
-function raceBleAcquire(acquirePromise, abortSignal) {
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        const settle = (fn) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(deadline);
-            abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.removeEventListener('abort', onAbort);
-            fn();
-        };
-        const onAbort = () => settle(() => reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled)));
-        const deadline = setTimeout(() => settle(() => reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`))), BLE_ACQUIRE_DEADLINE_MS);
-        acquirePromise.then(value => settle(() => resolve(value)), error => settle(() => reject(error)));
-        if (abortSignal) {
-            if (abortSignal.aborted) {
-                onAbort();
-                return;
-            }
-            abortSignal.addEventListener('abort', onAbort);
-        }
-    });
-}
-function connectDeviceForBle(method, device, abortSignal, retryCount = 0) {
+function connectDeviceForBle(method, device, retryCount = 0) {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
         try {
@@ -65607,31 +65574,9 @@ function connectDeviceForBle(method, device, abortSignal, retryCount = 0) {
                 !device.commands ||
                 device.commands.disposed;
             if (shouldAcquire) {
-                const useAcquireGuards = DataManager.getSettings('env') === 'desktop-web-ble';
-                if (useAcquireGuards && (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallQueueActionCancelled);
-                }
-                if (!useAcquireGuards) {
-                    yield device.acquire(method.payload.connectProtocol, {
-                        forceProtocolDetection: method.payload.forceProtocolDetection,
-                    });
-                }
-                else {
-                    try {
-                        yield raceBleAcquire(device.acquire(method.payload.connectProtocol, {
-                            forceProtocolDetection: method.payload.forceProtocolDetection,
-                        }), abortSignal);
-                    }
-                    catch (err) {
-                        if (err.errorCode === hdShared.HardwareErrorCode.BleTimeoutError &&
-                            device.mainId &&
-                            device.deviceConnector) {
-                            yield device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
-                            device.markTransportDisconnected();
-                        }
-                        throw err;
-                    }
-                }
+                yield device.acquire(method.payload.connectProtocol, {
+                    forceProtocolDetection: method.payload.forceProtocolDetection,
+                });
             }
             if ((_a = method.payload) === null || _a === void 0 ? void 0 : _a.onlyConnectBleDevice) {
                 if (shouldAcquire) {
@@ -65662,7 +65607,7 @@ function connectDeviceForBle(method, device, abortSignal, retryCount = 0) {
                 const nextRetry = retryCount + 1;
                 Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
                 yield wait(3000);
-                yield connectDeviceForBle(method, device, abortSignal, nextRetry);
+                yield connectDeviceForBle(method, device, nextRetry);
             }
             else {
                 throw err;
@@ -65747,7 +65692,7 @@ const ensureConnected = (_context, method, connectId, pollingId, abortSignal) =>
                         if (tryCount === 1) {
                             device.beginConnectionAttempt();
                         }
-                        yield connectDeviceForBle(method, device, abortSignal);
+                        yield connectDeviceForBle(method, device);
                     }
                     resolve(device);
                     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.0-alpha.174",
+  "version": "1.2.0-alpha.176",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.0-alpha.174",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.174",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.176",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.176",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "buffer": "^6.0.3",
@@ -46,5 +46,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "ea906ff2ef191338cbc98d083e8217ddfb23c92c"
+  "gitHead": "a5152148317effe811cde8adecdfe75c28e82657"
 }

package/src/api/FirmwareUpdateV4.ts

@@ -530,9 +530,9 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
 
   private protocolV2InstallBaselineVersions = new Map<number, string>();
 
-  private protocolV2InstallNeedsBleReconnect = false;
+  private protocolV2InstallNeedsReconnect = false;
 
-  private protocolV2InstallRequestConfirmed = false;
+  private protocolV2InstallTerminalSuccessObserved = false;
 
   private protocolV2LastRuntimeProbeFeatures?: Features;
 
@@ -2441,13 +2441,13 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     const expectedPaths = new Map(targets.map(target => [target.target_id, target.path]));
     const startTime = Date.now();
     let lastError: unknown;
-    // USB may keep the loader link usable. BLE can release it as installation starts, so its
-    // recovery reconnects directly to status polling without generic Ping or DeviceInfo probes.
-    let shouldReconnect = this.protocolV2InstallNeedsBleReconnect;
-    this.protocolV2InstallNeedsBleReconnect = false;
+    // The loader may release either USB or BLE as installation starts. Recovery reconnects
+    // directly to status polling without generic Ping or DeviceInfo probes.
+    let shouldReconnect = this.protocolV2InstallNeedsReconnect;
+    this.protocolV2InstallNeedsReconnect = false;
     let deviceInfo: ProtocolV2DeviceInfo | undefined;
     let bleInstallLinkReady = false;
-    let installEvidenceObserved = this.protocolV2InstallRequestConfirmed;
+    let installEvidenceObserved = this.protocolV2InstallTerminalSuccessObserved;
     let currentInstallStatusObserved = false;
     const liveTargetIds = new Set<number>();
 
@@ -2465,7 +2465,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             : await this.verifyProtocolV2ReconnectIdentity();
           shouldReconnect = false;
         }
-        const currentDeviceInfo = deviceInfo;
+        let currentDeviceInfo = deviceInfo;
         try {
           const statusResponse = await this.device.getCommands().typedCall(
             'DeviceFirmwareUpdateStatusGet',
@@ -2479,7 +2479,7 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             },
             { timeoutMs: PROTOCOL_V2_FIRMWARE_STATUS_RESPONSE_TIMEOUT }
           );
-          if (this.protocolV2InstallRequestConfirmed) {
+          if (this.protocolV2InstallTerminalSuccessObserved) {
             installEvidenceObserved = true;
           }
           const statusTargets = (statusResponse.message.records ??
@@ -2502,23 +2502,33 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             const targetId = normalizeProtocolV2TargetId(target.target_id);
             return targetId !== undefined && expectedTargetIds.has(targetId);
           });
+          const hasCurrentInstallEvidence =
+            currentInstallStatusObserved || this.protocolV2InstallTerminalSuccessObserved;
           const shouldVerifyTargetCompletion =
-            !requireCurrentInstallStatus || currentInstallStatusObserved;
+            !requireCurrentInstallStatus || hasCurrentInstallEvidence;
           if (
             shouldVerifyTargetCompletion &&
             this.assertProtocolV2TargetStatus(
               statusTargets,
               expectedTargetIds,
               expectedPaths,
-              requireCurrentInstallStatus ? liveTargetIds : undefined
+              requireCurrentInstallStatus && !this.protocolV2InstallTerminalSuccessObserved
+                ? liveTargetIds
+                : undefined
             )
           ) {
             return;
           }
 
+          if (!hasCurrentInstallEvidence) {
+            // A successful status poll clears DeviceCommands' cancel action. Keep cancellation
+            // available while UpdateRequest is still waiting for confirmation on the device.
+            this.device.setCancelableAction(() => this.device.getCommands().cancelDevice());
+          }
+
           if (
             requireCurrentInstallStatus &&
-            !currentInstallStatusObserved &&
+            !hasCurrentInstallEvidence &&
             matchingStatusTargets.length > 0
           ) {
             lastError = new Error(
@@ -2526,6 +2536,18 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
             );
           }
 
+          if (
+            statusTargets.length === 0 &&
+            !currentDeviceInfo &&
+            bleInstallLinkReady &&
+            installEvidenceObserved
+          ) {
+            // BLE install reconnect skips generic probes because loaders may not answer Ping.
+            // Restore the verified identity only after current-install evidence disappears.
+            currentDeviceInfo = await this.verifyProtocolV2ReconnectIdentity();
+            deviceInfo = currentDeviceInfo;
+          }
+
           if (statusTargets.length === 0 && currentDeviceInfo) {
             const isNormalMode = await this.probeProtocolV2NormalMode(currentDeviceInfo);
             if (
@@ -2960,11 +2982,11 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
     targets: Array<{ target_id: number; path: string }>;
   }) {
     this.protocolV2LastRuntimeProbeFeatures = undefined;
-    this.protocolV2InstallNeedsBleReconnect = false;
-    this.protocolV2InstallRequestConfirmed = false;
+    this.protocolV2InstallNeedsReconnect = false;
+    this.protocolV2InstallTerminalSuccessObserved = false;
     const commands = this.device.getCommands();
     await commands.typedCall('DeviceFirmwareUpdateStage', 'Success', { targets });
-    this.device.setCancelableAction(() => commands.cancelDevice());
+    this.device.setCancelableAction(() => this.device.getCommands().cancelDevice());
     const interaction = this.device.createProtocolV2UiPhaseMetadata('button', 'start');
     this.postMessage(
       createUiMessage(UI_REQUEST.REQUEST_BUTTON, {
@@ -2978,55 +3000,31 @@ export default class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod<FirmwareU
       })
     );
 
-    if (this.isBleReconnect()) {
-      try {
-        await commands.call(
-          'DeviceFirmwareUpdateRequest',
-          {},
-          {
-            returnAfterWrite: true,
-            expectedTypes: ['Success'],
-            onResponseAfterWrite: response => {
-              if (response.type !== 'Success') return;
-              this.protocolV2InstallRequestConfirmed = true;
-              this.device.clearCancelableAction();
-              this.postProgressMessage(1, 'installingFirmware');
-              Log.log('[FirmwareUpdateV4] BLE firmware install confirmed by device response');
-            },
-          }
-        );
-        Log.log(
-          '[FirmwareUpdateV4] BLE firmware install request written; continue with status polling'
-        );
-      } catch (error) {
-        this.throwIfAborted();
-        if (!isProtocolV2DeviceDisconnectedError(error)) {
-          throw error;
-        }
-        Log.log(
-          '[FirmwareUpdateV4] BLE transport released while writing install request; continue status polling'
-        );
-        this.protocolV2InstallNeedsBleReconnect = true;
-      }
-      return;
-    }
-
     try {
-      await commands.typedCall('DeviceFirmwareUpdateRequest', 'Success', {});
-      this.protocolV2InstallRequestConfirmed = true;
-      this.postProgressMessage(1, 'installingFirmware');
-      Log.log('[FirmwareUpdateV4] firmware install confirmed by device response');
+      await commands.call(
+        'DeviceFirmwareUpdateRequest',
+        {},
+        {
+          returnAfterWrite: true,
+          expectedTypes: ['Success'],
+          onResponseAfterWrite: response => {
+            if (response.type !== 'Success') return;
+            this.protocolV2InstallTerminalSuccessObserved = true;
+            this.device.clearCancelableAction();
+            Log.log('[FirmwareUpdateV4] firmware install completed by device response');
+          },
+        }
+      );
+      Log.log('[FirmwareUpdateV4] firmware install request written; continue with status polling');
     } catch (error) {
       this.throwIfAborted();
       if (!isProtocolV2DeviceDisconnectedError(error)) {
         throw error;
       }
       Log.log(
-        '[FirmwareUpdateV4] BLE transport released after install request; continue status polling'
+        '[FirmwareUpdateV4] transport released while writing install request; continue status polling'
       );
-      if (this.isBleReconnect()) {
-        this.protocolV2InstallNeedsBleReconnect = true;
-      }
+      this.protocolV2InstallNeedsReconnect = true;
     }
   }
 

package/src/core/index.ts

@@ -415,13 +415,6 @@ const onCallDevice = async (
   if (method.payload?.onlyConnectBleDevice) {
     preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
-    // This early return bypasses the normal-path bookkeeping at the end of the
-    // call. Without it the task leaks and haunts every later queue snapshot
-    // and cancel sweep (field log: a completed task lingered for 6 minutes),
-    // and the request stays in the active maps, so repeated preconnects pile
-    // up phantom work in diagnostics.
-    completeMethodRequestContext(method);
-    requestQueue.releaseTask(method.responseID);
     return createResponseMessage(method.responseID, true, null);
   }
 
@@ -961,60 +954,7 @@ export function isMissingDetectedProtocolV2Error(method: BaseMethod, error: unkn
  * If the Bluetooth connection times out, retry up to 6 times
  * @param retryCount - Current retry count (default 0)
  */
-// device.acquire awaits a transport reply with no deadline of its own; a
-// transport that never settles (field case: Electron main lost an IPC reply,
-// "reply was never sent" after 5 minutes) hangs the call forever and cancel()
-// only takes effect at poll checkpoints. Race acquire against a deadline and
-// the caller's abort signal so the hang is bounded and cancel is immediate.
-const BLE_ACQUIRE_DEADLINE_MS = 60 * 1000;
-
-function raceBleAcquire<T>(acquirePromise: Promise<T>, abortSignal?: AbortSignal): Promise<T> {
-  return new Promise<T>((resolve, reject) => {
-    let settled = false;
-    const settle = (fn: () => void) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(deadline);
-      abortSignal?.removeEventListener('abort', onAbort);
-      fn();
-    };
-    const onAbort = () =>
-      settle(() => reject(ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled)));
-    const deadline = setTimeout(
-      () =>
-        settle(() =>
-          reject(
-            ERRORS.TypedError(
-              HardwareErrorCode.BleTimeoutError,
-              `BLE acquire exceeded ${BLE_ACQUIRE_DEADLINE_MS}ms deadline`
-            )
-          )
-        ),
-      BLE_ACQUIRE_DEADLINE_MS
-    );
-    // Attach before any early return so a late settlement of acquirePromise
-    // is always consumed — an abort or deadline must never leave the acquire
-    // rejection unhandled.
-    acquirePromise.then(
-      value => settle(() => resolve(value)),
-      error => settle(() => reject(error))
-    );
-    if (abortSignal) {
-      if (abortSignal.aborted) {
-        onAbort();
-        return;
-      }
-      abortSignal.addEventListener('abort', onAbort);
-    }
-  });
-}
-
-async function connectDeviceForBle(
-  method: BaseMethod,
-  device: Device,
-  abortSignal?: AbortSignal,
-  retryCount = 0
-) {
+async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
   try {
     if (device.wasInterruptedByUser()) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceInterruptedFromUser);
@@ -1028,43 +968,9 @@ async function connectDeviceForBle(
       !device.commands ||
       device.commands.disposed;
     if (shouldAcquire) {
-      // The deadline/abort guards are scoped to the desktop electron
-      // transport: its IPC acquire is the only path with a proven
-      // never-settling failure mode, while react-native/lowlevel acquire may
-      // legitimately block on a user-driven system bonding prompt for longer
-      // than any sane deadline. Other envs keep the plain acquire unchanged.
-      const useAcquireGuards = DataManager.getSettings('env') === 'desktop-web-ble';
-      // A cancel landing during the retry backoff must not start a new acquire.
-      if (useAcquireGuards && abortSignal?.aborted) {
-        throw ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
-      }
-      if (!useAcquireGuards) {
-        await device.acquire(method.payload.connectProtocol, {
-          forceProtocolDetection: method.payload.forceProtocolDetection,
-        });
-      } else {
-        try {
-          await raceBleAcquire(
-            device.acquire(method.payload.connectProtocol, {
-              forceProtocolDetection: method.payload.forceProtocolDetection,
-            }),
-            abortSignal
-          );
-        } catch (err) {
-          // A deadline hit means the transport is wedged mid-acquire; drop the
-          // link before the retry so it cold-connects instead of stacking a
-          // second connect onto the half-open one.
-          if (
-            err.errorCode === HardwareErrorCode.BleTimeoutError &&
-            device.mainId &&
-            device.deviceConnector
-          ) {
-            await device.deviceConnector.disconnect(device.mainId).catch(() => undefined);
-            device.markTransportDisconnected();
-          }
-          throw err;
-        }
-      }
+      await device.acquire(method.payload.connectProtocol, {
+        forceProtocolDetection: method.payload.forceProtocolDetection,
+      });
     }
     if (method.payload?.onlyConnectBleDevice) {
       if (shouldAcquire) {
@@ -1104,7 +1010,7 @@ async function connectDeviceForBle(
       const nextRetry = retryCount + 1;
       Log.debug(`Bluetooth connection will retry, retry count: ${nextRetry}`);
       await wait(3000);
-      await connectDeviceForBle(method, device, abortSignal, nextRetry);
+      await connectDeviceForBle(method, device, nextRetry);
     } else {
       throw err;
     }
@@ -1214,7 +1120,7 @@ const ensureConnected = async (
             if (tryCount === 1) {
               device.beginConnectionAttempt();
             }
-            await connectDeviceForBle(method, device, abortSignal);
+            await connectDeviceForBle(method, device);
           }
           resolve(device);
           return;