@onekeyfe/hd-core 1.2.0-alpha.13 → 1.2.0-alpha.131

package/src/api/device/DeviceUpdateBootloader.ts

@@ -5,16 +5,26 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { FirmwareUpdateTipMessage } from '../../events/ui-request';
 import { FirmwareUpdateBaseMethod } from '../firmware/FirmwareUpdateBaseMethod';
 import { getSysResourceBinary } from '../firmware/getBinary';
-import { updateBootloader } from '../firmware/uploadFirmware';
+import { updateBootloader, updateBootloaderFromSource } from '../firmware/uploadFirmware';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
-import { checkBootloaderLength } from '../firmware/updateBootloader';
-import { getFirmwareType } from '../../utils';
+import { checkBootloaderLength, checkBootloaderSourceLength } from '../firmware/updateBootloader';
+import { openFirmwareByteSource } from '../firmware/FirmwareArtifactSource';
+import { resolveFirmwareUpdateHostBinding } from '../firmware/FirmwareHostBinding';
+import {
+  assertFirmwareUpdatePreparedPlanBinding,
+  assertFirmwareUpdatePreparedPlanDeviceIdentity,
+  getFirmwareUpdatePreparedRawArtifact,
+  validateFirmwareUpdatePreparedPlan,
+} from '../firmware/FirmwareUpdatePreparedPlan';
+import { getDeviceType, getDeviceUUID } from '../../utils';
+import { resolveDeviceBootloaderMode } from '../../utils/deviceFeaturesCompat';
 
 import type { DeviceUpdateBootloaderParams } from '../../types/api/deviceUpdateBootloader';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Device } from '../../device/Device';
 import type { Features } from '../../types';
+import type { FirmwareByteSource } from '../firmware/FirmwareArtifactSource';
 
 export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any> {
   init() {
@@ -44,17 +54,68 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     return true;
   }
 
+  async updateBootloaderWithEmmcFileWriteFromSource(_device: Device, source: FirmwareByteSource) {
+    const filePath = '0:boot/bootloader.bin';
+
+    this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
+    await this.emmcCommonUpdateProcessFromSource({
+      source,
+      filePath,
+    });
+    this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
+    await this.reboot(RebootType.Normal);
+    this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloaderSuccess);
+    return true;
+  }
+
   async updateTouchBootloader({
     device,
     features,
     firmwareType,
+    binary: preparedBinary,
+    source: preparedSource,
   }: {
     device: Device;
     features?: Features;
     firmwareType: EFirmwareType;
+    binary?: ArrayBuffer;
+    source?: FirmwareByteSource;
   }) {
-    let { binary } = this.payload;
+    if (preparedSource) {
+      if (!(await checkBootloaderSourceLength(preparedSource))) {
+        throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
+      }
+      if (features && device.isBootloader()) {
+        this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
+        const result = await this.updateBootloaderWithEmmcFileWriteFromSource(
+          device,
+          preparedSource
+        );
+        return result;
+      }
+      if (features && !device.isBootloader()) {
+        await updateBootloaderFromSource(
+          this.device.getCommands().typedCall.bind(this.device.getCommands()),
+          this.postMessage,
+          device,
+          preparedSource
+        );
+        return true;
+      }
+    }
+
+    let binary = preparedBinary;
     if (!binary) {
+      if (DataManager.getSettings('firmwareManifestMode') === 'external-only') {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Bootloader must be prepared by the external firmware host',
+          {
+            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+            artifactName: 'bootloader',
+          }
+        );
+      }
       this.postTipMessage(FirmwareUpdateTipMessage.CheckLatestUiResource);
       const resourceUrl = features
         ? DataManager.getBootloaderResource(features, firmwareType)
@@ -69,7 +130,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
       }
     }
 
