@onekeyfe/hd-core 1.1.34-alpha.3 → 1.1.34-alpha.4

package/src/api/evm/EVMGetAddress.ts

@@ -44,7 +44,7 @@ export default class EvmGetAddress extends BaseMethod<EthereumGetAddressOneKey[]
   }
 
   async getEvmAddress(param: EthereumGetAddressOneKey) {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (TransportManager.getMessageVersion() === 'v1') {
       return getAddressLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         param,

package/src/api/evm/EVMGetPublicKey.ts

@@ -2,10 +2,11 @@ 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 TransportManager from '../../data-manager/TransportManager';
 import getPublicKey from './latest/getPublicKey';
 import getPublicKeyLegacyV1 from './legacyV1/getPublicKey';
-import { batchGetPublickeys, supportBatchPublicKeyByDevice } from '../helpers/batchGetPublickeys';
+import { batchGetPublickeys } from '../helpers/batchGetPublickeys';
 
 import type { EVMGetPublicKeyParams, EVMPublicKey } from '../../types';
 import type { EthereumGetPublicKey, EthereumGetPublicKeyOneKey } from '@onekeyfe/hd-transport';
@@ -56,7 +57,7 @@ export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneK
   }
 
   getEvmPublicKey(param: EthereumGetPublicKey) {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (TransportManager.getMessageVersion() === 'v1') {
       return getPublicKeyLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         param,
@@ -72,7 +73,7 @@ export default class EVMGetPublicKey extends BaseMethod<EthereumGetPublicKeyOneK
   async run() {
     const responses: EVMPublicKey[] = [];
 
-    if (this.useBatch && supportBatchPublicKeyByDevice(this.device)) {
+    if (this.useBatch && supportBatchPublicKey(this.device?.features)) {
       try {
         const res = await batchGetPublickeys(this.device, this.params, 'secp256k1', 60, {
           includeNode: false,

package/src/api/evm/EVMSignMessage.ts

@@ -36,7 +36,7 @@ export default class EVMSignMessage extends BaseMethod<EthereumSignMessageOneKey
   }
 
   async run() {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (TransportManager.getMessageVersion() === 'v1') {
       return signMessageLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         params: this.params,

package/src/api/evm/EVMSignMessageEIP712.ts

@@ -5,7 +5,6 @@ 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.
@@ -33,12 +32,8 @@ export default class EVMSignMessageEIP712 extends BaseMethod<EthereumSignMessage
     };
   }
 
-  getVersionRange(): DeviceFirmwareRange {
+  getVersionRange() {
     return {
-      pro2: {
-        min: '0.0.0',
-        unsupported: true,
-      },
       model_mini: {
         min: '2.1.9',
       },
@@ -49,14 +44,6 @@ 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/evm/EVMSignTransaction.ts

@@ -122,7 +122,7 @@ export default class EVMSignTransaction extends BaseMethod {
 
     if (formattedTx == null) throw ERRORS.TypedError('Runtime', 'formattedTx is not set');
 
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (TransportManager.getMessageVersion() === 'v1') {
       return signTransactionLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         addressN,

package/src/api/evm/EVMSignTypedData.ts

@@ -9,6 +9,7 @@ import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { formatAnyHex, parseChainId, stripHexStartZeroes } from '../helpers/hexUtils';
+import { getDeviceFirmwareVersion, getDeviceType } from '../../utils';
 import { existCapability } from '../../utils/capabilitieUtils';
 import {
   DeviceModelToTypes,
@@ -25,19 +26,11 @@ import { encodeData, getFieldType, parseArrayType } from '../helpers/typeNameUti
 import type {
   EthereumTypedDataSignature,
   EthereumTypedDataStructAck,
-  EthereumTypedDataStructAckOneKey,
   MessageKey,
   MessageResponse,
   TypedCall,
 } from '@onekeyfe/hd-transport';
 
-/**
- * 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;
-
 export type EVMSignTypedDataParams = {
   addressN: number[];
   metamaskV4Compat: boolean;
@@ -137,6 +130,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
       if (supportTrezor) {
         response = await typedCall(
           'EthereumTypedDataStructAck',
+          // @ts-ignore
           [
             'EthereumTypedDataStructRequest',
             'EthereumTypedDataValueRequest',
@@ -147,12 +141,13 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
       } else {
         response = await typedCall(
           'EthereumTypedDataStructAckOneKey',
+          // @ts-ignore
           [
             'EthereumTypedDataStructRequestOneKey',
             'EthereumTypedDataValueRequestOneKey',
             'EthereumTypedDataSignatureOneKey',
           ],
-          toOneKeyStructAck(dataStruckAck)
+          dataStruckAck
         );
       }
     }
@@ -188,7 +183,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
         } else if (typeof memberData === 'object' && memberData !== null) {
           const memberTypeDefinition = types[memberTypeName][index];
           memberTypeName = memberTypeDefinition.type;
-          memberData = (memberData as Record<string, unknown>)[memberTypeDefinition.name];
+          memberData = memberData[memberTypeDefinition.name];
         } else {
           // TODO
         }
@@ -225,14 +220,6 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     if (response.type === 'EthereumGnosisSafeTxRequest') {
       const { data } = this.params;
-      const verifyingContract = data.domain?.verifyingContract;
-      // verifyingContract is required by proto and essential to a Gnosis Safe signature.
-      if (!verifyingContract) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.CallMethodInvalidParameter,
-          'EIP712Domain.verifyingContract is required for Gnosis Safe transaction'
-        );
-      }
       const param = {
         to: data.message.to,
         value: formatAnyHex(new BigNumber(data.message.value).toString(16)),
@@ -245,10 +232,11 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
         refundReceiver: data.message.refundReceiver,
         nonce: formatAnyHex(new BigNumber(data.message.nonce).toString(16)),
         chain_id: parseChainId(data.domain.chainId),
-        verifyingContract,
+        verifyingContract: data.domain.verifyingContract,
       };
       response = await typedCall(
         'EthereumGnosisSafeTxAck',
+        // @ts-ignore
         ['EthereumTypedDataSignature', 'EthereumTypedDataSignatureOneKey'],
         param
       );
@@ -274,8 +262,8 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     let supportTrezor = false;
     let response: MessageResponse<MessageKey>;
-    switch (TransportManager.getProtocolV1MessageSchema()) {
-      case 'v1LegacySchema':
+    switch (TransportManager.getMessageVersion()) {
+      case 'v1':
         supportTrezor = true;
         response = await signTypedDataLegacyV1({
           typedCall: this.device.commands.typedCall.bind(this.device.commands),
@@ -286,7 +274,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
         });
         break;
 
-      case 'v1CurrentSchema':
+      case 'latest':
       default:
         supportTrezor = false;
         response = await signTypedData({
@@ -322,8 +310,8 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
   }) {
     if (!domainHash) throw ERRORS.TypedError('Runtime', 'domainHash is required');
 
-    switch (TransportManager.getProtocolV1MessageSchema()) {
-      case 'v1LegacySchema':
+    switch (TransportManager.getMessageVersion()) {
+      case 'v1':
         return signTypedHashLegacyV1({
           typedCall,
           addressN,
@@ -333,7 +321,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
           device: this.device,
         });
 
-      case 'v1CurrentSchema':
+      case 'latest':
       default:
         return signTypedHash({
           typedCall,
@@ -360,8 +348,8 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     let biggerLimit = 1024; // 1k
 
-    const currentVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
-    const currentDeviceType = this.device.getCurrentDeviceType();
+    const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+    const currentDeviceType = getDeviceType(this.device.features);
     const supportBiggerDataVersion = '4.4.0';
 
     const supportBiggerData =
@@ -544,9 +532,9 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
   }
 
   supportSignTyped() {
-    const deviceType = this.device.getCurrentDeviceType();
+    const deviceType = getDeviceType(this.device.features);
     if (DeviceModelToTypes.model_mini.includes(deviceType)) {
-      const currentVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
+      const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
       const supportSignTypedVersion = '2.2.0';
 
       if (semver.lt(currentVersion, supportSignTypedVersion)) {
@@ -576,7 +564,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
     // For Classic / Mini:
     // - If parsed typed-data capability is missing, keep using blind-sign.
     // - For Mini with parsed capability, add extra format checks before parsed signing.
-    const deviceType = this.device.getCurrentDeviceType();
+    const deviceType = getDeviceType(this.device.features);
     if (
       DeviceModelToTypes.model_mini.includes(deviceType) &&
       (!supportEip712OnClassic || this.hasClassicFamilyTypedDataFormatViolations(this.params.data))

package/src/api/evm/EVMVerifyMessage.ts

@@ -31,7 +31,7 @@ export default class EVMSignMessage extends BaseMethod<EthereumVerifyMessageOneK
   }
 
   async run() {
-    if (TransportManager.getProtocolV1MessageSchema() === 'v1LegacySchema') {
+    if (TransportManager.getMessageVersion() === 'v1') {
       return verifyMessageLegacyV1({
         typedCall: this.device.commands.typedCall.bind(this.device.commands),
         params: this.params,

package/src/api/evm/latest/signTypedHash.ts

@@ -1,6 +1,8 @@
 import semver from 'semver';
 import { EDeviceType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
+import { getDeviceFirmwareVersion, getDeviceType } from '../../../utils';
+
 import type { Device } from '../../../device/Device';
 import type { MessageResponse, TypedCall } from '@onekeyfe/hd-transport';
 
@@ -19,10 +21,10 @@ export const signTypedHash = async ({
   domainHash: string;
   messageHash: string | undefined;
 }): Promise<MessageResponse<'EthereumTypedDataSignatureOneKey'>> => {
-  const deviceType = device.getCurrentDeviceType();
+  const deviceType = getDeviceType(device.features);
   if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
     // Touch Pro Sign NestedArrays
-    const currentVersion = device.getCurrentFirmwareVersionString() ?? '0.0.0';
+    const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
     const supportNestedArraysSignVersion = '4.2.0';
 
     // 4.2.0 is the first version that supports nested arrays in signTypedData

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

@@ -7,12 +7,10 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetAddressOneKey;
 }): Promise<MessageResponse<'EthereumAddress'>> {
-  // 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 = {
+  return typedCall('EthereumGetAddress', 'EthereumAddress', {
     address_n: param.address_n,
     show_display: param.show_display,
+    // @ts-ignore
     chain_id: param.chain_id,
-  };
-  return typedCall('EthereumGetAddress', 'EthereumAddress', message);
+  });
 }

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

@@ -11,12 +11,10 @@ export default async function ({
   typedCall: TypedCall;
   param: EthereumGetPublicKeyOneKey;
 }): Promise<MessageResponse<'EthereumPublicKey'>> {
-  // 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 = {
+  return typedCall('EthereumGetPublicKey', 'EthereumPublicKey', {
     address_n: param.address_n,
     show_display: param.show_display,
+    // @ts-ignore
     chain_id: param.chain_id,
-  };
-  return typedCall('EthereumGetPublicKey', 'EthereumPublicKey', message);
+  });
 }

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

@@ -11,14 +11,12 @@ export default async function ({
   typedCall: TypedCall;
   params: EthereumSignMessageOneKey;
 }): Promise<EthereumMessageSignature> {
-  // 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 = {
+  const res = await typedCall('EthereumSignMessage', 'EthereumMessageSignature', {
     address_n: params.address_n,
     message: params.message,
+    // @ts-ignore
     chain_id: params.chain_id,
-  };
-  const res = await typedCall('EthereumSignMessage', 'EthereumMessageSignature', message);
+  });
 
   return Promise.resolve(res.message);
 }

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

@@ -16,23 +16,22 @@ export const signTypedData = async ({
 }) => {
   const { primaryType }: EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> = data;
 
-  // 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,
-    metamask_v4_compat: metamaskV4Compat,
-    chain_id: chainId,
-  };
   const response = await typedCall(
     'EthereumSignTypedData',
+    // @ts-ignore
     [
       'EthereumTypedDataStructRequest',
       'EthereumTypedDataValueRequest',
       'EthereumTypedDataSignature',
       'EthereumGnosisSafeTxRequest',
     ],
-    message
+    {
+      address_n: addressN,
+      primary_type: primaryType as string,
+      metamask_v4_compat: metamaskV4Compat,
+      // @ts-ignore
+      chain_id: chainId,
+    }
   );
   return response;
 };

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

@@ -1,6 +1,8 @@
 import semver from 'semver';
 import { EDeviceType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
+import { getDeviceFirmwareVersion, getDeviceType } from '../../../utils';
+
 import type { Device } from '../../../device/Device';
 import type { MessageResponse, TypedCall } from '@onekeyfe/hd-transport';
 
@@ -22,10 +24,10 @@ export const signTypedHash = async ({
   | MessageResponse<'EthereumTypedDataSignature'>
   | MessageResponse<'EthereumTypedDataSignatureOneKey'>
 > => {
-  const deviceType = device.getCurrentDeviceType();
+  const deviceType = getDeviceType(device.features);
   if (deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro) {
     // Touch Pro Sign NestedArrays
-    const currentVersion = device.getCurrentFirmwareVersionString() ?? '0.0.0';
+    const currentVersion = getDeviceFirmwareVersion(device.features).join('.');
     const supportNestedArraysSignVersion = '4.2.0';
 
     // 4.2.0 is the first version that supports nested arrays in signTypedData
@@ -38,13 +40,11 @@ export const signTypedHash = async ({
     }
   }
 
-  // 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 = {
+  return typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', {
     address_n: addressN,
     domain_separator_hash: domainHash ?? '',
     message_hash: messageHash,
+    // @ts-ignore
     chain_id: chainId,
-  };
-  return typedCall('EthereumSignTypedHash', 'EthereumTypedDataSignature', message);
+  });
 };

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

@@ -7,15 +7,13 @@ export default async function ({
   typedCall: TypedCall;
   params: EthereumVerifyMessageOneKey;
 }): Promise<Success> {
-  // 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 = {
+  const res = await typedCall('EthereumVerifyMessage', 'Success', {
     signature: params.signature,
     message: params.message,
     address: params.address,
+    // @ts-ignore
     chain_id: params.chain_id,
-  };
-  const res = await typedCall('EthereumVerifyMessage', 'Success', message);
+  });
 
   return Promise.resolve(res.message);
 }

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -8,15 +8,12 @@ import {
 
 import { FirmwareUpdateTipMessage, UI_REQUEST, createUiMessage } from '../../events/ui-request';
 import { DevicePool } from '../../device/DevicePool';
-import { LoggerNames, getLogger, wait } from '../../utils';
+import { LoggerNames, getDeviceType, getDeviceUUID, getLogger, wait } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
 import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
-import { createFirmwareProgressThrottle } from './progressThrottle';
-import { writeFirmwareByteSource } from './FirmwareArtifactSource';
 
-import type { FirmwareCheckpointWriter } from './FirmwareCheckpoint';
 import type {
   IFirmwareUpdateProgressType,
   IFirmwareUpdateTipMessage,
@@ -26,7 +23,6 @@ import type { RebootType } from '@onekeyfe/hd-transport';
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { KnownDevice } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
@@ -44,8 +40,6 @@ const isDeviceDisconnectedError = (error: unknown) => {
 export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
   checkPromise: Deferred<any> | null = null;
 
-  private shouldPostFirmwareProgress = createFirmwareProgressThrottle();
-
   init(): void {}
 
   run(): Promise<any> {
@@ -89,10 +83,6 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
    * @param progress Post the percentage of the progress
    */
   postProgressMessage = (progress: number, progressType: IFirmwareUpdateProgressType) => {
-    if (!this.shouldPostFirmwareProgress(progress, progressType)) {
-      return;
-    }
-
     this.postMessage(
       createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
         device: this.device.toMessageObject() as KnownDevice,
@@ -148,14 +138,12 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     // check device goto bootloader mode
     let isFirstCheck = true;
     let checkCount = 0;
-    let hasPromptedWebDevice = false;
-    let isPromptingWebDevice = false;
     // eslint-disable-next-line prefer-const
     let timeoutTimer: ReturnType<typeof setTimeout> | undefined;
 
     const isTouchOrProDevice =
-      this?.device?.getCurrentDeviceType() === EDeviceType.Touch ||
-      this?.device?.getCurrentDeviceType() === EDeviceType.Pro;
+      getDeviceType(this?.device?.features) === EDeviceType.Touch ||
+      getDeviceType(this?.device?.features) === EDeviceType.Pro;
 
     const intervalTimer: ReturnType<typeof setInterval> | undefined = setInterval(
       async () => {
@@ -170,28 +158,23 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
         if (
           checkCount > 4 &&
           DataManager.isBrowserWebUsb(DataManager.getSettings('env')) &&
-          !this.payload.skipWebDevicePrompt &&
-          !hasPromptedWebDevice &&
-          !isPromptingWebDevice
+          !this.payload.skipWebDevicePrompt
         ) {
-          isPromptingWebDevice = true;
+          clearInterval(intervalTimer);
+          clearTimeout(timeoutTimer);
+
           try {
             this.postTipMessage(FirmwareUpdateTipMessage.SelectDeviceInBootloaderForWebDevice);
             const confirmed = await this._promptDeviceInBootloaderForWebDevice();
-            hasPromptedWebDevice = true;
             if (confirmed) {
               await this._checkDeviceInBootloaderMode(connectId, intervalTimer, timeoutTimer);
             }
           } catch (e) {
-            clearInterval(intervalTimer);
-            clearTimeout(timeoutTimer);
             Log.log(
               'FirmwareUpdateBaseMethod [checkDeviceToBootloader] _promptDeviceInBootloaderForWebDevice failed: ',
               e
             );
             this.checkPromise?.reject(e);
-          } finally {
-            isPromptingWebDevice = false;
           }
           return;
         }
@@ -204,7 +187,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
               true
             );
             await this.device.initialize();
-            if (this.device.isBootloader()) {
+            if (this.device.features?.bootloader_mode) {
               clearInterval(intervalTimer);
               this.checkPromise?.resolve(true);
             }
@@ -237,7 +220,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     const devicesDescriptor = deviceDiff?.descriptors ?? [];
     const { deviceList } = await DevicePool.getDevices(devicesDescriptor, connectId);
 
-    if (deviceList.length === 1 && deviceList[0]?.isBootloader()) {
+    if (deviceList.length === 1 && deviceList[0]?.features?.bootloader_mode) {
       // should update current device from cache
       // because device was reboot and had some new requests
       this.device.updateFromCache(deviceList[0]);
@@ -251,17 +234,14 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     return false;
   }
 
-  async enterBootloaderMode(checkpointWriter?: FirmwareCheckpointWriter) {
+  async enterBootloaderMode() {
     const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-    if (this.device.features && !this.device.isBootloader()) {
-      const serialNo = this.device.getCurrentSerialNo();
-      const deviceType = this.device.getCurrentDeviceType();
+    if (this.device.features && !this.device.features.bootloader_mode) {
+      const uuid = getDeviceUUID(this.device.features);
+      const deviceType = getDeviceType(this.device.features);
       // auto go to bootloader mode
       try {
         this.postTipMessage(FirmwareUpdateTipMessage.AutoRebootToBootloader);
-        await checkpointWriter?.commit({
-          stage: 'BEFORE_DEVICE_MODE_CHANGE',
-        });
         const bootRes = await typedCall('DeviceBackToBoot', 'Success');
         // @ts-expect-error
         if (bootRes.type === 'CallMethodError') {
@@ -272,7 +252,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
 
         // force clean classic device cache so that the device can initialize again
         if (DeviceModelToTypes.model_classic.includes(deviceType)) {
-          DevicePool.clearDeviceCache(serialNo);
+          DevicePool.clearDeviceCache(uuid);
         }
         delete DevicePool.devicesCache[''];
         await this.checkPromise?.promise;
@@ -393,54 +373,6 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
   }
 
-  async emmcCommonUpdateProcessFromSource({
-    source,
-    filePath,
-    processedSize,
-    totalSize,
-  }: {
-    source: FirmwareByteSource;
-    filePath: string;
-    processedSize?: number;
-    totalSize?: number;
-  }) {
-    if (!filePath.startsWith('0:')) {
-      throw new Error('filePath must start with 0:');
-    }
-    const env = DataManager.getSettings('env');
-    const chunkSize = 1024 * (DataManager.isBleConnect(env) ? 16 : 128);
-
-    await writeFirmwareByteSource({
-      source,
-      chunkSize,
-      write: async ({ data, sourceOffset, length, first }) => {
-        const progress =
-          totalSize !== undefined && processedSize !== undefined
-            ? Math.min(Math.ceil(((processedSize + sourceOffset + length) / totalSize) * 100), 99)
-            : Math.min(Math.ceil(((sourceOffset + length) / source.size) * 100), 99);
-        const writeRes = await this.emmcFileWriteWithRetry(
-          filePath,
-          length,
-          sourceOffset,
-          data,
-          first,
-          progress
-        );
-        if (!writeRes) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.EmmcFileWriteFirmwareError,
-            'transfer data error'
-          );
-        }
-        const processedBytes = Number(writeRes.message.processed_byte);
-        this.postProgressMessage(progress, 'transferData');
-        return Number.isFinite(processedBytes) ? processedBytes : length;
-      },
-    });
-
-    return totalSize !== undefined ? (processedSize ?? 0) + source.size : 0;
-  }
-
   async emmcFileWriteWithRetry(
     filePath: string,
     chunkLength: number,
@@ -504,7 +436,7 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
           const deviceDiff = await this.device.deviceConnector?.enumerate();
           const devicesDescriptor = deviceDiff?.descriptors ?? [];
           const { deviceList } = await DevicePool.getDevices(devicesDescriptor, undefined);
-          if (deviceList.length === 1 && deviceList[0]?.isBootloader()) {
+          if (deviceList.length === 1 && deviceList[0]?.features?.bootloader_mode) {
             this.device.updateFromCache(deviceList[0]);
             await this.device.acquire();
             this.device.getCommands().mainId = this.device.mainId ?? '';

package/src/api/firmware/bootloaderHelper.ts

@@ -1,7 +1,7 @@
 import semver from 'semver';
 import { EDeviceType } from '@onekeyfe/hd-shared';
 
-import { getDeviceBootloaderVersion, getDeviceType } from '../../utils';
+import { getDeviceType } from '../../utils';
 
 import type { Features, IVersionArray } from '../../types';
 
@@ -38,10 +38,9 @@ export function shouldUpdateBootloaderForClassicAndMini({
 export function isEnteredManuallyBoot(features: Features, updateType: string) {
   const deviceType = getDeviceType(features);
   const isMini = deviceType === EDeviceType.Mini;
-  const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
   const isBoot183ClassicUpBle =
     updateType === 'firmware' &&
     deviceType === EDeviceType.Classic &&
-    bootloaderVersion === '1.8.3';
+    features.bootloader_version === '1.8.3';
   return isMini || isBoot183ClassicUpBle;
 }