@onekeyfe/hd-transport-react-native 1.2.2-alpha.100 → 1.2.2-alpha.3

package/dist/bleStaleBond.d.ts

@@ -0,0 +1,5 @@
+import { isBleStaleBondHardwareError } from '@onekeyfe/hd-shared';
+export { isBleStaleBondHardwareError };
+export declare const isNativeBleStaleBondError: (error: unknown) => boolean;
+export declare const toBleStaleBondHardwareError: (error: unknown) => Error;
+//# sourceMappingURL=bleStaleBond.d.ts.map

package/dist/bleStaleBond.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bleStaleBond.d.ts","sourceRoot":"","sources":["../src/bleStaleBond.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,2BAA2B,EAC5B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,2BAA2B,EAAE,CAAC;AAkBvC,eAAO,MAAM,yBAAyB,UAAW,OAAO,KAAG,OAe1D,CAAC;AAEF,eAAO,MAAM,2BAA2B,UAAW,OAAO,UAkBzD,CAAC"}

package/dist/index.d.ts

@@ -38,6 +38,14 @@ type BleAcquireInput = {
     protocolHint?: ProtocolType;
 };
 
+type FirmwareInstallBleAcquireInput = BleAcquireInput & {
+    /**
+     * Reuse the already-verified protocol after an expected firmware-install
+     * disconnect. The install loader accepts status requests but may not answer
+     * the generic protocol probe used by a normal acquire.
+     */
+    skipProtocolProbe?: boolean;
+};
 type FirmwareUploadWriteRetryType = 'congested';
 type ResolvedBleCharacteristics = {
     writeCharacteristic: Characteristic;
@@ -126,6 +134,14 @@ declare class ReactNativeBleTransport {
     private confirmedProtocolV2;
     /** Consecutive detections that failed while trusting sessionProtocols. */
     private protocolReprobeFailures;
+    /**
+     * Native encryption/pairing failures seen before Protocol V2 probe starts.
+     * Pro2/Neo GATT connect can succeed on a stale iOS bond; the CCCD write then
+     * fails with ATT 5/15. Remember it so detectProtocol fails immediately.
+     */
+    private staleBondErrors;
+    /** Strict or previously confirmed V2 target while acquire installs notifications. */
+    private acquiringProtocolV2;
     private protocolV2Assemblers;
     private protocolV2FrameQueues;
     private protocolV2FramePromises;
@@ -155,7 +171,7 @@ declare class ReactNativeBleTransport {
      */
     enumerate(): Promise<IOneKeyDevice[]>;
     private installTransportForAcquire;
-    acquire(input: BleAcquireInput): Promise<{
+    acquire(input: FirmwareInstallBleAcquireInput): Promise<{
         uuid: string;
         protocolType: ProtocolType;
     }>;
@@ -216,6 +232,8 @@ declare class ReactNativeBleTransport {
     private resolveProtocolV2Frame;
     private resetProtocolV2Frames;
     private rejectProtocolV2Frames;
+    private rememberStaleBondError;
+    private throwIfStaleBondError;
     private readProtocolV2Frame;
     private writeProtocolV2Packet;
     private writeProtocolV2Frame;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -194,6 +194,38 @@ const subscribeBleOn = (bleManager, ms = 1000) => new Promise((resolve, reject)
     }, ms);
 });
 
+const ATT_INSUFFICIENT_AUTHENTICATION = 5;
+const ATT_INSUFFICIENT_ENCRYPTION = 15;
+const IOS_PEER_REMOVED_PAIRING_INFORMATION = 14;
+const nativeErrorText = (error) => [error.reason, error.message]
+    .filter((value) => typeof value === 'string')
+    .join(' ');
+const isNativeBleStaleBondError = (error) => {
+    if (!error || typeof error !== 'object') {
+        return typeof error === 'string' ? hdShared.isBleStaleBondErrorText(error) : false;
+    }
+    const nativeError = error;
+    if (nativeError.attErrorCode === ATT_INSUFFICIENT_AUTHENTICATION ||
+        nativeError.attErrorCode === ATT_INSUFFICIENT_ENCRYPTION ||
+        nativeError.iosErrorCode === IOS_PEER_REMOVED_PAIRING_INFORMATION) {
+        return true;
+    }
+    return hdShared.isBleStaleBondErrorText(nativeErrorText(nativeError));
+};
+const toBleStaleBondHardwareError = (error) => {
+    if (hdShared.isBleStaleBondHardwareError(error)) {
+        return error;
+    }
+    const nativeError = (error !== null && error !== void 0 ? error : {});
+    const text = nativeErrorText(nativeError);
+    const normalizedText = text.toLowerCase();
+    const peerRemoved = nativeError.iosErrorCode === IOS_PEER_REMOVED_PAIRING_INFORMATION ||
+        normalizedText.includes('peer removed pairing information');
+    return hdShared.ERRORS.TypedError(peerRemoved
+        ? hdShared.HardwareErrorCode.BlePeerRemovedPairingInformation
+        : hdShared.HardwareErrorCode.BleDeviceBondError, text || undefined);
+};
+
 const isHeaderChunk = (chunk) => {
     if (chunk.length < 9)
         return false;
@@ -372,12 +404,11 @@ const requestNegotiatedMtu = (device, stage, attempt) => __awaiter(void 0, void
     }
 });
 const resolveNegotiatedMtu = (device) => requestNegotiatedMtu(device, 'connected', 0);
-function remapError(error) {
+function remapError(error, mapProtocolV2StaleBond) {
     var _a;
     if (error instanceof reactNativeBlePlx.BleError) {
-        if (error.iosErrorCode === reactNativeBlePlx.BleATTErrorCode.UnlikelyError ||
-            error.reason === 'Peer removed pairing information') {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BlePeerRemovedPairingInformation);
+        if (mapProtocolV2StaleBond && isNativeBleStaleBondError(error)) {
+            throw toBleStaleBondHardwareError(error);
         }
         if ((error === null || error === void 0 ? void 0 : error.attErrorCode) === 22) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceBondError);
@@ -408,6 +439,8 @@ class ReactNativeBleTransport {
         this.sessionProtocols = new Map();
         this.confirmedProtocolV2 = new Set();
         this.protocolReprobeFailures = new Map();
+        this.staleBondErrors = new Map();
+        this.acquiringProtocolV2 = new Set();
         this.protocolV2Assemblers = new Map();
         this.protocolV2FrameQueues = new Map();
         this.protocolV2FramePromises = new Map();
@@ -802,19 +835,46 @@ class ReactNativeBleTransport {
     acquireUnlocked(input) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const { uuid, forceCleanRunPromise, expectedProtocol } = input;
+            const { uuid, forceCleanRunPromise, expectedProtocol, skipProtocolProbe } = input;
+            const shouldMapProtocolV2StaleBond = expectedProtocol
+                ? expectedProtocol === 'V2'
+                : this.confirmedProtocolV2.has(uuid);
             const cachedTransport = transportCache[uuid];
+            if (skipProtocolProbe && !cachedTransport && this.blePlxManager) {
+                Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] refresh uncached BLE connection for firmware install:', uuid);
+                const manager = this.blePlxManager;
+                yield this.runNativeTeardown(uuid, manager, () => __awaiter(this, void 0, void 0, function* () {
+                    yield this.runBestEffortNativeOperation('firmware install reconnect: cancel uncached device connection', () => manager.cancelDeviceConnection(uuid));
+                }));
+            }
             if (cachedTransport) {
-                const cachedProtocol = this.deviceProtocol.get(uuid);
-                const isCachedDeviceConnected = yield cachedTransport.device.isConnected().catch(() => false);
-                if (isCachedDeviceConnected &&
-                    cachedProtocol &&
-                    (!expectedProtocol || cachedProtocol === expectedProtocol)) {
-                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] reuse cached BLE transport:', uuid, cachedProtocol);
-                    return { uuid, protocolType: cachedProtocol };
+                if (skipProtocolProbe) {
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] refresh cached BLE connection for firmware install:', uuid);
+                    const manager = this.blePlxManager;
+                    yield this.releaseUnlocked(uuid, true);
+                    yield this.runNativeTeardown(uuid, manager, () => __awaiter(this, void 0, void 0, function* () {
+                        const operations = [];
+                        if (manager) {
+                            operations.push(this.runBestEffortNativeOperation('firmware install reconnect: cancel device connection', () => manager.cancelDeviceConnection(uuid)));
+                        }
+                        operations.push(this.runBestEffortNativeOperation('firmware install reconnect: device cancel connection', () => cachedTransport.device.cancelConnection()));
+                        yield Promise.all(operations);
+                    }));
+                }
+                else {
+                    const cachedProtocol = this.deviceProtocol.get(uuid);
+                    const isCachedDeviceConnected = yield cachedTransport.device
+                        .isConnected()
+                        .catch(() => false);
+                    if (isCachedDeviceConnected &&
+                        cachedProtocol &&
+                        (!expectedProtocol || cachedProtocol === expectedProtocol)) {
+                        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] reuse cached BLE transport:', uuid, cachedProtocol);
+                        return { uuid, protocolType: cachedProtocol };
+                    }
+                    Log === null || Log === void 0 ? void 0 : Log.debug('transport not reusable, will release: ', uuid);
+                    yield this.releaseUnlocked(uuid, true);
                 }
-                Log === null || Log === void 0 ? void 0 : Log.debug('transport not reusable, will release: ', uuid);
-                yield this.releaseUnlocked(uuid, true);
             }
             let device = null;
             if (forceCleanRunPromise && this.runPromise) {
@@ -871,7 +931,7 @@ class ReactNativeBleTransport {
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleAlreadyConnected);
                     }
                     else {
-                        remapError(e);
+                        remapError(e, shouldMapProtocolV2StaleBond);
                     }
                 }
             }
