@onekeyfe/hd-transport-react-native 1.2.3-alpha.10 → 1.2.3-alpha.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.3-alpha.10",
+  "version": "1.2.3-alpha.11",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
   "main": "dist/index.js",
@@ -20,11 +20,11 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.3-alpha.10",
-    "@onekeyfe/hd-shared": "1.2.3-alpha.10",
-    "@onekeyfe/hd-transport": "1.2.3-alpha.10",
-    "@onekeyfe/react-native-ble-utils": "0.1.9",
+    "@onekeyfe/hd-core": "1.2.3-alpha.11",
+    "@onekeyfe/hd-shared": "1.2.3-alpha.11",
+    "@onekeyfe/hd-transport": "1.2.3-alpha.11",
+    "@onekeyfe/react-native-ble-utils": "0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "2295285a846281941c21955684281446f587d993"
+  "gitHead": "b4254228fd77d7263e059e5f2a2fe0e1f8ea8060"
 }

package/src/BleManager.ts

@@ -1,7 +1,6 @@
 import BleUtils from '@onekeyfe/react-native-ble-utils';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
-import { onBleKeyMissing, startBleKeyMissingTracking } from './bleKeyMissing';
 import { bleLogger } from './logger';
 
 import type { Peripheral } from '@onekeyfe/react-native-ble-utils';
@@ -33,71 +32,20 @@ export const getBondedDevices = () => BleUtils.getBondedPeripherals();
 
 export const pairDevice = (macAddress: string) => BleUtils.pairDevice(macAddress);
 
-/**
- * Android replaces a bond as BONDING -> NONE, then NONE -> BONDING within milliseconds.
- * The window covers slow broadcast delivery before the first half counts as a failure.
- */
-export const SYSTEM_BONDING_RESTART_WINDOW_MS = 1500;
-
-export type DeviceBondStateOptions = {
-  /**
-   * The system, not this transport, started the bonding in progress. Android 16+ re-pairs
-   * by itself after it detects a lost bond, and a successful re-pair replaces the old bond
-   * instead of going straight to BONDED.
-   */
-  systemInitiated?: boolean;
-};
-
-const createBondFailureError = (bondState: Peripheral['bondState']) => {
-  const nativeReason =
-    'reason' in bondState && typeof bondState.reason === 'number' ? bondState.reason : undefined;
-  const reason =
-    nativeReason === undefined ? 'unknown' : bondFailureReasons[nativeReason] ?? 'unknown';
-  const params = {
-    phase: 'bond',
-    reason,
-    ...(nativeReason === undefined ? {} : { nativeReason }),
-  };
-  if (reason === 'timeout') {
-    // Connection timeouts are retried by Core; pairing requires a new user attempt.
-    return ERRORS.TypedError(
-      HardwareErrorCode.BleDeviceNotBonded,
-      'Bluetooth pairing timed out',
-      params
-    );
-  }
-  if (reason === 'canceled') {
-    return ERRORS.TypedError(
-      HardwareErrorCode.BleDeviceBondedCanceled,
-      'Bluetooth pairing canceled',
-      params
-    );
-  }
-  return ERRORS.TypedError(
-    HardwareErrorCode.BleDeviceNotBonded,
-    'Bluetooth pairing failed',
-    params
-  );
-};
-
 export const onDeviceBondState = (
   bleMacAddress: string,
-  signal?: AbortSignal,
-  options?: DeviceBondStateOptions
+  signal?: AbortSignal
 ): Promise<Peripheral | undefined> =>
   new Promise((resolve, reject) => {
     if (signal?.aborted) {
       reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected));
       return;
     }
-    let pendingFailure: ReturnType<typeof setTimeout> | undefined;
     const cleanup = () => {
       if (timeout) {
         clearTimeout(timeout);
       }
-      if (pendingFailure) clearTimeout(pendingFailure);
       if (cleanupListener) cleanupListener();
-      cleanupKeyMissing?.();
       signal?.removeEventListener('abort', onAbort);
     };
     const onAbort = () => {
@@ -117,20 +65,6 @@ export const onDeviceBondState = (
       );
     }, 60 * 1000);
 
