@onekeyfe/hd-transport-react-native 1.2.4-alpha.0 → 1.2.4-alpha.1

package/src/__tests__/iosPeerTermination.test.ts

@@ -0,0 +1,303 @@
+import EventEmitter from 'events';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport from '../index';
+import {
+  IOS_PEER_TERMINATION_LINK_WINDOW_MS,
+  IOS_PEER_TERMINATION_REPEAT_WINDOW_MS,
+  IosPeerTerminationTracker,
+} from '../bleIosStaleBond';
+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({ bonded: true, bonding: false })),
+    onDeviceBondState: jest.fn(),
+  },
+}));
+
+const UUID = '2146E74A-21CC-2EA6-2CE3-B4258520FD0F';
+
+// What ble-plx rejects the in-flight operation with when the device ends the link. An iPhone 17
+// reports a wiped device this way instead of CBErrorPeerRemovedPairingInformation.
+const nativeDisconnect = (iosErrorCode: number, reason: string) =>
+  Object.assign(new Error(`Device ${UUID} was disconnected`), {
+    errorCode: 201,
+    iosErrorCode,
+    reason,
+  });
+const peerEndedLink = () => nativeDisconnect(7, 'The specified device has disconnected from us.');
+const linkTimedOut = () => nativeDisconnect(6, 'The connection has timed out unexpectedly.');
+
+function createHarness() {
+  const writeCharacteristic = {
+    uuid: '00000002-0000-1000-8000-00805f9b34fb',
+    isWritableWithResponse: true,
+    writeWithResponse: jest.fn(() => Promise.resolve()),
+  };
+  const notifyCharacteristic = {
+    uuid: '00000003-0000-1000-8000-00805f9b34fb',
+    isNotifiable: true,
+    monitor: jest.fn(() => ({ remove: jest.fn() })),
+  };
+  const device = {
+    id: UUID,
+    name: 'Pro 2 48E9',
+    localName: 'Pro 2 48E9',
+    mtu: 247,
+    serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
+    isConnected: jest.fn(() => Promise.resolve(false)),
+    cancelConnection: jest.fn(() => Promise.resolve()),
+    connect: jest.fn(),
+    discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
+    characteristicsForService: jest.fn(() =>
+      Promise.resolve([writeCharacteristic, notifyCharacteristic])
+    ),
+    services: jest.fn(() => Promise.resolve([])),
+    onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
+  };
+  device.connect.mockImplementation(() => Promise.resolve(device));
+  const transport = new ReactNativeBleTransport({});
+  (transport as any).blePlxManager = {
+    devices: jest.fn(() => Promise.resolve([device])),
+    connectedDevices: jest.fn(() => Promise.resolve([])),
+    connectToDevice: jest.fn(() => Promise.resolve(device)),
+    cancelTransaction: jest.fn(() => Promise.resolve()),
+    cancelDeviceConnection: jest.fn(() => Promise.resolve()),
+    onStateChange: jest.fn((listener: (state: string) => void) => {
+      setImmediate(() => listener('PoweredOn'));
+      return { remove: jest.fn() };
+    }),
+    state: jest.fn(() => Promise.resolve('PoweredOn')),
+  };
+  transport.init(
+    { debug: jest.fn(), error: jest.fn(), warn: jest.fn() } as any,
+    new EventEmitter()
+  );
+  transport.configure(protocolV1Schema);
+  return { transport, device, writeCharacteristic, notifyCharacteristic };
+}
+
+type Outcome = { code?: unknown; params?: unknown; native?: unknown };
+
+const flush = () =>
+  new Promise(resolve => {
+    setImmediate(resolve);
+  });
+
+/** Runs one acquire to its end, moving the fake clock past the transport's own waits. */
+async function acquire(
+  transport: ReactNativeBleTransport,
+  input: Record<string, unknown> = {}
+): Promise<Outcome> {
+  let outcome: Outcome | undefined;
+  transport.acquire({ uuid: UUID, ...input } as never).then(
+    () => {
+      outcome = {};
+    },
+    error => {
+      const { code, params } = ERRORS.serializeError({ error });
+      outcome = { code, params, native: (error as { iosErrorCode?: unknown }).iosErrorCode };
+    }
+  );
+  for (let i = 0; i < 400 && !outcome; i += 1) {
+    // eslint-disable-next-line no-await-in-loop
+    await flush();
+    if (!outcome) jest.advanceTimersByTime(100);
+  }
+  if (!outcome) throw new Error('acquire did not settle');
+  return outcome;
+}
+
+describe('iOS link ended by the device right after connecting', () => {
+  beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance', 'nextTick'] });
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  test('keeps the first error so Core retries, then reports an invalid bond', async () => {
+    const { transport, device } = createHarness();
+    device.discoverAllServicesAndCharacteristics.mockImplementation(() =>
+      Promise.reject(peerEndedLink())
+    );
+
+    // Core retries an error it cannot classify, which is what makes the second attempt.
+    await expect(acquire(transport)).resolves.toEqual({ native: 7 });
+    await expect(acquire(transport)).resolves.toEqual({
+      code: HardwareErrorCode.BleBondInvalid,
+      params: { phase: 'connect', reason: 'peer_disconnected' },
+    });
+    // The verdict consumes the evidence, so the next one needs two attempts again.
+    await expect(acquire(transport)).resolves.toEqual({ native: 7 });
+  });
+
+  test('counts a drop that interrupts the first write the same way', async () => {
+    const { transport, writeCharacteristic } = createHarness();
+    writeCharacteristic.writeWithResponse.mockImplementation(() => Promise.reject(peerEndedLink()));
+
+    await expect(acquire(transport)).resolves.toMatchObject({
+      code: HardwareErrorCode.BleDeviceNotBonded,
+    });
+    await expect(acquire(transport)).resolves.toMatchObject({
+      code: HardwareErrorCode.BleBondInvalid,
+    });
+  });
+
+  test('counts a drop that only the notification stream reports', async () => {
+    const { transport, notifyCharacteristic } = createHarness();
+    // The request went out before the link ended, so no write is there to fail.
+    notifyCharacteristic.monitor.mockImplementation(((
+      listener: (error: unknown, characteristic: unknown) => void
+    ) => {
+      setTimeout(() => listener(peerEndedLink(), null), 50);
+      return { remove: jest.fn() };
+    }) as never);
+
+    await expect(acquire(transport)).resolves.not.toMatchObject({
+      code: HardwareErrorCode.BleBondInvalid,
+    });
+    await expect(acquire(transport)).resolves.toMatchObject({
+      code: HardwareErrorCode.BleBondInvalid,
+    });
+  });
+
+  test('needs the second drop soon after the first', async () => {
+    const { transport, device } = createHarness();
+    device.discoverAllServicesAndCharacteristics.mockImplementation(() =>
+      Promise.reject(peerEndedLink())
+    );
+
+    await acquire(transport);
+    jest.setSystemTime(Date.now() + IOS_PEER_TERMINATION_REPEAT_WINDOW_MS + 1);
+
+    await expect(acquire(transport)).resolves.toEqual({ native: 7 });
+  });
+
+  test('starts over after an attempt that failed for another reason', async () => {
+    const { transport, device } = createHarness();
+    device.discoverAllServicesAndCharacteristics
+      .mockImplementationOnce(() => Promise.reject(peerEndedLink()))
+      .mockImplementationOnce(() => Promise.reject(linkTimedOut()))
+      .mockImplementation(() => Promise.reject(peerEndedLink()));
+
+    await acquire(transport);
+    await expect(acquire(transport)).resolves.toEqual({ native: 6 });
+    await expect(acquire(transport)).resolves.toEqual({ native: 7 });
+  });
+
+  test('starts over once the device has answered', async () => {
+    const { transport, device } = createHarness();
+    (transport as any).detectProtocol = jest.fn(() => Promise.resolve('V1'));
+    device.discoverAllServicesAndCharacteristics
+      .mockImplementationOnce(() => Promise.reject(peerEndedLink()))
+      .mockImplementationOnce(() => Promise.resolve())
+      .mockImplementation(() => Promise.reject(peerEndedLink()));
+
+    await acquire(transport);
+    await expect(acquire(transport)).resolves.toEqual({});
+
+    await expect(acquire(transport)).resolves.toEqual({ native: 7 });
+  });
+
+  test('never classifies a firmware-install reconnect', async () => {
+    const { transport, device } = createHarness();
+    device.discoverAllServicesAndCharacteristics.mockImplementation(() =>
+      Promise.reject(peerEndedLink())
+    );
+    const reconnect = { expectedProtocol: 'V2', skipProtocolProbe: true };
+
+    await expect(acquire(transport, reconnect)).resolves.toEqual({ native: 7 });
+    await expect(acquire(transport, reconnect)).resolves.toEqual({ native: 7 });
+    // The device was rebooting, so those drops are not evidence for a later attempt either.
+    await expect(acquire(transport)).resolves.toEqual({ native: 7 });
+  });
+
+  test('reports a lost bond that iOS names during GATT setup', async () => {
+    const { transport, device } = createHarness();
+    device.discoverAllServicesAndCharacteristics.mockImplementation(() =>
+      Promise.reject(nativeDisconnect(14, 'Peer removed pairing information'))
+    );
+
+    await expect(acquire(transport)).resolves.toMatchObject({
+      code: HardwareErrorCode.BlePeerRemovedPairingInformation,
+    });
+  });
+});
+
+describe('IosPeerTerminationTracker', () => {
+  beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['performance'] });
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  const dropLink = (tracker: IosPeerTerminationTracker, linkAgeMs = 0) => {
+    tracker.attemptStarted(UUID);
+    tracker.linkStarted(UUID);
+    jest.setSystemTime(Date.now() + linkAgeMs);
+    tracker.note(UUID, peerEndedLink());
+    return tracker.attemptFailed(UUID);
+  };
+
+  test('ignores a drop on a link that was reused or had been up for a while', () => {
+    const tracker = new IosPeerTerminationTracker();
+    expect(dropLink(tracker)).toBe(false);
+
+    tracker.attemptStarted(UUID);
+    tracker.note(UUID, peerEndedLink());
+    expect(tracker.attemptFailed(UUID)).toBe(false);
+
+    expect(dropLink(tracker)).toBe(false);
+    expect(dropLink(tracker, IOS_PEER_TERMINATION_LINK_WINDOW_MS + 1)).toBe(false);
+  });
+
+  test('ignores errors that do not say the peer ended the link', () => {
+    const tracker = new IosPeerTerminationTracker();
+    expect(dropLink(tracker)).toBe(false);
+
+    tracker.attemptStarted(UUID);
+    tracker.linkStarted(UUID);
+    tracker.note(UUID, linkTimedOut());
+    tracker.note(UUID, { errorCode: 201 });
+    tracker.note(UUID, undefined);
+    expect(tracker.attemptFailed(UUID)).toBe(false);
+  });
+});

