@onekeyfe/hd-core 1.2.0-alpha.46 → 1.2.0-alpha.48

package/src/data/messages/messages-protocol-v2.json

@@ -450,8 +450,6 @@
         "MessageType_DeviceInfo": 60601,
         "MessageType_DeviceStatusGet": 60602,
         "MessageType_DeviceStatus": 60603,
-        "MessageType_ResourceInventoryGet": 60604,
-        "MessageType_ResourceInventory": 60605,
         "MessageType_FilesystemPermissionFix": 60800,
         "MessageType_FilesystemPathInfo": 60801,
         "MessageType_FilesystemPathInfoQuery": 60802,
@@ -11996,16 +11994,6 @@
         "APP": 85
       }
     },
-    "ResourceBundleType": {
-      "values": {
-        "IMAGES": 0,
-        "ANIMATION": 1,
-        "WALLPAPER": 2,
-        "TRANSLATIONS": 3,
-        "ROOBERT": 4,
-        "NOTO": 5
-      }
-    },
     "DeviceFirmwareImageInfo": {
       "fields": {
         "version": {
@@ -12203,37 +12191,6 @@
         }
       }
     },
-    "ResourceInventoryGet": {
-      "fields": {}
-    },
-    "ResourceInventoryItem": {
-      "fields": {
-        "type": {
-          "rule": "required",
-          "type": "ResourceBundleType",
-          "id": 1
-        },
-        "size": {
-          "rule": "required",
-          "type": "uint32",
-          "id": 2
-        },
-        "header_hash": {
-          "rule": "required",
-          "type": "bytes",
-          "id": 3
-        }
-      }
-    },
-    "ResourceInventory": {
-      "fields": {
-        "items": {
-          "rule": "repeated",
-          "type": "ResourceInventoryItem",
-          "id": 1
-        }
-      }
-    },
     "DeviceSessionErrorCode": {
       "values": {
         "DeviceSessionError_None": 0,

package/src/data-manager/DataManager.ts

@@ -509,6 +509,10 @@ export default class DataManager {
     return this.deviceMap[EDeviceType.Pro2]?.resources?.stable;
   }
 
+  static getProtocolV2BootResources() {
+    return this.deviceMap[EDeviceType.Pro2]?.resources?.boot;
+  }
+
   static getProtobufMessages(schema: ProtobufMessageSchema = 'v1CurrentSchema'): JSON {
     return this.messages[schema];
   }

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

@@ -1,12 +1,13 @@
 import { sha256 } from '@noble/hashes/sha256';
+import { PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE } from '@onekeyfe/hd-transport';
 
 import type {
+  IProtocolV2BootResources,
   IProtocolV2Resource,
   IProtocolV2ResourceType,
   IProtocolV2Resources,
 } from '../../types';
 import type { DeviceCommands } from '../../device/DeviceCommands';
-import type { ResourceInventory } from '@onekeyfe/hd-transport';
 
 export const PROTOCOL_V2_RESOURCE_TYPES = [
   'images',
@@ -30,23 +31,16 @@ export const PROTOCOL_V2_RESOURCE_DEVICE_PATHS: Readonly<Record<IProtocolV2Resou
 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;
 
-const RESOURCE_TYPE_BY_DEVICE_VALUE: Readonly<Record<string, IProtocolV2ResourceType>> = {
-  '0': 'images',
-  IMAGES: 'images',
-  '1': 'animation',
-  ANIMATION: 'animation',
-  '2': 'wallpaper',
-  WALLPAPER: 'wallpaper',
-  '3': 'translations',
-  TRANSLATIONS: 'translations',
-  '4': 'roobert',
-  ROOBERT: 'roobert',
-  '5': 'noto',
-  NOTO: 'noto',
-};
-
 export type ProtocolV2ResourceInventoryItem = {
   type: IProtocolV2ResourceType;
   size: number;
@@ -60,57 +54,153 @@ export type ProtocolV2ResourceUpdatePlan = {
   resources: IProtocolV2Resource[];
 };
 
-/** Normalize the success-only device response into the SDK resource identity shape. */
-export function parseProtocolV2ResourceInventory(
-  value: ResourceInventory | unknown
-): ProtocolV2ResourceInventoryItem[] {
-  const items = (value as { items?: unknown })?.items;
-  if (!Array.isArray(items)) {
-    throw new Error('Invalid Pro2 resource inventory: items must be an array');
+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;
   }
-
-  const inventory = items.map((item, index) => {
-    if (!item || typeof item !== 'object') {
-      throw new Error(`Invalid Pro2 resource inventory item at ${index}`);
+  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;
     }
-    const raw = item as { type?: unknown; size?: unknown; header_hash?: unknown };
-    const type = RESOURCE_TYPE_BY_DEVICE_VALUE[String(raw.type).toUpperCase()];
-    if (!type) {
-      throw new Error(`Invalid Pro2 resource inventory type at ${index}`);
+  }
+  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);
     }
-    if (!Number.isSafeInteger(raw.size) || Number(raw.size) <= 0) {
-      throw new Error(`Invalid Pro2 resource inventory size at ${index}`);
+    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 {
-      type,
-      size: Number(raw.size),
-      headerHash: normalizeHex(raw.header_hash, SHA3_512_HEX_LENGTH, 'inventory headerHash'),
-    };
-  });
+    return bytes;
+  }
+  return new Uint8Array(0);
+}
 
-  if (new Set(inventory.map(item => item.type)).size !== inventory.length) {
-    throw new Error('Invalid Pro2 resource inventory: duplicate resource type');
+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 PROTOCOL_V2_RESOURCE_TYPES.flatMap(type => {
-    const item = inventory.find(candidate => candidate.type === type);
-    return item ? [item] : [];
-  });
+  return bytesToHex(
+    bytes.slice(
+      PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET,
+      PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET + PROTOCOL_V2_OKPP_HASH_SIZE
+    )
+  );
 }
 
-export async function requestProtocolV2ResourceInventory({
+async function readProtocolV2ResourceIdentity({
   commands,
+  resource,
+  chunkSize,
   timeoutMs = PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS,
 }: {
-  commands: DeviceCommands;
+  commands: Pick<DeviceCommands, 'typedCall'>;
+  resource: IProtocolV2Resource;
+  chunkSize: number;
   timeoutMs?: number;
-}): Promise<ProtocolV2ResourceInventoryItem[]> {
-  const { message } = await commands.typedCall(
-    'ResourceInventoryGet',
-    'ResourceInventory',
-    {},
+}): Promise<ProtocolV2ResourceInventoryItem | undefined> {
+  const path = PROTOCOL_V2_RESOURCE_DEVICE_PATHS[resource.type];
+  const pathInfo = await commands.typedCall(
+    'FilesystemPathInfoQuery',
+    'FilesystemPathInfo',
+    { path },
     { timeoutMs }
   );
-  return parseProtocolV2ResourceInventory(message);
+  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 {
@@ -149,6 +239,34 @@ function validateResource(value: unknown, index: number): IProtocolV2Resource {
   };
 }
 
+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 !== 'CRATE') {
+    throw new Error('Invalid Pro2 boot resources target: expected CRATE');
+  }
+  if (typeof resource.url !== 'string' || !resource.url.startsWith('https://')) {
+    throw new Error('Invalid Pro2 boot resources url');
+  }
+  if (!Number.isSafeInteger(resource.size) || Number(resource.size) <= 0) {
+    throw new Error('Invalid Pro2 boot resources size');
+  }
+  return {
+    required: false,
+    target: 'CRATE',
+    url: resource.url,
+    size: Number(resource.size),
+    fileHash: normalizeHex(resource.fileHash, SHA256_HEX_LENGTH, 'boot fileHash'),
+    payloadHash: normalizeHex(resource.payloadHash, SHA3_512_HEX_LENGTH, 'boot payloadHash'),
+    headerHash: normalizeHex(resource.headerHash, SHA3_512_HEX_LENGTH, 'boot headerHash'),
+  };
+}
+
 /** Validate a complete Pro2 stable resource set from remote configuration. */
 export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources | undefined {
   if (value === undefined) return undefined;
@@ -160,7 +278,8 @@ export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources |
     throw new Error('Invalid Pro2 resources config: stable must be an array');
   }
 
-  const stable = (value as { stable: unknown[] }).stable.map(validateResource);
+  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 six unique resource types');
@@ -170,6 +289,7 @@ export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources |
       throw new Error(`Invalid Pro2 resources config: stable is missing ${type}`);
     }
   }
+  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);
@@ -178,10 +298,11 @@ export function parseProtocolV2Resources(value: unknown): IProtocolV2Resources |
       }
       return resource;
     }),
