@onekeyfe/hd-core 1.2.0-alpha.2 → 1.2.0-alpha.21

package/__tests__/device-state-events.test.ts

@@ -0,0 +1,162 @@
+import { Device } from '../src/device/Device';
+import { DEVICE } from '../src/events';
+import { EOneKeyDeviceMode } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('Device state events', () => {
+  test('emits only the canonical state event for Protocol V2', () => {
+    const device = Device.fromDescriptor({
+      id: 'pro2',
+      path: 'pro2',
+      protocolType: 'V2',
+    } as never);
+    const onState = jest.fn();
+    const onFeatures = jest.fn();
+    device.on(DEVICE.STATE, onState);
+    device.on(DEVICE.FEATURES, onFeatures);
+
+    const state = device.updateState(
+      {
+        protocol: 'V2',
+        identity: { label: 'Renamed', bleName: 'Pro2 1234' },
+        raw: {
+          protocolV2DeviceInfo: { protocol_version: 2 },
+        },
+      },
+      'settings-write'
+    );
+
+    expect(state?.identity.label).toBe('Renamed');
+    expect(onState).toHaveBeenCalledWith(
+      device,
+      expect.objectContaining({
+        state: expect.objectContaining({ revision: 1 }),
+        revision: 1,
+        source: 'settings-write',
+      })
+    );
+    expect(onFeatures).not.toHaveBeenCalled();
+    expect(onState.mock.calls[0][1].state).not.toHaveProperty('raw');
+    expect(onState.mock.calls[0][1].state).not.toHaveProperty('session');
+    expect(device.state?.raw?.protocolV2DeviceInfo).toEqual({ protocol_version: 2 });
+  });
+
+  test.each([
+    ['normal', null, EOneKeyDeviceMode.normal],
+    ['notInitialized', false, EOneKeyDeviceMode.notInitialized],
+    ['backupMode', true, EOneKeyDeviceMode.backupMode],
+    ['bootloader', null, EOneKeyDeviceMode.bootloader],
+    ['romloader', null, EOneKeyDeviceMode.bootloader],
+  ] as const)(
+    'uses canonical %s mode even when initialized is %s',
+    (mode, initialized, expected) => {
+      const device = Device.fromDescriptor({
+        id: 'mode',
+        path: 'mode',
+        protocolType: 'V2',
+      } as never);
+      device.updateState({ protocol: 'V2', status: { mode, initialized } }, 'initialize');
+
+      expect(device.getMode()).toBe(expected);
+    }
+  );
+
+  test('commits lock success to canonical state and emits one state event', async () => {
+    const device = Device.fromDescriptor({ id: 'pro2', path: 'pro2', protocolType: 'V2' } as never);
+    (device as any).commands = {
+      typedCall: jest.fn().mockResolvedValue({ message: { message: 'locked' } }),
+    };
+    device.updateState(
+      { protocol: 'V2', status: { mode: 'normal', initialized: true, unlocked: true } },
+      'initialize'
+    );
+    const onState = jest.fn();
+    device.on(DEVICE.STATE, onState);
+
+    await device.lockDevice();
+
+    expect(device.state?.status.unlocked).toBe(false);
+    expect(onState).toHaveBeenCalledWith(
+      device,
+      expect.objectContaining({ source: 'lock', changedKeys: ['status.unlocked'] })
+    );
+  });
+
+  test('continues emitting projected Features events for Protocol V1', () => {
+    const device = Device.fromDescriptor({ id: 'legacy', path: 'legacy' } as never);
+    const onFeatures = jest.fn();
+    device.on(DEVICE.FEATURES, onFeatures);
+
+    device.updateState(
+      {
+        protocol: 'V1',
+        identity: { label: 'Legacy' },
+      },
+      'settings-write'
+    );
+
+    expect(onFeatures).toHaveBeenCalledWith(device, expect.objectContaining({ label: 'Legacy' }));
+  });
+
+  test('keeps Features assignment as an import-only compatibility projection', () => {
+    const device = Device.fromDescriptor({ id: 'legacy', path: 'legacy' } as never);
+
+    (device as any).features = {
+      protocol: 'V1',
+      deviceType: 'pro',
+      firmwareType: 'universal',
+      model: 'pro',
+      vendor: 'onekey.so',
+      deviceId: 'device-1',
+      serialNo: 'SERIAL-1',
+      label: 'Imported',
+      bleName: null,
+      capabilities: [],
+      mode: 'normal',
+      initialized: true,
+      bootloaderMode: false,
+      unlocked: true,
+      firmwarePresent: true,
+      passphraseProtection: false,
+      pinProtection: true,
+      backupRequired: false,
+      noBackup: false,
+      unfinishedBackup: false,
+      recoveryMode: false,
+      language: 'en-US',
+      bleEnabled: true,
+      sdCardPresent: false,
+      sdProtection: false,
+      wipeCodeProtection: false,
+      passphraseAlwaysOnDevice: false,
+      safetyChecks: null,
+      autoLockDelayMs: 10_000,
+      autoShutdownDelayMs: 20_000,
+      displayRotation: 0,
+      experimentalFeatures: false,
+      wallpaperPath: null,
+      brightness: 50,
+      animationEnabled: true,
+      tapToWake: true,
+      hapticFeedback: true,
+      deviceNameDisplayEnabled: true,
+      airgapMode: false,
+      fidoEnabled: true,
+      usbLockEnabled: false,
+      randomKeypad: false,
+      firmwareVersion: '4.0.0',
+      bootloaderVersion: '1.0.0',
+      boardVersion: '1.0.0',
+      bleVersion: '1.0.0',
+      sessionId: null,
+    };
+
+    expect(device.state?.identity.label).toBe('Imported');
+    expect(device.features).not.toBe((device as any).state);
+    expect(device.features?.label).toBe('Imported');
+  });
+});

