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

package/src/index.ts

@@ -47,18 +47,6 @@ import {
   getInfosForServiceUuid,
   isSameBleUuid,
 } from './constants';
-import {
-  isBleKeyMissingSupported,
-  startBleKeyMissingTracking,
-  stopBleKeyMissingTracking,
-  waitForBleKeyMissing,
-} from './bleKeyMissing';
-import {
-  markBleLinkEncrypted,
-  startBleEncryptionTracking,
-  stopBleEncryptionTracking,
-  waitForAndroidLinkEncryption,
-} from './bleEncryption';
 import { isNativeBleDisconnectError, toBleDisconnectHardwareError } from './bleNativeDisconnect';
 import {
   isBleStaleBondHardwareError,
@@ -74,7 +62,6 @@ import type { Deferred } from '@onekeyfe/hd-shared';
 import type { Characteristic, Device, Subscription } from 'react-native-ble-plx';
 import type EventEmitter from 'events';
 import type { BleAcquireInput, TransportOptions } from './types';
-import type { AndroidLinkEncryption } from './bleEncryption';
 
 type FirmwareInstallBleAcquireInput = BleAcquireInput & {
   /**
@@ -201,36 +188,50 @@ const shouldRethrowProtocolProbeError = (error: unknown): boolean => {
     code === HardwareErrorCode.BleWriteCharacteristicError
   );
 };
-/**
- * Android reports a lost bond (ACTION_KEY_MISSING) while it encrypts a new link, so only
- * a failure this soon after the link started can be explained by it. Later disconnects,
- * such as a firmware-update reboot, must keep their own meaning.
- */
-export const ANDROID_KEY_MISSING_LINK_WINDOW_MS = 10_000;
-/** The broadcast and the GATT disconnect it explains travel separately; either can land first. */
-export const ANDROID_KEY_MISSING_GRACE_MS = 500;
-/**
- * Android reports a bonded link's first encryption result within about half a second of
- * connecting. Past this, the result is treated as unknown and the link is used as before.
- */
-export const ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS = 1500;
-/**
- * A system re-pairing needs the user to accept a pairing request and confirm the code on the
- * device. The Bluetooth stack gives up after 30s and then reports key missing.
- */
-export const ANDROID_SYSTEM_REPAIR_TIMEOUT_MS = 35_000;
-/**
- * How a link dropped by a device that refuses a stale bond reaches JS. A wedged write is
- * excluded: the system is still re-pairing then and has not reported key missing yet.
- */
-const isAndroidLinkLossError = (error: unknown): boolean => {
+
+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;
+};
+
+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 ||
-    code === HardwareErrorCode.BleCharacteristicNotifyError ||
-    code === HardwareErrorCode.BleConnectedError
+    code === HardwareErrorCode.BleDeviceDisconnected
   );
 };
 /** Consecutive wedged writes on one device before the BLE manager itself is recreated. */
@@ -575,6 +576,14 @@ 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>();
 
