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

package/src/transports/nobleBlePlugin.ts

@@ -0,0 +1,415 @@
+import {
+  ERRORS,
+  HardwareErrorCode,
+  ONEKEY_SERVICE_UUID,
+  isOnekeyDevice,
+  wait,
+} from '@onekeyfe/hd-shared';
+
+import type { LowLevelDevice, LowlevelTransportSharedPlugin } from '@onekeyfe/hd-transport';
+import type { Characteristic, Peripheral, Service } from '@stoprocent/noble';
+
+type NobleModule = {
+  state: string;
+  startScanning(
+    serviceUUIDs: string[],
+    allowDuplicates: boolean,
+    callback?: (error?: Error) => void
+  ): void;
+  stopScanning(callback?: () => void): void;
+  on(event: 'stateChange', listener: (state: string) => void): void;
+  on(event: 'discover', listener: (peripheral: Peripheral) => void): void;
+  removeListener(event: 'stateChange', listener: (state: string) => void): void;
+  removeListener(event: 'discover', listener: (peripheral: Peripheral) => void): void;
+};
+
+type CharacteristicPair = {
+  write: Characteristic;
+  notify: Characteristic;
+};
+
+const ONEKEY_SERVICE_UUIDS = [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 = 10_000;
+const DEVICE_SCAN_TIMEOUT = 8_000;
+const CONNECTION_TIMEOUT = 8_000;
+const SERVICE_DISCOVERY_TIMEOUT = 10_000;
+const BLE_PACKET_SIZE = 192;
+const BLE_WRITE_DELAY = 5;
+const BLE_ENCRYPTION_ERROR_PATTERNS = [/encryption is insufficient/i, /insufficient encryption/i];
+
+let noble: NobleModule | null = null;
+let nobleReadyPromise: Promise<void> | null = null;
+const discoveredDevices = new Map<string, Peripheral>();
+const connectedDevices = new Map<string, Peripheral>();
+const deviceCharacteristics = new Map<string, CharacteristicPair>();
+const notificationQueue: string[] = [];
+const pendingReceivers: Array<(data: string) => void> = [];
+
+function getBleUuidKey(uuid?: string | null) {
+  const normalized = (uuid ?? '').replace(/-/g, '').toLowerCase();
+  return normalized.length >= 8 ? normalized.substring(4, 8) : normalized;
+}
+
+function isGenericBleService(uuid?: string | null) {
+  return ['1800', '1801', '180a', '180f'].includes(getBleUuidKey(uuid));
+}
+
+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)
+    );
+  });
+}
+
+function isOneKeyPeripheral(peripheral: Peripheral) {
+  const deviceName = peripheral.advertisement?.localName || null;
+  return isOnekeyDevice(deviceName, peripheral.id) || hasOneKeyAdvertisementService(peripheral);
+}
+
+function enqueueNotification(data: Buffer) {
+  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') as NobleModule;
+    } catch (error) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.BleUnsupported,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+
+  if (noble.state === 'poweredOn') return;
+
+  if (nobleReadyPromise) {
+    await nobleReadyPromise;
+    return;
+  }
+
+  nobleReadyPromise = new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      noble?.removeListener('stateChange', onStateChange);
+      reject(ERRORS.TypedError(HardwareErrorCode.BlePoweredOff, 'Bluetooth is not powered on'));
+    }, BLUETOOTH_INIT_TIMEOUT);
+
+    const onStateChange = (state: string) => {
+      if (state === 'poweredOn') {
+        clearTimeout(timeout);
+        noble?.removeListener('stateChange', onStateChange);
+        resolve();
+      } else if (state === 'unsupported') {
+        clearTimeout(timeout);
+        noble?.removeListener('stateChange', onStateChange);
+        reject(ERRORS.TypedError(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?: string) {
+  await initializeNoble();
+  if (!noble) {
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'Noble not initialized');
+  }
+
+  if (!targetDeviceId) {
+    discoveredDevices.clear();
+  }
+
+  const nobleInstance = noble;
+  return new Promise<Peripheral[]>((resolve, reject) => {
+    const found = new Map<string, Peripheral>();
+
+    const cleanup = () => {
+      clearTimeout(timeout);
+      nobleInstance.removeListener('discover', onDiscover);
+      stopScanning();
+    };
+
+    const finish = () => {
+      cleanup();
+      resolve([...found.values()]);
+    };
+
+    const onDiscover = (peripheral: 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?: Error) => {
+      if (error) {
+        cleanup();
+        reject(ERRORS.TypedError(HardwareErrorCode.BleScanError, error.message));
+      }
+    });
+  });
+}
+
+function connectPeripheral(peripheral: Peripheral) {
+  if (peripheral.state === 'connected') return Promise.resolve();
+
+  return new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError, 'Connection timeout'));
+    }, CONNECTION_TIMEOUT);
+
+    peripheral.connect((error?: Error) => {
+      clearTimeout(timeout);
+      if (error) {
+        reject(ERRORS.TypedError(HardwareErrorCode.BleConnectedError, error.message));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+async function discoverCharacteristics(peripheral: Peripheral): Promise<CharacteristicPair> {
+  const services = await new Promise<Service[]>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, 'Service discovery timeout'));
+    }, SERVICE_DISCOVERY_TIMEOUT);
+
+    peripheral.discoverServices([], (error, discoveredServices) => {
+      clearTimeout(timeout);
+      if (error) {
+        reject(ERRORS.TypedError(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 ERRORS.TypedError(HardwareErrorCode.BleServiceNotFound, 'No BLE service found');
+  }
+  const selectedService = service;
+
+  const characteristics = await new Promise<Characteristic[]>((resolve, reject) => {
+    selectedService.discoverCharacteristics([], (error, discoveredCharacteristics) => {
+      if (error) {
+        reject(ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotFound, error.message));
+        return;
+      }
+      resolve(discoveredCharacteristics);
+    });
+  });
+
+  let writeCharacteristic: Characteristic | undefined;
+  let notifyCharacteristic: Characteristic | undefined;
+  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 ERRORS.TypedError(
+      HardwareErrorCode.BleCharacteristicNotFound,
+      'Required OneKey BLE characteristics not found'
+    );
+  }
+
+  return {
+    write: writeCharacteristic,
+    notify: notifyCharacteristic,
+  };
+}
+
+function subscribeNotifications(deviceId: string, notifyCharacteristic: Characteristic) {
+  return new Promise<void>(resolve => {
+    notifyCharacteristic.unsubscribe(() => resolve());
+  })
+    .then(
+      () =>
+        new Promise<void>((resolve, reject) => {
+          notifyCharacteristic.subscribe((error?: Error) => {
+            if (error) {
+              const errorMessage = error.message || String(error);
+              if (BLE_ENCRYPTION_ERROR_PATTERNS.some(pattern => pattern.test(errorMessage))) {
+                reject(
+                  ERRORS.TypedError(
+                    HardwareErrorCode.BleDeviceNotBonded,
+                    `BLE device ${deviceId} is not paired or the encrypted link is not ready: ${errorMessage}`
+                  )
+                );
+                return;
+              }
+              reject(
+                ERRORS.TypedError(
+                  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 ERRORS.TypedError(HardwareErrorCode.BleCharacteristicNotifyChangeFailure);
+    });
+}
+
+function writeCharacteristic(characteristic: Characteristic, buffer: Buffer) {
+  return new Promise<void>((resolve, reject) => {
+    characteristic.write(buffer, true, (error?: Error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+async function disconnectDevice(uuid: string) {
+  const peripheral = connectedDevices.get(uuid);
+  const characteristics = deviceCharacteristics.get(uuid);
+  if (characteristics) {
+    characteristics.notify.removeAllListeners('data');
+    await new Promise<void>(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<void>(resolve => {
+    peripheral.disconnect(() => resolve());
+  });
+}
+
+export function createNobleBlePlugin(): LowlevelTransportSharedPlugin {
+  return {
+    version: 'OneKey-CLI-Noble-1.0',
+
+    async init() {
+      await initializeNoble();
+    },
+
+    async enumerate(): Promise<LowLevelDevice[]> {
+      const devices = await scanDevices();
+      return devices.map(device => ({
+        commType: 'ble',
+        id: device.id,
+        name: device.advertisement?.localName || 'Unknown BLE Device',
+      }));
+    },
+
+    async connect(uuid: string) {
+      let peripheral = discoveredDevices.get(uuid);
+      if (!peripheral) {
+        [peripheral] = await scanDevices(uuid);
+      }
+      if (!peripheral) {
+        throw ERRORS.TypedError(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: string) {
+      await disconnectDevice(uuid);
+    },
+
+    async send(uuid: string, data: string) {
+      const characteristics = deviceCharacteristics.get(uuid);
+      if (!characteristics) {
+        throw ERRORS.TypedError(
+          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 wait(BLE_WRITE_DELAY);
+        }
+      }
+    },
+
+    async receive() {
+      const queued = notificationQueue.shift();
+      if (queued !== undefined) return queued;
+      return new Promise<string>(resolve => {
+        pendingReceivers.push(resolve);
+      });
+    },
+  };
+}