@onekeyfe/hd-core 1.2.0-alpha.9 → 1.2.0-alpha.90

package/src/utils/deviceFeaturesUtils.ts

@@ -30,6 +30,18 @@ export const getSupportProtocolV1MessageSchema = (
   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] &&
@@ -55,11 +67,16 @@ export const getSupportProtocolV1MessageSchema = (
   };
 };
 
-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 ||
+    deviceType === EDeviceType.Neo
+  ) {
     return { support: false };
   }
 
@@ -74,7 +91,8 @@ export const supportNewPassphrase = (features?: Features): SupportFeatureType =>
   if (
     deviceType === EDeviceType.Touch ||
     deviceType === EDeviceType.Pro ||
-    deviceType === EDeviceType.Pro2
+    deviceType === EDeviceType.Pro2 ||
+    deviceType === EDeviceType.Neo
   ) {
     return { support: true };
   }
@@ -89,8 +107,9 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   options?: {
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
-    allowCreateAttachPin?: boolean;
     initSession?: boolean;
+    deriveCardano?: boolean;
+    rejectAttachPinForMainWallet?: boolean;
   }
 ) => {
   if (device.isProtocolV2()) {
@@ -105,6 +124,9 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
     return getProtocolV2WalletSession(device, {
       initSession: options?.initSession,
       expectedPassphraseState: options?.expectPassphraseState,
+      onlyMainPin: options?.onlyMainPin,
+      deriveCardano: options?.deriveCardano,
+      rejectAttachPinForMainWallet: options?.rejectAttachPinForMainWallet,
     });
   }
 
@@ -123,7 +145,8 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   const isModeT =
     deviceType === EDeviceType.Touch ||
     deviceType === EDeviceType.Pro ||
-    deviceType === EDeviceType.Pro2;
+    deviceType === EDeviceType.Pro2 ||
+    deviceType === EDeviceType.Neo;
 
   // 如果可以获取到 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
@@ -140,12 +163,16 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
 
   // Attach to pin try to fix internal state
   const deviceId = device.getCurrentDeviceId();
+  let existingSessionId: string | null | undefined;
+  if (!options?.initSession && typeof device.getInternalState === 'function') {
+    existingSessionId = device.getInternalState();
+  }
   device.updateInternalState(
     device.getCurrentPassphraseProtection() ?? false,
     passphraseState,
     deviceId,
     newSession,
-    options?.initSession ? null : device.features?.sessionId
+    options?.initSession ? null : existingSessionId
   );
 
   return {
@@ -155,7 +182,7 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   };
 };
 
-// 仅适用于 Protocol V1 的 Pro：Pro2 走独立版本线，不能套用 4.15.0 门槛
+// 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');
 
