@onekeyfe/hd-core 1.1.34-alpha.3 → 1.1.34-alpha.4

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

@@ -1,358 +0,0 @@
-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.epochs).toEqual([
-      {
-        epoch: 0,
-        kind: 'resource-sync',
-        artifactIds: ['resourceBundle:images'],
-        targets: ['resource'],
-      },
-      {
-        epoch: 1,
-        kind: 'bootloader-install',
-        artifactIds: ['component:boot'],
-        targets: ['boot'],
-      },
-      {
-        epoch: 2,
-        kind: 'bootloader-verify',
-        artifactIds: [],
-        targets: ['boot'],
-      },
-      {
-        epoch: 3,
-        kind: 'component-install',
-        artifactIds: ['component:app_v1', 'component:se01'],
-        targets: ['app_v1', 'se01'],
-      },
-      {
-        epoch: 4,
-        kind: 'final-verify',
-        artifactIds: [],
-        targets: ['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('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);
-  });
-});

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

@@ -1,200 +0,0 @@
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
-
-import { buildFirmwareUpdatePlan } from '../../src/api/firmware/FirmwareUpdatePlan';
-import {
-  assertFirmwareUpdatePreparedPlanBinding,
-  prepareFirmwareUpdatePlan,
-  validateFirmwareUpdatePreparedPlan,
-} from '../../src/api/firmware/FirmwareUpdatePreparedPlan';
-
-import type { Features } from '../../src/types';
-
-const buildPlan = () =>
-  buildFirmwareUpdatePlan({
-    features: {
-      deviceType: EDeviceType.Classic1s,
-      serialNo: 'classic1s-device-id',
-      firmwareVersion: '1.0.0',
-      bootloaderVersion: '1.0.0',
-    } as Features,
-    firmwareType: EFirmwareType.Universal,
-    platform: 'native',
-    firmware: {
-      status: 'outdated',
-      release: {
-        url: 'https://firmware.onekey.so/classic/firmware.bin',
-        expectedSize: 4,
-        fingerprint: 'a'.repeat(64),
-        version: [3, 0, 0],
-        resource: 'https://firmware.onekey.so/classic/resource.zip',
-        resourceExpectedSize: 8,
-        resourceFingerprint: 'b'.repeat(64),
-      },
-    },
-    ble: {
-      status: 'valid',
-      release: undefined,
-    },
-    bootloader: {
-      status: 'valid',
-      release: undefined,
-    },
-  });
-
-const artifact = (sha256: string, size: number) => ({
-  artifactRef: `fw:${sha256}`,
-  size,
-  sha256,
-});
-
-describe('FirmwareUpdatePreparedPlan', () => {
-  test('binds all receipts into a URL-free, network-forbidden plan', () => {
-    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),
-            },
-          ],
-        },
-      ],
-    });
-
-    expect(prepared.networkPolicy).toBe('forbid');
-    expect(prepared.planDigest).toBe(plan.planDigest);
-    expect(prepared.preparedPlanDigest).toMatch(/^[a-f0-9]{64}$/u);
-    expect(JSON.stringify(prepared)).not.toContain('https://');
-    expect(validateFirmwareUpdatePreparedPlan(prepared)).toEqual(prepared);
-    expect(
-      assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan: prepared,
-        executor: 'v2',
-        platform: 'native',
-        scopeTargets: ['firmware', 'resource'],
-        bindings: [
-          {
-            target: 'firmware',
-            artifact: artifact('a'.repeat(64), 4),
-          },
-          {
-            target: 'resource',
-            entryName: 'resource/index.bin',
-            artifact: artifact('c'.repeat(64), 2),
-          },
-        ],
-      })
-    ).toEqual(prepared);
-    expect(() =>
-      assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan: prepared,
-        executor: 'v2',
-        platform: 'native',
-        scopeTargets: ['firmware'],
-        bindings: [
-          {
-            target: 'firmware',
-            artifact: artifact('b'.repeat(64), 8),
-          },
-        ],
-      })
-    ).toThrow('artifact binding is invalid');
-  });
-
-  test('rejects receipt drift and a tampered update plan digest', () => {
-    const plan = buildPlan();
-    expect(() =>
-      prepareFirmwareUpdatePlan({
-        plan,
-        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
-        artifacts: [
-          {
-            artifactId: 'firmware',
-            artifact: artifact('d'.repeat(64), 4),
-          },
-          {
-            artifactId: 'resource',
-            artifact: artifact('b'.repeat(64), 8),
-            materializedEntries: [
-              {
-                entryName: 'resource/index.bin',
-                artifact: artifact('c'.repeat(64), 2),
-              },
-            ],
-          },
-        ],
-      })
-    ).toThrow('receipt does not match');
-
-    expect(() =>
-      prepareFirmwareUpdatePlan({
-        plan: { ...plan, planDigest: 'f'.repeat(64) },
-        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
-        artifacts: [],
-      })
-    ).toThrow('plan digest is invalid');
-  });
-
-  test('projects portable archive paths to unique device resource names', () => {
-    const plan = buildPlan();
-    const buildArtifacts = (entryNames: string[]) => [
-      {
-        artifactId: 'firmware',
-        artifact: artifact('a'.repeat(64), 4),
-      },
-      {
-        artifactId: 'resource',
-        artifact: artifact('b'.repeat(64), 8),
-        materializedEntries: entryNames.map((entryName, index) => ({
-          entryName,
-          artifact: artifact(String(index + 1).repeat(64), 2),
-        })),
-      },
-    ];
-
-    expect(() =>
-      prepareFirmwareUpdatePlan({
-        plan,
-        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
-        artifacts: buildArtifacts(['icons/index.bin', 'fonts/index.bin']),
-      })
-    ).toThrow('duplicate entry names');
-    expect(() =>
-      prepareFirmwareUpdatePlan({
-        plan,
-        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
-        artifacts: buildArtifacts(['../index.bin']),
-      })
-    ).toThrow('entry name is invalid');
-  });
-
-  test('rejects unknown fields even when a caller presents a plan-shaped object', () => {
-    const plan = buildPlan();
-    expect(() =>
-      prepareFirmwareUpdatePlan({
-        plan: {
-          ...plan,
-          artifacts: [
-            {
-              ...plan.artifacts[0],
-              unexpectedUrl: 'https://attacker.invalid/payload',
-            },
-            plan.artifacts[1],
-          ],
-        } as typeof plan,
-        leaseRef: 'fwlease:00000000-0000-4000-8000-000000000001',
-        artifacts: [],
-      })
-    ).toThrow('invalid field set');
-  });
-});

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

