@onekeyfe/hardware-cli 1.2.2-alpha.100 → 1.2.2-alpha.12

package/dist/transports/nobleBlePlugin.d.ts

@@ -1,2 +1,4 @@
+/// <reference types="node" />
 import type { LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
+export declare function resolveNobleProtocolV2PacketCapacity(mtu: number | null | undefined, platform?: NodeJS.Platform): number;
 export declare function createNobleBlePlugin(): LowlevelTransportSharedPlugin;

package/dist/transports/nobleBlePlugin.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNobleBlePlugin = void 0;
+exports.createNobleBlePlugin = exports.resolveNobleProtocolV2PacketCapacity = void 0;
 const hd_shared_1 = require("@onekeyfe/hd-shared");
 const ONEKEY_SERVICE_UUIDS = [hd_shared_1.ONEKEY_SERVICE_UUID];
 const ONEKEY_SERVICE_UUID_ALIASES = (0, hd_shared_1.createKnownBleUuidAliases)(hd_shared_1.ONEKEY_SERVICE_UUID);
@@ -11,8 +11,22 @@ const DEVICE_SCAN_TIMEOUT = 8000;
 const CONNECTION_TIMEOUT = 8000;
 const SERVICE_DISCOVERY_TIMEOUT = 10000;
 const BLE_CLEANUP_TIMEOUT = 100;
-const BLE_PACKET_SIZE = 192;
+const BLE_PACKET_SIZE_FALLBACK = 192;
+const BLE_PACKET_SIZE_MAX = 244;
+const ATT_WRITE_HEADER_SIZE = 3;
 const BLE_ENCRYPTION_ERROR_PATTERNS = [/encryption is insufficient/i, /insufficient encryption/i];
+function resolveNobleProtocolV2PacketCapacity(mtu, platform = process.platform) {
+    if (typeof mtu !== 'number' || !Number.isFinite(mtu) || mtu <= 0) {
+        return BLE_PACKET_SIZE_FALLBACK;
+    }
+    const reportedCapacity = Math.floor(mtu);
+    const payloadCapacity = platform === 'linux' ? reportedCapacity - ATT_WRITE_HEADER_SIZE : reportedCapacity;
+    if (payloadCapacity <= 0) {
+        return BLE_PACKET_SIZE_FALLBACK;
+    }
+    return Math.min(payloadCapacity, BLE_PACKET_SIZE_MAX);
+}
+exports.resolveNobleProtocolV2PacketCapacity = resolveNobleProtocolV2PacketCapacity;
 let noble = null;
 let nobleReadyPromise = null;
 const discoveredDevices = new Map();
@@ -20,6 +34,7 @@ const connectedDevices = new Map();
 const deviceCharacteristics = new Map();
 const notificationStates = new Map();
 const notificationGenerations = new Map();
+const disconnectListeners = new Map();
 function isOneKeyPeripheral(peripheral) {
     const serviceUuids = peripheral.advertisement?.serviceUuids;
     return ((0, hd_shared_1.hasOnekeyCommunicationService)(serviceUuids) &&
@@ -63,11 +78,32 @@ function clearNotificationState(deviceId, reason) {
     if (!state)
         return;
     notificationStates.delete(deviceId);
-    const error = new Error(reason);
+    const error = reason instanceof Error ? reason : new Error(reason);
     state.pendingReceivers.forEach(receiver => receiver.reject(error));
     state.pendingReceivers.clear();
     state.queue.length = 0;
 }
+function removeDisconnectListener(deviceId) {
+    const tracked = disconnectListeners.get(deviceId);
+    if (!tracked)
+        return;
+    tracked.peripheral.removeListener('disconnect', tracked.listener);
+    disconnectListeners.delete(deviceId);
+}
+function trackUnexpectedDisconnect(deviceId, peripheral) {
+    removeDisconnectListener(deviceId);
+    const listener = (reason) => {
+        removeDisconnectListener(deviceId);
+        if (connectedDevices.get(deviceId) !== peripheral)
+            return;
+        deviceCharacteristics.get(deviceId)?.notify.removeAllListeners('data');
+        connectedDevices.delete(deviceId);
+        deviceCharacteristics.delete(deviceId);
+        clearNotificationState(deviceId, hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleDeviceDisconnected, reason || `BLE device disconnected: ${deviceId}`));
+    };
+    disconnectListeners.set(deviceId, { peripheral, listener });
+    peripheral.on('disconnect', listener);
+}
 function waitForNobleCleanup(registerCallback) {
     return new Promise(resolve => {
         let completed = false;
@@ -280,6 +316,7 @@ function writeCharacteristic(characteristic, buffer, withoutResponse) {
 async function disconnectDevice(uuid) {
     const peripheral = connectedDevices.get(uuid);
     const characteristics = deviceCharacteristics.get(uuid);
+    removeDisconnectListener(uuid);
     clearNotificationState(uuid, `BLE device disconnected: ${uuid}`);
     if (characteristics) {
         characteristics.notify.removeAllListeners('data');
@@ -321,8 +358,10 @@ function createNobleBlePlugin() {
                 await subscribeNotifications(uuid, notificationState.generation, characteristics.notify);
                 connectedDevices.set(uuid, peripheral);
                 deviceCharacteristics.set(uuid, characteristics);
+                trackUnexpectedDisconnect(uuid, peripheral);
             }
             catch (error) {
+                removeDisconnectListener(uuid);
                 clearNotificationState(uuid, `BLE notification subscription failed: ${uuid}`);
                 if (characteristics) {
                     characteristics.notify.removeAllListeners('data');
@@ -337,6 +376,9 @@ function createNobleBlePlugin() {
         async disconnect(uuid) {
             await disconnectDevice(uuid);
         },
+        getProtocolV2PacketCapacity(uuid) {
+            return resolveNobleProtocolV2PacketCapacity(connectedDevices.get(uuid)?.mtu);
+        },
         async send(uuid, data, options) {
             const characteristics = deviceCharacteristics.get(uuid);
             if (!characteristics) {
@@ -344,8 +386,9 @@ function createNobleBlePlugin() {
             }
             const buffer = Buffer.from(data, 'hex');
             const withoutResponse = options?.withoutResponse ?? true;
-            for (let offset = 0; offset < buffer.length; offset += BLE_PACKET_SIZE) {
-                const chunk = buffer.subarray(offset, Math.min(offset + BLE_PACKET_SIZE, buffer.length));
+            const packetCapacity = resolveNobleProtocolV2PacketCapacity(connectedDevices.get(uuid)?.mtu);
+            for (let offset = 0; offset < buffer.length; offset += packetCapacity) {
+                const chunk = buffer.subarray(offset, Math.min(offset + packetCapacity, buffer.length));
                 await writeCharacteristic(characteristics.write, chunk, withoutResponse);
             }
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hardware-cli",
-  "version": "1.2.2-alpha.100",
+  "version": "1.2.2-alpha.12",
   "description": "OneKey hardware wallet CLI for testing device communication",
   "author": "OneKey",
   "license": "Apache-2.0",
@@ -31,12 +31,12 @@
     "test": "jest"
   },
   "dependencies": {
-    "@onekeyfe/hd-common-connect-sdk": "1.2.2-alpha.100",
-    "@onekeyfe/hd-core": "1.2.2-alpha.100",
-    "@onekeyfe/hd-shared": "1.2.2-alpha.100",
-    "@onekeyfe/hd-transport-usb": "1.2.2-alpha.100",
+    "@onekeyfe/hd-common-connect-sdk": "1.2.2-alpha.12",
+    "@onekeyfe/hd-core": "1.2.2-alpha.12",
+    "@onekeyfe/hd-shared": "1.2.2-alpha.12",
+    "@onekeyfe/hd-transport-usb": "1.2.2-alpha.12",
     "@stoprocent/noble": "2.3.16",
     "commander": "^12.0.0"
   },
-  "gitHead": "c40dad085297b0e3cc2020bd218c146dff6ed3e1"
+  "gitHead": "9b5a45bc55819d22ed752899b4c40aad70de4527"
 }

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

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'events';
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 type MockCharacteristic = EventEmitter & {
   uuid: string;
@@ -27,18 +28,20 @@ const createPeripheral = (id: string) => {
     uuid: '0001',
     discoverCharacteristics: jest.fn((_uuids, callback) => callback(null, [write, notify])),
   };
-  return {
-    peripheral: {
-      id,
-      state: 'connected',
-      advertisement: {
-        localName: `OneKey Pro 2 ${id}`,
-        serviceUuids: ['0001'],
-      },
-      discoverServices: jest.fn((_uuids, callback) => callback(null, [service])),
-      connect: jest.fn(callback => callback()),
-      disconnect: jest.fn(callback => callback()),
+  const peripheral = Object.assign(new EventEmitter(), {
+    id,
+    state: 'connected',
+    mtu: null as number | null,
+    advertisement: {
+      localName: `OneKey Pro 2 ${id}`,
+      serviceUuids: ['0001'],
     },
+    discoverServices: jest.fn((_uuids, callback) => callback(null, [service])),
+    connect: jest.fn(callback => callback()),
+    disconnect: jest.fn(callback => callback()),
+  });
+  return {
+    peripheral,
     service,
     write,
     notify,
@@ -52,6 +55,15 @@ describe('Noble BLE plugin notification routing', () => {
     jest.clearAllMocks();
   });
 
+  test('normalizes the platform-specific Noble MTU to a safe write capacity', async () => {
+    const { resolveNobleProtocolV2PacketCapacity } = await import('../transports/nobleBlePlugin');
+
+    expect(resolveNobleProtocolV2PacketCapacity(null, 'darwin')).toBe(192);
+    expect(resolveNobleProtocolV2PacketCapacity(244, 'darwin')).toBe(244);
+    expect(resolveNobleProtocolV2PacketCapacity(247, 'linux')).toBe(244);
+    expect(resolveNobleProtocolV2PacketCapacity(512, 'win32')).toBe(244);
+  });
+
   test('does not enumerate Find My advertisements that expose FFFD', async () => {
     jest.useFakeTimers({ doNotFake: ['performance'] });
     const oneKey = createPeripheral('onekey-device');
@@ -177,6 +189,38 @@ describe('Noble BLE plugin notification routing', () => {
     expect(result).toBe('completed');
   });
 
+  test('rejects a pending receive when the peripheral disconnects unexpectedly', async () => {
+    const device = createPeripheral('device-a');
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    await plugin.connect('device-a');
+
+    const receive = plugin.receive('device-a');
+    device.peripheral.state = 'disconnected';
+    device.peripheral.emit('disconnect', 'Remote User Terminated Connection');
+
+    await expect(receive).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.BleDeviceDisconnected,
+    });
+    await expect(plugin.receive('device-a')).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.TransportNotFound,
+    });
+  });
+
   test('disconnects an untracked peripheral when service discovery fails', async () => {
     const device = createPeripheral('device-a');
     device.peripheral.discoverServices.mockImplementation((_uuids, callback) =>
@@ -342,6 +386,33 @@ describe('Noble BLE plugin notification routing', () => {
     expect(wait).not.toHaveBeenCalled();
   });
 
+  test('uses the connected peripheral write capacity without padding', async () => {
+    const device = createPeripheral('device-a');
+    device.peripheral.mtu = process.platform === 'linux' ? 247 : 244;
+    const noble = new EventEmitter() as EventEmitter & {
+      state: string;
+      startScanning: jest.Mock;
+      stopScanning: jest.Mock;
+    };
+    noble.state = 'poweredOn';
+    noble.startScanning = jest.fn((_services, _duplicates, callback) => {
+      callback?.();
+      noble.emit('discover', device.peripheral);
+    });
+    noble.stopScanning = jest.fn(callback => callback?.());
+    jest.doMock('@stoprocent/noble', () => noble);
+
+    const { createNobleBlePlugin } = await import('../transports/nobleBlePlugin');
+    const plugin = createNobleBlePlugin();
+    await plugin.init();
+    await plugin.connect('device-a');
+
+    await plugin.send('device-a', 'aa'.repeat(245));
+
+    expect(plugin.getProtocolV2PacketCapacity?.('device-a')).toBe(244);
+    expect(device.write.write.mock.calls.map(([packet]) => packet.length)).toEqual([244, 1]);
+  });
+
   test('preserves a short final BLE packet without padding', async () => {
     const device = createPeripheral('device-a');
     const noble = new EventEmitter() as EventEmitter & {

package/src/transports/nobleBlePlugin.ts

@@ -43,6 +43,11 @@ type NobleNotificationState = {
   pendingReceivers: Set<NoblePendingReceiver>;
 };
 
+type NobleDisconnectListener = {
+  peripheral: Peripheral;
+  listener: (reason: string) => void;
+};
+
 const ONEKEY_SERVICE_UUIDS = [ONEKEY_SERVICE_UUID];
 const ONEKEY_SERVICE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_SERVICE_UUID);
 const ONEKEY_WRITE_UUID_ALIASES = createKnownBleUuidAliases(ONEKEY_WRITE_CHARACTERISTIC_UUID);
@@ -53,9 +58,27 @@ const DEVICE_SCAN_TIMEOUT = 8_000;
 const CONNECTION_TIMEOUT = 8_000;
 const SERVICE_DISCOVERY_TIMEOUT = 10_000;
 const BLE_CLEANUP_TIMEOUT = 100;
-const BLE_PACKET_SIZE = 192;
+const BLE_PACKET_SIZE_FALLBACK = 192;
+const BLE_PACKET_SIZE_MAX = 244;
+const ATT_WRITE_HEADER_SIZE = 3;
 const BLE_ENCRYPTION_ERROR_PATTERNS = [/encryption is insufficient/i, /insufficient encryption/i];
 
+export function resolveNobleProtocolV2PacketCapacity(
+  mtu: number | null | undefined,
+  platform: NodeJS.Platform = process.platform
+) {
+  if (typeof mtu !== 'number' || !Number.isFinite(mtu) || mtu <= 0) {
+    return BLE_PACKET_SIZE_FALLBACK;
+  }
+  const reportedCapacity = Math.floor(mtu);
+  const payloadCapacity =
+    platform === 'linux' ? reportedCapacity - ATT_WRITE_HEADER_SIZE : reportedCapacity;
+  if (payloadCapacity <= 0) {
+    return BLE_PACKET_SIZE_FALLBACK;
+  }
+  return Math.min(payloadCapacity, BLE_PACKET_SIZE_MAX);
+}
+
 let noble: NobleModule | null = null;
 let nobleReadyPromise: Promise<void> | null = null;
 const discoveredDevices = new Map<string, Peripheral>();
@@ -63,6 +86,7 @@ const connectedDevices = new Map<string, Peripheral>();
 const deviceCharacteristics = new Map<string, CharacteristicPair>();
 const notificationStates = new Map<string, NobleNotificationState>();
 const notificationGenerations = new Map<string, number>();
+const disconnectListeners = new Map<string, NobleDisconnectListener>();
 
 function isOneKeyPeripheral(peripheral: Peripheral) {
   const serviceUuids = peripheral.advertisement?.serviceUuids;
@@ -108,17 +132,45 @@ function createNotificationState(deviceId: string) {
   return state;
 }
 
-function clearNotificationState(deviceId: string, reason: string) {
+function clearNotificationState(deviceId: string, reason: string | Error) {
   const state = notificationStates.get(deviceId);
   if (!state) return;
 
   notificationStates.delete(deviceId);
-  const error = new Error(reason);
+  const error = reason instanceof Error ? reason : new Error(reason);
   state.pendingReceivers.forEach(receiver => receiver.reject(error));
   state.pendingReceivers.clear();
   state.queue.length = 0;
 }
 
+function removeDisconnectListener(deviceId: string) {
+  const tracked = disconnectListeners.get(deviceId);
+  if (!tracked) return;
+  tracked.peripheral.removeListener('disconnect', tracked.listener);
+  disconnectListeners.delete(deviceId);
+}
+
+function trackUnexpectedDisconnect(deviceId: string, peripheral: Peripheral) {
+  removeDisconnectListener(deviceId);
+  const listener = (reason: string) => {
+    removeDisconnectListener(deviceId);
+    if (connectedDevices.get(deviceId) !== peripheral) return;
+
+    deviceCharacteristics.get(deviceId)?.notify.removeAllListeners('data');
+    connectedDevices.delete(deviceId);
+    deviceCharacteristics.delete(deviceId);
+    clearNotificationState(
+      deviceId,
+      ERRORS.TypedError(
+        HardwareErrorCode.BleDeviceDisconnected,
+        reason || `BLE device disconnected: ${deviceId}`
+      )
+    );
+  };
+  disconnectListeners.set(deviceId, { peripheral, listener });
+  peripheral.on('disconnect', listener);
+}
+
 function waitForNobleCleanup(registerCallback: (callback: () => void) => void) {
   return new Promise<void>(resolve => {
     let completed = false;
@@ -377,6 +429,7 @@ function writeCharacteristic(
 async function disconnectDevice(uuid: string) {
   const peripheral = connectedDevices.get(uuid);
   const characteristics = deviceCharacteristics.get(uuid);
+  removeDisconnectListener(uuid);
   clearNotificationState(uuid, `BLE device disconnected: ${uuid}`);
   if (characteristics) {
     characteristics.notify.removeAllListeners('data');
@@ -425,7 +478,9 @@ export function createNobleBlePlugin(): LowlevelTransportSharedPlugin {
         await subscribeNotifications(uuid, notificationState.generation, characteristics.notify);
         connectedDevices.set(uuid, peripheral);
         deviceCharacteristics.set(uuid, characteristics);
+        trackUnexpectedDisconnect(uuid, peripheral);
       } catch (error) {
+        removeDisconnectListener(uuid);
         clearNotificationState(uuid, `BLE notification subscription failed: ${uuid}`);
         if (characteristics) {
           characteristics.notify.removeAllListeners('data');
@@ -442,6 +497,10 @@ export function createNobleBlePlugin(): LowlevelTransportSharedPlugin {
       await disconnectDevice(uuid);
     },
 
+    getProtocolV2PacketCapacity(uuid: string) {
+      return resolveNobleProtocolV2PacketCapacity(connectedDevices.get(uuid)?.mtu);
+    },
+
     async send(uuid: string, data: string, options?: { withoutResponse?: boolean }) {
       const characteristics = deviceCharacteristics.get(uuid);
       if (!characteristics) {
@@ -453,8 +512,9 @@ export function createNobleBlePlugin(): LowlevelTransportSharedPlugin {
 
       const buffer = Buffer.from(data, 'hex');
       const withoutResponse = options?.withoutResponse ?? true;
-      for (let offset = 0; offset < buffer.length; offset += BLE_PACKET_SIZE) {
-        const chunk = buffer.subarray(offset, Math.min(offset + BLE_PACKET_SIZE, buffer.length));
+      const packetCapacity = resolveNobleProtocolV2PacketCapacity(connectedDevices.get(uuid)?.mtu);
+      for (let offset = 0; offset < buffer.length; offset += packetCapacity) {
+        const chunk = buffer.subarray(offset, Math.min(offset + packetCapacity, buffer.length));
         await writeCharacteristic(characteristics.write, chunk, withoutResponse);
       }
     },