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

package/src/utils/deviceFeaturesUtils.ts

@@ -1,47 +1,32 @@
 import semver from 'semver';
 import { isNaN } from 'lodash';
 import { EDeviceType, type EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { Enum_Capability, type GetPassphraseState } from '@onekeyfe/hd-transport';
+import { Enum_Capability } from '@onekeyfe/hd-transport';
 
 import { toHardened } from '../api/helpers/pathUtils';
 import { DeviceModelToTypes, DeviceTypeToModels } from '../types';
-import DataManager, {
-  type IFirmwareField,
-  type ProtocolV1MessageSchema,
-} from '../data-manager/DataManager';
+import DataManager, { type IFirmwareField, type MessageVersion } 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 { Features, IDeviceType, SupportFeatureType } from '../types';
+import type { DeviceCommands } from '../device/DeviceCommands';
+import type { Features, SupportFeatureType } from '../types';
 
-export const getSupportProtocolV1MessageSchema = (
+export const getSupportMessageVersion = (
   features: Features | undefined
-): { messages: JSON; protocolV1MessageSchema: ProtocolV1MessageSchema } => {
+): { messages: JSON; messageVersion: MessageVersion } => {
   if (!features)
     return {
-      messages: DataManager.messages.v1CurrentSchema,
-      protocolV1MessageSchema: 'v1CurrentSchema',
+      messages: DataManager.messages.latest,
+      messageVersion: 'latest',
     };
 
   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] &&
@@ -52,30 +37,26 @@ export const getSupportProtocolV1MessageSchema = (
   const sortedDeviceVersionConfigs =
     deviceVersionConfigs?.sort((a, b) => semver.compare(b.minVersion, a.minVersion)) ?? [];
 
-  for (const { minVersion, protocolV1MessageSchema } of sortedDeviceVersionConfigs) {
+  for (const { minVersion, messageVersion } of sortedDeviceVersionConfigs) {
     if (semver.gte(currentDeviceVersion, minVersion)) {
       return {
-        messages: DataManager.messages[protocolV1MessageSchema],
-        protocolV1MessageSchema,
+        messages: DataManager.messages[messageVersion],
+        messageVersion,
       };
     }
   }
 
   return {
-    messages: DataManager.messages.v1CurrentSchema,
-    protocolV1MessageSchema: 'v1CurrentSchema',
+    messages: DataManager.messages.latest,
+    messageVersion: 'latest',
   };
 };
 
-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 ||
-    deviceType === EDeviceType.Pro2
-  ) {
+  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
     return { support: false };
   }
 
@@ -87,11 +68,7 @@ export const supportNewPassphrase = (features?: Features): SupportFeatureType =>
   if (!features) return { support: false };
 
   const deviceType = getDeviceType(features);
-  if (
-    deviceType === EDeviceType.Touch ||
-    deviceType === EDeviceType.Pro ||
-    deviceType === EDeviceType.Pro2
-  ) {
+  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
     return { support: true };
   }
 
@@ -105,46 +82,25 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   options?: {
     expectPassphraseState?: string;
     onlyMainPin?: boolean;
-    initSession?: 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,
-    });
-  }
-
-  const { features } = device;
+  const { features, commands } = device;
   const locked = features?.unlocked === false;
-  const deviceType = device.getCurrentDeviceType();
-
-  if (options?.initSession) {
-    device.clearInternalState();
-  }
 
-  const { passphraseState, newSession, unlockedAttachPin } = await getPassphraseState(device, {
-    ...options,
-  });
+  const { passphraseState, newSession, unlockedAttachPin } = await getPassphraseState(
+    features,
+    commands,
+    {
+      ...options,
+    }
+  );
 
   const isModeT =
-    deviceType === EDeviceType.Touch ||
-    deviceType === EDeviceType.Pro ||
-    deviceType === EDeviceType.Pro2;
+    getDeviceType(features) === EDeviceType.Touch || getDeviceType(features) === EDeviceType.Pro;
 
   // 如果可以获取到 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 && device.getCurrentPassphraseProtection() !== true;