package/__tests__/device-state-mapper.test.ts

@@ -0,0 +1,241 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import { Enum_SafetyCheckLevel } from '@onekeyfe/hd-transport';
+import {
+  mapApplySettingsToState,
+  mapDeviceSettingsToState,
+  mapProtocolV1FeaturesToState,
+  mapProtocolV2DeviceInfoToState,
+  mapProtocolV2DeviceStatusToState,
+} from '../src/device/DeviceStateMapper';
+
+import type { PROTO } from '../src/constants';
+import type { DeviceSettings, DeviceStatus, ProtocolV2DeviceInfo } from '@onekeyfe/hd-transport';
+
+describe('DeviceStateMapper', () => {
+  test('maps Protocol V1 Features into structured state sections', () => {
+    const patch = mapProtocolV1FeaturesToState({
+      onekey_device_type: 'PRO',
+      device_id: 'device-1',
+      label: 'Pro Wallet',
+      initialized: true,
+      unlocked: true,
+      language: 'en-US',
+      major_version: 4,
+      minor_version: 10,
+      patch_version: 1,
+      se_ver: '1.1.0.2',
+    } as PROTO.Features);
+
+    expect(patch).toMatchObject({
+      protocol: 'V1',
+      identity: {
+        deviceType: EDeviceType.Pro,
+        deviceId: 'device-1',
+        label: 'Pro Wallet',
+      },
+      status: { mode: 'normal', initialized: true, unlocked: true },
+      settings: { language: 'en-US' },
+      versions: { firmware: '4.10.1', se: '1.1.0.2', se01: '1.1.0.2' },
+    });
+  });
+
+  test.each([
+    ['CLASSIC1S', EDeviceType.Classic1s],
+    ['TOUCH', EDeviceType.Touch],
+    ['PRO', EDeviceType.Pro],
+  ] as const)(
+    'keeps the real label separate from display fallbacks for Protocol V1 %s',
+    (onekeyDeviceType, expectedDeviceType) => {
+      const patch = mapProtocolV1FeaturesToState({
+        onekey_device_type: onekeyDeviceType,
+        onekey_ble_name: `${onekeyDeviceType} BLE`,
+        initialized: true,
+      } as PROTO.Features);
+
+      expect(patch.identity).toMatchObject({
+        deviceType: expectedDeviceType,
+        label: null,
+        bleName: `${onekeyDeviceType} BLE`,
+      });
+    }
+  );
+
+  test.each([
+    ['CLASSIC1S', EDeviceType.Classic1s],
+    ['TOUCH', EDeviceType.Touch],
+    ['PRO', EDeviceType.Pro],
+  ] as const)(
+    'preserves Protocol V1 backup mode semantics for %s',
+    (onekeyDeviceType, expectedDeviceType) => {
+      const patch = mapProtocolV1FeaturesToState({
+        onekey_device_type: onekeyDeviceType,
+        initialized: true,
+        no_backup: true,
+      } as PROTO.Features);
+
+      expect(patch.identity?.deviceType).toBe(expectedDeviceType);
+      expect(patch.status?.mode).toBe('backupMode');
+    }
+  );
+
+  test('normalizes legacy Bitcoin-only and Attach PIN fields from Protocol V1', () => {
+    const patch = mapProtocolV1FeaturesToState({
+      onekey_device_type: 'PRO',
+      capabilities: [1],
+      attach_to_pin_user: true,
+      unlocked_attach_pin: true,
+      initialized: true,
+    } as PROTO.Features);
+
+    expect(patch.identity?.firmwareType).toBe(EFirmwareType.BitcoinOnly);
+    expect(patch.status).toMatchObject({
+      attachToPinEnabled: true,
+      unlockedAttachPin: true,
+    });
+  });
+
+  test('keeps Protocol V1 universal firmware when the decoded Bitcoin-like capability is present', () => {
+    const patch = mapProtocolV1FeaturesToState({
+      onekey_device_type: 'CLASSIC1S',
+      capabilities: ['Capability_Bitcoin_like'],
+      initialized: true,
+    } as PROTO.Features);
+
+    expect(patch.identity?.firmwareType).toBe(EFirmwareType.Universal);
+  });
+
+  test('maps Protocol V2 DeviceInfo without inventing runtime status', () => {
+    const patch = mapProtocolV2DeviceInfoToState(
+      {
+        protocol_version: 2,
+        hw: { serial_no: 'SERIAL-1' },
+        fw: {
+          application: { version: '5.0.0' },
+          bootloader: { version: '2.0.0' },
+        },
+        coprocessor: {
+          bt_adv_name: 'Pro2 1234',
+          application: { version: '1.2.3' },
+        },
+      } as ProtocolV2DeviceInfo,
+      'normal'
+    );
+
+    expect(patch.identity).toMatchObject({
+      deviceType: EDeviceType.Pro2,
+      serialNo: 'SERIAL-1',
+      bleName: 'Pro2 1234',
+    });
+    expect(patch.versions).toMatchObject({
+      firmware: '5.0.0',
+      bootloader: '2.0.0',
+      ble: '1.2.3',
+    });
+    expect(patch).toMatchObject({ protocolVersion: 2 });
+    expect(patch.status?.unlocked).toBeUndefined();
+  });
+
+  test('keeps normal mode when Protocol V2 application and SE versions are returned together', () => {
+    const patch = mapProtocolV2DeviceInfoToState(
+      {
+        protocol_version: 2,
+        hw: { serial_no: 'SERIAL-NORMAL' },
+        fw: {
+          application: { version: '5.0.0' },
+          bootloader: { version: '2.0.0' },
+        },
+        se1: {
+          application: { version: '1.0.0', build_id: 'se-app', hash: [0x01, 0x02] },
+          bootloader: { version: '0.1.0', build_id: 'se-boot', hash: [0x03, 0x04] },
+        },
+      } as ProtocolV2DeviceInfo,
+      'normal'
+    );
+
+    expect(patch.status?.mode).toBe('normal');
+    expect(patch.verification).toMatchObject({
+      se01BuildId: 'se-app',
+      se01Hash: '0102',
+      se01BootBuildId: 'se-boot',
+      se01BootHash: '0304',
+    });
+  });
+
+  test.each([
+    [
+      'bootloader',
+      {
+        hw: { serial_no: 'SERIAL-BOOT' },
+        fw: { bootloader: { version: '2.0.0' } },
+        se1: {},
+      },
+    ],
+    [
+      'romloader',
+      {
+        hw: { serial_no: 'SERIAL-ROM' },
+        fw: {
+          romloader: { version: '1.0.0' },
+          bootloader: { version: '2.0.0' },
+        },
+      },
+    ],
+  ] as const)('clears stale device identity in Protocol V2 %s mode', (mode, info) => {
+    const patch = mapProtocolV2DeviceInfoToState(info as ProtocolV2DeviceInfo, mode);
+
+    expect(patch.status?.mode).toBe(mode);
+    expect(patch.identity).toMatchObject({ deviceId: null });
+  });
+
+  test('maps Protocol V2 status separately and ignores locked passphrase value', () => {
+    const locked = mapProtocolV2DeviceStatusToState({
+      device_id: 'device-2',
+      init_states: true,
+      unlocked: false,
+      passphrase_enabled: true,
+      backup_required: true,
+    } as DeviceStatus);
+
+    expect(locked.identity?.deviceId).toBe('device-2');
+    expect(locked.status).toMatchObject({
+      mode: 'normal',
+      initialized: true,
+      unlocked: false,
+      backupRequired: true,
+    });
+    expect(locked.status).not.toHaveProperty('passphraseProtection');
+  });
+
+  test('maps common settings into identity, status and settings sections', () => {
+    expect(
+      mapApplySettingsToState({
+        label: 'Renamed',
+        use_passphrase: true,
+        haptic_feedback: false,
+        use_ble: true,
+        safety_checks: 'Strict',
+      })
+    ).toEqual({
+      identity: { label: 'Renamed' },
+      status: { passphraseProtection: true },
+      settings: {
+        hapticFeedback: false,
+        bleEnabled: true,
+        safetyChecks: Enum_SafetyCheckLevel.Strict,
+      },
+    });
+
+    expect(
+      mapDeviceSettingsToState({
+        label: 'Pro2',
+        language: 'en-Latn-US',
+        brightness: 80,
+        autolock_delay_ms: 30_000,
+      } as DeviceSettings)
+    ).toEqual({
+      identity: { label: 'Pro2' },
+      settings: { language: 'en', brightness: 80, autoLockDelayMs: 30_000 },
+    });
+  });
+});