@@ -1,81 +0,0 @@
-import { EFirmwareType } from '@onekeyfe/hd-shared';
-
-import FirmwareUpdateV3 from '../../src/api/FirmwareUpdateV3';
-import { FirmwareCheckpointWriter } from '../../src/api/firmware/FirmwareCheckpoint';
-
-jest.mock('../../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-const createMethod = ({ firmwareVersion }: { firmwareVersion: string }) => {
-  const checkpoints: unknown[] = [];
-  const method = new FirmwareUpdateV3({
-    id: 1,
-    payload: {
-      method: 'firmwareUpdateV3',
-      platform: 'desktop',
-      firmwareVersion: [4, 10, 0],
-      firmwareType: EFirmwareType.Universal,
-      checkpointSequenceStart: 1,
-      resumeCheckpoint: {
-        schemaVersion: 1,
-        sequence: 1,
-        stage: 'INSTALL_ACCEPTED',
-        destructiveActionStarted: true,
-        target: 'firmware',
-      },
-      checkpointSink: {
-        commit(checkpoint) {
-          checkpoints.push(checkpoint);
-          return Promise.resolve();
-        },
-      },
-    },
-  });
-  method.init();
-  (method as any).checkpointWriter = new FirmwareCheckpointWriter((method as any).params, {
-    required: true,
-  });
-  const features = {
-    firmwareVersion,
-    bootloaderVersion: '2.8.0',
-    bleVersion: '1.0.0',
-    firmwareType: EFirmwareType.Universal,
-    capabilities: [],
-  };
-  return { checkpoints, features, method };
-};
-
-describe('firmware recovery reconciliation', () => {
-  it('finishes an acknowledged V3 install only after expected versions match', async () => {
-    const { checkpoints, features, method } = createMethod({
-      firmwareVersion: '4.10.0',
-    });
-
-    await expect((method as any).reconcileInterruptedInstall(features)).resolves.toEqual({
-      bootloaderVersion: '2.8.0',
-      bleVersion: '1.0.0',
-      firmwareVersion: '4.10.0',
-    });
-    expect(checkpoints).toEqual([
-      expect.objectContaining({
-        sequence: 2,
-        stage: 'FINAL_VERIFIED',
-      }),
-    ]);
-  });
-
-  it('never resends an ambiguous V3 install when versions cannot reconcile it', async () => {
-    const { checkpoints, features, method } = createMethod({
-      firmwareVersion: '4.9.0',
-    });
-
-    await expect((method as any).reconcileInterruptedInstall(features)).rejects.toMatchObject({
-      params: {
-        firmwareUpdateCode: 'FirmwareReconciliationUnavailable',
-      },
-    });
-    expect(checkpoints).toEqual([]);
-  });
-});

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