@@ -164,8 +191,9 @@ export const getPassphraseState = async (
   options?: {
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
-    allowCreateAttachPin?: boolean;
     initSession?: boolean;
+    deriveCardano?: boolean;
+    rejectAttachPinForMainWallet?: boolean;
   }
 ): Promise<{
   passphraseState: string | undefined;
@@ -174,7 +202,7 @@ export const getPassphraseState = async (
 }> => {
   const { features, commands } = device;
 
-  // 设备尚未建立任何状态时无法判定，保持旧的空返回语义
+  // Preserve legacy empty-result semantics until the device has established state.
   if (!features)
     return { passphraseState: undefined, newSession: undefined, unlockedAttachPin: undefined };
 
@@ -185,6 +213,9 @@ export const getPassphraseState = async (
     return getProtocolV2WalletSession(device, {
       initSession: options?.initSession,
       expectedPassphraseState: options?.expectPassphraseState,
+      onlyMainPin: options?.onlyMainPin,
+      deriveCardano: options?.deriveCardano,
+      rejectAttachPinForMainWallet: options?.rejectAttachPinForMainWallet,
     });
   }
 
@@ -196,12 +227,9 @@ export const getPassphraseState = async (
     supportAttachPinCapability || supportProSeriesAttachPinPassphrase(deviceType, firmwareVersion);
 
   if (supportGetPassphraseState) {
-    const payload: GetPassphraseState = options?.onlyMainPin
-      ? { _only_main_pin: true }
-      : { passphrase_state: options?.expectPassphraseState };
-    if (options?.allowCreateAttachPin) {
-      payload.allow_create_attach_pin = true;
-    }
+    const payload: GetPassphraseState = {
+      passphrase_state: options?.onlyMainPin ? undefined : options?.expectPassphraseState,
+    };
 
     const { message, type } = await commands.typedCall(
       'GetPassphraseState',
@@ -300,7 +328,7 @@ export const getFirmwareUpdateField = ({
   if (deviceType === EDeviceType.Pro) {
     return latestFirmwareField;
   }
-  if (deviceType === EDeviceType.Pro2) {
+  if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) {
     return 'firmware-v1';
   }
   return 'firmware';
@@ -346,7 +374,7 @@ export const getFirmwareUpdateFieldArray = (
     return ['firmware-v8'];
   }
 
-  if (deviceType === 'pro2') {
+  if (deviceType === 'pro2' || deviceType === 'neo') {
     return ['firmware-v1'];
   }
 

package/src/utils/deviceInfoUtils.ts

@@ -1,51 +1,21 @@
-import { isEmpty } from 'lodash';
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
-import { Enum_Capability } from '@onekeyfe/hd-transport';
+import { EDeviceType } from '@onekeyfe/hd-shared';
 
 import { DeviceModelToTypes } from '../types';
-import { existCapability } from './capabilitieUtils';
+import {
+  resolveDeviceBleName,
+  resolveDeviceFirmwareType,
+  resolveDeviceSerialNo,
+  resolveDeviceType,
+} from './deviceFeaturesCompat';
 
-import type { Features, IDeviceModel, IDeviceType, IVersionRange } from '../types';
+import type { IDeviceModel, IDeviceType, IVersionRange } from '../types';
+import type { DeviceFeaturesInput } from './deviceFeaturesCompat';
 
 /**
  * get device type by features
  */
-export const getDeviceType = (features?: Features): IDeviceType => {
-  if (!features || typeof features !== 'object') {
-    return EDeviceType.Unknown;
-  }
-  if (features.deviceType) {
-    return features.deviceType;
-  }
-
-  if (features.model === EDeviceType.Pro2 || features.model === 'pro2') {
-    return EDeviceType.Pro2;
-  }
-
-  // low version hardware
-  // onekey_serial_no > onekey_serial > serial_no
-  const serialNo = getDeviceUUID(features);
-
-  // not exist serialNo, bootloader mode, model 1 is classic
-  if (isEmpty(serialNo) && features.bootloaderMode === true && features.model === '1') {
-    return EDeviceType.Classic;
-  }
-
-  if (isEmpty(serialNo)) return EDeviceType.Unknown;
-
-  const miniFlag = serialNo.slice(0, 2);
-  // By May 2021, the miniFlag is 'bixin' for all classic devices
-  if (miniFlag.toLowerCase() === 'bi') return EDeviceType.Classic;
-  if (miniFlag.toLowerCase() === 'cl') return EDeviceType.Classic;
-  if (miniFlag.toLowerCase() === 'cp') return EDeviceType.ClassicPure;
-  if (miniFlag.toLowerCase() === 'mi') return EDeviceType.Mini;
-  if (miniFlag.toLowerCase() === 'tc') return EDeviceType.Touch;
-  if (miniFlag.toLowerCase() === 'pr') return EDeviceType.Pro;
-  if (miniFlag.toLowerCase() === 'p2') return EDeviceType.Pro2;
-
-  // unknown device
-  return EDeviceType.Unknown;
-};
+export const getDeviceType = (features?: DeviceFeaturesInput): IDeviceType =>
+  resolveDeviceType(features);
 
 /**
  * get device type by ble name
@@ -61,6 +31,7 @@ export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
   if (/^Touch/i.test(name)) return EDeviceType.Touch;
 
   if (/\bPro\s*2\b/i.test(name) || /^Pro2/i.test(name)) return EDeviceType.Pro2;
+  if (/\bNeo\b/i.test(name) || /^Neo/i.test(name)) return EDeviceType.Neo;
   if (/\bPro\b/i.test(name) || /^Pro/i.test(name)) return EDeviceType.Pro;
 
   return EDeviceType.Unknown;
@@ -70,33 +41,35 @@ export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
  * Get Connected Device ble name by features
  * @returns
  */
-export const getDeviceBleName = (features?: Features): string | null => {
-  if (features == null) return null;
-  return features.bleName || null;
-};
+export const getDeviceBleName = (features?: DeviceFeaturesInput): string | null =>
+  resolveDeviceBleName(features);
 
 /**
- * Get Connected Device UUID by features
+ * Get Connected Device serial number by features
  */
-export const getDeviceUUID = (features: Features) => {
-  return features.serialNo ?? '';
-};
+export const getDeviceSerialNo = (features?: DeviceFeaturesInput): string =>
+  resolveDeviceSerialNo(features);
+
+/**
+ * @deprecated Use getDeviceSerialNo instead.
+ */
+export const getDeviceUUID = getDeviceSerialNo;
 
 /**
  * Get Connected Device label by features
  */
-export const getDeviceLabel = (features?: Features) => {
+export const getDeviceLabel = (features?: DeviceFeaturesInput) => {
   if (!features) return null;
 
   const deviceType = getDeviceType(features);
   if (deviceType == null) return null;
 
-  if (typeof features.label === 'string' && !isEmpty(features.label)) {
+  if ('label' in features && typeof features.label === 'string' && features.label.length > 0) {
     return features.label;
   }
 
   const bleName = getDeviceBleName(features);
-  if (!isEmpty(bleName)) return bleName;
+  if (bleName) return bleName;
 
   if (deviceType === EDeviceType.ClassicPure) {
     return 'OneKey Classic 1S';
@@ -110,7 +83,7 @@ export const getDeviceLabel = (features?: Features) => {
  * Type has a higher priority than Model
  */
 export const getMethodVersionRange = (
-  features: Features | undefined,
+  features: DeviceFeaturesInput | undefined,
   getVersionRange: (deviceModel: IDeviceType | IDeviceModel) => IVersionRange | undefined
 ): IVersionRange | undefined => {
   const deviceType = getDeviceType(features);
@@ -121,6 +94,7 @@ export const getMethodVersionRange = (
   }
 
   const modelFallbacks: IDeviceModel[] = [
+    'model_pro2',
     'model_classic1s',
     'model_classic',
     'model_mini',
@@ -138,19 +112,5 @@ export const getMethodVersionRange = (
   return undefined;
 };
 
-export const isMethodVersionRangeUnsupported = (versionRange?: IVersionRange): boolean =>
-  versionRange?.unsupported === true;
-
-export const getFirmwareType = (features: Features | undefined) => {
-  if (!features) {
-    return EFirmwareType.Universal;
-  }
-  if (features.firmwareType) {
-    return features.firmwareType;
-  }
-  // old firmware
-  return features?.capabilities?.length > 0 &&
-    !existCapability(features, Enum_Capability.Capability_Bitcoin_like)
-    ? EFirmwareType.BitcoinOnly
-    : EFirmwareType.Universal;
-};
+export const getFirmwareType = (features?: DeviceFeaturesInput) =>
+  resolveDeviceFirmwareType(features);

package/src/utils/deviceSettings.ts

@@ -1,6 +1,52 @@
 import { EDeviceType } from '@onekeyfe/hd-shared';
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
 
 import type { IDeviceType } from '../types';
+import type { DeviceSettingsParams } from '../types/api/deviceSettings';
+import type { SafetyCheckLevel } from '@onekeyfe/hd-transport';
+
+export type DeviceSettingsProtocol = 'V1' | 'V2';
+export type DeviceSettingsField = keyof DeviceSettingsParams;
+
+export const DEVICE_SETTINGS_SHARED_FIELDS = [
+  'language',
+  'label',
+  'usePassphrase',
+  'autoLockDelayMs',
+  'autoShutdownDelayMs',
+  'hapticFeedback',
+  'bluetoothEnabled',
+] as const satisfies readonly DeviceSettingsField[];
+
+export const DEVICE_SETTINGS_V1_ONLY_FIELDS = [
+  'homescreen',
+  'passphraseSource',
+  'displayRotation',
+  'passphraseAlwaysOnDevice',
+  'safetyChecks',
+  'experimentalFeatures',
+  'changeBrightness',
+] as const satisfies readonly DeviceSettingsField[];
+
+export const DEVICE_SETTINGS_V2_ONLY_FIELDS = [
+  'brightness',
+  'airgapMode',
+  'animationEnabled',
+  'tapToWake',
+  'deviceNameDisplayEnabled',
+  'fidoEnabled',
+  'usbLockEnabled',
+  'randomKeypad',
+] as const satisfies readonly DeviceSettingsField[];
+
+export const PROTOCOL_V2_NEVER_TIMEOUT_MS = 0x10000000;
+
+export const normalizeSafetyCheckLevel = (
+  value: SafetyCheckLevel | null | undefined
+): Enum_SafetyCheckLevel | null | undefined => {
+  if (typeof value === 'number' || value === null || value === undefined) return value;
+  return Enum_SafetyCheckLevel[value];
+};
 
 export const LANGUAGE_LABELS = {
   en: 'English',
@@ -19,6 +65,50 @@ export const LANGUAGE_LABELS = {
 export type LanguageKey = keyof typeof LANGUAGE_LABELS;
 export type LanguageOption = { code: LanguageKey; label: (typeof LANGUAGE_LABELS)[LanguageKey] };
 
+export const PROTOCOL_V2_LANGUAGE_BY_KEY: Record<LanguageKey, string> = {
+  en: 'en-Latn-US',
+  zh_cn: 'zh-Hans-CN',
+  zh_hk: 'zh-Hant-HK',
+  ja: 'ja-Jpan-JP',
+  ko: 'ko-Kore-KR',
+  fr: 'fr-Latn-FR',
+  de: 'de-Latn-DE',
+  ru: 'ru-Cyrl-RU',
+  es: 'es-Latn-ES',
+  it: 'it-Latn-IT',
+  pt_br: 'pt-Latn-BR',
+};
+
+export const mapLanguageToProtocolV2 = (language?: string) =>
+  language ? PROTOCOL_V2_LANGUAGE_BY_KEY[language as LanguageKey] ?? language : undefined;
+
+const PROTOCOL_V2_LANGUAGE_KEY_BY_TAG = Object.fromEntries(
+  Object.entries(PROTOCOL_V2_LANGUAGE_BY_KEY).map(([key, tag]) => [tag, key])
+) as Record<string, LanguageKey>;
+
+export const mapLanguageFromProtocolV2 = (language?: string) =>
+  language ? PROTOCOL_V2_LANGUAGE_KEY_BY_TAG[language] ?? language : undefined;
+
+const PRO2_LANGUAGE_OPTIONS = [
+  { code: 'en', label: 'English' },
+  { code: 'zh_cn', label: '简体中文' },
+  { code: 'zh_hk', label: '繁體中文（香港）' },
+  { code: 'zh-Hant-TW', label: '繁體中文（台灣）' },
+  { code: 'ja', label: '日本語' },
+  { code: 'ko', label: '한국어' },
+  { code: 'fr', label: 'Français' },
+  { code: 'de', label: 'Deutsch' },
+  { code: 'ru', label: 'Русский' },
+  { code: 'es', label: 'Español' },
+  { code: 'it', label: 'Italiano' },
+  { code: 'pt_br', label: 'Portuguese (Brazil)' },
+  { code: 'vi-Latn-VN', label: 'Tiếng Việt' },
+  { code: 'tr-Latn-TR', label: 'Türkçe' },
+  { code: 'id-Latn-ID', label: 'Bahasa Indonesia' },
+  { code: 'fil-Latn-PH', label: 'Filipino' },
+  { code: 'uk-Cyrl-UA', label: 'Українська' },
+] as const;
+
 export const getLanguageConfig = (deviceType: IDeviceType): Record<string, string>[] => {
   let keys: LanguageKey[] = [];
 
@@ -36,6 +126,9 @@ export const getLanguageConfig = (deviceType: IDeviceType): Record<string, strin
     case EDeviceType.Pro:
       keys = Object.keys(LANGUAGE_LABELS) as LanguageKey[];
       break;
+    case EDeviceType.Pro2:
+    case EDeviceType.Neo:
+      return PRO2_LANGUAGE_OPTIONS.map(option => ({ ...option }));
     default:
       keys = [];
       break;
@@ -44,66 +137,108 @@ export const getLanguageConfig = (deviceType: IDeviceType): Record<string, strin
   return keys.map(key => ({ code: key, label: LANGUAGE_LABELS[key] }));
 };
 
-export type DurationParts = {
-  seconds: number;
-  minute: number;
-  hour: number;
-  day: number;
+export type DeviceSettingsDurationOption = {
+  label: string;
+  valueMs: number;
 };
 
-export const getAutoLockOptions = (_deviceType: IDeviceType): DurationParts[] => {
-  switch (_deviceType) {
+export type DeviceSettingsValueOption<T> = {
+  label: string;
+  value: T;
+};
+
+const durationOption = (valueMs: number): DeviceSettingsDurationOption => {
+  if (valueMs === 0 || valueMs === PROTOCOL_V2_NEVER_TIMEOUT_MS) {
+    return { label: 'Never', valueMs };
+  }
+  if (valueMs < 60_000) {
+    return { label: `${valueMs / 1000} seconds`, valueMs };
+  }
+  const minutes = valueMs / 60_000;
+  return { label: `${minutes} ${minutes === 1 ? 'minute' : 'minutes'}`, valueMs };
+};
+
+const withNever = (
+  values: readonly number[],
+  protocol: DeviceSettingsProtocol
+): DeviceSettingsDurationOption[] =>
+  [...values, protocol === 'V2' ? PROTOCOL_V2_NEVER_TIMEOUT_MS : 0].map(durationOption);
+
+export const getAutoLockOptions = (
+  deviceType: IDeviceType,
+  protocol: DeviceSettingsProtocol
+): DeviceSettingsDurationOption[] => {
+  switch (deviceType) {
     case EDeviceType.Mini:
     case EDeviceType.Classic:
     case EDeviceType.Classic1s:
     case EDeviceType.ClassicPure:
-      return [
-        { seconds: 0, minute: 1, hour: 0, day: 0 },
-        { seconds: 0, minute: 2, hour: 0, day: 0 },
-        { seconds: 0, minute: 5, hour: 0, day: 0 },
-        { seconds: 0, minute: 10, hour: 0, day: 0 },
-        { seconds: 0, minute: 0, hour: 0, day: 0 },
-      ];
+      return withNever([60_000, 120_000, 300_000, 600_000], protocol);
     case EDeviceType.Touch:
     case EDeviceType.Pro:
-      return [
-        { seconds: 30, minute: 0, hour: 0, day: 0 },
-        { seconds: 0, minute: 1, hour: 0, day: 0 },
-        { seconds: 0, minute: 2, hour: 0, day: 0 },
-        { seconds: 0, minute: 5, hour: 0, day: 0 },
-        { seconds: 0, minute: 10, hour: 0, day: 0 },
-        { seconds: 0, minute: 30, hour: 0, day: 0 },
-        { seconds: 0, minute: 0, hour: 0, day: 0 },
-      ];
+    case EDeviceType.Pro2:
+    case EDeviceType.Neo:
+      return withNever([30_000, 60_000, 120_000, 300_000, 600_000, 1_800_000], protocol);
     default:
       return [];
   }
 };
 
-export const getAutoShutDownOptions = (_deviceType: IDeviceType): DurationParts[] => {
-  switch (_deviceType) {
+export const getAutoShutDownOptions = (
+  deviceType: IDeviceType,
+  protocol: DeviceSettingsProtocol
+): DeviceSettingsDurationOption[] => {
+  switch (deviceType) {
     case EDeviceType.Mini:
       return [];
     case EDeviceType.Classic:
     case EDeviceType.Classic1s:
     case EDeviceType.ClassicPure:
-      return [
-        { seconds: 0, minute: 1, hour: 0, day: 0 },
-        { seconds: 0, minute: 3, hour: 0, day: 0 },
-        { seconds: 0, minute: 5, hour: 0, day: 0 },
-        { seconds: 0, minute: 10, hour: 0, day: 0 },
-        { seconds: 0, minute: 0, hour: 0, day: 0 },
-      ];
+      return withNever([60_000, 180_000, 300_000, 600_000], protocol);
     case EDeviceType.Touch:
     case EDeviceType.Pro:
-      return [
-        { seconds: 0, minute: 1, hour: 0, day: 0 },
-        { seconds: 0, minute: 2, hour: 0, day: 0 },
-        { seconds: 0, minute: 5, hour: 0, day: 0 },
-        { seconds: 0, minute: 10, hour: 0, day: 0 },
-        { seconds: 0, minute: 0, hour: 0, day: 0 },
-      ];
+      return withNever([60_000, 120_000, 300_000, 600_000], protocol);
+    case EDeviceType.Pro2:
+    case EDeviceType.Neo:
+      return withNever([60_000, 120_000, 300_000, 600_000, 1_800_000], protocol);
     default:
       return [];
   }
 };
+
+export type DeviceSettingsCapabilities = {
+  protocol: DeviceSettingsProtocol;
+  supportedFields: readonly DeviceSettingsField[];
+  languageOptions: ReadonlyArray<Record<string, string>>;
+  autoLockDelayOptions: readonly DeviceSettingsDurationOption[];
+  autoShutdownDelayOptions: readonly DeviceSettingsDurationOption[];
+  ranges: {
+    brightness?: { min: number; max: number };
+  };
+  safetyCheckOptions: ReadonlyArray<DeviceSettingsValueOption<Enum_SafetyCheckLevel>>;
+  onDeviceConfirmationFields: readonly DeviceSettingsField[];
+};
+
+export const getDeviceSettingsCapabilities = (
+  deviceType: IDeviceType,
+  protocol: DeviceSettingsProtocol
+): DeviceSettingsCapabilities => ({
+  protocol,
+  supportedFields:
+    protocol === 'V2'
+      ? [...DEVICE_SETTINGS_SHARED_FIELDS, ...DEVICE_SETTINGS_V2_ONLY_FIELDS]
+      : [...DEVICE_SETTINGS_SHARED_FIELDS, ...DEVICE_SETTINGS_V1_ONLY_FIELDS],
+  languageOptions: getLanguageConfig(deviceType),
+  autoLockDelayOptions: getAutoLockOptions(deviceType, protocol),
+  autoShutdownDelayOptions: getAutoShutDownOptions(deviceType, protocol),
+  ranges: protocol === 'V2' ? { brightness: { min: 10, max: 100 } } : {},
+  safetyCheckOptions:
+    protocol === 'V1'
+      ? [
+          { label: 'Strict', value: Enum_SafetyCheckLevel.Strict },
+          { label: 'Prompt Always', value: Enum_SafetyCheckLevel.PromptAlways },
+          { label: 'Prompt Temporarily', value: Enum_SafetyCheckLevel.PromptTemporarily },
+        ]
+      : [],
+  onDeviceConfirmationFields: protocol === 'V2' ? ['usePassphrase', 'airgapMode'] : [],
+});

package/src/utils/deviceVersionUtils.ts

@@ -1,61 +1,42 @@
 import semver from 'semver';
 
-import type { Features, IVersionArray } from '../types';
+import {
+  resolveDeviceBleFirmwareVersion,
+  resolveDeviceBoardVersion,
+  resolveDeviceBootloaderVersion,
+  resolveDeviceFirmwareVersion,
+} from './deviceFeaturesCompat';
 
-/**
- * Get Connected Device version by features
- */
-export const getDeviceFirmwareVersion = (features: Features | undefined): IVersionArray => {
-  if (!features) return [0, 0, 0];
+import type { IVersionArray } from '../types';
+import type { DeviceFeaturesInput } from './deviceFeaturesCompat';
 
-  if (features.firmwareVersion && semver.valid(features.firmwareVersion)) {
-    return features.firmwareVersion.split('.').map(Number) as IVersionArray;
-  }
+const EMPTY_VERSION: IVersionArray = [0, 0, 0];
 
-  return [0, 0, 0];
+export const parseDeviceVersion = (version?: string | null): IVersionArray => {
+  const parsed = version ? semver.parse(version) : null;
+  return parsed ? [parsed.major, parsed.minor, parsed.patch] : [...EMPTY_VERSION];
 };
 
 /**
- * Get Connected Device bluetooth firmware version by features
+ * Get Connected Device version by features
  */
-export const getDeviceBLEFirmwareVersion = (features: Features): IVersionArray => {
-  const bleVer = features?.bleVersion;
-
-  if (!bleVer) {
-    return [0, 0, 0];
-  }
-
-  if (!semver.valid(bleVer)) {
-    return [0, 0, 0];
-  }
-
-  if (bleVer) {
-    return bleVer.split('.').map(Number) as IVersionArray;
-  }
-  return [0, 0, 0];
-};
+export const getDeviceFirmwareVersion = (features?: DeviceFeaturesInput): IVersionArray =>
+  parseDeviceVersion(resolveDeviceFirmwareVersion(features));
 
 /**
  * Get Connected Device bootloader version by features
  */
-export const getDeviceBootloaderVersion = (features: Features | undefined): IVersionArray => {
-  if (!features) return [0, 0, 0];
-
-  // classic1s 3.5.0 pro 4.6.0
-  if (features.bootloaderVersion && semver.valid(features.bootloaderVersion)) {
-    return features.bootloaderVersion.split('.').map(Number) as IVersionArray;
-  }
-
-  return [0, 0, 0];
-};
+export const getDeviceBootloaderVersion = (features?: DeviceFeaturesInput): IVersionArray =>
+  parseDeviceVersion(resolveDeviceBootloaderVersion(features));
 
 /**
- * Get Connected Device boardloader version by features
+ * Get Connected Device boardloader/romloader version by features
  */
-export const getDeviceBoardloaderVersion = (features: Features): IVersionArray => {
-  if (features?.boardVersion && semver.valid(features.boardVersion)) {
-    return features.boardVersion.split('.').map(Number) as IVersionArray;
-  }
+export const getDeviceBoardloaderVersion = (features?: DeviceFeaturesInput): IVersionArray =>
+  parseDeviceVersion(resolveDeviceBoardVersion(features));
 
-  return [0, 0, 0];
-};
+/**
+ * Get Connected Device bluetooth firmware version by features
+ */
+export const getDeviceBLEFirmwareVersion = (features?: DeviceFeaturesInput): IVersionArray =>
+  parseDeviceVersion(resolveDeviceBleFirmwareVersion(features));