@onekeyfe/hd-core 1.1.34-alpha.2 → 1.1.34-alpha.3

package/src/types/api/protocolV2.ts

@@ -0,0 +1,244 @@
+import type { CommonParams, Response } from '../params';
+import type {
+  DevOnboardingStatus,
+  DeviceFactoryInfo,
+  DeviceFirmwareUpdateStatus,
+  DeviceSettings,
+  DeviceStatus,
+  ProtocolInfo,
+  ProtocolV2DeviceInfo,
+  Success,
+} from '@onekeyfe/hd-transport';
+import type {
+  DeviceFactoryInfoSetParams,
+  DeviceFirmwareUpdateParams,
+  DeviceFirmwareUpdateStatusGetParams,
+  DeviceRebootParams,
+} from '../../api/protocol-v2/helpers';
+import type { DeviceSessionOpenParams } from '../../api/protocol-v2/DeviceSessionOpen';
+import type { DeviceInfoGetParams } from '../../api/protocol-v2/DeviceInfoGet';
+import type { DeviceSettingsSetParams } from '../../api/protocol-v2/DeviceSettingsSet';
+import type { DeviceSettingsPageShowParams } from '../../api/protocol-v2/DeviceSettingsPageShow';
+import type {
+  DeviceUploadWallpaperParams,
+  DeviceUploadWallpaperResponse,
+} from '../../api/protocol-v2/DeviceUploadWallpaper';
+
+// Re-export implementation parameter types as the single source of truth.
+export type {
+  DeviceFirmwareTargetInput,
+  DeviceFirmwareUpdateParams,
+  DeviceFirmwareUpdateStatusGetParams,
+  DeviceRebootParams,
+  DeviceFactoryInfoSetParams,
+  RebootTypeInput,
+} from '../../api/protocol-v2/helpers';
+export type { DeviceSessionOpenParams } from '../../api/protocol-v2/DeviceSessionOpen';
+export type {
+  DeviceInfoGetParams,
+  DeviceInfoGetTargets,
+  DeviceInfoGetTypes,
+} from '../../api/protocol-v2/DeviceInfoGet';
+export type { DeviceSettingsSetParams } from '../../api/protocol-v2/DeviceSettingsSet';
+export type {
+  DeviceSettingsPageShowParams,
+  SupportedDeviceSettingsPage,
+} from '../../api/protocol-v2/DeviceSettingsPageShow';
+export type {
+  DeviceUploadWallpaperParams,
+  DeviceUploadWallpaperResponse,
+} from '../../api/protocol-v2/DeviceUploadWallpaper';
+
+// ── Shared response shapes (Protocol V2 file system) ────────────────────
+
+export type FileOpSuccess = { message?: string };
+
+export type FileInfo = {
+  path: string;
+  offset: number;
+  total_size: number;
+  data?: Uint8Array;
+  data_hash?: number;
+  processed_byte?: number;
+  chunks?: number;
+};
+
+export type DirInfo = {
+  path: string;
+  child_dirs?: string;
+  child_files?: string;
+};
+
+// All FilesystemPathInfo proto fields are required; keep this type aligned.
+export type PathInfoResult = {
+  exist: boolean;
+  size: number;
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+  readonly: boolean;
+  hidden: boolean;
+  system: boolean;
+  archive: boolean;
+  directory: boolean;
+};
+
+export type DeviceSessionOpenResponse = {
+  session_id: string;
+  btc_test_address: string;
+};
+
+// ── Method signatures ─────────────────────────────────────────────────────
+
+/** @deprecated Development-only raw Protocol V2 command. Use `getDeviceState`. */
+export declare function deviceInfoGet(
+  connectId: string,
+  params?: CommonParams & DeviceInfoGetParams
+): Response<ProtocolV2DeviceInfo>;
+
+/** @deprecated Development-only raw Protocol V2 command. Use `getDeviceState`. */
+export declare function deviceStatusGet(
+  connectId: string,
+  params?: CommonParams
+): Response<DeviceStatus>;
+
+/** @deprecated Development-only raw Protocol V2 command. Use `getDeviceState`. */
+export declare function deviceSettingsGet(
+  connectId: string,
+  params?: CommonParams
+): Response<DeviceSettings>;
+
+/** @deprecated Development-only raw Protocol V2 command. */
+export declare function protocolInfoRequest(
+  connectId: string,
+  params?: CommonParams
+): Response<ProtocolInfo>;
+
+export declare function ping(
+  connectId: string,
+  params?: CommonParams & { message?: string }
+): Response<Success>;
+
+export declare function deviceReboot(
+  connectId: string,
+  params: CommonParams & DeviceRebootParams
+): Response<Success>;
+
+export declare function deviceGetOnboardingStatus(
+  connectId: string,
+  params?: CommonParams
+): Response<DevOnboardingStatus>;
+
+/**
+ * @deprecated Use `openWalletSession` instead of the raw Protocol V2 command.
+ */
+export declare function deviceSessionOpen(
+  connectId: string,
+  params: CommonParams & DeviceSessionOpenParams
+): Response<DeviceSessionOpenResponse>;
+
+export declare function deviceFirmwareUpdate(
+  connectId: string,
+  params: CommonParams & DeviceFirmwareUpdateParams
+): Response<Success | DeviceFirmwareUpdateStatus>;
+
+export declare function deviceGetFirmwareUpdateStatus(
+  connectId: string,
+  params?: CommonParams & DeviceFirmwareUpdateStatusGetParams
+): Response<DeviceFirmwareUpdateStatus>;
+
+export declare function deviceFactoryInfoSet(
+  connectId: string,
+  params: CommonParams & DeviceFactoryInfoSetParams
+): Response<Success>;
+
+export declare function deviceFactoryInfoGet(
+  connectId: string,
+  params?: CommonParams
+): Response<DeviceFactoryInfo>;
+
+export declare function deviceSettingsSet(
+  connectId: string,
+  params: CommonParams & DeviceSettingsSetParams
+): Response<Success>;
+
+export declare function deviceSettingsPageShow(
+  connectId: string,
+  params: CommonParams & DeviceSettingsPageShowParams
+): Response<Success>;
+
+export declare function deviceUploadWallpaper(
+  connectId: string,
+  params: CommonParams & DeviceUploadWallpaperParams
+): Response<DeviceUploadWallpaperResponse>;
+
+export declare function filesystemPermissionFix(
+  connectId: string,
+  params?: CommonParams
+): Response<Success>;
+
+export declare function fileRead(
+  connectId: string,
+  params: {
+    path: string;
+    offset?: number;
+    totalSize?: number;
+    chunkLen?: number;
+    uiPercentage?: number;
+  }
+): Response<FileInfo>;
+
+export declare function fileWrite(
+  connectId: string,
+  params: {
+    path: string;
+    offset?: number;
+    totalSize?: number;
+    chunkSize?: number;
+    chunkLen?: number;
+    data: ArrayBuffer | Uint8Array | Blob | string;
+    overwrite?: boolean;
+    append?: boolean;
+    uiPercentage?: number;
+    timeoutMs?: number | string;
+  }
+): Response<FileInfo>;
+
+export declare function fileDelete(
+  connectId: string,
+  params: { path: string }
+): Response<FileOpSuccess>;
+
+export declare function dirList(
+  connectId: string,
+  params: { path: string; depth?: number }
+): Response<DirInfo>;
+
+export declare function dirMake(
+  connectId: string,
+  params: { path: string }
+): Response<FileOpSuccess>;
+
+export declare function dirRemove(
+  connectId: string,
+  params: { path: string }
+): Response<FileOpSuccess>;
+
+export declare function pathInfo(
+  connectId: string,
+  params: { path: string; timeoutMs?: number | string }
+): Response<PathInfoResult>;
+
+export declare function uploadPortfolio(
+  connectId: string,
+  params: {
+    operationId?: string;
+    packageBytes: ArrayBuffer | Uint8Array | Blob;
+    timeoutMs?: number | string;
+  }
+): Response<FileInfo & { portfolioUpdated: true }>;
+
+export declare function filesystemFormat(connectId: string): Response<Success>;

