@onekeyfe/hd-core 1.2.0-alpha.99 → 1.2.1-alpha.0

package/__tests__/device-wallet-session-store.test.ts

@@ -352,7 +352,75 @@ describe('Protocol V1 wallet identity initialization', () => {
     jest.restoreAllMocks();
   });
 
-  test('verifies the live device id without resetting the cached wallet session', async () => {
+  test('sends no wallet context before identity is proven on first contact', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    // No cached features: there is no local evidence which device sits here.
+    deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'intruder-device', session_id: 'intruder-session' },
+    });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await expect(
+      device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+
+    // Exactly one context-free Initialize: neither the cached session_id nor
+    // the passphrase_state may reach an unproven device.
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      { is_contains_attach: true },
+      expect.any(Object)
+    );
+    // The expected device's cached session is untouched.
+    expect(deviceWalletSessionStore.get('device-a', 'hidden-a')).toBe('session-a');
+  });
+
+  test('proves identity first, then resumes the wallet session on first contact', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({
+        type: 'Features',
+        message: { device_id: 'device-a', session_id: 'standard-session' },
+      })
+      .mockResolvedValueOnce({
+        type: 'Features',
+        message: { device_id: 'device-a', session_id: 'session-a' },
+      });
+    device.commands = { typedCall } as never;
+    jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'Initialize',
+      'Features',
+      { is_contains_attach: true },
+      expect.any(Object)
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(
+      2,
+      'Initialize',
+      'Features',
+      expect.objectContaining({
+        session_id: 'session-a',
+        passphrase_state: 'hidden-a',
+      }),
+      expect.any(Object)
+    );
+    // The context-free identity call must not overwrite the cached session.
+    expect(deviceWalletSessionStore.get('device-a', 'hidden-a')).toBe('session-a');
+  });
+
+  test('purges cached sessions and rejects when the live device identity changes', async () => {
     const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
     device.features = {
       protocol: 'V1',
@@ -363,7 +431,7 @@ describe('Protocol V1 wallet identity initialization', () => {
     deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
     const typedCall = jest.fn().mockResolvedValue({
       type: 'Features',
-      message: { device_id: 'live-device-b' },
+      message: { device_id: 'live-device-b', session_id: 'wrong-device-session' },
     });
     device.commands = { typedCall } as never;
     jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
@@ -371,11 +439,76 @@ describe('Protocol V1 wallet identity initialization', () => {
     await expect(
       device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
     ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+    // Identity is validated from the single Initialize round trip; no separate
+    // GetFeatures preflight.
     expect(typedCall).toHaveBeenCalledTimes(1);
-    expect(typedCall).toHaveBeenCalledWith('GetFeatures', 'Features', {});
+    expect(typedCall).toHaveBeenCalledWith(
+      'Initialize',
+      'Features',
+      expect.objectContaining({ passphrase_state: 'hidden-a' }),
+      expect.any(Object)
+    );
+    // Identity change purges the previous device's cached sessions (pre-existing
+    // reconcileDeviceIdentity behavior — never carry sessions across devices)…
+    expect(deviceWalletSessionStore.get('cached-device-a', 'hidden-a')).toBeUndefined();
+    // …and the session the mismatched Initialize cached under the wrong
+    // device's identity is dropped as well.
+    expect(deviceWalletSessionStore.get('live-device-b', 'hidden-a')).toBeUndefined();
   });
 
-  test('resumes a cached V1 wallet after a non-destructive live identity read', async () => {
+  test('drops the wrong-device session even when reconfigure fails after Initialize', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-b', path: 'connect-b' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'cached-device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    deviceWalletSessionStore.set('cached-device-a', 'hidden-a', 'session-a');
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'live-device-b', session_id: 'wrong-device-session' },
+    });
+    device.commands = { typedCall } as never;
+    // Pre-encode resync succeeds; the post-response reconfigure inside
+    // callInitialize rejects — the session write has already happened by then.
+    jest
+      .spyOn(TransportManager, 'reconfigure')
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(new Error('configure failed'));
+
+    await expect(
+      device.initialize({ deviceId: 'cached-device-a', passphraseState: 'hidden-a' })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.DeviceCheckDeviceIdError });
+    // The wrong-device session must not survive the error path either.
+    expect(deviceWalletSessionStore.get('live-device-b', 'hidden-a')).toBeUndefined();
+  });
+
+  test('re-syncs the V1 message schema for this device before encoding Initialize', async () => {
+    const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
+    device.features = {
+      protocol: 'V1',
+      deviceId: 'device-a',
+      unlocked: true,
+      passphraseProtection: true,
+    } as never;
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'Features',
+      message: { device_id: 'device-a' },
+    });
+    device.commands = { typedCall } as never;
+    const reconfigure = jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
+
+    await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
+
+    // A stale process-global schema (from another device) would silently strip
+    // passphrase_state from the wire message, so the resync must come first.
+    expect(reconfigure.mock.invocationCallOrder[0]).toBeLessThan(
+      typedCall.mock.invocationCallOrder[0]
+    );
+  });
+
+  test('resumes a cached V1 wallet with a single identity-validated Initialize', async () => {
     const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
     device.features = {
       protocol: 'V1',
@@ -384,22 +517,17 @@ describe('Protocol V1 wallet identity initialization', () => {
       passphraseProtection: true,
     } as never;
     deviceWalletSessionStore.set('device-a', 'hidden-a', 'session-a');
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
-      .mockResolvedValueOnce({
-        type: 'Features',
-        message: { device_id: 'device-a', session_id: 'session-a' },
-      });
+    const typedCall = jest.fn().mockResolvedValueOnce({
+      type: 'Features',
+      message: { device_id: 'device-a', session_id: 'session-a' },
+    });
     device.commands = { typedCall } as never;
     jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
 
     await device.initialize({ deviceId: 'device-a', passphraseState: 'hidden-a' });
 
-    expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
-    expect(typedCall).toHaveBeenNthCalledWith(
-      2,
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
       'Initialize',
       'Features',
       expect.objectContaining({
@@ -408,9 +536,10 @@ describe('Protocol V1 wallet identity initialization', () => {
       }),
       expect.any(Object)
     );
+    expect(deviceWalletSessionStore.get('device-a', 'hidden-a')).toBe('session-a');
   });
 
-  test('selects the standard V1 wallet after a non-destructive live identity read', async () => {
+  test('selects the standard V1 wallet with a single identity-validated Initialize', async () => {
     const device = Device.fromDescriptor({ id: 'connect-a', path: 'connect-a' } as never);
     device.features = {
       protocol: 'V1',
@@ -420,17 +549,14 @@ describe('Protocol V1 wallet identity initialization', () => {
     } as never;
     const typedCall = jest
       .fn()
-      .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } })
       .mockResolvedValueOnce({ type: 'Features', message: { device_id: 'device-a' } });
     device.commands = { typedCall } as never;
     jest.spyOn(TransportManager, 'reconfigure').mockResolvedValue(undefined);
 
     await device.initialize({ deviceId: 'device-a' });
 
-    expect(typedCall).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenNthCalledWith(1, 'GetFeatures', 'Features', {});
-    expect(typedCall).toHaveBeenNthCalledWith(
-      2,
+    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledWith(
       'Initialize',
       'Features',
       {

package/__tests__/deviceSettings.test.ts

@@ -1,6 +1,7 @@
 import { EDeviceType } from '@onekeyfe/hd-shared';
 
 import {
+  DEVICE_SETTINGS_NEVER_TIMEOUT_MS,
   PROTOCOL_V2_NEVER_TIMEOUT_MS,
   getAutoLockOptions,
   getAutoShutDownOptions,
@@ -67,7 +68,6 @@ describe('Pro 2 device settings options', () => {
       { label: '2 minutes', valueMs: 120_000 },
       { label: '5 minutes', valueMs: 300_000 },
       { label: '10 minutes', valueMs: 600_000 },
-      { label: '30 minutes', valueMs: 1_800_000 },
       { label: 'Never', valueMs: PROTOCOL_V2_NEVER_TIMEOUT_MS },
     ]);
   });
@@ -82,10 +82,14 @@ describe('Pro 2 device settings options', () => {
     );
   });
 
-  test('keeps the legacy and Protocol V2 never values protocol-specific', () => {
+  test('returns the firmware-supported never value for both protocols', () => {
     expect(getAutoLockOptions(EDeviceType.Pro, 'V1').slice(-1)[0]).toEqual({
       label: 'Never',
-      valueMs: 0,
+      valueMs: DEVICE_SETTINGS_NEVER_TIMEOUT_MS,
+    });
+    expect(getAutoShutDownOptions(EDeviceType.Pro, 'V1').slice(-1)[0]).toEqual({
+      label: 'Never',
+      valueMs: DEVICE_SETTINGS_NEVER_TIMEOUT_MS,
     });
     expect(getAutoLockOptions(EDeviceType.Pro2, 'V2').slice(-1)[0]).toEqual({
       label: 'Never',

package/__tests__/deviceUploadNft.test.ts

@@ -1,4 +1,6 @@
 import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
+import { encode as encodeJpeg } from 'jpeg-js';
 
 import DeviceUploadNft from '../src/api/protocol-v2/DeviceUploadNft';
 
@@ -13,6 +15,19 @@ const createRgba = (width: number, height: number) => {
   return data;
 };
 
+const jpegBase64Cache = new Map<string, string>();
+
+const createJpegBase64 = (width: number, height: number) => {
+  const key = `${width}x${height}`;
+  const cached = jpegBase64Cache.get(key);
+  if (cached) return cached;
+  const value = encodeJpeg({ width, height, data: createRgba(width, height) }, 80).data.toString(
+    'base64'
+  );
+  jpegBase64Cache.set(key, value);
+  return value;
+};
+
 const createMethod = ({
   typedCall,
   supportedMessages = [60802, 60805, 60808, 61500],
@@ -26,8 +41,8 @@ const createMethod = ({
     id: 1,
     payload: {
       method: 'deviceUploadNft',
-      image: { width: 540, height: 540, rgba: createRgba(540, 540) },
-      thumbnail: { width: 263, height: 263, rgba: createRgba(263, 263) },
+      imageJpegBase64: createJpegBase64(540, 540),
+      thumbnailJpegBase64: createJpegBase64(263, 263),
       title: 'CryptoPunk #3100',
       subtitle: 'CryptoPunks',
       timestampMs: 1_760_000_000_000,
@@ -86,8 +101,8 @@ describe('DeviceUploadNft', () => {
       id: 1,
       payload: {
         method: 'deviceUploadNft',
-        image: { width: 540, height: 540, rgba: createRgba(540, 540) },
-        thumbnail: { width: 263, height: 263, rgba: createRgba(263, 263) },
+        imageJpegBase64: createJpegBase64(540, 540),
+        thumbnailJpegBase64: createJpegBase64(263, 263),
         title: 'CryptoPunk #3100',
         subtitle: 'CryptoPunks',
         timestampMs: 1_760_000_000_000,
@@ -96,12 +111,29 @@ describe('DeviceUploadNft', () => {
 
     method.init();
 
+    expect(method.unlockPolicy).toBe('unlock-before-run');
+    expect(method.protocolV2PreUnlockPinType).toBe(DeviceSessionPinType.Any);
     expect((method as any).params).toMatchObject({
       chunkSize: 2048,
       paceMs: 0,
     });
   });
 
+  test('rejects invalid image Base64 before device communication', () => {
+    const method = new DeviceUploadNft({
+      id: 1,
+      payload: {
+        method: 'deviceUploadNft',
+        imageJpegBase64: 'not-base64',
+        thumbnailJpegBase64: createJpegBase64(263, 263),
+        title: 'NFT',
+        subtitle: '',
+      },
+    });
+
+    expect(() => method.init()).toThrow('canonical Base64');
+  });
+
   test('uploads the triplet in order without creating the firmware-owned directory', async () => {
     const typedCall = jest.fn((request: string, _response: string, params: any) => {
       if (request === 'FilesystemPathInfoQuery') {

package/__tests__/firmware-update/device-update-bootloader.test.ts

@@ -1,4 +1,6 @@
 import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
 
 import DeviceUpdateBootloader from '../../src/api/device/DeviceUpdateBootloader';
 import {
@@ -27,10 +29,11 @@ jest.mock('../../src/device/DevicePool', () => ({
   DevicePool: {},
 }));
 
+const artifactBytes = Uint8Array.from([1, 2, 3, 4]);
 const artifact = {
   artifactRef: `fw:${'a'.repeat(64)}`,
-  size: 4,
-  sha256: 'a'.repeat(64),
+  size: artifactBytes.byteLength,
+  sha256: bytesToHex(sha256(artifactBytes)),
 };
 
 const createMethod = () => {
@@ -38,7 +41,14 @@ const createMethod = () => {
   const close = jest.fn().mockRejectedValue(closeError);
   const artifactReader = {
     open: jest.fn().mockResolvedValue({ readerId: 'reader-1', size: artifact.size }),
-    read: jest.fn(),
+    read: jest.fn(({ offset, length }: { offset: number; length: number }) => {
+      const data = artifactBytes.slice(offset, offset + length).buffer;
+      return Promise.resolve({
+        data,
+        bytesRead: data.byteLength,
+        eof: offset + length === artifactBytes.byteLength,
+      });
+    }),
     close,
   };
   const hostBindingGeneration = registerFirmwareUpdateHostBinding({

package/__tests__/firmware-update/firmware-artifact-source.test.ts

@@ -1,3 +1,6 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
+
 import {
   MAX_FIRMWARE_ARTIFACT_READ_BYTES,
   openFirmwareByteSource,
@@ -6,19 +9,20 @@ import {
 
 import type { FirmwareArtifactReader } from '../../src/types/api/firmwareUpdate';
 
+const artifactBytes = Uint8Array.from([1, 2, 3, 4, 5, 6]);
 const artifact = {
   artifactRef: `fw:${'a'.repeat(64)}`,
-  size: 6,
-  sha256: 'b'.repeat(64),
+  size: artifactBytes.byteLength,
+  sha256: bytesToHex(sha256(artifactBytes)),
 };
 
-const createReader = () => {
-  const open = jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: artifact.size }));
+const createReader = (bytes = artifactBytes) => {
+  const open = jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: bytes.byteLength }));
   const read = jest.fn(({ offset, length }: { readerId: string; offset: number; length: number }) =>
     Promise.resolve({
-      data: Uint8Array.from([1, 2, 3, 4, 5, 6]).slice(offset, offset + length).buffer,
+      data: bytes.slice(offset, offset + length).buffer,
       bytesRead: length,
-      eof: offset + length === artifact.size,
+      eof: offset + length === bytes.byteLength,
     })
   );
   const close = jest.fn(() => Promise.resolve());
@@ -27,12 +31,18 @@ const createReader = () => {
 };
 
 describe('FirmwareArtifactSource', () => {
-  it('reads an opaque artifact through bounded sequential reads', async () => {
-    const { reader, close } = createReader();
+  it('materializes verified bytes before exposing the source', async () => {
+    const backingBytes = Uint8Array.from(artifactBytes);
+    const { reader, read, close } = createReader(backingBytes);
     const source = await openFirmwareByteSource({ artifact, reader });
     if (!source) {
       throw new Error('Expected a firmware byte source');
     }
+    expect(read).toHaveBeenCalledWith({ readerId: 'reader-1', offset: 0, length: artifact.size });
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+
+    backingBytes.fill(9);
+    read.mockClear();
 
     const writes: Array<{ offset: number; data: number[] }> = [];
     await writeFirmwareByteSource({
@@ -52,9 +62,50 @@ describe('FirmwareArtifactSource', () => {
       { offset: 0, data: [1, 2, 3, 4] },
       { offset: 4, data: [5, 6] },
     ]);
+    expect(read).not.toHaveBeenCalled();
+    expect(close).toHaveBeenCalledTimes(1);
+  });
+
+  it('rejects same-sized bytes that do not match the receipt digest', async () => {
+    const { reader, close } = createReader(Uint8Array.from([6, 5, 4, 3, 2, 1]));
+
+    await expect(openFirmwareByteSource({ artifact, reader })).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+      },
+    });
     expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
   });
 
+  it('verifies large artifacts through bounded sequential reads', async () => {
+    const bytes = new Uint8Array(MAX_FIRMWARE_ARTIFACT_READ_BYTES + 3);
+    bytes.fill(7);
+    const largeArtifact = {
+      ...artifact,
+      size: bytes.byteLength,
+      sha256: bytesToHex(sha256(bytes)),
+    };
+    const { reader, read } = createReader(bytes);
+
+    const source = await openFirmwareByteSource({ artifact: largeArtifact, reader });
+    if (!source) {
+      throw new Error('Expected a firmware byte source');
+    }
+    expect(read.mock.calls.map(([request]) => request)).toEqual([
+      {
+        readerId: 'reader-1',
+        offset: 0,
+        length: MAX_FIRMWARE_ARTIFACT_READ_BYTES,
+      },
+      {
+        readerId: 'reader-1',
+        offset: MAX_FIRMWARE_ARTIFACT_READ_BYTES,
+        length: 3,
+      },
+    ]);
+    await source.close();
+  });
+
   it('rejects a reader whose opened size differs from the receipt', async () => {
     const { reader, open, close } = createReader();
     open.mockResolvedValue({
@@ -70,7 +121,7 @@ describe('FirmwareArtifactSource', () => {
     expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
   });
 
-  it('rejects paths and over-limit reads before invoking the host', async () => {
+  it('rejects paths and over-limit writes before invoking the host again', async () => {
     const { reader, read } = createReader();
     await expect(
       openFirmwareByteSource({
@@ -87,6 +138,7 @@ describe('FirmwareArtifactSource', () => {
     if (!source) {
       throw new Error('Expected a firmware byte source');
     }
+    read.mockClear();
     await expect(
       writeFirmwareByteSource({
         source,

package/__tests__/firmware-update/firmware-prepared-host-digest.test.ts

@@ -1,4 +1,6 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex } from '@noble/hashes/utils';
 
 import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
 import FirmwareUpdateV3 from '../../src/api/FirmwareUpdateV3';
@@ -24,6 +26,9 @@ const noUpdate = {
   release: undefined,
 };
 
+const preparedArtifactBytes = Uint8Array.from([1, 2, 3, 4]);
+const preparedArtifactSha256 = bytesToHex(sha256(preparedArtifactBytes));
+
 const createPreparedPlan = ({
   executor,
   target,
@@ -31,11 +36,10 @@ const createPreparedPlan = ({
   executor: 'v2' | 'v3';
   target: 'firmware' | 'bootloader';
 }) => {
-  const sha256 = target === 'firmware' ? 'a'.repeat(64) : 'b'.repeat(64);
   const artifact: FirmwareArtifactReference = {
-    artifactRef: `fw:${sha256}`,
-    size: 4,
-    sha256,
+    artifactRef: `fw:${preparedArtifactSha256}`,
+    size: preparedArtifactBytes.byteLength,
+    sha256: preparedArtifactSha256,
   };
   const isV3 = executor === 'v3';
   const plan = buildFirmwareUpdatePlan({
@@ -97,11 +101,10 @@ const registerMismatchedHost = () => {
 };
 
 const createPreparedV4Plan = () => {
-  const sha256 = 'c'.repeat(64);
   const artifact: FirmwareArtifactReference = {
-    artifactRef: `fw:${sha256}`,
-    size: 4,
-    sha256,
+    artifactRef: `fw:${preparedArtifactSha256}`,
+    size: preparedArtifactBytes.byteLength,
+    sha256: preparedArtifactSha256,
   };
   const plan = buildFirmwareUpdatePlan({
     features: {
@@ -424,7 +427,14 @@ describe('prepared firmware host digest binding', () => {
     });
     const artifactReader = {
       open: jest.fn().mockResolvedValue({ readerId: 'bootloader-reader', size: artifact.size }),
-      read: jest.fn(),
+      read: jest.fn(({ offset, length }: { offset: number; length: number }) => {
+        const data = preparedArtifactBytes.slice(offset, offset + length).buffer;
+        return Promise.resolve({
+          data,
+          bytesRead: data.byteLength,
+          eof: offset + length === preparedArtifactBytes.byteLength,
+        });
+      }),
       close: jest.fn().mockResolvedValue(undefined),
     };
     const hostBindingGeneration = registerFirmwareUpdateHostBinding({

package/__tests__/firmware-update/firmware-prepared-resource-archive.test.ts

@@ -105,6 +105,27 @@ const createPreparedResourcePlan = ({
 };
 
 describe.each(['v2', 'v3'] as const)('%s prepared resource archive binding', executor => {
+  test('rejects a missing artifact reader', async () => {
+    const entryBinary = Uint8Array.from([1, 2, 3, 4]).buffer;
+    const zip = new JSZip();
+    zip.file('images/logo.bin', entryBinary);
+    const archiveBinary = await zip.generateAsync({ type: 'arraybuffer' });
+    const { preparedPlan } = createPreparedResourcePlan({
+      executor,
+      archiveBinary,
+      entryBinary,
+    });
+
+    await expect(
+      readVerifiedPreparedResourceArchive({
+        preparedPlan,
+        reader: undefined,
+      })
+    ).rejects.toMatchObject({
+      params: { firmwareUpdateCode: 'FirmwareArtifactReaderInvalid' },
+    });
+  });
+
   test('uses canonical bytes extracted from the approved ZIP', async () => {
     const entryBinary = Uint8Array.from([1, 2, 3, 4]).buffer;
     const zip = new JSZip();

package/__tests__/firmware-update/firmware-update-bootloader-poll.test.ts

@@ -203,6 +203,69 @@ describe.each([
   });
 });
 
+describe('FirmwareUpdateV2 WebUSB bootloader polling', () => {
+  beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  test('skips interval ticks while a bootloader probe is in flight and resumes afterward', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('desktop' as never);
+    jest.spyOn(DataManager, 'isBleConnect').mockReturnValue(false);
+    jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(false);
+
+    const method = new FirmwareUpdateV2({
+      id: 1,
+      payload: { method: 'firmwareUpdateV2', connectId: WEBUSB_ID },
+    });
+
+    let inFlight = 0;
+    let maxInFlight = 0;
+    const resolveProbes: Array<(found: boolean) => void> = [];
+    const probe = jest.spyOn(method as any, '_checkDeviceInBootloaderMode').mockImplementation(
+      () =>
+        new Promise<boolean>(resolve => {
+          inFlight += 1;
+          maxInFlight = Math.max(maxInFlight, inFlight);
+          resolveProbes.push(found => {
+            inFlight -= 1;
+            resolve(found);
+          });
+        })
+    );
+
+    method.device = {
+      getCurrentDeviceType: jest.fn(() => EDeviceType.Classic),
+    } as unknown as Device;
+
+    method.checkDeviceToBootloader(WEBUSB_ID);
+
+    for (let elapsed = 0; elapsed < 6500; elapsed += 500) {
+      jest.advanceTimersByTime(500);
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+    }
+
+    expect(probe).toHaveBeenCalled();
+    expect(maxInFlight).toBe(1);
+
+    resolveProbes[0]?.(false);
+    await flush();
+    jest.advanceTimersByTime(2000);
+    await flush();
+
+    expect(probe).toHaveBeenCalledTimes(2);
+    expect(maxInFlight).toBe(1);
+    resolveProbes[1]?.(false);
+    await flush();
+  });
+});
+
 describe.each([
   [
     'FirmwareUpdateV2',