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

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,