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

package/dist/BleManager.d.ts

@@ -1,9 +1,10 @@
 import type { Peripheral } from '@onekeyfe/react-native-ble-utils';
 export declare const getConnectedDeviceIds: (serviceUuids: string[]) => Promise<Peripheral[]>;
 export declare const getBondedDevices: () => Promise<Peripheral[]>;
-export declare const pairDevice: (macAddress: string) => Promise<{
-    bonded: boolean;
-    bonding: boolean;
-}>;
-export declare const onDeviceBondState: (bleMacAddress: string, signal?: AbortSignal) => Promise<Peripheral | undefined>;
+export declare const pairDevice: (macAddress: string) => Promise<import("@onekeyfe/react-native-ble-utils").PairDeviceResult>;
+export declare const SYSTEM_BONDING_RESTART_WINDOW_MS = 1500;
+export type DeviceBondStateOptions = {
+    systemInitiated?: boolean;
+};
+export declare const onDeviceBondState: (bleMacAddress: string, signal?: AbortSignal, options?: DeviceBondStateOptions) => Promise<Peripheral | undefined>;
 //# sourceMappingURL=BleManager.d.ts.map

package/dist/BleManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BleManager.d.ts","sourceRoot":"","sources":["../src/BleManager.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAsBnE,eAAO,MAAM,qBAAqB,iBAAkB,MAAM,EAAE,0BACZ,CAAC;AAEjD,eAAO,MAAM,gBAAgB,6BAAwC,CAAC;AAEtE,eAAO,MAAM,UAAU,eAAgB,MAAM;;;EAAoC,CAAC;AAElF,eAAO,MAAM,iBAAiB,kBACb,MAAM,WACZ,WAAW,KACnB,QAAQ,UAAU,GAAG,SAAS,CAmF7B,CAAC"}
+{"version":3,"file":"BleManager.d.ts","sourceRoot":"","sources":["../src/BleManager.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAsBnE,eAAO,MAAM,qBAAqB,iBAAkB,MAAM,EAAE,0BACZ,CAAC;AAEjD,eAAO,MAAM,gBAAgB,6BAAwC,CAAC;AAEtE,eAAO,MAAM,UAAU,eAAgB,MAAM,yEAAoC,CAAC;AAMlF,eAAO,MAAM,gCAAgC,OAAO,CAAC;AAErD,MAAM,MAAM,sBAAsB,GAAG;IAMnC,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAkCF,eAAO,MAAM,iBAAiB,kBACb,MAAM,WACZ,WAAW,YACV,sBAAsB,KAC/B,QAAQ,UAAU,GAAG,SAAS,CA0E7B,CAAC"}

package/dist/bleKeyMissing.d.ts

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

package/dist/bleKeyMissing.d.ts.map

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

package/dist/index.d.ts

@@ -62,6 +62,14 @@ declare const getFirmwareUploadWriteRetryType: (error: unknown) => FirmwareUploa
  */
 declare const BLE_WRITE_PACKET_TIMEOUT_MS = 10000;
 declare const BLE_NATIVE_TEARDOWN_TIMEOUT_MS = 3000;
+/**
+ * Android reports a lost bond (ACTION_KEY_MISSING) while it encrypts a new link, so only
+ * a failure this soon after the link started can be explained by it. Later disconnects,
+ * such as a firmware-update reboot, must keep their own meaning.
+ */
+declare const ANDROID_KEY_MISSING_LINK_WINDOW_MS = 10000;
+/** The broadcast and the GATT disconnect it explains travel separately; either can land first. */
+declare const ANDROID_KEY_MISSING_GRACE_MS = 500;
 /** Consecutive wedged writes on one device before the BLE manager itself is recreated. */
 declare const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 type ProtocolV2BleTuning = {
@@ -155,6 +163,8 @@ declare class ReactNativeBleTransport {
      * fails with ATT 5/15. Remember it so detectProtocol fails immediately.
      */
     private staleBondErrors;
+    /** When the current Android link attempt began; bounds which key-missing signals apply. */
+    private androidLinkStartedAt;
     /** Strict or previously confirmed V2 target while acquire installs notifications. */
     private acquiringProtocolV2;
     private protocolV2Assemblers;
@@ -200,6 +210,12 @@ declare class ReactNativeBleTransport {
     private releaseNative;
     post(session: string, name: string, data: Record<string, unknown>): Promise<void>;
     call(uuid: string, name: string, data: Record<string, unknown>, options?: TransportCallOptions): Promise<transport.MessageFromOneKey>;
+    /**
+     * Android 16+ keeps a bond the device no longer holds keys for. The device drops the link
+     * and the only structured evidence is ACTION_KEY_MISSING, so a link loss right after
+     * connect is re-read as an invalid bond when that signal belongs to the same attempt.
+     */
+    private resolveAndroidBondInvalid;
     private callProtocolV1;
     stop(): Promise<void>;
     disconnect(session: string): Promise<void>;
@@ -279,4 +295,4 @@ declare class ReactNativeBleTransport {
     getProtocolType(path: string): ProtocolType | undefined;
 }
 
-export { ANDROID_LINK_DROP_QUIET_MS, ANDROID_MTU_EXCHANGE_TIMEOUT_MS, BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD, BLE_CONNECT_TIMEOUT_MS, BLE_GATT_SETUP_TIMEOUT_MS, BLE_NATIVE_TEARDOWN_TIMEOUT_MS, BLE_SETUP_WEDGED_MESSAGE, BLE_WRITE_PACKET_TIMEOUT_MS, BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD, IOneKeyDevice, PROTOCOL_REPROBE_FALLBACK_ATTEMPTS, ProtocolV2BleTuning, configureProtocolV2BleTuning, ReactNativeBleTransport as default, getFirmwareUploadWriteRetryType, getProtocolV2BleTuning, resetProtocolV2BleTuning };
+export { ANDROID_KEY_MISSING_GRACE_MS, ANDROID_KEY_MISSING_LINK_WINDOW_MS, ANDROID_LINK_DROP_QUIET_MS, ANDROID_MTU_EXCHANGE_TIMEOUT_MS, BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD, BLE_CONNECT_TIMEOUT_MS, BLE_GATT_SETUP_TIMEOUT_MS, BLE_NATIVE_TEARDOWN_TIMEOUT_MS, BLE_SETUP_WEDGED_MESSAGE, BLE_WRITE_PACKET_TIMEOUT_MS, BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD, IOneKeyDevice, PROTOCOL_REPROBE_FALLBACK_ATTEMPTS, ProtocolV2BleTuning, configureProtocolV2BleTuning, ReactNativeBleTransport as default, getFirmwareUploadWriteRetryType, getProtocolV2BleTuning, resetProtocolV2BleTuning };

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

@@ -46,6 +46,76 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+const lastKeyMissingAt = new Map();
+const listeners = new Set();
+let unsubscribeNative;
+const normalizeDeviceId = (deviceId) => deviceId.toLowerCase();
+const getCapableBleUtils = () => {
+    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() !== undefined;
+const startBleKeyMissingTracking = () => {
+    if (unsubscribeNative)
+        return true;
+    const bleUtils = getCapableBleUtils();
+    if (!(bleUtils === null || bleUtils === void 0 ? void 0 : bleUtils.onDeviceKeyMissing))
+        return false;
+    unsubscribeNative = bleUtils.onDeviceKeyMissing(event => {
+        if (typeof (event === null || event === void 0 ? void 0 : event.id) !== 'string')
+            return;
+        const deviceId = normalizeDeviceId(event.id);
+        lastKeyMissingAt.set(deviceId, Date.now());
+        listeners.forEach(listener => listener(deviceId));
+    });
+    return true;
+};
+const stopBleKeyMissingTracking = () => {
+    unsubscribeNative === null || unsubscribeNative === void 0 ? void 0 : unsubscribeNative();
+    unsubscribeNative = undefined;
+    lastKeyMissingAt.clear();
+    listeners.clear();
+};
+const hasBleKeyMissingSince = (deviceId, sinceMs) => {
+    const at = lastKeyMissingAt.get(normalizeDeviceId(deviceId));
+    return at !== undefined && at >= sinceMs;
+};
+const onBleKeyMissing = (deviceId, callback) => {
+    const target = normalizeDeviceId(deviceId);
+    const listener = id => {
+        if (id === target)
+            callback();
+    };
+    listeners.add(listener);
+    return () => {
+        listeners.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;
@@ -70,17 +140,35 @@ const bondFailureReasons = {
 };
 const getConnectedDeviceIds = (serviceUuids) => BleUtils__default["default"].getConnectedPeripherals(serviceUuids);
 const pairDevice = (macAddress) => BleUtils__default["default"].pairDevice(macAddress);
-const onDeviceBondState = (bleMacAddress, signal) => new Promise((resolve, reject) => {
+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) => {
     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 = () => {
@@ -95,35 +183,44 @@ const onDeviceBondState = (bleMacAddress, signal) => new Promise((resolve, rejec
             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, _b;
+        var _a;
         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();
-            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));
-            }
+            reject(createBondFailureError(bondState));
         }
     });
 });
@@ -386,6 +483,16 @@ 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 isAndroidLinkLossError = (error) => {
+    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);
+};
 const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 const DEVICE_SCAN_TIMEOUT_MS = 3000;
 const IOS_NOTIFY_READY_DELAY_MS = 150;
@@ -583,6 +690,7 @@ class ReactNativeBleTransport {
         this.silentDetections = 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();
@@ -1016,7 +1124,14 @@ class ReactNativeBleTransport {
             if (!uuid) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleRequiredUUID);
             }
-            return this.runLifecycleOperation(uuid, () => this.acquireUnlocked(input));
+            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);
+                }
+            }));
         });
     }
     acquireUnlocked(input) {
@@ -1098,10 +1213,14 @@ class ReactNativeBleTransport {
             if (this.stopped)
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             if (reactNative.Platform.OS === 'android') {
+                startBleKeyMissingTracking();
+                this.androidLinkStartedAt.delete(uuid);
                 try {
                     const bondState = yield pairDevice(uuid);
                     if (bondState.bonding) {
-                        yield onDeviceBondState(uuid, this.bondAbortController.signal);
+                        yield onDeviceBondState(uuid, this.bondAbortController.signal, {
+                            systemInitiated: bondState.initiated === false,
+                        });
                     }
                     else if (!bondState.bonded) {
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
@@ -1113,6 +1232,7 @@ class ReactNativeBleTransport {
                     }));
                     throw error;
                 }
+                this.androidLinkStartedAt.set(uuid, Date.now());
             }
             if (this.stopped)
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
@@ -1510,14 +1630,39 @@ 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 (this.runPromise && !forceRun) {
+            if (protocol !== 'V2' && this.runPromise && !forceRun) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.TransportCallInProgress);
             }
