@onekeyfe/hd-transport-react-native 1.2.0-alpha.7 → 1.2.0-alpha.70

package/dist/subscribeBleOn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscribeBleOn.d.ts","sourceRoot":"","sources":["../src/subscribeBleOn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,eAAO,MAAM,cAAc,eAAgB,aAAa,kBAAc,QAAQ,IAAI,CAqB9E,CAAC"}
+{"version":3,"file":"subscribeBleOn.d.ts","sourceRoot":"","sources":["../src/subscribeBleOn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C,eAAO,MAAM,cAAc,eAAgB,aAAa,kBAAc,QAAQ,IAAI,CAmB9E,CAAC"}

package/dist/transportLog.d.ts

@@ -0,0 +1,2 @@
+export { createTransportCallLog } from '@onekeyfe/hd-transport';
+//# sourceMappingURL=transportLog.d.ts.map

package/dist/transportLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transportLog.d.ts","sourceRoot":"","sources":["../src/transportLog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/types.d.ts

@@ -7,5 +7,6 @@ export type BleAcquireInput = {
     uuid: string;
     forceCleanRunPromise?: boolean;
     expectedProtocol?: ProtocolType;
+    protocolHint?: ProtocolType;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,YAAY,EAAE,UAAU,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAExE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,gBAAgB,CAAC,EAAE,YAAY,CAAC;CACjC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,YAAY,EAAE,UAAU,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAExE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,gBAAgB,CAAC,EAAE,YAAY,CAAC;IAChC,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC"}

package/jest.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  preset: '../../jest.config.js',
+  testEnvironment: 'node',
+  modulePathIgnorePatterns: ['node_modules', '<rootDir>/dist'],
+  moduleNameMapper: {
+    // The workspace symlinks resolve to prebuilt dist outputs that can lag behind src.
+    '^@onekeyfe/hd-transport$': '<rootDir>/../hd-transport/src/index.ts',
+    '^@onekeyfe/hd-shared$': '<rootDir>/../shared/src/index.ts',
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.0-alpha.7",
+  "version": "1.2.0-alpha.70",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
   "main": "dist/index.js",
@@ -15,15 +15,16 @@
   "scripts": {
     "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
     "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "test": "jest",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.0-alpha.7",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.7",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.7",
-    "@onekeyfe/react-native-ble-utils": "^0.1.4",
+    "@onekeyfe/hd-core": "1.2.0-alpha.70",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.70",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.70",
+    "@onekeyfe/react-native-ble-utils": "^0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "001372047f518aaeed5fcbe87b990b8b619a9a65"
+  "gitHead": "d86b033cf970f97e060c49fe4cf618f38b9ce666"
 }

package/src/BleTransport.ts

@@ -1,12 +1,7 @@
-import { BleErrorCode } from 'react-native-ble-plx';
-import { wait } from '@onekeyfe/hd-shared';
-
-import { bleLogger } from './logger';
+import { Platform } from 'react-native';
 
 import type { Characteristic, Device, Subscription } from 'react-native-ble-plx';
 
-const Log = bleLogger;
-
 export default class BleTransport {
   id: string;
 
@@ -28,10 +23,6 @@ export default class BleTransport {
 
   monitorToken?: number;
 
-  static MAX_RETRIES = 5;
-
-  static RETRY_DELAY = 2000;
-
   constructor(
     device: Device,
     writeCharacteristic: Characteristic,
@@ -43,37 +34,11 @@ export default class BleTransport {
     this.notifyCharacteristic = notifyCharacteristic;
   }
 
-  /**
-   * @description only for pro / touch , while upgrade firmware
-   * @param data
-   * @param retryCount
-   * @returns
-   */
-  async writeWithRetry(data: string, retryCount = BleTransport.MAX_RETRIES): Promise<void> {
-    try {
-      await this.writeCharacteristic.writeWithoutResponse(data);
-    } catch (error) {
-      Log?.debug(
-        `Write retry attempt ${BleTransport.MAX_RETRIES - retryCount + 1}, error: ${error}`
-      );
-      if (retryCount > 0) {
-        await wait(BleTransport.RETRY_DELAY);
-        if (
-          error.errorCode === BleErrorCode.DeviceDisconnected ||
-          error.errorCode === BleErrorCode.CharacteristicNotFound
-        ) {
-          try {
-            await this.device.connect();
-            await this.device.discoverAllServicesAndCharacteristics();
-          } catch (e) {
-            Log?.debug(`Connect or discoverAllServicesAndCharacteristics error: ${e}`);
-          }
-        } else {
-          Log?.debug(`writeCharacteristic error: ${error}`);
-        }
-        return this.writeWithRetry(data, retryCount - 1);
-      }
-      throw error;
+  async writeWithRetry(data: string): Promise<void> {
+    if (Platform.OS === 'ios' && this.writeCharacteristic.isWritableWithResponse) {
+      await this.writeCharacteristic.writeWithResponse(data);
+      return;
     }
+    await this.writeCharacteristic.writeWithoutResponse(data);
   }
 }

package/src/__tests__/BleTransport.test.ts

@@ -0,0 +1,93 @@
+import { BleErrorCode } from 'react-native-ble-plx';
+import { Platform } from 'react-native';
+
+import BleTransport from '../BleTransport';
+
+jest.mock(
+  'react-native',
+  () => ({
+    Platform: { OS: 'ios' },
+  }),
+  { virtual: true }
+);
+
+jest.mock(
+  'react-native-ble-plx',
+  () => ({
+    BleErrorCode: {
+      DeviceDisconnected: 205,
+      CharacteristicNotFound: 404,
+    },
+  }),
+  { virtual: true }
+);
+
+jest.mock('@onekeyfe/hd-shared', () => ({
+  ...jest.requireActual('@onekeyfe/hd-shared'),
+  wait: jest.fn(() => Promise.resolve()),
+}));
+
+describe('BleTransport side-effecting writes', () => {
+  beforeEach(() => {
+    Platform.OS = 'ios';
+  });
+
+  test('does not reconnect or replay after the device disconnects', async () => {
+    const error = Object.assign(new Error('device disconnected'), {
+      errorCode: BleErrorCode.DeviceDisconnected,
+    });
+    const writeCharacteristic = {
+      isWritableWithResponse: true,
+      writeWithResponse: jest.fn(() => Promise.reject(error)),
+      writeWithoutResponse: jest.fn(() => Promise.resolve()),
+    };
+    const device = {
+      id: 'classic-id',
+      connect: jest.fn(() => Promise.resolve()),
+      discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(device as any, writeCharacteristic as any, {} as any);
+
+    await expect(transport.writeWithRetry('payload')).rejects.toBe(error);
+
+    expect(writeCharacteristic.writeWithResponse).toHaveBeenCalledTimes(1);
+    expect(device.connect).not.toHaveBeenCalled();
+  });
+
+  test('keeps Android Protocol V1 writes on writeWithoutResponse', async () => {
+    Platform.OS = 'android';
+    const writeCharacteristic = {
+      isWritableWithResponse: true,
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(
+      { id: 'classic-id' } as any,
+      writeCharacteristic as any,
+      {} as any
+    );
+
+    await transport.writeWithRetry('payload');
+
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledWith('payload');
+  });
+
+  test('uses writeWithoutResponse on iOS when the characteristic lacks response support', async () => {
+    const writeCharacteristic = {
+      isWritableWithResponse: false,
+      writeWithResponse: jest.fn(() => Promise.resolve()),
+      writeWithoutResponse: jest.fn(() => Promise.resolve()),
+    };
+    const transport = new BleTransport(
+      { id: 'classic-id' } as any,
+      writeCharacteristic as any,
+      {} as any
+    );
+
+    await transport.writeWithRetry('payload');
+
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).toHaveBeenCalledWith('payload');
+  });
+});

package/src/__tests__/bleStrategy.test.ts

@@ -1,8 +1,4 @@
-import {
-  hasWritableCapability,
-  resolveBleWriteMode,
-  resolveProtocolV2PacketCapacity,
-} from '../bleStrategy';
+import { hasWritableCapability, resolveProtocolV2PacketCapacity } from '../bleStrategy';
 
 describe('React Native BLE strategy', () => {
   test('accepts writeWithoutResponse-only characteristics', () => {
@@ -12,7 +8,6 @@ describe('React Native BLE strategy', () => {
     };
 
     expect(hasWritableCapability(characteristic)).toBe(true);
-    expect(resolveBleWriteMode(characteristic)).toBe('withoutResponse');
   });
 
   test('falls back to Android default ATT payload when MTU is unavailable', () => {

package/src/__tests__/connectTimeout.test.ts

@@ -0,0 +1,281 @@
+import { EventEmitter } from 'events';
+import { BleErrorCode } from 'react-native-ble-plx';
+
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport, {
+  BLE_CONNECT_TIMEOUT_MS,
+  BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD,
+  BLE_GATT_SETUP_TIMEOUT_MS,
+} from '../index';
+import protocolV1Schema from './protocolV1SchemaFixture';
+
+jest.mock(
+  'react-native',
+  () => ({
+    Platform: { OS: 'ios', select: (spec: Record<string, unknown>) => spec.ios },
+    PermissionsAndroid: {
+      PERMISSIONS: {},
+      RESULTS: {},
+      request: jest.fn(),
+      requestMultiple: jest.fn(),
+    },
+  }),
+  { virtual: true }
+);
+
+jest.mock('react-native-ble-plx', () => ({
+  BleATTErrorCode: { InvalidHandle: 1, UnlikelyError: 14 },
+  BleError: Error,
+  BleErrorCode: {
+    DeviceDisconnected: 201,
+    OperationStartFailed: 601,
+    DeviceMTUChangeFailed: 401,
+    OperationCancelled: 2,
+    OperationTimedOut: 3,
+    DeviceAlreadyConnected: 203,
+  },
+  BleManager: jest.fn(),
+  ScanMode: { LowLatency: 2 },
+}));
+
+jest.mock('@onekeyfe/react-native-ble-utils', () => ({
+  __esModule: true,
+  default: {
+    getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
+    getBondedPeripherals: jest.fn(() => Promise.resolve([])),
+    pairDevice: jest.fn(() => Promise.resolve()),
+  },
+}));
+
+const UUID = 'stalled-connect-device';
+
+const flush = () =>
+  new Promise(resolve => {
+    setImmediate(resolve);
+  });
+
+async function advanceUntil(settled: () => boolean, totalMs: number, stepMs = 250) {
+  for (let elapsed = 0; elapsed < totalMs; elapsed += stepMs) {
+    jest.advanceTimersByTime(stepMs);
+    // eslint-disable-next-line no-await-in-loop
+    await flush();
+    if (settled()) return;
+  }
+  throw new Error(`fake timers exhausted after ${totalMs}ms before the connect settled`);
+}
+
+/** A device whose native connect() never settles — the observed iOS failure mode. */
+function createHarness(connectImpl: () => Promise<unknown>) {
+  const connect = jest.fn(connectImpl);
+  const writeCharacteristic = {
+    uuid: '00000002-0000-1000-8000-00805f9b34fb',
+    isWritableWithResponse: true,
+  };
+  const notifyCharacteristic = {
+    uuid: '00000003-0000-1000-8000-00805f9b34fb',
+    isNotifiable: true,
+  };
+  const device = {
+    id: UUID,
+    name: 'OneKey Classic',
+    localName: 'OneKey Classic',
+    serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
+    isConnected: jest.fn(() => Promise.resolve(false)),
+    cancelConnection: jest.fn(() => Promise.resolve()),
+    connect,
+    discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
+    characteristicsForService: jest.fn(() =>
+      Promise.resolve([writeCharacteristic, notifyCharacteristic])
+    ),
+    services: jest.fn(() => Promise.resolve([])),
+    onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
+  };
+  const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
+  const bleManager = {
+    devices: jest.fn(() => Promise.resolve([device])),
+    connectedDevices: jest.fn(() => Promise.resolve([])),
+    connectToDevice: jest.fn(connectImpl),
+    cancelTransaction: jest.fn(() => Promise.resolve()),
+    cancelDeviceConnection: jest.fn(() => Promise.resolve()),
+    onStateChange: jest.fn((listener: (state: string) => void) => {
+      // Dispatch asynchronously: subscribeBleOn wires its own cleanup after
+      // registering, so a synchronous callback would run before it is ready.
+      setImmediate(() => listener('PoweredOn'));
+      return { remove: jest.fn() };
+    }),
+    state: jest.fn(() => Promise.resolve('PoweredOn')),
+    startDeviceScan: jest.fn(),
+    stopDeviceScan: jest.fn(),
+  };
+  (transport as any).blePlxManager = bleManager;
+  transport.init(
+    { debug: jest.fn(), error: jest.fn(), warn: jest.fn() } as any,
+    new EventEmitter()
+  );
+  transport.configure(protocolV1Schema);
+  return { transport, device, bleManager, connect };
+}
+
+describe('BLE connect timeout', () => {
+  beforeAll(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.restoreAllMocks();
+  });
+
+  test('a native connect that never settles is bounded instead of blocking forever', async () => {
+    // iOS applies its own connect timeout on a serial queue; when that queue is busy
+    // the timeout never fires and acquire() blocks until the app-level 60s timeout.
+    const { transport } = createHarness(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+
+    const errors: Array<{ errorCode?: unknown }> = [];
+    let settled = false;
+    transport.acquire({ uuid: UUID }).catch(e => {
+      errors.push(e);
+      settled = true;
+    });
+    await flush();
+
+    await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
+
+    expect(errors).toHaveLength(1);
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleConnectedError);
+  });
+
+  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.
+    expect(BLE_CONNECT_TIMEOUT_MS).toBeGreaterThanOrEqual(6000);
+    expect(BLE_CONNECT_TIMEOUT_MS).toBeLessThanOrEqual(12000);
+  });
+
+  test('a stalled connect is abandoned natively so the next attempt is not cancelled by it', async () => {
+    const { transport, bleManager } = createHarness(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+
+    let settled = false;
+    transport.acquire({ uuid: UUID }).catch(() => {
+      settled = true;
+    });
+    await flush();
+    await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+  });
+
+  test('repeated stalled connects recreate the BLE manager', async () => {
+    const { transport, bleManager } = createHarness(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+    const destroy = jest.fn();
+    (bleManager as unknown as { destroy: jest.Mock }).destroy = destroy;
+
+    for (let attempt = 0; attempt < BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD; attempt += 1) {
+      let settled = false;
+      transport.acquire({ uuid: UUID }).catch(() => {
+        settled = true;
+      });
+      // eslint-disable-next-line no-await-in-loop
+      await flush();
+      // eslint-disable-next-line no-await-in-loop
+      await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
+    }
+
+    expect(destroy).toHaveBeenCalledTimes(1);
+    expect((transport as unknown as { blePlxManager?: unknown }).blePlxManager).toBeUndefined();
+  });
+
+  test('native connect timeouts contribute to the same manager reset budget', async () => {
+    const { transport, bleManager } = createHarness(() => Promise.resolve());
+    const destroy = jest.fn();
+    (bleManager as unknown as { destroy: jest.Mock }).destroy = destroy;
+    const nativeTimeout = Object.assign(new Error('Operation timed out'), {
+      errorCode: BleErrorCode.OperationTimedOut,
+    });
+
+    for (let attempt = 0; attempt < BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD; attempt += 1) {
+      // eslint-disable-next-line no-await-in-loop
+      await expect(
+        (transport as any).connectWithTimeout(UUID, () => Promise.reject(nativeTimeout))
+      ).rejects.toBe(nativeTimeout);
+    }
+
+    expect(destroy).toHaveBeenCalledTimes(1);
+  });
+
+  test('GATT discovery is bounded and abandons the native connection', async () => {
+    const { transport, device, bleManager } = createHarness(() => Promise.resolve());
+    device.discoverAllServicesAndCharacteristics.mockImplementation(
+      () =>
+        new Promise(() => {
+          // never settles
+        })
+    );
+
+    const errors: Array<{ errorCode?: unknown }> = [];
+    let settled = false;
+    (transport as any).resolveCharacteristicsWithTimeout(UUID, device).catch((error: unknown) => {
+      errors.push(error as { errorCode?: unknown });
+      settled = true;
+    });
+    await flush();
+    await advanceUntil(() => settled, BLE_GATT_SETUP_TIMEOUT_MS + 5000);
+
+    expect(errors).toHaveLength(1);
+    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleConnectedError);
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
+  });
+
+  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;
+    device.discoverAllServicesAndCharacteristics
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>(resolve => {
+            resolveAbandonedDiscovery = resolve;
+          })
+      )
+      .mockResolvedValueOnce(undefined);
+
+    let firstSettled = false;
+    (transport as any).resolveCharacteristicsWithTimeout(UUID, device).catch(() => {
+      firstSettled = true;
+    });
+    await flush();
+    await advanceUntil(() => firstSettled, BLE_GATT_SETUP_TIMEOUT_MS + 5000);
+
+    await expect(
+      (transport as any).resolveCharacteristicsWithTimeout(UUID, device)
+    ).resolves.toMatchObject({
+      writeCharacteristic: expect.any(Object),
+      notifyCharacteristic: expect.any(Object),
+    });
+
+    resolveAbandonedDiscovery?.();
+    await flush();
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledTimes(1);
+    expect((transport as any).connectionSetupTimeoutCounts.has(UUID)).toBe(false);
+  });
+});

package/src/__tests__/constants.test.ts

@@ -0,0 +1,20 @@
+import { getBluetoothServiceUuids, getInfosForServiceUuid } from '../constants';
+
+describe('React Native BLE service filters', () => {
+  test('does not scan or configure the ignored FFFD service', () => {
+    expect(getBluetoothServiceUuids()).not.toContain('fffd');
+    expect(getInfosForServiceUuid('fffd', 'classic')).toBeNull();
+    expect(getInfosForServiceUuid('0000fffd-0000-1000-8000-00805f9b34fb', 'classic')).toBeNull();
+  });
+
+  test('keeps the OneKey communication service configured', () => {
+    expect(getBluetoothServiceUuids()).toContain('00000001-0000-1000-8000-00805f9b34fb');
+    expect(getInfosForServiceUuid('0001', 'classic')).toMatchObject({
+      serviceUuid: '00000001-0000-1000-8000-00805f9b34fb',
+    });
+  });
+
+  test('does not match a vendor-specific UUID containing the OneKey short key', () => {
+    expect(getInfosForServiceUuid('abcd0001-1234-5678-9012-abcdefabcdef', 'classic')).toBeNull();
+  });
+});

package/src/__tests__/enumerate.test.ts

@@ -0,0 +1,132 @@
+import { EventEmitter } from 'events';
+
+import { getConnectedDeviceIds } from '../BleManager';
+import ReactNativeBleTransport from '../index';
+
+jest.mock(
+  'react-native',
+  () => ({
+    PermissionsAndroid: {},
+    Platform: { OS: 'ios' },
+  }),
+  { virtual: true }
+);
+
+jest.mock('react-native-ble-plx', () => ({
+  BleError: class BleError extends Error {},
+  BleErrorCode: {},
+  BleManager: jest.fn(),
+  ScanMode: { LowLatency: 2 },
+}));
+
+jest.mock('../BleManager', () => ({
+  getConnectedDeviceIds: jest.fn(),
+  onDeviceBondState: jest.fn(),
+  pairDevice: jest.fn(),
+}));
+
+jest.mock('../subscribeBleOn', () => ({
+  subscribeBleOn: jest.fn(() => Promise.resolve()),
+}));
+
+const ONEKEY_SERVICE_UUID = '00000001-0000-1000-8000-00805f9b34fb';
+
+describe('ReactNativeBleTransport iOS discovery', () => {
+  test('filters a bonded Pro2 Find My peripheral while keeping the wallet peripheral', async () => {
+    jest.mocked(getConnectedDeviceIds).mockResolvedValueOnce([
+      {
+        id: 'find-my-peripheral',
+        name: 'Pro2 6E9E - Find My',
+        localName: null,
+        serviceUUIDs: [ONEKEY_SERVICE_UUID],
+      },
+      {
+        id: 'wallet-peripheral',
+        name: 'Pro2 6E9E',
+        localName: 'Pro2 6E9E',
+        serviceUUIDs: [ONEKEY_SERVICE_UUID],
+      },
+    ] as never);
+    const blePlxManager = {
+      startDeviceScan: jest.fn(),
+      stopDeviceScan: jest.fn(),
+    };
+    const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
+    transport.blePlxManager = blePlxManager as never;
+    transport.init({ debug: jest.fn(), error: jest.fn() }, new EventEmitter());
+
+    const devices = await transport.enumerate();
+
+    expect(devices.map(device => device.id)).toEqual(['wallet-peripheral']);
+  });
+
+  test('filters a scanned Pro2 Find My peripheral by name when localName is null', async () => {
+    jest.mocked(getConnectedDeviceIds).mockResolvedValueOnce([]);
+    const blePlxManager = {
+      startDeviceScan: jest.fn((_serviceUUIDs, _options, listener) => {
+        queueMicrotask(() => {
+          listener(null, {
+            id: 'find-my-peripheral',
+            name: 'Pro2 6E9E - Find My',
+            localName: null,
+            serviceUUIDs: [ONEKEY_SERVICE_UUID],
+          });
+          listener(null, {
+            id: 'wallet-peripheral',
+            name: 'Pro2 6E9E',
+            localName: 'Pro2 6E9E',
+            serviceUUIDs: [ONEKEY_SERVICE_UUID],
+          });
+        });
+      }),
+      stopDeviceScan: jest.fn(),
+    };
+    const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
+    transport.blePlxManager = blePlxManager as never;
+    transport.init({ debug: jest.fn(), error: jest.fn() }, new EventEmitter());
+
+    const devices = await transport.enumerate();
+
+    expect(devices.map(device => device.id)).toEqual(['wallet-peripheral']);
+  });
+
+  test('ignores an unnamed scanned advertisement while keeping the named wallet peripheral', async () => {
+    jest.mocked(getConnectedDeviceIds).mockResolvedValueOnce([]);
+    const blePlxManager = {
+      startDeviceScan: jest.fn((_serviceUUIDs, _options, listener) => {
+        queueMicrotask(() => {
+          listener(null, {
+            id: 'unnamed-peripheral',
+            name: null,
+            localName: null,
+            serviceUUIDs: [
+              '0000180a-0000-1000-8000-00805f9b34fb',
+              '0000180f-0000-1000-8000-00805f9b34fb',
+              '0000fffd-0000-1000-8000-00805f9b34fb',
+              ONEKEY_SERVICE_UUID,
+            ],
+          });
+          listener(null, {
+            id: 'wallet-peripheral',
+            name: 'Pro2 769D',
+            localName: 'Pro2 769D',
+            serviceUUIDs: [
+              '0000180a-0000-1000-8000-00805f9b34fb',
+              '0000180f-0000-1000-8000-00805f9b34fb',
+              '0000fffd-0000-1000-8000-00805f9b34fb',
+              ONEKEY_SERVICE_UUID,
+            ],
+          });
+        });
+      }),
+      stopDeviceScan: jest.fn(),
+    };
+    const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
+    transport.blePlxManager = blePlxManager as never;
+    transport.init({ debug: jest.fn(), error: jest.fn() }, new EventEmitter());
+
+    const devices = await transport.enumerate();
+
+    expect(devices.map(device => device.id)).toEqual(['wallet-peripheral']);
+  });
+});