@onekeyfe/hd-core 1.1.28 → 1.2.0-alpha.1

package/src/types/api/index.ts

@@ -1,3 +1,35 @@
+import type {
+  deviceFirmwareUpdate,
+  deviceGetDeviceInfo,
+  deviceGetFirmwareUpdateStatus,
+  deviceGetOnboardingStatus,
+  deviceReboot,
+  devFirmwareUpdate,
+  devGetDeviceInfo,
+  devGetFirmwareUpdateStatus,
+  devReboot,
+  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';
@@ -11,11 +43,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 +169,19 @@ import type { neoSignTransaction } from './neoSignTransaction';
 import type { ConnectSettings } from '../settings';
 
 export * from './export';
+export type {
+  DeviceInfoMode,
+  DeviceInfoProtocol,
+  DeviceInfoScope,
+  DeviceInfoSource,
+  DeviceInfoStatus,
+  DeviceProfile,
+  GetDeviceInfoParams,
+  DeviceProfileRaw,
+  DeviceProfileVerify,
+  DeviceProfileVersions,
+} from './getDeviceInfo';
+export type { GetPassphraseStateParams, GetPassphraseStatePayload } from './getPassphraseState';
 
 export type CoreApi = {
   /**
@@ -170,6 +221,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 +249,43 @@ 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;
+  devReboot: typeof devReboot;
+  devGetDeviceInfo: typeof devGetDeviceInfo;
+  devFirmwareUpdate: typeof devFirmwareUpdate;
+  devGetFirmwareUpdateStatus: typeof devGetFirmwareUpdateStatus;
+  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
    */

package/src/types/api/protocolV2.ts

@@ -0,0 +1,200 @@
+import type { CommonParams, Response } from '../params';
+import type {
+  DevFirmwareUpdateStatus,
+  FactoryDeviceInfo,
+  OnboardingStatus,
+  ProtoVersion,
+  ProtocolV2DeviceInfo,
+  Success,
+} from '@onekeyfe/hd-transport';
+import type {
+  DeviceFirmwareUpdateParams,
+  DeviceRebootParams,
+  FactoryDeviceInfoSettingsParams,
+} from '../../api/protocol-v2/helpers';
+import type { DeviceGetDeviceInfoParams } from '../../api/protocol-v2/DeviceGetDeviceInfo';
+
+// 参数类型单源：以 api/protocol-v2 的实现为准（type-only re-export，无运行时依赖）
+export type {
+  DeviceFirmwareTargetInput,
+  DeviceFirmwareUpdateParams,
+  DeviceRebootParams,
+  FactoryDeviceInfoSettingsParams,
+  RebootTypeInput,
+} from '../../api/protocol-v2/helpers';
+export type {
+  DeviceGetDeviceInfoParams,
+  DeviceGetDeviceInfoTargets,
+  DeviceGetDeviceInfoTypes,
+} from '../../api/protocol-v2/DeviceGetDeviceInfo';
+
+// ── 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;
+};
+
+// proto 中 FilesystemPathInfo 的全部字段均为 required，类型与之保持一致
+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;
+};
+
+// ── Method signatures ─────────────────────────────────────────────────────
+
+export declare function getProtoVersion(
+  connectId: string,
+  params?: CommonParams
+): Response<ProtoVersion>;
+
+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 deviceGetDeviceInfo(
+  connectId: string,
+  params?: CommonParams & DeviceGetDeviceInfoParams
+): Response<ProtocolV2DeviceInfo>;
+
+export declare function deviceGetOnboardingStatus(
+  connectId: string,
+  params?: CommonParams
+): Response<OnboardingStatus>;
+
+export declare function deviceFirmwareUpdate(
+  connectId: string,
+  params: CommonParams & DeviceFirmwareUpdateParams
+): Response<Success | DevFirmwareUpdateStatus>;
+
+export declare function deviceGetFirmwareUpdateStatus(
+  connectId: string,
+  params?: CommonParams
+): Response<DevFirmwareUpdateStatus>;
+
+export declare function devReboot(
+  connectId: string,
+  params: CommonParams & DeviceRebootParams
+): Response<Success>;
+
+export declare function devGetDeviceInfo(
+  connectId: string,
+  params?: CommonParams & DeviceGetDeviceInfoParams
+): Response<ProtocolV2DeviceInfo>;
+
+export declare function devFirmwareUpdate(
+  connectId: string,
+  params: CommonParams & DeviceFirmwareUpdateParams
+): Response<Success | DevFirmwareUpdateStatus>;
+
+export declare function devGetFirmwareUpdateStatus(
+  connectId: string,
+  params?: CommonParams
+): Response<DevFirmwareUpdateStatus>;
+
+export declare function factoryDeviceInfoSettings(
+  connectId: string,
+  params: FactoryDeviceInfoSettingsParams
+): Response<Success>;
+
+export declare function factoryGetDeviceInfo(connectId: string): Response<FactoryDeviceInfo>;
+
+export declare function filesystemFixPermission(connectId: string): 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 const filesystemFileRead: typeof fileRead;
+export declare const filesystemFileWrite: typeof fileWrite;
+export declare const filesystemFileDelete: typeof fileDelete;
+export declare const filesystemDirList: typeof dirList;
+export declare const filesystemDirMake: typeof dirMake;
+export declare const filesystemDirRemove: typeof dirRemove;
+export declare const filesystemPathInfoQuery: typeof pathInfo;
+
+export declare function filesystemFormat(connectId: string): Response<Success>;
+
+export declare function filesystemDiskControl(
+  connectId: string,
+  // enable 收紧为 boolean | 0 | 1（兼容历史的 '0' / '1' 字符串输入，内部归一化为 0/1）
+  params: CommonParams & { enable: boolean | 0 | 1; timeoutMs?: number | 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/device.ts

@@ -1,8 +1,8 @@
-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 } from '@onekeyfe/hd-transport';
 
 export type DeviceStatus = 'available' | 'occupied' | 'used';
 
@@ -33,7 +33,8 @@ export type KnownDevice = {
   name: string;
   error?: typeof undefined;
   mode: EOneKeyDeviceMode;
-  features: PROTO.Features;
+  features?: Features;
+  sessionId?: string | null;
   unavailableCapabilities: UnavailableCapabilities;
   bleFirmwareVersion: IVersionArray | null;
   firmwareVersion: IVersionArray | null;
@@ -85,7 +86,100 @@ export type SearchDevice = {
 
 export type Device = KnownDevice;
 
-export type Features = PROTO.Features;
+export type DeviceFeaturesProtocol = 'V1' | 'V2' | 'unknown';
+
+export type DeviceFeaturesMode =
+  | 'normal'
+  | 'bootloader'
+  | '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;
+};
+
+export type Features = {
+  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;
+  safetyChecks: string | null;
+  autoLockDelayMs: number | null;
+  displayRotation: number | null;
+  experimentalFeatures: 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 OnekeyFeatures = PROTO.OnekeyFeatures;
 
@@ -96,7 +190,8 @@ export type IDeviceType =
   | EDeviceType.ClassicPure
   | EDeviceType.Mini
   | EDeviceType.Touch
-  | EDeviceType.Pro;
+  | EDeviceType.Pro
+  | EDeviceType.Pro2;
 
 /**
  * model_classic: 'classic' | 'classic1s' | 'classicpure'
@@ -124,6 +219,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 +232,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;
   /**
@@ -52,6 +54,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 };

package/src/types/settings.ts

@@ -34,6 +34,11 @@ export type ConnectSettings = {
   fetchConfig?: boolean;
   extension?: string;
   configFetcher?: (url: string) => Promise<RemoteConfigResponse | null>;
+  /**
+   * 临时开关：Protocol V2 DevGetDeviceInfo 未稳定前用于 mock 设备信息。
+   * 正式 app 可显式设置为 false 以调用真实 DevGetDeviceInfo；固件稳定后删除。
+   */
+  protocolV2DeviceInfoMockEnabled?: boolean;
 };
 
 export type IVersionArray = [number, number, number];
@@ -83,7 +88,7 @@ export type IBLEFirmwareReleaseInfo = {
   };
 };
 
-type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
+type IKnownDevice = Exclude<IDeviceType, 'unknown' | 'pro2'>;
 
 /**
  * Device firmware configuration map

package/src/utils/capabilitieUtils.ts

@@ -2,8 +2,7 @@ import type { Enum_Capability } from '@onekeyfe/hd-transport';
 import type { Features } from '../types/device';
 
 export const existCapability = (features?: Features, capability?: Enum_Capability) =>
-  // @ts-expect-error
-  features?.capabilities?.includes(capability);
+  capability !== undefined && features?.capabilities?.includes(capability);
 
 export const requireCapability = (features: Features, capability: Enum_Capability) => {
   if (!existCapability(features, capability)) {