@onekeyfe/hardware-cli 1.2.0-alpha.2 → 1.2.0-alpha.4

package/dist/transports/nobleBlePlugin.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNobleBlePlugin = void 0;
+const hd_shared_1 = require("@onekeyfe/hd-shared");
+const ONEKEY_SERVICE_UUIDS = [hd_shared_1.ONEKEY_SERVICE_UUID];
+const PRO2_ADVERTISEMENT_SERVICE_UUID_KEYS = new Set(['fffd']);
+const NORMALIZED_WRITE_UUID = '0002';
+const NORMALIZED_NOTIFY_UUID = '0003';
+const NORMALIZED_ONEKEY_SERVICE_UUIDS = new Set([
+    ...ONEKEY_SERVICE_UUIDS.map(uuid => getBleUuidKey(uuid)),
+    '0001',
+]);
+const BLUETOOTH_INIT_TIMEOUT = 10000;
+const DEVICE_SCAN_TIMEOUT = 8000;
+const CONNECTION_TIMEOUT = 8000;
+const SERVICE_DISCOVERY_TIMEOUT = 10000;
+const BLE_PACKET_SIZE = 192;
+const BLE_WRITE_DELAY = 5;
+const BLE_ENCRYPTION_ERROR_PATTERNS = [/encryption is insufficient/i, /insufficient encryption/i];
+let noble = null;
+let nobleReadyPromise = null;
+const discoveredDevices = new Map();
+const connectedDevices = new Map();
+const deviceCharacteristics = new Map();
+const notificationQueue = [];
+const pendingReceivers = [];
+function getBleUuidKey(uuid) {
+    const normalized = (uuid ?? '').replace(/-/g, '').toLowerCase();
+    return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
+}
+function isGenericBleService(uuid) {
+    return ['1800', '1801', '180a', '180f'].includes(getBleUuidKey(uuid));
+}
+function hasOneKeyAdvertisementService(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));
+    });
+}
+function isOneKeyPeripheral(peripheral) {
+    const deviceName = peripheral.advertisement?.localName || null;
+    return (0, hd_shared_1.isOnekeyDevice)(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
+}
+function enqueueNotification(data) {
+    const hex = data.toString('hex');
+    const receiver = pendingReceivers.shift();
+    if (receiver) {
+        receiver(hex);
+        return;
+    }
+    notificationQueue.push(hex);
+}
+async function initializeNoble() {
+    if (!noble) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires, global-require
+            noble = require('@stoprocent/noble');
+        }
+        catch (error) {
+            throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleUnsupported, error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (noble.state === 'poweredOn')
+        return;
+    if (nobleReadyPromise) {
+        await nobleReadyPromise;
+        return;
+    }
+    nobleReadyPromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            noble?.removeListener('stateChange', onStateChange);
+            reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BlePoweredOff, 'Bluetooth is not powered on'));
+        }, BLUETOOTH_INIT_TIMEOUT);
+        const onStateChange = (state) => {
+            if (state === 'poweredOn') {
+                clearTimeout(timeout);
+                noble?.removeListener('stateChange', onStateChange);
+                resolve();
+            }
+            else if (state === 'unsupported') {
+                clearTimeout(timeout);
+                noble?.removeListener('stateChange', onStateChange);
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleUnsupported));
+            }
+        };
+        noble?.on('stateChange', onStateChange);
+    }).finally(() => {
+        nobleReadyPromise = null;
+    });
+    await nobleReadyPromise;
+}
+function stopScanning() {
+    try {
+        noble?.stopScanning();
+    }
+    catch {
+        // ignore best-effort scan cleanup
+    }
+}
+async function scanDevices(targetDeviceId) {
+    await initializeNoble();
+    if (!noble) {
+        throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.RuntimeError, 'Noble not initialized');
+    }
+    if (!targetDeviceId) {
+        discoveredDevices.clear();
+    }
+    const nobleInstance = noble;
+    return new Promise((resolve, reject) => {
+        const found = new Map();
+        const cleanup = () => {
+            clearTimeout(timeout);
+            nobleInstance.removeListener('discover', onDiscover);
+            stopScanning();
+        };
+        const finish = () => {
+            cleanup();
+            resolve([...found.values()]);
+        };
+        const onDiscover = (peripheral) => {
+            if (targetDeviceId && peripheral.id !== targetDeviceId)
+                return;
+            if (!targetDeviceId && !isOneKeyPeripheral(peripheral))
+                return;
+            discoveredDevices.set(peripheral.id, peripheral);
+            found.set(peripheral.id, peripheral);
+            if (targetDeviceId) {
+                finish();
+            }
+        };
+        const timeout = setTimeout(finish, DEVICE_SCAN_TIMEOUT);
+        nobleInstance.on('discover', onDiscover);
+        nobleInstance.startScanning([], false, (error) => {
+            if (error) {
+                cleanup();
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleScanError, error.message));
+            }
+        });
+    });
+}
+function connectPeripheral(peripheral) {
+    if (peripheral.state === 'connected')
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleConnectedError, 'Connection timeout'));
+        }, CONNECTION_TIMEOUT);
+        peripheral.connect((error) => {
+            clearTimeout(timeout);
+            if (error) {
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleConnectedError, error.message));
+                return;
+            }
+            resolve();
+        });
+    });
+}
+async function discoverCharacteristics(peripheral) {
+    const services = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleServiceNotFound, 'Service discovery timeout'));
+        }, SERVICE_DISCOVERY_TIMEOUT);
+        peripheral.discoverServices([], (error, discoveredServices) => {
+            clearTimeout(timeout);
+            if (error) {
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleServiceNotFound, error.message));
+                return;
+            }
+            resolve(discoveredServices);
+        });
+    });
+    let service = services.find(s => NORMALIZED_ONEKEY_SERVICE_UUIDS.has(getBleUuidKey(s.uuid)));
+    if (!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 hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleServiceNotFound, 'No BLE service found');
+    }
+    const selectedService = service;
+    const characteristics = await new Promise((resolve, reject) => {
+        selectedService.discoverCharacteristics([], (error, discoveredCharacteristics) => {
+            if (error) {
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleCharacteristicNotFound, error.message));
+                return;
+            }
+            resolve(discoveredCharacteristics);
+        });
+    });
+    let writeCharacteristic;
+    let notifyCharacteristic;
+    for (const characteristic of characteristics) {
+        const uuidKey = getBleUuidKey(characteristic.uuid);
+        if (uuidKey === NORMALIZED_WRITE_UUID) {
+            writeCharacteristic = characteristic;
+        }
+        else if (uuidKey === NORMALIZED_NOTIFY_UUID) {
+            notifyCharacteristic = characteristic;
+        }
+    }
+    if (!writeCharacteristic || !notifyCharacteristic) {
+        throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleCharacteristicNotFound, 'Required OneKey BLE characteristics not found');
+    }
+    return {
+        write: writeCharacteristic,
+        notify: notifyCharacteristic,
+    };
+}
+function subscribeNotifications(deviceId, notifyCharacteristic) {
+    return new Promise(resolve => {
+        notifyCharacteristic.unsubscribe(() => resolve());
+    })
+        .then(() => new Promise((resolve, reject) => {
+        notifyCharacteristic.subscribe((error) => {
+            if (error) {
+                const errorMessage = error.message || String(error);
+                if (BLE_ENCRYPTION_ERROR_PATTERNS.some(pattern => pattern.test(errorMessage))) {
+                    reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleDeviceNotBonded, `BLE device ${deviceId} is not paired or the encrypted link is not ready: ${errorMessage}`));
+                    return;
+                }
+                reject(hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleCharacteristicNotifyChangeFailure, `Failed to subscribe notifications for ${deviceId}: ${errorMessage}`));
+                return;
+            }
+            resolve();
+        });
+    }))
+        .then(() => {
+        notifyCharacteristic.removeAllListeners('data');
+        notifyCharacteristic.on('data', enqueueNotification);
+    })
+        .catch(error => {
+        notifyCharacteristic.removeAllListeners('data');
+        if (error) {
+            throw error;
+        }
+        throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleCharacteristicNotifyChangeFailure);
+    });
+}
+function writeCharacteristic(characteristic, buffer) {
+    return new Promise((resolve, reject) => {
+        characteristic.write(buffer, true, (error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+async function disconnectDevice(uuid) {
+    const peripheral = connectedDevices.get(uuid);
+    const characteristics = deviceCharacteristics.get(uuid);
+    if (characteristics) {
+        characteristics.notify.removeAllListeners('data');
+        await new Promise(resolve => {
+            characteristics.notify.unsubscribe(() => resolve());
+        });
+    }
+    connectedDevices.delete(uuid);
+    deviceCharacteristics.delete(uuid);
+    notificationQueue.length = 0;
+    pendingReceivers.splice(0).forEach(resolve => resolve(''));
+    if (!peripheral || peripheral.state === 'disconnected')
+        return;
+    await new Promise(resolve => {
+        peripheral.disconnect(() => resolve());
+    });
+}
+function createNobleBlePlugin() {
+    return {
+        version: 'OneKey-CLI-Noble-1.0',
+        async init() {
+            await initializeNoble();
+        },
+        async enumerate() {
+            const devices = await scanDevices();
+            return devices.map(device => ({
+                commType: 'ble',
+                id: device.id,
+                name: device.advertisement?.localName || 'Unknown BLE Device',
+            }));
+        },
+        async connect(uuid) {
+            let peripheral = discoveredDevices.get(uuid);
+            if (!peripheral) {
+                [peripheral] = await scanDevices(uuid);
+            }
+            if (!peripheral) {
+                throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.DeviceNotFound, `BLE device not found: ${uuid}`);
+            }
+            await connectPeripheral(peripheral);
+            const characteristics = await discoverCharacteristics(peripheral);
+            await subscribeNotifications(uuid, characteristics.notify);
+            connectedDevices.set(uuid, peripheral);
+            deviceCharacteristics.set(uuid, characteristics);
+        },
+        async disconnect(uuid) {
+            await disconnectDevice(uuid);
+        },
+        async send(uuid, data) {
+            const characteristics = deviceCharacteristics.get(uuid);
+            if (!characteristics) {
+                throw hd_shared_1.ERRORS.TypedError(hd_shared_1.HardwareErrorCode.BleCharacteristicNotFound, `BLE device is not connected: ${uuid}`);
+            }
+            const buffer = Buffer.from(data, 'hex');
+            for (let offset = 0; offset < buffer.length; offset += BLE_PACKET_SIZE) {
+                const chunk = buffer.subarray(offset, Math.min(offset + BLE_PACKET_SIZE, buffer.length));
+                await writeCharacteristic(characteristics.write, chunk);
+                if (offset + BLE_PACKET_SIZE < buffer.length) {
+                    await (0, hd_shared_1.wait)(BLE_WRITE_DELAY);
+                }
+            }
+        },
+        async receive() {
+            const queued = notificationQueue.shift();
+            if (queued !== undefined)
+                return queued;
+            return new Promise(resolve => {
+                pendingReceivers.push(resolve);
+            });
+        },
+    };
+}
+exports.createNobleBlePlugin = createNobleBlePlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hardware-cli",
-  "version": "1.2.0-alpha.2",
+  "version": "1.2.0-alpha.4",
   "description": "OneKey hardware wallet CLI for testing device communication",
   "author": "OneKey",
   "license": "Apache-2.0",
@@ -30,11 +30,12 @@
     "test": "jest"
   },
   "dependencies": {
-    "@onekeyfe/hd-common-connect-sdk": "1.2.0-alpha.2",
-    "@onekeyfe/hd-core": "1.2.0-alpha.2",
-    "@onekeyfe/hd-shared": "1.2.0-alpha.2",
-    "@onekeyfe/hd-transport-usb": "1.2.0-alpha.2",
+    "@onekeyfe/hd-common-connect-sdk": "1.2.0-alpha.4",
+    "@onekeyfe/hd-core": "1.2.0-alpha.4",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.4",
+    "@onekeyfe/hd-transport-usb": "1.2.0-alpha.4",
+    "@stoprocent/noble": "2.3.16",
     "commander": "^12.0.0"
   },
-  "gitHead": "6c183b7f7027f4b4d3db4f427f6360351a6c6680"
+  "gitHead": "6f83d130f022a75003385bc4b2386cd0b2b539b5"
 }