@onekeyfe/hd-core 1.1.27-alpha.32 → 1.1.27-alpha.34

package/src/api/scdo/ScdoGetAddress.ts

@@ -4,7 +4,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 
 import type { ScdoGetAddress as HardwareScdoGetAddress } from '@onekeyfe/hd-transport';
-import type { ScdoAddress, ScdoGetAddressParams } from '../../types';
+import type { DeviceFirmwareRange, ScdoAddress, ScdoGetAddressParams } from '../../types';
 
 export default class ScdoGetAddress extends BaseMethod<HardwareScdoGetAddress[]> {
   hasBundle = false;
@@ -38,8 +38,12 @@ export default class ScdoGetAddress extends BaseMethod<HardwareScdoGetAddress[]>
     });
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/scdo/ScdoSignMessage.ts

@@ -5,6 +5,7 @@ import { validateParams } from '../helpers/paramsValidator';
 import { stripHexPrefix } from '../helpers/hexUtils';
 
 import type { ScdoSignMessage as HardwareScdoSignMessage } from '@onekeyfe/hd-transport';
+import type { DeviceFirmwareRange } from '../../types';
 
 export default class ScdoSignMessage extends BaseMethod<HardwareScdoSignMessage> {
   init() {
@@ -27,8 +28,12 @@ export default class ScdoSignMessage extends BaseMethod<HardwareScdoSignMessage>
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/scdo/ScdoSignTransaction.ts

@@ -6,7 +6,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex, stripHexStartZeroes } from '../helpers/hexUtils';
 
-import type { ScdoSignTransactionParams } from '../../types';
+import type { DeviceFirmwareRange, ScdoSignTransactionParams } from '../../types';
 import type {
   ScdoSignTx as HardwareScdoSignTx,
   ScdoSignedTx,
@@ -50,8 +50,12 @@ export default class ScdoSignTransaction extends BaseMethod<HardwareScdoSignTx>
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_touch: {
         min: '4.10.0',
       },

package/src/api/stellar/StellarGetAddress.ts

@@ -4,7 +4,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 
 import type { StellarGetAddress as HardwareStellarGetAddress } from '@onekeyfe/hd-transport';
-import type { StellarAddress, StellarGetAddressParams } from '../../types';
+import type { DeviceFirmwareRange, StellarAddress, StellarGetAddressParams } from '../../types';
 
 export default class StellarGetAddress extends BaseMethod<HardwareStellarGetAddress[]> {
   hasBundle = false;
@@ -38,6 +38,15 @@ export default class StellarGetAddress extends BaseMethod<HardwareStellarGetAddr
     });
   }
 
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
+    };
+  }
+
   async run() {
     const responses: StellarAddress[] = [];
 

package/src/api/stellar/StellarSignTransaction.ts

@@ -10,7 +10,11 @@ import type {
   StellarSignTx as HardwareStellarSignTx,
   StellarSignedTx,
 } from '@onekeyfe/hd-transport';
-import type { StellarOperation, StellarSignTransactionParams } from '../../types';
+import type {
+  DeviceFirmwareRange,
+  StellarOperation,
+  StellarSignTransactionParams,
+} from '../../types';
 
 // Firmware accepts up to 1024 bytes per chunk; 1 byte = 2 hex chars
 const SOROBAN_CHUNK_BYTES = 1024;
@@ -28,6 +32,15 @@ export default class StellarSignTransaction extends BaseMethod<HardwareStellarSi
     extSent: number;
   };
 
