@onekeyfe/hd-core 1.2.0-alpha.96 → 1.2.0-alpha.97

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

@@ -1,8 +1,11 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
 import FirmwareUpdate from '../../src/api/FirmwareUpdate';
 import FirmwareUpdateV2 from '../../src/api/FirmwareUpdateV2';
 import FirmwareUpdateV3 from '../../src/api/FirmwareUpdateV3';
 import { BOOTLOADER_POLL_INITIALIZE_TIMEOUT_MS } from '../../src/api/firmware/FirmwareUpdateBaseMethod';
 import { DataManager } from '../../src/data-manager';
+import { DevicePool } from '../../src/device/DevicePool';
 
 import type { Device } from '../../src/device/Device';
 
@@ -12,6 +15,7 @@ jest.mock('../../src/data/config', () => ({
 }));
 
 const BLE_ID = 'ble-device';
+const WEBUSB_ID = 'webusb-device';
 
 const flush = () =>
   new Promise(resolve => {
@@ -198,3 +202,111 @@ describe.each([
     expect(maxActiveProbes).toBe(1);
   });
 });
+
+describe.each([
+  [
+    'FirmwareUpdateV2',
+    () =>
+      new FirmwareUpdateV2({
+        id: 1,
+        payload: { method: 'firmwareUpdateV2', connectId: WEBUSB_ID },
+      }),
+  ],
+  [
+    'FirmwareUpdateV3 (base method)',
+    () =>
+      new FirmwareUpdateV3({
+        id: 1,
+        payload: { method: 'firmwareUpdateV3', connectId: WEBUSB_ID },
+      }),
+  ],
+])('%s WebUSB bootloader authorization', (_name, buildMethod) => {
+  beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+    jest.restoreAllMocks();
+  });
+
+  test('pauses the reboot deadline while waiting for browser authorization', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    jest.spyOn(DataManager, 'isBleConnect').mockReturnValue(false);
+    jest.spyOn(DataManager, 'isBrowserWebUsb').mockReturnValue(true);
+
+    const method = buildMethod();
+    let permissionGranted = false;
+    const bootloaderDevice = {
+      isBootloader: jest.fn(() => true),
+    } as unknown as Device;
+    jest.spyOn(DevicePool, 'getDevices').mockImplementation(() =>
+      Promise.resolve({
+        devices: {},
+        deviceList: permissionGranted ? [bootloaderDevice] : [],
+      })
+    );
+
+    const commands = { disposed: true };
+    const updateFromCache = jest.fn();
+    method.device = {
+      originalDescriptor: {
+        id: WEBUSB_ID,
+        path: WEBUSB_ID,
+        protocolType: 'V1',
+      },
+      deviceConnector: {
+        enumerate: jest.fn(() =>
+          Promise.resolve({
+            descriptors: permissionGranted ? [{ path: 'bootloader-device' }] : [],
+          })
+        ),
+      },
+      commands,
+      updateFromCache,
+      getCurrentDeviceType: jest.fn(() => EDeviceType.Pro),
+    } as unknown as Device;
+    method.postTipMessage = jest.fn();
+
+    let resolvePrompt: (deviceId: string) => void = () => undefined;
+    const promptPromise = new Promise<string>(resolve => {
+      resolvePrompt = resolve;
+    });
+    const prompt = jest
+      .spyOn(method as any, '_promptDeviceInBootloaderForWebDevice')
+      .mockReturnValue(promptPromise);
+
+    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);
+
+    // Browser permission depends on a user gesture and must not consume the
+    // automatic reboot detection deadline.
+    for (let elapsed = 0; elapsed < 35000; elapsed += 500) {
+      jest.advanceTimersByTime(500);
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+    }
+    expect(rejected).not.toHaveBeenCalled();
+
+    permissionGranted = true;
+    resolvePrompt('bootloader-device');
+    await flush();
+    await flush();
+
+    expect(resolved).toHaveBeenCalledWith(true);
+    expect(updateFromCache).toHaveBeenCalledWith(bootloaderDevice);
+    expect(commands.disposed).toBe(false);
+  });
+});

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

