@onekeyfe/hd-transport-electron 1.2.0-alpha.2 → 1.2.0-alpha.20

package/dist/{index-02fc07fe.js → index-55699e30.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-94c42077.js'); });
+        const { setupNobleBleHandlers } = yield Promise.resolve().then(function () { return require('./noble-ble-handler-16791965.js'); });
         setupNobleBleHandlers(webContents);
     });
 }

package/dist/index.d.ts

@@ -26,6 +26,10 @@ interface Logger {
     error(message: string, ...args: any[]): void;
 }
 
+/**
+ * Desktop API types for Electron preload script
+ * These types define the core interface for Noble BLE communication
+ */
 interface NobleBleAPI {
     enumerate: () => Promise<{
         id: string;

package/dist/index.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./index-02fc07fe.js');
+var index = require('./index-55699e30.js');
 
 
 

package/dist/{noble-ble-handler-94c42077.js → noble-ble-handler-16791965.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-02fc07fe.js');
+var index = require('./index-55699e30.js');
 var hdShared = require('@onekeyfe/hd-shared');
 var pRetry = require('p-retry');
 
@@ -109,11 +109,6 @@ function isOneKeyPeripheral(peripheral) {
     return hdShared.isOnekeyDevice(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
 }
 function emitRawNotification(deviceId, data) {
-    logger === null || logger === void 0 ? void 0 : 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'));
@@ -415,11 +410,6 @@ function transmitHexDataToDevice(deviceId, hexData) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, `Device ${deviceId} not connected or characteristics not available`);
         }
         const toBuffer = Buffer.from(hexData, 'hex');
-        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Writing data:', {
-            deviceId,
-            dataLength: toBuffer.length,
-            firstBytes: toBuffer.subarray(0, 8).toString('hex'),
-        });
         const doGetWriteCharacteristic = () => { var _a; return (_a = deviceCharacteristics.get(deviceId)) === null || _a === void 0 ? void 0 : _a.write; };
         if (!IS_WINDOWS || pairedDevices.has(deviceId)) {
             const writeCharacteristic = doGetWriteCharacteristic();
@@ -464,18 +454,16 @@ function transmitHexDataToDevice(deviceId, hexData) {
 }
 function handleDeviceDiscovered(peripheral) {
     var _a, _b;
-    const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
-    const serviceUuids = ((_b = peripheral.advertisement) === null || _b === void 0 ? void 0 : _b.serviceUuids) || [];
     if (!isOneKeyPeripheral(peripheral)) {
         return;
     }
     const isNewDevice = !discoveredDevices.has(peripheral.id);
     discoveredDevices.set(peripheral.id, peripheral);
     if (isNewDevice) {
-        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Discovered OneKey BLE device:', {
-            name: deviceName,
-            id: peripheral.id,
-            serviceUUIDs: serviceUuids,
+        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) || [],
         });
     }
 }
@@ -683,10 +671,13 @@ function discoverServicesAndCharacteristics(peripheral) {
                     }
                 });
             });
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] All services:', services === null || services === void 0 ? void 0 : services.map(s => s.uuid));
             if (!services || services.length === 0) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No services found');
             }
