@onekeyfe/hd-transport-electron 1.2.0-alpha.32 → 1.2.0-alpha.34

package/dist/ble-ops.d.ts

@@ -1,6 +1,11 @@
 /// <reference types="node" />
 import type { Characteristic } from '@stoprocent/noble';
 import type { Logger } from './types/noble-extended';
+type BleCallback = (error?: Error) => void;
+export declare function runBleCallbackOperation(operation: (callback: BleCallback) => void, options: {
+    timeoutMs: number;
+    timeoutBehavior: 'resolve' | 'reject';
+}): Promise<void>;
 export interface SoftRefreshParams {
     deviceId: string;
     notifyCharacteristic: Characteristic | null | undefined;
@@ -11,4 +16,5 @@ export interface SoftRefreshParams {
     logger: Logger | null;
 }
 export declare function softRefreshSubscription(params: SoftRefreshParams): Promise<void>;
+export {};
 //# sourceMappingURL=ble-ops.d.ts.map

package/dist/ble-ops.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ble-ops.d.ts","sourceRoot":"","sources":["../src/ble-ops.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,CAAC;IACxD,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG,eAAe,GAAG,MAAM,CAAC,CAAC;IAC9E,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8CtF"}
+{"version":3,"file":"ble-ops.d.ts","sourceRoot":"","sources":["../src/ble-ops.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD,KAAK,WAAW,GAAG,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;AAE3C,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,CAAC,QAAQ,EAAE,WAAW,KAAK,IAAI,EAC1C,OAAO,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,SAAS,GAAG,QAAQ,CAAA;CAAE,GACpE,OAAO,CAAC,IAAI,CAAC,CA2Bf;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,CAAC;IACxD,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG,eAAe,GAAG,MAAM,CAAC,CAAC;IAC9E,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0CtF"}

package/dist/{index-55699e30.js → index-5f728113.js}

@@ -32,7 +32,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 
 function initNobleBleSupport(webContents) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-16791965.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-d58af248.js'); });
         setupNobleBleHandlers(webContents);
     });
 }

package/dist/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./index-55699e30.js');
+var index = require('./index-5f728113.js');
 
 
 

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

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-55699e30.js');
+var index = require('./index-5f728113.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -17,6 +17,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 +56,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) => {
@@ -59,6 +86,7 @@ const bluetoothState = {
     initialized: false,
 };
 let persistentStateListener = null;
+let persistentDiscoverListener = null;
 const discoveredDevices = new Map();
 const connectedDevices = new Map();
 const pairedDevices = new Set();
@@ -66,16 +94,18 @@ const deviceCharacteristics = new Map();
 const notificationCallbacks = new Map();
 const subscribedDevices = new Map();
 const subscriptionOperations = new Map();
+const deviceDisconnectListeners = 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_CHECK_INTERVAL = 500;
 const CONNECTION_TIMEOUT = 8000;
 const SERVICE_DISCOVERY_TIMEOUT = 10000;
+const BLE_CLEANUP_TIMEOUT = 250;
 const BLE_PACKET_SIZE = 192;
 const UNIFIED_WRITE_DELAY = 5;
 const RETRY_CONFIG = { MAX_ATTEMPTS: 15, WRITE_TIMEOUT: 2000 };
@@ -83,30 +113,15 @@ 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 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;
+    return (hdShared.hasOnekeyCommunicationService(serviceUuids) &&
+        hdShared.isOnekeyBluetoothDevice({
+            id: peripheral.id,
+            localName: (_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.localName,
+            serviceUuids,
+        }));
 }
 function emitRawNotification(deviceId, data) {
     const appCb = notificationCallbacks.get(deviceId);
@@ -245,9 +260,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) {
@@ -272,6 +290,11 @@ function cleanupDevice(deviceId, webContents, options = {}) {
     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);
+        }
         connectedDevices.delete(deviceId);
         deviceCharacteristics.delete(deviceId);
         notificationCallbacks.delete(deviceId);
@@ -306,10 +329,15 @@ function handleDeviceDisconnect(deviceId, webContents) {
     });
 }
 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);
 }
 function writeCharacteristicWithAck(deviceId, writeCharacteristic, buffer) {
     return index.__awaiter(this, void 0, void 0, function* () {
@@ -470,15 +498,15 @@ 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 performTargetedScan(targetDeviceId) {
@@ -491,7 +519,7 @@ function performTargetedScan(targetDeviceId) {
         return new Promise((resolve, reject) => {
             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,
@@ -583,25 +611,23 @@ 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 runBleCallbackOperation(callback => nobleInstance.stopScanning(() => callback()), {
+            timeoutMs: BLE_CLEANUP_TIMEOUT,
+            timeoutBehavior: 'resolve',
         });
+        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);
@@ -678,14 +704,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 +727,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 +764,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: CONNECTION_TIMEOUT,
+            timeoutBehavior: 'reject',
         });
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Force reconnect successful');
+        connectedDevices.set(deviceId, peripheral);
         yield hdShared.wait(500);
     });
 }
@@ -844,13 +851,23 @@ 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);
         }
     });
