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

package/src/api/device/DeviceFullyUploadResource.ts

@@ -5,11 +5,12 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { BaseMethod } from '../BaseMethod';
 import { getSysResourceBinary } from '../firmware/getBinary';
 import { updateResources } from '../firmware/uploadFirmware';
+import { getDeviceFirmwareVersion, getDeviceType, getFirmwareType } from '../../utils';
 import { createUiMessage } from '../../events/ui-request';
 import { DataManager } from '../../data-manager';
 
 import type { Deferred } from '@onekeyfe/hd-shared';
-import type { KnownDevice } from '../../types';
+import type { Features, KnownDevice } from '../../types';
 import type { DeviceFullyUploadResourceParams } from '../../types/api/deviceFullyUploadResource';
 
 export default class DeviceFullyUploadResource extends BaseMethod {
@@ -32,12 +33,12 @@ export default class DeviceFullyUploadResource extends BaseMethod {
     );
   };
 
-  isSupportResourceUpdate(updateType: string) {
+  isSupportResourceUpdate(features: Features, updateType: string) {
     if (updateType !== 'firmware') return false;
 
-    const deviceType = this.device.getCurrentDeviceType();
+    const deviceType = getDeviceType(features);
     const isTouchMode = deviceType === EDeviceType.Touch || deviceType === EDeviceType.Pro;
-    const currentVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
+    const currentVersion = getDeviceFirmwareVersion(features).join('.');
 
     return isTouchMode && semver.gte(currentVersion, '3.4.0');
   }
@@ -48,10 +49,10 @@ export default class DeviceFullyUploadResource extends BaseMethod {
 
     const payload = this.payload as DeviceFullyUploadResourceParams;
 
-    const deviceFirmwareType = device.getCurrentFirmwareType();
+    const deviceFirmwareType = getFirmwareType(features);
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
-    if (!device.isBootloader() && features) {
+    if (!features?.bootloader_mode && features) {
       // check & upgrade firmware resource
       if (features) {
         let { binary } = this.payload;

package/src/api/device/DeviceLock.ts

@@ -5,10 +5,11 @@ import type { LockDevice } from '@onekeyfe/hd-transport';
 export default class DeviceLock extends BaseMethod<LockDevice> {
   init() {
     this.useDevicePassphraseState = false;
-    this.unlockPolicy = 'none';
   }
 
   async run() {
-    return this.device.lockDevice();
+    const res = await this.device.commands.typedCall('LockDevice', 'Success');
+
+    return Promise.resolve(res.message);
   }
 }

package/src/api/device/DeviceRebootToBoardloader.ts

@@ -1,5 +1,3 @@
-import { DeviceRebootType } from '@onekeyfe/hd-transport';
-
 import { BaseMethod } from '../BaseMethod';
 
 import type { RebootToBoardloaderParams } from '../../types/api/deviceRebootToBoardloader';
@@ -23,18 +21,10 @@ export default class DeviceRebootToBoardloader extends BaseMethod<RebootToBoardl
   }
 
   async run() {
-    // Protocol V2 submodule firmware uses DeviceReboot with reboot_type enum.
-    if (this.device.isProtocolV2()) {
-      const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
-        reboot_type: DeviceRebootType.Romloader,
-      });
-      this.device.markProtocolV2Reboot(DeviceRebootType.Romloader);
-      return Promise.resolve(res.message);
-    }
-
     // On Touch devices, messsage code 904 is RebootToBoardloader
     // so BininOutMessageSE message code 904 is used here
     const res = await this.device.commands.typedCall('BixinOutMessageSE', 'Success');
+
     return Promise.resolve(res.message);
   }
 }

package/src/api/device/DeviceRebootToBootloader.ts

@@ -1,5 +1,3 @@
-import { DeviceRebootType } from '@onekeyfe/hd-transport';
-
 import { BaseMethod } from '../BaseMethod';
 
 import type { RebootToBootloader } from '@onekeyfe/hd-transport';
@@ -23,16 +21,8 @@ export default class DeviceRebootToBootloader extends BaseMethod<RebootToBootloa
   }
 
   async run() {
-    // Protocol V2 submodule firmware uses DeviceReboot with reboot_type enum.
-    if (this.device.isProtocolV2()) {
-      const res = await this.device.commands.typedCall('DeviceReboot', 'Success', {
-        reboot_type: DeviceRebootType.Bootloader,
-      });
-      this.device.markProtocolV2Reboot(DeviceRebootType.Bootloader);
-      return Promise.resolve(res.message);
-    }
-
     const res = await this.device.commands.typedCall('RebootToBootloader', 'Success');
+
     return Promise.resolve(res.message);
   }
 }

