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

package/src/protocols/protocol-v2/resources.ts

@@ -1,210 +1,16 @@
-import { sha256 } from '@noble/hashes/sha256';
-import { PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE } from '@onekeyfe/hd-transport';
-
 import type {
-  IProtocolV2BootResources,
-  IProtocolV2Resource,
-  IProtocolV2ResourceFile,
-  IProtocolV2ResourceType,
+  IProtocolV2ResourceManifest,
+  IProtocolV2ResourceManifestFile,
   IProtocolV2Resources,
 } from '../../types';
-import type { DeviceCommands } from '../../device/DeviceCommands';
-
-export const PROTOCOL_V2_RESOURCE_TYPES = [
-  'images',
-  'animation',
-  'wallpaper',
-  'translations',
-  'roobert',
-  'noto',
-  'firmware_logo',
-] as const satisfies readonly IProtocolV2ResourceType[];
+import type { FirmwareUpdateV4Target } from '../../types/api/firmwareUpdate';
 
-export const PROTOCOL_V2_RESOURCE_DEVICE_PATHS: Readonly<Record<IProtocolV2ResourceType, string>> =
-  {
-    images: 'vol0:/bundles/images/images.okpkg',
-    animation: 'vol0:/bundles/images/animation.okpkg',
-    wallpaper: 'vol0:/bundles/images/wallpaper.okpkg',
-    translations: 'vol0:/bundles/translations/translations.okpkg',
-    roobert: 'vol0:/bundles/font/roobert.okpkg',
-    noto: 'vol0:/bundles/font/noto.okpkg',
-    firmware_logo: 'vol0:/bundles/firmware_logo.okpkg',
-  };
+export const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH =
+  'vol0:/loaders/bootloader/boot_resource.okpkg';
+export const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH = `${PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH}.staging`;
+export const PROTOCOL_V2_ROM_PARAMS_PACKAGE_PATH = 'vol0:/loaders/rom/params.okpkg';
 
-const RESOURCE_TYPE_SET = new Set<string>(PROTOCOL_V2_RESOURCE_TYPES);
 const SHA256_HEX_LENGTH = 64;