+  const needRefreshWithPassphrase = passphraseState && features?.passphrase_protection !== true;
   // 如果 Touch/Pro 在之前是锁定状态，刷新设备状态
   // if Touch/Pro was locked before, refresh the device state
   const needRefreshWithLocked = isModeT && locked;
@@ -155,72 +111,49 @@ export const getPassphraseStateWithRefreshDeviceInfo = async (
   }
 
   // Attach to pin try to fix internal state
-  const deviceId = device.getCurrentDeviceId();
-  device.updateInternalState(
-    device.getCurrentPassphraseProtection() ?? false,
-    passphraseState,
-    deviceId,
-    newSession,
-    options?.initSession ? null : device.features?.sessionId
-  );
+  if (features?.device_id) {
+    device.updateInternalState(
+      device.features?.passphrase_protection ?? false,
+      passphraseState,
+      device.features?.device_id ?? '',
+      newSession,
+      device.features?.session_id
+    );
+  }
 
-  return {
-    passphraseState,
-    newSession,
-    unlockedAttachPin: unlockedAttachPin ?? device.features?.unlockedAttachPin,
-  };
+  return { passphraseState, newSession, 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 (
-  device: Device,
+  features: Features | undefined,
+  commands: DeviceCommands,
   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 = 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 firmwareVersion = getDeviceFirmwareVersion(features);
+  const deviceType = getDeviceType(features);
 
   const supportAttachPinCapability = existCapability(
     features,
     Enum_Capability.Capability_AttachToPin
   );
   const supportGetPassphraseState =
-    supportAttachPinCapability || supportProSeriesAttachPinPassphrase(deviceType, firmwareVersion);
+    supportAttachPinCapability ||
+    (deviceType === EDeviceType.Pro && semver.gte(firmwareVersion.join('.'), '4.15.0'));
 
   if (supportGetPassphraseState) {
-    const payload: GetPassphraseState = {
+    const { message, type } = await commands.typedCall('GetPassphraseState', 'PassphraseState', {
       passphrase_state: options?.onlyMainPin ? undefined : options?.expectPassphraseState,
-    };
-
-    const { message, type } = await commands.typedCall(
-      'GetPassphraseState',
-      'PassphraseState',
-      payload
-    );
+    });
 
     // @ts-expect-error
     if (type === 'CallMethodError') {
@@ -253,8 +186,40 @@ export const getPassphraseState = async (
   };
 };
 
-// supportBatchPublicKey 已迁移为 device-aware 版本：
-// 见 api/helpers/batchGetPublickeys.ts 的 supportBatchPublicKeyByDevice
+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');
+};
 
 export const supportModifyHomescreen = (features?: Features): SupportFeatureType => {
   if (!features) return { support: false };
@@ -313,9 +278,6 @@ export const getFirmwareUpdateField = ({
   if (deviceType === EDeviceType.Pro) {
     return latestFirmwareField;
   }
-  if (deviceType === EDeviceType.Pro2) {
-    return 'firmware-v1';
-  }
   return 'firmware';
 };
 /**
@@ -359,10 +321,6 @@ export const getFirmwareUpdateFieldArray = (
     return ['firmware-v8'];
   }
 
-  if (deviceType === 'pro2') {
-    return ['firmware-v1'];
-  }
-
   return ['firmware'];
 };
 
@@ -382,8 +340,12 @@ 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.firmwareVersion && !semver.valid(tempFeatures.firmwareVersion)) {
-    tempFeatures.firmwareVersion = fixVersion(tempFeatures.firmwareVersion);
+  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);
   }
 
   return tempFeatures;

package/src/utils/deviceInfoUtils.ts

@@ -1,22 +1,65 @@
 import { isEmpty } from 'lodash';
-import { EDeviceType } from '@onekeyfe/hd-shared';
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { Enum_Capability } from '@onekeyfe/hd-transport';
 
 import { DeviceModelToTypes } from '../types';
-import {
-  resolveDeviceBleName,
-  resolveDeviceFirmwareType,
-  resolveDeviceSerialNo,
-  resolveDeviceType,
-} from './deviceFeaturesCompat';
+import { existCapability } from './capabilitieUtils';
 
-import type { IDeviceModel, IDeviceType, IVersionRange } from '../types';
-import type { DeviceFeaturesInput } from './deviceFeaturesCompat';
+import type { Features, IDeviceModel, IDeviceType, IVersionRange } from '../types';
 
 /**
  * get device type by features
  */
-export const getDeviceType = (features?: DeviceFeaturesInput): IDeviceType =>
-  resolveDeviceType(features);
+export const getDeviceType = (features?: Features): IDeviceType => {
+  if (!features || typeof features !== 'object') {
+    return EDeviceType.Unknown;
+  }
+
+  // classic1s 3.5.0 pro 4.6.0
+  switch (features.onekey_device_type) {
+    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 'PURE':
+      return EDeviceType.ClassicPure;
+    default:
+      // future And old device onekey_device_type is empty
+      if (!isEmpty(features.onekey_serial_no)) {
+        return EDeviceType.Unknown;
+      }
+    // old device type
+  }
+
+  // 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.bootloader_mode === 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;
+
+  // unknown device
+  return EDeviceType.Unknown;
+};
 
 /**
  * get device type by ble name
@@ -25,14 +68,13 @@ export const getDeviceType = (features?: DeviceFeaturesInput): IDeviceType =>
 export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
   if (!name) return EDeviceType.Unknown;
 
-  if (/^BixinKey/i.test(name)) return EDeviceType.Classic;
-  if (/^K/i.test(name)) return EDeviceType.Classic;
+  if (name.startsWith('BixinKey')) return EDeviceType.Classic;
+  if (name.startsWith('K')) return EDeviceType.Classic;
 
-  if (/^T/i.test(name)) return EDeviceType.Touch;
-  if (/^Touch/i.test(name)) return EDeviceType.Touch;
+  if (name.startsWith('T')) return EDeviceType.Touch;
+  if (name.startsWith('Touch')) return EDeviceType.Touch;
 
-  if (/\bPro\s*2\b/i.test(name) || /^Pro2/i.test(name)) return EDeviceType.Pro2;
-  if (/\bPro\b/i.test(name) || /^Pro/i.test(name)) return EDeviceType.Pro;
+  if (name.startsWith('Pro')) return EDeviceType.Pro;
 
   return EDeviceType.Unknown;
 };
@@ -41,30 +83,29 @@ export const getDeviceTypeByBleName = (name?: string): IDeviceType => {
  * Get Connected Device ble name by features
  * @returns
  */
-export const getDeviceBleName = (features?: DeviceFeaturesInput): string | null =>
-  resolveDeviceBleName(features);
-
-/**
- * Get Connected Device serial number by features
- */
-export const getDeviceSerialNo = (features?: DeviceFeaturesInput): string =>
-  resolveDeviceSerialNo(features);
+export const getDeviceBleName = (features?: Features): string | null => {
+  if (features == null) return null;
+  return features.onekey_ble_name || features.ble_name || null;
+};
 
 /**
- * @deprecated Use getDeviceSerialNo instead.
+ * Get Connected Device UUID by features
  */
-export const getDeviceUUID = getDeviceSerialNo;
+export const getDeviceUUID = (features: Features) => {
+  const serialNo = features.onekey_serial_no || features.onekey_serial || features.serial_no;
+  return serialNo ?? '';
+};
 
 /**
  * Get Connected Device label by features
  */
-export const getDeviceLabel = (features?: DeviceFeaturesInput) => {
+export const getDeviceLabel = (features?: Features) => {
   if (!features) return null;
 
   const deviceType = getDeviceType(features);
   if (deviceType == null) return null;
 
-  if ('label' in features && typeof features.label === 'string' && !isEmpty(features.label)) {
+  if (typeof features.label === 'string' && !isEmpty(features.label)) {
     return features.label;
   }
 
@@ -83,12 +124,12 @@ export const getDeviceLabel = (features?: DeviceFeaturesInput) => {
  * Type has a higher priority than Model
  */
 export const getMethodVersionRange = (
-  features: DeviceFeaturesInput | undefined,
+  features: Features | undefined,
   getVersionRange: (deviceModel: IDeviceType | IDeviceModel) => IVersionRange | undefined
 ): IVersionRange | undefined => {
   const deviceType = getDeviceType(features);
+  let versionRange: IVersionRange | undefined = getVersionRange(deviceType);
 
-  const versionRange = getVersionRange(deviceType);
   if (versionRange) {
     return versionRange;
   }
@@ -101,18 +142,26 @@ export const getMethodVersionRange = (
   ];
   for (const model of modelFallbacks) {
     if (DeviceModelToTypes[model].includes(deviceType)) {
-      const versionRange = getVersionRange(model);
+      versionRange = getVersionRange(model);
       if (versionRange) {
         return versionRange;
       }
     }
   }
 
-  return undefined;
+  return versionRange;
 };
 
-export const isMethodVersionRangeUnsupported = (versionRange?: IVersionRange): boolean =>
-  versionRange?.unsupported === true;
-
-export const getFirmwareType = (features?: DeviceFeaturesInput) =>
-  resolveDeviceFirmwareType(features);
+export const getFirmwareType = (features: Features | undefined) => {
+  if (!features) {
+    return EFirmwareType.Universal;
+  }
+  if (features.fw_vendor === 'OneKey Bitcoin-only') {
+    return EFirmwareType.BitcoinOnly;
+  }
+  // old firmware
+  return features?.capabilities?.length > 0 &&
+    !existCapability(features, Enum_Capability.Capability_Bitcoin_like)
+    ? EFirmwareType.BitcoinOnly
+    : EFirmwareType.Universal;
+};

package/src/utils/deviceSettings.ts

@@ -19,33 +19,6 @@ 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 PRO2_LANGUAGE_OPTIONS = [
-  ...Object.entries(LANGUAGE_LABELS).map(([code, label]) => ({ code, label })),
-  { code: 'zh-Hant-TW', label: '繁體中文（台灣）' },
-  { 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[] = [];
 
@@ -63,8 +36,6 @@ export const getLanguageConfig = (deviceType: IDeviceType): Record<string, strin
     case EDeviceType.Pro:
       keys = Object.keys(LANGUAGE_LABELS) as LanguageKey[];
       break;
-    case EDeviceType.Pro2:
-      return PRO2_LANGUAGE_OPTIONS.map(option => ({ ...option }));
     default:
       keys = [];
       break;
@@ -104,16 +75,6 @@ export const getAutoLockOptions = (_deviceType: IDeviceType): DurationParts[] =>
         { seconds: 0, minute: 30, hour: 0, day: 0 },
         { seconds: 0, minute: 0, hour: 0, day: 0 },
       ];
-    case EDeviceType.Pro2:
-      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 },
-      ];
     default:
       return [];
   }
@@ -142,15 +103,6 @@ export const getAutoShutDownOptions = (_deviceType: IDeviceType): DurationParts[
         { seconds: 0, minute: 10, hour: 0, day: 0 },
         { seconds: 0, minute: 0, hour: 0, day: 0 },
       ];
-    case EDeviceType.Pro2:
-      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: 30, hour: 0, day: 0 },
-        { seconds: 0, minute: 0, hour: 0, day: 0 },
-      ];
     default:
       return [];
   }