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

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

@@ -376,62 +376,66 @@ describe('buildFirmwareUpdatePlan', () => {
     }
   );
 
-  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([
+    {
+      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'],
+      });
 
-  test.each(['firmware', 'ble', 'bootloader'] as const)(
-    'rejects a remote legacy %s artifact without complete integrity metadata',
-    target => {
-      expectFirmwarePlanInvalid(
-        () =>
-          buildFirmwareUpdatePlan({
-            features: createFeatures({ deviceType: EDeviceType.Classic1s }),
-            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,
-          }),
-        'integrity metadata is invalid'
-      );
+      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);
     }
   );
 

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',
+    });
+  });
 });