@onekeyfe/hd-core 1.2.0-alpha.0 → 1.2.0-alpha.10

package/src/deviceProfile/buildDeviceProfile.ts

@@ -1,5 +1,4 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
-import { OneKeyDeviceType, OneKeySEState, OneKeySeType } from '@onekeyfe/hd-transport';
 
 import {
   getDeviceBLEFirmwareVersion,
@@ -26,12 +25,13 @@ import type {
   GetDeviceInfoParams,
 } from '../types/api/getDeviceInfo';
 import type { Features, OnekeyFeatures } from '../types';
-import type { DevFirmwareImageInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+import type { DeviceFirmwareImageInfo, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+import { isProtocolV2BootloaderDeviceInfo } from '../protocols/protocol-v2/features';
 
 type BuildProtocolV1ProfileParams = {
   protocol?: DeviceInfoProtocol;
   features?: Features;
-  onekeyFeatures?: OnekeyFeatures;
+  protocolV1OneKeyFeatures?: OnekeyFeatures;
   sources?: DeviceInfoSource[];
   scope?: GetDeviceInfoParams['scope'];
   includeRaw?: boolean;
@@ -42,17 +42,11 @@ type BuildProtocolV2ProfileParams = {
   sources?: DeviceInfoSource[];
   scope?: GetDeviceInfoParams['scope'];
   includeRaw?: boolean;
-  /**
-   * hw.serial_no 为空时的回退身份（通常传 transport 层的 device path）。
-   * 早期 Pro2 工程板没有烧录 serial_no，空 serialNo 会导致设备无法进入
-   * DevicePool 的 devices 字典，后续 getDevice(connectId) 必然失败。
-   */
-  fallbackSerialNo?: string;
 };
 
 const isMeaningfulVersion = (version?: string | null) => Boolean(version && version !== '0.0.0');
 
-const firstVersion = (...versions: Array<string | null | undefined>) =>
+const firstMeaningfulVersion = (...versions: Array<string | null | undefined>) =>
   versions.find(isMeaningfulVersion) ?? null;
 
 const versionArrayToString = (version?: Array<number | string | null> | null) => {
@@ -75,24 +69,25 @@ const bytesToHex = (value: unknown): string | undefined => {
   return undefined;
 };
 
-const getImageVersion = (image?: DevFirmwareImageInfo | null) => image?.version ?? null;
+const getImageVersion = (image?: DeviceFirmwareImageInfo | null) => image?.version ?? null;
 
-const getImageBuildId = (image?: DevFirmwareImageInfo | null) => image?.build_id ?? undefined;
+const getImageBuildId = (image?: DeviceFirmwareImageInfo | null) => image?.build_id ?? undefined;
 
-const getImageHash = (image?: DevFirmwareImageInfo | null) => bytesToHex(image?.hash);
+const getImageHash = (image?: DeviceFirmwareImageInfo | null) => bytesToHex(image?.hash);
 
 const shouldIncludeVerify = (scope?: GetDeviceInfoParams['scope']) =>
   scope === 'verify' || scope === 'full';
 
 const getDeviceMode = (features?: Features): DeviceInfoStatus['mode'] => {
   if (!features) return 'unknown';
-  if (features.bootloader_mode === true) return 'bootloader';
+  if (features.bootloaderMode === true) return 'bootloader';
   if (features.initialized === false) return 'notInitialized';
   if (features.initialized === true) return 'normal';
   return 'unknown';
 };
 
 const getProtocolV2Mode = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus['mode'] => {
+  if (isProtocolV2BootloaderDeviceInfo(deviceInfo)) return 'bootloader';
   const initialized = deviceInfo?.status?.init_states;
   if (initialized === false) return 'notInitialized';
   if (initialized === true) return 'normal';
@@ -101,246 +96,220 @@ const getProtocolV2Mode = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus[
 
 const normalizeV1Versions = (
   features?: Features,
-  onekeyFeatures?: OnekeyFeatures
+  protocolV1OneKeyFeatures?: OnekeyFeatures
 ): DeviceProfileVersions => ({
-  firmware: firstVersion(
-    onekeyFeatures?.onekey_firmware_version,
+  firmware: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_firmware_version,
     versionArrayToString(getDeviceFirmwareVersion(features))
   ),
-  bootloader: firstVersion(
-    onekeyFeatures?.onekey_boot_version,
+  bootloader: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_boot_version,
     versionArrayToString(getDeviceBootloaderVersion(features))
   ),
-  board: firstVersion(
-    onekeyFeatures?.onekey_board_version,
+  board: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_board_version,
     versionArrayToString(features ? getDeviceBoardloaderVersion(features) : undefined)
   ),
-  ble: firstVersion(
-    onekeyFeatures?.onekey_ble_version,
-    features?.onekey_ble_version,
-    features?.ble_ver,
+  ble: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_ble_version,
+    features?.bleVersion,
     versionArrayToString(features ? getDeviceBLEFirmwareVersion(features) : undefined)
   ),
-  se01: firstVersion(onekeyFeatures?.onekey_se01_version, features?.onekey_se01_version),
-  se02: firstVersion(onekeyFeatures?.onekey_se02_version, features?.onekey_se02_version),
-  se03: firstVersion(onekeyFeatures?.onekey_se03_version, features?.onekey_se03_version),
-  se04: firstVersion(onekeyFeatures?.onekey_se04_version, features?.onekey_se04_version),
-  se01Boot: firstVersion(
-    onekeyFeatures?.onekey_se01_boot_version,
-    features?.onekey_se01_boot_version
+  se01: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se01_version,
+    features?.se01Version
   ),
-  se02Boot: firstVersion(
-    onekeyFeatures?.onekey_se02_boot_version,
-    features?.onekey_se02_boot_version
+  se02: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se02_version,
+    features?.se02Version
   ),
-  se03Boot: firstVersion(
-    onekeyFeatures?.onekey_se03_boot_version,
-    features?.onekey_se03_boot_version
+  se03: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se03_version,
+    features?.se03Version
   ),
-  se04Boot: firstVersion(
-    onekeyFeatures?.onekey_se04_boot_version,
-    features?.onekey_se04_boot_version
+  se04: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se04_version,
+    features?.se04Version
+  ),
+  se01Boot: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se01_boot_version,
+    features?.se01BootVersion
+  ),
+  se02Boot: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se02_boot_version,
+    features?.se02BootVersion
+  ),
+  se03Boot: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se03_boot_version,
+    features?.se03BootVersion
+  ),
+  se04Boot: firstMeaningfulVersion(
+    protocolV1OneKeyFeatures?.onekey_se04_boot_version,
+    features?.se04BootVersion
   ),
 });
 
-const normalizeV2Versions = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVersions => ({
-  firmware: firstVersion(getImageVersion(deviceInfo?.fw?.app)),
-  bootloader: firstVersion(getImageVersion(deviceInfo?.fw?.boot)),
-  board: firstVersion(getImageVersion(deviceInfo?.fw?.board)),
-  ble: firstVersion(getImageVersion(deviceInfo?.bt?.app)),
-  se01: firstVersion(getImageVersion(deviceInfo?.se1?.app)),
-  se02: firstVersion(getImageVersion(deviceInfo?.se2?.app)),
-  se03: firstVersion(getImageVersion(deviceInfo?.se3?.app)),
-  se04: firstVersion(getImageVersion(deviceInfo?.se4?.app)),
-  se01Boot: firstVersion(getImageVersion(deviceInfo?.se1?.boot)),
-  se02Boot: firstVersion(getImageVersion(deviceInfo?.se2?.boot)),
-  se03Boot: firstVersion(getImageVersion(deviceInfo?.se3?.boot)),
-  se04Boot: firstVersion(getImageVersion(deviceInfo?.se4?.boot)),
-});
+const normalizeV2Versions = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVersions => {
+  const info = deviceInfo;
+  return {
+    firmware: firstMeaningfulVersion(getImageVersion(info?.fw?.application)),
+    bootloader: firstMeaningfulVersion(getImageVersion(info?.fw?.bootloader)),
+    board: firstMeaningfulVersion(
+      getImageVersion(info?.fw?.application_data ?? info?.fw?.romloader)
+    ),
+    ble: firstMeaningfulVersion(getImageVersion(info?.coprocessor?.application)),
+    se01: firstMeaningfulVersion(getImageVersion(info?.se1?.application)),
+    se02: firstMeaningfulVersion(getImageVersion(info?.se2?.application)),
+    se03: firstMeaningfulVersion(getImageVersion(info?.se3?.application)),
+    se04: firstMeaningfulVersion(getImageVersion(info?.se4?.application)),
+    se01Boot: firstMeaningfulVersion(getImageVersion(info?.se1?.bootloader)),
+    se02Boot: firstMeaningfulVersion(getImageVersion(info?.se2?.bootloader)),
+    se03Boot: firstMeaningfulVersion(getImageVersion(info?.se3?.bootloader)),
+    se04Boot: firstMeaningfulVersion(getImageVersion(info?.se4?.bootloader)),
+  };
+};
 
 // V2 状态由 normalizeV2Status 处理，这里只服务 buildProfileFromProtocolV1 的 V1 路径。
 const normalizeV1Status = (features?: Features): DeviceInfoStatus => ({
   mode: getDeviceMode(features),
   initialized: features?.initialized ?? null,
-  bootloaderMode: features?.bootloader_mode ?? null,
+  bootloaderMode: features?.bootloaderMode ?? null,
   unlocked: features?.unlocked ?? null,
-  passphraseProtection: features?.passphrase_protection ?? null,
-  backupRequired: features?.needs_backup ?? null,
-  noBackup: features?.no_backup ?? null,
+  passphraseProtection: features?.passphraseProtection ?? null,
+  attachToPinEnabled: features?.attachToPinEnabled ?? null,
+  unlockedAttachPin: features?.unlockedAttachPin ?? null,
+  backupRequired: features?.backupRequired ?? null,
+  noBackup: features?.noBackup ?? null,
   language: features?.language ?? null,
-  bleEnabled: features?.ble_enable ?? null,
+  bleEnabled: features?.bleEnabled ?? null,
 });
 
-const normalizeV2Status = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus => ({
-  mode: getProtocolV2Mode(deviceInfo),
-  initialized: deviceInfo?.status?.init_states ?? null,
-  bootloaderMode: false,
-  unlocked: null,
-  passphraseProtection: deviceInfo?.status?.passphrase_protection ?? null,
-  backupRequired: deviceInfo?.status?.backup_required ?? null,
-  noBackup: null,
-  language: deviceInfo?.status?.language ?? null,
-  bleEnabled: deviceInfo?.status?.bt_enable ?? null,
-});
+const normalizeV2Status = (deviceInfo?: ProtocolV2DeviceInfo): DeviceInfoStatus => {
+  const status = deviceInfo?.status;
+  const bootloaderMode = isProtocolV2BootloaderDeviceInfo(deviceInfo);
+  return {
+    mode: getProtocolV2Mode(deviceInfo),
+    initialized: status?.init_states ?? null,
+    bootloaderMode,
+    unlocked: status?.unlocked ?? null,
+    passphraseProtection: status?.passphrase_enabled ?? null,
+    attachToPinEnabled: status?.attach_to_pin_enabled ?? null,
+    unlockedAttachPin: status?.unlocked_by_attach_to_pin ?? null,
+    backupRequired: status?.backup_required ?? null,
+    noBackup: null,
+    language: null,
+    bleEnabled: null,
+  };
+};
 
 const normalizeV1Verify = (
   features?: Features,
-  onekeyFeatures?: OnekeyFeatures
+  protocolV1OneKeyFeatures?: OnekeyFeatures
 ): DeviceProfileVerify => ({
-  firmwareBuildId: onekeyFeatures?.onekey_firmware_build_id ?? features?.onekey_firmware_build_id,
-  firmwareHash: onekeyFeatures?.onekey_firmware_hash ?? features?.onekey_firmware_hash,
-  bootloaderBuildId: onekeyFeatures?.onekey_boot_build_id ?? features?.onekey_boot_build_id,
-  bootloaderHash: onekeyFeatures?.onekey_boot_hash ?? features?.onekey_boot_hash,
-  boardBuildId: onekeyFeatures?.onekey_board_build_id ?? features?.onekey_board_build_id,
-  boardHash: onekeyFeatures?.onekey_board_hash ?? features?.onekey_board_hash,
-  bleBuildId: onekeyFeatures?.onekey_ble_build_id ?? features?.onekey_ble_build_id,
-  bleHash: onekeyFeatures?.onekey_ble_hash ?? features?.onekey_ble_hash,
-  se01BuildId: onekeyFeatures?.onekey_se01_build_id ?? features?.onekey_se01_build_id,
-  se01Hash: onekeyFeatures?.onekey_se01_hash ?? features?.onekey_se01_hash,
-  se02BuildId: onekeyFeatures?.onekey_se02_build_id ?? features?.onekey_se02_build_id,
-  se02Hash: onekeyFeatures?.onekey_se02_hash ?? features?.onekey_se02_hash,
-  se03BuildId: onekeyFeatures?.onekey_se03_build_id ?? features?.onekey_se03_build_id,
-  se03Hash: onekeyFeatures?.onekey_se03_hash ?? features?.onekey_se03_hash,
-  se04BuildId: onekeyFeatures?.onekey_se04_build_id ?? features?.onekey_se04_build_id,
-  se04Hash: onekeyFeatures?.onekey_se04_hash ?? features?.onekey_se04_hash,
-  se01BootBuildId: onekeyFeatures?.onekey_se01_boot_build_id ?? features?.onekey_se01_boot_build_id,
-  se01BootHash: onekeyFeatures?.onekey_se01_boot_hash ?? features?.onekey_se01_boot_hash,
-  se02BootBuildId: onekeyFeatures?.onekey_se02_boot_build_id ?? features?.onekey_se02_boot_build_id,
-  se02BootHash: onekeyFeatures?.onekey_se02_boot_hash ?? features?.onekey_se02_boot_hash,
-  se03BootBuildId: onekeyFeatures?.onekey_se03_boot_build_id ?? features?.onekey_se03_boot_build_id,
-  se03BootHash: onekeyFeatures?.onekey_se03_boot_hash ?? features?.onekey_se03_boot_hash,
-  se04BootBuildId: onekeyFeatures?.onekey_se04_boot_build_id ?? features?.onekey_se04_boot_build_id,
-  se04BootHash: onekeyFeatures?.onekey_se04_boot_hash ?? features?.onekey_se04_boot_hash,
+  firmwareBuildId:
+    protocolV1OneKeyFeatures?.onekey_firmware_build_id ?? features?.verify?.firmwareBuildId,
+  firmwareHash: protocolV1OneKeyFeatures?.onekey_firmware_hash ?? features?.verify?.firmwareHash,
+  bootloaderBuildId:
+    protocolV1OneKeyFeatures?.onekey_boot_build_id ?? features?.verify?.bootloaderBuildId,
+  bootloaderHash: protocolV1OneKeyFeatures?.onekey_boot_hash ?? features?.verify?.bootloaderHash,
+  boardBuildId: protocolV1OneKeyFeatures?.onekey_board_build_id ?? features?.verify?.boardBuildId,
+  boardHash: protocolV1OneKeyFeatures?.onekey_board_hash ?? features?.verify?.boardHash,
+  bleBuildId: protocolV1OneKeyFeatures?.onekey_ble_build_id ?? features?.verify?.bleBuildId,
+  bleHash: protocolV1OneKeyFeatures?.onekey_ble_hash ?? features?.verify?.bleHash,
+  se01BuildId: protocolV1OneKeyFeatures?.onekey_se01_build_id ?? features?.verify?.se01BuildId,
+  se01Hash: protocolV1OneKeyFeatures?.onekey_se01_hash ?? features?.verify?.se01Hash,
+  se02BuildId: protocolV1OneKeyFeatures?.onekey_se02_build_id ?? features?.verify?.se02BuildId,
+  se02Hash: protocolV1OneKeyFeatures?.onekey_se02_hash ?? features?.verify?.se02Hash,
+  se03BuildId: protocolV1OneKeyFeatures?.onekey_se03_build_id ?? features?.verify?.se03BuildId,
+  se03Hash: protocolV1OneKeyFeatures?.onekey_se03_hash ?? features?.verify?.se03Hash,
+  se04BuildId: protocolV1OneKeyFeatures?.onekey_se04_build_id ?? features?.verify?.se04BuildId,
+  se04Hash: protocolV1OneKeyFeatures?.onekey_se04_hash ?? features?.verify?.se04Hash,
+  se01BootBuildId:
+    protocolV1OneKeyFeatures?.onekey_se01_boot_build_id ?? features?.verify?.se01BootBuildId,
+  se01BootHash: protocolV1OneKeyFeatures?.onekey_se01_boot_hash ?? features?.verify?.se01BootHash,
+  se02BootBuildId:
+    protocolV1OneKeyFeatures?.onekey_se02_boot_build_id ?? features?.verify?.se02BootBuildId,
+  se02BootHash: protocolV1OneKeyFeatures?.onekey_se02_boot_hash ?? features?.verify?.se02BootHash,
+  se03BootBuildId:
+    protocolV1OneKeyFeatures?.onekey_se03_boot_build_id ?? features?.verify?.se03BootBuildId,
+  se03BootHash: protocolV1OneKeyFeatures?.onekey_se03_boot_hash ?? features?.verify?.se03BootHash,
+  se04BootBuildId:
+    protocolV1OneKeyFeatures?.onekey_se04_boot_build_id ?? features?.verify?.se04BootBuildId,
+  se04BootHash: protocolV1OneKeyFeatures?.onekey_se04_boot_hash ?? features?.verify?.se04BootHash,
 });
 
-const normalizeV2Verify = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVerify => ({
-  firmwareBuildId: getImageBuildId(deviceInfo?.fw?.app),
-  firmwareHash: getImageHash(deviceInfo?.fw?.app),
-  bootloaderBuildId: getImageBuildId(deviceInfo?.fw?.boot),
-  bootloaderHash: getImageHash(deviceInfo?.fw?.boot),
-  boardBuildId: getImageBuildId(deviceInfo?.fw?.board),
-  boardHash: getImageHash(deviceInfo?.fw?.board),
-  bleBuildId: getImageBuildId(deviceInfo?.bt?.app),
-  bleHash: getImageHash(deviceInfo?.bt?.app),
-  se01BuildId: getImageBuildId(deviceInfo?.se1?.app),
-  se01Hash: getImageHash(deviceInfo?.se1?.app),
-  se02BuildId: getImageBuildId(deviceInfo?.se2?.app),
-  se02Hash: getImageHash(deviceInfo?.se2?.app),
-  se03BuildId: getImageBuildId(deviceInfo?.se3?.app),
-  se03Hash: getImageHash(deviceInfo?.se3?.app),
-  se04BuildId: getImageBuildId(deviceInfo?.se4?.app),
-  se04Hash: getImageHash(deviceInfo?.se4?.app),
-  se01BootBuildId: getImageBuildId(deviceInfo?.se1?.boot),
-  se01BootHash: getImageHash(deviceInfo?.se1?.boot),
-  se02BootBuildId: getImageBuildId(deviceInfo?.se2?.boot),
-  se02BootHash: getImageHash(deviceInfo?.se2?.boot),
-  se03BootBuildId: getImageBuildId(deviceInfo?.se3?.boot),
-  se03BootHash: getImageHash(deviceInfo?.se3?.boot),
-  se04BootBuildId: getImageBuildId(deviceInfo?.se4?.boot),
-  se04BootHash: getImageHash(deviceInfo?.se4?.boot),
-});
+const normalizeV2Verify = (deviceInfo?: ProtocolV2DeviceInfo): DeviceProfileVerify => {
+  const info = deviceInfo;
+  return {
+    firmwareBuildId: getImageBuildId(info?.fw?.application),
+    firmwareHash: getImageHash(info?.fw?.application),
+    bootloaderBuildId: getImageBuildId(info?.fw?.bootloader),
+    bootloaderHash: getImageHash(info?.fw?.bootloader),
+    boardBuildId: getImageBuildId(info?.fw?.application_data ?? info?.fw?.romloader),
+    boardHash: getImageHash(info?.fw?.application_data ?? info?.fw?.romloader),
+    bleBuildId: getImageBuildId(info?.coprocessor?.application),
+    bleHash: getImageHash(info?.coprocessor?.application),
+    se01BuildId: getImageBuildId(info?.se1?.application),
+    se01Hash: getImageHash(info?.se1?.application),
+    se02BuildId: getImageBuildId(info?.se2?.application),
+    se02Hash: getImageHash(info?.se2?.application),
+    se03BuildId: getImageBuildId(info?.se3?.application),
+    se03Hash: getImageHash(info?.se3?.application),
+    se04BuildId: getImageBuildId(info?.se4?.application),
+    se04Hash: getImageHash(info?.se4?.application),
+    se01BootBuildId: getImageBuildId(info?.se1?.bootloader),
+    se01BootHash: getImageHash(info?.se1?.bootloader),
+    se02BootBuildId: getImageBuildId(info?.se2?.bootloader),
+    se02BootHash: getImageHash(info?.se2?.bootloader),
+    se03BootBuildId: getImageBuildId(info?.se3?.bootloader),
+    se03BootHash: getImageHash(info?.se3?.bootloader),
+    se04BootBuildId: getImageBuildId(info?.se4?.bootloader),
+    se04BootHash: getImageHash(info?.se4?.bootloader),
+  };
+};
 
 const normalizeRaw = ({
   features,
-  onekeyFeatures,
+  protocolV1OneKeyFeatures,
   protocolV2DeviceInfo,
 }: {
   features?: Features;
-  onekeyFeatures?: OnekeyFeatures;
+  protocolV1OneKeyFeatures?: OnekeyFeatures;
   protocolV2DeviceInfo?: ProtocolV2DeviceInfo;
 }): DeviceProfileRaw => ({
   ...(features ? { features } : {}),
-  ...(onekeyFeatures ? { onekeyFeatures } : {}),
+  ...(protocolV1OneKeyFeatures ? { protocolV1OneKeyFeatures } : {}),
   ...(protocolV2DeviceInfo ? { protocolV2DeviceInfo } : {}),
 });
 
-/**
- * V1 profile 构建用的 features 合并视图。
- *
- * OnekeyFeatures 与 Features 的同名字段（onekey_device_type / onekey_se_type /
- * onekey_se0X_state）wire 同源：传输层解码会把 proto 枚举输出为名称字符串，与
- * Features 侧的 string 声明一致，仅生成类型分别声明为枚举/字符串，这里按
- * Features 的声明显式归一，避免整体 as Features 断言。
- */
-const mergeV1Features = (
-  features?: Features,
-  onekeyFeatures?: OnekeyFeatures
-): Features | undefined => {
-  if (!features && !onekeyFeatures) return undefined;
-
-  const {
-    onekey_device_type: onekeyDeviceType,
-    onekey_se_type: onekeySeType,
-    onekey_se01_state: onekeySe01State,
-    onekey_se02_state: onekeySe02State,
-    onekey_se03_state: onekeySe03State,
-    onekey_se04_state: onekeySe04State,
-    ...restOnekeyFeatures
-  } = onekeyFeatures ?? {};
-
-  const toEnumName = (
-    enumObject: Record<string | number, string | number>,
-    value: number | string | null | undefined
-  ): string | null | undefined => {
-    if (value == null || typeof value === 'string') return value;
-    const label = enumObject[value];
-    return typeof label === 'string' ? label : String(value);
-  };
-
-  return {
-    // 仅 onekeyFeatures 的场景没有完整 Features 底座（与历史 as Features 行为一致，
-    // 该路径目前没有调用方触达：两处调用都至少携带 features）。
-    ...((features ?? {}) as Features),
-    ...restOnekeyFeatures,
-    ...(onekeyDeviceType !== undefined
-      ? { onekey_device_type: toEnumName(OneKeyDeviceType, onekeyDeviceType) }
-      : {}),
-    ...(onekeySeType !== undefined
-      ? { onekey_se_type: toEnumName(OneKeySeType, onekeySeType) }
-      : {}),
-    ...(onekeySe01State !== undefined
-      ? { onekey_se01_state: toEnumName(OneKeySEState, onekeySe01State) }
-      : {}),
-    ...(onekeySe02State !== undefined
-      ? { onekey_se02_state: toEnumName(OneKeySEState, onekeySe02State) }
-      : {}),
-    ...(onekeySe03State !== undefined
-      ? { onekey_se03_state: toEnumName(OneKeySEState, onekeySe03State) }
-      : {}),
-    ...(onekeySe04State !== undefined
-      ? { onekey_se04_state: toEnumName(OneKeySEState, onekeySe04State) }
-      : {}),
-  };
-};
-
 export function buildProfileFromProtocolV1({
   protocol = 'V1',
   features,
-  onekeyFeatures,
+  protocolV1OneKeyFeatures,
   sources = ['features'],
   scope = 'basic',
   includeRaw = false,
 }: BuildProtocolV1ProfileParams): DeviceProfile {
-  const sourceFeatures = mergeV1Features(features, onekeyFeatures);
-  const verify = normalizeV1Verify(sourceFeatures, onekeyFeatures);
+  const sourceFeatures = features;
+  const verify = normalizeV1Verify(sourceFeatures, protocolV1OneKeyFeatures);
 
   return {
     protocol,
     sources,
     deviceType: getDeviceType(sourceFeatures),
     firmwareType: getFirmwareType(sourceFeatures),
-    deviceId: sourceFeatures?.device_id || (sourceFeatures ? getDeviceUUID(sourceFeatures) : ''),
+    deviceId: sourceFeatures?.deviceId || (sourceFeatures ? getDeviceUUID(sourceFeatures) : ''),
     serialNo: sourceFeatures ? getDeviceUUID(sourceFeatures) : '',
     label: getDeviceLabel(sourceFeatures),
     bleName: getDeviceBleName(sourceFeatures),
     status: normalizeV1Status(sourceFeatures),
-    versions: normalizeV1Versions(sourceFeatures, onekeyFeatures),
+    versions: normalizeV1Versions(sourceFeatures, protocolV1OneKeyFeatures),
     ...(shouldIncludeVerify(scope) ? { verify } : {}),
     ...(includeRaw
       ? {
           raw: normalizeRaw({
             features,
-            onekeyFeatures,
+            protocolV1OneKeyFeatures,
           }),
         }
       : {}),
@@ -352,12 +321,12 @@ export function buildProfileFromProtocolV2({
   sources = ['deviceInfo'],
   scope = 'basic',
   includeRaw = false,
-  fallbackSerialNo,
 }: BuildProtocolV2ProfileParams): DeviceProfile {
-  // 早期工程板 hw.serial_no 为空串，回退到调用方提供的 transport path（mock 身份）。
-  const serialNo = deviceInfo?.hw?.serial_no || fallbackSerialNo || '';
-  const label = deviceInfo?.status?.label ?? null;
-  const bleName = deviceInfo?.bt?.adv_name ?? null;
+  const info = deviceInfo;
+  const deviceId = info?.status?.device_id || '';
+  const serialNo = deviceInfo?.hw?.serial_no || '';
+  const label = null;
+  const bleName = info?.coprocessor?.bt_adv_name ?? null;
   const verify = normalizeV2Verify(deviceInfo);
 
   return {
@@ -365,11 +334,7 @@ export function buildProfileFromProtocolV2({
     sources,
     deviceType: EDeviceType.Pro2,
     firmwareType: EFirmwareType.Universal,
-    // Protocol V2 的 DevGetDeviceInfo 没有 device_id 字段（固件 proto 仅提供 hw.serial_no），
-    // 这里只能回退 serialNo。注意语义差异：V1 的 device_id 随擦除/换种子轮换，serialNo 永不变化。
-    // 固件在 DevStatus 暴露 device_id 后，此处必须改为读取它，否则 wipe 后基于 deviceId 的
-    // session 缓存（deviceSessionCache）不会自然失效。
-    deviceId: serialNo,
+    deviceId,
     serialNo,
     label,
     bleName,

package/src/deviceProfile/index.ts

@@ -1,2 +1,5 @@
 export { buildProfileFromProtocolV1, buildProfileFromProtocolV2 } from './buildDeviceProfile';
-export { buildProtocolV2GetFeaturesPayload } from './legacyFeaturesView';
+export {
+  buildProtocolV1FeaturesPayload,
+  buildProtocolV2FeaturesPayload,
+} from './buildDeviceFeatures';

package/src/inject.ts

@@ -100,6 +100,7 @@ export const createCoreApi = (
   | 'switchTransport'
 > => ({
   getLogs: () => call({ method: 'getLogs' }),
+  clearSessionCache: params => call({ ...params, method: 'clearSessionCache' }),
   /**
    * 搜索设备
    */
@@ -151,28 +152,24 @@ export const createCoreApi = (
   deviceRebootToBootloader: connectId => call({ connectId, method: 'deviceRebootToBootloader' }),
 
   // File system & device control API (Protocol V2 only)
-  getProtoVersion: (connectId, params) => call({ ...params, connectId, method: 'getProtoVersion' }),
+  protocolInfoRequest: (connectId, params) =>
+    call({ ...params, connectId, method: 'protocolInfoRequest' }),
   ping: (connectId, params) => call({ ...params, connectId, method: 'ping' }),
   deviceReboot: (connectId, params) => call({ ...params, connectId, method: 'deviceReboot' }),
-  deviceGetDeviceInfo: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceGetDeviceInfo' }),
-  deviceGetOnboardingStatus: (connectId, params) =>
-    call({ ...params, connectId, method: 'deviceGetOnboardingStatus' }),
+  deviceInfoGet: (connectId, params) => call({ ...params, connectId, method: 'deviceInfoGet' }),
+  deviceStatusGet: (connectId, params) => call({ ...params, connectId, method: 'deviceStatusGet' }),
+  deviceSessionGet: (connectId, params) =>
+    call({ ...params, connectId, method: 'deviceSessionGet' }),
   deviceFirmwareUpdate: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceFirmwareUpdate' }),
   deviceGetFirmwareUpdateStatus: (connectId, params) =>
     call({ ...params, connectId, method: 'deviceGetFirmwareUpdateStatus' }),
-  devReboot: (connectId, params) => call({ ...params, connectId, method: 'devReboot' }),
-  devGetDeviceInfo: (connectId, params) =>
-    call({ ...params, connectId, method: 'devGetDeviceInfo' }),
-  devFirmwareUpdate: (connectId, params) =>
-    call({ ...params, connectId, method: 'devFirmwareUpdate' }),
-  devGetFirmwareUpdateStatus: (connectId, params) =>
-    call({ ...params, connectId, method: 'devGetFirmwareUpdateStatus' }),
-  factoryDeviceInfoSettings: (connectId, params) =>
-    call({ ...params, connectId, method: 'factoryDeviceInfoSettings' }),
-  factoryGetDeviceInfo: connectId => call({ connectId, method: 'factoryGetDeviceInfo' }),
-  filesystemFixPermission: connectId => call({ connectId, method: 'filesystemFixPermission' }),
+  deviceFactoryInfoSet: (connectId, params) =>
+    call({ ...params, connectId, method: 'deviceFactoryInfoSet' }),
+  deviceFactoryInfoGet: (connectId, params) =>
+    call({ ...params, connectId, method: 'deviceFactoryInfoGet' }),
+  filesystemPermissionFix: (connectId, params) =>
+    call({ ...params, connectId, method: 'filesystemPermissionFix' }),
   fileRead: (connectId, params) => call({ ...params, connectId, method: 'fileRead' }),
   fileWrite: (connectId, params) => call({ ...params, connectId, method: 'fileWrite' }),
   fileDelete: (connectId, params) => call({ ...params, connectId, method: 'fileDelete' }),