@onekeyfe/hd-transport-electron 1.1.23 → 1.1.24-alpha.1

package/dist/{index-1fa563cd.js → index-de36348d.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-1a6d7f4a.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-2e41f27c.js'); });
         setupNobleBleHandlers(webContents);
     });
 }

package/dist/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./index-1fa563cd.js');
+var index = require('./index-de36348d.js');
 
 
 

package/dist/{noble-ble-handler-1a6d7f4a.js → noble-ble-handler-2e41f27c.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-1fa563cd.js');
+var index = require('./index-de36348d.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var hdTransport = require('@onekeyfe/hd-transport');
 var pRetry = require('p-retry');
@@ -85,6 +85,7 @@ const DEVICE_SCAN_TIMEOUT = 5000;
 const FAST_SCAN_TIMEOUT = 1500;
 const DEVICE_CHECK_INTERVAL = 500;
 const CONNECTION_TIMEOUT = 3000;
+const SERVICE_DISCOVERY_TIMEOUT = 10000;
 const BLE_PACKET_SIZE = 192;
 const UNIFIED_WRITE_DELAY = 5;
 const RETRY_CONFIG = { MAX_ATTEMPTS: 15, WRITE_TIMEOUT: 2000 };
@@ -305,11 +306,12 @@ function initializeNoble() {
 }
 function cleanupDevice(deviceId, webContents, options = {}) {
     var _a;
-    const { cleanupConnection = true, sendDisconnectEvent = false, cancelOperations = true, reason = 'unknown', } = options;
+    const { cleanupConnection = true, cleanupDiscoveredCache = false, sendDisconnectEvent = false, cancelOperations = true, reason = 'unknown', } = options;
     logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting device cleanup', {
         deviceId,
         reason,
         cleanupConnection,
+        cleanupDiscoveredCache,
         sendDisconnectEvent,
         cancelOperations,
     });
@@ -324,6 +326,9 @@ function cleanupDevice(deviceId, webContents, options = {}) {
         subscriptionOperations.delete(deviceId);
         pairedDevices.delete(deviceId);
     }
+    if (cleanupDiscoveredCache) {
+        discoveredDevices.delete(deviceId);
+    }
     if (sendDisconnectEvent && webContents) {
         webContents.send(hdShared.EOneKeyBleMessageKeys.BLE_DEVICE_DISCONNECTED, {
             id: deviceId,
@@ -469,7 +474,7 @@ function transmitHexDataToDevice(deviceId, hexData) {
                 yield writeCharacteristicWithAck(deviceId, writeCharacteristic, toBuffer);
                 return;
             }
-            for (let offset = 0, idx = 0; offset < toBuffer.length; idx++) {
+            for (let offset = 0; offset < toBuffer.length;) {
                 const chunkSize = Math.min(BLE_PACKET_SIZE, toBuffer.length - offset);
                 const chunk = toBuffer.subarray(offset, offset + chunkSize);
                 offset += chunkSize;
@@ -528,50 +533,40 @@ function performTargetedScan(targetDeviceId) {
         if (!noble) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
         }
+        const nobleInstance = noble;
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting targeted scan for device:', targetDeviceId);
-        ensureDiscoverListener();
         return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                if (noble) {
-                    noble.stopScanning();
-                }
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan timeout for device:', targetDeviceId);
-                resolve(null);
-            }, FAST_SCAN_TIMEOUT);
             const onDiscover = (peripheral) => {
                 var _a;
                 if (peripheral.id === targetDeviceId) {
-                    clearTimeout(timeout);
-                    if (noble) {
-                        noble.stopScanning();
-                        noble.removeListener('discover', onDiscover);
-                    }
-                    discoveredDevices.set(peripheral.id, peripheral);
-                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] OneKey device found during targeted scan:', {
+                    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) || 'Unknown',
+                        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);
                 }
             };
-            if (noble) {
-                noble.removeListener('discover', onDiscover);
-                noble.on('discover', onDiscover);
-            }
-            if (noble) {
-                noble.startScanning(ONEKEY_SERVICE_UUIDS, false, (error) => {
-                    if (error) {
-                        clearTimeout(timeout);
-                        if (noble) {
-                            noble.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));
-                        return;
-                    }
-                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan started for device:', targetDeviceId);
-                });
-            }
+            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);
+            nobleInstance.on('discover', onDiscover);
+            nobleInstance.startScanning(ONEKEY_SERVICE_UUIDS, 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));
+                    return;
+                }
+                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan started for device:', targetDeviceId);
+            });
         });
     });
 }