+    ...(boot ? { boot } : undefined),
   };
 }
 
-/** Compare the application inventory or select the full set for bootloader recovery. */
+/** 比较文件系统资源清单；恢复模式无法取得清单时回退到全量更新。 */
 export function buildProtocolV2ResourceUpdatePlan({
   resources,
   inventory,
@@ -193,14 +314,19 @@ export function buildProtocolV2ResourceUpdatePlan({
   mode: ProtocolV2ResourceUpdateMode;
   forced?: boolean;
 }): ProtocolV2ResourceUpdatePlan {
-  if (mode === 'bootloader-recovery' || forced) {
+  if (forced) {
     return {
       status: resources.length > 0 ? 'outdated' : 'valid',
       resources: [...resources],
     };
   }
   if (!inventory) {
-    return { status: 'unknown', resources: [] };
+    return mode === 'bootloader-recovery'
+      ? {
+          status: resources.length > 0 ? 'outdated' : 'valid',
+          resources: [...resources],
+        }
+      : { status: 'unknown', resources: [] };
   }
 
   const inventoryByType = new Map(inventory.map(item => [item.type, item]));

package/src/types/api/firmwareUpdate.ts

@@ -63,6 +63,7 @@ export interface FirmwareUpdateV3Params {
  */
 export type FirmwareUpdateV4Target =
   | 'boot'
+  | 'boot_resources'
   | 'app_v1'
   | 'app_v2'
   | 'coprocessor'
@@ -82,6 +83,8 @@ export interface FirmwareUpdateV4Params {
   romloaderBinary?: ArrayBuffer;
   /** FW_MGMT_TARGET_BOOTLOADER = 3 */
   bootloaderBinary?: ArrayBuffer;
+  /** FW_MGMT_TARGET_CRATE = 1; optional Pro2 startup resources. */
+  bootResourcesBinary?: ArrayBuffer;
   /** FW_MGMT_TARGET_APPLICATION_P1 = 4 */
   applicationP1Binary?: ArrayBuffer;
   /** FW_MGMT_TARGET_APPLICATION_P2 = 5 */

package/src/types/settings.ts

@@ -81,8 +81,24 @@ export type IProtocolV2Resource = {
   headerHash: string;
 };
 
+/** Optional Pro2 startup-resource CRATE installed by the bootloader updater. */
+export type IProtocolV2BootResources = {
+  required: false;
+  target: 'CRATE';
+  url: string;
+  /** Complete CRATE file size in bytes. */
+  size: number;
+  /** SHA-256 of the complete CRATE file. */
+  fileHash: string;
+  /** SHA3-512 payload_hash from the signed CRATE header. */
+  payloadHash: string;
+  /** SHA3-512 header_hash from the signed CRATE header. */
+  headerHash: string;
+};
+
 export type IProtocolV2Resources = {
   stable: IProtocolV2Resource[];
+  boot?: IProtocolV2BootResources;
 };
 
 /** Pro2 RESC bundle okpkg descriptor for incremental FileWrite synchronization. */