@onekeyfe/hd-transport-electron 1.2.0-alpha.7 → 1.2.0-alpha.71

package/dist/{noble-ble-handler-94c42077.js → noble-ble-handler-7ac9c43d.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-02fc07fe.js');
+var index = require('./index-bd1cfdb6.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,54 +105,39 @@ 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_PACKET_SIZE_FALLBACK = 192;
+const BLE_PACKET_SIZE_MAXIMUM = 244;
 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 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()) || hdShared.isPro2FindMyAdvertisementName(localName)) {
+        return false;
+    }
+    return (hdShared.hasOnekeyCommunicationService(serviceUuids) &&
+        hdShared.isOnekeyBluetoothDevice({
+            id: peripheral.id,
+            localName,
+            serviceUuids,
+        }));
 }
 function emitRawNotification(deviceId, data) {
-    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Raw notification', {
-        deviceId,
-        dataLength: data.length,
-        firstBytes: data.subarray(0, 8).toString('hex'),
-    });
     const appCb = notificationCallbacks.get(deviceId);
     if (appCb)
         appCb(data.toString('hex'));
@@ -250,9 +274,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) {
@@ -277,6 +304,16 @@ 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);
+        }
+        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);
@@ -311,12 +348,34 @@ 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);
+    setupMtuListener(peripheral, deviceId, webContents);
+}
+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;
+        webContents.send(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_MTU_CHANGED, {
+            id: deviceId,
+            mtu,
+        });
+    };
+    deviceMtuListeners.set(deviceId, { peripheral, listener });
+    peripheral.on('mtu', listener);
 }
-function writeCharacteristicWithAck(deviceId, writeCharacteristic, buffer) {
+function writeCharacteristicWithoutResponse(deviceId, writeCharacteristic, buffer) {
     return index.__awaiter(this, void 0, void 0, function* () {
         return new Promise((resolve, reject) => {
             writeCharacteristic.write(buffer, true, (error) => {
@@ -348,7 +407,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);
@@ -415,84 +474,78 @@ function transmitHexDataToDevice(deviceId, hexData) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, `Device ${deviceId} not connected or characteristics not available`);
         }
         const toBuffer = Buffer.from(hexData, 'hex');
-        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Writing data:', {
-            deviceId,
-            dataLength: toBuffer.length,
-            firstBytes: toBuffer.subarray(0, 8).toString('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);
         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) {
+                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);
             }
             return;
         }
-        if (toBuffer.length <= BLE_PACKET_SIZE) {
-            yield hdShared.wait(UNIFIED_WRITE_DELAY);
+        if (toBuffer.length <= packetCapacity) {
             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);
-            }
         }
     });
 }
 function handleDeviceDiscovered(peripheral) {
     var _a, _b;
-    const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
-    const serviceUuids = ((_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.serviceUuids) || [];
     if (!isOneKeyPeripheral(peripheral)) {
         return;
     }
     const isNewDevice = !discoveredDevices.has(peripheral.id);
     discoveredDevices.set(peripheral.id, peripheral);
     if (isNewDevice) {
-        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Discovered OneKey BLE device:', {
-            name: deviceName,
-            id: peripheral.id,
-            serviceUUIDs: serviceUuids,
+        logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] OneKey BLE device discovered', {
+            deviceId: peripheral.id,
+            name: ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device',
+            serviceUUIDs: ((_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.serviceUuids) || [],
         });
     }
 }
 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) {
@@ -501,33 +554,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) => {
                 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);
@@ -550,12 +613,12 @@ 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 checkDevices = () => {
                 discoveredDevices.forEach((peripheral, id) => {
                     var _a;
@@ -571,23 +634,23 @@ function enumerateDevices() {
                     }
                 });
             };
-            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([], false, (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);
-            });
+            }));
         });
     });
 }