@@ -1,70 +0,0 @@
-import { EDeviceType } from '@onekeyfe/hd-shared';
-
-import { uploadFirmwareFromSource } from '../../src/api/firmware/uploadFirmware';
-
-import type { Device } from '../../src/device/Device';
-import type { FirmwareByteSource } from '../../src/api/firmware/FirmwareArtifactSource';
-
-jest.mock('../../src/data/config', () => ({
-  getSDKVersion: jest.fn(() => '1.0.0'),
-  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
-}));
-
-describe('uploadFirmwareFromSource', () => {
-  it('serves legacy Touch firmware requests without materializing the complete artifact', async () => {
-    const size = 700 * 1024;
-    const requestedRanges: Array<{ offset: number; length: number }> = [];
-    const source: FirmwareByteSource = {
-      size,
-      readAt: jest.fn((offset: number, length: number) => {
-        requestedRanges.push({ offset, length });
-        return Promise.resolve(new ArrayBuffer(length));
-      }),
-      close: jest.fn(() => Promise.resolve()),
-    };
-    let nextOffset = 0;
-    const requestedLength = 128 * 1024;
-    const typedCall = jest.fn((type: string) => {
-      if (type === 'FirmwareErase') {
-        return Promise.resolve({
-          type: 'FirmwareRequest',
-          message: {
-            offset: nextOffset,
-            length: Math.min(requestedLength, size - nextOffset),
-          },
-        });
-      }
-      if (type === 'FirmwareUpload') {
-        nextOffset += Math.min(requestedLength, size - nextOffset);
-        if (nextOffset < size) {
-          return Promise.resolve({
-            type: 'FirmwareRequest',
-            message: {
-              offset: nextOffset,
-              length: Math.min(requestedLength, size - nextOffset),
-            },
-          });
-        }
-        return Promise.resolve({
-          type: 'Success',
-          message: { message: 'installed' },
-        });
-      }
-      return Promise.reject(new Error(`Unexpected command: ${type}`));
-    });
-    const device = {
-      features: undefined,
-      emit: jest.fn(),
-      getCurrentDeviceType: () => EDeviceType.Touch,
-      toMessageObject: () => ({}),
-    } as unknown as Device;
-
-    await expect(
-      uploadFirmwareFromSource('firmware', typedCall as never, jest.fn(), device, source)
-    ).resolves.toEqual({ message: 'installed' });
-
-    expect(requestedRanges).toHaveLength(Math.ceil(size / requestedLength));
-    expect(requestedRanges.every(({ length }) => length <= 256 * 1024)).toBe(true);
-    expect(requestedRanges.some(({ length }) => length === size)).toBe(false);
-  });
-});