-            return this.callProtocolV1(uuid, name, data, options);
+            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',
+            });
         });
     }
     callProtocolV1(uuid, name, data, options) {
@@ -1733,6 +1878,8 @@ class ReactNativeBleTransport {
         this.androidPriorityResetTimers.forEach(timeout => clearTimeout(timeout));
         this.androidPriorityResetTimers.clear();
         this.androidHighPriorityDevices.clear();
+        this.androidLinkStartedAt.clear();
+        stopBleKeyMissingTracking();
         const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
         (_a = this.runPromise) === null || _a === void 0 ? void 0 : _a.reject(error);
         this.runPromise = null;
@@ -2766,6 +2913,8 @@ class ReactNativeBleTransport {
     }
 }
 
+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.BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD = BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-react-native",
-  "version": "1.2.3-alpha.7",
+  "version": "1.2.3-alpha.9",
   "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.7",
-    "@onekeyfe/hd-shared": "1.2.3-alpha.7",
-    "@onekeyfe/hd-transport": "1.2.3-alpha.7",
-    "@onekeyfe/react-native-ble-utils": "0.1.6",
+    "@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",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "b71eb64f2fc6b58ec7847f93cc99225bfec04d5b"
+  "gitHead": "0fc494d4b87cf3dcc4eb1fbe3910a3cbc914e5f5"
 }

