@onekeyfe/hd-core 1.1.27 → 1.2.0-alpha.0

package/src/api/GetDeviceInfo.ts

@@ -0,0 +1,152 @@
+import semver from 'semver';
+import { EDeviceType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { UI_REQUEST } from '../constants/ui-request';
+import {
+  PROTOCOL_V2_DEVICE_INFO_REQUEST,
+  PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
+  PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
+} from '../protocols/protocol-v2';
+import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
+import { buildProfileFromProtocolV1, buildProfileFromProtocolV2 } from '../deviceProfile';
+import { getDeviceType } from '../utils';
+import { fixVersion } from '../utils/deviceFeaturesUtils';
+import { BaseMethod } from './BaseMethod';
+
+import type {
+  DeviceInfoScope,
+  DeviceInfoSource,
+  GetDeviceInfoParams,
+} from '../types/api/getDeviceInfo';
+import type { Features, OnekeyFeatures } from '../types';
+
+const DEVICE_INFO_SCOPES: readonly DeviceInfoScope[] = ['basic', 'versions', 'verify', 'full'];
+
+function isDeviceInfoScope(scope: unknown): scope is DeviceInfoScope {
+  return typeof scope === 'string' && DEVICE_INFO_SCOPES.includes(scope as DeviceInfoScope);
+}
+
+function normalizeScope(scope: unknown): GetDeviceInfoParams['scope'] {
+  if (scope === undefined || scope === null) return 'basic';
+  if (isDeviceInfoScope(scope)) {
+    return scope;
+  }
+  throw ERRORS.TypedError(
+    HardwareErrorCode.CallMethodInvalidParameter,
+    `Invalid getDeviceInfo scope: ${String(scope)}`
+  );
+}
+
+function resolveProtocolV2DeviceInfoRequest(params: GetDeviceInfoParams) {
+  if (params.scope === 'verify' || params.scope === 'full') {
+    return PROTOCOL_V2_DEVICE_INFO_REQUEST;
+  }
+  if (params.scope === 'versions') {
+    return PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST;
+  }
+  return PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST;
+}
+
+function shouldReadOnekeyFeatures(params: GetDeviceInfoParams) {
+  return (
+    params.includeRaw === true ||
+    params.scope === 'versions' ||
+    params.scope === 'verify' ||
+    params.scope === 'full'
+  );
+}
+
+function supportOnekeyFeatures(features?: Features) {
+  if (!features || features.bootloader_mode) return false;
+
+  const deviceType = getDeviceType(features);
+  return ![
+    EDeviceType.Unknown,
+    EDeviceType.Classic1s,
+    EDeviceType.ClassicPure,
+    EDeviceType.Pro2,
+  ].includes(deviceType);
+}
+
+function normalizeOnekeyFeatures(message: OnekeyFeatures) {
+  if (message.onekey_firmware_version && !semver.valid(message.onekey_firmware_version)) {
+    message.onekey_firmware_version = fixVersion(message.onekey_firmware_version);
+  }
+  return message;
+}
+
+export default class GetDeviceInfo extends BaseMethod<GetDeviceInfoParams> {
+  init() {
+    this.allowDeviceMode = [
+      ...this.allowDeviceMode,
+      UI_REQUEST.NOT_INITIALIZE,
+      UI_REQUEST.BOOTLOADER,
+    ];
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = {
+      scope: normalizeScope(this.payload.scope),
+      refresh: this.payload.refresh,
+      includeRaw: this.payload.includeRaw,
+    };
+  }
+
+  async run() {
+    if (this.device.isProtocolV2()) {
+      return this.runProtocolV2();
+    }
+    return this.runProtocolV1();
+  }
+
+  private async runProtocolV2() {
+    const sources: DeviceInfoSource[] = ['deviceInfo'];
+    const protocolV2DeviceInfo = await requestProtocolV2DeviceInfo({
+      commands: this.device.commands,
+      request: resolveProtocolV2DeviceInfoRequest(this.params),
+    });
+    const profile = buildProfileFromProtocolV2({
+      deviceInfo: protocolV2DeviceInfo,
+      sources,
+      scope: this.params.scope,
+      includeRaw: this.params.includeRaw,
+      fallbackSerialNo: this.device.originalDescriptor?.path,
+    });
+    // 缓存走字段级合并：basic 请求不能降级已有的完整 profile；返回值仍按请求 scope 给出
+    if (typeof this.device.applyProfileUpdate === 'function') {
+      this.device.applyProfileUpdate(profile, protocolV2DeviceInfo);
+    } else {
+      this.device.updateProfile?.(profile);
+    }
+    return profile;
+  }
+
+  private async runProtocolV1() {
+    if (this.params.refresh === true) {
+      await this.device.getFeatures();
+    }
+
+    const sources: DeviceInfoSource[] = ['features'];
+    const { features } = this.device;
+    let onekeyFeatures: OnekeyFeatures | undefined;
+
+    if (shouldReadOnekeyFeatures(this.params) && supportOnekeyFeatures(features)) {
+      const { message } = await this.device.commands.typedCall(
+        'OnekeyGetFeatures',
+        'OnekeyFeatures'
+      );
+      onekeyFeatures = normalizeOnekeyFeatures(message);
+      sources.push('onekeyFeatures');
+    }
+
+    const profile = buildProfileFromProtocolV1({
+      protocol: 'V1',
+      features,
+      onekeyFeatures,
+      sources,
+      scope: this.params.scope,
+      includeRaw: this.params.includeRaw,
+    });
+    this.device.updateProfile?.(profile);
+    return profile;
+  }
+}

package/src/api/GetFeatures.ts

@@ -14,10 +14,13 @@ export default class GetFeatures extends BaseMethod {
     this.skipForceUpdateCheck = true;
   }
 
-  run() {
-    if (this.payload?.detectBootloaderDevice && this.device.features?.bootloader_mode) {
+  async run() {
+    if (this.payload?.detectBootloaderDevice && this.device.isBootloader()) {
       return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceDetectInBootloaderMode));
     }
+    if (this.device.isProtocolV2()) {
+      return this.device.getFeatures();
+    }
     return Promise.resolve(this.device.features);
   }
 }