@@ -595,25 +658,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);
@@ -624,22 +682,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',
@@ -683,23 +731,22 @@ function discoverServicesAndCharacteristics(peripheral) {
                     }
                 });
             });
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] All services:', services === null || services === void 0 ? void 0 : services.map(s => s.uuid));
             if (!services || services.length === 0) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No services found');
             }
-            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];
-            }
+            logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] services discovered', {
+                deviceId: peripheral.id,
+                serviceUUIDs: services.map(service => service.uuid),
+            });
+            const service = services.find(s => hdShared.matchesKnownBleUuid(s.uuid, ONEKEY_SERVICE_UUID_ALIASES));
             if (!service) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound);
             }
             const selectedService = service;
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Using service:', selectedService.uuid);
+            logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] service selected', {
+                deviceId: peripheral.id,
+                serviceUuid: selectedService.uuid,
+            });
             const characteristics = yield new Promise((resolve, reject) => {
                 selectedService.discoverCharacteristics([], (error, chars) => {
                     if (error) {
@@ -711,30 +758,26 @@ function discoverServicesAndCharacteristics(peripheral) {
                     }
                 });
             });
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Discovered characteristics:', {
-                count: (characteristics === null || characteristics === void 0 ? void 0 : characteristics.length) || 0,
-                uuids: (characteristics === null || characteristics === void 0 ? void 0 : characteristics.map(c => c.uuid)) || [],
-            });
             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;
                 }
             }
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Characteristic discovery result:', {
-                writeFound: !!writeCharacteristic,
-                notifyFound: !!notifyCharacteristic,
-            });
             if (!writeCharacteristic || !notifyCharacteristic) {
                 logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Missing characteristics - write:', !!writeCharacteristic, 'notify:', !!notifyCharacteristic);
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, 'Required characteristics not found');
             }
+            logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] characteristics selected', {
+                deviceId: peripheral.id,
+                serviceUuid: selectedService.uuid,
+                writeUuid: writeCharacteristic.uuid,
+                notifyUuid: notifyCharacteristic.uuid,
+            });
             return { write: writeCharacteristic, notify: notifyCharacteristic };
         }))();
         try {
@@ -755,27 +798,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);
     });
 }
@@ -852,13 +885,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);
         }
     });
@@ -931,12 +974,24 @@ function connectDevice(deviceId, webContents) {
             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));
@@ -966,17 +1021,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',
         });
     });
 }
@@ -991,18 +1049,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);
@@ -1054,19 +1105,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)) {
@@ -1087,19 +1132,17 @@ function subscribeNotifications(deviceId, callback) {
     });
 }
 function setupNobleBleHandlers(webContents) {
-    console.log('[NobleBLE] Attempting to set up Noble BLE handlers.');
     try {
-        console.log('[NobleBLE] NOBLE_VERSION_771');
         logger = require('electron-log');
-        console.log('[NobleBLE] electron-log loaded successfully.');
         const { ipcMain } = require('electron');
-        console.log('[NobleBLE] electron.ipcMain loaded successfully.');
         safeLog(logger, 'info', 'Setting up Noble BLE IPC handlers');
-        console.log(`[NobleBLE] Registering handler for: ${hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE}`);
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, () => index.__awaiter(this, void 0, void 0, function* () {
             try {
                 const devices = yield enumerateDevices();
-                safeLog(logger, 'info', 'Enumeration completed, devices:', devices);
+                safeLog(logger, 'debug', 'Enumeration completed', {
+                    count: devices.length,
+                    devices: devices.map(device => ({ id: device.id, name: device.name })),
+                });
                 return devices;
             }
             catch (error) {
@@ -1124,7 +1167,6 @@ function setupNobleBleHandlers(webContents) {
             yield disconnectDevice(deviceId);
         }));
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_WRITE, (_event, deviceId, hexData) => index.__awaiter(this, void 0, void 0, function* () {
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] IPC WRITE', { deviceId, len: hexData.length });
             yield transmitHexDataToDevice(deviceId, hexData);
         }));
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_SUBSCRIBE, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {
@@ -1169,23 +1211,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');
     }