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

package/__tests__/protocol-v2.test.ts

@@ -51,7 +51,7 @@ import {
 } from '../src/protocols/protocol-v2/features';
 import {
   buildProfileFromProtocolV2,
-  buildProtocolV2GetFeaturesPayload,
+  buildProtocolV2FeaturesPayload,
 } from '../src/deviceProfile';
 import {
   getDeviceType,
@@ -91,44 +91,34 @@ const descriptor = {
  */
 function stubDevice<T extends Record<string, any>>(device: T): T {
   const d = device as any;
-  d.isProtocolV2 ??= () =>
-    d.profile?.protocol === 'V2' || d.originalDescriptor?.protocolType === 'V2';
+  d.isProtocolV2 ??= () => d.originalDescriptor?.protocolType === 'V2';
   d.getProtocol ??= () => (d.isProtocolV2() ? 'V2' : 'V1');
-  d.getCurrentDeviceType ??= () => d.profile?.deviceType ?? getDeviceType(d.features);
-  d.getCurrentFirmwareType ??= () => d.profile?.firmwareType ?? getFirmwareType(d.features);
+  d.getCurrentDeviceType ??= () => getDeviceType(d.features);
+  d.getCurrentFirmwareType ??= () => getFirmwareType(d.features);
   d.getCurrentFirmwareVersionString ??= () =>
-    d.profile?.versions?.firmware ??
-    (d.features ? getDeviceFirmwareVersion(d.features).join('.') : undefined);
-  d.getCurrentBLEFirmwareVersionString ??= () => d.profile?.versions?.ble ?? undefined;
-  d.getCurrentSafetyChecks ??= () => d.features?.safety_checks;
-  d.getCurrentDeviceId ??= () => d.profile?.deviceId || d.features?.device_id || undefined;
-  d.getCurrentSerialNo ??= () => d.profile?.serialNo || '';
+    d.features ? getDeviceFirmwareVersion(d.features).join('.') : undefined;
+  d.getCurrentBLEFirmwareVersionString ??= () => d.features?.bleVersion;
+  d.getCurrentSafetyChecks ??= () => d.features?.safetyChecks;
+  d.getCurrentDeviceId ??= () => d.features?.deviceId || undefined;
+  d.getCurrentSerialNo ??= () => d.features?.serialNo || '';
   d.getCurrentPassphraseProtection ??= () =>
-    d.profile ? d.profile.status?.passphraseProtection : d.features?.passphrase_protection;
+    d.features?.passphraseProtection;
   d.getCurrentMethodVersionRange ??= (fn: (model: any) => any) => {
     const deviceType = d.getCurrentDeviceType();
     const range = fn(deviceType);
     if (range) return range;
     return getMethodVersionRange(d.features, fn);
   };
-  d.updateProfile ??= (p: any) => {
-    d.profile = p;
-  };
-  d.applyProfileUpdate ??= (p: any) => {
-    d.profile = p;
-    return p;
+  d.updateProtocolV2Features ??= (deviceInfo?: ProtocolV2DeviceInfo) => {
+    d.features = buildProtocolV2FeaturesPayload(deviceInfo, d.features);
+    return d.features;
   };
   return device;
 }
 
 // 直接复用生产映射函数，避免测试内副本与实现漂移（之前的手抄副本已缺失 se boot 字段）
 function normalizeProtocolV2Features(_descriptor: unknown, deviceInfo?: ProtocolV2DeviceInfo) {
-  const profile = buildProfileFromProtocolV2({
-    deviceInfo,
-    sources: ['deviceInfo'],
-    scope: 'verify',
-  });
-  return buildProtocolV2GetFeaturesPayload(profile, deviceInfo);
+  return buildProtocolV2FeaturesPayload(deviceInfo);
 }
 
 async function requestProtocolV2LegacyFeatures({
@@ -152,15 +142,13 @@ describe('Protocol V2 feature adapter', () => {
       });
       expect(typedCall).not.toHaveBeenCalled();
       expect(deviceInfo).toEqual(buildMockProtocolV2DeviceInfo());
-      // 空 serial_no + fallbackSerialNo：身份字段回退 transport path
       const profile = buildProfileFromProtocolV2({
         deviceInfo,
-        fallbackSerialNo: 'usb-path',
       });
       expect(profile).toMatchObject({
         protocol: 'V2',
-        deviceId: 'usb-path',
-        serialNo: 'usb-path',
+        deviceId: '',
+        serialNo: '',
         status: { initialized: true },
         versions: { firmware: '0.1.0' },
       });
@@ -174,6 +162,7 @@ describe('Protocol V2 feature adapter', () => {
       protocol_version: 1,
       hw: {
         serial_no: 'PR2SERIAL',
+        device_id: 'PRO2-DEVICE-ID',
       },
       fw: {
         board: {
@@ -223,40 +212,34 @@ describe('Protocol V2 feature adapter', () => {
       },
     });
 
-    expect(features.device_id).toBe('PR2SERIAL');
-    expect(features.serial_no).toBe('PR2SERIAL');
-    expect(features.onekey_serial_no).toBe('PR2SERIAL');
-    expect(features.onekey_device_type).toBe('pro2');
-    expect(features.protocol_version).toBe(1);
-    expect(features.major_version).toBe(1);
-    expect(features.minor_version).toBe(2);
-    expect(features.patch_version).toBe(3);
-    expect(features.onekey_firmware_version).toBe('1.2.3');
-    expect(features.onekey_firmware_build_id).toBe('app-build');
-    expect(features.onekey_firmware_hash).toBe('abc123');
-    expect(features.bootloader_version).toBe('0.2.0');
-    expect(features.onekey_boot_build_id).toBe('boot-build');
-    expect(features.onekey_boot_hash).toBe('0a0b');
-    expect(features.onekey_board_hash).toBe('0102ff');
-    expect(features.ble_name).toBe('Pro2 BLE');
-    expect(features.onekey_ble_version).toBe('4.5.6');
-    expect(features.onekey_ble_hash).toBe('0c0d');
-    expect(features.onekey_se01_version).toBe('7.8.9');
-    expect(features.onekey_se01_hash).toBe('0e0f');
-    expect(features.onekey_se01_state).toBe('APP');
-    expect(features.onekey_se02_state).toBe('BOOT');
+    expect(features.deviceId).toBe('PRO2-DEVICE-ID');
+    expect(features.serialNo).toBe('PR2SERIAL');
+    expect(features.deviceType).toBe('pro2');
+    expect(features.protocolVersion).toBe(1);
+    expect(features.firmwareVersion).toBe('1.2.3');
+    expect(features.verify?.firmwareBuildId).toBe('app-build');
+    expect(features.verify?.firmwareHash).toBe('abc123');
+    expect(features.bootloaderVersion).toBe('0.2.0');
+    expect(features.verify?.bootloaderBuildId).toBe('boot-build');
+    expect(features.verify?.bootloaderHash).toBe('0a0b');
+    expect(features.verify?.boardHash).toBe('0102ff');
+    expect(features.bleName).toBe('Pro2 BLE');
+    expect(features.bleVersion).toBe('4.5.6');
+    expect(features.verify?.bleHash).toBe('0c0d');
+    expect(features.se01Version).toBe('7.8.9');
+    expect(features.verify?.se01Hash).toBe('0e0f');
     expect(features.label).toBe('My Pro2');
     expect(features.language).toBe('en-US');
     expect(features.initialized).toBe(false);
-    expect(features.needs_backup).toBe(true);
-    expect(features.passphrase_protection).toBe(true);
-    expect(features.ble_enable).toBe(true);
+    expect(features.backupRequired).toBe(true);
+    expect(features.passphraseProtection).toBe(true);
+    expect(features.bleEnabled).toBe(true);
   });
 
   test('uses GetPassphraseState payloads compatible with Pro series passphrase flow', async () => {
     const features = normalizeProtocolV2Features(descriptor as any);
     // Pro2 版本线独立于 Pro 系列：V2 设备无论固件版本都支持 GetPassphraseState
-    features.onekey_firmware_version = '1.2.3';
+    features.firmwareVersion = '1.2.3';
     const typedCall = jest.fn().mockResolvedValue({
       type: 'PassphraseState',
       message: {
@@ -296,12 +279,12 @@ describe('Protocol V2 feature adapter', () => {
 
   test('returns unified GetPassphraseState object payload for existing Pro devices', async () => {
     const features = {
-      device_id: 'pro-device-id',
-      onekey_device_type: 'PRO',
-      onekey_firmware_version: '4.15.0',
-      passphrase_protection: true,
-      session_id: 'feature-session',
-      unlocked_attach_pin: true,
+      deviceId: 'pro-device-id',
+      deviceType: 'pro',
+      firmwareVersion: '4.15.0',
+      passphraseProtection: true,
+      sessionId: 'feature-session',
+      unlockedAttachPin: true,
     };
     const typedCall = jest.fn().mockResolvedValue({
       type: 'PassphraseState',
@@ -319,6 +302,7 @@ describe('Protocol V2 feature adapter', () => {
       },
     });
     method.device = stubDevice({
+      originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features,
       commands: { typedCall },
       updateInternalState,
@@ -327,10 +311,10 @@ describe('Protocol V2 feature adapter', () => {
     }) as any;
 
     await expect(method.run()).resolves.toEqual({
-      passphrase_state: 'state-pro',
-      session_id: 'session-pro',
-      unlocked_attach_pin: false,
-      passphrase_protection: true,
+      passphraseState: 'state-pro',
+      sessionId: 'session-pro',
+      unlockedAttachPin: false,
+      passphraseProtection: true,
     });
     expect(updateInternalState).toHaveBeenCalledWith(
       true,
@@ -341,14 +325,14 @@ describe('Protocol V2 feature adapter', () => {
     );
   });
 
-  test('prefers DeviceProfile for GetPassphraseState response metadata', async () => {
+  test('uses features for GetPassphraseState response metadata', async () => {
     const features = {
-      device_id: 'legacy-pro-device-id',
-      onekey_device_type: 'PRO',
-      onekey_firmware_version: '4.15.0',
-      passphrase_protection: false,
-      session_id: 'feature-session',
-      unlocked_attach_pin: true,
+      deviceId: null,
+      deviceType: 'pro2',
+      firmwareVersion: '4.15.0',
+      passphraseProtection: true,
+      sessionId: 'feature-session',
+      unlockedAttachPin: true,
     };
     const typedCall = jest.fn().mockResolvedValue({
       type: 'PassphraseState',
@@ -367,51 +351,26 @@ describe('Protocol V2 feature adapter', () => {
       },
     });
     method.device = stubDevice({
+      originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features,
-      profile: {
-        protocol: 'V2',
-        sources: ['deviceInfo'],
-        deviceType: 'pro2',
-        firmwareType: 'universal',
-        deviceId: 'PR2SERIAL',
-        serialNo: 'PR2SERIAL',
-        label: null,
-        bleName: null,
-        status: {
-          mode: 'normal',
-          initialized: true,
-          bootloaderMode: false,
-          unlocked: null,
-          passphraseProtection: true,
-          backupRequired: false,
-          noBackup: null,
-          language: null,
-        },
-        versions: {
-          firmware: '4.15.0',
-          bootloader: null,
-          board: null,
-          ble: null,
-        },
-      },
       commands: { typedCall },
       updateInternalState,
       getFeatures,
       getCurrentDeviceType: () => 'pro2',
-      getCurrentDeviceId: () => 'PR2SERIAL',
+      getCurrentDeviceId: () => undefined,
       getCurrentPassphraseProtection: () => true,
     }) as any;
 
     await expect(method.run()).resolves.toEqual({
-      passphrase_state: 'state-pro2',
-      session_id: 'session-pro2',
-      unlocked_attach_pin: false,
-      passphrase_protection: true,
+      passphraseState: 'state-pro2',
+      sessionId: 'session-pro2',
+      unlockedAttachPin: false,
+      passphraseProtection: true,
     });
     expect(getFeatures).not.toHaveBeenCalled();
   });
 
-  test('uses DeviceProfile identity for Pro2 passphrase session cache', async () => {
+  test('stores Pro2 passphrase session cache without synthetic device id', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     const typedCall = jest.fn().mockResolvedValue({
       type: 'PassphraseState',
@@ -459,8 +418,8 @@ describe('Protocol V2 feature adapter', () => {
         hw: { serial_no: 'PR2SERIAL' },
       }
     );
-    (device as any).features.onekey_firmware_version = '4.15.0';
-    (device as any).features.passphrase_protection = true;
+    (device as any).features.firmwareVersion = '4.15.0';
+    (device as any).features.passphraseProtection = true;
     (device as any).features.unlocked = true;
     (device as any).commands = { typedCall };
 
@@ -470,8 +429,8 @@ describe('Protocol V2 feature adapter', () => {
     });
 
     expect(device.passphraseState).toBeUndefined();
-    expect(device.features?.passphrase_protection).toBe(true);
-    expect(device.features?.session_id).toBeNull();
+    expect(device.features?.passphraseProtection).toBe(true);
+    expect(device.features?.sessionId).toBeNull();
     expect(device.getInternalState()).toBeUndefined();
     device.passphraseState = 'state-auto';
     expect(device.getInternalState()).toBe('session-auto');
@@ -501,7 +460,7 @@ describe('Protocol V2 feature adapter', () => {
         },
       }
     );
-    (device as any).features.onekey_firmware_version = '4.15.0';
+    (device as any).features.firmwareVersion = '4.15.0';
     (device as any).features.unlocked = true;
     (device as any).commands = { typedCall };
 
@@ -512,8 +471,8 @@ describe('Protocol V2 feature adapter', () => {
       newSession: 'main-pin-session',
     });
 
-    expect(device.features?.passphrase_protection).toBe(false);
-    expect(device.features?.session_id).toBeNull();
+    expect(device.features?.passphraseProtection).toBe(false);
+    expect(device.features?.sessionId).toBeNull();
     expect(device.getInternalState()).toBeUndefined();
     expect(typedCall).toHaveBeenLastCalledWith('GetPassphraseState', 'PassphraseState', {
       _only_main_pin: true,
@@ -535,8 +494,8 @@ describe('Protocol V2 feature adapter', () => {
       ...descriptor,
       protocolType: 'V2',
     } as any);
-    (device as any).features.onekey_firmware_version = '4.15.0';
-    (device as any).features.passphrase_protection = true;
+    (device as any).features.firmwareVersion = '4.15.0';
+    (device as any).features.passphraseProtection = true;
     (device as any).commands = { typedCall };
 
     await expect(device.checkPassphraseStateSafety('expected-state', false, true)).resolves.toBe(
@@ -552,15 +511,14 @@ describe('Protocol V2 feature adapter', () => {
   test('marks fallback features as unavailable when DeviceInfo is missing', () => {
     const features = normalizeProtocolV2Features(descriptor as any);
 
-    expect(features.device_id).toBe('');
-    expect(features.serial_no).toBe('');
-    expect(features.onekey_serial_no).toBe('');
-    expect(features.initialized).toBe(false);
-    expect(features.unlocked).toBe(false);
-    expect(features.firmware_present).toBe(false);
+    expect(features.deviceId).toBeNull();
+    expect(features.serialNo).toBe('');
+    expect(features.initialized).toBeNull();
+    expect(features.unlocked).toBeNull();
+    expect(features.firmwarePresent).toBeNull();
   });
 
-  test('uses Protocol V2 DeviceInfo serial_no as device_id instead of descriptor id', () => {
+  test('uses Protocol V2 hw.device_id and does not fall back to serial_no', () => {
     const features = normalizeProtocolV2Features(
       {
         id: 'PR2000000000',
@@ -570,108 +528,69 @@ describe('Protocol V2 feature adapter', () => {
       {
         hw: {
           serial_no: 'PR9999999999',
+          device_id: 'DEVICE-ID-9999',
         },
       }
     );
 
-    expect(features.device_id).toBe('PR9999999999');
-    expect(features.onekey_serial_no).toBe('PR9999999999');
-    expect(features.serial_no).toBe('PR9999999999');
+    expect(features.deviceId).toBe('DEVICE-ID-9999');
+    expect(features.serialNo).toBe('PR9999999999');
   });
 
-  test('does not expose legacy feature ids when Protocol V2 profile is incomplete', () => {
+  test('does not use Protocol V2 serial_no as deviceId when hw.device_id is absent', () => {
+    const features = normalizeProtocolV2Features(
+      {
+        id: 'PR2000000000',
+        path: 'PR2000000000',
+        protocolType: 'V2',
+      } as any,
+      {
+        hw: {
+          serial_no: 'PR9999999999',
+        },
+      }
+    );
+
+    expect(features.deviceId).toBeNull();
+    expect(features.serialNo).toBe('PR9999999999');
+  });
+
+  test('uses Protocol V2 features directly when profile is absent', () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = {
       ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-      device_id: 'LEGACY-ID',
-      serial_no: 'LEGACY-SERIAL',
+      serialNo: 'LEGACY-SERIAL',
       label: 'Legacy Label',
-      ble_name: 'Legacy BLE',
-      passphrase_protection: true,
+      bleName: 'Legacy BLE',
+      passphraseProtection: true,
     };
-    device.updateProfile({
-      protocol: 'V2',
-      sources: ['deviceInfo'],
-      deviceType: 'pro2',
-      firmwareType: 'universal',
-      deviceId: '',
-      serialNo: '',
-      label: null,
-      bleName: null,
-      status: {
-        mode: 'normal',
-        initialized: true,
-        bootloaderMode: false,
-        unlocked: null,
-        passphraseProtection: null,
-        backupRequired: false,
-        noBackup: null,
-        language: null,
-      },
-      versions: {
-        firmware: null,
-        bootloader: null,
-        board: null,
-        ble: null,
-      },
-    });
 
     expect(device.toMessageObject()).toMatchObject({
-      uuid: '',
+      uuid: 'LEGACY-SERIAL',
       deviceId: null,
-      bleName: null,
-      label: 'OneKey Pro2',
+      bleName: 'Legacy BLE',
+      label: 'Legacy Label',
       deviceType: 'pro2',
     });
-    expect(device.getCurrentPassphraseProtection()).toBeNull();
+    expect(device.getCurrentPassphraseProtection()).toBe(true);
     expect(device.hasUsePassphrase()).toBe(true);
-    expect(device.isInitialized()).toBe(true);
-    expect(device.getMode()).toBe('normal');
-    expect(device.getFirmwareVersion()).toBeNull();
   });
 
-  test('keeps Protocol V2 cached profile as identity source when syncing legacy features', () => {
+  test('syncs Protocol V2 cached features without cached profile', () => {
     const cached = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (cached as any).features = {
       ...normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
-      device_id: 'LEGACY-ID',
-      serial_no: 'LEGACY-SERIAL',
-      onekey_serial_no: 'LEGACY-SERIAL',
+      deviceId: null,
+      serialNo: 'LEGACY-SERIAL',
     };
-    cached.updateProfile({
-      protocol: 'V2',
-      sources: ['deviceInfo'],
-      deviceType: 'pro2',
-      firmwareType: 'universal',
-      deviceId: '',
-      serialNo: '',
-      label: null,
-      bleName: null,
-      status: {
-        mode: 'normal',
-        initialized: true,
-        bootloaderMode: false,
-        unlocked: null,
-        passphraseProtection: null,
-        backupRequired: false,
-        noBackup: null,
-        language: null,
-      },
-      versions: {
-        firmware: null,
-        bootloader: null,
-        board: null,
-        ble: null,
-      },
-    });
 
     const current = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     current.updateFromCache(cached);
 
     expect(current.getCurrentDeviceId()).toBeUndefined();
-    expect(current.getCurrentSerialNo()).toBe('');
+    expect(current.getCurrentSerialNo()).toBe('LEGACY-SERIAL');
     expect(current.toMessageObject()).toMatchObject({
-      uuid: '',
+      uuid: 'LEGACY-SERIAL',
       deviceId: null,
     });
   });
@@ -695,9 +614,9 @@ describe('Protocol V2 feature adapter', () => {
       descriptor: descriptor as any,
     });
 
-    expect(features.device_id).toBe('PR2SERIAL');
+    expect(features.deviceId).toBeNull();
     expect(features.initialized).toBe(true);
-    expect(features.passphrase_protection).toBe(true);
+    expect(features.passphraseProtection).toBe(true);
     expect(commands.typedCall).toHaveBeenCalledTimes(1);
     expect(commands.typedCall).toHaveBeenNthCalledWith(
       1,
@@ -776,7 +695,6 @@ describe('Protocol V2 feature adapter', () => {
       },
       commands: { typedCall },
       _updateFeatures: jest.fn(),
-      updateProfile: jest.fn(),
     });
 
     const result = await method.run();
@@ -801,7 +719,7 @@ describe('Protocol V2 feature adapter', () => {
     expect(result).toMatchObject({
       protocol: 'V2',
       deviceType: 'pro2',
-      deviceId: 'PR2SERIAL',
+      deviceId: '',
       serialNo: 'PR2SERIAL',
       label: 'Raw Pro2',
       bleName: 'Raw Pro2 BLE',
@@ -846,17 +764,16 @@ describe('Protocol V2 feature adapter', () => {
         onekey_ble_version: '2.3.4',
       },
       commands: { typedCall },
-      updateProfile: jest.fn(),
     });
 
     const result = await method.run();
 
     expect(result).toMatchObject({
       protocol: 'V2',
-      // 身份字段不得取自 legacy features（LEGACY-ID / LEGACY-SERIAL）；
-      // hw.serial_no 缺失时回退 descriptor.path（早期工程板无 serial 的 mock 身份）。
-      deviceId: 'usb-path',
-      serialNo: 'usb-path',
+      // 身份字段不得取自 legacy features（LEGACY-ID / LEGACY-SERIAL），
+      // hw.serial_no 缺失时也不回退 descriptor.path。
+      deviceId: '',
+      serialNo: '',
       label: null,
       bleName: null,
       status: {
@@ -948,7 +865,6 @@ describe('Protocol V2 feature adapter', () => {
       originalDescriptor: { ...descriptor, protocolType: 'V2' },
       features: normalizeProtocolV2Features({ ...descriptor, protocolType: 'V2' } as any),
       commands: { typedCall },
-      updateProfile: jest.fn(),
     });
 
     const result = await method.run();
@@ -1088,7 +1004,7 @@ describe('Protocol V2 feature adapter', () => {
     });
   });
 
-  test('returns Protocol V2 oneKey fields without calling legacy OnekeyGetFeatures', async () => {
+  test('does not call legacy OnekeyGetFeatures for Protocol V2 devices', async () => {
     const method = new GetOnekeyFeatures({
       id: 1,
       payload: {
@@ -1124,17 +1040,11 @@ describe('Protocol V2 feature adapter', () => {
       }),
       expect.anything()
     );
-    expect(message).toMatchObject({
-      onekey_device_type: 'pro2',
-      onekey_firmware_version: '1.2.3',
-      onekey_firmware_build_id: 'app-build',
-      onekey_serial_no: 'PR2SERIAL',
-      onekey_ble_name: 'Pro2 BLE',
-    });
+    expect(message).toEqual({});
     expect(message).not.toHaveProperty('label');
   });
 
-  test('refreshes cached Protocol V2 profile with a lightweight status request on later runs', async () => {
+  test('refreshes cached Protocol V2 features with a lightweight status request on later runs', async () => {
     const device = Device.fromDescriptor({
       path: 'usb-path',
       protocolType: 'V2',
@@ -1169,17 +1079,17 @@ describe('Protocol V2 feature adapter', () => {
     await device.initialize();
 
     expect(device.features).toMatchObject({
-      device_id: 'PR2SERIAL',
-      onekey_firmware_version: '1.2.3',
-      passphrase_protection: false,
+      deviceId: null,
+      firmwareVersion: '1.2.3',
+      passphraseProtection: false,
       label: 'renamed',
     });
-    expect(device.profile?.deviceId).toBe('PR2SERIAL');
+    expect((device as any).profile).toBeUndefined();
     // status 字段被第二次刷新更新
-    expect(device.profile?.status.passphraseProtection).toBe(false);
-    expect(device.profile?.label).toBe('renamed');
+    expect(device.features?.passphraseProtection).toBe(false);
+    expect(device.features?.label).toBe('renamed');
     // 轻量刷新不含 fw target，已有版本信息按字段级合并保留
-    expect(device.profile?.versions.firmware).toBe('1.2.3');
+    expect(device.features?.firmwareVersion).toBe('1.2.3');
     expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenNthCalledWith(
       1,
@@ -1253,15 +1163,15 @@ describe('Protocol V2 feature adapter', () => {
     const features = await device.getFeatures();
 
     expect(device.features).toMatchObject({
-      device_id: 'PR2SERIAL',
-      onekey_firmware_version: '1.2.4',
-      passphrase_protection: true,
+      deviceId: null,
+      firmwareVersion: '1.2.4',
+      passphraseProtection: true,
     });
     expect(features).toMatchObject({
-      onekey_device_type: 'pro2',
-      onekey_serial_no: 'PR2SERIAL',
-      onekey_firmware_version: '1.2.4',
-      passphrase_protection: true,
+      deviceType: 'pro2',
+      serialNo: 'PR2SERIAL',
+      firmwareVersion: '1.2.4',
+      passphraseProtection: true,
     });
     expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenNthCalledWith(
@@ -1319,7 +1229,6 @@ describe('Protocol V2 feature adapter', () => {
     });
     method.init();
     (method as any).device = stubDevice({
-      profile: device.profile,
       features: device.features,
       commands: { typedCall: jest.fn() },
     });
@@ -1358,14 +1267,14 @@ describe('Protocol V2 feature adapter', () => {
     expect(typedCall).not.toHaveBeenCalledWith('GetAddress', 'Address', expect.anything());
     expect(typedCall).not.toHaveBeenCalledWith('GetFeatures', 'Features', {});
     expect(features).toMatchObject({
-      onekey_device_type: 'pro2',
-      device_id: 'PR2SERIAL',
-      onekey_firmware_version: '1.2.3',
+      deviceType: 'pro2',
+      deviceId: null,
+      firmwareVersion: '1.2.3',
       unlocked: true,
     });
   });
 
-  test('syncs Protocol V2 profile passphrase state after unlock response', async () => {
+  test('syncs Protocol V2 features passphrase state after unlock response', async () => {
     const device = Device.fromDescriptor({ ...descriptor, protocolType: 'V2' } as any);
     (device as any).features = normalizeProtocolV2Features(
       { ...descriptor, protocolType: 'V2' } as any,
@@ -1375,32 +1284,6 @@ describe('Protocol V2 feature adapter', () => {
         status: { passphrase_protection: false },
       }
     );
-    device.updateProfile({
-      protocol: 'V2',
-      sources: ['deviceInfo'],
-      deviceType: 'pro2',
-      firmwareType: 'universal',
-      deviceId: 'PR2SERIAL',
-      serialNo: 'PR2SERIAL',
-      label: null,
-      bleName: null,
-      status: {
-        mode: 'normal',
-        initialized: true,
-        bootloaderMode: false,
-        unlocked: null,
-        passphraseProtection: false,
-        backupRequired: false,
-        noBackup: null,
-        language: null,
-      },
-      versions: {
-        firmware: '4.15.0',
-        bootloader: null,
-        board: null,
-        ble: null,
-      },
-    });
     const typedCall = jest.fn().mockResolvedValue({
       type: 'UnLockDeviceResponse',
       message: {
@@ -1412,8 +1295,8 @@ describe('Protocol V2 feature adapter', () => {
 
     await device.unlockDevice();
 
-    expect(device.profile?.status.passphraseProtection).toBe(true);
-    expect(device.features?.passphrase_protection).toBe(true);
+    expect((device as any).profile).toBeUndefined();
+    expect(device.features?.passphraseProtection).toBe(true);
   });
 });
 
@@ -1432,7 +1315,7 @@ describe('API compatibility handling', () => {
     method.init();
     (method as any).device = stubDevice({
       features: {
-        onekey_device_type: 'pro2',
+        deviceType: 'pro2',
       },
       originalDescriptor: {
         protocolType: 'V2',
@@ -1470,7 +1353,7 @@ describe('API compatibility handling', () => {
 
   test('does not mark Pro2 Tron, Solana, TON, SUI and Polkadot methods as unsupported', () => {
     const features = {
-      onekey_device_type: 'pro2',
+      deviceType: 'pro2',
     } as Features;
 
     const tronMethod = new TronGetAddress({
@@ -1621,7 +1504,7 @@ describe('API compatibility handling', () => {
 
   test('allows Pro2 Solana signing methods through Protocol V2 version checks', () => {
     const features = {
-      onekey_device_type: 'pro2',
+      deviceType: 'pro2',
     } as Features;
 
     const solSignMessageMethod = new SolSignMessage({
@@ -1715,7 +1598,7 @@ describe('API compatibility handling', () => {
     method.init();
     (method as any).device = stubDevice({
       features: {
-        onekey_device_type: 'pro2',
+        deviceType: 'pro2',
       },
       originalDescriptor: {
         protocolType: 'V2',
@@ -2589,7 +2472,7 @@ describe('Protocol V2 reboot methods', () => {
     });
   });
 
-  test('sends DeviceReboot from deviceReboot', async () => {
+  test('sends DevReboot from deviceReboot', async () => {
     const typedCall = jest.fn().mockResolvedValue({ message: { message: 'ok' } });
     const method = new DeviceReboot({
       id: 1,
@@ -2603,7 +2486,7 @@ describe('Protocol V2 reboot methods', () => {
 
     await method.run();
 
-    expect(typedCall).toHaveBeenCalledWith('DeviceReboot', 'Success', {
+    expect(typedCall).toHaveBeenCalledWith('DevReboot', 'Success', {
       reboot_type: 2,
     });
   });