@onekeyfe/hd-core 1.2.0-alpha.24 → 1.2.0-alpha.26

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

@@ -0,0 +1,119 @@
+import {
+  MAX_FIRMWARE_ARTIFACT_READ_BYTES,
+  openFirmwareByteSource,
+  writeFirmwareByteSource,
+} from '../../src/api/firmware/FirmwareArtifactSource';
+
+import type { FirmwareArtifactReader } from '../../src/types/api/firmwareUpdate';
+
+const artifact = {
+  artifactRef: `fw:${'a'.repeat(64)}`,
+  size: 6,
+  sha256: 'b'.repeat(64),
+};
+
+const createReader = () => {
+  const open = jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: artifact.size }));
+  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,
+      bytesRead: length,
+      eof: offset + length === artifact.size,
+    })
+  );
+  const close = jest.fn(() => Promise.resolve());
+  const reader: FirmwareArtifactReader = { open, read, close };
+  return { reader, open, read, close };
+};
+
+describe('FirmwareArtifactSource', () => {
+  it('reads an opaque artifact through bounded sequential reads', async () => {
+    const { reader, close } = createReader();
+    const source = await openFirmwareByteSource({ artifact, reader });
+    if (!source) {
+      throw new Error('Expected a firmware byte source');
+    }
+
+    const writes: Array<{ offset: number; data: number[] }> = [];
+    await writeFirmwareByteSource({
+      source,
+      chunkSize: 4,
+      write: ({ data, sourceOffset, length }) => {
+        writes.push({
+          offset: sourceOffset,
+          data: Array.from(new Uint8Array(data)),
+        });
+        return Promise.resolve(length);
+      },
+    });
+    await source.close();
+
+    expect(writes).toEqual([
+      { offset: 0, data: [1, 2, 3, 4] },
+      { offset: 4, data: [5, 6] },
+    ]);
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+  });
+
+  it('rejects a reader whose opened size differs from the receipt', async () => {
+    const { reader, open, close } = createReader();
+    open.mockResolvedValue({
+      readerId: 'reader-1',
+      size: artifact.size + 1,
+    });
+
+    await expect(openFirmwareByteSource({ artifact, reader })).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+      },
+    });
+    expect(close).toHaveBeenCalledWith({ readerId: 'reader-1' });
+  });
+
+  it('rejects paths and over-limit reads before invoking the host', async () => {
+    const { reader, read } = createReader();
+    await expect(
+      openFirmwareByteSource({
+        artifact: { ...artifact, artifactRef: '/tmp/firmware.bin' },
+        reader,
+      })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+      },
+    });
+
+    const source = await openFirmwareByteSource({ artifact, reader });
+    if (!source) {
+      throw new Error('Expected a firmware byte source');
+    }
+    await expect(
+      writeFirmwareByteSource({
+        source,
+        chunkSize: MAX_FIRMWARE_ARTIFACT_READ_BYTES + 1,
+        write: ({ length }) => Promise.resolve(length),
+      })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReadTooLarge',
+      },
+    });
+    expect(read).not.toHaveBeenCalled();
+    await source.close();
+  });
+
+  it('closes stale readers when open returns invalid metadata', async () => {
+    const { reader, open, close } = createReader();
+    open.mockResolvedValue({
+      readerId: '',
+      size: artifact.size,
+    });
+
+    await expect(openFirmwareByteSource({ artifact, reader })).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+      },
+    });
+    expect(close).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,70 @@
+import {
+  getFirmwareUpdateHostBindingGeneration,
+  registerFirmwareUpdateHostBinding,
+  resolveFirmwareUpdateHostBinding,
+  unregisterFirmwareUpdateHostBinding,
+} from '../../src/api/firmware/FirmwareHostBinding';
+
+const createBinding = () => ({
+  artifactReader: {
+    open: jest.fn(() => Promise.resolve({ readerId: 'reader-1', size: 4 })),
+    read: jest.fn(() =>
+      Promise.resolve({
+        data: new ArrayBuffer(4),
+        bytesRead: 4,
+        eof: true,
+      })
+    ),
+    close: jest.fn(() => Promise.resolve()),
+  },
+});
+
+describe('firmware host binding generation', () => {
+  afterEach(() => {
+    unregisterFirmwareUpdateHostBinding();
+  });
+
+  test('invalidates callbacks from a replaced generation', async () => {
+    const staleBinding = createBinding();
+    const staleGeneration = registerFirmwareUpdateHostBinding(staleBinding);
+    const stale = resolveFirmwareUpdateHostBinding(staleGeneration);
+    const activeGeneration = registerFirmwareUpdateHostBinding(createBinding());
+
+    expect(activeGeneration).toBeGreaterThan(staleGeneration);
+    expect(getFirmwareUpdateHostBindingGeneration()).toBe(activeGeneration);
+    await expect(
+      stale.artifactReader.read({
+        readerId: 'reader-1',
+        offset: 0,
+        length: 4,
+      })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
+      },
+    });
+    expect(unregisterFirmwareUpdateHostBinding(staleGeneration)).toBe(false);
+    expect(getFirmwareUpdateHostBindingGeneration()).toBe(activeGeneration);
+  });
+
+  test('closes an artifact opened during a generation race', async () => {
+    const binding = createBinding();
+    binding.artifactReader.open.mockImplementationOnce(() => {
+      registerFirmwareUpdateHostBinding(createBinding());
+      return Promise.resolve({ readerId: 'stale-reader', size: 4 });
+    });
+    const generation = registerFirmwareUpdateHostBinding(binding);
+    const guarded = resolveFirmwareUpdateHostBinding(generation);
+
+    await expect(
+      guarded.artifactReader.open({ artifactRef: `fw:${'a'.repeat(64)}` })
+    ).rejects.toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwareArtifactReaderInvalid',
+      },
+    });
+    expect(binding.artifactReader.close).toHaveBeenCalledWith({
+      readerId: 'stale-reader',
+    });
+  });
+});

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

