@onekeyfe/hd-core 1.1.27-alpha.4 → 1.1.27-alpha.41

package/src/protocols/protocol-v2/features.ts

@@ -0,0 +1,287 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import type { Features } from '../../types';
+import type { DeviceCommands } from '../../device/DeviceCommands';
+import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+
+type ProtocolV2Bytes = Uint8Array | number[] | string;
+
+type ProtocolV2FirmwareImageInfo = {
+  version?: string;
+  build_id?: string;
+  hash?: ProtocolV2Bytes;
+};
+
+type ProtocolV2SEInfo = {
+  boot?: ProtocolV2FirmwareImageInfo;
+  app?: ProtocolV2FirmwareImageInfo;
+  type?: number;
+  state?: number;
+};
+
+type ProtocolV2DeviceInfo = {
+  protocol_version?: number;
+  hw?: {
+    Device_type?: number;
+    device_type?: number;
+    serial_no?: string;
+    hardware_version?: string;
+    hardware_version_raw_adc?: number;
+  };
+  fw?: {
+    board?: ProtocolV2FirmwareImageInfo;
+    boot?: ProtocolV2FirmwareImageInfo;
+    app?: ProtocolV2FirmwareImageInfo;
+  };
+  bt?: {
+    boot?: ProtocolV2FirmwareImageInfo;
+    app?: ProtocolV2FirmwareImageInfo;
+    adv_name?: string;
+    mac?: ProtocolV2Bytes;
+  };
+  se1?: ProtocolV2SEInfo;
+  se2?: ProtocolV2SEInfo;
+  se3?: ProtocolV2SEInfo;
+  se4?: ProtocolV2SEInfo;
+  status?: {
+    language?: string;
+    bt_enable?: boolean;
+    init_states?: boolean;
+    backup_required?: boolean;
+    passphrase_protection?: boolean;
+    label?: string;
+  };
+};
+
+export const PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST = {
+  targets: {
+    hw: true,
+    fw: true,
+    bt: true,
+    status: true,
+  },
+  types: {
+    version: true,
+    specific: true,
+  },
+};
+
+export const PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST = {
+  targets: {
+    hw: true,
+    fw: true,
+    bt: true,
+    se1: true,
+    se2: true,
+    se3: true,
+    se4: true,
+    status: true,
+  },
+  types: {
+    version: true,
+    build_id: true,
+    hash: true,
+    specific: true,
+  },
+};
+
+export const PROTOCOL_V2_DEVICE_INFO_REQUEST = PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST;
+
+function parseVersion(version?: string | null): [number, number, number] {
+  if (!version) return [0, 0, 0];
+  const [major = 0, minor = 0, patch = 0] = version.split('.').map(part => Number(part) || 0);
+  return [major, minor, patch];
+}
+
+function 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;
+}
+
+function getDescriptorId(descriptor: DeviceDescriptor) {
+  return descriptor.path || descriptor.id || '';
+}
+
+function getImageVersion(image?: ProtocolV2FirmwareImageInfo) {
+  return image?.version || undefined;
+}
+
+function getImageBuildId(image?: ProtocolV2FirmwareImageInfo) {
+  return image?.build_id || undefined;
+}
+
+function getImageHash(image?: ProtocolV2FirmwareImageInfo) {
+  return bytesToHex(image?.hash);
+}
+
+function getSeState(se?: ProtocolV2SEInfo) {
+  switch (se?.state) {
+    case 0:
+      return 'BOOT';
+    case 51:
+      return 'APP_FACTORY';
+    case 85:
+      return 'APP';
+    default:
+      return null;
+  }
+}
+
+function createBaseFeatures(descriptor: DeviceDescriptor): Features {
+  const descriptorId = getDescriptorId(descriptor);
+  return {
+    vendor: 'onekey.so',
+    major_version: 0,
+    minor_version: 0,
+    patch_version: 0,
+    bootloader_mode: false,
+    device_id: descriptorId,
+    pin_protection: null,
+    passphrase_protection: null,
+    language: null,
+    label: null,
+    initialized: false,
+    revision: null,
+    bootloader_hash: null,
+    imported: null,
+    unlocked: false,
+    firmware_present: false,
+    needs_backup: null,
+    flags: null,
+    model: 'pro2',
+    fw_major: 0,
+    fw_minor: 0,
+    fw_patch: 0,
+    fw_vendor: null,
+    unfinished_backup: null,
+    no_backup: null,
+    recovery_mode: null,
+    capabilities: [],
+    backup_type: null,
+    sd_card_present: null,
+    sd_protection: null,
+    wipe_code_protection: null,
+    session_id: null,
+    passphrase_always_on_device: null,
+    safety_checks: null,
+    auto_lock_delay_ms: null,
+    display_rotation: null,
+    experimental_features: null,
+    protocol_version: null,
+    onekey_device_type: EDeviceType.Pro2,
+    onekey_serial_no: descriptorId,
+    serial_no: descriptorId,
+  };
+}
+
+export function normalizeProtocolV2Features(
+  descriptor: DeviceDescriptor,
+  deviceInfo?: ProtocolV2DeviceInfo
+): Features {
+  const features = createBaseFeatures(descriptor);
+  if (!deviceInfo) return features;
+
+  const serialNo =
+    deviceInfo.hw?.serial_no || features.onekey_serial_no || getDescriptorId(descriptor);
+  const firmwareVersion = getImageVersion(deviceInfo.fw?.app);
+  const [fwMajor, fwMinor, fwPatch] = parseVersion(firmwareVersion);
+
+  return {
+    ...features,
+    major_version: fwMajor,
+    minor_version: fwMinor,
+    patch_version: fwPatch,
+    fw_major: fwMajor,
+    fw_minor: fwMinor,
+    fw_patch: fwPatch,
+    device_id: serialNo,
+    serial_no: serialNo,
+    onekey_serial_no: serialNo,
+    protocol_version: deviceInfo.protocol_version ?? features.protocol_version,
+    label: deviceInfo.status?.label ?? features.label,
+    language: deviceInfo.status?.language ?? features.language,
+    initialized: deviceInfo.status?.init_states ?? features.initialized,
+    passphrase_protection:
+      deviceInfo.status?.passphrase_protection ?? features.passphrase_protection,
+    needs_backup: deviceInfo.status?.backup_required ?? features.needs_backup,
+    ble_enable: deviceInfo.status?.bt_enable,
+    onekey_ble_name: deviceInfo.bt?.adv_name,
+    ble_name: deviceInfo.bt?.adv_name,
+    onekey_firmware_version: firmwareVersion,
+    onekey_firmware_build_id: getImageBuildId(deviceInfo.fw?.app),
+    onekey_firmware_hash: getImageHash(deviceInfo.fw?.app),
+    onekey_boot_version: getImageVersion(deviceInfo.fw?.boot),
+    bootloader_version: getImageVersion(deviceInfo.fw?.boot),
+    onekey_boot_build_id: getImageBuildId(deviceInfo.fw?.boot),
+    onekey_boot_hash: getImageHash(deviceInfo.fw?.boot),
+    onekey_board_version: getImageVersion(deviceInfo.fw?.board),
+    onekey_board_build_id: getImageBuildId(deviceInfo.fw?.board),
+    onekey_board_hash: getImageHash(deviceInfo.fw?.board),
+    onekey_ble_version: getImageVersion(deviceInfo.bt?.app),
+    ble_ver: getImageVersion(deviceInfo.bt?.app),
+    onekey_ble_build_id: getImageBuildId(deviceInfo.bt?.app),
+    onekey_ble_hash: getImageHash(deviceInfo.bt?.app),
+    onekey_se01_version: getImageVersion(deviceInfo.se1?.app),
+    onekey_se01_hash: getImageHash(deviceInfo.se1?.app),
+    onekey_se01_build_id: getImageBuildId(deviceInfo.se1?.app),
+    onekey_se01_boot_version: getImageVersion(deviceInfo.se1?.boot),
+    onekey_se01_boot_hash: getImageHash(deviceInfo.se1?.boot),
+    onekey_se01_boot_build_id: getImageBuildId(deviceInfo.se1?.boot),
+    onekey_se01_state: getSeState(deviceInfo.se1),
+    onekey_se02_version: getImageVersion(deviceInfo.se2?.app),
+    onekey_se02_hash: getImageHash(deviceInfo.se2?.app),
+    onekey_se02_build_id: getImageBuildId(deviceInfo.se2?.app),
+    onekey_se02_boot_version: getImageVersion(deviceInfo.se2?.boot),
+    onekey_se02_boot_hash: getImageHash(deviceInfo.se2?.boot),
+    onekey_se02_boot_build_id: getImageBuildId(deviceInfo.se2?.boot),
+    onekey_se02_state: getSeState(deviceInfo.se2),
+    onekey_se03_version: getImageVersion(deviceInfo.se3?.app),
+    onekey_se03_hash: getImageHash(deviceInfo.se3?.app),
+    onekey_se03_build_id: getImageBuildId(deviceInfo.se3?.app),
+    onekey_se03_boot_version: getImageVersion(deviceInfo.se3?.boot),
+    onekey_se03_boot_hash: getImageHash(deviceInfo.se3?.boot),
+    onekey_se03_boot_build_id: getImageBuildId(deviceInfo.se3?.boot),
+    onekey_se03_state: getSeState(deviceInfo.se3),
+    onekey_se04_version: getImageVersion(deviceInfo.se4?.app),
+    onekey_se04_hash: getImageHash(deviceInfo.se4?.app),
+    onekey_se04_build_id: getImageBuildId(deviceInfo.se4?.app),
+    onekey_se04_boot_version: getImageVersion(deviceInfo.se4?.boot),
+    onekey_se04_boot_hash: getImageHash(deviceInfo.se4?.boot),
+    onekey_se04_boot_build_id: getImageBuildId(deviceInfo.se4?.boot),
+    onekey_se04_state: getSeState(deviceInfo.se4),
+  };
+}
+
+export async function getProtocolV2Features({
+  commands,
+  descriptor,
+  timeoutMs,
+}: {
+  commands: DeviceCommands;
+  descriptor: DeviceDescriptor;
+  timeoutMs?: number;
+}) {
+  const callOptions = timeoutMs ? { timeoutMs } : undefined;
+  const { message } = callOptions
+    ? await commands.typedCall(
+        'DeviceGetDeviceInfo',
+        'DeviceInfo',
+        PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
+        callOptions
+      )
+    : await commands.typedCall(
+        'DeviceGetDeviceInfo',
+        'DeviceInfo',
+        PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST
+      );
+  return normalizeProtocolV2Features(descriptor, message as unknown as ProtocolV2DeviceInfo);
+}