@@ -905,7 +965,7 @@ class ReactNativeBleTransport {
                         }
                     }
                     else {
-                        remapError(e);
+                        remapError(e, shouldMapProtocolV2StaleBond);
                     }
                 }
             }
@@ -919,11 +979,38 @@ class ReactNativeBleTransport {
             if (protocolHint) {
                 this.deviceProtocolHints.set(uuid, protocolHint);
             }
-            yield this.installTransportForAcquire(uuid, acquiredDevice, {
-                writeCharacteristic,
-                notifyCharacteristic,
-            });
+            if (shouldMapProtocolV2StaleBond) {
+                this.acquiringProtocolV2.add(uuid);
+            }
             try {
+                yield this.installTransportForAcquire(uuid, acquiredDevice, {
+                    writeCharacteristic,
+                    notifyCharacteristic,
+                });
+                if (skipProtocolProbe) {
+                    if (!expectedProtocol) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'skipProtocolProbe requires an expected BLE protocol');
+                    }
+                    const hasConfirmedProtocol = this.sessionProtocols.get(uuid) === expectedProtocol ||
+                        (expectedProtocol === 'V2' && this.confirmedProtocolV2.has(uuid));
+                    if (!hasConfirmedProtocol) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'skipProtocolProbe requires a previously confirmed protocol for this BLE endpoint');
+                    }
+                    this.deviceProtocol.set(uuid, expectedProtocol);
+                    this.sessionProtocols.set(uuid, expectedProtocol);
+                    this.protocolReprobeFailures.delete(uuid);
+                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol selected without probe', {
+                        deviceId: uuid,
+                        protocol: expectedProtocol,
+                        source: 'firmware-install-reconnect',
+                    });
+                    const currentTransport = transportCache[uuid];
+                    if (!currentTransport) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportNotFound);
+                    }
+                    this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
+                    return { uuid, protocolType: expectedProtocol };
+                }
                 const protocolType = yield this.detectProtocol(uuid, expectedProtocol, protocolHint, () => __awaiter(this, void 0, void 0, function* () {
                     yield this.installTransportForAcquire(uuid, acquiredDevice);
                 }));