@@ -583,49 +578,48 @@ function enumerateDevices() {
         if (!noble) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
         }
+        const nobleInstance = noble;
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting device enumeration');
         discoveredDevices.clear();
         ensureDiscoverListener();
         return new Promise((resolve, reject) => {
             const devices = [];
-            if (!noble) {
-                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available'));
-                return;
-            }
-            const timeout = setTimeout(() => {
-                if (noble) {
-                    noble.stopScanning();
-                }
+            let intervalId;
+            const cleanup = () => {
+                clearTimeout(timeoutId);
+                if (intervalId)
+                    clearInterval(intervalId);
+                nobleInstance.stopScanning();
+            };
+            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',
+                        });
+                    }
+                });
+            };
+            const timeoutId = setTimeout(() => {
+                cleanup();
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scan completed, found devices:', devices.length);
                 resolve(devices);
             }, DEVICE_SCAN_TIMEOUT);
-            noble.startScanning(ONEKEY_SERVICE_UUIDS, false, (error) => {
+            nobleInstance.startScanning(ONEKEY_SERVICE_UUIDS, false, (error) => {
                 if (error) {
-                    clearTimeout(timeout);
+                    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');
-                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',
-                            });
-                        }
-                    });
-                };
-                const interval = setInterval(checkDevices, DEVICE_CHECK_INTERVAL);
-                setTimeout(() => {
-                    clearInterval(interval);
-                }, DEVICE_SCAN_TIMEOUT);
+                intervalId = setInterval(checkDevices, DEVICE_CHECK_INTERVAL);
             });
         });
     });
@@ -689,54 +683,87 @@ function getDevice(deviceId) {
 }
 function discoverServicesAndCharacteristics(peripheral) {
     return index.__awaiter(this, void 0, void 0, function* () {
-        return new Promise((resolve, reject) => {
-            peripheral.discoverServices(ONEKEY_SERVICE_UUIDS, (error, services) => {
-                if (error) {
-                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed:', error);
-                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, error.message));
-                    return;
-                }
-                if (!services || services.length === 0) {
-                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No OneKey services found'));
-                    return;
-                }
-                const service = services[0];
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Found service:', service.uuid);
-                service.discoverCharacteristics([hdShared.ONEKEY_WRITE_CHARACTERISTIC_UUID, hdShared.ONEKEY_NOTIFY_CHARACTERISTIC_UUID], (error, characteristics) => {
+        let timeoutId;
+        let onDisconnect;
+        const cleanup = () => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (onDisconnect)
+                peripheral.removeListener('disconnect', onDisconnect);
+        };
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery timeout');
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'Service discovery timeout'));
+            }, SERVICE_DISCOVERY_TIMEOUT);
+        });
+        const disconnectPromise = new Promise((_, reject) => {
+            onDisconnect = () => {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Device disconnected during service discovery');
+                reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'Device disconnected during service discovery'));
+            };
+            peripheral.once('disconnect', onDisconnect);
+        });
+        const discoveryPromise = (() => index.__awaiter(this, void 0, void 0, function* () {
+            const services = yield new Promise((resolve, reject) => {
+                peripheral.discoverServices(ONEKEY_SERVICE_UUIDS, (error, svc) => {
+                    if (error) {
+                        logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed:', error);
+                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, error.message));
+                    }
+                    else {
+                        resolve(svc);
+                    }
+                });
+            });
+            if (!services || services.length === 0) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No OneKey services found');
+            }
+            const service = services[0];
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Found service:', service.uuid);
+            const characteristics = yield new Promise((resolve, reject) => {
+                service.discoverCharacteristics([hdShared.ONEKEY_WRITE_CHARACTERISTIC_UUID, hdShared.ONEKEY_NOTIFY_CHARACTERISTIC_UUID], (error, chars) => {
                     if (error) {
                         logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Characteristic discovery failed:', error);
                         reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, error.message));
-                        return;
                     }
-                    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) {
-                            writeCharacteristic = characteristic;
-                        }
-                        else if (uuidKey === NORMALIZED_NOTIFY_UUID) {
-                            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);
-                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, 'Required characteristics not found'));
-                        return;
+                    else {
+                        resolve(chars);
                     }