package/src/api/GetOnekeyFeatures.ts

@@ -2,8 +2,81 @@ import semver from 'semver';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { fixVersion } from '../utils/deviceFeaturesUtils';
+import { PROTOCOL_V2_DEVICE_INFO_REQUEST } from '../protocols/protocol-v2';
+import { requestProtocolV2DeviceInfo } from '../protocols/protocol-v2/features';
+import { buildProfileFromProtocolV2, buildProtocolV2GetFeaturesPayload } from '../deviceProfile';
 import { BaseMethod } from './BaseMethod';
 
+import type { OnekeyFeatures } from '../types';
+
+const ONEKEY_FEATURE_KEYS: Array<keyof OnekeyFeatures> = [
+  'onekey_device_type',
+  'onekey_board_version',
+  'onekey_boot_version',
+  'onekey_firmware_version',
+  'onekey_board_hash',
+  'onekey_boot_hash',
+  'onekey_firmware_hash',
+  'onekey_board_build_id',
+  'onekey_boot_build_id',
+  'onekey_firmware_build_id',
+  'onekey_serial_no',
+  'onekey_ble_name',
+  'onekey_ble_version',
+  'onekey_ble_build_id',
+  'onekey_ble_hash',
+  'onekey_se_type',
+  'onekey_se01_state',
+  'onekey_se02_state',
+  'onekey_se03_state',
+  'onekey_se04_state',
+  'onekey_se01_version',
+  'onekey_se02_version',
+  'onekey_se03_version',
+  'onekey_se04_version',
+  'onekey_se01_hash',
+  'onekey_se02_hash',
+  'onekey_se03_hash',
+  'onekey_se04_hash',
+  'onekey_se01_build_id',
+  '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',
+];
+
+function normalizeOnekeyFirmwareVersion(message: OnekeyFeatures) {
+  if (message.onekey_firmware_version && !semver.valid(message.onekey_firmware_version)) {
+    message.onekey_firmware_version = fixVersion(message.onekey_firmware_version);
+  }
+}
+
+function pickOnekeyFeatures(features?: OnekeyFeatures | null): OnekeyFeatures {
+  const message: OnekeyFeatures = {};
+  if (!features) return message;
+
+  for (const key of ONEKEY_FEATURE_KEYS) {
+    const value = features[key];
+    if (value !== undefined && value !== null) {
+      (message as Record<string, unknown>)[key] = value;
+    }
+  }
+
+  normalizeOnekeyFirmwareVersion(message);
+  return message;
+}
+
 export default class GetOnekeyFeatures extends BaseMethod {
   init() {
     this.allowDeviceMode = [
@@ -16,10 +89,29 @@ export default class GetOnekeyFeatures extends BaseMethod {
   }
 
   async run() {
-    const { message } = await this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
-    if (!!message.onekey_firmware_version && !semver.valid(message.onekey_firmware_version)) {
-      message.onekey_firmware_version = fixVersion(message.onekey_firmware_version);
+    if (this.device.isProtocolV2()) {
+      // V2 没有 OnekeyGetFeatures 消息：
+      // 取完整 DevGetDeviceInfo（含 SE/hash/build_id）后写入 features 兼容视图。
+      const deviceInfo = await requestProtocolV2DeviceInfo({
+        commands: this.device.commands,
+        request: PROTOCOL_V2_DEVICE_INFO_REQUEST,
+      });
+      const profile = this.device.applyProfileUpdate(
+        buildProfileFromProtocolV2({
+          deviceInfo,
+          sources: ['deviceInfo'],
+          scope: 'verify',
+          fallbackSerialNo: this.device.originalDescriptor?.path,
+        }),
+        deviceInfo
+      );
+      return pickOnekeyFeatures(
+        buildProtocolV2GetFeaturesPayload(profile, deviceInfo) as OnekeyFeatures
+      );
     }
+
+    const { message } = await this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
+    normalizeOnekeyFirmwareVersion(message);
     return Promise.resolve(message);
   }
 }

package/src/api/GetPassphraseState.ts

@@ -1,4 +1,4 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
@@ -11,18 +11,24 @@ export default class GetPassphraseState extends BaseMethod {
   }
 
   async run() {
-    if (!this.device.features)
-      return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed));
-
-    const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(this.device);
+    const { passphraseState, newSession, unlockedAttachPin } =
+      await getPassphraseStateWithRefreshDeviceInfo(this.device, {
+        expectPassphraseState: this.payload.passphraseState,
+        onlyMainPin: this.payload.useEmptyPassphrase,
+        allowCreateAttachPin: this.payload.allowCreateAttachPin,
+      });
 
     const { features } = this.device;
+    const passphraseProtection = this.device.getCurrentPassphraseProtection() ?? null;
+    const deviceType = this.device.getCurrentDeviceType();
+    const isProSeries = deviceType === EDeviceType.Pro || deviceType === EDeviceType.Pro2;
 
     // refresh device info
-    if (features && features.passphrase_protection === true) {
-      return Promise.resolve(passphraseState);
-    }
-
-    return Promise.resolve(undefined);
+    return Promise.resolve({
+      passphrase_state: isProSeries || passphraseProtection === true ? passphraseState : undefined,
+      session_id: newSession ?? features?.session_id ?? undefined,
+      unlocked_attach_pin: unlockedAttachPin ?? features?.unlocked_attach_pin,
+      passphrase_protection: passphraseProtection,
+    });
   }
 }

