@onekeyfe/hd-transport-electron 1.2.2-alpha.102 → 1.2.2-alpha.104

package/dist/{index-8e6acfc1.js → index-985e2bf3.js}

@@ -55,13 +55,13 @@ function invokeNobleBleIpc(request) {
 
 function initNobleBleSupport(webContents) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-3a1d131d.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-263d4736.js'); });
         setupNobleBleHandlers(webContents);
     });
 }
 function disposeNobleBleSupport(releaseNoble) {
     return __awaiter(this, void 0, void 0, function* () {
-        const handler = yield Promise.resolve().then(function () { return require('./noble-ble-handler-3a1d131d.js'); });
+        const handler = yield Promise.resolve().then(function () { return require('./noble-ble-handler-263d4736.js'); });
         yield handler.disposeNobleBleSupport(releaseNoble);
     });
 }

package/dist/index.d.ts

@@ -18,6 +18,7 @@ interface NobleModule {
     startScanning(serviceUUIDs: string[], allowDuplicates: boolean, callback?: (error?: Error) => void): void;
     stopScanning(callback?: () => void): void;
     stop(): void;
+    cancelConnect?(id: string): void;
     on(event: 'stateChange', listener: (state: string) => void): void;
     on(event: 'discover', listener: (peripheral: Peripheral) => void): void;
     removeListener(event: 'stateChange', listener: (state: string) => void): void;

package/dist/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./index-8e6acfc1.js');
+var index = require('./index-985e2bf3.js');
 
 
 

package/dist/{noble-ble-handler-3a1d131d.js → noble-ble-handler-263d4736.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-8e6acfc1.js');
+var index = require('./index-985e2bf3.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -101,9 +101,21 @@ const NOBLE_BLE_SUBSCRIBE_TIMEOUT_MS = 10000;
 let noble = null;
 let logger = null;
 let disposing = false;
+let nativeReleased = false;
 let disposePromise;
+let windowCleanup;
 let removeIpcHandlers;
 const pendingCancellations = new Set();
+const pendingEnumerations = new Set();
+const nativeConnections = new Set();
+function trackNativeConnection(operation, cancel) {
+    const connection = {
+        cancel,
+        settled: operation.then(() => undefined, () => undefined),
+    };
+    nativeConnections.add(connection);
+    connection.settled = connection.settled.finally(() => nativeConnections.delete(connection));
+}
 function assertBleActive() {
     if (disposing) {
         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, 'Noble BLE is shutting down');
@@ -182,9 +194,24 @@ function connectPeripheralWithCancellation(peripheral, deviceId, messagePrefix =
         (_a = connectingDevices
             .get(deviceId)) === null || _a === void 0 ? void 0 : _a.cancel(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, `Device ${deviceId} connect attempt was superseded`));
         connectingDevices.set(deviceId, pendingConnection);
-        peripheral.connect(error => {
+        let completeNative;
+        trackNativeConnection(new Promise(resolve => {
+            completeNative = resolve;
+        }), () => {
+            var _a;
+            if (typeof peripheral.cancelConnect === 'function')
+                peripheral.cancelConnect();
+            else
+                (_a = noble === null || noble === void 0 ? void 0 : noble.cancelConnect) === null || _a === void 0 ? void 0 : _a.call(noble, deviceId);
+        });
+        const onConnect = (error) => {
+            if (nativeReleased) {
+                completeNative();
+                return;
+            }
             if (error) {
                 settle(() => reject(createNobleBleConnectionError(error, messagePrefix)));
+                completeNative();
                 return;
             }
             if (!settle(() => {
@@ -195,13 +222,27 @@ function connectPeripheralWithCancellation(peripheral, deviceId, messagePrefix =
                 if (!activeConnection || activeConnection.peripheral !== peripheral) {
                     try {
                         peripheral.removeAllListeners('disconnect');
-                        peripheral.disconnect(() => undefined);
+                        runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+                            timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
+                            timeoutBehavior: 'resolve',
+                        })
+                            .catch(() => undefined)
+                            .finally(completeNative);
+                        return;
                     }
                     catch (_a) {
                     }
                 }
             }
-        });
+            completeNative();
+        };
+        try {
+            peripheral.connect(onConnect);
+        }
+        catch (error) {
+            completeNative();
+            settle(() => reject(error));
+        }
     });
 }
 const pairedDevices = new Set();
@@ -833,7 +874,7 @@ function performTargetedScan(targetDeviceId, timeoutMs = NOBLE_BLE_TARGETED_SCAN
         });
     });
 }
