@onekeyfe/hd-core 1.2.0-alpha.33 → 1.2.0-alpha.35

package/src/device/Device.ts

@@ -55,6 +55,7 @@ import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
 import { toHardened } from '../api/helpers/pathUtils';
 import {
+  PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE,
   PROTOCOL_V2_FEATURES_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_FULL_DEVICE_INFO_REQUEST,
   PROTOCOL_V2_VERSIONS_DEVICE_INFO_REQUEST,
@@ -62,8 +63,11 @@ import {
   getProtocolV2RuntimeMode,
   requestProtocolV2DeviceInfo,
   requestProtocolV2DeviceStatus,
+  requestProtocolV2ProtocolInfo,
+  supportsProtocolV2Message,
 } from '../protocols/protocol-v2/features';
 import { buildProtocolV1FeaturesPayload } from '../deviceProfile';
+import { resolveProtocolV2DeviceIdentity } from '../deviceProfile/protocolV2DeviceIdentity';
 
 import type { PROTO } from '../constants';
 import type { DeviceStateReadOptions } from '../types/api/getDeviceState';
@@ -77,6 +81,7 @@ import type { Deferred, HardwareConnectProtocol } from '@onekeyfe/hd-shared';
 import type {
   OneKeyDeviceInfo as DeviceDescriptor,
   DeviceStatus,
+  ProtocolInfo,
   ProtocolV2DeviceInfo,
   Success,
 } from '@onekeyfe/hd-transport';
@@ -280,7 +285,7 @@ export class Device extends EventEmitter {
 
   // simplified object to pass via postMessage
   toMessageObject(): DeviceTyped | null {
-    if (this.isUnacquired()) return null;
+    if (this.isUnacquired() || !this.features) return null;
 
     const env = DataManager.getSettings('env');
     const deviceType = this.getCurrentDeviceType();
@@ -297,6 +302,8 @@ export class Device extends EventEmitter {
     return {
       /** Android uses a MAC address, while iOS and USB use transport-specific identifiers. */
       connectId: DataManager.isBleConnect(env) ? this.mainId || null : connectId,
+      /** Persist this after the first active probe so later calls do not need to guess. */
+      connectProtocol: this.originalDescriptor.protocolType,
       /** Stable physical-device identity. */
       serialNo,
       /** @deprecated Use serialNo instead. */
@@ -364,12 +371,12 @@ export class Device extends EventEmitter {
   }
 
   async acquire(
-    connectProtocol?: HardwareConnectProtocol,
+    expectedProtocol?: HardwareConnectProtocol,
     options?: { throwOnRunPromiseError?: boolean }
   ) {
     const env = DataManager.getSettings('env');
     const mainIdKey = DataManager.isBleConnect(env) ? 'id' : 'session';
-    const expectedProtocol = connectProtocol ?? this.originalDescriptor.protocolType;
+    const protocolHint = expectedProtocol ? undefined : this.originalDescriptor.protocolType;
     try {
       let acquireResult: unknown;
       if (DataManager.isBleConnect(env)) {
@@ -381,7 +388,8 @@ export class Device extends EventEmitter {
           this.originalDescriptor.id,
           undefined,
           true,
-          expectedProtocol
+          expectedProtocol,
+          protocolHint
         );
         this.mainId = (acquireResult as any)?.uuid ?? '';
         Log.debug('Expected uuid:', this.mainId);
@@ -390,7 +398,8 @@ export class Device extends EventEmitter {
           this.originalDescriptor.path,
           this.originalDescriptor.session,
           undefined,
-          expectedProtocol
+          expectedProtocol,
+          protocolHint
         );
         this.mainId = acquireResult as string | undefined;
         Log.debug('Expected session id:', this.mainId);
@@ -717,13 +726,20 @@ export class Device extends EventEmitter {
     return deviceWalletSessionStore.get(deviceId, this.passphraseState);
   }
 
+  getStandardInternalState(_deviceId?: string) {
+    const deviceId = this.getSessionCacheDeviceKey(_deviceId);
+    if (!deviceId) return undefined;
+    return deviceWalletSessionStore.getStandard(deviceId);
+  }
+
   // attach to pin to fix internal state
   updateInternalState(
     enablePassphrase: boolean,
     passphraseState: string | undefined,
     deviceId: string | undefined,
     sessionId: string | null = null,
-    featuresSessionId: string | null = null
+    featuresSessionId: string | null = null,
+    walletType: 'standard' | 'hidden' = 'hidden'
   ) {
     Log.debug(
       'updateInternalState session param: ',
@@ -740,7 +756,15 @@ export class Device extends EventEmitter {
     if (enablePassphrase) {
       const walletSessionId =
         sessionId || featuresSessionId || deviceWalletSessionStore.getPending(cacheDeviceKey);
-      deviceWalletSessionStore.set(cacheDeviceKey, passphraseState, walletSessionId ?? undefined);
+      if (walletType === 'standard') {
+        deviceWalletSessionStore.setStandard(
+          cacheDeviceKey,
+          passphraseState,
+          walletSessionId ?? undefined
+        );
+      } else {
+        deviceWalletSessionStore.set(cacheDeviceKey, passphraseState, walletSessionId ?? undefined);
+      }
     }
 
     deviceWalletSessionStore.deletePending(cacheDeviceKey);
@@ -779,6 +803,12 @@ export class Device extends EventEmitter {
     }
   }
 
+  clearStandardInternalState(_deviceId?: string) {
+    const deviceId = this.getSessionCacheDeviceKey(_deviceId);
+    if (!deviceId) return;
+    deviceWalletSessionStore.deleteStandard(deviceId);
+  }
+
   async initialize(options?: InitOptions) {
     // Protocol V2 does not support legacy Initialize; use its dedicated flow.
     if (this.isProtocolV2()) {
@@ -810,9 +840,12 @@ export class Device extends EventEmitter {
 
       const expectedDeviceId = options?.deviceId;
       if (expectedDeviceId) {
-        // Establish the live physical identity before sending wallet-bound state.
+        // 先只读校验物理设备身份；钱包上下文仍由下方携带完整参数的
+        // Initialize 选择，避免标准钱包请求复用此前的隐藏钱包上下文。
         this.passphraseState = undefined;
-        await callInitialize({ is_contains_attach: true });
+        const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
+        this._updateFeatures(message);
+        await TransportManager.reconfigure(this.features);
         if (!this.checkDeviceId(expectedDeviceId)) {
           throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
         }
@@ -836,15 +869,7 @@ export class Device extends EventEmitter {
         payload.derive_cardano = true;
       }
 
-      const requiresWalletInitialize =
-        !expectedDeviceId ||
-        Boolean(internalState) ||
-        Boolean(options?.passphraseState) ||
-        options?.deriveCardano === true ||
-        options?.initSession === true;
-      if (requiresWalletInitialize) {
-        await callInitialize(payload, options?.initSession);
-      }
+      await callInitialize(payload, options?.initSession);
     } catch (error) {
       Log.error('Initialization failed:', error);
       throw error;
@@ -1020,40 +1045,60 @@ export class Device extends EventEmitter {
   }
 
   async probeProtocolV2RuntimeState(deviceInfo: ProtocolV2DeviceInfo, timeoutMs?: number) {
-    let deviceStatus: DeviceStatus;
-    try {
-      deviceStatus = await requestProtocolV2DeviceStatus({
-        commands: this.commands,
-        timeoutMs,
-      });
-    } catch (error) {
-      const runtimeMode = getProtocolV2RuntimeMode({
-        deviceInfo,
-        deviceStatusAvailable: false,
-      });
-      Log.debug('Protocol V2 DeviceStatusGet unavailable; use temporary loader fallback', {
-        runtimeMode,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return this.updateProtocolV2Features(deviceInfo, null, runtimeMode);
+    const protocolInfo = await requestProtocolV2ProtocolInfo({
+      commands: this.commands,
+      timeoutMs,
+    });
+    const runtimeMode = getProtocolV2RuntimeMode(protocolInfo);
+    const protocolV2DeviceType = resolveProtocolV2DeviceIdentity(
+      deviceInfo.hw?.Device_type
+    ).deviceType;
+    if (runtimeMode === 'romloader' && protocolV2DeviceType !== EDeviceType.Pro2) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceInitializeFailed,
+        'Protocol V2 romloader mode is only supported for Pro2.'
+      );
+    }
+    const deviceStatusSupported = supportsProtocolV2Message(
+      protocolInfo,
+      PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE
+    );
+
+    if (runtimeMode === 'bootloader' || runtimeMode === 'romloader') {
+      return this.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
+    }
+
+    if (!deviceStatusSupported) {
+      if (runtimeMode === 'normal') {
+        return this.updateProtocolV2Features(deviceInfo, null, runtimeMode, protocolInfo);
+      }
+      throw ERRORS.TypedError(
+        HardwareErrorCode.DeviceInitializeFailed,
+        `Unknown Protocol V2 build fingerprint without DeviceStatusGet capability: ${protocolInfo.build_fingerprint}`
+      );
     }
-    return this.updateProtocolV2Features(deviceInfo, deviceStatus, 'normal');
+
+    const deviceStatus = await requestProtocolV2DeviceStatus({
+      commands: this.commands,
+      timeoutMs,
+    });
+    return this.updateProtocolV2Features(deviceInfo, deviceStatus, 'normal', protocolInfo);
   }
 
   updateProtocolV2Features(
     deviceInfo?: ProtocolV2DeviceInfo,
     deviceStatus?: DeviceStatus | null,
-    runtimeMode?: ProtocolV2RuntimeMode
+    runtimeMode?: ProtocolV2RuntimeMode,
+    protocolInfo?: ProtocolInfo
   ) {
     const previousDeviceId = this.getCurrentDeviceId();
-    const resolvedMode =
-      runtimeMode ??
-      (deviceStatus
-        ? getProtocolV2RuntimeMode({ deviceInfo, deviceStatusAvailable: true })
-        : this.state?.status.mode);
+    const resolvedMode = runtimeMode ?? (deviceStatus ? 'normal' : this.state?.status.mode);
     if (deviceInfo) {
       this.updateState(mapProtocolV2DeviceInfoToState(deviceInfo, resolvedMode), 'device-info');
     }
+    if (protocolInfo) {
+      this.updateState({ raw: { protocolV2ProtocolInfo: protocolInfo } }, 'device-info');
+    }
     if (deviceStatus) {
       this.updateState(mapProtocolV2DeviceStatusToState(deviceStatus), 'device-status');
     }
@@ -1122,7 +1167,7 @@ export class Device extends EventEmitter {
             attachToPinEnabled: null,
             unlockedAttachPin: null,
           },
-          raw: { protocolV2DeviceStatus: null },
+          raw: { protocolV2ProtocolInfo: null, protocolV2DeviceStatus: null },
         },
         'transport-reconnect'
       );
@@ -1132,7 +1177,7 @@ export class Device extends EventEmitter {
     this.updateState(
       {
         status: { mode: 'normal', unlocked: null },
-        raw: { protocolV2DeviceStatus: null },
+        raw: { protocolV2ProtocolInfo: null, protocolV2DeviceStatus: null },
       },
       'transport-reconnect'
     );
@@ -1378,7 +1423,16 @@ export class Device extends EventEmitter {
 
   isBootloader() {
     if (!this.state) return undefined;
-    return this.state.status.mode === 'bootloader' || this.state.status.mode === 'romloader';
+    return this.state.status.mode === 'bootloader';
+  }
+
+  isRomloader() {
+    if (!this.state) return undefined;
+    return (
+      this.isProtocolV2() &&
+      this.getCurrentDeviceType() === EDeviceType.Pro2 &&
+      this.state.status.mode === 'romloader'
+    );
   }
 
   isInitialized() {

package/src/device/DeviceCommands.ts

@@ -6,6 +6,7 @@ import {
   type Messages,
   type Transport,
   type TransportCallOptions,
+  getSafeTransportLogPayload,
 } from '@onekeyfe/hd-transport';
 
 import TransportManager from '../data-manager/TransportManager';
@@ -282,7 +283,11 @@ export class DeviceCommands {
   ): Promise<DefaultMessageResponse> {
     const shouldReduceDebug = shouldReduceDebugForCall(type);
     if (!shouldReduceDebug) {
-      Log.debug('[DeviceCommands] [call] Sending', type);
+      Log.debug(
+        '[DeviceCommands] [call] Sending',
+        type,
+        getSafeTransportLogPayload(msg ?? {}, type)
+      );
     }
 
     try {
@@ -290,13 +295,18 @@ export class DeviceCommands {
       this.callPromise = promise;
       const res = await promise;
       if (!shouldReduceDebug) {
-        LogCore.debug('[DeviceCommands] [call] Received', res.type);
+        LogCore.debug(
+          '[DeviceCommands] [call] Received',
+          res.type,
+          getSafeTransportLogPayload(res.message, res.type)
+        );
       }
       return res;
     } catch (error) {
       LogCore.debug('[DeviceCommands] [call] Received error', {
         request: type,
         errorCode: error?.errorCode,
+        response: getSafeTransportLogPayload(error?.response?.data, type),
       });
       if (error.errorCode === HardwareErrorCode.BleDeviceBondError) {
         return {

package/src/device/DeviceConnector.ts

@@ -82,9 +82,10 @@ export default class DeviceConnector {
     path: string,
     session?: string | null,
     forceCleanRunPromise?: boolean,
-    connectProtocol?: HardwareConnectProtocol
+    expectedProtocol?: HardwareConnectProtocol,
+    protocolHint?: HardwareConnectProtocol
   ) {
-    Log.debug('acquire', path, session, connectProtocol);
+    Log.debug('acquire', path, session, expectedProtocol, protocolHint);
     const env = DataManager.getSettings('env');
     try {
       let res;
@@ -92,21 +93,23 @@ export default class DeviceConnector {
         res = await this.transport.acquire({
           uuid: path,
           forceCleanRunPromise,
-          expectedProtocol: connectProtocol,
+          expectedProtocol,
+          protocolHint,
         });
       } else {
         res = await this.transport.acquire({
           path,
           previous: session ?? null,
-          expectedProtocol: connectProtocol,
+          expectedProtocol,
+          protocolHint,
         });
       }
-      if (connectProtocol) {
+      if (expectedProtocol) {
         const detectedProtocol = this.transport.getProtocolType(path);
-        if (detectedProtocol !== connectProtocol) {
+        if (detectedProtocol !== expectedProtocol) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            `Device protocol mismatch: expected ${connectProtocol}, detected ${detectedProtocol}`
+            `Device protocol mismatch: expected ${expectedProtocol}, detected ${detectedProtocol}`
           );
         }
       }

package/src/device/DevicePool.ts

@@ -306,9 +306,11 @@ export class DevicePool extends EventEmitter {
     this.disconnectPool = [];
     this.devicesCache = {};
 
-    // Clear all event listeners but keep the emitter instance
-    this.emitter.removeAllListeners();
-
     Log.debug('DevicePool state has been reset');
   }
+
+  static dispose() {
+    this.resetState();
+    this.emitter.removeAllListeners();
+  }
 }

package/src/device/DeviceStateMapper.ts

@@ -1,6 +1,7 @@
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { EFirmwareType } from '@onekeyfe/hd-shared';
 
 import { buildProtocolV1FeaturesPayload } from '../deviceProfile/buildDeviceFeatures';
+import { resolveProtocolV2DeviceIdentity } from '../deviceProfile/protocolV2DeviceIdentity';
 import {
   mapLanguageFromProtocolV2,
   mapLanguageToProtocolV2,
@@ -211,14 +212,15 @@ export const mapProtocolV2DeviceInfoToState = (
   mode: DeviceStateMode = 'unknown'
 ): DeviceStatePatch => {
   const loader = mode === 'bootloader' || mode === 'romloader';
+  const identity = resolveProtocolV2DeviceIdentity(info.hw?.Device_type);
 
   return {
     protocol: 'V2',
     protocolVersion: info.protocol_version,
     identity: definedEntries({
-      deviceType: EDeviceType.Pro2,
+      deviceType: identity.deviceType,
       firmwareType: EFirmwareType.Universal,
-      model: 'pro2',
+      model: identity.model,
       vendor: 'onekey.so',
       serialNo: info.hw?.serial_no,
       bleName: info.coprocessor?.bt_adv_name,

package/src/device/DeviceStateProjector.ts

@@ -16,12 +16,6 @@ export const projectFeatures = (state: StoredDeviceState): Features => {
   delete publicRawFeatures.session_id;
   delete publicRawFeatures.sessionId;
   delete publicRawFeatures.passphraseState;
-  const publicRaw = snapshot.raw
-    ? {
-        ...snapshot.raw,
-        protocolV1Features: publicRawFeatures,
-      }
-    : undefined;
   const rawOneKeyFeatures = snapshot.raw?.protocolV1OneKeyFeatures ?? {};
   const bootloaderMode =
     snapshot.protocol === 'V1'
@@ -90,7 +84,6 @@ export const projectFeatures = (state: StoredDeviceState): Features => {
     se04BootVersion: snapshot.versions.se04Boot,
     seVersion: snapshot.versions.se ?? null,
     verify: snapshot.verification,
-    raw: publicRaw,
     device_id: snapshot.identity.deviceId ?? undefined,
     ble_name: snapshot.identity.bleName ?? undefined,
     passphrase_protection: snapshot.status.passphraseProtection ?? undefined,

package/src/device/DeviceWalletSessionStore.ts

@@ -1,6 +1,11 @@
 export class DeviceWalletSessionStore {
   private readonly walletSessions = new Map<string, Map<string, string>>();
 
+  private readonly standardWalletSessions = new Map<
+    string,
+    { passphraseState: string; sessionId: string }
+  >();
+
   private readonly pendingSessions = new Map<string, string>();
 
   get(deviceKey: string, passphraseState?: string) {
@@ -18,6 +23,17 @@ export class DeviceWalletSessionStore {
     deviceSessions.set(passphraseState, sessionId);
   }
 
+  getStandard(deviceKey: string) {
+    if (!deviceKey) return undefined;
+    return this.standardWalletSessions.get(deviceKey);
+  }
+
+  setStandard(deviceKey: string, passphraseState?: string, sessionId?: string) {
+    if (!deviceKey || !passphraseState || !sessionId) return;
+    this.set(deviceKey, passphraseState, sessionId);
+    this.standardWalletSessions.set(deviceKey, { passphraseState, sessionId });
+  }
+
   setPending(deviceKey: string, sessionId?: string) {
     if (!deviceKey || !sessionId) return;
     this.pendingSessions.set(deviceKey, sessionId);
@@ -30,6 +46,10 @@ export class DeviceWalletSessionStore {
 
   delete(deviceKey: string, passphraseState?: string) {
     if (!deviceKey || !passphraseState) return;
+    const standardWalletSession = this.standardWalletSessions.get(deviceKey);
+    if (standardWalletSession?.passphraseState === passphraseState) {
+      this.standardWalletSessions.delete(deviceKey);
+    }
     const deviceSessions = this.walletSessions.get(deviceKey);
     if (!deviceSessions) return;
     deviceSessions.delete(passphraseState);
@@ -38,6 +58,15 @@ export class DeviceWalletSessionStore {
     }
   }
 
+  deleteStandard(deviceKey: string) {
+    if (!deviceKey) return;
+    const standardWalletSession = this.standardWalletSessions.get(deviceKey);
+    this.standardWalletSessions.delete(deviceKey);
+    if (standardWalletSession) {
+      this.delete(deviceKey, standardWalletSession.passphraseState);
+    }
+  }
+
   deletePending(deviceKey: string) {
     if (!deviceKey) return;
     this.pendingSessions.delete(deviceKey);
@@ -46,6 +75,7 @@ export class DeviceWalletSessionStore {
   deleteDevice(deviceKey: string) {
     if (!deviceKey) return;
     this.walletSessions.delete(deviceKey);
+    this.standardWalletSessions.delete(deviceKey);
     this.pendingSessions.delete(deviceKey);
   }
 
@@ -54,16 +84,24 @@ export class DeviceWalletSessionStore {
 
     const sourceSessions = this.walletSessions.get(from);
     if (sourceSessions) {
-      const targetSessions = this.walletSessions.get(to) ?? new Map<string, string>();
-      this.walletSessions.set(to, targetSessions);
       sourceSessions.forEach((sessionId, passphraseState) => {
-        if (!targetSessions.has(passphraseState)) {
-          targetSessions.set(passphraseState, sessionId);
+        if (!this.get(to, passphraseState)) {
+          this.set(to, passphraseState, sessionId);
         }
       });
       this.walletSessions.delete(from);
     }
 
+    const standardWalletSession = this.standardWalletSessions.get(from);
+    if (
+      standardWalletSession &&
+      !this.standardWalletSessions.has(to) &&
+      this.get(to, standardWalletSession.passphraseState) === standardWalletSession.sessionId
+    ) {
+      this.standardWalletSessions.set(to, standardWalletSession);
+    }
+    this.standardWalletSessions.delete(from);
+
     const pendingSession = this.pendingSessions.get(from);
     if (pendingSession && !this.pendingSessions.has(to)) {
       this.pendingSessions.set(to, pendingSession);
@@ -98,6 +136,7 @@ export class DeviceWalletSessionStore {
 
   clear() {
     this.walletSessions.clear();
+    this.standardWalletSessions.clear();
     this.pendingSessions.clear();
   }
 }

package/src/deviceProfile/buildDeviceFeatures.ts

@@ -1,4 +1,4 @@
-import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { EFirmwareType } from '@onekeyfe/hd-shared';
 
 import {
   resolveDeviceBleFirmwareVersion,
@@ -11,6 +11,7 @@ import {
   resolveDeviceType,
 } from '../utils/deviceFeaturesCompat';
 import { normalizeSafetyCheckLevel } from '../utils/deviceSettings';
+import { resolveProtocolV2DeviceIdentity } from './protocolV2DeviceIdentity';
 
 import type {
   DeviceFirmwareImageInfo,
@@ -224,6 +225,12 @@ export const buildProtocolV2FeaturesPayload = ({
   const samePhysicalDevice =
     !incomingSerialNo || !previous?.serialNo || incomingSerialNo === previous.serialNo;
   const cached = samePhysicalDevice ? previous : undefined;
+  const incomingDeviceType = info?.hw?.Device_type;
+  const resolvedIdentity = resolveProtocolV2DeviceIdentity(incomingDeviceType);
+  const cachedIdentity =
+    incomingDeviceType === undefined || incomingDeviceType === null ? cached : undefined;
+  const deviceType = cachedIdentity ? cachedIdentity.deviceType : resolvedIdentity.deviceType;
+  const model = cachedIdentity ? cachedIdentity.model : resolvedIdentity.model;
 
   const firmwareVersion = firstMeaningfulVersion(
     getImageVersion(fwApplication),
@@ -253,7 +260,7 @@ export const buildProtocolV2FeaturesPayload = ({
   const attachToPinEnabled = status?.attach_to_pin_enabled ?? cached?.attachToPinEnabled ?? null;
   const unlockedAttachPin =
     status?.unlocked_by_attach_to_pin ?? cached?.unlockedAttachPin ?? undefined;
-  const bootloaderMode = runtimeMode === 'bootloader';
+  const bootloaderMode = runtimeMode === 'bootloader' || runtimeMode === 'romloader';
   let mode: DeviceFeaturesMode = 'unknown';
   if (runtimeMode) {
     mode = runtimeMode;
@@ -270,9 +277,9 @@ export const buildProtocolV2FeaturesPayload = ({
   return {
     protocol: 'V2',
     protocolVersion: deviceInfo?.protocol_version ?? cached?.protocolVersion ?? null,
-    deviceType: EDeviceType.Pro2,
+    deviceType,
     firmwareType: cached?.firmwareType ?? EFirmwareType.Universal,
-    model: 'pro2',
+    model,
     vendor: 'onekey.so',
     deviceId,
     serialNo,

package/src/deviceProfile/protocolV2DeviceIdentity.ts

@@ -0,0 +1,32 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+import { DeviceType } from '@onekeyfe/hd-transport';
+
+export const resolveProtocolV2DeviceIdentity = (
+  deviceType?: DeviceType | keyof typeof DeviceType | null
+): { deviceType: EDeviceType; model: string | null } => {
+  switch (deviceType) {
+    case DeviceType.CLASSIC1:
+    case 'CLASSIC1':
+      return { deviceType: EDeviceType.Classic, model: 'classic' };
+    case DeviceType.CLASSIC1S:
+    case 'CLASSIC1S':
+      return { deviceType: EDeviceType.Classic1s, model: 'classic1s' };
+    case DeviceType.CLASSIC1S_PURE:
+    case 'CLASSIC1S_PURE':
+      return { deviceType: EDeviceType.ClassicPure, model: 'classicpure' };
+    case DeviceType.MINI:
+    case 'MINI':
+      return { deviceType: EDeviceType.Mini, model: 'mini' };
+    case DeviceType.TOUCH:
+    case 'TOUCH':
+      return { deviceType: EDeviceType.Touch, model: 'touch' };
+    case DeviceType.PRO:
+    case 'PRO':
+      return { deviceType: EDeviceType.Pro, model: 'pro' };
+    case DeviceType.PRO2:
+    case 'PRO2':
+      return { deviceType: EDeviceType.Pro2, model: 'pro2' };
+    default:
+      return { deviceType: EDeviceType.Unknown, model: null };
+  }
+};