@@ -1,10 +1,6 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
 import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
-import {
-  assertFirmwareUpdatePreparedPlanDeviceIdentity,
-  prepareFirmwareUpdatePlan,
-} from '../../src/api/firmware/FirmwareUpdatePreparedPlan';
 
 import type { Features } from '../../src/types';
 
@@ -301,6 +297,12 @@ describe('buildFirmwareUpdatePlan', () => {
       forceTarget: 'firmware' as const,
       release: {
         components: {},
+        resourceBundles: [
+          {
+            name: 'images',
+            url: 'https://firmware.onekey.so/pro2/images.okpkg',
+          },
+        ],
       },
     },
     {
@@ -310,8 +312,6 @@ describe('buildFirmwareUpdatePlan', () => {
           applicationP1: {
             target: 'APPLICATION_P1',
             url: 'https://firmware.onekey.so/pro2/application-p1.bin',
-            expectedSize: 1024,
-            fingerprint: '1111111111111111111111111111111111111111111111111111111111111111',
           },
         },
       },
@@ -325,23 +325,41 @@ describe('buildFirmwareUpdatePlan', () => {
     }
   );
 
-  test('limits a Pro2 firmware force to component artifacts', () => {
-    const plan = buildFirmwareUpdatePlan(
-      createProtocolV2ForceInput(['firmware'], {
-        components: {
-          applicationP1: {
-            target: 'APPLICATION_P1',
-            url: 'https://firmware.onekey.so/pro2/application-p1.bin',
-            expectedSize: 1024,
-            fingerprint: '1111111111111111111111111111111111111111111111111111111111111111',
+  test.each([
+    {
+      forceTarget: 'firmware' as const,
+      expectedArtifactIds: ['component:app_v1'],
+      expectedTargets: ['app_v1'],
+    },
+    {
+      forceTarget: 'resource' as const,
+      expectedArtifactIds: ['resourceBundle:images'],
+      expectedTargets: ['resource'],
+    },
+  ])(
+    'limits a Pro2 $forceTarget force to the selected artifact role',
+    ({ forceTarget, expectedArtifactIds, expectedTargets }) => {
+      const plan = buildFirmwareUpdatePlan(
+        createProtocolV2ForceInput([forceTarget], {
+          components: {
+            applicationP1: {
+              target: 'APPLICATION_P1',
+              url: 'https://firmware.onekey.so/pro2/application-p1.bin',
+            },
           },
-        },
-      })
-    );
+          resourceBundles: [
+            {
+              name: 'images',
+              url: 'https://firmware.onekey.so/pro2/images.okpkg',
+            },
+          ],
+        })
+      );
 
-    expect(plan.artifacts.map(artifact => artifact.artifactId)).toEqual(['component:app_v1']);
-    expect(plan.targetsToUpdate).toEqual(['app_v1']);
-  });
+      expect(plan.artifacts.map(artifact => artifact.artifactId)).toEqual(expectedArtifactIds);
+      expect(plan.targetsToUpdate).toEqual(expectedTargets);
+    }
+  );
 
   test('rejects a prepared native plan without a stable device identity', () => {
     const features = createFeatures({
@@ -366,72 +384,7 @@ describe('buildFirmwareUpdatePlan', () => {
     ).toThrow('requires a stable device identity');
   });
 
-  test('allows an identity-less Protocol V2 device while retaining the model binding', () => {
-    const features = createFeatures({
-      deviceType: EDeviceType.Pro2,
-    });
-    delete (features as Partial<Features>).serialNo;
-
-    const plan = buildFirmwareUpdatePlan({
-      features,
-      firmwareType: EFirmwareType.Universal,
-      platform: 'desktop',
-      firmware: {
-        status: 'outdated',
-        release: {
-          components: {
-            applicationP1: {
-              target: 'APPLICATION_P1',
-              url: 'https://firmware.onekey.so/pro2/application-p1.bin',
-              expectedSize: 1024,
-              fingerprint: '1111111111111111111111111111111111111111111111111111111111111111',
-            },
-          },
-        },
-      },
-      ble: noUpdate,
-      bootloader: noUpdate,
-    });
-
-    expect(plan).toMatchObject({
-      executor: 'v4',
-      deviceIdentity: 'unavailable',
-      deviceModel: String(EDeviceType.Pro2),
-    });
-
-    const preparedPlan = prepareFirmwareUpdatePlan({
-      plan,
-      leaseRef: 'fwlease:00000000-0000-4000-8000-000000000004',
-      artifacts: [
-        {
-          artifactId: 'component:app_v1',
-          artifact: {
-            artifactRef: `fw:${'1'.repeat(64)}`,
-            size: 1024,
-            sha256: '1'.repeat(64),
-          },
-        },
-      ],
-    });
-    expect(() =>
-      assertFirmwareUpdatePreparedPlanDeviceIdentity({
-        preparedPlan,
-        deviceIdentity: undefined,
-        bootloaderMode: false,
-        deviceModel: String(EDeviceType.Pro2),
-      })
-    ).not.toThrow();
-    expect(() =>
-      assertFirmwareUpdatePreparedPlanDeviceIdentity({
-        preparedPlan,
-        deviceIdentity: undefined,
-        bootloaderMode: false,
-        deviceModel: String(EDeviceType.Neo),
-      })
-    ).toThrow();
-  });
-
-  test('maps the Pro2 component order without downloading artifacts', () => {
+  test('maps the Pro2 component order and resource bundles without downloading them', () => {
     const plan = buildFirmwareUpdatePlan({
       features: createFeatures({ deviceType: EDeviceType.Pro2 }),
       firmwareType: EFirmwareType.Universal,
@@ -450,16 +403,18 @@ describe('buildFirmwareUpdatePlan', () => {
             bootloader: {
               target: 'BOOTLOADER',
               url: 'https://firmware.onekey.so/pro2/bootloader.bin',
-              expectedSize: 2048,
-              fingerprint: '2222222222222222222222222222222222222222222222222222222222222222',
             },
             se01: {
               target: 'SE01',
               url: 'https://firmware.onekey.so/pro2/se01.bin',
-              expectedSize: 512,
-              fingerprint: '3333333333333333333333333333333333333333333333333333333333333333',
             },
           },
+          resourceBundles: [
+            {
+              name: 'images',
+              url: 'https://firmware.onekey.so/pro2/images.okpkg',
+            },
+          ],
         },
       },
       ble: noUpdate,
@@ -471,8 +426,9 @@ describe('buildFirmwareUpdatePlan', () => {
       'component:boot',
       'component:app_v1',
       'component:se01',
+      'resourceBundle:images',
     ]);
-    expect(plan.targetsToUpdate).toEqual(['boot', 'app_v1', 'se01']);
+    expect(plan.targetsToUpdate).toEqual(['boot', 'app_v1', 'se01', 'resource']);
     expect(plan.artifacts[1]).toEqual(
       expect.objectContaining({
         expectedSize: 1024,
@@ -481,41 +437,6 @@ describe('buildFirmwareUpdatePlan', () => {
     );
   });
 
-  test.each([
-    {
-      expectedSize: undefined,
-      fingerprint: '1'.repeat(64),
-    },
-    {
-      expectedSize: 1024,
-      fingerprint: undefined,
-    },
-  ])('rejects a remote Pro2 component without complete integrity metadata', integrity => {
-    expectFirmwarePlanInvalid(
-      () =>
-        buildFirmwareUpdatePlan({
-          features: createFeatures({ deviceType: EDeviceType.Pro2 }),
-          firmwareType: EFirmwareType.Universal,
-          platform: 'desktop',
-          firmware: {
-            status: 'required',
-            release: {
-              components: {
-                applicationP1: {
-                  target: 'APPLICATION_P1',
-                  url: 'https://firmware.onekey.so/pro2/application-p1.bin',
-                  ...integrity,
-                },
-              },
-            },
-          },
-          ble: noUpdate,
-          bootloader: noUpdate,
-        }),
-      'integrity metadata is invalid'
-    );
-  });
-
   test('rejects Pro2 ROMLOADER because it requires a separate loader flow', () => {
     expect(() =>
       buildFirmwareUpdatePlan({
@@ -547,19 +468,37 @@ describe('buildFirmwareUpdatePlan', () => {
           application: {
             target: 'APPLICATION_P1',
             url: 'https://firmware.onekey.so/pro2/application.bin',
-            expectedSize: 1024,
-            fingerprint: '1111111111111111111111111111111111111111111111111111111111111111',
           },
           applicationDuplicate: {
             target: 'APPLICATION_P1',
             url: 'https://firmware.onekey.so/pro2/application-duplicate.bin',
-            expectedSize: 1024,
-            fingerprint: '2222222222222222222222222222222222222222222222222222222222222222',
           },
         },
       },
       expectedError: 'duplicates target app_v1',
     },
+    {
+      label: 'resource bundle name',
+      release: {
+        components: {
+          application: {
+            target: 'APPLICATION_P1',
+            url: 'https://firmware.onekey.so/pro2/application.bin',
+          },
+        },
+        resourceBundles: [
+          {
+            name: 'images',
+            url: 'https://firmware.onekey.so/pro2/images.okpkg',
+          },
+          {
+            name: 'images',
+            url: 'https://firmware.onekey.so/pro2/images-duplicate.okpkg',
+          },
+        ],
+      },
+      expectedError: 'duplicates name images',
+    },
   ])('rejects a duplicate Pro2 $label', ({ release, expectedError }) => {
     expect(() =>
       buildFirmwareUpdatePlan({

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

@@ -1,9 +1,6 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
-import {
-  buildFirmwareUpdatePlan,
-  digestFirmwareUpdateContract,
-} from '../../src/api/firmware/FirmwareUpdatePlan';
+import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
 import {
   assertFirmwareUpdatePreparedPlanBinding,
   assertFirmwareUpdatePreparedPlanDeviceIdentity,
@@ -212,55 +209,6 @@ describe('FirmwareUpdatePreparedPlan', () => {
     ).toThrow('entry name is invalid');
   });
 
-  test('rejects duplicate materialized entry names during standalone validation', () => {
-    const plan = buildPlan();
-    const prepared = prepareFirmwareUpdatePlan({
-      plan,
-      leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
-      artifacts: [
-        {
-          artifactId: 'firmware',
-          artifact: artifact('a'.repeat(64), 4),
-        },
-        {
-          artifactId: 'resource',
-          artifact: artifact('b'.repeat(64), 8),
-          materializedEntries: [
-            {
-              entryName: 'resource/index.bin',
-              artifact: artifact('c'.repeat(64), 2),
-            },
-          ],
-        },
-      ],
-    });
-    const resourceArtifact = prepared.artifacts.find(item => item.target === 'resource')!;
-    const tamperedWithoutDigest = {
-      ...prepared,
-      artifacts: prepared.artifacts.map(item =>
-        item === resourceArtifact
-          ? {
-              ...item,
-              materializedEntries: [
-                ...resourceArtifact.materializedEntries!,
-                {
-                  entryName: 'other/index.bin',
-                  artifact: artifact('d'.repeat(64), 2),
-                },
-              ],
-            }
-          : item
-      ),
-    };
-    const { preparedPlanDigest: _preparedPlanDigest, ...digestInput } = tamperedWithoutDigest;
-    const tampered = {
-      ...tamperedWithoutDigest,
-      preparedPlanDigest: digestFirmwareUpdateContract(digestInput),
-    };
-
-    expect(() => validateFirmwareUpdatePreparedPlan(tampered)).toThrow('duplicate entry names');
-  });
-
   test('rejects unknown fields even when a caller presents a plan-shaped object', () => {
     const plan = buildPlan();
     expect(() =>