-    if (!checkBootloaderLength(binary)) {
+    if (!binary || !checkBootloaderLength(binary)) {
       throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
     }
 
@@ -77,7 +138,8 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     if (features && device.isBootloader()) {
       // Use emmcFileWrite + reboot logic for bootloader mode
       this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-      return this.updateBootloaderWithEmmcFileWrite(device, binary);
+      const result = await this.updateBootloaderWithEmmcFileWrite(device, binary);
+      return result;
     }
 
     if (features && !device.isBootloader()) {
@@ -97,13 +159,95 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     const { features } = device;
 
     const payload = this.payload as DeviceUpdateBootloaderParams;
+    const hasPreparedPlan = payload.preparedPlan !== undefined;
+    if (hasPreparedPlan && payload.binary !== undefined) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Prepared bootloader plans cannot be combined with a legacy binary'
+      );
+    }
+    if (!hasPreparedPlan && payload.artifact !== undefined) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        'Bootloader artifacts require a prepared plan'
+      );
+    }
+    const preparedPlan = hasPreparedPlan
+      ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
+      : undefined;
+    const plannedArtifact = preparedPlan
+      ? getFirmwareUpdatePreparedRawArtifact({
+          preparedPlan,
+          target: 'bootloader',
+          role: 'bootloader',
+        }).artifact
+      : undefined;
+    const artifactReader = preparedPlan
+      ? resolveFirmwareUpdateHostBinding(
+          payload.hostBindingGeneration,
+          preparedPlan.preparedPlanDigest
+        ).artifactReader
+      : payload.artifactReader;
+    const executionParams = {
+      ...payload,
+      artifactReader,
+    };
+    if (preparedPlan && plannedArtifact) {
+      assertFirmwareUpdatePreparedPlanDeviceIdentity({
+        preparedPlan,
+        deviceIdentity: getDeviceUUID(features) || undefined,
+        bootloaderMode: resolveDeviceBootloaderMode(features),
+        deviceModel: String(getDeviceType(features)),
+      });
+      assertFirmwareUpdatePreparedPlanBinding({
+        preparedPlan,
+        executor: 'v2',
+        scopeTargets: ['bootloader'],
+        bindings: [
+          {
+            target: 'bootloader',
+            artifact: payload.artifact ?? plannedArtifact,
+          },
+        ],
+      });
+      const source = await openFirmwareByteSource({
+        artifact: plannedArtifact,
+        reader: executionParams.artifactReader,
+      });
+      if (!source) {
+        throw ERRORS.TypedError(
+          HardwareErrorCode.RuntimeError,
+          'Bootloader artifact is not prepared'
+        );
+      }
+      try {
+        const deviceType = device.getCurrentDeviceType();
+        if (DeviceModelToTypes.model_touch.includes(deviceType)) {
+          return await this.updateTouchBootloader({
+            device,
+            features,
+            firmwareType: preparedPlan.firmwareType,
+            source,
+          });
+        }
+        return true;
+      } finally {
+        await source.close().catch(() => undefined);
+      }
+    }
 
+    const { binary } = payload;
     const deviceType = device.getCurrentDeviceType();
-    const deviceFirmwareType = getFirmwareType(features);
+    const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-      return this.updateTouchBootloader({ device, features, firmwareType });
+      return this.updateTouchBootloader({
+        device,
+        features,
+        firmwareType,
+        binary,
+      });
     }
 
     return Promise.resolve(true);

package/src/api/device/DeviceWipe.ts

@@ -1,14 +1,39 @@
+import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
+
 import { BaseMethod } from '../BaseMethod';
 
 import type { WipeDevice } from '@onekeyfe/hd-transport';
 
 export default class DeviceWipe extends BaseMethod<WipeDevice> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
+    this.unlockPolicy = 'unlock-before-run';
     this.useDevicePassphraseState = false;
+    this.protocolV2UiInteraction = {
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'device-management',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      page: DeviceSettingsPage.DeviceReset,
+      operation: 'wipe-device',
+    };
   }
 
   async run() {
+    if (this.device.isProtocolV2()) {
+      const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
+        page: DeviceSettingsPage.DeviceReset,
+      });
+      this.device.invalidateAfterWipe();
+      return Promise.resolve(res.message);
+    }
+
     const res = await this.device.commands.typedCall('WipeDevice', 'Success');
