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

package/__tests__/protocol-v2.test.ts

@@ -254,52 +254,6 @@ describe('DeviceUploadWallpaper', () => {
     });
   });
 
-  test('uploads and applies the fixed wallpaper package on firmware 1.0.1', 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: { message: 'wallpaper applied' } };
-      }
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const method = new DeviceUploadWallpaper({
-      id: 1,
-      payload: {
-        method: 'deviceUploadWallpaper',
-        jpegBase64: createJpegBase64(604, 1024),
-      },
-    });
-    const device = stubWallpaperDevice({
-      commands: { typedCall },
-      getCurrentFirmwareVersionString: jest.fn(() => '1.0.1'),
-    });
-    (method as any).device = device;
-    method.postMessage = jest.fn();
-
-    method.init();
-    const result = await method.run();
-
-    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(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('文件上传失败时不修改 wallpaper_path', async () => {
     const typedCall = jest.fn().mockImplementation(request => {
       if (request === 'FilesystemDirMake') return { message: {} };
@@ -1068,7 +1022,6 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'session-1',
       unlockedAttachPin: false,
       resumed: false,
-      walletStatusRefreshed: true,
     });
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
@@ -1332,7 +1285,6 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'main-wallet-session',
       unlockedAttachPin: undefined,
       resumed: false,
-      walletStatusRefreshed: true,
     });
 
     expect(promptPassphrase).toHaveBeenCalled();
@@ -1419,7 +1371,6 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'hidden-after-unlock-session',
       unlockedAttachPin: undefined,
       resumed: false,
-      walletStatusRefreshed: true,
     });
 
     expect(unlockDevice).not.toHaveBeenCalled();
@@ -4869,23 +4820,6 @@ 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,
@@ -4967,87 +4901,6 @@ 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,
@@ -5437,108 +5290,6 @@ 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,
@@ -5614,11 +5365,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(call).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateRequest',
       {},
-      expect.objectContaining({
-        returnAfterWrite: true,
-        expectedTypes: ['Success'],
-        onResponseAfterWrite: expect.any(Function),
-      })
+      { returnAfterWrite: true }
     );
     expect(typedCall.mock.invocationCallOrder[0]).toBeLessThan(call.mock.invocationCallOrder[0]);
     expect((method.postMessage as jest.Mock).mock.invocationCallOrder[0]).toBeLessThan(
@@ -5659,7 +5406,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
-  test('does not enter install state when the empty request fails', async () => {
+  test('does not enter install state when writing the empty request fails', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5667,7 +5414,7 @@ describe('Protocol V2 firmware update targets', () => {
       },
     });
     const typedCall = jest.fn().mockResolvedValue({ type: 'Success', message: {} });
-    const call = jest.fn().mockRejectedValue(new Error('request failed'));
+    const call = jest.fn().mockRejectedValue(new Error('write failed'));
 
     (method as any).device = stubDevice({
       getCommands: () => ({ typedCall, call }),
@@ -5682,117 +5429,13 @@ describe('Protocol V2 firmware update targets', () => {
       (method as any).protocolV2StartFirmwareUpdate({
         targets: [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
       })
-    ).rejects.toThrow('request failed');
+    ).rejects.toThrow('write failed');
 
-    expect(call).toHaveBeenCalledWith(
-      'DeviceFirmwareUpdateRequest',
-      {},
-      expect.objectContaining({
-        returnAfterWrite: true,
-        expectedTypes: ['Success'],
-        onResponseAfterWrite: expect.any(Function),
-      })
-    );
+    expect(call).toHaveBeenCalledTimes(1);
     expect(method.postTipMessage).not.toHaveBeenCalled();
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
-  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().mockResolvedValue({ type: 'Success', message: {} });
-    const call = jest.fn().mockRejectedValue(new Error('React Native BLE transport released'));
-
-    (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call }),
-      createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
-      toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
-    });
-    (method as any).isBleReconnect = jest.fn(() => true);
-    method.postMessage = jest.fn();
-
-    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);
-  });
-
-  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,
@@ -5836,7 +5479,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).toHaveBeenCalledWith(100, 'installingFirmware');
   });
 