package/src/protocols/protocol-v2/firmware.ts

@@ -0,0 +1,26 @@
+/**
+ * Protocol V2 DeviceFirmwareTargetType enum (from messages-protocol-v2.json).
+ */
+export const ProtocolV2FirmwareTargetType = {
+  TARGET_INVALID: 0,
+  TARGET_ROMLOADER: 1,
+  TARGET_BOOTLOADER: 2,
+  TARGET_FIRMWARE_P1: 3,
+  TARGET_FIRMWARE_P2: 4,
+  TARGET_COPROCESSOR: 5,
+  TARGET_SE: 6,
+  TARGET_RESOURCE: 10,
+} as const;
+
+/**
+ * Map Protocol V2 firmware file name to DeviceFirmwareUpdate target_id.
+ */
+export function protocolV2FileNameToTargetId(fileName: string): number {
+  const normalized = fileName.toLowerCase();
+  if (normalized.includes('romloader')) return ProtocolV2FirmwareTargetType.TARGET_ROMLOADER;
+  if (normalized.includes('bootloader')) return ProtocolV2FirmwareTargetType.TARGET_BOOTLOADER;
+  if (normalized.includes('ble')) return ProtocolV2FirmwareTargetType.TARGET_COPROCESSOR;
+  if (normalized.includes('se')) return ProtocolV2FirmwareTargetType.TARGET_SE;
+  if (normalized.includes('p2')) return ProtocolV2FirmwareTargetType.TARGET_FIRMWARE_P2;
+  return ProtocolV2FirmwareTargetType.TARGET_FIRMWARE_P1;
+}