package/src/BleManager.ts

@@ -1,6 +1,7 @@
 import BleUtils from '@onekeyfe/react-native-ble-utils';
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
+import { onBleKeyMissing, startBleKeyMissingTracking } from './bleKeyMissing';
 import { bleLogger } from './logger';
 
 import type { Peripheral } from '@onekeyfe/react-native-ble-utils';
@@ -32,20 +33,71 @@ export const getBondedDevices = () => BleUtils.getBondedPeripherals();
 
 export const pairDevice = (macAddress: string) => BleUtils.pairDevice(macAddress);
 
+/**
+ * Android replaces a bond as BONDING -> NONE, then NONE -> BONDING within milliseconds.
+ * The window covers slow broadcast delivery before the first half counts as a failure.
+ */
+export const SYSTEM_BONDING_RESTART_WINDOW_MS = 1500;
+
+export type DeviceBondStateOptions = {
+  /**
+   * The system, not this transport, started the bonding in progress. Android 16+ re-pairs
+   * by itself after it detects a lost bond, and a successful re-pair replaces the old bond
+   * instead of going straight to BONDED.
+   */
+  systemInitiated?: boolean;
+};
+
+const createBondFailureError = (bondState: Peripheral['bondState']) => {
+  const nativeReason =
+    'reason' in bondState && typeof bondState.reason === 'number' ? bondState.reason : undefined;
+  const reason =
+    nativeReason === undefined ? 'unknown' : bondFailureReasons[nativeReason] ?? 'unknown';
+  const params = {
+    phase: 'bond',
+    reason,
+    ...(nativeReason === undefined ? {} : { nativeReason }),
+  };
+  if (reason === 'timeout') {
+    // Connection timeouts are retried by Core; pairing requires a new user attempt.
+    return ERRORS.TypedError(
+      HardwareErrorCode.BleDeviceNotBonded,
+      'Bluetooth pairing timed out',
+      params
+    );
+  }
+  if (reason === 'canceled') {
+    return ERRORS.TypedError(
+      HardwareErrorCode.BleDeviceBondedCanceled,
+      'Bluetooth pairing canceled',
+      params
+    );
+  }
+  return ERRORS.TypedError(
+    HardwareErrorCode.BleDeviceNotBonded,
+    'Bluetooth pairing failed',
+    params
+  );
+};
+
 export const onDeviceBondState = (
   bleMacAddress: string,
-  signal?: AbortSignal
+  signal?: AbortSignal,
+  options?: DeviceBondStateOptions
 ): Promise<Peripheral | undefined> =>
   new Promise((resolve, reject) => {
     if (signal?.aborted) {
       reject(ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected));
       return;
     }
+    let pendingFailure: ReturnType<typeof setTimeout> | undefined;
     const cleanup = () => {
       if (timeout) {
         clearTimeout(timeout);
       }
+      if (pendingFailure) clearTimeout(pendingFailure);
       if (cleanupListener) cleanupListener();
+      cleanupKeyMissing?.();
       signal?.removeEventListener('abort', onAbort);
     };
     const onAbort = () => {
@@ -65,6 +117,20 @@ export const onDeviceBondState = (
       );
     }, 60 * 1000);
 
