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

package/src/utils/deviceFeaturesCompat.ts

@@ -0,0 +1,191 @@
+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 resolveDeviceBootloaderMode = (features?: DeviceFeaturesInput): boolean => {
+  if (!features) return false;
+  const compatible = asCompatibleFeatures(features);
+  return (compatible.bootloaderMode ?? compatible.bootloader_mode) === true;
+};
+
+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 'NEO':
+      return EDeviceType.Neo;
+    case 'PURE':
+      return EDeviceType.ClassicPure;
+    default:
+      break;
+  }
+
+  if (compatible.model?.toString().toLowerCase() === EDeviceType.Pro2) {
+    return EDeviceType.Pro2;
+  }
+  if (compatible.model?.toString().toLowerCase() === EDeviceType.Neo) {
+    return EDeviceType.Neo;
+  }
+
+  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);
+  const bootloaderMode = compatible.bootloaderMode ?? compatible.bootloader_mode;
+  return firstMeaningfulVersion(
+    compatible.firmwareVersion,
+    compatible.onekey_firmware_version,
+    compatible.onekey_version,
+    bootloaderMode
+      ? null
+      : 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

@@ -13,14 +13,11 @@ 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 { Features, IDeviceType, SupportFeatureType } from '../types';
 
-// 生成的 GetPassphraseState 已包含 _only_main_pin / allow_create_attach_pin，
-// 不再需要手动扩展字段。
-type GetPassphraseStateMessage = GetPassphraseState;
-
 export const getSupportProtocolV1MessageSchema = (
   features: Features | undefined
 ): { messages: JSON; protocolV1MessageSchema: ProtocolV1MessageSchema } => {
@@ -33,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] &&
@@ -58,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 };
   }
 
@@ -77,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 };
   }
@@ -92,13 +107,37 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   options?: {
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
-    allowCreateAttachPin?: boolean;
+    initSession?: boolean;
+    deriveCardano?: boolean;
+    rejectAttachPinForMainWallet?: boolean;
   }
 ) => {
+  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,
+      deriveCardano: options?.deriveCardano,
+      rejectAttachPinForMainWallet: options?.rejectAttachPinForMainWallet,
+    });
+  }
+
   const { features } = device;
   const locked = features?.unlocked === false;
   const deviceType = device.getCurrentDeviceType();
 
+  if (options?.initSession) {
+    device.clearInternalState();
+  }
+
   const { passphraseState, newSession, unlockedAttachPin } = await getPassphraseState(device, {
     ...options,
   });
@@ -106,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
@@ -123,19 +163,26 @@ 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,
-    device.features?.sessionId
+    options?.initSession ? null : existingSessionId
   );
 
-  return { passphraseState, newSession, unlockedAttachPin };
+  return {
+    passphraseState,
+    newSession,
+    unlockedAttachPin: unlockedAttachPin ?? device.features?.unlockedAttachPin,
+  };
 };
 
-// 仅适用于 Protocol V1 的 Pro：Pro2 走独立版本线，不能套用 4.15.0 门槛
-// （Pro2 在 getPassphraseState 中通过 isProtocolV2 直接判定支持）。
+// 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');
 
@@ -144,7 +191,9 @@ export const getPassphraseState = async (
   options?: {
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
-    allowCreateAttachPin?: boolean;
+    initSession?: boolean;
+    deriveCardano?: boolean;
+    rejectAttachPinForMainWallet?: boolean;
   }
 ): Promise<{
   passphraseState: string | undefined;
@@ -153,31 +202,34 @@ 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 };
 
   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,
+      deriveCardano: options?.deriveCardano,
+      rejectAttachPinForMainWallet: options?.rejectAttachPinForMainWallet,
+    });
+  }
+
   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 ||
-    supportProSeriesAttachPinPassphrase(deviceType, firmwareVersion);
+    supportAttachPinCapability || supportProSeriesAttachPinPassphrase(deviceType, firmwareVersion);
 
   if (supportGetPassphraseState) {
-    const payload: GetPassphraseStateMessage = 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',
@@ -276,6 +328,9 @@ export const getFirmwareUpdateField = ({
   if (deviceType === EDeviceType.Pro) {
     return latestFirmwareField;
   }
+  if (deviceType === EDeviceType.Pro2 || deviceType === EDeviceType.Neo) {
+    return 'firmware-v1';
+  }
   return 'firmware';
 };
 /**
@@ -319,6 +374,10 @@ export const getFirmwareUpdateFieldArray = (
     return ['firmware-v8'];
   }
 
+  if (deviceType === 'pro2' || deviceType === 'neo') {
+    return ['firmware-v1'];
+  }
+
   return ['firmware'];
 };
 

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