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

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

@@ -0,0 +1,222 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+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' },
+    });
+  });
+
+  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);
+
+    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);
+
+    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' } },
+      },
+    ],
+    [
+      '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);
+
+    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 })
+    ).toEqual({
+      identity: { label: 'Renamed' },
+      status: { passphraseProtection: true },
+      settings: { hapticFeedback: false },
+    });
+
+    expect(
+      mapDeviceSettingsToState({
+        label: 'Pro2',
+        brightness: 80,
+        autolock_delay_ms: 30_000,
+      } as DeviceSettings)
+    ).toEqual({
+      identity: { label: 'Pro2' },
+      settings: { 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,115 @@
+import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+
+import { DeviceStateStore, createEmptyDeviceState } from '../src/device/DeviceStateStore';
+
+describe('DeviceStateStore', () => {
+  test('merges patches, ignores undefined and recomputes displayName', () => {
+    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 } },
+      'apply-settings'
+    );
+
+    expect(result.state.identity).toMatchObject({
+      label: 'My Wallet',
+      bleName: 'Pro2 1234',
+      displayName: 'My Wallet',
+    });
+    expect(result.revision).toBe(2);
+    expect(result.changedKeys).toContain('identity.label');
+    expect(result.changedKeys).toContain('identity.displayName');
+  });
+
+  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('clears only ephemeral session state', () => {
+    const store = new DeviceStateStore(createEmptyDeviceState());
+    store.update(
+      {
+        identity: { label: 'Kept' },
+        session: { sessionId: 'session-1', passphraseState: 'state-1' },
+      },
+      'initialize'
+    );
+
+    const result = store.clearSession('transport-reconnect');
+
+    expect(result?.state.identity.label).toBe('Kept');
+    expect(result?.state.session).toBeUndefined();
+  });
+
+  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,
+    });
+  });
+
+  test.each([
+    [EDeviceType.Classic1s, 'OneKey Classic 1S'],
+    [EDeviceType.ClassicPure, 'OneKey Classic 1S Pure'],
+    [EDeviceType.Touch, 'OneKey Touch'],
+    [EDeviceType.Pro, 'OneKey Pro'],
+    [EDeviceType.Pro2, 'OneKey Pro 2'],
+  ] as const)(
+    'uses the product display name for %s when label and BLE name are absent',
+    (type, name) => {
+      const state = createEmptyDeviceState({ deviceType: type });
+
+      expect(state.identity.displayName).toBe(name);
+    }
+  );
+});

package/__tests__/device-wallet-session-store.test.ts

@@ -3,6 +3,8 @@ import {
   DeviceWalletSessionStore,
   deviceWalletSessionStore,
 } from '../src/device/DeviceWalletSessionStore';