package/__tests__/device-state-projector.test.ts

@@ -0,0 +1,94 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import { createEmptyDeviceState } from '../src/device/DeviceStateStore';
+import { projectFeatures } from '../src/device/DeviceStateProjector';
+
+describe('DeviceStateProjector', () => {
+  test('projects legacy Features from the canonical snapshot', () => {
+    const state = createEmptyDeviceState({
+      deviceType: EDeviceType.Pro2,
+      firmwareType: EFirmwareType.Universal,
+      deviceId: 'device-1',
+      serialNo: 'SERIAL-1',
+      label: 'My Pro2',
+      bleName: 'Pro2 1234',
+    });
+    state.protocol = 'V2';
+    state.protocolVersion = 7;
+    state.status = {
+      ...state.status,
+      mode: 'normal',
+      initialized: true,
+      unlocked: true,
+      passphraseProtection: false,
+    };
+    state.settings = {
+      ...state.settings,
+      language: 'en-US',
+      brightness: 80,
+      autoLockDelayMs: 30_000,
+    };
+    state.versions = {
+      ...state.versions,
+      firmware: '5.0.0',
+      bootloader: '2.0.0',
+      ble: '1.2.3',
+    };
+
+    const features = projectFeatures(state);
+    expect(features).toMatchObject({
+      protocol: 'V2',
+      protocolVersion: 7,
+      label: 'My Pro2',
+      unlocked: true,
+      brightness: 80,
+      firmwareVersion: '5.0.0',
+    });
+  });
+
+  test.each([
+    [EDeviceType.Classic1s],
+    [EDeviceType.ClassicPure],
+    [EDeviceType.Touch],
+    [EDeviceType.Pro],
+  ] as const)('preserves Protocol V1 compatibility defaults for %s', deviceType => {
+    const state = createEmptyDeviceState({ deviceType });
+    state.protocol = 'V1';
+    state.versions.se = '1.1.0.2';
+    state.raw = {
+      protocolV1Features: {
+        onekey_device_type: deviceType,
+        initialized: true,
+      } as never,
+    };
+
+    const features = projectFeatures(state);
+
+    expect(features).toMatchObject({
+      protocolVersion: 1,
+      label: null,
+      bootloaderMode: null,
+      bootloader_mode: null,
+      seVersion: '1.1.0.2',
+    });
+  });
+
+  test('returns an isolated compatibility snapshot', () => {
+    const state = createEmptyDeviceState({ deviceType: EDeviceType.Pro });
+    state.protocol = 'V1';
+    state.capabilities = [1];
+    state.verification = { firmwareBuildId: 'build-1' };
+    state.raw = {
+      protocolV1Features: { label: 'Original' } as never,
+    };
+
+    const features = projectFeatures(state);
+    features.capabilities.push(2);
+    if (features.verify) features.verify.firmwareBuildId = 'mutated';
+    if (features.raw?.protocolV1Features) features.raw.protocolV1Features.label = 'Mutated';
+
+    expect(state.capabilities).toEqual([1]);
+    expect(state.verification?.firmwareBuildId).toBe('build-1');
+    expect(state.raw.protocolV1Features?.label).toBe('Original');
+  });
+});