+    // A failed system re-pair restores the old bond, so it also ends in BONDED. Key
+    // missing is what tells it apart from a bond that now works.
+    const cleanupKeyMissing = startBleKeyMissingTracking()
+      ? onBleKeyMissing(bleMacAddress, () => {
+          cleanup();
+          reject(
+            ERRORS.TypedError(HardwareErrorCode.BleBondInvalid, undefined, {
+              phase: 'bond',
+              reason: 'key_missing',
+            })
+          );
+        })
+      : undefined;
+
     const cleanupListener = BleUtils.onDeviceBondState(peripheral => {
       if (peripheral.id?.toLowerCase() !== bleMacAddress.toLowerCase()) {
         return;
@@ -73,49 +139,23 @@ export const onDeviceBondState = (
 
       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?.systemInitiated) {
+        if (pendingFailure) clearTimeout(pendingFailure);
+        pendingFailure = setTimeout(() => {
+          cleanup();
+          reject(createBondFailureError(bondState));
+        }, SYSTEM_BONDING_RESTART_WINDOW_MS);
       } else if (hasFailed) {
         cleanup();
-        const nativeReason =
-          'reason' in bondState && typeof bondState.reason === 'number'
-            ? bondState.reason
-            : undefined;
-        const reason =
-          nativeReason === undefined ? 'unknown' : bondFailureReasons[nativeReason] ?? 'unknown';
-        const params = {
-          phase: 'bond',
-          reason,
-          ...(nativeReason === undefined ? {} : { nativeReason }),
-        };
-        if (reason === 'timeout') {
-          // Connection timeouts are retried by Core; pairing requires a new user attempt.
-          reject(
-            ERRORS.TypedError(
-              HardwareErrorCode.BleDeviceNotBonded,
-              'Bluetooth pairing timed out',
-              params
-            )
-          );
-        } else if (reason === 'canceled') {
-          reject(
-            ERRORS.TypedError(
-              HardwareErrorCode.BleDeviceBondedCanceled,
-              'Bluetooth pairing canceled',
-              params
-            )
-          );
-        } else {
-          reject(
-            ERRORS.TypedError(
-              HardwareErrorCode.BleDeviceNotBonded,
-              'Bluetooth pairing failed',
-              params
-            )
-          );
-        }
+        reject(createBondFailureError(bondState));
       }
     });
   });

package/src/__tests__/androidKeyMissing.test.ts

