@onekeyfe/hd-core 1.2.0-alpha.101 → 1.2.0-alpha.102

package/__tests__/bridgeBinaryPayload.test.ts

@@ -0,0 +1,173 @@
+import { HardwareTopLevelSdk } from '../src';
+import { findMethod } from '../src/api/utils';
+import {
+  decodeBridgeBinaryPayload,
+  encodeBridgeBinaryPayload,
+} from '../src/utils/bridgeBinaryPayload';
+
+import type { LowLevelCoreApi } from '../src';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+const crossJsonOnlyBridge = (value: unknown): unknown => JSON.parse(JSON.stringify(value));
+
+describe('bridge binary payload', () => {
+  test('preserves nested ArrayBuffer and sliced Uint8Array values', async () => {
+    const arrayBuffer = new Uint8Array([1, 2, 3]).buffer;
+    const backing = new Uint8Array([90, 4, 5, 6, 91]);
+    const encoded = await encodeBridgeBinaryPayload({
+      arrayBuffer,
+      bytes: backing.subarray(1, 4),
+    });
+    const decoded = decodeBridgeBinaryPayload(crossJsonOnlyBridge(encoded)) as {
+      arrayBuffer: ArrayBuffer;
+      bytes: Uint8Array;
+    };
+
+    expect(decoded.arrayBuffer).toBeInstanceOf(ArrayBuffer);
+    expect(Array.from(new Uint8Array(decoded.arrayBuffer))).toEqual([1, 2, 3]);
+    expect(decoded.bytes).toBeInstanceOf(Uint8Array);
+    expect(Array.from(decoded.bytes)).toEqual([4, 5, 6]);
+  });
+
+  test('encodes Blob input as byte data', async () => {
+    const encoded = await encodeBridgeBinaryPayload(new Blob([new Uint8Array([7, 8])]));
+    const decoded = decodeBridgeBinaryPayload(crossJsonOnlyBridge(encoded));
+
+    expect(decoded).toBeInstanceOf(Uint8Array);
+    expect(Array.from(decoded as Uint8Array)).toEqual([7, 8]);
+  });
+
+  test('routes portfolio, wallpaper and NFT bytes through the top-level boundary', async () => {
+    const restoredPayloads: Array<Record<string, any>> = [];
+    const lowLevelApi = {
+      call: jest.fn(params => {
+        const wirePayload = crossJsonOnlyBridge(params);
+        const method = findMethod({ id: 1, payload: wirePayload } as any);
+        restoredPayloads.push(method.payload);
+        return Promise.resolve({ success: true, payload: {} });
+      }),
+      init: jest.fn(() => Promise.resolve(true)),
+    } as unknown as LowLevelCoreApi;
+    const sdk = HardwareTopLevelSdk();
+    await sdk.init({}, lowLevelApi);
+
+    const portfolioBytes = new Uint8Array([1, 2, 3]).buffer;
+    const wallpaperBacking = new Uint8Array([90, 4, 5, 6, 91]);
+    const nftBacking = new Uint8Array([80, 7, 8, 9, 10, 81]);
+    await sdk.uploadPortfolio('connect-id', { packageBytes: portfolioBytes });
+    await sdk.deviceUploadWallpaper('connect-id', {
+      width: 604,
+      height: 1024,
+      rgba: wallpaperBacking.subarray(1, 4),
+    });
+    await sdk.deviceUploadNft('connect-id', {
+      image: { width: 540, height: 540, rgba: nftBacking.subarray(1, 3) },
+      thumbnail: { width: 263, height: 263, rgba: nftBacking.subarray(3, 5) },
+      title: 'NFT',
+      subtitle: '',
+    });
+
+    expect(Array.from(new Uint8Array(restoredPayloads[0].packageBytes))).toEqual([1, 2, 3]);
+    expect(Array.from(restoredPayloads[1].rgba)).toEqual([4, 5, 6]);
+    expect(Array.from(restoredPayloads[2].image.rgba)).toEqual([7, 8]);
+    expect(Array.from(restoredPayloads[2].thumbnail.rgba)).toEqual([9, 10]);
+  });
+
+  test('routes firmware update binaries through the top-level boundary', async () => {
+    const restoredPayloads: Array<Record<string, any>> = [];
+    const lowLevelApi = {
+      call: jest.fn(params => {
+        const wirePayload = crossJsonOnlyBridge(params);
+        const method = findMethod({ id: 1, payload: wirePayload } as any);
+        restoredPayloads.push(method.payload);
+        return Promise.resolve({ success: true, payload: {} });
+      }),
+      init: jest.fn(() => Promise.resolve(true)),
+    } as unknown as LowLevelCoreApi;
+    const sdk = HardwareTopLevelSdk();
+    await sdk.init({}, lowLevelApi);
+    const binary = (...bytes: number[]) => Uint8Array.from(bytes).buffer;
+
+    await sdk.firmwareUpdate('connect-id', {
+      binary: binary(1),
+      updateType: 'firmware',
+    });
+    await sdk.firmwareUpdateV2('connect-id', {
+      binary: binary(2),
+      updateType: 'firmware',
+      platform: 'ext',
+    });
+    await sdk.firmwareUpdateV3('connect-id', {
+      platform: 'ext',
+      bleBinary: binary(3),
+      firmwareBinary: binary(4),
+      bootloaderBinary: binary(5),
+      resourceBinary: binary(6),
+    });
+    await sdk.firmwareUpdateV4('connect-id', {
+      platform: 'ext',
+      targetsToUpdate: [
+        'boot',
+        'app_v1',
+        'app_v2',
+        'coprocessor',
+        'se01',
+        'se02',
+        'se03',
+        'se04',
+        'resource',
+      ],
+      romloaderBinary: binary(7),
+      bootloaderBinary: binary(8),
+      applicationP1Binary: binary(9),
+      applicationP2Binary: binary(10),
+      coprocessorBinary: binary(11),
+      se01Binary: binary(12),
+      se02Binary: binary(13),
+      se03Binary: binary(14),
+      se04Binary: binary(15),
+      resourceArchiveBinary: binary(16),
+    });
+    await sdk.deviceUpdateBootloader('connect-id', { binary: binary(17) });
+    await sdk.deviceFullyUploadResource('connect-id', { binary: binary(18) });
+
+    expect(restoredPayloads).toHaveLength(6);
+    const restoredBinaries = [
+      restoredPayloads[0].binary,
+      restoredPayloads[1].binary,
+      restoredPayloads[2].bleBinary,
+      restoredPayloads[2].firmwareBinary,
+      restoredPayloads[2].bootloaderBinary,
+      restoredPayloads[2].resourceBinary,
+      restoredPayloads[3].romloaderBinary,
+      restoredPayloads[3].bootloaderBinary,
+      restoredPayloads[3].applicationP1Binary,
+      restoredPayloads[3].applicationP2Binary,
+      restoredPayloads[3].coprocessorBinary,
+      restoredPayloads[3].se01Binary,
+      restoredPayloads[3].se02Binary,
+      restoredPayloads[3].se03Binary,
+      restoredPayloads[3].se04Binary,
+      restoredPayloads[3].resourceArchiveBinary,
+      restoredPayloads[4].binary,
+      restoredPayloads[5].binary,
+    ];
+    expect(restoredBinaries.map(value => Array.from(new Uint8Array(value)))).toEqual(
+      Array.from({ length: 18 }, (_, index) => [index + 1])
+    );
+  });
+
+  test('rejects malformed tagged binary data', () => {
+    expect(() =>
+      decodeBridgeBinaryPayload({
+        __onekey_hd_bridge_binary_payload__: 1,
+        data: 'not-base64',
+        type: 'uint8-array',
+      })
+    ).toThrow('Invalid bridge binary payload data');
+  });
+});