package/src/api/PathInfo.ts

@@ -0,0 +1,39 @@
+import { BaseMethod } from './BaseMethod';
+import {
+  validateNonEmptyString,
+  validateOptionalNonNegativeInteger,
+} from './helpers/filesystemValidation';
+
+export type PathInfoParams = {
+  path: string;
+  timeoutMs?: number | string;
+};
+
+export default class PathInfo extends BaseMethod<PathInfoParams> {
+  init() {
+    // Protocol V2 (Pro2) 专属方法，core 调度层统一做非 V2 设备守卫
+    this.requireProtocolV2 = true;
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      path: validateNonEmptyString(this.payload.path, 'path'),
+      timeoutMs: validateOptionalNonNegativeInteger(this.payload.timeoutMs, 'timeoutMs'),
+    };
+  }
+
+  async run() {
+    const timeoutMs =
+      this.params.timeoutMs === undefined ? undefined : Number(this.params.timeoutMs);
+    const res = await this.device.commands.typedCall(
+      'FilesystemPathInfoQuery',
+      'FilesystemPathInfo',
+      {
+        path: this.params.path,
+      },
+      {
+        timeoutMs,
+      }
+    );
+    return Promise.resolve(res.message);
+  }
+}

package/src/api/PromptWebDeviceAccess.ts

