@onekeyfe/hardware-cli 1.2.0-alpha.1 → 1.2.0-alpha.100

package/src/__tests__/noble-ble-plugin.test.ts

@@ -0,0 +1,370 @@
+import { EventEmitter } from 'events';
+
+type MockCharacteristic = EventEmitter & {
+  uuid: string;
+  unsubscribe: jest.Mock;
+  subscribe: jest.Mock;
+  write: jest.Mock;
+  removeAllListeners: jest.Mock;
+};
+
+const createCharacteristic = (uuid: string): MockCharacteristic => {
+  const characteristic = new EventEmitter() as MockCharacteristic;
+  characteristic.uuid = uuid;
+  characteristic.unsubscribe = jest.fn(callback => callback());
+  characteristic.subscribe = jest.fn(callback => callback());
+  characteristic.write = jest.fn((_buffer, _withoutResponse, callback) => callback());
+  characteristic.removeAllListeners = jest.fn(
+    characteristic.removeAllListeners.bind(characteristic)
+  );
+  return characteristic;
+};
+
+const createPeripheral = (id: string) => {
+  const write = createCharacteristic('0002');
+  const notify = createCharacteristic('0003');
+  const service = {
+    uuid: '0001',
+    discoverCharacteristics: jest.fn((_uuids, callback) => callback(null, [write, notify])),
+  };
+  return {
+    peripheral: {
+      id,
+      state: 'connected',
+      advertisement: {
+        localName: `OneKey Pro 2 ${id}`,
+        serviceUuids: ['0001'],
+      },
+      discoverServices: jest.fn((_uuids, callback) => callback(null, [service])),
+      connect: jest.fn(callback => callback()),
+      disconnect: jest.fn(callback => callback()),
+    },
+    service,
+    write,
+    notify,
+  };
+};
+
+describe('Noble BLE plugin notification routing', () => {
+  afterEach(() => {
+    jest.useRealTimers();
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  test('does not enumerate Find My advertisements that expose FFFD', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    const oneKey = createPeripheral('onekey-device');
+    const findMy = createPeripheral('find-my-device');
+    findMy.peripheral.advertisement.localName = 'Find My';
+    findMy.peripheral.advertisement.serviceUuids = ['fffd'];
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', findMy.peripheral);
+      noble.emit('discover', oneKey.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    const devicesPromise = plugin.enumerate();
+    await Promise.resolve();
+    jest.runAllTimers();
+    await Promise.resolve();
+
+    await expect(devicesPromise).resolves.toEqual([
+      expect.objectContaining({ id: 'onekey-device' }),
+    ]);
+    jest.useRealTimers();
+  });
+
+  test('does not enumerate a name-only candidate without the communication service', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    const nameOnly = createPeripheral('name-only-device');
+    nameOnly.peripheral.advertisement.serviceUuids = [];
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', nameOnly.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    const devicesPromise = plugin.enumerate();
+    await Promise.resolve();
+    jest.runAllTimers();
+    await Promise.resolve();
+
+    await expect(devicesPromise).resolves.toEqual([]);
+    jest.useRealTimers();
+  });
+
+  test('routes notifications to the receiver waiting for the same device', async () => {
+    const deviceA = createPeripheral('device-a');
+    const deviceB = createPeripheral('device-b');
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', deviceA.peripheral);
+      noble.emit('discover', deviceB.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    await plugin.connect('device-a');
+    await plugin.connect('device-b');
+
+    const receiveA = plugin.receive('device-a');
+    const receiveB = plugin.receive('device-b');
+    deviceB.notify.emit('data', Buffer.from('bb', 'hex'));
+    deviceA.notify.emit('data', Buffer.from('aa', 'hex'));
+
+    await expect(Promise.all([receiveA, receiveB])).resolves.toEqual(['aa', 'bb']);
+  });
+
+  test('finishes disconnect cleanup when Noble never calls unsubscribe back', async () => {
+    const device = createPeripheral('device-a');
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    await plugin.connect('device-a');
+    device.notify.unsubscribe.mockImplementation(() => undefined);
+
+    const result = await Promise.race([
+      plugin.disconnect('device-a').then(() => 'completed'),
+      new Promise(resolve => {
+        setTimeout(() => resolve('blocked'), 300);
+      }),
+    ]);
+
+    expect(result).toBe('completed');
+  });
+
+  test('disconnects an untracked peripheral when service discovery fails', async () => {
+    const device = createPeripheral('device-a');
+    device.peripheral.discoverServices.mockImplementation((_uuids, callback) =>
+      callback(new Error('service discovery failed'))
+    );
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+
+    await expect(plugin.connect('device-a')).rejects.toThrow('service discovery failed');
+    expect(device.peripheral.disconnect).toHaveBeenCalledTimes(1);
+  });
+
+  test('rejects a vendor-specific service containing the OneKey short UUID', async () => {
+    const device = createPeripheral('device-a');
+    device.service.uuid = 'abcd0001-1234-5678-9012-abcdefabcdef';
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+
+    await expect(plugin.connect('device-a')).rejects.toThrow('No BLE service found');
+  });
+
+  test('unsubscribes and disconnects an untracked peripheral when notification setup fails', async () => {
+    const device = createPeripheral('device-a');
+    device.notify.subscribe.mockImplementation(callback =>
+      callback(new Error('notification setup failed'))
+    );
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+
+    await expect(plugin.connect('device-a')).rejects.toThrow('notification setup failed');
+    expect(device.notify.unsubscribe).toHaveBeenCalled();
+    expect(device.peripheral.disconnect).toHaveBeenCalledTimes(1);
+  });
+
+  test('uses withoutResponse for normal and high-volume writes', async () => {
+    const device = createPeripheral('device-a');
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    await plugin.connect('device-a');
+
+    await plugin.send('device-a', 'aa');
+    await plugin.send('device-a', 'bb');
+
+    expect(device.write.write.mock.calls.map(([, withoutResponse]) => withoutResponse)).toEqual([
+      true,
+      true,
+    ]);
+  });
+
+  test('uses acknowledged writes when requested by firmware upload', async () => {
+    const device = createPeripheral('device-a');
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    await plugin.connect('device-a');
+
+    await (plugin.send as any)('device-a', 'aa', { withoutResponse: false });
+
+    expect(device.write.write).toHaveBeenCalledWith(
+      expect.any(Buffer),
+      false,
+      expect.any(Function)
+    );
+  });
+
+  test('does not add a fixed delay between 192-byte writes', async () => {
+    const device = createPeripheral('device-a');
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    const wait = jest.fn(() => Promise.resolve());
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+    jest.doMock('@onekeyfe/hd-shared', () => ({
+      ...jest.requireActual('@onekeyfe/hd-shared'),
+      wait,
+    }));
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    await plugin.connect('device-a');
+
+    await plugin.send('device-a', 'aa'.repeat(193));
+
+    expect(device.write.write).toHaveBeenCalledTimes(2);
+    expect(wait).not.toHaveBeenCalled();
+  });
+
+  test('preserves a short final BLE packet without padding', async () => {
+    const device = createPeripheral('device-a');
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    await plugin.connect('device-a');
+
+    await plugin.send('device-a', 'aabb');
+
+    const packet = device.write.write.mock.calls[0][0] as Buffer;
+    expect(packet).toEqual(Buffer.from('aabb', 'hex'));
+  });
+});

package/src/__tests__/wallet-session.test.ts

@@ -0,0 +1,64 @@
+import { prepareSession } from '../cli';
+import { resolvePassphraseByChoice } from '../sdk';
+import { preloadSessionFromKeychain } from '../session';
+
+jest.mock('../session', () => ({
+  clearSessionFromKeychain: jest.fn(),
+  preloadSessionFromKeychain: jest.fn(),
+}));
+
+describe('CLI wallet session', () => {
+  test('maps the Attach PIN choice to an on-device Attach PIN response', async () => {
+    await expect(resolvePassphraseByChoice('4')).resolves.toEqual({
+      value: '',
+      passphraseOnDevice: false,
+      attachPinOnDevice: true,
+    });
+  });
+
+  test('uses the public wallet identity without persisting an internal session id', async () => {
+    const sdk = {
+      searchDevices: jest.fn().mockResolvedValue({
+        success: true,
+        payload: [
+          {
+            connectId: 'pro2-connect-id',
+            deviceId: 'device-id',
+            deviceType: 'pro2',
+            features: {
+              deviceId: 'device-id',
+              deviceType: 'pro2',
+              unlocked: true,
+              passphraseProtection: true,
+            },
+          },
+        ],
+      }),
+      getFeatures: jest.fn(),
+      openWalletSession: jest.fn().mockResolvedValue({
+        success: true,
+        payload: {
+          protocol: 'V2',
+          walletType: 'hidden',
+          deviceId: 'device-id',
+          passphraseState: 'wallet-state',
+          resumed: false,
+        },
+      }),
+    };
+    const globalOpts: Record<string, unknown> = {};
+    (preloadSessionFromKeychain as jest.Mock).mockResolvedValueOnce(undefined);
+
+    await expect(prepareSession(sdk as never, globalOpts)).resolves.toBe('wallet-state');
+
+    expect(sdk.openWalletSession).toHaveBeenCalledWith('pro2-connect-id', {
+      mode: 'select-hidden',
+    });
+    expect(sdk.getFeatures).not.toHaveBeenCalled();
+    expect(globalOpts).toMatchObject({
+      connectId: 'pro2-connect-id',
+      deviceId: 'device-id',
+      passphraseState: 'wallet-state',
+    });
+  });
+});

package/src/__tests__/wallpaper-upload-command.test.ts

@@ -0,0 +1,46 @@
+import { buildWallpaperUploadMetrics, program } from '../cli';
+
+describe('upload-wallpaper CLI command', () => {
+  test('exposes a command backed by the SDK wallpaper API', () => {
+    const command = program.commands.find(item => item.name() === 'upload-wallpaper');
+
+    expect(command).toBeDefined();
+    expect(command?.description()).toBe('Upload and activate a Pro2 wallpaper');
+  });
+
+  test('reports effective transfer speed from encoded bytes and elapsed time', () => {
+    expect(
+      buildWallpaperUploadMetrics({
+        totalBytes: 2_473_984,
+        transferredBytes: 2_473_984,
+        startedAt: 1_000,
+        endedAt: 2_000,
+        lastProgress: 100,
+      })
+    ).toEqual({
+      totalBytes: 2_473_984,
+      transferredBytes: 2_473_984,
+      totalSeconds: 1,
+      transferKiBPerSecond: 2416,
+      lastProgress: 100,
+    });
+  });
+
+  test('uses confirmed bytes for an interrupted transfer rate', () => {
+    expect(
+      buildWallpaperUploadMetrics({
+        totalBytes: 1_855_500,
+        transferredBytes: 631_800,
+        startedAt: 1_000,
+        endedAt: 101_000,
+        lastProgress: 34,
+      })
+    ).toEqual({
+      totalBytes: 1_855_500,
+      transferredBytes: 631_800,
+      totalSeconds: 100,
+      transferKiBPerSecond: 6.17,
+      lastProgress: 34,
+    });
+  });
+});