@onekeyfe/hd-transport-electron 1.2.0-alpha.15 → 1.2.0-alpha.151

package/dist/{noble-ble-handler-16791965.js → noble-ble-handler-efd3df55.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-55699e30.js');
+var index = require('./index-70b4a97d.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -8,6 +8,14 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var pRetry__default = /*#__PURE__*/_interopDefaultLegacy(pRetry);
 
+const BLE_ATT_HEADER_BYTES = 3;
+function resolveBlePacketCapacity(mtu, maximumPacketCapacity, fallbackPacketCapacity) {
+    if (typeof mtu !== 'number' || !Number.isFinite(mtu) || mtu <= BLE_ATT_HEADER_BYTES) {
+        return fallbackPacketCapacity;
+    }
+    return Math.min(maximumPacketCapacity, Math.floor(mtu) - BLE_ATT_HEADER_BYTES);
+}
+
 function safeLog(logger, level, message, ...args) {
     if (logger) {
         logger[level](message, ...args);
@@ -17,6 +25,37 @@ function safeLog(logger, level, message, ...args) {
     }
 }
 
+function runBleCallbackOperation(operation, options) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        };
+        const timeout = setTimeout(() => {
+            if (options.timeoutBehavior === 'reject') {
+                settle(new Error(`BLE operation timed out after ${options.timeoutMs}ms`));
+            }
+            else {
+                settle();
+            }
+        }, options.timeoutMs);
+        try {
+            operation(settle);
+        }
+        catch (error) {
+            settle(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+}
 function softRefreshSubscription(params) {
     return index.__awaiter(this, void 0, void 0, function* () {
         const { deviceId, notifyCharacteristic, subscriptionOperations, subscribedDevices, pairedDevices, onNotificationData, logger, } = params;
@@ -25,17 +64,13 @@ function softRefreshSubscription(params) {
         }
         logger === null || logger === void 0 ? void 0 : logger.info('[BLE-OPS] Starting subscription refresh', { deviceId });
         subscriptionOperations.set(deviceId, 'subscribing');
-        yield new Promise(resolve => {
-            notifyCharacteristic.unsubscribe(() => resolve());
+        yield runBleCallbackOperation(callback => notifyCharacteristic.unsubscribe(callback), {
+            timeoutMs: 250,
+            timeoutBehavior: 'resolve',
         });
-        yield new Promise((resolve, reject) => {
-            notifyCharacteristic.subscribe((error) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                resolve();
-            });
+        yield runBleCallbackOperation(callback => notifyCharacteristic.subscribe(callback), {
+            timeoutMs: 8000,
+            timeoutBehavior: 'reject',
         });
         notifyCharacteristic.removeAllListeners('data');
         notifyCharacteristic.on('data', (data) => {
@@ -51,6 +86,9 @@ function softRefreshSubscription(params) {
     });
 }
 
+const NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS = 5000;
+const NOBLE_BLE_CONNECTION_TIMEOUT_MS = 10000;
+
 let noble = null;
 let logger = null;
 const bluetoothState = {
@@ -59,6 +97,7 @@ const bluetoothState = {
     initialized: false,
 };
 let persistentStateListener = null;
+let persistentDiscoverListener = null;
 const discoveredDevices = new Map();
 const connectedDevices = new Map();
 const pairedDevices = new Set();
@@ -66,47 +105,45 @@ const deviceCharacteristics = new Map();
 const notificationCallbacks = new Map();
 const subscribedDevices = new Map();
 const subscriptionOperations = new Map();
+const deviceDisconnectListeners = new Map();
+const deviceMtuListeners = new Map();
 const ONEKEY_SERVICE_UUIDS = [hdShared.ONEKEY_SERVICE_UUID];
-const PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS = new Set(['fffd']);
-const NORMALIZED_WRITE_UUID = '0002';
-const NORMALIZED_NOTIFY_UUID = '0003';
+const ONEKEY_SERVICE_UUID_ALIASES = hdShared.createKnownBleUuidAliases(hdShared.ONEKEY_SERVICE_UUID);
+const ONEKEY_WRITE_UUID_ALIASES = hdShared.createKnownBleUuidAliases(hdShared.ONEKEY_WRITE_CHARACTERISTIC_UUID);
+const ONEKEY_NOTIFY_UUID_ALIASES = hdShared.createKnownBleUuidAliases(hdShared.ONEKEY_NOTIFY_CHARACTERISTIC_UUID);
 const BLUETOOTH_INIT_TIMEOUT = 10000;
-const DEVICE_SCAN_TIMEOUT = 8000;
-const FAST_SCAN_TIMEOUT = 8000;
+const DEVICE_SCAN_TIMEOUT = 5000;
 const DEVICE_CHECK_INTERVAL = 500;
-const CONNECTION_TIMEOUT = 8000;
 const SERVICE_DISCOVERY_TIMEOUT = 10000;
-const BLE_PACKET_SIZE = 192;
-const UNIFIED_WRITE_DELAY = 5;
+const BLE_CLEANUP_TIMEOUT = 250;
+const BLE_IDLE_DISCONNECT_MS = 3 * 60000;
+const BLE_BUSY_BACKSTOP_MS = 10 * 60000;
+const BLE_PACKET_SIZE_FALLBACK = 192;
+const BLE_PACKET_SIZE_MAXIMUM = 244;
+const DEFAULT_WRITE_PACING_DELAY_MS = 5;
 const RETRY_CONFIG = { MAX_ATTEMPTS: 15, WRITE_TIMEOUT: 2000 };
 const IS_WINDOWS = process.platform === 'win32';
 const ABORTABLE_WRITE_ERROR_PATTERNS = [
     /status:\s*3/i,
 ];
-function getBleUuidKey(uuid) {
-    const normalized = (uuid !== null && uuid !== void 0 ? uuid : '').replace(/-/g, '').toLowerCase();
-    return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
-}
-const NORMALIZED_ONEKEY_SERVICE_UUIDS = new Set([
-    ...ONEKEY_SERVICE_UUIDS.map(uuid => getBleUuidKey(uuid)),
-    '0001',
-]);
-function isGenericBleService(uuid) {
-    return ['1800', '1801', '180a', '180f'].includes(getBleUuidKey(uuid));
-}
-function hasOneKeyAdvertisementService(peripheral) {
-    var _a, _b;
-    const serviceUuids = (_b = (_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.serviceUuids) !== null && _b !== void 0 ? _b : [];
-    return serviceUuids.some(uuid => {
-        const uuidKey = getBleUuidKey(uuid);
-        return (NORMALIZED_ONEKEY_SERVICE_UUIDS.has(uuidKey) ||
-            PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(uuidKey));
-    });
+function resolveNobleBleWritePacingDelay(options) {
+    return typeof (options === null || options === void 0 ? void 0 : options.pacingDelayMs) === 'number' && Number.isFinite(options.pacingDelayMs)
+        ? Math.min(Math.max(Math.floor(options.pacingDelayMs), 0), 1000)
+        : DEFAULT_WRITE_PACING_DELAY_MS;
 }
 function isOneKeyPeripheral(peripheral) {
-    var _a;
-    const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || null;
-    return hdShared.isOnekeyDevice(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
+    var _a, _b;
+    const serviceUuids = (_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.serviceUuids;
+    const localName = (_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.localName;
+    if (!(localName === null || localName === void 0 ? void 0 : localName.trim())) {
+        return false;
+    }
+    return (hdShared.hasOnekeyCommunicationService(serviceUuids) &&
+        hdShared.isOnekeyBluetoothDevice({
+            id: peripheral.id,
+            localName,
+            serviceUuids,
+        }));
 }
 function emitRawNotification(deviceId, data) {
     const appCb = notificationCallbacks.get(deviceId);
@@ -205,6 +242,7 @@ function initializeNoble() {
         try {
             noble = require('@stoprocent/noble');
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Noble library loaded');
+            setupPersistentStateListener();
             yield new Promise((resolve, reject) => {
                 if (!noble) {
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not initialized'));
@@ -214,7 +252,6 @@ function initializeNoble() {
                     resolve();
                     return;
                 }
-                setupPersistentStateListener();
                 const timeout = setTimeout(() => {
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Bluetooth initialization timeout'));
                 }, BLUETOOTH_INIT_TIMEOUT);
@@ -245,9 +282,12 @@ function initializeNoble() {
                 };
                 noble.on('stateChange', onStateChange);
             });
-            noble.on('discover', (peripheral) => {
-                handleDeviceDiscovered(peripheral);
-            });
+            if (!persistentDiscoverListener) {
+                persistentDiscoverListener = (peripheral) => {
+                    handleDeviceDiscovered(peripheral);
+                };
+                noble.on('discover', persistentDiscoverListener);
+            }
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Noble initialized successfully');
         }
         catch (error) {
@@ -258,6 +298,62 @@ function initializeNoble() {
         }
     });
 }
+const idleDisconnectTimers = new Map();
+const idleDisconnectInFlight = new Map();
+function clearIdleDisconnect(deviceId) {
+    const timer = idleDisconnectTimers.get(deviceId);
+    if (timer) {
+        clearTimeout(timer);
+        idleDisconnectTimers.delete(deviceId);
+    }
+}
+function awaitIdleDisconnect(deviceId) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        const pending = idleDisconnectInFlight.get(deviceId);
+        if (pending)
+            yield pending.catch(() => undefined);
+    });
+}
+function broadcastToAllWebContents(channel, payload) {
+    try {
+        const { webContents: electronWebContents } = require('electron');
+        for (const wc of electronWebContents.getAllWebContents()) {
+            if (!wc.isDestroyed())
+                wc.send(channel, payload);
+        }
+    }
+    catch (error) {
+        logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] broadcast failed:', { channel, error: String(error) });
+    }
+}
+function armIdleDisconnect(deviceId, ms = BLE_IDLE_DISCONNECT_MS, reason = 'idle') {
+    clearIdleDisconnect(deviceId);
+    idleDisconnectTimers.set(deviceId, setTimeout(() => {
+        var _a;
+        idleDisconnectTimers.delete(deviceId);
+        if (!connectedDevices.has(deviceId))
+            return;
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Keep-alive timeout, disconnecting device', { deviceId, reason });
+        const peripheral = connectedDevices.get(deviceId);
+        const deviceName = ((_a = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
+        const pending = disconnectDevice(deviceId)
+            .then(() => {
+            broadcastToAllWebContents(hdShared.EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
+                id: deviceId,
+                name: deviceName,
+            });
+        })
+            .catch(error => {
+            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Keep-alive disconnect failed', { deviceId, error });
+        })
+            .finally(() => {
+            if (idleDisconnectInFlight.get(deviceId) === pending) {
+                idleDisconnectInFlight.delete(deviceId);
+            }
+        });
+        idleDisconnectInFlight.set(deviceId, pending);
+    }, ms));
+}
 function cleanupDevice(deviceId, webContents, options = {}) {
     var _a;
     const { cleanupConnection = true, cleanupDiscoveredCache = false, sendDisconnectEvent = false, cancelOperations = true, reason = 'unknown', } = options;
@@ -269,9 +365,20 @@ function cleanupDevice(deviceId, webContents, options = {}) {
         sendDisconnectEvent,
         cancelOperations,
     });
+    clearIdleDisconnect(deviceId);
     const peripheral = connectedDevices.get(deviceId);
     const deviceName = ((_a = peripheral === null || peripheral === void 0 ? void 0 : peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
     if (cleanupConnection) {
+        const disconnectEntry = deviceDisconnectListeners.get(deviceId);
+        if (disconnectEntry) {
+            disconnectEntry.peripheral.removeListener('disconnect', disconnectEntry.listener);
+            deviceDisconnectListeners.delete(deviceId);
+        }
+        const mtuEntry = deviceMtuListeners.get(deviceId);
+        if (mtuEntry) {
+            mtuEntry.peripheral.removeListener('mtu', mtuEntry.listener);
+            deviceMtuListeners.delete(deviceId);
+        }
         connectedDevices.delete(deviceId);
         deviceCharacteristics.delete(deviceId);
         notificationCallbacks.delete(deviceId);
@@ -282,8 +389,8 @@ function cleanupDevice(deviceId, webContents, options = {}) {
     if (cleanupDiscoveredCache) {
         discoveredDevices.delete(deviceId);
     }
-    if (sendDisconnectEvent && webContents) {
-        webContents.send(hdShared.EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
+    if (sendDisconnectEvent) {
+        broadcastToAllWebContents(hdShared.EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
             id: deviceId,
             name: deviceName,
         });
@@ -300,18 +407,43 @@ function handleDeviceDisconnect(deviceId, webContents) {
     });
     cleanupDevice(deviceId, webContents, {
         cleanupConnection: true,
+        cleanupDiscoveredCache: true,
         sendDisconnectEvent: true,
         cancelOperations: true,
         reason: 'auto-disconnect',
     });
 }
 function setupDisconnectListener(peripheral, deviceId, webContents) {
-    peripheral.removeAllListeners('disconnect');
-    peripheral.on('disconnect', () => {
+    const existing = deviceDisconnectListeners.get(deviceId);
+    if (existing) {
+        existing.peripheral.removeListener('disconnect', existing.listener);
+    }
+    const listener = () => {
         handleDeviceDisconnect(deviceId, webContents);
-    });
+    };
+    deviceDisconnectListeners.set(deviceId, { peripheral, listener });
+    peripheral.on('disconnect', listener);
+    setupMtuListener(peripheral, deviceId, webContents);
 }
-function writeCharacteristicWithAck(deviceId, writeCharacteristic, buffer) {
+function setupMtuListener(peripheral, deviceId, webContents) {
+    const existing = deviceMtuListeners.get(deviceId);
+    if (existing) {
+        existing.peripheral.removeListener('mtu', existing.listener);
+    }
+    const listener = (mtu) => {
+        if (!Number.isFinite(mtu) || mtu <= 0)
+            return;
+        if (webContents.isDestroyed())
+            return;
+        webContents.send(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_MTU_CHANGED, {
+            id: deviceId,
+            mtu,
+        });
+    };
+    deviceMtuListeners.set(deviceId, { peripheral, listener });
+    peripheral.on('mtu', listener);
+}
+function writeCharacteristicWithoutResponse(deviceId, writeCharacteristic, buffer) {
     return index.__awaiter(this, void 0, void 0, function* () {
         return new Promise((resolve, reject) => {
             writeCharacteristic.write(buffer, true, (error) => {
@@ -343,7 +475,7 @@ function attemptWindowsWriteUntilPaired(deviceId, doGetWriteCharacteristic, payl
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Write characteristic not available for ${deviceId}`);
             }
             try {
-                yield writeCharacteristicWithAck(deviceId, latestWrite, payload);
+                yield writeCharacteristicWithoutResponse(deviceId, latestWrite, payload);
             }
             catch (e) {
                 const errorMessage = e instanceof Error ? e.message : String(e);
@@ -402,52 +534,57 @@ function attemptWindowsWriteUntilPaired(deviceId, doGetWriteCharacteristic, payl
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `No response observed after ${RETRY_CONFIG.MAX_ATTEMPTS} writes: ${deviceId}`);
     });
 }
-function transmitHexDataToDevice(deviceId, hexData) {
+function transmitHexDataToDevice(deviceId, hexData, options) {
     return index.__awaiter(this, void 0, void 0, function* () {
         const characteristics = deviceCharacteristics.get(deviceId);
         const peripheral = connectedDevices.get(deviceId);
         if (!peripheral || !characteristics) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, `Device ${deviceId} not connected or characteristics not available`);
         }
+        armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
         const toBuffer = Buffer.from(hexData, 'hex');
         const doGetWriteCharacteristic = () => { var _a; return (_a = deviceCharacteristics.get(deviceId)) === null || _a === void 0 ? void 0 : _a.write; };
+        const packetCapacity = resolveBlePacketCapacity(peripheral.mtu, BLE_PACKET_SIZE_MAXIMUM, BLE_PACKET_SIZE_FALLBACK);
+        const pacingDelayMs = resolveNobleBleWritePacingDelay(options);
         if (!IS_WINDOWS || pairedDevices.has(deviceId)) {
             const writeCharacteristic = doGetWriteCharacteristic();
             if (!writeCharacteristic) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, `Write characteristic not available for ${deviceId}`);
             }
-            if (toBuffer.length <= BLE_PACKET_SIZE) {
-                yield hdShared.wait(UNIFIED_WRITE_DELAY);
-                yield writeCharacteristicWithAck(deviceId, writeCharacteristic, toBuffer);
+            if (toBuffer.length <= packetCapacity) {
+                if (pacingDelayMs > 0)
+                    yield hdShared.wait(pacingDelayMs);
+                yield writeCharacteristicWithoutResponse(deviceId, writeCharacteristic, toBuffer);
                 return;
             }
             for (let offset = 0; offset < toBuffer.length;) {
-                const chunkSize = Math.min(BLE_PACKET_SIZE, toBuffer.length - offset);
+                const chunkSize = Math.min(packetCapacity, toBuffer.length - offset);
                 const chunk = toBuffer.subarray(offset, offset + chunkSize);
                 offset += chunkSize;
                 const latest = doGetWriteCharacteristic();
                 if (!latest) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, `Write characteristic not available for ${deviceId}`);
                 }
-                yield writeCharacteristicWithAck(deviceId, latest, chunk);
-                if (offset < toBuffer.length) {
-                    yield hdShared.wait(UNIFIED_WRITE_DELAY);
+                yield writeCharacteristicWithoutResponse(deviceId, latest, chunk);
+                if (offset < toBuffer.length && pacingDelayMs > 0) {
+                    yield hdShared.wait(pacingDelayMs);
                 }
             }
             return;
         }
-        if (toBuffer.length <= BLE_PACKET_SIZE) {
-            yield hdShared.wait(UNIFIED_WRITE_DELAY);
+        if (toBuffer.length <= packetCapacity) {
+            if (pacingDelayMs > 0)
+                yield hdShared.wait(pacingDelayMs);
             yield attemptWindowsWriteUntilPaired(deviceId, doGetWriteCharacteristic, toBuffer, 'single');
             return;
         }
         for (let offset = 0, idx = 0; offset < toBuffer.length; idx++) {
-            const chunkSize = Math.min(BLE_PACKET_SIZE, toBuffer.length - offset);
+            const chunkSize = Math.min(packetCapacity, toBuffer.length - offset);
             const chunk = toBuffer.subarray(offset, offset + chunkSize);
             offset += chunkSize;
             yield attemptWindowsWriteUntilPaired(deviceId, doGetWriteCharacteristic, chunk, `chunk-${idx + 1}`);
-            if (offset < toBuffer.length) {
-                yield hdShared.wait(UNIFIED_WRITE_DELAY);
+            if (offset < toBuffer.length && pacingDelayMs > 0) {
+                yield hdShared.wait(pacingDelayMs);
             }
         }
     });
@@ -470,17 +607,25 @@ function handleDeviceDiscovered(peripheral) {
 function ensureDiscoverListener() {
     if (!noble)
         return;
-    const listenerCount = noble.listenerCount('discover');
-    if (listenerCount === 0) {
+    if (!persistentDiscoverListener) {
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Discover listener missing, re-adding it');
-        noble.on('discover', (peripheral) => {
+        persistentDiscoverListener = (peripheral) => {
             handleDeviceDiscovered(peripheral);
-        });
+        };
+        noble.on('discover', persistentDiscoverListener);
     }
     else {
-        logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] Discover listener already exists, count:', listenerCount);
+        logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] Discover listener already registered');
     }
 }
+function waitForNobleScanStop(nobleInstance) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        yield runBleCallbackOperation(callback => nobleInstance.stopScanning(() => callback()), {
+            timeoutMs: BLE_CLEANUP_TIMEOUT,
+            timeoutBehavior: 'resolve',
+        });
+    });
+}
 function performTargetedScan(targetDeviceId) {
     return index.__awaiter(this, void 0, void 0, function* () {
         if (!noble) {
@@ -489,33 +634,43 @@ function performTargetedScan(targetDeviceId) {
         const nobleInstance = noble;
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting targeted scan for device:', targetDeviceId);
         return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (peripheral, error) => index.__awaiter(this, void 0, void 0, function* () {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                nobleInstance.removeListener('discover', onDiscover);
+                yield waitForNobleScanStop(nobleInstance);
+                if (error) {
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to start targeted scan:', error);
+                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleScanError, error.message));
+                    return;
+                }
+                if (peripheral) {
+                    discoveredDevices.set(peripheral.id, peripheral);
+                }
+                resolve(peripheral);
+            });
             const onDiscover = (peripheral) => {
                 var _a;
-                if (peripheral.id === targetDeviceId) {
+                if (peripheral.id === targetDeviceId && isOneKeyPeripheral(peripheral)) {
                     logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Target device found during targeted scan:', {
                         id: peripheral.id,
                         name: (_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName,
                     });
-                    clearTimeout(timeoutId);
-                    nobleInstance.removeListener('discover', onDiscover);
-                    nobleInstance.stopScanning();
-                    discoveredDevices.set(peripheral.id, peripheral);
-                    resolve(peripheral);
+                    finish(peripheral).catch(reject);
                 }
             };
             const timeoutId = setTimeout(() => {
-                nobleInstance.removeListener('discover', onDiscover);
-                nobleInstance.stopScanning();
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan timeout for device:', targetDeviceId);
-                resolve(null);
-            }, FAST_SCAN_TIMEOUT);
+                finish(null).catch(reject);
+            }, NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS);
             nobleInstance.on('discover', onDiscover);
-            nobleInstance.startScanning([], false, (error) => {
+            nobleInstance.startScanning([], true, (error) => {
                 if (error) {
-                    clearTimeout(timeoutId);
-                    nobleInstance.removeListener('discover', onDiscover);
-                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to start targeted scan:', error);
-                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleScanError, error.message));
+                    finish(null, error).catch(reject);
                     return;
                 }
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan started for device:', targetDeviceId);
@@ -538,44 +693,44 @@ function enumerateDevices() {
         return new Promise((resolve, reject) => {
             const devices = [];
             let intervalId;
-            const cleanup = () => {
+            const cleanup = () => index.__awaiter(this, void 0, void 0, function* () {
                 clearTimeout(timeoutId);
                 if (intervalId)
                     clearInterval(intervalId);
-                nobleInstance.stopScanning();
+                yield waitForNobleScanStop(nobleInstance);
+            });
+            const pushDevice = (peripheral, id) => {
+                var _a;
+                if (devices.some(d => d.id === id))
+                    return;
+                devices.push({
+                    commType: 'electron-ble',
+                    id,
+                    name: ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device',
+                    state: peripheral.state || 'disconnected',
+                });
             };
             const checkDevices = () => {
-                discoveredDevices.forEach((peripheral, id) => {
-                    var _a;
-                    const existingDevice = devices.find(d => d.id === id);
-                    if (!existingDevice) {
-                        const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
-                        devices.push({
-                            commType: 'electron-ble',
-                            id,
-                            name: deviceName,
-                            state: peripheral.state || 'disconnected',
-                        });
-                    }
-                });
+                discoveredDevices.forEach(pushDevice);
+                connectedDevices.forEach(pushDevice);
             };
-            const timeoutId = setTimeout(() => {
+            const timeoutId = setTimeout(() => index.__awaiter(this, void 0, void 0, function* () {
                 checkDevices();
-                cleanup();
+                yield cleanup();
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scan completed, found devices:', devices.length);
                 resolve(devices);
-            }, DEVICE_SCAN_TIMEOUT);
+            }), DEVICE_SCAN_TIMEOUT);
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scanning for OneKey BLE devices');
-            nobleInstance.startScanning([], false, (error) => {
+            nobleInstance.startScanning([], true, (error) => index.__awaiter(this, void 0, void 0, function* () {
                 if (error) {
-                    cleanup();
+                    yield cleanup();
                     logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to start scanning:', error);
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleScanError, error.message));
                     return;
                 }
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scanning started for OneKey devices');
                 intervalId = setInterval(checkDevices, DEVICE_CHECK_INTERVAL);
-            });
+            }));
         });
     });
 }
@@ -583,25 +738,20 @@ function stopScanning() {
     return index.__awaiter(this, void 0, void 0, function* () {
         if (!noble)
             return;
-        return new Promise(resolve => {
-            if (!noble) {
-                resolve();
-                return;
-            }
-            noble.stopScanning(() => {
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scanning stopped');
-                resolve();
-            });
-        });
+        const nobleInstance = noble;
+        yield waitForNobleScanStop(nobleInstance);
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scanning stopped');
     });
 }
 function cleanupNobleListeners() {
     if (!noble)
         return;
     try {
-        noble.removeAllListeners('discover');
-        noble.removeAllListeners('stateChange');
-        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] All Noble listeners cleaned up');
+        if (persistentDiscoverListener) {
+            noble.removeListener('discover', persistentDiscoverListener);
+            persistentDiscoverListener = null;
+        }
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Owned Noble listeners cleaned up');
     }
     catch (error) {
         logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to clean up some listeners:', error);
@@ -612,22 +762,12 @@ function getDevice(deviceId) {
     const peripheral = discoveredDevices.get(deviceId);
     if (peripheral) {
         const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
-        return {
-            commType: 'electron-ble',
-            id: peripheral.id,
-            name: deviceName,
-            state: peripheral.state || 'disconnected',
-        };
+        return Object.assign({ commType: 'electron-ble', id: peripheral.id, name: deviceName, state: peripheral.state || 'disconnected' }, (typeof peripheral.mtu === 'number' ? { mtu: peripheral.mtu } : {}));
     }
     const connectedPeripheral = connectedDevices.get(deviceId);
     if (connectedPeripheral) {
         const deviceName = ((_b = connectedPeripheral.advertisement) === null || _b === void 0 ? void 0 : _b.localName) || 'Unknown Device';
-        return {
-            commType: 'electron-ble',
-            id: connectedPeripheral.id,
-            name: deviceName,
-            state: connectedPeripheral.state || 'connected',
-        };
+        return Object.assign({ commType: 'electron-ble', id: connectedPeripheral.id, name: deviceName, state: connectedPeripheral.state || 'connected' }, (typeof connectedPeripheral.mtu === 'number' ? { mtu: connectedPeripheral.mtu } : {}));
     }
     return {
         commType: 'electron-ble',
@@ -678,14 +818,7 @@ function discoverServicesAndCharacteristics(peripheral) {
                 deviceId: peripheral.id,
                 serviceUUIDs: services.map(service => service.uuid),
             });
-            let service = services.find(s => NORMALIZED_ONEKEY_SERVICE_UUIDS.has(getBleUuidKey(s.uuid)));
-            if (!service) {
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Known OneKey service UUID not found, trying first vendor service');
-                service =
-                    services.find(s => PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(getBleUuidKey(s.uuid))) ||
-                        services.find(s => !isGenericBleService(s.uuid)) ||
-                        services[0];
-            }
+            const service = services.find(s => hdShared.matchesKnownBleUuid(s.uuid, ONEKEY_SERVICE_UUID_ALIASES));
             if (!service) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound);
             }
@@ -708,12 +841,10 @@ function discoverServicesAndCharacteristics(peripheral) {
             let writeCharacteristic = null;
             let notifyCharacteristic = null;
             for (const characteristic of characteristics) {
-                const uuid = characteristic.uuid.replace(/-/g, '').toLowerCase();
-                const uuidKey = uuid.length >= 8 ? uuid.substring(4, 8) : uuid;
-                if (uuidKey === NORMALIZED_WRITE_UUID) {
+                if (hdShared.matchesKnownBleUuid(characteristic.uuid, ONEKEY_WRITE_UUID_ALIASES)) {
                     writeCharacteristic = characteristic;
                 }
-                else if (uuidKey === NORMALIZED_NOTIFY_UUID) {
+                else if (hdShared.matchesKnownBleUuid(characteristic.uuid, ONEKEY_NOTIFY_UUID_ALIASES)) {
                     notifyCharacteristic = characteristic;
                 }
             }
@@ -747,27 +878,17 @@ function forceReconnectPeripheral(peripheral, deviceId) {
             reason: 'force-reconnect',
         });
         if (peripheral.state === 'connected') {
-            peripheral.removeAllListeners('disconnect');
-            yield new Promise(resolve => {
-                peripheral.disconnect(() => {
-                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Force disconnect completed');
-                    resolve();
-                });
-            });
+            yield runBleCallbackOperation(callback => peripheral.disconnect(() => {
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Force disconnect completed');
+                callback();
+            }), { timeoutMs: BLE_CLEANUP_TIMEOUT, timeoutBehavior: 'resolve' });
         }
-        yield new Promise((resolve, reject) => {
-            peripheral.connect((error) => {
-                if (error) {
-                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Force reconnect failed:', error);
-                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, error.message));
-                }
-                else {
-                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Force reconnect successful');
-                    connectedDevices.set(deviceId, peripheral);
-                    resolve();
-                }
-            });
+        yield runBleCallbackOperation(callback => peripheral.connect(callback), {
+            timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+            timeoutBehavior: 'reject',
         });
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Force reconnect successful');
+        connectedDevices.set(deviceId, peripheral);
         yield hdShared.wait(500);
     });
 }
@@ -844,18 +965,83 @@ function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
 }
 function setupConnectionAndDiscoverServices(peripheral, deviceId, webContents) {
     return index.__awaiter(this, void 0, void 0, function* () {
+        setupDisconnectListener(peripheral, deviceId, webContents);
+        try {
+            return yield discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
+        }
+        catch (initialError) {
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct service discovery failed, retrying after reconnect', {
+                deviceId,
+                error: initialError,
+            });
+        }
         yield forceReconnectPeripheral(peripheral, deviceId);
         setupDisconnectListener(peripheral, deviceId, webContents);
         try {
             return yield discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
         }
-        catch (error) {
-            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed, attempting fresh scan...', error);
+        catch (reconnectError) {
+            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed after reconnect, attempting fresh scan...', reconnectError);
             return freshScanAndDiscover(deviceId, webContents);
         }
     });
 }
+const DIRECT_CONNECT_TIMEOUT_MS = 2000;
+const DIRECT_CONNECT_COOLDOWN_MS = 15000;
+const directConnectCooldownUntil = new Map();
+function tryDirectConnectById(deviceId) {
+    var _a;
+    return index.__awaiter(this, void 0, void 0, function* () {
+        const nobleInstance = noble;
+        if (!(nobleInstance === null || nobleInstance === void 0 ? void 0 : nobleInstance.connectAsync))
+            return undefined;
+        const cooldownUntil = (_a = directConnectCooldownUntil.get(deviceId)) !== null && _a !== void 0 ? _a : 0;
+        if (Date.now() < cooldownUntil)
+            return undefined;
+        try {
+            const directPromise = nobleInstance.connectAsync(deviceId);
+            const raced = yield Promise.race([
+                directPromise,
+                new Promise(resolve => {
+                    setTimeout(() => resolve('timeout'), DIRECT_CONNECT_TIMEOUT_MS);
+                }),
+            ]);
+            if (raced === 'timeout') {
+                directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct connect-by-id timed out, falling back to scan', {
+                    deviceId,
+                });
+                directPromise
+                    .then(late => {
+                    const latePeripheral = late !== null && late !== void 0 ? late : discoveredDevices.get(deviceId);
+                    if (latePeripheral &&
+                        latePeripheral.state === 'connected' &&
+                        !connectedDevices.has(deviceId)) {
+                        latePeripheral.removeAllListeners('disconnect');
+                        latePeripheral.disconnect(() => undefined);
+                    }
+                })
+                    .catch(() => undefined);
+                return undefined;
+            }
+            const peripheral = raced !== null && raced !== void 0 ? raced : discoveredDevices.get(deviceId);
+            if (!peripheral || peripheral.state !== 'connected')
+                return undefined;
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct connect-by-id succeeded', { deviceId });
+            return peripheral;
+        }
+        catch (error) {
+            directConnectCooldownUntil.set(deviceId, Date.now() + DIRECT_CONNECT_COOLDOWN_MS);
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct connect-by-id failed, falling back to scan', {
+                deviceId,
+                error: String(error),
+            });
+            return undefined;
+        }
+    });
+}
 function connectDevice(deviceId, webContents) {
+    var _a;
     return index.__awaiter(this, void 0, void 0, function* () {
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connect device request:', {
             deviceId,
@@ -865,7 +1051,7 @@ function connectDevice(deviceId, webContents) {
             totalDiscovered: discoveredDevices.size,
             totalConnected: connectedDevices.size,
         });
-        let peripheral = discoveredDevices.get(deviceId);
+        let peripheral = (_a = discoveredDevices.get(deviceId)) !== null && _a !== void 0 ? _a : connectedDevices.get(deviceId);
         if (!peripheral) {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device not discovered, attempting targeted scan for:', deviceId);
             if (!noble) {
@@ -874,6 +1060,12 @@ function connectDevice(deviceId, webContents) {
             if (!noble) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
             }
+            peripheral = yield tryDirectConnectById(deviceId);
+            if (peripheral) {
+                discoveredDevices.set(deviceId, peripheral);
+            }
+        }
+        if (!peripheral) {
             try {
                 const foundPeripheral = yield performTargetedScan(deviceId);
                 if (!foundPeripheral) {
@@ -894,8 +1086,8 @@ function connectDevice(deviceId, webContents) {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device already connected, skipping connection step');
             if (!connectedDevices.has(deviceId)) {
                 connectedDevices.set(deviceId, peripheral);
-                setupDisconnectListener(peripheral, deviceId, webContents);
             }
+            setupDisconnectListener(peripheral, deviceId, webContents);
             if (deviceCharacteristics.has(deviceId)) {
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device characteristics already available');
                 const ongoingOperation = subscriptionOperations.get(deviceId);
@@ -917,18 +1109,37 @@ function connectDevice(deviceId, webContents) {
                 notificationCallbacks.delete(deviceId);
                 subscribedDevices.delete(deviceId);
             }
-            const characteristics = yield setupConnectionAndDiscoverServices(peripheral, deviceId, webContents);
-            deviceCharacteristics.set(deviceId, characteristics);
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device ready for communication:', deviceId);
+            try {
+                const characteristics = yield setupConnectionAndDiscoverServices(peripheral, deviceId, webContents);
+                deviceCharacteristics.set(deviceId, characteristics);
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device ready for communication:', deviceId);
+            }
+            catch (setupError) {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection setup failed on kept-alive link:', setupError);
+                yield disconnectDevice(deviceId).catch(() => undefined);
+                throw setupError;
+            }
             return;
         }
         return new Promise((resolve, reject) => {
+            let connectionTimedOut = false;
             const timeout = setTimeout(() => {
+                connectionTimedOut = true;
                 reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, 'Connection timeout'));
-            }, CONNECTION_TIMEOUT);
+            }, NOBLE_BLE_CONNECTION_TIMEOUT_MS);
             const connectedPeripheral = peripheral;
             connectedPeripheral.connect((error) => index.__awaiter(this, void 0, void 0, function* () {
                 clearTimeout(timeout);
+                if (connectionTimedOut) {
+                    if (!error) {
+                        try {
+                            connectedPeripheral.disconnect(() => undefined);
+                        }
+                        catch (_a) {
+                        }
+                    }
+                    return;
+                }
                 if (error) {
                     logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection failed:', error);
                     reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, error.message));
@@ -958,17 +1169,21 @@ function disconnectDevice(deviceId) {
         if (!peripheral) {
             return;
         }
-        return new Promise(resolve => {
-            peripheral.removeAllListeners('disconnect');
-            peripheral.disconnect(() => {
-                cleanupDevice(deviceId, undefined, {
-                    cleanupConnection: true,
-                    sendDisconnectEvent: false,
-                    cancelOperations: true,
-                    reason: 'manual-disconnect',
-                });
-                resolve();
-            });
+        const disconnectEntry = deviceDisconnectListeners.get(deviceId);
+        if (disconnectEntry) {
+            disconnectEntry.peripheral.removeListener('disconnect', disconnectEntry.listener);
+            deviceDisconnectListeners.delete(deviceId);
+        }
+        yield runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+            timeoutMs: BLE_CLEANUP_TIMEOUT,
+            timeoutBehavior: 'resolve',
+        });
+        cleanupDevice(deviceId, undefined, {
+            cleanupConnection: true,
+            cleanupDiscoveredCache: true,
+            sendDisconnectEvent: false,
+            cancelOperations: true,
+            reason: 'manual-disconnect',
         });
     });
 }
@@ -983,18 +1198,11 @@ function unsubscribeNotifications(deviceId) {
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Unsubscribing from notifications for device:', deviceId);
         subscriptionOperations.set(deviceId, 'unsubscribing');
         try {
-            yield new Promise((resolve, reject) => {
-                notifyCharacteristic.unsubscribe((error) => {
-                    if (error) {
-                        logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Notification unsubscription failed:', error);
-                        reject(error);
-                    }
-                    else {
-                        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Notification unsubscription successful');
-                        resolve();
-                    }
-                });
+            yield runBleCallbackOperation(callback => notifyCharacteristic.unsubscribe(callback), {
+                timeoutMs: BLE_CLEANUP_TIMEOUT,
+                timeoutBehavior: 'resolve',
             });
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Notification unsubscription completed');
             notifyCharacteristic.removeAllListeners('data');
             notificationCallbacks.delete(deviceId);
             subscribedDevices.delete(deviceId);
@@ -1046,19 +1254,13 @@ function subscribeNotifications(deviceId, callback) {
         notificationCallbacks.set(deviceId, callback);
         function rebuildAppSubscription(deviceId, notifyCharacteristic) {
             return index.__awaiter(this, void 0, void 0, function* () {
-                yield new Promise(resolve => {
-                    notifyCharacteristic.unsubscribe(() => {
-                        resolve();
-                    });
+                yield runBleCallbackOperation(callback => notifyCharacteristic.unsubscribe(callback), {
+                    timeoutMs: BLE_CLEANUP_TIMEOUT,
+                    timeoutBehavior: 'resolve',
                 });
-                yield new Promise((resolve, reject) => {
-                    notifyCharacteristic.subscribe((error) => {
-                        if (error) {
-                            reject(error);
-                            return;
-                        }
-                        resolve();
-                    });
+                yield runBleCallbackOperation(callback => notifyCharacteristic.subscribe(callback), {
+                    timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+                    timeoutBehavior: 'reject',
                 });
                 notifyCharacteristic.on('data', (data) => {
                     if (!pairedDevices.has(deviceId)) {
@@ -1082,8 +1284,12 @@ function setupNobleBleHandlers(webContents) {
     try {
         logger = require('electron-log');
         const { ipcMain } = require('electron');
+        const handle = (channel, listener) => {
+            ipcMain.removeHandler(channel);
+            ipcMain.handle(channel, listener);
+        };
         safeLog(logger, 'info', 'Setting up Noble BLE IPC handlers');
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, () => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, () => index.__awaiter(this, void 0, void 0, function* () {
             try {
                 const devices = yield enumerateDevices();
                 safeLog(logger, 'debug', 'Enumeration completed', {
@@ -1097,34 +1303,54 @@ function setupNobleBleHandlers(webContents) {
                 throw error;
             }
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_STOP_SCAN, () => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_STOP_SCAN, () => index.__awaiter(this, void 0, void 0, function* () {
             yield stopScanning();
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_GET_DEVICE, (_event, deviceId) => getDevice(deviceId));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_GET_DEVICE, (_event, deviceId) => getDevice(deviceId));
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] IPC CONNECT request received:', {
                 deviceId,
                 hasPeripheral: connectedDevices.has(deviceId),
                 hasCharacteristics: deviceCharacteristics.has(deviceId),
                 totalConnectedDevices: connectedDevices.size,
             });
-            yield connectDevice(deviceId, webContents);
+            clearIdleDisconnect(deviceId);
+            yield awaitIdleDisconnect(deviceId);
+            try {
+                yield connectDevice(deviceId, webContents);
+            }
+            finally {
+                if (connectedDevices.has(deviceId)) {
+                    armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
+                }
+            }
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_DISCONNECT, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_RELEASE, (_event, deviceId, keepSession) => {
+            if (!connectedDevices.has(deviceId))
+                return;
+            if (keepSession) {
+                armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
+                return;
+            }
+            armIdleDisconnect(deviceId);
+        });
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_DISCONNECT, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
             yield disconnectDevice(deviceId);
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_WRITE, (_event, deviceId, hexData) => index.__awaiter(this, void 0, void 0, function* () {
-            yield transmitHexDataToDevice(deviceId, hexData);
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_WRITE, (_event, deviceId, hexData, options) => index.__awaiter(this, void 0, void 0, function* () {
+            yield transmitHexDataToDevice(deviceId, hexData, options);
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_SUBSCRIBE, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_SUBSCRIBE, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
             yield subscribeNotifications(deviceId, (data) => {
                 webContents.send(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_NOTIFICATION, deviceId, data);
             });
+            armIdleDisconnect(deviceId, BLE_BUSY_BACKSTOP_MS, 'busy-backstop');
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_UNSUBSCRIBE, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_UNSUBSCRIBE, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
             yield unsubscribeNotifications(deviceId);
+            armIdleDisconnect(deviceId);
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_CANCEL_PAIRING, () => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_CANCEL_PAIRING, () => index.__awaiter(this, void 0, void 0, function* () {
             const deviceIds = Array.from(connectedDevices.keys());
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Cancel pairing invoked', {
                 platform: process.platform,
@@ -1140,7 +1366,7 @@ function setupNobleBleHandlers(webContents) {
                 }
             }
         }));
-        ipcMain.handle(hdShared.EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK, () => index.__awaiter(this, void 0, void 0, function* () {
+        handle(hdShared.EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK, () => index.__awaiter(this, void 0, void 0, function* () {
             try {
                 const bluetoothStatus = yield checkBluetoothAvailability();
                 safeLog(logger, 'info', 'Bluetooth availability check completed:', bluetoothStatus);
@@ -1158,23 +1384,19 @@ function setupNobleBleHandlers(webContents) {
         }));
         webContents.on('destroyed', () => {
             safeLog(logger, 'info', 'Cleaning up Noble BLE handlers');
-            const deviceIds = Array.from(connectedDevices.keys());
-            deviceIds.forEach(deviceId => {
-                cleanupDevice(deviceId, undefined, {
-                    cleanupConnection: true,
-                    sendDisconnectEvent: false,
-                    cancelOperations: true,
-                    reason: 'app-quit',
-                });
+            (() => index.__awaiter(this, void 0, void 0, function* () {
+                const deviceIds = Array.from(connectedDevices.keys());
+                for (const deviceId of deviceIds) {
+                    yield unsubscribeNotifications(deviceId).catch(() => undefined);
+                    yield disconnectDevice(deviceId).catch(() => undefined);
+                }
+                yield stopScanning().catch(() => undefined);
+                cleanupNobleListeners();
+                discoveredDevices.clear();
+                safeLog(logger, 'info', 'Noble BLE cleanup completed');
+            }))().catch(error => {
+                safeLog(logger, 'error', 'Noble BLE cleanup failed', error);
             });
-            stopScanning();
-            if (noble && persistentStateListener) {
-                noble.removeListener('stateChange', persistentStateListener);
-                persistentStateListener = null;
-            }
-            cleanupNobleListeners();
-            discoveredDevices.clear();
-            safeLog(logger, 'info', 'Noble BLE cleanup completed');
         });
         safeLog(logger, 'info', 'Noble BLE IPC handlers setup completed');
     }
@@ -1184,4 +1406,5 @@ function setupNobleBleHandlers(webContents) {
     }
 }
 
+exports.resolveNobleBleWritePacingDelay = resolveNobleBleWritePacingDelay;
 exports.setupNobleBleHandlers = setupNobleBleHandlers;