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

package/dist/index.js

@@ -46,76 +46,6 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const lastKeyMissingAt = new Map();
-const listeners$1 = new Set();
-let unsubscribeNative$1;
-const normalizeDeviceId$1 = (deviceId) => deviceId.toLowerCase();
-const getCapableBleUtils$1 = () => {
-    if (reactNative.Platform.OS !== 'android')
-        return undefined;
-    const bleUtils = BleUtils__default["default"];
-    if (typeof bleUtils.supportsDeviceKeyMissing !== 'function' ||
-        typeof bleUtils.onDeviceKeyMissing !== 'function') {
-        return undefined;
-    }
-    return bleUtils.supportsDeviceKeyMissing() ? bleUtils : undefined;
-};
-const isBleKeyMissingSupported = () => getCapableBleUtils$1() !== undefined;
-const startBleKeyMissingTracking = () => {
-    if (unsubscribeNative$1)
-        return true;
-    const bleUtils = getCapableBleUtils$1();
-    if (!(bleUtils === null || bleUtils === void 0 ? void 0 : bleUtils.onDeviceKeyMissing))
-        return false;
-    unsubscribeNative$1 = bleUtils.onDeviceKeyMissing(event => {
-        if (typeof (event === null || event === void 0 ? void 0 : event.id) !== 'string')
-            return;
-        const deviceId = normalizeDeviceId$1(event.id);
-        lastKeyMissingAt.set(deviceId, Date.now());
-        listeners$1.forEach(listener => listener(deviceId));
-    });
-    return true;
-};
-const stopBleKeyMissingTracking = () => {
-    unsubscribeNative$1 === null || unsubscribeNative$1 === void 0 ? void 0 : unsubscribeNative$1();
-    unsubscribeNative$1 = undefined;
-    lastKeyMissingAt.clear();
-    listeners$1.clear();
-};
-const hasBleKeyMissingSince = (deviceId, sinceMs) => {
-    const at = lastKeyMissingAt.get(normalizeDeviceId$1(deviceId));
-    return at !== undefined && at >= sinceMs;
-};
-const onBleKeyMissing = (deviceId, callback) => {
-    const target = normalizeDeviceId$1(deviceId);
-    const listener = id => {
-        if (id === target)
-            callback();
-    };
-    listeners$1.add(listener);
-    return () => {
-        listeners$1.delete(listener);
-    };
-};
-const waitForBleKeyMissing = (deviceId, sinceMs, timeoutMs) => {
-    if (!startBleKeyMissingTracking())
-        return Promise.resolve(false);
-    if (hasBleKeyMissingSince(deviceId, sinceMs))
-        return Promise.resolve(true);
-    return new Promise(resolve => {
-        const settle = (found) => {
-            clearTimeout(timer);
-            cleanup();
-            resolve(found);
-        };
-        const cleanup = onBleKeyMissing(deviceId, () => {
-            if (hasBleKeyMissingSince(deviceId, sinceMs))
-                settle(true);
-        });
-        const timer = setTimeout(() => settle(false), timeoutMs);
-    });
-};
-
 let activeLogger;
 const setBleLogger = (logger) => {
     activeLogger = logger;
@@ -140,35 +70,17 @@ const bondFailureReasons = {
 };
 const getConnectedDeviceIds = (serviceUuids) => BleUtils__default["default"].getConnectedPeripherals(serviceUuids);
 const pairDevice = (macAddress) => BleUtils__default["default"].pairDevice(macAddress);
-const SYSTEM_BONDING_RESTART_WINDOW_MS = 1500;
-const createBondFailureError = (bondState) => {
-    var _a;
-    const nativeReason = 'reason' in bondState && typeof bondState.reason === 'number' ? bondState.reason : undefined;
-    const reason = nativeReason === undefined ? 'unknown' : (_a = bondFailureReasons[nativeReason]) !== null && _a !== void 0 ? _a : 'unknown';
-    const params = Object.assign({ phase: 'bond', reason }, (nativeReason === undefined ? {} : { nativeReason }));
-    if (reason === 'timeout') {
-        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out', params);
-    }
-    if (reason === 'canceled') {
-        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled, 'Bluetooth pairing canceled', params);
-    }
-    return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed', params);
-};
-const onDeviceBondState = (bleMacAddress, signal, options) => new Promise((resolve, reject) => {
+const onDeviceBondState = (bleMacAddress, signal) => new Promise((resolve, reject) => {
     if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
         reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
         return;
     }
-    let pendingFailure;
     const cleanup = () => {
         if (timeout) {
             clearTimeout(timeout);
         }
-        if (pendingFailure)
-            clearTimeout(pendingFailure);
         if (cleanupListener)
             cleanupListener();
-        cleanupKeyMissing === null || cleanupKeyMissing === void 0 ? void 0 : cleanupKeyMissing();
         signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
     };
     const onAbort = () => {
@@ -183,44 +95,35 @@ const onDeviceBondState = (bleMacAddress, signal, options) => new Promise((resol
             reason: 'timeout',
         }));
     }, 60 * 1000);
-    const cleanupKeyMissing = startBleKeyMissingTracking()
-        ? onBleKeyMissing(bleMacAddress, () => {
-            cleanup();
-            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid, undefined, {
-                phase: 'bond',
-                reason: 'key_missing',
-            }));
-        })
-        : undefined;
     const cleanupListener = BleUtils__default["default"].onDeviceBondState(peripheral => {
-        var _a;
+        var _a, _b;
         if (((_a = peripheral.id) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== bleMacAddress.toLowerCase()) {
             return;
         }
         const { bondState } = peripheral;
         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 === null || options === void 0 ? void 0 : 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' : (_b = bondFailureReasons[nativeReason]) !== null && _b !== void 0 ? _b : 'unknown';
+            const params = Object.assign({ phase: 'bond', reason }, (nativeReason === undefined ? {} : { nativeReason }));
+            if (reason === 'timeout') {
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out', params));
+            }
+            else if (reason === 'canceled') {
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondedCanceled, 'Bluetooth pairing canceled', params));
+            }
+            else {
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing failed', params));
+            }
         }
     });
 });
