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

package/src/index.ts

@@ -59,6 +59,7 @@ import {
   stopBleEncryptionTracking,
   waitForAndroidLinkEncryption,
 } from './bleEncryption';
+import { IosPeerTerminationTracker } from './bleIosStaleBond';
 import { isNativeBleDisconnectError, toBleDisconnectHardwareError } from './bleNativeDisconnect';
 import {
   isBleStaleBondHardwareError,
@@ -233,55 +234,6 @@ const isAndroidLinkLossError = (error: unknown): boolean => {
     code === HardwareErrorCode.BleConnectedError
   );
 };
-
-const logIosBleBondDiagnostic = (
-  phase: string,
-  error: unknown,
-  outcome: 'fallback' | 'rethrow'
-) => {
-  if (Platform.OS !== 'ios') return;
-
-  const nativeError = (error ?? {}) as {
-    name?: unknown;
-    errorCode?: unknown;
-    attErrorCode?: unknown;
-    iosErrorCode?: unknown;
-    androidErrorCode?: unknown;
-  };
-  const scalar = (value: unknown) =>
-    typeof value === 'string' || typeof value === 'number' ? value : undefined;
-
-  Log?.debug('[ReactNativeBleTransport][BleBondDiagnostic] probe error', {
-    phase,
-    outcome,
-    errorName: scalar(nativeError.name),
-    errorCode: scalar(nativeError.errorCode),
-    attErrorCode: scalar(nativeError.attErrorCode),
-    iosErrorCode: scalar(nativeError.iosErrorCode),
-    androidErrorCode: scalar(nativeError.androidErrorCode),
-    nativeStaleBond: isNativeBleStaleBondError(error),
-    hardwareStaleBond: isBleStaleBondHardwareError(error),
-    nativeDisconnect: isNativeBleDisconnectError(error),
-  });
-};
-
-type IosProbeDisconnectEvidence = {
-  phase: 'protocol-v1-get-features' | 'protocol-v2-ping';
-  errorCode?: string | number;
-  recordedAt: number;
-};
-
-const IOS_PROBE_DISCONNECT_EVIDENCE_TTL_MS = 5 * 60_000;
-
-const isIosProbeDisconnectError = (error: unknown): boolean => {
-  if (Platform.OS !== 'ios') return false;
-  const code = (error as { errorCode?: unknown })?.errorCode;
-  return (
-    isNativeBleDisconnectError(error) ||
-    code === HardwareErrorCode.BleDeviceNotBonded ||
-    code === HardwareErrorCode.BleDeviceDisconnected
-  );
-};
 /** Consecutive wedged writes on one device before the BLE manager itself is recreated. */
 export const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 const DEVICE_SCAN_TIMEOUT_MS = 3000;
@@ -624,14 +576,6 @@ export default class ReactNativeBleTransport {
   /** Endpoints whose last detection got no answer; 'woken' once their Initialize wake is spent. */
   private silentDetections = new Map<string, 'silent' | 'woken'>();
 
-  /**
-   * iOS can report a reset Pro2 as a generic peripheral disconnect instead of
-   * CBErrorPeerRemovedPairingInformation. Keep that first probe failure across
-   * the automatic cold reconnect and require a second failed probe before
-   * classifying the OS bond as invalid.
-   */
-  private iosProbeDisconnectEvidence = new Map<string, IosProbeDisconnectEvidence>();
-
   /** Android endpoints whose cached GATT table is suspect; the next connect refreshes it. */
   private androidGattCacheRefreshes = new Set<string>();
 
@@ -645,6 +589,9 @@ export default class ReactNativeBleTransport {
   /** When the current Android link attempt began; bounds which key-missing signals apply. */
   private androidLinkStartedAt: Map<string, number> = new Map();
 
+  /** iOS acquire attempts whose new link the peer ended; two in a row mean a stale bond. */
+  private iosPeerTermination = new IosPeerTerminationTracker();
+
   /** Strict or previously confirmed V2 target while acquire installs notifications. */
   private acquiringProtocolV2 = new Set<string>();
 
@@ -1169,7 +1116,7 @@ export default class ReactNativeBleTransport {
       try {
         return await this.acquireUnlocked(input);
       } catch (error) {
-        throw await this.resolveAndroidBondInvalid(uuid, error);
+        throw this.resolveIosBondInvalid(input, await this.resolveAndroidBondInvalid(uuid, error));
       }
     });
   }
