@onekeyfe/hd-core 1.2.0-alpha.13 → 1.2.0-alpha.131

package/src/api/protocol-v2/DeviceSessionGet.ts

@@ -1,15 +0,0 @@
-import { BaseMethod } from '../BaseMethod';
-
-export default class DeviceSessionGet extends BaseMethod {
-  init() {
-    this.requireProtocolV2 = true;
-    this.useDevicePassphraseState = false;
-    this.skipForceUpdateCheck = true;
-    this.params = undefined;
-  }
-
-  async run() {
-    const { message } = await this.device.commands.typedCall('DeviceSessionGet', 'DeviceSession', {});
-    return message;
-  }
-}

package/src/api/protocol-v2/DeviceSettingsGet.ts

@@ -1,16 +0,0 @@
-import { BaseMethod } from '../BaseMethod';
-
-export default class DeviceSettingsGet extends BaseMethod {
-  init() {
-    this.requireProtocolV2 = true;
-    this.unlockPolicy = 'retry-on-locked';
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    this.params = undefined;
-  }
-
-  async run() {
-    const res = await this.device.commands.typedCall('DeviceSettingsGet', 'DeviceSettings', {});
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/protocol-v2/DeviceSettingsPageShow.ts

@@ -1,59 +0,0 @@
-import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
-
-import { BaseMethod } from '../BaseMethod';
-import { invalidParameter } from '../helpers/filesystemValidation';
-
-export type SupportedDeviceSettingsPage = DeviceSettingsPage;
-
-export type DeviceSettingsPageShowParams = {
-  page?:
-    | SupportedDeviceSettingsPage
-    | 'DeviceReset'
-    | 'DevicePinChange'
-    | 'DevicePassphrase'
-    | 'DeviceAirgap';
-  fieldName?: string;
-  field_name?: string;
-};
-
-const SUPPORTED_PAGES = new Set<number>([
-  DeviceSettingsPage.DeviceReset,
-  DeviceSettingsPage.DevicePinChange,
-  DeviceSettingsPage.DevicePassphrase,
-  DeviceSettingsPage.DeviceAirgap,
-]);
-
-function normalizePage(value: DeviceSettingsPageShowParams['page']): SupportedDeviceSettingsPage {
-  const page = typeof value === 'string' ? DeviceSettingsPage[value] : value;
-  if (page !== undefined && SUPPORTED_PAGES.has(page)) {
-    return page as SupportedDeviceSettingsPage;
-  }
-  throw invalidParameter(
-    'Parameter [page] must be DeviceReset, DevicePinChange, DevicePassphrase, or DeviceAirgap.'
-  );
-}
-
-export default class DeviceSettingsPageShow extends BaseMethod<{
-  page: SupportedDeviceSettingsPage;
-  field_name?: string;
-}> {
-  init() {
-    this.requireProtocolV2 = true;
-    this.unlockPolicy = 'retry-on-locked';
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    this.params = {
-      page: normalizePage(this.payload.page),
-      field_name: this.payload.field_name ?? this.payload.fieldName,
-    };
-  }
-
-  async run() {
-    const res = await this.device.commands.typedCall(
-      'DeviceSettingsPageShow',
-      'Success',
-      this.params
-    );
-    return Promise.resolve(res.message);
-  }
-}

package/src/api/protocol-v2/DeviceSettingsSet.ts

@@ -1,39 +0,0 @@
-import { BaseMethod } from '../BaseMethod';
-import { invalidParameter } from '../helpers/filesystemValidation';
-
-import type { DeviceSettings } from '@onekeyfe/hd-transport';
-
-export type DeviceSettingsSetParams = {
-  settings?: Omit<DeviceSettings, 'passphrase_enable' | 'airgap_mode'>;
-};
-
-export default class DeviceSettingsSet extends BaseMethod<{
-  settings: Omit<DeviceSettings, 'passphrase_enable' | 'airgap_mode'>;
-}> {
-  init() {
-    const settings = this.payload.settings;
-    if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
-      throw invalidParameter('Parameter [settings] must be an object.');
-    }
-
-    const {
-      passphrase_enable: _passphraseEnable,
-      airgap_mode: _airgapMode,
-      ...supported
-    } = settings as DeviceSettings;
-    if (Object.keys(supported).length === 0) {
-      throw invalidParameter('Parameter [settings] must contain at least one supported setting.');
-    }
-
-    this.requireProtocolV2 = true;
-    this.unlockPolicy = 'retry-on-locked';
-    this.skipForceUpdateCheck = true;
-    this.useDevicePassphraseState = false;
-    this.params = { settings: supported };
-  }
-
-  async run() {
-    const res = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', this.params);
-    return Promise.resolve(res.message);
-  }
-}

package/src/deviceProfile/buildDeviceProfile.ts

@@ -1,354 +0,0 @@
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
-
-import {
-  getDeviceBLEFirmwareVersion,
-  getDeviceBoardloaderVersion,
-  getDeviceBootloaderVersion,
-  getDeviceFirmwareVersion,
-} from '../utils/deviceVersionUtils';
-import {
-  getDeviceBleName,
-  getDeviceLabel,
-  getDeviceType,
-  getDeviceUUID,
-  getFirmwareType,
-} from '../utils/deviceInfoUtils';
-import {
-  isProtocolV2BootloaderDeviceInfo,
-  isProtocolV2RomloaderDeviceInfo,
-} from '../protocols/protocol-v2/features';
-
-import type {
-  DeviceInfoProtocol,
-  DeviceInfoSource,
-  DeviceInfoStatus,
-  DeviceProfile,
-  DeviceProfileRaw,
-  DeviceProfileVerify,
-  DeviceProfileVersions,
-  GetDeviceInfoParams,
-} from '../types/api/getDeviceInfo';
-import type { Features, OnekeyFeatures } from '../types';
-import type { DeviceFirmwareImageInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
-
-type BuildProtocolV1ProfileParams = {
-  protocol?: DeviceInfoProtocol;
-  features?: Features;
-  protocolV1OneKeyFeatures?: OnekeyFeatures;
-  sources?: DeviceInfoSource[];
-  scope?: GetDeviceInfoParams['scope'];
-  includeRaw?: boolean;
-};
-
-type BuildProtocolV2ProfileParams = {
-  deviceInfo?: ProtocolV2DeviceInfo;
-  sources?: DeviceInfoSource[];
-  scope?: GetDeviceInfoParams['scope'];
-  includeRaw?: boolean;
-};
-
-const isMeaningfulVersion = (version?: string | null) => Boolean(version && version !== '0.0.0');
-
-const firstMeaningfulVersion = (...versions: Array<string | null | undefined>) =>
-  versions.find(isMeaningfulVersion) ?? null;
-
-const versionArrayToString = (version?: Array<number | string | null> | null) => {
-  if (!version || version.length === 0) return null;
-  const value = version.join('.');
-  return isMeaningfulVersion(value) ? value : null;
-};
-
-const 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;
-};
-
-const getImageVersion = (image?: DeviceFirmwareImageInfo | null) => image?.version ?? null;
-
-const getImageBuildId = (image?: DeviceFirmwareImageInfo | null) => image?.build_id ?? undefined;
-
-const getImageHash = (image?: DeviceFirmwareImageInfo | null) => bytesToHex(image?.hash);
-
-const shouldIncludeVerify = (scope?: GetDeviceInfoParams['scope']) =>
-  scope === 'verify' || scope === 'full';
-
-const getDeviceMode = (features?: Features): DeviceInfoStatus['mode'] => {
-  if (!features) return 'unknown';
-  if (features.bootloaderMode === true) return 'bootloader';
-  if (features.initialized === false) return 'notInitialized';
-  if (features.initialized === true) return 'normal';
-  return 'unknown';
-};
-
-const getProtocolV2Mode = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus['mode'] => {
-  if (isProtocolV2RomloaderDeviceInfo(deviceInfo)) return 'romloader';
-  if (isProtocolV2BootloaderDeviceInfo(deviceInfo)) return 'bootloader';
-  const initialized = deviceInfo?.status?.init_states;
-  if (initialized === false) return 'notInitialized';
-  if (initialized === true) return 'normal';
-  return 'unknown';
-};
-
-const normalizeV1Versions = (
-  features?: Features,
-  protocolV1OneKeyFeatures?: OnekeyFeatures
-): DeviceProfileVersions => ({
-  firmware: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_firmware_version,
-    versionArrayToString(getDeviceFirmwareVersion(features))
-  ),
-  bootloader: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_boot_version,
-    versionArrayToString(getDeviceBootloaderVersion(features))
-  ),
-  board: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_board_version,
-    versionArrayToString(features ? getDeviceBoardloaderVersion(features) : undefined)
-  ),
-  ble: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_ble_version,
-    features?.bleVersion,
-    versionArrayToString(features ? getDeviceBLEFirmwareVersion(features) : undefined)
-  ),
-  se01: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_se01_version,
-    features?.se01Version
-  ),
-  se02: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_se02_version,
-    features?.se02Version
-  ),
-  se03: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_se03_version,
-    features?.se03Version
-  ),
-  se04: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_se04_version,
-    features?.se04Version
-  ),
-  se01Boot: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_se01_boot_version,
-    features?.se01BootVersion
-  ),
-  se02Boot: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_se02_boot_version,
-    features?.se02BootVersion
-  ),
-  se03Boot: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_se03_boot_version,
-    features?.se03BootVersion
-  ),
-  se04Boot: firstMeaningfulVersion(
-    protocolV1OneKeyFeatures?.onekey_se04_boot_version,
-    features?.se04BootVersion
-  ),
-});
-
-const normalizeV2Versions = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVersions => {
-  const info = deviceInfo;
-  return {
-    firmware: firstMeaningfulVersion(getImageVersion(info?.fw?.application)),
-    bootloader: firstMeaningfulVersion(getImageVersion(info?.fw?.bootloader)),
-    board: firstMeaningfulVersion(getImageVersion(info?.fw?.romloader)),
-    ble: firstMeaningfulVersion(getImageVersion(info?.coprocessor?.application)),
-    se01: firstMeaningfulVersion(getImageVersion(info?.se1?.application)),
-    se02: firstMeaningfulVersion(getImageVersion(info?.se2?.application)),
-    se03: firstMeaningfulVersion(getImageVersion(info?.se3?.application)),
-    se04: firstMeaningfulVersion(getImageVersion(info?.se4?.application)),
-    se01Boot: firstMeaningfulVersion(getImageVersion(info?.se1?.bootloader)),
-    se02Boot: firstMeaningfulVersion(getImageVersion(info?.se2?.bootloader)),
-    se03Boot: firstMeaningfulVersion(getImageVersion(info?.se3?.bootloader)),
-    se04Boot: firstMeaningfulVersion(getImageVersion(info?.se4?.bootloader)),
-  };
-};
-
-// V2 状态由 normalizeV2Status 处理，这里只服务 buildProfileFromProtocolV1 的 V1 路径。
-const normalizeV1Status = (features?: Features): DeviceInfoStatus => ({
-  mode: getDeviceMode(features),
-  initialized: features?.initialized ?? null,
-  bootloaderMode: features?.bootloaderMode ?? null,
-  unlocked: features?.unlocked ?? null,
-  passphraseProtection: features?.passphraseProtection ?? null,
-  attachToPinEnabled: features?.attachToPinEnabled ?? null,
-  unlockedAttachPin: features?.unlockedAttachPin ?? null,
-  backupRequired: features?.backupRequired ?? null,
-  noBackup: features?.noBackup ?? null,
-  language: features?.language ?? null,
-  bleEnabled: features?.bleEnabled ?? null,
-});
-
-const normalizeV2Status = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus => {
-  const status = deviceInfo?.status;
-  const bootloaderMode = isProtocolV2BootloaderDeviceInfo(deviceInfo);
-  return {
-    mode: getProtocolV2Mode(deviceInfo),
-    initialized: status?.init_states ?? null,
-    bootloaderMode,
-    unlocked: status?.unlocked ?? null,
-    passphraseProtection: status?.passphrase_enabled ?? null,
-    attachToPinEnabled: status?.attach_to_pin_enabled ?? null,
-    unlockedAttachPin: status?.unlocked_by_attach_to_pin ?? null,
-    backupRequired: status?.backup_required ?? null,
-    noBackup: null,
-    language: null,
-    bleEnabled: null,
-  };
-};
-
-const normalizeV1Verify = (
-  features?: Features,
-  protocolV1OneKeyFeatures?: OnekeyFeatures
-): DeviceProfileVerify => ({
-  firmwareBuildId:
-    protocolV1OneKeyFeatures?.onekey_firmware_build_id ?? features?.verify?.firmwareBuildId,
-  firmwareHash: protocolV1OneKeyFeatures?.onekey_firmware_hash ?? features?.verify?.firmwareHash,
-  bootloaderBuildId:
-    protocolV1OneKeyFeatures?.onekey_boot_build_id ?? features?.verify?.bootloaderBuildId,
-  bootloaderHash: protocolV1OneKeyFeatures?.onekey_boot_hash ?? features?.verify?.bootloaderHash,
-  boardBuildId: protocolV1OneKeyFeatures?.onekey_board_build_id ?? features?.verify?.boardBuildId,
-  boardHash: protocolV1OneKeyFeatures?.onekey_board_hash ?? features?.verify?.boardHash,
-  bleBuildId: protocolV1OneKeyFeatures?.onekey_ble_build_id ?? features?.verify?.bleBuildId,
-  bleHash: protocolV1OneKeyFeatures?.onekey_ble_hash ?? features?.verify?.bleHash,
-  se01BuildId: protocolV1OneKeyFeatures?.onekey_se01_build_id ?? features?.verify?.se01BuildId,
-  se01Hash: protocolV1OneKeyFeatures?.onekey_se01_hash ?? features?.verify?.se01Hash,
-  se02BuildId: protocolV1OneKeyFeatures?.onekey_se02_build_id ?? features?.verify?.se02BuildId,
-  se02Hash: protocolV1OneKeyFeatures?.onekey_se02_hash ?? features?.verify?.se02Hash,
-  se03BuildId: protocolV1OneKeyFeatures?.onekey_se03_build_id ?? features?.verify?.se03BuildId,
-  se03Hash: protocolV1OneKeyFeatures?.onekey_se03_hash ?? features?.verify?.se03Hash,
-  se04BuildId: protocolV1OneKeyFeatures?.onekey_se04_build_id ?? features?.verify?.se04BuildId,
-  se04Hash: protocolV1OneKeyFeatures?.onekey_se04_hash ?? features?.verify?.se04Hash,
-  se01BootBuildId:
-    protocolV1OneKeyFeatures?.onekey_se01_boot_build_id ?? features?.verify?.se01BootBuildId,
-  se01BootHash: protocolV1OneKeyFeatures?.onekey_se01_boot_hash ?? features?.verify?.se01BootHash,
-  se02BootBuildId:
-    protocolV1OneKeyFeatures?.onekey_se02_boot_build_id ?? features?.verify?.se02BootBuildId,
-  se02BootHash: protocolV1OneKeyFeatures?.onekey_se02_boot_hash ?? features?.verify?.se02BootHash,
-  se03BootBuildId:
-    protocolV1OneKeyFeatures?.onekey_se03_boot_build_id ?? features?.verify?.se03BootBuildId,
-  se03BootHash: protocolV1OneKeyFeatures?.onekey_se03_boot_hash ?? features?.verify?.se03BootHash,
-  se04BootBuildId:
-    protocolV1OneKeyFeatures?.onekey_se04_boot_build_id ?? features?.verify?.se04BootBuildId,
-  se04BootHash: protocolV1OneKeyFeatures?.onekey_se04_boot_hash ?? features?.verify?.se04BootHash,
-});
-
-const normalizeV2Verify = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVerify => {
-  const info = deviceInfo;
-  return {
-    firmwareBuildId: getImageBuildId(info?.fw?.application),
-    firmwareHash: getImageHash(info?.fw?.application),
-    bootloaderBuildId: getImageBuildId(info?.fw?.bootloader),
-    bootloaderHash: getImageHash(info?.fw?.bootloader),
-    boardBuildId: getImageBuildId(info?.fw?.romloader),
-    boardHash: getImageHash(info?.fw?.romloader),
-    bleBuildId: getImageBuildId(info?.coprocessor?.application),
-    bleHash: getImageHash(info?.coprocessor?.application),
-    se01BuildId: getImageBuildId(info?.se1?.application),
-    se01Hash: getImageHash(info?.se1?.application),
-    se02BuildId: getImageBuildId(info?.se2?.application),
-    se02Hash: getImageHash(info?.se2?.application),
-    se03BuildId: getImageBuildId(info?.se3?.application),
-    se03Hash: getImageHash(info?.se3?.application),
-    se04BuildId: getImageBuildId(info?.se4?.application),
-    se04Hash: getImageHash(info?.se4?.application),
-    se01BootBuildId: getImageBuildId(info?.se1?.bootloader),
-    se01BootHash: getImageHash(info?.se1?.bootloader),
-    se02BootBuildId: getImageBuildId(info?.se2?.bootloader),
-    se02BootHash: getImageHash(info?.se2?.bootloader),
-    se03BootBuildId: getImageBuildId(info?.se3?.bootloader),
-    se03BootHash: getImageHash(info?.se3?.bootloader),
-    se04BootBuildId: getImageBuildId(info?.se4?.bootloader),
-    se04BootHash: getImageHash(info?.se4?.bootloader),
-  };
-};
-
-const normalizeRaw = ({
-  features,
-  protocolV1OneKeyFeatures,
-  protocolV2DeviceInfo,
-}: {
-  features?: Features;
-  protocolV1OneKeyFeatures?: OnekeyFeatures;
-  protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
-}): DeviceProfileRaw => ({
-  ...(features ? { features } : {}),
-  ...(protocolV1OneKeyFeatures ? { protocolV1OneKeyFeatures } : {}),
-  ...(protocolV2DeviceInfo ? { protocolV2DeviceInfo } : {}),
-});
-
-export function buildProfileFromProtocolV1({
-  protocol = 'V1',
-  features,
-  protocolV1OneKeyFeatures,
-  sources = ['features'],
-  scope = 'basic',
-  includeRaw = false,
-}: BuildProtocolV1ProfileParams): DeviceProfile {
-  const sourceFeatures = features;
-  const verify = normalizeV1Verify(sourceFeatures, protocolV1OneKeyFeatures);
-
-  return {
-    protocol,
-    sources,
-    deviceType: getDeviceType(sourceFeatures),
-    firmwareType: getFirmwareType(sourceFeatures),
-    deviceId: sourceFeatures?.deviceId || (sourceFeatures ? getDeviceUUID(sourceFeatures) : ''),
-    serialNo: sourceFeatures ? getDeviceUUID(sourceFeatures) : '',
-    label: getDeviceLabel(sourceFeatures),
-    bleName: getDeviceBleName(sourceFeatures),
-    status: normalizeV1Status(sourceFeatures),
-    versions: normalizeV1Versions(sourceFeatures, protocolV1OneKeyFeatures),
-    ...(shouldIncludeVerify(scope) ? { verify } : {}),
-    ...(includeRaw
-      ? {
-          raw: normalizeRaw({
-            features,
-            protocolV1OneKeyFeatures,
-          }),
-        }
-      : {}),
-  };
-}
-
-export function buildProfileFromProtocolV2({
-  deviceInfo,
-  sources = ['deviceInfo'],
-  scope = 'basic',
-  includeRaw = false,
-}: BuildProtocolV2ProfileParams): DeviceProfile {
-  const info = deviceInfo;
-  const deviceId = info?.status?.device_id || '';
-  const serialNo = deviceInfo?.hw?.serial_no || '';
-  const label = null;
-  const bleName = info?.coprocessor?.bt_adv_name ?? null;
-  const verify = normalizeV2Verify(deviceInfo);
-
-  return {
-    protocol: 'V2',
-    sources,
-    deviceType: EDeviceType.Pro2,
-    firmwareType: EFirmwareType.Universal,
-    deviceId,
-    serialNo,
-    label,
-    bleName,
-    status: normalizeV2Status(deviceInfo),
-    versions: normalizeV2Versions(deviceInfo),
-    ...(shouldIncludeVerify(scope) ? { verify } : {}),
-    ...(includeRaw
-      ? {
-          raw: normalizeRaw({
-            protocolV2DeviceInfo: deviceInfo,
-          }),
-        }
-      : {}),
-  };
-}

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