@@ -0,0 +1,13 @@
+import { getFirmwareUpdateCapabilities } from '../../src/api/firmware/FirmwareUpdateCapabilities';
+
+describe('getFirmwareUpdateCapabilities', () => {
+  it('advertises only the prepared artifact contract', () => {
+    expect(getFirmwareUpdateCapabilities()).toEqual({
+      planSchemaVersion: 2,
+      preparedPlanSchemaVersion: 2,
+      hostBindingProtocolVersion: 2,
+      manifestModes: ['external-only', 'sdk-managed'],
+      supportsArtifactReader: true,
+    });
+  });
+});

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

@@ -0,0 +1,354 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
+
+import type { Features } from '../../src/types';
+
+const createFeatures = ({
+  deviceType,
+  firmwareVersion = '1.0.0',
+  bootloaderVersion = '1.0.0',
+}: {
+  deviceType: EDeviceType;
+  firmwareVersion?: string;
+  bootloaderVersion?: string;
+}) =>
+  ({
+    deviceType,
+    serialNo: `${deviceType}-device-id`,
+    firmwareVersion,
+    bootloaderVersion,
+  } as Features);
+
+const noUpdate = {
+  status: 'valid',
+  release: undefined,
+};
+
+describe('buildFirmwareUpdatePlan', () => {
+  test('selects all legacy artifacts before execution and chooses the desktop full resource', () => {
+    const plan = buildFirmwareUpdatePlan({
+      features: createFeatures({
+        deviceType: EDeviceType.Classic1s,
+        firmwareVersion: '1.0.0',
+      }),
+      firmwareType: EFirmwareType.Universal,
+      platform: 'desktop',
+      firmware: {
+        status: 'outdated',
+        release: {
+          url: 'https://firmware.onekey.so/classic/firmware.bin',
+          expectedSize: 1024,
+          fingerprint: '1111111111111111111111111111111111111111111111111111111111111111',
+          version: [3, 0, 0],
+          resource: 'https://firmware.onekey.so/classic/resource.zip',
+          fullResource: 'https://firmware.onekey.so/classic/full-resource.zip',
+          fullResourceExpectedSize: 4096,
+          fullResourceFingerprint:
+            '2222222222222222222222222222222222222222222222222222222222222222',
+          fullResourceRange: ['2.0.0', '3.0.0'],
+        },
+      },
+      ble: {
+        status: 'outdated',
+        release: {
+          webUpdate: 'https://firmware.onekey.so/classic/ble.bin',
+          expectedSize: 512,
+          fingerprintWeb: '3333333333333333333333333333333333333333333333333333333333333333',
+        },
+      },
+      bootloader: {
+        status: 'outdated',
+        shouldUpdate: true,
+        release: {
+          bootloaderResource: 'https://firmware.onekey.so/classic/bootloader.bin',
+          bootloaderExpectedSize: 768,
+          bootloaderFingerprint: '4444444444444444444444444444444444444444444444444444444444444444',
+          bootloaderVersion: [2, 0, 0],
+        },
+      },
+    });
+
+    expect(plan.executor).toBe('v2');
+    expect(plan.artifacts).toEqual([
+      expect.objectContaining({
+        artifactId: 'bootloader',
+        role: 'bootloader',
+        expectedSize: 768,
+        targetVersion: '2.0.0',
+      }),
+      expect.objectContaining({
+        artifactId: 'firmware',
+        role: 'firmware',
+        expectedSize: 1024,
+        targetVersion: '3.0.0',
+      }),
+      expect.objectContaining({
+        artifactId: 'resource',
+        role: 'resource',
+        url: 'https://firmware.onekey.so/classic/full-resource.zip',
+        expectedSize: 4096,
+      }),
+      expect.objectContaining({
+        artifactId: 'ble',
+        role: 'ble',
+        expectedSize: 512,
+      }),
+    ]);
+    expect(plan.targetsToUpdate).toEqual(['bootloader', 'firmware', 'resource', 'ble']);
+  });
+
+  test('selects V3 for Pro with bootloader 2.8 or newer', () => {
+    const plan = buildFirmwareUpdatePlan({
+      features: createFeatures({
+        deviceType: EDeviceType.Pro,
+        bootloaderVersion: '2.8.0',
+      }),
+      firmwareType: EFirmwareType.BitcoinOnly,
+      platform: 'native',
+      firmware: {
+        status: 'outdated',
+        release: {
+          url: 'https://firmware.onekey.so/pro/firmware.bin',
+          version: [4, 0, 0],
+        },
+      },
+      ble: noUpdate,
+      bootloader: noUpdate,
+    });
+
+    expect(plan.executor).toBe('v3');
+    expect(plan.firmwareType).toBe(EFirmwareType.BitcoinOnly);
+    expect(plan.platform).toBe('native');
+  });
+
+  test('rejects a prepared native plan without a stable device identity', () => {
+    const features = createFeatures({
+      deviceType: EDeviceType.Classic1s,
+    });
+    delete (features as Partial<Features>).serialNo;
+
+    expect(() =>
+      buildFirmwareUpdatePlan({
+        features,
+        firmwareType: EFirmwareType.Universal,
+        platform: 'native',
+        firmware: {
+          status: 'outdated',
+          release: {
+            url: 'https://firmware.onekey.so/classic/firmware.bin',
+          },
+        },
+        ble: noUpdate,
+        bootloader: noUpdate,
+      })
+    ).toThrow('requires a stable device identity');
+  });
+
+  test('maps the Pro2 component order and resource bundles without downloading them', () => {
+    const plan = buildFirmwareUpdatePlan({
+      features: createFeatures({ deviceType: EDeviceType.Pro2 }),
+      firmwareType: EFirmwareType.Universal,
+      platform: 'desktop',
+      firmware: {
+        status: 'required',
+        release: {
+          installOrder: ['bootloader', 'applicationP1'],
+          components: {
+            applicationP1: {
+              target: 'APPLICATION_P1',
+              url: 'https://firmware.onekey.so/pro2/application-p1.bin',
+              expectedSize: 1024,
+              fingerprint: '1111111111111111111111111111111111111111111111111111111111111111',
+            },
+            bootloader: {
+              target: 'BOOTLOADER',
+              url: 'https://firmware.onekey.so/pro2/bootloader.bin',
+            },
+            se01: {
+              target: 'SE01',
+              url: 'https://firmware.onekey.so/pro2/se01.bin',
+            },
+          },
+          resourceBundles: [
+            {
+              name: 'images',
+              url: 'https://firmware.onekey.so/pro2/images.okpkg',
+            },
+          ],
+        },
+      },
+      ble: noUpdate,
+      bootloader: noUpdate,
+    });
+
+    expect(plan.executor).toBe('v4');
+    expect(plan.artifacts.map(artifact => artifact.artifactId)).toEqual([
+      'component:boot',
+      'component:app_v1',
+      'component:se01',
+      'resourceBundle:images',
+    ]);
+    expect(plan.targetsToUpdate).toEqual(['boot', 'app_v1', 'se01', 'resource']);
+    expect(plan.artifacts[1]).toEqual(
+      expect.objectContaining({
+        expectedSize: 1024,
+        expectedSha256: '1111111111111111111111111111111111111111111111111111111111111111',
+      })
+    );
+  });
+
+  test('rejects Pro2 ROMLOADER because it requires a separate loader flow', () => {
+    expect(() =>
+      buildFirmwareUpdatePlan({
+        features: createFeatures({ deviceType: EDeviceType.Pro2 }),
+        firmwareType: EFirmwareType.Universal,
+        platform: 'desktop',
+        firmware: {
+          status: 'required',
+          release: {
+            components: {
+              romloader: {
+                target: 'ROMLOADER',
+                url: 'https://firmware.onekey.so/pro2/romloader.bin',
+              },
+            },
+          },
+        },
+        ble: noUpdate,
+        bootloader: noUpdate,
+      })
+    ).toThrow('ROMLOADER requires its dedicated loader flow');
+  });
+
+  test.each([
+    {
+      label: 'component target',
+      release: {
+        components: {
+          application: {
+            target: 'APPLICATION_P1',
+            url: 'https://firmware.onekey.so/pro2/application.bin',
+          },
+          applicationDuplicate: {
+            target: 'APPLICATION_P1',
+            url: 'https://firmware.onekey.so/pro2/application-duplicate.bin',
+          },
+        },
+      },
+      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({
+        features: createFeatures({ deviceType: EDeviceType.Pro2 }),
+        firmwareType: EFirmwareType.Universal,
+        platform: 'desktop',
+        firmware: {
+          status: 'required',
+          release,
+        },
+        ble: noUpdate,
+        bootloader: noUpdate,
+      })
+    ).toThrow(expectedError);
+  });
+
+  test('produces a deterministic digest and binds it to the platform', () => {
+    const input = {
+      features: createFeatures({ deviceType: EDeviceType.Classic1s }),
+      firmwareType: EFirmwareType.Universal,
+      firmware: noUpdate,
+      ble: noUpdate,
+      bootloader: noUpdate,
+    };
+    const first = buildFirmwareUpdatePlan({ ...input, platform: 'native' });
+    const second = buildFirmwareUpdatePlan({ ...input, platform: 'native' });
+    const desktop = buildFirmwareUpdatePlan({ ...input, platform: 'desktop' });
+
+    expect(first.planDigest).toMatch(/^[a-f0-9]{64}$/);
+    expect(first.planDigest).toBe(second.planDigest);
+    expect(first.planDigest).not.toBe(desktop.planDigest);
+  });
+
+  test('normalizes a malformed artifact URL to FirmwarePlanInvalid', () => {
+    let thrown: unknown;
+    try {
+      buildFirmwareUpdatePlan({
+        features: createFeatures({ deviceType: EDeviceType.Classic1s }),
+        firmwareType: EFirmwareType.Universal,
+        platform: 'native',
+        firmware: {
+          status: 'outdated',
+          release: {
+            url: 'not a url',
+            version: [3, 0, 0],
+          },
+        },
+        ble: noUpdate,
+        bootloader: noUpdate,
+      });
+    } catch (error) {
+      thrown = error;
+    }
+
+    expect(thrown).toMatchObject({
+      params: {
+        firmwareUpdateCode: 'FirmwarePlanInvalid',
+      },
+    });
+  });
+
+  test('binds trusted artifact integrity metadata into the plan digest', () => {
+    const createPlan = (fingerprint: string) =>
+      buildFirmwareUpdatePlan({
+        features: createFeatures({ deviceType: EDeviceType.Classic1s }),
+        firmwareType: EFirmwareType.Universal,
+        platform: 'native',
+        firmware: {
+          status: 'outdated',
+          release: {
+            url: 'https://firmware.onekey.so/classic/firmware.bin',
+            version: [3, 0, 0],
+            expectedSize: 1024,
+            fingerprint,
+          },
+        },
+        ble: noUpdate,
+        bootloader: noUpdate,
+      });
+
+    const first = createPlan('1111111111111111111111111111111111111111111111111111111111111111');
+    const second = createPlan('2222222222222222222222222222222222222222222222222222222222222222');
+
+    expect(first.artifacts[0]).toEqual(
+      expect.objectContaining({
+        expectedSize: 1024,
+        expectedSha256: '1111111111111111111111111111111111111111111111111111111111111111',
+      })
+    );
+    expect(first.planDigest).not.toBe(second.planDigest);
+  });
+});