@@ -51,9 +51,19 @@ export default class PromptWebDeviceAccess extends BaseMethod {
         }
 
         if (isWebUsbEnv) {
+          const usbDevice = device as USBDevice;
+          let path = usbDevice.serialNumber ?? '';
+          if (!path) {
+            // 早期 Pro2 工程板 USB descriptor 没有 serial number。
+            // 授权后重新枚举，transport 会为空 serial 设备生成会话内稳定的 mock path，
+            // 这里按 USBDevice 对象身份找回该 path，保证后续 acquire 能匹配。
+            const diff = await this.connector?.enumerate();
+            const matched = diff?.descriptors?.find(d => (d as any).device === usbDevice);
+            path = matched?.path ?? '';
+          }
           devicesDescriptor = [
             {
-              path: (device as USBDevice).serialNumber ?? '',
+              path,
               device,
               debug: true,
             },

package/src/api/SearchDevices.ts

@@ -34,17 +34,22 @@ export default class SearchDevices extends BaseMethod {
         const lowerId = device.id?.toLowerCase();
         if (!seenIds.has(lowerId)) {
           seenIds.add(lowerId);
+          const bleName =
+            device.name ?? (device as unknown as { localName?: string }).localName ?? '';
           devices.push({
             ...device,
             connectId: device.id,
-            deviceType: getDeviceTypeByBleName(device.name ?? ''),
+            name: bleName || device.name,
+            deviceType: getDeviceTypeByBleName(bleName),
           });
         }
       }
       return devices;
     }
 
-    const { deviceList } = await DevicePool.getDevices(devicesDescriptor);
+    const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined, {
+      connectProtocol: this.payload.connectProtocol,
+    });
     return deviceList.map(device => device.toMessageObject());
   }
 }

package/src/api/alephium/AlephiumGetAddress.ts

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

package/src/api/alephium/AlephiumSignMessage.ts

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

package/src/api/alephium/AlephiumSignTransaction.ts

@@ -8,10 +8,11 @@ import { validateParams } from '../helpers/paramsValidator';
 
 import type {
   AlephiumSignedTx,
+  AlephiumTxRequest,
   AlephiumSignTx as HardwareAlephiumSignTx,
   TypedCall,
 } from '@onekeyfe/hd-transport';
-import type { AlephiumSignTransactionParams } from '../../types';
+import type { AlephiumSignTransactionParams, DeviceFirmwareRange } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 
 export default class AlephiumSignTransaction extends BaseMethod<HardwareAlephiumSignTx> {
@@ -39,8 +40,12 @@ export default class AlephiumSignTransaction extends BaseMethod<HardwareAlephium
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_touch: {
         min: '4.10.0',
       },
@@ -58,7 +63,10 @@ export default class AlephiumSignTransaction extends BaseMethod<HardwareAlephium
     data: Buffer,
     scriptOpt?: Buffer,
     dataOffset = 0
-  ): Promise<AlephiumSignedTx> => {
+    // 设备可能在最后一个 AlephiumTxRequest（无 data_length）里返回签名，
+    // 该消息没有 address 字段，返回类型如实声明为联合类型
+  ): Promise<AlephiumSignedTx | AlephiumTxRequest> => {
+    const responseType = res.type;
     if (res.type === 'AlephiumSignedTx') {
       return res.message;
     }
@@ -109,7 +117,10 @@ export default class AlephiumSignTransaction extends BaseMethod<HardwareAlephium
       return this.processTxRequest(typedCall, response, data, scriptOpt, dataOffset);
     }
 