@@ -1,46 +0,0 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import { LoggerNames, getLogger } from '../../utils';
-
-import type { BaseMethod } from '../../api/BaseMethod';
-import type { Device } from '../../device/Device';
-
-const Log = getLogger(LoggerNames.Core);
-
-type RunnableMethod = Pick<BaseMethod, 'run' | 'unlockPolicy'> & { name?: string };
-type UnlockableDevice = Pick<Device, 'isProtocolV2' | 'unlockDevice'>;
-
-function isDeviceLockedError(error: unknown): boolean {
-  return (
-    typeof error === 'object' &&
-    error !== null &&
-    'errorCode' in error &&
-    error.errorCode === HardwareErrorCode.DeviceLocked
-  );
-}
-
-export async function runMethodWithUnlockRetry(method: RunnableMethod, device: UnlockableDevice) {
-  try {
-    return await method.run();
-  } catch (error) {
-    if (
-      !device.isProtocolV2() ||
-      method.unlockPolicy !== 'retry-on-locked' ||
-      !isDeviceLockedError(error)
-    ) {
-      throw error;
-    }
-
-    Log.debug('Protocol V2 unlock retry triggered', { method: method.name });
-    await device.unlockDevice();
-    Log.debug('Protocol V2 unlock completed', { method: method.name });
-    try {
-      const response = await method.run();
-      Log.debug('Protocol V2 method retry completed', { method: method.name, success: true });
-      return response;
-    } catch (retryError) {
-      Log.debug('Protocol V2 method retry completed', { method: method.name, success: false });
-      throw retryError;
-    }
-  }
-}