@@ -585,9 +594,6 @@ export default class ReactNativeBleTransport {
    */
   private staleBondErrors: Map<string, Error> = new Map();
 
-  /** When the current Android link attempt began; bounds which key-missing signals apply. */
-  private androidLinkStartedAt: Map<string, number> = new Map();
-
   /** Strict or previously confirmed V2 target while acquire installs notifications. */
   private acquiringProtocolV2 = new Set<string>();
 
@@ -652,11 +658,6 @@ export default class ReactNativeBleTransport {
   init(logger: any, emitter: EventEmitter) {
     setBleLogger(logger);
     this.emitter = emitter;
-    if (Platform.OS === 'android') {
-      // Link security events are only meaningful if they were observed since the link came up.
-      startBleKeyMissingTracking();
-      startBleEncryptionTracking();
-    }
   }
 
   configure(signedData: any) {
@@ -1108,13 +1109,7 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.BleRequiredUUID);
     }
 
-    return this.runLifecycleOperation(uuid, async () => {
-      try {
-        return await this.acquireUnlocked(input);
-      } catch (error) {
-        throw await this.resolveAndroidBondInvalid(uuid, error);
-      }
-    });
+    return this.runLifecycleOperation(uuid, () => this.acquireUnlocked(input));
   }
 
   private async acquireUnlocked(input: FirmwareInstallBleAcquireInput) {
@@ -1194,8 +1189,6 @@ export default class ReactNativeBleTransport {
 
     let device: Device | null = null;
     const isAndroid = Platform.OS === 'android';
-    // Only a bond that existed before this acquire can have been lost by the device.
-    let androidBondedBeforeConnect = false;
     // A firmware-install reconnect always refreshes: the new firmware may expose a different table.
     const refreshAndroidGattCache =
       isAndroid && (!!skipProtocolProbe || this.androidGattCacheRefreshes.has(uuid));
@@ -1227,19 +1220,11 @@ export default class ReactNativeBleTransport {
 
     if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
     if (Platform.OS === 'android') {
-      // Subscribe before the link exists: key missing is broadcast while Android encrypts it.
-      startBleKeyMissingTracking();
-      startBleEncryptionTracking();
-      // Failures before the new link starts must not be read against the previous link.
-      this.androidLinkStartedAt.delete(uuid);
       // Initiate bonding locally before GATT can trigger peripheral-initiated pairing.
       try {
         const bondState = await pairDevice(uuid);
-        androidBondedBeforeConnect = !bondState.bonding && bondState.bonded;
         if (bondState.bonding) {
-          await onDeviceBondState(uuid, this.bondAbortController.signal, {
-            systemInitiated: bondState.initiated === false,
-          });
+          await onDeviceBondState(uuid, this.bondAbortController.signal);
         } else if (!bondState.bonded) {
           throw ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
         }
@@ -1251,7 +1236,6 @@ export default class ReactNativeBleTransport {
         });
         throw error;
       }
-      this.androidLinkStartedAt.set(uuid, Date.now());
     }
     if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
 
@@ -1439,13 +1423,7 @@ export default class ReactNativeBleTransport {
       this.acquiringProtocolV2.add(uuid);
     }
 
-    let linkEncryption: AndroidLinkEncryption | undefined;
     try {
-      // A firmware-install reconnect keeps its existing sequence.
-      if (androidBondedBeforeConnect && !skipProtocolProbe) {
-        linkEncryption = await this.waitForAndroidLinkSecurity(uuid);
-        if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
-      }
       await this.installTransportForAcquire(uuid, acquiredDevice, {
         writeCharacteristic,
         notifyCharacteristic,
@@ -1497,16 +1475,13 @@ export default class ReactNativeBleTransport {
         throw ERRORS.TypedError(HardwareErrorCode.TransportNotFound);
       }
       this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
-      if (linkEncryption === 'unresolved') {
-        // Notifications and the probe only work on an encrypted link, so the next reuse of this
-        // link needs no result that was reported before tracking started.
-        markBleLinkEncrypted(uuid);
-      }
       return { uuid, protocolType };
     } catch (error) {
       // A failed acquire must retire the physical link before Core retries. Logical
       // release leaves GATT connected even when neither protocol receives a response.
-      await this.disconnectUnlocked(uuid);
+      await this.disconnectUnlocked(uuid, {
+        preserveIosProbeDisconnect: this.iosProbeDisconnectEvidence.has(uuid),
+      });
       throw error;
     } finally {
       this.acquiringProtocolV2.delete(uuid);
@@ -1770,77 +1745,16 @@ export default class ReactNativeBleTransport {
         `Device protocol has not been detected for ${uuid}`
       );
     }
-    const forceRun = name === 'Initialize' || name === 'Cancel';
-    if (protocol !== 'V2' && this.runPromise && !forceRun) {
-      throw ERRORS.TypedError(HardwareErrorCode.TransportCallInProgress);
-    }
-
-    try {
-      return protocol === 'V2'
-        ? await this.callProtocolV2(uuid, name, data, options)
-        : await this.callProtocolV1(uuid, name, data, options);
-    } catch (error) {
-      // An expected-V1 acquire skips the probe, so the first call is what meets the dropped link.
-      throw await this.resolveAndroidBondInvalid(uuid, error);
+    if (protocol === 'V2') {
+      return this.callProtocolV2(uuid, name, data, options);
     }
-  }
 
-  /**
-   * Android 16+ keeps a bond the device no longer holds keys for. The device drops the link
-   * and the only structured evidence is ACTION_KEY_MISSING, so a link loss right after
-   * connect is re-read as an invalid bond when that signal belongs to the same attempt.
-   */
-  private async resolveAndroidBondInvalid(uuid: string, error: unknown): Promise<unknown> {
-    if (Platform.OS !== 'android' || !isBleKeyMissingSupported()) return error;
-    if (isBleStaleBondHardwareError(error) || !isAndroidLinkLossError(error)) return error;
-    const linkStartedAt = this.androidLinkStartedAt.get(uuid);
-    if (
-      linkStartedAt === undefined ||
-      Date.now() - linkStartedAt > ANDROID_KEY_MISSING_LINK_WINDOW_MS
-    ) {
-      return error;
-    }
-    if (!(await waitForBleKeyMissing(uuid, linkStartedAt, ANDROID_KEY_MISSING_GRACE_MS))) {
-      return error;
+    const forceRun = name === 'Initialize' || name === 'Cancel';
+    if (this.runPromise && !forceRun) {
+      throw ERRORS.TypedError(HardwareErrorCode.TransportCallInProgress);
     }
-    Log?.debug('[ReactNativeBleTransport] Android key missing, bond is invalid:', uuid);
-    return ERRORS.TypedError(HardwareErrorCode.BleBondInvalid, undefined, {
-      phase: 'connect',
-      reason: 'key_missing',
-    });
-  }
 
-  /**
-   * 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
-   * encrypts again with the same stale key; firmware that allows one failure per link then drops
-   * it before the system can re-pair. Holding GATT until the result lets a lost bond be re-paired
-   * in place. Without the platform signal this resolves immediately.
-   */
-  private async waitForAndroidLinkSecurity(uuid: string): Promise<AndroidLinkEncryption> {
-    const linkStartedAt = this.androidLinkStartedAt.get(uuid);
-    if (linkStartedAt === undefined) return 'unresolved';
-    const waitStartedAt = Date.now();
-    const result = await waitForAndroidLinkEncryption({
-      deviceId: uuid,
-      linkStartedAt,
-      resultTimeoutMs: ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS,
-      repairTimeoutMs: ANDROID_SYSTEM_REPAIR_TIMEOUT_MS,
-      keyMissingGraceMs: ANDROID_KEY_MISSING_GRACE_MS,
-      signal: this.bondAbortController.signal,
-      onRepairStarted: () => {
-        Log?.debug(
-          '[ReactNativeBleTransport] Android bond lost, waiting for system re-pairing:',
-          uuid
-        );
-      },
-    });
-    Log?.debug('[ReactNativeBleTransport] Android link encryption', {
-      connectIdSuffix: uuid.slice(-8),
-      result,
-      waitedMs: Date.now() - waitStartedAt,
-    });
-    return result;
+    return this.callProtocolV1(uuid, name, data, options);
   }
 
   private async callProtocolV1(
@@ -2108,9 +2022,7 @@ export default class ReactNativeBleTransport {
     this.androidPriorityResetTimers.forEach(timeout => clearTimeout(timeout));
     this.androidPriorityResetTimers.clear();
     this.androidHighPriorityDevices.clear();
-    this.androidLinkStartedAt.clear();
-    stopBleKeyMissingTracking();
-    stopBleEncryptionTracking();
+    this.iosProbeDisconnectEvidence.clear();
     const error = ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
     this.runPromise?.reject(error);
     this.runPromise = null;
@@ -2146,7 +2058,10 @@ export default class ReactNativeBleTransport {
     return this.runLifecycleOperation(session, () => this.disconnectUnlocked(session));
   }
 
-  private async disconnectUnlocked(session: string) {
+  private async disconnectUnlocked(
+    session: string,
+    options?: { preserveIosProbeDisconnect?: boolean }
+  ) {
     await this.protocolV2Links.invalidateLink(session, 'React Native BLE transport disconnected');
     const transport = transportCache[session];
     const manager = this.blePlxManager;
@@ -2188,6 +2103,9 @@ export default class ReactNativeBleTransport {
     this.deviceProtocolHints.delete(session);
     this.sessionProtocols.delete(session);
     this.protocolReprobeFailures.delete(session);
+    if (!options?.preserveIosProbeDisconnect) {
+      this.iosProbeDisconnectEvidence.delete(session);
+    }
     this.protocolV2Assemblers.delete(session);
     this.resetProtocolV2Frames(session);
 
@@ -2536,6 +2454,7 @@ export default class ReactNativeBleTransport {
     this.deviceProtocol.delete(uuid);
     this.probingProtocols.delete(uuid);
     this.staleBondErrors.delete(uuid);
+    this.iosProbeDisconnectEvidence.delete(uuid);
     this.acquiringProtocolV2.delete(uuid);
     this.protocolV2Assemblers.delete(uuid);
     this.resetProtocolV2Frames(uuid);
@@ -2634,6 +2553,7 @@ export default class ReactNativeBleTransport {
     this.deviceProtocol.delete(uuid);
     this.probingProtocols.delete(uuid);
     this.staleBondErrors.delete(uuid);
+    this.iosProbeDisconnectEvidence.delete(uuid);
     this.acquiringProtocolV2.delete(uuid);
     this.protocolV2Assemblers.delete(uuid);
     this.resetProtocolV2Frames(uuid);
@@ -2687,6 +2607,7 @@ export default class ReactNativeBleTransport {
     this.deviceProtocol.clear();
     this.probingProtocols.clear();
     this.staleBondErrors.clear();
+    this.iosProbeDisconnectEvidence.clear();
     this.acquiringProtocolV2.clear();
     this.sessionProtocols.clear();
     // Keep transport-lifetime V2 proof so the same endpoint can finish a no-probe
@@ -2730,6 +2651,47 @@ export default class ReactNativeBleTransport {
     );
   }
 
+  private rememberIosProbeDisconnect(
+    uuid: string,
+    phase: IosProbeDisconnectEvidence['phase'],
+    error: unknown
+  ): Error | undefined {
+    if (!isIosProbeDisconnectError(error)) return undefined;
+
+    const previous = this.iosProbeDisconnectEvidence.get(uuid);
+    const errorCode = (error as { errorCode?: unknown })?.errorCode;
+    const evidence: IosProbeDisconnectEvidence = {
+      phase,
+      ...(typeof errorCode === 'string' || typeof errorCode === 'number' ? { errorCode } : {}),
+    };
+    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.consumeIosProbeDisconnect(uuid, 'repeated-probe-disconnect');
+  }
+
+  private consumeIosProbeDisconnect(
+    uuid: string,
+    confirmation: 'repeated-probe-disconnect' | 'follow-up-no-response'
+  ): Error | undefined {
+    const evidence = this.iosProbeDisconnectEvidence.get(uuid);
+    if (!evidence) return undefined;
+
+    this.iosProbeDisconnectEvidence.delete(uuid);
+    Log?.debug('[ReactNativeBleTransport][BleBondDiagnostic] stale bond confirmed', {
+      confirmation,
+      triggerPhase: evidence.phase,
+      triggerErrorCode: evidence.errorCode,
+      finalErrorCode: HardwareErrorCode.BleBondInvalid,
+    });
+    return ERRORS.TypedError(HardwareErrorCode.BleBondInvalid);
+  }
+
   private clearProbeProtocol(uuid: string, protocol: ProtocolType) {
     if (this.probingProtocols.get(uuid) === protocol) {
       this.probingProtocols.delete(uuid);
@@ -2761,6 +2723,7 @@ 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,
@@ -2776,6 +2739,7 @@ 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);
@@ -2786,6 +2750,18 @@ export default class ReactNativeBleTransport {
         });
         return 'V2';
       }
+      const staleBondError = this.consumeIosProbeDisconnect(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);
     }
 
@@ -2821,6 +2797,7 @@ 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') {
@@ -2850,6 +2827,25 @@ export default class ReactNativeBleTransport {
 
     this.deviceProtocol.delete(uuid);
     this.probingProtocols.delete(uuid);
+    const staleBondError = this.consumeIosProbeDisconnect(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.staleBondErrors.has(uuid),
+        finalErrorCode: staleBondError
+          ? HardwareErrorCode.BleBondInvalid
+          : HardwareErrorCode.BleTimeoutError,
+      });
+    }
+    if (staleBondError) throw staleBondError;
     throw this.createProtocolDetectionError();
   }
 
@@ -2948,7 +2944,19 @@ export default class ReactNativeBleTransport {
     } catch (error) {
       this.clearProbeProtocol(uuid, 'V1');
       Log?.debug('[ReactNativeBleTransport] Protocol V1 GetFeatures probe failed:', error);
-      if (shouldRethrowProtocolProbeError(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) {
         throw error;
       }
       return false;
@@ -2963,18 +2971,26 @@ export default class ReactNativeBleTransport {
     this.probingProtocols.set(uuid, 'V2');
     this.protocolV2Assemblers.get(uuid)?.reset();
     this.throwIfStaleBondError(uuid);
-    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,
-    });
+    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;
+    }
     if (!detected) {
       this.clearProbeProtocol(uuid, 'V2');
     } else {

package/dist/bleEncryption.d.ts

@@ -1,17 +0,0 @@
-export declare const HCI_PIN_OR_KEY_MISSING = 6;
-export type AndroidLinkEncryption = 'encrypted' | 'already-encrypted' | 're-paired' | 'unresolved';
-export declare const isBleEncryptionTrackingSupported: () => boolean;
-export declare const startBleEncryptionTracking: () => boolean;
-export declare const stopBleEncryptionTracking: () => void;
-export declare const markBleLinkEncrypted: (deviceId: string) => void;
-export type WaitForAndroidLinkEncryptionOptions = {
-    deviceId: string;
-    linkStartedAt: number;
-    resultTimeoutMs: number;
-    repairTimeoutMs: number;
-    keyMissingGraceMs: number;
-    signal?: AbortSignal;
-    onRepairStarted?: () => void;
-};
-export declare const waitForAndroidLinkEncryption: ({ deviceId, linkStartedAt, resultTimeoutMs, repairTimeoutMs, keyMissingGraceMs, signal, onRepairStarted, }: WaitForAndroidLinkEncryptionOptions) => Promise<AndroidLinkEncryption>;
-//# sourceMappingURL=bleEncryption.d.ts.map

package/dist/bleEncryption.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bleEncryption.d.ts","sourceRoot":"","sources":["../src/bleEncryption.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,sBAAsB,IAAO,CAAC;AAE3C,MAAM,MAAM,qBAAqB,GAE7B,WAAW,GAEX,mBAAmB,GAEnB,WAAW,GAEX,YAAY,CAAC;AA0CjB,eAAO,MAAM,gCAAgC,eAA2C,CAAC;AAGzF,eAAO,MAAM,0BAA0B,QAAO,OAwB7C,CAAC;AAEF,eAAO,MAAM,yBAAyB,YAMrC,CAAC;AAMF,eAAO,MAAM,oBAAoB,aAAc,MAAM,SAGpD,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAAG;IAChD,QAAQ,EAAE,MAAM,CAAC;IAEjB,aAAa,EAAE,MAAM,CAAC;IAEtB,eAAe,EAAE,MAAM,CAAC;IAExB,eAAe,EAAE,MAAM,CAAC;IAExB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC;AAOF,eAAO,MAAM,4BAA4B,+GAQtC,mCAAmC,KAAG,QAAQ,qBAAqB,CAuHrE,CAAC"}

package/dist/bleKeyMissing.d.ts

@@ -1,7 +0,0 @@
-export declare const isBleKeyMissingSupported: () => boolean;
-export declare const startBleKeyMissingTracking: () => boolean;
-export declare const stopBleKeyMissingTracking: () => void;
-export declare const hasBleKeyMissingSince: (deviceId: string, sinceMs: number) => boolean;
-export declare const onBleKeyMissing: (deviceId: string, callback: () => void) => (() => void);
-export declare const waitForBleKeyMissing: (deviceId: string, sinceMs: number, timeoutMs: number) => Promise<boolean>;
-//# sourceMappingURL=bleKeyMissing.d.ts.map

package/dist/bleKeyMissing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bleKeyMissing.d.ts","sourceRoot":"","sources":["../src/bleKeyMissing.ts"],"names":[],"mappings":"AAwCA,eAAO,MAAM,wBAAwB,eAA2C,CAAC;AAGjF,eAAO,MAAM,0BAA0B,QAAO,OAY7C,CAAC;AAEF,eAAO,MAAM,yBAAyB,YAKrC,CAAC;AAEF,eAAO,MAAM,qBAAqB,aAAc,MAAM,WAAW,MAAM,KAAG,OAGzE,CAAC;AAGF,eAAO,MAAM,eAAe,aAAc,MAAM,YAAY,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CASnF,CAAC;AAOF,eAAO,MAAM,oBAAoB,aACrB,MAAM,WACP,MAAM,aACJ,MAAM,KAChB,QAAQ,OAAO,CAejB,CAAC"}