-const SHA3_512_HEX_LENGTH = 128;
-const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
-const PROTOCOL_V2_OKPP_TYPE_OFFSET = 0x08;
-const PROTOCOL_V2_OKPP_HEADER_LENGTH_OFFSET = 0x0c;
-const PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET = 0x240;
-const PROTOCOL_V2_OKPP_HASH_SIZE = 64;
-const PROTOCOL_V2_RESOURCE_IDENTITY_READ_SIZE =
-  PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET + PROTOCOL_V2_OKPP_HASH_SIZE;
-const PROTOCOL_V2_MIN_FILE_READ_CHUNK_SIZE = 64;
-export const PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS = 5 * 1000;
-
-export type ProtocolV2ResourceInventoryItem = {
-  type: IProtocolV2ResourceType;
-  size: number;
-  headerHash: string;
-};
-
-export type ProtocolV2ResourceUpdateMode = 'application' | 'bootloader-recovery';
-
-export type ProtocolV2ResourceUpdatePlan = {
-  status: 'valid' | 'outdated' | 'unknown';
-  resources: IProtocolV2Resource[];
-};
-
-function toFiniteNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value === 'string') {
-    const numeric = Number(value);
-    return Number.isFinite(numeric) ? numeric : undefined;
-  }
-  if (value && typeof value === 'object') {
-    const longLike = value as { toNumber?: () => number };
-    if (typeof longLike.toNumber === 'function') {
-      const numeric = longLike.toNumber();
-      return Number.isFinite(numeric) ? numeric : undefined;
-    }
-  }
-  return undefined;
-}
-
-function toUint8Array(value: unknown): Uint8Array {
-  if (value instanceof Uint8Array) return value;
-  if (value instanceof ArrayBuffer) return new Uint8Array(value);
-  if (ArrayBuffer.isView(value)) {
-    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-  }
-  if (typeof value === 'string') {
-    const hex = value.replace(/^0x/i, '');
-    if (!hex || hex.length % 2 !== 0 || /[^0-9a-f]/i.test(hex)) {
-      return new Uint8Array(0);
-    }
-    const bytes = new Uint8Array(hex.length / 2);
-    for (let index = 0; index < bytes.length; index += 1) {
-      bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
-    }
-    return bytes;
-  }
-  return new Uint8Array(0);
-}
-
-function readAscii(bytes: Uint8Array, offset: number, length: number): string {
-  return Array.from(bytes.slice(offset, offset + length), byte => String.fromCharCode(byte)).join(
-    ''
-  );
-}
-
-function parseProtocolV2ResourceHeaderHash(bytes: Uint8Array): string | undefined {
-  if (bytes.byteLength < PROTOCOL_V2_RESOURCE_IDENTITY_READ_SIZE) return undefined;
-  if (readAscii(bytes, 0, 4) !== 'OKPP') return undefined;
-  if (readAscii(bytes, PROTOCOL_V2_OKPP_TYPE_OFFSET, 4) !== 'RESC') return undefined;
-
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  if (
-    view.getUint32(PROTOCOL_V2_OKPP_HEADER_LENGTH_OFFSET, true) !== PROTOCOL_V2_OKPP_HEADER_SIZE
-  ) {
-    return undefined;
-  }
-  return bytesToHex(
-    bytes.slice(
-      PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET,
-      PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET + PROTOCOL_V2_OKPP_HASH_SIZE
-    )
-  );
-}
-
-async function readProtocolV2ResourceIdentity({
-  commands,
-  resource,
-  chunkSize,
-  timeoutMs = PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS,
-}: {
-  commands: Pick<DeviceCommands, 'typedCall'>;
-  resource: IProtocolV2Resource;
-  chunkSize: number;
-  timeoutMs?: number;
-}): Promise<ProtocolV2ResourceInventoryItem | undefined> {
-  const path = PROTOCOL_V2_RESOURCE_DEVICE_PATHS[resource.type];
-  const pathInfo = await commands.typedCall(
-    'FilesystemPathInfoQuery',
-    'FilesystemPathInfo',
-    { path },
-    { timeoutMs }
-  );
-  const size = toFiniteNumber(pathInfo.message?.size);
-  if (
-    !pathInfo.message?.exist ||
-    pathInfo.message?.directory ||
-    !Number.isSafeInteger(size) ||
-    size !== resource.size ||
-    size < PROTOCOL_V2_OKPP_HEADER_SIZE
-  ) {
-    return undefined;
-  }
-
-  const header = new Uint8Array(PROTOCOL_V2_RESOURCE_IDENTITY_READ_SIZE);
-  let offset = 0;
-  while (offset < header.byteLength) {
-    const readLength = Math.min(chunkSize, header.byteLength - offset);
-    const response = await commands.typedCall(
-      'FilesystemFileRead',
-      'FilesystemFile',
-      {
-        file: { path, offset, total_size: 0 },
-        chunk_len: readLength,
-      },
-      { timeoutMs }
-    );
-    const data = toUint8Array(response.message?.data);
-    if (data.byteLength === 0) return undefined;
-    const copied = Math.min(data.byteLength, header.byteLength - offset);
-    header.set(data.subarray(0, copied), offset);
-    offset += copied;
-  }
-
-  const headerHash = parseProtocolV2ResourceHeaderHash(header);
-  return headerHash ? { type: resource.type, size, headerHash } : undefined;
-}
-
-/**
- * 使用已发布 Pro2 固件支持的文件系统消息构建资源清单。
- * 缺失、无法读取或格式错误的文件不会进入清单，因此会被选中重写。
- */
-export async function readProtocolV2ResourceInventory({
-  commands,
-  resources,
-  chunkSize = PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE,
-  timeoutMs = PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS,
-}: {
-  commands: Pick<DeviceCommands, 'typedCall'>;
-  resources: readonly IProtocolV2Resource[];
-  chunkSize?: number;
-  timeoutMs?: number;
-}): Promise<ProtocolV2ResourceInventoryItem[]> {
-  const normalizedChunkSize = Number.isFinite(chunkSize)
-    ? Math.max(Math.floor(chunkSize), PROTOCOL_V2_MIN_FILE_READ_CHUNK_SIZE)
-    : PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE;
-  const inventory: ProtocolV2ResourceInventoryItem[] = [];
-  for (const resource of resources) {
-    try {
-      const item = await readProtocolV2ResourceIdentity({
-        commands,
-        resource,
-        chunkSize: normalizedChunkSize,
-        timeoutMs,
-      });
-      if (item) inventory.push(item);
-    } catch {
-      // 单个资源无法读取时按缺失处理，不阻断其余资源的增量检查。
-    }
-  }
-  return inventory;
-}
 
 function normalizeHex(value: unknown, expectedLength: number, field: string): string {
   if (typeof value !== 'string') {
@@ -219,176 +25,186 @@ function normalizeHex(value: unknown, expectedLength: number, field: string): st
   return normalized;
 }
 
-function validateResource(value: unknown, index: number): IProtocolV2Resource {
+/** Validate a complete Pro2 stable resource set from remote configuration. */
+export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources | undefined {
+  if (value === undefined) return undefined;
   if (!value || typeof value !== 'object') {
-    throw new Error(`Invalid Pro2 resource at stable[${index}]`);
+    throw new Error('Invalid Pro2 resources config');
   }
-  const resource = value as Partial<IProtocolV2Resource>;
-  if (typeof resource.type !== 'string' || !RESOURCE_TYPE_SET.has(resource.type)) {
-    throw new Error(`Invalid Pro2 resource type at stable[${index}]`);
+  const { source } = value as { source?: unknown };
+  if (!source || typeof source !== 'object') {
+    throw new Error('Invalid Pro2 resources config: source is required');
   }
-  if (typeof resource.url !== 'string' || !resource.url.startsWith('https://')) {
-    throw new Error(`Invalid Pro2 resource url at stable[${index}]`);
+  const { archiveUrl, archiveSha256, archiveSize } = source as {
+    archiveUrl?: unknown;
+    archiveSha256?: unknown;
+    archiveSize?: unknown;
+  };
+  if (typeof archiveUrl !== 'string' || !archiveUrl.startsWith('https://')) {
+    throw new Error('Invalid Pro2 resources config: source.archiveUrl must use HTTPS');
+  }
+  if (typeof archiveSha256 !== 'string' || !/^[0-9a-fA-F]{64}$/.test(archiveSha256)) {
+    throw new Error('Invalid Pro2 resources config: source.archiveSha256 must be a SHA-256 digest');
   }
-  if (!Number.isSafeInteger(resource.size) || Number(resource.size) <= 0) {
-    throw new Error(`Invalid Pro2 resource size at stable[${index}]`);
+  if (!Number.isSafeInteger(archiveSize) || (archiveSize as number) <= 0) {
+    throw new Error('Invalid Pro2 resources config: source.archiveSize must be a positive integer');
   }
   return {
-    type: resource.type,
-    url: resource.url,
-    size: Number(resource.size),
-    fileHash: normalizeHex(resource.fileHash, SHA256_HEX_LENGTH, 'fileHash'),
-    headerHash: normalizeHex(resource.headerHash, SHA3_512_HEX_LENGTH, 'headerHash'),
+    source: {
+      archiveUrl,
+      archiveSha256: archiveSha256.toLowerCase(),
+      archiveSize: archiveSize as number,
+    },
   };
 }
 
-function validateBootResources(value: unknown): IProtocolV2BootResources {
-  if (!value || typeof value !== 'object') {
-    throw new Error('Invalid Pro2 boot resources config');
-  }
-  const resource = value as Partial<IProtocolV2BootResources>;
-  if (resource.required !== false) {
-    throw new Error('Invalid Pro2 boot resources required flag: expected false');
-  }
-  if (resource.target !== 'RES') {
-    throw new Error('Invalid Pro2 boot resources target: expected RES');
-  }
+const PROTOCOL_V2_RESOURCE_MANIFEST_DEVICE_ROOTS = [
+  'vol0:/bundles/',
+  'vol0:/loaders/rom/',
+] as const;
+
+function isAllowedManifestDevicePath(path: string): boolean {
   if (
-    resource.manifestUrl !== undefined &&
-    (typeof resource.manifestUrl !== 'string' || !resource.manifestUrl.startsWith('https://'))
+    !path.endsWith('.okpkg') ||
+    path.includes('\\') ||
+    path.includes('//') ||
+    path.split('/').some(part => part === '.' || part === '..')
   ) {
-    throw new Error('Invalid Pro2 boot resources manifestUrl');
+    return false;
   }
-  if (!Array.isArray(resource.files) || resource.files.length === 0) {
-    throw new Error('Invalid Pro2 boot resources files');
+  if (path === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH) {
+    return true;
   }
-  const files = resource.files.map((value, index): IProtocolV2ResourceFile => {
-    if (!value || typeof value !== 'object') {
-      throw new Error(`Invalid Pro2 boot resource file at files[${index}]`);
-    }
-    const file = value as Partial<IProtocolV2ResourceFile>;
-    if (typeof file.url !== 'string' || !file.url.startsWith('https://')) {
-      throw new Error(`Invalid Pro2 boot resource url at files[${index}]`);
-    }
-    if (
-      typeof file.devicePath !== 'string' ||
-      !file.devicePath.startsWith('vol0:/') ||
-      file.devicePath.includes('..') ||
-      file.devicePath.includes('\\')
-    ) {
-      throw new Error(`Invalid Pro2 boot resource devicePath at files[${index}]`);
-    }
-    if (!Number.isSafeInteger(file.size) || Number(file.size) <= 0) {
-      throw new Error(`Invalid Pro2 boot resource size at files[${index}]`);
-    }
-    return {
-      ...(typeof file.name === 'string' && file.name ? { name: file.name } : undefined),
-      url: file.url,
-      devicePath: file.devicePath,
-      size: Number(file.size),
-      fileHash: normalizeHex(file.fileHash, SHA256_HEX_LENGTH, `boot files[${index}].fileHash`),
-    };
-  });
-  if (new Set(files.map(file => file.devicePath)).size !== files.length) {
-    throw new Error('Invalid Pro2 boot resources files: duplicate devicePath');
+  return PROTOCOL_V2_RESOURCE_MANIFEST_DEVICE_ROOTS.some(root => path.startsWith(root));
+}
+
+function assertManifestString(value: unknown, field: string): string {
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`Invalid Pro2 resource manifest ${field}`);
   }
-  return {
-    required: false,
-    target: 'RES',
-    ...(resource.manifestUrl ? { manifestUrl: resource.manifestUrl } : undefined),
-    files,
-  };
+  return value;
 }
 
-/** Validate a complete Pro2 stable resource set from remote configuration. */
-export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources | undefined {
-  if (value === undefined) return undefined;
+function assertManifestRelativePath(value: unknown, field: string): string {
+  const path = assertManifestString(value, field);
   if (
-    !value ||
-    typeof value !== 'object' ||
-    !Array.isArray((value as { stable?: unknown }).stable)
+    path.startsWith('/') ||
+    path.includes('\\') ||
+    path.includes(':') ||
+    path.split('/').some(part => !part || part === '.' || part === '..')
   ) {
-    throw new Error('Invalid Pro2 resources config: stable must be an array');
+    throw new Error(`Invalid Pro2 resource manifest ${field}`);
   }
+  return path;
+}
 
-  const config = value as { stable: unknown[]; boot?: unknown };
-  const stable = config.stable.map(validateResource);
-  const types = new Set(stable.map(resource => resource.type));
-  if (stable.length !== PROTOCOL_V2_RESOURCE_TYPES.length || types.size !== stable.length) {
-    throw new Error(
-      `Invalid Pro2 resources config: stable must contain ${PROTOCOL_V2_RESOURCE_TYPES.length} unique resource types`
-    );
+function parseProtocolV2ResourceManifestFile(
+  value: unknown,
+  index: number
+): IProtocolV2ResourceManifestFile {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}]`);
+  }
+  const file = value as Partial<IProtocolV2ResourceManifestFile>;
+  const archivePath = assertManifestRelativePath(file.archive_path, `files[${index}].archive_path`);
+  const originalName = assertManifestRelativePath(
+    file.original_name,
+    `files[${index}].original_name`
+  );
+  if (originalName.includes('/')) {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}].original_name`);
+  }
+  const devicePath = assertManifestString(file.device_path, `files[${index}].device_path`);
+  if (!isAllowedManifestDevicePath(devicePath)) {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}].device_path`);
+  }
+  if (!Number.isSafeInteger(file.size) || Number(file.size) <= 0) {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}].size`);
   }
-  for (const type of PROTOCOL_V2_RESOURCE_TYPES) {
-    if (!types.has(type)) {
-      throw new Error(`Invalid Pro2 resources config: stable is missing ${type}`);
-    }
+  const digest = normalizeHex(file.sha256, SHA256_HEX_LENGTH, `files[${index}].sha256`);
+  if (file.signed !== true) {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}].signed`);
+  }
+  if (file.sig_algo !== 'ed25519' && file.sig_algo !== 'mldsa65') {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}].sig_algo`);
+  }
+  if (file.payload_version !== null && typeof file.payload_version !== 'string') {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}].payload_version`);
+  }
+  if (!archivePath.endsWith('.okpkg') || !originalName.endsWith('.okpkg')) {
+    throw new Error(`Invalid Pro2 resource manifest files[${index}] package extension`);
   }
-  const boot = config.boot === undefined ? undefined : validateBootResources(config.boot);
   return {
-    stable: PROTOCOL_V2_RESOURCE_TYPES.map(type => {
-      const resource = stable.find(item => item.type === type);
-      if (!resource) {
-        throw new Error(`Invalid Pro2 resources config: stable is missing ${type}`);
-      }
-      return resource;
-    }),
-    ...(boot ? { boot } : undefined),
+    archive_path: archivePath,
+    original_name: originalName,
+    device_path: devicePath,
+    size: Number(file.size),
+    sha256: digest,
+    signed: true,
+    sig_algo: file.sig_algo,
+    payload_version: file.payload_version ?? null,
   };
 }
 
-/** 比较文件系统资源清单；恢复模式无法取得清单时回退到全量更新。 */
-export function buildProtocolV2ResourceUpdatePlan({
-  resources,
-  inventory,
-  mode,
-  forced = false,
-}: {
-  resources: readonly IProtocolV2Resource[];
-  inventory?: readonly ProtocolV2ResourceInventoryItem[];
-  mode: ProtocolV2ResourceUpdateMode;
-  forced?: boolean;
-}): ProtocolV2ResourceUpdatePlan {
-  if (forced) {
-    return {
-      status: resources.length > 0 ? 'outdated' : 'valid',
-      resources: [...resources],
-    };
+export function parseProtocolV2ResourceManifest(value: unknown): IProtocolV2ResourceManifest {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('Invalid Pro2 resource manifest');
   }
-  if (!inventory) {
-    return mode === 'bootloader-recovery'
-      ? {
-          status: resources.length > 0 ? 'outdated' : 'valid',
-          resources: [...resources],
-        }
-      : { status: 'unknown', resources: [] };
+  const manifest = value as Partial<IProtocolV2ResourceManifest>;
+  if (
+    manifest.schema !== 1 ||
+    manifest.variant !== 'resource' ||
+    manifest.device_root !== 'vol0:' ||
+    manifest.restore_mode !== 'bootloader_update' ||
+    !Array.isArray(manifest.trees) ||
+    !Array.isArray(manifest.files)
+  ) {
+    throw new Error('Invalid Pro2 resource manifest contract');
+  }
+  const files = manifest.files.map(parseProtocolV2ResourceManifestFile);
+  const devicePaths = new Set(files.map(file => file.device_path));
+  const archivePaths = new Set(files.map(file => file.archive_path));
+  if (
+    files.length === 0 ||
+    devicePaths.size !== files.length ||
+    archivePaths.size !== files.length ||
+    !devicePaths.has(PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH) ||
+    !files.some(file => file.device_path.startsWith('vol0:/bundles/'))
+  ) {
+    throw new Error('Invalid Pro2 resource manifest file set');
   }
-
-  const inventoryByType = new Map(inventory.map(item => [item.type, item]));
-  const changedResources = resources.filter(resource => {
-    const current = inventoryByType.get(resource.type);
-    return (
-      !current ||
-      current.size !== resource.size ||
-      current.headerHash.toLowerCase() !== resource.headerHash.toLowerCase()
-    );
-  });
-
   return {
-    status: changedResources.length === 0 ? 'valid' : 'outdated',
-    resources: changedResources,
+    schema: 1,
+    artifact_name: assertManifestString(manifest.artifact_name, 'artifact_name'),
+    release_name: assertManifestString(manifest.release_name, 'release_name'),
+    variant: 'resource',
+    commit: assertManifestString(manifest.commit, 'commit'),
+    short_sha: assertManifestString(manifest.short_sha, 'short_sha'),
+    timestamp_utc: assertManifestString(manifest.timestamp_utc, 'timestamp_utc'),
+    core_version: assertManifestString(manifest.core_version, 'core_version'),
+    key_set: assertManifestString(manifest.key_set, 'key_set'),
+    device_root: 'vol0:',
+    restore_mode: 'bootloader_update',
+    trees: manifest.trees.map((tree, index) => {
+      if (!tree || typeof tree !== 'object') {
+        throw new Error(`Invalid Pro2 resource manifest trees[${index}]`);
+      }
+      const item = tree as { path?: unknown; device?: unknown };
+      return {
+        path: assertManifestRelativePath(item.path, `trees[${index}].path`),
+        device: assertManifestString(item.device, `trees[${index}].device`),
+      };
+    }),
+    files,
   };
 }
 
-function bytesToHex(bytes: Uint8Array): string {
-  return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
-}
-
-/** Verify the complete downloaded file before any device mutation. */
-export function isProtocolV2ResourceFileValid(
-  binary: ArrayBuffer,
-  resource: Pick<IProtocolV2ResourceFile, 'size' | 'fileHash'>
-): boolean {
-  if (binary.byteLength !== resource.size) return false;
-  return bytesToHex(sha256(new Uint8Array(binary))) === resource.fileHash.toLowerCase();
+export function selectProtocolV2ResourceManifestFiles({
+  manifest,
+  targetsToUpdate,
+}: {
+  manifest: IProtocolV2ResourceManifest;
+  targetsToUpdate: readonly FirmwareUpdateV4Target[];
+}): IProtocolV2ResourceManifestFile[] {
+  return targetsToUpdate.includes('resource') ? [...manifest.files] : [];
 }

package/src/types/api/checkAllFirmwareRelease.ts

@@ -1,30 +1,43 @@
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { CommonParams, Response } from '../params';
-import type {
-  DeviceStateVersions,
-  Features,
-  IDeviceBLEFirmwareStatus,
-  IDeviceFirmwareStatus,
-} from '../device';
+import type { DeviceStateVersions, Features, IDeviceFirmwareStatus } from '../device';
 import type {
   IBLEFirmwareReleaseInfo,
   IFirmwareReleaseInfo,
+  IProtocolV2FirmwareComponent,
   IProtocolV2FirmwareComponentTarget,
+  IProtocolV2ResourceSource,
 } from '../settings';
 import type { FirmwareUpdateV4Target } from './firmwareUpdate';
 import type { FirmwareUpdatePlan, FirmwareUpdatePlanForceTarget } from './firmwareUpdatePlan';
 
-export type FirmwareRelease = {
+export type ProtocolV2ComponentReleaseInfo = IProtocolV2FirmwareComponent & {
+  protocol: 'V2';
+  configKey: string;
+  componentTarget: IProtocolV2FirmwareComponentTarget;
+  required: boolean;
+  changelog: IFirmwareReleaseInfo['changelog'];
+};
+
+export type FirmwareReleaseCheckResult = {
   shouldUpdate?: boolean;
   status: IDeviceFirmwareStatus;
   changelog?: {
     'zh-CN': string;
     'en-US': string;
   }[];
-  release: IDeviceBLEFirmwareStatus | IBLEFirmwareReleaseInfo | IFirmwareReleaseInfo;
+  release:
+    | IBLEFirmwareReleaseInfo
+    | IFirmwareReleaseInfo
+    | ProtocolV2ComponentReleaseInfo
+    | undefined;
   bootloaderMode?: boolean;
 };
 
+export type BridgeReleaseCheckResult = Omit<FirmwareReleaseCheckResult, 'release'> & {
+  release: string | undefined;
+};
+
 export type ProtocolV2FirmwareComponentReleaseStatus =
   | 'valid'
   | 'outdated'
@@ -49,10 +62,10 @@ export type ProtocolV2FirmwareComponentRelease = {
 };
 
 export type AllFirmwareRelease = {
-  firmware: FirmwareRelease;
-  ble: FirmwareRelease;
-  bootloader?: FirmwareRelease;
-  bridge?: FirmwareRelease;
+  firmware: FirmwareReleaseCheckResult;
+  ble: FirmwareReleaseCheckResult;
+  bootloader?: FirmwareReleaseCheckResult;
+  bridge?: BridgeReleaseCheckResult;
   features?: Features;
   protocol?: 'V1' | 'V2';
   deviceType?: 'pro2' | 'neo';
@@ -61,6 +74,7 @@ export type AllFirmwareRelease = {
   hasUpgrade?: boolean;
   required?: boolean;
   resourceStatus?: 'valid' | 'outdated' | 'unknown';
+  resourceArchive?: IProtocolV2ResourceSource;
   currentVersions?: DeviceStateVersions;
   components?: ProtocolV2FirmwareComponentRelease[];
   targetsToUpdate?: FirmwareUpdateV4Target[];
@@ -74,6 +88,7 @@ export type CheckAllFirmwareReleaseParams = {
   firmwareType?: EFirmwareType;
   platform?: 'native' | 'desktop' | 'ext' | 'web' | 'web-embed';
   forceUpdateTargets?: FirmwareUpdatePlanForceTarget[];
+  protocolV2ForceUpdateTargets?: FirmwareUpdateV4Target[];
 };
 
 export declare function checkAllFirmwareRelease(

package/src/types/api/checkBLEFirmwareRelease.ts

@@ -1,15 +1,6 @@
-import type { IBLEFirmwareReleaseInfo } from '../settings';
 import type { Response } from '../params';
-import type { IDeviceBLEFirmwareStatus } from '../device';
+import type { FirmwareReleaseCheckResult } from './checkAllFirmwareRelease';
 
-type BleFirmwareRelease = {
-  status: IDeviceBLEFirmwareStatus;
-  changelog: {
-    'zh-CN': string;
-    'en-US': string;
-  }[];
-  release: IBLEFirmwareReleaseInfo;
-  bootloaderMode: boolean;
-};
-
-export declare function checkBLEFirmwareRelease(connectId?: string): Response<BleFirmwareRelease>;
+export declare function checkBLEFirmwareRelease(
+  connectId?: string
+): Response<FirmwareReleaseCheckResult | null>;

package/src/types/api/checkBootloaderRelease.ts

@@ -1,12 +1,8 @@
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { CommonParams, Response } from '../params';
+import type { FirmwareReleaseCheckResult } from './checkAllFirmwareRelease';
 
-export type CheckBootloaderReleaseResponse = {
-  shouldUpdate: boolean;
-  status: 'outdated' | 'valid';
-  release: string | undefined;
-  bootloaderMode: boolean;
-} | null;
+export type CheckBootloaderReleaseResponse = FirmwareReleaseCheckResult | null;
 
 export type CheckBootloaderReleaseParams = {
   willUpdateFirmwareVersion?: string;