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

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

@@ -0,0 +1,117 @@
+import { initConnector, initCore } from '../src/core';
+import { DataManager } from '../src/data-manager';
+import TransportManager from '../src/data-manager/TransportManager';
+import { Device } from '../src/device/Device';
+import { DevicePool } from '../src/device/DevicePool';
+import { CORE_EVENT, DEVICE, IFRAME } from '../src/events';
+
+import type Core from '../src/core';
+import type { CoreMessage } from '../src/events';
+import type { KnownDevice } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+const createInitializedDevice = (protocol: 'V1' | 'V2') => {
+  const device = Device.fromDescriptor({
+    id: 'ble-discovery-id',
+    path: 'ble-discovery-id',
+    commType: 'ble',
+    protocolType: protocol,
+  } as never);
+  device.mainId = 'ble-connect-id';
+  device.features = {
+    protocol,
+    deviceType: protocol === 'V2' ? 'pro2' : 'classic',
+    firmwareType: 'universal',
+    deviceId: 'wallet-device-id',
+    serialNo: 'SERIAL-001',
+    label: 'OneKey Test',
+    bleName: 'OneKey Test BLE',
+    capabilities: [],
+    mode: 'normal',
+    initialized: true,
+    bootloaderMode: false,
+    firmwareVersion: '1.2.3',
+    bootloaderVersion: '1.0.0',
+    boardVersion: '1.0.0',
+    bleVersion: '2.3.4',
+  } as never;
+  return device;
+};
+
+describe('public device lifecycle events', () => {
+  let core: Core | undefined;
+
+  beforeEach(() => {
+    DevicePool.resetState();
+    jest.spyOn(TransportManager, 'load').mockImplementation();
+    TransportManager.transport = {
+      stop: jest.fn().mockResolvedValue(undefined),
+    } as never;
+  });
+
+  afterEach(async () => {
+    await core?.dispose();
+    core = undefined;
+    jest.restoreAllMocks();
+  });
+
+  test.each([
+    ['react-native', 'V1'],
+    ['react-native', 'V2'],
+    ['lowlevel', 'V1'],
+    ['lowlevel', 'V2'],
+  ] as const)(
+    'emits KnownDevice snapshots for %s Protocol %s connect and disconnect events',
+    async (env, protocol) => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+      core = initCore();
+      initConnector();
+
+      await core.handleMessage({
+        id: 'register-device-connect-listener',
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: { method: 'clearSessionCache' },
+      } as CoreMessage);
+
+      const messages: CoreMessage[] = [];
+      core.on(CORE_EVENT, message => messages.push(message));
+      const internalDevice = createInitializedDevice(protocol);
+
+      DevicePool.emitter.emit(DEVICE.CONNECT, internalDevice);
+      internalDevice.updateState({ identity: { label: 'Updated label' } }, 'settings-write');
+      DevicePool.emitter.emit(DEVICE.DISCONNECT, internalDevice);
+
+      const connectMessage = messages.find(message => message.type === DEVICE.CONNECT);
+      const disconnectMessage = messages.find(message => message.type === DEVICE.DISCONNECT);
+      const connectedDevice = connectMessage?.payload.device as KnownDevice;
+      const disconnectedDevice = disconnectMessage?.payload.device as KnownDevice;
+
+      expect(connectedDevice).toMatchObject({
+        connectId: 'ble-connect-id',
+        serialNo: 'SERIAL-001',
+        uuid: 'SERIAL-001',
+        label: 'OneKey Test',
+        state: { protocol },
+      });
+      expect(disconnectedDevice).toMatchObject({
+        connectId: 'ble-connect-id',
+        serialNo: 'SERIAL-001',
+        uuid: 'SERIAL-001',
+        label: 'Updated label',
+        state: { protocol },
+      });
+      expect(connectedDevice).not.toBe(internalDevice);
+      expect(connectedDevice).not.toBe(disconnectedDevice);
+      expect(connectedDevice).not.toHaveProperty('run');
+      expect(connectedDevice).not.toHaveProperty('acquire');
+      expect(connectedDevice).not.toHaveProperty('commands');
+      expect(() => JSON.stringify(connectedDevice)).not.toThrow();
+      expect(connectedDevice.label).toBe('OneKey Test');
+    }
+  );
+});

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