package/src/api/device/DeviceSettings.ts

@@ -1,31 +1,10 @@
 import { HardwareErrorCode, TypedError } from '@onekeyfe/hd-shared';
-import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
 
 import { BaseMethod } from '../BaseMethod';
-import { invalidParameter } from '../helpers/filesystemValidation';
 import { validateParams } from '../helpers/paramsValidator';
-import {
-  mapApplySettingsToState,
-  mapCommonSettingsToProtocolV2,
-  mapDeviceSettingsToState,
-} from '../../device/DeviceStateMapper';
-import { getProtocolV2SettingsBehavior } from '../../protocols/protocol-v2/settingsUnlockPolicy';
 import { LANGUAGE_LABELS } from '../../utils/deviceSettings';
 
 import type { ApplySettings } from '@onekeyfe/hd-transport';
-import type { DeviceSettingsParams } from '../../types/api/deviceSettings';
-
-const settingsPageForPayload = (
-  payload: DeviceSettingsParams
-): DeviceSettingsPage.DevicePassphrase | DeviceSettingsPage.DeviceAirgap | undefined => {
-  if (payload.usePassphrase !== undefined) {
-    return DeviceSettingsPage.DevicePassphrase;
-  }
-  if (payload.airgapMode !== undefined) {
-    return DeviceSettingsPage.DeviceAirgap;
-  }
-  return undefined;
-};
 
 export default class DeviceSettings extends BaseMethod<ApplySettings> {
   init() {
@@ -45,16 +24,7 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
       { name: 'experimentalFeatures', type: 'boolean' },
       { name: 'autoShutdownDelayMs', type: 'number' },
       { name: 'changeBrightness', type: 'boolean' },
-      { name: 'brightness', type: 'number' },
       { name: 'hapticFeedback', type: 'boolean' },
-      { name: 'bluetoothEnabled', type: 'boolean' },
-      { name: 'airgapMode', type: 'boolean' },
-      { name: 'animationEnabled', type: 'boolean' },
-      { name: 'tapToWake', type: 'boolean' },
-      { name: 'deviceNameDisplayEnabled', type: 'boolean' },
-      { name: 'fidoEnabled', type: 'boolean' },
-      { name: 'usbLockEnabled', type: 'boolean' },
-      { name: 'randomKeypad', type: 'boolean' },
     ]);
 
     // init params
@@ -75,28 +45,6 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
         : undefined),
       haptic_feedback: this.payload.hapticFeedback,
     };