-                    resolve({ write: writeCharacteristic, notify: notifyCharacteristic });
                 });
             });
-        });
+            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) {
+                    writeCharacteristic = characteristic;
+                }
+                else if (uuidKey === NORMALIZED_NOTIFY_UUID) {
+                    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');
+            }
+            return { write: writeCharacteristic, notify: notifyCharacteristic };
+        }))();
+        try {
+            return yield Promise.race([discoveryPromise, timeoutPromise, disconnectPromise]);
+        }
+        finally {
+            cleanup();
+        }
     });
 }
 function forceReconnectPeripheral(peripheral, deviceId) {
@@ -749,20 +776,19 @@ 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 hdShared.wait(1000);
         }
-        peripheral.removeAllListeners();
         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(new Error(`Force reconnect failed: ${error.message}`));
+                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, error.message));
                 }
                 else {
                     logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Force reconnect successful');
@@ -774,49 +800,34 @@ function forceReconnectPeripheral(peripheral, deviceId) {
         yield hdShared.wait(500);
     });
 }
-function connectAndDiscoverWithFreshScan(deviceId) {
+function freshScanAndDiscover(deviceId, webContents) {
     return index.__awaiter(this, void 0, void 0, function* () {
-        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Attempting connection with fresh peripheral scan as fallback');
-        const currentPeripheral = discoveredDevices.get(deviceId);
-        if (currentPeripheral) {
-            try {
-                return yield discoverServicesAndCharacteristicsWithRetry(currentPeripheral, deviceId);
-            }
-            catch (error) {
-                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed with existing peripheral, attempting fresh scan...');
-            }
-        }
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Performing fresh scan to get new peripheral object for device:', deviceId);
-        try {
-            const freshPeripheral = yield performTargetedScan(deviceId);
-            if (!freshPeripheral) {
-                discoveredDevices.delete(deviceId);
-                subscriptionOperations.set(deviceId, 'idle');
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Deep cleanup before throwing DeviceNotFound (fresh scan null)', {
-                    deviceId,
-                });
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found in fresh scan`);
-            }
-            discoveredDevices.set(deviceId, freshPeripheral);
-            yield new Promise((resolve, reject) => {
-                freshPeripheral.connect((error) => {
-                    if (error) {
-                        reject(new Error(`Fresh peripheral connection failed: ${error.message}`));
-                    }
-                    else {
-                        connectedDevices.set(deviceId, freshPeripheral);
-                        resolve();
-                    }
-                });
+        const freshPeripheral = yield performTargetedScan(deviceId);
+        if (!freshPeripheral) {
+            discoveredDevices.delete(deviceId);
+            subscriptionOperations.set(deviceId, 'idle');
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Deep cleanup before throwing DeviceNotFound (fresh scan null)', {
+                deviceId,
             });
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Attempting service discovery with fresh peripheral');
-            yield hdShared.wait(1000);
-            return yield discoverServicesAndCharacteristics(freshPeripheral);
-        }
-        catch (error) {
-            logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Fresh scan and connection failed:', error);
-            throw error;
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found in fresh scan`);
         }
+        discoveredDevices.set(deviceId, freshPeripheral);
+        yield new Promise((resolve, reject) => {
+            freshPeripheral.connect((error) => {
+                if (error) {
+                    reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `Fresh peripheral connection failed: ${error.message}`));
+                }
+                else {
+                    connectedDevices.set(deviceId, freshPeripheral);
+                    resolve();
+                }
+            });
+        });
+        setupDisconnectListener(freshPeripheral, deviceId, webContents);
+        yield hdShared.wait(500);
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Attempting service discovery with fresh peripheral');
+        return discoverServicesAndCharacteristics(freshPeripheral);
     });
 }
 function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
@@ -829,21 +840,11 @@ function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
                 maxRetries: 5,
                 targetUUIDs: ONEKEY_SERVICE_UUIDS,
             });