@@ -958,17 +975,20 @@ 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,
+            sendDisconnectEvent: false,
+            cancelOperations: true,
+            reason: 'manual-disconnect',
         });
     });
 }
@@ -983,18 +1003,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 +1059,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: CONNECTION_TIMEOUT,
+                    timeoutBehavior: 'reject',
                 });
                 notifyCharacteristic.on('data', (data) => {
                     if (!pairedDevices.has(deviceId)) {
@@ -1158,23 +1165,23 @@ 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);
+                if (noble && persistentStateListener) {
+                    noble.removeListener('stateChange', persistentStateListener);
+                    persistentStateListener = null;
+                }
+                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');
     }

package/dist/noble-ble-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAsB,WAAW,EAAE,MAAM,UAAU,CAAC;AAw8ChE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAiKpE"}
+{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAsB,WAAW,EAAE,MAAM,UAAU,CAAC;AA46ChE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAyJpE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-electron",
-  "version": "1.2.0-alpha.32",
+  "version": "1.2.0-alpha.34",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -25,9 +25,9 @@
     "electron-log": ">=4.0.0"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.2.0-alpha.32",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.32",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.32",
+    "@onekeyfe/hd-core": "1.2.0-alpha.34",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.34",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.34",
     "@stoprocent/noble": "2.3.16",
     "p-retry": "^4.6.2"
   },
@@ -36,5 +36,5 @@
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "468888b93df8b147a512f63a8cbdc40ca1c5c1cf"
+  "gitHead": "07f10b4c9fab177da7c36d976ec18b075492b57f"
 }

package/src/__tests__/ble-ops.test.ts