package/src/types/api/searchDevices.ts

@@ -1,4 +1,4 @@
 import type { SearchDevice } from '../device';
-import type { Response } from '../params';
+import type { CommonParams, Response } from '../params';
 
-export declare function searchDevices(): Response<SearchDevice[]>;
+export declare function searchDevices(params?: CommonParams): Response<SearchDevice[]>;

package/src/types/api/sessionCache.ts

@@ -0,0 +1,14 @@
+import type { Response } from '../params';
+
+export type ClearSessionCacheParams = {
+  deviceId?: string;
+  passphraseState?: string;
+};
+
+export type ClearSessionCachePayload = {
+  cleared: true;
+};
+
+export declare function clearSessionCache(
+  params?: ClearSessionCacheParams
+): Response<ClearSessionCachePayload>;

package/src/types/device.ts

@@ -1,8 +1,12 @@
-import { EDeviceType } from '@onekeyfe/hd-shared';
+import { EDeviceType, type EFirmwareType } from '@onekeyfe/hd-shared';
 
 import type { IVersionArray } from './settings';
 import type { PROTO } from '../constants';
-import type { OneKeyDeviceCommType } from '@onekeyfe/hd-transport';
+import type {
+  OneKeyDeviceCommType,
+  ProtocolV2DeviceInfo,
+  DeviceStatus as ProtocolV2DeviceStatus,
+} from '@onekeyfe/hd-transport';
 
 export type DeviceStatus = 'available' | 'occupied' | 'used';
 