@@ -0,0 +1,132 @@
+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).toHaveBeenNthCalledWith(1, { refreshSections: ['status'] });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['settings'] });
+  });
+
+  test('keeps a discovered device when its Protocol V2 label cannot be read', async () => {
+    const labelError = new Error('settings unavailable');
+    const getDeviceState = jest
+      .fn()
+      .mockResolvedValueOnce({ status: { mode: 'normal' } })
+      .mockRejectedValueOnce(labelError);
+    const device = {
+      isProtocolV2: () => true,
+      getDeviceState,
+      run: jest.fn(async (callback: () => Promise<void>) => callback()),
+    } as any;
+
+    await expect(
+      (DevicePool as any)._refreshRuntimeState(device, { refreshRuntimeState: true })
+    ).resolves.toBeUndefined();
+    expect(getDeviceState).toHaveBeenCalledTimes(2);
+  });
+
+  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,391 @@
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSettingsPage } from '@onekeyfe/hd-transport';
+
+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();
+  const getDeviceState = jest.fn();
+  return {
+    device: {
+      features,
+      isProtocolV2: () => protocol === 'V2',
+      getCurrentDeviceType: () => (protocol === 'V2' ? EDeviceType.Pro2 : EDeviceType.Pro),
+      commands: { typedCall },
+      updateState,
+      getDeviceState,
+    },
+    typedCall,
+    updateState,
+    getDeviceState,
+  };
+}
+
+describe('DeviceSettings protocol routing', () => {
+  it.each([
+    ['label', { label: 'Shared Label' }],
+    ['language', { language: 'ja-JP' }],
+    ['brightness', { brightness: 80 }],
+    ['haptic feedback', { hapticFeedback: true }],
+  ])('does not unlock Protocol V2 before changing %s', (_name, settings) => {
+    const method = new DeviceSettings({
+      id: 1,
+      payload: {
+        method: 'deviceSettings',
+        ...settings,
+      },
+    });
+
+    method.init();
+
+    expect(method.unlockPolicy).toBe('none');
+  });
+
+  it.each([
+    ['auto lock', { autoLockDelayMs: 60_000 }],
+    ['auto shutdown', { autoShutdownDelayMs: 120_000 }],
+    ['mixed settings', { brightness: 80, autoLockDelayMs: 60_000 }],
+  ])('unlocks Protocol V2 before changing %s', (_name, settings) => {
+    const method = new DeviceSettings({
+      id: 1,
+      payload: {
+        method: 'deviceSettings',
+        ...settings,
+      },
+    });
+
+    method.init();
+
+    expect(method.unlockPolicy).toBe('retry-on-locked');
+  });
+
+  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',
+        bluetoothEnabled: true,
+      },
+    });
+    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',
+      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,
+      use_ble: true,
+      haptic_feedback: undefined,
+    });
+    expect(updateState).toHaveBeenCalledWith(
+      {
+        identity: { label: 'Shared Label' },
+        settings: { language: 'ja', bleEnabled: true },
+      },
+      'settings-write'
+    );
+  });
+
+  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',
+        autoLockDelayMs: 60_000,
+        hapticFeedback: true,
+        bluetoothEnabled: 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-Jpan-JP',
+        bt_enable: true,
+        autolock_delay_ms: 60_000,
+        haptic_feedback: true,
+      },
+    });
+    expect(updateState).toHaveBeenCalledWith(
+      {
+        identity: { label: 'Shared Label' },
+        settings: {
+          language: 'ja',
+          bleEnabled: true,
+          autoLockDelayMs: 60_000,
+          hapticFeedback: true,
+        },
+      },
+      'settings-write'
+    );
+    expect(typedCall.mock.calls.map(call => call[0])).not.toEqual(
+      expect.arrayContaining(['DeviceInfoGet', 'DeviceStatusGet', 'DeviceSettingsGet'])
+    );
+  });
+
+  it('uses the Pro2 passphrase page as a device-side toggle and verifies the target state', async () => {
+    const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState
+      .mockResolvedValueOnce({
+        status: { passphraseProtection: false },
+      })
+      .mockResolvedValueOnce({
+        status: { passphraseProtection: true },
+      });
+    const method = new DeviceSettings({
+      id: 3,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
+      page: DeviceSettingsPage.DevicePassphrase,
+    });
+    expect(typedCall).not.toHaveBeenCalledWith('DeviceSettingsSet', 'Success', expect.anything());
+    expect(getDeviceState).toHaveBeenNthCalledWith(1, { refreshSections: ['status'] });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['status'] });
+  });
+
+  it('does not open a Pro2 settings page when the hardware already matches the target', async () => {
+    const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState.mockResolvedValue({
+      settings: { airgapMode: false },
+    });
+    const method = new DeviceSettings({
+      id: 4,
+      payload: {
+        method: 'deviceSettings',
+        airgapMode: false,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({
+      message: 'Settings already match requested value.',
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+    expect(getDeviceState).toHaveBeenCalledWith({ refreshSections: ['settings'] });
+  });
+
+  it('rejects a successful Pro2 page response when the hardware did not reach the target', async () => {
+    const { device, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState.mockResolvedValue({
+      status: { passphraseProtection: false },
+    });
+    const method = new DeviceSettings({
+      id: 5,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      message: 'Protocol V2 passphrase setting did not reach the requested value.',
+    });
+  });
+
+  it('keeps Protocol V1 passphrase settings on ApplySettings', async () => {
+    const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 6,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await method.run();
+
+    expect(typedCall).toHaveBeenCalledWith(
+      'ApplySettings',
+      'Success',
+      expect.objectContaining({ use_passphrase: true })
+    );
+    expect(getDeviceState).not.toHaveBeenCalled();
+  });
+
+  it('rejects combining a Pro2 device-side toggle with direct settings', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 7,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: true,
+        label: 'New Label',
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    expect(method.unlockPolicy).toBe('none');
+    expect(method.protocolV2UiInteraction).toBeUndefined();
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('rejects two Pro2 device-side toggles without starting an interaction', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 8,
+      payload: {
+        method: 'deviceSettings',
+        usePassphrase: true,
+        airgapMode: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    expect(method.unlockPolicy).toBe('none');
+    expect(method.protocolV2UiInteraction).toBeUndefined();
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('rejects Protocol V1-only settings on Protocol V2 without partially applying the request', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 9,
+      payload: {
+        method: 'deviceSettings',
+        label: 'Must not be partially applied',
+        safetyChecks: 0,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      message: 'Protocol V2 does not support settings: safetyChecks.',
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('rejects Protocol V2-only settings on Protocol V1 without partially applying the request', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 10,
+      payload: {
+        method: 'deviceSettings',
+        label: 'Must not be partially applied',
+        brightness: 80,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+      message: 'Protocol V1 does not support settings: brightness.',
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('accepts the Protocol V2 never timeout wire value', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 11,
+      payload: {
+        method: 'deviceSettings',
+        autoLockDelayMs: 0x10000000,
+        autoShutdownDelayMs: 0x10000000,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await method.run();
+
+    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsSet', 'Success', {
+      settings: {
+        autolock_delay_ms: 0x10000000,
+        autoshutdown_delay_ms: 0x10000000,
+      },
+    });
+  });
+
+  it('rejects unsupported Protocol V2 timeout values before sending a command', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V2' });
+    const method = new DeviceSettings({
+      id: 12,
+      payload: {
+        method: 'deviceSettings',
+        autoLockDelayMs: 0,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
+  it('rejects unknown Protocol V1 safety check levels before sending a command', async () => {
+    const { device, typedCall } = createDevice({ protocol: 'V1' });
+    const method = new DeviceSettings({
+      id: 13,
+      payload: {
+        method: 'deviceSettings',
+        safetyChecks: 3,
+      },
+    } as never);
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+    });
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+});

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'];