@onekeyfe/hd-core 1.1.27-alpha.4 → 1.1.27-alpha.41

package/src/api/GetDeviceInfo.ts

@@ -0,0 +1,161 @@
+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,
+  normalizeProtocolV2Features,
+} from '../protocols/protocol-v2';
+import { getDeviceType } from '../utils';
+import { fixVersion } from '../utils/deviceFeaturesUtils';
+import { buildUnifiedDeviceInfo } from './helpers/deviceInfo';
+import { BaseMethod } from './BaseMethod';
+
+import type {
+  DeviceInfoScope,
+  DeviceInfoSource,
+  GetDeviceInfoParams,
+} from '../types/api/getDeviceInfo';
+import type { Features, OnekeyFeatures } from '../types';
+import type { ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+
+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 shouldReadProtocolV2DeviceInfo(params: GetDeviceInfoParams) {
+  return (
+    params.refresh === true ||
+    params.includeRaw === true ||
+    params.scope === 'verify' ||
+    params.scope === 'full'
+  );
+}
+
+function getProtocolV2DeviceInfoRequest(params: GetDeviceInfoParams) {
+  if (params.scope === 'verify' || params.scope === 'full') {
+    return PROTOCOL_V2_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.originalDescriptor?.protocolType === 'V2') {
+      return this.runProtocolV2();
+    }
+    return this.runProtocolV1();
+  }
+
+  private async runProtocolV2() {
+    const sources: DeviceInfoSource[] = ['features'];
+    let { features } = this.device;
+    let protocolV2DeviceInfo: ProtocolV2DeviceInfo | undefined;
+
+    if (shouldReadProtocolV2DeviceInfo(this.params)) {
+      const { message } = await this.device.commands.typedCall(
+        'DeviceGetDeviceInfo',
+        'DeviceInfo',
+        getProtocolV2DeviceInfoRequest(this.params)
+      );
+      protocolV2DeviceInfo = message as unknown as ProtocolV2DeviceInfo;
+      features = normalizeProtocolV2Features(this.device.originalDescriptor, protocolV2DeviceInfo);
+      this.device._updateFeatures(features);
+      sources.push('deviceGetDeviceInfo');
+    }
+
+    return buildUnifiedDeviceInfo({
+      protocol: 'V2',
+      features,
+      protocolV2DeviceInfo,
+      sources,
+      scope: this.params.scope,
+      includeRaw: this.params.includeRaw,
+    });
+  }
+
+  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');
+    }
+
+    return buildUnifiedDeviceInfo({
+      protocol: 'V1',
+      features,
+      onekeyFeatures,
+      sources,
+      scope: this.params.scope,
+      includeRaw: this.params.includeRaw,
+    });
+  }
+}

package/src/api/GetOnekeyFeatures.ts

@@ -4,6 +4,76 @@ import { UI_REQUEST } from '../constants/ui-request';
 import { fixVersion } from '../utils/deviceFeaturesUtils';
 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 +86,12 @@ 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.originalDescriptor?.protocolType === 'V2') {
+      return Promise.resolve(pickOnekeyFeatures(this.device.features as OnekeyFeatures));
     }
+
+    const { message } = await this.device.commands.typedCall('OnekeyGetFeatures', 'OnekeyFeatures');
+    normalizeOnekeyFirmwareVersion(message);
     return Promise.resolve(message);
   }
 }

package/src/api/GetPassphraseState.ts

