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

package/src/noble-ble-handler.ts

@@ -9,14 +9,25 @@ import {
   EOneKeyBleMessageKeys,
   ERRORS,
   HardwareErrorCode,
+  ONEKEY_NOTIFY_CHARACTERISTIC_UUID,
   ONEKEY_SERVICE_UUID,
-  isOnekeyDevice,
+  ONEKEY_WRITE_CHARACTERISTIC_UUID,
+  createKnownBleUuidAliases,
+  hasOnekeyCommunicationService,
+  isOnekeyBluetoothDevice,
+  isPro2FindMyAdvertisementName,
+  matchesKnownBleUuid,
   wait,
 } from '@onekeyfe/hd-shared';
 import pRetry from 'p-retry';
 
+import { resolveBlePacketCapacity } from './ble-packet-capacity';
 import { safeLog } from './types/noble-extended';
-import { softRefreshSubscription } from './ble-ops';
+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';
@@ -39,6 +50,7 @@ const bluetoothState: {
 
 // Global persistent state listener for app layer
 let persistentStateListener: ((state: string) => void) | null = null;
+let persistentDiscoverListener: ((peripheral: Peripheral) => void) | null = null;
 
 // Device cache and connection state
 const discoveredDevices = new Map<string, Peripheral>();
@@ -50,6 +62,14 @@ const subscribedDevices = new Map<string, boolean>(); // Track subscription stat
 
 // 🔒 Subscription operation state tracking to prevent race conditions
 const subscriptionOperations = new Map<string, 'subscribing' | 'unsubscribing' | 'idle'>();
+const deviceDisconnectListeners = new Map<
+  string,
+  { peripheral: Peripheral; listener: () => void }
+>();
+const deviceMtuListeners = new Map<
+  string,
+  { peripheral: Peripheral; listener: (mtu: number) => void }
+>();
 
 // Windows-only response watchdog state moved to utils/windows-ble-recovery
 
@@ -59,57 +79,44 @@ const subscriptionOperations = new Map<string, 'subscribing' | 'unsubscribing' |
 
 // Service UUIDs to scan for - using constants from hd-shared
 const ONEKEY_SERVICE_UUIDS = [ONEKEY_SERVICE_UUID];
-const PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS = new Set(['fffd']);
-
-// Pre-normalized characteristic identifiers for fast comparison
-const NORMALIZED_WRITE_UUID = '0002';
-const NORMALIZED_NOTIFY_UUID = '0003';
+const ONEKEY_SERVICE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_SERVICE_UUID);
+const ONEKEY_WRITE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_WRITE_CHARACTERISTIC_UUID);
+const ONEKEY_NOTIFY_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_NOTIFY_CHARACTERISTIC_UUID);
 
 // Timeout and interval constants
 const BLUETOOTH_INIT_TIMEOUT = 10000; // 10 seconds for Bluetooth initialization
-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_SCAN_TIMEOUT = 5000; // 5 seconds for device scanning
 const DEVICE_CHECK_INTERVAL = 500; // 500ms interval for periodic device checks
-const CONNECTION_TIMEOUT = 8000; // 8 seconds for device connection (BLE reconnect after release can be slow)
 const SERVICE_DISCOVERY_TIMEOUT = 10000; // 10 seconds for service discovery
+const BLE_CLEANUP_TIMEOUT = 250;
 
 // Write-related constants
-const BLE_PACKET_SIZE = 192;
-const UNIFIED_WRITE_DELAY = 5;
+const BLE_PACKET_SIZE_FALLBACK = 192;
+const BLE_PACKET_SIZE_MAXIMUM = 244;
 const RETRY_CONFIG = { MAX_ATTEMPTS: 15, WRITE_TIMEOUT: 2000 } as const;
 const IS_WINDOWS = process.platform === 'win32';
 const ABORTABLE_WRITE_ERROR_PATTERNS = [
   /status:\s*3/i, // Windows pairing cancelled / GATT write failed
 ];
 
