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

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -16,7 +16,7 @@ import {
   getDeviceFirmwareVersion,
   getFirmwareType,
   getMethodVersionRange,
-  shouldSkipMethodSupportCheck,
+  isMethodVersionRangeUnsupported,
 } from '../../utils';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { onDeviceButtonHandler } from '../../core';
@@ -460,16 +460,16 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
  * @param method BaseMethod
  */
 function preCheckDeviceSupport(device: Device, method: BaseMethod) {
-  if (shouldSkipMethodSupportCheck(device.features, device.originalDescriptor?.protocolType)) {
-    return;
-  }
-
   const versionRange = getMethodVersionRange(
     device.features,
     type => method.getVersionRange()[type]
   );
   const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
 
+  if (isMethodVersionRangeUnsupported(versionRange)) {
+    throw ERRORS.createDeviceNotSupportMethodError(method.name, getFirmwareType(device.features));
+  }
+
   if (
     versionRange &&
     semver.valid(versionRange.min) &&
@@ -492,20 +492,9 @@ function handleSkippableHardwareError(
   method: BaseMethod
 ): HardwareError | undefined {
   let error: HardwareError | undefined;
-  const skipMethodSupportCheck = shouldSkipMethodSupportCheck(
-    device.features,
-    device.originalDescriptor?.protocolType
-  );
 
   if (e instanceof HardwareError && e.errorCode !== HardwareErrorCode.RuntimeError) {
     const { errorCode } = e;
-    if (
-      skipMethodSupportCheck &&
-      (errorCode === HardwareErrorCode.CallMethodNeedUpgradeFirmware ||
-        errorCode === HardwareErrorCode.DeviceNotSupportMethod)
-    ) {
-      return undefined;
-    }
     if (errorCode === HardwareErrorCode.CallMethodNeedUpgradeFirmware) {
       error = e;
     } else if (errorCode === HardwareErrorCode.DeviceNotSupportMethod) {
@@ -515,16 +504,20 @@ function handleSkippableHardwareError(
     e.message?.includes('Failure_UnexpectedMessage') ||
     e.message?.includes('Failure_UnknownMessage')
   ) {
-    if (skipMethodSupportCheck) {
-      return undefined;
-    }
-
     const versionRange = getMethodVersionRange(
       device.features,
       type => method.getVersionRange()[type]
     );
     const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
 
+    if (isMethodVersionRangeUnsupported(versionRange)) {
+      error = ERRORS.createDeviceNotSupportMethodError(
+        method.name,
+        getFirmwareType(device.features)
+      );
+      return error;
+    }
+
     if (
       versionRange &&
       semver.valid(versionRange.min) &&

package/src/api/benfen/BenfenGetAddress.ts

@@ -6,7 +6,7 @@ import { hex2BfcAddress, publicKeyToAddress } from './normalize';
 import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
 import { batchGetPublickeys } 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 +47,12 @@ export default class BenfenGetAddress extends BaseMethod<HardwareBenfenGetAddres
     });
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       pro: {
         min: '4.12.0',
       },

package/src/api/benfen/BenfenGetPublicKey.ts

@@ -4,7 +4,7 @@ import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
 
-import type { BenfenGetPublicKeyParams, BenfenPublicKey } from '../../types';
+import type { BenfenGetPublicKeyParams, BenfenPublicKey, DeviceFirmwareRange } from '../../types';
 
 export default class BenfenGetPublicKey extends BaseMethod<any> {
   hasBundle = false;
@@ -38,8 +38,12 @@ export default class BenfenGetPublicKey extends BaseMethod<any> {
     });
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       pro: {
         min: '4.12.0',
       },

package/src/api/benfen/BenfenSignMessage.ts

@@ -5,6 +5,7 @@ import { validateParams } from '../helpers/paramsValidator';
 import { stripHexPrefix } from '../helpers/hexUtils';
 
 import type { BenfenSignMessage as HardwareBenfenSignMessage } from '@onekeyfe/hd-transport';
+import type { DeviceFirmwareRange } from '../../types';
 
 export default class BenfenSignMessage extends BaseMethod<HardwareBenfenSignMessage> {
   init() {
@@ -25,8 +26,12 @@ export default class BenfenSignMessage extends BaseMethod<HardwareBenfenSignMess
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       pro: {
         min: '4.12.0',
       },

package/src/api/benfen/BenfenSignTransaction.ts

@@ -8,6 +8,7 @@ import { formatAnyHex } from '../helpers/hexUtils';
 
 import type { BenfenSignTx, BenfenSignedTx, MessageType, TypedCall } from '@onekeyfe/hd-transport';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
+import type { DeviceFirmwareRange } from '../../types';
 
 export default class BenfenSignTransaction extends BaseMethod<BenfenSignTx> {
   init() {
@@ -32,8 +33,12 @@ export default class BenfenSignTransaction extends BaseMethod<BenfenSignTx> {
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       pro: {
         min: '4.12.0',
       },

package/src/api/btc/helpers/versionLimit.ts

@@ -1,3 +1,5 @@
+import type { DeviceFirmwareRange } from '../../../types';
+
 function isCoinNameInList(coinName: string, coinNames: (string | undefined)[]) {
   for (let i = 0; i < coinNames.length; i++) {
     const coin_name = coinNames[i];
@@ -8,9 +10,13 @@ function isCoinNameInList(coinName: string, coinNames: (string | undefined)[]) {
   return false;
 }
 
-export function getBitcoinForkVersionRange(params: (string | undefined)[]) {
+export function getBitcoinForkVersionRange(params: (string | undefined)[]): DeviceFirmwareRange {
   if (isCoinNameInList('Neurai', params)) {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_mini: {
         min: '3.7.0',
       },

package/src/api/evm/EVMSignMessageEIP712.ts

@@ -5,6 +5,7 @@ import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 
 import type { EthereumSignMessageEIP712 } from '@onekeyfe/hd-transport';
+import type { DeviceFirmwareRange } from '../../types';
 
 /**
  * @deprecated Use EVMSignTypedData instead.
@@ -31,8 +32,12 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EthereumSignMessage
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_mini: {
         min: '2.1.9',
       },
@@ -43,6 +48,14 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EthereumSignMessage
   }
 
   async run() {
+    this.checkFeatureVersionLimit(
+      () => true,
+      () => this.getVersionRange(),
+      {
+        strictCheckDeviceSupport: true,
+      }
+    );
+
     const res = await this.device.commands.typedCall(
       'EthereumSignMessageEIP712',
       'EthereumMessageSignature',

package/src/api/helpers/batchGetPublickeys.ts

@@ -7,7 +7,7 @@ import {
 import { supportBatchPublicKey } from '../../utils/deviceFeaturesUtils';
 import { isEqualBip44CoinType } from './pathUtils';
 import { splitArray } from '../../utils/arrayUtils';
-import { getDeviceType, getFirmwareType, shouldSkipMethodSupportCheck } from '../../utils';
+import { getDeviceType, getFirmwareType } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
 
 import type { EcdsaPublicKeys, Path } from '@onekeyfe/hd-transport';
@@ -28,9 +28,7 @@ export async function batchGetPublickeys(
     throw TypedError(HardwareErrorCode.ForbiddenKeyPath, 'Path length must be greater than 3');
   }
 
-  const supportsBatchPublicKey =
-    shouldSkipMethodSupportCheck(device.features, device.originalDescriptor?.protocolType) ||
-    supportBatchPublicKey(device.features, options);
+  const supportsBatchPublicKey = supportBatchPublicKey(device.features, options);
   if (!supportsBatchPublicKey) {
     throw createDeviceNotSupportMethodError('BatchGetPublickeys', getFirmwareType(device.features));
   }

package/src/api/helpers/deviceInfo.ts

@@ -0,0 +1,205 @@
+import {
+  getDeviceBLEFirmwareVersion,
+  getDeviceBleName,
+  getDeviceBoardloaderVersion,
+  getDeviceBootloaderVersion,
+  getDeviceFirmwareVersion,
+  getDeviceLabel,
+  getDeviceType,
+  getDeviceUUID,
+  getFirmwareType,
+} from '../../utils';
+
+import type {
+  DeviceInfoProtocol,
+  DeviceInfoSource,
+  DeviceInfoStatus,
+  GetDeviceInfoParams,
+  UnifiedDeviceInfo,
+  UnifiedDeviceInfoRaw,
+  UnifiedDeviceInfoVerify,
+  UnifiedDeviceInfoVersions,
+} from '../../types/api/getDeviceInfo';
+import type { Features, OnekeyFeatures } from '../../types';
+import type { ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+
+type BuildDeviceInfoParams = {
+  protocol: DeviceInfoProtocol;
+  features?: Features;
+  onekeyFeatures?: OnekeyFeatures;
+  protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
+  sources: DeviceInfoSource[];
+  scope?: GetDeviceInfoParams['scope'];
+  includeRaw?: boolean;
+};
+
+const isMeaningfulVersion = (version?: string | null) => Boolean(version && version !== '0.0.0');
+
+const versionArrayToString = (version?: Array<number | string | null> | null) => {
+  if (!version || version.length === 0) return null;
+  const value = version.join('.');
+  return isMeaningfulVersion(value) ? value : null;
+};
+
+const firstVersion = (...versions: Array<string | null | undefined>) =>
+  versions.find(isMeaningfulVersion) ?? null;
+
+const safeGetDeviceUUID = (features?: Features) => (features ? getDeviceUUID(features) : '');
+
+const shouldIncludeVerify = (scope?: GetDeviceInfoParams['scope']) =>
+  scope === 'verify' || scope === 'full';
+
+const getDeviceMode = (features?: Features): DeviceInfoStatus['mode'] => {
+  if (!features) return 'unknown';
+  if (features.bootloader_mode === true) return 'bootloader';
+  if (features.initialized === false) return 'notInitialized';
+  if (features.initialized === true) return 'normal';
+  return 'unknown';
+};
+
+const normalizeVersions = (
+  features?: Features,
+  onekeyFeatures?: OnekeyFeatures
+): UnifiedDeviceInfoVersions => ({
+  firmware: firstVersion(
+    onekeyFeatures?.onekey_firmware_version,
+    versionArrayToString(getDeviceFirmwareVersion(features))
+  ),
+  bootloader: firstVersion(
+    onekeyFeatures?.onekey_boot_version,
+    versionArrayToString(getDeviceBootloaderVersion(features))
+  ),
+  board: firstVersion(
+    onekeyFeatures?.onekey_board_version,
+    versionArrayToString(features ? getDeviceBoardloaderVersion(features) : undefined)
+  ),
+  ble: firstVersion(
+    onekeyFeatures?.onekey_ble_version,
+    features?.onekey_ble_version,
+    features?.ble_ver,
+    versionArrayToString(features ? getDeviceBLEFirmwareVersion(features) : undefined)
+  ),
+  se01: firstVersion(onekeyFeatures?.onekey_se01_version, features?.onekey_se01_version),
+  se02: firstVersion(onekeyFeatures?.onekey_se02_version, features?.onekey_se02_version),
+  se03: firstVersion(onekeyFeatures?.onekey_se03_version, features?.onekey_se03_version),
+  se04: firstVersion(onekeyFeatures?.onekey_se04_version, features?.onekey_se04_version),
+  se01Boot: firstVersion(
+    onekeyFeatures?.onekey_se01_boot_version,
+    features?.onekey_se01_boot_version
+  ),
+  se02Boot: firstVersion(
+    onekeyFeatures?.onekey_se02_boot_version,
+    features?.onekey_se02_boot_version
+  ),
+  se03Boot: firstVersion(
+    onekeyFeatures?.onekey_se03_boot_version,
+    features?.onekey_se03_boot_version
+  ),
+  se04Boot: firstVersion(
+    onekeyFeatures?.onekey_se04_boot_version,
+    features?.onekey_se04_boot_version
+  ),
+});
+
+const normalizeStatus = (protocol: DeviceInfoProtocol, features?: Features): DeviceInfoStatus => ({
+  mode: getDeviceMode(features),
+  initialized: features?.initialized ?? null,
+  bootloaderMode: features?.bootloader_mode ?? null,
+  unlocked: protocol === 'V2' ? null : features?.unlocked ?? null,
+  passphraseProtection: features?.passphrase_protection ?? null,
+  backupRequired: features?.needs_backup ?? null,
+  language: features?.language ?? null,
+  bleEnabled: (features as { ble_enable?: boolean } | undefined)?.ble_enable ?? null,
+});
+
+const normalizeVerify = (
+  features?: Features,
+  onekeyFeatures?: OnekeyFeatures
+): UnifiedDeviceInfoVerify => {
+  const featureRecord = features as Record<string, string | undefined> | undefined;
+  return {
+    firmwareBuildId: onekeyFeatures?.onekey_firmware_build_id ?? features?.onekey_firmware_build_id,
+    firmwareHash: onekeyFeatures?.onekey_firmware_hash ?? features?.onekey_firmware_hash,
+    bootloaderBuildId: onekeyFeatures?.onekey_boot_build_id ?? features?.onekey_boot_build_id,
+    bootloaderHash: onekeyFeatures?.onekey_boot_hash ?? features?.onekey_boot_hash,
+    boardBuildId: onekeyFeatures?.onekey_board_build_id ?? featureRecord?.onekey_board_build_id,
+    boardHash: onekeyFeatures?.onekey_board_hash ?? features?.onekey_board_hash,
+    bleBuildId: onekeyFeatures?.onekey_ble_build_id ?? features?.onekey_ble_build_id,
+    bleHash: onekeyFeatures?.onekey_ble_hash ?? features?.onekey_ble_hash,
+    se01BuildId: onekeyFeatures?.onekey_se01_build_id ?? features?.onekey_se01_build_id,
+    se01Hash: onekeyFeatures?.onekey_se01_hash ?? featureRecord?.onekey_se01_hash,
+    se02BuildId: onekeyFeatures?.onekey_se02_build_id ?? featureRecord?.onekey_se02_build_id,
+    se02Hash: onekeyFeatures?.onekey_se02_hash ?? featureRecord?.onekey_se02_hash,
+    se03BuildId: onekeyFeatures?.onekey_se03_build_id ?? featureRecord?.onekey_se03_build_id,
+    se03Hash: onekeyFeatures?.onekey_se03_hash ?? featureRecord?.onekey_se03_hash,
+    se04BuildId: onekeyFeatures?.onekey_se04_build_id ?? featureRecord?.onekey_se04_build_id,
+    se04Hash: onekeyFeatures?.onekey_se04_hash ?? featureRecord?.onekey_se04_hash,
+    se01BootBuildId:
+      onekeyFeatures?.onekey_se01_boot_build_id ?? features?.onekey_se01_boot_build_id,
+    se01BootHash: onekeyFeatures?.onekey_se01_boot_hash ?? features?.onekey_se01_boot_hash,
+    se02BootBuildId:
+      onekeyFeatures?.onekey_se02_boot_build_id ?? features?.onekey_se02_boot_build_id,
+    se02BootHash: onekeyFeatures?.onekey_se02_boot_hash ?? features?.onekey_se02_boot_hash,
+    se03BootBuildId:
+      onekeyFeatures?.onekey_se03_boot_build_id ?? features?.onekey_se03_boot_build_id,
+    se03BootHash: onekeyFeatures?.onekey_se03_boot_hash ?? features?.onekey_se03_boot_hash,
+    se04BootBuildId:
+      onekeyFeatures?.onekey_se04_boot_build_id ?? features?.onekey_se04_boot_build_id,
+    se04BootHash: onekeyFeatures?.onekey_se04_boot_hash ?? features?.onekey_se04_boot_hash,
+  };
+};
+
+const normalizeRaw = ({
+  features,
+  onekeyFeatures,
+  protocolV2DeviceInfo,
+}: Pick<
+  BuildDeviceInfoParams,
+  'features' | 'onekeyFeatures' | 'protocolV2DeviceInfo'
+>): UnifiedDeviceInfoRaw => ({
+  ...(features ? { features } : {}),
+  ...(onekeyFeatures ? { onekeyFeatures } : {}),
+  ...(protocolV2DeviceInfo ? { protocolV2DeviceInfo } : {}),
+});
+
+export function buildUnifiedDeviceInfo({
+  protocol,
+  features,
+  onekeyFeatures,
+  protocolV2DeviceInfo,
+  sources,
+  scope = 'basic',
+  includeRaw = false,
+}: BuildDeviceInfoParams): UnifiedDeviceInfo {
+  const mergedFeatures = {
+    ...(features ?? {}),
+    ...(onekeyFeatures ?? {}),
+  } as Features;
+  const hasFeatures = Boolean(features || onekeyFeatures);
+  const sourceFeatures = hasFeatures ? mergedFeatures : undefined;
+  const deviceType = getDeviceType(sourceFeatures);
+  const verify = normalizeVerify(sourceFeatures, onekeyFeatures);
+
+  return {
+    protocol,
+    sources,
+    deviceType,
+    firmwareType: getFirmwareType(sourceFeatures),
+    deviceId: sourceFeatures?.device_id || safeGetDeviceUUID(sourceFeatures),
+    serialNo: safeGetDeviceUUID(sourceFeatures),
+    label: getDeviceLabel(sourceFeatures),
+    bleName: getDeviceBleName(sourceFeatures),
+    status: normalizeStatus(protocol, sourceFeatures),
+    versions: normalizeVersions(sourceFeatures, onekeyFeatures),
+    ...(shouldIncludeVerify(scope) ? { verify } : {}),
+    ...(includeRaw
+      ? {
+          raw: normalizeRaw({
+            features,
+            onekeyFeatures,
+            protocolV2DeviceInfo,
+          }),
+        }
+      : {}),
+  };
+}

package/src/api/index.ts

@@ -2,6 +2,7 @@ export { default as testInitializeDeviceDuration } from './test/TestInitializeDe
 
 export { default as searchDevices } from './SearchDevices';
 export { default as getFeatures } from './GetFeatures';
+export { default as getDeviceInfo } from './GetDeviceInfo';
 export { default as getOnekeyFeatures } from './GetOnekeyFeatures';
 export { default as getPassphraseState } from './GetPassphraseState';
 export { default as getLogs } from './GetLogs';
@@ -52,6 +53,7 @@ export { default as factoryDeviceInfoSettings } from './protocol-v2/FactoryDevic
 export { default as factoryGetDeviceInfo } from './protocol-v2/FactoryGetDeviceInfo';
 export { default as filesystemFixPermission } from './protocol-v2/FilesystemFixPermission';
 export { default as filesystemFormat } from './protocol-v2/FilesystemFormat';
+export { default as filesystemDiskControl } from './protocol-v2/FilesystemDiskControl';
 export { default as fileRead } from './FileRead';
 export { default as fileWrite } from './FileWrite';
 export { default as fileDelete } from './FileDelete';

package/src/api/neo/NeoGetAddress.ts

@@ -5,6 +5,7 @@ import { UI_REQUEST } from '../../constants/ui-request';
 
 import type { NeoGetAddress as HardwareNeoGetAddress } from '@onekeyfe/hd-transport';
 import type { NeoAddress, NeoGetAddressParams } from '../../types/api/neoGetAddress';
+import type { DeviceFirmwareRange } from '../../types';
 
 export default class NeoGetAddress extends BaseMethod<HardwareNeoGetAddress[]> {
   hasBundle = false;
@@ -37,8 +38,12 @@ export default class NeoGetAddress extends BaseMethod<HardwareNeoGetAddress[]> {
     });
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       pro: {
         min: '4.12.0',
       },

package/src/api/neo/NeoSignTransaction.ts

@@ -5,6 +5,7 @@ import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 
 import type { NeoSignTx } from '@onekeyfe/hd-transport';
+import type { DeviceFirmwareRange } from '../../types';
 
 export default class NeoSignTransaction extends BaseMethod<NeoSignTx> {
   init() {
@@ -28,8 +29,12 @@ export default class NeoSignTransaction extends BaseMethod<NeoSignTx> {
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       pro: {
         min: '4.12.0',
       },

package/src/api/nervos/NervosGetAddress.ts

@@ -4,7 +4,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
 
 import type { NervosGetAddress as HardwareNervosGetAddress } from '@onekeyfe/hd-transport';
-import type { NervosAddress, NervosGetAddressParams } from '../../types';
+import type { DeviceFirmwareRange, NervosAddress, NervosGetAddressParams } from '../../types';
 
 export default class NervosGetAddress extends BaseMethod<HardwareNervosGetAddress[]> {
   hasBundle = false;
@@ -40,8 +40,12 @@ export default class NervosGetAddress extends BaseMethod<HardwareNervosGetAddres
     });
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_mini: {
         min: '3.7.0',
       },

package/src/api/nervos/NervosSignTransaction.ts

@@ -5,7 +5,7 @@ import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
 
-import type { NervosSignTransactionParams, NervosSignedTx } from '../../types';
+import type { DeviceFirmwareRange, NervosSignTransactionParams, NervosSignedTx } from '../../types';
 import type { NervosSignTx as HardwareNervosSignTx, TypedCall } from '@onekeyfe/hd-transport';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 
@@ -40,8 +40,12 @@ export default class NervosSignTransaction extends BaseMethod<NervosSignTx> {
     };
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_mini: {
         min: '3.7.0',
       },

package/src/api/nexa/NexaGetAddress.ts

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

package/src/api/nexa/NexaSignTransaction.ts

@@ -6,7 +6,7 @@ import { validateParams } from '../helpers/paramsValidator';
 
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
 import type { TypedCall } from '@onekeyfe/hd-transport';
-import type { NexaSignTransactionParams, NexaSignature } from '../../types';
+import type { DeviceFirmwareRange, NexaSignTransactionParams, NexaSignature } from '../../types';
 
 export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionParams> {
   hasBundle = false;
@@ -25,8 +25,12 @@ export default class NexaSignTransaction extends BaseMethod<NexaSignTransactionP
     this.params = payload;
   }
 
-  getVersionRange() {
+  getVersionRange(): DeviceFirmwareRange {
     return {
+      pro2: {
+        min: '0.0.0',
+        unsupported: true,
+      },
       model_mini: {
         min: '3.2.0',
       },

package/src/api/protocol-v2/DeviceFirmwareUpdate.ts

@@ -4,6 +4,8 @@ import {
   PROTOCOL_V2_FIRMWARE_UPDATE_RESPONSE_TYPES,
   normalizeFirmwareTargets,
 } from './helpers';
+import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
+import type { KnownDevice } from '../../types';
 
 import type { DeviceFirmwareUpdateParams } from './helpers';
 
@@ -27,7 +29,21 @@ export default class DeviceFirmwareUpdate extends BaseMethod<DeviceFirmwareUpdat
       {
         targets,
       },
-      PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS
+      {
+        ...PROTOCOL_V2_FIRMWARE_UPDATE_OPTIONS,
+        onIntermediateResponse: response => {
+          if (response.type !== 'DeviceFirmwareInstallProgress') return;
+          const progress = Number(response.message?.progress);
+          if (!Number.isFinite(progress)) return;
+          this.postMessage(
+            createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
+              device: this.device.toMessageObject() as KnownDevice,
+              progress: Math.min(Math.max(progress, 0), 100),
+              progressType: 'installingFirmware',
+            })
+          );
+        },
+      }
     );
     return Promise.resolve(res.message);
   }

package/src/api/protocol-v2/FilesystemDiskControl.ts

@@ -0,0 +1,34 @@
+import { BaseMethod } from '../BaseMethod';
+import {
+  validateNonNegativeInteger,
+  validateOptionalNonNegativeInteger,
+} from '../helpers/filesystemValidation';
+
+export type FilesystemDiskControlParams = {
+  enable?: number | string;
+  timeoutMs?: number | string;
+};
+
+export default class FilesystemDiskControl extends BaseMethod<FilesystemDiskControlParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = {
+      enable: validateNonNegativeInteger(this.payload.enable, 'enable', 0),
+      timeoutMs: validateOptionalNonNegativeInteger(this.payload.timeoutMs, 'timeoutMs'),
+    };
+  }
+
+  async run() {
+    const timeoutMs = Number(this.params.timeoutMs);
+    const res = await this.device.commands.typedCall(
+      'FilesystemDiskControl',
+      'Success',
+      {
+        enable: Number(this.params.enable ?? 0),
+      },
+      Number.isFinite(timeoutMs) && timeoutMs > 0 ? { timeoutMs } : undefined
+    );
+    return Promise.resolve(res.message);
+  }
+}