@onekeyfe/hd-core 1.1.27-patch.1 → 1.2.0-alpha.0

package/src/device/Device.ts

@@ -19,21 +19,30 @@ import {
   getDeviceLabel,
   getDeviceType,
   getDeviceUUID,
+  getFirmwareType,
   getLogger,
-  getMethodVersionRange,
 } from '../utils';
 import {
   fixFeaturesFirmwareVersion,
   getPassphraseStateWithRefreshDeviceInfo,
+  supportInputPinOnSoftware,
+  supportModifyHomescreen,
 } from '../utils/deviceFeaturesUtils';
 import { generateInstanceId } from '../utils/tracing';
 // eslint-disable-next-line import/no-cycle
 import { DeviceCommands } from './DeviceCommands';
 import {
   type DeviceFirmwareRange,
+  DeviceModelToTypes,
+  DeviceTypeToModels,
   type Device as DeviceTyped,
   EOneKeyDeviceMode,
   type Features,
+  type IDeviceModel,
+  type IDeviceType,
+  type IVersionArray,
+  type IVersionRange,
+  type SupportFeatureType,
   type UnavailableCapabilities,
 } from '../types';
 import { DEVICE, UI_REQUEST } from '../events';
@@ -41,6 +50,15 @@ import { DataManager } from '../data-manager';
 import TransportManager from '../data-manager/TransportManager';
 import { toHardened } from '../api/helpers/pathUtils';
 import { existCapability } from '../utils/capabilitieUtils';