-            if (attemptNumber === 3) {
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Attempting force reconnect to clear connection state...');
-                try {
-                    yield forceReconnectPeripheral(peripheral, deviceId);
-                }
-                catch (error) {
-                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Force reconnect failed:', error);
-                    throw error;
-                }
-            }
             if (attemptNumber > 1) {
                 logger === null || logger === void 0 ? void 0 : logger.info(`[NobleBLE] Service discovery retry attempt ${attemptNumber}/5`);
             }
             if (peripheral.state !== 'connected') {
-                throw new Error(`Device not connected: ${peripheral.state}`);
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleConnectedError, `Device not connected: ${peripheral.state}`);
             }
             try {
                 return yield discoverServicesAndCharacteristics(peripheral);
@@ -870,6 +871,19 @@ function discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId) {
         });
     });
 }
+function setupConnectionAndDiscoverServices(peripheral, deviceId, webContents) {
+    return index.__awaiter(this, void 0, void 0, function* () {
+        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);
+            return freshScanAndDiscover(deviceId, webContents);
+        }
+    });
+}
 function connectDevice(deviceId, webContents) {
     return index.__awaiter(this, void 0, void 0, function* () {
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connect device request:', {
@@ -933,17 +947,10 @@ function connectDevice(deviceId, webContents) {
                 devicePacketStates.delete(deviceId);
                 subscribedDevices.delete(deviceId);
             }
-            yield hdShared.wait(300);
-            try {
-                const characteristics = yield connectAndDiscoverWithFreshScan(deviceId);
-                deviceCharacteristics.set(deviceId, characteristics);
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device ready for communication:', deviceId);
-                return;
-            }
-            catch (error) {
-                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service/characteristic discovery failed after all attempts:', error);
-                throw error;
-            }
+            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);
+            return;
         }
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
@@ -959,17 +966,17 @@ function connectDevice(deviceId, webContents) {
                 }
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connected to device:', deviceId);
                 connectedDevices.set(deviceId, connectedPeripheral);
-                setupDisconnectListener(connectedPeripheral, deviceId, webContents);
                 try {
-                    const characteristics = yield connectAndDiscoverWithFreshScan(deviceId);
+                    const characteristics = yield setupConnectionAndDiscoverServices(connectedPeripheral, deviceId, webContents);
                     deviceCharacteristics.set(deviceId, characteristics);
                     logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device ready for communication:', deviceId);
                     resolve();
                 }
-                catch (discoveryError) {
-                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service/characteristic discovery failed after all attempts:', discoveryError);
-                    connectedPeripheral.disconnect();
-                    reject(discoveryError);
+                catch (setupError) {
+                    logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Connection setup failed:', setupError);
+                    connectedPeripheral.disconnect(() => {
+                        reject(setupError);
+                    });
                 }
             }));
         });
@@ -1114,9 +1121,13 @@ function subscribeNotifications(deviceId, callback) {
                 });
             });
         }
-        yield rebuildAppSubscription(deviceId, notifyCharacteristic);
-        subscribedDevices.set(deviceId, true);
-        subscriptionOperations.set(deviceId, 'idle');
+        try {
+            yield rebuildAppSubscription(deviceId, notifyCharacteristic);
+            subscribedDevices.set(deviceId, true);
+        }
+        finally {
+            subscriptionOperations.set(deviceId, 'idle');
+        }
     });
 }
 function setupNobleBleHandlers(webContents) {

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":"AAwBA,OAAO,KAAK,EAAsB,WAAW,EAAE,MAAM,UAAU,CAAC;AA0+ChE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAsKpE"}
+{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAsB,WAAW,EAAE,MAAM,UAAU,CAAC;AAshDhE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAsKpE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-electron",
-  "version": "1.1.23",
+  "version": "1.1.24-alpha.1",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
   "license": "MIT",
@@ -25,10 +25,10 @@
     "electron-log": ">=4.0.0"
   },
   "dependencies": {
-    "@onekeyfe/hd-core": "1.1.23",
-    "@onekeyfe/hd-shared": "1.1.23",
-    "@onekeyfe/hd-transport": "1.1.23",
-    "@stoprocent/noble": "2.3.4",
+    "@onekeyfe/hd-core": "1.1.24-alpha.1",
+    "@onekeyfe/hd-shared": "1.1.24-alpha.1",
+    "@onekeyfe/hd-transport": "1.1.24-alpha.1",
+    "@stoprocent/noble": "2.3.16",
     "p-retry": "^4.6.2"
   },
   "devDependencies": {
@@ -36,5 +36,5 @@
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "eb24e6d66c84185b820a82b880c9707f3f548131"
+  "gitHead": "54b5b47750112a573f51ebd264583786d8ee977a"
 }