package/src/__tests__/protocolReprobe.test.ts

@@ -1,6 +1,3 @@
-import { Platform } from 'react-native';
-import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
-
 import ReactNativeBleTransport, { PROTOCOL_REPROBE_FALLBACK_ATTEMPTS } from '../index';
 import protocolV1Schema from './protocolV1SchemaFixture';
 
@@ -92,9 +89,7 @@ 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.toMatchObject({
-      errorCode: HardwareErrorCode.BleTimeoutError,
-    });
+    await expect(detect(transport)).rejects.toBeDefined();
 
     expect(probeV1).toHaveBeenCalledTimes(1);
     expect(probeV2).toHaveBeenCalledTimes(1);
@@ -159,113 +154,3 @@ describe('protocol re-probe after a known device goes away', () => {
     expect((known.transport as any).protocolReprobeFailures.get(UUID)).toBeUndefined();
   });
 });
-
-describe('iOS reset-device stale bond confirmation', () => {
-  afterEach(() => {
-    Object.assign(Platform, { OS: 'ios' });
-  });
-
-  test('promotes a probe disconnect followed by a silent reconnect to BleBondInvalid', async () => {
-    const transport = new ReactNativeBleTransport({});
-    transport.configure(protocolV1Schema);
-    (transport as any).callProtocolV1 = jest
-      .fn()
-      .mockRejectedValue(ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded));
-
-    await expect(detect(transport)).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleDeviceNotBonded,
-    });
-
-    (transport as any).probeProtocolV1 = jest.fn(() => Promise.resolve(false));
-    (transport as any).probeProtocolV2 = jest.fn(() => Promise.resolve(false));
-    (transport as any).resetProbeStateAfterProtocolProbe = jest.fn(() => Promise.resolve());
-
-    await expect(detect(transport)).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleBondInvalid,
-    });
-    await expect(detect(transport)).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleBondInvalid,
-    });
-    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(true);
-  });
-
-  test('promotes a repeated iOS probe disconnect without waiting for probe timeouts', () => {
-    const { transport } = createHarness({ v1: false, v2: false });
-    const firstError = Object.assign(new Error('The specified device has disconnected from us'), {
-      errorCode: 201,
-      iosErrorCode: 7,
-    });
-    const secondError = ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
-
-    expect(
-      (transport as any).rememberIosProbeDisconnect(UUID, 'protocol-v1-get-features', firstError)
-    ).toBeUndefined();
-    expect(
-      (transport as any).rememberIosProbeDisconnect(UUID, 'protocol-v2-ping', secondError)
-    ).toMatchObject({ errorCode: HardwareErrorCode.BleBondInvalid });
-    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(true);
-  });
-
-  test('clears the disconnect evidence after a valid protocol response', async () => {
-    const { transport } = createHarness({ v1: true, v2: false });
-    (transport as any).rememberIosProbeDisconnect(
-      UUID,
-      'protocol-v1-get-features',
-      ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded)
-    );
-
-    await expect(detect(transport)).resolves.toBe('V1');
-    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(false);
-  });
-
-  test('preserves evidence across disconnect and stalled setup cleanup', async () => {
-    const { transport } = createHarness({ v1: false, v2: false });
-    (transport as any).rememberIosProbeDisconnect(
-      UUID,
-      'protocol-v1-get-features',
-      ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded)
-    );
-
-    await (transport as any).disconnectUnlocked(UUID);
-    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(true);
-
-    (transport as any).abandonStalledConnection(UUID, 'connect-native');
-    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(true);
-
-    await expect(detect(transport)).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleBondInvalid,
-    });
-  });
-
-  test('expires old disconnect evidence before classifying a later timeout', async () => {
-    const { transport } = createHarness({ v1: false, v2: false });
-    (transport as any).rememberIosProbeDisconnect(
-      UUID,
-      'protocol-v1-get-features',
-      ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded)
-    );
-    const evidence = (transport as any).iosProbeDisconnectEvidence.get(UUID);
-    evidence.recordedAt = Date.now() - 5 * 60_000 - 1;
-
-    await expect(detect(transport)).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleTimeoutError,
-    });
-    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(false);
-  });
-
-  test('does not classify the same sequence as a stale bond on Android', async () => {
-    Object.assign(Platform, { OS: 'android' });
-    const { transport } = createHarness({ v1: false, v2: false });
-
-    expect(
-      (transport as any).rememberIosProbeDisconnect(
-        UUID,
-        'protocol-v1-get-features',
-        ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded)
-      )
-    ).toBeUndefined();
-    await expect(detect(transport)).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.BleTimeoutError,
-    });
-  });
-});

