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

package/src/types/api/checkFirmwareRelease.ts

@@ -1,6 +1,17 @@
+import type { IFirmwareReleaseInfo } from '../settings';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Response } from '../params';
-import type { FirmwareReleaseCheckResult } from './checkAllFirmwareRelease';
+import type { IDeviceFirmwareStatus } from '../device';
+
+type FirmwareRelease = {
+  status: IDeviceFirmwareStatus;
+  changelog: {
+    'en-US': string;
+    'zh-CN': string;
+  }[];
+  release: IFirmwareReleaseInfo;
+  bootloaderMode: boolean;
+};
 
 export type CheckFirmwareReleaseParams = {
   firmwareType?: EFirmwareType;
@@ -9,4 +20,4 @@ export type CheckFirmwareReleaseParams = {
 export declare function checkFirmwareRelease(
   connectId?: string,
   params?: CheckFirmwareReleaseParams
-): Response<FirmwareReleaseCheckResult | null>;
+): Response<FirmwareRelease>;

package/src/types/api/checkFirmwareTypeAvailable.ts

@@ -1,6 +1,6 @@
 import type { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Response } from '../params';
-import type { FirmwareReleaseCheckResult } from './checkAllFirmwareRelease';
+import type { FirmwareRelease } from './checkAllFirmwareRelease';
 
 export type CheckFirmwareTypeAvailableParams = {
   deviceType: EDeviceType;
@@ -9,4 +9,4 @@ export type CheckFirmwareTypeAvailableParams = {
 
 export declare function checkFirmwareTypeAvailable(
   params: CheckFirmwareTypeAvailableParams
-): Response<FirmwareReleaseCheckResult | undefined>;
+): Response<FirmwareRelease | undefined>;

package/src/types/api/export.ts

@@ -50,12 +50,7 @@ export type {
   FirmwareUpdatePreparedPlan,
 } from './firmwareUpdatePreparedPlan';
 export type { FirmwareUpdateCapabilities } from './firmwareUpdateCapabilities';
-export type {
-  AllFirmwareRelease,
-  BridgeReleaseCheckResult,
-  FirmwareReleaseCheckResult,
-  ProtocolV2ComponentReleaseInfo,
-} from './checkAllFirmwareRelease';
+export type { AllFirmwareRelease } from './checkAllFirmwareRelease';
 export type {
   ProtocolV2FirmwareComponentRelease,
   ProtocolV2FirmwareComponentReleaseStatus,

package/src/types/api/firmwareUpdate.ts

@@ -26,8 +26,6 @@ export interface FirmwareArtifactReader {
 
 export interface FirmwareUpdateHostBinding {
   artifactReader: FirmwareArtifactReader;
-  /** 将读取器 generation 绑定到包含 ZIP 条目的完整 PreparedPlan。 */
-  preparedPlanDigest: string;
 }
 
 export interface FirmwareUpdateBinaryParams {
@@ -120,7 +118,6 @@ export interface FirmwareUpdateV3Params {
  */
 export type FirmwareUpdateV4Target =
   | 'boot'
-  /** @deprecated Use resource with resourceArchiveBinary. */
   | 'boot_resources'
   | 'app_v1'
   | 'app_v2'
@@ -133,7 +130,6 @@ export type FirmwareUpdateV4Target =
 
 export interface FirmwareUpdateV4Params {
   preparedPlan?: FirmwareUpdatePreparedPlan;
-  /** Required whenever preparedPlan is present; Core resolves the reader from this digest-bound host. */
   hostBindingGeneration?: number;
   platform: IPlatform;
   expectedDeviceId?: string;
@@ -157,16 +153,26 @@ export interface FirmwareUpdateV4Params {
   se02Binary?: ArrayBuffer;
   se03Binary?: ArrayBuffer;
   se04Binary?: ArrayBuffer;
-  /** Complete Protocol V2 resource ZIP for local development; Core converts it to a local PreparedPlan. */
-  resourceArchiveBinary?: ArrayBuffer;
   forcedUpdateRes?: boolean;
+  /**
+   * Arbitrary Protocol V2 resource files written directly with FilesystemFileWrite.
+   * Use this for manifest-driven boot resources and other non-RESC files.
+   * When provided, these files are authoritative for resource and boot_resources targets.
+   */
+  resourceFiles?: Array<{
+    binary: ArrayBuffer;
+    devicePath: string;
+    size?: number;
+    fileHash?: string;
+  }>;
   artifactReader?: FirmwareArtifactReader;
   componentArtifacts?: Partial<
-    Record<
-      Exclude<FirmwareUpdateV4Target, 'resource' | 'boot_resources'>,
-      FirmwareArtifactReference
-    >
+    Record<Exclude<FirmwareUpdateV4Target, 'resource'>, FirmwareArtifactReference>
   >;
+  resourceBundleArtifacts?: Array<{
+    name: string;
+    artifact: FirmwareArtifactReference;
+  }>;
 }
 
 export declare function registerFirmwareUpdateHostBinding(

package/src/types/settings.ts

@@ -64,44 +64,66 @@ export type IProtocolV2FirmwareComponent = {
   version?: IVersionArray;
 };
 
-export type IProtocolV2ResourceSource = {
-  archiveUrl: string;
-  archiveSha256: string;
-  archiveSize: number;
-};
+export type IProtocolV2ResourceType =
+  | 'images'
+  | 'animation'
+  | 'wallpaper'
+  | 'translations'
+  | 'roobert'
+  | 'noto'
+  | 'firmware_logo';
 
-export type IProtocolV2Resources = {
-  source: IProtocolV2ResourceSource;
+/** Pro2 RES package descriptor. Hashes identify content without a human-managed version. */
+export type IProtocolV2Resource = {
+  type: IProtocolV2ResourceType;
+  url: string;
+  /** Complete okpkg file size in bytes. */
+  size: number;
+  /** SHA-256 of the complete okpkg file. */
+  fileHash: string;
+  /** SHA3-512 header_hash from the signed okpkg header. */
+  headerHash: string;
 };
 
-export type IProtocolV2ResourceManifestFile = {
-  archive_path: string;
-  original_name: string;
-  device_path: string;
+/** A file from the Protocol V2 resource manifest, written directly with FileWrite. */
+export type IProtocolV2ResourceFile = {
+  name?: string;
+  url: string;
+  devicePath: string;
   size: number;
-  sha256: string;
-  signed: true;
-  sig_algo: 'ed25519' | 'mldsa65';
-  payload_version: string | null;
+  /** SHA-256 of the complete file. */
+  fileHash: string;
+};
+
+/** Optional Protocol V2 boot resources restored as individual files. */
+export type IProtocolV2BootResources = {
+  required: false;
+  target: 'RES';
+  manifestUrl?: string;
+  files: IProtocolV2ResourceFile[];
+};
+
+export type IProtocolV2Resources = {
+  stable: IProtocolV2Resource[];
+  boot?: IProtocolV2BootResources;
 };
 
-export type IProtocolV2ResourceManifest = {
-  schema: 1;
-  artifact_name: string;
-  release_name: string;
-  variant: 'resource';
-  commit: string;
-  short_sha: string;
-  timestamp_utc: string;
-  core_version: string;
-  key_set: string;
-  device_root: 'vol0:';
-  restore_mode: 'bootloader_update';
-  trees: Array<{
-    path: string;
-    device: string;
-  }>;
-  files: IProtocolV2ResourceManifestFile[];
+/** Pro2 RESC bundle okpkg descriptor for incremental FileWrite synchronization. */
+export type IProtocolV2ResourceBundle = {
+  /** Bundle name, such as images, animation, translations, or fonts_roobert. */
+  name: string;
+  /** Download URL. */
+  url: string;
+  fingerprint?: string;
+  expectedSize?: number;
+  /** Device target path, such as vol0:/bundles/images/images.okpkg. */
+  devicePath: string;
+  /** okpkg payload_version used to skip matching content after FileRead. */
+  version?: IVersionArray;
+  /** okpkg payload_hash used for SHA3-512 comparison after FileRead. */
+  payloadHash?: string;
+  /** okpkg header_hash used for SHA3-512 comparison after FileRead. */
+  headerHash?: string;
 };
 
 /** STM32 firmware config */
@@ -131,6 +153,8 @@ export type IFirmwareReleaseInfo = {
   upgradeType?: 'payload-package-set' | string;
   components?: Record<string, IProtocolV2FirmwareComponent>;
   installOrder?: string[];
+  /** Pro2 RESC bundles for incremental direct FileWrite synchronization. */
+  resourceBundles?: IProtocolV2ResourceBundle[];
   bootloaderChangelog?: {
     [k in ILocale]: string;
   };
@@ -159,20 +183,22 @@ export type IBLEFirmwareReleaseInfo = {
 };
 
 type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
+type ILegacyKnownDevice = Exclude<IKnownDevice, 'neo'>;
+
 type IDeviceReleaseInfo = {
-  firmware?: IFirmwareReleaseInfo[];
+  firmware: IFirmwareReleaseInfo[];
   /** Protocol V2 payload package set */
   'firmware-v1'?: IFirmwareReleaseInfo[];
   'firmware-v2'?: IFirmwareReleaseInfo[];
   'firmware-v8'?: IFirmwareReleaseInfo[];
   'firmware-btc-v8'?: IFirmwareReleaseInfo[];
-  ble?: IBLEFirmwareReleaseInfo[];
+  ble: IBLEFirmwareReleaseInfo[];
   /** Independent Protocol V2 resource release configuration. */
   resources?: IProtocolV2Resources;
 };
 
 export type DeviceTypeMap = {
-  [k in Exclude<IKnownDevice, 'neo'>]: IDeviceReleaseInfo;
+  [k in ILegacyKnownDevice]: IDeviceReleaseInfo;
 } & {
   /** Optional until every remote-config producer publishes a Neo entry. */
   neo?: IDeviceReleaseInfo;

package/src/utils/deviceFeaturesUtils.ts

@@ -328,7 +328,7 @@ export const getFirmwareUpdateField = ({
   if (deviceType === EDeviceType.Pro) {
     return latestFirmwareField;
   }
-  if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) {
+  if (deviceType === EDeviceType.Pro2) {
     return 'firmware-v1';
   }
   return 'firmware';
@@ -374,7 +374,7 @@ export const getFirmwareUpdateFieldArray = (
     return ['firmware-v8'];
   }
 
-  if (deviceType === 'pro2' || deviceType === 'neo') {
+  if (deviceType === 'pro2') {
     return ['firmware-v1'];
   }
 

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

@@ -1,199 +0,0 @@
-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'],
-      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

@@ -1,112 +0,0 @@
-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;
-    expect(componentArtifact?.size).toBe(componentBinary.byteLength);
-    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 });
-
-    host.release();
-    expect(unregisterFirmwareUpdateHostBinding).toHaveBeenCalledWith(7);
-  });
-});