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

package/__tests__/DeviceEventRegistration.test.ts

@@ -6,6 +6,7 @@ const handlers = {
   button: jest.fn(),
   passphrase: jest.fn(),
   passphraseOnDevice: jest.fn(),
+  attachPinOnDevice: jest.fn(),
 };
 
 const createDevice = (protocolV2: boolean) => ({
@@ -23,6 +24,7 @@ describe('hardware UI event registration', () => {
       DEVICE.BUTTON,
       DEVICE.PASSPHRASE,
       DEVICE.PASSPHRASE_ON_DEVICE,
+      DEVICE.ATTACH_PIN_ON_DEVICE,
     ]);
   });
 
@@ -35,6 +37,7 @@ describe('hardware UI event registration', () => {
       DEVICE.BUTTON,
       DEVICE.PASSPHRASE,
       DEVICE.PASSPHRASE_ON_DEVICE,
+      DEVICE.ATTACH_PIN_ON_DEVICE,
     ]);
   });
 });

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

@@ -0,0 +1,78 @@
+import { mergeDeviceFeaturesPatch } from '../src/device/DeviceFeaturesState';
+
+import type { Features } from '../src/types';
+
+const baseFeatures = {
+  protocol: 'V2',
+  deviceType: 'pro2',
+  firmwareType: 'universal',
+  model: 'pro2',
+  vendor: 'onekey.so',
+  deviceId: null,
+  serialNo: 'P20001',
+  label: 'Old Label',
+  bleName: 'Pro2 0001',
+  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: null,
+  sdProtection: null,
+  wipeCodeProtection: null,
+  passphraseAlwaysOnDevice: null,
+  safetyChecks: null,
+  autoLockDelayMs: 60_000,
+  displayRotation: null,
+  experimentalFeatures: false,
+  firmwareVersion: '1.0.0',
+  bootloaderVersion: '1.0.0',
+  boardVersion: '1.0.0',
+  bleVersion: '1.0.0',
+  sessionId: null,
+} as Features;
+
+describe('mergeDeviceFeaturesPatch', () => {
+  it('ignores undefined fields instead of clearing cached values', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, {
+      label: undefined,
+      language: 'ja-JP',
+    });
+
+    expect(next).toMatchObject({
+      label: 'Old Label',
+      language: 'ja-JP',
+    });
+  });
+
+  it('allows null to explicitly clear a cached value', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, { label: null });
+
+    expect(next.label).toBeNull();
+  });
+
+  it('returns the same object when no value changes', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, {
+      label: 'Old Label',
+      language: undefined,
+    });
+
+    expect(next).toBe(baseFeatures);
+  });
+
+  it('returns a new object when a defined value changes', () => {
+    const next = mergeDeviceFeaturesPatch(baseFeatures, { label: 'New Label' });
+
+    expect(next).not.toBe(baseFeatures);
+    expect(next.label).toBe('New Label');
+  });
+});

package/__tests__/device-identity.test.ts