-    const page = settingsPageForPayload(this.payload);
-    const directSettings = mapCommonSettingsToProtocolV2(this.payload);
-    const hasConflictingPages =
-      this.payload.usePassphrase !== undefined && this.payload.airgapMode !== undefined;
-    const combinesPageWithDirectSettings =
-      page !== undefined && Object.keys(directSettings).length > 0;
-    if (hasConflictingPages || combinesPageWithDirectSettings) {
-      // V1 may still accept passphrase plus direct settings. Suppress only the
-      // Protocol V2 pre-run interaction; run() returns the protocol-specific error.
-      this.unlockPolicy = 'none';
-      this.protocolV2UiInteraction = undefined;
-      return;
-    }
-    const behavior =
-      page === undefined
-        ? getProtocolV2SettingsBehavior({
-            kind: 'direct',
-            settings: directSettings,
-          })
-        : getProtocolV2SettingsBehavior({ kind: 'page', page });
-    this.unlockPolicy = behavior.unlockPolicy;
-    this.protocolV2UiInteraction = behavior.uiInteraction;
   }
 
   getVersionRange() {
@@ -112,78 +60,9 @@ export default class DeviceSettings extends BaseMethod<ApplySettings> {
 
   async run() {
     try {
-      if (this.device.isProtocolV2()) {
-        const settings = mapCommonSettingsToProtocolV2(this.payload);
-        const requestedPassphrase = this.payload.usePassphrase;
-        const requestedAirgap = this.payload.airgapMode;
-        const hasPassphrasePage = requestedPassphrase !== undefined;
-        const hasAirgapPage = requestedAirgap !== undefined;
-
-        if (hasPassphrasePage && hasAirgapPage) {
-          throw invalidParameter(
-            'Protocol V2 passphrase and air-gap settings must be changed in separate calls.'
-          );
-        }
-        if ((hasPassphrasePage || hasAirgapPage) && Object.keys(settings).length > 0) {
-          throw invalidParameter(
-            'Protocol V2 on-device settings must not be combined with direct settings.'
-          );
-        }
-        if (requestedPassphrase !== undefined) {
-          const current = await this.device.getDeviceState({ refreshSections: ['status'] });
-          if (current.status.passphraseProtection === requestedPassphrase) {
-            return { message: 'Settings already match requested value.' };
-          }
-
-          const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
-            page: DeviceSettingsPage.DevicePassphrase,
-          });
-          const updated = await this.device.getDeviceState({ refreshSections: ['status'] });
-          if (updated.status.passphraseProtection !== requestedPassphrase) {
-            throw TypedError(
-              HardwareErrorCode.RuntimeError,
-              'Protocol V2 passphrase setting did not reach the requested value.'
-            );
-          }
-          return res.message;
-        }
-        if (requestedAirgap !== undefined) {
-          const current = await this.device.getDeviceState({ refreshSections: ['settings'] });
-          if (current.settings.airgapMode === requestedAirgap) {
-            return { message: 'Settings already match requested value.' };
-          }
-
-          const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
-            page: DeviceSettingsPage.DeviceAirgap,
-          });
-          const updated = await this.device.getDeviceState({ refreshSections: ['settings'] });
-          if (updated.settings.airgapMode !== requestedAirgap) {
-            throw TypedError(
-              HardwareErrorCode.RuntimeError,
-              'Protocol V2 air-gap setting did not reach the requested value.'
-            );
-          }
-          return res.message;
-        }
-        if (Object.keys(settings).length === 0) {
-          throw invalidParameter('No Protocol V2 compatible setting provided.');
-        }
-
-        const res = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
-          settings,
-        });
-        this.device.updateState(mapDeviceSettingsToState(settings), 'apply-settings');
-        return res.message;
-      }
-
-      if (this.payload.airgapMode !== undefined) {
-        throw invalidParameter('Air-gap settings are not supported by Protocol V1.');
-      }
-
       const res = await this.device.commands.typedCall('ApplySettings', 'Success', {
         ...this.params,
       });