+import {
+  PROTOCOL_V2_STATUS_DEVICE_INFO_REQUEST,
+  requestProtocolV2DeviceInfo,
+} from '../protocols/protocol-v2/features';
+import {
+  buildProfileFromProtocolV1,
+  buildProfileFromProtocolV2,
+  buildProtocolV2GetFeaturesPayload,
+} from '../deviceProfile';
 
 import type { PROTO } from '../constants';
 import type {
@@ -49,15 +67,21 @@ import type {
   PassphraseRequestPayload,
 } from '../events';
 import type { PassphrasePromptResponse } from './DeviceCommands';
-import type { Deferred } from '@onekeyfe/hd-shared';
-import type { OneKeyDeviceInfo as DeviceDescriptor } from '@onekeyfe/hd-transport';
+import type { Deferred, HardwareConnectProtocol } from '@onekeyfe/hd-shared';
+import type {
+  OneKeyDeviceInfo as DeviceDescriptor,
+  ProtocolV2DeviceInfo,
+  Success,
+} from '@onekeyfe/hd-transport';
 import type DeviceConnector from './DeviceConnector';
+import type { DeviceProfile } from '../types/api/getDeviceInfo';
 
 export type InitOptions = {
   initSession?: boolean;
   deviceId?: string;
   passphraseState?: string;
   deriveCardano?: boolean;
+  connectProtocol?: HardwareConnectProtocol;
 };
 
 export type RunOptions = {
@@ -72,6 +96,11 @@ const parseRunOptions = (options?: RunOptions): RunOptions => {
 
 const Log = getLogger(LoggerNames.Device);
 
+const profileVersionToArray = (version?: string | null): IVersionArray | null => {
+  if (!version) return null;
+  return version.split('.').map(part => Number(part) || 0) as IVersionArray;
+};
+
 export interface DeviceEvents {
   [DEVICE.PIN]: [Device, PROTO.PinMatrixRequestType | undefined, (err: any, pin: string) => void];
   [DEVICE.PASSPHRASE_ON_DEVICE]: [Device, ((response: any) => void)?];
@@ -167,12 +196,39 @@ export class Device extends EventEmitter {
   private deviceAcquired = false;
 
   /**
-   * 设备信息
+   * 唯一设备状态缓存。
+   *
+   * V1 直接保存原生 Features；V2 保存由 DevGetDeviceInfo/profile 映射出的
+   * legacy Features 兼容视图。profile 作为结构化视图按需由 features 派生，
+   * 不再单独维护第二份缓存。
    */
   features: Features | undefined = undefined;
 
+  private getFeaturesProfile(): DeviceProfile | undefined {
+    if (!this.features) return undefined;
+    const protocol = this.originalDescriptor.protocolType === 'V2' ? 'V2' : 'V1';
+    return buildProfileFromProtocolV1({
+      protocol,
+      features: this.features,
+      onekeyFeatures: this.features as Parameters<typeof buildProfileFromProtocolV1>[0]['onekeyFeatures'],
+      sources: ['features'],
+      scope: 'verify',
+    });
+  }
+
+  get profile(): DeviceProfile | undefined {
+    return this.getFeaturesProfile();
+  }
+
+  set profile(profile: DeviceProfile | undefined) {
+    this.updateProfile(profile);
+  }
+
   /**
-   * 是否需要更新设备信息
+   * 是否需要更新设备信息。
+   *
+   * 历史名称保留用于兼容现有调用语义；对 V2 表示 features 需要由
+   * DevGetDeviceInfo 刷新。
    */
   featuresNeedsReload = false;
 
@@ -228,32 +284,38 @@ export class Device extends EventEmitter {
 
   // simplified object to pass via postMessage
   toMessageObject(): DeviceTyped | null {
-    if (this.isUnacquired() || !this.features) return null;
+    if (this.isUnacquired()) return null;
 
     const env = DataManager.getSettings('env');
-    const deviceType = getDeviceType(this.features);
+    const deviceType = this.getCurrentDeviceType();
 
-    const bleName = getDeviceBleName(this.features);
-    const label = getDeviceLabel(this.features);
+    const bleName = this.getCurrentBleName();
+    const label = this.getCurrentLabel();
+    const serialNo = this.getCurrentSerialNo();
+    const deviceId = this.getCurrentDeviceId() || null;
+
+    const features = this.features;
 
     return {
       /** Android uses Mac address, iOS uses uuid, USB uses uuid  */
-      connectId: DataManager.isBleConnect(env) ? this.mainId || null : getDeviceUUID(this.features),
+      connectId: DataManager.isBleConnect(env) ? this.mainId || null : serialNo,
       /** Hardware ID, will not change at any time */
-      uuid: getDeviceUUID(this.features),
+      uuid: serialNo,
       commType: this.originalDescriptor.commType,
       sdkInstanceId: this.sdkInstanceId,
       instanceId: this.instanceId,
       createdAt: this.createdAt,
       deviceType,
       /** ID for current seeds, will clear after replace a new seed at device */
-      deviceId: this.features.device_id || null,
+      deviceId,
       path: this.originalDescriptor?.path,
       bleName,
       name: bleName || label || `OneKey ${deviceType?.toUpperCase()}`,
       label: label || 'OneKey',
       mode: this.getMode(),
-      features: this.features,
+      features,
+      profile: this.profile,
+      sessionId: this.features?.session_id ?? null,
       firmwareVersion: this.getFirmwareVersion(),
       bleFirmwareVersion: this.getBLEFirmwareVersion(),
       unavailableCapabilities: this.unavailableCapabilities,
@@ -264,13 +326,13 @@ export class Device extends EventEmitter {
    * Device connect
    * @returns {Promise<boolean>}
    */
-  connect() {
+  connect(connectProtocol?: HardwareConnectProtocol) {
     const env = DataManager.getSettings('env');
     // eslint-disable-next-line no-async-promise-executor
     return new Promise<boolean>(async (resolve, reject) => {
       if (DataManager.isBleConnect(env)) {
         try {
-          await this.acquire();
+          await this.acquire(connectProtocol);
           resolve(true);
         } catch (error) {
           reject(error);
@@ -280,7 +342,7 @@ export class Device extends EventEmitter {
       // 不存在 Session ID 或存在 Session ID 但设备在别处使用，都需要 acquire 获取最新 sessionID
       if (!this.mainId || (!this.isUsedHere() && this.originalDescriptor)) {
         try {
-          await this.acquire();
+          await this.acquire(connectProtocol);
           resolve(true);
         } catch (error) {
           reject(error);
@@ -295,23 +357,49 @@ export class Device extends EventEmitter {
     });
   }
 
-  async acquire() {
+  async acquire(connectProtocol?: HardwareConnectProtocol) {
     const env = DataManager.getSettings('env');
     const mainIdKey = DataManager.isBleConnect(env) ? 'id' : 'session';
+    const expectedProtocol = connectProtocol ?? this.originalDescriptor.protocolType;
     try {
+      let acquireResult: unknown;
       if (DataManager.isBleConnect(env)) {
-        const res = await this.deviceConnector?.acquire(this.originalDescriptor.id);
-        this.mainId = (res as unknown as any).uuid ?? '';
+        // forceCleanRunPromise=true（自 e21b83c6 引入，修复 Pro2 BLE 重连）：
+        // acquire 意味着开启一个全新会话，transport 里残留的上一次 runPromise
+        // 必然属于已死亡的会话（如固件升级重启、探测中断），不清理会让新会话的
+        // 调用被旧 promise 卡死。无法在 Device 层面区分“重连恢复”与普通 acquire，
+        // 因此对 BLE acquire 恒清理是有意为之。
+        acquireResult = await this.deviceConnector?.acquire(
+          this.originalDescriptor.id,
+          undefined,
+          true,
+          expectedProtocol
+        );
+        this.mainId = (acquireResult as any)?.uuid ?? '';
         Log.debug('Expected uuid:', this.mainId);
       } else {
-        this.mainId = await this.deviceConnector?.acquire(
+        acquireResult = await this.deviceConnector?.acquire(
           this.originalDescriptor.path,
-          this.originalDescriptor.session
+          this.originalDescriptor.session,
+          undefined,
+          expectedProtocol
         );
+        this.mainId = acquireResult as string | undefined;
         Log.debug('Expected session id:', this.mainId);
       }
       this.deviceAcquired = true;
       this.updateDescriptor({ [mainIdKey]: this.mainId } as unknown as DeviceDescriptor);
+
+      // Propagate protocol version detected during acquire.
+      const detectedProtocol =
+        (acquireResult as { protocolType?: HardwareConnectProtocol } | undefined)?.protocolType ??
+        TransportManager.transport?.getProtocolType?.(
+          DataManager.isBleConnect(env) ? this.originalDescriptor.id : this.originalDescriptor.path
+        );
+      if (detectedProtocol) {
+        this.originalDescriptor.protocolType = detectedProtocol;
+      }
+
       if (this.commands) {
         await this.commands.dispose(false);
       }
@@ -368,12 +456,10 @@ export class Device extends EventEmitter {
   }
 
   /**
-   * Pre-initialize: connect + Initialize ahead of the sign. Only runs the
-   * fallback init when features are missing (gate on `!this.features`, not
-   * isUsedHere which is always false on BLE); otherwise just records the mark.
+   * Pre-initialize: connect + Initialize ahead of the sign.
    */
   async preInitialize(initOptions?: InitOptions) {
-    if (!this.features) {
+    if (this.isUnacquired()) {
       await this.acquire();
       await this.initialize(initOptions);
     }
@@ -419,6 +505,157 @@ export class Device extends EventEmitter {
     return this.commands;
   }
 
+  /**
+   * 唯一协议判别器。
+   *
+   * descriptor.protocolType 是协议探测后的结果；V2 features 由 DevGetDeviceInfo
+   * 映射产生，profile 只是 features 的结构化视图。
+   * 全 SDK 的协议分支都必须走这里，不要直接读 originalDescriptor.protocolType
+   * 或 profile.protocol。
+   */
+  getProtocol(): 'V1' | 'V2' {
+    return this.originalDescriptor.protocolType === 'V2' ? 'V2' : 'V1';
+  }
+
+  isProtocolV2() {
+    return this.getProtocol() === 'V2';
+  }
+
+  getCurrentDeviceType() {
+    return this.profile?.deviceType ?? getDeviceType(this.features);
+  }
+
+  getCurrentDeviceId() {
+    if (this.profile) {
+      return this.profile.deviceId || undefined;
+    }
+    return this.features?.device_id || undefined;
+  }
+
+  getCurrentSerialNo() {
+    if (this.profile) {
+      return this.profile.serialNo || '';
+    }
+    return this.features ? getDeviceUUID(this.features) : '';
+  }
+
+  getCurrentBleName() {
+    // V2 不回退 legacy features，避免缓存残留的 V1 数据泄漏到 Pro2 视图
+    if (this.isProtocolV2()) return this.profile?.bleName ?? null;
+    return this.profile?.bleName ?? getDeviceBleName(this.features);
+  }
+
+  getCurrentLabel() {
+    if (this.isProtocolV2()) return this.profile?.label ?? null;
+    return this.profile?.label ?? getDeviceLabel(this.features);
+  }
+
+  getCurrentPassphraseProtection() {
+    if (this.profile) {
+      return this.profile.status.passphraseProtection;
+    }
+    return this.features?.passphrase_protection;
+  }
+
+  getCurrentFirmwareType() {
+    return this.profile?.firmwareType ?? getFirmwareType(this.features);
+  }
+
+  getCurrentFirmwareVersionString() {
+    return this.profile?.versions.firmware ?? getDeviceFirmwareVersion(this.features)?.join('.');
+  }
+
+  getCurrentBLEFirmwareVersionString() {
+    if (this.profile?.versions.ble) return this.profile.versions.ble;
+    if (!this.features) return undefined;
+    return getDeviceBLEFirmwareVersion(this.features).join('.');
+  }
+
+  getCurrentSafetyChecks() {
+    return this.features?.safety_checks;
+  }
+
+  getCurrentMethodVersionRange(
+    getVersionRange: (deviceModel: IDeviceType | IDeviceModel) => IVersionRange | undefined
+  ) {
+    const deviceType = this.getCurrentDeviceType();
+    const versionRange = getVersionRange(deviceType);
+    if (versionRange) return versionRange;
+
+    // Most-specific model first; must match getMethodVersionRange in deviceInfoUtils,
+    // otherwise e.g. Classic1s resolves the looser model_mini range before model_classic1s.
+    const modelFallbacks: IDeviceModel[] = [
+      'model_classic1s',
+      'model_classic',
+      'model_mini',
+      'model_touch',
+    ];
+    for (const model of modelFallbacks) {
+      if (DeviceTypeToModels[deviceType]?.includes(model)) {
+        const fallbackRange = getVersionRange(model);
+        if (fallbackRange) return fallbackRange;
+      }
+    }
+    return undefined;
+  }
+
+  supportNewPassphrase(): SupportFeatureType {
+    const deviceType = this.getCurrentDeviceType();
+    if (
+      deviceType === EDeviceType.Touch ||
+      deviceType === EDeviceType.Pro ||
+      deviceType === EDeviceType.Pro2
+    ) {
+      return { support: true };
+    }
+
+    const firmwareVersion = this.getCurrentFirmwareVersionString();
+    return {
+      support: Boolean(firmwareVersion && semver.gte(firmwareVersion, '2.4.0')),
+      require: '2.4.0',
+    };
+  }
+
+  supportInputPinOnSoftware(): SupportFeatureType {
+    if (this.features) return supportInputPinOnSoftware(this.features);
+
+    const deviceType = this.getCurrentDeviceType();
+    if (
+      deviceType === EDeviceType.Touch ||
+      deviceType === EDeviceType.Pro ||
+      deviceType === EDeviceType.Pro2
+    ) {
+      return { support: false };
+    }
+
+    const firmwareVersion = this.getCurrentFirmwareVersionString();
+    return {
+      support: Boolean(firmwareVersion && semver.gte(firmwareVersion, '2.3.0')),
+      require: '2.3.0',
+    };
+  }
+
+  supportModifyHomescreen(): SupportFeatureType {
+    // Pro2 走独立 1.x 版本线，不能套用 Touch/Pro 的 3.4.0 门槛（恒 false 且未来会误判）。
+    // 依据：firmware-pro2 协议 schema（messages-protocol-v2.json）的 ApplySettings
+    // 包含 homescreen 字段，V2 固件从首个版本即支持修改主屏。
+    if (this.isProtocolV2()) {
+      return { support: true };
+    }
+
+    if (this.features) return supportModifyHomescreen(this.features);
+
+    const deviceType = this.getCurrentDeviceType();
+    if (DeviceModelToTypes.model_mini.includes(deviceType)) {
+      return { support: true };
+    }
+
+    const firmwareVersion = this.getCurrentFirmwareVersionString();
+    return {
+      support: Boolean(firmwareVersion && semver.gte(firmwareVersion, '3.4.0')),
+    };
+  }
+
   private generateStateKey(deviceId: string, passphraseState?: string) {
     if (passphraseState) {
       return `${deviceId}@${passphraseState}`;
@@ -432,10 +669,11 @@ export class Device extends EventEmitter {
       'getInternalState session param: ',
       `device_id: ${_deviceId}`,
       `features.device_id: ${this.features?.device_id}`,
+      `profile.deviceId: ${this.profile?.deviceId}`,
       `passphraseState: ${this.passphraseState}`
     );
 
-    const deviceId = _deviceId || this.features?.device_id;
+    const deviceId = _deviceId || this.getCurrentDeviceId();
     if (!deviceId) return undefined;
     // Security invariant: no passphraseState → no session lookup.
     // A previous fallback that scanned `${deviceId}@*` keys could silently
@@ -490,13 +728,13 @@ export class Device extends EventEmitter {
       `state: ${state}`,
       `initSession: ${initSession}`,
       `device_id: ${this.features?.device_id}`,
+      `profile.deviceId: ${this.profile?.deviceId}`,
       `passphraseState: ${this.passphraseState}`
     );
 
-    if (!this.features) return;
     if (!this.passphraseState && !initSession) return;
 
-    const deviceId = this.features?.device_id;
+    const deviceId = this.getCurrentDeviceId();
     if (!deviceId) return;
 
     const key = this.generateStateKey(deviceId, this.passphraseState);
@@ -510,7 +748,7 @@ export class Device extends EventEmitter {
   clearInternalState(_deviceId?: string) {
     Log.debug('clearInternalState param: ', _deviceId);
 
-    const deviceId = _deviceId || this.features?.device_id;
+    const deviceId = _deviceId || this.getCurrentDeviceId();
     if (!deviceId) return;
     const key = `${deviceId}`;
     delete deviceSessionCache[key];
@@ -522,6 +760,21 @@ export class Device extends EventEmitter {
   }
 
   async initialize(options?: InitOptions) {
+    // Protocol V2 不支持传统 Initialize，直接使用协议专用初始化流程。
+    if (this.isProtocolV2()) {
+      this.passphraseState = options?.passphraseState;
+      if (this.profile && !this.featuresNeedsReload && !options?.initSession) {
+        // 不能直接信任缓存 profile：设备端 wipe / 完成初始化 / 改 label 后
+        // profile 会永久陈旧。每次 run 做一次轻量 status 刷新（不含 fw/SE，
+        // 单帧请求开销很小），用 applyProfileUpdate 字段级合并，
+        // 不会降级已有的 verify / SE versions 数据。
+        await this._refreshProtocolV2Status();
+        return;
+      }
+      await this._initializeProtocolV2();
+      return;
+    }
+
     // Log.debug('initialize param:', options);
 
     this.passphraseState = options?.passphraseState;
@@ -565,9 +818,91 @@ export class Device extends EventEmitter {
     }
   }
 
+  /**
+   * Device initialization over Protocol V2.
+   *
+   * Protocol V2 不走传统 Initialize/GetFeatures；DeviceProfile 作为标准模型，
+   * 同时维护一份由 profile/deviceInfo 适配出的 legacy Features，兼容旧方法内部判断。
+   */
+  private async _initializeProtocolV2() {
+    Log.debug('Initialize device via Protocol V2 profile adapter');
+
+    try {
+      // 超时由 requestProtocolV2DeviceInfo 内部的 typedCall timeoutMs（默认 10s）负责，
+      // 不再额外包一层 Promise.race：外层 race 的 timer 不会清理，
+      // 且 reject 后底层调用仍会残留。
+      const deviceInfo = await requestProtocolV2DeviceInfo({
+        commands: this.commands,
+      });
+      // 默认请求不含 SE/hash 数据，scope 如实标注为 basic；
+      // 完整数据由 getDeviceInfo(scope:'verify'|'full') 获取。
+      const profile = this.applyProfileUpdate(
+        buildProfileFromProtocolV2({
+          deviceInfo,
+          sources: ['deviceInfo'],
+          scope: 'basic',
+          fallbackSerialNo: this.originalDescriptor?.path,
+        }),
+        deviceInfo
+      );
+      Log.debug('Protocol V2 profile:', profile);
+      this.featuresNeedsReload = false;
+    } catch (error) {
+      Log.error('Protocol V2 initialization failed:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Protocol V2 的轻量状态刷新（每次 run 前调用）。
+   *
+   * 请求 hw + bt + status（不含 fw/SE target）：status 提供 init_states / label /
+   * passphrase_protection 等会在设备端变化的字段；hw/bt 提供 serialNo / bleName，
+   * 避免 applyProfileUpdate 的顶层字段覆盖把已有身份字段清空。
+   * versions 为空时按字段级合并保留旧值，verify 数据不会被降级。
+   */
+  private async _refreshProtocolV2Status() {
+    try {
+      const deviceInfo = await requestProtocolV2DeviceInfo({
+        commands: this.commands,
+        request: PROTOCOL_V2_STATUS_DEVICE_INFO_REQUEST,
+      });
+      const profile = this.applyProfileUpdate(
+        buildProfileFromProtocolV2({
+          deviceInfo,
+          sources: ['deviceInfo'],
+          scope: 'basic',
+          fallbackSerialNo: this.originalDescriptor?.path,
+        }),
+        deviceInfo
+      );
+      Log.debug('Protocol V2 profile (status refresh):', profile);
+    } catch (error) {
+      Log.error('Protocol V2 status refresh failed:', error);
+      throw error;
+    }
+  }
+
   async getFeatures() {
+    if (this.isProtocolV2()) {
+      const deviceInfo = await requestProtocolV2DeviceInfo({
+        commands: this.commands,
+      });
+      const profile = this.applyProfileUpdate(
+        buildProfileFromProtocolV2({
+          deviceInfo,
+          sources: ['deviceInfo'],
+          scope: 'basic',
+          fallbackSerialNo: this.originalDescriptor?.path,
+        }),
+        deviceInfo
+      );
+      return this.features ?? this.updateProtocolV2Features(profile, deviceInfo);
+    }
+
     const { message } = await this.commands.typedCall('GetFeatures', 'Features', {});
     this._updateFeatures(message);
+    return message;
   }
 
   _updateFeatures(feat: Features, initSession?: boolean) {
@@ -575,7 +910,7 @@ export class Device extends EventEmitter {
     if (this.features && this.features.session_id && !feat.session_id) {
       feat.session_id = this.features.session_id;
     }
-    if (this.features && this.features.device_id && feat.session_id) {
+    if (this.getCurrentDeviceId() && feat.session_id) {
       this.setInternalState(feat.session_id, initSession);
     }
     feat.unlocked = feat.unlocked ?? true;
@@ -583,10 +918,81 @@ export class Device extends EventEmitter {
     feat = fixFeaturesFirmwareVersion(feat);
 
     this.features = feat;
+    if (!this.isProtocolV2()) {
+      this.updateProfile(
+        buildProfileFromProtocolV1({
+          features: feat,
+          sources: ['features'],
+        })
+      );
+    }
     this.featuresNeedsReload = false;
     this.emit(DEVICE.FEATURES, this, feat);
   }
 
+  updateProfile(profile: DeviceProfile | undefined) {
+    if (!profile) {
+      this.features = undefined;
+      return;
+    }
+    if (profile.protocol === 'V2') {
+      this.updateProtocolV2Features(profile, profile.raw?.protocolV2DeviceInfo);
+      return;
+    }
+    if (profile.raw?.features) {
+      this.features = fixFeaturesFirmwareVersion(profile.raw.features);
+    }
+  }
+
+  /**
+   * 字段级合并刷新 profile，并返回合并后的结果。
+   *
+   * basic 范围的刷新（initialize / getFeatures）拿不到 SE 版本和 verify 数据，
+   * 不能整体替换掉 getDeviceInfo(scope:'verify'|'full') 建立的完整 profile。
+   */
+  applyProfileUpdate(next: DeviceProfile, deviceInfo?: ProtocolV2DeviceInfo): DeviceProfile {
+    const prev = this.profile;
+    if (!prev || prev.protocol !== next.protocol) {
+      this.updateProfile({
+        ...next,
+        raw: {
+          ...next.raw,
+          ...(deviceInfo ? { protocolV2DeviceInfo: deviceInfo } : {}),
+        },
+      });
+      return next;
+    }
+
+    const versions = { ...prev.versions };
+    for (const [key, value] of Object.entries(next.versions)) {
+      if (value != null) {
+        (versions as Record<string, string | null | undefined>)[key] = value;
+      }
+    }
+
+    const merged: DeviceProfile = {
+      ...prev,
+      ...next,
+      versions,
+      verify: next.verify ?? prev.verify,
+      raw: {
+        ...prev.raw,
+        ...next.raw,
+        ...(deviceInfo ? { protocolV2DeviceInfo: deviceInfo } : {}),
+      },
+    };
+    this.updateProfile(merged);
+    return merged;
+  }
+
+  private updateProtocolV2Features(profile: DeviceProfile, deviceInfo?: ProtocolV2DeviceInfo) {
+    const features = fixFeaturesFirmwareVersion(
+      buildProtocolV2GetFeaturesPayload(profile, deviceInfo)
+    );
+    this._updateFeatures(features);
+    return features;
+  }
+
   /**
    * 暂时只在 acquire 后更新 Session ID
    * 后续看是否有需要依据 listen 返回结果更新
@@ -605,7 +1011,12 @@ export class Device extends EventEmitter {
     }
 
     if (forceUpdate) {
-      this.originalDescriptor = descriptor;
+      // 枚举得到的 descriptor 可能不带 protocolType（如 WebUSB enumerate），
+      // 不能让覆盖丢掉已探测的协议结果。
+      this.originalDescriptor = {
+        ...descriptor,
+        protocolType: descriptor.protocolType ?? this.originalDescriptor.protocolType,
+      };
     }
   }
 
@@ -616,6 +1027,7 @@ export class Device extends EventEmitter {
     if (device.features) {
       this._updateFeatures(device.features);
     }
+    this.updateProfile(device.profile);
   }
 
   async run(fn?: () => Promise<void>, options?: RunOptions) {
@@ -635,7 +1047,7 @@ export class Device extends EventEmitter {
       const env = DataManager.getSettings('env');
       if (env !== 'react-native') {
         try {
-          await this.acquire();
+          await this.acquire(options.connectProtocol);
         } catch (error) {
           this.runPromise = null;
           return Promise.reject(error);
@@ -748,6 +1160,16 @@ export class Device extends EventEmitter {
   }
 
   getMode() {
+    if (this.profile) {
+      if (this.profile.status.mode === 'bootloader') return EOneKeyDeviceMode.bootloader;
+      if (this.profile.status.mode === 'notInitialized') return EOneKeyDeviceMode.notInitialized;
+      if (this.profile.status.noBackup === true) return EOneKeyDeviceMode.backupMode;
+      if (this.profile.status.mode === 'normal') return EOneKeyDeviceMode.normal;
+      // mode 'unknown'（V2 设备未上报 init_states）保守按未初始化处理，
+      // 与 isInitialized() 的 fail-closed 行为保持一致。
+      if (this.isProtocolV2()) return EOneKeyDeviceMode.notInitialized;
+    }
+
     if (this.features?.bootloader_mode) {
       // bootloader mode
       return EOneKeyDeviceMode.bootloader;
@@ -768,11 +1190,17 @@ export class Device extends EventEmitter {
   }
 
   getFirmwareVersion() {
+    const profileVersion = profileVersionToArray(this.profile?.versions.firmware);
+    if (profileVersion) return profileVersion;
+    if (this.isProtocolV2()) return null;
     if (!this.features) return null;
     return getDeviceFirmwareVersion(this.features);
   }
 
   getBLEFirmwareVersion() {
+    const profileVersion = profileVersionToArray(this.profile?.versions.ble);
+    if (profileVersion) return profileVersion;
+    if (this.isProtocolV2()) return null;
     if (!this.features) return null;
     return getDeviceBLEFirmwareVersion(this.features);
   }
@@ -802,24 +1230,42 @@ export class Device extends EventEmitter {
   }
 
   isBootloader() {
+    if (this.profile) {
+      return (
+        this.profile.status.mode === 'bootloader' || this.profile.status.bootloaderMode === true
+      );
+    }
     return this.features && !!this.features.bootloader_mode;
   }
 
   isInitialized() {
+    if (this.profile) {
+      if (this.profile.status.initialized != null) return this.profile.status.initialized;
+      if (this.profile.status.mode === 'normal') return true;
+      if (this.profile.status.mode === 'notInitialized') return false;
+      // V2 设备未上报 init_states 时按未初始化处理（fail-closed）：
+      // 未知状态放行会让未初始化设备绕过 NOT_INITIALIZE 门禁。
+      if (this.isProtocolV2()) return false;
+      if (this.features) return !!this.features.initialized;
+      return false;
+    }
     return this.features && !!this.features.initialized;
   }
 
   isSeedless() {
+    if (this.profile) {
+      return this.profile.status.noBackup === true;
+    }
     return this.features && !!this.features.no_backup;
   }
 
   isUnacquired(): boolean {
-    return this.features === undefined;
+    return this.features === undefined && this.profile === undefined;
   }
 
   hasUnexpectedMode(allow: string[], require: string[]) {
     // both allow and require cases might generate single unexpected mode
-    if (this.features) {
+    if (!this.isUnacquired()) {
       // allow cases
       if (this.isBootloader() && !allow.includes(UI_REQUEST.BOOTLOADER)) {
         return UI_REQUEST.BOOTLOADER;
@@ -840,27 +1286,30 @@ export class Device extends EventEmitter {
   }
 
   hasUsePassphrase() {
+    const deviceType = this.getCurrentDeviceType();
     const isModeT =
-      getDeviceType(this.features) === EDeviceType.Touch ||
-      getDeviceType(this.features) === EDeviceType.Pro;
-    const preCheckTouch = isModeT && this.features?.unlocked === false;
-
-    return this.features && (!!this.features.passphrase_protection || preCheckTouch);
+      deviceType === EDeviceType.Touch ||
+      deviceType === EDeviceType.Pro ||
+      deviceType === EDeviceType.Pro2;
+    const unlocked = this.profile ? this.profile.status.unlocked : this.features?.unlocked;
+    const preCheckTouch = isModeT && unlocked === false;
+    const passphraseProtection = this.getCurrentPassphraseProtection();
+
+    return Boolean(passphraseProtection === true || preCheckTouch);
   }
 
   checkDeviceId(deviceId: string) {
-    if (this.features) {
-      return this.features.device_id === deviceId;
-    }
-    return false;
+    return this.getCurrentDeviceId() === deviceId;
   }
 
-  async lockDevice() {
+  async lockDevice(): Promise<Success> {
     const res = await this.commands.typedCall('LockDevice', 'Success', {});
     return res.message;
   }
 
   supportUnlockVersionRange(): DeviceFirmwareRange {
+    // 仅适用于 Protocol V1 的 Pro 系列；Pro2 走独立版本线，
+    // 且 Protocol V2 固件从首个版本即支持 UnLockDevice（见 unlockDevice 的 isProtocolV2 短路）。
     return {
       pro: {
         min: '4.15.0',
@@ -869,9 +1318,9 @@ export class Device extends EventEmitter {
   }
 
   async unlockDevice() {
-    const firmwareVersion = getDeviceFirmwareVersion(this.features)?.join('.');
-    const versionRange = getMethodVersionRange(
-      this.features,
+    const firmwareVersion = this.getCurrentFirmwareVersionString() ?? '0.0.0';
+    // profile 优先的版本范围解析；features 仅作为 V1 capability 判断来源
+    const versionRange = this.getCurrentMethodVersionRange(
       type => this.supportUnlockVersionRange()[type]
     );
 
@@ -879,12 +1328,29 @@ export class Device extends EventEmitter {
       this.features,
       Enum_Capability.Capability_AttachToPin
     );
-
+    // Pro2 (Protocol V2) 版本线独立于 Pro 系列，固件从首个版本即支持 UnLockDevice
     const supportUnlock =
-      supportAttachPinCapability || (versionRange && semver.gte(firmwareVersion, versionRange.min));
+      this.isProtocolV2() ||
+      supportAttachPinCapability ||
+      (versionRange &&
+        semver.valid(firmwareVersion) &&
+        semver.gte(firmwareVersion, versionRange.min));
 
     if (supportUnlock) {
       const res = await this.commands.typedCall('UnLockDevice', 'UnLockDeviceResponse');
+      // 解锁结果同步到 profile（标准模型），features 仅在 V1 缓存存在时回写
+      if (this.profile) {
+        this.updateProfile({
+          ...this.profile,
+          status: {
+            ...this.profile.status,
+            unlocked: res.message.unlocked == null ? null : res.message.unlocked,
+            ...(res.message.passphrase_protection != null
+              ? { passphraseProtection: res.message.passphrase_protection }
+              : {}),
+          },
+        });
+      }
       if (this.features) {
         this.features.unlocked = res.message.unlocked == null ? null : res.message.unlocked;
         this.features.unlocked_attach_pin =
@@ -895,9 +1361,16 @@ export class Device extends EventEmitter {
         return Promise.resolve(this.features);
       }
 
-      const featuresRes = await this.commands.typedCall('GetFeatures', 'Features');
-      this._updateFeatures(featuresRes.message);
-      return Promise.resolve(featuresRes.message);
+      const features = await this.getFeatures();
+      return Promise.resolve(features);
+    }
+
+    // legacy 解锁探测仅适用于 Protocol V1 老固件；V2 固件必然支持 UnLockDevice
+    if (this.isProtocolV2()) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'unlock device error: device firmware does not support UnLockDevice'
+      );
     }
 
     const { type } = await this.commands.typedCall('GetAddress', 'Address', {
@@ -911,9 +1384,8 @@ export class Device extends EventEmitter {
     if (type === 'CallMethodError') {
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'unlock device error');
     }
-    const res = await this.commands.typedCall('GetFeatures', 'Features');
-    this._updateFeatures(res.message);
-    return Promise.resolve(res.message);
+    const features = await this.getFeatures();
+    return Promise.resolve(features);
   }
 
   async checkPassphraseStateSafety(
@@ -921,7 +1393,7 @@ export class Device extends EventEmitter {
     useEmptyPassphrase?: boolean,
     skipPassphraseCheck?: boolean
   ) {
-    if (!this.features) return false;
+    if (this.isUnacquired()) return false;
 
     const { passphraseState: newPassphraseState, unlockedAttachPin } =
       await getPassphraseStateWithRefreshDeviceInfo(this, {
@@ -929,14 +1401,11 @@ export class Device extends EventEmitter {
         onlyMainPin: useEmptyPassphrase,
       });
 
-    if (skipPassphraseCheck) {
-      return true;
-    }
-
     // Main wallet and unlock Attach Pin, throw safe error
     const mainWalletUseAttachPin = unlockedAttachPin && useEmptyPassphrase;
     const useErrorAttachPin =
       unlockedAttachPin && passphraseState && passphraseState !== newPassphraseState;
+    const passphraseStateMismatch = !!passphraseState && passphraseState !== newPassphraseState;
 
     Log.debug('Check passphrase state safety: ', {
       passphraseState,
@@ -945,6 +1414,14 @@ export class Device extends EventEmitter {
       useEmptyPassphrase,
     });
 
+    if (skipPassphraseCheck) {
+      if (passphraseStateMismatch) {
+        this.clearInternalState();
+        return false;
+      }
+      return true;
+    }
+
     if (mainWalletUseAttachPin || useErrorAttachPin) {
       try {
         await this.lockDevice();
@@ -956,7 +1433,7 @@ export class Device extends EventEmitter {
     }
 
     // When exists passphraseState, check passphraseState
-    if (passphraseState && passphraseState !== newPassphraseState) {
+    if (passphraseStateMismatch) {
       this.clearInternalState();
       return false;
     }