@@ -0,0 +1,23 @@
+import { runBleCallbackOperation } from '../ble-ops';
+
+describe('Electron Noble callback operations', () => {
+  test('settles when Noble never invokes the callback', async () => {
+    const result = await runBleCallbackOperation(
+      callback => {
+        void callback;
+      },
+      { timeoutMs: 5, timeoutBehavior: 'resolve' }
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  test('rejects callback errors before the timeout', async () => {
+    await expect(
+      runBleCallbackOperation(callback => callback(new Error('operation failed')), {
+        timeoutMs: 50,
+        timeoutBehavior: 'reject',
+      })
+    ).rejects.toThrow('operation failed');
+  });
+});

package/src/ble-ops.ts

@@ -1,6 +1,40 @@
 import type { Characteristic } from '@stoprocent/noble';
 import type { Logger } from './types/noble-extended';
 
+type BleCallback = (error?: Error) => void;
+
+export function runBleCallbackOperation(
+  operation: (callback: BleCallback) => void,
+  options: { timeoutMs: number; timeoutBehavior: 'resolve' | 'reject' }
+): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    let settled = false;
+    const settle = (error?: 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)));
+    }
+  });
+}
+
 export interface SoftRefreshParams {
   deviceId: string;
   notifyCharacteristic: Characteristic | null | undefined;
@@ -30,18 +64,14 @@ export async function softRefreshSubscription(params: SoftRefreshParams): Promis
 
   subscriptionOperations.set(deviceId, 'subscribing');
 
-  await new Promise<void>(resolve => {
-    notifyCharacteristic.unsubscribe(() => resolve());
+  await runBleCallbackOperation(callback => notifyCharacteristic.unsubscribe(callback), {
+    timeoutMs: 250,
+    timeoutBehavior: 'resolve',
   });
 
-  await new Promise<void>((resolve, reject) => {
-    notifyCharacteristic.subscribe((error?: Error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
+  await runBleCallbackOperation(callback => notifyCharacteristic.subscribe(callback), {
+    timeoutMs: 8_000,
+    timeoutBehavior: 'reject',
   });
 
   notifyCharacteristic.removeAllListeners('data');

package/src/noble-ble-handler.ts

@@ -9,14 +9,19 @@ import {
   EOneKeyBleMessageKeys,
   ERRORS,
   HardwareErrorCode,
+  ONEKEY_NOTIFY_CHARACTERISTIC_UUID,
   ONEKEY_SERVICE_UUID,
-  isOnekeyDevice,
+  ONEKEY_WRITE_CHARACTERISTIC_UUID,
+  createKnownBleUuidAliases,
+  hasOnekeyCommunicationService,
+  isOnekeyBluetoothDevice,
+  matchesKnownBleUuid,
   wait,
 } from '@onekeyfe/hd-shared';
 import pRetry from 'p-retry';
 
 import { safeLog } from './types/noble-extended';
-import { softRefreshSubscription } from './ble-ops';
+import { runBleCallbackOperation, softRefreshSubscription } from './ble-ops';
 
 import type { IpcMainInvokeEvent, WebContents } from 'electron';
 import type { Characteristic, Peripheral, Service } from '@stoprocent/noble';
@@ -39,6 +44,7 @@ const bluetoothState: {
 
 // Global persistent state listener for app layer
 let persistentStateListener: ((state: string) => void) | null = null;
+let persistentDiscoverListener: ((peripheral: Peripheral) => void) | null = null;
 
 // Device cache and connection state
 const discoveredDevices = new Map<string, Peripheral>();
@@ -50,6 +56,10 @@ const subscribedDevices = new Map<string, boolean>(); // Track subscription stat
 
 // 🔒 Subscription operation state tracking to prevent race conditions
 const subscriptionOperations = new Map<string, 'subscribing' | 'unsubscribing' | 'idle'>();
+const deviceDisconnectListeners = new Map<
+  string,
+  { peripheral: Peripheral; listener: () => void }
+>();
 
 // Windows-only response watchdog state moved to utils/windows-ble-recovery
 
@@ -59,11 +69,9 @@ const subscriptionOperations = new Map<string, 'subscribing' | 'unsubscribing' |
 
 // Service UUIDs to scan for - using constants from hd-shared
 const ONEKEY_SERVICE_UUIDS = [ONEKEY_SERVICE_UUID];
-const PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS = new Set(['fffd']);
-
-// Pre-normalized characteristic identifiers for fast comparison
-const NORMALIZED_WRITE_UUID = '0002';
-const NORMALIZED_NOTIFY_UUID = '0003';
+const ONEKEY_SERVICE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_SERVICE_UUID);
+const ONEKEY_WRITE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_WRITE_CHARACTERISTIC_UUID);
+const ONEKEY_NOTIFY_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_NOTIFY_CHARACTERISTIC_UUID);
 
 // Timeout and interval constants
 const BLUETOOTH_INIT_TIMEOUT = 10000; // 10 seconds for Bluetooth initialization
@@ -72,6 +80,7 @@ const FAST_SCAN_TIMEOUT = 8000; // 8 seconds for targeted scanning (Pro2 has lon
 const DEVICE_CHECK_INTERVAL = 500; // 500ms interval for periodic device checks
 const CONNECTION_TIMEOUT = 8000; // 8 seconds for device connection (BLE reconnect after release can be slow)
 const SERVICE_DISCOVERY_TIMEOUT = 10000; // 10 seconds for service discovery
+const BLE_CLEANUP_TIMEOUT = 250;
 
 // Write-related constants
 const BLE_PACKET_SIZE = 192;
@@ -82,34 +91,16 @@ const ABORTABLE_WRITE_ERROR_PATTERNS = [
   /status:\s*3/i, // Windows pairing cancelled / GATT write failed
 ];
 
-function getBleUuidKey(uuid?: string | null) {
-  const normalized = (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?: string | null) {
-  return ['1800', '1801', '180a', '180f'].includes(getBleUuidKey(uuid));
-}
-
-function hasOneKeyAdvertisementService(peripheral: Peripheral) {
-  const serviceUuids = peripheral.advertisement?.serviceUuids ?? [];
-  return serviceUuids.some(uuid => {
-    const uuidKey = getBleUuidKey(uuid);
-    return (
-      NORMALIZED_ONEKEY_SERVICE_UUIDS.has(uuidKey) ||
-      PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(uuidKey)
-    );
-  });
-}
-
 function isOneKeyPeripheral(peripheral: Peripheral) {
-  const deviceName = peripheral.advertisement?.localName || null;
-  return isOnekeyDevice(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
+  const serviceUuids = peripheral.advertisement?.serviceUuids;
+  return (
+    hasOnekeyCommunicationService(serviceUuids) &&
+    isOnekeyBluetoothDevice({
+      id: peripheral.id,
+      localName: peripheral.advertisement?.localName,
+      serviceUuids,
+    })
+  );
 }
 
 /**
@@ -290,9 +281,12 @@ async function initializeNoble(): Promise<void> {
     });
 
     // Set up device discovery
-    noble.on('discover', (peripheral: Peripheral) => {
-      handleDeviceDiscovered(peripheral);
-    });
+    if (!persistentDiscoverListener) {
+      persistentDiscoverListener = (peripheral: Peripheral) => {
+        handleDeviceDiscovered(peripheral);
+      };
+      noble.on('discover', persistentDiscoverListener);
+    }
 
     logger?.info('[NobleBLE] Noble initialized successfully');
   } catch (error) {
@@ -354,6 +348,11 @@ function cleanupDevice(
 
   // 1. Clean up connection state
   if (cleanupConnection) {
+    const disconnectEntry = deviceDisconnectListeners.get(deviceId);
+    if (disconnectEntry) {
+      disconnectEntry.peripheral.removeListener('disconnect', disconnectEntry.listener);
+      deviceDisconnectListeners.delete(deviceId);
+    }
     connectedDevices.delete(deviceId);
     deviceCharacteristics.delete(deviceId);
     notificationCallbacks.delete(deviceId);
@@ -403,13 +402,16 @@ function setupDisconnectListener(
   deviceId: string,
   webContents: WebContents
 ): void {
-  // Remove any existing disconnect listeners to avoid duplicates
-  peripheral.removeAllListeners('disconnect');
+  const existing = deviceDisconnectListeners.get(deviceId);
+  if (existing) {
+    existing.peripheral.removeListener('disconnect', existing.listener);
+  }
 
-  // Set up new disconnect listener
-  peripheral.on('disconnect', () => {
+  const listener = () => {
     handleDeviceDisconnect(deviceId, webContents);
-  });
+  };
+  deviceDisconnectListeners.set(deviceId, { peripheral, listener });
+  peripheral.on('disconnect', listener);
 }
 
 // ===== Write helpers (inline) =====
@@ -628,16 +630,14 @@ function handleDeviceDiscovered(peripheral: Peripheral): void {
 function ensureDiscoverListener(): void {
   if (!noble) return;
 
-  // Check if discover listener exists by checking listener count
-  const listenerCount = (noble as any).listenerCount('discover');
-
-  if (listenerCount === 0) {
+  if (!persistentDiscoverListener) {
     logger?.info('[NobleBLE] Discover listener missing, re-adding it');
-    noble.on('discover', (peripheral: Peripheral) => {
+    persistentDiscoverListener = (peripheral: Peripheral) => {
       handleDeviceDiscovered(peripheral);
-    });
+    };
+    noble.on('discover', persistentDiscoverListener);
   } else {
-    logger?.debug('[NobleBLE] Discover listener already exists, count:', listenerCount);
+    logger?.debug('[NobleBLE] Discover listener already registered');
   }
 }
 
@@ -656,7 +656,7 @@ async function performTargetedScan(targetDeviceId: string): Promise<Peripheral |
   return new Promise((resolve, reject) => {
     // Local discover listener - only matches target device
     const onDiscover = (peripheral: Peripheral) => {
-      if (peripheral.id === targetDeviceId) {
+      if (peripheral.id === targetDeviceId && isOneKeyPeripheral(peripheral)) {
         logger?.info('[NobleBLE] Target device found during targeted scan:', {
           id: peripheral.id,
           name: peripheral.advertisement?.localName,
@@ -774,30 +774,24 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
 // Stop scanning
 async function stopScanning(): Promise<void> {
   if (!noble) return;
-
-  return new Promise<void>(resolve => {
-    if (!noble) {
-      resolve();
-      return;
-    }
-
-    noble.stopScanning(() => {
-      logger?.info('[NobleBLE] Scanning stopped');
-      resolve();
-    });
+  const nobleInstance = noble;
+  await runBleCallbackOperation(callback => nobleInstance.stopScanning(() => callback()), {
+    timeoutMs: BLE_CLEANUP_TIMEOUT,
+    timeoutBehavior: 'resolve',
   });
+  logger?.info('[NobleBLE] Scanning stopped');
 }
 
 // Clean up all Noble listeners (for app exit)
 function cleanupNobleListeners(): void {
   if (!noble) return;
 
-  // Remove all listeners to prevent memory leaks
-  // Noble uses EventEmitter, need to use removeAllListeners
   try {
-    (noble as any).removeAllListeners('discover');
-    (noble as any).removeAllListeners('stateChange');
-    logger?.info('[NobleBLE] All Noble listeners cleaned up');
+    if (persistentDiscoverListener) {
+      noble.removeListener('discover', persistentDiscoverListener);
+      persistentDiscoverListener = null;
+    }
+    logger?.info('[NobleBLE] Owned Noble listeners cleaned up');
   } catch (error) {
     logger?.error('[NobleBLE] Failed to clean up some listeners:', error);
   }
@@ -905,14 +899,7 @@ async function discoverServicesAndCharacteristics(
     });
 
     // Find OneKey service — Noble may expose 128-bit UUIDs as short UUID keys.
-    let service = services.find(s => NORMALIZED_ONEKEY_SERVICE_UUIDS.has(getBleUuidKey(s.uuid)));
-    if (!service) {
-      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 => matchesKnownBleUuid(s.uuid, ONEKEY_SERVICE_UUID_ALIASES));
     if (!service) {
       throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
     }
@@ -938,12 +925,9 @@ async function discoverServicesAndCharacteristics(
     let notifyCharacteristic: Characteristic | null = 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 (matchesKnownBleUuid(characteristic.uuid, ONEKEY_WRITE_UUID_ALIASES)) {
         writeCharacteristic = characteristic;
-      } else if (uuidKey === NORMALIZED_NOTIFY_UUID) {
+      } else if (matchesKnownBleUuid(characteristic.uuid, ONEKEY_NOTIFY_UUID_ALIASES)) {
         notifyCharacteristic = characteristic;
       }
     }
@@ -1000,29 +984,23 @@ async function forceReconnectPeripheral(peripheral: Peripheral, deviceId: string
 
   // Step 2: Force disconnect if connected
   if (peripheral.state === 'connected') {
-    // Remove disconnect listener before intentional disconnect to avoid spurious events
-    peripheral.removeAllListeners('disconnect');
-    await new Promise<void>(resolve => {
-      peripheral.disconnect(() => {
-        logger?.info('[NobleBLE] Force disconnect completed');
-        resolve();
-      });
-    });
+    await runBleCallbackOperation(
+      callback =>
+        peripheral.disconnect(() => {
+          logger?.info('[NobleBLE] Force disconnect completed');
+          callback();
+        }),
+      { timeoutMs: BLE_CLEANUP_TIMEOUT, timeoutBehavior: 'resolve' }
+    );
   }
 
   // Step 3: Re-establish connection
-  await new Promise<void>((resolve, reject) => {
-    peripheral.connect((error: Error | undefined) => {
-      if (error) {
-        logger?.error('[NobleBLE] Force reconnect failed:', error);
-        reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError, error.message));
-      } else {
-        logger?.info('[NobleBLE] Force reconnect successful');
-        connectedDevices.set(deviceId, peripheral);
-        resolve();
-      }
-    });
+  await runBleCallbackOperation(callback => peripheral.connect(callback), {
+    timeoutMs: CONNECTION_TIMEOUT,
+    timeoutBehavior: 'reject',
   });
+  logger?.info('[NobleBLE] Force reconnect successful');
+  connectedDevices.set(deviceId, peripheral);
 
   // Wait for connection to stabilize
   await wait(500);
@@ -1153,16 +1131,26 @@ async function setupConnectionAndDiscoverServices(
   deviceId: string,
   webContents: WebContents
 ): Promise<CharacteristicPair> {
-  // Force reconnect to clear GATT cache
-  await forceReconnectPeripheral(peripheral, deviceId);
   setupDisconnectListener(peripheral, deviceId, webContents);
 
-  // Discover services and characteristics with retry
   try {
     return await discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
-  } catch (error) {
-    // Last resort: fresh scan to get new peripheral object
-    logger?.error('[NobleBLE] Service discovery failed, attempting fresh scan...', error);
+  } catch (initialError) {
+    logger?.info('[NobleBLE] Direct service discovery failed, retrying after reconnect', {
+      deviceId,
+      error: initialError,
+    });
+  }
+
+  await forceReconnectPeripheral(peripheral, deviceId);
+  setupDisconnectListener(peripheral, deviceId, webContents);
+  try {
+    return await discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
+  } catch (reconnectError) {
+    logger?.error(
+      '[NobleBLE] Service discovery failed after reconnect, attempting fresh scan...',
+      reconnectError
+    );
     return freshScanAndDiscover(deviceId, webContents);
   }
 }
@@ -1325,20 +1313,21 @@ async function disconnectDevice(deviceId: string): Promise<void> {
     return;
   }
 
-  return new Promise<void>(resolve => {
-    // Remove disconnect listener to avoid triggering handleDeviceDisconnect
-    peripheral.removeAllListeners('disconnect');
-
-    peripheral.disconnect(() => {
-      // Clean up device state using unified function
-      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);
+  }
+
+  await runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+    timeoutMs: BLE_CLEANUP_TIMEOUT,
+    timeoutBehavior: 'resolve',
+  });
+  cleanupDevice(deviceId, undefined, {
+    cleanupConnection: true,
+    sendDisconnectEvent: false,
+    cancelOperations: true,
+    reason: 'manual-disconnect',
   });
 }
 
@@ -1359,17 +1348,11 @@ async function unsubscribeNotifications(deviceId: string): Promise<void> {
   subscriptionOperations.set(deviceId, 'unsubscribing');
 
   try {
-    await new Promise<void>((resolve, reject) => {
-      notifyCharacteristic.unsubscribe((error: Error | undefined) => {
-        if (error) {
-          logger?.error('[NobleBLE] Notification unsubscription failed:', error);
-          reject(error);
-        } else {
-          logger?.info('[NobleBLE] Notification unsubscription successful');
-          resolve();
-        }
-      });
+    await runBleCallbackOperation(callback => notifyCharacteristic.unsubscribe(callback), {
+      timeoutMs: BLE_CLEANUP_TIMEOUT,
+      timeoutBehavior: 'resolve',
     });
+    logger?.info('[NobleBLE] Notification unsubscription completed');
 
     // Remove all listeners and clear subscription status
     notifyCharacteristic.removeAllListeners('data');
@@ -1462,19 +1445,13 @@ async function subscribeNotifications(
     notifyCharacteristic: Characteristic
   ): Promise<void> {
     // Listeners already cleaned up above, no need to repeat
-    await new Promise<void>(resolve => {
-      notifyCharacteristic.unsubscribe(() => {
-        resolve();
-      });
+    await runBleCallbackOperation(callback => notifyCharacteristic.unsubscribe(callback), {
+      timeoutMs: BLE_CLEANUP_TIMEOUT,
+      timeoutBehavior: 'resolve',
     });
-    await new Promise<void>((resolve, reject) => {
-      notifyCharacteristic.subscribe((error?: Error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve();
-      });
+    await runBleCallbackOperation(callback => notifyCharacteristic.subscribe(callback), {
+      timeoutMs: CONNECTION_TIMEOUT,
+      timeoutBehavior: 'reject',
     });
 
     notifyCharacteristic.on('data', (data: Buffer) => {
@@ -1626,32 +1603,24 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     // Cleanup on app quit
     webContents.on('destroyed', () => {
       safeLog(logger, 'info', 'Cleaning up Noble BLE handlers');
+      (async () => {
+        const deviceIds = Array.from(connectedDevices.keys());
+        for (const deviceId of deviceIds) {
+          await unsubscribeNotifications(deviceId).catch(() => undefined);
+          await disconnectDevice(deviceId).catch(() => undefined);
+        }
 
-      // 1. Clean up all connected devices (unified cleanup, avoid duplicates)
-      const deviceIds = Array.from(connectedDevices.keys());
-      deviceIds.forEach(deviceId => {
-        cleanupDevice(deviceId, undefined, {
-          cleanupConnection: true,
-          sendDisconnectEvent: false,
-          cancelOperations: true,
-          reason: 'app-quit',
-        });
+        await stopScanning().catch(() => undefined);
+        if (noble && persistentStateListener) {
+          noble.removeListener('stateChange', persistentStateListener);
+          persistentStateListener = null;
+        }
+        cleanupNobleListeners();
+        discoveredDevices.clear();
+        safeLog(logger, 'info', 'Noble BLE cleanup completed');
+      })().catch(error => {
+        safeLog(logger, 'error', 'Noble BLE cleanup failed', error);
       });
-
-      // 2. Stop scanning
-      stopScanning();
-
-      // 3. Clean up Noble listeners
-      if (noble && persistentStateListener) {
-        noble.removeListener('stateChange', persistentStateListener);
-        persistentStateListener = null;
-      }
-      cleanupNobleListeners();
-
-      // 4. Clear discovered devices cache
-      discoveredDevices.clear();
-
-      safeLog(logger, 'info', 'Noble BLE cleanup completed');
     });
 
     safeLog(logger, 'info', 'Noble BLE IPC handlers setup completed');