@@ -0,0 +1,307 @@
+import EventEmitter from 'events';
+
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import ReactNativeBleTransport, {
+  ANDROID_KEY_MISSING_GRACE_MS,
+  ANDROID_KEY_MISSING_LINK_WINDOW_MS,
+} from '../index';
+import { SYSTEM_BONDING_RESTART_WINDOW_MS, onDeviceBondState } from '../BleManager';
+import { stopBleKeyMissingTracking } from '../bleKeyMissing';
+import protocolV1Schema from './protocolV1SchemaFixture';
+
+let mockKeyMissingSupported = true;
+let mockEmitKeyMissing: ((event: { id?: string }) => void) | undefined;
+let mockEmitBondState: ((peripheral: unknown) => void) | undefined;
+
+jest.mock(
+  'react-native',
+  () => ({
+    Platform: { OS: 'android', select: (spec: Record<string, unknown>) => spec.android },
+    PermissionsAndroid: {
+      PERMISSIONS: {},
+      RESULTS: {},
+      request: jest.fn(),
+      requestMultiple: jest.fn(),
+    },
+  }),
+  { virtual: true }
+);
+
+jest.mock('react-native-ble-plx', () => ({
+  BleATTErrorCode: { InvalidHandle: 1 },
+  BleError: Error,
+  BleErrorCode: { DeviceDisconnected: 201, OperationStartFailed: 601 },
+  BleManager: jest.fn(),
+  ScanMode: { LowLatency: 2 },
+}));
+
+jest.mock('@onekeyfe/react-native-ble-utils', () => ({
+  __esModule: true,
+  default: {
+    getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
+    getBondedPeripherals: jest.fn(() => Promise.resolve([])),
+    pairDevice: jest.fn(() => Promise.resolve({ bonded: true, bonding: false })),
+    supportsDeviceKeyMissing: jest.fn(() => mockKeyMissingSupported),
+    onDeviceKeyMissing: jest.fn((callback: (event: { id?: string }) => void) => {
+      mockEmitKeyMissing = callback;
+      return () => {
+        mockEmitKeyMissing = undefined;
+      };
+    }),
+    onDeviceBondState: jest.fn((callback: (peripheral: unknown) => void) => {
+      mockEmitBondState = callback;
+      return () => {
+        mockEmitBondState = undefined;
+      };
+    }),
+  },
+}));
+
+const UUID = 'CC:06:1C:FD:48:E9';
+
+const flush = () =>
+  new Promise(resolve => {
+    setImmediate(resolve);
+  });
+
+const advance = async (ms: number) => {
+  jest.advanceTimersByTime(ms);
+  await flush();
+};
+
+// What ble-plx reports when the device drops the link while the first write is queued.
+const peerTerminated = () =>
+  Promise.reject(
+    Object.assign(new Error(`Device ${UUID} was disconnected`), {
+      errorCode: 201,
+      attErrorCode: 19,
+      reason: 'Disconnected with status 19 (GATT_CONN_TERMINATE_PEER_USER)',
+    })
+  );
+
+function createConnectedTransport(linkAgeMs = 0) {
+  const t = new ReactNativeBleTransport({});
+  t.configure(protocolV1Schema);
+  (t as any).deviceProtocol.set(UUID, 'V1');
+  (t as any).getCachedTransport = () => ({
+    writeCharacteristic: { writeWithoutResponse: jest.fn(peerTerminated) },
+  });
+  (t as any).androidLinkStartedAt.set(UUID, Date.now() - linkAgeMs);
+  return t;
+}
+
+const settle = (promise: Promise<unknown>) => {
+  const outcome: { error?: { errorCode?: unknown }; done: boolean } = { done: false };
+  promise.then(
+    () => {
+      outcome.done = true;
+    },
+    error => {
+      outcome.error = error;
+      outcome.done = true;
+    }
+  );
+  return outcome;
+};
+
+describe('Android key missing', () => {
+  beforeEach(() => {
+    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
+    mockKeyMissingSupported = true;
+  });
+
+  afterEach(() => {
+    stopBleKeyMissingTracking();
+    jest.clearAllTimers();
+    jest.useRealTimers();
+  });
+
+  describe('link dropped right after connect', () => {
+    test('reports an invalid bond when the system says the keys are missing', async () => {
+      const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
+      await flush();
+      // The broadcast is delivered separately and can trail the GATT disconnect.
+      mockEmitKeyMissing?.({ id: UUID.toLowerCase() });
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+    });
+
+    test('keeps the original error when no key missing follows', async () => {
+      const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
+      await flush();
+      expect(outcome.done).toBe(false);
+
+      await advance(ANDROID_KEY_MISSING_GRACE_MS);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('ignores key missing reported for an earlier link', async () => {
+      const transport = createConnectedTransport();
+      const earlier = settle(transport.call(UUID, 'GetFeatures', {}));
+      await flush();
+      mockEmitKeyMissing?.({ id: UUID });
+      await flush();
+      expect(earlier.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+
+      // The user re-paired; a later link that drops is an ordinary disconnect.
+      await advance(1000);
+      (transport as any).androidLinkStartedAt.set(UUID, Date.now());
+      const later = settle(transport.call(UUID, 'GetFeatures', {}));
+      await flush();
+      await advance(ANDROID_KEY_MISSING_GRACE_MS);
+
+      expect(later.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('ignores key missing for another device', async () => {
+      const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
+      await flush();
+      mockEmitKeyMissing?.({ id: 'E9:B9:F4:DD:DE:CD' });
+      await advance(ANDROID_KEY_MISSING_GRACE_MS);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('does not wait on a link that has been up for a while', async () => {
+      const transport = createConnectedTransport(ANDROID_KEY_MISSING_LINK_WINDOW_MS + 1);
+      const outcome = settle(transport.call(UUID, 'GetFeatures', {}));
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('does not wait when the OS or native build never reports key missing', async () => {
+      mockKeyMissingSupported = false;
+      const outcome = settle(createConnectedTransport().call(UUID, 'GetFeatures', {}));
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+  });
+
+  describe('acquire over a bond the device no longer holds', () => {
+    // Android still reports BONDED, so connect, MTU and GATT setup all succeed and the
+    // protocol probe is the first operation to meet the dropped link.
+    function createStaleBondHarness() {
+      const writeCharacteristic = {
+        uuid: '00000002-0000-1000-8000-00805f9b34fb',
+        isWritableWithoutResponse: true,
+        writeWithoutResponse: jest.fn(peerTerminated),
+      };
+      const notifyCharacteristic = {
+        uuid: '00000003-0000-1000-8000-00805f9b34fb',
+        isNotifiable: true,
+        monitor: jest.fn(() => ({ remove: jest.fn() })),
+      };
+      const device = {
+        id: UUID,
+        name: 'Pro 2 48E9',
+        localName: 'Pro 2 48E9',
+        mtu: 247,
+        serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
+        isConnected: jest.fn(() => Promise.resolve(true)),
+        cancelConnection: jest.fn(() => Promise.resolve()),
+        discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
+        characteristicsForService: jest.fn(() =>
+          Promise.resolve([writeCharacteristic, notifyCharacteristic])
+        ),
+        services: jest.fn(() => Promise.resolve([])),
+        onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
+      };
+      const transport = new ReactNativeBleTransport({});
+      (transport as any).blePlxManager = {
+        devices: jest.fn(() => Promise.resolve([device])),
+        connectedDevices: jest.fn(() => Promise.resolve([])),
+        cancelTransaction: jest.fn(() => Promise.resolve()),
+        cancelDeviceConnection: jest.fn(() => Promise.resolve()),
+        onStateChange: jest.fn((listener: (state: string) => void) => {
+          setImmediate(() => listener('PoweredOn'));
+          return { remove: jest.fn() };
+        }),
+        state: jest.fn(() => Promise.resolve('PoweredOn')),
+      };
+      transport.init(
+        { debug: jest.fn(), error: jest.fn(), warn: jest.fn() } as any,
+        new EventEmitter()
+      );
+      transport.configure(protocolV1Schema);
+      return { transport, write: writeCharacteristic.writeWithoutResponse };
+    }
+
+    async function acquireUntilSettled(keyMissing: boolean) {
+      const { transport, write } = createStaleBondHarness();
+      const outcome = settle(transport.acquire({ uuid: UUID }));
+      for (let i = 0; i < 100 && !outcome.done; i += 1) {
+        // eslint-disable-next-line no-await-in-loop
+        await advance(100);
+        // The broadcast follows the dropped link, which the probe write is first to meet.
+        if (keyMissing && write.mock.calls.length > 0) mockEmitKeyMissing?.({ id: UUID });
+      }
+      expect(write).toHaveBeenCalled();
+      return JSON.parse(JSON.stringify(ERRORS.serializeError({ error: outcome.error })));
+    }
+
+    test('ends as an invalid bond that survives the Core response path', async () => {
+      await expect(acquireUntilSettled(true)).resolves.toEqual({
+        code: HardwareErrorCode.BleBondInvalid,
+        error: expect.stringContaining('Forget the device'),
+        params: { phase: 'connect', reason: 'key_missing' },
+      });
+    });
+
+    test('keeps the legacy error when the system reports nothing', async () => {
+      await expect(acquireUntilSettled(false)).resolves.toMatchObject({
+        code: HardwareErrorCode.BleDeviceNotBonded,
+      });
+    });
+  });
+
+  describe('waiting for bonding', () => {
+    const bondState = (preState: string, state: string) =>
+      mockEmitBondState?.({ id: UUID, bondState: { preState, state } });
+
+    test('fails as an invalid bond when the system re-pair ends in key missing', async () => {
+      const outcome = settle(onDeviceBondState(UUID, undefined, { systemInitiated: true }));
+      mockEmitKeyMissing?.({ id: UUID });
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleBondInvalid);
+    });
+
+    test('follows a system re-pair that replaces the bond', async () => {
+      const outcome = settle(onDeviceBondState(UUID, undefined, { systemInitiated: true }));
+      bondState('BOND_BONDING', 'BOND_NONE');
+      bondState('BOND_NONE', 'BOND_BONDING');
+      await advance(SYSTEM_BONDING_RESTART_WINDOW_MS);
+      expect(outcome.done).toBe(false);
+
+      bondState('BOND_BONDING', 'BOND_BONDED');
+      await flush();
+
+      expect(outcome.done).toBe(true);
+      expect(outcome.error).toBeUndefined();
+    });
+
+    test('fails a system re-pair that ends without a bond', async () => {
+      const outcome = settle(onDeviceBondState(UUID, undefined, { systemInitiated: true }));
+      bondState('BOND_BONDING', 'BOND_NONE');
+      await flush();
+      expect(outcome.done).toBe(false);
+
+      await advance(SYSTEM_BONDING_RESTART_WINDOW_MS);
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+
+    test('fails a bonding this transport started as soon as it ends without a bond', async () => {
+      const outcome = settle(onDeviceBondState(UUID));
+      bondState('BOND_BONDING', 'BOND_NONE');
+      await flush();
+
+      expect(outcome.error?.errorCode).toBe(HardwareErrorCode.BleDeviceNotBonded);
+    });
+  });
+});

package/src/__tests__/enumerate.test.ts

@@ -25,6 +25,14 @@ jest.mock('../BleManager', () => ({
   pairDevice: jest.fn(),
 }));
 
+// The native facade is replaced wholesale above; key missing is covered by its own suite.
+jest.mock('../bleKeyMissing', () => ({
+  isBleKeyMissingSupported: jest.fn(() => false),
+  startBleKeyMissingTracking: jest.fn(() => false),
+  stopBleKeyMissingTracking: jest.fn(),
+  waitForBleKeyMissing: jest.fn(() => Promise.resolve(false)),
+}));
+
 jest.mock('../subscribeBleOn', () => ({
   subscribeBleOn: jest.fn(() => Promise.resolve()),
 }));

package/src/__tests__/protocolV2Link.test.ts

@@ -45,6 +45,14 @@ jest.mock('../BleManager', () => ({
   pairDevice: jest.fn(() => Promise.resolve({ bonded: true, bonding: false })),
 }));
 
+// The native facade is replaced wholesale above; key missing is covered by its own suite.
+jest.mock('../bleKeyMissing', () => ({
+  isBleKeyMissingSupported: jest.fn(() => false),
+  startBleKeyMissingTracking: jest.fn(() => false),
+  stopBleKeyMissingTracking: jest.fn(),
+  waitForBleKeyMissing: jest.fn(() => Promise.resolve(false)),
+}));
+
 jest.mock('../subscribeBleOn', () => ({
   subscribeBleOn: jest.fn(() => Promise.resolve()),
 }));

package/src/bleKeyMissing.ts

@@ -0,0 +1,106 @@
+import { Platform } from 'react-native';
+import BleUtils from '@onekeyfe/react-native-ble-utils';
+
+/**
+ * Android 16+ keeps its side of a bond the device no longer has keys for, and reports it
+ * with ACTION_KEY_MISSING instead of a GATT status. The device then drops the link, so
+ * without this signal a wiped device is indistinguishable from any other disconnect.
+ *
+ * The signal only describes the link that was being encrypted when it fired. Callers must
+ * bound it to their own connection attempt with `sinceMs`; reusing an older one would turn
+ * an ordinary disconnect (a firmware-update reboot, for example) into a terminal bond error.
+ */
+
+// An app can still resolve a react-native-ble-utils older than 0.1.8, and the JS bundle can
+// run on a native build that predates the event, so neither method is assumed to exist.
+type KeyMissingCapableBleUtils = Partial<
+  Pick<typeof BleUtils, 'supportsDeviceKeyMissing' | 'onDeviceKeyMissing'>
+>;
+
+type KeyMissingListener = (deviceId: string) => void;
+
+const lastKeyMissingAt = new Map<string, number>();
+const listeners = new Set<KeyMissingListener>();
+let unsubscribeNative: (() => void) | undefined;
+
+const normalizeDeviceId = (deviceId: string) => deviceId.toLowerCase();
+
+const getCapableBleUtils = (): KeyMissingCapableBleUtils | undefined => {
+  if (Platform.OS !== 'android') return undefined;
+  const bleUtils: KeyMissingCapableBleUtils = BleUtils;
+  if (
+    typeof bleUtils.supportsDeviceKeyMissing !== 'function' ||
+    typeof bleUtils.onDeviceKeyMissing !== 'function'
+  ) {
+    return undefined;
+  }
+  return bleUtils.supportsDeviceKeyMissing() ? bleUtils : undefined;
+};
+
+/** False means the event can never fire here, so nothing should wait for it. */
+export const isBleKeyMissingSupported = () => getCapableBleUtils() !== undefined;
+
+/** Idempotent. Returns whether the signal is available on this OS and native build. */
+export const startBleKeyMissingTracking = (): boolean => {
+  if (unsubscribeNative) return true;
+  const bleUtils = getCapableBleUtils();
+  if (!bleUtils?.onDeviceKeyMissing) return false;
+
+  unsubscribeNative = bleUtils.onDeviceKeyMissing(event => {
+    if (typeof event?.id !== 'string') return;
+    const deviceId = normalizeDeviceId(event.id);
+    lastKeyMissingAt.set(deviceId, Date.now());
+    listeners.forEach(listener => listener(deviceId));
+  });
+  return true;
+};
+
+export const stopBleKeyMissingTracking = () => {
+  unsubscribeNative?.();
+  unsubscribeNative = undefined;
+  lastKeyMissingAt.clear();
+  listeners.clear();
+};
+
+export const hasBleKeyMissingSince = (deviceId: string, sinceMs: number): boolean => {
+  const at = lastKeyMissingAt.get(normalizeDeviceId(deviceId));
+  return at !== undefined && at >= sinceMs;
+};
+
+/** Calls back for every later signal on this device until the returned cleanup runs. */
+export const onBleKeyMissing = (deviceId: string, callback: () => void): (() => void) => {
+  const target = normalizeDeviceId(deviceId);
+  const listener: KeyMissingListener = id => {
+    if (id === target) callback();
+  };
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+};
+
+/**
+ * Resolves true once a signal at or after `sinceMs` exists for the device, false when
+ * none arrives within `timeoutMs`. The broadcast and the GATT disconnect it explains are
+ * delivered on separate paths, so the disconnect can reach JS first.
+ */
+export const waitForBleKeyMissing = (
+  deviceId: string,
+  sinceMs: number,
+  timeoutMs: number
+): Promise<boolean> => {
+  if (!startBleKeyMissingTracking()) return Promise.resolve(false);
+  if (hasBleKeyMissingSince(deviceId, sinceMs)) return Promise.resolve(true);
+
+  return new Promise(resolve => {
+    const settle = (found: boolean) => {
+      clearTimeout(timer);
+      cleanup();
+      resolve(found);
+    };
+    const cleanup = onBleKeyMissing(deviceId, () => {
+      if (hasBleKeyMissingSince(deviceId, sinceMs)) settle(true);
+    });
+    const timer = setTimeout(() => settle(false), timeoutMs);
+  });
+};

package/src/index.ts

@@ -47,6 +47,12 @@ import {
   getInfosForServiceUuid,
   isSameBleUuid,
 } from './constants';
+import {
+  isBleKeyMissingSupported,
+  startBleKeyMissingTracking,
+  stopBleKeyMissingTracking,
+  waitForBleKeyMissing,
+} from './bleKeyMissing';
 import { isNativeBleDisconnectError, toBleDisconnectHardwareError } from './bleNativeDisconnect';
 import {
   isBleStaleBondHardwareError,
@@ -188,6 +194,28 @@ const shouldRethrowProtocolProbeError = (error: unknown): boolean => {
     code === HardwareErrorCode.BleWriteCharacteristicError
   );
 };
+/**
+ * Android reports a lost bond (ACTION_KEY_MISSING) while it encrypts a new link, so only
+ * a failure this soon after the link started can be explained by it. Later disconnects,
+ * such as a firmware-update reboot, must keep their own meaning.
+ */
+export const ANDROID_KEY_MISSING_LINK_WINDOW_MS = 10_000;
+/** The broadcast and the GATT disconnect it explains travel separately; either can land first. */
+export const ANDROID_KEY_MISSING_GRACE_MS = 500;
+/**
+ * How a link dropped by a device that refuses a stale bond reaches JS. A wedged write is
+ * excluded: the system is still re-pairing then and has not reported key missing yet.
+ */
+const isAndroidLinkLossError = (error: unknown): boolean => {
+  const code = (error as { errorCode?: unknown })?.errorCode;
+  return (
+    isNativeBleDisconnectError(error) ||
+    code === HardwareErrorCode.BleDeviceNotBonded ||
+    code === HardwareErrorCode.BleDeviceDisconnected ||
+    code === HardwareErrorCode.BleCharacteristicNotifyError ||
+    code === HardwareErrorCode.BleConnectedError
+  );
+};
 /** Consecutive wedged writes on one device before the BLE manager itself is recreated. */
 export const BLE_WRITE_TIMEOUT_MANAGER_RESET_THRESHOLD = 2;
 const DEVICE_SCAN_TIMEOUT_MS = 3000;
@@ -540,6 +568,9 @@ export default class ReactNativeBleTransport {
    */
   private staleBondErrors: Map<string, Error> = new Map();
 
+  /** When the current Android link attempt began; bounds which key-missing signals apply. */
+  private androidLinkStartedAt: Map<string, number> = new Map();
+
   /** Strict or previously confirmed V2 target while acquire installs notifications. */
   private acquiringProtocolV2 = new Set<string>();
 
@@ -1055,7 +1086,13 @@ export default class ReactNativeBleTransport {
       throw ERRORS.TypedError(HardwareErrorCode.BleRequiredUUID);
     }
 
-    return this.runLifecycleOperation(uuid, () => this.acquireUnlocked(input));
+    return this.runLifecycleOperation(uuid, async () => {
+      try {
+        return await this.acquireUnlocked(input);
+      } catch (error) {
+        throw await this.resolveAndroidBondInvalid(uuid, error);
+      }
+    });
   }
 
   private async acquireUnlocked(input: FirmwareInstallBleAcquireInput) {
@@ -1166,11 +1203,17 @@ export default class ReactNativeBleTransport {
 
     if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
     if (Platform.OS === 'android') {
+      // Subscribe before the link exists: key missing is broadcast while Android encrypts it.
+      startBleKeyMissingTracking();
+      // Failures before the new link starts must not be read against the previous link.
+      this.androidLinkStartedAt.delete(uuid);
       // Initiate bonding locally before GATT can trigger peripheral-initiated pairing.
       try {
         const bondState = await pairDevice(uuid);
         if (bondState.bonding) {
-          await onDeviceBondState(uuid, this.bondAbortController.signal);
+          await onDeviceBondState(uuid, this.bondAbortController.signal, {
+            systemInitiated: bondState.initiated === false,
+          });
         } else if (!bondState.bonded) {
           throw ERRORS.TypedError(HardwareErrorCode.BleDeviceNotBonded, 'device is not bonded');
         }
@@ -1182,6 +1225,7 @@ export default class ReactNativeBleTransport {
         });
         throw error;
       }
+      this.androidLinkStartedAt.set(uuid, Date.now());
     }
     if (this.stopped) throw ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
 
@@ -1689,16 +1733,44 @@ export default class ReactNativeBleTransport {
         `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 (this.runPromise && !forceRun) {
+    if (protocol !== 'V2' && this.runPromise && !forceRun) {
       throw ERRORS.TypedError(HardwareErrorCode.TransportCallInProgress);
     }
 
-    return this.callProtocolV1(uuid, name, data, options);
+    try {
+      return protocol === 'V2'
+        ? await this.callProtocolV2(uuid, name, data, options)
+        : await this.callProtocolV1(uuid, name, data, options);
+    } catch (error) {
+      // An expected-V1 acquire skips the probe, so the first call is what meets the dropped link.
+      throw await this.resolveAndroidBondInvalid(uuid, error);
+    }
+  }
+
+  /**
+   * Android 16+ keeps a bond the device no longer holds keys for. The device drops the link
+   * and the only structured evidence is ACTION_KEY_MISSING, so a link loss right after
+   * connect is re-read as an invalid bond when that signal belongs to the same attempt.
+   */
+  private async resolveAndroidBondInvalid(uuid: string, error: unknown): Promise<unknown> {
+    if (Platform.OS !== 'android' || !isBleKeyMissingSupported()) return error;
+    if (isBleStaleBondHardwareError(error) || !isAndroidLinkLossError(error)) return error;
+    const linkStartedAt = this.androidLinkStartedAt.get(uuid);
+    if (
+      linkStartedAt === undefined ||
+      Date.now() - linkStartedAt > ANDROID_KEY_MISSING_LINK_WINDOW_MS
+    ) {
+      return error;
+    }
+    if (!(await waitForBleKeyMissing(uuid, linkStartedAt, ANDROID_KEY_MISSING_GRACE_MS))) {
+      return error;
+    }
+    Log?.debug('[ReactNativeBleTransport] Android key missing, bond is invalid:', uuid);
+    return ERRORS.TypedError(HardwareErrorCode.BleBondInvalid, undefined, {
+      phase: 'connect',
+      reason: 'key_missing',
+    });
   }
 
   private async callProtocolV1(
@@ -1966,6 +2038,8 @@ export default class ReactNativeBleTransport {
     this.androidPriorityResetTimers.forEach(timeout => clearTimeout(timeout));
     this.androidPriorityResetTimers.clear();
     this.androidHighPriorityDevices.clear();
+    this.androidLinkStartedAt.clear();
+    stopBleKeyMissingTracking();
     const error = ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected);
     this.runPromise?.reject(error);
     this.runPromise = null;