@onekeyfe/hd-core 1.2.0-alpha.19 → 1.2.0-alpha.20

package/src/device/DeviceCommands.ts

@@ -1,4 +1,11 @@
 import { ERRORS, HardwareError, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import {
+  DeviceErrorCode,
+  type FailureType,
+  type Messages,
+  type Transport,
+  type TransportCallOptions,
+} from '@onekeyfe/hd-transport';
 
 import TransportManager from '../data-manager/TransportManager';
 import DataManager from '../data-manager/DataManager';
@@ -12,12 +19,6 @@ import {
 } from '../utils/tracing';
 
 import type { Device } from './Device';
-import type {
-  FailureType,
-  Messages,
-  Transport,
-  TransportCallOptions,
-} from '@onekeyfe/hd-transport';
 
 export type PassphrasePromptResponse = {
   passphrase?: string;
@@ -51,11 +52,16 @@ const HIGH_VOLUME_DEBUG_CALLS = new Set([
   'FirmwareUpload',
   'ResourceAck',
 ]);
+const SENSITIVE_DEBUG_CALLS = new Set(['DeviceSessionGet']);
 
 function shouldReduceDebugForCall(type: string) {
   return HIGH_VOLUME_DEBUG_CALLS.has(type);
 }
 
+function shouldBlockDebugForCall(type: string) {
+  return SENSITIVE_DEBUG_CALLS.has(type);
+}
+
 function getBinaryByteLength(value: unknown): number | undefined {
   if (value instanceof ArrayBuffer) {
     return value.byteLength;
@@ -98,6 +104,12 @@ function sanitizeDebugPayload(value: unknown, key = '', depth = 0): unknown {
     return summarizeRedactedData(value);
   }
 
+  // Redact passphrase-bearing keys as defense in depth so wallet identifiers and
+  // host passphrases cannot reach diagnostic logs through a future call path.
+  if (key && /passphrase/i.test(key)) {
+    return '[redacted passphrase]';
+  }
+
   const byteLength = getBinaryByteLength(value);
   if (byteLength !== undefined) {
     return `[binary: ${byteLength} bytes]`;
@@ -141,10 +153,9 @@ function sanitizeDebugPayload(value: unknown, key = '', depth = 0): unknown {
 }
 
 /**
- * 交互式 Ack（ButtonAck / PinMatrixAck / PassphraseAck 等）不应继承原调用的
- * timeoutMs：设备在等待用户操作（确认、输入 PIN/passphrase），思考时间不可预估，
- * 沿用业务调用的超时会把用户操作截断。仅保留 expectedTypes / intermediateTypes
- * 等与响应类型相关的选项。
+ * Interactive acknowledgements must not inherit timeoutMs from the original call.
+ * User confirmation and PIN/passphrase entry have unbounded think time. Preserve only
+ * response-related options such as expectedTypes and intermediateTypes.
  */
 const stripInteractiveAckTimeout = (
   options?: TransportCallOptions
@@ -440,6 +451,7 @@ export class DeviceCommands {
         'PinMatrixAck',
         'PassphraseAck',
         'Cancel',
+        'DeviceSessionGet',
         'BixinPinInputOnDevice',
         'FilesystemFileRead',
         'FilesystemFileWrite',
@@ -450,7 +462,7 @@ export class DeviceCommands {
         'FirmwareUpload',
         'ResourceAck',
       ] as any;
-      if (!skipTypes.includes(type) && msg) {
+      if (!skipTypes.includes(type) && !shouldBlockDebugForCall(type) && msg) {
         // Use debug channel to avoid noise escalation
         Log.debug('[DeviceCommands] [typedCall] Sending payload', type, sanitizeDebugPayload(msg));
       }
@@ -475,12 +487,14 @@ export class DeviceCommands {
       // throw bridge network error
       if (error instanceof HardwareError) {
         if (error.errorCode === HardwareErrorCode.ResponseUnexpectTypeError) {
-          Log.debug('[DeviceCommands] [typedCall] Unexpected response type', {
-            request: type,
-            expected: resType,
-            received: response.type,
-            response: sanitizeDebugPayload(response.message),
-          });
+          if (!shouldBlockDebugForCall(type)) {
+            Log.debug('[DeviceCommands] [typedCall] Unexpected response type', {
+              request: type,
+              expected: resType,
+              received: response.type,
+              response: sanitizeDebugPayload(response.message),
+            });
+          }
           // Do not intercept CallMethodError
           // Do not intercept “assertType: Response of unexpected type” error
           // Blocking the above two messages will not know what the specific error message is, and the specific error should be handled by the subsequent business logic.
@@ -519,8 +533,8 @@ export class DeviceCommands {
     options?: TransportCallOptions
   ): Promise<DefaultMessageResponse> {
     try {
-      if (shouldReduceDebugForCall(callType)) {
-        // 高频文件写入每个 chunk 都会经过这里，避免 debug log 反向拖慢传输。
+      if (shouldReduceDebugForCall(callType) || shouldBlockDebugForCall(callType)) {
+        // Skip high-volume or security-sensitive response payloads.
       } else if (DataManager.getSettings('env') === 'react-native') {
         Log.debug('_filterCommonTypes: ', JSON.stringify(sanitizeDebugPayload(res)));
       } else {
@@ -578,9 +592,25 @@ export class DeviceCommands {
       }
 
       if (code === 'Failure_ProcessError') {
+        const normalizedMessage = message?.trim() ?? '';
+        const isLegacyProtocolV2ActionCancelledFailure =
+          this.device.isProtocolV2() &&
+          /^(?:cancelled on device|confirm dismissed)$/i.test(normalizedMessage);
         const isLegacyProtocolV2LockedFailure =
-          this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(message?.trim() ?? '');
-        if (subcode === 9 || isLegacyProtocolV2LockedFailure) {
+          this.device.isProtocolV2() && /^device (?:is )?locked$/i.test(normalizedMessage);
+        if (
+          subcode === DeviceErrorCode.DeviceError_ActionCancelled ||
+          isLegacyProtocolV2ActionCancelledFailure
+        ) {
+          error = ERRORS.TypedError(HardwareErrorCode.ActionCancelled, message, {
+            failureCode: code,
+            subcode,
+            firmwareMessage: message,
+          });
+        } else if (
+          subcode === DeviceErrorCode.DeviceError_DeviceLocked ||
+          isLegacyProtocolV2LockedFailure
+        ) {
           error = ERRORS.TypedError(HardwareErrorCode.DeviceLocked, message, {
             failureCode: code,
             subcode,

package/src/device/DeviceFeaturesState.ts

@@ -10,11 +10,11 @@ export type DeviceFeaturesUpdateSource =
   | 'cache';
 
 /**
- * 合并设备状态的字段级 patch。
+ * Merge a field-level device-state patch.
  *
- * `undefined` 表示本次响应未提供该字段，不覆盖缓存；`null` 表示设备明确
- * 返回空值，需要写入缓存。raw 等对象字段由调用方构造完整值后再传入，
- * 这里不做隐式深合并。
+ * `undefined` means the response omitted a field and preserves the cache; `null`
+ * means the device explicitly returned an empty value and must be cached. Callers
+ * provide complete object fields such as raw; this function does not deep-merge.
  */
 export function mergeDeviceFeaturesPatch(previous: Features, patch: Partial<Features>): Features {
   let next = previous;

package/src/device/DevicePool.ts

@@ -160,7 +160,7 @@ export class DevicePool extends EventEmitter {
       try {
         await device.initialize(initOptions);
         if (initOptions?.refreshRuntimeState && device.isProtocolV2()) {
-          await device.getDeviceState({ refreshSections: ['status'] });
+          await this._refreshProtocolV2DiscoveryState(device);
         }
       } finally {
         await device.release();
@@ -175,9 +175,9 @@ export class DevicePool extends EventEmitter {
     await device.run(
       async () => {
         try {
-          await device.getDeviceState({ refreshSections: ['status'] });
+          await this._refreshProtocolV2DiscoveryState(device);
         } catch (error) {
-          // Device.run 在回调正常结束后统一 release；随后再把真实读取错误交给调用方。
+          // Device.run releases after the callback; then propagate the actual read error.
           refreshError = error;
         }
       },
@@ -187,6 +187,20 @@ export class DevicePool extends EventEmitter {
     if (refreshError) throw new Error(String(refreshError));
   }
 
+  /**
+   * Device lists require live mode and name data. A status failure remains a connection
+   * error; settings only supplies a label, so its failure retains the existing name.
+   * Device.getDeviceState skips unsupported status/settings calls in loader mode.
+   */
+  static async _refreshProtocolV2DiscoveryState(device: Device) {
+    await device.getDeviceState({ refreshSections: ['status'] });
+    try {
+      await device.getDeviceState({ refreshSections: ['settings'] });
+    } catch (error) {
+      Log.debug('Unable to refresh Protocol V2 device label during discovery', error);
+    }
+  }
+
   static async _checkDevicePool(initOptions?: InitOptions, connectId?: string) {
     await this._sendConnectMessage(initOptions, connectId);
     this._sendDisconnectMessage();

package/src/device/DeviceStateMapper.ts

@@ -1,11 +1,15 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
 import { buildProtocolV1FeaturesPayload } from '../deviceProfile/buildDeviceFeatures';
-import {
-  isProtocolV2BootloaderDeviceInfo,
-  isProtocolV2RomloaderDeviceInfo,
-} from '../protocols/protocol-v2/features';
+import { mapLanguageToProtocolV2 } from '../utils/deviceSettings';
 
+import type {
+  ApplySettings,
+  DeviceFirmwareImageInfo,
+  DeviceSettings,
+  DeviceStatus,
+  ProtocolV2DeviceInfo,
+} from '@onekeyfe/hd-transport';
 import type { PROTO } from '../constants';
 import type {
   DeviceFeaturesVerify,
@@ -15,13 +19,6 @@ import type {
   OnekeyFeatures,
 } from '../types';
 import type { DeviceSettingsParams } from '../types/api/deviceSettings';
-import type {
-  ApplySettings,
-  DeviceFirmwareImageInfo,
-  DeviceSettings,
-  DeviceStatus,
-  ProtocolV2DeviceInfo,
-} from '@onekeyfe/hd-transport';
 
 const definedEntries = <T extends Record<string, unknown>>(value: T): T =>
   Object.fromEntries(
@@ -113,8 +110,9 @@ export const mapFeaturesToState = (features: Features): DeviceStatePatch => ({
     bootloader: features.bootloaderVersion,
     board: features.boardVersion,
     ble: features.bleVersion,
+    // Legacy devices expose one SE version; project it to se01 and keep se as an alias.
     se: features.seVersion,
-    se01: features.se01Version,
+    se01: features.se01Version ?? features.seVersion,
     se02: features.se02Version,
     se03: features.se03Version,
     se04: features.se04Version,
@@ -125,10 +123,6 @@ export const mapFeaturesToState = (features: Features): DeviceStatePatch => ({
   },
   capabilities: features.capabilities,
   verification: definedEntries(features.verify ?? {}),
-  session: {
-    sessionId: features.sessionId,
-    passphraseState: features.passphraseState,
-  },
   raw: features.raw,
 });
 
@@ -193,19 +187,9 @@ export const mapProtocolV1OnekeyFeaturesToState = (features: OnekeyFeatures): De
 
 export const mapProtocolV2DeviceInfoToState = (
   info: ProtocolV2DeviceInfo,
-  currentMode?: DeviceStateMode
+  mode: DeviceStateMode = 'unknown'
 ): DeviceStatePatch => {
-  const romloader = isProtocolV2RomloaderDeviceInfo(info);
-  const bootloader = isProtocolV2BootloaderDeviceInfo(info);
-  const loader = romloader || bootloader;
-  let mode: DeviceStateMode = 'normal';
-  if (romloader) {
-    mode = 'romloader';
-  } else if (bootloader) {
-    mode = 'bootloader';
-  } else if (currentMode === 'notInitialized' || currentMode === 'backupMode') {
-    mode = currentMode;
-  }
+  const loader = mode === 'bootloader' || mode === 'romloader';
 
   return {
     protocol: 'V2',
@@ -350,7 +334,7 @@ export const mapCommonSettingsToProtocolV2 = (settings: DeviceSettingsParams): D
   definedEntries({
     label: settings.label,
     bt_enable: settings.bluetoothEnabled,
-    language: settings.language,
+    language: mapLanguageToProtocolV2(settings.language),
     brightness: settings.brightness,
     autolock_delay_ms: settings.autoLockDelayMs,
     autoshutdown_delay_ms: settings.autoShutdownDelayMs,

package/src/device/DeviceStateProjector.ts

@@ -1,25 +1,29 @@
-import type { DeviceFeaturesRaw, DeviceState, DeviceStateSession, Features } from '../types';
+import { cloneDeviceState } from './cloneDeviceState';
+
+import type { DeviceFeaturesRaw, DeviceState, Features } from '../types';
 
 type StoredDeviceState = DeviceState & {
   raw?: DeviceFeaturesRaw;
-  session?: DeviceStateSession;
 };
 
 const getBootloaderMode = (state: StoredDeviceState) =>
   state.status.mode === 'bootloader' || state.status.mode === 'romloader';
 
 export const projectFeatures = (state: StoredDeviceState): Features => {
-  const snapshot = structuredClone(state);
+  const snapshot = cloneDeviceState(state);
   const rawFeatures = snapshot.raw?.protocolV1Features ?? {};
+  const publicRawFeatures = { ...rawFeatures } as Record<string, unknown>;
+  delete publicRawFeatures.session_id;
+  delete publicRawFeatures.sessionId;
+  delete publicRawFeatures.passphraseState;
   const rawOneKeyFeatures = snapshot.raw?.protocolV1OneKeyFeatures ?? {};
-  const sessionId = snapshot.session?.sessionId ?? null;
   const bootloaderMode =
     snapshot.protocol === 'V1'
       ? (rawFeatures as { bootloader_mode?: boolean | null }).bootloader_mode ?? null
       : getBootloaderMode(snapshot);
 
   return {
-    ...rawFeatures,
+    ...publicRawFeatures,
     ...rawOneKeyFeatures,
     protocol: snapshot.protocol,
     protocolVersion: snapshot.protocolVersion ?? (snapshot.protocol === 'V1' ? 1 : null),
@@ -80,13 +84,12 @@ export const projectFeatures = (state: StoredDeviceState): Features => {
     se04BootVersion: snapshot.versions.se04Boot,
     seVersion: snapshot.versions.se ?? null,
     verify: snapshot.verification,
-    sessionId,
-    passphraseState: snapshot.session?.passphraseState,
     raw: snapshot.raw,
     device_id: snapshot.identity.deviceId ?? undefined,
-    session_id: sessionId ?? undefined,
     ble_name: snapshot.identity.bleName ?? undefined,
     passphrase_protection: snapshot.status.passphraseProtection ?? undefined,
     bootloader_mode: bootloaderMode,
+    sessionId: null,
+    session_id: null,
   } as unknown as Features;
 };

package/src/device/DeviceStateStore.ts

@@ -1,17 +1,17 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
+import { cloneDeviceState } from './cloneDeviceState';
+
 import type {
   DeviceFeaturesRaw,
   DeviceState,
   DeviceStateIdentity,
   DeviceStatePatch,
-  DeviceStateSession,
   DeviceStateUpdateSource,
 } from '../types';
 
 type StoredDeviceState = DeviceState & {
   raw?: DeviceFeaturesRaw;
-  session?: DeviceStateSession;
 };
 
 export type DeviceStateUpdateResult = {
@@ -21,22 +21,6 @@ export type DeviceStateUpdateResult = {
   changedKeys: string[];
 };
 
-const PRODUCT_DISPLAY_NAMES: Partial<Record<DeviceStateIdentity['deviceType'], string>> = {
-  [EDeviceType.Classic]: 'OneKey Classic',
-  [EDeviceType.Classic1s]: 'OneKey Classic 1S',
-  [EDeviceType.ClassicPure]: 'OneKey Classic 1S Pure',
-  [EDeviceType.Mini]: 'OneKey Mini',
-  [EDeviceType.Touch]: 'OneKey Touch',
-  [EDeviceType.Pro]: 'OneKey Pro',
-  [EDeviceType.Pro2]: 'OneKey Pro 2',
-};
-
-const getModelDisplayName = (deviceType: DeviceStateIdentity['deviceType']) =>
-  PRODUCT_DISPLAY_NAMES[deviceType] ?? 'OneKey';
-
-const getDisplayName = (identity: DeviceStateIdentity) =>
-  identity.label || identity.bleName || getModelDisplayName(identity.deviceType);
-
 export function createEmptyDeviceState(
   identity: Partial<DeviceStateIdentity> = {}
 ): StoredDeviceState {
@@ -49,10 +33,8 @@ export function createEmptyDeviceState(
     serialNo: '',
     label: null,
     bleName: null,
-    displayName: '',
     ...identity,
   };
-  normalizedIdentity.displayName = getDisplayName(normalizedIdentity);
 
   return {
     schemaVersion: 1,
@@ -128,7 +110,7 @@ export class DeviceStateStore {
   private state: StoredDeviceState | undefined;
 
   constructor(initial?: StoredDeviceState) {
-    this.state = initial ? structuredClone(initial) : undefined;
+    this.state = initial ? cloneDeviceState(initial) : undefined;
   }
 
   getState() {
@@ -138,7 +120,7 @@ export class DeviceStateStore {
   replace(state: StoredDeviceState, source: DeviceStateUpdateSource): DeviceStateUpdateResult {
     const revision = (this.state?.revision ?? 0) + 1;
     this.state = {
-      ...structuredClone(state),
+      ...cloneDeviceState(state),
       revision,
       updatedAt: Date.now(),
     };
@@ -151,7 +133,7 @@ export class DeviceStateStore {
   }
 
   update(patch: DeviceStatePatch, source: DeviceStateUpdateSource): DeviceStateUpdateResult {
-    const next = structuredClone(this.state ?? createEmptyDeviceState());
+    const next = cloneDeviceState(this.state ?? createEmptyDeviceState());
     const changedKeys: string[] = [];
 
     if (patch.protocol !== undefined && patch.protocol !== next.protocol) {
@@ -168,13 +150,13 @@ export class DeviceStateStore {
     if (patch.versions) applySectionPatch(next.versions, patch.versions, 'versions', changedKeys);
 
     if (patch.capabilities !== undefined && !isEqual(next.capabilities, patch.capabilities)) {
-      next.capabilities = structuredClone(patch.capabilities);
+      next.capabilities = cloneDeviceState(patch.capabilities);
       changedKeys.push('capabilities');
     }
     if (patch.verification !== undefined) {
       const mergedVerification = {
-        ...structuredClone(next.verification ?? {}),
-        ...structuredClone(patch.verification),
+        ...cloneDeviceState(next.verification ?? {}),
+        ...cloneDeviceState(patch.verification),
       };
       if (!isEqual(next.verification, mergedVerification)) {
         next.verification = mergedVerification;
@@ -182,12 +164,12 @@ export class DeviceStateStore {
       }
     }
     if (patch.raw !== undefined) {
-      const mergedRaw = structuredClone(next.raw ?? {});
+      const mergedRaw = cloneDeviceState(next.raw ?? {});
       for (const [key, value] of Object.entries(patch.raw)) {
         if (value === null) {
           delete mergedRaw[key as keyof typeof mergedRaw];
         } else if (value !== undefined) {
-          mergedRaw[key as keyof typeof mergedRaw] = structuredClone(value) as never;
+          mergedRaw[key as keyof typeof mergedRaw] = cloneDeviceState(value) as never;
         }
       }
       if (!isEqual(next.raw, mergedRaw)) {
@@ -195,23 +177,6 @@ export class DeviceStateStore {
         changedKeys.push('raw');
       }
     }
-    if (patch.session === null) {
-      if (next.session !== undefined) {
-        delete next.session;
-        changedKeys.push('session');
-      }
-    } else if (patch.session) {
-      const session = next.session ?? { sessionId: null };
-      applySectionPatch(session, patch.session, 'session', changedKeys);
-      next.session = session;
-    }
-
-    const displayName = getDisplayName(next.identity);
-    if (displayName !== next.identity.displayName) {
-      next.identity.displayName = displayName;
-      changedKeys.push('identity.displayName');
-    }
-
     if (changedKeys.length > 0) {
       next.revision = (this.state?.revision ?? 0) + 1;
       next.updatedAt = Date.now();
@@ -227,16 +192,10 @@ export class DeviceStateStore {
       changedKeys,
     };
   }
-
-  clearSession(source: DeviceStateUpdateSource) {
-    if (!this.state?.session) return undefined;
-    return this.update({ session: null }, source);
-  }
 }
 
 export const createPublicDeviceState = (state: StoredDeviceState): DeviceState => {
-  const snapshot = structuredClone(state);
+  const snapshot = cloneDeviceState(state);
   delete snapshot.raw;
-  delete snapshot.session;
   return snapshot;
 };

package/src/device/DeviceWalletSessionStore.ts

@@ -49,7 +49,7 @@ export class DeviceWalletSessionStore {
     this.pendingSessions.delete(deviceKey);
   }
 
-  migrateDeviceKey(from: string, to: string) {
+  private migrateTemporaryDeviceKey(from: string, to: string) {
     if (!from || !to || from === to) return;
 
     const sourceSessions = this.walletSessions.get(from);
@@ -57,15 +57,42 @@ export class DeviceWalletSessionStore {
       const targetSessions = this.walletSessions.get(to) ?? new Map<string, string>();
       this.walletSessions.set(to, targetSessions);
       sourceSessions.forEach((sessionId, passphraseState) => {
-        targetSessions.set(passphraseState, sessionId);
+        if (!targetSessions.has(passphraseState)) {
+          targetSessions.set(passphraseState, sessionId);
+        }
       });
       this.walletSessions.delete(from);
     }
 
     const pendingSession = this.pendingSessions.get(from);
-    if (pendingSession) {
+    if (pendingSession && !this.pendingSessions.has(to)) {
       this.pendingSessions.set(to, pendingSession);
-      this.pendingSessions.delete(from);
+    }
+    this.pendingSessions.delete(from);
+  }
+
+  reconcileDeviceIdentity({
+    temporaryKey,
+    previousDeviceId,
+    nextDeviceId,
+  }: {
+    temporaryKey?: string;
+    previousDeviceId?: string;
+    nextDeviceId?: string;
+  }) {
+    if (!nextDeviceId) return;
+
+    // A stable identity changing from A to B means the descriptor now refers to a
+    // different physical device. Never copy A's wallet sessions into B's cache.
+    if (previousDeviceId && previousDeviceId !== nextDeviceId) {
+      this.deleteDevice(previousDeviceId);
+      return;
+    }
+
+    // Migration is allowed only for the first promotion from a transport-local
+    // descriptor key to a firmware-provided stable identity.
+    if (!previousDeviceId && temporaryKey) {
+      this.migrateTemporaryDeviceKey(temporaryKey, nextDeviceId);
     }
   }
 

package/src/device/cloneDeviceState.ts

@@ -0,0 +1,39 @@
+/**
+ * Host-independent deep clone for DeviceState snapshots.
+ *
+ * Avoid the global structuredClone API because older Hermes and WebView hosts do not
+ * provide it. Explicitly clone plain objects, arrays, binary buffers, and common
+ * built-ins so initialization and state snapshots remain portable.
+ */
+export const cloneDeviceState = <T>(value: T): T => {
+  if (value === null || typeof value !== 'object') {
+    return value;
+  }
+
+  // Copy underlying binary memory so external mutation cannot alter a snapshot.
+  if (value instanceof Uint8Array) {
+    return new Uint8Array(value) as unknown as T;
+  }
+  if (value instanceof ArrayBuffer) {
+    return value.slice(0) as unknown as T;
+  }
+
+  if (value instanceof Date) {
+    return new Date(value.getTime()) as unknown as T;
+  }
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags) as unknown as T;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(item => cloneDeviceState(item)) as unknown as T;
+  }
+
+  // DeviceState contains only plain objects at this boundary.
+  const cloned: Record<string, unknown> = {};
+  const source = value as Record<string, unknown>;
+  for (const key of Object.keys(source)) {
+    cloned[key] = cloneDeviceState(source[key]);
+  }
+  return cloned as unknown as T;
+};

package/src/device/deviceIdentity.ts

@@ -3,8 +3,8 @@ import type { Device } from './Device';
 type DeviceIdentityReader = Pick<Device, 'isProtocolV2' | 'getDeviceState' | 'checkDeviceId'>;
 
 /**
- * Protocol V2 的 deviceId 来自运行态状态，比较前必须读取一次实时 status。
- * Protocol V1 继续复用 Initialize/GetFeatures 已经返回的设备身份。
+ * Protocol V2 deviceId comes from runtime state and requires a live status read.
+ * Protocol V1 reuses the identity returned by Initialize/GetFeatures.
  */
 export async function checkLiveDeviceId(
   device: DeviceIdentityReader,