@onekeyfe/hd-transport-react-native 1.2.3-alpha.3 → 1.2.3-alpha.5

package/src/__tests__/connectTimeout.test.ts

@@ -1,8 +1,13 @@
 import { EventEmitter } from 'events';
-import { BleErrorCode } from 'react-native-ble-plx';
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { Platform } from 'react-native';
+import { BleErrorCode, BleManager } from 'react-native-ble-plx';
+import BleUtils from '@onekeyfe/react-native-ble-utils';
+import { ERRORS, HardwareErrorCode, createDeferred } from '@onekeyfe/hd-shared';
 
+import { onDeviceBondState } from '../BleManager';
 import ReactNativeBleTransport, {
+  ANDROID_LINK_DROP_QUIET_MS,
+  ANDROID_MTU_EXCHANGE_TIMEOUT_MS,
   BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD,
   BLE_CONNECT_TIMEOUT_MS,
   BLE_GATT_SETUP_TIMEOUT_MS,
@@ -10,6 +15,8 @@ import ReactNativeBleTransport, {
 } from '../index';
 import protocolV1Schema from './protocolV1SchemaFixture';
 
+import type { Peripheral } from '@onekeyfe/react-native-ble-utils';
+
 jest.mock(
   'react-native',
   () => ({
@@ -44,12 +51,131 @@ jest.mock('@onekeyfe/react-native-ble-utils', () => ({
   default: {
     getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
     getBondedPeripherals: jest.fn(() => Promise.resolve([])),
-    pairDevice: jest.fn(() => Promise.resolve()),
+    pairDevice: jest.fn(() => Promise.resolve({ bonded: true, bonding: false })),
+    onDeviceBondState: jest.fn(),
   },
 }));
 
 const UUID = 'stalled-connect-device';
 
+describe('Android bond failure reasons', () => {
+  let emitBondState: (peripheral: Peripheral) => void;
+  const cleanup = jest.fn();
+
+  beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+    cleanup.mockClear();
+    jest.spyOn(BleUtils, 'onDeviceBondState').mockImplementation(listener => {
+      emitBondState = listener;
+      return cleanup;
+    });
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    jest.useRealTimers();
+  });
+
+  test.each([
+    [6, 'timeout', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out'],
+    [3, 'canceled', HardwareErrorCode.BleDeviceBondedCanceled, 'Bluetooth pairing canceled'],
+    [1, 'authentication_failed', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [2, 'rejected', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [4, 'device_unreachable', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [5, 'discovery_in_progress', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [7, 'repeated_attempts', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [8, 'remote_canceled', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [9, 'removed', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [undefined, 'unknown', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+    [999, 'unknown', HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed'],
+  ] as const)(
+    'preserves Android reason %s as %s across serialization',
+    async (nativeReason, reason, code, message) => {
+      const result = onDeviceBondState(UUID).catch(error =>
+        JSON.parse(JSON.stringify(ERRORS.serializeError({ error })))
+      );
+      emitBondState({
+        id: UUID,
+        advertising: {},
+        bondState: {
+          preState: 'BOND_BONDING',
+          state: 'BOND_NONE',
+          ...(nativeReason === undefined ? {} : { reason: nativeReason }),
+        },
+      });
+
+      await expect(result).resolves.toEqual({
+        code,
+        error: message,
+        params: {
+          phase: 'bond',
+          reason,
+          ...(nativeReason === undefined ? {} : { nativeReason }),
+        },
+      });
+      expect(cleanup).toHaveBeenCalledTimes(1);
+      expect(jest.getTimerCount()).toBe(0);
+    }
+  );
+
+  test('reports a timeout if no bond event arrives within the SDK deadline', async () => {
+    const result = onDeviceBondState(UUID);
+    const rejection = expect(result).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceNotBonded,
+      params: { phase: 'bond', reason: 'timeout' },
+    });
+    jest.advanceTimersByTime(60_000);
+    await rejection;
+    expect(cleanup).toHaveBeenCalledTimes(1);
+  });
+
+  test('aborts the bond wait and removes its listener and deadline', async () => {
+    const controller = new AbortController();
+    const result = onDeviceBondState(UUID, controller.signal);
+    const rejection = expect(result).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+
+    controller.abort();
+
+    await rejection;
+    expect(cleanup).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test('does not subscribe when the transport stopped before the bond wait starts', async () => {
+    const controller = new AbortController();
+    controller.abort();
+    const subscribe = jest.spyOn(BleUtils, 'onDeviceBondState').mockClear();
+
+    await expect(onDeviceBondState(UUID, controller.signal)).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+    expect(subscribe).not.toHaveBeenCalled();
+    expect(jest.getTimerCount()).toBe(0);
+  });
+
+  test('ignores other devices and clears the deadline after bonding succeeds', async () => {
+    const result = onDeviceBondState(UUID);
+    const otherPeripheral = {
+      id: 'another-device',
+      advertising: {},
+      bondState: { preState: 'BOND_BONDING', state: 'BOND_NONE', reason: 6 },
+    };
+    emitBondState(otherPeripheral);
+    expect(cleanup).not.toHaveBeenCalled();
+    const peripheral: Peripheral = {
+      id: UUID.toUpperCase(),
+      advertising: {},
+      bondState: { preState: 'BOND_BONDING', state: 'BOND_BONDED' },
+    };
+    emitBondState(peripheral);
+    await expect(result).resolves.toBe(peripheral);
+    expect(cleanup).toHaveBeenCalledTimes(1);
+    expect(jest.getTimerCount()).toBe(0);
+  });
+});
+
 const flush = () =>
   new Promise(resolve => {
     setImmediate(resolve);
@@ -129,6 +255,60 @@ describe('BLE connect timeout', () => {
   afterEach(() => {
     jest.clearAllTimers();
     jest.restoreAllMocks();
+    Object.assign(Platform, { OS: 'ios' });
+  });
+
+  test('waits for singleton destruction before creating the next manager', async () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    const destruction = createDeferred<void>();
+    Object.assign(bleManager, { destroy: jest.fn(() => destruction.promise) });
+    const createManager = jest.mocked(BleManager);
+    createManager.mockClear();
+    (transport as unknown as { resetPlxManager(): void }).resetPlxManager();
+    const first = transport.getPlxManager();
+    const second = transport.getPlxManager();
+    await flush();
+    expect(createManager).not.toHaveBeenCalled();
+    destruction.resolve();
+    expect(await first).toBe(await second);
+    expect(createManager).toHaveBeenCalledTimes(1);
+  });
+
+  test('does not reuse a manager after asynchronous destruction fails', async () => {
+    const { bleManager } = createHarness(() => Promise.resolve());
+    let transport!: ReactNativeBleTransport;
+    jest.isolateModules(() => {
+      const { default: Transport } = jest.requireActual<typeof import('../index')>('../index');
+      transport = new Transport({});
+    });
+    transport.blePlxManager = bleManager as never;
+    const destruction = createDeferred<void>();
+    Object.assign(bleManager, { destroy: jest.fn(() => destruction.promise) });
+    (transport as unknown as { resetPlxManager(): void }).resetPlxManager();
+    const result = transport.getPlxManager();
+    const failure = expect(result).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.PollingTimeout,
+    });
+    destruction.reject(new Error('Native destruction failed'));
+    await failure;
+  });
+
+  test('bounds reset waiting without letting a new transport bypass unfinished destruction', async () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    const destruction = createDeferred<void>();
+    Object.assign(bleManager, { destroy: jest.fn(() => destruction.promise) });
+    const createManager = jest.mocked(BleManager);
+    createManager.mockClear();
+    (transport as unknown as { resetPlxManager(): void }).resetPlxManager();
+    const nextTransport = new ReactNativeBleTransport({});
+    const result = nextTransport.getPlxManager().catch(error => error);
+    await flush();
+    jest.advanceTimersByTime(BLE_CONNECT_TIMEOUT_MS);
+    await expect(result).resolves.toMatchObject({ errorCode: HardwareErrorCode.PollingTimeout });
+    expect(createManager).not.toHaveBeenCalled();
+    destruction.resolve();
+    await nextTransport.getPlxManager();
+    expect(createManager).toHaveBeenCalledTimes(1);
   });
 
   test('a native connect that never settles is bounded instead of blocking forever', async () => {
@@ -155,6 +335,96 @@ describe('BLE connect timeout', () => {
     expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleConnectedError);
   });
 
+  test('stop drains its scan and removes the timer before another transport scans', async () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    const nativeStop = createDeferred<void>();
+    bleManager.stopDeviceScan.mockImplementation(() => nativeStop.promise);
+    const scanned = transport.enumerate().catch(error => error);
+    await flush();
+    await flush();
+    expect(bleManager.startDeviceScan).toHaveBeenCalledTimes(1);
+    const stopping = transport.stop();
+    expect(transport.stop()).toBe(stopping);
+    let stopped = false;
+    stopping.then(() => {
+      stopped = true;
+    });
+    await flush();
+    expect(stopped).toBe(false);
+    nativeStop.resolve();
+    await stopping;
+    await expect(scanned).resolves.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+    jest.advanceTimersByTime(transport.scanTimeout);
+    await flush();
+    expect(bleManager.stopDeviceScan).toHaveBeenCalledTimes(1);
+    await expect(transport.getPlxManager()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+  });
+
+  test.each(['V1', 'V2'] as const)(
+    'stop completes while Android %s bonding remains pending',
+    async expectedProtocol => {
+      Object.assign(Platform, { OS: 'android' });
+      const { transport, bleManager, connect } = createHarness(() => Promise.resolve());
+      jest.spyOn(BleUtils, 'pairDevice').mockResolvedValueOnce({ bonded: false, bonding: true });
+      const listening = createDeferred<void>();
+      const cleanup = jest.fn();
+      jest.spyOn(BleUtils, 'onDeviceBondState').mockImplementationOnce(() => {
+        listening.resolve();
+        return cleanup;
+      });
+      const acquiring = transport.acquire({ uuid: UUID, expectedProtocol });
+      const rejection = expect(acquiring).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.BleDeviceDisconnected,
+      });
+      await listening.promise;
+
+      // Advance only the existing 100ms disconnect drain, not the bond deadline.
+      let stopped = false;
+      const stopping = transport.stop().then(() => {
+        stopped = true;
+      });
+      await advanceUntil(() => stopped, 1000);
+      expect(stopped).toBe(true);
+      await stopping;
+
+      await rejection;
+      expect(cleanup).toHaveBeenCalledTimes(1);
+      expect(jest.getTimerCount()).toBe(0);
+      expect(bleManager.devices).not.toHaveBeenCalled();
+      expect(connect).not.toHaveBeenCalled();
+    }
+  );
+
+  test('stop rejects a pending read and waits for native disconnection without destroying the shared manager', async () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    const nativeDisconnect = createDeferred<void>();
+    bleManager.cancelDeviceConnection.mockImplementation(() => nativeDisconnect.promise);
+    const destroy = jest.fn();
+    Object.assign(bleManager, { destroy });
+    const read = createDeferred<void>();
+    transport.runPromise = read;
+    Object.assign(transport, { runPromiseDeviceId: UUID });
+    const readResult = read.promise.catch(error => error);
+    let stopped = false;
+    const stopping = transport.stop().then(() => {
+      stopped = true;
+    });
+    await flush();
+    await expect(readResult).resolves.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+    expect(stopped).toBe(false);
+    nativeDisconnect.resolve();
+    await advanceUntil(() => stopped, 1000);
+    await stopping;
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+    expect(destroy).not.toHaveBeenCalled();
+  });
+
   test('the connect budget leaves generous headroom over a healthy connect', () => {
     // Healthy connects finish in ~2-3s (the native budget is 3s); this backstop only
     // fires when the native timeout itself fails to.
@@ -162,6 +432,78 @@ describe('BLE connect timeout', () => {
     expect(BLE_CONNECT_TIMEOUT_MS).toBeLessThanOrEqual(12000);
   });
 
+  test.each(
+    (['ios', 'android'] as const).flatMap(platform =>
+      (['connect', 'mtu', 'gatt'] as const).flatMap(stage =>
+        (['reject', 'resolve'] as const).map(completion => ({ platform, stage, completion }))
+      )
+    )
+  )(
+    'stop cancels $platform $stage before draining a late $completion',
+    async ({ platform, stage, completion }) => {
+      Object.assign(Platform, { OS: platform });
+      const { transport, device, bleManager, connect } = createHarness(
+        () => nativeOperation.promise
+      );
+      const nativeOperation = createDeferred<typeof device>();
+      const nativeDisconnect = createDeferred<void>();
+      const requestMtu = jest.fn(() => Promise.resolve(device));
+      Object.assign(device, { mtu: stage === 'mtu' ? 23 : 247, requestMTU: requestMtu });
+      device.isConnected.mockResolvedValue(true);
+      if (stage === 'connect') device.isConnected.mockResolvedValueOnce(false);
+      if (stage === 'mtu') requestMtu.mockImplementationOnce(() => nativeOperation.promise);
+      if (stage === 'gatt') {
+        device.discoverAllServicesAndCharacteristics.mockImplementationOnce(() =>
+          nativeOperation.promise.then(() => undefined)
+        );
+      }
+      const destroy = jest.fn();
+      Object.assign(bleManager, { destroy });
+      const monitor = jest.spyOn(transport, '_monitorCharacteristic');
+      const acquire = transport.acquire({ uuid: UUID }).catch(error => error);
+      await flush();
+      await flush();
+      const pending = {
+        connect,
+        mtu: requestMtu,
+        gatt: device.discoverAllServicesAndCharacteristics,
+      }[stage];
+      expect(pending).toHaveBeenCalledTimes(1);
+
+      bleManager.cancelDeviceConnection.mockImplementation(() => nativeDisconnect.promise);
+      let stopped = false;
+      const stopping = transport.stop().then(() => {
+        stopped = true;
+      });
+      try {
+        await flush();
+        expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+        expect(stopped).toBe(false);
+      } finally {
+        // Native completion can race cancellation; neither outcome may restart setup.
+        if (completion === 'resolve') nativeOperation.resolve(device);
+        else
+          nativeOperation.reject(
+            Object.assign(new Error('Operation was cancelled'), {
+              errorCode: BleErrorCode.OperationCancelled,
+            })
+          );
+        nativeDisconnect.resolve();
+        await advanceUntil(() => stopped, BLE_CONNECT_TIMEOUT_MS + BLE_GATT_SETUP_TIMEOUT_MS);
+        await stopping;
+      }
+      await expect(acquire).resolves.toBeInstanceOf(Error);
+      expect(connect).toHaveBeenCalledTimes(stage === 'connect' ? 1 : 0);
+      expect(monitor).not.toHaveBeenCalled();
+      if (stage === 'mtu')
+        expect(device.discoverAllServicesAndCharacteristics).not.toHaveBeenCalled();
+      expect(bleManager.cancelDeviceConnection.mock.calls).toEqual(
+        Array.from({ length: bleManager.cancelDeviceConnection.mock.calls.length }, () => [UUID])
+      );
+      expect(destroy).not.toHaveBeenCalled();
+    }
+  );
+
   test('a stalled connect is abandoned natively so the next attempt is not cancelled by it', async () => {
     const { transport, bleManager } = createHarness(
       () =>
@@ -268,6 +610,57 @@ describe('BLE connect timeout', () => {
     expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
   });
 
+  test('a native GATT timeout abandons the native connection', async () => {
+    const { transport, device, bleManager } = createHarness(() => Promise.resolve());
+    const nativeTimeout = Object.assign(new Error('Operation timed out'), {
+      errorCode: BleErrorCode.OperationTimedOut,
+    });
+    device.discoverAllServicesAndCharacteristics.mockRejectedValueOnce(nativeTimeout);
+
+    await expect((transport as any).resolveCharacteristicsWithTimeout(UUID, device)).rejects.toBe(
+      nativeTimeout
+    );
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+  });
+
+  test.each([
+    {
+      nativeFields: { errorCode: BleErrorCode.DeviceDisconnected, iosErrorCode: 14 },
+      reason: 'Peer removed pairing information',
+      errorCode: HardwareErrorCode.BlePeerRemovedPairingInformation,
+    },
+    {
+      nativeFields: { errorCode: 0, attErrorCode: 5 },
+      reason: 'GATT_INSUF_AUTHENTICATION',
+      errorCode: HardwareErrorCode.BleDeviceBondError,
+    },
+  ])(
+    'maps a stale bond during GATT discovery to canonical error $errorCode',
+    async ({ nativeFields, reason, errorCode }) => {
+      const { transport, device } = createHarness(() => Promise.resolve());
+      const nativeError = Object.assign(new Error(reason), nativeFields, { reason });
+      device.discoverAllServicesAndCharacteristics.mockRejectedValueOnce(nativeError);
+
+      await expect(
+        (transport as any).resolveCharacteristicsWithTimeout(UUID, device)
+      ).rejects.toMatchObject({ errorCode });
+    }
+  );
+
+  test('normalizes an unstructured GATT disconnect instead of leaking an unknown error', async () => {
+    const { transport, device } = createHarness(() => Promise.resolve());
+    const nativeError = Object.assign(new Error(`BleError: Device ${UUID} was disconnected`), {
+      errorCode: 0,
+    });
+    device.discoverAllServicesAndCharacteristics.mockRejectedValueOnce(nativeError);
+
+    await expect(
+      (transport as any).resolveCharacteristicsWithTimeout(UUID, device)
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+  });
+
   test('a successful GATT retry clears the timeout budget before an abandoned call settles', async () => {
     const { transport, device, bleManager } = createHarness(() => Promise.resolve());
     let resolveAbandonedDiscovery: (() => void) | undefined;
@@ -300,4 +693,73 @@ describe('BLE connect timeout', () => {
     expect(bleManager.cancelDeviceConnection).toHaveBeenCalledTimes(1);
     expect((transport as any).connectionSetupTimeoutCounts.has(UUID)).toBe(false);
   });
+
+  test('holds an unusable link past the idle timer', async () => {
+    Object.assign(Platform, { OS: 'android' });
+    const { transport, device, bleManager } = createHarness(() => Promise.resolve(device));
+    device.isConnected.mockResolvedValue(true);
+    Object.assign(device, { mtu: 23, requestMTU: jest.fn(() => new Promise(() => {})) });
+    let settled: Error | undefined;
+    const acquire = transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }).catch(error => {
+      settled = error;
+    });
+    await flush();
+    await flush();
+    expect(device.requestMTU).toHaveBeenCalledTimes(1);
+
+    jest.advanceTimersByTime(ANDROID_MTU_EXCHANGE_TIMEOUT_MS);
+    await flush();
+    await flush();
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+
+    jest.advanceTimersByTime(4000);
+    await flush();
+    await flush();
+    expect(settled).toBeUndefined();
+
+    await advanceUntil(() => !!settled, ANDROID_LINK_DROP_QUIET_MS);
+    await acquire;
+    expect(settled).toMatchObject({ errorCode: HardwareErrorCode.BleConnectedError });
+    expect(device.discoverAllServicesAndCharacteristics).not.toHaveBeenCalled();
+  });
+
+  test('a slow but successful MTU exchange completes inside the bound', async () => {
+    Object.assign(Platform, { OS: 'android' });
+    const { transport, device } = createHarness(() => Promise.resolve(device));
+    device.isConnected.mockResolvedValue(true);
+    const negotiated = { ...device, mtu: 247 };
+    Object.assign(device, {
+      mtu: 23,
+      // A cold cache makes the stack discover first; the exchange then completes late.
+      requestMTU: jest.fn(
+        () =>
+          new Promise(resolve => {
+            setTimeout(() => resolve(negotiated), 10_000);
+          })
+      ),
+    });
+    const [, notifyCharacteristic] = await device.characteristicsForService();
+    Object.assign(notifyCharacteristic, { monitor: jest.fn(() => ({ remove: jest.fn() })) });
+    let result: unknown;
+    let failure: Error | undefined;
+    const acquire = transport.acquire({ uuid: UUID, expectedProtocol: 'V1' }).then(
+      value => {
+        result = value;
+      },
+      error => {
+        failure = error;
+      }
+    );
+    await flush();
+    await flush();
+    expect(device.discoverAllServicesAndCharacteristics).not.toHaveBeenCalled();
+
+    jest.advanceTimersByTime(10_000);
+    await advanceUntil(() => result !== undefined || failure !== undefined, 5000);
+    await acquire;
+    expect(failure).toBeUndefined();
+    expect(result).toEqual({ uuid: UUID, protocolType: 'V1' });
+    expect(device.discoverAllServicesAndCharacteristics).toHaveBeenCalledTimes(1);
+    await transport.release(UUID, true);
+  });
 });

package/src/__tests__/enumerate.test.ts

@@ -1,5 +1,8 @@
 import { EventEmitter } from 'events';
 
+import { BleErrorCode } from 'react-native-ble-plx';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import { getConnectedDeviceIds } from '../BleManager';
 import ReactNativeBleTransport from '../index';
 
@@ -14,7 +17,14 @@ jest.mock(
 
 jest.mock('react-native-ble-plx', () => ({
   BleError: class BleError extends Error {},
-  BleErrorCode: {},
+  BleErrorCode: {
+    BluetoothUnsupported: 100,
+    BluetoothUnauthorized: 101,
+    BluetoothPoweredOff: 102,
+    BluetoothInUnknownState: 103,
+    ScanStartFailed: 600,
+    LocationServicesDisabled: 601,
+  },
   BleManager: jest.fn(),
   ScanMode: { LowLatency: 2 },
 }));
@@ -31,6 +41,31 @@ jest.mock('../subscribeBleOn', () => ({
 
 const ONEKEY_SERVICE_UUID = '00000001-0000-1000-8000-00805f9b34fb';
 
+describe('ReactNativeBleTransport scan error mapping', () => {
+  test.each([
+    [BleErrorCode.BluetoothPoweredOff, HardwareErrorCode.BlePoweredOff],
+    [BleErrorCode.BluetoothUnsupported, HardwareErrorCode.BleUnsupported],
+    [BleErrorCode.BluetoothInUnknownState, HardwareErrorCode.BleScanError],
+    [BleErrorCode.BluetoothUnauthorized, HardwareErrorCode.BleLocationError],
+  ])('maps native BLE error %s to hardware error %s', async (nativeCode, errorCode) => {
+    jest.mocked(getConnectedDeviceIds).mockResolvedValueOnce([]);
+    const blePlxManager = {
+      startDeviceScan: jest.fn((_serviceUUIDs, _options, listener) => {
+        queueMicrotask(() => {
+          listener({ errorCode: nativeCode, reason: 'native scan failure' }, null);
+        });
+      }),
+      stopDeviceScan: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new ReactNativeBleTransport({ scanTimeout: 10_000 });
+    transport.blePlxManager = blePlxManager as never;
+    transport.init({ debug: jest.fn(), error: jest.fn() }, new EventEmitter());
+
+    await expect(transport.enumerate()).rejects.toMatchObject({ errorCode });
+    expect(blePlxManager.stopDeviceScan).toHaveBeenCalledTimes(1);
+  });
+});
+
 describe('ReactNativeBleTransport iOS discovery', () => {
   test('keeps a bonded Pro2 communication peripheral after Find My changes its name', async () => {
     jest.mocked(getConnectedDeviceIds).mockResolvedValueOnce([