-      this.device.updateState(mapApplySettingsToState(this.params), 'apply-settings');
       return res.message;
     } catch (error) {
       if (error.message?.toLowerCase().includes('no setting provided')) {

package/src/api/device/DeviceSupportFeatures.ts

@@ -1,3 +1,9 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import {
+  supportInputPinOnSoftware,
+  supportModifyHomescreen,
+} from '../../utils/deviceFeaturesUtils';
 import { BaseMethod } from '../BaseMethod';
 
 export default class DeviceSupportFeatures extends BaseMethod {
@@ -7,8 +13,13 @@ export default class DeviceSupportFeatures extends BaseMethod {
   }
 
   run() {
-    const inputPinOnSoftware = this.device.supportInputPinOnSoftware();
-    const modifyHomescreen = this.device.supportModifyHomescreen();
+    if (!this.device.features)
+      return Promise.reject(
+        ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Device not initialized')
+      );
+
+    const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
+    const modifyHomescreen = supportModifyHomescreen(this.device.features);
     return Promise.resolve({
       inputPinOnSoftware,
       modifyHomescreen,

package/src/api/device/DeviceUnlock.ts

@@ -5,15 +5,6 @@ import type { LockDevice } from '@onekeyfe/hd-transport';
 export default class DeviceUnlock extends BaseMethod<LockDevice> {
   init() {
     this.useDevicePassphraseState = false;
-    this.unlockPolicy = 'none';
-    this.protocolV2UiInteraction = {
-      request: 'pin',
-      source: 'method-lifecycle',
-      reason: 'device-unlock',
-      completion: 'operation-completed',
-      deviceOnly: true,
-      operation: 'unlock-device',
-    };
   }
 
   async run() {

package/src/api/device/DeviceUpdateBootloader.ts

@@ -5,20 +5,16 @@ 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, updateBootloaderFromSource } from '../firmware/uploadFirmware';
+import { updateBootloader } from '../firmware/uploadFirmware';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
-import { checkBootloaderLength, checkBootloaderSourceLength } from '../firmware/updateBootloader';
-import { openFirmwareByteSource } from '../firmware/FirmwareArtifactSource';
-import { FirmwareCheckpointWriter } from '../firmware/FirmwareCheckpoint';
-import { resolveFirmwareUpdateHostBinding } from '../firmware/FirmwareHostBinding';
-import { assertFirmwareUpdatePreparedPlanBinding } from '../firmware/FirmwareUpdatePreparedPlan';
+import { checkBootloaderLength } from '../firmware/updateBootloader';
+import { getDeviceType, getFirmwareType } from '../../utils';
 
 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() {
@@ -48,94 +44,17 @@ 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,
-    checkpointWriter,
   }: {
     device: Device;
     features?: Features;
     firmwareType: EFirmwareType;
-    binary?: ArrayBuffer;
-    source?: FirmwareByteSource;
-    checkpointWriter: FirmwareCheckpointWriter;
   }) {
-    if (preparedSource) {
-      if (!(await checkBootloaderSourceLength(preparedSource))) {
-        throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
-      }
-      if (features && device.isBootloader()) {
-        this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-        await checkpointWriter.commit({
-          stage: 'FILE_TRANSFER_STARTED',
-          target: 'bootloader',
-        });
-        const result = await this.updateBootloaderWithEmmcFileWriteFromSource(
-          device,
-          preparedSource
-        );
-        await checkpointWriter.commit({
-          stage: 'FILE_TRANSFER_COMPLETED',
-          target: 'bootloader',
-        });
-        await checkpointWriter.commit({
-          stage: 'FINAL_VERIFIED',
-          target: 'bootloader',
-        });
-        return result;
-      }
-      if (features && !device.isBootloader()) {
-        await checkpointWriter.commit({
-          stage: 'FILE_TRANSFER_STARTED',
-          target: 'bootloader',
-        });
-        await updateBootloaderFromSource(
-          this.device.getCommands().typedCall.bind(this.device.getCommands()),
-          this.postMessage,
-          device,
-          preparedSource
-        );
-        await checkpointWriter.commit({
-          stage: 'FILE_TRANSFER_COMPLETED',
-          target: 'bootloader',
-        });
-        await checkpointWriter.commit({
-          stage: 'FINAL_VERIFIED',
-          target: 'bootloader',
-        });
-        return true;
-      }
-    }
-
-    let binary = preparedBinary;
+    let { binary } = this.payload;
     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)
@@ -150,50 +69,25 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
       }
     }
 
-    if (!binary || !checkBootloaderLength(binary)) {
+    if (!checkBootloaderLength(binary)) {
       throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
     }
 
     // Check if device is in bootloader mode
-    if (features && device.isBootloader()) {
+    if (features && features.bootloader_mode) {
       // Use emmcFileWrite + reboot logic for bootloader mode
       this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-      await checkpointWriter.commit({
-        stage: 'FILE_TRANSFER_STARTED',
-        target: 'bootloader',
-      });
-      const result = await this.updateBootloaderWithEmmcFileWrite(device, binary);
-      await checkpointWriter.commit({
-        stage: 'FILE_TRANSFER_COMPLETED',
-        target: 'bootloader',
-      });
-      await checkpointWriter.commit({
-        stage: 'FINAL_VERIFIED',
-        target: 'bootloader',
-      });
-      return result;
+      return this.updateBootloaderWithEmmcFileWrite(device, binary);
     }
 
-    if (features && !device.isBootloader()) {
+    if (features && !features.bootloader_mode) {
       // Use original updateBootloader logic for normal mode
-      await checkpointWriter.commit({
-        stage: 'FILE_TRANSFER_STARTED',
-        target: 'bootloader',
-      });
       await updateBootloader(
         this.device.getCommands().typedCall.bind(this.device.getCommands()),
         this.postMessage,
         device,
         binary
       );
-      await checkpointWriter.commit({
-        stage: 'FILE_TRANSFER_COMPLETED',
-        target: 'bootloader',
-      });
-      await checkpointWriter.commit({
-        stage: 'FINAL_VERIFIED',
-        target: 'bootloader',
-      });
       return Promise.resolve(true);
     }
   }
@@ -203,71 +97,13 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     const { features } = device;
 
     const payload = this.payload as DeviceUpdateBootloaderParams;
-    const hostBinding = payload.artifact
-      ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
-      : undefined;
-    const executionParams = {
-      ...payload,
-      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
-      checkpointSink: hostBinding?.checkpointSink ?? payload.checkpointSink,
-    };
-    const checkpointWriter = new FirmwareCheckpointWriter(executionParams, {
-      required: !!hostBinding,
-    });
-    if (payload.artifact) {
-      assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan: payload.preparedPlan,
-        executor: 'v2',
-        scopeTargets: ['bootloader'],
-        bindings: [
-          {
-            target: 'bootloader',
-            artifact: payload.artifact,
-          },
-        ],
-      });
-      const source = await openFirmwareByteSource({
-        artifact: payload.artifact,
-        reader: executionParams.artifactReader,
-      });
-      if (!source) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Bootloader artifact is not prepared'
-        );
-      }
-      try {
-        const deviceType = device.getCurrentDeviceType();
-        const deviceFirmwareType = device.getCurrentFirmwareType();
-        const firmwareType = payload.firmwareType ?? deviceFirmwareType;
-        if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-          return await this.updateTouchBootloader({
-            device,
-            features,
-            firmwareType,
-            source,
-            checkpointWriter,
-          });
-        }
-        return true;
-      } finally {
-        await source.close();
-      }
-    }
 
-    const { binary } = payload;
-    const deviceType = device.getCurrentDeviceType();
-    const deviceFirmwareType = device.getCurrentFirmwareType();
+    const deviceType = getDeviceType(features);
+    const deviceFirmwareType = getFirmwareType(features);
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-      return this.updateTouchBootloader({
-        device,
-        features,
-        firmwareType,
-        binary,
-        checkpointWriter,
-      });
+      return this.updateTouchBootloader({ device, features, firmwareType });
     }
 
     return Promise.resolve(true);

