@onekeyfe/hd-transport-electron 1.2.0-alpha.66 → 1.2.0-alpha.67

package/dist/{index-84fea839.js → index-5f728113.js}

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

package/dist/index.js

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

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

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-84fea839.js');
+var index = require('./index-5f728113.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -78,9 +78,6 @@ 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 = {
@@ -103,8 +100,10 @@ const ONEKEY_SERVICE_UUID_ALIASES = hdShared.createKnownBleUuidAliases(hdShared.
 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 = 5000;
+const DEVICE_SCAN_TIMEOUT = 8000;
+const FAST_SCAN_TIMEOUT = 8000;
 const DEVICE_CHECK_INTERVAL = 500;
+const CONNECTION_TIMEOUT = 8000;
 const SERVICE_DISCOVERY_TIMEOUT = 10000;
 const BLE_CLEANUP_TIMEOUT = 250;
 const BLE_PACKET_SIZE = 192;
@@ -117,14 +116,10 @@ const ABORTABLE_WRITE_ERROR_PATTERNS = [
 function isOneKeyPeripheral(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,
+            localName: (_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.localName,
             serviceUuids,
         }));
 }
@@ -514,14 +509,6 @@ function ensureDiscoverListener() {
         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) {
@@ -530,25 +517,6 @@ 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 && isOneKeyPeripheral(peripheral)) {
@@ -556,17 +524,26 @@ function performTargetedScan(targetDeviceId) {
                         id: peripheral.id,
                         name: (_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName,
                     });
-                    finish(peripheral).catch(reject);
+                    clearTimeout(timeoutId);
+                    nobleInstance.removeListener('discover', onDiscover);
+                    nobleInstance.stopScanning();
+                    discoveredDevices.set(peripheral.id, peripheral);
+                    resolve(peripheral);
                 }
             };
             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);
-                finish(null).catch(reject);
-            }, NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS);
+                resolve(null);
+            }, FAST_SCAN_TIMEOUT);
             nobleInstance.on('discover', onDiscover);
             nobleInstance.startScanning([], false, (error) => {
                 if (error) {
-                    finish(null, error).catch(reject);
+                    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);
@@ -589,12 +566,12 @@ function enumerateDevices() {
         return new Promise((resolve, reject) => {
             const devices = [];
             let intervalId;
-            const cleanup = () => index.__awaiter(this, void 0, void 0, function* () {
+            const cleanup = () => {
                 clearTimeout(timeoutId);
                 if (intervalId)
                     clearInterval(intervalId);
-                yield waitForNobleScanStop(nobleInstance);
-            });
+                nobleInstance.stopScanning();
+            };
             const checkDevices = () => {
                 discoveredDevices.forEach((peripheral, id) => {
                     var _a;
@@ -610,23 +587,23 @@ function enumerateDevices() {
                     }
                 });
             };
-            const timeoutId = setTimeout(() => index.__awaiter(this, void 0, void 0, function* () {
+            const timeoutId = setTimeout(() => {
                 checkDevices();
-                yield cleanup();
+                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) => index.__awaiter(this, void 0, void 0, function* () {
+            nobleInstance.startScanning([], false, (error) => {
                 if (error) {
-                    yield cleanup();
+                    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);
-            }));
+            });
         });
     });
 }
@@ -635,7 +612,10 @@ function stopScanning() {
         if (!noble)
             return;
         const nobleInstance = noble;
-        yield waitForNobleScanStop(nobleInstance);
+        yield runBleCallbackOperation(callback => nobleInstance.stopScanning(() => callback()), {
+            timeoutMs: BLE_CLEANUP_TIMEOUT,
+            timeoutBehavior: 'resolve',
+        });
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scanning stopped');
     });
 }
@@ -790,7 +770,7 @@ function forceReconnectPeripheral(peripheral, deviceId) {
             }), { timeoutMs: BLE_CLEANUP_TIMEOUT, timeoutBehavior: 'resolve' });
         }
         yield runBleCallbackOperation(callback => peripheral.connect(callback), {
-            timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+            timeoutMs: CONNECTION_TIMEOUT,
             timeoutBehavior: 'reject',
         });
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Force reconnect successful');
@@ -960,24 +940,12 @@ 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'));
-            }, NOBLE_BLE_CONNECTION_TIMEOUT_MS);
+            }, CONNECTION_TIMEOUT);
             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));
