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

package/src/api/firmware/FirmwareUpdatePreparedPlan.ts

@@ -278,7 +278,14 @@ export const validateFirmwareUpdatePreparedPlan = (value: unknown): FirmwareUpda
     artifactIds.add(artifact.artifactId);
     artifactTargets.add(artifact.target);
     assertFirmwareArtifactReference(artifact.artifact);
-    artifact.materializedEntries?.forEach(assertPreparedEntry);
+    const materializedEntryNames =
+      artifact.materializedEntries?.map(entry => {
+        assertPreparedEntry(entry);
+        return getFirmwareUpdateResourceName(entry.entryName).toLowerCase();
+      }) ?? [];
+    if (new Set(materializedEntryNames).size !== materializedEntryNames.length) {
+      return preparedPlanError('Firmware prepared plan contains duplicate entry names');
+    }
   }
   if (
     preparedPlan.targetsToUpdate.some(target => !FIRMWARE_UPDATE_PLAN_TARGETS.has(target)) ||
@@ -295,25 +302,53 @@ export const validateFirmwareUpdatePreparedPlan = (value: unknown): FirmwareUpda
   return preparedPlan;
 };
 
+export const getFirmwareUpdatePreparedRawArtifact = ({
+  preparedPlan: value,
+  target,
+  role,
+}: {
+  preparedPlan: unknown;
+  target: FirmwareUpdatePreparedArtifact['target'];
+  role: FirmwareUpdatePreparedArtifact['role'];
+}): FirmwareUpdatePreparedArtifact => {
+  const preparedPlan = validateFirmwareUpdatePreparedPlan(value);
+  const artifacts = preparedPlan.artifacts.filter(artifact => artifact.target === target);
+  if (artifacts.length !== 1 || artifacts[0].role !== role || artifacts[0].container !== 'raw') {
+    return preparedPlanError(`Firmware prepared plan ${target} artifact is invalid`);
+  }
+  return artifacts[0];
+};
+
 /**
  * Identity observed on the live device while a degraded recovery plan runs, keyed by
- * the plan's opaque lease. Bootloader recovery starts with no serial and the device
- * reports one only after the firmware phase reboots it, so the later phases of the
- * SAME workflow must be allowed to continue — but only for the device that first
- * answered, never for a second one that appears mid-recovery.
+ * the approved prepared-plan digest. Bootloader recovery starts with no serial and
+ * the device reports one only after the firmware phase reboots it, so the later
+ * phases of the SAME workflow must be allowed to continue — but only for the device
+ * that first answered, never for a second one that appears mid-recovery.
  */
 const degradedPlanIdentityPins = new Map<string, string>();
 /** Keep the pin map from growing without bound across many workflows. */
 const DEGRADED_PLAN_IDENTITY_PIN_LIMIT = 32;
 