package/src/api/device/DeviceUploadResource.ts

@@ -8,6 +8,7 @@ import { DeviceModelToTypes } from '../../types';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams } from '../helpers/paramsValidator';
 import { hexToBytes } from '../helpers/hexUtils';
+import { getDeviceFirmwareVersion, getDeviceType } from '../../utils';
 import { PROTO } from '../../constants';
 
 import type { DeviceUploadResourceParams, DeviceUploadResourceResponse } from '../../types';
@@ -36,8 +37,8 @@ export default class DeviceUploadResource extends BaseMethod<ResourceUpload> {
   }
 
   checkUploadNFTSupport() {
-    const deviceType = this.device.getCurrentDeviceType();
-    const currentVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
+    const deviceType = getDeviceType(this.device.features);
+    const currentVersion = getDeviceFirmwareVersion(this.device.features).join('.');
     if (!DeviceModelToTypes.model_touch.includes(deviceType)) {
       throw ERRORS.TypedError(HardwareErrorCode.CallMethodError, 'Device Not Support Upload NFT');
     }
@@ -137,8 +138,8 @@ export default class DeviceUploadResource extends BaseMethod<ResourceUpload> {
       };
       response.applyScreen = true;
 
-      const firmwareVersion = this.device.getCurrentFirmwareVersionString() ?? '0.0.0';
-      const deviceType = this.device.getCurrentDeviceType();
+      const firmwareVersion = getDeviceFirmwareVersion(this.device.features).join('.');
+      const deviceType = getDeviceType(this.device.features);
       if (deviceType === EDeviceType.Pro && semver.gte(firmwareVersion, '4.17.0')) {
         response.applyScreen = false;
       }

package/src/api/device/DeviceVerify.ts

@@ -5,6 +5,7 @@ import { bytesToHex } from '@noble/hashes/utils';
 import { formatAnyHex } from '../helpers/hexUtils';
 import { BaseMethod } from '../BaseMethod';
 import { validateParams, validateResult } from '../helpers/paramsValidator';
+import { getDeviceType } from '../../utils';
 import { DeviceModelToTypes } from '../../types';
 
 import type { BixinVerifyDeviceRequest } from '@onekeyfe/hd-transport';
@@ -25,7 +26,7 @@ export default class DeviceVerify extends BaseMethod<BixinVerifyDeviceRequest> {
 
   async run() {
     // For Classic、Mini device we use EthereumSignTypedData
-    const deviceType = this.device.getCurrentDeviceType();
+    const deviceType = getDeviceType(this.device.features);
     let response: DeviceVerifySignature | undefined;
 
     if (DeviceModelToTypes.model_classic.includes(deviceType)) {

package/src/api/device/DeviceWipe.ts

@@ -1,32 +1,13 @@
-import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
-
 import { BaseMethod } from '../BaseMethod';
 
 import type { WipeDevice } from '@onekeyfe/hd-transport';
 
 export default class DeviceWipe extends BaseMethod<WipeDevice> {
   init() {
-    this.unlockPolicy = 'retry-on-locked';
     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,
-      });
-      return Promise.resolve(res.message);
-    }
-
     const res = await this.device.commands.typedCall('WipeDevice', 'Success');
 
     return Promise.resolve(res.message);

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