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

package/dist/index.js

@@ -47,10 +47,10 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 };
 
 const lastKeyMissingAt = new Map();
-const listeners = new Set();
-let unsubscribeNative;
-const normalizeDeviceId = (deviceId) => deviceId.toLowerCase();
-const getCapableBleUtils = () => {
+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"];
@@ -60,41 +60,41 @@ const getCapableBleUtils = () => {
     }
     return bleUtils.supportsDeviceKeyMissing() ? bleUtils : undefined;
 };
-const isBleKeyMissingSupported = () => getCapableBleUtils() !== undefined;
+const isBleKeyMissingSupported = () => getCapableBleUtils$1() !== undefined;
 const startBleKeyMissingTracking = () => {
-    if (unsubscribeNative)
+    if (unsubscribeNative$1)
         return true;
-    const bleUtils = getCapableBleUtils();
+    const bleUtils = getCapableBleUtils$1();
     if (!(bleUtils === null || bleUtils === void 0 ? void 0 : bleUtils.onDeviceKeyMissing))
         return false;
-    unsubscribeNative = bleUtils.onDeviceKeyMissing(event => {
+    unsubscribeNative$1 = bleUtils.onDeviceKeyMissing(event => {
         if (typeof (event === null || event === void 0 ? void 0 : event.id) !== 'string')
             return;
-        const deviceId = normalizeDeviceId(event.id);
+        const deviceId = normalizeDeviceId$1(event.id);
         lastKeyMissingAt.set(deviceId, Date.now());
-        listeners.forEach(listener => listener(deviceId));
+        listeners$1.forEach(listener => listener(deviceId));
     });
     return true;
 };
 const stopBleKeyMissingTracking = () => {
-    unsubscribeNative === null || unsubscribeNative === void 0 ? void 0 : unsubscribeNative();
-    unsubscribeNative = undefined;
+    unsubscribeNative$1 === null || unsubscribeNative$1 === void 0 ? void 0 : unsubscribeNative$1();
+    unsubscribeNative$1 = undefined;
     lastKeyMissingAt.clear();
-    listeners.clear();
+    listeners$1.clear();
 };
 const hasBleKeyMissingSince = (deviceId, sinceMs) => {
-    const at = lastKeyMissingAt.get(normalizeDeviceId(deviceId));
+    const at = lastKeyMissingAt.get(normalizeDeviceId$1(deviceId));
     return at !== undefined && at >= sinceMs;
 };
 const onBleKeyMissing = (deviceId, callback) => {
-    const target = normalizeDeviceId(deviceId);
+    const target = normalizeDeviceId$1(deviceId);
     const listener = id => {
         if (id === target)
             callback();
     };
-    listeners.add(listener);
+    listeners$1.add(listener);
     return () => {
-        listeners.delete(listener);
+        listeners$1.delete(listener);
     };
 };
 const waitForBleKeyMissing = (deviceId, sinceMs, timeoutMs) => {
@@ -328,6 +328,172 @@ 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]
@@ -485,6 +651,8 @@ const shouldRethrowProtocolProbeError = (error) => {
 };
 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 code = error === null || error === void 0 ? void 0 : error.errorCode;
     return (isNativeBleDisconnectError(error) ||
@@ -493,6 +661,33 @@ const isAndroidLinkLossError = (error) => {
         code === hdShared.HardwareErrorCode.BleCharacteristicNotifyError ||
         code === hdShared.HardwareErrorCode.BleConnectedError);
 };
+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 IOS_PROBE_DISCONNECT_EVIDENCE_TTL_MS = 5 * 60000;
+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);
+};
 const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 const DEVICE_SCAN_TIMEOUT_MS = 3000;
 const IOS_NOTIFY_READY_DELAY_MS = 150;
