@onekeyfe/hd-transport-react-native 1.2.0-alpha.9 → 1.2.0-alpha.91

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']);
+  });
+});

package/src/__tests__/protocolReprobe.test.ts

@@ -0,0 +1,132 @@
+import ReactNativeBleTransport, { PROTOCOL_REPROBE_FALLBACK_ATTEMPTS } 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 },
+  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 = 'reprobe-device';
+
+/** Drive detectProtocol with stubbed probes so we can observe which are attempted. */
+function createHarness({ v1, v2 }: { v1: boolean; v2: boolean }) {
+  const transport = new ReactNativeBleTransport({});
+  transport.configure(protocolV1Schema);
+  const probeV1 = jest.fn(() => {
+    if (v1) {
+      (transport as any).deviceProtocol.set(UUID, 'V1');
+    }
+    return Promise.resolve(v1);
+  });
+  const probeV2 = jest.fn(() => {
+    if (v2) {
+      (transport as any).deviceProtocol.set(UUID, 'V2');
+    }
+    return Promise.resolve(v2);
+  });
+  (transport as any).probeProtocolV1 = probeV1;
+  (transport as any).probeProtocolV2 = probeV2;
+  (transport as any).resetProbeStateAfterProtocolProbe = jest.fn(() => Promise.resolve());
+  return { transport, probeV1, probeV2 };
+}
+
+const detect = (transport: ReactNativeBleTransport) =>
+  (transport as any).detectProtocol(UUID, undefined, undefined, () =>
+    Promise.resolve()
+  ) as Promise<string>;
+
+describe('protocol re-probe after a known device goes away', () => {
+  test('an unknown device still probes both protocols', async () => {
+    const { transport, probeV1, probeV2 } = createHarness({ v1: false, v2: false });
+
+    await expect(detect(transport)).rejects.toBeDefined();
+
+    expect(probeV1).toHaveBeenCalledTimes(1);
+    expect(probeV2).toHaveBeenCalledTimes(1);
+  });
+
+  test('a device already known to speak V1 does not pay the V2 probe while it is away', async () => {
+    const known = createHarness({ v1: true, v2: false });
+    // First detection confirms V1 (this is the session that just talked to the device).
+    await expect(detect(known.transport)).resolves.toBe('V1');
+
+    // The device now reboots after a firmware install: V1 stops answering.
+    (known.transport as any).deviceProtocol.delete(UUID);
+    const probeV1 = jest.fn(() => Promise.resolve(false));
+    const probeV2 = jest.fn(() => Promise.resolve(false));
+    (known.transport as any).probeProtocolV1 = probeV1;
+    (known.transport as any).probeProtocolV2 = probeV2;
+
+    await expect(detect(known.transport)).rejects.toBeDefined();
+
+    expect(probeV1).toHaveBeenCalledTimes(1);
+    // The 10s Protocol V2 ping is pure waste for a device we just spoke V1 to.
+    expect(probeV2).not.toHaveBeenCalled();
+  });
+
+  test('after repeated failures it re-probes every protocol again', async () => {
+    const known = createHarness({ v1: true, v2: false });
+    await expect(detect(known.transport)).resolves.toBe('V1');
+
+    (known.transport as any).deviceProtocol.delete(UUID);
+    const probeV1 = jest.fn(() => Promise.resolve(false));
+    const probeV2 = jest.fn(() => Promise.resolve(false));
+    (known.transport as any).probeProtocolV1 = probeV1;
+    (known.transport as any).probeProtocolV2 = probeV2;
+
+    for (let attempt = 0; attempt < PROTOCOL_REPROBE_FALLBACK_ATTEMPTS; attempt += 1) {
+      // eslint-disable-next-line no-await-in-loop
+      await expect(detect(known.transport)).rejects.toBeDefined();
+    }
+    expect(probeV2).not.toHaveBeenCalled();
+
+    // The device may genuinely have changed protocol, so the shortcut must expire.
+    await expect(detect(known.transport)).rejects.toBeDefined();
+    expect(probeV2).toHaveBeenCalled();
+  });
+
+  test('a successful detection clears the failure streak', async () => {
+    const known = createHarness({ v1: true, v2: false });
+    await expect(detect(known.transport)).resolves.toBe('V1');
+    (known.transport as any).deviceProtocol.delete(UUID);
+
+    const failingV1 = jest.fn(() => Promise.resolve(false));
+    (known.transport as any).probeProtocolV1 = failingV1;
+    await expect(detect(known.transport)).rejects.toBeDefined();
+
+    // Device comes back.
+    (known.transport as any).probeProtocolV1 = jest.fn(() => {
+      (known.transport as any).deviceProtocol.set(UUID, 'V1');
+      return Promise.resolve(true);
+    });
+    await expect(detect(known.transport)).resolves.toBe('V1');
+
+    expect((known.transport as any).protocolReprobeFailures.get(UUID)).toBeUndefined();
+  });
+});

package/src/__tests__/protocolV1SchemaFixture.ts

@@ -0,0 +1,39 @@
+const protocolV1Schema = {
+  nested: {
+    Initialize: {
+      fields: {
+        session_id: { type: 'bytes', id: 1 },
+        derive_cardano: { type: 'bool', id: 3 },
+      },
+    },
+    GetFeatures: { fields: {} },
+    Success: {
+      fields: {
+        message: { type: 'string', id: 1 },
+      },
+    },
+    Ping: {
+      fields: {
+        message: { type: 'string', id: 1 },
+        button_protection: { type: 'bool', id: 2 },
+      },
+    },
+    FirmwareUpload: {
+      fields: {
+        payload: { rule: 'required', type: 'bytes', id: 1 },
+        hash: { type: 'bytes', id: 2 },
+      },
+    },
+    MessageType: {
+      values: {
+        MessageType_Initialize: 0,
+        MessageType_Ping: 1,
+        MessageType_Success: 2,
+        MessageType_FirmwareUpload: 7,
+        MessageType_GetFeatures: 55,
+      },
+    },
+  },
+};
+
+export default protocolV1Schema;