@@ -328,172 +231,6 @@ const subscribeBleOn = (bleManager, ms = 1000) => new Promise((resolve, reject)
     }, ms);
 });
 
-const HCI_PIN_OR_KEY_MISSING = 0x06;
-const lastEncryption = new Map();
-const lastAclDisconnectAt = new Map();
-const listeners = new Set();
-let unsubscribeNative;
-const normalizeDeviceId = (deviceId) => deviceId.toLowerCase();
-const isEncrypted = (record) => record.status === 0 && record.enabled;
-const getCapableBleUtils = () => {
-    if (reactNative.Platform.OS !== 'android')
-        return undefined;
-    const bleUtils = BleUtils__default["default"];
-    if (typeof bleUtils.supportsDeviceEncryptionChange !== 'function' ||
-        typeof bleUtils.onDeviceEncryptionChange !== 'function' ||
-        typeof bleUtils.onDeviceAclDisconnected !== 'function') {
-        return undefined;
-    }
-    return bleUtils.supportsDeviceEncryptionChange() ? bleUtils : undefined;
-};
-const notify = (deviceId) => {
-    listeners.forEach(listener => listener(deviceId));
-};
-const startBleEncryptionTracking = () => {
-    if (unsubscribeNative)
-        return true;
-    const bleUtils = getCapableBleUtils();
-    if (!(bleUtils === null || bleUtils === void 0 ? void 0 : bleUtils.onDeviceEncryptionChange) || !bleUtils.onDeviceAclDisconnected)
-        return false;
-    unsubscribeNative = [
-        bleUtils.onDeviceEncryptionChange(event => {
-            if (typeof (event === null || event === void 0 ? void 0 : event.id) !== 'string')
-                return;
-            const deviceId = normalizeDeviceId(event.id);
-            lastEncryption.set(deviceId, {
-                at: Date.now(),
-                status: Number(event.status),
-                enabled: event.enabled === true,
-            });
-            notify(deviceId);
-        }),
-        bleUtils.onDeviceAclDisconnected(event => {
-            if (typeof (event === null || event === void 0 ? void 0 : event.id) !== 'string')
-                return;
-            const deviceId = normalizeDeviceId(event.id);
-            lastAclDisconnectAt.set(deviceId, Date.now());
-            notify(deviceId);
-        }),
-    ];
-    return true;
-};
-const stopBleEncryptionTracking = () => {
-    unsubscribeNative === null || unsubscribeNative === void 0 ? void 0 : unsubscribeNative.forEach(unsubscribe => unsubscribe());
-    unsubscribeNative = undefined;
-    lastEncryption.clear();
-    lastAclDisconnectAt.clear();
-    listeners.clear();
-};
-const markBleLinkEncrypted = (deviceId) => {
-    if (!unsubscribeNative)
-        return;
-    lastEncryption.set(normalizeDeviceId(deviceId), { at: Date.now(), status: 0, enabled: true });
-};
-const waitForAndroidLinkEncryption = ({ deviceId, linkStartedAt, resultTimeoutMs, repairTimeoutMs, keyMissingGraceMs, signal, onRepairStarted, }) => {
-    if (!startBleEncryptionTracking())
-        return Promise.resolve('unresolved');
-    startBleKeyMissingTracking();
-    const target = normalizeDeviceId(deviceId);
-    const previous = lastEncryption.get(target);
-    const previousDropAt = lastAclDisconnectAt.get(target);
-    if (previous &&
-        previous.at < linkStartedAt &&
-        isEncrypted(previous) &&
-        (previousDropAt === undefined || previousDropAt < previous.at)) {
-        return Promise.resolve('already-encrypted');
-    }
-    return new Promise((resolve, reject) => {
-        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-            reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
-            return;
-        }
-        let repairStartedAt;
-        let droppedDuringRepair = false;
-        let timer;
-        let settled = false;
-        const cleanup = () => {
-            settled = true;
-            if (timer)
-                clearTimeout(timer);
-            listeners.delete(onLinkEvent);
-            cleanupKeyMissing();
-            signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
-        };
-        const finish = (result) => {
-            cleanup();
-            resolve(result);
-        };
-        const fail = (error) => {
-            cleanup();
-            reject(error);
-        };
-        const arm = (ms, onExpire) => {
-            if (timer)
-                clearTimeout(timer);
-            timer = setTimeout(onExpire, ms);
-        };
-        const bondInvalid = () => hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid, undefined, {
-            phase: 'connect',
-            reason: 'key_missing',
-        });
-        const evaluate = () => {
-            if (settled)
-                return;
-            const record = lastEncryption.get(target);
-            const dropAt = lastAclDisconnectAt.get(target);
-            if (repairStartedAt === undefined) {
-                if (hasBleKeyMissingSince(target, linkStartedAt)) {
-                    fail(bondInvalid());
-                    return;
-                }
-                if (dropAt !== undefined && dropAt >= linkStartedAt) {
-                    finish('unresolved');
-                    return;
-                }
-                if (!record || record.at < linkStartedAt)
-                    return;
-                if (isEncrypted(record)) {
-                    finish('encrypted');
-                    return;
-                }
-                if (record.status !== HCI_PIN_OR_KEY_MISSING) {
-                    finish('unresolved');
-                    return;
-                }
-                repairStartedAt = record.at;
-                onRepairStarted === null || onRepairStarted === void 0 ? void 0 : onRepairStarted();
-                arm(repairTimeoutMs, () => fail(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'Bluetooth pairing timed out', {
-                    phase: 'bond',
-                    reason: 'timeout',
-                })));
-                return;
-            }
-            if (hasBleKeyMissingSince(target, repairStartedAt)) {
-                fail(bondInvalid());
-                return;
-            }
-            if (record && record.at > repairStartedAt && isEncrypted(record)) {
-                finish('re-paired');
-                return;
-            }
-            if (!droppedDuringRepair && dropAt !== undefined && dropAt >= repairStartedAt) {
-                droppedDuringRepair = true;
-                arm(keyMissingGraceMs, () => fail(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected)));
-            }
-        };
-        const onLinkEvent = id => {
-            if (id === target)
-                evaluate();
-        };
-        const onAbort = () => fail(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected));
-        listeners.add(onLinkEvent);
-        const cleanupKeyMissing = onBleKeyMissing(target, evaluate);
-        signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
-        arm(resultTimeoutMs, () => finish('unresolved'));
-        evaluate();
-    });
-};
-
 const BLE_PLX_DEVICE_DISCONNECTED = 201;
 const IOS_PERIPHERAL_DISCONNECTED = 7;
 const nativeErrorText$1 = (error) => [error.reason, error.message]