package/__tests__/device-state-store.test.ts

@@ -0,0 +1,82 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import { DeviceStateStore, createEmptyDeviceState } from '../src/device/DeviceStateStore';
+
+describe('DeviceStateStore', () => {
+  test('merges identity patches and ignores undefined', () => {
+    const store = new DeviceStateStore(
+      createEmptyDeviceState({
+        deviceType: EDeviceType.Pro2,
+        firmwareType: EFirmwareType.Universal,
+      })
+    );
+
+    store.update({ identity: { bleName: 'Pro2 1234', label: null } }, 'initialize');
+    const result = store.update(
+      { identity: { label: 'My Wallet', bleName: undefined } },
+      'settings-write'
+    );
+
+    expect(result.state.identity).toMatchObject({
+      label: 'My Wallet',
+      bleName: 'Pro2 1234',
+    });
+    expect(result.revision).toBe(2);
+    expect(result.changedKeys).toContain('identity.label');
+  });
+
+  test('does not advance revision when the patch has no real changes', () => {
+    const store = new DeviceStateStore(createEmptyDeviceState());
+    const first = store.update({ status: { unlocked: null } }, 'device-status');
+    const second = store.update({ status: { unlocked: null } }, 'device-status');
+
+    expect(first.revision).toBe(0);
+    expect(second.revision).toBe(0);
+    expect(second.changedKeys).toEqual([]);
+  });
+
+  test('stores the wire protocol version independently from the protocol family', () => {
+    const store = new DeviceStateStore(createEmptyDeviceState());
+
+    const result = store.update({ protocol: 'V2', protocolVersion: 7 }, 'device-info');
+
+    expect(result.state.protocol).toBe('V2');
+    expect(result.state.protocolVersion).toBe(7);
+    expect(result.changedKeys).toContain('protocolVersion');
+  });
+
+  test('merges raw protocol sources instead of replacing the previous source', () => {
+    const store = new DeviceStateStore(createEmptyDeviceState());
+    const deviceInfo = { protocol_version: 2, hw: { serial_no: 'SERIAL-1' } };
+    const deviceStatus = { device_id: 'DEVICE-1', unlocked: true };
+
+    store.update({ raw: { protocolV2DeviceInfo: deviceInfo } }, 'device-info');
+    const result = store.update({ raw: { protocolV2DeviceStatus: deviceStatus } }, 'device-status');
+
+    expect(result.state.raw).toEqual({
+      protocolV2DeviceInfo: deviceInfo,
+      protocolV2DeviceStatus: deviceStatus,
+    });
+  });
+
+  test('removes only the explicitly cleared raw protocol source', () => {
+    const store = new DeviceStateStore(createEmptyDeviceState());
+    const deviceInfo = { protocol_version: 2, hw: { serial_no: 'SERIAL-1' } };
+    const deviceStatus = { device_id: 'DEVICE-1', unlocked: true };
+
+    store.update(
+      {
+        raw: {
+          protocolV2DeviceInfo: deviceInfo,
+          protocolV2DeviceStatus: deviceStatus,
+        },
+      },
+      'initialize'
+    );
+    const result = store.update({ raw: { protocolV2DeviceStatus: null } }, 'device-info');
+
+    expect(result.state.raw).toEqual({
+      protocolV2DeviceInfo: deviceInfo,
+    });
+  });
+});