@@ -1,7 +1,8 @@
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { EDeviceType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
+import { getDeviceType } from '../utils/deviceInfoUtils';
 import { BaseMethod } from './BaseMethod';
 
 export default class GetPassphraseState extends BaseMethod {
@@ -14,15 +15,23 @@ export default class GetPassphraseState extends BaseMethod {
     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 isPro2 = getDeviceType(features) === EDeviceType.Pro2;
+    const passphraseProtection = features?.passphrase_protection ?? null;
 
     // refresh device info
-    if (features && features.passphrase_protection === true) {
-      return Promise.resolve(passphraseState);
-    }
-
-    return Promise.resolve(undefined);
+    return Promise.resolve({
+      passphrase_state: isPro2 || 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,25 @@
+import { BaseMethod } from './BaseMethod';
+import { validateNonEmptyString } from './helpers/filesystemValidation';
+
+export type PathInfoParams = {
+  path: string;
+};
+
+export default class PathInfo extends BaseMethod<PathInfoParams> {
+  init() {
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+    this.params = { path: validateNonEmptyString(this.payload.path, 'path') };
+  }
+
+  async run() {
+    const res = await this.device.commands.typedCall(
+      'FilesystemPathInfoQuery',
+      'FilesystemPathInfo',
+      {
+        path: this.params.path,
+      }
+    );
+    return Promise.resolve(res.message);
+  }
+}

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,12 +5,12 @@ 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() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     // check payload
     validateParams(this.payload, [
@@ -30,8 +30,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

@@ -11,14 +11,13 @@ import type {
   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> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     // check payload
     validateParams(this.payload, [
@@ -39,8 +38,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',
       },

package/src/api/algo/AlgoSignTransaction.ts

@@ -12,7 +12,6 @@ export default class AlgoSignTransaction extends BaseMethod<HardwareAlgorandSign
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode];
-    this.allowUsePreInitialize = true;
 
     // check payload
     validateParams(this.payload, [

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -12,7 +12,12 @@ 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 {
+  getDeviceFirmwareVersion,
+  getFirmwareType,
+  getMethodVersionRange,
+  isMethodVersionRangeUnsupported,
+} from '../../utils';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { onDeviceButtonHandler } from '../../core';
 import {
@@ -371,14 +376,6 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       this.device.on(DEVICE.PASSPHRASE, onSignalAbort);
 
       preCheckDeviceSupport(this.device, method);
-      if (this.temporarySafetyCheckPrompted) {
-        method.temporarySafetyCheckPrompted = true;
-      } else {
-        const appliedTemporarySafetyCheck = await method.checkSafetyLevelOnTestNet();
-        if (appliedTemporarySafetyCheck) {
-          this.temporarySafetyCheckPrompted = true;
-        }
-      }
 
       const response = await method.run();
 
@@ -469,6 +466,10 @@ function preCheckDeviceSupport(device: Device, method: BaseMethod) {
   );
   const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
 
+  if (isMethodVersionRangeUnsupported(versionRange)) {
+    throw ERRORS.createDeviceNotSupportMethodError(method.name, getFirmwareType(device.features));
+  }
+
   if (
     versionRange &&
     semver.valid(versionRange.min) &&
@@ -509,6 +510,14 @@ function handleSkippableHardwareError(
     );
     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/aptos/AptosSignInMessage.ts

@@ -10,7 +10,6 @@ export default class AptosSignInMessage extends BaseMethod<AptosSignSIWAMessage>
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     // check payload
     validateParams(this.payload, [

package/src/api/aptos/AptosSignMessage.ts

@@ -10,7 +10,6 @@ export default class AptosSignMessage extends BaseMethod<HardwareAptosSignMessag
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     // check payload
     validateParams(this.payload, [

package/src/api/aptos/AptosSignTransaction.ts

@@ -10,7 +10,6 @@ export default class AptosSignTransaction extends BaseMethod<HardwareAptosSignTx
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     // check payload
     validateParams(this.payload, [

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,12 +5,12 @@ 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() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     validateParams(this.payload, [
       { name: 'path', required: true },
@@ -26,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,12 +8,12 @@ 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() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     validateParams(this.payload, [
       { name: 'path', required: true },
@@ -33,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/BTCSignMessage.ts

@@ -12,7 +12,6 @@ export default class BTCSignMessage extends BaseMethod<SignMessage> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     validateParams(this.payload, [
       { name: 'path', required: true },

package/src/api/btc/BTCSignPsbt.ts

@@ -13,7 +13,6 @@ export default class BTCSignPsbt extends BaseMethod<SignPsbt> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     validateParams(this.payload, [
       { name: 'psbt', type: 'hexString', required: true },

package/src/api/btc/BTCSignTransaction.ts

@@ -29,7 +29,6 @@ export default class BTCSignTransaction extends BaseMethod<Params> {
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
-    this.allowUsePreInitialize = true;
 
     validateParams(this.payload, [
       { name: 'coin', type: 'string', required: true },

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',
       },