-const pinDegradedPlanIdentity = (leaseRef: string, deviceIdentity: string) => {
-  if (degradedPlanIdentityPins.size >= DEGRADED_PLAN_IDENTITY_PIN_LIMIT) {
+const pinDegradedPlanIdentity = (preparedPlanDigest: string, deviceIdentity: string) => {
+  const key = preparedPlanDigest.toLowerCase();
+  if (
+    !degradedPlanIdentityPins.has(key) &&
+    degradedPlanIdentityPins.size >= DEGRADED_PLAN_IDENTITY_PIN_LIMIT
+  ) {
     const oldest = degradedPlanIdentityPins.keys().next();
     if (!oldest.done) {
       degradedPlanIdentityPins.delete(oldest.value);
     }
   }
-  degradedPlanIdentityPins.set(leaseRef, deviceIdentity);
+  degradedPlanIdentityPins.set(key, deviceIdentity);
+};
+
+/** Release recovery identity state when its digest-bound host workflow ends. */
+export const clearFirmwareUpdatePreparedPlanDeviceIdentityPin = (
+  preparedPlanDigest: string
+): void => {
+  degradedPlanIdentityPins.delete(preparedPlanDigest.toLowerCase());
 };
 
 export const assertFirmwareUpdatePreparedPlanDeviceIdentity = ({
@@ -340,10 +375,12 @@ export const assertFirmwareUpdatePreparedPlanDeviceIdentity = ({
     if (deviceModel === undefined || preparedPlan.deviceModel !== deviceModel) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
     }
-    const pinnedIdentity = degradedPlanIdentityPins.get(preparedPlan.leaseRef);
+    const pinnedIdentity = degradedPlanIdentityPins.get(
+      preparedPlan.preparedPlanDigest.toLowerCase()
+    );
     if (!deviceIdentity) {
-      // Still identity-less: only legitimate while the device sits in bootloader.
-      if (bootloaderMode !== true) {
+      // V4 设备可能尚未写入序列号；V2 则只允许 bootloader 恢复流程缺少身份。
+      if (preparedPlan.executor !== 'v4' && bootloaderMode !== true) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
       }
       return preparedPlan;
@@ -351,7 +388,7 @@ export const assertFirmwareUpdatePreparedPlanDeviceIdentity = ({
     // The recovered device now reports a serial: bind this recovery to it, and hold
     // every later phase to the same one.
     if (!pinnedIdentity) {
-      pinDegradedPlanIdentity(preparedPlan.leaseRef, deviceIdentity);
+      pinDegradedPlanIdentity(preparedPlan.preparedPlanDigest, deviceIdentity);
       return preparedPlan;
     }
     if (pinnedIdentity !== deviceIdentity) {

package/src/api/firmware/protocolV2Release.ts

@@ -0,0 +1,168 @@
+import { EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { DataManager } from '../../data-manager';
+
+import type { EDeviceType } from '@onekeyfe/hd-shared';
+import type { Device } from '../../device/Device';
+import type {
+  DeviceState,
+  Features,
+  IFirmwareReleaseInfo,
+  IProtocolV2FirmwareComponentTarget,
+} from '../../types';
+import type {
+  FirmwareReleaseCheckResult,
+  ProtocolV2ComponentReleaseInfo,
+  ProtocolV2FirmwareReleaseStatus,
+} from '../../types/api/checkAllFirmwareRelease';
+import type { ProtocolV2FirmwareReleasePlan } from '../CheckAllFirmwareRelease';
+
+export const PROTOCOL_V2_MAIN_FIRMWARE_TARGETS: readonly IProtocolV2FirmwareComponentTarget[] = [
+  'APPLICATION_P1',
+  'APPLICATION_P2',
+  'SE01',
+  'SE02',
+  'SE03',
+  'SE04',
+];
+
+export const PROTOCOL_V2_BLE_TARGETS: readonly IProtocolV2FirmwareComponentTarget[] = [
+  'COPROCESSOR',
+];
+
+export const PROTOCOL_V2_BOOTLOADER_TARGETS: readonly IProtocolV2FirmwareComponentTarget[] = [
+  'BOOTLOADER',
+];
+
+export type ProtocolV2FirmwareReleaseContext = {
+  state: Omit<DeviceState, 'identity'> & {
+    identity: Omit<DeviceState['identity'], 'deviceType'> & {
+      deviceType: EDeviceType.Pro2 | EDeviceType.Neo;
+    };
+  };
+  features: Features;
+  firmwareType: EFirmwareType;
+  release: IFirmwareReleaseInfo | undefined;
+};
+
+export async function loadProtocolV2FirmwareReleaseContext({
+  device,
+  firmwareType: firmwareTypeParam,
+  checkFirmwareHash = false,
+  methodName,
+}: {
+  device: Device;
+  firmwareType?: EFirmwareType;
+  checkFirmwareHash?: boolean;
+  methodName: string;
+}): Promise<ProtocolV2FirmwareReleaseContext> {
+  const state = await device.getDeviceState({
+    refreshSections: checkFirmwareHash
+      ? ['identity', 'versions', 'verification']
+      : ['identity', 'versions'],
+  });
+  if (state.identity.deviceType !== 'pro2' && state.identity.deviceType !== 'neo') {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.DeviceNotSupportMethod,
+      `${methodName} requires a Pro2 or Neo device for Protocol V2`
+    );
+  }
+
+  const { features } = device;
+  if (!features) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `${methodName} requires initialized device features`
+    );
+  }
+
+  const firmwareType = firmwareTypeParam ?? state.identity.firmwareType ?? EFirmwareType.Universal;
+  return {
+    state: state as ProtocolV2FirmwareReleaseContext['state'],
+    features,
+    firmwareType,
+    release: DataManager.getFirmwareLatestRelease(features, firmwareType),
+  };
+}
+
+export function summarizeProtocolV2FirmwareRelease(
+  plan: ProtocolV2FirmwareReleasePlan,
+  componentTargets: readonly IProtocolV2FirmwareComponentTarget[]
+): ProtocolV2FirmwareReleasePlan {
+  const targetSet = new Set<IProtocolV2FirmwareComponentTarget>(componentTargets);
+  const components = plan.components.filter(component => targetSet.has(component.componentTarget));
+  const targetsToUpdate = Array.from(
+    new Set(
+      components.flatMap(component =>
+        component.status === 'outdated' && component.updateTarget ? [component.updateTarget] : []
+      )
+    )
+  );
+  const hasUpgrade = targetsToUpdate.length > 0;
+  const required = !!plan.release?.required && hasUpgrade;
+  let status: ProtocolV2FirmwareReleaseStatus = 'valid';
+  if (!plan.release || components.length === 0) {
+    status = 'unavailable';
+  } else if (required) {
+    status = 'required';
+  } else if (hasUpgrade) {
+    status = 'outdated';
+  } else if (components.some(component => component.status === 'unknown')) {
+    status = 'unknown';
+  } else if (components.every(component => component.status === 'unsupported')) {
+    status = 'unavailable';
+  }
+
+  return {
+    ...plan,
+    status,
+    hasUpgrade,
+    required,
+    components,
+    targetsToUpdate,
+  };
+}
+
+export function toProtocolV2FirmwareReleaseInfo({
+  plan,
+  state,
+  release,
+}: {
+  plan: ProtocolV2FirmwareReleasePlan;
+  state: DeviceState;
+  release: FirmwareReleaseCheckResult['release'];
+}): FirmwareReleaseCheckResult {
+  return {
+    shouldUpdate: plan.hasUpgrade,
+    status: plan.status === 'unavailable' ? 'unknown' : plan.status,
+    // Protocol V2 components share package-set release notes. The optional
+    // bootloaderChangelog field belongs to the legacy Protocol V1 release model.
+    changelog: plan.release ? [plan.release.changelog] : [],
+    release,
+    bootloaderMode: state.status.mode === 'bootloader' || state.status.mode === 'romloader',
+  };
+}
+
+export function getProtocolV2ComponentReleaseInfo(
+  plan: ProtocolV2FirmwareReleasePlan,
+  componentTarget: IProtocolV2FirmwareComponentTarget
+): ProtocolV2ComponentReleaseInfo | undefined {
+  const componentRelease = plan.components.find(
+    component => component.componentTarget === componentTarget
+  );
+  if (!componentRelease || !plan.release) {
+    return undefined;
+  }
+  const component = plan.release.components?.[componentRelease.configKey];
+  if (!component) {
+    return undefined;
+  }
+  return {
+    ...component,
+    protocol: 'V2',
+    configKey: componentRelease.configKey,
+    componentTarget,
+    required: plan.release.required,
+    changelog: plan.release.changelog,
+  };
+}

package/src/data-manager/DataManager.ts

@@ -94,12 +94,10 @@ export default class DataManager {
       ble: [],
     },
     [EDeviceType.Pro2]: {
-      firmware: [],
-      ble: [],
+      'firmware-v1': [],
     },
     [EDeviceType.Neo]: {
-      firmware: [],
-      ble: [],
+      'firmware-v1': [],
     },
     [EDeviceType.ClassicPure]: {
       firmware: [],
@@ -121,6 +119,8 @@ export default class DataManager {
 
   static protocolV2ResourcesConfigError: Error | undefined;
 
+  private static protocolV2NeoResourcesConfigError: Error | undefined;
+
   static getFirmwareStatus = (
     features: Features,
     firmwareType: EFirmwareType
@@ -410,6 +410,7 @@ export default class DataManager {
   static async load(settings: ConnectSettings): Promise<boolean> {
     this.settings = settings;
     this.protocolV2ResourcesConfigError = undefined;
+    this.protocolV2NeoResourcesConfigError = undefined;
     const manifestMode =
       settings.firmwareManifestMode ?? (settings.fetchConfig ? 'sdk-managed' : undefined);
     if (settings.preloadedConfig) {
@@ -476,15 +477,21 @@ export default class DataManager {
       pro2Resources = parseProtocolV2Resources(
         (data.pro2 as { resources?: unknown } | undefined)?.resources
       );
-      neoResources = parseProtocolV2Resources(
-        (data.neo as { resources?: unknown } | undefined)?.resources
-      );
     } catch (error) {
       // Firmware resource metadata is not required for base communication. If the
       // remote config is temporarily incomplete, disable this resource update only.
       this.protocolV2ResourcesConfigError =
         error instanceof Error ? error : new Error(String(error));
-      Log.warn('[DataConfig] Ignoring invalid Protocol V2 resources config:', error);
+      Log.warn('[DataConfig] Ignoring invalid Pro2 resources config:', error);
+    }
+    try {
+      neoResources = parseProtocolV2Resources(
+        (data.neo as { resources?: unknown } | undefined)?.resources
+      );
+    } catch (error) {
+      this.protocolV2NeoResourcesConfigError =
+        error instanceof Error ? error : new Error(String(error));
+      Log.warn('[DataConfig] Ignoring invalid Neo resources config:', error);
     }
     const enrichedPro2Config = this.enrichFirmwareReleaseInfo(data.pro2);
     const enrichedNeoConfig = this.enrichFirmwareReleaseInfo(data.neo);
@@ -537,7 +544,12 @@ export default class DataManager {
   /** Force a fresh remote config before an update is allowed to mutate the device. */
   static async forceReloadData({
     requireResources = false,
-  }: { requireResources?: boolean } = {}): Promise<void> {
+    resourceDeviceType = EDeviceType.Pro2,
+  }: {
+    requireResources?: boolean;
+    resourceDeviceType?: EDeviceType.Pro2 | EDeviceType.Neo;
+  } = {}): Promise<void> {
+    const resourceDeviceName = resourceDeviceType === EDeviceType.Pro2 ? 'Pro2' : 'Neo';
     if (!this.settings) {
       throw new Error('Remote config settings are not initialized');
     }
@@ -545,10 +557,14 @@ export default class DataManager {
       this.lastCheckTimestamp > 0 &&
       getTimeStamp() - this.lastCheckTimestamp <= FIRMWARE_UPDATE_CONFIG_FRESHNESS_MS;
     if (hasFreshConfig) {
-      if (requireResources && this.protocolV2ResourcesConfigError) {
+      const resourcesConfigError =
+        resourceDeviceType === EDeviceType.Pro2
+          ? this.protocolV2ResourcesConfigError
+          : this.protocolV2NeoResourcesConfigError;
+      if (requireResources && resourcesConfigError) {
         throw ERRORS.TypedError(
           HardwareErrorCode.FirmwareUpdateDownloadFailed,
-          `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`
+          `Invalid ${resourceDeviceName} resources config: ${resourcesConfigError.message}`
         );
       }
       return;
@@ -560,23 +576,23 @@ export default class DataManager {
         'Unable to refresh the latest remote config'
       );
     }
-    if (requireResources && this.protocolV2ResourcesConfigError) {
+    const resourcesConfigError =
+      resourceDeviceType === EDeviceType.Pro2
+        ? this.protocolV2ResourcesConfigError
+        : this.protocolV2NeoResourcesConfigError;
+    if (requireResources && resourcesConfigError) {
       throw ERRORS.TypedError(
         HardwareErrorCode.FirmwareUpdateDownloadFailed,
-        `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`
+        `Invalid ${resourceDeviceName} resources config: ${resourcesConfigError.message}`
       );
     }
     this.lastCheckTimestamp = getTimeStamp();
   }
 
-  static getProtocolV2Resources(deviceType: EDeviceType.Pro2 | EDeviceType.Neo = EDeviceType.Pro2) {
-    return this.deviceMap[deviceType]?.resources?.stable;
-  }
-
-  static getProtocolV2BootResources(
+  static getProtocolV2ResourceSource(
     deviceType: EDeviceType.Pro2 | EDeviceType.Neo = EDeviceType.Pro2
   ) {
-    return this.deviceMap[deviceType]?.resources?.boot;
+    return this.deviceMap[deviceType]?.resources?.source;
   }
 
   static getProtobufMessages(schema: ProtobufMessageSchema = 'v1CurrentSchema'): JSON {

package/src/index.ts

@@ -21,6 +21,16 @@ export { executeCallback, cleanupCallback };
 export { preloadSessionCache } from './device/Device';
 export { projectFeatures as projectDeviceStateFeatures } from './device/DeviceStateProjector';
 export { getMethodSupportedProtocols } from './api/utils';
+export {
+  parseProtocolV2ResourceManifest,
+  selectProtocolV2ResourceManifestFiles,
+} from './protocols/protocol-v2/resources';
+export { prepareFirmwareUpdateV4MemoryHost } from './api/firmware/FirmwareMemoryHost';
+export type {
+  FirmwareMemoryArtifact,
+  FirmwareMemoryArtifactEntry,
+  FirmwareUpdateV4MemoryHost,
+} from './api/firmware/FirmwareMemoryHost';
 export {
   getFirmwareUpdateHostBindingGeneration,
   registerFirmwareUpdateHostBinding,