@onekeyfe/hd-transport-electron 1.1.34-alpha.3 → 1.1.34-alpha.4

package/dist/ble-ops.d.ts

@@ -7,7 +7,12 @@ export interface SoftRefreshParams {
     subscriptionOperations: Map<string, 'subscribing' | 'unsubscribing' | 'idle'>;
     subscribedDevices: Map<string, boolean>;
     pairedDevices: Set<string>;
-    onNotificationData: (deviceId: string, data: Buffer) => void;
+    notificationCallbacks: Map<string, (hex: string) => void>;
+    processNotificationData: (deviceId: string, data: Buffer) => {
+        isComplete: boolean;
+        completePacket?: string;
+        error?: string;
+    };
     logger: Logger | null;
 }
 export declare function softRefreshSubscription(params: SoftRefreshParams): Promise<void>;

package/dist/ble-ops.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ble-ops.d.ts","sourceRoot":"","sources":["../src/ble-ops.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,CAAC;IACxD,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG,eAAe,GAAG,MAAM,CAAC,CAAC;IAC9E,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7D,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8CtF"}
+{"version":3,"file":"ble-ops.d.ts","sourceRoot":"","sources":["../src/ble-ops.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,CAAC;IACxD,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG,eAAe,GAAG,MAAM,CAAC,CAAC;IAC9E,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACxC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,qBAAqB,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC,CAAC;IAC1D,uBAAuB,EAAE,CACvB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,KACT;QACH,UAAU,EAAE,OAAO,CAAC;QACpB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuDtF"}

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

package/dist/index.d.ts

@@ -26,10 +26,6 @@ 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-55699e30.js');
+var index = require('./index-de36348d.js');
 
 
 

package/dist/{noble-ble-handler-16791965.js → noble-ble-handler-2e41f27c.js}

@@ -1,7 +1,8 @@
 'use strict';
 
-var index = require('./index-55699e30.js');
+var index = require('./index-de36348d.js');
 var hdShared = require('@onekeyfe/hd-shared');
+var hdTransport = require('@onekeyfe/hd-transport');
 var pRetry = require('p-retry');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -19,7 +20,7 @@ function safeLog(logger, level, message, ...args) {
 
 function softRefreshSubscription(params) {
     return index.__awaiter(this, void 0, void 0, function* () {
-        const { deviceId, notifyCharacteristic, subscriptionOperations, subscribedDevices, pairedDevices, onNotificationData, logger, } = params;
+        const { deviceId, notifyCharacteristic, subscriptionOperations, subscribedDevices, pairedDevices, notificationCallbacks, processNotificationData, logger, } = params;
         if (!notifyCharacteristic) {
             throw new Error(`Notify characteristic not available for device ${deviceId}`);
         }
@@ -43,7 +44,16 @@ function softRefreshSubscription(params) {
                 pairedDevices.add(deviceId);
                 logger === null || logger === void 0 ? void 0 : logger.info('[BLE-OPS] Device paired successfully', { deviceId });
             }
-            onNotificationData(deviceId, data);
+            const result = processNotificationData(deviceId, data);
+            if (result.error) {
+                logger === null || logger === void 0 ? void 0 : logger.error('[BLE-OPS] Packet processing error:', result.error);
+                return;
+            }
+            if (result.isComplete && result.completePacket) {
+                const appCb = notificationCallbacks.get(deviceId);
+                if (appCb)
+                    appCb(result.completePacket);
+            }
         });
         subscribedDevices.set(deviceId, true);
         subscriptionOperations.set(deviceId, 'idle');
@@ -66,15 +76,15 @@ const deviceCharacteristics = new Map();
 const notificationCallbacks = new Map();
 const subscribedDevices = new Map();
 const subscriptionOperations = new Map();
+const devicePacketStates = new Map();
 const ONEKEY_SERVICE_UUIDS = [hdShared.ONEKEY_SERVICE_UUID];
-const PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS = new Set(['fffd']);
 const NORMALIZED_WRITE_UUID = '0002';
 const NORMALIZED_NOTIFY_UUID = '0003';
 const BLUETOOTH_INIT_TIMEOUT = 10000;
-const DEVICE_SCAN_TIMEOUT = 8000;
-const FAST_SCAN_TIMEOUT = 8000;
+const DEVICE_SCAN_TIMEOUT = 5000;
+const FAST_SCAN_TIMEOUT = 1500;
 const DEVICE_CHECK_INTERVAL = 500;
-const CONNECTION_TIMEOUT = 8000;
+const CONNECTION_TIMEOUT = 3000;
 const SERVICE_DISCOVERY_TIMEOUT = 10000;
 const BLE_PACKET_SIZE = 192;
 const UNIFIED_WRITE_DELAY = 5;
@@ -83,35 +93,70 @@ const IS_WINDOWS = process.platform === 'win32';
 const ABORTABLE_WRITE_ERROR_PATTERNS = [
     /status:\s*3/i,
 ];
-function getBleUuidKey(uuid) {
-    const normalized = (uuid !== null && uuid !== void 0 ? 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) {
-    return ['1800', '1801', '180a', '180f'].includes(getBleUuidKey(uuid));
-}
-function hasOneKeyAdvertisementService(peripheral) {
-    var _a, _b;
-    const serviceUuids = (_b = (_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.serviceUuids) !== null && _b !== void 0 ? _b : [];
-    return serviceUuids.some(uuid => {
-        const uuidKey = getBleUuidKey(uuid);
-        return (NORMALIZED_ONEKEY_SERVICE_UUIDS.has(uuidKey) ||
-            PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(uuidKey));
+const MIN_HEADER_LENGTH = 9;
+function processNotificationData(deviceId, data) {
+    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Notification', {
+        deviceId,
+        dataLength: data.length,
     });
+    let packetState = devicePacketStates.get(deviceId);
+    if (!packetState) {
+        packetState = { bufferLength: 0, buffer: [], packetCount: 0 };
+        devicePacketStates.set(deviceId, packetState);
+        logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Initialized new packet state for device:', deviceId);
+    }
+    try {
+        if (hdShared.isHeaderChunk(data)) {
+            if (data.length < MIN_HEADER_LENGTH) {
+                return { isComplete: false, error: 'Invalid header chunk: too short' };
+            }
+            const messageId = `${deviceId}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+            packetState.bufferLength = data.readInt32BE(5);
+            packetState.buffer = [...data.subarray(3)];
+            packetState.packetCount = 1;
+            packetState.messageId = messageId;
+            if (packetState.bufferLength < 0) {
+                logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Invalid negative packet length detected:', {
+                    length: packetState.bufferLength,
+                    dataLength: data.length,
+                    rawHeader: data.subarray(0, Math.min(16, data.length)).toString('hex'),
+                    lengthBytes: data.subarray(5, 9).toString('hex'),
+                });
+                resetPacketState(packetState);
+                return { isComplete: false, error: 'Invalid packet length in header' };
+            }
+        }
+        else {
+            if (packetState.bufferLength === 0) {
+                return { isComplete: false, error: 'Received data chunk without header' };
+            }
+            packetState.packetCount += 1;
+            packetState.buffer = packetState.buffer.concat([...data]);
+        }
+        if (packetState.buffer.length - hdTransport.COMMON_HEADER_SIZE >= packetState.bufferLength) {
+            const completeBuffer = Buffer.from(packetState.buffer);
+            const hexString = completeBuffer.toString('hex');
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Packet assembled', {
+                deviceId,
+                totalPackets: packetState.packetCount,
+                expectedLength: packetState.bufferLength,
+                actualLength: packetState.buffer.length - hdTransport.COMMON_HEADER_SIZE,
+            });
+            resetPacketState(packetState);
+            return { isComplete: true, completePacket: hexString };
+        }
+        return { isComplete: false };
+    }
+    catch (error) {
+        resetPacketState(packetState);
+        return { isComplete: false, error: `Packet processing error: ${error}` };
+    }
 }
-function isOneKeyPeripheral(peripheral) {
-    var _a;
-    const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || null;
-    return hdShared.isOnekeyDevice(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
-}
-function emitRawNotification(deviceId, data) {
-    const appCb = notificationCallbacks.get(deviceId);
-    if (appCb)
-        appCb(data.toString('hex'));
+function resetPacketState(packetState) {
+    packetState.bufferLength = 0;
+    packetState.buffer = [];
+    packetState.packetCount = 0;
+    packetState.messageId = undefined;
 }
 function checkBluetoothAvailability() {
     return index.__awaiter(this, void 0, void 0, function* () {
@@ -156,6 +201,7 @@ function setupPersistentStateListener() {
             deviceCharacteristics.clear();
             subscribedDevices.clear();
             notificationCallbacks.clear();
+            devicePacketStates.clear();
             subscriptionOperations.clear();
             pairedDevices.clear();
             if (noble) {
@@ -275,6 +321,7 @@ function cleanupDevice(deviceId, webContents, options = {}) {
         connectedDevices.delete(deviceId);
         deviceCharacteristics.delete(deviceId);
         notificationCallbacks.delete(deviceId);
+        devicePacketStates.delete(deviceId);
         subscribedDevices.delete(deviceId);
         subscriptionOperations.delete(deviceId);
         pairedDevices.delete(deviceId);
@@ -389,7 +436,8 @@ function attemptWindowsWriteUntilPaired(deviceId, doGetWriteCharacteristic, payl
                     subscriptionOperations,
                     subscribedDevices,
                     pairedDevices,
-                    onNotificationData: emitRawNotification,
+                    notificationCallbacks,
+                    processNotificationData,
                     logger,
                 });
                 logger === null || logger === void 0 ? void 0 : logger.info('[BLE-Write] Subscription refresh completed', { deviceId });
@@ -410,6 +458,11 @@ 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();
@@ -453,19 +506,13 @@ function transmitHexDataToDevice(deviceId, hexData) {
     });
 }
 function handleDeviceDiscovered(peripheral) {
-    var _a, _b;
-    if (!isOneKeyPeripheral(peripheral)) {
+    var _a;
+    const deviceName = ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.localName) || 'Unknown Device';
+    if (!hdShared.isOnekeyDevice(deviceName)) {
         return;
     }
-    const isNewDevice = !discoveredDevices.has(peripheral.id);
+    logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Discovered OneKey device:', deviceName);
     discoveredDevices.set(peripheral.id, peripheral);
-    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) || [],
-        });
-    }
 }
 function ensureDiscoverListener() {
     if (!noble)
@@ -510,7 +557,7 @@ function performTargetedScan(targetDeviceId) {
                 resolve(null);
             }, FAST_SCAN_TIMEOUT);
             nobleInstance.on('discover', onDiscover);
-            nobleInstance.startScanning([], false, (error) => {
+            nobleInstance.startScanning(ONEKEY_SERVICE_UUIDS, false, (error) => {
                 if (error) {
                     clearTimeout(timeoutId);
                     nobleInstance.removeListener('discover', onDiscover);
@@ -560,13 +607,11 @@ function enumerateDevices() {
                 });
             };
             const timeoutId = setTimeout(() => {
-                checkDevices();
                 cleanup();
                 logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scan completed, found devices:', devices.length);
                 resolve(devices);
             }, DEVICE_SCAN_TIMEOUT);
-            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Scanning for OneKey BLE devices');
-            nobleInstance.startScanning([], false, (error) => {
+            nobleInstance.startScanning(ONEKEY_SERVICE_UUIDS, false, (error) => {
                 if (error) {
                     cleanup();
                     logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Failed to start scanning:', error);
@@ -661,7 +706,7 @@ function discoverServicesAndCharacteristics(peripheral) {
         });
         const discoveryPromise = (() => index.__awaiter(this, void 0, void 0, function* () {
             const services = yield new Promise((resolve, reject) => {
-                peripheral.discoverServices([], (error, svc) => {
+                peripheral.discoverServices(ONEKEY_SERVICE_UUIDS, (error, svc) => {
                     if (error) {
                         logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Service discovery failed:', error);
                         reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, error.message));
@@ -672,30 +717,12 @@ function discoverServicesAndCharacteristics(peripheral) {
                 });
             });
             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');
-                service =
-                    services.find(s => PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS.has(getBleUuidKey(s.uuid))) ||
-                        services.find(s => !isGenericBleService(s.uuid)) ||
-                        services[0];
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound, 'No OneKey services found');
             }
-            if (!service) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleServiceNotFound);
-            }
-            const selectedService = service;
-            logger === null || logger === void 0 ? void 0 : logger.debug('[NobleBLE] service selected', {
-                deviceId: peripheral.id,
-                serviceUuid: selectedService.uuid,
-            });
+            const service = services[0];
+            logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Found service:', service.uuid);
             const characteristics = yield new Promise((resolve, reject) => {
-                selectedService.discoverCharacteristics([], (error, chars) => {
+                service.discoverCharacteristics([hdShared.ONEKEY_WRITE_CHARACTERISTIC_UUID, hdShared.ONEKEY_NOTIFY_CHARACTERISTIC_UUID], (error, chars) => {
                     if (error) {
                         logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Characteristic discovery failed:', error);
                         reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BleCharacteristicNotFound, error.message));
@@ -705,6 +732,10 @@ 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) {
@@ -717,16 +748,14 @@ 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 {
@@ -915,6 +944,7 @@ function connectDevice(deviceId, webContents) {
                     existingCharacteristics.notify.removeAllListeners('data');
                 }
                 notificationCallbacks.delete(deviceId);
+                devicePacketStates.delete(deviceId);
                 subscribedDevices.delete(deviceId);
             }
             const characteristics = yield setupConnectionAndDiscoverServices(peripheral, deviceId, webContents);
@@ -997,6 +1027,7 @@ function unsubscribeNotifications(deviceId) {
             });
             notifyCharacteristic.removeAllListeners('data');
             notificationCallbacks.delete(deviceId);
+            devicePacketStates.delete(deviceId);
             subscribedDevices.delete(deviceId);
         }
         finally {
@@ -1036,6 +1067,12 @@ function subscribeNotifications(deviceId, callback) {
         if (subscribedDevices.get(deviceId)) {
             logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device already subscribed to characteristic, updating callback only');
             notificationCallbacks.set(deviceId, callback);
+            devicePacketStates.set(deviceId, {
+                bufferLength: 0,
+                buffer: [],
+                packetCount: 0,
+                messageId: undefined,
+            });
             subscriptionOperations.set(deviceId, 'idle');
             return Promise.resolve();
         }
@@ -1044,6 +1081,12 @@ function subscribeNotifications(deviceId, callback) {
         }
         notifyCharacteristic.removeAllListeners('data');
         notificationCallbacks.set(deviceId, callback);
+        devicePacketStates.set(deviceId, {
+            bufferLength: 0,
+            buffer: [],
+            packetCount: 0,
+            messageId: undefined,
+        });
         function rebuildAppSubscription(deviceId, notifyCharacteristic) {
             return index.__awaiter(this, void 0, void 0, function* () {
                 yield new Promise(resolve => {
@@ -1065,7 +1108,16 @@ function subscribeNotifications(deviceId, callback) {
                         pairedDevices.add(deviceId);
                         logger === null || logger === void 0 ? void 0 : logger.info('[NobleBLE] Device paired successfully', { deviceId });
                     }
-                    emitRawNotification(deviceId, data);
+                    const result = processNotificationData(deviceId, data);
+                    if (result.error) {
+                        logger === null || logger === void 0 ? void 0 : logger.error('[NobleBLE] Packet processing error:', result.error);
+                        return;
+                    }
+                    if (result.isComplete && result.completePacket) {
+                        const appCb = notificationCallbacks.get(deviceId);
+                        if (appCb)
+                            appCb(result.completePacket);
+                    }
                 });
             });
         }
@@ -1079,17 +1131,19 @@ 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, 'debug', 'Enumeration completed', {
-                    count: devices.length,
-                    devices: devices.map(device => ({ id: device.id, name: device.name })),
-                });
+                safeLog(logger, 'info', 'Enumeration completed, devices:', devices);
                 return devices;
             }
             catch (error) {
@@ -1114,6 +1168,7 @@ 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;AAw8ChE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAiKpE"}
+{"version":3,"file":"noble-ble-handler.d.ts","sourceRoot":"","sources":["../src/noble-ble-handler.ts"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EAAsB,WAAW,EAAE,MAAM,UAAU,CAAC;AAshDhE,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAsKpE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-transport-electron",
-  "version": "1.1.34-alpha.3",
+  "version": "1.1.34-alpha.4",
   "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.1.34-alpha.3",
-    "@onekeyfe/hd-shared": "1.1.34-alpha.3",
-    "@onekeyfe/hd-transport": "1.1.34-alpha.3",
+    "@onekeyfe/hd-core": "1.1.34-alpha.4",
+    "@onekeyfe/hd-shared": "1.1.34-alpha.4",
+    "@onekeyfe/hd-transport": "1.1.34-alpha.4",
     "@stoprocent/noble": "2.3.16",
     "p-retry": "^4.6.2"
   },
@@ -36,5 +36,5 @@
     "electron": "^25.0.0",
     "typescript": "^5.3.3"
   },
-  "gitHead": "3688bc8495eeb2ffd5616270d13fa29e8967623a"
+  "gitHead": "d546bc55410990351d34009230aefea77725d0d6"
 }

package/src/ble-ops.ts

@@ -7,7 +7,15 @@ export interface SoftRefreshParams {
   subscriptionOperations: Map<string, 'subscribing' | 'unsubscribing' | 'idle'>;
   subscribedDevices: Map<string, boolean>;
   pairedDevices: Set<string>;
-  onNotificationData: (deviceId: string, data: Buffer) => void;
+  notificationCallbacks: Map<string, (hex: string) => void>;
+  processNotificationData: (
+    deviceId: string,
+    data: Buffer
+  ) => {
+    isComplete: boolean;
+    completePacket?: string;
+    error?: string;
+  };
   logger: Logger | null;
 }
 
@@ -18,7 +26,8 @@ export async function softRefreshSubscription(params: SoftRefreshParams): Promis
     subscriptionOperations,
     subscribedDevices,
     pairedDevices,
-    onNotificationData,
+    notificationCallbacks,
+    processNotificationData,
     logger,
   } = params;
 
@@ -51,7 +60,15 @@ export async function softRefreshSubscription(params: SoftRefreshParams): Promis
       logger?.info('[BLE-OPS] Device paired successfully', { deviceId });
     }
 
-    onNotificationData(deviceId, data);
+    const result = processNotificationData(deviceId, data);
+    if (result.error) {
+      logger?.error('[BLE-OPS] Packet processing error:', result.error);
+      return;
+    }
+    if (result.isComplete && result.completePacket) {
+      const appCb = notificationCallbacks.get(deviceId);
+      if (appCb) appCb(result.completePacket);
+    }
   });
 
   subscribedDevices.set(deviceId, true);

package/src/noble-ble-handler.ts

@@ -9,10 +9,14 @@ import {
   EOneKeyBleMessageKeys,
   ERRORS,
   HardwareErrorCode,
+  ONEKEY_NOTIFY_CHARACTERISTIC_UUID,
   ONEKEY_SERVICE_UUID,
+  ONEKEY_WRITE_CHARACTERISTIC_UUID,
+  isHeaderChunk,
   isOnekeyDevice,
   wait,
 } from '@onekeyfe/hd-shared';
+import { COMMON_HEADER_SIZE } from '@onekeyfe/hd-transport';
 import pRetry from 'p-retry';
 
 import { safeLog } from './types/noble-extended';
@@ -51,6 +55,15 @@ 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'>();
 
+// Packet reassembly state for each device
+interface PacketAssemblyState {
+  bufferLength: number;
+  buffer: number[];
+  packetCount: number;
+  messageId?: string; // Add message ID to track concurrent requests
+}
+const devicePacketStates = new Map<string, PacketAssemblyState>();
+
 // Windows-only response watchdog state moved to utils/windows-ble-recovery
 
 // Pairing-related state removed
@@ -59,7 +72,6 @@ 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';
@@ -67,10 +79,10 @@ const NORMALIZED_NOTIFY_UUID = '0003';
 
 // 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 FAST_SCAN_TIMEOUT = 1500; // 1.5 seconds for fast targeted 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 CONNECTION_TIMEOUT = 3000; // 3 seconds for device connection
 const SERVICE_DISCOVERY_TIMEOUT = 10000; // 10 seconds for service discovery
 
 // Write-related constants
@@ -82,43 +94,101 @@ 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',
-]);
+// Validation limits
+const MIN_HEADER_LENGTH = 9; // Minimum header chunk length
 
-function isGenericBleService(uuid?: string | null) {
-  return ['1800', '1801', '180a', '180f'].includes(getBleUuidKey(uuid));
+// Packet processing result types
+interface PacketProcessResult {
+  isComplete: boolean;
+  completePacket?: string;
+  error?: string;
 }
 
-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)
-    );
+// Process incoming BLE notification data with proper packet reassembly
+function processNotificationData(deviceId: string, data: Buffer): PacketProcessResult {
+  //  notification telemetry
+  logger?.info('[NobleBLE] Notification', {
+    deviceId,
+    dataLength: data.length,
   });
-}
 
-function isOneKeyPeripheral(peripheral: Peripheral) {
-  const deviceName = peripheral.advertisement?.localName || null;
-  return isOnekeyDevice(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
+  // Get or initialize packet state for this device
+  let packetState = devicePacketStates.get(deviceId);
+  if (!packetState) {
+    packetState = { bufferLength: 0, buffer: [], packetCount: 0 };
+    devicePacketStates.set(deviceId, packetState);
+    logger?.info('[NobleBLE] Initialized new packet state for device:', deviceId);
+  }
+
+  try {
+    if (isHeaderChunk(data)) {
+      // Validate header chunk
+      if (data.length < MIN_HEADER_LENGTH) {
+        return { isComplete: false, error: 'Invalid header chunk: too short' };
+      }
+
+      // Generate message ID for this packet sequence
+      const messageId = `${deviceId}-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+
+      // Reset packet state for new message
+      packetState.bufferLength = data.readInt32BE(5);
+      packetState.buffer = [...data.subarray(3)];
+      packetState.packetCount = 1;
+      packetState.messageId = messageId;
+
+      // Only validate for negative lengths (which would be invalid)
+      if (packetState.bufferLength < 0) {
+        logger?.error('[NobleBLE] Invalid negative packet length detected:', {
+          length: packetState.bufferLength,
+          dataLength: data.length,
+          rawHeader: data.subarray(0, Math.min(16, data.length)).toString('hex'),
+          lengthBytes: data.subarray(5, 9).toString('hex'),
+        });
+        resetPacketState(packetState);
+        return { isComplete: false, error: 'Invalid packet length in header' };
+      }
+    } else {
+      // Validate we have an active packet session
+      if (packetState.bufferLength === 0) {
+        return { isComplete: false, error: 'Received data chunk without header' };
+      }
+
+      // Increment packet counter and append data
+      packetState.packetCount += 1;
+      packetState.buffer = packetState.buffer.concat([...data]);
+    }
+
+    // Check if packet is complete
+    if (packetState.buffer.length - COMMON_HEADER_SIZE >= packetState.bufferLength) {
+      const completeBuffer = Buffer.from(packetState.buffer);
+      const hexString = completeBuffer.toString('hex');
+
+      logger?.info('[NobleBLE] Packet assembled', {
+        deviceId,
+        totalPackets: packetState.packetCount,
+        expectedLength: packetState.bufferLength,
+        actualLength: packetState.buffer.length - COMMON_HEADER_SIZE,
+      });
+
+      // Reset packet state for next message
+      resetPacketState(packetState);
+
+      return { isComplete: true, completePacket: hexString };
+    }
+
+    return { isComplete: false };
+  } catch (error) {
+    resetPacketState(packetState);
+    return { isComplete: false, error: `Packet processing error: ${error}` };
+  }
 }
 
-/**
- * Forward a single BLE notification chunk (not an assembled packet) to the
- * renderer-side transport. Packet reassembly is handled by ElectronBleTransport.
- */
-function emitRawNotification(deviceId: string, data: Buffer): void {
-  const appCb = notificationCallbacks.get(deviceId);
-  if (appCb) appCb(data.toString('hex'));
+// Reset packet state to clean state
+function resetPacketState(packetState: PacketAssemblyState): void {
+  packetState.bufferLength = 0;
+  packetState.buffer = [];
+  packetState.packetCount = 0;
+  packetState.messageId = undefined;
 }
 
 // Check Bluetooth availability - returns detailed state
@@ -180,6 +250,7 @@ function setupPersistentStateListener(): void {
       deviceCharacteristics.clear();
       subscribedDevices.clear();
       notificationCallbacks.clear();
+      devicePacketStates.clear();
       subscriptionOperations.clear();
       pairedDevices.clear();
 
@@ -357,6 +428,7 @@ function cleanupDevice(
     connectedDevices.delete(deviceId);
     deviceCharacteristics.delete(deviceId);
     notificationCallbacks.delete(deviceId);
+    devicePacketStates.delete(deviceId);
     subscribedDevices.delete(deviceId);
     subscriptionOperations.delete(deviceId);
     pairedDevices.delete(deviceId);
@@ -518,7 +590,8 @@ async function attemptWindowsWriteUntilPaired(
         subscriptionOperations,
         subscribedDevices,
         pairedDevices,
-        onNotificationData: emitRawNotification,
+        notificationCallbacks,
+        processNotificationData,
         logger,
       });
       logger?.info('[BLE-Write] Subscription refresh completed', { deviceId });
@@ -545,6 +618,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;
 
   if (!IS_WINDOWS || pairedDevices.has(deviceId)) {
@@ -606,21 +685,15 @@ async function transmitHexDataToDevice(deviceId: string, hexData: string): Promi
 
 // Handle discovered device (for general enumeration only)
 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.
-  if (!isOneKeyPeripheral(peripheral)) {
+  const deviceName = peripheral.advertisement?.localName || 'Unknown Device';
+
+  // Only process OneKey devices for general discovery
+  if (!isOnekeyDevice(deviceName)) {
     return;
   }
 
-  const isNewDevice = !discoveredDevices.has(peripheral.id);
+  logger?.info('[NobleBLE] Discovered OneKey device:', deviceName);
   discoveredDevices.set(peripheral.id, peripheral);
-  if (isNewDevice) {
-    logger?.debug('[NobleBLE] OneKey BLE device discovered', {
-      deviceId: peripheral.id,
-      name: peripheral.advertisement?.localName || 'Unknown Device',
-      serviceUUIDs: peripheral.advertisement?.serviceUuids || [],
-    });
-  }
 }
 
 // Ensure discover listener is properly set up
@@ -680,8 +753,8 @@ async function performTargetedScan(targetDeviceId: string): Promise<Peripheral |
     // Add local listener for this scan
     nobleInstance.on('discover', onDiscover);
 
-    // Start scanning — no service UUID filter (Pro2 may use different service UUID)
-    nobleInstance.startScanning([], false, (error?: Error) => {
+    // Start scanning
+    nobleInstance.startScanning(ONEKEY_SERVICE_UUIDS, false, (error?: Error) => {
       if (error) {
         clearTimeout(timeoutId);
         nobleInstance.removeListener('discover', onDiscover);
@@ -743,19 +816,15 @@ async function enumerateDevices(): Promise<DeviceInfo[]> {
       });
     };
 
-    // Set timeout for scanning — use longer timeout to catch slow-advertising devices like Pro2
+    // Set timeout for scanning
     const timeoutId = setTimeout(() => {
-      // Final collection before resolving — catches devices discovered near the deadline
-      checkDevices();
       cleanup();
       logger?.info('[NobleBLE] Scan completed, found devices:', devices.length);
       resolve(devices);
     }, DEVICE_SCAN_TIMEOUT);
 
-    // 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) => {
+    // Start scanning for OneKey service UUIDs
+    nobleInstance.startScanning(ONEKEY_SERVICE_UUIDS, false, (error?: Error) => {
       if (error) {
         cleanup();
         logger?.error('[NobleBLE] Failed to start scanning:', error);
@@ -883,9 +952,9 @@ async function discoverServicesAndCharacteristics(
 
   // Main discovery logic as async function
   const discoveryPromise = (async (): Promise<CharacteristicPair> => {
-    // Step 1: Discover ALL services (no filter — Pro2 may use different service UUID)
+    // Step 1: Discover services (promisified)
     const services = await new Promise<Service[]>((resolve, reject) => {
-      peripheral.discoverServices([], (error, svc) => {
+      peripheral.discoverServices(ONEKEY_SERVICE_UUIDS, (error, svc) => {
         if (error) {
           logger?.error('[NobleBLE] Service discovery failed:', error);
           reject(ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, error.message));
@@ -896,44 +965,33 @@ async function discoverServicesAndCharacteristics(
     });
 
     if (!services || services.length === 0) {
-      throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, 'No services found');
+      throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, 'No OneKey services found');
     }
 
-    logger?.debug('[NobleBLE] services discovered', {
-      deviceId: peripheral.id,
-      serviceUUIDs: services.map(service => service.uuid),
-    });
+    const service = services[0];
+    logger?.info('[NobleBLE] Found 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];
-    }
-    if (!service) {
-      throw ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound);
-    }
-    const selectedService = service;
-    logger?.debug('[NobleBLE] service selected', {
-      deviceId: peripheral.id,
-      serviceUuid: selectedService.uuid,
-    });
-    // Step 2: Discover ALL characteristics (no filter)
+    // Step 2: Discover characteristics (promisified)
     const characteristics = await new Promise<Characteristic[]>((resolve, reject) => {
-      selectedService.discoverCharacteristics([], (error, chars) => {
-        if (error) {
-          logger?.error('[NobleBLE] Characteristic discovery failed:', error);
-          reject(ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotFound, error.message));
-        } else {
-          resolve(chars);
+      service.discoverCharacteristics(
+        [ONEKEY_WRITE_CHARACTERISTIC_UUID, ONEKEY_NOTIFY_CHARACTERISTIC_UUID],
+        (error, chars) => {
+          if (error) {
+            logger?.error('[NobleBLE] Characteristic discovery failed:', error);
+            reject(ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotFound, error.message));
+          } else {
+            resolve(chars);
+          }
         }
-      });
+      );
     });
 
     // 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;
 
@@ -948,6 +1006,11 @@ async function discoverServicesAndCharacteristics(
       }
     }
 
+    logger?.info('[NobleBLE] Characteristic discovery result:', {
+      writeFound: !!writeCharacteristic,
+      notifyFound: !!notifyCharacteristic,
+    });
+
     if (!writeCharacteristic || !notifyCharacteristic) {
       logger?.error(
         '[NobleBLE] Missing characteristics - write:',
@@ -961,13 +1024,6 @@ 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 };
   })();
 
@@ -1264,6 +1320,7 @@ async function connectDevice(deviceId: string, webContents: WebContents): Promis
         existingCharacteristics.notify.removeAllListeners('data');
       }
       notificationCallbacks.delete(deviceId);
+      devicePacketStates.delete(deviceId);
       subscribedDevices.delete(deviceId);
       // Continue to re-setup the connection properly
     }
@@ -1374,6 +1431,7 @@ async function unsubscribeNotifications(deviceId: string): Promise<void> {
     // Remove all listeners and clear subscription status
     notifyCharacteristic.removeAllListeners('data');
     notificationCallbacks.delete(deviceId);
+    devicePacketStates.delete(deviceId);
     subscribedDevices.delete(deviceId);
   } finally {
     // 🔒 CRITICAL: Always clear operation state (even on error)
@@ -1440,6 +1498,14 @@ async function subscribeNotifications(
     // Just update the callback without re-subscribing
     notificationCallbacks.set(deviceId, callback);
 
+    // Reset packet state for new session
+    devicePacketStates.set(deviceId, {
+      bufferLength: 0,
+      buffer: [],
+      packetCount: 0,
+      messageId: undefined,
+    });
+
     // 🔒 Clear operation state
     subscriptionOperations.set(deviceId, 'idle');
     return Promise.resolve();
@@ -1456,6 +1522,14 @@ async function subscribeNotifications(
   // Store callback for this device
   notificationCallbacks.set(deviceId, callback);
 
+  // Reset packet state for new subscription session
+  devicePacketStates.set(deviceId, {
+    bufferLength: 0,
+    buffer: [],
+    packetCount: 0,
+    messageId: undefined,
+  });
+
   // Helper: rebuild a clean application-layer subscription
   async function rebuildAppSubscription(
     deviceId: string,
@@ -1484,7 +1558,15 @@ async function subscribeNotifications(
         logger?.info('[NobleBLE] Device paired successfully', { deviceId });
       }
 
-      emitRawNotification(deviceId, data);
+      const result = processNotificationData(deviceId, data);
+      if (result.error) {
+        logger?.error('[NobleBLE] Packet processing error:', result.error);
+        return;
+      }
+      if (result.isComplete && result.completePacket) {
+        const appCb = notificationCallbacks.get(deviceId);
+        if (appCb) appCb(result.completePacket);
+      }
     });
   }
 
@@ -1499,25 +1581,29 @@ 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, 'debug', 'Enumeration completed', {
-          count: devices.length,
-          devices: devices.map(device => ({ id: device.id, name: device.name })),
-        });
+        safeLog(logger, 'info', 'Enumeration completed, devices:', devices);
         return devices;
       } catch (error) {
         safeLog(logger, 'error', 'Enumeration failed:', error);
@@ -1562,6 +1648,7 @@ 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);
       }
     );