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

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$1 = new Set();
+let unsubscribeNative$1;
+const normalizeDeviceId$1 = (deviceId) => deviceId.toLowerCase();
+const getCapableBleUtils$1 = () => {
+    if (reactNative.Platform.OS !== 'android')
+        return undefined;
+    const bleUtils = BleUtils__default["default"];
+    if (typeof bleUtils.supportsDeviceKeyMissing !== 'function' ||
+        typeof bleUtils.onDeviceKeyMissing !== 'function') {
+        return undefined;
+    }
+    return bleUtils.supportsDeviceKeyMissing() ? bleUtils : undefined;
+};
+const isBleKeyMissingSupported = () => getCapableBleUtils$1() !== undefined;
+const startBleKeyMissingTracking = () => {
+    if (unsubscribeNative$1)
+        return true;
+    const bleUtils = getCapableBleUtils$1();
+    if (!(bleUtils === null || bleUtils === void 0 ? void 0 : bleUtils.onDeviceKeyMissing))
+        return false;
+    unsubscribeNative$1 = bleUtils.onDeviceKeyMissing(event => {
+        if (typeof (event === null || event === void 0 ? void 0 : event.id) !== 'string')
+            return;
+        const deviceId = normalizeDeviceId$1(event.id);
+        lastKeyMissingAt.set(deviceId, Date.now());
+        listeners$1.forEach(listener => listener(deviceId));
+    });
+    return true;
+};
+const stopBleKeyMissingTracking = () => {
+    unsubscribeNative$1 === null || unsubscribeNative$1 === void 0 ? void 0 : unsubscribeNative$1();
+    unsubscribeNative$1 = undefined;
+    lastKeyMissingAt.clear();
+    listeners$1.clear();
+};
+const hasBleKeyMissingSince = (deviceId, sinceMs) => {
+    const at = lastKeyMissingAt.get(normalizeDeviceId$1(deviceId));
+    return at !== undefined && at >= sinceMs;
+};
+const onBleKeyMissing = (deviceId, callback) => {
+    const target = normalizeDeviceId$1(deviceId);
+    const listener = id => {
+        if (id === target)
+            callback();
+    };
+    listeners$1.add(listener);
+    return () => {
+        listeners$1.delete(listener);
+    };
+};
+const waitForBleKeyMissing = (deviceId, sinceMs, timeoutMs) => {
+    if (!startBleKeyMissingTracking())
+        return Promise.resolve(false);
+    if (hasBleKeyMissingSince(deviceId, sinceMs))
+        return Promise.resolve(true);
+    return new Promise(resolve => {
+        const settle = (found) => {
+            clearTimeout(timer);
+            cleanup();
+            resolve(found);
+        };
+        const cleanup = onBleKeyMissing(deviceId, () => {
+            if (hasBleKeyMissingSince(deviceId, sinceMs))
+                settle(true);
+        });
+        const timer = setTimeout(() => settle(false), timeoutMs);
+    });
+};
+
 let activeLogger;
 const setBleLogger = (logger) => {
     activeLogger = logger;
@@ -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));
         }
     });
 });
@@ -231,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]
@@ -386,6 +649,18 @@ const shouldRethrowProtocolProbeError = (error) => {
         code === hdShared.HardwareErrorCode.BleCharacteristicNotifyChangeFailure ||
         code === hdShared.HardwareErrorCode.BleWriteCharacteristicError);
 };
+const ANDROID_KEY_MISSING_LINK_WINDOW_MS = 10000;
+const ANDROID_KEY_MISSING_GRACE_MS = 500;
+const ANDROID_ENCRYPTION_RESULT_TIMEOUT_MS = 1500;
+const ANDROID_SYSTEM_REPAIR_TIMEOUT_MS = 35000;
+const isAndroidLinkLossError = (error) => {
+    const 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 +858,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();
@@ -630,6 +906,10 @@ class ReactNativeBleTransport {
     init(logger, emitter) {
         setBleLogger(logger);
         this.emitter = emitter;
+        if (reactNative.Platform.OS === 'android') {
+            startBleKeyMissingTracking();
+            startBleEncryptionTracking();
+        }
     }
     configure(signedData) {
         const messages = parseConfigure(signedData);
@@ -1016,7 +1296,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) {
@@ -1071,6 +1358,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) {
@@ -1098,10 +1386,16 @@ class ReactNativeBleTransport {
             if (this.stopped)
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
             if (reactNative.Platform.OS === 'android') {
+                startBleKeyMissingTracking();
+                startBleEncryptionTracking();
+                this.androidLinkStartedAt.delete(uuid);
                 try {
                     const bondState = yield pairDevice(uuid);
+                    androidBondedBeforeConnect = !bondState.bonding && bondState.bonded;
                     if (bondState.bonding) {
-                        yield onDeviceBondState(uuid, this.bondAbortController.signal);
+                        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 +1407,7 @@ class ReactNativeBleTransport {
                     }));
                     throw error;
                 }
+                this.androidLinkStartedAt.set(uuid, Date.now());
             }
             if (this.stopped)
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
@@ -1270,7 +1565,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,
@@ -1309,6 +1610,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) {
@@ -1510,14 +1814,64 @@ 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',
+            });
+        });
+    }
+    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) {
@@ -1733,6 +2087,9 @@ class ReactNativeBleTransport {
         this.androidPriorityResetTimers.forEach(timeout => clearTimeout(timeout));
         this.androidPriorityResetTimers.clear();
         this.androidHighPriorityDevices.clear();
+        this.androidLinkStartedAt.clear();
+        stopBleKeyMissingTracking();
+        stopBleEncryptionTracking();
         const error = hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected);
         (_a = this.runPromise) === null || _a === void 0 ? void 0 : _a.reject(error);
         this.runPromise = null;
@@ -2766,8 +3123,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.8",
+  "version": "1.2.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.3-alpha.8",
-    "@onekeyfe/hd-shared": "1.2.3-alpha.8",
-    "@onekeyfe/hd-transport": "1.2.3-alpha.8",
-    "@onekeyfe/react-native-ble-utils": "0.1.6",
+    "@onekeyfe/hd-core": "1.2.3",
+    "@onekeyfe/hd-shared": "1.2.3",
+    "@onekeyfe/hd-transport": "1.2.3",
+    "@onekeyfe/react-native-ble-utils": "0.1.9",
     "react-native-ble-plx": "3.5.1"
   },
-  "gitHead": "170aac4b7ca98bf24b5dd36b9729c98a10389161"
+  "gitHead": "de8e0beb9d993464fbcac6231d7efe501d789c7d"
 }