-    // A failed system re-pair restores the old bond, so it also ends in BONDED. Key
-    // missing is what tells it apart from a bond that now works.
-    const cleanupKeyMissing = startBleKeyMissingTracking()
-      ? onBleKeyMissing(bleMacAddress, () => {
-          cleanup();
-          reject(
-            ERRORS.TypedError(HardwareErrorCode.BleBondInvalid, undefined, {
-              phase: 'bond',
-              reason: 'key_missing',
-            })
-          );
-        })
-      : undefined;
-
     const cleanupListener = BleUtils.onDeviceBondState(peripheral => {
       if (peripheral.id?.toLowerCase() !== bleMacAddress.toLowerCase()) {
         return;
@@ -139,23 +73,49 @@ export const onDeviceBondState = (
 
       const hasBonded = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_BONDED';
       const hasFailed = bondState.preState === 'BOND_BONDING' && bondState.state === 'BOND_NONE';
-      const hasRestarted = bondState.preState === 'BOND_NONE' && bondState.state === 'BOND_BONDING';
       Logger.debug('onDeviceBondState bondState:', bondState);
       if (hasBonded) {
         cleanup();
         resolve(peripheral);
-      } else if (hasRestarted && pendingFailure) {
-        clearTimeout(pendingFailure);
-        pendingFailure = undefined;
-      } else if (hasFailed && options?.systemInitiated) {
-        if (pendingFailure) clearTimeout(pendingFailure);
-        pendingFailure = setTimeout(() => {
-          cleanup();
-          reject(createBondFailureError(bondState));
-        }, SYSTEM_BONDING_RESTART_WINDOW_MS);
       } else if (hasFailed) {
         cleanup();
-        reject(createBondFailureError(bondState));
+        const nativeReason =
+          'reason' in bondState && typeof bondState.reason === 'number'
+            ? bondState.reason
+            : undefined;
+        const reason =
+          nativeReason === undefined ? 'unknown' : bondFailureReasons[nativeReason] ?? 'unknown';
+        const params = {
+          phase: 'bond',
+          reason,
+          ...(nativeReason === undefined ? {} : { nativeReason }),
+        };
+        if (reason === 'timeout') {
+          // Connection timeouts are retried by Core; pairing requires a new user attempt.
+          reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.BleDeviceNotBonded,
+              'Bluetooth pairing timed out',
+              params
+            )
+          );
+        } else if (reason === 'canceled') {
+          reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.BleDeviceBondedCanceled,
+              'Bluetooth pairing canceled',
+              params
+            )
+          );
+        } else {
+          reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.BleDeviceNotBonded,
+              'Bluetooth pairing failed',
+              params
+            )
+          );
+        }
       }
     });
   });

package/src/__tests__/enumerate.test.ts

@@ -25,21 +25,6 @@ jest.mock('../BleManager', () => ({
   pairDevice: jest.fn(),
 }));
 
-// The native facade is replaced wholesale above; key missing and link encryption are covered
-// by their own suites.
-jest.mock('../bleKeyMissing', () => ({
-  isBleKeyMissingSupported: jest.fn(() => false),
-  startBleKeyMissingTracking: jest.fn(() => false),
-  stopBleKeyMissingTracking: jest.fn(),
-  waitForBleKeyMissing: jest.fn(() => Promise.resolve(false)),
-}));
-jest.mock('../bleEncryption', () => ({
-  markBleLinkEncrypted: jest.fn(),
-  startBleEncryptionTracking: jest.fn(() => false),
-  stopBleEncryptionTracking: jest.fn(),
-  waitForAndroidLinkEncryption: jest.fn(() => Promise.resolve('unresolved')),
-}));
-
 jest.mock('../subscribeBleOn', () => ({
   subscribeBleOn: jest.fn(() => Promise.resolve()),
 }));

package/src/__tests__/protocolReprobe.test.ts

@@ -1,3 +1,6 @@
+import { Platform } from 'react-native';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import ReactNativeBleTransport, { PROTOCOL_REPROBE_FALLBACK_ATTEMPTS } from '../index';
 import protocolV1Schema from './protocolV1SchemaFixture';
 
@@ -89,7 +92,9 @@ 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();
+    await expect(detect(transport)).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleTimeoutError,
+    });
 
     expect(probeV1).toHaveBeenCalledTimes(1);
     expect(probeV2).toHaveBeenCalledTimes(1);
@@ -154,3 +159,90 @@ 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,
+    });
+  });
+
+  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 });
+  });
+
+  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 for acquire retry cleanup and clears it on an explicit disconnect', 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, {
+      preserveIosProbeDisconnect: true,
+    });
+    expect((transport as any).iosProbeDisconnectEvidence.has(UUID)).toBe(true);
+
+    await (transport as any).disconnectUnlocked(UUID);
+    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/__tests__/protocolV2Link.test.ts

@@ -45,21 +45,6 @@ jest.mock('../BleManager', () => ({
   pairDevice: jest.fn(() => Promise.resolve({ bonded: true, bonding: false })),
 }));
 
-// The native facade is replaced wholesale above; key missing and link encryption are covered
-// by their own suites.
-jest.mock('../bleKeyMissing', () => ({
-  isBleKeyMissingSupported: jest.fn(() => false),
-  startBleKeyMissingTracking: jest.fn(() => false),
-  stopBleKeyMissingTracking: jest.fn(),
-  waitForBleKeyMissing: jest.fn(() => Promise.resolve(false)),
-}));
-jest.mock('../bleEncryption', () => ({
-  markBleLinkEncrypted: jest.fn(),
-  startBleEncryptionTracking: jest.fn(() => false),
-  stopBleEncryptionTracking: jest.fn(),
-  waitForAndroidLinkEncryption: jest.fn(() => Promise.resolve('unresolved')),
-}));
-
 jest.mock('../subscribeBleOn', () => ({
   subscribeBleOn: jest.fn(() => Promise.resolve()),
 }));