@@ -1177,6 +1124,7 @@ export default class ReactNativeBleTransport {
   private async acquireUnlocked(input: FirmwareInstallBleAcquireInput) {
     if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
     const { uuid, forceCleanRunPromise, expectedProtocol, skipProtocolProbe } = input;
+    this.iosPeerTermination.attemptStarted(uuid);
     const shouldMapProtocolV2StaleBond = expectedProtocol
       ? expectedProtocol === 'V2'
       : this.confirmedProtocolV2.has(uuid);
@@ -1549,6 +1497,7 @@ export default class ReactNativeBleTransport {
         }
       );
       if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
+      this.iosPeerTermination.linkProven(uuid);
       const currentTransport = transportCache[uuid];
       if (!currentTransport) {
         throw ERRORS.TypedError(HardwareErrorCode.TransportNotFound);
@@ -1581,6 +1530,7 @@ export default class ReactNativeBleTransport {
     const subscription = characteristic.monitor((error, c) => {
       const isCurrentMonitor = this.monitorTokens.get(uuid) === monitorToken;
       if (error) {
+        if (isCurrentMonitor) this.noteIosLinkError(uuid, 'notify', error);
         Log?.debug(
           `error monitor ${characteristic.uuid}, deviceId: ${characteristic.deviceID}: ${
             error as unknown as string
@@ -1867,6 +1817,56 @@ export default class ReactNativeBleTransport {
     });
   }
 
+  /**
+   * iOS says why a link ended only on the operation it interrupted, so the native codes are read
+   * and logged here. Codes only: the reason text is localized and cannot be matched or searched.
+   */
+  private noteIosLinkError(uuid: string, stage: 'gatt-setup' | 'notify' | 'write', error: unknown) {
+    if (Platform.OS !== 'ios') return;
+    this.iosPeerTermination.note(uuid, error);
+    // Writes and notifications also fail for reasons that say nothing about the link.
+    if (stage !== 'gatt-setup' && !isNativeBleDisconnectError(error)) return;
+    const native = (error ?? {}) as {
+      errorCode?: unknown;
+      iosErrorCode?: unknown;
+      attErrorCode?: unknown;
+    };
+    const code = (value: unknown) =>
+      typeof value === 'number' || typeof value === 'string' ? value : undefined;
+    Log?.debug('[ReactNativeBleTransport] iOS operation failed', {
+      connectIdSuffix: uuid.slice(-8),
+      stage,
+      errorCode: code(native.errorCode),
+      iosErrorCode: code(native.iosErrorCode),
+      attErrorCode: code(native.attErrorCode),
+    });
+  }
+
+  /**
+   * iPhones that do not report a lost bond only show the device ending each new link. One such
+   * attempt keeps its error so Core retries; the second in a row is the stale bond.
+   */
+  private resolveIosBondInvalid(input: FirmwareInstallBleAcquireInput, error: unknown): unknown {
+    if (Platform.OS !== 'ios') return error;
+    const { uuid, skipProtocolProbe } = input;
+    // A firmware-install reconnect expects the device to come and go.
+    if (skipProtocolProbe || isBleStaleBondHardwareError(error)) {
+      this.iosPeerTermination.forget(uuid);
+      return error;
+    }
+    if (!this.iosPeerTermination.attemptFailed(uuid)) return error;
+    Log?.debug(
+      '[ReactNativeBleTransport] iOS peer ended two new links in a row, bond is invalid:',
+      {
+        connectIdSuffix: uuid.slice(-8),
+      }
+    );
+    return ERRORS.TypedError(HardwareErrorCode.BleBondInvalid, undefined, {
+      phase: 'connect',
+      reason: 'peer_disconnected',
+    });
+  }
+
   /**
    * Android 16+ encrypts a bonded link on its own right after connecting. Subscribing to
    * notifications before that finishes gets the CCCD write rejected, and the framework's retry
@@ -2166,9 +2166,9 @@ export default class ReactNativeBleTransport {
     this.androidPriorityResetTimers.clear();
     this.androidHighPriorityDevices.clear();
     this.androidLinkStartedAt.clear();
+    this.iosPeerTermination.reset();
     stopBleKeyMissingTracking();
     stopBleEncryptionTracking();
-    this.iosProbeDisconnectEvidence.clear();
     const error = ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
     this.runPromise?.reject(error);
     this.runPromise = null;
@@ -2484,6 +2484,7 @@ export default class ReactNativeBleTransport {
         }),
       ]);
       succeeded = true;
+      this.iosPeerTermination.linkStarted(uuid);
       return result;
     } catch (error) {
       if (timedOut || isNativeOperationTimeoutError(error)) {
@@ -2537,6 +2538,11 @@ export default class ReactNativeBleTransport {
       succeeded = true;
       return result;
     } catch (error) {
+      this.noteIosLinkError(uuid, 'gatt-setup', error);
+      if (Platform.OS === 'ios' && isNativeBleStaleBondError(error)) {
+        // iOS can report the lost bond on the first request instead of on the connect.
+        throw toBleStaleBondHardwareError(error);
+      }
       if (timedOut || isNativeOperationTimeoutError(error)) {
         const resetManager = this.abandonStalledConnection(
           uuid,
@@ -2654,6 +2660,7 @@ export default class ReactNativeBleTransport {
       ]);
       this.writeTimeoutCounts.delete(uuid);
     } catch (error) {
+      this.noteIosLinkError(uuid, 'write', error);
       if (timedOut) {
         // A superseded call's late write must not tear down the link the current
         // call is using; only the owner of the transport may declare it dead.
@@ -2788,64 +2795,6 @@ export default class ReactNativeBleTransport {
     );
   }
 
-  private rememberIosProbeDisconnect(
-    uuid: string,
-    phase: IosProbeDisconnectEvidence['phase'],
-    error: unknown
-  ): Error | undefined {
-    if (!isIosProbeDisconnectError(error)) return undefined;
-
-    const previous = this.getIosProbeDisconnectEvidence(uuid);
-    const errorCode = (error as { errorCode?: unknown })?.errorCode;
-    const evidence: IosProbeDisconnectEvidence = {
-      phase,
-      ...(typeof errorCode === 'string' || typeof errorCode === 'number' ? { errorCode } : {}),
-      recordedAt: Date.now(),
-    };
-    this.iosProbeDisconnectEvidence.set(uuid, evidence);
-    Log?.debug('[ReactNativeBleTransport][BleBondDiagnostic] probe disconnect recorded', {
-      phase,
-      errorCode: evidence.errorCode,
-      repeated: Boolean(previous),
-    });
-
-    if (!previous) return undefined;
-    return this.confirmIosProbeDisconnect(uuid, 'repeated-probe-disconnect');
-  }
-
-  private getIosProbeDisconnectEvidence(uuid: string): IosProbeDisconnectEvidence | undefined {
-    const evidence = this.iosProbeDisconnectEvidence.get(uuid);
-    if (!evidence) return undefined;
-
-    const ageMs = Date.now() - evidence.recordedAt;
-    if (ageMs <= IOS_PROBE_DISCONNECT_EVIDENCE_TTL_MS) return evidence;
-
-    this.iosProbeDisconnectEvidence.delete(uuid);
-    Log?.debug('[ReactNativeBleTransport][BleBondDiagnostic] probe disconnect expired', {
-      triggerPhase: evidence.phase,
-      triggerErrorCode: evidence.errorCode,
-      ageMs,
-    });
-    return undefined;
-  }
-
-  private confirmIosProbeDisconnect(
-    uuid: string,
-    confirmation: 'repeated-probe-disconnect' | 'follow-up-no-response'
-  ): Error | undefined {
-    const evidence = this.getIosProbeDisconnectEvidence(uuid);
-    if (!evidence) return undefined;
-
-    Log?.debug('[ReactNativeBleTransport][BleBondDiagnostic] stale bond confirmed', {
-      confirmation,
-      triggerPhase: evidence.phase,
-      triggerErrorCode: evidence.errorCode,
-      evidenceAgeMs: Date.now() - evidence.recordedAt,
-      finalErrorCode: HardwareErrorCode.BleBondInvalid,
-    });
-    return ERRORS.TypedError(HardwareErrorCode.BleBondInvalid);
-  }
-
   private clearProbeProtocol(uuid: string, protocol: ProtocolType) {
     if (this.probingProtocols.get(uuid) === protocol) {
       this.probingProtocols.delete(uuid);
@@ -2877,7 +2826,6 @@ export default class ReactNativeBleTransport {
     // received no response. skipProtocolProbe does not need it either — its only
     // caller is the V2 firmware-install reconnect.
     if (expectedProtocol === 'V1') {
-      this.iosProbeDisconnectEvidence.delete(uuid);
       this.deviceProtocol.set(uuid, 'V1');
       Log?.debug('[ReactNativeBleTransport] protocol selected', {
         deviceId: uuid,
@@ -2893,7 +2841,6 @@ export default class ReactNativeBleTransport {
 
     if (expectedProtocol === 'V2') {
       if (await this.probeProtocolV2(uuid)) {
-        this.iosProbeDisconnectEvidence.delete(uuid);
         this.deviceProtocol.set(uuid, 'V2');
         this.sessionProtocols.set(uuid, 'V2');
         this.confirmedProtocolV2.add(uuid);
@@ -2904,18 +2851,6 @@ export default class ReactNativeBleTransport {
         });
         return 'V2';
       }
-      const staleBondError = this.confirmIosProbeDisconnect(uuid, 'follow-up-no-response');
-      if (Platform.OS === 'ios') {
-        Log?.debug('[ReactNativeBleTransport][BleBondDiagnostic] protocol detection ended', {
-          outcome: 'expected-v2-no-response',
-          expectedProtocol,
-          protocolHint: protocolHint ?? 'none',
-          finalErrorCode: staleBondError
-            ? HardwareErrorCode.BleBondInvalid
-            : HardwareErrorCode.RuntimeError,
-        });
-      }
-      if (staleBondError) throw staleBondError;
       throw this.createProtocolMismatchError(expectedProtocol);
     }
 
@@ -2951,7 +2886,6 @@ export default class ReactNativeBleTransport {
       const detected =
         protocol === 'V1' ? await this.probeProtocolV1(uuid) : await this.probeProtocolV2(uuid);
       if (detected) {
-        this.iosProbeDisconnectEvidence.delete(uuid);
         this.deviceProtocol.set(uuid, protocol);
         this.sessionProtocols.set(uuid, protocol);
         if (protocol === 'V2') {
@@ -2981,25 +2915,6 @@ export default class ReactNativeBleTransport {
 
     this.deviceProtocol.delete(uuid);
     this.probingProtocols.delete(uuid);
-    const staleBondError = this.confirmIosProbeDisconnect(uuid, 'follow-up-no-response');
-    if (Platform.OS === 'ios') {
-      Log?.debug('[ReactNativeBleTransport][BleBondDiagnostic] protocol detection ended', {
-        outcome: 'all-probes-no-response',
-        expectedProtocol: expectedProtocol ?? 'none',
-        protocolHint: protocolHint ?? 'none',
-        sessionProtocol: sessionProtocol ?? 'none',
-        probeOrder: probeOrder.join(','),
-        trustSessionProtocol,
-        reprobeFailures,
-        transportCached: Boolean(transportCache[uuid]),
-        notifyActive: Boolean(transportCache[uuid]?.notifySubscription),
-        staleBondRecorded: this.iosProbeDisconnectEvidence.has(uuid),
-        finalErrorCode: staleBondError
-          ? HardwareErrorCode.BleBondInvalid
-          : HardwareErrorCode.BleTimeoutError,
-      });
-    }
-    if (staleBondError) throw staleBondError;
     throw this.createProtocolDetectionError();
   }
 
@@ -3098,19 +3013,7 @@ export default class ReactNativeBleTransport {
     } catch (error) {
       this.clearProbeProtocol(uuid, 'V1');
       Log?.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe failed:', error);
-      const shouldRethrow = shouldRethrowProtocolProbeError(error);
-      const staleBondError = this.rememberIosProbeDisconnect(
-        uuid,
-        'protocol-v1-get-features',
-        error
-      );
-      logIosBleBondDiagnostic(
-        'protocol-v1-get-features',
-        error,
-        shouldRethrow ? 'rethrow' : 'fallback'
-      );
-      if (staleBondError) throw staleBondError;
-      if (shouldRethrow) {
+      if (shouldRethrowProtocolProbeError(error)) {
         throw error;
       }
       return false;
@@ -3125,26 +3028,18 @@ export default class ReactNativeBleTransport {
     this.probingProtocols.set(uuid, 'V2');
     this.protocolV2Assemblers.get(uuid)?.reset();
     this.throwIfStaleBondError(uuid);
-    let detected: boolean;
-    try {
-      detected = await probeProtocolV2Helper({
-        call: (name: string, data: Record<string, unknown>, options?: TransportCallOptions) =>
-          this.callProtocolV2(uuid, name, data, options),
-        timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
-        logger: Log,
-        logPrefix: 'ProtocolV2 RN-BLE',
-        onProbeFailed: () => {
-          this.protocolV2Assemblers.get(uuid)?.reset();
-          this.resetProtocolV2Frames(uuid);
-        },
-        shouldRethrow: shouldRethrowProtocolProbeError,
-      });
-    } catch (error) {
-      const staleBondError = this.rememberIosProbeDisconnect(uuid, 'protocol-v2-ping', error);
-      logIosBleBondDiagnostic('protocol-v2-ping', error, 'rethrow');
-      if (staleBondError) throw staleBondError;
-      throw error;
-    }
+    const detected = await probeProtocolV2Helper({
+      call: (name: string, data: Record<string, unknown>, options?: TransportCallOptions) =>
+        this.callProtocolV2(uuid, name, data, options),
+      timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
+      logger: Log,
+      logPrefix: 'ProtocolV2 RN-BLE',
+      onProbeFailed: () => {
+        this.protocolV2Assemblers.get(uuid)?.reset();
+        this.resetProtocolV2Frames(uuid);
+      },
+      shouldRethrow: shouldRethrowProtocolProbeError,
+    });
     if (!detected) {
       this.clearProbeProtocol(uuid, 'V2');
     } else {