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

package/src/types/settings.ts

@@ -31,6 +31,8 @@ export type ConnectSettings = {
   timestamp: number;
   isFrame?: boolean;
   preRelease?: boolean;
+  firmwareManifestMode?: 'sdk-managed' | 'external-only';
+  preloadedConfig?: RemoteConfigResponse;
   fetchConfig?: boolean;
   extension?: string;
   configFetcher?: (url: string) => Promise<RemoteConfigResponse | null>;
@@ -40,6 +42,43 @@ export type IVersionArray = [number, number, number];
 
 export type ILocale = 'zh-CN' | 'en-US';
 
+export type IProtocolV2FirmwareComponentTarget =
+  | 'ROMLOADER'
+  | 'BOOTLOADER'
+  | 'APPLICATION_P1'
+  | 'APPLICATION_P2'
+  | 'COPROCESSOR'
+  | 'SE01'
+  | 'SE02'
+  | 'SE03'
+  | 'SE04';
+
+export type IProtocolV2FirmwareComponent = {
+  target: IProtocolV2FirmwareComponentTarget;
+  url: string;
+  fingerprint?: string;
+  expectedSize?: number;
+  version?: IVersionArray;
+};
+
+/** Pro2 RESC bundle okpkg descriptor for incremental FileWrite synchronization. */
+export type IProtocolV2ResourceBundle = {
+  /** Bundle name, such as images, animation, translations, or fonts_roobert. */
+  name: string;
+  /** Download URL. */
+  url: string;
+  fingerprint?: string;
+  expectedSize?: number;
+  /** Device target path, such as vol0:/bundles/images/images.okpkg. */
+  devicePath: string;
+  /** okpkg payload_version used to skip matching content after FileRead. */
+  version?: IVersionArray;
+  /** okpkg payload_hash used for SHA3-512 comparison after FileRead. */
+  payloadHash?: string;
+  /** okpkg header_hash used for SHA3-512 comparison after FileRead. */
+  headerHash?: string;
+};
+
 /** STM32 firmware config */
 export type IFirmwareReleaseInfo = {
   required: boolean;
@@ -51,17 +90,29 @@ export type IFirmwareReleaseInfo = {
   firmwareType?: EFirmwareType;
   /** Firmware UI resource */
   resource?: string;
+  resourceFingerprint?: string;
+  resourceExpectedSize?: number;
   /** Firmware full UI resource */
   fullResource?: string;
+  fullResourceFingerprint?: string;
+  fullResourceExpectedSize?: number;
   fullResourceRange?: string[];
   bootloaderResource?: string;
+  bootloaderFingerprint?: string;
+  bootloaderExpectedSize?: number;
   bootloaderVersion?: IVersionArray;
   displayBootloaderVersion?: IVersionArray;
   bootloaderRelatedFirmwareVersion?: IVersionArray;
+  upgradeType?: 'payload-package-set' | string;
+  components?: Record<string, IProtocolV2FirmwareComponent>;
+  installOrder?: string[];
+  /** Pro2 RESC bundles for incremental direct FileWrite synchronization. */
+  resourceBundles?: IProtocolV2ResourceBundle[];
   bootloaderChangelog?: {
     [k in ILocale]: string;
   };
   fingerprint: string;
+  expectedSize?: number;
   version: IVersionArray;
   changelog: {
     [k in ILocale]: string;
@@ -77,6 +128,7 @@ export type IBLEFirmwareReleaseInfo = {
   webUpdate: string;
   fingerprint: string;
   fingerprintWeb: string;
+  expectedSize?: number;
   version: IVersionArray;
   changelog: {
     [k in ILocale]: string;
@@ -85,41 +137,14 @@ export type IBLEFirmwareReleaseInfo = {
 
 type IKnownDevice = Exclude<IDeviceType, 'unknown'>;
 
-/**
- * Device firmware configuration map
- *
- * IMPORTANT: This type is used for firmware update logic.
- * - DO NOT remove existing firmware fields
- * - Only ADD new optional firmware fields for new versions
- * - 'firmware' field is required for backward compatibility
- * - 'ble' field is required for BLE firmware updates
- *
- * @example
- * // When adding firmware-v8:
- * // {
- * //   firmware: IFirmwareReleaseInfo[];
- * //   'firmware-v2'?: IFirmwareReleaseInfo[];
- * //   'firmware-v8'?: IFirmwareReleaseInfo[];
- * //   'firmware-v8'?: IFirmwareReleaseInfo[];      // New
- * //   'firmware-btc-v8'?: IFirmwareReleaseInfo[];
- * //   'firmware-btc-v8'?: IFirmwareReleaseInfo[];  // New
- * //   ble: IBLEFirmwareReleaseInfo[];
- * // }
- */
 export type DeviceTypeMap = {
   [k in IKnownDevice]: {
-    /** Base firmware field (required for backward compatibility) */
     firmware: IFirmwareReleaseInfo[];
-    /** Firmware v2 (Touch/Pro specific) */
+    /** Pro2 Protocol V2 payload package set */
+    'firmware-v1'?: IFirmwareReleaseInfo[];
     'firmware-v2'?: IFirmwareReleaseInfo[];
-    /** Universal firmware v7 */
     'firmware-v8'?: IFirmwareReleaseInfo[];
-    /** Bitcoin-only firmware v7 */
     'firmware-btc-v8'?: IFirmwareReleaseInfo[];
-    // Future firmware versions should be added here as optional fields:
-    // 'firmware-v8'?: IFirmwareReleaseInfo[];
-    // 'firmware-btc-v8'?: IFirmwareReleaseInfo[];
-    /** BLE firmware (required) */
     ble: IBLEFirmwareReleaseInfo[];
   };
 };

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)) {

package/src/utils/deviceFeaturesCompat.ts

@@ -0,0 +1,173 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { Enum_Capability } from '@onekeyfe/hd-transport';
+
+import type { PROTO } from '../constants';
+import type { Features, IDeviceType } from '../types';
+
+export type DeviceFeaturesInput = Features | PROTO.Features;
+
+type CompatibleDeviceFeatures = Partial<Features> &
+  Partial<PROTO.Features> & {
+    onekey_serial?: string;
+    onekey_version?: string;
+  };
+
+const asCompatibleFeatures = (features: DeviceFeaturesInput): CompatibleDeviceFeatures =>
+  features as CompatibleDeviceFeatures;
+
+const firstNonEmptyString = (...values: Array<string | null | undefined>) =>
+  values.find(value => typeof value === 'string' && value.length > 0);
+
+const firstMeaningfulVersion = (...versions: Array<string | null | undefined>) =>
+  versions.find(version => Boolean(version && version !== '0.0.0')) ?? null;
+
+const versionFromParts = (major?: number | null, minor?: number | null, patch?: number | null) =>
+  [major, minor, patch].map(part => Number(part) || 0).join('.');
+
+export const resolveDeviceSerialNo = (features?: DeviceFeaturesInput): string => {
+  if (!features) return '';
+  const compatible = asCompatibleFeatures(features);
+  return (
+    firstNonEmptyString(
+      compatible.serialNo,
+      compatible.onekey_serial_no,
+      compatible.onekey_serial,
+      compatible.serial_no
+    ) ?? ''
+  );
+};
+
+export const resolveDeviceType = (features?: DeviceFeaturesInput): IDeviceType => {
+  if (!features || typeof features !== 'object') {
+    return EDeviceType.Unknown;
+  }
+
+  const compatible = asCompatibleFeatures(features);
+  if (compatible.deviceType && compatible.deviceType !== EDeviceType.Unknown) {
+    return compatible.deviceType;
+  }
+
+  switch (compatible.onekey_device_type?.toString().toUpperCase()) {
+    case 'CLASSIC':
+      return EDeviceType.Classic;
+    case 'CLASSIC1S':
+      return EDeviceType.Classic1s;
+    case 'MINI':
+      return EDeviceType.Mini;
+    case 'TOUCH':
+      return EDeviceType.Touch;
+    case 'PRO':
+      return EDeviceType.Pro;
+    case 'PRO2':
+      return EDeviceType.Pro2;
+    case 'PURE':
+      return EDeviceType.ClassicPure;
+    default:
+      break;
+  }
+
+  if (compatible.model?.toString().toLowerCase() === EDeviceType.Pro2) {
+    return EDeviceType.Pro2;
+  }
+
+  const serialNo = resolveDeviceSerialNo(features);
+  const prefix = serialNo.slice(0, 2).toLowerCase();
+  if (prefix === 'bi' || prefix === 'cl') return EDeviceType.Classic;
+  if (prefix === 'cp') return EDeviceType.ClassicPure;
+  if (prefix === 'mi') return EDeviceType.Mini;
+  if (prefix === 'tc') return EDeviceType.Touch;
+  if (prefix === 'pr') return EDeviceType.Pro;
+  if (prefix === 'p2') return EDeviceType.Pro2;
+
+  const bootloaderMode = compatible.bootloaderMode ?? compatible.bootloader_mode;
+  if (!serialNo && bootloaderMode === true && compatible.model === '1') {
+    return EDeviceType.Classic;
+  }
+
+  return compatible.deviceType ?? EDeviceType.Unknown;
+};
+
+export const resolveDeviceFirmwareType = (features?: DeviceFeaturesInput): EFirmwareType => {
+  if (!features) {
+    return EFirmwareType.Universal;
+  }
+
+  const compatible = asCompatibleFeatures(features);
+  if (compatible.firmwareType) {
+    return compatible.firmwareType;
+  }
+  if (compatible.fw_vendor === 'OneKey Bitcoin-only') {
+    return EFirmwareType.BitcoinOnly;
+  }
+
+  const capabilities = compatible.capabilities as Array<number | string> | null | undefined;
+  const supportsBitcoinLike = capabilities?.some(
+    capability =>
+      capability === Enum_Capability.Capability_Bitcoin_like ||
+      capability === 'Capability_Bitcoin_like'
+  );
+  return capabilities?.length && !supportsBitcoinLike
+    ? EFirmwareType.BitcoinOnly
+    : EFirmwareType.Universal;
+};
+
+export const resolveDeviceBleName = (features?: DeviceFeaturesInput): string | null => {
+  if (!features) return null;
+  const compatible = asCompatibleFeatures(features);
+  return (
+    firstNonEmptyString(compatible.bleName, compatible.onekey_ble_name, compatible.ble_name) ?? null
+  );
+};
+
+export const resolveDeviceFirmwareVersion = (features?: DeviceFeaturesInput): string | null => {
+  if (!features) return null;
+  const compatible = asCompatibleFeatures(features);
+  return firstMeaningfulVersion(
+    compatible.firmwareVersion,
+    compatible.onekey_firmware_version,
+    compatible.onekey_version,
+    versionFromParts(compatible.major_version, compatible.minor_version, compatible.patch_version)
+  );
+};
+
+export const resolveDeviceBootloaderVersion = (features?: DeviceFeaturesInput): string | null => {
+  if (!features) return null;
+  const compatible = asCompatibleFeatures(features);
+  const bootloaderMode = compatible.bootloaderMode ?? compatible.bootloader_mode;
+  return firstMeaningfulVersion(
+    compatible.bootloaderVersion,
+    compatible.onekey_boot_version,
+    compatible.bootloader_version,
+    compatible.onekey_bootloader_version,
+    bootloaderMode
+      ? versionFromParts(
+          compatible.major_version,
+          compatible.minor_version,
+          compatible.patch_version
+        )
+      : null
+  );
+};
+
+export const resolveDeviceBoardVersion = (features?: DeviceFeaturesInput): string | null => {
+  if (!features) return null;
+  const compatible = asCompatibleFeatures(features);
+  return firstMeaningfulVersion(
+    compatible.boardVersion,
+    compatible.onekey_board_version,
+    compatible.boardloader_version,
+    compatible.onekey_romloader_version,
+    compatible.romloader_version
+  );
+};
+
+export const resolveDeviceBleFirmwareVersion = (features?: DeviceFeaturesInput): string | null => {
+  if (!features) return null;
+  const compatible = asCompatibleFeatures(features);
+  return firstMeaningfulVersion(
+    compatible.bleVersion,
+    compatible.onekey_ble_version,
+    compatible.ble_ver,
+    compatible.onekey_coprocessor_version
+  );
+};

package/src/utils/deviceFeaturesUtils.ts

@@ -1,32 +1,47 @@
 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 { getProtocolV2WalletSession } from '../protocols/protocol-v2/walletSession';
 
 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 = (
+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('.');
   const deviceType = getDeviceType(features);
 
+  // In bootloader mode the major/minor/patch fields carry the bootloader version, not the
+  // firmware version; normalizing them would mis-route to the legacy schema (e.g. 2.x < 3.3.0).
+  // The legacy getDeviceFirmwareVersion returned 0.0.0 here and landed on v1CurrentSchema, so
+  // force v1CurrentSchema for every bootloader device, including in-place upgrades on
+  // Classic1s/Touch/Pro where firmware is still present.
+  if (features.bootloaderMode === true) {
+    return {
+      messages: DataManager.messages.v1CurrentSchema,
+      protocolV1MessageSchema: 'v1CurrentSchema',
+    };
+  }
+
   const deviceVersionConfigs =
     PROTOBUF_MESSAGE_CONFIG[deviceType] ||
     (DeviceTypeToModels[deviceType] &&
@@ -37,26 +52,30 @@ 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',
   };
 };
 
-export const supportInputPinOnSoftware = (features: Features): SupportFeatureType => {
+export const supportInputPinOnSoftware = (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: false };
   }
 
@@ -68,7 +87,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 +105,46 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   options?: {
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
+    initSession?: boolean;
   }
 ) => {
-  const { features, commands } = device;
+  if (device.isProtocolV2()) {
+    if (!device.features) {
+      return {
+        passphraseState: undefined,
+        newSession: undefined,
+        unlockedAttachPin: undefined,
+      };
+    }
+
+    return getProtocolV2WalletSession(device, {
+      initSession: options?.initSession,
+      expectedPassphraseState: options?.expectPassphraseState,
+      onlyMainPin: options?.onlyMainPin,
+    });
+  }
+
+  const { features } = device;
   const locked = features?.unlocked === false;
+  const deviceType = device.getCurrentDeviceType();
 
-  const { passphraseState, newSession, unlockedAttachPin } = await getPassphraseState(
-    features,
-    commands,
-    {
-      ...options,
-    }
-  );
+  if (options?.initSession) {
+    device.clearInternalState();
+  }
+
+  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,49 +155,72 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   }
 
   // Attach to pin try to fix internal state
-  if (features?.device_id) {
-    device.updateInternalState(
-      device.features?.passphrase_protection ?? false,
-      passphraseState,
-      device.features?.device_id ?? '',
-      newSession,
-      device.features?.session_id
-    );
-  }
+  const deviceId = device.getCurrentDeviceId();
+  device.updateInternalState(
+    device.getCurrentPassphraseProtection() ?? false,
+    passphraseState,
+    deviceId,
+    newSession,
+    options?.initSession ? null : device.features?.sessionId
+  );
 
-  return { passphraseState, newSession, unlockedAttachPin };
+  return {
+    passphraseState,
+    newSession,
+    unlockedAttachPin: unlockedAttachPin ?? device.features?.unlockedAttachPin,
+  };
 };
 
+// Applies to Protocol V1 Pro only; Pro2 has an independent version line.
+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;
+    initSession?: boolean;
   }
 ): Promise<{
   passphraseState: string | undefined;
   newSession: string | undefined;
   unlockedAttachPin: boolean | undefined;
 }> => {
+  const { features, commands } = device;
+
+  // Preserve legacy empty-result semantics until the device has established state.
   if (!features)
     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();
+
+  if (device.isProtocolV2()) {
+    return getProtocolV2WalletSession(device, {
+      initSession: options?.initSession,
+      expectedPassphraseState: options?.expectPassphraseState,
+      onlyMainPin: options?.onlyMainPin,
+    });
+  }
 
   const supportAttachPinCapability = existCapability(
     features,
     Enum_Capability.Capability_AttachToPin
   );
   const supportGetPassphraseState =
-    supportAttachPinCapability ||
-    (deviceType === EDeviceType.Pro && semver.gte(firmwareVersion.join('.'), '4.15.0'));
+    supportAttachPinCapability || supportProSeriesAttachPinPassphrase(deviceType, firmwareVersion);
 
   if (supportGetPassphraseState) {
-    const { message, type } = await commands.typedCall('GetPassphraseState', 'PassphraseState', {
+    const payload: GetPassphraseState = {
       passphrase_state: options?.onlyMainPin ? undefined : options?.expectPassphraseState,
-    });
+    };
+
+    const { message, type } = await commands.typedCall(
+      'GetPassphraseState',
+      'PassphraseState',
+      payload
+    );
 
     // @ts-expect-error
     if (type === 'CallMethodError') {
@@ -186,40 +253,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 };
@@ -278,6 +313,9 @@ export const getFirmwareUpdateField = ({
   if (deviceType === EDeviceType.Pro) {
     return latestFirmwareField;
   }
+  if (deviceType === EDeviceType.Pro2) {
+    return 'firmware-v1';
+  }
   return 'firmware';
 };
 /**
@@ -321,6 +359,10 @@ export const getFirmwareUpdateFieldArray = (
     return ['firmware-v8'];
   }
 
+  if (deviceType === 'pro2') {
+    return ['firmware-v1'];
+  }
+
   return ['firmware'];
 };
 
@@ -340,12 +382,8 @@ export const fixFeaturesFirmwareVersion = (features: Features): Features => {
   // fix Touch、Pro device when bootloader version is lower than 2.5.2, the features returned do not have firmware_version error
   const tempFeatures = { ...features };
 
-  if (tempFeatures.onekey_firmware_version && !semver.valid(tempFeatures.onekey_firmware_version)) {
-    tempFeatures.onekey_firmware_version = fixVersion(tempFeatures.onekey_firmware_version);
-  }
-
-  if (tempFeatures.onekey_version && !semver.valid(tempFeatures.onekey_version)) {
-    tempFeatures.onekey_version = fixVersion(tempFeatures.onekey_version);
+  if (tempFeatures.firmwareVersion && !semver.valid(tempFeatures.firmwareVersion)) {
+    tempFeatures.firmwareVersion = fixVersion(tempFeatures.firmwareVersion);
   }
 
   return tempFeatures;