package/__tests__/device-utils.test.ts

@@ -0,0 +1,106 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import {
+  getDeviceSerialNo,
+  getDeviceType,
+  getDeviceUUID,
+  getFirmwareType,
+} from '../src/utils/deviceInfoUtils';
+import {
+  getDeviceBLEFirmwareVersion,
+  getDeviceBoardloaderVersion,
+  getDeviceBootloaderVersion,
+  getDeviceFirmwareVersion,
+} from '../src/utils/deviceVersionUtils';
+import {
+  buildProtocolV1FeaturesPayload,
+  buildProtocolV2FeaturesPayload,
+} from '../src/deviceProfile';
+
+import type { PROTO } from '../src/constants';
+
+describe('device feature selectors', () => {
+  test('reads legacy Protocol V1 features without exposing the internal builder', () => {
+    const features = {
+      onekey_device_type: 'CLASSIC1S',
+      onekey_serial_no: 'CP123456',
+      fw_vendor: 'OneKey Bitcoin-only',
+      onekey_firmware_version: 'v3.5.0',
+      onekey_boot_version: '2.8.0-alpha.1',
+      onekey_board_version: '1.2.3+board',
+      onekey_ble_version: '1.4.0+ble',
+    } as PROTO.Features;
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Classic1s);
+    expect(getDeviceSerialNo(features)).toBe('CP123456');
+    expect(getFirmwareType(features)).toBe(EFirmwareType.BitcoinOnly);
+    expect(getDeviceFirmwareVersion(features)).toEqual([3, 5, 0]);
+    expect(getDeviceBootloaderVersion(features)).toEqual([2, 8, 0]);
+    expect(getDeviceBoardloaderVersion(features)).toEqual([1, 2, 3]);
+    expect(getDeviceBLEFirmwareVersion(features)).toEqual([1, 4, 0]);
+  });
+
+  test('keeps getDeviceUUID as a compatibility alias', () => {
+    const features = {
+      onekey_serial_no: 'PR123456',
+      fw_vendor: 'OneKey Bitcoin-only',
+      onekey_board_version: '1.2.3',
+      onekey_ble_version: '2.3.4',
+    } as PROTO.Features;
+
+    expect(getDeviceUUID(features)).toBe(getDeviceSerialNo(features));
+  });
+
+  test('uses bootloader version parts from old Protocol V1 firmware', () => {
+    const features = {
+      bootloader_mode: true,
+      major_version: 1,
+      minor_version: 8,
+      patch_version: 3,
+      model: '1',
+    } as PROTO.Features;
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Classic);
+    expect(getDeviceBootloaderVersion(features)).toEqual([1, 8, 3]);
+  });
+
+  test('shares Protocol V1 compatibility semantics with the internal builder', () => {
+    const rawFeatures = {
+      onekey_device_type: 'PRO',
+      onekey_serial_no: 'PR123456',
+      onekey_firmware_version: '4.16.0',
+      onekey_boot_version: '2.8.0',
+      fw_vendor: 'OneKey Bitcoin-only',
+    } as PROTO.Features;
+    const normalized = buildProtocolV1FeaturesPayload(rawFeatures);
+
+    expect(getDeviceType(normalized)).toBe(getDeviceType(rawFeatures));
+    expect(getDeviceSerialNo(normalized)).toBe(getDeviceSerialNo(rawFeatures));
+    expect(getFirmwareType(normalized)).toBe(getFirmwareType(rawFeatures));
+    expect(getDeviceFirmwareVersion(normalized)).toEqual(getDeviceFirmwareVersion(rawFeatures));
+    expect(getDeviceBootloaderVersion(normalized)).toEqual(getDeviceBootloaderVersion(rawFeatures));
+  });
+
+  test('reads normalized Protocol V2 features through the same public selectors', () => {
+    const features = buildProtocolV2FeaturesPayload({
+      deviceInfo: {
+        hw: { serial_no: 'P2-001' },
+        fw: {
+          application: { version: '5.0.0' },
+          bootloader: { version: '2.0.0' },
+          romloader: { version: '1.0.0' },
+        },
+        coprocessor: {
+          application: { version: '3.0.0' },
+        },
+      },
+    });
+
+    expect(getDeviceType(features)).toBe(EDeviceType.Pro2);
+    expect(getDeviceSerialNo(features)).toBe('P2-001');
+    expect(getDeviceFirmwareVersion(features)).toEqual([5, 0, 0]);
+    expect(getDeviceBootloaderVersion(features)).toEqual([2, 0, 0]);
+    expect(getDeviceBoardloaderVersion(features)).toEqual([1, 0, 0]);
+    expect(getDeviceBLEFirmwareVersion(features)).toEqual([3, 0, 0]);
+  });
+});