@onekeyfe/hd-core 1.2.0-alpha.87 → 1.2.0-alpha.89

package/src/api/firmware/FirmwareMemoryHost.ts

@@ -6,7 +6,6 @@ import type { CoreApi } from '../../types/api';
 import type {
   FirmwareArtifactReader,
   FirmwareArtifactReference,
-  FirmwareUpdateV4Target,
 } from '../../types/api/firmwareUpdate';
 import type { FirmwareUpdatePlan } from '../../types/api/firmwareUpdatePlan';
 
@@ -24,33 +23,11 @@ export type FirmwareMemoryArtifact = {
 export type FirmwareUpdateV4MemoryHost = {
   preparedPlan: ReturnType<CoreApi['prepareFirmwareUpdatePlan']>;
   hostBindingGeneration: number;
-  targetsToUpdate: FirmwareUpdateV4Target[];
-  expectedDeviceId: string;
-  expectedTargetVersions: Partial<Record<FirmwareUpdateV4Target, string>>;
-  componentArtifacts: Partial<
-    Record<Exclude<FirmwareUpdateV4Target, 'resource'>, FirmwareArtifactReference>
-  >;
   release: () => void;
 };
 
 let memoryHostSequence = 0;
 
-const FIRMWARE_UPDATE_V4_COMPONENT_TARGETS = new Set<Exclude<FirmwareUpdateV4Target, 'resource'>>([
-  'boot',
-  'app_v1',
-  'app_v2',
-  'coprocessor',
-  'se01',
-  'se02',
-  'se03',
-  'se04',
-]);
-
-const isFirmwareUpdateV4ComponentTarget = (
-  target: string
-): target is Exclude<FirmwareUpdateV4Target, 'resource'> =>
-  FIRMWARE_UPDATE_V4_COMPONENT_TARGETS.has(target as Exclude<FirmwareUpdateV4Target, 'resource'>);
-
 const createReference = (binary: ArrayBuffer, prefix: string): FirmwareArtifactReference => {
   const digest = bytesToHex(sha256(new Uint8Array(binary)));
   return {
@@ -84,14 +61,19 @@ export function prepareFirmwareUpdateV4MemoryHost({
   const hostId = `${Date.now()}:${memoryHostSequence}`;
   const binaries = new Map<string, Uint8Array>();
   const inputs = artifacts.map((input, artifactIndex) => {
-    const artifact = createReference(input.binary, `${hostId}:artifact:${artifactIndex}`);
-    binaries.set(artifact.artifactRef, new Uint8Array(input.binary));
+    const artifactBinary = new Uint8Array(input.binary).slice();
+    const artifact = createReference(
+      artifactBinary.buffer as ArrayBuffer,
+      `${hostId}:artifact:${artifactIndex}`
+    );
+    binaries.set(artifact.artifactRef, artifactBinary);
     const materializedEntries = input.materializedEntries?.map((entry, entryIndex) => {
+      const entryBinary = new Uint8Array(entry.binary).slice();
       const entryArtifact = createReference(
-        entry.binary,
+        entryBinary.buffer as ArrayBuffer,
         `${hostId}:entry:${artifactIndex}:${entryIndex}`
       );
-      binaries.set(entryArtifact.artifactRef, new Uint8Array(entry.binary));
+      binaries.set(entryArtifact.artifactRef, entryBinary);
       return {
         entryName: entry.entryName,
         artifact: entryArtifact,
@@ -148,23 +130,9 @@ export function prepareFirmwareUpdateV4MemoryHost({
     artifactReader,
     preparedPlanDigest: preparedPlan.preparedPlanDigest,
   });
-  const componentArtifacts: FirmwareUpdateV4MemoryHost['componentArtifacts'] = {};
-  const expectedTargetVersions: FirmwareUpdateV4MemoryHost['expectedTargetVersions'] = {};
-  for (const artifact of preparedPlan.artifacts) {
-    if (artifact.role === 'component' && isFirmwareUpdateV4ComponentTarget(artifact.target)) {
-      componentArtifacts[artifact.target] = artifact.artifact;
-    }
-    if (artifact.targetVersion) {
-      expectedTargetVersions[artifact.target as FirmwareUpdateV4Target] = artifact.targetVersion;
-    }
-  }
   return {
     preparedPlan,
     hostBindingGeneration,
-    targetsToUpdate: [...preparedPlan.targetsToUpdate] as FirmwareUpdateV4Target[],
-    expectedDeviceId: preparedPlan.deviceIdentity,
-    expectedTargetVersions,
-    componentArtifacts,
     release: () => {
       sdk.unregisterFirmwareUpdateHostBinding(hostBindingGeneration);
       readers.clear();

package/src/api/firmware/FirmwareUpdatePlan.ts

@@ -504,6 +504,13 @@ const buildProtocolV2Artifacts = (
       );
     }
     componentTargetSet.add(target);
+    const integrity = asIntegrity({
+      size: component.expectedSize,
+      sha256: component.fingerprint,
+    });
+    if (integrity.expectedSize === undefined || integrity.expectedSha256 === undefined) {
+      planError(`Protocol V2 component ${key} integrity metadata is invalid`);
+    }
     artifacts.push({
       artifactId: `component:${target}`,
       role: 'component',
@@ -511,10 +518,7 @@ const buildProtocolV2Artifacts = (
       url: assertArtifactUrl(component.url, `Protocol V2 component ${key}`),
       container: 'raw',
       logicalName: key,
-      ...asIntegrity({
-        size: component.expectedSize,
-        sha256: component.fingerprint,
-      }),
+      ...integrity,
       ...(asVersion(component.version) ? { targetVersion: asVersion(component.version) } : {}),
     });
     targets.push(target);
@@ -632,6 +636,47 @@ const finalizeFirmwareUpdatePlan = ({
   });
 };
 
+export type ProtocolV2LocalFirmwareUpdatePlanArtifact = {
+  artifactId: string;
+  target: Exclude<FirmwareUpdateV4Target, 'boot_resources'>;
+  container: 'raw' | 'zip';
+  logicalName: string;
+  expectedSize: number;
+  expectedSha256: string;
+  targetVersion?: string;
+};
+
+export const buildProtocolV2LocalFirmwareUpdatePlan = ({
+  features,
+  firmwareType,
+  platform,
+  artifacts,
+}: {
+  features: Features;
+  firmwareType: EFirmwareType;
+  platform: FirmwareUpdatePlatform;
+  artifacts: ProtocolV2LocalFirmwareUpdatePlanArtifact[];
+}): FirmwareUpdatePlan => {
+  if (artifacts.length === 0) {
+    return planError('Protocol V2 local firmware plan has no artifacts');
+  }
+  const plan = finalizeFirmwareUpdatePlan({
+    features,
+    firmwareType,
+    platform,
+    artifacts: artifacts.map(artifact => ({
+      ...artifact,
+      role: artifact.target === 'resource' ? 'resourceBundle' : 'component',
+      url: `https://local-firmware.invalid/${encodeURIComponent(artifact.artifactId)}`,
+    })),
+    targetsToUpdate: artifacts.map(artifact => artifact.target),
+  });
+  if (plan.executor !== 'v4') {
+    return planError('Protocol V2 local firmware plan requires executor v4');
+  }
+  return plan;
+};
+
 export const buildProtocolV2FirmwareUpdatePlan = ({
   features,
   firmwareType,

package/src/types/api/firmwareUpdate.ts

@@ -120,6 +120,8 @@ export interface FirmwareUpdateV3Params {
  */
 export type FirmwareUpdateV4Target =
   | 'boot'
+  /** @deprecated Use resource with resourceArchiveBinary. */
+  | 'boot_resources'
   | 'app_v1'
   | 'app_v2'
   | 'coprocessor'
@@ -154,11 +156,28 @@ 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;
+  /** @deprecated Package the complete signed resource set as a ZIP and use resourceArchiveBinary. */
+  resourceFiles?: Array<{
+    binary: ArrayBuffer;
+    devicePath: string;
+    size?: number;
+    fileHash?: string;
+  }>;
   forcedUpdateRes?: boolean;
   artifactReader?: FirmwareArtifactReader;
   componentArtifacts?: Partial<
-    Record<Exclude<FirmwareUpdateV4Target, 'resource'>, FirmwareArtifactReference>
+    Record<
+      Exclude<FirmwareUpdateV4Target, 'resource' | 'boot_resources'>,
+      FirmwareArtifactReference
+    >
   >;
+  /** @deprecated Use a ZIP artifact in preparedPlan instead. */
+  resourceBundleArtifacts?: Array<{
+    name: string;
+    artifact: FirmwareArtifactReference;
+  }>;
 }
 
 export declare function registerFirmwareUpdateHostBinding(