@onekeyfe/hd-core 1.2.0-alpha.98 → 1.2.0

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',
@@ -231,7 +294,7 @@ describe.each([
     jest.restoreAllMocks();
   });
 
-  test('pauses the reboot deadline while waiting for browser authorization', async () => {
+  test('resumes bounded polling after browser authorization returns an empty enumeration', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
     jest.spyOn(DataManager, 'isBleConnect').mockReturnValue(false);
     jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(true);
@@ -300,13 +363,76 @@ describe.each([
     }
     expect(rejected).not.toHaveBeenCalled();
 
-    permissionGranted = true;
     resolvePrompt('bootloader-device');
     await flush();
     await flush();
 
+    // The chooser may resolve before the newly authorized device appears in the
+    // next WebUSB enumeration. That transient empty result must not strand the
+    // deferred check after its original interval and timeout were cleared.
+    expect(resolved).not.toHaveBeenCalled();
+    expect(rejected).not.toHaveBeenCalled();
+
+    permissionGranted = true;
+    for (let elapsed = 0; elapsed < 5000; elapsed += 500) {
+      jest.advanceTimersByTime(500);
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      if (resolved.mock.calls.length) break;
+    }
+
     expect(resolved).toHaveBeenCalledWith(true);
     expect(updateFromCache).toHaveBeenCalledWith(bootloaderDevice);
     expect(commands.disposed).toBe(false);
   });
+
+  test('rejects after the fresh deadline when the authorized device never appears', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    jest.spyOn(DataManager, 'isBleConnect').mockReturnValue(false);
+    jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(true);
+    jest.spyOn(DevicePool, 'getDevices').mockResolvedValue({ devices: {}, deviceList: [] });
+
+    const method = buildMethod();
+    method.device = {
+      originalDescriptor: {
+        id: WEBUSB_ID,
+        path: WEBUSB_ID,
+        protocolType: 'V1',
+      },
+      deviceConnector: {
+        enumerate: jest.fn().mockResolvedValue({ descriptors: [] }),
+      },
+      commands: { disposed: true },
+      updateFromCache: jest.fn(),
+      getCurrentDeviceType: jest.fn(() => EDeviceType.Pro),
+    } as unknown as Device;
+    method.postTipMessage = jest.fn();
+    const prompt = jest
+      .spyOn(method as any, '_promptDeviceInBootloaderForWebDevice')
+      .mockResolvedValue('bootloader-device');
+
+    method.checkDeviceToBootloader(WEBUSB_ID);
+    const resolved = jest.fn();
+    const rejected = jest.fn();
+    method.checkPromise?.promise.then(resolved, rejected);
+
+    for (let elapsed = 0; elapsed < 15000; elapsed += 500) {
+      jest.advanceTimersByTime(500);
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      if (prompt.mock.calls.length) break;
+    }
+    expect(prompt).toHaveBeenCalledTimes(1);
+
+    for (let elapsed = 0; elapsed < 31000; elapsed += 500) {
+      jest.advanceTimersByTime(500);
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      if (rejected.mock.calls.length) break;
+    }
+
+    expect(resolved).not.toHaveBeenCalled();
+    expect(rejected).toHaveBeenCalledTimes(1);
+    expect(prompt).toHaveBeenCalledTimes(1);
+  });
 });

package/__tests__/firmware-update/firmware-update-plan-bootloader-identity.test.ts

@@ -1,6 +1,10 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
 import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+import {
+  registerFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from '../../src/api/firmware/FirmwareHostBinding';
 import {
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
   prepareFirmwareUpdatePlan,
@@ -179,6 +183,19 @@ describe('firmware update plan identity in bootloader mode', () => {
         ],
       });
     };
+    const createBinding = (preparedPlanDigest: string) => ({
+      preparedPlanDigest,
+      artifactReader: {
+        open: () => Promise.resolve({ readerId: 'unused', size: 0 }),
+        read: () =>
+          Promise.resolve({
+            data: new ArrayBuffer(0),
+            bytesRead: 0,
+            eof: true,
+          }),
+        close: () => Promise.resolve(),
+      },
+    });
 
     test('accepts the phase that runs after the device reboots and reports a serial', () => {
       const preparedPlan = prepareRecoveryPlan();
@@ -250,6 +267,69 @@ describe('firmware update plan identity in bootloader mode', () => {
         })
       ).not.toThrow();
     });
