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

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

@@ -0,0 +1,199 @@
+import { EFirmwareType } from '@onekeyfe/hd-shared';
+
+import CheckAllFirmwareRelease from '../src/api/CheckAllFirmwareRelease';
+import CheckBLEFirmwareRelease from '../src/api/CheckBLEFirmwareRelease';
+import CheckBootloaderRelease from '../src/api/CheckBootloaderRelease';
+import CheckFirmwareRelease from '../src/api/CheckFirmwareRelease';
+import { DataManager } from '../src/data-manager';
+
+import type { IFirmwareReleaseInfo } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+const release: IFirmwareReleaseInfo = {
+  required: false,
+  version: [2, 0, 0],
+  url: 'https://example.com/application-p1.okpkg',
+  fingerprint: 'release-fingerprint',
+  changelog: {
+    'zh-CN': '更新',
+    'en-US': 'Update',
+  },
+  bootloaderChangelog: {
+    'zh-CN': '旧版 Bootloader 更新',
+    'en-US': 'Legacy bootloader update',
+  },
+  installOrder: ['bootloader', 'applicationP1', 'coprocessor'],
+  components: {
+    bootloader: {
+      target: 'BOOTLOADER',
+      url: 'https://example.com/bootloader.okpkg',
+      version: [2, 0, 0],
+    },
+    applicationP1: {
+      target: 'APPLICATION_P1',
+      url: 'https://example.com/application-p1.okpkg',
+      version: [2, 0, 0],
+    },
+    coprocessor: {
+      target: 'COPROCESSOR',
+      url: 'https://example.com/coprocessor.okpkg',
+      version: [2, 0, 0],
+    },
+  },
+};
+
+const createDevice = (deviceType: 'pro2' | 'neo') => ({
+  isProtocolV2: () => true,
+  features: {
+    deviceType,
+    firmwareVersion: '1.0.0',
+  },
+  getDeviceState: jest.fn().mockResolvedValue({
+    identity: {
+      deviceType,
+      firmwareType: EFirmwareType.Universal,
+    },
+    status: { mode: 'normal' },
+    versions: {
+      firmware: '1.0.0',
+      applicationP1: '1.0.0',
+      bootloader: '1.0.0',
+      board: '1.0.0',
+      ble: '1.0.0',
+    },
+  }),
+});
+
+describe.each(['pro2', 'neo'] as const)('Protocol V2 release checks for %s', deviceType => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('supports firmware, BLE, bootloader, and aggregate release checks', async () => {
+    jest.spyOn(DataManager, 'getFirmwareLatestRelease').mockReturnValue(release);
+    jest.spyOn(DataManager, 'getProtocolV2ResourceSource').mockReturnValue({
+      archiveUrl: `https://example.com/${deviceType}/pro2-resource.zip`,
+      archiveSha256: 'a'.repeat(64),
+      archiveSize: 16_815_479,
+    });
+
+    const firmwareMethod = new CheckFirmwareRelease({
+      id: 1,
+      payload: { method: 'checkFirmwareRelease' },
+    });
+    firmwareMethod.init();
+    firmwareMethod.device = createDevice(deviceType) as unknown as CheckFirmwareRelease['device'];
+
+    const bleMethod = new CheckBLEFirmwareRelease({
+      id: 2,
+      payload: { method: 'checkBLEFirmwareRelease' },
+    });
+    bleMethod.init();
+    bleMethod.device = createDevice(deviceType) as unknown as CheckBLEFirmwareRelease['device'];
+
+    const bootloaderMethod = new CheckBootloaderRelease({
+      id: 3,
+      payload: { method: 'checkBootloaderRelease' },
+    });
+    bootloaderMethod.init();
+    bootloaderMethod.device = createDevice(
+      deviceType
+    ) as unknown as CheckBootloaderRelease['device'];
+
+    const allMethod = new CheckAllFirmwareRelease({
+      id: 4,
+      payload: { method: 'checkAllFirmwareRelease' },
+    });
+    allMethod.init();
+    allMethod.device = createDevice(deviceType) as unknown as CheckAllFirmwareRelease['device'];
+
+    await expect(firmwareMethod.run()).resolves.toMatchObject({
+      status: 'outdated',
+      shouldUpdate: true,
+      release,
+    });
+    await expect(bleMethod.run()).resolves.toMatchObject({
+      status: 'outdated',
+      shouldUpdate: true,
+      release: {
+        protocol: 'V2',
+        configKey: 'coprocessor',
+        componentTarget: 'COPROCESSOR',
+        target: 'COPROCESSOR',
+        url: 'https://example.com/coprocessor.okpkg',
+        version: [2, 0, 0],
+      },
+    });
+    await expect(bootloaderMethod.run()).resolves.toMatchObject({
+      status: 'outdated',
+      shouldUpdate: true,
+      changelog: [release.changelog],
+      release: {
+        protocol: 'V2',
+        configKey: 'bootloader',
+        componentTarget: 'BOOTLOADER',
+        target: 'BOOTLOADER',
+        url: 'https://example.com/bootloader.okpkg',
+        version: [2, 0, 0],
+        changelog: release.changelog,
+      },
+    });
+    await expect(allMethod.run()).resolves.toMatchObject({
+      protocol: 'V2',
+      deviceType,
+      status: 'outdated',
+      hasUpgrade: true,
+      targetsToUpdate: ['boot', 'app_v1', 'coprocessor', 'resource'],
+      firmware: { status: 'outdated', shouldUpdate: true },
+      ble: {
+        status: 'outdated',
+        shouldUpdate: true,
+        release: { componentTarget: 'COPROCESSOR' },
+      },
+      bootloader: {
+        status: 'outdated',
+        shouldUpdate: true,
+        release: { componentTarget: 'BOOTLOADER' },
+      },
+    });
+
+    expect(firmwareMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    expect(bleMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    expect(bootloaderMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+    expect(allMethod.getSupportedProtocols()).toEqual(['V1', 'V2']);
+  });
+});
+
+test('returns null from optional release probes when device features are unavailable', async () => {
+  const deviceWithoutFeatures = {
+    isProtocolV2: jest.fn(() => true),
+    features: undefined,
+    getDeviceState: jest.fn(),
+  };
+  const firmwareMethod = new CheckFirmwareRelease({
+    id: 1,
+    payload: { method: 'checkFirmwareRelease' },
+  });
+  const bleMethod = new CheckBLEFirmwareRelease({
+    id: 2,
+    payload: { method: 'checkBLEFirmwareRelease' },
+  });
+  const bootloaderMethod = new CheckBootloaderRelease({
+    id: 3,
+    payload: { method: 'checkBootloaderRelease' },
+  });
+
+  firmwareMethod.device = deviceWithoutFeatures as unknown as CheckFirmwareRelease['device'];
+  bleMethod.device = deviceWithoutFeatures as unknown as CheckBLEFirmwareRelease['device'];
+  bootloaderMethod.device = deviceWithoutFeatures as unknown as CheckBootloaderRelease['device'];
+
+  await expect(firmwareMethod.run()).resolves.toBeNull();
+  await expect(bleMethod.run()).resolves.toBeNull();
+  await expect(bootloaderMethod.run()).resolves.toBeNull();
+  expect(deviceWithoutFeatures.isProtocolV2).not.toHaveBeenCalled();
+  expect(deviceWithoutFeatures.getDeviceState).not.toHaveBeenCalled();
+});

package/__tests__/firmware-memory-host.test.ts

@@ -0,0 +1,126 @@
+import { prepareFirmwareUpdateV4MemoryHost } from '../src/api/firmware/FirmwareMemoryHost';
+
+import type { CoreApi } from '../src/types/api';
+import type { FirmwareUpdatePlan } from '../src/types/api/firmwareUpdatePlan';
+
+describe('prepareFirmwareUpdateV4MemoryHost', () => {
+  test('registers artifact-backed component and resource readers', async () => {
+    const componentBinary = new Uint8Array([1, 2, 3, 4]).buffer;
+    const archiveBinary = new Uint8Array([5, 6]).buffer;
+    const manifestBinary = new TextEncoder().encode('{"schema":1}').buffer;
+    let artifactReader: Parameters<
+      CoreApi['registerFirmwareUpdateHostBinding']
+    >[0]['artifactReader'];
+    const unregisterFirmwareUpdateHostBinding = jest.fn();
+    const sdk = {
+      prepareFirmwareUpdatePlan: jest.fn(({ plan, artifacts }) => ({
+        schemaVersion: 2,
+        preparedPlanDigest: 'b'.repeat(64),
+        planDigest: plan.planDigest,
+        networkPolicy: 'forbid',
+        executor: plan.executor,
+        deviceIdentity: plan.deviceIdentity,
+        deviceModel: plan.deviceModel,
+        firmwareType: plan.firmwareType,
+        platform: plan.platform,
+        leaseRef: 'test-lease',
+        targetsToUpdate: plan.targetsToUpdate,
+        artifacts: plan.artifacts.map(planArtifact => {
+          const input = artifacts.find(item => item.artifactId === planArtifact.artifactId);
+          return {
+            ...planArtifact,
+            artifact: input?.artifact,
+            materializedEntries: input?.materializedEntries,
+          };
+        }),
+      })),
+      registerFirmwareUpdateHostBinding: jest.fn(binding => {
+        artifactReader = binding.artifactReader;
+        return 7;
+      }),
+      unregisterFirmwareUpdateHostBinding,
+    } as unknown as Pick<
+      CoreApi,
+      | 'prepareFirmwareUpdatePlan'
+      | 'registerFirmwareUpdateHostBinding'
+      | 'unregisterFirmwareUpdateHostBinding'
+    >;
+    const plan = {
+      schemaVersion: 2,
+      planDigest: 'a'.repeat(64),
+      executor: 'v4',
+      deviceIdentity: 'device-id',
+      deviceModel: 'pro2',
+      firmwareType: 0,
+      platform: 'web',
+      targetsToUpdate: ['boot', 'resource'],
+      artifacts: [
+        {
+          artifactId: 'component:boot',
+          role: 'component',
+          target: 'boot',
+          url: 'https://example.com/boot.okpkg',
+          container: 'raw',
+        },
+        {
+          artifactId: 'resource:archive',
+          role: 'resourceBundle',
+          target: 'resource',
+          url: 'https://example.com/resource.zip',
+          container: 'zip',
+          logicalName: 'resource-archive',
+        },
+      ],
+    } as FirmwareUpdatePlan;
+
+    const host = prepareFirmwareUpdateV4MemoryHost({
+      sdk,
+      plan,
+      artifacts: [
+        { artifactId: 'component:boot', binary: componentBinary },
+        {
+          artifactId: 'resource:archive',
+          binary: archiveBinary,
+          materializedEntries: [{ entryName: 'manifest.json', binary: manifestBinary }],
+        },
+      ],
+    });
+
+    expect(host.hostBindingGeneration).toBe(7);
+    expect(sdk.registerFirmwareUpdateHostBinding).toHaveBeenCalledWith(
+      expect.objectContaining({ preparedPlanDigest: host.preparedPlan.preparedPlanDigest })
+    );
+    const componentArtifact = host.preparedPlan.artifacts.find(
+      artifact => artifact.target === 'boot'
+    )?.artifact;
+    const resourceEntryArtifact = host.preparedPlan.artifacts.find(
+      artifact => artifact.target === 'resource'
+    )?.materializedEntries?.[0]?.artifact;
+    expect(componentArtifact?.size).toBe(componentBinary.byteLength);
+    expect(resourceEntryArtifact?.size).toBe(manifestBinary.byteLength);
+    if (!artifactReader || !componentArtifact || !resourceEntryArtifact) {
+      throw new Error('Firmware memory host test setup is incomplete');
+    }
+    new Uint8Array(componentBinary).fill(9);
+    const opened = await artifactReader.open({
+      artifactRef: componentArtifact.artifactRef,
+    });
+    const chunk = await artifactReader.read({
+      readerId: opened.readerId,
+      offset: 1,
+      length: 2,
+    });
+    expect(Array.from(new Uint8Array(chunk.data))).toEqual([2, 3]);
+    await artifactReader.close({ readerId: opened.readerId });
+
+    // Materialized ZIP entries are receipts only. Execution opens the approved
+    // archive and re-derives these bytes, so the memory host must not retain a
+    // second readable copy of every expanded resource file.
+    expect(() => artifactReader.open({ artifactRef: resourceEntryArtifact.artifactRef })).toThrow(
+      'Firmware memory artifact is unavailable'
+    );
+
+    host.release();
+    expect(unregisterFirmwareUpdateHostBinding).toHaveBeenCalledWith(7);
+  });
+});

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

@@ -9,6 +9,11 @@ import {
 jest.mock('../../src/api/firmware/FirmwareUpdatePreparedPlan', () => ({
   assertFirmwareUpdatePreparedPlanBinding: jest.fn(),
   assertFirmwareUpdatePreparedPlanDeviceIdentity: jest.fn(),
+  clearFirmwareUpdatePreparedPlanDeviceIdentityPin: jest.fn(),
+  getFirmwareUpdatePreparedRawArtifact: jest.fn(
+    ({ preparedPlan }: { preparedPlan: { artifacts: unknown[] } }) => preparedPlan.artifacts[0]
+  ),
+  validateFirmwareUpdatePreparedPlan: jest.fn((preparedPlan: unknown) => preparedPlan),
 }));
 
 jest.mock('../../src/data-manager', () => ({
@@ -36,14 +41,21 @@ const createMethod = () => {
     read: jest.fn(),
     close,
   };
-  const hostBindingGeneration = registerFirmwareUpdateHostBinding({ artifactReader });
+  const hostBindingGeneration = registerFirmwareUpdateHostBinding({
+    artifactReader,
+    preparedPlanDigest: 'a'.repeat(64),
+  });
   const method = new DeviceUpdateBootloader({
     id: 1,
     payload: {
       method: 'deviceUpdateBootloader',
       artifact,
       hostBindingGeneration,
-      preparedPlan: {},
+      preparedPlan: {
+        preparedPlanDigest: 'a'.repeat(64),
+        firmwareType: EFirmwareType.Universal,
+        artifacts: [{ artifact }],
+      },
     },
   });
   (method as any).device = {

package/__tests__/firmware-update/firmware-host-binding.test.ts

@@ -6,6 +6,7 @@ import {
 } from '../../src/api/firmware/FirmwareHostBinding';
 
 const createBinding = () => ({
+  preparedPlanDigest: 'a'.repeat(64),
   artifactReader: {
     open: jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: 4 })),
     read: jest.fn(() =>
@@ -67,4 +68,12 @@ describe('firmware host binding generation', () => {
       readerId: 'stale-reader',
     });
   });
+
+  test('rejects a prepared plan from another host generation before opening artifacts', () => {
+    const generation = registerFirmwareUpdateHostBinding(createBinding());
+
+    expect(() => resolveFirmwareUpdateHostBinding(generation, 'b'.repeat(64))).toThrow(
+      'does not match the prepared plan'
+    );
+  });
 });