@@ -649,17 +386,31 @@ const shouldRethrowProtocolProbeError = (error) => {
         code === hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure ||
         code === hdShared.HardwareErrorCode.BleWriteCharacteristicError);
 };
-const ANDROID_KEY_MISSING_LINK_WINDOW_MS = 10000;
-const ANDROID_KEY_MISSING_GRACE_MS = 500;
-const ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS = 1500;
-const ANDROID_SYSTEM_REPAIR_TIMEOUT_MS = 35000;
-const isAndroidLinkLossError = (error) => {
+const logIosBleBondDiagnostic = (phase, error, outcome) => {
+    if (reactNative.Platform.OS !== 'ios')
+        return;
+    const nativeError = (error !== null && error !== void 0 ? error : {});
+    const scalar = (value) => typeof value === 'string' || typeof value === 'number' ? value : undefined;
+    Log === null || Log === void 0 ? void 0 : 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: hdShared.isBleStaleBondHardwareError(error),
+        nativeDisconnect: isNativeBleDisconnectError(error),
+    });
+};
+const isIosProbeDisconnectError = (error) => {
+    if (reactNative.Platform.OS !== 'ios')
+        return false;
     const code = error === null || error === void 0 ? void 0 : error.errorCode;
     return (isNativeBleDisconnectError(error) ||
         code === hdShared.HardwareErrorCode.BleDeviceNotBonded ||
-        code === hdShared.HardwareErrorCode.BleDeviceDisconnected ||
-        code === hdShared.HardwareErrorCode.BleCharacteristicNotifyError ||
-        code === hdShared.HardwareErrorCode.BleConnectedError);
+        code === hdShared.HardwareErrorCode.BleDeviceDisconnected);
 };
 const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 const DEVICE_SCAN_TIMEOUT_MS = 3000;
