@onekeyfe/hd-core 1.2.0-alpha.2 → 1.2.0-alpha.21

package/src/types/device.ts

@@ -2,7 +2,12 @@ import { EDeviceType, type EFirmwareType } 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,
+} from '@onekeyfe/hd-transport';
 
 export type DeviceStatus = 'available' | 'occupied' | 'used';
 
@@ -23,6 +28,12 @@ export type UnavailableCapabilities = { [key: string]: UnavailableCapability };
 
 export type KnownDevice = {
   connectId: string | null;
+  /**
+   * 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;
@@ -34,7 +45,8 @@ export type KnownDevice = {
   error?: typeof undefined;
   mode: EOneKeyDeviceMode;
   features?: Features;
-  sessionId?: string | null;
+  /** Unified SDK device-state snapshot; features remains a legacy projection. */
+  state?: DeviceState;
   unavailableCapabilities: UnavailableCapabilities;
   bleFirmwareVersion: IVersionArray | null;
   firmwareVersion: IVersionArray | null;
@@ -47,6 +59,17 @@ export type KnownDevice = {
 
 export type SearchDevice = {
   connectId: string | null;
+  /**
+   * 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 +114,7 @@ export type DeviceFeaturesProtocol = 'V1' | 'V2' | 'unknown';
 export type DeviceFeaturesMode =
   | 'normal'
   | 'bootloader'
+  | 'romloader'
   | 'notInitialized'
   | 'backupMode'
   | 'unknown';
@@ -126,9 +150,135 @@ export type DeviceFeaturesRaw = {
   protocolV1Features?: PROTO.Features;
   protocolV1OneKeyFeatures?: OnekeyFeatures;
   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;
+  attachToPinEnabled: boolean | null;
+  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;
+  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,10 +307,22 @@ export type Features = {
   sdProtection: boolean | null;
   wipeCodeProtection: boolean | null;
   passphraseAlwaysOnDevice: boolean | null;
-  safetyChecks: string | null;
+  attachToPinEnabled?: 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;
   firmwareVersion: string | null;
   bootloaderVersion: string | null;
   boardVersion: string | null;
@@ -181,6 +343,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 =

package/src/types/params.ts

@@ -14,6 +14,10 @@ export interface CommonParams {
    * Timeout time for single polling
    */
   timeout?: number;
+  /**
+   * DeviceInfoGet timeout during Protocol V2 initialization.
+   */
+  protocolV2DeviceInfoTimeoutMs?: number;
   /**
    * passphrase state
    */

package/src/types/settings.ts

@@ -40,6 +40,40 @@ export type IVersionArray = [number, number, number];
 
 export type ILocale = 'zh-CN' | 'en-US';
 
+export type IProtocolV2FirmwareComponentTarget =
+  | 'ROMLOADER'
+  | 'BOOTLOADER'
+  | 'APPLICATION_P1'
+  | 'APPLICATION_P2'
+  | 'COPROCESSOR'
+  | 'SE01'
+  | 'SE02'
+  | 'SE03'
+  | 'SE04';
+
+export type IProtocolV2FirmwareComponent = {
+  target: IProtocolV2FirmwareComponentTarget;
+  url: string;
+  fingerprint?: string;
+  version?: IVersionArray;
+};
+
+/** 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;
+  /** 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 */
 export type IFirmwareReleaseInfo = {
   required: boolean;
@@ -58,6 +92,11 @@ export type IFirmwareReleaseInfo = {
   bootloaderVersion?: IVersionArray;
   displayBootloaderVersion?: IVersionArray;
   bootloaderRelatedFirmwareVersion?: IVersionArray;
+  upgradeType?: 'payload-package-set' | string;
+  components?: Record<string, IProtocolV2FirmwareComponent>;
+  installOrder?: string[];
+  /** Pro2 RESC bundles for incremental direct FileWrite synchronization. */
+  resourceBundles?: IProtocolV2ResourceBundle[];
   bootloaderChangelog?: {
     [k in ILocale]: string;
   };
@@ -83,43 +122,16 @@ export type IBLEFirmwareReleaseInfo = {
   };
 };
 
-type IKnownDevice = Exclude<IDeviceType, 'unknown' | 'pro2'>;
+type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
 
-/**
- * Device firmware configuration map
- *
- * IMPORTANT: This type is used for firmware update logic.
- * - DO NOT remove existing firmware fields
- * - Only ADD new optional firmware fields for new versions
- * - 'firmware' field is required for backward compatibility
- * - 'ble' field is required for BLE firmware updates
- *
- * @example
- * // When adding firmware-v8:
- * // {
- * //   firmware: IFirmwareReleaseInfo[];
- * //   'firmware-v2'?: IFirmwareReleaseInfo[];
- * //   'firmware-v8'?: IFirmwareReleaseInfo[];
- * //   'firmware-v8'?: IFirmwareReleaseInfo[];      // New
- * //   'firmware-btc-v8'?: IFirmwareReleaseInfo[];
- * //   'firmware-btc-v8'?: IFirmwareReleaseInfo[];  // New
- * //   ble: IBLEFirmwareReleaseInfo[];
- * // }
- */
 export type DeviceTypeMap = {
   [k in IKnownDevice]: {
-    /** Base firmware field (required for backward compatibility) */
     firmware: IFirmwareReleaseInfo[];
-    /** Firmware v2 (Touch/Pro specific) */
+    /** Pro2 Protocol V2 payload package set */
+    'firmware-v1'?: IFirmwareReleaseInfo[];
     'firmware-v2'?: IFirmwareReleaseInfo[];
-    /** Universal firmware v7 */
     'firmware-v8'?: IFirmwareReleaseInfo[];
-    /** Bitcoin-only firmware v7 */
     'firmware-btc-v8'?: IFirmwareReleaseInfo[];
-    // Future firmware versions should be added here as optional fields:
-    // 'firmware-v8'?: IFirmwareReleaseInfo[];
-    // 'firmware-btc-v8'?: IFirmwareReleaseInfo[];
-    /** BLE firmware (required) */
     ble: IBLEFirmwareReleaseInfo[];
   };
 };

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,173 @@
+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 'PURE':
+      return EDeviceType.ClassicPure;
+    default:
+      break;
+  }
+
+  if (compatible.model?.toString().toLowerCase() === EDeviceType.Pro2) {
+    return EDeviceType.Pro2;
+  }
+
+  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);
+  return firstMeaningfulVersion(
+    compatible.firmwareVersion,
+    compatible.onekey_firmware_version,
+    compatible.onekey_version,
+    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
+  );
+};