@onekeyfe/hardware-cli 1.2.0-alpha.4 → 1.2.0-alpha.41

package/src/__tests__/device-state-commands.test.ts

@@ -0,0 +1,118 @@
+import { getCanonicalDeviceState, getCompatibleFeatures } from '../deviceStateCommands';
+
+const createSdkMock = () => ({
+  searchDevices: jest.fn(),
+  getDeviceState: jest.fn(),
+  getFeatures: jest.fn(),
+});
+
+describe('设备状态 CLI 兼容层', () => {
+  test('Protocol V2 直接返回 SDK 搜索结果中的兼容 features', async () => {
+    const sdk = createSdkMock();
+    const features = {
+      protocol: 'V2',
+      deviceType: 'pro2',
+      deviceId: 'device-id',
+    };
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [
+        {
+          connectId: 'pro2-connect-id',
+          state: { protocol: 'V2' },
+          features,
+        },
+      ],
+    });
+
+    await expect(getCompatibleFeatures(sdk as never, 'pro2-connect-id')).resolves.toEqual({
+      success: true,
+      payload: features,
+    });
+    expect(sdk.getFeatures).not.toHaveBeenCalled();
+  });
+
+  test('Protocol V1 继续调用公共 getFeatures 保持旧行为', async () => {
+    const sdk = createSdkMock();
+    const response = {
+      success: true,
+      payload: { protocol: 'V1', label: 'Classic' },
+    };
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [
+        {
+          connectId: 'classic-connect-id',
+          state: { protocol: 'V1' },
+        },
+      ],
+    });
+    sdk.getFeatures.mockResolvedValue(response);
+
+    await expect(getCompatibleFeatures(sdk as never, 'classic-connect-id')).resolves.toBe(response);
+    expect(sdk.getFeatures).toHaveBeenCalledWith('classic-connect-id');
+  });
+
+  test('未显式指定设备时选择搜索结果中的第一台设备', async () => {
+    const sdk = createSdkMock();
+    const response = { success: true, payload: { protocol: 'V1' } };
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [{ connectId: 'first-device', state: { protocol: 'V1' } }],
+    });
+    sdk.getFeatures.mockResolvedValue(response);
+
+    await expect(getCompatibleFeatures(sdk as never)).resolves.toBe(response);
+    expect(sdk.getFeatures).toHaveBeenCalledWith('first-device');
+  });
+
+  test('显式 connectId 不在搜索结果时返回结构化错误', async () => {
+    const sdk = createSdkMock();
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [{ connectId: 'another-device', state: { protocol: 'V1' } }],
+    });
+
+    await expect(getCompatibleFeatures(sdk as never, 'missing-device')).resolves.toEqual({
+      success: false,
+      payload: {
+        code: 'DEVICE_NOT_FOUND',
+        error: 'Device not found: missing-device',
+      },
+    });
+    expect(sdk.getFeatures).not.toHaveBeenCalled();
+  });
+
+  test('get-state 将 firmware scope 传给 SDK', async () => {
+    const sdk = createSdkMock();
+    const response = { success: true, payload: { protocol: 'V2' } };
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [{ connectId: 'pro2-connect-id', state: { protocol: 'V2' } }],
+    });
+    sdk.getDeviceState.mockResolvedValue(response);
+
+    await expect(
+      getCanonicalDeviceState(sdk as never, 'pro2-connect-id', 'firmware')
+    ).resolves.toBe(response);
+    expect(sdk.getDeviceState).toHaveBeenCalledWith('pro2-connect-id', {
+      scope: 'firmware',
+    });
+    expect(sdk.searchDevices).toHaveBeenCalledTimes(1);
+  });
+
+  test('get-state 未指定 connectId 时搜索并选择第一台设备', async () => {
+    const sdk = createSdkMock();
+    const state = { protocol: 'V2', revision: 2 };
+    sdk.searchDevices.mockResolvedValue({
+      success: true,
+      payload: [{ connectId: 'pro2-connect-id', state }],
+    });
+
+    await expect(getCanonicalDeviceState(sdk as never, undefined, 'runtime')).resolves.toEqual({
+      success: true,
+      payload: state,
+    });
+    expect(sdk.getDeviceState).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,18 @@
+import { getLegacyFirmwareConnectTimeout, program } from '../cli';
+
+describe('firmware-update-legacy CLI command', () => {
+  test('提供 Classic/Pure 的本地固件升级命令', () => {
+    const command = program.commands.find(item => item.name() === 'firmware-update-legacy');
+
+    expect(command).toBeDefined();
+    expect(command?.description()).toBe('Update Classic/Pure firmware through the legacy protocol');
+    expect(command?.options.find(option => option.long === '--binary')?.mandatory).toBe(true);
+    expect(command?.options.some(option => option.long === '--device-name')).toBe(true);
+    expect(command?.options.some(option => option.long === '--update-type')).toBe(true);
+  });
+
+  test('USB Classic 固件升级使用足够的设备探测超时', () => {
+    expect(getLegacyFirmwareConnectTimeout('usb')).toBe(90_000);
+    expect(getLegacyFirmwareConnectTimeout('ble')).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,100 @@
+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');
+
+    expect(command).toBeDefined();
+    expect(command?.description()).toBe(
+      'Run Protocol V2 firmware update through sdk.firmwareUpdateV4'
+    );
+  });
+
+  test('does not expose the pre-release firmware-update-v4-debug command', () => {
+    expect(program.commands.some(item => item.name() === 'firmware-update-v4-debug')).toBe(false);
+    expect(program.commands.some(item => item.aliases().includes('firmware-update-v4-debug'))).toBe(
+      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

@@ -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,55 @@
+import { prepareSession } from '../cli';
+import { preloadSessionFromKeychain } from '../session';
+
+jest.mock('../session', () => ({
+  clearSessionFromKeychain: jest.fn(),
+  preloadSessionFromKeychain: jest.fn(),
+}));
+
+describe('CLI wallet session', () => {
+  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',
+    });
+  });
+});