@onekeyfe/hd-transport-electron 1.2.0-alpha.163 → 1.2.0-alpha.165

package/dist/{index-b18020df.js → index-5478256a.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-8b4037fe.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-255383f1.js'); });
         setupNobleBleHandlers(webContents);
     });
 }

package/dist/index.js

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

package/dist/{noble-ble-handler-8b4037fe.js → noble-ble-handler-255383f1.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-b18020df.js');
+var index = require('./index-5478256a.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -599,18 +599,36 @@ function transmitHexDataToDevice(deviceId, hexData, options) {
         }
     });
 }
+const BLE_COLD_CONNECT_SCAN_TIMEOUT_MS = 1500;
+const bleNamesById = new Map();
+function rememberBleName(deviceId, name) {
+    const trimmed = name === null || name === void 0 ? void 0 : name.trim();
+    if (trimmed) {
+        bleNamesById.set(deviceId, trimmed);
+    }
+}
+function resolveBleName(deviceId) {
+    var _a, _b, _c, _d, _e, _f;
+    const live = ((_c = (_b = (_a = connectedDevices.get(deviceId)) === null || _a === void 0 ? void 0 : _a.advertisement) === null || _b === void 0 ? void 0 : _b.localName) === null || _c === void 0 ? void 0 : _c.trim()) ||
+        ((_f = (_e = (_d = discoveredDevices.get(deviceId)) === null || _d === void 0 ? void 0 : _d.advertisement) === null || _e === void 0 ? void 0 : _e.localName) === null || _f === void 0 ? void 0 : _f.trim());
+    return live || bleNamesById.get(deviceId);
+}
+function shouldConnectByIdFirst(deviceId) {
+    return hdShared.isPro2FamilyBleName(resolveBleName(deviceId));
+}
 function handleDeviceDiscovered(peripheral) {
-    var _a, _b;
+    var _a, _b, _c;
     if (!isOneKeyPeripheral(peripheral)) {
         return;
     }
     const isNewDevice = !discoveredDevices.has(peripheral.id);
     discoveredDevices.set(peripheral.id, peripheral);
+    rememberBleName(peripheral.id, (_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName);
     if (isNewDevice) {
         logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] OneKey BLE device discovered', {
             deviceId: peripheral.id,
-            name: ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device',
-            serviceUUIDs: ((_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.serviceUuids) || [],
+            name: ((_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.localName) || 'Unknown Device',
+            serviceUUIDs: ((_c = peripheral.advertisement) === null || _c === void 0 ? void 0 : _c.serviceUuids) || [],
         });
     }
 }
@@ -636,7 +654,7 @@ function waitForNobleScanStop(nobleInstance) {
         });
     });
 }