@@ -1096,7 +1064,7 @@ function subscribeNotifications(deviceId, callback) {
                     timeoutBehavior: 'resolve',
                 });
                 yield runBleCallbackOperation(callback => notifyCharacteristic.subscribe(callback), {
-                    timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+                    timeoutMs: CONNECTION_TIMEOUT,
                     timeoutBehavior: 'reject',
                 });
                 notifyCharacteristic.on('data', (data) => {

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

package/package.json

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

package/src/noble-ble-handler.ts

@@ -15,7 +15,6 @@ import {
   createKnownBleUuidAliases,
   hasOnekeyCommunicationService,
   isOnekeyBluetoothDevice,
-  isPro2FindMyAdvertisementName,
   matchesKnownBleUuid,
   wait,
 } from '@onekeyfe/hd-shared';
@@ -23,10 +22,6 @@ import pRetry from 'p-retry';
 
 import { safeLog } from './types/noble-extended';
 import { runBleCallbackOperation, softRefreshSubscription } from './ble-ops';
-import {
-  NOBLE_BLE_CONNECTION_TIMEOUT_MS,
-  NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS,
-} from './noble-ble-timeouts';
 
 import type { IpcMainInvokeEvent, WebContents } from 'electron';
 import type { Characteristic, Peripheral, Service } from '@stoprocent/noble';
@@ -80,8 +75,10 @@ const ONEKEY_NOTIFY_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_NOTIFY_CHARA
 
 // Timeout and interval constants
 const BLUETOOTH_INIT_TIMEOUT = 10000; // 10 seconds for Bluetooth initialization
-const DEVICE_SCAN_TIMEOUT = 5000; // 5 seconds for device scanning
+const DEVICE_SCAN_TIMEOUT = 8000; // 8 seconds for device scanning (Pro2 has longer advertising interval)
+const FAST_SCAN_TIMEOUT = 8000; // 8 seconds for targeted scanning (Pro2 has longer advertising interval)
 const DEVICE_CHECK_INTERVAL = 500; // 500ms interval for periodic device checks
+const CONNECTION_TIMEOUT = 8000; // 8 seconds for device connection (BLE reconnect after release can be slow)
 const SERVICE_DISCOVERY_TIMEOUT = 10000; // 10 seconds for service discovery
 const BLE_CLEANUP_TIMEOUT = 250;
 
@@ -96,19 +93,11 @@ const ABORTABLE_WRITE_ERROR_PATTERNS = [
 
 function isOneKeyPeripheral(peripheral: Peripheral) {
   const serviceUuids = peripheral.advertisement?.serviceUuids;
-  const localName = peripheral.advertisement?.localName;
-
-  // Noble localName is the current advertisement name, so reject the Pro2
-  // Find My endpoint before the communication-service fast path accepts it.
-  if (!localName?.trim() || isPro2FindMyAdvertisementName(localName)) {
-    return false;
-  }
-
   return (
     hasOnekeyCommunicationService(serviceUuids) &&
     isOnekeyBluetoothDevice({
       id: peripheral.id,
-      localName,
+      localName: peripheral.advertisement?.localName,
       serviceUuids,
     })
   );
@@ -652,13 +641,6 @@ function ensureDiscoverListener(): void {
   }
 }
 
-async function waitForNobleScanStop(nobleInstance: NobleModule): Promise<void> {
-  await runBleCallbackOperation(callback => nobleInstance.stopScanning(() => callback()), {
-    timeoutMs: BLE_CLEANUP_TIMEOUT,
-    timeoutBehavior: 'resolve',
-  });
-}
-
 // Perform targeted scan for a specific device ID
 // Uses self-contained local listener pattern - no global state needed
 async function performTargetedScan(targetDeviceId: string): Promise<Peripheral | null> {
@@ -672,26 +654,6 @@ async function performTargetedScan(targetDeviceId: string): Promise<Peripheral |
   logger?.info('[NobleBLE] Starting targeted scan for device:', targetDeviceId);
 
   return new Promise((resolve, reject) => {
-    let settled = false;
-
-    const finish = async (peripheral: Peripheral | null, error?: Error) => {
-      if (settled) return;
-      settled = true;
-      if (timeoutId) clearTimeout(timeoutId);
-      nobleInstance.removeListener('discover', onDiscover);
-      await waitForNobleScanStop(nobleInstance);
-
-      if (error) {
-        logger?.error('[NobleBLE] Failed to start targeted scan:', error);
-        reject(ERRORS.TypedError(HardwareErrorCode.BleScanError, error.message));
-        return;
-      }
-      if (peripheral) {
-        discoveredDevices.set(peripheral.id, peripheral);
-      }
-      resolve(peripheral);
-    };
-
     // Local discover listener - only matches target device
     const onDiscover = (peripheral: Peripheral) => {
       if (peripheral.id === targetDeviceId && isOneKeyPeripheral(peripheral)) {
@@ -699,14 +661,21 @@ async function performTargetedScan(targetDeviceId: string): Promise<Peripheral |
           id: peripheral.id,
           name: peripheral.advertisement?.localName,
         });
-        finish(peripheral).catch(reject);
+        clearTimeout(timeoutId);
+        nobleInstance.removeListener('discover', onDiscover);
+        nobleInstance.stopScanning();
+        discoveredDevices.set(peripheral.id, peripheral);
+        resolve(peripheral);
       }
     };
 
+    // Timeout handler - must be after onDiscover so it can reference it
     const timeoutId = setTimeout(() => {
+      nobleInstance.removeListener('discover', onDiscover);
+      nobleInstance.stopScanning();
       logger?.info('[NobleBLE] Targeted scan timeout for device:', targetDeviceId);
-      finish(null).catch(reject);
-    }, NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS);
+      resolve(null);
+    }, FAST_SCAN_TIMEOUT);
 
     // Add local listener for this scan
     nobleInstance.on('discover', onDiscover);
@@ -714,7 +683,10 @@ async function performTargetedScan(targetDeviceId: string): Promise<Peripheral |
     // Start scanning — no service UUID filter (Pro2 may use different service UUID)
     nobleInstance.startScanning([], false, (error?: Error) => {
       if (error) {
-        finish(null, error).catch(reject);
+        clearTimeout(timeoutId);
+        nobleInstance.removeListener('discover', onDiscover);
+        logger?.error('[NobleBLE] Failed to start targeted scan:', error);
+        reject(ERRORS.TypedError(HardwareErrorCode.BleScanError, error.message));
         return;
       }
       logger?.info('[NobleBLE] Targeted scan started for device:', targetDeviceId);
@@ -748,13 +720,11 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
     const devices: DeviceInfo[] = [];
     let intervalId: ReturnType<typeof setInterval> | 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 () => {
+    // Cleanup function: clears both timeout and interval
+    const cleanup = () => {
       clearTimeout(timeoutId);
       if (intervalId) clearInterval(intervalId);
-      await waitForNobleScanStop(nobleInstance);
+      nobleInstance.stopScanning();
     };
 
     // Collect discovered devices into the devices array
@@ -774,10 +744,10 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
     };
 
     // Set timeout for scanning — use longer timeout to catch slow-advertising devices like Pro2
-    const timeoutId = setTimeout(async () => {
+    const timeoutId = setTimeout(() => {
       // Final collection before resolving — catches devices discovered near the deadline
       checkDevices();
-      await cleanup();
+      cleanup();
       logger?.info('[NobleBLE] Scan completed, found devices:', devices.length);
       resolve(devices);
     }, DEVICE_SCAN_TIMEOUT);
@@ -785,9 +755,9 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
     // Start scanning without a service UUID filter so Pro2 advertisements with
     // short vendor UUIDs can be found, but only OneKey candidates are logged/returned.
     logger?.info('[NobleBLE] Scanning for OneKey BLE devices');
-    nobleInstance.startScanning([], false, async (error?: Error) => {
+    nobleInstance.startScanning([], false, (error?: Error) => {
       if (error) {
-        await cleanup();
+        cleanup();
         logger?.error('[NobleBLE] Failed to start scanning:', error);
         reject(ERRORS.TypedError(HardwareErrorCode.BleScanError, error.message));
         return;
@@ -805,7 +775,10 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
 async function stopScanning(): Promise<void> {
   if (!noble) return;
   const nobleInstance = noble;
-  await waitForNobleScanStop(nobleInstance);
+  await runBleCallbackOperation(callback => nobleInstance.stopScanning(() => callback()), {
+    timeoutMs: BLE_CLEANUP_TIMEOUT,
+    timeoutBehavior: 'resolve',
+  });
   logger?.info('[NobleBLE] Scanning stopped');
 }
 
@@ -1023,7 +996,7 @@ async function forceReconnectPeripheral(peripheral: Peripheral, deviceId: string
 
   // Step 3: Re-establish connection
   await runBleCallbackOperation(callback => peripheral.connect(callback), {
-    timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+    timeoutMs: CONNECTION_TIMEOUT,
     timeoutBehavior: 'reject',
   });
   logger?.info('[NobleBLE] Force reconnect successful');
@@ -1295,30 +1268,15 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
   }
 
   return new Promise((resolve, reject) => {
-    let connectionTimedOut = false;
     const timeout = setTimeout(() => {
-      connectionTimedOut = true;
       reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError, 'Connection timeout'));
-    }, NOBLE_BLE_CONNECTION_TIMEOUT_MS);
+    }, CONNECTION_TIMEOUT);
 
     // TypeScript type assertion - peripheral is guaranteed to be defined at this point
     const connectedPeripheral = peripheral as Peripheral;
     connectedPeripheral.connect(async (error: Error | undefined) => {
       clearTimeout(timeout);
 
-      // Noble may invoke the callback after the SDK timed out and released the request.
-      // Ignore it to avoid initializing disposed commands or leaving an orphaned connection.
-      if (connectionTimedOut) {
-        if (!error) {
-          try {
-            connectedPeripheral.disconnect(() => undefined);
-          } catch {
-            // Best-effort cleanup only.
-          }
-        }
-        return;
-      }
-
       if (error) {
         logger?.error('[NobleBLE] Connection failed:', error);
         reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError, error.message));
@@ -1492,7 +1450,7 @@ async function subscribeNotifications(
       timeoutBehavior: 'resolve',
     });
     await runBleCallbackOperation(callback => notifyCharacteristic.subscribe(callback), {
-      timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+      timeoutMs: CONNECTION_TIMEOUT,
       timeoutBehavior: 'reject',
     });
 

package/dist/noble-ble-timeouts.d.ts

@@ -1,3 +0,0 @@
-export declare const NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS = 5000;
-export declare const NOBLE_BLE_CONNECTION_TIMEOUT_MS = 10000;
-//# sourceMappingURL=noble-ble-timeouts.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"noble-ble-timeouts.d.ts","sourceRoot":"","sources":["../src/noble-ble-timeouts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kCAAkC,OAAQ,CAAC;AACxD,eAAO,MAAM,+BAA+B,QAAS,CAAC"}

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

@@ -1,354 +0,0 @@
-import { EventEmitter } from 'events';
-import { EOneKeyBleMessageKeys } from '@onekeyfe/hd-shared';
-
-import {
-  NOBLE_BLE_CONNECTION_TIMEOUT_MS,
-  NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS,
-} from '../noble-ble-timeouts';
-
-import type { WebContents } from 'electron';
-
-type IpcHandler = (...args: unknown[]) => Promise<unknown> | unknown;
-
-const createPeripheral = (id: string, localName?: string) => ({
-  id,
-  state: 'disconnected',
-  advertisement: {
-    localName,
-    serviceUuids: ['0001', 'fffd'],
-  },
-});
-
-describe('Electron Noble BLE device discovery', () => {
-  afterEach(() => {
-    jest.useRealTimers();
-    jest.resetModules();
-    jest.clearAllMocks();
-  });
-
-  test('allows enough time for a slow targeted scan and connection', () => {
-    expect(NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS).toBe(5_000);
-    expect(NOBLE_BLE_CONNECTION_TIMEOUT_MS).toBe(10_000);
-  });
-
-  test('waits for Noble to stop scanning before enumeration resolves', async () => {
-    jest.useFakeTimers({ doNotFake: ['performance'] });
-
-    const handlers = new Map<string, IpcHandler>();
-    const ipcMain = {
-      handle: jest.fn((channel: string, handler: IpcHandler) => {
-        handlers.set(channel, handler);
-      }),
-    };
-    const noble = new EventEmitter() as EventEmitter & {
-      state: string;
-      startScanning: jest.Mock;
-      stopScanning: jest.Mock;
-    };
-    let resolveScanStarted = () => undefined;
-    const scanStarted = new Promise<void>(resolve => {
-      resolveScanStarted = resolve;
-    });
-    let stopScanningCallback: (() => void) | undefined;
-    noble.state = 'poweredOn';
-    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
-      callback?.();
-      noble.emit('discover', createPeripheral('onekey-device', 'Pro2 A1B2'));
-      resolveScanStarted();
-    });
-    noble.stopScanning = jest.fn(callback => {
-      stopScanningCallback = callback;
-    });
-
-    jest.doMock('@stoprocent/noble', () => noble);
-    jest.doMock('electron', () => ({ ipcMain }));
-    jest.doMock('electron-log', () => ({
-      info: jest.fn(),
-      debug: jest.fn(),
-      error: jest.fn(),
-    }));
-
-    const { setupNobleBleHandlers } = await import('../noble-ble-handler');
-    setupNobleBleHandlers({
-      on: jest.fn(),
-      send: jest.fn(),
-    } as unknown as WebContents);
-
-    const enumerate = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE);
-    if (!enumerate) {
-      throw new Error('Electron Noble BLE enumerate handler was not registered');
-    }
-
-    let enumerationResolved = false;
-    const devicesPromise = Promise.resolve(enumerate()).then(devices => {
-      enumerationResolved = true;
-      return devices;
-    });
-    await scanStarted;
-    jest.advanceTimersByTime(5_000);
-    await Promise.resolve();
-
-    expect(noble.stopScanning).toHaveBeenCalledTimes(1);
-    expect(enumerationResolved).toBe(false);
-
-    stopScanningCallback?.();
-    await expect(devicesPromise).resolves.toEqual([
-      expect.objectContaining({ id: 'onekey-device' }),
-    ]);
-  });
-
-  test('waits for a targeted scan to stop before connecting', async () => {
-    jest.useFakeTimers({ doNotFake: ['performance'] });
-
-    const handlers = new Map<string, IpcHandler>();
-    const ipcMain = {
-      handle: jest.fn((channel: string, handler: IpcHandler) => {
-        handlers.set(channel, handler);
-      }),
-    };
-    const noble = new EventEmitter() as EventEmitter & {
-      state: string;
-      startScanning: jest.Mock;
-      stopScanning: jest.Mock;
-    };
-    let resolveScanStarted = () => undefined;
-    const scanStarted = new Promise<void>(resolve => {
-      resolveScanStarted = resolve;
-    });
-    let stopScanningCallback: (() => void) | undefined;
-    const peripheral = Object.assign(
-      new EventEmitter(),
-      createPeripheral('target-device', 'Pro2 A1B2'),
-      {
-        connect: jest.fn((callback: (error?: Error) => void) => {
-          callback(new Error('expected test connection failure'));
-        }),
-      }
-    );
-    noble.state = 'poweredOn';
-    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
-      callback?.();
-      noble.emit('discover', peripheral);
-      resolveScanStarted();
-    });
-    noble.stopScanning = jest.fn(callback => {
-      stopScanningCallback = callback;
-    });
-
-    jest.doMock('@stoprocent/noble', () => noble);
-    jest.doMock('electron', () => ({ ipcMain }));
-    jest.doMock('electron-log', () => ({
-      info: jest.fn(),
-      debug: jest.fn(),
-      error: jest.fn(),
-    }));
-
-    const { setupNobleBleHandlers } = await import('../noble-ble-handler');
-    setupNobleBleHandlers({
-      on: jest.fn(),
-      send: jest.fn(),
-    } as unknown as WebContents);
-
-    const connect = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT);
-    if (!connect) {
-      throw new Error('Electron Noble BLE connect handler was not registered');
-    }
-
-    const connectPromise = Promise.resolve(connect(undefined, 'target-device'));
-    await scanStarted;
-
-    expect(noble.stopScanning).toHaveBeenCalledTimes(1);
-    expect(peripheral.connect).not.toHaveBeenCalled();
-
-    stopScanningCallback?.();
-    await expect(connectPromise).rejects.toThrow('expected test connection failure');
-    expect(peripheral.connect).toHaveBeenCalledTimes(1);
-  });
-
-  test('disconnects a connection callback that arrives after timeout', async () => {
-    jest.useFakeTimers({ doNotFake: ['performance'] });
-
-    const handlers = new Map<string, IpcHandler>();
-    const ipcMain = {
-      handle: jest.fn((channel: string, handler: IpcHandler) => {
-        handlers.set(channel, handler);
-      }),
-    };
-    const noble = new EventEmitter() as EventEmitter & {
-      state: string;
-      startScanning: jest.Mock;
-      stopScanning: jest.Mock;
-    };
-    let connectCallback: ((error?: Error) => void) | undefined;
-    let resolveConnectStarted = () => undefined;
-    const connectStarted = new Promise<void>(resolve => {
-      resolveConnectStarted = resolve;
-    });
-    const peripheral = Object.assign(
-      new EventEmitter(),
-      createPeripheral('slow-device', 'Pro2 A1B2'),
-      {
-        connect: jest.fn((callback: (error?: Error) => void) => {
-          connectCallback = callback;
-          resolveConnectStarted();
-        }),
-        disconnect: jest.fn((callback: () => void) => callback()),
-      }
-    );
-    noble.state = 'poweredOn';
-    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
-      callback?.();
-      noble.emit('discover', peripheral);
-    });
-    noble.stopScanning = jest.fn(callback => callback?.());
-
-    jest.doMock('@stoprocent/noble', () => noble);
-    jest.doMock('electron', () => ({ ipcMain }));
-    jest.doMock('electron-log', () => ({
-      info: jest.fn(),
-      debug: jest.fn(),
-      error: jest.fn(),
-    }));
-
-    const { setupNobleBleHandlers } = await import('../noble-ble-handler');
-    setupNobleBleHandlers({
-      on: jest.fn(),
-      send: jest.fn(),
-    } as unknown as WebContents);
-
-    const connect = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_CONNECT);
-    if (!connect) {
-      throw new Error('Electron Noble BLE connect handler was not registered');
-    }
-
-    const connectPromise = Promise.resolve(connect(undefined, 'slow-device'));
-    await connectStarted;
-    expect(peripheral.connect).toHaveBeenCalledTimes(1);
-
-    jest.advanceTimersByTime(NOBLE_BLE_CONNECTION_TIMEOUT_MS);
-    await expect(connectPromise).rejects.toThrow('Connection timeout');
-
-    connectCallback?.();
-    await Promise.resolve();
-    expect(peripheral.disconnect).toHaveBeenCalledTimes(1);
-  });
-
-  test('does not enumerate a Pro2 Find My advertisement with the communication service', async () => {
-    jest.useFakeTimers({ doNotFake: ['performance'] });
-
-    const handlers = new Map<string, IpcHandler>();
-    const ipcMain = {
-      handle: jest.fn((channel: string, handler: IpcHandler) => {
-        handlers.set(channel, handler);
-      }),
-    };
-    const noble = new EventEmitter() as EventEmitter & {
-      state: string;
-      startScanning: jest.Mock;
-      stopScanning: jest.Mock;
-    };
-    let resolveScanStarted = () => undefined;
-    const scanStarted = new Promise<void>(resolve => {
-      resolveScanStarted = resolve;
-    });
-    noble.state = 'poweredOn';
-    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
-      callback?.();
-      noble.emit('discover', createPeripheral('find-my-device', 'Pro2 A1B2 - Find My'));
-      noble.emit('discover', createPeripheral('onekey-device', 'Pro2 A1B2'));
-      resolveScanStarted();
-    });
-    noble.stopScanning = jest.fn(callback => callback?.());
-
-    jest.doMock('@stoprocent/noble', () => noble);
-    jest.doMock('electron', () => ({ ipcMain }));
-    jest.doMock('electron-log', () => ({
-      info: jest.fn(),
-      debug: jest.fn(),
-      error: jest.fn(),
-    }));
-
-    const { setupNobleBleHandlers } = await import('../noble-ble-handler');
-    setupNobleBleHandlers({
-      on: jest.fn(),
-      send: jest.fn(),
-    } as unknown as WebContents);
-
-    const enumerate = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE);
-    if (!enumerate) {
-      throw new Error('Electron Noble BLE enumerate handler was not registered');
-    }
-
-    const devicesPromise = Promise.resolve(enumerate());
-    await scanStarted;
-    jest.advanceTimersByTime(5000);
-
-    await expect(devicesPromise).resolves.toEqual([
-      expect.objectContaining({
-        id: 'onekey-device',
-        name: 'Pro2 A1B2',
-      }),
-    ]);
-  });
-
-  test('does not enumerate a Find My peripheral first discovered without a name', async () => {
-    jest.useFakeTimers({ doNotFake: ['performance'] });
-
-    const handlers = new Map<string, IpcHandler>();
-    const ipcMain = {
-      handle: jest.fn((channel: string, handler: IpcHandler) => {
-        handlers.set(channel, handler);
-      }),
-    };
-    const noble = new EventEmitter() as EventEmitter & {
-      state: string;
-      startScanning: jest.Mock;
-      stopScanning: jest.Mock;
-    };
-    let resolveScanStarted = () => undefined;
-    const scanStarted = new Promise<void>(resolve => {
-      resolveScanStarted = resolve;
-    });
-    const findMyPeripheral = createPeripheral('find-my-device');
-    noble.state = 'poweredOn';
-    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
-      callback?.();
-      noble.emit('discover', findMyPeripheral);
-      findMyPeripheral.advertisement.localName = 'Pro2 A1B2 - Find My';
-      noble.emit('discover', findMyPeripheral);
-      noble.emit('discover', createPeripheral('onekey-device', 'Pro2 A1B2'));
-      resolveScanStarted();
-    });
-    noble.stopScanning = jest.fn(callback => callback?.());
-
-    jest.doMock('@stoprocent/noble', () => noble);
-    jest.doMock('electron', () => ({ ipcMain }));
-    jest.doMock('electron-log', () => ({
-      info: jest.fn(),
-      debug: jest.fn(),
-      error: jest.fn(),
-    }));
-
-    const { setupNobleBleHandlers } = await import('../noble-ble-handler');
-    setupNobleBleHandlers({
-      on: jest.fn(),
-      send: jest.fn(),
-    } as unknown as WebContents);
-
-    const enumerate = handlers.get(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE);
-    if (!enumerate) {
-      throw new Error('Electron Noble BLE enumerate handler was not registered');
-    }
-
-    const devicesPromise = Promise.resolve(enumerate());
-    await scanStarted;
-    jest.advanceTimersByTime(5000);
-
-    await expect(devicesPromise).resolves.toEqual([
-      expect.objectContaining({
-        id: 'onekey-device',
-        name: 'Pro2 A1B2',
-      }),
-    ]);
-  });
-});

package/src/noble-ble-timeouts.ts

@@ -1,2 +0,0 @@
-export const NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS = 5_000;
-export const NOBLE_BLE_CONNECTION_TIMEOUT_MS = 10_000;