-function enumerateDevices() {
+function enumerateDevices(isWindowDestroyed) {
     return index.__awaiter(this, void 0, void 0, function* () {
         if (!noble) {
             yield initializeNoble();
@@ -842,6 +883,8 @@ function enumerateDevices() {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
         }
         assertBleActive();
+        if (isWindowDestroyed())
+            return [];
         const nobleInstance = noble;
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Starting device enumeration');
         discoveredDevices.clear();
@@ -850,14 +893,20 @@ function enumerateDevices() {
             const devices = [];
             let settled = false;
             let intervalId;
-            const cleanup = () => index.__awaiter(this, void 0, void 0, function* () {
-                settled = true;
-                pendingCancellations.delete(cancel);
-                clearTimeout(timeoutId);
-                if (intervalId)
-                    clearInterval(intervalId);
-                yield waitForNobleScanStop(nobleInstance);
-            });
+            let cleanupPromise;
+            const cleanup = () => {
+                if (!cleanupPromise) {
+                    settled = true;
+                    pendingCancellations.delete(cancel);
+                    clearTimeout(timeoutId);
+                    if (intervalId)
+                        clearInterval(intervalId);
+                    cleanupPromise = waitForNobleScanStop(nobleInstance).finally(() => {
+                        pendingEnumerations.delete(cancel);
+                    });
+                }
+                return cleanupPromise;
+            };
             const pushDevice = (peripheral, id) => {
                 var _a;
                 if (devices.some(d => d.id === id))
@@ -881,10 +930,9 @@ function enumerateDevices() {
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scan completed, found devices:', devices.length);
                 resolve(devices);
             }), DEVICE_SCAN_TIMEOUT);
-            const cancel = () => {
-                cleanup().then(() => resolve([]), reject);
-            };
+            const cancel = () => cleanup().then(() => resolve([]), reject);
             pendingCancellations.add(cancel);
+            pendingEnumerations.add(cancel);
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scanning for OneKey BLE devices');
             nobleInstance.startScanning([], true, (error) => index.__awaiter(this, void 0, void 0, function* () {
                 if (settled)
@@ -903,7 +951,7 @@ function enumerateDevices() {
 }
 function stopScanning() {
     return index.__awaiter(this, void 0, void 0, function* () {
-        if (!noble)
+        if (!noble || nativeReleased)
             return;
         const nobleInstance = noble;
         yield waitForNobleScanStop(nobleInstance);
@@ -1168,12 +1216,28 @@ function tryDirectConnectById(deviceId) {
             return undefined;
         let timer;
         let cancel;
+        let abandoned = false;
         try {
             const directPromise = nobleInstance.connectAsync(deviceId);
+            trackNativeConnection(directPromise.then((late) => index.__awaiter(this, void 0, void 0, function* () {
+                if ((!abandoned && !disposing) || nativeReleased)
+                    return;
+                const peripheral = late !== null && late !== void 0 ? late : discoveredDevices.get(deviceId);
+                if ((peripheral === null || peripheral === void 0 ? void 0 : peripheral.state) === 'connected' && !connectedDevices.has(deviceId)) {
+                    peripheral.removeAllListeners('disconnect');
+                    yield runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+                        timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
+                        timeoutBehavior: 'resolve',
+                    });
+                }
+            })), () => { var _a; return (_a = nobleInstance.cancelConnect) === null || _a === void 0 ? void 0 : _a.call(nobleInstance, deviceId); });
             const raced = yield Promise.race([
                 directPromise,
                 new Promise(resolve => {
-                    cancel = () => resolve('timeout');
+                    cancel = () => {
+                        abandoned = true;
+                        resolve('timeout');
+                    };
                     pendingCancellations.add(cancel);
                     timer = setTimeout(cancel, DIRECT_CONNECT_TIMEOUT_MS);
                 }),
@@ -1183,17 +1247,6 @@ function tryDirectConnectById(deviceId) {
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Direct connect-by-id timed out, falling back to scan', {
                     deviceId,
                 });
-                directPromise
-                    .then(late => {
-                    const latePeripheral = late !== null && late !== void 0 ? late : discoveredDevices.get(deviceId);
-                    if (latePeripheral &&
-                        latePeripheral.state === 'connected' &&
-                        !connectedDevices.has(deviceId)) {
-                        latePeripheral.removeAllListeners('disconnect');
-                        latePeripheral.disconnect(() => undefined);
-                    }
-                })
-                    .catch(() => undefined);
                 return undefined;
             }
             const peripheral = raced !== null && raced !== void 0 ? raced : discoveredDevices.get(deviceId);
@@ -1333,6 +1386,8 @@ function connectDevice(deviceId, webContents) {
 function disconnectDevice(deviceId) {
     var _a;
     return index.__awaiter(this, void 0, void 0, function* () {
+        if (nativeReleased)
+            return;
         const pendingConnection = connectingDevices.get(deviceId);
         const peripheral = (_a = connectedDevices.get(deviceId)) !== null && _a !== void 0 ? _a : pendingConnection === null || pendingConnection === void 0 ? void 0 : pendingConnection.peripheral;
         if (!peripheral) {
@@ -1362,6 +1417,8 @@ function disconnectDevice(deviceId) {
 }
 function unsubscribeNotifications(deviceId) {
     return index.__awaiter(this, void 0, void 0, function* () {
+        if (nativeReleased)
+            return;
         const peripheral = connectedDevices.get(deviceId);
         const characteristics = deviceCharacteristics.get(deviceId);
         if (!peripheral || !characteristics) {
@@ -1469,6 +1526,7 @@ function subscribeNotifications(deviceId, callback) {
 function setupNobleBleHandlers(webContents) {
     if (disposing)
         return;
+    let windowDestroyed = false;
     try {
         logger = require('electron-log');
         const { ipcMain } = require('electron');
@@ -1479,7 +1537,12 @@ function setupNobleBleHandlers(webContents) {
             ipcMain.removeHandler(channel);
             ipcMain.handle(channel, (...args) => index.__awaiter(this, void 0, void 0, function* () {
                 try {
+                    if (windowCleanup)
+                        yield windowCleanup;
                     assertBleActive();
+                    if (windowDestroyed) {
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, 'BLE window destroyed');
+                    }
                     return yield Promise.resolve(listener(...args));
                 }
                 catch (error) {
@@ -1490,7 +1553,7 @@ function setupNobleBleHandlers(webContents) {
         safeLog(logger, 'info', 'Setting up Noble BLE IPC handlers');
         handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, () => index.__awaiter(this, void 0, void 0, function* () {
             try {
-                const devices = yield enumerateDevices();
+                const devices = yield enumerateDevices(() => windowDestroyed);
                 safeLog(logger, 'debug', 'Enumeration completed', {
                     count: devices.length,
                     devices: devices.map(device => ({ id: device.id, name: device.name })),
@@ -1582,15 +1645,29 @@ function setupNobleBleHandlers(webContents) {
             }
         }));
         webContents.on('destroyed', () => {
+            windowDestroyed = true;
             if (disposing)
                 return;
             safeLog(logger, 'info', 'Cleaning up Noble BLE handlers');
-            (() => index.__awaiter(this, void 0, void 0, function* () {
+            const previousCleanup = windowCleanup;
+            const enumerations = Array.from(pendingEnumerations, cancel => cancel());
+            windowCleanup = (() => index.__awaiter(this, void 0, void 0, function* () {
+                if (previousCleanup)
+                    yield previousCleanup;
+                yield Promise.allSettled(enumerations);
+                if (disposing)
+                    return;
                 const deviceIds = Array.from(connectedDevices.keys());
                 for (const deviceId of deviceIds) {
+                    if (disposing)
+                        return;
                     yield unsubscribeNotifications(deviceId).catch(() => undefined);
+                    if (disposing)
+                        return;
                     yield disconnectDevice(deviceId).catch(() => undefined);
                 }
+                if (disposing)
+                    return;
                 yield stopScanning().catch(() => undefined);
                 cleanupNobleListeners();
                 discoveredDevices.clear();
@@ -1621,11 +1698,22 @@ function disposeNobleBleSupport(releaseNoble = instance => instance.stop()) {
     for (const pending of connectingDevices.values()) {
         pending.cancel(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleDeviceDisconnected, 'Noble BLE is shutting down'));
     }
+    const connections = Array.from(nativeConnections);
+    for (const connection of connections) {
+        try {
+            connection.cancel();
+        }
+        catch (error) {
+            logger === null || logger === void 0 ? void 0 : logger.warn('[NobleBLE] Native connect cancellation failed', error);
+        }
+    }
     let timeout;
     disposePromise = (() => index.__awaiter(this, void 0, void 0, function* () {
         try {
             yield Promise.race([
                 Promise.allSettled([
+                    windowCleanup,
+                    ...connections.map(connection => connection.settled),
                     stopScanning(),
                     ...pendingPeripherals.map(peripheral => runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
                         timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
@@ -1646,6 +1734,7 @@ function disposeNobleBleSupport(releaseNoble = instance => instance.stop()) {
         }
         finally {
             clearTimeout(timeout);
+            nativeReleased = true;
             cleanupNobleListeners();
             if (instance && persistentStateListener) {
                 instance.removeListener('stateChange', persistentStateListener);

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":"AAkCA,OAAO,KAAK,EAA+B,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAiB1F,KAAK,mBAAmB,GAAG,KAAK,GAAG;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,mBAAmB,EAAE,aAAa,SAAK,+CAiB3F;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAgCvF;AAmJD,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AAsxDD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CA+MpE;AAOD,wBAAgB,sBAAsB,CACpC,YAAY,GAAE,CAAC,QAAQ,EAAE;IAAE,IAAI,IAAI,IAAI,CAAA;CAAE,KAAK,IAAkC,GAC/E,OAAO,CAAC,IAAI,CAAC,CAqDf"}
+{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAkCA,OAAO,KAAK,EAA+B,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAiC1F,KAAK,mBAAmB,GAAG,KAAK,GAAG;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,mBAAmB,EAAE,aAAa,SAAK,+CAiB3F;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAgCvF;AA+KD,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AAkyDD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAkOpE;AAOD,wBAAgB,sBAAsB,CACpC,YAAY,GAAE,CAAC,QAAQ,EAAE;IAAE,IAAI,IAAI,IAAI,CAAA;CAAE,KAAK,IAAkC,GAC/E,OAAO,CAAC,IAAI,CAAC,CAiEf"}

package/dist/types/noble-extended.d.ts

@@ -15,6 +15,7 @@ export interface NobleModule {
     startScanning(serviceUUIDs: string[], allowDuplicates: boolean, callback?: (error?: Error) => void): void;
     stopScanning(callback?: () => void): void;
     stop(): void;
+    cancelConnect?(id: string): void;
     on(event: 'stateChange', listener: (state: string) => void): void;
     on(event: 'discover', listener: (peripheral: Peripheral) => void): void;
     removeListener(event: 'stateChange', listener: (state: string) => void): void;

package/dist/types/noble-extended.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noble-extended.d.ts","sourceRoot":"","sources":["../../src/types/noble-extended.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGnE,MAAM,WAAW,UAAW,SAAQ,oBAAoB;IACtD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAGD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,cAAc,CAAC;CACxB;AAGD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CACX,YAAY,EAAE,MAAM,EAAE,EACtB,eAAe,EAAE,OAAO,EACxB,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,GACjC,IAAI,CAAC;IACR,YAAY,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAC1C,IAAI,IAAI,IAAI,CAAC;IACb,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAClE,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;IACxE,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAC9E,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;CACrF;AAGD,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC7C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;CAC9C;AAGD,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,EACjC,OAAO,EAAE,MAAM,EACf,GAAG,IAAI,EAAE,GAAG,EAAE,GACb,IAAI,CAMN"}
+{"version":3,"file":"noble-extended.d.ts","sourceRoot":"","sources":["../../src/types/noble-extended.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAGnE,MAAM,WAAW,UAAW,SAAQ,oBAAoB;IACtD,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAGD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,cAAc,CAAC;CACxB;AAGD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CACX,YAAY,EAAE,MAAM,EAAE,EACtB,eAAe,EAAE,OAAO,EACxB,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,GACjC,IAAI,CAAC;IACR,YAAY,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IAC1C,IAAI,IAAI,IAAI,CAAC;IACb,aAAa,CAAC,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,EAAE,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAClE,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;IACxE,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IAC9E,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;CACrF;AAGD,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC7C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;CAC9C;AAGD,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,EACjC,OAAO,EAAE,MAAM,EACf,GAAG,IAAI,EAAE,GAAG,EAAE,GACb,IAAI,CAMN"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-electron",
-  "version": "1.2.2-alpha.102",
+  "version": "1.2.2-alpha.104",
   "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.2-alpha.102",
-    "@onekeyfe/hd-shared": "1.2.2-alpha.102",
-    "@onekeyfe/hd-transport": "1.2.2-alpha.102",
+    "@onekeyfe/hd-core": "1.2.2-alpha.104",
+    "@onekeyfe/hd-shared": "1.2.2-alpha.104",
+    "@onekeyfe/hd-transport": "1.2.2-alpha.104",
     "@stoprocent/noble": "2.3.16",
     "p-retry": "^4.6.2"
   },
@@ -36,5 +36,5 @@
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "abddc95e03d794d9c6fce7765d59de1f48a684d0"
+  "gitHead": "67835939d9f779ffd50cd8b482d8c5b53bd580bd"
 }

package/src/__tests__/noble-ble-handler.test.ts

@@ -750,6 +750,10 @@ describe('Electron Noble BLE device discovery', () => {
 });
 
 describe('Noble BLE process shutdown', () => {
+  const flushCallbacks = () =>
+    new Promise<void>(resolve => {
+      setImmediate(resolve);
+    });
   afterEach(() => {
     jest.useRealTimers();
     jest.resetModules();
@@ -825,16 +829,20 @@ describe('Noble BLE process shutdown', () => {
     expect(jest.getTimerCount()).toBe(0);
   });
 
-  test('disconnects an in-flight connection and rejects its late success', async () => {
+  test('cancels native connects and waits for disconnect before release', async () => {
     const { sdk, native, handlers } = await setup();
     await handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK)?.({});
-    let connectCallback: (() => void) | undefined;
+    let connectCallback: ((error?: Error) => void) | undefined;
+    let disconnectCallback: (() => void) | undefined;
     const peripheral = Object.assign(new EventEmitter(), {
       ...createPeripheral('pending-device', 'OneKey Pro'),
       connect: jest.fn(callback => {
         connectCallback = callback;
       }),
-      disconnect: jest.fn(callback => callback?.()),
+      cancelConnect: jest.fn(() => connectCallback?.(new Error('connection canceled'))),
+      disconnect: jest.fn(callback => {
+        disconnectCallback = callback;
+      }),
       discoverServices: jest.fn(),
     });
     native.emit('discover', peripheral);
@@ -842,14 +850,70 @@ describe('Noble BLE process shutdown', () => {
     await Promise.resolve();
     await Promise.resolve();
     expect(peripheral.connect).toHaveBeenCalledTimes(1);
-    await sdk.disposeNobleBleSupport();
+    const disposing = sdk.disposeNobleBleSupport();
+    await flushCallbacks();
+    expect(peripheral.cancelConnect).toHaveBeenCalledTimes(1);
     expect(peripheral.disconnect).toHaveBeenCalled();
+    expect(native.stop).not.toHaveBeenCalled();
+    disconnectCallback?.();
+    await disposing;
     expect(native.stop).toHaveBeenCalledTimes(1);
-    connectCallback?.();
     expect(await connecting).toMatchObject({ success: false });
     expect(peripheral.discoverServices).not.toHaveBeenCalled();
   });
 
+  test.each(['peripheral', 'direct'])(
+    'keeps late %s connects inert after the disposal timeout',
+    async route => {
+      jest.useFakeTimers({ doNotFake: ['performance', 'setImmediate'] });
+      const { sdk, native, handlers } = await setup();
+      await handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK)?.({});
+      let finishConnect: () => void = () => undefined;
+      const peripheral = Object.assign(new EventEmitter(), {
+        ...createPeripheral('late-device', 'OneKey Pro'),
+        connect: jest.fn(callback => {
+          finishConnect = () => callback();
+        }),
+        cancelConnect: jest.fn(),
+        disconnect: jest.fn(callback => callback?.()),
+        discoverServices: jest.fn(),
+      });
+      const connectAsync = jest.fn(
+        () =>
+          new Promise(resolve => {
+            finishConnect = () => resolve(peripheral);
+          })
+      );
+      const cancelConnect = jest.fn();
+      if (route === 'direct') Object.assign(native, { connectAsync, cancelConnect });
+      else native.emit('discover', peripheral);
+      const connecting = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT)?.({}, peripheral.id);
+      await flushCallbacks();
+      if (route === 'direct') {
+        jest.advanceTimersByTime(1500);
+        await flushCallbacks();
+      }
+      expect(route === 'direct' ? connectAsync : peripheral.connect).toHaveBeenCalledTimes(1);
+      const disposing = sdk.disposeNobleBleSupport();
+      await flushCallbacks();
+      expect(route === 'direct' ? cancelConnect : peripheral.cancelConnect).toHaveBeenCalledTimes(
+        1
+      );
+      expect(native.stop).not.toHaveBeenCalled();
+      jest.advanceTimersByTime(3500);
+      await disposing;
+      const disconnects = peripheral.disconnect.mock.calls.length;
+      peripheral.state = 'connected';
+      finishConnect();
+      await flushCallbacks();
+      expect(peripheral.disconnect).toHaveBeenCalledTimes(disconnects);
+      expect(peripheral.discoverServices).not.toHaveBeenCalled();
+      expect(native.stop).toHaveBeenCalledTimes(1);
+      expect(await connecting).toMatchObject({ success: false });
+      expect(jest.getTimerCount()).toBe(0);
+    }
+  );
+
   test('allows a host to defer shared native release until both transports are idle', async () => {
     const { sdk, native, handlers } = await setup();
     await handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK)?.({});
@@ -859,16 +923,96 @@ describe('Noble BLE process shutdown', () => {
     expect(native.stop).not.toHaveBeenCalled();
   });
 
-  test('window destruction preserves the native manager for a soft restart', async () => {
+  test('replacement window scanning waits for old cleanup and preserves native', async () => {
+    jest.useFakeTimers({ doNotFake: ['performance', 'setImmediate'] });
     const { sdk, native, handlers, window } = await setup();
     await handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK)?.({});
+    let finishOldCleanup: (() => void) | undefined;
+    native.stopScanning.mockImplementationOnce(callback => {
+      finishOldCleanup = callback;
+    });
     window.emit('destroyed');
-    await Promise.resolve();
-    await Promise.resolve();
     sdk.setupNobleBleHandlers(new EventEmitter() as unknown as WebContents);
-    await handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK)?.({});
+    const scan = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE)?.({});
+    await flushCallbacks();
+    expect(native.startScanning).not.toHaveBeenCalled();
+    finishOldCleanup?.();
+    await flushCallbacks();
+    expect(native.startScanning).toHaveBeenCalledTimes(1);
+    expect(native.listenerCount('discover')).toBe(1);
+    native.emit('discover', createPeripheral('replacement-device', 'OneKey Pro'));
+    jest.advanceTimersByTime(5000);
+    expect(await scan).toEqual([expect.objectContaining({ id: 'replacement-device' })]);
     expect(native.stop).not.toHaveBeenCalled();
     await sdk.disposeNobleBleSupport();
     expect(native.stop).toHaveBeenCalledTimes(1);
   });
+
+  test.each(['started', 'late-start-callback'])(
+    'retires an old enumeration before a shared native scan resumes: %s',
+    async scanState => {
+      jest.useFakeTimers({ doNotFake: ['performance', 'setImmediate'] });
+      const { sdk, native, handlers, window } = await setup();
+      let lateStart: (() => void) | undefined;
+      if (scanState === 'late-start-callback') {
+        native.startScanning.mockImplementationOnce((_uuids, _duplicates, callback) => {
+          lateStart = callback;
+        });
+      }
+      let oldScanSettled = false;
+      const oldScan = Promise.resolve(
+        handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE)?.({})
+      ).then(result => {
+        oldScanSettled = true;
+        return result;
+      });
+      await flushCallbacks();
+      jest.advanceTimersByTime(1000);
+
+      let finishOldScan: (() => void) | undefined;
+      native.stopScanning.mockImplementationOnce(callback => {
+        finishOldScan = callback;
+      });
+      window.emit('destroyed');
+      sdk.setupNobleBleHandlers(new EventEmitter() as unknown as WebContents);
+      const replacementReady = handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK)?.({});
+      let replacementSettled = false;
+      Promise.resolve(replacementReady).then(() => {
+        replacementSettled = true;
+      });
+      await flushCallbacks();
+      expect(replacementSettled).toBe(false);
+      finishOldScan?.();
+      await replacementReady;
+      await flushCallbacks();
+      expect(oldScanSettled).toBe(true);
+      expect(await oldScan).toEqual([]);
+
+      // Another transport can now scan on the same process-wide Noble instance.
+      native.startScanning([], true, () => undefined);
+      const stopCount = native.stopScanning.mock.calls.length;
+      lateStart?.();
+      jest.advanceTimersByTime(5000);
+      await flushCallbacks();
+      expect(native.stopScanning).toHaveBeenCalledTimes(stopCount);
+      expect(jest.getTimerCount()).toBe(0);
+      expect(native.stop).not.toHaveBeenCalled();
+      await sdk.disposeNobleBleSupport();
+    }
+  );
+
+  test('does not start an old window enumeration after Bluetooth becomes ready', async () => {
+    const { sdk, native, handlers, window } = await setup('unknown');
+    const oldScan = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE)?.({});
+    await flushCallbacks();
+    window.emit('destroyed');
+    sdk.setupNobleBleHandlers(new EventEmitter() as unknown as WebContents);
+    await handlers.get(EOneKeyBleMessageKeys.BLE_AVAILABILITY_CHECK)?.({});
+
+    native.state = 'poweredOn';
+    native.emit('stateChange', 'poweredOn');
+    expect(await oldScan).toEqual([]);
+    expect(native.startScanning).not.toHaveBeenCalled();
+    await sdk.disposeNobleBleSupport();
+  });
 });

package/src/noble-ble-handler.ts

@@ -41,9 +41,25 @@ import type { CharacteristicPair, DeviceInfo, Logger, NobleModule } from './type
 let noble: NobleModule | null = null;
 let logger: Logger | null = null;
 let disposing = false;
+let nativeReleased = false;
 let disposePromise: Promise<void> | undefined;
+let windowCleanup: Promise<void> | undefined;
 let removeIpcHandlers: (() => void) | undefined;
 const pendingCancellations = new Set<() => void>();
+const pendingEnumerations = new Set<() => Promise<void>>();
+const nativeConnections = new Set<{ cancel: () => void; settled: Promise<void> }>();
+
+function trackNativeConnection(operation: Promise<unknown>, cancel: () => void): void {
+  const connection = {
+    cancel,
+    settled: operation.then(
+      () => undefined,
+      () => undefined
+    ),
+  };
+  nativeConnections.add(connection);
+  connection.settled = connection.settled.finally(() => nativeConnections.delete(connection));
+}
 
 function assertBleActive(): void {
   if (disposing) {
@@ -170,9 +186,24 @@ function connectPeripheralWithCancellation(
       );
     connectingDevices.set(deviceId, pendingConnection);
 
-    peripheral.connect(error => {
+    let completeNative!: () => void;
+    trackNativeConnection(
+      new Promise<void>(resolve => {
+        completeNative = resolve;
+      }),
+      () => {
+        if (typeof peripheral.cancelConnect === 'function') peripheral.cancelConnect();
+        else noble?.cancelConnect?.(deviceId);
+      }
+    );
+    const onConnect = (error?: Error | null) => {
+      if (nativeReleased) {
+        completeNative();
+        return;
+      }
       if (error) {
         settle(() => reject(createNobleBleConnectionError(error, messagePrefix)));
+        completeNative();
         return;
       }
 
@@ -186,13 +217,26 @@ function connectPeripheralWithCancellation(
         if (!activeConnection || activeConnection.peripheral !== peripheral) {
           try {
             peripheral.removeAllListeners('disconnect');
-            peripheral.disconnect(() => undefined);
+            runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+              timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
+              timeoutBehavior: 'resolve',
+            })
+              .catch(() => undefined)
+              .finally(completeNative);
+            return;
           } catch {
             // Best-effort cleanup for a stale native callback.
           }
         }
       }
-    });
+      completeNative();
+    };
+    try {
+      peripheral.connect(onConnect);
+    } catch (error) {
+      completeNative();
+      settle(() => reject(error));
+    }
   });
 }
 const pairedDevices = new Set<string>(); // Windows BLE device pairing status tracking
@@ -1107,7 +1151,7 @@ async function performTargetedScan(
 }
 
 // Enumerate devices
-async function enumerateDevices(): Promise<DeviceInfo[]> {
+async function enumerateDevices(isWindowDestroyed: () => boolean): Promise<DeviceInfo[]> {
   if (!noble) {
     await initializeNoble();
   }
@@ -1117,6 +1161,7 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
   }
 
   assertBleActive();
+  if (isWindowDestroyed()) return [];
   // Capture noble reference for use in closures (TypeScript narrowing)
   const nobleInstance = noble;
 
@@ -1133,16 +1178,22 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
     const devices: DeviceInfo[] = [];
     let settled = false;
     let intervalId: ReturnType<typeof setInterval> | undefined;
+    let cleanupPromise: Promise<void> | undefined;
 
     // Cleanup function: clears timers and waits until Noble confirms scanning
     // has stopped. Resolving enumerate before this callback creates a race with
     // an immediately-following connection attempt.
-    const cleanup = async () => {
-      settled = true;
-      pendingCancellations.delete(cancel);
-      clearTimeout(timeoutId);
-      if (intervalId) clearInterval(intervalId);
-      await waitForNobleScanStop(nobleInstance);
+    const cleanup = () => {
+      if (!cleanupPromise) {
+        settled = true;
+        pendingCancellations.delete(cancel);
+        clearTimeout(timeoutId);
+        if (intervalId) clearInterval(intervalId);
+        cleanupPromise = waitForNobleScanStop(nobleInstance).finally(() => {
+          pendingEnumerations.delete(cancel);
+        });
+      }
+      return cleanupPromise;
     };
 
     // Collect discovered devices into the devices array
@@ -1171,10 +1222,9 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
       resolve(devices);
     }, DEVICE_SCAN_TIMEOUT);
 
-    const cancel = () => {
-      cleanup().then(() => resolve([]), reject);
-    };
+    const cancel = () => cleanup().then(() => resolve([]), reject);
     pendingCancellations.add(cancel);
+    pendingEnumerations.add(cancel);
 
     // Start scanning without a service UUID filter so Pro2 advertisements with
     // short vendor UUIDs can be found. Repeated advertisements are required when
@@ -1199,7 +1249,7 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
 
 // Stop scanning
 async function stopScanning(): Promise<void> {
-  if (!noble) return;
+  if (!noble || nativeReleased) return;
   const nobleInstance = noble;
   await waitForNobleScanStop(nobleInstance);
   logger?.info('[NobleBLE] Scanning stopped');
@@ -1651,13 +1701,31 @@ async function tryDirectConnectById(deviceId: string): Promise<Peripheral | unde
 
   let timer: ReturnType<typeof setTimeout> | undefined;
   let cancel: (() => void) | undefined;
+  let abandoned = false;
   try {
     // The late-orphan guard must attach to THIS pending connect.
     const directPromise = nobleInstance.connectAsync(deviceId);
+    trackNativeConnection(
+      directPromise.then(async late => {
+        if ((!abandoned && !disposing) || nativeReleased) return;
+        const peripheral = late ?? discoveredDevices.get(deviceId);
+        if (peripheral?.state === 'connected' && !connectedDevices.has(deviceId)) {
+          peripheral.removeAllListeners('disconnect');
+          await runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+            timeoutMs: BLE_DISCONNECT_CONFIRM_TIMEOUT_MS,
+            timeoutBehavior: 'resolve',
+          });
+        }
+      }),
+      () => nobleInstance.cancelConnect?.(deviceId)
+    );
     const raced = await Promise.race([
       directPromise,
       new Promise<'timeout'>(resolve => {
-        cancel = () => resolve('timeout');
+        cancel = () => {
+          abandoned = true;
+          resolve('timeout');
+        };
         pendingCancellations.add(cancel);
         timer = setTimeout(cancel, DIRECT_CONNECT_TIMEOUT_MS);
       }),
@@ -1667,20 +1735,6 @@ async function tryDirectConnectById(deviceId: string): Promise<Peripheral | unde
       logger?.info('[NobleBLE] Direct connect-by-id timed out, falling back to scan', {
         deviceId,
       });
-      // Promise.race times out the caller only; a late success orphans the link.
-      directPromise
-        .then(late => {
-          const latePeripheral = late ?? discoveredDevices.get(deviceId);
-          if (
-            latePeripheral &&
-            latePeripheral.state === 'connected' &&
-            !connectedDevices.has(deviceId)
-          ) {
-            latePeripheral.removeAllListeners('disconnect');
-            latePeripheral.disconnect(() => undefined);
-          }
-        })
-        .catch(() => undefined);
       return undefined;
     }
     // Backends emit `discover` as a side effect, so the cache may hold it.
@@ -1877,6 +1931,7 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
 
 // Disconnect device
 async function disconnectDevice(deviceId: string): Promise<void> {
+  if (nativeReleased) return;
   const pendingConnection = connectingDevices.get(deviceId);
   const peripheral = connectedDevices.get(deviceId) ?? pendingConnection?.peripheral;
   if (!peripheral) {
@@ -1917,6 +1972,7 @@ async function disconnectDevice(deviceId: string): Promise<void> {
 
 // Unsubscribe from notifications
 async function unsubscribeNotifications(deviceId: string): Promise<void> {
+  if (nativeReleased) return;
   const peripheral = connectedDevices.get(deviceId);
   const characteristics = deviceCharacteristics.get(deviceId);
 
@@ -2074,6 +2130,7 @@ async function subscribeNotifications(
 // Setup IPC handlers
 export function setupNobleBleHandlers(webContents: WebContents): void {
   if (disposing) return;
+  let windowDestroyed = false;
   try {
     // @ts-ignore – electron-log is only available at runtime
     // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
@@ -2092,7 +2149,15 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
       ipcMain.removeHandler(channel);
       ipcMain.handle(channel, async (...args) => {
         try {
+          // A replacement renderer must not race the old renderer's shared-state cleanup.
+          if (windowCleanup) await windowCleanup;
           assertBleActive();
+          if (windowDestroyed) {
+            throw ERRORS.TypedError(
+              HardwareErrorCode.BleDeviceDisconnected,
+              'BLE window destroyed'
+            );
+          }
           return await Promise.resolve(listener(...args));
         } catch (error) {
           return createNobleBleIpcErrorResponse(error);
@@ -2105,7 +2170,7 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     // Handle enumerate request
     handle(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, async () => {
       try {
-        const devices = await enumerateDevices();
+        const devices = await enumerateDevices(() => windowDestroyed);
         safeLog(logger, 'debug', 'Enumeration completed', {
           count: devices.length,
           devices: devices.map(device => ({ id: device.id, name: device.name })),
@@ -2250,15 +2315,25 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
 
     // Window cleanup also runs during renderer soft restart; native release belongs to app quit.
     webContents.on('destroyed', () => {
+      windowDestroyed = true;
       if (disposing) return;
       safeLog(logger, 'info', 'Cleaning up Noble BLE handlers');
-      (async () => {
+      const previousCleanup = windowCleanup;
+      // Cancel before yielding so old timers cannot stop a replacement renderer's scan.
+      const enumerations = Array.from(pendingEnumerations, cancel => cancel());
+      windowCleanup = (async () => {
+        if (previousCleanup) await previousCleanup;
+        await Promise.allSettled(enumerations);
+        if (disposing) return;
         const deviceIds = Array.from(connectedDevices.keys());
         for (const deviceId of deviceIds) {
+          if (disposing) return;
           await unsubscribeNotifications(deviceId).catch(() => undefined);
+          if (disposing) return;
           await disconnectDevice(deviceId).catch(() => undefined);
         }
 
+        if (disposing) return;
         await stopScanning().catch(() => undefined);
         // persistentStateListener is process-lifetime, NOT per-window: this
         // destroy handler also fires on a renderer soft restart, and removing
@@ -2302,11 +2377,21 @@ export function disposeNobleBleSupport(
       ERRORS.TypedError(HardwareErrorCode.BleDeviceDisconnected, 'Noble BLE is shutting down')
     );
   }
+  const connections = Array.from(nativeConnections);
+  for (const connection of connections) {
+    try {
+      connection.cancel();
+    } catch (error) {
+      logger?.warn('[NobleBLE] Native connect cancellation failed', error);
+    }
+  }
   let timeout: ReturnType<typeof setTimeout> | undefined;
   disposePromise = (async () => {
     try {
       await Promise.race([
         Promise.allSettled([
+          windowCleanup,
+          ...connections.map(connection => connection.settled),
           stopScanning(),
           ...pendingPeripherals.map(peripheral =>
             runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
@@ -2328,6 +2413,8 @@ export function disposeNobleBleSupport(
       ]);
     } finally {
       clearTimeout(timeout);
+      // Bounded cleanup may finish before a broken native callback; it must stay inert afterwards.
+      nativeReleased = true;
       cleanupNobleListeners();
       if (instance && persistentStateListener) {
         instance.removeListener('stateChange', persistentStateListener);

package/src/types/noble-extended.ts

@@ -30,6 +30,7 @@ export interface NobleModule {
   ): void;
   stopScanning(callback?: () => void): void;
   stop(): void;
+  cancelConnect?(id: string): void;
   on(event: 'stateChange', listener: (state: string) => void): void;
   on(event: 'discover', listener: (peripheral: Peripheral) => void): void;
   removeListener(event: 'stateChange', listener: (state: string) => void): void;