@@ -688,6 +883,7 @@ 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();
@@ -738,6 +934,10 @@ class ReactNativeBleTransport {
     init(logger, emitter) {
         setBleLogger(logger);
         this.emitter = emitter;
+        if (reactNative.Platform.OS === 'android') {
+            startBleKeyMissingTracking();
+            startBleEncryptionTracking();
+        }
     }
     configure(signedData) {
         const messages = parseConfigure(signedData);
@@ -1186,6 +1386,7 @@ 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) {
@@ -1214,9 +1415,11 @@ class ReactNativeBleTransport {
                 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,
@@ -1390,7 +1593,13 @@ 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,
@@ -1429,6 +1638,9 @@ 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) {
@@ -1665,6 +1877,31 @@ class ReactNativeBleTransport {
             });
         });
     }
+    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;
+        });
+    }
     callProtocolV1(uuid, name, data, options) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._messages) {
@@ -1880,6 +2117,8 @@ class ReactNativeBleTransport {
         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;
@@ -2365,6 +2604,50 @@ 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.getIosProbeDisconnectEvidence(uuid);
+        const errorCode = error === null || error === void 0 ? void 0 : error.errorCode;
+        const evidence = Object.assign(Object.assign({ phase }, (typeof errorCode === 'string' || typeof errorCode === 'number' ? { errorCode } : {})), { recordedAt: Date.now() });
+        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.confirmIosProbeDisconnect(uuid, 'repeated-probe-disconnect');
+    }
+    getIosProbeDisconnectEvidence(uuid) {
+        const evidence = this.iosProbeDisconnectEvidence.get(uuid);
+        if (!evidence)
+            return undefined;
+        const ageMs = Date.now() - evidence.recordedAt;
+        if (ageMs <= IOS_PROBE_DISCONNECT_EVIDENCE_TTL_MS)
+            return evidence;
+        this.iosProbeDisconnectEvidence.delete(uuid);
+        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport][BleBondDiagnostic] probe disconnect expired', {
+            triggerPhase: evidence.phase,
+            triggerErrorCode: evidence.errorCode,
+            ageMs,
+        });
+        return undefined;
+    }
+    confirmIosProbeDisconnect(uuid, confirmation) {
+        const evidence = this.getIosProbeDisconnectEvidence(uuid);
+        if (!evidence)
+            return undefined;
+        Log === null || Log === void 0 ? void 0 : Log.debug('[ReactNativeBleTransport][BleBondDiagnostic] stale bond confirmed', {
+            confirmation,
+            triggerPhase: evidence.phase,
+            triggerErrorCode: evidence.errorCode,
+            evidenceAgeMs: Date.now() - evidence.recordedAt,
+            finalErrorCode: hdShared.HardwareErrorCode.BleBondInvalid,
+        });
+        return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleBondInvalid);
+    }
     clearProbeProtocol(uuid, protocol) {
         if (this.probingProtocols.get(uuid) === protocol) {
             this.probingProtocols.delete(uuid);
@@ -2378,9 +2661,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,
@@ -2394,6 +2678,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);
@@ -2404,6 +2689,19 @@ class ReactNativeBleTransport {
                     });
                     return 'V2';
                 }
+                const staleBondError = this.confirmIosProbeDisconnect(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);
@@ -2427,6 +2725,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') {
@@ -2452,6 +2751,26 @@ class ReactNativeBleTransport {
             }
             this.deviceProtocol.delete(uuid);
             this.probingProtocols.delete(uuid);
+            const staleBondError = this.confirmIosProbeDisconnect(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.iosProbeDisconnectEvidence.has(uuid),
+                    finalErrorCode: staleBondError
+                        ? hdShared.HardwareErrorCode.BleBondInvalid
+                        : hdShared.HardwareErrorCode.BleTimeoutError,
+                });
+            }
+            if (staleBondError)
+                throw staleBondError;
             throw this.createProtocolDetectionError();
         });
     }
@@ -2535,7 +2854,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;
@@ -2551,18 +2875,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');
             }
@@ -2913,10 +3247,12 @@ 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;

package/package.json

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