@onekeyfe/hardware-cli 1.2.0-alpha.9 → 1.2.0-alpha.91

package/src/__tests__/firmware-update-v4-command.test.ts

@@ -1,6 +1,34 @@
-import { program } from '../cli';
+import { createSDK, disposeSDK } from '../sdk';
+import { program, runFirmwareUpdateV4WithRetry } from '../cli';
+
+jest.mock('../sdk', () => ({
+  createSDK: jest.fn(),
+  disposeSDK: jest.fn(),
+}));
+
+const transientProbeFailure = {
+  success: false,
+  payload: {
+    error: 'Device protocol mismatch: expected V2; device did not respond to expected protocol',
+  },
+};
+
+const createSdkMock = () => ({
+  getDeviceState: jest.fn(),
+  firmwareUpdateV4: jest.fn(),
+  on: jest.fn(),
+  off: jest.fn(),
+});
 
 describe('firmware-update-v4 CLI command', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
   test('exposes firmware-update-v4 as the formal command', () => {
     const command = program.commands.find(item => item.name() === 'firmware-update-v4');
 
@@ -8,6 +36,7 @@ describe('firmware-update-v4 CLI command', () => {
     expect(command?.description()).toBe(
       'Run Protocol V2 firmware update through sdk.firmwareUpdateV4'
     );
+    expect(command?.options.some(option => option.long === '--resource-archive')).toBe(true);
   });
 
   test('does not expose the pre-release firmware-update-v4-debug command', () => {
@@ -16,4 +45,57 @@ describe('firmware-update-v4 CLI command', () => {
       false
     );
   });
+
+  test('retries only the read-only USB probe before starting the firmware update', async () => {
+    const firstSdk = createSdkMock();
+    const retrySdk = createSdkMock();
+    firstSdk.getDeviceState.mockResolvedValue(transientProbeFailure);
+    retrySdk.getDeviceState.mockResolvedValue({ success: true, payload: { protocol: 'V2' } });
+    retrySdk.firmwareUpdateV4.mockResolvedValue({ success: true, payload: {} });
+    jest.mocked(createSDK).mockResolvedValue(retrySdk as never);
+    jest.mocked(disposeSDK).mockResolvedValue(undefined);
+    jest.spyOn(global, 'setTimeout').mockImplementation(callback => {
+      callback();
+      return 0 as never;
+    });
+
+    const result = await runFirmwareUpdateV4WithRetry({
+      sdk: firstSdk as never,
+      globalOpts: { transport: 'usb', connectId: 'stale-connect-id' },
+      params: { applicationP1Binary: new ArrayBuffer(1) } as never,
+      retries: 1,
+    });
+
+    expect(firstSdk.firmwareUpdateV4).not.toHaveBeenCalled();
+    expect(disposeSDK).toHaveBeenCalledTimes(1);
+    expect(retrySdk.getDeviceState).toHaveBeenCalledWith(undefined, {
+      scope: 'runtime',
+      connectProtocol: 'V2',
+      retryCount: 0,
+    });
+    expect(retrySdk.firmwareUpdateV4).toHaveBeenCalledTimes(1);
+    expect(result).toMatchObject({ success: true, payload: { metrics: { attempt: 2 } } });
+  });
+
+  test('does not replay firmwareUpdateV4 after the read-only probe succeeds', async () => {
+    const sdk = createSdkMock();
+    sdk.getDeviceState.mockResolvedValue({ success: true, payload: { protocol: 'V2' } });
+    sdk.firmwareUpdateV4.mockResolvedValue(transientProbeFailure);
+
+    const result = await runFirmwareUpdateV4WithRetry({
+      sdk: sdk as never,
+      globalOpts: { transport: 'usb', connectId: 'pro2-connect-id' },
+      params: { applicationP1Binary: new ArrayBuffer(1) } as never,
+      retries: 2,
+    });
+
+    expect(sdk.getDeviceState).toHaveBeenCalledTimes(1);
+    expect(sdk.firmwareUpdateV4).toHaveBeenCalledTimes(1);
+    expect(disposeSDK).not.toHaveBeenCalled();
+    expect(createSDK).not.toHaveBeenCalled();
+    expect(result).toMatchObject({
+      success: false,
+      payload: { error: transientProbeFailure.payload.error, metrics: { attempt: 1 } },
+    });
+  });
 });

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

@@ -33,22 +33,88 @@ const createPeripheral = (id: string) => {
       state: 'connected',
       advertisement: {
         localName: `OneKey Pro 2 ${id}`,
-        serviceUuids: ['fffd'],
+        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');
@@ -110,4 +176,195 @@ describe('Noble BLE plugin notification routing', () => {
 
     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,
+    });
+  });
+});