package/__tests__/check-all-firmware-release-protocol-v2.test.ts

@@ -346,6 +346,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     expect(typedCall).not.toHaveBeenCalled();
     expect(getDeviceState).toHaveBeenCalledWith({
       refreshSections: ['identity', 'versions'],
+      allowLegacyProtocolV2ProtocolInfo: true,
     });
     expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
   });
@@ -725,6 +726,7 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     });
     expect(getDeviceState).toHaveBeenCalledWith({
       refreshSections: ['identity', 'versions', 'verification'],
+      allowLegacyProtocolV2ProtocolInfo: true,
     });
   });
 

package/__tests__/device-pool-state.test.ts

@@ -38,6 +38,35 @@ describe('DevicePool state lifecycle', () => {
     expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['settings'] });
   });
 
+  test('keeps legacy ProtocolInfo compatibility scoped to a discovery refresh', async () => {
+    const getDeviceState = jest.fn().mockResolvedValue({ status: { mode: 'bootloader' } });
+    const run = jest.fn(async (callback: () => Promise<void>) => callback());
+    const device = {
+      isProtocolV2: () => true,
+      getDeviceState,
+      run,
+    } as any;
+
+    await (DevicePool as any)._refreshRuntimeState(device, {
+      refreshRuntimeState: true,
+      allowLegacyProtocolV2ProtocolInfo: true,
+    });
+
+    expect(run).toHaveBeenCalledWith(expect.any(Function), {
+      connectProtocol: undefined,
+      forceProtocolDetection: undefined,
+      allowLegacyProtocolV2ProtocolInfo: true,
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(1, {
+      refreshSections: ['status'],
+      allowLegacyProtocolV2ProtocolInfo: true,
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
+      refreshSections: ['settings'],
+      allowLegacyProtocolV2ProtocolInfo: true,
+    });
+  });
+
   test('actively re-detects a cached device when protocol detection is forced', async () => {
     const descriptor = { path: 'cached-path', protocolType: 'V1' } as any;
     const device = Device.fromDescriptor(descriptor);

package/__tests__/get-device-state.test.ts

@@ -202,25 +202,111 @@ describe('getDeviceState', () => {
     expect(state.versions.se01).toBe('1.0.0');
   });
 
-  test.each(['bootloader', 'romloader'] as const)(
-    'uses ProtocolInfo to preserve %s mode without DeviceStatusGet',
-    async mode => {
+  test.each([
+    ['bootloader', EDeviceType.Pro2, DeviceType.PRO2],
+    ['romloader', EDeviceType.Pro2, DeviceType.PRO2],
+    ['bootloader', EDeviceType.Neo, DeviceType.NEO],
+    ['romloader', EDeviceType.Neo, DeviceType.NEO],
+  ] as const)(
+    'refreshes cached %s state after %s reboots into the application',
+    async (mode, deviceType, protocolV2DeviceType) => {
       const typedCall = jest.fn().mockImplementation((requestType: string) => {
-        if (requestType === 'DeviceInfoGet') {
+        if (requestType === 'ProtocolInfoRequest') {
+          return { message: protocolV2ApplicationInfo };
+        }
+        if (requestType === 'DeviceStatusGet') {
           return {
-            message: {
-              hw: { Device_type: DeviceType.PRO2, serial_no: 'SERIAL-1' },
+            message: { init_states: true, unlocked: true, device_id: 'wallet-1' },
+          };
+        }
+        throw new Error(`Unexpected request: ${requestType}`);
+      });
+      const device = createV2Device(typedCall);
+      device.updateState(
+        {
+          protocol: 'V2',
+          identity: { deviceType },
+          status: { mode },
+          raw: {
+            protocolV2DeviceInfo: {
+              hw: { Device_type: protocolV2DeviceType, serial_no: 'SERIAL-1' },
               fw:
                 mode === 'romloader'
                   ? { romloader: { version: '1.0.0' } }
                   : { bootloader: { version: '1.0.0' } },
             },
-          };
-        }
-        if (requestType === 'ProtocolInfoRequest') {
-          return { message: getProtocolV2LoaderInfo(mode) };
-        }
-        throw new Error(`Unexpected request: ${requestType}`);
+            protocolV2ProtocolInfo: getProtocolV2LoaderInfo(mode),
+          },
+        },
+        'initialize'
+      );
+
+      const state = await device.getDeviceState({ refreshSections: ['status'] });
+
+      expect(state.status.mode).toBe('normal');
+      expect(state.identity.deviceId).toBe('wallet-1');
+      expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+        'ProtocolInfoRequest',
+        'DeviceStatusGet',
+      ]);
+    }
+  );
+
+  test.each([
+    [EDeviceType.Pro2, DeviceType.PRO2],
+    [EDeviceType.Neo, DeviceType.NEO],
+  ] as const)('invalidates cached loader state when %s is cancelled', async (deviceType, type) => {
+    const typedCall = jest.fn().mockImplementation((requestType: string) => {
+      if (requestType === 'DeviceInfoGet') {
+        return {
+          message: {
+            protocol_version: 2,
+            hw: { Device_type: type, serial_no: 'SERIAL-1' },
+            fw: { application: { version: '5.0.0' } },
+          },
+        };
+      }
+      if (requestType === 'ProtocolInfoRequest') {
+        return { message: protocolV2ApplicationInfo };
+      }
+      if (requestType === 'DeviceStatusGet') {
+        return {
+          message: { init_states: true, unlocked: true, device_id: 'wallet-1' },
+        };
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const cancel = jest.fn().mockResolvedValue(undefined);
+    const device = createV2Device(typedCall);
+    (device as any).commands = { cancel, typedCall };
+    device.updateState(
+      {
+        protocol: 'V2',
+        identity: { deviceType },
+        status: { mode: 'bootloader' },
+        raw: { protocolV2ProtocolInfo: getProtocolV2LoaderInfo('bootloader') },
+      },
+      'initialize'
+    );
+
+    await device.interruptionFromUser();
+    await device.initialize();
+
+    expect(cancel).toHaveBeenCalledTimes(1);
+    expect(device.state?.status.mode).toBe('normal');
+    expect(device.state?.identity.deviceId).toBe('wallet-1');
+    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
+      'DeviceInfoGet',
+      'ProtocolInfoRequest',
+      'DeviceStatusGet',
+    ]);
+  });
+
+  test.each(['bootloader', 'romloader'] as const)(
+    'keeps live %s mode after refreshing cached loader state',
+    async mode => {
+      const typedCall = jest.fn().mockResolvedValue({
+        message: getProtocolV2LoaderInfo(mode),
       });
       const device = createV2Device(typedCall);
       device.updateState(
@@ -236,7 +322,10 @@ describe('getDeviceState', () => {
       const state = await device.getDeviceState({ refreshSections: ['status'] });
 
       expect(state.status.mode).toBe(mode);
-      expect(typedCall).not.toHaveBeenCalled();
+      expect(typedCall).toHaveBeenCalledTimes(1);
+      expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
+        eventless_wallet_session: true,
+      });
     }
   );
 

package/__tests__/protocol-v2-legacy-recovery.test.ts

@@ -0,0 +1,29 @@
+import { isLegacyProtocolV2FirmwareRecoveryMethod } from '../src/core/protocolV2LegacyRecovery';
+
+import type { BaseMethod } from '../src/api/BaseMethod';
+
+const createMethod = (
+  name: string,
+  payload: Record<string, unknown>
+): Pick<BaseMethod, 'name' | 'payload'> => ({
+  name,
+  payload: { method: name, ...payload },
+});
+
+describe('Protocol V2 legacy firmware recovery policy', () => {
+  test.each([
+    ['firmware state read', 'getDeviceState', { scope: 'firmware' }],
+    ['firmware release check', 'checkAllFirmwareRelease', {}],
+    ['firmware update', 'firmwareUpdateV4', {}],
+  ])('allows legacy ProtocolInfo for %s', (_label, name, payload) => {
+    expect(isLegacyProtocolV2FirmwareRecoveryMethod(createMethod(name, payload))).toBe(true);
+  });
+
+  test.each([
+    ['runtime state read', 'getDeviceState', { scope: 'runtime' }],
+    ['settings state read', 'getDeviceState', { scope: 'settings' }],
+    ['ordinary API', 'getFeatures', {}],
+  ])('rejects legacy ProtocolInfo for %s', (_label, name, payload) => {
+    expect(isLegacyProtocolV2FirmwareRecoveryMethod(createMethod(name, payload))).toBe(false);
+  });
+});

package/__tests__/protocol-v2.test.ts

@@ -3194,6 +3194,125 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).toHaveBeenCalledTimes(1);
   });
 
+  test('rejects a cached legacy ProtocolInfo outside discovery and firmware recovery', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'ProtocolInfo',
+      message: {
+        version: 1,
+        build_fingerprint: '',
+        supported_messages: [],
+        protobuf_definition: null,
+      },
+    });
+    (device as any).commands = { typedCall };
+
+    await expect(
+      device.probeProtocolV2RuntimeState({
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
+        fw: { application: { version: '1.2.3' } },
+      })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceInitializeFailed });
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test('uses DeviceStatusGet to identify App mode for an allowed legacy ProtocolInfo', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: {
+          version: 1,
+          build_fingerprint: '',
+          supported_messages: [],
+          protobuf_definition: null,
+        },
+      })
+      .mockResolvedValueOnce({
+        type: 'DeviceStatus',
+        message: { init_states: true, unlocked: true },
+      });
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState(
+      {
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'PR2SERIAL' },
+        fw: { application: { version: '1.2.3' } },
+      },
+      5000,
+      { allowLegacyProtocolV2ProtocolInfo: true }
+    );
+
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'ProtocolInfoRequest',
+      'ProtocolInfo',
+      { eventless_wallet_session: true },
+      { timeoutMs: 5000 }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'DeviceStatusGet',
+      'DeviceStatus',
+      {},
+      { timeoutMs: 5000 }
+    );
+    expect(device.features).toMatchObject({
+      mode: 'normal',
+      bootloaderMode: false,
+      initialized: true,
+      unlocked: true,
+    });
+  });
+
+  test('maps an allowed legacy loader to bootloader only after an explicit unsupported status', async () => {
+    const device = Device.fromDescriptor({
+      path: 'usb-path',
+      protocolType: 'V2',
+    } as any);
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'ProtocolInfo',
+        message: {
+          version: 1,
+          build_fingerprint: '',
+          supported_messages: [],
+          protobuf_definition: null,
+        },
+      })
+      .mockRejectedValueOnce(new Error('Failure_UnexpectedMessage,Unknown message'));
+    (device as any).commands = { typedCall };
+
+    await device.probeProtocolV2RuntimeState(
+      {
+        hw: { Device_type: DeviceType.NEO, serial_no: 'NEOSERIAL' },
+        fw: { bootloader: { version: '0.2.0' } },
+      },
+      undefined,
+      { allowLegacyProtocolV2ProtocolInfo: true }
+    );
+
+    expect(typedCall).toHaveBeenNthCalledWith(1, 'ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceStatusGet', 'DeviceStatus', {});
+    expect(device.features).toMatchObject({
+      deviceType: 'neo',
+      mode: 'bootloader',
+      bootloaderMode: true,
+      initialized: null,
+    });
+  });
+
   test('does not reinterpret a state update error as runtime detection failure', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
@@ -4249,6 +4368,43 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postTipMessage).toHaveBeenCalledWith('GoToBootloaderSuccess');
   });
 