+            logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] services discovered', {
+                deviceId: peripheral.id,
+                serviceUUIDs: services.map(service => service.uuid),
+            });
             let service = services.find(s => NORMALIZED_ONEKEY_SERVICE_UUIDS.has(getBleUuidKey(s.uuid)));
             if (!service) {
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Known OneKey service UUID not found, trying first vendor service');
@@ -699,7 +690,10 @@ function discoverServicesAndCharacteristics(peripheral) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound);
             }
             const selectedService = service;
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Using service:', selectedService.uuid);
+            logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] service selected', {
+                deviceId: peripheral.id,
+                serviceUuid: selectedService.uuid,
+            });
             const characteristics = yield new Promise((resolve, reject) => {
                 selectedService.discoverCharacteristics([], (error, chars) => {
                     if (error) {
@@ -711,10 +705,6 @@ function discoverServicesAndCharacteristics(peripheral) {
                     }
                 });
             });
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Discovered characteristics:', {
-                count: (characteristics === null || characteristics === void 0 ? void 0 : characteristics.length) || 0,
-                uuids: (characteristics === null || characteristics === void 0 ? void 0 : characteristics.map(c => c.uuid)) || [],
-            });
             let writeCharacteristic = null;
             let notifyCharacteristic = null;
             for (const characteristic of characteristics) {
@@ -727,14 +717,16 @@ function discoverServicesAndCharacteristics(peripheral) {
                     notifyCharacteristic = characteristic;
                 }
             }
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Characteristic discovery result:', {
-                writeFound: !!writeCharacteristic,
-                notifyFound: !!notifyCharacteristic,
-            });
             if (!writeCharacteristic || !notifyCharacteristic) {
                 logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Missing characteristics - write:', !!writeCharacteristic, 'notify:', !!notifyCharacteristic);
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, 'Required characteristics not found');
             }
+            logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] characteristics selected', {
+                deviceId: peripheral.id,
+                serviceUuid: selectedService.uuid,
+                writeUuid: writeCharacteristic.uuid,
+                notifyUuid: notifyCharacteristic.uuid,
+            });
             return { write: writeCharacteristic, notify: notifyCharacteristic };
         }))();
         try {
@@ -1087,19 +1079,17 @@ function subscribeNotifications(deviceId, callback) {
     });
 }
 function setupNobleBleHandlers(webContents) {
-    console.log('[NobleBLE] Attempting to set up Noble BLE handlers.');
     try {
-        console.log('[NobleBLE] NOBLE_VERSION_771');
         logger = require('electron-log');
-        console.log('[NobleBLE] electron-log loaded successfully.');
         const { ipcMain } = require('electron');
-        console.log('[NobleBLE] electron.ipcMain loaded successfully.');
         safeLog(logger, 'info', 'Setting up Noble BLE IPC handlers');
-        console.log(`[NobleBLE] Registering handler for: ${hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE}`);
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_ENUMERATE, () => index.__awaiter(this, void 0, void 0, function* () {
             try {
                 const devices = yield 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) {
@@ -1124,7 +1114,6 @@ function setupNobleBleHandlers(webContents) {
             yield disconnectDevice(deviceId);
         }));
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_WRITE, (_event, deviceId, hexData) => index.__awaiter(this, void 0, void 0, function* () {
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] IPC WRITE', { deviceId, len: hexData.length });
             yield transmitHexDataToDevice(deviceId, hexData);
         }));
         ipcMain.handle(hdShared.EOneKeyBleMessageKeys.NOBLE_BLE_SUBSCRIBE, (_event, deviceId) => index.__awaiter(this, void 0, void 0, function* () {

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

package/package.json

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

package/src/noble-ble-handler.ts

@@ -117,12 +117,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'));
 }
@@ -551,12 +545,6 @@ 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;
 
   if (!IS_WINDOWS || pairedDevices.has(deviceId)) {
@@ -618,9 +606,6 @@ async function transmitHexDataToDevice(deviceId: string, hexData: string): Promi
 
 // 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 +615,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 || [],
     });
   }
 }
@@ -910,16 +895,15 @@ 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) {
@@ -933,8 +917,10 @@ async function discoverServicesAndCharacteristics(
       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,11 +934,6 @@ 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;
 
@@ -967,11 +948,6 @@ async function discoverServicesAndCharacteristics(
       }
     }
 
-    logger?.info('[NobleBLE] Characteristic discovery result:', {
-      writeFound: !!writeCharacteristic,
-      notifyFound: !!notifyCharacteristic,
-    });
-
     if (!writeCharacteristic || !notifyCharacteristic) {
       logger?.error(
         '[NobleBLE] Missing characteristics - write:',
@@ -985,6 +961,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 };
   })();
 
@@ -1516,29 +1499,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 +1562,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);
       }
     );