+  getVersionRange(): DeviceFirmwareRange {
+    return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
+    };
+  }
+
   parseOperation = (op: StellarOperation) => {
     switch (op.type) {
       case 'createAccount':

package/src/api/sui/SuiSignTransaction.ts

@@ -1,5 +1,6 @@
 import semver from 'semver';
 import { bytesToHex } from '@noble/hashes/utils';
+import { EDeviceType } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
@@ -9,12 +10,8 @@ import { formatAnyHex } from '../helpers/hexUtils';
 import { getDeviceFirmwareVersion, getDeviceType } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
 
-import type {
-  SuiSignTx as HardwareSuiSignTx,
-  SuiSignedTx,
-  TypedCall,
-} from '@onekeyfe/hd-transport';
-import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type { SuiSignTx as HardwareSuiSignTx, SuiSignedTx } from '@onekeyfe/hd-transport';
+import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
 
 type SuiSignTx = Omit<HardwareSuiSignTx, 'data_initial_chunk' | 'data_length'> & HardwareSuiSignTx;
 
@@ -52,6 +49,13 @@ export default class SuiSignTransaction extends BaseMethod<SuiSignTx> {
   }
 
   supportChunkTransfer() {
+    if (
+      this.device.originalDescriptor?.protocolType === 'V2' ||
+      getDeviceType(this.device.features) === EDeviceType.Pro2
+    ) {
+      return true;
+    }
+
     const deviceType = getDeviceType(this.device.features);
     const deviceFirmwareVersion = getDeviceFirmwareVersion(this.device.features).join('.');
 
@@ -84,7 +88,7 @@ export default class SuiSignTransaction extends BaseMethod<SuiSignTx> {
 
     if (!data_length) {
       // sign Done
-      return res.message;
+      return res.message as SuiSignedTx;
     }
 
     const payload = data.subarray(offset, offset + data_length);
@@ -103,7 +107,7 @@ export default class SuiSignTransaction extends BaseMethod<SuiSignTx> {
   async run() {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
     let offset = 0;
-    let data: Buffer;
+    let data = Buffer.alloc(0);
 
     if (this.supportChunkTransfer()) {
       offset = this.chunkByteSize;
@@ -120,7 +124,6 @@ export default class SuiSignTransaction extends BaseMethod<SuiSignTx> {
       ...this.params,
     });
 
-    // @ts-expect-error
     return this.processTxRequest(typedCall, res, data, offset);
   }
 }

package/src/core/index.ts

@@ -24,8 +24,8 @@ import {
   getFirmwareType,
   getLogger,
   getMethodVersionRange,
+  isMethodVersionRangeUnsupported,
   setLoggerPostMessage,
-  shouldSkipMethodSupportCheck,
   wait,
 } from '../utils';
 import {
@@ -346,10 +346,6 @@ const onCallDevice = async (
         device.features,
         type => method.getVersionRange()[type]
       );
-      const skipMethodSupportCheck = shouldSkipMethodSupportCheck(
-        device.features,
-        device.originalDescriptor?.protocolType
-      );
 
       if (device.features) {
         await DataManager.checkAndReloadData();
@@ -400,7 +396,11 @@ const onCallDevice = async (
           );
         }
 
-        if (!skipMethodSupportCheck && versionRange) {
+        if (isMethodVersionRangeUnsupported(versionRange)) {
+          throw createDeviceNotSupportMethodError(method.name, getFirmwareType(device.features));
+        }
+
+        if (versionRange) {
           if (
             semver.valid(versionRange.min) &&
             semver.lt(currentFirmwareVersion, versionRange.min)
@@ -432,7 +432,7 @@ const onCallDevice = async (
               createDeprecatedHardwareError(currentFirmwareVersion, versionRange.max, method.name)
             );
           }
-        } else if (!skipMethodSupportCheck && method.strictCheckDeviceSupport) {
+        } else if (method.strictCheckDeviceSupport) {
           throw createDeviceNotSupportMethodError(method.name, getFirmwareType(device.features));
         }
       }

package/src/data/messages/messages-protocol-v2.json

@@ -501,6 +501,7 @@
         "MessageType_FilesystemDirMake": 60809,
         "MessageType_FilesystemDirRemove": 60810,
         "MessageType_FilesystemFormat": 60811,
+        "MessageType_FilesystemDiskControl": 60812,
         "MessageType_DeviceFirmwareUpdate": 61000,
         "MessageType_DeviceFirmwareInstallProgress": 61001,
         "MessageType_DeviceGetFirmwareUpdateStatus": 61002,
@@ -12403,6 +12404,15 @@
     "FilesystemFormat": {
       "fields": {}
     },
+    "FilesystemDiskControl": {
+      "fields": {
+        "enable": {
+          "rule": "required",
+          "type": "uint32",
+          "id": 1
+        }
+      }
+    },
     "DeviceGetOnboardingStatus": {
       "fields": {}
     },

package/src/inject.ts

@@ -109,6 +109,7 @@ export const createCoreApi = (
    * 获取设备信息
    */
   getFeatures: (connectId, params) => call({ ...params, connectId, method: 'getFeatures' }),
+  getDeviceInfo: (connectId, params) => call({ ...params, connectId, method: 'getDeviceInfo' }),
   getOnekeyFeatures: (connectId, params) =>
     call({ ...params, connectId, method: 'getOnekeyFeatures' }),
 
@@ -187,6 +188,8 @@ export const createCoreApi = (
   filesystemPathInfoQuery: (connectId, params) =>
     call({ ...params, connectId, method: 'filesystemPathInfoQuery' }),
   filesystemFormat: connectId => call({ connectId, method: 'filesystemFormat' }),
+  filesystemDiskControl: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemDiskControl' }),
   deviceRecovery: (connectId, params) => call({ ...params, connectId, method: 'deviceRecovery' }),
   deviceReset: (connectId, params) => call({ ...params, connectId, method: 'deviceReset' }),
   deviceSettings: (connectId, params) => call({ ...params, connectId, method: 'deviceSettings' }),

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

@@ -53,7 +53,7 @@ type ProtocolV2DeviceInfo = {
   };
 };
 
-const PROTOCOL_V2_DEVICE_INFO_REQUEST = {
+export const PROTOCOL_V2_DEVICE_INFO_REQUEST = {
   targets: {
     hw: true,
     fw: true,
@@ -161,6 +161,7 @@ function createBaseFeatures(descriptor: DeviceDescriptor): Features {
     auto_lock_delay_ms: null,
     display_rotation: null,
     experimental_features: null,
+    protocol_version: null,
     onekey_device_type: EDeviceType.Pro2,
     onekey_serial_no: descriptorId,
     serial_no: descriptorId,
@@ -190,6 +191,7 @@ export function normalizeProtocolV2Features(
     device_id: serialNo,
     serial_no: serialNo,
     onekey_serial_no: serialNo,
+    protocol_version: deviceInfo.protocol_version ?? features.protocol_version,
     label: deviceInfo.status?.label ?? features.label,
     language: deviceInfo.status?.language ?? features.language,
     initialized: deviceInfo.status?.init_states ?? features.initialized,
@@ -207,6 +209,7 @@ export function normalizeProtocolV2Features(
     onekey_boot_build_id: getImageBuildId(deviceInfo.fw?.boot),
     onekey_boot_hash: getImageHash(deviceInfo.fw?.boot),
     onekey_board_version: getImageVersion(deviceInfo.fw?.board),
+    onekey_board_build_id: getImageBuildId(deviceInfo.fw?.board),
     onekey_board_hash: getImageHash(deviceInfo.fw?.board),
     onekey_ble_version: getImageVersion(deviceInfo.bt?.app),
     ble_ver: getImageVersion(deviceInfo.bt?.app),
@@ -215,12 +218,30 @@ export function normalizeProtocolV2Features(
     onekey_se01_version: getImageVersion(deviceInfo.se1?.app),
     onekey_se01_hash: getImageHash(deviceInfo.se1?.app),
     onekey_se01_build_id: getImageBuildId(deviceInfo.se1?.app),
+    onekey_se01_boot_version: getImageVersion(deviceInfo.se1?.boot),
+    onekey_se01_boot_hash: getImageHash(deviceInfo.se1?.boot),
+    onekey_se01_boot_build_id: getImageBuildId(deviceInfo.se1?.boot),
     onekey_se01_state: getSeState(deviceInfo.se1),
     onekey_se02_version: getImageVersion(deviceInfo.se2?.app),
+    onekey_se02_hash: getImageHash(deviceInfo.se2?.app),
+    onekey_se02_build_id: getImageBuildId(deviceInfo.se2?.app),
+    onekey_se02_boot_version: getImageVersion(deviceInfo.se2?.boot),
+    onekey_se02_boot_hash: getImageHash(deviceInfo.se2?.boot),
+    onekey_se02_boot_build_id: getImageBuildId(deviceInfo.se2?.boot),
     onekey_se02_state: getSeState(deviceInfo.se2),
     onekey_se03_version: getImageVersion(deviceInfo.se3?.app),
+    onekey_se03_hash: getImageHash(deviceInfo.se3?.app),
+    onekey_se03_build_id: getImageBuildId(deviceInfo.se3?.app),
+    onekey_se03_boot_version: getImageVersion(deviceInfo.se3?.boot),
+    onekey_se03_boot_hash: getImageHash(deviceInfo.se3?.boot),
+    onekey_se03_boot_build_id: getImageBuildId(deviceInfo.se3?.boot),
     onekey_se03_state: getSeState(deviceInfo.se3),
     onekey_se04_version: getImageVersion(deviceInfo.se4?.app),
+    onekey_se04_hash: getImageHash(deviceInfo.se4?.app),
+    onekey_se04_build_id: getImageBuildId(deviceInfo.se4?.app),
+    onekey_se04_boot_version: getImageVersion(deviceInfo.se4?.boot),
+    onekey_se04_boot_hash: getImageHash(deviceInfo.se4?.boot),
+    onekey_se04_boot_build_id: getImageBuildId(deviceInfo.se4?.boot),
     onekey_se04_state: getSeState(deviceInfo.se4),
   };
 }
@@ -228,12 +249,10 @@ export function normalizeProtocolV2Features(
 export async function getProtocolV2Features({
   commands,
   descriptor,
-  onDeviceInfoError,
   timeoutMs,
 }: {
   commands: DeviceCommands;
   descriptor: DeviceDescriptor;
-  onDeviceInfoError?: (error: unknown) => void;
   timeoutMs?: number;
 }) {
   const callOptions = timeoutMs ? { timeoutMs } : undefined;
@@ -243,22 +262,17 @@ export async function getProtocolV2Features({
     await commands.typedCall('Ping', 'Success', { message: 'init' });
   }
 
-  try {
-    const { message } = callOptions
-      ? await commands.typedCall(
-          'DeviceGetDeviceInfo',
-          'DeviceInfo',
-          PROTOCOL_V2_DEVICE_INFO_REQUEST,
-          callOptions
-        )
-      : await commands.typedCall(
-          'DeviceGetDeviceInfo',
-          'DeviceInfo',
-          PROTOCOL_V2_DEVICE_INFO_REQUEST
-        );
-    return normalizeProtocolV2Features(descriptor, message as unknown as ProtocolV2DeviceInfo);
-  } catch (error) {
-    onDeviceInfoError?.(error);
-    return normalizeProtocolV2Features(descriptor);
-  }
+  const { message } = callOptions
+    ? await commands.typedCall(
+        'DeviceGetDeviceInfo',
+        'DeviceInfo',
+        PROTOCOL_V2_DEVICE_INFO_REQUEST,
+        callOptions
+      )
+    : await commands.typedCall(
+        'DeviceGetDeviceInfo',
+        'DeviceInfo',
+        PROTOCOL_V2_DEVICE_INFO_REQUEST
+      );
+  return normalizeProtocolV2Features(descriptor, message as unknown as ProtocolV2DeviceInfo);
 }

package/src/types/api/getDeviceInfo.ts

@@ -0,0 +1,97 @@
+import type { CommonParams, Response } from '../params';
+import type { Features, IDeviceType, OnekeyFeatures } from '../device';
+import type { EFirmwareType } from '@onekeyfe/hd-shared';
+import type { ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+
+export type DeviceInfoProtocol = 'V1' | 'V2' | 'unknown';
+
+export type DeviceInfoSource = 'features' | 'onekeyFeatures' | 'deviceGetDeviceInfo';
+
+export type DeviceInfoScope = 'basic' | 'versions' | 'verify' | 'full';
+
+export type GetDeviceInfoParams = {
+  scope?: DeviceInfoScope;
+  refresh?: boolean;
+  includeRaw?: boolean;
+};
+
+export type DeviceInfoMode = 'normal' | 'bootloader' | 'notInitialized' | 'unknown';
+
+export type DeviceInfoStatus = {
+  mode: DeviceInfoMode;
+  initialized: boolean | null;
+  bootloaderMode: boolean | null;
+  unlocked: boolean | null;
+  passphraseProtection: boolean | null;
+  backupRequired: boolean | null;
+  language: string | null;
+  bleEnabled?: boolean | null;
+};
+
+export type UnifiedDeviceInfoVersions = {
+  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 UnifiedDeviceInfoVerify = {
+  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 UnifiedDeviceInfoRaw = {
+  features?: Features;
+  onekeyFeatures?: OnekeyFeatures;
+  protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
+};
+
+export type UnifiedDeviceInfo = {
+  protocol: DeviceInfoProtocol;
+  sources: DeviceInfoSource[];
+  deviceType: IDeviceType;
+  firmwareType: EFirmwareType;
+  deviceId: string;
+  serialNo: string;
+  label: string | null;
+  bleName: string | null;
+  status: DeviceInfoStatus;
+  versions: UnifiedDeviceInfoVersions;
+  verify?: UnifiedDeviceInfoVerify;
+  raw?: UnifiedDeviceInfoRaw;
+};
+
+export declare function getDeviceInfo(
+  connectId?: string,
+  params?: CommonParams & GetDeviceInfoParams
+): Response<UnifiedDeviceInfo>;

package/src/types/api/index.ts

@@ -15,6 +15,7 @@ import type {
   filesystemDirList,
   filesystemDirMake,
   filesystemDirRemove,
+  filesystemDiskControl,
   filesystemFileDelete,
   filesystemFileRead,
   filesystemFileWrite,
@@ -37,6 +38,7 @@ import type { checkAllFirmwareRelease } from './checkAllFirmwareRelease';
 import type { checkFirmwareTypeAvailable } from './checkFirmwareTypeAvailable';
 import type { searchDevices } from './searchDevices';
 import type { getFeatures } from './getFeatures';
+import type { getDeviceInfo } from './getDeviceInfo';
 import type { getOnekeyFeatures } from './getOnekeyFeatures';
 import type { getPassphraseState } from './getPassphraseState';
 import type { checkFirmwareRelease } from './checkFirmwareRelease';
@@ -162,6 +164,18 @@ import type { neoSignTransaction } from './neoSignTransaction';
 import type { ConnectSettings } from '../settings';
 
 export * from './export';
+export type {
+  DeviceInfoMode,
+  DeviceInfoProtocol,
+  DeviceInfoScope,
+  DeviceInfoSource,
+  DeviceInfoStatus,
+  GetDeviceInfoParams,
+  UnifiedDeviceInfo,
+  UnifiedDeviceInfoRaw,
+  UnifiedDeviceInfoVerify,
+  UnifiedDeviceInfoVersions,
+} from './getDeviceInfo';
 export type { GetPassphraseStateParams, GetPassphraseStatePayload } from './getPassphraseState';
 
 export type CoreApi = {
@@ -201,6 +215,7 @@ export type CoreApi = {
   searchDevices: typeof searchDevices;
   promptWebDeviceAccess: typeof promptWebDeviceAccess;
   getFeatures: typeof getFeatures;
+  getDeviceInfo: typeof getDeviceInfo;
   getOnekeyFeatures: typeof getOnekeyFeatures;
   getPassphraseState: typeof getPassphraseState;
   deviceBackup: typeof deviceBackup;
@@ -259,6 +274,7 @@ export type CoreApi = {
   filesystemDirRemove: typeof filesystemDirRemove;
   filesystemPathInfoQuery: typeof filesystemPathInfoQuery;
   filesystemFormat: typeof filesystemFormat;
+  filesystemDiskControl: typeof filesystemDiskControl;
 
   /**
    * All network function

package/src/types/api/protocolV2.ts

@@ -219,3 +219,8 @@ export declare function filesystemPathInfoQuery(
 ): ReturnType<typeof pathInfo>;
 
 export declare function filesystemFormat(connectId: string): Response<Success>;
+
+export declare function filesystemDiskControl(
+  connectId: string,
+  params: CommonParams & { enable: number | string; timeoutMs?: number | string }
+): Response<Success>;

package/src/types/device.ts

@@ -85,7 +85,35 @@ export type SearchDevice = {
 
 export type Device = KnownDevice;
 
-export type Features = PROTO.Features;
+type OnekeyFeatureExtensions = Partial<
+  Pick<
+    PROTO.OnekeyFeatures,
+    | 'onekey_board_build_id'
+    | 'onekey_se02_hash'
+    | 'onekey_se03_hash'
+    | 'onekey_se04_hash'
+    | 'onekey_se02_build_id'
+    | 'onekey_se03_build_id'
+    | 'onekey_se04_build_id'
+    | 'onekey_se01_boot_version'
+    | 'onekey_se02_boot_version'
+    | 'onekey_se03_boot_version'
+    | 'onekey_se04_boot_version'
+    | 'onekey_se01_boot_hash'
+    | 'onekey_se02_boot_hash'
+    | 'onekey_se03_boot_hash'
+    | 'onekey_se04_boot_hash'
+    | 'onekey_se01_boot_build_id'
+    | 'onekey_se02_boot_build_id'
+    | 'onekey_se03_boot_build_id'
+    | 'onekey_se04_boot_build_id'
+  >
+>;
+
+export type Features = PROTO.Features &
+  OnekeyFeatureExtensions & {
+    protocol_version?: number | null;
+  };
 
 export type OnekeyFeatures = PROTO.OnekeyFeatures;
 
@@ -138,6 +166,7 @@ export type ITransportStatus = 'valid' | 'outdated';
 export type IVersionRange = {
   min: string;
   max?: string;
+  unsupported?: boolean;
 };
 
 export type DeviceFirmwareRange = {

package/src/utils/deviceFeaturesUtils.ts

@@ -231,7 +231,10 @@ export const supportBatchPublicKey = (
 
   const deviceType = getDeviceType(features);
   // btc batch get public key
-  if (!!options?.includeNode && deviceType === EDeviceType.Pro) {
+  if (
+    !!options?.includeNode &&
+    (deviceType === EDeviceType.Pro || deviceType === EDeviceType.Pro2)
+  ) {
     return semver.gte(currentVersion, '4.14.0');
   }
   if (!!options?.includeNode && deviceType === EDeviceType.Touch) {
@@ -248,7 +251,11 @@ export const supportBatchPublicKey = (
   }
 
   // support batch get public key
-  if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
+  if (
+    deviceType === EDeviceType.Touch ||
+    deviceType === EDeviceType.Pro ||
+    deviceType === EDeviceType.Pro2
+  ) {
     return semver.gte(currentVersion, '3.1.0');
   }
 

package/src/utils/deviceInfoUtils.ts

@@ -132,8 +132,8 @@ export const getMethodVersionRange = (
   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;
   }
@@ -146,20 +146,18 @@ export const getMethodVersionRange = (
   ];
   for (const model of modelFallbacks) {
     if (DeviceModelToTypes[model].includes(deviceType)) {
-      versionRange = getVersionRange(model);
+      const versionRange = getVersionRange(model);
       if (versionRange) {
         return versionRange;
       }
     }
   }
 
-  return versionRange;
+  return undefined;
 };
 
-export const shouldSkipMethodSupportCheck = (
-  features: Features | undefined,
-  protocolType?: string
-): boolean => protocolType === 'V2' || getDeviceType(features) === EDeviceType.Pro2;
+export const isMethodVersionRangeUnsupported = (versionRange?: IVersionRange): boolean =>
+  versionRange?.unsupported === true;
 
 export const getFirmwareType = (features: Features | undefined) => {
   if (!features) {

package/src/utils/index.ts

@@ -11,7 +11,7 @@ export {
   getDeviceUUID,
   getDeviceLabel,
   getMethodVersionRange,
-  shouldSkipMethodSupportCheck,
+  isMethodVersionRangeUnsupported,
   getFirmwareType,
 } from './deviceInfoUtils';
 export {