+  test('keeps an ambiguous legacy runtime on the direct loader update path', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    (method as any).device = stubDevice({
+      originalDescriptor: { id: 'usb-id', path: 'legacy-path', protocolType: 'V2' },
+      state: {
+        raw: {
+          protocolV2ProtocolInfo: {
+            version: 1,
+            build_fingerprint: '',
+            supported_messages: [],
+            protobuf_definition: null,
+          },
+        },
+      },
+      features: {
+        deviceType: 'pro2',
+        mode: 'bootloader',
+        bootloaderMode: true,
+        capabilities: [],
+      },
+      isBootloader: () => true,
+      isRomloader: () => false,
+    });
+    (method as any).protocolV2Reboot = jest.fn();
+    method.postTipMessage = jest.fn();
+
+    await expect((method as any).enterProtocolV2BootloaderMode()).resolves.toBe(false);
+
+    expect((method as any).protocolV2LegacyDirectUpdate).toBe(true);
+    expect((method as any).protocolV2Reboot).not.toHaveBeenCalled();
+  });
+
   test('keeps Protocol V2 romloader active before firmware transfer', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -4881,6 +5037,81 @@ describe('Protocol V2 firmware update targets', () => {
     expect(method.postProgressMessage).not.toHaveBeenCalled();
   });
 
+  test('reboots a legacy App only after the direct update endpoint is explicitly unavailable', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
+    const typedCall = jest
+      .fn()
+      .mockRejectedValueOnce(new Error('Failure_InvalidMessage,Handler not registered'))
+      .mockResolvedValueOnce({ type: 'Success', message: { message: '' } });
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).protocolV2LegacyDirectUpdate = true;
+    (method as any).rebootProtocolV2ToBootloader = jest.fn().mockResolvedValue(true);
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    await expect((method as any).protocolV2StartFirmwareUpdate({ targets })).resolves.toEqual({
+      type: 'Success',
+      message: { message: '' },
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'DeviceFirmwareUpdateRequest',
+      'Success',
+      { targets },
+      { timeoutMs: 180000 }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'DeviceFirmwareUpdateRequest',
+      'Success',
+      { targets },
+      { timeoutMs: 180000 }
+    );
+    expect((method as any).rebootProtocolV2ToBootloader).toHaveBeenCalledTimes(1);
+    expect(method.postTipMessage).toHaveBeenCalledWith('FirmwareUpdating');
+    expect(method.postProgressMessage).toHaveBeenCalledWith(0, 'installingFirmware');
+  });
+
+  test('does not replay a legacy direct update after a link failure', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    const typedCall = jest.fn().mockRejectedValue(new Error('LIBUSB_TRANSFER_TIMED_OUT'));
+
+    (method as any).device = stubDevice({
+      getCommands: () => ({ typedCall }),
+    });
+    (method as any).protocolV2LegacyDirectUpdate = true;
+    (method as any).rebootProtocolV2ToBootloader = jest.fn();
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    await expect(
+      (method as any).protocolV2StartFirmwareUpdate({
+        targets: [{ target_id: 4, path: 'vol0:/application_p1.bin' }],
+      })
+    ).rejects.toThrow('LIBUSB_TRANSFER_TIMED_OUT');
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect((method as any).rebootProtocolV2ToBootloader).not.toHaveBeenCalled();
+    expect(method.postTipMessage).not.toHaveBeenCalled();
+    expect(method.postProgressMessage).not.toHaveBeenCalled();
+  });
+
   test('polls only firmware status while Protocol V2 bootloader is installing', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,
@@ -5009,7 +5240,9 @@ describe('Protocol V2 firmware update targets', () => {
     (method as any).device = stubDevice({ probeProtocolV2RuntimeState });
 
     await expect((method as any).probeProtocolV2NormalMode(deviceInfo)).resolves.toBe(expected);
-    expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000);
+    expect(probeProtocolV2RuntimeState).toHaveBeenCalledWith(deviceInfo, 5000, {
+      allowLegacyProtocolV2ProtocolInfo: true,
+    });
   });
 
   test('keeps polling when the firmware status handler is missing in loader mode', async () => {

package/__tests__/refresh-device-state.test.ts

@@ -48,7 +48,10 @@ describe('live device state reads', () => {
 
     await method.run();
 
-    expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: [...refreshSections] });
+    expect(getDeviceState).toHaveBeenCalledWith({
+      refreshSections: [...refreshSections],
+      ...(scope === 'firmware' ? { allowLegacyProtocolV2ProtocolInfo: true } : {}),
+    });
   });
 
   test.each(['bootloader', 'romloader'] as const)(

package/__tests__/search-devices.test.ts

@@ -94,6 +94,7 @@ describe('SearchDevices', () => {
         connectProtocol: undefined,
         forceProtocolDetection: true,
         refreshRuntimeState: true,
+        allowLegacyProtocolV2ProtocolInfo: true,
       }
     );
     expect(mockGetDevices).toHaveBeenNthCalledWith(
@@ -104,6 +105,7 @@ describe('SearchDevices', () => {
         connectProtocol: undefined,
         forceProtocolDetection: true,
         refreshRuntimeState: true,
+        allowLegacyProtocolV2ProtocolInfo: true,
       }
     );
   });