@onekeyfe/hd-core 1.1.27 → 1.2.0-alpha.0

package/src/types/api/protocolV2.ts

@@ -0,0 +1,201 @@
+import type { CommonParams, Response } from '../params';
+import type {
+  DeviceFirmwareUpdateStatus,
+  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 | DeviceFirmwareUpdateStatus>;
+
+export declare function deviceGetFirmwareUpdateStatus(
+  connectId: string,
+  params?: CommonParams
+): Response<DevFirmwareUpdateStatus | DeviceFirmwareUpdateStatus>;
+
+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

@@ -3,6 +3,7 @@ import { EDeviceType } from '@onekeyfe/hd-shared';
 import type { IVersionArray } from './settings';
 import type { PROTO } from '../constants';
 import type { OneKeyDeviceCommType } from '@onekeyfe/hd-transport';
+import type { DeviceProfile } from './api/getDeviceInfo';
 
 export type DeviceStatus = 'available' | 'occupied' | 'used';
 
@@ -33,7 +34,9 @@ export type KnownDevice = {
   name: string;
   error?: typeof undefined;
   mode: EOneKeyDeviceMode;
-  features: PROTO.Features;
+  profile?: DeviceProfile;
+  features?: PROTO.Features;
+  sessionId?: string | null;
   unavailableCapabilities: UnavailableCapabilities;
   bleFirmwareVersion: IVersionArray | null;
   firmwareVersion: IVersionArray | null;
@@ -85,7 +88,35 @@ export type SearchDevice = {
 
 export type Device = KnownDevice;
 
-export type Features = PROTO.Features;
+type OnekeyFeatureExtensions = Partial<
+  Pick<
+    PROTO.OnekeyFeatures,
+    | 'onekey_board_build_id'
+    | 'onekey_se02_hash'
+    | 'onekey_se03_hash'
+    | 'onekey_se04_hash'
+    | 'onekey_se02_build_id'
+    | 'onekey_se03_build_id'
+    | 'onekey_se04_build_id'
+    | 'onekey_se01_boot_version'
+    | 'onekey_se02_boot_version'
+    | 'onekey_se03_boot_version'
+    | 'onekey_se04_boot_version'
+    | 'onekey_se01_boot_hash'
+    | 'onekey_se02_boot_hash'
+    | 'onekey_se03_boot_hash'
+    | 'onekey_se04_boot_hash'
+    | 'onekey_se01_boot_build_id'
+    | 'onekey_se02_boot_build_id'
+    | 'onekey_se03_boot_build_id'
+    | 'onekey_se04_boot_build_id'
+  >
+>;
+
+export type Features = PROTO.Features &
+  OnekeyFeatureExtensions & {
+    protocol_version?: number | null;
+  };
 
 export type OnekeyFeatures = PROTO.OnekeyFeatures;
 
@@ -96,7 +127,8 @@ export type IDeviceType =
   | EDeviceType.ClassicPure
   | EDeviceType.Mini
   | EDeviceType.Touch
-  | EDeviceType.Pro;
+  | EDeviceType.Pro
+  | EDeviceType.Pro2;
 
 /**
  * model_classic: 'classic' | 'classic1s' | 'classicpure'
@@ -124,6 +156,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 +169,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

@@ -83,7 +83,7 @@ export type IBLEFirmwareReleaseInfo = {
   };
 };
 
-type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
+type IKnownDevice = Exclude<IDeviceType, 'unknown' | 'pro2'>;
 
 /**
  * Device firmware configuration map

package/src/utils/deviceFeaturesUtils.ts

@@ -1,27 +1,33 @@
 import semver from 'semver';
 import { isNaN } from 'lodash';
 import { EDeviceType, type EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { Enum_Capability } from '@onekeyfe/hd-transport';
+import { Enum_Capability, type GetPassphraseState } from '@onekeyfe/hd-transport';
 
 import { toHardened } from '../api/helpers/pathUtils';
 import { DeviceModelToTypes, DeviceTypeToModels } from '../types';
-import DataManager, { type IFirmwareField, type MessageVersion } from '../data-manager/DataManager';
+import DataManager, {
+  type IFirmwareField,
+  type ProtocolV1MessageSchema,
+} from '../data-manager/DataManager';
 import { PROTOBUF_MESSAGE_CONFIG } from '../data-manager/MessagesConfig';
 import { getDeviceType } from './deviceInfoUtils';
 import { getDeviceFirmwareVersion } from './deviceVersionUtils';
 import { existCapability } from './capabilitieUtils';
 
 import type { Device } from '../device/Device';
-import type { DeviceCommands } from '../device/DeviceCommands';
-import type { Features, SupportFeatureType } from '../types';
+import type { Features, IDeviceType, SupportFeatureType } from '../types';
 
-export const getSupportMessageVersion = (
+// 生成的 GetPassphraseState 已包含 _only_main_pin / allow_create_attach_pin，
+// 不再需要手动扩展字段。
+type GetPassphraseStateMessage = GetPassphraseState;
+
+export const getSupportProtocolV1MessageSchema = (
   features: Features | undefined
-): { messages: JSON; messageVersion: MessageVersion } => {
+): { messages: JSON; protocolV1MessageSchema: ProtocolV1MessageSchema } => {
   if (!features)
     return {
-      messages: DataManager.messages.latest,
-      messageVersion: 'latest',
+      messages: DataManager.messages.v1CurrentSchema,
+      protocolV1MessageSchema: 'v1CurrentSchema',
     };
 
   const currentDeviceVersion = getDeviceFirmwareVersion(features).join('.');
@@ -37,18 +43,18 @@ export const getSupportMessageVersion = (
   const sortedDeviceVersionConfigs =
     deviceVersionConfigs?.sort((a, b) => semver.compare(b.minVersion, a.minVersion)) ?? [];
 
-  for (const { minVersion, messageVersion } of sortedDeviceVersionConfigs) {
+  for (const { minVersion, protocolV1MessageSchema } of sortedDeviceVersionConfigs) {
     if (semver.gte(currentDeviceVersion, minVersion)) {
       return {
-        messages: DataManager.messages[messageVersion],
-        messageVersion,
+        messages: DataManager.messages[protocolV1MessageSchema],
+        protocolV1MessageSchema,
       };
     }
   }
 
   return {
-    messages: DataManager.messages.latest,
-    messageVersion: 'latest',
+    messages: DataManager.messages.v1CurrentSchema,
+    protocolV1MessageSchema: 'v1CurrentSchema',
   };
 };
 
@@ -68,7 +74,11 @@ export const supportNewPassphrase = (features?: Features): SupportFeatureType =>
   if (!features) return { support: false };
 
   const deviceType = getDeviceType(features);
-  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
+  if (
+    deviceType === EDeviceType.Touch ||
+    deviceType === EDeviceType.Pro ||
+    deviceType === EDeviceType.Pro2
+  ) {
     return { support: true };
   }
 
@@ -82,25 +92,26 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   options?: {
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
+    allowCreateAttachPin?: boolean;
   }
 ) => {
-  const { features, commands } = device;
+  const { features } = device;
   const locked = features?.unlocked === false;
+  const deviceType = device.getCurrentDeviceType();
 
-  const { passphraseState, newSession, unlockedAttachPin } = await getPassphraseState(
-    features,
-    commands,
-    {
-      ...options,
-    }
-  );
+  const { passphraseState, newSession, unlockedAttachPin } = await getPassphraseState(device, {
+    ...options,
+  });
 
   const isModeT =
-    getDeviceType(features) === EDeviceType.Touch || getDeviceType(features) === EDeviceType.Pro;
+    deviceType === EDeviceType.Touch ||
+    deviceType === EDeviceType.Pro ||
+    deviceType === EDeviceType.Pro2;
 
   // 如果可以获取到 passphraseState，但是设备 features 显示设备未开启 passphrase，需要刷新设备状态
   // if passphraseState can be obtained, but the device features show that the device has not enabled passphrase, the device status needs to be refreshed
-  const needRefreshWithPassphrase = passphraseState && features?.passphrase_protection !== true;
+  const needRefreshWithPassphrase =
+    passphraseState && device.getCurrentPassphraseProtection() !== true;
   // 如果 Touch/Pro 在之前是锁定状态，刷新设备状态
   // if Touch/Pro was locked before, refresh the device state
   const needRefreshWithLocked = isModeT && locked;
@@ -111,11 +122,12 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   }
 
   // Attach to pin try to fix internal state
-  if (features?.device_id) {
+  const deviceId = device.getCurrentDeviceId();
+  if (deviceId) {
     device.updateInternalState(
-      device.features?.passphrase_protection ?? false,
+      device.getCurrentPassphraseProtection() ?? false,
       passphraseState,
-      device.features?.device_id ?? '',
+      deviceId,
       newSession,
       device.features?.session_id
     );
@@ -124,36 +136,56 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   return { passphraseState, newSession, unlockedAttachPin };
 };
 
+// 仅适用于 Protocol V1 的 Pro：Pro2 走独立版本线，不能套用 4.15.0 门槛
+// （Pro2 在 getPassphraseState 中通过 isProtocolV2 直接判定支持）。
+const supportProSeriesAttachPinPassphrase = (deviceType: IDeviceType, firmwareVersion: string) =>
+  deviceType === EDeviceType.Pro && semver.gte(firmwareVersion, '4.15.0');
+
 export const getPassphraseState = async (
-  features: Features | undefined,
-  commands: DeviceCommands,
+  device: Device,
   options?: {
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
+    allowCreateAttachPin?: boolean;
   }
 ): Promise<{
   passphraseState: string | undefined;
   newSession: string | undefined;
   unlockedAttachPin: boolean | undefined;
 }> => {
-  if (!features)
+  const { features, commands } = device;
+
+  // 设备尚未建立任何状态（V1 无 features 且无 profile）时无法判定，保持旧的空返回语义
+  if (!features && !device.profile)
     return { passphraseState: undefined, newSession: undefined, unlockedAttachPin: undefined };
 
-  const firmwareVersion = getDeviceFirmwareVersion(features);
-  const deviceType = getDeviceType(features);
+  const firmwareVersion = device.getCurrentFirmwareVersionString() ?? '0.0.0';
+  const deviceType = device.getCurrentDeviceType();
 
   const supportAttachPinCapability = existCapability(
     features,
     Enum_Capability.Capability_AttachToPin
   );
+  // Pro2 (Protocol V2) 协议自带 GetPassphraseState(10028)，固件从首个版本即支持，
+  // 不依赖 Pro 系列的 4.15.0 版本线；V2 也没有 GetAddress Testnet 探测这条 legacy 回退路径。
   const supportGetPassphraseState =
+    device.isProtocolV2() ||
     supportAttachPinCapability ||
-    (deviceType === EDeviceType.Pro && semver.gte(firmwareVersion.join('.'), '4.15.0'));
+    supportProSeriesAttachPinPassphrase(deviceType, firmwareVersion);
 
   if (supportGetPassphraseState) {
-    const { message, type } = await commands.typedCall('GetPassphraseState', 'PassphraseState', {
-      passphrase_state: options?.onlyMainPin ? undefined : options?.expectPassphraseState,
-    });
+    const payload: GetPassphraseStateMessage = options?.onlyMainPin
+      ? { _only_main_pin: true }
+      : { passphrase_state: options?.expectPassphraseState };
+    if (options?.allowCreateAttachPin) {
+      payload.allow_create_attach_pin = true;
+    }
+
+    const { message, type } = await commands.typedCall(
+      'GetPassphraseState',
+      'PassphraseState',
+      payload
+    );
 
     // @ts-expect-error
     if (type === 'CallMethodError') {
@@ -186,40 +218,8 @@ export const getPassphraseState = async (
   };
 };
 
-export const supportBatchPublicKey = (
-  features?: Features,
-  options?: {
-    includeNode?: boolean;
-  }
-): boolean => {
-  if (!features) return false;
-  const currentVersion = getDeviceFirmwareVersion(features).join('.');
-
-  const deviceType = getDeviceType(features);
-  // btc batch get public key
-  if (!!options?.includeNode && deviceType === EDeviceType.Pro) {
-    return semver.gte(currentVersion, '4.14.0');
-  }
-  if (!!options?.includeNode && deviceType === EDeviceType.Touch) {
-    return semver.gte(currentVersion, '4.11.0');
-  }
-  if (!!options?.includeNode && DeviceModelToTypes.model_classic1s.includes(deviceType)) {
-    return semver.gte(currentVersion, '3.12.0');
-  }
-  if (!!options?.includeNode && DeviceModelToTypes.model_mini.includes(deviceType)) {
-    return semver.gte(currentVersion, '3.10.0');
-  }
-  if (options?.includeNode) {
-    return false;
-  }
-
-  // support batch get public key
-  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
-    return semver.gte(currentVersion, '3.1.0');
-  }
-
-  return semver.gte(currentVersion, '2.6.0');
-};
+// supportBatchPublicKey 已迁移为 device-aware 版本：
+// 见 api/helpers/batchGetPublickeys.ts 的 supportBatchPublicKeyByDevice
 
 export const supportModifyHomescreen = (features?: Features): SupportFeatureType => {
   if (!features) return { support: false };

package/src/utils/deviceInfoUtils.ts

@@ -27,6 +27,9 @@ export const getDeviceType = (features?: Features): IDeviceType => {
       return EDeviceType.Touch;
     case 'PRO':
       return EDeviceType.Pro;
+    case 'PRO2':
+    case 'pro2':
+      return EDeviceType.Pro2;
     case 'PURE':
       return EDeviceType.ClassicPure;
     default:
@@ -68,13 +71,14 @@ export const getDeviceType = (features?: Features): IDeviceType => {
 export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
   if (!name) return EDeviceType.Unknown;
 
-  if (name.startsWith('BixinKey')) return EDeviceType.Classic;
-  if (name.startsWith('K')) return EDeviceType.Classic;
+  if (/^BixinKey/i.test(name)) return EDeviceType.Classic;
+  if (/^K/i.test(name)) return EDeviceType.Classic;
 
-  if (name.startsWith('T')) return EDeviceType.Touch;
-  if (name.startsWith('Touch')) return EDeviceType.Touch;
+  if (/^T/i.test(name)) return EDeviceType.Touch;
+  if (/^Touch/i.test(name)) return EDeviceType.Touch;
 
-  if (name.startsWith('Pro')) return EDeviceType.Pro;
+  if (/\bPro\s*2\b/i.test(name) || /^Pro2/i.test(name)) return EDeviceType.Pro2;
+  if (/\bPro\b/i.test(name) || /^Pro/i.test(name)) return EDeviceType.Pro;
 
   return EDeviceType.Unknown;
 };
@@ -128,8 +132,8 @@ export const getMethodVersionRange = (
   getVersionRange: (deviceModel: IDeviceType | IDeviceModel) => IVersionRange | undefined
 ): IVersionRange | undefined => {
   const deviceType = getDeviceType(features);
-  let versionRange: IVersionRange | undefined = getVersionRange(deviceType);
 
+  const versionRange = getVersionRange(deviceType);
   if (versionRange) {
     return versionRange;
   }
@@ -142,16 +146,19 @@ export const getMethodVersionRange = (
   ];
   for (const model of modelFallbacks) {
     if (DeviceModelToTypes[model].includes(deviceType)) {
-      versionRange = getVersionRange(model);
+      const versionRange = getVersionRange(model);
       if (versionRange) {
         return versionRange;
       }
     }
   }
 
-  return versionRange;
+  return undefined;
 };
 
+export const isMethodVersionRangeUnsupported = (versionRange?: IVersionRange): boolean =>
+  versionRange?.unsupported === true;
+
 export const getFirmwareType = (features: Features | undefined) => {
   if (!features) {
     return EFirmwareType.Universal;

package/src/utils/index.ts

@@ -11,6 +11,7 @@ export {
   getDeviceUUID,
   getDeviceLabel,
   getMethodVersionRange,
+  isMethodVersionRangeUnsupported,
   getFirmwareType,
 } from './deviceInfoUtils';
 export {