@@ -0,0 +1,30 @@
+import { checkLiveDeviceId } from '../src/device/deviceIdentity';
+
+describe('live device identity', () => {
+  test('refreshes Protocol V2 status before comparing the expected device id', async () => {
+    let currentDeviceId = 'OLD_DEVICE_ID';
+    const device = {
+      isProtocolV2: () => true,
+      getDeviceState: jest.fn().mockImplementation(async () => {
+        currentDeviceId = 'NEW_DEVICE_ID';
+        return { identity: { deviceId: currentDeviceId } };
+      }),
+      checkDeviceId: jest.fn((expected: string) => currentDeviceId === expected),
+    };
+
+    await expect(checkLiveDeviceId(device as never, 'OLD_DEVICE_ID')).resolves.toBe(false);
+    expect(device.getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status'] });
+    expect(device.checkDeviceId).toHaveBeenCalledWith('OLD_DEVICE_ID');
+  });
+
+  test('keeps Protocol V1 identity checks on the Initialize/GetFeatures state', async () => {
+    const device = {
+      isProtocolV2: () => false,
+      getDeviceState: jest.fn(),
+      checkDeviceId: jest.fn(() => true),
+    };
+
+    await expect(checkLiveDeviceId(device as never, 'V1_DEVICE_ID')).resolves.toBe(true);
+    expect(device.getDeviceState).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,113 @@
+import { DevicePool } from '../src/device/DevicePool';
+import { Device } from '../src/device/Device';
+import { DEVICE } from '../src/events';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
+}));
+
+describe('DevicePool state lifecycle', () => {
+  beforeEach(() => {
+    DevicePool.resetState();
+  });
+
+  afterEach(() => {
+    DevicePool.resetState();
+  });
+
+  test('refreshes runtime state for a cached Protocol V2 discovery result', async () => {
+    const descriptor = { path: 'pro2-path', protocolType: 'V2' } as any;
+    const getDeviceState = jest.fn().mockResolvedValue({ status: { mode: 'normal' } });
+    const device = {
+      originalDescriptor: descriptor,
+      updateDescriptor: jest.fn(),
+      isProtocolV2: () => true,
+      getDeviceState,
+      run: jest.fn(async (callback: () => Promise<void>) => callback()),
+    } as any;
+    DevicePool.devicesCache = { 'pro2-id': device };
+
+    await DevicePool.getDevices([descriptor], 'pro2-id', {
+      connectProtocol: 'V2',
+      refreshRuntimeState: true,
+    });
+
+    expect(device.run).toHaveBeenCalledTimes(1);
+    expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['status'] });
+  });
+
+  test('uses the disconnected descriptor and invalidates its cached state', () => {
+    const descriptor = { path: 'pro2-path', protocolType: 'V2' } as any;
+    const device = {
+      originalDescriptor: descriptor,
+      markTransportDisconnected: jest.fn(),
+    } as any;
+    DevicePool.devicesCache = { 'pro2-id': device };
+    DevicePool.disconnectPool = [descriptor];
+    const onDisconnect = jest.fn();
+    DevicePool.emitter.on(DEVICE.DISCONNECT, onDisconnect);
+
+    (DevicePool as any)._sendDisconnectMessage();
+
+    expect(device.markTransportDisconnected).toHaveBeenCalledTimes(1);
+    expect(onDisconnect).toHaveBeenCalledWith(device);
+    expect(DevicePool.disconnectPool).toEqual([]);
+  });
+
+  test('releases a newly created device when initialization fails', async () => {
+    const descriptor = { path: 'pro2-path', protocolType: 'V2' } as any;
+    const release = jest.fn().mockResolvedValue(undefined);
+    const device = {
+      connect: jest.fn().mockResolvedValue(true),
+      initialize: jest.fn().mockRejectedValue(new Error('initialize failed')),
+      release,
+    } as any;
+    const fromDescriptor = jest.spyOn(Device, 'fromDescriptor').mockReturnValue(device);
+
+    try {
+      await expect((DevicePool as any)._createDevice(descriptor)).rejects.toThrow(
+        'initialize failed'
+      );
+    } finally {
+      fromDescriptor.mockRestore();
+    }
+
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+
+  test('releases the cached device before surfacing a runtime refresh error', async () => {
+    const refreshError = new Error('status failed');
+    let callbackRejected = false;
+    const device = {
+      isProtocolV2: () => true,
+      getDeviceState: jest.fn().mockRejectedValue(refreshError),
+      run: jest.fn(async (callback: () => Promise<void>) => {
+        try {
+          await callback();
+        } catch {
+          callbackRejected = true;
+        }
+      }),
+    } as any;
+
+    await expect(
+      (DevicePool as any)._refreshRuntimeState(device, { refreshRuntimeState: true })
+    ).rejects.toBe(refreshError);
+    expect(callbackRejected).toBe(false);
+  });
+
+  test('releases an acquired device when reinitialization fails', async () => {
+    const device = Device.fromDescriptor({ path: 'pro2-path', protocolType: 'V2' } as any);
+    (device as any).commands = { disposed: true };
+    jest.spyOn(device, 'acquire').mockResolvedValue(true);
+    jest.spyOn(device, 'initialize').mockRejectedValue(new Error('reinitialize failed'));
+    const release = jest.spyOn(device, 'release').mockResolvedValue(undefined);
+
+    await expect(device.run(jest.fn().mockResolvedValue(undefined))).rejects.toThrow(
+      'reinitialize failed'
+    );
+
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+});

package/__tests__/device-settings.test.ts

@@ -0,0 +1,108 @@
+import DeviceSettings from '../src/api/device/DeviceSettings';
+
+import type { Features } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+const features = {
+  protocol: 'V2',
+  label: 'Old Label',
+  language: 'en-US',
+} as Features;
+
+function createDevice({ protocol }: { protocol: 'V1' | 'V2' }) {
+  const typedCall = jest.fn().mockResolvedValue({ message: { message: 'Success' } });
+  const updateState = jest.fn();
+  return {
+    device: {
+      features,
+      isProtocolV2: () => protocol === 'V2',
+      commands: { typedCall },
+      updateState,
+    },
+    typedCall,
+    updateState,
+  };
+}
+
+describe('DeviceSettings protocol routing', () => {
+  it('uses ApplySettings and commits the confirmed patch for Protocol V1', async () => {
+    const { device, typedCall, updateState } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 1,
+      payload: {
+        method: 'deviceSettings',
+        label: 'Shared Label',
+        language: 'ja-JP',
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith('ApplySettings', 'Success', {
+      label: 'Shared Label',
+      language: 'ja-JP',
+      use_passphrase: undefined,
+      homescreen: undefined,
+      _passphrase_source: undefined,
+      auto_lock_delay_ms: undefined,
+      display_rotation: undefined,
+      passphrase_always_on_device: undefined,
+      safety_checks: undefined,
+      experimental_features: undefined,
+      auto_shutdown_delay_ms: undefined,
+      haptic_feedback: undefined,
+    });
+    expect(updateState).toHaveBeenCalledWith(
+      {
+        identity: { label: 'Shared Label' },
+        settings: { language: 'ja-JP' },
+      },
+      'apply-settings'
+    );
+  });
+
+  it('uses DeviceSettingsSet and commits the confirmed patch for Protocol V2', async () => {
+    const { device, typedCall, updateState } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 2,
+      payload: {
+        method: 'deviceSettings',
+        label: 'Shared Label',
+        language: 'ja-JP',
+        autoLockDelayMs: 60_000,
+        hapticFeedback: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsSet', 'Success', {
+      settings: {
+        label: 'Shared Label',
+        language: 'ja-JP',
+        autolock_delay_ms: 60_000,
+        haptic_feedback: true,
+      },
+    });
+    expect(updateState).toHaveBeenCalledWith(
+      {
+        identity: { label: 'Shared Label' },
+        settings: {
+          language: 'ja-JP',
+          autoLockDelayMs: 60_000,
+          hapticFeedback: true,
+        },
+      },
+      'apply-settings'
+    );
+    expect(typedCall.mock.calls.map(call => call[0])).not.toEqual(
+      expect.arrayContaining(['DeviceInfoGet', 'DeviceStatusGet', 'DeviceSettingsGet'])
+    );
+  });
+});

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

@@ -0,0 +1,27 @@
+import { DEVICE } from '../src/events';
+import type { DeviceState, DeviceStateEvent } from '../src/types';
+
+describe('DeviceState contract', () => {
+  test('exports the unified device state event contract', () => {
+    expect(DEVICE.STATE).toBe('state');
+
+    const state = {} as DeviceState;
+    const event: DeviceStateEvent = {
+      connectId: 'usb-1',
+      state,
+      revision: 1,
+      source: 'initialize',
+      changedKeys: ['identity.label'],
+    };
+
+    expect(event.state).toBe(state);
+  });
+});
+
+// raw 仅供 SDK 内部兼容投影使用，不属于公共 DeviceState。
+// @ts-expect-error raw 不应成为外部接入者需要理解的字段
+type RemovedPublicRaw = DeviceState['raw'];
+
+// session 属于 SDK 运行时内部缓存，不应通过公共状态或事件暴露。
+// @ts-expect-error session 不属于公共 DeviceState
+type RemovedPublicSession = DeviceState['session'];

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

@@ -0,0 +1,163 @@
+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' },
+        session: { sessionId: 'private-session', passphraseState: 'private-state' },
+        raw: {
+          protocolV2DeviceInfo: { protocol_version: 2 },
+        },
+      },
+      'apply-settings'
+    );
+
+    expect(state?.identity.displayName).toBe('Renamed');
+    expect(onState).toHaveBeenCalledWith(
+      device,
+      expect.objectContaining({
+        state: expect.objectContaining({ revision: 1 }),
+        revision: 1,
+        source: 'apply-settings',
+      })
+    );
+    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' },
+      },
+      'apply-settings'
+    );
+
+    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');
+  });
+});