package/src/types/api/getDeviceInfo.ts

@@ -1,101 +0,0 @@
-import type { CommonParams, Response } from '../params';
-import type { Features, IDeviceType, OnekeyFeatures } from '../device';
-import type { EFirmwareType } from '@onekeyfe/hd-shared';
-import type { ProtocolType, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
-
-// 协议类型单源：从 hd-transport 的 ProtocolType 派生，只额外允许 'unknown'。
-export type DeviceInfoProtocol = ProtocolType | 'unknown';
-
-export type DeviceInfoSource = 'features' | 'protocolV1OneKeyFeatures' | 'deviceInfo';
-
-export type DeviceInfoScope = 'basic' | 'versions' | 'verify' | 'full';
-
-export type GetDeviceInfoParams = {
-  scope?: DeviceInfoScope;
-  refresh?: boolean;
-  includeRaw?: boolean;
-};
-
-export type DeviceInfoMode = 'normal' | 'bootloader' | 'romloader' | 'notInitialized' | 'unknown';
-
-export type DeviceInfoStatus = {
-  mode: DeviceInfoMode;
-  initialized: boolean | null;
-  bootloaderMode: boolean | null;
-  unlocked: boolean | null;
-  passphraseProtection: boolean | null;
-  attachToPinEnabled?: boolean | null;
-  unlockedAttachPin?: boolean | null;
-  backupRequired: boolean | null;
-  noBackup: boolean | null;
-  language: string | null;
-  bleEnabled: boolean | null;
-};
-
-export type DeviceProfileVersions = {
-  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 DeviceProfileVerify = {
-  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 DeviceProfileRaw = {
-  features?: Features;
-  protocolV1OneKeyFeatures?: OnekeyFeatures;
-  protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
-};
-
-export type DeviceProfile = {
-  protocol: DeviceInfoProtocol;
-  sources: DeviceInfoSource[];
-  deviceType: IDeviceType;
-  firmwareType: EFirmwareType;
-  deviceId: string;
-  serialNo: string;
-  label: string | null;
-  bleName: string | null;
-  status: DeviceInfoStatus;
-  versions: DeviceProfileVersions;
-  verify?: DeviceProfileVerify;
-  raw?: DeviceProfileRaw;
-};
-
-export declare function getDeviceInfo(
-  connectId?: string,
-  params?: CommonParams & GetDeviceInfoParams
-): Response<DeviceProfile>;