+    this.device.invalidateAfterWipe();
 
     return Promise.resolve(res.message);
   }

package/src/api/device/PreInitialize.ts

@@ -18,6 +18,10 @@ const parseInitOptions = (payload?: {
 });
 
 export default class PreInitialize extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;

package/src/api/dynex/DnxGetAddress.ts

@@ -1,5 +1,3 @@
-import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
-
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
@@ -49,10 +47,6 @@ export default class DnxGetAddress extends BaseMethod<HardwareDnxGetAddress[]> {
   }
 
   async run() {
-    if (this.device.isProtocolV2()) {
-      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
-    }
-
     const responses: DnxAddress[] = [];
 
     for (let i = 0; i < this.params.length; i++) {

package/src/api/dynex/DnxSignTransaction.ts

@@ -1,5 +1,3 @@
-import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
-
 import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
@@ -118,10 +116,6 @@ export default class DnxSignTransaction extends BaseMethod<DnxSignTx> {
   }
 
   async run() {
-    if (this.device.isProtocolV2()) {
-      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
-    }
-
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
 
     const res = await this.device.commands.typedCall('DnxSignTx', 'DnxInputRequest', {

package/src/api/evm/EVMGetAddress.ts

@@ -2,14 +2,18 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
-import TransportManager from '../../data-manager/TransportManager';
 import getAddressLegacyV1 from './legacyV1/getAddress';
 import getAddress from './latest/getAddress';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 
 import type { EVMAddress, EVMGetAddressParams } from '../../types';
 import type { EthereumGetAddressOneKey } from '@onekeyfe/hd-transport';
 
 export default class EvmGetAddress extends BaseMethod<EthereumGetAddressOneKey[]> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   init() {
@@ -44,7 +48,7 @@ export default class EvmGetAddress extends BaseMethod<EthereumGetAddressOneKey[]
   }
 
   async getEvmAddress(param: EthereumGetAddressOneKey) {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
       return getAddressLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         param,

package/src/api/evm/EVMGetPublicKey.ts

@@ -2,15 +2,19 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { serializedPath, validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
-import TransportManager from '../../data-manager/TransportManager';
 import getPublicKey from './latest/getPublicKey';
 import getPublicKeyLegacyV1 from './legacyV1/getPublicKey';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 import { batchGetPublickeys, supportBatchPublicKeyByDevice } from '../helpers/batchGetPublickeys';
 
 import type { EVMGetPublicKeyParams, EVMPublicKey } from '../../types';
 import type { EthereumGetPublicKey, EthereumGetPublicKeyOneKey } from '@onekeyfe/hd-transport';
 
 export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneKey[]> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   hasBundle = false;
 
   confirmShowOnOneKey = false;
@@ -56,7 +60,7 @@ export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneK
   }
 
   getEvmPublicKey(param: EthereumGetPublicKey) {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
       return getPublicKeyLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         param,

package/src/api/evm/EVMSignMessage.ts

@@ -3,13 +3,17 @@ import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
-import TransportManager from '../../data-manager/TransportManager';
 import signMessage from './latest/signMessage';
 import signMessageLegacyV1 from './legacyV1/signMessage';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 
 import type { EthereumSignMessageOneKey } from '@onekeyfe/hd-transport';
 
 export default class EVMSignMessage extends BaseMethod<EthereumSignMessageOneKey> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
@@ -36,7 +40,7 @@ export default class EVMSignMessage extends BaseMethod<EthereumSignMessageOneKey
   }
 
   async run() {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
       return signMessageLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         params: this.params,

package/src/api/evm/EVMSignMessageEIP712.ts

@@ -35,10 +35,6 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EthereumSignMessage
 
   getVersionRange(): DeviceFirmwareRange {
     return {
-      pro2: {
-        min: '0.0.0',
-        unsupported: true,
-      },
       model_mini: {
         min: '2.1.9',
       },
@@ -49,13 +45,7 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EthereumSignMessage
   }
 
   async run() {
-    this.checkFeatureVersionLimit(
-      () => true,
-      () => this.getVersionRange(),
-      {
-        strictCheckDeviceSupport: true,
-      }
-    );
+    this.assertProtocolSupported(this.device.getProtocol(), this.device.getCurrentFirmwareType());
 
     const res = await this.device.commands.typedCall(
       'EthereumSignMessageEIP712',

package/src/api/evm/EVMSignTransaction.ts

@@ -5,9 +5,9 @@ import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
-import TransportManager from '../../data-manager/TransportManager';
 import { signTransaction } from './latest/signTransaction';
 import { signTransaction as signTransactionLegacyV1 } from './legacyV1/signTransaction';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 
 import type {
   EVMSignTransactionParams,
@@ -18,6 +18,10 @@ import type {
 import type { SchemaParam } from '../helpers/paramsValidator';
 
 export default class EVMSignTransaction extends BaseMethod {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   addressN: number[] = [];
 
   isEIP1559 = false;
@@ -122,7 +126,7 @@ export default class EVMSignTransaction extends BaseMethod {
 
     if (formattedTx == null) throw ERRORS.TypedError('Runtime', 'formattedTx is not set');
 
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
       return signTransactionLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         addressN,

package/src/api/evm/EVMSignTypedData.ts

@@ -15,8 +15,8 @@ import {
   type EthereumSignTypedDataMessage,
   type EthereumSignTypedDataTypes,
 } from '../../types';
-import TransportManager from '../../data-manager/TransportManager';
 import { signTypedHash as signTypedHashLegacyV1 } from './legacyV1/signTypedHash';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 import { signTypedHash } from './latest/signTypedHash';
 import { signTypedData as signTypedDataLegacyV1 } from './legacyV1/signTypedData';
 import { signTypedData } from './latest/signTypedData';
@@ -32,9 +32,8 @@ import type {
 } from '@onekeyfe/hd-transport';
 
 /**
- * EthereumTypedDataStructAckOneKey 与 EthereumTypedDataStructAck 的字段结构与
- * 枚举数值完全一致（生成产物的 OneKey/Trezor 双份消息），仅枚举名义类型不同；
- * 这里做无运行时成本的名义转换，避免在调用点散落 any。
+ * EthereumTypedDataStructAckOneKey and EthereumTypedDataStructAck have identical
+ * fields and enum values. This zero-cost nominal conversion avoids scattered `any`.
  */
 const toOneKeyStructAck = (ack: EthereumTypedDataStructAck): EthereumTypedDataStructAckOneKey =>
   ack as unknown as EthereumTypedDataStructAckOneKey;
@@ -57,6 +56,10 @@ const MINI_MAX_ARRAY_TYPE_FIELDS = 24;
 const MINI_MAX_ARRAY_ELEMENTS = 24;
 
 export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
@@ -227,8 +230,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
     if (response.type === 'EthereumGnosisSafeTxRequest') {
       const { data } = this.params;
       const verifyingContract = data.domain?.verifyingContract;
-      // EthereumGnosisSafeTxAck.verifyingContract 在 proto 中是 required 字段，
-      // Gnosis Safe 签名缺少 verifyingContract 没有意义，这里给出明确的参数错误。
+      // verifyingContract is required by proto and essential to a Gnosis Safe signature.
       if (!verifyingContract) {
         throw ERRORS.TypedError(
           HardwareErrorCode.CallMethodInvalidParameter,
@@ -276,29 +278,23 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     let supportTrezor = false;
     let response: MessageResponse<MessageKey>;
-    switch (TransportManager.getProtocolV1MessageSchema()) {
-      case 'v1LegacySchema':
-        supportTrezor = true;
-        response = await signTypedDataLegacyV1({
-          typedCall: this.device.commands.typedCall.bind(this.device.commands),
-          addressN,
-          data,
-          metamaskV4Compat,
-          chainId,
-        });
-        break;
-
-      case 'v1CurrentSchema':
-      default:
-        supportTrezor = false;
-        response = await signTypedData({
-          typedCall: this.device.commands.typedCall.bind(this.device.commands),
-          addressN,
-          data,
-          metamaskV4Compat,
-          chainId,
-        });
-        break;
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
+      supportTrezor = true;
+      response = await signTypedDataLegacyV1({
+        typedCall: this.device.commands.typedCall.bind(this.device.commands),
+        addressN,
+        data,
+        metamaskV4Compat,
+        chainId,
+      });
+    } else {
+      response = await signTypedData({
+        typedCall: this.device.commands.typedCall.bind(this.device.commands),
+        addressN,
+        data,
+        metamaskV4Compat,
+        chainId,
+      });
     }
 
     return this.handleSignTypedData({
@@ -324,28 +320,24 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
   }) {
     if (!domainHash) throw ERRORS.TypedError('Runtime', 'domainHash is required');
 
-    switch (TransportManager.getProtocolV1MessageSchema()) {
-      case 'v1LegacySchema':
-        return signTypedHashLegacyV1({
-          typedCall,
-          addressN,
-          domainHash,
-          messageHash,
-          chainId,
-          device: this.device,
-        });
-
-      case 'v1CurrentSchema':
-      default:
-        return signTypedHash({
-          typedCall,
-          addressN,
-          domainHash,
-          messageHash,
-          chainId,
-          device: this.device,
-        });
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
+      return signTypedHashLegacyV1({
+        typedCall,
+        addressN,
+        domainHash,
+        messageHash,
+        chainId,
+        device: this.device,
+      });
     }
+    return signTypedHash({
+      typedCall,
+      addressN,
+      domainHash,
+      messageHash,
+      chainId,
+      device: this.device,
+    });
   }
 
   getVersionRange() {

package/src/api/evm/EVMVerifyMessage.ts

@@ -2,13 +2,17 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex } from '../helpers/hexUtils';
-import TransportManager from '../../data-manager/TransportManager';
 import verifyMessageLegacyV1 from './legacyV1/verifyMessage';
 import verifyMessage from './latest/verifyMessage';
+import { shouldUseLegacyV1EvmMessages } from './protocol';
 
 import type { EthereumVerifyMessageOneKey } from '@onekeyfe/hd-transport';
 
 export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessageOneKey> {
+  getSupportedProtocols() {
+    return ['V1', 'V2'] as const;
+  }
+
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
@@ -31,7 +35,7 @@ export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessageOneK
   }
 
   async run() {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (shouldUseLegacyV1EvmMessages(this.device)) {
       return verifyMessageLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         params: this.params,

package/src/api/evm/legacyV1/getAddress.ts

@@ -7,8 +7,8 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetAddressOneKey;
 }): Promise<MessageResponse<'EthereumAddress'>> {
-  // legacy EthereumGetAddress 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: param.address_n,
     show_display: param.show_display,

package/src/api/evm/legacyV1/getPublicKey.ts

@@ -11,8 +11,8 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetPublicKeyOneKey;
 }): Promise<MessageResponse<'EthereumPublicKey'>> {
-  // legacy EthereumGetPublicKey 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: param.address_n,
     show_display: param.show_display,

package/src/api/evm/legacyV1/signMessage.ts

@@ -11,8 +11,8 @@ export default async function ({
   typedCall: TypedCall;
   params: EthereumSignMessageOneKey;
 }): Promise<EthereumMessageSignature> {
-  // legacy EthereumSignMessage 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: params.address_n,
     message: params.message,

package/src/api/evm/legacyV1/signTypedData.ts

@@ -16,8 +16,8 @@ export const signTypedData = async ({
 }) => {
   const { primaryType }: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> = data;
 
-  // legacy EthereumSignTypedData 的生成类型没有 chain_id 字段，但旧固件按 OneKey 扩展
-  // 接受该字段；通过预先声明的对象（非 fresh literal）携带额外字段，保持原有运行时行为。
+  // The generated legacy type omits chain_id, but old firmware accepts the OneKey
+  // extension. A non-fresh object preserves that runtime field without a type cast.
   const message = {
     address_n: addressN,
     primary_type: primaryType as string,