package/src/protocols/protocol-v2/index.ts

@@ -0,0 +1,2 @@
+export * from './features';
+export * from './firmware';

package/src/types/api/export.ts

@@ -28,6 +28,7 @@ export type {
   FirmwareUpdateParams,
   FirmwareUpdateBinaryParams,
   FirmwareUpdateV3Params,
+  FirmwareUpdateV4Params,
 } from './firmwareUpdate';
 export type { AllFirmwareRelease } from './checkAllFirmwareRelease';
 

package/src/types/api/firmwareUpdate.ts

@@ -41,6 +41,7 @@ export declare function firmwareUpdateV2(
 export interface FirmwareUpdateV3Params {
   bleVersion?: number[];
   bleBinary?: ArrayBuffer;
+  chunkSize?: number;
 
   firmwareVersion?: number[];
   firmwareBinary?: ArrayBuffer;
@@ -56,6 +57,8 @@ export interface FirmwareUpdateV3Params {
   platform: IPlatform;
 }
 
+export type FirmwareUpdateV4Params = FirmwareUpdateV3Params;
+
 export declare function firmwareUpdateV3(
   connectId: string | undefined,
   params: Params<FirmwareUpdateV3Params>
@@ -64,3 +67,12 @@ export declare function firmwareUpdateV3(
   firmwareVersion: string;
   bootloaderVersion: string;
 }>;
+
+export declare function firmwareUpdateV4(
+  connectId: string | undefined,
+  params: Params<FirmwareUpdateV4Params>
+): Response<{
+  bleVersion: string;
+  firmwareVersion: string;
+  bootloaderVersion: string;
+}>;

package/src/types/api/getDeviceInfo.ts

@@ -0,0 +1,97 @@
+import type { CommonParams, Response } from '../params';
+import type { Features, IDeviceType, OnekeyFeatures } from '../device';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
+import type { ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+
+export type DeviceInfoProtocol = 'V1' | 'V2' | 'unknown';
+
+export type DeviceInfoSource = 'features' | 'onekeyFeatures' | 'deviceGetDeviceInfo';
+
+export type DeviceInfoScope = 'basic' | 'versions' | 'verify' | 'full';
+
+export type GetDeviceInfoParams = {
+  scope?: DeviceInfoScope;
+  refresh?: boolean;
+  includeRaw?: boolean;
+};
+
+export type DeviceInfoMode = 'normal' | 'bootloader' | 'notInitialized' | 'unknown';
+
+export type DeviceInfoStatus = {
+  mode: DeviceInfoMode;
+  initialized: boolean | null;
+  bootloaderMode: boolean | null;
+  unlocked: boolean | null;
+  passphraseProtection: boolean | null;
+  backupRequired: boolean | null;
+  language: string | null;
+  bleEnabled?: boolean | null;
+};
+
+export type UnifiedDeviceInfoVersions = {
+  firmware: string | null;
+  bootloader: string | null;
+  board: string | null;
+  ble: 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 UnifiedDeviceInfoVerify = {
+  firmwareBuildId?: string;
+  firmwareHash?: string;
+  bootloaderBuildId?: string;
+  bootloaderHash?: string;
+  boardBuildId?: string;
+  boardHash?: string;
+  bleBuildId?: string;
+  bleHash?: string;
+  se01BuildId?: string;
+  se01Hash?: string;
+  se02BuildId?: string;
+  se02Hash?: string;
+  se03BuildId?: string;
+  se03Hash?: string;
+  se04BuildId?: string;
+  se04Hash?: string;
+  se01BootBuildId?: string;
+  se01BootHash?: string;
+  se02BootBuildId?: string;
+  se02BootHash?: string;
+  se03BootBuildId?: string;
+  se03BootHash?: string;
+  se04BootBuildId?: string;
+  se04BootHash?: string;
+};
+
+export type UnifiedDeviceInfoRaw = {
+  features?: Features;
+  onekeyFeatures?: OnekeyFeatures;
+  protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
+};
+
+export type UnifiedDeviceInfo = {
+  protocol: DeviceInfoProtocol;
+  sources: DeviceInfoSource[];
+  deviceType: IDeviceType;
+  firmwareType: EFirmwareType;
+  deviceId: string;
+  serialNo: string;
+  label: string | null;
+  bleName: string | null;
+  status: DeviceInfoStatus;
+  versions: UnifiedDeviceInfoVersions;
+  verify?: UnifiedDeviceInfoVerify;
+  raw?: UnifiedDeviceInfoRaw;
+};
+
+export declare function getDeviceInfo(
+  connectId?: string,
+  params?: CommonParams & GetDeviceInfoParams
+): Response<UnifiedDeviceInfo>;

package/src/types/api/getPassphraseState.ts

@@ -1,6 +1,17 @@
 import type { CommonParams, Response } from '../params';
 
+export type GetPassphraseStatePayload = {
+  passphrase_state?: string;
+  session_id?: string;
+  unlocked_attach_pin?: boolean;
+  passphrase_protection?: boolean | null;
+};
+
+export type GetPassphraseStateParams = CommonParams & {
+  allowCreateAttachPin?: boolean;
+};
+
 export declare function getPassphraseState(
   connectId?: string,
-  params?: CommonParams
-): Response<string>;
+  params?: GetPassphraseStateParams
+): Response<GetPassphraseStatePayload>;

package/src/types/api/index.ts

@@ -1,8 +1,35 @@
+import type {
+  deviceFirmwareUpdate,
+  deviceGetDeviceInfo,
+  deviceGetFirmwareUpdateStatus,
+  deviceGetOnboardingStatus,
+  deviceReboot,
+  dirList,
+  dirMake,
+  dirRemove,
+  factoryDeviceInfoSettings,
+  factoryGetDeviceInfo,
+  fileDelete,
+  fileRead,
+  fileWrite,
+  filesystemDirList,
+  filesystemDirMake,
+  filesystemDirRemove,
+  filesystemDiskControl,
+  filesystemFileDelete,
+  filesystemFileRead,
+  filesystemFileWrite,
+  filesystemFixPermission,
+  filesystemFormat,
+  filesystemPathInfoQuery,
+  getProtoVersion,
+  pathInfo,
+  ping,
+} from './protocolV2';
 import type { off, on, removeAllListeners } from './event';
 import type { uiResponse } from './uiResponse';
 import type { init, updateSettings } from './init';
 import type { testInitializeDeviceDuration } from './testInitializeDeviceDuration';
-import type { preInitialize } from './preInitialize';
 import type { getLogs } from './getLogs';
 import type { checkBridgeStatus } from './checkBridgeStatus';
 import type { checkBridgeRelease } from './checkBridgeRelease';
@@ -11,11 +38,17 @@ import type { checkAllFirmwareRelease } from './checkAllFirmwareRelease';
 import type { checkFirmwareTypeAvailable } from './checkFirmwareTypeAvailable';
 import type { searchDevices } from './searchDevices';
 import type { getFeatures } from './getFeatures';
+import type { getDeviceInfo } from './getDeviceInfo';
 import type { getOnekeyFeatures } from './getOnekeyFeatures';
 import type { getPassphraseState } from './getPassphraseState';
 import type { checkFirmwareRelease } from './checkFirmwareRelease';
 import type { checkBLEFirmwareRelease } from './checkBLEFirmwareRelease';
-import type { firmwareUpdate, firmwareUpdateV2, firmwareUpdateV3 } from './firmwareUpdate';
+import type {
+  firmwareUpdate,
+  firmwareUpdateV2,
+  firmwareUpdateV3,
+  firmwareUpdateV4,
+} from './firmwareUpdate';
 import type { promptWebDeviceAccess } from './promptWebDeviceAccess';
 import type { deviceReset } from './deviceReset';
 import type { deviceRecovery } from './deviceRecovery';
@@ -131,6 +164,19 @@ import type { neoSignTransaction } from './neoSignTransaction';
 import type { ConnectSettings } from '../settings';
 
 export * from './export';
+export type {
+  DeviceInfoMode,
+  DeviceInfoProtocol,
+  DeviceInfoScope,
+  DeviceInfoSource,
+  DeviceInfoStatus,
+  GetDeviceInfoParams,
+  UnifiedDeviceInfo,
+  UnifiedDeviceInfoRaw,
+  UnifiedDeviceInfoVerify,
+  UnifiedDeviceInfoVersions,
+} from './getDeviceInfo';
+export type { GetPassphraseStateParams, GetPassphraseStatePayload } from './getPassphraseState';
 
 export type CoreApi = {
   /**
@@ -153,7 +199,6 @@ export type CoreApi = {
    * Test function
    */
   testInitializeDeviceDuration: typeof testInitializeDeviceDuration;
-  preInitialize: typeof preInitialize;
 
   /**
    * Core function
@@ -170,6 +215,7 @@ export type CoreApi = {
   searchDevices: typeof searchDevices;
   promptWebDeviceAccess: typeof promptWebDeviceAccess;
   getFeatures: typeof getFeatures;
+  getDeviceInfo: typeof getDeviceInfo;
   getOnekeyFeatures: typeof getOnekeyFeatures;
   getPassphraseState: typeof getPassphraseState;
   deviceBackup: typeof deviceBackup;
@@ -197,8 +243,39 @@ export type CoreApi = {
   firmwareUpdate: typeof firmwareUpdate;
   firmwareUpdateV2: typeof firmwareUpdateV2;
   firmwareUpdateV3: typeof firmwareUpdateV3;
+  firmwareUpdateV4: typeof firmwareUpdateV4;
   cipherKeyValue: typeof cipherKeyValue;
 
+  /**
+   * File system & device control API (Protocol V2 only)
+   */
+  getProtoVersion: typeof getProtoVersion;
+  ping: typeof ping;
+  deviceReboot: typeof deviceReboot;
+  deviceGetDeviceInfo: typeof deviceGetDeviceInfo;
+  deviceGetOnboardingStatus: typeof deviceGetOnboardingStatus;
+  deviceFirmwareUpdate: typeof deviceFirmwareUpdate;
+  deviceGetFirmwareUpdateStatus: typeof deviceGetFirmwareUpdateStatus;
+  factoryDeviceInfoSettings: typeof factoryDeviceInfoSettings;
+  factoryGetDeviceInfo: typeof factoryGetDeviceInfo;
+  filesystemFixPermission: typeof filesystemFixPermission;
+  fileRead: typeof fileRead;
+  fileWrite: typeof fileWrite;
+  fileDelete: typeof fileDelete;
+  dirList: typeof dirList;
+  dirMake: typeof dirMake;
+  dirRemove: typeof dirRemove;
+  pathInfo: typeof pathInfo;
+  filesystemFileRead: typeof filesystemFileRead;
+  filesystemFileWrite: typeof filesystemFileWrite;
+  filesystemFileDelete: typeof filesystemFileDelete;
+  filesystemDirList: typeof filesystemDirList;
+  filesystemDirMake: typeof filesystemDirMake;
+  filesystemDirRemove: typeof filesystemDirRemove;
+  filesystemPathInfoQuery: typeof filesystemPathInfoQuery;
+  filesystemFormat: typeof filesystemFormat;
+  filesystemDiskControl: typeof filesystemDiskControl;
+
   /**
    * All network function
    */