@onekeyfe/hd-core 1.1.28 → 1.2.0-alpha.1

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -0,0 +1,368 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import type { Features } from '../types';
+import type { PROTO } from '../constants';
+import type { DevFirmwareImageInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+
+type ProtocolV2DeviceInfoCompat = ProtocolV2DeviceInfo & {
+  fw?: ProtocolV2DeviceInfo['fw'] & {
+    application?: DevFirmwareImageInfo | null;
+    application_data?: DevFirmwareImageInfo | null;
+    bootloader?: DevFirmwareImageInfo | null;
+    romloader?: DevFirmwareImageInfo | null;
+  };
+  coprocessor?: {
+    application?: DevFirmwareImageInfo | null;
+    bootloader?: DevFirmwareImageInfo | null;
+    bt_adv_name?: string | null;
+    bt_mac?: unknown;
+  } | null;
+};
+
+type ProtocolV1FeaturesCompat = PROTO.Features &
+  Partial<PROTO.OnekeyFeatures> & {
+    protocol_version?: number | null;
+    onekey_version?: string;
+    onekey_serial?: string;
+  };
+
+const getImageVersion = (image?: DevFirmwareImageInfo | null) => image?.version ?? null;
+
+const bytesToHex = (value: unknown): string | undefined => {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (value instanceof Uint8Array) {
+    return Array.from(value)
+      .map(byte => byte.toString(16).padStart(2, '0'))
+      .join('');
+  }
+  if (Array.isArray(value)) {
+    return value.map(byte => Number(byte).toString(16).padStart(2, '0')).join('');
+  }
+  return undefined;
+};
+
+const getImageBuildId = (image?: DevFirmwareImageInfo | null) => image?.build_id ?? undefined;
+
+const getImageHash = (image?: DevFirmwareImageInfo | null) => bytesToHex(image?.hash);
+
+const firstValue = <T>(...values: Array<T | null | undefined>) =>
+  values.find(value => value !== undefined && value !== null);
+
+const firstMeaningfulVersion = (...versions: Array<string | null | undefined>) =>
+  versions.find(version => Boolean(version && version !== '0.0.0')) ?? null;
+
+const versionFromParts = (major?: number | null, minor?: number | null, patch?: number | null) =>
+  [major, minor, patch].map(part => Number(part) || 0).join('.');
+
+const getProtocolV1Mode = (features: ProtocolV1FeaturesCompat): Features['mode'] => {
+  if (features.bootloader_mode === true) return 'bootloader';
+  if (features.initialized === false) return 'notInitialized';
+  if (features.initialized === true) return 'normal';
+  return 'unknown';
+};
+
+const getProtocolV1DeviceType = (features: ProtocolV1FeaturesCompat): Features['deviceType'] => {
+  const onekeyDeviceType = features.onekey_device_type as string | null | undefined;
+  switch (onekeyDeviceType) {
+    case 'CLASSIC':
+      return EDeviceType.Classic;
+    case 'CLASSIC1S':
+      return EDeviceType.Classic1s;
+    case 'MINI':
+      return EDeviceType.Mini;
+    case 'TOUCH':
+      return EDeviceType.Touch;
+    case 'PRO':
+      return EDeviceType.Pro;
+    case 'PRO2':
+    case 'pro2':
+      return EDeviceType.Pro2;
+    case 'PURE':
+      return EDeviceType.ClassicPure;
+    default:
+      break;
+  }
+
+  const serialNo = features.onekey_serial_no || features.onekey_serial || features.serial_no || '';
+  const prefix = serialNo.slice(0, 2).toLowerCase();
+  if (prefix === 'bi' || prefix === 'cl') return EDeviceType.Classic;
+  if (prefix === 'cp') return EDeviceType.ClassicPure;
+  if (prefix === 'mi') return EDeviceType.Mini;
+  if (prefix === 'tc') return EDeviceType.Touch;
+  if (prefix === 'pr') return EDeviceType.Pro;
+  if (prefix === 'p2') return EDeviceType.Pro2;
+  if (!serialNo && features.bootloader_mode === true && features.model === '1') {
+    return EDeviceType.Classic;
+  }
+  return EDeviceType.Unknown;
+};
+
+const getProtocolV1FirmwareType = (
+  features: ProtocolV1FeaturesCompat
+): Features['firmwareType'] => {
+  if (features.fw_vendor === 'OneKey Bitcoin-only') return EFirmwareType.BitcoinOnly;
+  return EFirmwareType.Universal;
+};
+
+const getProtocolV1Label = (
+  features: ProtocolV1FeaturesCompat,
+  deviceType: Features['deviceType'],
+  bleName: string | null
+) => {
+  if (features.label) return features.label;
+  if (bleName) return bleName;
+  if (deviceType === EDeviceType.Unknown) return null;
+  if (deviceType === EDeviceType.ClassicPure) return 'OneKey Classic 1S';
+  return `OneKey ${deviceType.charAt(0).toUpperCase()}${deviceType.slice(1)}`;
+};
+
+export const buildProtocolV1FeaturesPayload = (
+  protocolV1Features: PROTO.Features,
+  previous?: Features
+): Features => {
+  const features = protocolV1Features as ProtocolV1FeaturesCompat;
+  const firmwareVersion = firstMeaningfulVersion(
+    features.onekey_firmware_version,
+    features.onekey_version,
+    versionFromParts(features.major_version, features.minor_version, features.patch_version)
+  );
+  const bootloaderVersion = firstMeaningfulVersion(
+    features.onekey_boot_version,
+    features.bootloader_version,
+    features.bootloader_mode
+      ? versionFromParts(features.major_version, features.minor_version, features.patch_version)
+      : null
+  );
+  const boardVersion = firstMeaningfulVersion(
+    features.onekey_board_version,
+    features.boardloader_version
+  );
+  const bleVersion = firstMeaningfulVersion(features.onekey_ble_version, features.ble_ver);
+  const serialNo = features.onekey_serial_no || features.onekey_serial || features.serial_no || '';
+  const bleName = features.onekey_ble_name || features.ble_name || null;
+  const deviceType = getProtocolV1DeviceType(features);
+  const sessionId = features.session_id ?? previous?.sessionId ?? null;
+
+  return {
+    protocol: 'V1',
+    protocolVersion: features.protocol_version ?? previous?.protocolVersion ?? 1,
+    deviceType,
+    firmwareType: getProtocolV1FirmwareType(features),
+    model: features.model ?? null,
+    vendor: features.vendor ?? null,
+    deviceId: features.device_id ?? null,
+    serialNo,
+    label: getProtocolV1Label(features, deviceType, bleName),
+    bleName,
+    capabilities: features.capabilities ?? [],
+    mode: getProtocolV1Mode(features),
+    initialized: features.initialized ?? null,
+    bootloaderMode: features.bootloader_mode ?? null,
+    unlocked: features.unlocked ?? true,
+    firmwarePresent: features.firmware_present ?? null,
+    passphraseProtection: features.passphrase_protection ?? null,
+    pinProtection: features.pin_protection ?? null,
+    backupRequired: features.needs_backup ?? null,
+    noBackup: features.no_backup ?? null,
+    unfinishedBackup: features.unfinished_backup ?? null,
+    recoveryMode: features.recovery_mode ?? null,
+    language: features.language ?? null,
+    bleEnabled: features.ble_enable ?? null,
+    sdCardPresent: features.sd_card_present ?? null,
+    sdProtection: features.sd_protection ?? null,
+    wipeCodeProtection: features.wipe_code_protection ?? null,
+    passphraseAlwaysOnDevice: features.passphrase_always_on_device ?? null,
+    safetyChecks: features.safety_checks ?? null,
+    autoLockDelayMs: features.auto_lock_delay_ms ?? null,
+    displayRotation: features.display_rotation ?? null,
+    experimentalFeatures: features.experimental_features ?? null,
+    firmwareVersion,
+    bootloaderVersion,
+    boardVersion,
+    bleVersion,
+    se01Version: firstMeaningfulVersion(features.onekey_se01_version),
+    se02Version: firstMeaningfulVersion(features.onekey_se02_version),
+    se03Version: firstMeaningfulVersion(features.onekey_se03_version),
+    se04Version: firstMeaningfulVersion(features.onekey_se04_version),
+    se01BootVersion: firstMeaningfulVersion(features.onekey_se01_boot_version),
+    se02BootVersion: firstMeaningfulVersion(features.onekey_se02_boot_version),
+    se03BootVersion: firstMeaningfulVersion(features.onekey_se03_boot_version),
+    se04BootVersion: firstMeaningfulVersion(features.onekey_se04_boot_version),
+    seVersion: features.se_ver ?? null,
+    verify: {
+      firmwareBuildId: features.onekey_firmware_build_id,
+      firmwareHash: features.onekey_firmware_hash,
+      bootloaderBuildId: features.onekey_boot_build_id,
+      bootloaderHash: features.onekey_boot_hash,
+      boardBuildId: features.onekey_board_build_id,
+      boardHash: features.onekey_board_hash,
+      bleBuildId: features.onekey_ble_build_id,
+      bleHash: features.onekey_ble_hash,
+      se01BuildId: features.onekey_se01_build_id,
+      se01Hash: features.onekey_se01_hash,
+      se02BuildId: features.onekey_se02_build_id,
+      se02Hash: features.onekey_se02_hash,
+      se03BuildId: features.onekey_se03_build_id,
+      se03Hash: features.onekey_se03_hash,
+      se04BuildId: features.onekey_se04_build_id,
+      se04Hash: features.onekey_se04_hash,
+      se01BootBuildId: features.onekey_se01_boot_build_id,
+      se01BootHash: features.onekey_se01_boot_hash,
+      se02BootBuildId: features.onekey_se02_boot_build_id,
+      se02BootHash: features.onekey_se02_boot_hash,
+      se03BootBuildId: features.onekey_se03_boot_build_id,
+      se03BootHash: features.onekey_se03_boot_hash,
+      se04BootBuildId: features.onekey_se04_boot_build_id,
+      se04BootHash: features.onekey_se04_boot_hash,
+    },
+    sessionId,
+    raw: {
+      protocolV1Features: protocolV1Features,
+    },
+  };
+};
+
+/**
+ * Protocol V2 的结构化 `Features` 构建器。
+ *
+ * 这是 Device 内部唯一缓存状态。字段只来自 DevGetDeviceInfo 或前一次 features
+ * 缓存的同名字段级合并；不存在协议等价语义的字段保持 null/空值，不再通过
+ * DeviceProfile 或 transport path 做身份兜底。
+ */
+export const buildProtocolV2FeaturesPayload = (
+  deviceInfo?: ProtocolV2DeviceInfo,
+  previous?: Features
+): Features => {
+  const info = deviceInfo as ProtocolV2DeviceInfoCompat | undefined;
+  const fwApplication = firstValue(info?.fw?.application, info?.fw?.app);
+  const fwBootloader = firstValue(info?.fw?.bootloader, info?.fw?.boot);
+  const fwBoard = firstValue(info?.fw?.application_data, info?.fw?.board);
+  const bleApplication = firstValue(info?.coprocessor?.application, info?.bt?.app);
+
+  const firmwareVersion = firstMeaningfulVersion(
+    getImageVersion(fwApplication),
+    previous?.firmwareVersion
+  );
+  const bootloaderVersion = firstMeaningfulVersion(
+    getImageVersion(fwBootloader),
+    previous?.bootloaderVersion
+  );
+  const boardVersion = firstMeaningfulVersion(getImageVersion(fwBoard), previous?.boardVersion);
+  const bleVersion = firstMeaningfulVersion(getImageVersion(bleApplication), previous?.bleVersion);
+  const deviceId = firstValue(info?.hw?.device_id, previous?.deviceId) ?? null;
+  const serialNo = firstValue(info?.hw?.serial_no, previous?.serialNo) ?? '';
+  const label = firstValue(deviceInfo?.status?.label, previous?.label) ?? null;
+  const bleName = firstValue(info?.coprocessor?.bt_adv_name, info?.bt?.adv_name, previous?.bleName);
+  const initialized = firstValue(deviceInfo?.status?.init_states, previous?.initialized) ?? null;
+  const passphraseProtection =
+    firstValue(deviceInfo?.status?.passphrase_protection, previous?.passphraseProtection) ?? null;
+  const language = firstValue(deviceInfo?.status?.language, previous?.language) ?? null;
+  const backupRequired =
+    firstValue(deviceInfo?.status?.backup_required, previous?.backupRequired) ?? null;
+  const bleEnabled = firstValue(deviceInfo?.status?.bt_enable, previous?.bleEnabled);
+
+  return {
+    protocol: 'V2',
+    protocolVersion: deviceInfo?.protocol_version ?? previous?.protocolVersion ?? null,
+    deviceType: EDeviceType.Pro2,
+    firmwareType: previous?.firmwareType ?? EFirmwareType.Universal,
+    model: 'pro2',
+    vendor: 'onekey.so',
+    deviceId,
+    serialNo,
+    label,
+    bleName: bleName ?? null,
+    capabilities: [],
+    mode: initialized === false ? 'notInitialized' : initialized === true ? 'normal' : 'unknown',
+    initialized,
+    bootloaderMode: false,
+    unlocked: previous?.unlocked ?? null,
+    firmwarePresent: previous?.firmwarePresent ?? null,
+    passphraseProtection,
+    pinProtection: null,
+    backupRequired,
+    noBackup: null,
+    unfinishedBackup: null,
+    recoveryMode: null,
+    language,
+    bleEnabled: bleEnabled ?? null,
+    sdCardPresent: null,
+    sdProtection: null,
+    wipeCodeProtection: null,
+    passphraseAlwaysOnDevice: null,
+    safetyChecks: null,
+    autoLockDelayMs: null,
+    displayRotation: null,
+    experimentalFeatures: null,
+    firmwareVersion,
+    bootloaderVersion,
+    boardVersion,
+    bleVersion,
+    se01Version: firstMeaningfulVersion(
+      getImageVersion(deviceInfo?.se1?.app),
+      previous?.se01Version
+    ),
+    se02Version: firstMeaningfulVersion(
+      getImageVersion(deviceInfo?.se2?.app),
+      previous?.se02Version
+    ),
+    se03Version: firstMeaningfulVersion(
+      getImageVersion(deviceInfo?.se3?.app),
+      previous?.se03Version
+    ),
+    se04Version: firstMeaningfulVersion(
+      getImageVersion(deviceInfo?.se4?.app),
+      previous?.se04Version
+    ),
+    se01BootVersion: firstMeaningfulVersion(
+      getImageVersion(deviceInfo?.se1?.boot),
+      previous?.se01BootVersion
+    ),
+    se02BootVersion: firstMeaningfulVersion(
+      getImageVersion(deviceInfo?.se2?.boot),
+      previous?.se02BootVersion
+    ),
+    se03BootVersion: firstMeaningfulVersion(
+      getImageVersion(deviceInfo?.se3?.boot),
+      previous?.se03BootVersion
+    ),
+    se04BootVersion: firstMeaningfulVersion(
+      getImageVersion(deviceInfo?.se4?.boot),
+      previous?.se04BootVersion
+    ),
+    seVersion: previous?.seVersion ?? null,
+    verify: {
+      firmwareBuildId: getImageBuildId(fwApplication) ?? previous?.verify?.firmwareBuildId,
+      firmwareHash: getImageHash(fwApplication) ?? previous?.verify?.firmwareHash,
+      bootloaderBuildId: getImageBuildId(fwBootloader) ?? previous?.verify?.bootloaderBuildId,
+      bootloaderHash: getImageHash(fwBootloader) ?? previous?.verify?.bootloaderHash,
+      boardBuildId: getImageBuildId(fwBoard) ?? previous?.verify?.boardBuildId,
+      boardHash: getImageHash(fwBoard) ?? previous?.verify?.boardHash,
+      bleBuildId: getImageBuildId(bleApplication) ?? previous?.verify?.bleBuildId,
+      bleHash: getImageHash(bleApplication) ?? previous?.verify?.bleHash,
+      se01BuildId: getImageBuildId(deviceInfo?.se1?.app) ?? previous?.verify?.se01BuildId,
+      se01Hash: getImageHash(deviceInfo?.se1?.app) ?? previous?.verify?.se01Hash,
+      se02BuildId: getImageBuildId(deviceInfo?.se2?.app) ?? previous?.verify?.se02BuildId,
+      se02Hash: getImageHash(deviceInfo?.se2?.app) ?? previous?.verify?.se02Hash,
+      se03BuildId: getImageBuildId(deviceInfo?.se3?.app) ?? previous?.verify?.se03BuildId,
+      se03Hash: getImageHash(deviceInfo?.se3?.app) ?? previous?.verify?.se03Hash,
+      se04BuildId: getImageBuildId(deviceInfo?.se4?.app) ?? previous?.verify?.se04BuildId,
+      se04Hash: getImageHash(deviceInfo?.se4?.app) ?? previous?.verify?.se04Hash,
+      se01BootBuildId: getImageBuildId(deviceInfo?.se1?.boot) ?? previous?.verify?.se01BootBuildId,
+      se01BootHash: getImageHash(deviceInfo?.se1?.boot) ?? previous?.verify?.se01BootHash,
+      se02BootBuildId: getImageBuildId(deviceInfo?.se2?.boot) ?? previous?.verify?.se02BootBuildId,
+      se02BootHash: getImageHash(deviceInfo?.se2?.boot) ?? previous?.verify?.se02BootHash,
+      se03BootBuildId: getImageBuildId(deviceInfo?.se3?.boot) ?? previous?.verify?.se03BootBuildId,
+      se03BootHash: getImageHash(deviceInfo?.se3?.boot) ?? previous?.verify?.se03BootHash,
+      se04BootBuildId: getImageBuildId(deviceInfo?.se4?.boot) ?? previous?.verify?.se04BootBuildId,
+      se04BootHash: getImageHash(deviceInfo?.se4?.boot) ?? previous?.verify?.se04BootHash,
+    },
+    sessionId: previous?.sessionId ?? null,
+    passphraseState: previous?.passphraseState,
+    unlockedAttachPin: previous?.unlockedAttachPin,
+    raw: {
+      protocolV2DeviceInfo: deviceInfo,
+    },
+  };
+};

package/src/deviceProfile/buildDeviceProfile.ts

@@ -0,0 +1,333 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import {
+  getDeviceBLEFirmwareVersion,
+  getDeviceBoardloaderVersion,
+  getDeviceBootloaderVersion,
+  getDeviceFirmwareVersion,
+} from '../utils/deviceVersionUtils';
+import {
+  getDeviceBleName,
+  getDeviceLabel,
+  getDeviceType,
+  getDeviceUUID,
+  getFirmwareType,
+} from '../utils/deviceInfoUtils';
+
+import type {
+  DeviceInfoProtocol,
+  DeviceInfoSource,
+  DeviceInfoStatus,
+  DeviceProfile,
+  DeviceProfileRaw,
+  DeviceProfileVerify,
+  DeviceProfileVersions,
+  GetDeviceInfoParams,
+} from '../types/api/getDeviceInfo';
+import type { Features, OnekeyFeatures } from '../types';
+import type { DevFirmwareImageInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+
+type BuildProtocolV1ProfileParams = {
+  protocol?: DeviceInfoProtocol;
+  features?: Features;
+  protocolV1OneKeyFeatures?: OnekeyFeatures;
+  sources?: DeviceInfoSource[];
+  scope?: GetDeviceInfoParams['scope'];
+  includeRaw?: boolean;
+};
+
+type BuildProtocolV2ProfileParams = {
+  deviceInfo?: ProtocolV2DeviceInfo;
+  sources?: DeviceInfoSource[];
+  scope?: GetDeviceInfoParams['scope'];
+  includeRaw?: boolean;
+};
+
+const isMeaningfulVersion = (version?: string | null) => Boolean(version && version !== '0.0.0');
+
+const firstMeaningfulVersion = (...versions: Array<string | null | undefined>) =>
+  versions.find(isMeaningfulVersion) ?? null;
+
+const versionArrayToString = (version?: Array<number | string | null> | null) => {
+  if (!version || version.length === 0) return null;
+  const value = version.join('.');
+  return isMeaningfulVersion(value) ? value : null;
+};
+
+const bytesToHex = (value: unknown): string | undefined => {
+  if (!value) return undefined;
+  if (typeof value === 'string') return value;
+  if (value instanceof Uint8Array) {
+    return Array.from(value)
+      .map(byte => byte.toString(16).padStart(2, '0'))
+      .join('');
+  }
+  if (Array.isArray(value)) {
+    return value.map(byte => Number(byte).toString(16).padStart(2, '0')).join('');
+  }
+  return undefined;
+};
+
+const getImageVersion = (image?: DevFirmwareImageInfo | null) => image?.version ?? null;
+
+const getImageBuildId = (image?: DevFirmwareImageInfo | null) => image?.build_id ?? undefined;
+
+const getImageHash = (image?: DevFirmwareImageInfo | null) => bytesToHex(image?.hash);
+
+const shouldIncludeVerify = (scope?: GetDeviceInfoParams['scope']) =>
+  scope === 'verify' || scope === 'full';
+
+const getDeviceMode = (features?: Features): DeviceInfoStatus['mode'] => {
+  if (!features) return 'unknown';
+  if (features.bootloaderMode === true) return 'bootloader';
+  if (features.initialized === false) return 'notInitialized';
+  if (features.initialized === true) return 'normal';
+  return 'unknown';
+};
+
+const getProtocolV2Mode = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus['mode'] => {
+  const initialized = deviceInfo?.status?.init_states;
+  if (initialized === false) return 'notInitialized';
+  if (initialized === true) return 'normal';
+  return 'unknown';
+};
+
+const normalizeV1Versions = (
+  features?: Features,
+  protocolV1OneKeyFeatures?: OnekeyFeatures
+): DeviceProfileVersions => ({
+  firmware: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_firmware_version,
+    versionArrayToString(getDeviceFirmwareVersion(features))
+  ),
+  bootloader: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_boot_version,
+    versionArrayToString(getDeviceBootloaderVersion(features))
+  ),
+  board: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_board_version,
+    versionArrayToString(features ? getDeviceBoardloaderVersion(features) : undefined)
+  ),
+  ble: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_ble_version,
+    features?.bleVersion,
+    versionArrayToString(features ? getDeviceBLEFirmwareVersion(features) : undefined)
+  ),
+  se01: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se01_version,
+    features?.se01Version
+  ),
+  se02: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se02_version,
+    features?.se02Version
+  ),
+  se03: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se03_version,
+    features?.se03Version
+  ),
+  se04: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se04_version,
+    features?.se04Version
+  ),
+  se01Boot: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se01_boot_version,
+    features?.se01BootVersion
+  ),
+  se02Boot: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se02_boot_version,
+    features?.se02BootVersion
+  ),
+  se03Boot: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se03_boot_version,
+    features?.se03BootVersion
+  ),
+  se04Boot: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se04_boot_version,
+    features?.se04BootVersion
+  ),
+});
+
+const normalizeV2Versions = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVersions => ({
+  firmware: firstMeaningfulVersion(getImageVersion(deviceInfo?.fw?.app)),
+  bootloader: firstMeaningfulVersion(getImageVersion(deviceInfo?.fw?.boot)),
+  board: firstMeaningfulVersion(getImageVersion(deviceInfo?.fw?.board)),
+  ble: firstMeaningfulVersion(getImageVersion(deviceInfo?.bt?.app)),
+  se01: firstMeaningfulVersion(getImageVersion(deviceInfo?.se1?.app)),
+  se02: firstMeaningfulVersion(getImageVersion(deviceInfo?.se2?.app)),
+  se03: firstMeaningfulVersion(getImageVersion(deviceInfo?.se3?.app)),
+  se04: firstMeaningfulVersion(getImageVersion(deviceInfo?.se4?.app)),
+  se01Boot: firstMeaningfulVersion(getImageVersion(deviceInfo?.se1?.boot)),
+  se02Boot: firstMeaningfulVersion(getImageVersion(deviceInfo?.se2?.boot)),
+  se03Boot: firstMeaningfulVersion(getImageVersion(deviceInfo?.se3?.boot)),
+  se04Boot: firstMeaningfulVersion(getImageVersion(deviceInfo?.se4?.boot)),
+});
+
+// V2 状态由 normalizeV2Status 处理，这里只服务 buildProfileFromProtocolV1 的 V1 路径。
+const normalizeV1Status = (features?: Features): DeviceInfoStatus => ({
+  mode: getDeviceMode(features),
+  initialized: features?.initialized ?? null,
+  bootloaderMode: features?.bootloaderMode ?? null,
+  unlocked: features?.unlocked ?? null,
+  passphraseProtection: features?.passphraseProtection ?? null,
+  backupRequired: features?.backupRequired ?? null,
+  noBackup: features?.noBackup ?? null,
+  language: features?.language ?? null,
+  bleEnabled: features?.bleEnabled ?? null,
+});
+
+const normalizeV2Status = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus => ({
+  mode: getProtocolV2Mode(deviceInfo),
+  initialized: deviceInfo?.status?.init_states ?? null,
+  bootloaderMode: false,
+  unlocked: null,
+  passphraseProtection: deviceInfo?.status?.passphrase_protection ?? null,
+  backupRequired: deviceInfo?.status?.backup_required ?? null,
+  noBackup: null,
+  language: deviceInfo?.status?.language ?? null,
+  bleEnabled: deviceInfo?.status?.bt_enable ?? null,
+});
+
+const normalizeV1Verify = (
+  features?: Features,
+  protocolV1OneKeyFeatures?: OnekeyFeatures
+): DeviceProfileVerify => ({
+  firmwareBuildId:
+    protocolV1OneKeyFeatures?.onekey_firmware_build_id ?? features?.verify?.firmwareBuildId,
+  firmwareHash: protocolV1OneKeyFeatures?.onekey_firmware_hash ?? features?.verify?.firmwareHash,
+  bootloaderBuildId:
+    protocolV1OneKeyFeatures?.onekey_boot_build_id ?? features?.verify?.bootloaderBuildId,
+  bootloaderHash: protocolV1OneKeyFeatures?.onekey_boot_hash ?? features?.verify?.bootloaderHash,
+  boardBuildId: protocolV1OneKeyFeatures?.onekey_board_build_id ?? features?.verify?.boardBuildId,
+  boardHash: protocolV1OneKeyFeatures?.onekey_board_hash ?? features?.verify?.boardHash,
+  bleBuildId: protocolV1OneKeyFeatures?.onekey_ble_build_id ?? features?.verify?.bleBuildId,
+  bleHash: protocolV1OneKeyFeatures?.onekey_ble_hash ?? features?.verify?.bleHash,
+  se01BuildId: protocolV1OneKeyFeatures?.onekey_se01_build_id ?? features?.verify?.se01BuildId,
+  se01Hash: protocolV1OneKeyFeatures?.onekey_se01_hash ?? features?.verify?.se01Hash,
+  se02BuildId: protocolV1OneKeyFeatures?.onekey_se02_build_id ?? features?.verify?.se02BuildId,
+  se02Hash: protocolV1OneKeyFeatures?.onekey_se02_hash ?? features?.verify?.se02Hash,
+  se03BuildId: protocolV1OneKeyFeatures?.onekey_se03_build_id ?? features?.verify?.se03BuildId,
+  se03Hash: protocolV1OneKeyFeatures?.onekey_se03_hash ?? features?.verify?.se03Hash,
+  se04BuildId: protocolV1OneKeyFeatures?.onekey_se04_build_id ?? features?.verify?.se04BuildId,
+  se04Hash: protocolV1OneKeyFeatures?.onekey_se04_hash ?? features?.verify?.se04Hash,
+  se01BootBuildId:
+    protocolV1OneKeyFeatures?.onekey_se01_boot_build_id ?? features?.verify?.se01BootBuildId,
+  se01BootHash: protocolV1OneKeyFeatures?.onekey_se01_boot_hash ?? features?.verify?.se01BootHash,
+  se02BootBuildId:
+    protocolV1OneKeyFeatures?.onekey_se02_boot_build_id ?? features?.verify?.se02BootBuildId,
+  se02BootHash: protocolV1OneKeyFeatures?.onekey_se02_boot_hash ?? features?.verify?.se02BootHash,
+  se03BootBuildId:
+    protocolV1OneKeyFeatures?.onekey_se03_boot_build_id ?? features?.verify?.se03BootBuildId,
+  se03BootHash: protocolV1OneKeyFeatures?.onekey_se03_boot_hash ?? features?.verify?.se03BootHash,
+  se04BootBuildId:
+    protocolV1OneKeyFeatures?.onekey_se04_boot_build_id ?? features?.verify?.se04BootBuildId,
+  se04BootHash: protocolV1OneKeyFeatures?.onekey_se04_boot_hash ?? features?.verify?.se04BootHash,
+});
+
+const normalizeV2Verify = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVerify => ({
+  firmwareBuildId: getImageBuildId(deviceInfo?.fw?.app),
+  firmwareHash: getImageHash(deviceInfo?.fw?.app),
+  bootloaderBuildId: getImageBuildId(deviceInfo?.fw?.boot),
+  bootloaderHash: getImageHash(deviceInfo?.fw?.boot),
+  boardBuildId: getImageBuildId(deviceInfo?.fw?.board),
+  boardHash: getImageHash(deviceInfo?.fw?.board),
+  bleBuildId: getImageBuildId(deviceInfo?.bt?.app),
+  bleHash: getImageHash(deviceInfo?.bt?.app),
+  se01BuildId: getImageBuildId(deviceInfo?.se1?.app),
+  se01Hash: getImageHash(deviceInfo?.se1?.app),
+  se02BuildId: getImageBuildId(deviceInfo?.se2?.app),
+  se02Hash: getImageHash(deviceInfo?.se2?.app),
+  se03BuildId: getImageBuildId(deviceInfo?.se3?.app),
+  se03Hash: getImageHash(deviceInfo?.se3?.app),
+  se04BuildId: getImageBuildId(deviceInfo?.se4?.app),
+  se04Hash: getImageHash(deviceInfo?.se4?.app),
+  se01BootBuildId: getImageBuildId(deviceInfo?.se1?.boot),
+  se01BootHash: getImageHash(deviceInfo?.se1?.boot),
+  se02BootBuildId: getImageBuildId(deviceInfo?.se2?.boot),
+  se02BootHash: getImageHash(deviceInfo?.se2?.boot),
+  se03BootBuildId: getImageBuildId(deviceInfo?.se3?.boot),
+  se03BootHash: getImageHash(deviceInfo?.se3?.boot),
+  se04BootBuildId: getImageBuildId(deviceInfo?.se4?.boot),
+  se04BootHash: getImageHash(deviceInfo?.se4?.boot),
+});
+
+const normalizeRaw = ({
+  features,
+  protocolV1OneKeyFeatures,
+  protocolV2DeviceInfo,
+}: {
+  features?: Features;
+  protocolV1OneKeyFeatures?: OnekeyFeatures;
+  protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
+}): DeviceProfileRaw => ({
+  ...(features ? { features } : {}),
+  ...(protocolV1OneKeyFeatures ? { protocolV1OneKeyFeatures } : {}),
+  ...(protocolV2DeviceInfo ? { protocolV2DeviceInfo } : {}),
+});
+
+export function buildProfileFromProtocolV1({
+  protocol = 'V1',
+  features,
+  protocolV1OneKeyFeatures,
+  sources = ['features'],
+  scope = 'basic',
+  includeRaw = false,
+}: BuildProtocolV1ProfileParams): DeviceProfile {
+  const sourceFeatures = features;
+  const verify = normalizeV1Verify(sourceFeatures, protocolV1OneKeyFeatures);
+
+  return {
+    protocol,
+    sources,
+    deviceType: getDeviceType(sourceFeatures),
+    firmwareType: getFirmwareType(sourceFeatures),
+    deviceId: sourceFeatures?.deviceId || (sourceFeatures ? getDeviceUUID(sourceFeatures) : ''),
+    serialNo: sourceFeatures ? getDeviceUUID(sourceFeatures) : '',
+    label: getDeviceLabel(sourceFeatures),
+    bleName: getDeviceBleName(sourceFeatures),
+    status: normalizeV1Status(sourceFeatures),
+    versions: normalizeV1Versions(sourceFeatures, protocolV1OneKeyFeatures),
+    ...(shouldIncludeVerify(scope) ? { verify } : {}),
+    ...(includeRaw
+      ? {
+          raw: normalizeRaw({
+            features,
+            protocolV1OneKeyFeatures,
+          }),
+        }
+      : {}),
+  };
+}
+
+export function buildProfileFromProtocolV2({
+  deviceInfo,
+  sources = ['deviceInfo'],
+  scope = 'basic',
+  includeRaw = false,
+}: BuildProtocolV2ProfileParams): DeviceProfile {
+  const deviceId = deviceInfo?.hw?.device_id || '';
+  const serialNo = deviceInfo?.hw?.serial_no || '';
+  const label = deviceInfo?.status?.label ?? null;
+  const bleName = deviceInfo?.bt?.adv_name ?? null;
+  const verify = normalizeV2Verify(deviceInfo);
+
+  return {
+    protocol: 'V2',
+    sources,
+    deviceType: EDeviceType.Pro2,
+    firmwareType: EFirmwareType.Universal,
+    deviceId,
+    serialNo,
+    label,
+    bleName,
+    status: normalizeV2Status(deviceInfo),
+    versions: normalizeV2Versions(deviceInfo),
+    ...(shouldIncludeVerify(scope) ? { verify } : {}),
+    ...(includeRaw
+      ? {
+          raw: normalizeRaw({
+            protocolV2DeviceInfo: deviceInfo,
+          }),
+        }
+      : {}),
+  };
+}