@onekeyfe/hd-core 1.2.0-alpha.6 → 1.2.0-alpha.60

package/src/types/device.ts

@@ -1,8 +1,14 @@
-import { EDeviceType, type EFirmwareType } from '@onekeyfe/hd-shared';
+import { EDeviceType, type EFirmwareType, type HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 
 import type { IVersionArray } from './settings';
 import type { PROTO } from '../constants';
-import type { OneKeyDeviceCommType, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+import type {
+  Enum_SafetyCheckLevel,
+  OneKeyDeviceCommType,
+  ProtocolV2DeviceInfo,
+  DeviceStatus as ProtocolV2DeviceStatus,
+  ProtocolInfo as ProtocolV2ProtocolInfo,
+} from '@onekeyfe/hd-transport';
 
 export type DeviceStatus = 'available' | 'occupied' | 'used';
 
@@ -23,6 +29,14 @@ export type UnavailableCapabilities = { [key: string]: UnavailableCapability };
 
 export type KnownDevice = {
   connectId: string | null;
+  /** Protocol family confirmed by the transport's active probe. */
+  connectProtocol?: HardwareConnectProtocol;
+  /**
+   * Stable physical-device identity. Current SDK responses always include this
+   * value; it remains optional in the type during the uuid compatibility window.
+   */
+  serialNo?: string;
+  /** @deprecated Use serialNo instead. */
   uuid: string;
   deviceId: string | null;
   deviceType: IDeviceType | null;
@@ -32,9 +46,12 @@ export type KnownDevice = {
   bleName: string | null;
   name: string;
   error?: typeof undefined;
+  /** Current SDK/transport usage state for connection indicators. */
+  status?: DeviceStatus;
   mode: EOneKeyDeviceMode;
-  features?: Features;
-  sessionId?: string | null;
+  features: Features;
+  /** Unified SDK device-state snapshot; features remains a legacy projection. */
+  state?: DeviceState;
   unavailableCapabilities: UnavailableCapabilities;
   bleFirmwareVersion: IVersionArray | null;
   firmwareVersion: IVersionArray | null;
@@ -47,6 +64,19 @@ export type KnownDevice = {
 
 export type SearchDevice = {
   connectId: string | null;
+  /** Protocol family confirmed by the transport's active probe. */
+  connectProtocol?: HardwareConnectProtocol;
+  /**
+   * Available after device initialization. BLE discovery does not connect to the
+   * device, so it returns null until a later initialized device response. Current
+   * SDK responses always include the field; it remains optional in the type during
+   * the uuid compatibility window.
+   */
+  serialNo?: string | null;
+  /**
+   * @deprecated Ambiguous legacy identifier. Use serialNo for hardware identity
+   * and connectId for transport routing.
+   */
   uuid: string;
   deviceId: string | null;
   deviceType: IDeviceType;
@@ -91,6 +121,7 @@ export type DeviceFeaturesProtocol = 'V1' | 'V2' | 'unknown';
 export type DeviceFeaturesMode =
   | 'normal'
   | 'bootloader'
+  | 'romloader'
   | 'notInitialized'
   | 'backupMode'
   | 'unknown';
@@ -98,6 +129,10 @@ export type DeviceFeaturesMode =
 export type DeviceFeaturesVerify = {
   firmwareBuildId?: string;
   firmwareHash?: string;
+  applicationP1BuildId?: string;
+  applicationP1Hash?: string;
+  applicationP2BuildId?: string;
+  applicationP2Hash?: string;
   bootloaderBuildId?: string;
   bootloaderHash?: string;
   boardBuildId?: string;
@@ -125,10 +160,141 @@ export type DeviceFeaturesVerify = {
 export type DeviceFeaturesRaw = {
   protocolV1Features?: PROTO.Features;
   protocolV1OneKeyFeatures?: OnekeyFeatures;
+  protocolV2ProtocolInfo?: ProtocolV2ProtocolInfo;
   protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
+  protocolV2DeviceStatus?: ProtocolV2DeviceStatus;
 };
 
-export type Features = {
+export type DeviceFeaturesRawPatch = {
+  [Key in keyof DeviceFeaturesRaw]?: DeviceFeaturesRaw[Key] | null;
+};
+
+export type DeviceStateProtocol = DeviceFeaturesProtocol;
+export type DeviceStateMode = DeviceFeaturesMode;
+export type DeviceStateSection = 'identity' | 'status' | 'settings' | 'versions' | 'verification';
+
+export type DeviceStateUpdateSource =
+  | 'initialize'
+  | 'device-info'
+  | 'device-status'
+  | 'settings-read'
+  | 'settings-write'
+  | 'change-pin'
+  | 'lock'
+  | 'unlock'
+  | 'passphrase'
+  | 'session-clear'
+  | 'firmware-update'
+  | 'transport-reconnect'
+  | 'compatibility';
+
+export type DeviceStateIdentity = {
+  deviceType: IDeviceType;
+  firmwareType: EFirmwareType;
+  model: string | null;
+  vendor: string | null;
+  deviceId: string | null;
+  serialNo: string;
+  label: string | null;
+  bleName: string | null;
+};
+
+export type DeviceStateStatus = {
+  mode: DeviceStateMode;
+  initialized: boolean | null;
+  unlocked: boolean | null;
+  firmwarePresent: boolean | null;
+  backupRequired: boolean | null;
+  noBackup: boolean | null;
+  unfinishedBackup: boolean | null;
+  recoveryMode: boolean | null;
+  passphraseProtection: boolean | null;
+  pinProtection: boolean | null;
+  /** `attach_to_pin_enabled`：是否至少存在一个 Attach PIN 绑定。 */
+  attachToPinEnabled: boolean | null;
+  /** `unlocked_by_attach_to_pin`：本次解锁是否由 Attach PIN 完成。 */
+  unlockedAttachPin: boolean | null;
+};
+
+export type DeviceStateSettings = {
+  language: string | null;
+  bleEnabled: boolean | null;
+  sdCardPresent: boolean | null;
+  sdProtection: boolean | null;
+  wipeCodeProtection: boolean | null;
+  passphraseAlwaysOnDevice: boolean | null;
+  safetyChecks: Enum_SafetyCheckLevel | null;
+  autoLockDelayMs: number | null;
+  autoShutdownDelayMs: number | null;
+  displayRotation: number | null;
+  experimentalFeatures: boolean | null;
+  wallpaperPath: string | null;
+  brightness: number | null;
+  animationEnabled: boolean | null;
+  tapToWake: boolean | null;
+  hapticFeedback: boolean | null;
+  deviceNameDisplayEnabled: boolean | null;
+  airgapMode: boolean | null;
+  fidoEnabled: boolean | null;
+  usbLockEnabled: boolean | null;
+  randomKeypad: boolean | null;
+};
+
+export type DeviceStateVersions = {
+  firmware: string | null;
+  applicationP1?: string | null;
+  applicationP2?: string | null;
+  bootloader: string | null;
+  board: string | null;
+  ble: string | null;
+  /** @deprecated Kept for legacy consumers; new code should read se01. */
+  se?: string | null;
+  se01?: string | null;
+  se02?: string | null;
+  se03?: string | null;
+  se04?: string | null;
+  se01Boot?: string | null;
+  se02Boot?: string | null;
+  se03Boot?: string | null;
+  se04Boot?: string | null;
+};
+
+export type DeviceState = {
+  schemaVersion: 1;
+  revision: number;
+  updatedAt: number;
+  protocol: DeviceStateProtocol;
+  /** Device-message protocol version, independent of the SDK V1/V2 protocol family. */
+  protocolVersion: number | null;
+  identity: DeviceStateIdentity;
+  status: DeviceStateStatus;
+  settings: DeviceStateSettings;
+  versions: DeviceStateVersions;
+  capabilities: Array<number | string>;
+  verification?: Partial<DeviceFeaturesVerify>;
+};
+
+export type DeviceStatePatch = {
+  protocol?: DeviceStateProtocol;
+  protocolVersion?: number | null;
+  identity?: Partial<DeviceStateIdentity>;
+  status?: Partial<DeviceStateStatus>;
+  settings?: Partial<DeviceStateSettings>;
+  versions?: Partial<DeviceStateVersions>;
+  capabilities?: Array<number | string>;
+  verification?: DeviceFeaturesVerify;
+  raw?: DeviceFeaturesRawPatch;
+};
+
+export type DeviceStateEvent = {
+  connectId: string | null;
+  state: DeviceState;
+  revision: number;
+  source: DeviceStateUpdateSource;
+  changedKeys: string[];
+};
+
+export type NormalizedFeatures = {
   protocol: DeviceFeaturesProtocol;
   protocolVersion?: number | null;
   deviceType: IDeviceType;
@@ -157,11 +323,23 @@ export type Features = {
   sdProtection: boolean | null;
   wipeCodeProtection: boolean | null;
   passphraseAlwaysOnDevice: boolean | null;
+  /** `attach_to_pin_enabled`：是否至少存在一个 Attach PIN 绑定。 */
   attachToPinEnabled?: boolean | null;
-  safetyChecks: string | null;
+  safetyChecks: Enum_SafetyCheckLevel | null;
   autoLockDelayMs: number | null;
+  autoShutdownDelayMs: number | null;
   displayRotation: number | null;
   experimentalFeatures: boolean | null;
+  wallpaperPath: string | null;
+  brightness: number | null;
+  animationEnabled: boolean | null;
+  tapToWake: boolean | null;
+  hapticFeedback: boolean | null;
+  deviceNameDisplayEnabled: boolean | null;
+  airgapMode: boolean | null;
+  fidoEnabled: boolean | null;
+  usbLockEnabled: boolean | null;
+  randomKeypad: boolean | null;
   firmwareVersion: string | null;
   bootloaderVersion: string | null;
   boardVersion: string | null;
@@ -182,6 +360,10 @@ export type Features = {
   raw?: DeviceFeaturesRaw;
 };
 
+export type Features = NormalizedFeatures &
+  Partial<Omit<PROTO.Features, keyof NormalizedFeatures>> &
+  Partial<Omit<PROTO.OnekeyFeatures, keyof NormalizedFeatures | keyof PROTO.Features>>;
+
 export type OnekeyFeatures = PROTO.OnekeyFeatures;
 
 export type IDeviceType =
@@ -192,14 +374,21 @@ export type IDeviceType =
   | EDeviceType.Mini
   | EDeviceType.Touch
   | EDeviceType.Pro
-  | EDeviceType.Pro2;
+  | EDeviceType.Pro2
+  | EDeviceType.Neo;
 
 /**
  * model_classic: 'classic' | 'classic1s' | 'classicpure'
  * model_mini: 'classic' | 'classic1s' | 'classicpure' | 'mini'
  * model_touch: 'touch' | 'pro'
+ * model_pro2: 'pro2' | 'neo'
  */
-export type IDeviceModel = 'model_classic' | 'model_mini' | 'model_touch' | 'model_classic1s';
+export type IDeviceModel =
+  | 'model_classic'
+  | 'model_mini'
+  | 'model_touch'
+  | 'model_classic1s'
+  | 'model_pro2';
 
 export const DeviceModelToTypes: { [deviceModel in IDeviceModel]: IDeviceType[] } = {
   model_mini: [
@@ -209,6 +398,7 @@ export const DeviceModelToTypes: { [deviceModel in IDeviceModel]: IDeviceType[]
     EDeviceType.Mini,
   ],
   model_touch: [EDeviceType.Touch, EDeviceType.Pro],
+  model_pro2: [EDeviceType.Pro2, EDeviceType.Neo],
   model_classic: [EDeviceType.Classic, EDeviceType.Classic1s, EDeviceType.ClassicPure],
   model_classic1s: [EDeviceType.Classic1s, EDeviceType.ClassicPure],
 };
@@ -220,7 +410,8 @@ export const DeviceTypeToModels: { [deviceType in IDeviceType]: IDeviceModel[] }
   [EDeviceType.Mini]: ['model_mini'],
   [EDeviceType.Touch]: ['model_touch'],
   [EDeviceType.Pro]: ['model_touch'],
-  [EDeviceType.Pro2]: [],
+  [EDeviceType.Pro2]: ['model_pro2'],
+  [EDeviceType.Neo]: ['model_pro2'],
   [EDeviceType.Unknown]: [],
 };
 
@@ -233,7 +424,6 @@ export type ITransportStatus = 'valid' | 'outdated';
 export type IVersionRange = {
   min: string;
   max?: string;
-  unsupported?: boolean;
 };
 
 export type DeviceFirmwareRange = {

package/src/types/params.ts

@@ -15,7 +15,7 @@ export interface CommonParams {
    */
   timeout?: number;
   /**
-   * Protocol V2 初始化阶段 DeviceInfoGet 超时时间
+   * DeviceInfoGet timeout during Protocol V2 initialization.
    */
   protocolV2DeviceInfoTimeoutMs?: number;
   /**
@@ -60,9 +60,16 @@ export interface CommonParams {
   usePreInitialize?: boolean;
 
   /**
-   * Expected transport protocol. If omitted, SDK probes Protocol V1 then Protocol V2.
+   * Strictly expected transport protocol. The SDK actively verifies this value and
+   * rejects a mismatch. After a successful probe, the cached protocol is also strict.
    */
   connectProtocol?: HardwareConnectProtocol;
+
+  /**
+   * Ignore a previously bound protocol for this call and actively detect the
+   * protocol again. Intended for the first verified connection or explicit recovery.
+   */
+  forceProtocolDetection?: boolean;
 }
 
 export type Params<T> = CommonParams & T & { bundle?: undefined };

package/src/types/settings.ts

@@ -49,32 +49,75 @@ export type IProtocolV2FirmwareComponentTarget =
   | 'SE01'
   | 'SE02'
   | 'SE03'
-  | 'SE04'
-  | 'CRATE';
+  | 'SE04';
 
 export type IProtocolV2FirmwareComponent = {
   target: IProtocolV2FirmwareComponentTarget;
   url: string;
+  /** SHA-256 of the complete okpkg, used after downloading the package. */
   fingerprint?: string;
+  /** OKPP payload hash, used to detect same-version package changes. */
+  payloadHash?: string;
   version?: IVersionArray;
-  resourceManifest?: IProtocolV2ResourceManifest;
 };
 
-export type IProtocolV2ResourceManifestPackage = {
+export type IProtocolV2ResourceType =
+  | 'images'
+  | 'animation'
+  | 'wallpaper'
+  | 'translations'
+  | 'roobert'
+  | 'noto';
+
+/** Pro2 RES package descriptor. Hashes identify content without a human-managed version. */
+export type IProtocolV2Resource = {
+  type: IProtocolV2ResourceType;
+  url: string;
+  /** Complete okpkg file size in bytes. */
+  size: number;
+  /** SHA-256 of the complete okpkg file. */
+  fileHash: string;
+  /** SHA3-512 header_hash from the signed okpkg header. */
+  headerHash: string;
+};
+
+/** A file from the Protocol V2 resource manifest, written directly with FileWrite. */
+export type IProtocolV2ResourceFile = {
   name?: string;
-  path: string;
-  type?: string;
-  version?: IVersionArray;
-  sha256?: string;
-  payloadHash?: string;
-  headerHash?: string;
+  url: string;
+  devicePath: string;
+  size: number;
+  /** SHA-256 of the complete file. */
+  fileHash: string;
 };
 
-export type IProtocolV2ResourceManifest = {
-  format?: 'okpkg-crate' | string;
-  target?: 'CRATE' | string;
+/** Optional Protocol V2 boot resources restored as individual files. */
+export type IProtocolV2BootResources = {
+  required: false;
+  target: 'RES';
+  manifestUrl?: string;
+  files: IProtocolV2ResourceFile[];
+};
+
+export type IProtocolV2Resources = {
+  stable: IProtocolV2Resource[];
+  boot?: IProtocolV2BootResources;
+};
+
+/** Pro2 RESC bundle okpkg descriptor for incremental FileWrite synchronization. */
+export type IProtocolV2ResourceBundle = {
+  /** Bundle name, such as images, animation, translations, or fonts_roobert. */
+  name: string;
+  /** Download URL. */
+  url: string;
+  /** Device target path, such as vol0:/bundles/images/images.okpkg. */
+  devicePath: string;
+  /** okpkg payload_version used to skip matching content after FileRead. */
   version?: IVersionArray;
-  packages: IProtocolV2ResourceManifestPackage[];
+  /** okpkg payload_hash used for SHA3-512 comparison after FileRead. */
+  payloadHash?: string;
+  /** okpkg header_hash used for SHA3-512 comparison after FileRead. */
+  headerHash?: string;
 };
 
 /** STM32 firmware config */
@@ -98,7 +141,8 @@ export type IFirmwareReleaseInfo = {
   upgradeType?: 'payload-package-set' | string;
   components?: Record<string, IProtocolV2FirmwareComponent>;
   installOrder?: string[];
-  resourceManifest?: IProtocolV2ResourceManifest;
+  /** Pro2 RESC bundles for incremental direct FileWrite synchronization. */
+  resourceBundles?: IProtocolV2ResourceBundle[];
   bootloaderChangelog?: {
     [k in ILocale]: string;
   };
@@ -125,17 +169,25 @@ export type IBLEFirmwareReleaseInfo = {
 };
 
 type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
+type ILegacyKnownDevice = Exclude<IKnownDevice, 'neo'>;
+
+type IDeviceReleaseInfo = {
+  firmware: IFirmwareReleaseInfo[];
+  /** Protocol V2 payload package set */
+  'firmware-v1'?: IFirmwareReleaseInfo[];
+  'firmware-v2'?: IFirmwareReleaseInfo[];
+  'firmware-v8'?: IFirmwareReleaseInfo[];
+  'firmware-btc-v8'?: IFirmwareReleaseInfo[];
+  ble: IBLEFirmwareReleaseInfo[];
+  /** Independent Protocol V2 resource release configuration. */
+  resources?: IProtocolV2Resources;
+};
 
 export type DeviceTypeMap = {
-  [k in IKnownDevice]: {
-    firmware: IFirmwareReleaseInfo[];
-    /** Pro2 Protocol V2 payload package set */
-    'firmware-v1'?: IFirmwareReleaseInfo[];
-    'firmware-v2'?: IFirmwareReleaseInfo[];
-    'firmware-v8'?: IFirmwareReleaseInfo[];
-    'firmware-btc-v8'?: IFirmwareReleaseInfo[];
-    ble: IBLEFirmwareReleaseInfo[];
-  };
+  [k in ILegacyKnownDevice]: IDeviceReleaseInfo;
+} & {
+  /** Optional until every remote-config producer publishes a Neo entry. */
+  neo?: IDeviceReleaseInfo;
 };
 
 export type AssetsMap = {

package/src/utils/assets.ts

@@ -1,5 +1,8 @@
 import { httpRequest as browserHttpRequest } from './networkUtils';
 
-export const httpRequest = (url: string, type: string): any => browserHttpRequest(url, type);
+import type { HttpRequestOptions } from './networkUtils';
+
+export const httpRequest = (url: string, type: string, options?: HttpRequestOptions): any =>
+  browserHttpRequest(url, type, options);
 
 export const getTimeStamp = () => new Date().getTime();

package/src/utils/deviceFeaturesCompat.ts

@@ -0,0 +1,185 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { Enum_Capability } from '@onekeyfe/hd-transport';
+
+import type { PROTO } from '../constants';
+import type { Features, IDeviceType } from '../types';
+
+export type DeviceFeaturesInput = Features | PROTO.Features;
+
+type CompatibleDeviceFeatures = Partial<Features> &
+  Partial<PROTO.Features> & {
+    onekey_serial?: string;
+    onekey_version?: string;
+  };
+
+const asCompatibleFeatures = (features: DeviceFeaturesInput): CompatibleDeviceFeatures =>
+  features as CompatibleDeviceFeatures;
+
+const firstNonEmptyString = (...values: Array<string | null | undefined>) =>
+  values.find(value => typeof value === 'string' && value.length > 0);
+
+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('.');
+
+export const resolveDeviceSerialNo = (features?: DeviceFeaturesInput): string => {
+  if (!features) return '';
+  const compatible = asCompatibleFeatures(features);
+  return (
+    firstNonEmptyString(
+      compatible.serialNo,
+      compatible.onekey_serial_no,
+      compatible.onekey_serial,
+      compatible.serial_no
+    ) ?? ''
+  );
+};
+
+export const resolveDeviceType = (features?: DeviceFeaturesInput): IDeviceType => {
+  if (!features || typeof features !== 'object') {
+    return EDeviceType.Unknown;
+  }
+
+  const compatible = asCompatibleFeatures(features);
+  if (compatible.deviceType && compatible.deviceType !== EDeviceType.Unknown) {
+    return compatible.deviceType;
+  }
+
+  switch (compatible.onekey_device_type?.toString().toUpperCase()) {
+    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':
+      return EDeviceType.Pro2;
+    case 'NEO':
+      return EDeviceType.Neo;
+    case 'PURE':
+      return EDeviceType.ClassicPure;
+    default:
+      break;
+  }
+
+  if (compatible.model?.toString().toLowerCase() === EDeviceType.Pro2) {
+    return EDeviceType.Pro2;
+  }
+  if (compatible.model?.toString().toLowerCase() === EDeviceType.Neo) {
+    return EDeviceType.Neo;
+  }
+
+  const serialNo = resolveDeviceSerialNo(features);
+  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;
+
+  const bootloaderMode = compatible.bootloaderMode ?? compatible.bootloader_mode;
+  if (!serialNo && bootloaderMode === true && compatible.model === '1') {
+    return EDeviceType.Classic;
+  }
+
+  return compatible.deviceType ?? EDeviceType.Unknown;
+};
+
+export const resolveDeviceFirmwareType = (features?: DeviceFeaturesInput): EFirmwareType => {
+  if (!features) {
+    return EFirmwareType.Universal;
+  }
+
+  const compatible = asCompatibleFeatures(features);
+  if (compatible.firmwareType) {
+    return compatible.firmwareType;
+  }
+  if (compatible.fw_vendor === 'OneKey Bitcoin-only') {
+    return EFirmwareType.BitcoinOnly;
+  }
+
+  const capabilities = compatible.capabilities as Array<number | string> | null | undefined;
+  const supportsBitcoinLike = capabilities?.some(
+    capability =>
+      capability === Enum_Capability.Capability_Bitcoin_like ||
+      capability === 'Capability_Bitcoin_like'
+  );
+  return capabilities?.length && !supportsBitcoinLike
+    ? EFirmwareType.BitcoinOnly
+    : EFirmwareType.Universal;
+};
+
+export const resolveDeviceBleName = (features?: DeviceFeaturesInput): string | null => {
+  if (!features) return null;
+  const compatible = asCompatibleFeatures(features);
+  return (
+    firstNonEmptyString(compatible.bleName, compatible.onekey_ble_name, compatible.ble_name) ?? null
+  );
+};
+
+export const resolveDeviceFirmwareVersion = (features?: DeviceFeaturesInput): string | null => {
+  if (!features) return null;
+  const compatible = asCompatibleFeatures(features);
+  const bootloaderMode = compatible.bootloaderMode ?? compatible.bootloader_mode;
+  return firstMeaningfulVersion(
+    compatible.firmwareVersion,
+    compatible.onekey_firmware_version,
+    compatible.onekey_version,
+    bootloaderMode
+      ? null
+      : versionFromParts(
+          compatible.major_version,
+          compatible.minor_version,
+          compatible.patch_version
+        )
+  );
+};
+
+export const resolveDeviceBootloaderVersion = (features?: DeviceFeaturesInput): string | null => {
+  if (!features) return null;
+  const compatible = asCompatibleFeatures(features);
+  const bootloaderMode = compatible.bootloaderMode ?? compatible.bootloader_mode;
+  return firstMeaningfulVersion(
+    compatible.bootloaderVersion,
+    compatible.onekey_boot_version,
+    compatible.bootloader_version,
+    compatible.onekey_bootloader_version,
+    bootloaderMode
+      ? versionFromParts(
+          compatible.major_version,
+          compatible.minor_version,
+          compatible.patch_version
+        )
+      : null
+  );
+};
+
+export const resolveDeviceBoardVersion = (features?: DeviceFeaturesInput): string | null => {
+  if (!features) return null;
+  const compatible = asCompatibleFeatures(features);
+  return firstMeaningfulVersion(
+    compatible.boardVersion,
+    compatible.onekey_board_version,
+    compatible.boardloader_version,
+    compatible.onekey_romloader_version,
+    compatible.romloader_version
+  );
+};
+
+export const resolveDeviceBleFirmwareVersion = (features?: DeviceFeaturesInput): string | null => {
+  if (!features) return null;
+  const compatible = asCompatibleFeatures(features);
+  return firstMeaningfulVersion(
+    compatible.bleVersion,
+    compatible.onekey_ble_version,
+    compatible.ble_ver,
+    compatible.onekey_coprocessor_version
+  );
+};