+
+    test('releases the identity pin when the digest-bound host workflow ends', () => {
+      const preparedPlan = prepareRecoveryPlan();
+      const firstGeneration = registerFirmwareUpdateHostBinding(
+        createBinding(preparedPlan.preparedPlanDigest)
+      );
+      try {
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan,
+          deviceIdentity: 'CLA45F0023',
+          bootloaderMode: false,
+          deviceModel: String(EDeviceType.Classic1s),
+        });
+      } finally {
+        expect(unregisterFirmwareUpdateHostBinding(firstGeneration)).toBe(true);
+      }
+
+      const secondGeneration = registerFirmwareUpdateHostBinding(
+        createBinding(preparedPlan.preparedPlanDigest)
+      );
+      try {
+        expect(() =>
+          assertFirmwareUpdatePreparedPlanDeviceIdentity({
+            preparedPlan,
+            deviceIdentity: 'CLA99Z9999',
+            bootloaderMode: false,
+            deviceModel: String(EDeviceType.Classic1s),
+          })
+        ).not.toThrow();
+      } finally {
+        expect(unregisterFirmwareUpdateHostBinding(secondGeneration)).toBe(true);
+      }
+    });
+
+    test('a stale unregister cannot release the active workflow identity pin', () => {
+      const stalePlan = prepareRecoveryPlan();
+      const staleGeneration = registerFirmwareUpdateHostBinding(
+        createBinding(stalePlan.preparedPlanDigest)
+      );
+      const activePlan = prepareRecoveryPlan();
+      const activeGeneration = registerFirmwareUpdateHostBinding(
+        createBinding(activePlan.preparedPlanDigest)
+      );
+      try {
+        assertFirmwareUpdatePreparedPlanDeviceIdentity({
+          preparedPlan: activePlan,
+          deviceIdentity: 'CLA45F0023',
+          bootloaderMode: false,
+          deviceModel: String(EDeviceType.Classic1s),
+        });
+        expect(unregisterFirmwareUpdateHostBinding(staleGeneration)).toBe(false);
+        expect(() =>
+          assertFirmwareUpdatePreparedPlanDeviceIdentity({
+            preparedPlan: activePlan,
+            deviceIdentity: 'CLA99Z9999',
+            bootloaderMode: false,
+            deviceModel: String(EDeviceType.Classic1s),
+          })
+        ).toThrow();
+      } finally {
+        expect(unregisterFirmwareUpdateHostBinding(activeGeneration)).toBe(true);
+      }
+    });
   });
 
   describe('prepared plan device identity assertion', () => {

package/__tests__/firmware-update/firmware-update-plan.test.ts

@@ -1,6 +1,9 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
-import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+import {
+  buildFirmwareUpdatePlan,
+  validateProtocolV2FirmwareUpdateTargets,
+} from '../../src/api/firmware/FirmwareUpdatePlan';
 import {
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
   prepareFirmwareUpdatePlan,
@@ -88,6 +91,18 @@ const createProtocolV2ForceInput = (
   forceUpdateTargets: forceUpdateTargets as BuildPlanInput['forceUpdateTargets'],
 });
 
+describe('validateProtocolV2FirmwareUpdateTargets', () => {
+  test('normalizes the deprecated boot_resources alias to resource', () => {
+    expect(validateProtocolV2FirmwareUpdateTargets(['boot_resources'])).toEqual(['resource']);
+  });
+
+  test('rejects duplicate semantic targets after alias normalization', () => {
+    expectFirmwarePlanInvalid(() =>
+      validateProtocolV2FirmwareUpdateTargets(['boot_resources', 'resource'])
+    );
+  });
+});
+
 describe('buildFirmwareUpdatePlan', () => {
   test('selects all legacy artifacts before execution and chooses the desktop full resource', () => {
     const plan = buildFirmwareUpdatePlan({
@@ -316,65 +331,114 @@ describe('buildFirmwareUpdatePlan', () => {
     expectFirmwarePlanInvalid(() => buildFirmwareUpdatePlan(createLegacyForceInput(['resource'])));
   });
 
-  test('rejects a legacy resource archive without complete integrity metadata', () => {
-    expectFirmwarePlanInvalid(
-      () =>
-        buildFirmwareUpdatePlan(
-          createLegacyForceInput(['resource'], {
-            url: 'https://firmware.onekey.so/pro/firmware.bin',
-            resource: 'https://firmware.onekey.so/pro/resource.zip',
-            resourceExpectedSize: 4096,
-          })
-        ),
-      'integrity metadata is invalid'
-    );
-  });
-
-  test.each(['firmware', 'ble', 'bootloader'] as const)(
-    'rejects a remote legacy %s artifact without complete integrity metadata',
-    target => {
+  test.each([
+    {
+      executor: 'V2',
+      deviceType: EDeviceType.Classic1s,
+      bootloaderVersion: '2.1.2',
+    },
+    {
+      executor: 'V3',
+      deviceType: EDeviceType.Pro,
+      bootloaderVersion: '2.8.4',
+    },
+  ])(
+    'rejects a resource-only prepared plan that the $executor executor cannot run',
+    ({ deviceType, bootloaderVersion }) => {
       expectFirmwarePlanInvalid(
         () =>
           buildFirmwareUpdatePlan({
-            features: createFeatures({ deviceType: EDeviceType.Classic1s }),
+            features: createFeatures({
+              deviceType,
+              firmwareVersion: '4.21.0',
+              bootloaderVersion,
+            }),
             firmwareType: EFirmwareType.Universal,
             platform: 'desktop',
-            firmware:
-              target === 'firmware'
-                ? {
-                    status: 'outdated',
-                    release: {
-                      url: 'https://firmware.onekey.so/classic/firmware.bin',
-                      expectedSize: 1024,
-                    },
-                  }
-                : noUpdate,
-            ble:
-              target === 'ble'
-                ? {
-                    status: 'outdated',
-                    release: {
-                      webUpdate: 'https://firmware.onekey.so/classic/ble.bin',
-                      expectedSize: 512,
-                    },
-                  }
-                : noUpdate,
-            bootloader:
-              target === 'bootloader'
-                ? {
-                    status: 'outdated',
-                    release: {
-                      bootloaderResource: 'https://firmware.onekey.so/classic/bootloader.bin',
-                      bootloaderExpectedSize: 768,
-                    },
-                  }
-                : noUpdate,
+            firmware: {
+              status: 'valid',
+              release: {
+                url: 'https://firmware.onekey.so/legacy/firmware.bin',
+                version: [4, 21, 0],
+                expectedSize: 1024,
+                fingerprint: '1'.repeat(64),
+                resource: 'https://firmware.onekey.so/legacy/resource.zip',
+                resourceExpectedSize: 4096,
+                resourceFingerprint: '2'.repeat(64),
+              },
+            },
+            ble: noUpdate,
+            bootloader: noUpdate,
+            forceUpdateTargets: ['resource'],
           }),
-        'integrity metadata is invalid'
+        'Legacy resource updates require a firmware target'
       );
     }
   );
 
+  test.each([
+    {
+      executor: 'v2',
+      deviceType: EDeviceType.Classic1s,
+      bootloaderVersion: '2.1.2',
+    },
+    {
+      executor: 'v3',
+      deviceType: EDeviceType.Pro,
+      bootloaderVersion: '2.8.4',
+    },
+  ])(
+    'allows $executor config releases without optional integrity metadata',
+    ({ executor, deviceType, bootloaderVersion }) => {
+      const plan = buildFirmwareUpdatePlan({
+        features: createFeatures({
+          deviceType,
+          firmwareVersion: '4.21.0',
+          bootloaderVersion,
+        }),
+        firmwareType: EFirmwareType.Universal,
+        platform: 'desktop',
+        firmware: {
+          status: 'valid',
+          release: {
+            url: 'https://firmware.onekey.so/legacy/firmware.bin',
+            version: [4, 21, 0],
+            fingerprint: '',
+            resource: 'https://firmware.onekey.so/legacy/resource.zip',
+            resourceFingerprint: '',
+          },
+        },
+        ble: {
+          status: 'valid',
+          release: {
+            webUpdate: 'https://firmware.onekey.so/legacy/ble.bin',
+            version: [2, 3, 7],
+            fingerprintWeb: '',
+          },
+        },
+        bootloader: {
+          status: 'valid',
+          release: {
+            bootloaderResource: 'https://firmware.onekey.so/legacy/bootloader.bin',
+            bootloaderVersion: [2, 8, 4],
+            bootloaderFingerprint: '',
+          },
+        },
+        forceUpdateTargets: ['firmware', 'resource', 'ble', 'bootloader'],
+      });
+
+      expect(plan.executor).toBe(executor);
+      expect(plan.artifacts.map(artifact => artifact.artifactId)).toEqual([
+        'bootloader',
+        'firmware',
+        'resource',
+        'ble',
+      ]);
+      expect(plan.artifacts.every(artifact => artifact.expectedSize === undefined)).toBe(true);
+      expect(plan.artifacts.every(artifact => artifact.expectedSha256 === undefined)).toBe(true);
+    }
+  );
+
   test.each(['ble', 'bootloader'] as const)(
     'rejects the unsupported Pro2 %s force target',
     forceTarget => {

package/__tests__/firmware-update/firmware-update-prepared-plan.test.ts

@@ -179,7 +179,7 @@ describe('FirmwareUpdatePreparedPlan', () => {
     ).toThrow('plan digest is invalid');
   });
 
-  test('projects portable archive paths to unique device resource names', () => {
+  test('keeps ZIP entries unique by archive path, not basename', () => {
     const plan = buildPlan();
     const buildArtifacts = (entryNames: string[]) => [
       {
@@ -200,7 +200,17 @@ describe('FirmwareUpdatePreparedPlan', () => {
       prepareFirmwareUpdatePlan({
         plan,
         leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
-        artifacts: buildArtifacts(['icons/index.bin', 'fonts/index.bin']),
+        artifacts: buildArtifacts([
+          'loaders/bootloader/params-pro2-prod_resource-unsigned.okpkg',
+          'loaders/rom/params-pro2-prod_resource-unsigned.okpkg',
+        ]),
+      })
+    ).not.toThrow();
+    expect(() =>
+      prepareFirmwareUpdatePlan({
+        plan,
+        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
+        artifacts: buildArtifacts(['loaders/rom/params.okpkg', 'loaders/rom/params.okpkg']),
       })
     ).toThrow('duplicate entry names');
     expect(() =>
@@ -234,7 +244,11 @@ describe('FirmwareUpdatePreparedPlan', () => {
         },
       ],
     });
-    const resourceArtifact = prepared.artifacts.find(item => item.target === 'resource')!;
+    const resourceArtifact = prepared.artifacts.find(item => item.target === 'resource');
+    expect(resourceArtifact).toBeDefined();
+    if (!resourceArtifact) {
+      throw new Error('Expected prepared resource artifact');
+    }
     const tamperedWithoutDigest = {
       ...prepared,
       artifacts: prepared.artifacts.map(item =>
@@ -242,9 +256,9 @@ describe('FirmwareUpdatePreparedPlan', () => {
           ? {
               ...item,
               materializedEntries: [
-                ...resourceArtifact.materializedEntries!,
+                ...(resourceArtifact.materializedEntries ?? []),
                 {
-                  entryName: 'other/index.bin',
+                  entryName: 'resource/index.bin',
                   artifact: artifact('d'.repeat(64), 2),
                 },
               ],

package/__tests__/firmware-update/firmware-update-v3-reconnect.test.ts

@@ -1,6 +1,7 @@
 import * as hdShared from '@onekeyfe/hd-shared';
 
 import FirmwareUpdateV3 from '../../src/api/FirmwareUpdateV3';
+import { DataManager } from '../../src/data-manager';
 import { DevicePool } from '../../src/device/DevicePool';
 
 import type { Device } from '../../src/device/Device';
@@ -112,10 +113,125 @@ describe('FirmwareUpdateV3 reconnect', () => {
         })
       ).rejects.toBe(reconnectError);
 
+      expect(commands.typedCall).toHaveBeenCalledWith('GetFeatures', 'Features', {});
       expect(waitForDeviceReconnect).toHaveBeenCalledWith(3 * 60 * 1000);
     } finally {
       jest.clearAllTimers();
       jest.useRealTimers();
     }
   });
+
+  it('lets Browser WebUSB clean up a timed out install probe before reconnecting', async () => {
+    jest.spyOn(hdShared, 'wait').mockResolvedValue(undefined);
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(true);
+    const method = new FirmwareUpdateV3({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV3',
+        connectId: 'webusb-device',
+      },
+    });
+    const reconnectError = new Error('stop after WebUSB reconnect assertion');
+    const waitForDeviceReconnect = jest
+      .spyOn(method, 'waitForDeviceReconnect')
+      .mockRejectedValue(reconnectError);
+    method.isBleReconnect = jest.fn(() => false);
+    method.params = {
+      platform: 'web',
+    } as any;
+    const commands = {
+      typedCall: jest.fn().mockRejectedValue(new Error('Protocol V1 read timeout after 3000ms')),
+    };
+    method.device = {
+      features: {},
+      getCommands: () => commands,
+    } as unknown as Device;
+    (method as any).createUpdatesFolderIfNotExists = jest.fn().mockResolvedValue(undefined);
+    (method as any).startEmmcFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
+    method.postTipMessage = jest.fn();
+    method.postProcessingMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    await expect(
+      (method as any).executeUpdate({
+        resourceBinary: null,
+        resourceEntries: [],
+        fwSources: [],
+        bootloaderSource: null,
+      })
+    ).rejects.toBe(reconnectError);
+
+    expect(commands.typedCall).toHaveBeenCalledWith(
+      'GetFeatures',
+      'Features',
+      {},
+      {
+        timeoutMs: 3000,
+      }
+    );
+    expect(waitForDeviceReconnect).toHaveBeenCalledWith(60 * 1000);
+  });
+
+  it('does not treat cached firmware versions as Browser WebUSB install completion', async () => {
+    jest.spyOn(hdShared, 'wait').mockResolvedValue(undefined);
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(true);
+    const method = new FirmwareUpdateV3({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV3',
+        connectId: 'webusb-device',
+      },
+    });
+    method.params = {
+      platform: 'web',
+    } as any;
+    const commands = {
+      typedCall: jest
+        .fn()
+        .mockResolvedValueOnce({
+          type: 'Features',
+          message: {
+            major_version: 0,
+            minor_version: 0,
+            patch_version: 0,
+          },
+        })
+        .mockResolvedValueOnce({
+          type: 'Features',
+          message: {
+            major_version: 4,
+            minor_version: 21,
+            patch_version: 0,
+            onekey_ble_version: '2.3.7',
+          },
+        }),
+    };
+    method.device = {
+      features: {
+        firmwareVersion: '4.21.0',
+        bleVersion: '2.3.7',
+      },
+      getCommands: () => commands,
+    } as unknown as Device;
+    (method as any).createUpdatesFolderIfNotExists = jest.fn().mockResolvedValue(undefined);
+    (method as any).startEmmcFirmwareUpdate = jest.fn().mockResolvedValue(undefined);
+    method.postTipMessage = jest.fn();
+    method.postProcessingMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    const result = await (method as any).executeUpdate({
+      resourceBinary: null,
+      resourceEntries: [],
+      fwSources: [],
+      bootloaderSource: null,
+    });
+
+    expect(commands.typedCall).toHaveBeenCalledTimes(2);
+    expect(result).toMatchObject({
+      firmwareVersion: '4.21.0',
+      bleVersion: '2.3.7',
+    });
+  });
 });