@@ -856,9 +607,9 @@ class ReactNativeBleTransport {
         this.confirmedProtocolV2 = new Set();
         this.protocolReprobeFailures = new Map();
         this.silentDetections = new Map();
+        this.iosProbeDisconnectEvidence = new Map();
         this.androidGattCacheRefreshes = new Set();
         this.staleBondErrors = new Map();
-        this.androidLinkStartedAt = new Map();
         this.acquiringProtocolV2 = new Set();
         this.protocolV2Assemblers = new Map();
         this.protocolV2FrameQueues = new Map();
@@ -906,10 +657,6 @@ class ReactNativeBleTransport {
     init(logger, emitter) {
         setBleLogger(logger);
         this.emitter = emitter;
-        if (reactNative.Platform.OS === 'android') {
-            startBleKeyMissingTracking();
-            startBleEncryptionTracking();
-        }
     }
     configure(signedData) {
         const messages = parseConfigure(signedData);
@@ -1296,14 +1043,7 @@ class ReactNativeBleTransport {
             if (!uuid) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleRequiredUUID);
             }
-            return this.runLifecycleOperation(uuid, () => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    return yield this.acquireUnlocked(input);
-                }
-                catch (error) {
-                    throw yield this.resolveAndroidBondInvalid(uuid, error);
-                }
-            }));
+            return this.runLifecycleOperation(uuid, () => this.acquireUnlocked(input));
         });
     }
     acquireUnlocked(input) {
@@ -1358,7 +1098,6 @@ class ReactNativeBleTransport {
             }
             let device = null;
             const isAndroid = reactNative.Platform.OS === 'android';
-            let androidBondedBeforeConnect = false;
             const refreshAndroidGattCache = isAndroid && (!!skipProtocolProbe || this.androidGattCacheRefreshes.has(uuid));
             let nativeConnectOptions = connectOptions;
             if (isAndroid) {
@@ -1386,16 +1125,10 @@ class ReactNativeBleTransport {
             if (this.stopped)
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             if (reactNative.Platform.OS === 'android') {
-                startBleKeyMissingTracking();
-                startBleEncryptionTracking();
-                this.androidLinkStartedAt.delete(uuid);
                 try {
                     const bondState = yield pairDevice(uuid);
-                    androidBondedBeforeConnect = !bondState.bonding && bondState.bonded;
                     if (bondState.bonding) {
-                        yield onDeviceBondState(uuid, this.bondAbortController.signal, {
-                            systemInitiated: bondState.initiated === false,
-                        });
+                        yield onDeviceBondState(uuid, this.bondAbortController.signal);
                     }
                     else if (!bondState.bonded) {
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
@@ -1407,7 +1140,6 @@ class ReactNativeBleTransport {
                     }));
                     throw error;
                 }
-                this.androidLinkStartedAt.set(uuid, Date.now());
             }
             if (this.stopped)
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
@@ -1565,13 +1297,7 @@ class ReactNativeBleTransport {
             if (shouldMapProtocolV2StaleBond) {
                 this.acquiringProtocolV2.add(uuid);
             }
-            let linkEncryption;
             try {
-                if (androidBondedBeforeConnect && !skipProtocolProbe) {
-                    linkEncryption = yield this.waitForAndroidLinkSecurity(uuid);
-                    if (this.stopped)
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
-                }
                 yield this.installTransportForAcquire(uuid, acquiredDevice, {
                     writeCharacteristic,
                     notifyCharacteristic,
@@ -1610,13 +1336,12 @@ class ReactNativeBleTransport {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound);
                 }
                 this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
-                if (linkEncryption === 'unresolved') {
-                    markBleLinkEncrypted(uuid);
-                }
                 return { uuid, protocolType };
             }
             catch (error) {
-                yield this.disconnectUnlocked(uuid);
+                yield this.disconnectUnlocked(uuid, {
+                    preserveIosProbeDisconnect: this.iosProbeDisconnectEvidence.has(uuid),
+                });
                 throw error;
             }
             finally {
@@ -1814,64 +1539,14 @@ class ReactNativeBleTransport {
             if (!protocol) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol has not been detected for ${uuid}`);
             }
+            if (protocol === 'V2') {
+                return this.callProtocolV2(uuid, name, data, options);
+            }
             const forceRun = name === 'Initialize' || name === 'Cancel';
-            if (protocol !== 'V2' && this.runPromise && !forceRun) {
+            if (this.runPromise && !forceRun) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
             }
-            try {
-                return protocol === 'V2'
-                    ? yield this.callProtocolV2(uuid, name, data, options)
-                    : yield this.callProtocolV1(uuid, name, data, options);
-            }
-            catch (error) {
-                throw yield this.resolveAndroidBondInvalid(uuid, error);
-            }
-        });
-    }
-    resolveAndroidBondInvalid(uuid, error) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (reactNative.Platform.OS !== 'android' || !isBleKeyMissingSupported())
-                return error;
-            if (hdShared.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 (!(yield waitForBleKeyMissing(uuid, linkStartedAt, ANDROID_KEY_MISSING_GRACE_MS))) {
-                return error;
-            }
-            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android key missing, bond is invalid:', uuid);
-            return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid, undefined, {
-                phase: 'connect',
-                reason: 'key_missing',
-            });
-        });
-    }
-    waitForAndroidLinkSecurity(uuid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const linkStartedAt = this.androidLinkStartedAt.get(uuid);
-            if (linkStartedAt === undefined)
-                return 'unresolved';
-            const waitStartedAt = Date.now();
-            const result = yield 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 === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android bond lost, waiting for system re-pairing:', uuid);
-                },
-            });
-            Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] Android link encryption', {
-                connectIdSuffix: uuid.slice(-8),
-                result,
-                waitedMs: Date.now() - waitStartedAt,
-            });
-            return result;
+            return this.callProtocolV1(uuid, name, data, options);
         });
     }
     callProtocolV1(uuid, name, data, options) {
@@ -2087,9 +1762,7 @@ class ReactNativeBleTransport {
         this.androidPriorityResetTimers.forEach(timeout => clearTimeout(timeout));
         this.androidPriorityResetTimers.clear();
         this.androidHighPriorityDevices.clear();
-        this.androidLinkStartedAt.clear();
-        stopBleKeyMissingTracking();
-        stopBleEncryptionTracking();
+        this.iosProbeDisconnectEvidence.clear();
         const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
         (_a = this.runPromise) === null || _a === void 0 ? void 0 : _a.reject(error);
         this.runPromise = null;
@@ -2118,7 +1791,7 @@ class ReactNativeBleTransport {
             return this.runLifecycleOperation(session, () => this.disconnectUnlocked(session));
         });
     }
-    disconnectUnlocked(session) {
+    disconnectUnlocked(session, options) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             yield this.protocolV2Links.invalidateLink(session, 'React Native BLE transport disconnected');
@@ -2154,6 +1827,9 @@ class ReactNativeBleTransport {
             this.deviceProtocolHints.delete(session);
             this.sessionProtocols.delete(session);
             this.protocolReprobeFailures.delete(session);
+            if (!(options === null || options === void 0 ? void 0 : options.preserveIosProbeDisconnect)) {
+                this.iosProbeDisconnectEvidence.delete(session);
+            }
             this.protocolV2Assemblers.delete(session);
             this.resetProtocolV2Frames(session);
             try {
@@ -2429,6 +2105,7 @@ 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);
@@ -2500,6 +2177,7 @@ 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);
@@ -2546,6 +2224,7 @@ class ReactNativeBleTransport {
         this.deviceProtocol.clear();
         this.probingProtocols.clear();
         this.staleBondErrors.clear();
+        this.iosProbeDisconnectEvidence.clear();
         this.acquiringProtocolV2.clear();
         this.sessionProtocols.clear();
         this.protocolReprobeFailures.clear();
@@ -2575,6 +2254,35 @@ class ReactNativeBleTransport {
     createProtocolDetectionError() {
         return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleTimeoutError, 'Unable to detect BLE protocol: device did not respond to Protocol V1 GetFeatures or Protocol V2 Ping');
     }
+    rememberIosProbeDisconnect(uuid, phase, error) {
+        if (!isIosProbeDisconnectError(error))
+            return undefined;
+        const previous = this.iosProbeDisconnectEvidence.get(uuid);
+        const errorCode = error === null || error === void 0 ? void 0 : error.errorCode;
+        const evidence = Object.assign({ phase }, (typeof errorCode === 'string' || typeof errorCode === 'number' ? { errorCode } : {}));
+        this.iosProbeDisconnectEvidence.set(uuid, evidence);
+        Log === null || Log === void 0 ? void 0 : 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');
+    }
+    consumeIosProbeDisconnect(uuid, confirmation) {
+        const evidence = this.iosProbeDisconnectEvidence.get(uuid);
+        if (!evidence)
+            return undefined;
+        this.iosProbeDisconnectEvidence.delete(uuid);
+        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport][BleBondDiagnostic] stale bond confirmed', {
+            confirmation,
+            triggerPhase: evidence.phase,
+            triggerErrorCode: evidence.errorCode,
+            finalErrorCode: hdShared.HardwareErrorCode.BleBondInvalid,
+        });
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid);
+    }
     clearProbeProtocol(uuid, protocol) {
         if (this.probingProtocols.get(uuid) === protocol) {
             this.probingProtocols.delete(uuid);
@@ -2588,9 +2296,10 @@ class ReactNativeBleTransport {
         return (_a = this.deviceProtocol.get(uuid)) !== null && _a !== void 0 ? _a : this.probingProtocols.get(uuid);
     }
     detectProtocol(uuid, expectedProtocol, protocolHint, rebuildTransport) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (expectedProtocol === 'V1') {
+                this.iosProbeDisconnectEvidence.delete(uuid);
                 this.deviceProtocol.set(uuid, 'V1');
                 Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol selected', {
                     deviceId: uuid,
@@ -2604,6 +2313,7 @@ class ReactNativeBleTransport {
             }
             if (expectedProtocol === 'V2') {
                 if (yield this.probeProtocolV2(uuid)) {
+                    this.iosProbeDisconnectEvidence.delete(uuid);
                     this.deviceProtocol.set(uuid, 'V2');
                     this.sessionProtocols.set(uuid, 'V2');
                     this.confirmedProtocolV2.add(uuid);
@@ -2614,6 +2324,19 @@ class ReactNativeBleTransport {
                     });
                     return 'V2';
                 }
+                const staleBondError = this.consumeIosProbeDisconnect(uuid, 'follow-up-no-response');
+                if (reactNative.Platform.OS === 'ios') {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport][BleBondDiagnostic] protocol detection ended', {
+                        outcome: 'expected-v2-no-response',
+                        expectedProtocol,
+                        protocolHint: protocolHint !== null && protocolHint !== void 0 ? protocolHint : 'none',
+                        finalErrorCode: staleBondError
+                            ? hdShared.HardwareErrorCode.BleBondInvalid
+                            : hdShared.HardwareErrorCode.RuntimeError,
+                    });
+                }
+                if (staleBondError)
+                    throw staleBondError;
                 throw this.createProtocolMismatchError(expectedProtocol);
             }
             const sessionProtocol = this.sessionProtocols.get(uuid);
@@ -2637,6 +2360,7 @@ class ReactNativeBleTransport {
                 }
                 const detected = protocol === 'V1' ? yield this.probeProtocolV1(uuid) : yield this.probeProtocolV2(uuid);
                 if (detected) {
+                    this.iosProbeDisconnectEvidence.delete(uuid);
                     this.deviceProtocol.set(uuid, protocol);
                     this.sessionProtocols.set(uuid, protocol);
                     if (protocol === 'V2') {
@@ -2662,6 +2386,26 @@ class ReactNativeBleTransport {
             }
             this.deviceProtocol.delete(uuid);
             this.probingProtocols.delete(uuid);
+            const staleBondError = this.consumeIosProbeDisconnect(uuid, 'follow-up-no-response');
+            if (reactNative.Platform.OS === 'ios') {
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport][BleBondDiagnostic] protocol detection ended', {
+                    outcome: 'all-probes-no-response',
+                    expectedProtocol: expectedProtocol !== null && expectedProtocol !== void 0 ? expectedProtocol : 'none',
+                    protocolHint: protocolHint !== null && protocolHint !== void 0 ? protocolHint : 'none',
+                    sessionProtocol: sessionProtocol !== null && sessionProtocol !== void 0 ? sessionProtocol : 'none',
+                    probeOrder: probeOrder.join(','),
+                    trustSessionProtocol,
+                    reprobeFailures,
+                    transportCached: Boolean(transportCache[uuid]),
+                    notifyActive: Boolean((_b = transportCache[uuid]) === null || _b === void 0 ? void 0 : _b.notifySubscription),
+                    staleBondRecorded: this.staleBondErrors.has(uuid),
+                    finalErrorCode: staleBondError
+                        ? hdShared.HardwareErrorCode.BleBondInvalid
+                        : hdShared.HardwareErrorCode.BleTimeoutError,
+                });
+            }
+            if (staleBondError)
+                throw staleBondError;
             throw this.createProtocolDetectionError();
         });
     }
@@ -2745,7 +2489,12 @@ class ReactNativeBleTransport {
             catch (error) {
                 this.clearProbeProtocol(uuid, 'V1');
                 Log === null || Log === void 0 ? void 0 : 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;
@@ -2761,18 +2510,28 @@ class ReactNativeBleTransport {
             this.probingProtocols.set(uuid, 'V2');
             (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
             this.throwIfStaleBondError(uuid);
-            const detected = yield transport.probeProtocolV2({
-                call: (name, data, options) => this.callProtocolV2(uuid, name, data, options),
-                timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
-                logger: Log,
-                logPrefix: 'ProtocolV2 RN-BLE',
-                onProbeFailed: () => {
-                    var _a;
-                    (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
-                    this.resetProtocolV2Frames(uuid);
-                },
-                shouldRethrow: shouldRethrowProtocolProbeError,
-            });
+            let detected;
+            try {
+                detected = yield transport.probeProtocolV2({
+                    call: (name, data, options) => this.callProtocolV2(uuid, name, data, options),
+                    timeoutMs: PROTOCOL_V2_PROBE_TIMEOUT_MS,
+                    logger: Log,
+                    logPrefix: 'ProtocolV2 RN-BLE',
+                    onProbeFailed: () => {
+                        var _a;
+                        (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.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');
             }
@@ -3123,12 +2882,8 @@ class ReactNativeBleTransport {
     }
 }
 
-exports.ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS = ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS;
-exports.ANDROID_KEY_MISSING_GRACE_MS = ANDROID_KEY_MISSING_GRACE_MS;
-exports.ANDROID_KEY_MISSING_LINK_WINDOW_MS = ANDROID_KEY_MISSING_LINK_WINDOW_MS;
 exports.ANDROID_LINK_DROP_QUIET_MS = ANDROID_LINK_DROP_QUIET_MS;
 exports.ANDROID_MTU_EXCHANGE_TIMEOUT_MS = ANDROID_MTU_EXCHANGE_TIMEOUT_MS;
-exports.ANDROID_SYSTEM_REPAIR_TIMEOUT_MS = ANDROID_SYSTEM_REPAIR_TIMEOUT_MS;
 exports.BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD = BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD;
 exports.BLE_CONNECT_TIMEOUT_MS = BLE_CONNECT_TIMEOUT_MS;
 exports.BLE_GATT_SETUP_TIMEOUT_MS = BLE_GATT_SETUP_TIMEOUT_MS;