+import { Device } from '../src/device/Device';
+import { DevicePool } from '../src/device/DevicePool';
 import { createCoreApi } from '../src/inject';
 
 jest.mock('../src/data/config', () => ({
@@ -73,6 +75,50 @@ describe('DeviceWalletSessionStore', () => {
 describe('ClearSessionCache', () => {
   beforeEach(() => {
     deviceWalletSessionStore.clear();
+    DevicePool.devicesCache = {};
+  });
+
+  afterEach(() => {
+    DevicePool.devicesCache = {};
+  });
+
+  test('clears matching sessions from both runtime stores', async () => {
+    const matchingDevice = Device.fromDescriptor({ id: 'one', path: 'one' } as never);
+    matchingDevice.updateState(
+      {
+        protocol: 'V1',
+        identity: { deviceId: 'device-1' },
+        session: { sessionId: 'session-a', passphraseState: 'hidden-a' },
+      },
+      'initialize'
+    );
+    const otherDevice = Device.fromDescriptor({ id: 'two', path: 'two' } as never);
+    otherDevice.updateState(
+      {
+        protocol: 'V1',
+        identity: { deviceId: 'device-2' },
+        session: { sessionId: 'session-b', passphraseState: 'hidden-a' },
+      },
+      'initialize'
+    );
+    DevicePool.devicesCache = { one: matchingDevice, two: otherDevice };
+    deviceWalletSessionStore.set('device-1', 'hidden-a', 'session-a');
+
+    const method = new ClearSessionCache({
+      payload: {
+        method: 'clearSessionCache',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-a',
+      },
+    });
+    method.init();
+    await method.run();
+
+    expect((matchingDevice.state as any)?.session).toBeUndefined();
+    expect((otherDevice.state as any)?.session).toEqual({
+      sessionId: 'session-b',
+      passphraseState: 'hidden-a',
+    });
   });
 
   test('clears one wallet without using a device', async () => {

package/__tests__/deviceFeaturesUtils.test.ts

@@ -1,7 +1,10 @@
 import { EDeviceType } from '@onekeyfe/hd-shared';
 
 import DataManager from '../src/data-manager/DataManager';
-import { getSupportProtocolV1MessageSchema } from '../src/utils/deviceFeaturesUtils';
+import {
+  getSupportProtocolV1MessageSchema,
+  supportInputPinOnSoftware,
+} from '../src/utils/deviceFeaturesUtils';
 
 import type { Features } from '../src/types';
 
@@ -24,4 +27,13 @@ describe('getSupportProtocolV1MessageSchema', () => {
     expect(result.protocolV1MessageSchema).toBe('v1CurrentSchema');
     expect(result.messages).toBe(DataManager.messages.v1CurrentSchema);
   });
+
+  test('Pro2 never supports entering PIN in software', () => {
+    const features = {
+      deviceType: EDeviceType.Pro2,
+      firmwareVersion: '9.9.9',
+    } as Features;
+
+    expect(supportInputPinOnSoftware(features)).toEqual({ support: false });
+  });
 });

package/__tests__/deviceSettings.test.ts

@@ -0,0 +1,54 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
+import {
+  getAutoLockOptions,
+  getAutoShutDownOptions,
+  getLanguageConfig,
+} from '../src/utils/deviceSettings';
+
+describe('Pro 2 device settings options', () => {
+  test('returns the firmware-supported BCP-47 languages', () => {
+    expect(getLanguageConfig(EDeviceType.Pro2)).toEqual([
+      { code: 'en-Latn-US', label: 'English' },
+      { code: 'zh-Hans-CN', label: '简体中文' },
+      { code: 'zh-Hant-HK', label: '繁體中文（香港）' },
+      { code: 'zh-Hant-TW', label: '繁體中文（台灣）' },
+      { code: 'ja-Jpan-JP', label: '日本語' },
+      { code: 'ko-Kore-KR', label: '한국어' },
+      { code: 'fr-Latn-FR', label: 'Français' },
+      { code: 'de-Latn-DE', label: 'Deutsch' },
+      { code: 'ru-Cyrl-RU', label: 'Русский' },
+      { code: 'es-Latn-ES', label: 'Español' },
+      { code: 'it-Latn-IT', label: 'Italiano' },
+      { code: 'pt-Latn-BR', label: 'Portuguese (Brazil)' },
+      { code: 'vi-Latn-VN', label: 'Tiếng Việt' },
+      { code: 'tr-Latn-TR', label: 'Türkçe' },
+      { code: 'id-Latn-ID', label: 'Bahasa Indonesia' },
+      { code: 'fil-Latn-PH', label: 'Filipino' },
+      { code: 'uk-Cyrl-UA', label: 'Українська' },
+    ]);
+  });
+
+  test('returns the firmware-supported auto-lock delays', () => {
+    expect(getAutoLockOptions(EDeviceType.Pro2)).toEqual([
+      { seconds: 30, minute: 0, hour: 0, day: 0 },
+      { seconds: 0, minute: 1, hour: 0, day: 0 },
+      { seconds: 0, minute: 2, hour: 0, day: 0 },
+      { seconds: 0, minute: 5, hour: 0, day: 0 },
+      { seconds: 0, minute: 10, hour: 0, day: 0 },
+      { seconds: 0, minute: 30, hour: 0, day: 0 },
+      { seconds: 0, minute: 0, hour: 0, day: 0 },
+    ]);
+  });
+
+  test('returns the firmware-supported auto-shutdown delays', () => {
+    expect(getAutoShutDownOptions(EDeviceType.Pro2)).toEqual([
+      { seconds: 0, minute: 1, hour: 0, day: 0 },
+      { seconds: 0, minute: 2, hour: 0, day: 0 },
+      { seconds: 0, minute: 5, hour: 0, day: 0 },
+      { seconds: 0, minute: 10, hour: 0, day: 0 },
+      { seconds: 0, minute: 30, hour: 0, day: 0 },
+      { seconds: 0, minute: 0, hour: 0, day: 0 },
+    ]);
+  });
+});