-function getBleUuidKey(uuid?: string | null) {
-  const normalized = (uuid ?? '').replace(/-/g, '').toLowerCase();
-  return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
-}
-
-const NORMALIZED_ONEKEY_SERVICE_UUIDS = new Set([
-  ...ONEKEY_SERVICE_UUIDS.map(uuid => getBleUuidKey(uuid)),
-  '0001',
-]);
-
-function isGenericBleService(uuid?: string | null) {
-  return ['1800', '1801', '180a', '180f'].includes(getBleUuidKey(uuid));
-}
+function isOneKeyPeripheral(peripheral: Peripheral) {
+  const serviceUuids = peripheral.advertisement?.serviceUuids;
+  const localName = peripheral.advertisement?.localName;
 
-function hasOneKeyAdvertisementService(peripheral: Peripheral) {
-  const serviceUuids = peripheral.advertisement?.serviceUuids ?? [];
-  return serviceUuids.some(uuid => {
-    const uuidKey = getBleUuidKey(uuid);
-    return (
-      NORMALIZED_ONEKEY_SERVICE_UUIDS.has(uuidKey) ||
-      PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(uuidKey)
-    );
-  });
-}
+  // 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;
+  }
 
-function isOneKeyPeripheral(peripheral: Peripheral) {
-  const deviceName = peripheral.advertisement?.localName || null;
-  return isOnekeyDevice(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
+  return (
+    hasOnekeyCommunicationService(serviceUuids) &&
+    isOnekeyBluetoothDevice({
+      id: peripheral.id,
+      localName,
+      serviceUuids,
+    })
+  );
 }
 
 /**
@@ -117,12 +124,6 @@ function isOneKeyPeripheral(peripheral: Peripheral) {
  * renderer-side transport. Packet reassembly is handled by ElectronBleTransport.
  */
 function emitRawNotification(deviceId: string, data: Buffer): void {
-  logger?.info('[NobleBLE] Raw notification', {
-    deviceId,
-    dataLength: data.length,
-    firstBytes: data.subarray(0, 8).toString('hex'),
-  });
-
   const appCb = notificationCallbacks.get(deviceId);
   if (appCb) appCb(data.toString('hex'));
 }
@@ -296,9 +297,12 @@ async function initializeNoble(): Promise<void> {
     });
 
     // Set up device discovery