@@ -935,7 +1022,7 @@ class ReactNativeBleTransport {
                 return { uuid, protocolType };
             }
             catch (error) {
-                if ((error === null || error === void 0 ? void 0 : error.errorCode) === hdShared.HardwareErrorCode.BleDeviceBondError) {
+                if (hdShared.isBleStaleBondHardwareError(error)) {
                     yield this.disconnectUnlocked(uuid);
                 }
                 else {
@@ -943,13 +1030,16 @@ class ReactNativeBleTransport {
                 }
                 throw error;
             }
+            finally {
+                this.acquiringProtocolV2.delete(uuid);
+            }
         });
     }
     _monitorCharacteristic(characteristic, uuid, monitorToken, notifyTransactionId) {
         let bufferLength = 0;
         let buffer$1 = [];
         const subscription = characteristic.monitor((error, c) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
             const isCurrentMonitor = this.monitorTokens.get(uuid) === monitorToken;
             if (error) {
                 Log === null || Log === void 0 ? void 0 : Log.debug(`error monitor ${characteristic.uuid}, deviceId: ${characteristic.deviceID}: ${error}`);
@@ -961,19 +1051,21 @@ class ReactNativeBleTransport {
                     Log === null || Log === void 0 ? void 0 : Log.debug('monitor error ignored for stale transport: ', uuid, notifyTransactionId);
                     return;
                 }
+                if ((this.getActiveProtocol(uuid) === 'V2' || this.acquiringProtocolV2.has(uuid)) &&
+                    isNativeBleStaleBondError(error)) {
+                    this.rememberStaleBondError(uuid, toBleStaleBondHardwareError(error));
+                    return;
+                }
                 if (this.getActiveProtocol(uuid) === 'V2') {
                     let errorCode = hdShared.HardwareErrorCode.BleCharacteristicNotifyError;
                     if ((_a = error.reason) === null || _a === void 0 ? void 0 : _a.includes('The connection has timed out unexpectedly')) {
                         errorCode = hdShared.HardwareErrorCode.BleTimeoutError;
                     }
-                    else if ((_b = error.reason) === null || _b === void 0 ? void 0 : _b.includes('Encryption is insufficient')) {
-                        errorCode = hdShared.HardwareErrorCode.BleDeviceBondError;
-                    }
-                    else if (((_c = error.reason) === null || _c === void 0 ? void 0 : _c.includes('Cannot write client characteristic config descriptor')) ||
-                        ((_d = error.reason) === null || _d === void 0 ? void 0 : _d.includes('Cannot find client characteristic config descriptor')) ||
-                        ((_e = error.reason) === null || _e === void 0 ? void 0 : _e.includes('The handle is invalid')) ||
-                        ((_f = error.reason) === null || _f === void 0 ? void 0 : _f.includes('Writing is not permitted')) ||
-                        ((_g = error.reason) === null || _g === void 0 ? void 0 : _g.includes('notify change failed for device'))) {
+                    else if (((_b = error.reason) === null || _b === void 0 ? void 0 : _b.includes('Cannot write client characteristic config descriptor')) ||
+                        ((_c = error.reason) === null || _c === void 0 ? void 0 : _c.includes('Cannot find client characteristic config descriptor')) ||
+                        ((_d = error.reason) === null || _d === void 0 ? void 0 : _d.includes('The handle is invalid')) ||
+                        ((_e = error.reason) === null || _e === void 0 ? void 0 : _e.includes('Writing is not permitted')) ||
+                        ((_f = error.reason) === null || _f === void 0 ? void 0 : _f.includes('notify change failed for device'))) {
                         errorCode = hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure;
                     }
                     this.rejectProtocolV2Frames(uuid, hdShared.ERRORS.TypedError(errorCode));
@@ -981,17 +1073,14 @@ class ReactNativeBleTransport {
                 }
                 if (this.runPromise && this.runPromiseDeviceId === uuid) {
                     let ERROR = hdShared.HardwareErrorCode.BleCharacteristicNotifyError;
-                    if ((_h = error.reason) === null || _h === void 0 ? void 0 : _h.includes('The connection has timed out unexpectedly')) {
+                    if ((_g = error.reason) === null || _g === void 0 ? void 0 : _g.includes('The connection has timed out unexpectedly')) {
                         ERROR = hdShared.HardwareErrorCode.BleTimeoutError;
                     }
-                    if ((_j = error.reason) === null || _j === void 0 ? void 0 : _j.includes('Encryption is insufficient')) {
-                        ERROR = hdShared.HardwareErrorCode.BleDeviceBondError;
-                    }
-                    if (((_k = error.reason) === null || _k === void 0 ? void 0 : _k.includes('Cannot write client characteristic config descriptor')) ||
-                        ((_l = error.reason) === null || _l === void 0 ? void 0 : _l.includes('Cannot find client characteristic config descriptor')) ||
-                        ((_m = error.reason) === null || _m === void 0 ? void 0 : _m.includes('The handle is invalid')) ||
-                        ((_o = error.reason) === null || _o === void 0 ? void 0 : _o.includes('Writing is not permitted')) ||
-                        ((_p = error.reason) === null || _p === void 0 ? void 0 : _p.includes('notify change failed for device'))) {
+                    if (((_h = error.reason) === null || _h === void 0 ? void 0 : _h.includes('Cannot write client characteristic config descriptor')) ||
+                        ((_j = error.reason) === null || _j === void 0 ? void 0 : _j.includes('Cannot find client characteristic config descriptor')) ||
+                        ((_k = error.reason) === null || _k === void 0 ? void 0 : _k.includes('The handle is invalid')) ||
+                        ((_l = error.reason) === null || _l === void 0 ? void 0 : _l.includes('Writing is not permitted')) ||
+                        ((_m = error.reason) === null || _m === void 0 ? void 0 : _m.includes('notify change failed for device'))) {
                         const notifyError = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure);
                         this.runPromise.reject(notifyError);
                         Log === null || Log === void 0 ? void 0 : Log.debug(`${hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure} ${error.message}    ${error.reason}`);
@@ -1033,7 +1122,7 @@ class ReactNativeBleTransport {
                     bufferLength = 0;
                     buffer$1 = [];
                     if (this.runPromiseDeviceId === uuid) {
-                        (_q = this.runPromise) === null || _q === void 0 ? void 0 : _q.resolve(value.toString('hex'));
+                        (_o = this.runPromise) === null || _o === void 0 ? void 0 : _o.resolve(value.toString('hex'));
                     }
                 }
             }
@@ -1044,7 +1133,7 @@ class ReactNativeBleTransport {
                     this.rejectProtocolV2Frames(uuid, notifyError);
                 }
                 else if (this.runPromiseDeviceId === uuid) {
-                    (_r = this.runPromise) === null || _r === void 0 ? void 0 : _r.reject(notifyError);
+                    (_p = this.runPromise) === null || _p === void 0 ? void 0 : _p.reject(notifyError);
                 }
             }
         }, notifyTransactionId);
@@ -1098,6 +1187,8 @@ class ReactNativeBleTransport {
             this.protocolV2HighVolumeLogSignatures.delete(uuid);
             this.deviceProtocol.delete(uuid);
             this.probingProtocols.delete(uuid);
+            this.staleBondErrors.delete(uuid);
+            this.acquiringProtocolV2.delete(uuid);
             (_e = this.protocolV2Assemblers.get(uuid)) === null || _e === void 0 ? void 0 : _e.reset();
             this.protocolV2Assemblers.delete(uuid);
             this.resetProtocolV2Frames(uuid);
@@ -1383,6 +1474,7 @@ class ReactNativeBleTransport {
             }
             this.deviceProtocol.delete(session);
             this.probingProtocols.delete(session);
+            this.staleBondErrors.delete(session);
             this.deviceProtocolHints.delete(session);
             this.sessionProtocols.delete(session);
             this.protocolReprobeFailures.delete(session);
@@ -1561,6 +1653,8 @@ class ReactNativeBleTransport {
         }
         this.deviceProtocol.delete(uuid);
         this.probingProtocols.delete(uuid);
+        this.staleBondErrors.delete(uuid);
+        this.acquiringProtocolV2.delete(uuid);
         this.protocolV2Assemblers.delete(uuid);
         this.resetProtocolV2Frames(uuid);
         if (timeouts >= BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD) {
@@ -1630,6 +1724,8 @@ class ReactNativeBleTransport {
         }
         this.deviceProtocol.delete(uuid);
         this.probingProtocols.delete(uuid);
+        this.staleBondErrors.delete(uuid);
+        this.acquiringProtocolV2.delete(uuid);
         this.protocolV2Assemblers.delete(uuid);
         this.resetProtocolV2Frames(uuid);
         if (timeouts >= BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD) {
@@ -1672,8 +1768,9 @@ class ReactNativeBleTransport {
         });
         this.deviceProtocol.clear();
         this.probingProtocols.clear();
+        this.staleBondErrors.clear();
+        this.acquiringProtocolV2.clear();
         this.sessionProtocols.clear();
-        this.confirmedProtocolV2.clear();
         this.protocolReprobeFailures.clear();
         this.writeTimeoutCounts.clear();
         this.connectionSetupTimeoutCounts.clear();
@@ -1686,9 +1783,8 @@ class ReactNativeBleTransport {
             Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] BLE manager destroy failed (ignored):', error);
         }
     }
-    createProtocolMismatchError(expected, uuid) {
-        const isStaleV2Bond = expected === 'V2' && this.confirmedProtocolV2.has(uuid);
-        return hdShared.ERRORS.TypedError(isStaleV2Bond ? hdShared.HardwareErrorCode.BleDeviceBondError : hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
+    createProtocolMismatchError(expected) {
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`);
     }
     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');
@@ -1708,27 +1804,17 @@ class ReactNativeBleTransport {
     detectProtocol(uuid, expectedProtocol, protocolHint, rebuildTransport) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (reactNative.Platform.OS === 'ios' && expectedProtocol === 'V1') {
-                this.deviceProtocol.set(uuid, expectedProtocol);
+            if (expectedProtocol === 'V1') {
+                this.deviceProtocol.set(uuid, 'V1');
                 Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol selected', {
                     deviceId: uuid,
-                    protocol: expectedProtocol,
+                    protocol: 'V1',
                     source: 'expected',
                 });
-                return expectedProtocol;
+                return 'V1';
             }
-            if (expectedProtocol === 'V1') {
-                if (yield this.probeProtocolV1(uuid)) {
-                    this.deviceProtocol.set(uuid, 'V1');
-                    this.sessionProtocols.set(uuid, 'V1');
-                    Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport] protocol detected', {
-                        deviceId: uuid,
-                        protocol: 'V1',
-                        source: 'expected',
-                    });
-                    return 'V1';
-                }
-                throw this.createProtocolMismatchError(expectedProtocol, uuid);
+            if (expectedProtocol === 'V2' || this.acquiringProtocolV2.has(uuid)) {
+                this.throwIfStaleBondError(uuid);
             }
             if (expectedProtocol === 'V2') {
                 if (yield this.probeProtocolV2(uuid)) {
@@ -1742,7 +1828,7 @@ class ReactNativeBleTransport {
                     });
                     return 'V2';
                 }
-                throw this.createProtocolMismatchError(expectedProtocol, uuid);
+                throw this.createProtocolMismatchError(expectedProtocol);
             }
             const sessionProtocol = this.sessionProtocols.get(uuid);
             const reprobeFailures = (_a = this.protocolReprobeFailures.get(uuid)) !== null && _a !== void 0 ? _a : 0;
@@ -1860,6 +1946,7 @@ 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,
@@ -1870,6 +1957,7 @@ class ReactNativeBleTransport {
                     (_a = this.protocolV2Assemblers.get(uuid)) === null || _a === void 0 ? void 0 : _a.reset();
                     this.resetProtocolV2Frames(uuid);
                 },
+                shouldRethrow: hdShared.isBleStaleBondHardwareError,
             });
             if (!detected) {
                 this.clearProbeProtocol(uuid, 'V2');
@@ -1930,6 +2018,19 @@ class ReactNativeBleTransport {
             framePromise.reject(error);
         }
     }
+    rememberStaleBondError(uuid, error) {
+        this.staleBondErrors.set(uuid, error);
+        this.rejectProtocolV2Frames(uuid, error);
+        if (this.runPromise && this.runPromiseDeviceId === uuid) {
+            this.runPromise.reject(error);
+        }
+    }
+    throwIfStaleBondError(uuid) {
+        const error = this.staleBondErrors.get(uuid);
+        if (error) {
+            throw error;
+        }
+    }
     readProtocolV2Frame(uuid) {
         return __awaiter(this, void 0, void 0, function* () {
             const queuedFrame = this.getProtocolV2FrameQueue(uuid).shift();
@@ -1978,6 +2079,11 @@ class ReactNativeBleTransport {
                     return;
                 }
                 catch (error) {
+                    if (isNativeBleStaleBondError(error) || hdShared.isBleStaleBondHardwareError(error)) {
+                        const bondError = toBleStaleBondHardwareError(error);
+                        this.rememberStaleBondError(uuid, bondError);
+                        throw bondError;
+                    }
                     if (getFirmwareUploadWriteRetryType(error) !== 'congested' ||
                         attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES) {
                         throw error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.2-alpha.100",
+  "version": "1.2.2-alpha.3",
   "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.2-alpha.100",
-    "@onekeyfe/hd-shared": "1.2.2-alpha.100",
-    "@onekeyfe/hd-transport": "1.2.2-alpha.100",
+    "@onekeyfe/hd-core": "1.2.2-alpha.3",
+    "@onekeyfe/hd-shared": "1.2.2-alpha.3",
+    "@onekeyfe/hd-transport": "1.2.2-alpha.3",
     "@onekeyfe/react-native-ble-utils": "^0.1.6",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "c40dad085297b0e3cc2020bd218c146dff6ed3e1"
+  "gitHead": "4efa66df8851607586d0ae6a431a63404beff51b"
 }

package/src/__tests__/bleStaleBond.test.ts

@@ -0,0 +1,39 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import { isNativeBleStaleBondError, toBleStaleBondHardwareError } from '../bleStaleBond';
+
+describe('native BLE stale bond mapping', () => {
+  test.each([
+    [
+      { attErrorCode: 15, reason: 'Encryption is insufficient' },
+      HardwareErrorCode.BleDeviceBondError,
+    ],
+    [
+      { attErrorCode: 5, reason: 'GATT_INSUF_AUTHENTICATION' },
+      HardwareErrorCode.BleDeviceBondError,
+    ],
+    [
+      { iosErrorCode: 14, reason: 'Peer removed pairing information' },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+    [
+      { reason: 'peer removed pairing information' },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+    [
+      { message: 'PEER REMOVED PAIRING INFORMATION' },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+  ])('maps %j to %s', (nativeError, errorCode) => {
+    expect(isNativeBleStaleBondError(nativeError)).toBe(true);
+    expect(toBleStaleBondHardwareError(nativeError)).toMatchObject({ errorCode });
+  });
+
+  test('does not treat the generic ATT unlikely error as a stale bond', () => {
+    expect(isNativeBleStaleBondError({ attErrorCode: 14, reason: 'Unlikely error' })).toBe(false);
+  });
+
+  test('does not treat a generic disconnect as a stale bond', () => {
+    expect(isNativeBleStaleBondError({ reason: 'Device disconnected' })).toBe(false);
+  });
+});

package/src/__tests__/protocolV2Link.test.ts

@@ -109,9 +109,11 @@ const schemas = {
 const createHarness = ({
   deviceName = 'OneKey Pro 2',
   isWritableWithResponse = true,
+  monitorError,
 }: {
   deviceName?: string;
   isWritableWithResponse?: boolean;
+  monitorError?: (Error & { reason?: string; attErrorCode?: number; iosErrorCode?: number }) | null;
 } = {}) => {
   const uuid = 'rn-pro2-id';
   const sentSeqs: number[] = [];
@@ -130,6 +132,9 @@ const createHarness = ({
     isNotifiable: true,
     monitor: jest.fn(callback => {
       notifyCallback = callback;
+      if (monitorError) {
+        queueMicrotask(() => callback(monitorError, null));
+      }
       return { remove: jest.fn() };
     }),
   };
@@ -405,6 +410,22 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.release(uuid, true);
   });
 
+  test('keeps native stale-bond write mapping out of Protocol V1 calls', async () => {
+    const { transport, uuid, writeCharacteristic } = createV1Harness();
+    const nativeError = Object.assign(new Error('Encryption is insufficient'), {
+      attErrorCode: 15,
+      reason: 'Encryption is insufficient',
+    });
+
+    await transport.acquire({ uuid, expectedProtocol: 'V1' });
+    writeCharacteristic.writeWithResponse.mockRejectedValueOnce(nativeError);
+
+    await expect(transport.call(uuid, 'Initialize', {}, { timeoutMs: 50 })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleWriteCharacteristicError,
+    });
+    await transport.release(uuid, true);
+  });
+
   test('detects Protocol V2 on iOS without using the BLE name as a protocol hint', async () => {
     const { transport, uuid, device, sentSeqs, writeCharacteristic } = createHarness({
       deviceName: 'Pro2 6E9E',
@@ -424,6 +445,93 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     await transport.release(uuid, true);
   });
 
+  test('physically refreshes an uncached Protocol V2 firmware install link without Ping', async () => {
+    const { transport, uuid, device, bleManager, writeCharacteristic } = createHarness();
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2');
+    (transport as any).sessionProtocols.set(uuid, 'V2');
+    device.connect = jest.fn().mockResolvedValue(device);
+    device.isConnected.mockResolvedValueOnce(false);
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(device.cancelConnection).not.toHaveBeenCalled();
+    expect(device.connect).toHaveBeenCalled();
+    expect(probeProtocolV2).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    expect(transport.getProtocolType(uuid)).toBe('V2');
+    await transport.release(uuid, true);
+  });
+
+  test('refreshes a cached firmware install connection instead of trusting GATT state', async () => {
+    const { transport, uuid, device, bleManager, writeCharacteristic } = createHarness();
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2');
+
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    device.connect = jest.fn().mockResolvedValue(device);
+    device.isConnected.mockResolvedValueOnce(false);
+    writeCharacteristic.writeWithResponse.mockClear();
+    writeCharacteristic.writeWithoutResponse.mockClear();
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+
+    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(uuid);
+    expect(device.cancelConnection).toHaveBeenCalled();
+    expect(device.connect).toHaveBeenCalled();
+    expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  });
+
+  test('rejects no-probe acquire before the BLE endpoint has confirmed a protocol', async () => {
+    const { transport, uuid } = createHarness();
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).rejects.toThrow('previously confirmed protocol');
+
+    expect(transport.getProtocolType(uuid)).toBeUndefined();
+  });
+
+  test('keeps confirmed V2 authorization across a BLE manager reset', async () => {
+    const { transport, uuid, device, bleManager, writeCharacteristic } = createHarness();
+    const probeProtocolV2 = jest.spyOn(transport as any, 'probeProtocolV2');
+
+    await transport.acquire({ uuid, expectedProtocol: 'V2' });
+    expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+
+    (transport as any).resetPlxManager();
+    transport.blePlxManager = bleManager as any;
+    device.connect = jest.fn().mockResolvedValue(device);
+    device.isConnected.mockResolvedValueOnce(false);
+    writeCharacteristic.writeWithResponse.mockClear();
+    writeCharacteristic.writeWithoutResponse.mockClear();
+
+    await expect(
+      transport.acquire({ uuid, expectedProtocol: 'V2', skipProtocolProbe: true })
+    ).resolves.toEqual({
+      uuid,
+      protocolType: 'V2',
+    });
+
+    expect(probeProtocolV2).toHaveBeenCalledTimes(1);
+    expect(writeCharacteristic.writeWithResponse).not.toHaveBeenCalled();
+    expect(writeCharacteristic.writeWithoutResponse).not.toHaveBeenCalled();
+    await transport.release(uuid, true);
+  });
+
   test.each(['ios', 'android'] as const)(
     'keeps a first expected Protocol V2 probe miss retryable on %s',
     async platform => {
@@ -459,8 +567,37 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
     }
   );
 
+  test.each([
+    [
+      'Encryption is insufficient',
+      { reason: 'Encryption is insufficient', attErrorCode: 15 },
+      HardwareErrorCode.BleDeviceBondError,
+    ],
+    [
+      'Peer removed pairing information',
+      { reason: 'Peer removed pairing information', iosErrorCode: 14 },
+      HardwareErrorCode.BlePeerRemovedPairingInformation,
+    ],
+  ] as const)(
+    'fails Protocol V2 acquire immediately on %s instead of waiting for Ping',
+    async (_label, nativeError, errorCode) => {
+      const { transport, uuid, device } = createHarness({
+        monitorError: Object.assign(new Error(nativeError.reason), nativeError),
+      });
+      const probe = jest.spyOn(transport as any, 'probeProtocolV2');
+
+      await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
+        errorCode,
+      });
+
+      expect(probe).not.toHaveBeenCalled();
+      expect(device.cancelConnection).toHaveBeenCalled();
+      expect(transport.getProtocolType(uuid)).toBeUndefined();
+    }
+  );
+
   test.each(['ios', 'android'] as const)(
-    'reports a stale bond on %s when a previously confirmed Protocol V2 device stops responding',
+    'keeps a confirmed Protocol V2 probe miss retryable on %s without native bond evidence',
     async platform => {
       setPlatformOS(platform);
       const { transport, uuid, device } = createHarness();
@@ -469,10 +606,10 @@ describe('ReactNativeBleTransport Protocol V2 link lifecycle', () => {
       jest.spyOn(transport as any, 'probeProtocolV2').mockResolvedValue(false);
 
       await expect(transport.acquire({ uuid, expectedProtocol: 'V2' })).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.BleDeviceBondError,
+        errorCode: HardwareErrorCode.RuntimeError,
       });
 
-      expect(device.cancelConnection).toHaveBeenCalled();
+      expect(device.cancelConnection).not.toHaveBeenCalled();
       expect(transport.getProtocolType(uuid)).toBeUndefined();
     }
   );

package/src/bleStaleBond.ts

@@ -0,0 +1,61 @@
+import {
+  ERRORS,
+  HardwareErrorCode,
+  isBleStaleBondErrorText,
+  isBleStaleBondHardwareError,
+} from '@onekeyfe/hd-shared';
+
+export { isBleStaleBondHardwareError };
+
+const ATT_INSUFFICIENT_AUTHENTICATION = 5;
+const ATT_INSUFFICIENT_ENCRYPTION = 15;
+const IOS_PEER_REMOVED_PAIRING_INFORMATION = 14;
+
+type NativeBleErrorFields = {
+  attErrorCode?: unknown;
+  iosErrorCode?: unknown;
+  reason?: unknown;
+  message?: unknown;
+};
+
+const nativeErrorText = (error: NativeBleErrorFields) =>
+  [error.reason, error.message]
+    .filter((value): value is string => typeof value === 'string')
+    .join(' ');
+
+export const isNativeBleStaleBondError = (error: unknown): boolean => {
+  if (!error || typeof error !== 'object') {
+    return typeof error === 'string' ? isBleStaleBondErrorText(error) : false;
+  }
+
+  const nativeError = error as NativeBleErrorFields;
+  if (
+    nativeError.attErrorCode === ATT_INSUFFICIENT_AUTHENTICATION ||
+    nativeError.attErrorCode === ATT_INSUFFICIENT_ENCRYPTION ||
+    nativeError.iosErrorCode === IOS_PEER_REMOVED_PAIRING_INFORMATION
+  ) {
+    return true;
+  }
+
+  return isBleStaleBondErrorText(nativeErrorText(nativeError));
+};
+
+export const toBleStaleBondHardwareError = (error: unknown) => {
+  if (isBleStaleBondHardwareError(error)) {
+    return error as Error;
+  }
+
+  const nativeError = (error ?? {}) as NativeBleErrorFields;
+  const text = nativeErrorText(nativeError);
+  const normalizedText = text.toLowerCase();
+  const peerRemoved =
+    nativeError.iosErrorCode === IOS_PEER_REMOVED_PAIRING_INFORMATION ||
+    normalizedText.includes('peer removed pairing information');
+
+  return ERRORS.TypedError(
+    peerRemoved
+      ? HardwareErrorCode.BlePeerRemovedPairingInformation
+      : HardwareErrorCode.BleDeviceBondError,
+    text || undefined
+  );
+};

package/src/index.ts

@@ -1,7 +1,6 @@
 import { PermissionsAndroid, Platform } from 'react-native';
 import { Buffer } from 'buffer';
 import {
-  BleATTErrorCode,
   BleError,
   BleErrorCode,
   BleManager as BlePlxManager,
@@ -48,6 +47,11 @@ import {
   getInfosForServiceUuid,
   isSameBleUuid,
 } from './constants';
+import {
+  isBleStaleBondHardwareError,
+  isNativeBleStaleBondError,
+  toBleStaleBondHardwareError,
+} from './bleStaleBond';
 import { isHeaderChunk } from './utils/validateNotify';
 import BleTransport from './BleTransport';
 import timer from './utils/timer';
@@ -58,6 +62,15 @@ import type { Characteristic, Device, Subscription } from 'react-native-ble-plx'
 import type EventEmitter from 'events';
 import type { BleAcquireInput, TransportOptions } from './types';
 
+type FirmwareInstallBleAcquireInput = BleAcquireInput & {
+  /**
+   * Reuse the already-verified protocol after an expected firmware-install
+   * disconnect. The install loader accepts status requests but may not answer
+   * the generic protocol probe used by a normal acquire.
+   */
+  skipProtocolProbe?: boolean;
+};
+
 const { check, ProtocolV1, parseConfigure } = transport;
 
 const Log = bleLogger;
@@ -307,15 +320,10 @@ const resolveNegotiatedMtu = (device: Device) => requestNegotiatedMtu(device, 'c
 
 type IOBleErrorRemap = Error | BleError | null | undefined;
 
-function remapError(error: IOBleErrorRemap) {
+function remapError(error: IOBleErrorRemap, mapProtocolV2StaleBond: boolean) {
   if (error instanceof BleError) {
-    if (
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      // @ts-expect-error
-      error.iosErrorCode === BleATTErrorCode.UnlikelyError ||
-      error.reason === 'Peer removed pairing information'
-    ) {
-      throw ERRORS.TypedError(HardwareErrorCode.BlePeerRemovedPairingInformation);
+    if (mapProtocolV2StaleBond && isNativeBleStaleBondError(error)) {
+      throw toBleStaleBondHardwareError(error);
     }
 
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -390,6 +398,16 @@ export default class ReactNativeBleTransport {
   /** Consecutive detections that failed while trusting sessionProtocols. */
   private protocolReprobeFailures: Map<string, number> = new Map();
 
+  /**
+   * Native encryption/pairing failures seen before Protocol V2 probe starts.
+   * Pro2/Neo GATT connect can succeed on a stale iOS bond; the CCCD write then
+   * fails with ATT 5/15. Remember it so detectProtocol fails immediately.
+   */
+  private staleBondErrors: Map<string, Error> = new Map();
+
+  /** Strict or previously confirmed V2 target while acquire installs notifications. */
+  private acquiringProtocolV2 = new Set<string>();
+
   private protocolV2Assemblers: Map<string, ProtocolV2FrameAssembler> = new Map();
 
   private protocolV2FrameQueues: Map<string, Uint8Array[]> = new Map();
@@ -865,7 +883,7 @@ export default class ReactNativeBleTransport {
     return transport;
   }
 
-  async acquire(input: BleAcquireInput) {
+  async acquire(input: FirmwareInstallBleAcquireInput) {
     const { uuid } = input;
 
     if (!uuid) {
@@ -875,28 +893,73 @@ export default class ReactNativeBleTransport {
     return this.runLifecycleOperation(uuid, () => this.acquireUnlocked(input));
   }
 
-  private async acquireUnlocked(input: BleAcquireInput) {
-    const { uuid, forceCleanRunPromise, expectedProtocol } = input;
+  private async acquireUnlocked(input: FirmwareInstallBleAcquireInput) {
+    const { uuid, forceCleanRunPromise, expectedProtocol, skipProtocolProbe } = input;
+    const shouldMapProtocolV2StaleBond = expectedProtocol
+      ? expectedProtocol === 'V2'
+      : this.confirmedProtocolV2.has(uuid);
 
     const cachedTransport = transportCache[uuid];
+    if (skipProtocolProbe && !cachedTransport && this.blePlxManager) {
+      Log?.debug(
+        '[ReactNativeBleTransport] refresh uncached BLE connection for firmware install:',
+        uuid
+      );
+      const manager = this.blePlxManager;
+      await this.runNativeTeardown(uuid, manager, async () => {
+        await this.runBestEffortNativeOperation(
+          'firmware install reconnect: cancel uncached device connection',
+          () => manager.cancelDeviceConnection(uuid)
+        );
+      });
+    }
     if (cachedTransport) {
-      const cachedProtocol = this.deviceProtocol.get(uuid);
-      const isCachedDeviceConnected = await cachedTransport.device.isConnected().catch(() => false);
-      if (
-        isCachedDeviceConnected &&
-        cachedProtocol &&
-        (!expectedProtocol || cachedProtocol === expectedProtocol)
-      ) {
-        Log?.debug('[ReactNativeBleTransport] reuse cached BLE transport:', uuid, cachedProtocol);
-        return { uuid, protocolType: cachedProtocol };
-      }
+      if (skipProtocolProbe) {
+        Log?.debug(
+          '[ReactNativeBleTransport] refresh cached BLE connection for firmware install:',
+          uuid
+        );
+        const manager = this.blePlxManager;
+        await this.releaseUnlocked(uuid, true);
+        await this.runNativeTeardown(uuid, manager, async () => {
+          const operations: Promise<unknown>[] = [];
+          if (manager) {
+            operations.push(
+              this.runBestEffortNativeOperation(
+                'firmware install reconnect: cancel device connection',
+                () => manager.cancelDeviceConnection(uuid)
+              )
+            );
+          }
+          operations.push(
+            this.runBestEffortNativeOperation(
+              'firmware install reconnect: device cancel connection',
+              () => cachedTransport.device.cancelConnection()
+            )
+          );
+          await Promise.all(operations);
+        });
+      } else {
+        const cachedProtocol = this.deviceProtocol.get(uuid);
+        const isCachedDeviceConnected = await cachedTransport.device
+          .isConnected()
+          .catch(() => false);
+        if (
+          isCachedDeviceConnected &&
+          cachedProtocol &&
+          (!expectedProtocol || cachedProtocol === expectedProtocol)
+        ) {
+          Log?.debug('[ReactNativeBleTransport] reuse cached BLE transport:', uuid, cachedProtocol);
+          return { uuid, protocolType: cachedProtocol };
+        }
 
-      /**
-       * If the transport is not reusable due to a protocol mismatch or stale
-       * connection, clean it up before creating a new transport instance.
-       */
-      Log?.debug('transport not reusable, will release: ', uuid);
-      await this.releaseUnlocked(uuid, true);
+        /**
+         * If the transport is not reusable due to a protocol mismatch or stale
+         * connection, clean it up before creating a new transport instance.
+         */
+        Log?.debug('transport not reusable, will release: ', uuid);
+        await this.releaseUnlocked(uuid, true);
+      }
     }
 
     let device: Device | null = null;
@@ -961,7 +1024,7 @@ export default class ReactNativeBleTransport {
           Log?.debug('device already connected');
           throw ERRORS.TypedError(HardwareErrorCode.BleAlreadyConnected);
         } else {
-          remapError(e);
+          remapError(e, shouldMapProtocolV2StaleBond);
         }
       }
     }
@@ -1005,7 +1068,7 @@ export default class ReactNativeBleTransport {
             }
           }
         } else {
-          remapError(e);
+          remapError(e, shouldMapProtocolV2StaleBond);
         }
       }
     }
@@ -1025,12 +1088,48 @@ export default class ReactNativeBleTransport {
       this.deviceProtocolHints.set(uuid, protocolHint);
     }
 
-    await this.installTransportForAcquire(uuid, acquiredDevice, {
-      writeCharacteristic,
-      notifyCharacteristic,
-    });
+    if (shouldMapProtocolV2StaleBond) {
+      this.acquiringProtocolV2.add(uuid);
+    }
 
     try {
+      await this.installTransportForAcquire(uuid, acquiredDevice, {
+        writeCharacteristic,
+        notifyCharacteristic,
+      });
+
+      if (skipProtocolProbe) {
+        if (!expectedProtocol) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            'skipProtocolProbe requires an expected BLE protocol'
+          );
+        }
+        const hasConfirmedProtocol =
+          this.sessionProtocols.get(uuid) === expectedProtocol ||
+          (expectedProtocol === 'V2' && this.confirmedProtocolV2.has(uuid));
+        if (!hasConfirmedProtocol) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.RuntimeError,
+            'skipProtocolProbe requires a previously confirmed protocol for this BLE endpoint'
+          );
+        }
+        this.deviceProtocol.set(uuid, expectedProtocol);
+        this.sessionProtocols.set(uuid, expectedProtocol);
+        this.protocolReprobeFailures.delete(uuid);
+        Log?.debug('[ReactNativeBleTransport] protocol selected without probe', {
+          deviceId: uuid,
+          protocol: expectedProtocol,
+          source: 'firmware-install-reconnect',
+        });
+        const currentTransport = transportCache[uuid];
+        if (!currentTransport) {
+          throw ERRORS.TypedError(HardwareErrorCode.TransportNotFound);
+        }
+        this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
+        return { uuid, protocolType: expectedProtocol };
+      }
+
       const protocolType = await this.detectProtocol(
         uuid,
         expectedProtocol,
@@ -1046,12 +1145,14 @@ export default class ReactNativeBleTransport {
       this.attachDisconnectSubscription(currentTransport, currentTransport.device, uuid);
       return { uuid, protocolType };
     } catch (error) {
-      if ((error as { errorCode?: unknown })?.errorCode === HardwareErrorCode.BleDeviceBondError) {
+      if (isBleStaleBondHardwareError(error)) {
         await this.disconnectUnlocked(uuid);
       } else {
         await this.releaseUnlocked(uuid, true);
       }
       throw error;
+    } finally {
+      this.acquiringProtocolV2.delete(uuid);
     }
   }
 
@@ -1079,17 +1180,21 @@ export default class ReactNativeBleTransport {
           Log?.debug('monitor error ignored for stale transport: ', uuid, notifyTransactionId);
           return;
         }
+        if (
+          (this.getActiveProtocol(uuid) === 'V2' || this.acquiringProtocolV2.has(uuid)) &&
+          isNativeBleStaleBondError(error)
+        ) {
+          this.rememberStaleBondError(uuid, toBleStaleBondHardwareError(error));
+          return;
+        }
         if (this.getActiveProtocol(uuid) === 'V2') {
           let errorCode:
-            | typeof HardwareErrorCode.BleDeviceBondError
             | typeof HardwareErrorCode.BleCharacteristicNotifyError
             | typeof HardwareErrorCode.BleCharacteristicNotifyChangeFailure
             | typeof HardwareErrorCode.BleTimeoutError =
             HardwareErrorCode.BleCharacteristicNotifyError;
           if (error.reason?.includes('The connection has timed out unexpectedly')) {
             errorCode = HardwareErrorCode.BleTimeoutError;
-          } else if (error.reason?.includes('Encryption is insufficient')) {
-            errorCode = HardwareErrorCode.BleDeviceBondError;
           } else if (
             error.reason?.includes('Cannot write client characteristic config descriptor') ||
             error.reason?.includes('Cannot find client characteristic config descriptor') ||
@@ -1104,16 +1209,12 @@ export default class ReactNativeBleTransport {
         }
         if (this.runPromise && this.runPromiseDeviceId === uuid) {
           let ERROR:
-            | typeof HardwareErrorCode.BleDeviceBondError
             | typeof HardwareErrorCode.BleCharacteristicNotifyError
             | typeof HardwareErrorCode.BleTimeoutError =
             HardwareErrorCode.BleCharacteristicNotifyError;
           if (error.reason?.includes('The connection has timed out unexpectedly')) {
             ERROR = HardwareErrorCode.BleTimeoutError;
           }
-          if (error.reason?.includes('Encryption is insufficient')) {
-            ERROR = HardwareErrorCode.BleDeviceBondError;
-          }
           if (
             error.reason?.includes('Cannot write client characteristic config descriptor') ||
             error.reason?.includes('Cannot find client characteristic config descriptor') || // pro firmware 2.3.0 upgrade
@@ -1248,6 +1349,8 @@ export default class ReactNativeBleTransport {
 
     this.deviceProtocol.delete(uuid);
     this.probingProtocols.delete(uuid);
+    this.staleBondErrors.delete(uuid);
+    this.acquiringProtocolV2.delete(uuid);
     // Confirmed protocol and caller hints stay in deviceProtocol / protocolHint.
     this.protocolV2Assemblers.get(uuid)?.reset();
     this.protocolV2Assemblers.delete(uuid);
@@ -1620,6 +1723,7 @@ export default class ReactNativeBleTransport {
     }
     this.deviceProtocol.delete(session);
     this.probingProtocols.delete(session);
+    this.staleBondErrors.delete(session);
     this.deviceProtocolHints.delete(session);
     this.sessionProtocols.delete(session);
     this.protocolReprobeFailures.delete(session);
@@ -1843,6 +1947,8 @@ export default class ReactNativeBleTransport {
     }
     this.deviceProtocol.delete(uuid);
     this.probingProtocols.delete(uuid);
+    this.staleBondErrors.delete(uuid);
+    this.acquiringProtocolV2.delete(uuid);
     this.protocolV2Assemblers.delete(uuid);
     this.resetProtocolV2Frames(uuid);
 
@@ -1939,6 +2045,8 @@ export default class ReactNativeBleTransport {
     }
     this.deviceProtocol.delete(uuid);
     this.probingProtocols.delete(uuid);
+    this.staleBondErrors.delete(uuid);
+    this.acquiringProtocolV2.delete(uuid);
     this.protocolV2Assemblers.delete(uuid);
     this.resetProtocolV2Frames(uuid);
 
@@ -1989,8 +2097,11 @@ export default class ReactNativeBleTransport {
     });
     this.deviceProtocol.clear();
     this.probingProtocols.clear();
+    this.staleBondErrors.clear();
+    this.acquiringProtocolV2.clear();
     this.sessionProtocols.clear();
-    this.confirmedProtocolV2.clear();
+    // Keep transport-lifetime V2 proof so the same endpoint can finish a no-probe
+    // firmware reconnect after the native BLE manager is recreated.
     this.protocolReprobeFailures.clear();
     this.writeTimeoutCounts.clear();
     this.connectionSetupTimeoutCounts.clear();
@@ -2003,12 +2114,11 @@ export default class ReactNativeBleTransport {
     }
   }
 
-  private createProtocolMismatchError(expected: ProtocolType, uuid: string) {
-    // A generic Ping miss is not a bond failure. Only a later miss after this
-    // endpoint already answered V2, or a native encryption/pairing error, is.
-    const isStaleV2Bond = expected === 'V2' && this.confirmedProtocolV2.has(uuid);
+  private createProtocolMismatchError(expected: ProtocolType) {
+    // A protocol probe miss alone does not prove that the OS bond is stale.
+    // Native authentication/encryption failures are mapped separately.
     return ERRORS.TypedError(
-      isStaleV2Bond ? HardwareErrorCode.BleDeviceBondError : HardwareErrorCode.RuntimeError,
+      HardwareErrorCode.RuntimeError,
       `Device protocol mismatch: expected ${expected}, but device did not respond to expected protocol`
     );
   }
@@ -2040,31 +2150,28 @@ export default class ReactNativeBleTransport {
     protocolHint?: ProtocolType,
     rebuildTransport?: () => Promise<void>
   ): Promise<ProtocolType> {
-    // iOS still skips an extra V1 Initialize during acquire. Expected V2 must
-    // Ping so USB-priority `link disabled` can surface instead of a later
-    // unmapped RuntimeError.
-    if (Platform.OS === 'ios' && expectedProtocol === 'V1') {
-      this.deviceProtocol.set(uuid, expectedProtocol);
+    // A declared V1 is taken at face value on every platform, as iOS has done
+    // since protocol probing arrived: the caller reads the protocol off its own
+    // device record, so the probe re-asks a question that is already answered
+    // and costs a round trip on every acquire. Expected V2 must still Ping so
+    // USB-priority `link disabled` surfaces here instead of as a later unmapped
+    // RuntimeError. sessionProtocols is deliberately NOT stamped here: that map
+    // records protocols the device actually answered on (it gates the
+    // trustSessionProtocol narrowing in forced detection), and this branch has
+    // received no response. skipProtocolProbe does not need it either — its only
+    // caller is the V2 firmware-install reconnect.
+    if (expectedProtocol === 'V1') {
+      this.deviceProtocol.set(uuid, 'V1');
       Log?.debug('[ReactNativeBleTransport] protocol selected', {
         deviceId: uuid,
-        protocol: expectedProtocol,
+        protocol: 'V1',
         source: 'expected',
       });
-      return expectedProtocol;
+      return 'V1';
     }
 
-    if (expectedProtocol === 'V1') {
-      if (await this.probeProtocolV1(uuid)) {
-        this.deviceProtocol.set(uuid, 'V1');
-        this.sessionProtocols.set(uuid, 'V1');
-        Log?.debug('[ReactNativeBleTransport] protocol detected', {
-          deviceId: uuid,
-          protocol: 'V1',
-          source: 'expected',
-        });
-        return 'V1';
-      }
-      throw this.createProtocolMismatchError(expectedProtocol, uuid);
+    if (expectedProtocol === 'V2' || this.acquiringProtocolV2.has(uuid)) {
+      this.throwIfStaleBondError(uuid);
     }
 
     if (expectedProtocol === 'V2') {
@@ -2079,7 +2186,7 @@ export default class ReactNativeBleTransport {
         });
         return 'V2';
       }
-      throw this.createProtocolMismatchError(expectedProtocol, uuid);
+      throw this.createProtocolMismatchError(expectedProtocol);
     }
 
     // Protocol must be actively probed after connection. Name, PID, and descriptors only
@@ -2223,6 +2330,7 @@ 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),
@@ -2233,6 +2341,7 @@ export default class ReactNativeBleTransport {
         this.protocolV2Assemblers.get(uuid)?.reset();
         this.resetProtocolV2Frames(uuid);
       },
+      shouldRethrow: isBleStaleBondHardwareError,
     });
     if (!detected) {
       this.clearProbeProtocol(uuid, 'V2');
@@ -2301,6 +2410,21 @@ export default class ReactNativeBleTransport {
     }
   }
 
+  private rememberStaleBondError(uuid: string, error: Error) {
+    this.staleBondErrors.set(uuid, error);
+    this.rejectProtocolV2Frames(uuid, error);
+    if (this.runPromise && this.runPromiseDeviceId === uuid) {
+      this.runPromise.reject(error);
+    }
+  }
+
+  private throwIfStaleBondError(uuid: string) {
+    const error = this.staleBondErrors.get(uuid);
+    if (error) {
+      throw error;
+    }
+  }
+
   private async readProtocolV2Frame(uuid: string) {
     const queuedFrame = this.getProtocolV2FrameQueue(uuid).shift();
     if (queuedFrame) {
@@ -2359,6 +2483,11 @@ export default class ReactNativeBleTransport {
         assertCurrentGeneration();
         return;
       } catch (error) {
+        if (isNativeBleStaleBondError(error) || isBleStaleBondHardwareError(error)) {
+          const bondError = toBleStaleBondHardwareError(error);
+          this.rememberStaleBondError(uuid, bondError);
+          throw bondError;
+        }
         if (
           getFirmwareUploadWriteRetryType(error) !== 'congested' ||
           attempt >= FIRMWARE_UPLOAD_WRITE_MAX_RETRIES