package/src/bleIosStaleBond.ts

@@ -0,0 +1,92 @@
+/**
+ * iOS reports a bond the device no longer holds as CBErrorPeerRemovedPairingInformation, but not
+ * on every iPhone. On the iPhone 17 family the device ends the link about a second after
+ * connecting instead (its firmware drops a link on the second key failure), and the app only sees
+ * CBErrorPeripheralDisconnected on whatever operation was in flight. The disconnect event carries
+ * no reason on iOS, so that error is the only place the code appears.
+ *
+ * A device that powers off or reboots right after connecting ends one link the same way, so a
+ * single drop proves nothing. iOS never re-pairs on its own, which makes a stale bond end every
+ * new link like that: two acquire attempts in a row, each dropped by the peer on a link it had
+ * just opened and before any response, is what this classifies as a stale bond.
+ */
+
+/** CBError.peripheralDisconnected: the peer ended the link. A link timeout is a different code. */
+const IOS_PERIPHERAL_DISCONNECTED = 7;
+
+/** The device drops a stale bond about a second after connecting; later drops mean something else. */
+export const IOS_PEER_TERMINATION_LINK_WINDOW_MS = 10_000;
+/** How long one dropped link stays usable as evidence for the next attempt. */
+export const IOS_PEER_TERMINATION_REPEAT_WINDOW_MS = 60_000;
+
+export const isIosPeerTerminationError = (error: unknown): boolean =>
+  (error as { iosErrorCode?: unknown } | null | undefined)?.iosErrorCode ===
+  IOS_PERIPHERAL_DISCONNECTED;
+
+export class IosPeerTerminationTracker {
+  /** When the current acquire attempt opened its link; unset when it reuses an older one. */
+  private linkStartedAt = new Map<string, number>();
+
+  /** When the peer ended the current attempt's link. */
+  private terminatedAt = new Map<string, number>();
+
+  /** When the previous attempt ended that way. */
+  private evidenceAt = new Map<string, number>();
+
+  attemptStarted(deviceId: string) {
+    this.linkStartedAt.delete(deviceId);
+    this.terminatedAt.delete(deviceId);
+  }
+
+  linkStarted(deviceId: string) {
+    this.linkStartedAt.set(deviceId, Date.now());
+    this.terminatedAt.delete(deviceId);
+  }
+
+  /** Reads the native error of a failed operation before it is mapped to a typed one. */
+  note(deviceId: string, error: unknown) {
+    if (!isIosPeerTerminationError(error)) return;
+    if (!this.terminatedAt.has(deviceId)) this.terminatedAt.set(deviceId, Date.now());
+  }
+
+  /** The device answered on this link, so its bond is valid. */
+  linkProven(deviceId: string) {
+    this.forget(deviceId);
+  }
+
+  forget(deviceId: string) {
+    this.linkStartedAt.delete(deviceId);
+    this.terminatedAt.delete(deviceId);
+    this.evidenceAt.delete(deviceId);
+  }
+
+  /** Returns true when this failed attempt is the second in a row the peer ended on a new link. */
+  attemptFailed(deviceId: string): boolean {
+    const startedAt = this.linkStartedAt.get(deviceId);
+    const terminatedAt = this.terminatedAt.get(deviceId);
+    const previous = this.evidenceAt.get(deviceId);
+    this.forget(deviceId);
+
+    if (
+      startedAt === undefined ||
+      terminatedAt === undefined ||
+      terminatedAt - startedAt > IOS_PEER_TERMINATION_LINK_WINDOW_MS
+    ) {
+      return false;
+    }
+    if (
+      previous !== undefined &&
+      terminatedAt - previous <= IOS_PEER_TERMINATION_REPEAT_WINDOW_MS
+    ) {
+      return true;
+    }
+    this.evidenceAt.set(deviceId, terminatedAt);
+    return false;
+  }
+
+  reset() {
+    this.linkStartedAt.clear();
+    this.terminatedAt.clear();
+    this.evidenceAt.clear();
+  }
+}