-  test('keeps polling after an empty status response until the target finishes', async () => {
+  test('keeps polling after install ACK until the target finishes', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -5845,10 +5488,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
     const typedCall = jest
       .fn()
-      .mockResolvedValueOnce({
-        type: 'DeviceFirmwareUpdateStatus',
-        message: { records: [] },
-      })
+      .mockResolvedValueOnce({ type: 'Success', message: {} })
       .mockResolvedValueOnce({
         type: 'DeviceFirmwareUpdateStatus',
         message: { records: [] },
@@ -5990,38 +5630,6 @@ 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,
@@ -6070,141 +5678,6 @@ 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,
@@ -6311,6 +5784,7 @@ describe('Protocol V2 firmware update targets', () => {
     });
     const typedCall = jest
       .fn()
+      .mockResolvedValueOnce({ type: 'Success', message: {} })
       .mockRejectedValueOnce(new Error('Pro2 is rebooting'))
       .mockResolvedValueOnce({
         type: 'DeviceFirmwareUpdateStatus',
@@ -6327,7 +5801,6 @@ 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);
@@ -6348,54 +5821,6 @@ 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],
@@ -6758,7 +6183,7 @@ describe('Protocol V2 firmware update targets', () => {
     expect(reconnectProtocolV2Device).not.toHaveBeenCalled();
     expect(typedCall).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
-      'DeviceFirmwareUpdateStatus',
+      ['DeviceFirmwareUpdateStatus', 'Success'],
       expect.anything(),
       expect.anything()
     );
@@ -7040,12 +6465,10 @@ describe('Protocol V2 firmware update targets', () => {
     });
     expect(typedCall).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
-      'DeviceFirmwareUpdateStatus',
+      ['DeviceFirmwareUpdateStatus', 'Success'],
       {
         fields: {
           status: true,
-          progress_percent: true,
-          phase_info: true,
           payload_version: true,
           path: true,
         },
@@ -8760,36 +8183,6 @@ 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('throttles repeated transfer progress while preserving file completion', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -9296,28 +8689,26 @@ describe('Protocol V2 firmware update targets', () => {
     expect(writePayloads.map(payload => payload.file.data.byteLength)).toEqual([1960, 1]);
   });
 
-  test('keeps confirmation active after the Request write until terminal Success arrives', async () => {
+  test('keeps the confirmation UI active after Stage and the empty Request are written', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
         method: 'firmwareUpdateV4',
       },
     });
-    let onResponseAfterWrite:
-      | ((response: { type: string; message: Record<string, never> }) => void)
-      | undefined;
+    let resolveWrite: ((value: unknown) => 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();
+    const call = jest.fn().mockImplementation(
+      () =>
+        new Promise(resolve => {
+          resolveWrite = resolve;
+        })
+    );
 
     (method as any).device = stubDevice({
-      getCommands: () => ({ typedCall, call, cancelDevice: jest.fn() }),
+      getCommands: () => ({ typedCall, call }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
-      clearCancelableAction,
     });
     method.postMessage = jest.fn();
     method.postProgressMessage = jest.fn();
@@ -9338,25 +8729,18 @@ describe('Protocol V2 firmware update targets', () => {
     expect(call).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateRequest',
       {},
-      expect.objectContaining({
-        returnAfterWrite: true,
-        expectedTypes: ['Success'],
-        onResponseAfterWrite: expect.any(Function),
-      })
+      { returnAfterWrite: true }
     );
     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('returns after the empty Protocol V2 firmware install request is written', async () => {
+  test('sends an empty Protocol V2 firmware install request without waiting for its response', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
       payload: {
@@ -9367,13 +8751,10 @@ 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, cancelDevice: jest.fn() }),
+      getCommands: () => ({ typedCall, call }),
       createProtocolV2UiPhaseMetadata: jest.fn().mockReturnValue(undefined),
       toMessageObject: jest.fn().mockReturnValue({ connectId: 'pro2' }),
     });
@@ -9389,14 +8770,9 @@ describe('Protocol V2 firmware update targets', () => {
     expect(call).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateRequest',
       {},
-      expect.objectContaining({
-        returnAfterWrite: true,
-        expectedTypes: ['Success'],
-        onResponseAfterWrite: expect.any(Function),
-      })
+      { returnAfterWrite: true }
     );
     expect(method.postTipMessage).not.toHaveBeenCalled();
-    expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 });
 
@@ -9579,16 +8955,7 @@ 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: 1,
-            progress_percent: 42,
-            phase_info: { phase: 1, progress_percent: 60 },
-            payload_version: 1,
-            path: 'vol1:application_p1.bin',
-          },
-        ],
+        records: [{ target_id: 4, status: 2, payload_version: 1, path: 'vol1:application_p1.bin' }],
       },
     });
     const method = new DeviceGetFirmwareUpdateStatus({
@@ -9597,8 +8964,6 @@ describe('Protocol V2 firmware update method', () => {
         method: 'deviceGetFirmwareUpdateStatus',
         fields: {
           status: true,
-          progress_percent: true,
-          phase_info: true,
           payload_version: true,
           path: true,
         },
@@ -9610,16 +8975,7 @@ describe('Protocol V2 firmware update method', () => {
     });
 
     await expect(method.run()).resolves.toEqual({
-      records: [
-        {
-          target_id: 4,
-          status: 1,
-          progress_percent: 42,
-          phase_info: { phase: 1, progress_percent: 60 },
-          payload_version: 1,
-          path: 'vol1:application_p1.bin',
-        },
-      ],
+      records: [{ target_id: 4, status: 2, payload_version: 1, path: 'vol1:application_p1.bin' }],
     });
     expect(typedCall).toHaveBeenCalledWith(
       'DeviceFirmwareUpdateStatusGet',
@@ -9627,8 +8983,6 @@ describe('Protocol V2 firmware update method', () => {
       {
         fields: {
           status: true,
-          progress_percent: true,
-          phase_info: true,
           payload_version: true,
           path: true,
         },