@onekeyfe/hd-core 1.2.0-alpha.12 → 1.2.0-alpha.121

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,20 @@ 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. Empty during BLE discovery until the
+   * physical serial number is available after initialization.
+   */
   uuid: string;
   deviceId: string | null;
   deviceType: IDeviceType;
@@ -99,6 +130,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;
@@ -126,10 +161,157 @@ 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 DeviceStateSecurityElement = {
+  type: string | null;
+  state: string | null;
+};
+
+export type DeviceStateSecurityElements = Partial<
+  Record<'se01' | 'se02' | 'se03' | 'se04', DeviceStateSecurityElement>
+>;
+
+export type DeviceStateSecurityElementsPatch = Partial<
+  Record<keyof DeviceStateSecurityElements, Partial<DeviceStateSecurityElement>>
+>;
+
+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;
+  /** Secure-element metadata exposed by the unified firmware information read. */
+  securityElements?: DeviceStateSecurityElements;
+  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>;
+  securityElements?: DeviceStateSecurityElementsPatch;
+  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;
@@ -158,11 +340,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;
@@ -183,6 +377,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 =
@@ -193,14 +391,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: [
@@ -210,6 +415,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],
 };
@@ -221,7 +427,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]: [],
 };
 
@@ -234,7 +441,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

@@ -31,6 +31,8 @@ export type ConnectSettings = {
   timestamp: number;
   isFrame?: boolean;
   preRelease?: boolean;
+  firmwareManifestMode?: 'sdk-managed' | 'external-only';
+  preloadedConfig?: RemoteConfigResponse;
   fetchConfig?: boolean;
   extension?: string;
   configFetcher?: (url: string) => Promise<RemoteConfigResponse | null>;
@@ -54,24 +56,37 @@ export type IProtocolV2FirmwareComponentTarget =
 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;
+  expectedSize?: number;
   version?: IVersionArray;
 };
 
-/** Pro2 RESC bundle okpkg 描述，用于 FileWrite 直写方式增量同步资源 */
-export type IProtocolV2ResourceBundle = {
-  /** bundle 名称，如 images / animation / translations / fonts_roobert */
-  name: string;
-  /** 下载 URL */
-  url: string;
-  /** 设备上的目标路径，如 vol0:/bundles/images/images.okpkg */
-  devicePath: string;
-  /** okpkg container 的 payload_version（用于 FileRead 比对跳过） */
-  version?: IVersionArray;
-  /** okpkg container 的 payload_hash（SHA3-512，用于 FileRead 比对） */
-  payloadHash?: string;
-  /** okpkg container 的 header_hash（SHA3-512，用于 FileRead 比对） */
-  headerHash?: string;
+export type IProtocolV2ResourceSource = {
+  archiveUrl: string;
+  archiveSha256: string;
+  archiveSize: number;
+};
+
+export type IProtocolV2Resources = {
+  source: IProtocolV2ResourceSource;
+};
+
+export type IProtocolV2ResourceManifestFile = {
+  archive_path: string;
+  original_name?: string;
+  device_path: string;
+  size: number;
+  sha256: string;
+  signed?: boolean;
+  sig_algo?: string;
+  payload_version?: string | null;
+};
+
+export type IProtocolV2ResourceManifest = {
+  files: IProtocolV2ResourceManifestFile[];
 };
 
 /** STM32 firmware config */
@@ -85,22 +100,27 @@ export type IFirmwareReleaseInfo = {
   firmwareType?: EFirmwareType;
   /** Firmware UI resource */
   resource?: string;
+  resourceFingerprint?: string;
+  resourceExpectedSize?: number;
   /** Firmware full UI resource */
   fullResource?: string;
+  fullResourceFingerprint?: string;
+  fullResourceExpectedSize?: number;
   fullResourceRange?: string[];
   bootloaderResource?: string;
+  bootloaderFingerprint?: string;
+  bootloaderExpectedSize?: number;
   bootloaderVersion?: IVersionArray;
   displayBootloaderVersion?: IVersionArray;
   bootloaderRelatedFirmwareVersion?: IVersionArray;
   upgradeType?: 'payload-package-set' | string;
   components?: Record<string, IProtocolV2FirmwareComponent>;
   installOrder?: string[];
-  /** Pro2 RESC bundle 列表（FileWrite 直写增量同步模式） */
-  resourceBundles?: IProtocolV2ResourceBundle[];
   bootloaderChangelog?: {
     [k in ILocale]: string;
   };
   fingerprint: string;
+  expectedSize?: number;
   version: IVersionArray;
   changelog: {
     [k in ILocale]: string;
@@ -116,6 +136,7 @@ export type IBLEFirmwareReleaseInfo = {
   webUpdate: string;
   fingerprint: string;
   fingerprintWeb: string;
+  expectedSize?: number;
   version: IVersionArray;
   changelog: {
     [k in ILocale]: string;
@@ -123,17 +144,23 @@ export type IBLEFirmwareReleaseInfo = {
 };
 
 type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
+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 Exclude<IKnownDevice, 'neo'>]: 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,191 @@
+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 resolveDeviceBootloaderMode = (features?: DeviceFeaturesInput): boolean => {
+  if (!features) return false;
+  const compatible = asCompatibleFeatures(features);
+  return (compatible.bootloaderMode ?? compatible.bootloader_mode) === true;
+};
+
+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
+  );
+};