-    noble.on('discover', (peripheral: Peripheral) => {
-      handleDeviceDiscovered(peripheral);
-    });
+    if (!persistentDiscoverListener) {
+      persistentDiscoverListener = (peripheral: Peripheral) => {
+        handleDeviceDiscovered(peripheral);
+      };
+      noble.on('discover', persistentDiscoverListener);
+    }
 
     logger?.info('[NobleBLE] Noble initialized successfully');
   } catch (error) {
@@ -360,6 +364,16 @@ function cleanupDevice(
 
   // 1. Clean up connection state
   if (cleanupConnection) {
+    const disconnectEntry = deviceDisconnectListeners.get(deviceId);
+    if (disconnectEntry) {
+      disconnectEntry.peripheral.removeListener('disconnect', disconnectEntry.listener);
+      deviceDisconnectListeners.delete(deviceId);
+    }
+    const mtuEntry = deviceMtuListeners.get(deviceId);
+    if (mtuEntry) {
+      mtuEntry.peripheral.removeListener('mtu', mtuEntry.listener);
+      deviceMtuListeners.delete(deviceId);
+    }
     connectedDevices.delete(deviceId);
     deviceCharacteristics.delete(deviceId);
     notificationCallbacks.delete(deviceId);
@@ -409,18 +423,43 @@ function setupDisconnectListener(
   deviceId: string,
   webContents: WebContents
 ): void {
-  // Remove any existing disconnect listeners to avoid duplicates
-  peripheral.removeAllListeners('disconnect');
+  const existing = deviceDisconnectListeners.get(deviceId);
+  if (existing) {
+    existing.peripheral.removeListener('disconnect', existing.listener);
+  }
 
-  // Set up new disconnect listener
-  peripheral.on('disconnect', () => {
+  const listener = () => {
     handleDeviceDisconnect(deviceId, webContents);
-  });
+  };
+  deviceDisconnectListeners.set(deviceId, { peripheral, listener });
+  peripheral.on('disconnect', listener);
+  setupMtuListener(peripheral, deviceId, webContents);
+}
+
+function setupMtuListener(
+  peripheral: Peripheral,
+  deviceId: string,
+  webContents: WebContents
+): void {
+  const existing = deviceMtuListeners.get(deviceId);
+  if (existing) {
+    existing.peripheral.removeListener('mtu', existing.listener);
+  }
+
+  const listener = (mtu: number) => {
+    if (!Number.isFinite(mtu) || mtu <= 0) return;
+    webContents.send(EOneKeyBleMessageKeys.NOBLE_BLE_MTU_CHANGED, {
+      id: deviceId,
+      mtu,
+    });
+  };
+  deviceMtuListeners.set(deviceId, { peripheral, listener });
+  peripheral.on('mtu', listener);
 }
 
 // ===== Write helpers (inline) =====
 
-async function writeCharacteristicWithAck(
+async function writeCharacteristicWithoutResponse(
   deviceId: string,
   writeCharacteristic: Characteristic,
   buffer: Buffer
@@ -468,7 +507,7 @@ async function attemptWindowsWriteUntilPaired(
     }
 
     try {
-      await writeCharacteristicWithAck(deviceId, latestWrite, payload);
+      await writeCharacteristicWithoutResponse(deviceId, latestWrite, payload);
     } catch (e) {
       const errorMessage = e instanceof Error ? e.message : String(e);
       logger?.error('[BLE-Write] Windows write error', {
@@ -551,13 +590,12 @@ async function transmitHexDataToDevice(deviceId: string, hexData: string): Promi
   }
 
   const toBuffer = Buffer.from(hexData, 'hex');
-  logger?.info('[NobleBLE] Writing data:', {
-    deviceId,
-    dataLength: toBuffer.length,
-    firstBytes: toBuffer.subarray(0, 8).toString('hex'),
-  });
-
   const doGetWriteCharacteristic = () => deviceCharacteristics.get(deviceId)?.write;
+  const packetCapacity = resolveBlePacketCapacity(
+    peripheral.mtu,
+    BLE_PACKET_SIZE_MAXIMUM,
+    BLE_PACKET_SIZE_FALLBACK
+  );
 
   if (!IS_WINDOWS || pairedDevices.has(deviceId)) {
     // macOS / Linux or already paired on Windows: direct write
@@ -568,14 +606,13 @@ async function transmitHexDataToDevice(deviceId: string, hexData: string): Promi
         `Write characteristic not available for ${deviceId}`
       );
     }
-    if (toBuffer.length <= BLE_PACKET_SIZE) {
-      await wait(UNIFIED_WRITE_DELAY);
-      await writeCharacteristicWithAck(deviceId, writeCharacteristic, toBuffer);
+    if (toBuffer.length <= packetCapacity) {
+      await writeCharacteristicWithoutResponse(deviceId, writeCharacteristic, toBuffer);
       return;
     }
     // chunked
     for (let offset = 0; offset < toBuffer.length; ) {
-      const chunkSize = Math.min(BLE_PACKET_SIZE, toBuffer.length - offset);
+      const chunkSize = Math.min(packetCapacity, toBuffer.length - offset);
       const chunk = toBuffer.subarray(offset, offset + chunkSize);
       offset += chunkSize;
       const latest = doGetWriteCharacteristic();
@@ -585,23 +622,19 @@ async function transmitHexDataToDevice(deviceId: string, hexData: string): Promi
           `Write characteristic not available for ${deviceId}`
         );
       }
-      await writeCharacteristicWithAck(deviceId, latest, chunk);
-      if (offset < toBuffer.length) {
-        await wait(UNIFIED_WRITE_DELAY);
-      }
+      await writeCharacteristicWithoutResponse(deviceId, latest, chunk);
     }
     return;
   }
 
   // Windows unpaired path: use loop
-  if (toBuffer.length <= BLE_PACKET_SIZE) {
-    await wait(UNIFIED_WRITE_DELAY);
+  if (toBuffer.length <= packetCapacity) {
     await attemptWindowsWriteUntilPaired(deviceId, doGetWriteCharacteristic, toBuffer, 'single');
     return;
   }
   // chunked loop
   for (let offset = 0, idx = 0; offset < toBuffer.length; idx++) {
-    const chunkSize = Math.min(BLE_PACKET_SIZE, toBuffer.length - offset);
+    const chunkSize = Math.min(packetCapacity, toBuffer.length - offset);
     const chunk = toBuffer.subarray(offset, offset + chunkSize);
     offset += chunkSize;
     await attemptWindowsWriteUntilPaired(
@@ -610,17 +643,11 @@ async function transmitHexDataToDevice(deviceId: string, hexData: string): Promi
       chunk,
       `chunk-${idx + 1}`
     );
-    if (offset < toBuffer.length) {
-      await wait(UNIFIED_WRITE_DELAY);
-    }
   }
 }
 
 // Handle discovered device (for general enumeration only)
 function handleDeviceDiscovered(peripheral: Peripheral): void {
-  const deviceName = peripheral.advertisement?.localName || 'Unknown Device';
-  const serviceUuids = peripheral.advertisement?.serviceUuids || [];
-
   // Only process OneKey candidates for general discovery. Avoid logging every
   // ambient BLE peripheral; it makes Pro2 debugging hard to read.
   if (!isOneKeyPeripheral(peripheral)) {
@@ -630,10 +657,10 @@ function handleDeviceDiscovered(peripheral: Peripheral): void {
   const isNewDevice = !discoveredDevices.has(peripheral.id);
   discoveredDevices.set(peripheral.id, peripheral);
   if (isNewDevice) {
-    logger?.info('[NobleBLE] Discovered OneKey BLE device:', {
-      name: deviceName,
-      id: peripheral.id,
-      serviceUUIDs: serviceUuids,
+    logger?.debug('[NobleBLE] OneKey BLE device discovered', {
+      deviceId: peripheral.id,
+      name: peripheral.advertisement?.localName || 'Unknown Device',
+      serviceUUIDs: peripheral.advertisement?.serviceUuids || [],
     });
   }
 }
@@ -643,19 +670,24 @@ function handleDeviceDiscovered(peripheral: Peripheral): void {
 function ensureDiscoverListener(): void {
   if (!noble) return;
 
-  // Check if discover listener exists by checking listener count
-  const listenerCount = (noble as any).listenerCount('discover');
-
-  if (listenerCount === 0) {
+  if (!persistentDiscoverListener) {
     logger?.info('[NobleBLE] Discover listener missing, re-adding it');
-    noble.on('discover', (peripheral: Peripheral) => {
+    persistentDiscoverListener = (peripheral: Peripheral) => {
       handleDeviceDiscovered(peripheral);
-    });
+    };
+    noble.on('discover', persistentDiscoverListener);
   } else {
-    logger?.debug('[NobleBLE] Discover listener already exists, count:', listenerCount);
+    logger?.debug('[NobleBLE] Discover listener already registered');
   }
 }
 
+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> {
@@ -669,28 +701,41 @@ 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) {
+      if (peripheral.id === targetDeviceId && isOneKeyPeripheral(peripheral)) {
         logger?.info('[NobleBLE] Target device found during targeted scan:', {
           id: peripheral.id,
           name: peripheral.advertisement?.localName,
         });
-        clearTimeout(timeoutId);
-        nobleInstance.removeListener('discover', onDiscover);
-        nobleInstance.stopScanning();
-        discoveredDevices.set(peripheral.id, peripheral);
-        resolve(peripheral);
+        finish(peripheral).catch(reject);
       }
     };
 
-    // 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);
-      resolve(null);
-    }, FAST_SCAN_TIMEOUT);
+      finish(null).catch(reject);
+    }, NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS);
 
     // Add local listener for this scan
     nobleInstance.on('discover', onDiscover);
@@ -698,10 +743,7 @@ 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) {
-        clearTimeout(timeoutId);
-        nobleInstance.removeListener('discover', onDiscover);
-        logger?.error('[NobleBLE] Failed to start targeted scan:', error);
-        reject(ERRORS.TypedError(HardwareErrorCode.BleScanError, error.message));
+        finish(null, error).catch(reject);
         return;
       }
       logger?.info('[NobleBLE] Targeted scan started for device:', targetDeviceId);
@@ -735,11 +777,13 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
     const devices: DeviceInfo[] = [];
     let intervalId: ReturnType<typeof setInterval> | undefined;
 
-    // Cleanup function: clears both timeout and interval
-    const cleanup = () => {
+    // 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 () => {
       clearTimeout(timeoutId);
       if (intervalId) clearInterval(intervalId);
-      nobleInstance.stopScanning();
+      await waitForNobleScanStop(nobleInstance);
     };
 
     // Collect discovered devices into the devices array
@@ -759,10 +803,10 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
     };
 
     // Set timeout for scanning — use longer timeout to catch slow-advertising devices like Pro2
-    const timeoutId = setTimeout(() => {
+    const timeoutId = setTimeout(async () => {
       // Final collection before resolving — catches devices discovered near the deadline
       checkDevices();
-      cleanup();
+      await cleanup();
       logger?.info('[NobleBLE] Scan completed, found devices:', devices.length);
       resolve(devices);
     }, DEVICE_SCAN_TIMEOUT);
@@ -770,9 +814,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, (error?: Error) => {
+    nobleInstance.startScanning([], false, async (error?: Error) => {
       if (error) {
-        cleanup();
+        await cleanup();
         logger?.error('[NobleBLE] Failed to start scanning:', error);
         reject(ERRORS.TypedError(HardwareErrorCode.BleScanError, error.message));
         return;
@@ -789,30 +833,21 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
 // Stop scanning
 async function stopScanning(): Promise<void> {
   if (!noble) return;
-
-  return new Promise<void>(resolve => {
-    if (!noble) {
-      resolve();
-      return;
-    }
-
-    noble.stopScanning(() => {
-      logger?.info('[NobleBLE] Scanning stopped');
-      resolve();
-    });
-  });
+  const nobleInstance = noble;
+  await waitForNobleScanStop(nobleInstance);
+  logger?.info('[NobleBLE] Scanning stopped');
 }
 
 // Clean up all Noble listeners (for app exit)
 function cleanupNobleListeners(): void {
   if (!noble) return;
 
-  // Remove all listeners to prevent memory leaks
-  // Noble uses EventEmitter, need to use removeAllListeners
   try {
-    (noble as any).removeAllListeners('discover');
-    (noble as any).removeAllListeners('stateChange');
-    logger?.info('[NobleBLE] All Noble listeners cleaned up');
+    if (persistentDiscoverListener) {
+      noble.removeListener('discover', persistentDiscoverListener);
+      persistentDiscoverListener = null;
+    }
+    logger?.info('[NobleBLE] Owned Noble listeners cleaned up');
   } catch (error) {
     logger?.error('[NobleBLE] Failed to clean up some listeners:', error);
   }
@@ -829,6 +864,7 @@ function getDevice(deviceId: string): DeviceInfo | null {
       id: peripheral.id,
       name: deviceName,
       state: peripheral.state || 'disconnected',
+      ...(typeof peripheral.mtu === 'number' ? { mtu: peripheral.mtu } : {}),
     };
   }
 
@@ -841,6 +877,7 @@ function getDevice(deviceId: string): DeviceInfo | null {
       id: connectedPeripheral.id,
       name: deviceName,
       state: connectedPeripheral.state || 'connected',
+      ...(typeof connectedPeripheral.mtu === 'number' ? { mtu: connectedPeripheral.mtu } : {}),
     };
   }
 
@@ -910,31 +947,25 @@ async function discoverServicesAndCharacteristics(
       });
     });
 
-    // Log all discovered services
-    logger?.info(
-      '[NobleBLE] All services:',
-      services?.map(s => s.uuid)
-    );
-
     if (!services || services.length === 0) {
       throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, 'No services found');
     }
 
+    logger?.debug('[NobleBLE] services discovered', {
+      deviceId: peripheral.id,
+      serviceUUIDs: services.map(service => service.uuid),
+    });
+
     // Find OneKey service — Noble may expose 128-bit UUIDs as short UUID keys.
-    let service = services.find(s => NORMALIZED_ONEKEY_SERVICE_UUIDS.has(getBleUuidKey(s.uuid)));
-    if (!service) {
-      logger?.info('[NobleBLE] Known OneKey service UUID not found, trying first vendor service');
-      service =
-        services.find(s => PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(getBleUuidKey(s.uuid))) ||
-        services.find(s => !isGenericBleService(s.uuid)) ||
-        services[0];
-    }
+    const service = services.find(s => matchesKnownBleUuid(s.uuid, ONEKEY_SERVICE_UUID_ALIASES));
     if (!service) {
       throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
     }
     const selectedService = service;
-    logger?.info('[NobleBLE] Using service:', selectedService.uuid);
-
+    logger?.debug('[NobleBLE] service selected', {
+      deviceId: peripheral.id,
+      serviceUuid: selectedService.uuid,
+    });
     // Step 2: Discover ALL characteristics (no filter)
     const characteristics = await new Promise<Characteristic[]>((resolve, reject) => {
       selectedService.discoverCharacteristics([], (error, chars) => {
@@ -948,30 +979,17 @@ async function discoverServicesAndCharacteristics(
     });
 
     // Step 3: Find required characteristics
-    logger?.info('[NobleBLE] Discovered characteristics:', {
-      count: characteristics?.length || 0,
-      uuids: characteristics?.map(c => c.uuid) || [],
-    });
-
     let writeCharacteristic: Characteristic | null = null;
     let notifyCharacteristic: Characteristic | null = null;
 
     for (const characteristic of characteristics) {
-      const uuid = characteristic.uuid.replace(/-/g, '').toLowerCase();
-      const uuidKey = uuid.length >= 8 ? uuid.substring(4, 8) : uuid;
-
-      if (uuidKey === NORMALIZED_WRITE_UUID) {
+      if (matchesKnownBleUuid(characteristic.uuid, ONEKEY_WRITE_UUID_ALIASES)) {
         writeCharacteristic = characteristic;
-      } else if (uuidKey === NORMALIZED_NOTIFY_UUID) {
+      } else if (matchesKnownBleUuid(characteristic.uuid, ONEKEY_NOTIFY_UUID_ALIASES)) {
         notifyCharacteristic = characteristic;
       }
     }
 
-    logger?.info('[NobleBLE] Characteristic discovery result:', {
-      writeFound: !!writeCharacteristic,
-      notifyFound: !!notifyCharacteristic,
-    });
-
     if (!writeCharacteristic || !notifyCharacteristic) {
       logger?.error(
         '[NobleBLE] Missing characteristics - write:',
@@ -985,6 +1003,13 @@ async function discoverServicesAndCharacteristics(
       );
     }
 
+    logger?.debug('[NobleBLE] characteristics selected', {
+      deviceId: peripheral.id,
+      serviceUuid: selectedService.uuid,
+      writeUuid: writeCharacteristic.uuid,
+      notifyUuid: notifyCharacteristic.uuid,
+    });
+
     return { write: writeCharacteristic, notify: notifyCharacteristic };
   })();
 
@@ -1017,29 +1042,23 @@ async function forceReconnectPeripheral(peripheral: Peripheral, deviceId: string
 
   // Step 2: Force disconnect if connected
   if (peripheral.state === 'connected') {
-    // Remove disconnect listener before intentional disconnect to avoid spurious events
-    peripheral.removeAllListeners('disconnect');
-    await new Promise<void>(resolve => {
-      peripheral.disconnect(() => {
-        logger?.info('[NobleBLE] Force disconnect completed');
-        resolve();
-      });
-    });
+    await runBleCallbackOperation(
+      callback =>
+        peripheral.disconnect(() => {
+          logger?.info('[NobleBLE] Force disconnect completed');
+          callback();
+        }),
+      { timeoutMs: BLE_CLEANUP_TIMEOUT, timeoutBehavior: 'resolve' }
+    );
   }
 
   // Step 3: Re-establish connection
-  await new Promise<void>((resolve, reject) => {
-    peripheral.connect((error: Error | undefined) => {
-      if (error) {
-        logger?.error('[NobleBLE] Force reconnect failed:', error);
-        reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError, error.message));
-      } else {
-        logger?.info('[NobleBLE] Force reconnect successful');
-        connectedDevices.set(deviceId, peripheral);
-        resolve();
-      }
-    });
+  await runBleCallbackOperation(callback => peripheral.connect(callback), {
+    timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+    timeoutBehavior: 'reject',
   });
+  logger?.info('[NobleBLE] Force reconnect successful');
+  connectedDevices.set(deviceId, peripheral);
 
   // Wait for connection to stabilize
   await wait(500);
@@ -1170,16 +1189,26 @@ async function setupConnectionAndDiscoverServices(
   deviceId: string,
   webContents: WebContents
 ): Promise<CharacteristicPair> {
-  // Force reconnect to clear GATT cache
-  await forceReconnectPeripheral(peripheral, deviceId);
   setupDisconnectListener(peripheral, deviceId, webContents);
 
-  // Discover services and characteristics with retry
   try {
     return await discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
-  } catch (error) {
-    // Last resort: fresh scan to get new peripheral object
-    logger?.error('[NobleBLE] Service discovery failed, attempting fresh scan...', error);
+  } catch (initialError) {
+    logger?.info('[NobleBLE] Direct service discovery failed, retrying after reconnect', {
+      deviceId,
+      error: initialError,
+    });
+  }
+
+  await forceReconnectPeripheral(peripheral, deviceId);
+  setupDisconnectListener(peripheral, deviceId, webContents);
+  try {
+    return await discoverServicesAndCharacteristicsWithRetry(peripheral, deviceId);
+  } catch (reconnectError) {
+    logger?.error(
+      '[NobleBLE] Service discovery failed after reconnect, attempting fresh scan...',
+      reconnectError
+    );
     return freshScanAndDiscover(deviceId, webContents);
   }
 }
@@ -1297,15 +1326,30 @@ 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'));
-    }, CONNECTION_TIMEOUT);
+    }, NOBLE_BLE_CONNECTION_TIMEOUT_MS);
 
     // 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));
@@ -1342,20 +1386,21 @@ async function disconnectDevice(deviceId: string): Promise<void> {
     return;
   }
 
-  return new Promise<void>(resolve => {
-    // Remove disconnect listener to avoid triggering handleDeviceDisconnect
-    peripheral.removeAllListeners('disconnect');
-
-    peripheral.disconnect(() => {
-      // Clean up device state using unified function
-      cleanupDevice(deviceId, undefined, {
-        cleanupConnection: true,
-        sendDisconnectEvent: false,
-        cancelOperations: true,
-        reason: 'manual-disconnect',
-      });
-      resolve();
-    });
+  const disconnectEntry = deviceDisconnectListeners.get(deviceId);
+  if (disconnectEntry) {
+    disconnectEntry.peripheral.removeListener('disconnect', disconnectEntry.listener);
+    deviceDisconnectListeners.delete(deviceId);
+  }
+
+  await runBleCallbackOperation(callback => peripheral.disconnect(() => callback()), {
+    timeoutMs: BLE_CLEANUP_TIMEOUT,
+    timeoutBehavior: 'resolve',
+  });
+  cleanupDevice(deviceId, undefined, {
+    cleanupConnection: true,
+    sendDisconnectEvent: false,
+    cancelOperations: true,
+    reason: 'manual-disconnect',
   });
 }
 
@@ -1376,17 +1421,11 @@ async function unsubscribeNotifications(deviceId: string): Promise<void> {
   subscriptionOperations.set(deviceId, 'unsubscribing');
 
   try {
-    await new Promise<void>((resolve, reject) => {
-      notifyCharacteristic.unsubscribe((error: Error | undefined) => {
-        if (error) {
-          logger?.error('[NobleBLE] Notification unsubscription failed:', error);
-          reject(error);
-        } else {
-          logger?.info('[NobleBLE] Notification unsubscription successful');
-          resolve();
-        }
-      });
+    await runBleCallbackOperation(callback => notifyCharacteristic.unsubscribe(callback), {
+      timeoutMs: BLE_CLEANUP_TIMEOUT,
+      timeoutBehavior: 'resolve',
     });
+    logger?.info('[NobleBLE] Notification unsubscription completed');
 
     // Remove all listeners and clear subscription status
     notifyCharacteristic.removeAllListeners('data');
@@ -1479,19 +1518,13 @@ async function subscribeNotifications(
     notifyCharacteristic: Characteristic
   ): Promise<void> {
     // Listeners already cleaned up above, no need to repeat
-    await new Promise<void>(resolve => {
-      notifyCharacteristic.unsubscribe(() => {
-        resolve();
-      });
+    await runBleCallbackOperation(callback => notifyCharacteristic.unsubscribe(callback), {
+      timeoutMs: BLE_CLEANUP_TIMEOUT,
+      timeoutBehavior: 'resolve',
     });
-    await new Promise<void>((resolve, reject) => {
-      notifyCharacteristic.subscribe((error?: Error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve();
-      });
+    await runBleCallbackOperation(callback => notifyCharacteristic.subscribe(callback), {
+      timeoutMs: NOBLE_BLE_CONNECTION_TIMEOUT_MS,
+      timeoutBehavior: 'reject',
     });
 
     notifyCharacteristic.on('data', (data: Buffer) => {
@@ -1516,29 +1549,25 @@ async function subscribeNotifications(
 
 // Setup IPC handlers
 export function setupNobleBleHandlers(webContents: WebContents): void {
-  // Use console.log for initial logging as electron-log might not be available yet.
-  console.log('[NobleBLE] Attempting to set up Noble BLE handlers.');
   try {
-    console.log('[NobleBLE] NOBLE_VERSION_771');
-
     // @ts-ignore – electron-log is only available at runtime
     // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
     logger = require('electron-log') as Logger;
-    console.log('[NobleBLE] electron-log loaded successfully.');
 
     // @ts-ignore – electron is only available at runtime
     // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
     const { ipcMain } = require('electron');
-    console.log('[NobleBLE] electron.ipcMain loaded successfully.');
 
     safeLog(logger, 'info', 'Setting up Noble BLE IPC handlers');
 
     // Handle enumerate request
-    console.log(`[NobleBLE] Registering handler for: ${EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE}`);
     ipcMain.handle(EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, async () => {
       try {
         const devices = await enumerateDevices();
-        safeLog(logger, 'info', 'Enumeration completed, devices:', devices);
+        safeLog(logger, 'debug', 'Enumeration completed', {
+          count: devices.length,
+          devices: devices.map(device => ({ id: device.id, name: device.name })),
+        });
         return devices;
       } catch (error) {
         safeLog(logger, 'error', 'Enumeration failed:', error);
@@ -1583,7 +1612,6 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     ipcMain.handle(
       EOneKeyBleMessageKeys.NOBLE_BLE_WRITE,
       async (_event: IpcMainInvokeEvent, deviceId: string, hexData: string) => {
-        logger?.info('[NobleBLE] IPC WRITE', { deviceId, len: hexData.length });
         await transmitHexDataToDevice(deviceId, hexData);
       }
     );
@@ -1648,32 +1676,24 @@ export function setupNobleBleHandlers(webContents: WebContents): void {
     // Cleanup on app quit
     webContents.on('destroyed', () => {
       safeLog(logger, 'info', 'Cleaning up Noble BLE handlers');
+      (async () => {
+        const deviceIds = Array.from(connectedDevices.keys());
+        for (const deviceId of deviceIds) {
+          await unsubscribeNotifications(deviceId).catch(() => undefined);
+          await disconnectDevice(deviceId).catch(() => undefined);
+        }
 
-      // 1. Clean up all connected devices (unified cleanup, avoid duplicates)
-      const deviceIds = Array.from(connectedDevices.keys());
-      deviceIds.forEach(deviceId => {
-        cleanupDevice(deviceId, undefined, {
-          cleanupConnection: true,
-          sendDisconnectEvent: false,
-          cancelOperations: true,
-          reason: 'app-quit',
-        });
+        await stopScanning().catch(() => undefined);
+        if (noble && persistentStateListener) {
+          noble.removeListener('stateChange', persistentStateListener);
+          persistentStateListener = null;
+        }
+        cleanupNobleListeners();
+        discoveredDevices.clear();
+        safeLog(logger, 'info', 'Noble BLE cleanup completed');
+      })().catch(error => {
+        safeLog(logger, 'error', 'Noble BLE cleanup failed', error);
       });
-
-      // 2. Stop scanning
-      stopScanning();
-
-      // 3. Clean up Noble listeners
-      if (noble && persistentStateListener) {
-        noble.removeListener('stateChange', persistentStateListener);
-        persistentStateListener = null;
-      }
-      cleanupNobleListeners();
-
-      // 4. Clear discovered devices cache
-      discoveredDevices.clear();
-
-      safeLog(logger, 'info', 'Noble BLE cleanup completed');
     });
 
     safeLog(logger, 'info', 'Noble BLE IPC handlers setup completed');