-function performTargetedScan(targetDeviceId) {
+function performTargetedScan(targetDeviceId, timeoutMs = NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS) {
     return index.__awaiter(this, void 0, void 0, function* () {
         if (!noble) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
@@ -676,7 +694,7 @@ function performTargetedScan(targetDeviceId) {
             const timeoutId = setTimeout(() => {
                 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);
+            }, timeoutMs);
             nobleInstance.on('discover', onDiscover);
             nobleInstance.startScanning([], true, (error) => {
                 if (error) {
@@ -1046,7 +1064,7 @@ function tryDirectConnectById(deviceId) {
     });
 }
 function connectDevice(deviceId, webContents) {
-    var _a, _b;
+    var _a, _b, _c;
     return index.__awaiter(this, void 0, void 0, function* () {
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connect device request:', {
             deviceId,
@@ -1064,27 +1082,41 @@ function connectDevice(deviceId, webContents) {
             if (!noble) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Noble not available');
             }
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device not cached, scanning for:', deviceId);
-            try {
-                peripheral = (_b = (yield performTargetedScan(deviceId))) !== null && _b !== void 0 ? _b : undefined;
-            }
-            catch (scanError) {
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan failed, falling back to direct connect', {
-                    deviceId,
-                    error: scanError instanceof Error ? scanError.message : String(scanError),
-                });
-            }
-            if (!peripheral) {
-                logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device not advertising, attempting direct connect by id:', deviceId);
-                peripheral = yield tryDirectConnectById(deviceId);
-                if (peripheral) {
-                    discoveredDevices.set(deviceId, peripheral);
+            const byIdFirst = shouldConnectByIdFirst(deviceId);
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Resolving device for cold connect', {
+                deviceId,
+                name: (_b = resolveBleName(deviceId)) !== null && _b !== void 0 ? _b : 'unknown',
+                strategy: byIdFirst ? 'connect-by-id-first' : 'scan-first',
+            });
+            const scanForPeripheral = () => index.__awaiter(this, void 0, void 0, function* () {
+                var _d;
+                try {
+                    return (_d = (yield performTargetedScan(deviceId, BLE_COLD_CONNECT_SCAN_TIMEOUT_MS))) !== null && _d !== void 0 ? _d : undefined;
                 }
+                catch (scanError) {
+                    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Targeted scan failed', {
+                        deviceId,
+                        error: scanError instanceof Error ? scanError.message : String(scanError),
+                    });
+                    return undefined;
+                }
+            });
+            const connectById = () => index.__awaiter(this, void 0, void 0, function* () {
+                const found = yield tryDirectConnectById(deviceId);
+                if (found) {
+                    discoveredDevices.set(deviceId, found);
+                }
+                return found;
+            });
+            peripheral = byIdFirst ? yield connectById() : yield scanForPeripheral();
+            if (!peripheral) {
+                peripheral = byIdFirst ? yield scanForPeripheral() : yield connectById();
             }
         }
         if (!peripheral) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found`);
         }
+        rememberBleName(deviceId, (_c = peripheral.advertisement) === null || _c === void 0 ? void 0 : _c.localName);
         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Connecting to device:', deviceId);
         if (peripheral.state === 'connected') {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device already connected, skipping connection step');

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":"AA+BA,OAAO,KAAK,EAA+B,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAoFhE,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AAwoDD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAkMpE"}
+{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAA+B,WAAW,EAAE,MAAM,UAAU,CAAC;AAEzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAoFhE,wBAAgB,+BAA+B,CAAC,OAAO,CAAC,EAAE,oBAAoB,UAI7E;AAksDD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAkMpE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-electron",
-  "version": "1.2.0-alpha.163",
+  "version": "1.2.0-alpha.165",
   "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.163",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.163",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.163",
+    "@onekeyfe/hd-core": "1.2.0-alpha.165",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.165",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.165",
     "@stoprocent/noble": "2.3.16",
     "p-retry": "^4.6.2"
   },
@@ -36,5 +36,5 @@
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "afed1c82345fc277cadf49677ab8371e6c6f3f9a"
+  "gitHead": "dc82ee336f9dc638352195bebd22ee606fa3ef5c"
 }

package/src/noble-ble-handler.ts

@@ -16,6 +16,7 @@ import {
   createKnownBleUuidAliases,
   hasOnekeyCommunicationService,
   isOnekeyBluetoothDevice,
+  isPro2FamilyBleName,
   matchesKnownBleUuid,
   wait,
 } from '@onekeyfe/hd-shared';
@@ -790,6 +791,41 @@ async function transmitHexDataToDevice(
 }
 
 // Handle discovered device (for general enumeration only)
+// A scan that finds nothing costs this much before the direct-connect
+// fallback runs. Every advertisement in the 6.5.0 control logs arrived within
+// 631ms, so this leaves ~2x headroom while keeping a miss cheap.
+const BLE_COLD_CONNECT_SCAN_TIMEOUT_MS = 1500;
+
+// Advertised names, kept for the life of the process: device caches are purged
+// on every disconnect, but the family a device belongs to never changes and
+// decides which connection strategy is safe for it.
+const bleNamesById = new Map<string, string>();
+
+function rememberBleName(deviceId: string, name?: string | null): void {
+  const trimmed = name?.trim();
+  if (trimmed) {
+    bleNamesById.set(deviceId, trimmed);
+  }
+}
+
+function resolveBleName(deviceId: string): string | undefined {
+  const live =
+    connectedDevices.get(deviceId)?.advertisement?.localName?.trim() ||
+    discoveredDevices.get(deviceId)?.advertisement?.localName?.trim();
+  return live || bleNamesById.get(deviceId);
+}
+
+/**
+ * Pro2/Neo connect by id first: they are unaffected by the stale-session
+ * problem and advertise under Find My names a OneKey-filtered scan cannot
+ * match. Everything else — Classic family, and any device whose name is not
+ * known yet — scans first, because connecting by id can resolve a session the
+ * device no longer serves (see setupConnectionAndDiscoverServices).
+ */
+function shouldConnectByIdFirst(deviceId: string): boolean {
+  return isPro2FamilyBleName(resolveBleName(deviceId));
+}
+
 function handleDeviceDiscovered(peripheral: Peripheral): void {
   // Only process OneKey candidates for general discovery. Avoid logging every
   // ambient BLE peripheral; it makes Pro2 debugging hard to read.
@@ -799,6 +835,7 @@ function handleDeviceDiscovered(peripheral: Peripheral): void {
 
   const isNewDevice = !discoveredDevices.has(peripheral.id);
   discoveredDevices.set(peripheral.id, peripheral);
+  rememberBleName(peripheral.id, peripheral.advertisement?.localName);
   if (isNewDevice) {
     logger?.debug('[NobleBLE] OneKey BLE device discovered', {
       deviceId: peripheral.id,
@@ -833,7 +870,10 @@ async function waitForNobleScanStop(nobleInstance: NobleModule): Promise<void> {
 
 // 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> {
+async function performTargetedScan(
+  targetDeviceId: string,
+  timeoutMs: number = NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS
+): Promise<Peripheral | null> {
   if (!noble) {
     throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Noble not available');
   }
@@ -878,7 +918,7 @@ async function performTargetedScan(targetDeviceId: string): Promise<Peripheral |
     const timeoutId = setTimeout(() => {
       logger?.info('[NobleBLE] Targeted scan timeout for device:', targetDeviceId);
       finish(null).catch(reject);
-    }, NOBLE_BLE_TARGETED_SCAN_TIMEOUT_MS);
+    }, timeoutMs);
 
     // Add local listener for this scan
     nobleInstance.on('discover', onDiscover);
@@ -1454,31 +1494,46 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
       throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Noble not available');
     }
 
-    // Scan before connecting by id. A live advertisement proves the device
-    // holds no link and will open a fresh session, and it is how 6.5.0 reached
-    // every cold connect (control logs: found in ~52ms, 16/16 sessions
-    // answered within ~1s). Connecting by id resolves through the OS cache
-    // instead: on a Classic 1S that can hand back a session the device no
-    // longer serves, where the link comes up and GATT resolves from cache but
-    // the device answers no protocol traffic at all.
-    logger?.info('[NobleBLE] Device not cached, scanning for:', deviceId);
-    try {
-      peripheral = (await performTargetedScan(deviceId)) ?? undefined;
-    } catch (scanError) {
-      logger?.info('[NobleBLE] Targeted scan failed, falling back to direct connect', {
-        deviceId,
-        error: scanError instanceof Error ? scanError.message : String(scanError),
-      });
-    }
+    // A live advertisement proves the device holds no link and will open a
+    // fresh session; connecting by id resolves through the OS cache instead
+    // and can hand back a session the device no longer serves (see
+    // setupConnectionAndDiscoverServices). Scanning is also the faster of the
+    // two when the device does advertise: ~96ms median against ~784ms for
+    // connect-by-id across the field logs. Pro2/Neo keep connect-by-id first
+    // because they are unaffected and may advertise under an unmatchable Find
+    // My name.
+    const byIdFirst = shouldConnectByIdFirst(deviceId);
+    logger?.info('[NobleBLE] Resolving device for cold connect', {
+      deviceId,
+      name: resolveBleName(deviceId) ?? 'unknown',
+      strategy: byIdFirst ? 'connect-by-id-first' : 'scan-first',
+    });
 
-    if (!peripheral) {
-      // Not advertising: held by another host, or bonded and silent. Connect
-      // by id is then the only way in.
-      logger?.info('[NobleBLE] Device not advertising, attempting direct connect by id:', deviceId);
-      peripheral = await tryDirectConnectById(deviceId);
-      if (peripheral) {
-        discoveredDevices.set(deviceId, peripheral);
+    const scanForPeripheral = async () => {
+      try {
+        return (await performTargetedScan(deviceId, BLE_COLD_CONNECT_SCAN_TIMEOUT_MS)) ?? undefined;
+      } catch (scanError) {
+        logger?.info('[NobleBLE] Targeted scan failed', {
+          deviceId,
+          error: scanError instanceof Error ? scanError.message : String(scanError),
+        });
+        return undefined;
       }
+    };
+
+    const connectById = async () => {
+      const found = await tryDirectConnectById(deviceId);
+      if (found) {
+        discoveredDevices.set(deviceId, found);
+      }
+      return found;
+    };
+
+    peripheral = byIdFirst ? await connectById() : await scanForPeripheral();
+    if (!peripheral) {
+      // The preferred route came up empty: not advertising (held elsewhere, or
+      // silent), or not reachable by id. Try the other one before giving up.
+      peripheral = byIdFirst ? await scanForPeripheral() : await connectById();
     }
   }
 
@@ -1487,6 +1542,10 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
     throw ERRORS.TypedError(HardwareErrorCode.DeviceNotFound, `Device ${deviceId} not found`);
   }
 
+  // Also covers the connect-by-id route, whose simulated discovery carries no
+  // service UUIDs and therefore never reaches handleDeviceDiscovered.
+  rememberBleName(deviceId, peripheral.advertisement?.localName);
+
   logger?.info('[NobleBLE] Connecting to device:', deviceId);
 
   // Check if device is already connected