-    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, `Unknown response type: ${res.type}`);
+    throw ERRORS.TypedError(
+      HardwareErrorCode.RuntimeError,
+      `Unknown response type: ${responseType}`
+    );
   };
 
   async run() {

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -12,7 +12,7 @@ import { validateParams } from '../helpers/paramsValidator';
 import { PROTO } from '../../constants';
 import { findMethod } from '../utils';
 import { DEVICE, IFRAME, createUiMessage } from '../../events';
-import { getDeviceFirmwareVersion, getFirmwareType, getMethodVersionRange } from '../../utils';
+import { isMethodVersionRangeUnsupported } from '../../utils';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { onDeviceButtonHandler } from '../../core';
 import {
@@ -463,11 +463,12 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
  * @param method BaseMethod
  */
 function preCheckDeviceSupport(device: Device, method: BaseMethod) {
-  const versionRange = getMethodVersionRange(
-    device.features,
-    type => method.getVersionRange()[type]
-  );
-  const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+  const versionRange = device.getCurrentMethodVersionRange(type => method.getVersionRange()[type]);
+  const currentVersion = device.getCurrentFirmwareVersionString() ?? '0.0.0';
+
+  if (isMethodVersionRangeUnsupported(versionRange)) {
+    throw ERRORS.createDeviceNotSupportMethodError(method.name, device.getCurrentFirmwareType());
+  }
 
   if (
     versionRange &&
@@ -478,10 +479,10 @@ function preCheckDeviceSupport(device: Device, method: BaseMethod) {
       currentVersion,
       requireVersion: versionRange.min,
       methodName: method.name,
-      firmwareType: getFirmwareType(device.features),
+      firmwareType: device.getCurrentFirmwareType(),
     });
   } else if (method.strictCheckDeviceSupport && !versionRange) {
-    throw ERRORS.createDeviceNotSupportMethodError(method.name, getFirmwareType(device.features));
+    throw ERRORS.createDeviceNotSupportMethodError(method.name, device.getCurrentFirmwareType());
   }
 }
 
@@ -503,11 +504,18 @@ function handleSkippableHardwareError(
     e.message?.includes('Failure_UnexpectedMessage') ||
     e.message?.includes('Failure_UnknownMessage')
   ) {
-    const versionRange = getMethodVersionRange(
-      device.features,
+    const versionRange = device.getCurrentMethodVersionRange(
       type => method.getVersionRange()[type]
     );
-    const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
+    const currentVersion = device.getCurrentFirmwareVersionString() ?? '0.0.0';
+
+    if (isMethodVersionRangeUnsupported(versionRange)) {
+      error = ERRORS.createDeviceNotSupportMethodError(
+        method.name,
+        device.getCurrentFirmwareType()
+      );
+      return error;
+    }
 
     if (
       versionRange &&
@@ -518,12 +526,12 @@ function handleSkippableHardwareError(
         currentVersion,
         requireVersion: versionRange.min,
         methodName: method.name,
-        firmwareType: getFirmwareType(device.features),
+        firmwareType: device.getCurrentFirmwareType(),
       });
     } else {
       error = ERRORS.createDeviceNotSupportMethodError(
         method.name,
-        getFirmwareType(device.features)
+        device.getCurrentFirmwareType()
       );
     }
   } else if (

package/src/api/aptos/AptosGetAddress.ts

@@ -5,9 +5,8 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
-import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
 import { hexToBytes } from '../helpers/hexUtils';
-import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+import { batchGetPublickeys, supportBatchPublicKeyByDevice } from '../helpers/batchGetPublickeys';
 
 import type { AptosAddress, AptosGetAddressParams } from '../../types';
 import type { AptosGetAddress as HardwareAptosGetAddress } from '@onekeyfe/hd-transport';
@@ -66,7 +65,7 @@ export default class AptosGetAddress extends BaseMethod<HardwareAptosGetAddress[
   }
 
   async run() {
-    const supportsBatchPublicKey = supportBatchPublicKey(this.device?.features);
+    const supportsBatchPublicKey = supportBatchPublicKeyByDevice(this.device);
     let responses: AptosAddress[] = [];
     if (supportsBatchPublicKey) {
       const publicKeyRes = await batchGetPublickeys(this.device, this.params, 'ed25519', 637);

package/src/api/benfen/BenfenGetAddress.ts

@@ -3,10 +3,9 @@ import { validateParams, validateResult } from '../helpers/paramsValidator';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { hex2BfcAddress, publicKeyToAddress } from './normalize';
-import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
-import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
+import { batchGetPublickeys, supportBatchPublicKeyByDevice } from '../helpers/batchGetPublickeys';
 
-import type { BenfenAddress, BenfenGetAddressParams } from '../../types';
+import type { BenfenAddress, BenfenGetAddressParams, DeviceFirmwareRange } from '../../types';
 import type { BenfenGetAddress as HardwareBenfenGetAddress } from '@onekeyfe/hd-transport';
 
 export default class BenfenGetAddress extends BaseMethod<HardwareBenfenGetAddress[]> {
@@ -47,8 +46,12 @@ export default class BenfenGetAddress extends BaseMethod<HardwareBenfenGetAddres
     });
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       pro: {
         min: '4.12.0',
       },
@@ -59,7 +62,7 @@ export default class BenfenGetAddress extends BaseMethod<HardwareBenfenGetAddres
   }
 
   async run() {
-    const supportsBatchPublicKey = supportBatchPublicKey(this.device?.features);
+    const supportsBatchPublicKey = supportBatchPublicKeyByDevice(this.device);
     let responses: BenfenAddress[] = [];
 
     if (supportsBatchPublicKey) {
@@ -75,7 +78,8 @@ export default class BenfenGetAddress extends BaseMethod<HardwareBenfenGetAddres
             'BenfenAddress',
             param
           );
-          address = addressRes.message.address;
+          // proto 里 BenfenAddress.address 是 optional；正常响应必然携带
+          address = addressRes.message.address ?? '';
         } else {
           address = publicKeyToAddress(publicKey);
         }
@@ -103,7 +107,7 @@ export default class BenfenGetAddress extends BaseMethod<HardwareBenfenGetAddres
           );
           const result = {
             path: serializedPath(param.address_n),
-            address: hex2BfcAddress(res.message.address),
+            address: hex2BfcAddress(res.message.address ?? ''),
           };
           if (this.shouldConfirm) {
             this.postPreviousAddressMessage(result);