@@ -23,6 +27,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;
@@ -33,7 +43,9 @@ export type KnownDevice = {
   name: string;
   error?: typeof undefined;
   mode: EOneKeyDeviceMode;
-  features: PROTO.Features;
+  features?: Features;
+  /** Unified SDK device-state snapshot; features remains a legacy projection. */
+  state?: DeviceState;
   unavailableCapabilities: UnavailableCapabilities;
   bleFirmwareVersion: IVersionArray | null;
   firmwareVersion: IVersionArray | null;
@@ -46,6 +58,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;
@@ -85,7 +108,242 @@ export type SearchDevice = {
 
 export type Device = KnownDevice;
 
-export type Features = PROTO.Features;
+export type DeviceFeaturesProtocol = 'V1' | 'V2' | 'unknown';
+
+export type DeviceFeaturesMode =
+  | 'normal'
+  | 'bootloader'
+  | 'romloader'
+  | 'notInitialized'
+  | 'backupMode'
+  | 'unknown';
+
+export type DeviceFeaturesVerify = {
+  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 DeviceFeaturesRaw = {
+  protocolV1Features?: PROTO.Features;
+  protocolV1OneKeyFeatures?: OnekeyFeatures;
+  protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
+  protocolV2DeviceStatus?: ProtocolV2DeviceStatus;
+};
+
+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'
+  | 'apply-settings'
+  | '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: string | 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;
+  firmwareType: EFirmwareType;
+  model: string | null;
+  vendor: string | null;
+  deviceId: string | null;
+  serialNo: string;
+  label: string | null;
+  bleName: string | null;
+  capabilities: Array<number | string>;
+  mode: DeviceFeaturesMode;
+  initialized: boolean | null;
+  bootloaderMode: boolean | null;
+  unlocked: boolean | null;
+  firmwarePresent: boolean | null;
+  passphraseProtection: boolean | null;
+  pinProtection: boolean | null;
+  backupRequired: boolean | null;
+  noBackup: boolean | null;
+  unfinishedBackup: boolean | null;
+  recoveryMode: boolean | null;
+  language: string | null;
+  bleEnabled: boolean | null;
+  sdCardPresent: boolean | null;
+  sdProtection: boolean | null;
+  wipeCodeProtection: boolean | null;
+  passphraseAlwaysOnDevice: boolean | null;
+  attachToPinEnabled?: boolean | null;
+  safetyChecks: string | 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;
+  bleVersion: string | null;
+  se01Version?: string | null;
+  se02Version?: string | null;
+  se03Version?: string | null;
+  se04Version?: string | null;
+  se01BootVersion?: string | null;
+  se02BootVersion?: string | null;
+  se03BootVersion?: string | null;
+  se04BootVersion?: string | null;
+  seVersion?: string | null;
+  verify?: DeviceFeaturesVerify;
+  sessionId: string | null;
+  passphraseState?: string;
+  unlockedAttachPin?: boolean;
+  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;
 
@@ -96,7 +354,8 @@ export type IDeviceType =
   | EDeviceType.ClassicPure
   | EDeviceType.Mini
   | EDeviceType.Touch
-  | EDeviceType.Pro;
+  | EDeviceType.Pro
+  | EDeviceType.Pro2;
 
 /**
  * model_classic: 'classic' | 'classic1s' | 'classicpure'
@@ -124,6 +383,7 @@ export const DeviceTypeToModels: { [deviceType in IDeviceType]: IDeviceModel[] }
   [EDeviceType.Mini]: ['model_mini'],
   [EDeviceType.Touch]: ['model_touch'],
   [EDeviceType.Pro]: ['model_touch'],
+  [EDeviceType.Pro2]: [],
   [EDeviceType.Unknown]: [],
 };
 
@@ -136,6 +396,7 @@ export type ITransportStatus = 'valid' | 'outdated';
 export type IVersionRange = {
   min: string;
   max?: string;
+  unsupported?: boolean;
 };
 
 export type DeviceFirmwareRange = {

package/src/types/params.ts

@@ -1,3 +1,5 @@
+import type { HardwareConnectProtocol } from '@onekeyfe/hd-shared';
+
 export interface CommonParams {
   keepSession?: boolean;
   /**
@@ -12,6 +14,10 @@ export interface CommonParams {
    * Timeout time for single polling
    */
   timeout?: number;
+  /**
+   * DeviceInfoGet timeout during Protocol V2 initialization.
+   */
+  protocolV2DeviceInfoTimeoutMs?: number;
   /**
    * passphrase state
    */
@@ -52,6 +58,11 @@ export interface CommonParams {
    * Use pre-initialized device state (BLE only)
    */
   usePreInitialize?: boolean;
+
+  /**
+   * Expected transport protocol. If omitted, SDK probes Protocol V1 then Protocol V2.
+   */
+  connectProtocol?: HardwareConnectProtocol;
 }
 
 export type Params<T> = CommonParams & T & { bundle?: undefined };