@onekeyfe/hd-core 1.2.0-alpha.9 → 1.2.0-alpha.91

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

@@ -0,0 +1,351 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+
+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('registers the shared device lifecycle listeners exactly once', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    core = initCore();
+    initConnector();
+
+    for (const id of ['first-call', 'second-call']) {
+      await core.handleMessage({
+        id,
+        event: IFRAME.CALL,
+        type: IFRAME.CALL,
+        payload: { method: 'clearSessionCache' },
+      } as CoreMessage);
+    }
+
+    expect(DevicePool.emitter.listenerCount(DEVICE.CONNECT)).toBe(1);
+    expect(DevicePool.emitter.listenerCount(DEVICE.DISCONNECT)).toBe(1);
+  });
+
+  test('keeps shared device lifecycle listeners across a device cache reset', () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    core = initCore();
+    initConnector();
+    const messages: CoreMessage[] = [];
+    core.on(CORE_EVENT, message => messages.push(message));
+    const device = createInitializedDevice('V2');
+
+    DevicePool.resetState();
+    DevicePool.emitter.emit(DEVICE.CONNECT, device);
+    DevicePool.emitter.emit(DEVICE.DISCONNECT, device);
+
+    expect(messages.filter(message => message.type === DEVICE.CONNECT)).toHaveLength(1);
+    expect(messages.filter(message => message.type === DEVICE.DISCONNECT)).toHaveLength(1);
+  });
+
+  test('uses a verified cached protocol as a strict expected protocol', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-id',
+      path: 'ble-id',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V1' });
+    device.deviceConnector = { acquire } as never;
+
+    await device.acquire();
+
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V1', undefined);
+    expect(device.getProtocol()).toBe('V1');
+    expect(device.originalDescriptor.protocolType).toBe('V1');
+  });
+
+  test('bypasses a cached protocol only for explicit active detection', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-id',
+      path: 'ble-id',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
+    device.deviceConnector = { acquire } as never;
+
+    await device.acquire(undefined, { forceProtocolDetection: true });
+
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, undefined, undefined);
+    expect(device.getProtocol()).toBe('V2');
+    expect(device.originalDescriptor.protocolType).toBe('V2');
+  });
+
+  test('does not reuse a stale protocol when active detection returns no protocol', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-id',
+      path: 'ble-id',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id' });
+    const release = jest.fn().mockResolvedValue(undefined);
+    device.deviceConnector = { acquire, release } as never;
+    await expect(
+      device.acquire(undefined, {
+        forceProtocolDetection: true,
+        throwOnRunPromiseError: true,
+      })
+    ).rejects.toMatchObject({ errorCode: HardwareErrorCode.RuntimeError });
+    expect(device.originalDescriptor.protocolType).toBe('V1');
+    expect(device.hasDeviceAcquire()).toBe(false);
+    expect(release).toHaveBeenCalledWith('ble-id', false);
+  });
+
+  test('actively reacquires an already connected device without initializing it', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('webusb' as never);
+    const device = Device.fromDescriptor({
+      id: 'usb-device',
+      path: 'usb-device',
+      session: 'old-session',
+      protocolType: 'V1',
+    } as never);
+    device.mainId = 'old-session';
+    device.commands = { disposed: false } as never;
+    const release = jest.spyOn(device, 'release').mockImplementation(() => {
+      device.mainId = null;
+      device.originalDescriptor.session = null;
+      device.commands.disposed = true;
+      return Promise.resolve();
+    });
+    const acquire = jest.spyOn(device, 'acquire').mockImplementation(() => {
+      device.mainId = 'new-session';
+      device.originalDescriptor.session = 'new-session';
+      device.originalDescriptor.protocolType = 'V2';
+      device.commands.disposed = false;
+      return Promise.resolve();
+    });
+    const initialize = jest.spyOn(device, 'initialize').mockResolvedValue(undefined);
+
+    await device.run(() => Promise.resolve(undefined), {
+      forceProtocolDetection: true,
+      skipInitialize: true,
+    });
+
+    expect(release).toHaveBeenCalled();
+    expect(acquire).toHaveBeenCalledWith(undefined, {
+      forceProtocolDetection: true,
+    });
+    expect(initialize).not.toHaveBeenCalled();
+    expect(device.getProtocol()).toBe('V2');
+  });
+
+  test('keeps the freshly probed React Native BLE session until the call completes', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-device',
+      path: 'ble-device',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    device.mainId = 'ble-device';
+    device.commands = { disposed: false } as never;
+    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+    const release = jest.spyOn(device, 'release').mockResolvedValue(undefined);
+    const run = jest.fn().mockResolvedValue(undefined);
+
+    await device.run(run, {
+      forceProtocolDetection: true,
+      skipInitialize: true,
+    });
+
+    expect(run).toHaveBeenCalledTimes(1);
+    expect(release).toHaveBeenCalledTimes(1);
+  });
+
+  test('keeps an explicit connectProtocol as a strict expected protocol', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    const device = Device.fromDescriptor({
+      id: 'ble-id',
+      path: 'ble-id',
+      commType: 'ble',
+      protocolType: 'V1',
+    } as never);
+    const acquire = jest.fn().mockResolvedValue({ uuid: 'ble-id', protocolType: 'V2' });
+    device.deviceConnector = { acquire } as never;
+
+    await device.acquire('V2');
+
+    expect(acquire).toHaveBeenCalledWith('ble-id', undefined, true, 'V2', undefined);
+    expect(device.getProtocol()).toBe('V2');
+  });
+
+  test('converts an internal transport disconnect into a public KnownDevice snapshot', () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
+    core = initCore();
+    initConnector();
+    const messages: CoreMessage[] = [];
+    core.on(CORE_EVENT, message => messages.push(message));
+    const device = createInitializedDevice('V2');
+    DevicePool.devicesCache['ble-connect-id'] = device;
+
+    DevicePool.emitter.emit(TRANSPORT_EVENT.DEVICE_DISCONNECT, {
+      id: 'ble-connect-id',
+      connectId: 'ble-connect-id',
+      name: 'OneKey Test BLE',
+    });
+
+    const disconnectMessage = messages.find(message => message.type === DEVICE.DISCONNECT);
+    expect(disconnectMessage?.payload.device).toMatchObject({
+      connectId: 'ble-connect-id',
+      serialNo: 'SERIAL-001',
+      state: { protocol: 'V2' },
+    });
+    expect(() => JSON.stringify(disconnectMessage?.payload.device)).not.toThrow();
+  });
+
+  test('treats an acquired BLE device as reusable until the transport disconnects', async () => {
+    jest.spyOn(DataManager, 'getSettings').mockReturnValue('desktop-web-ble' as never);
+    const device = createInitializedDevice('V2');
+    const acquire = jest.spyOn(device, 'acquire').mockResolvedValue(undefined);
+    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+    (device as any).commands = { disposed: false };
+
+    expect(device.isUsedHere()).toBe(true);
+    await expect(device.connect('V2')).resolves.toBe(true);
+    expect(acquire).not.toHaveBeenCalled();
+
+    device.markTransportDisconnected();
+    expect(device.isUsedHere()).toBe(false);
+  });
+
+  test('exposes the current transport usage state in public device snapshots', () => {
+    const getSettings = jest
+      .spyOn(DataManager, 'getSettings')
+      .mockReturnValue('desktop-web-ble' as never);
+    const device = createInitializedDevice('V2');
+
+    expect(device.toMessageObject()?.status).toBe('available');
+    expect(device.toMessageObject()?.connectProtocol).toBe('V2');
+
+    (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+    expect(device.toMessageObject()?.status).toBe('used');
+
+    device.markTransportDisconnected();
+    expect(device.toMessageObject()?.status).toBe('available');
+
+    getSettings.mockReturnValue('web' as never);
+    device.originalDescriptor.session = 'external-session';
+    expect(device.toMessageObject()?.status).toBe('occupied');
+  });
+
+  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',
+        status: 'available',
+        label: 'OneKey Test',
+        state: { protocol },
+      });
+      expect(disconnectedDevice).toMatchObject({
+        connectId: 'ble-connect-id',
+        serialNo: 'SERIAL-001',
+        uuid: 'SERIAL-001',
+        status: 'available',
+        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,166 @@
+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.dispose();
+  });
+
+  afterEach(() => {
+    DevicePool.dispose();
+  });
+
+  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('actively re-detects a cached device when protocol detection is forced', async () => {
+    const descriptor = { path: 'cached-path', protocolType: 'V1' } as any;
+    const device = Device.fromDescriptor(descriptor);
+    const acquire = jest.spyOn(device, 'acquire').mockImplementation(() => {
+      device.originalDescriptor.protocolType = 'V2';
+      return Promise.resolve(true);
+    });
+    const initialize = jest.spyOn(device, 'initialize').mockResolvedValue(undefined);
+    const release = jest.spyOn(device, 'release').mockResolvedValue(undefined);
+    DevicePool.devicesCache = { 'cached-id': device };
+
+    const result = await DevicePool.getDevices([descriptor], 'cached-id', {
+      forceProtocolDetection: true,
+    });
+
+    expect(acquire).toHaveBeenCalledWith(undefined, { forceProtocolDetection: true });
+    expect(initialize).toHaveBeenCalledWith({ forceProtocolDetection: true });
+    expect(release).toHaveBeenCalledTimes(1);
+    expect(device.originalDescriptor.protocolType).toBe('V2');
+    expect(result.deviceList).toEqual([device]);
+  });
+
+  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('preserves shared listeners when resetting cached device state', () => {
+    const listener = jest.fn();
+    DevicePool.emitter.on(DEVICE.CONNECT, listener);
+    DevicePool.devicesCache = { stale: {} as Device };
+
+    DevicePool.resetState();
+    DevicePool.emitter.emit(DEVICE.CONNECT, { path: 'next-device' });
+
+    expect(DevicePool.devicesCache).toEqual({});
+    expect(listener).toHaveBeenCalledWith({ path: 'next-device' });
+  });
+
+  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);
+  });
+});