@onekeyfe/hd-transport-electron 1.0.34-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { WebContents } from 'electron';
+
+interface BluetoothPairingDetails {
+    deviceId: string;
+    pairingKind: 'confirm' | 'confirmPin' | 'providePin';
+    pin?: string;
+}
+interface BluetoothPairingResponse {
+    confirmed: boolean;
+    pin?: string;
+}
+interface BluetoothDevice {
+    deviceId: string;
+    deviceName: string | null;
+}
+interface BleDevice {
+    id: string;
+    name: string;
+    paired?: boolean;
+}
+interface BleEnumerateOptions {
+    timeout?: number;
+    forceScan?: boolean;
+}
+interface ElectronBleAPI {
+    enumerate(options?: BleEnumerateOptions): Promise<BleDevice[]>;
+    onBleSelect(callback: (devices: BleDevice[]) => void): () => void;
+    selectBleDevice(deviceId: string): void;
+    cancelBleRequest(): void;
+    onBlePairingRequest(callback: (details: BluetoothPairingDetails) => void): () => void;
+    respondToPairing(response: BluetoothPairingResponse): void;
+    onBleDeviceDisconnected(callback: (device: {
+        id: string;
+        name: string | null;
+    }) => void): () => void;
+}
+declare const IPC_CHANNELS: {
+    readonly BLE_ENUMERATE: "ble-enumerate";
+    readonly BLE_ENUMERATE_RESULT: "ble-enumerate-result";
+    readonly BLE_SCAN_TIMEOUT: "ble-scan-timeout";
+    readonly BLE_SELECT: "ble-select";
+    readonly BLE_SELECT_RESULT: "ble-select-result";
+    readonly BLE_PAIRING_REQUEST: "ble-pairing-request";
+    readonly BLE_PAIRING_RESPONSE: "ble-pairing-response";
+};
+declare global {
+    interface Window {
+        electronBleAPI: ElectronBleAPI;
+    }
+}
+
+declare function initElectronBleBridge(webContents: WebContents): void;
+
+export { BleDevice, BleEnumerateOptions, BluetoothDevice, BluetoothPairingDetails, BluetoothPairingResponse, ElectronBleAPI, IPC_CHANNELS, initElectronBleBridge };

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,UAAU,CAAC;AAGjE,cAAc,SAAS,CAAC;AAmBxB,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,QAmK7D"}

package/dist/index.js

@@ -0,0 +1,123 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hdShared = require('@onekeyfe/hd-shared');
+
+const IPC_CHANNELS = {
+    BLE_ENUMERATE: 'ble-enumerate',
+    BLE_ENUMERATE_RESULT: 'ble-enumerate-result',
+    BLE_SCAN_TIMEOUT: 'ble-scan-timeout',
+    BLE_SELECT: 'ble-select',
+    BLE_SELECT_RESULT: 'ble-select-result',
+    BLE_PAIRING_REQUEST: 'ble-pairing-request',
+    BLE_PAIRING_RESPONSE: 'ble-pairing-response',
+};
+
+function initElectronBleBridge(webContents) {
+    const electron = require('electron');
+    const { ipcMain } = electron;
+    const logger = require('electron-log');
+    const { session } = webContents;
+    let selectBluetoothCallback = null;
+    let bluetoothPairingCallback = null;
+    let preSelectedDeviceId = null;
+    let lastLoggedDeviceList = '';
+    const logDeviceListIfChanged = (deviceList) => {
+        const sortedDevices = [...deviceList].sort((a, b) => a.deviceId.localeCompare(b.deviceId));
+        const deviceListString = JSON.stringify(sortedDevices.map(d => ({
+            deviceId: d.deviceId,
+            deviceName: d.deviceName,
+        })));
+        if (deviceListString !== lastLoggedDeviceList) {
+            logger.info('[Main] Raw device list:', deviceList);
+            lastLoggedDeviceList = deviceListString;
+            return true;
+        }
+        return false;
+    };
+    webContents.on('select-bluetooth-device', (event, deviceList, callback) => {
+        event.preventDefault();
+        logger.info('[Main] select-bluetooth-device event triggered');
+        const deviceListChanged = logDeviceListIfChanged(deviceList);
+        if (!deviceListChanged) {
+            logger.info('[Main] Device list unchanged, continuing...');
+        }
+        logger.info('[Main] Pre-selected device:', preSelectedDeviceId);
+        selectBluetoothCallback = callback;
+        if (!deviceList.length) {
+            logger.info('[Main] Empty device list, waiting for more devices...');
+            return;
+        }
+        const filteredDevices = deviceList
+            .filter(d => hdShared.isOnekeyDevice(d.deviceName))
+            .map(d => ({ id: d.deviceId, name: d.deviceName }));
+        if (filteredDevices.length > 0) {
+            if (deviceListChanged) {
+                logger.info('[Main] Found OneKey devices:', filteredDevices);
+            }
+            if (preSelectedDeviceId) {
+                logger.info('[Main] Set Pre-selected device:', preSelectedDeviceId);
+                const targetDevice = filteredDevices.find(d => d.id === preSelectedDeviceId);
+                if (targetDevice) {
+                    logger.info('[Main] Found pre-selected device:', targetDevice);
+                    callback(targetDevice.id);
+                    selectBluetoothCallback = null;
+                    return;
+                }
+            }
+            webContents.send(hdShared.EOneKeyBleMessageKeys.BLE_SELECT, filteredDevices);
+        }
+        else if (deviceListChanged) {
+            logger.info('[Main] No OneKey devices in this batch, continue scanning...');
+        }
+    });
+    ipcMain.on(hdShared.EOneKeyBleMessageKeys.BLE_PRE_SELECT, (_event, deviceId) => {
+        logger.info('[Main] Pre-selecting device:', deviceId);
+        preSelectedDeviceId = deviceId;
+        lastLoggedDeviceList = '';
+    });
+    ipcMain.on(hdShared.EOneKeyBleMessageKeys.BLE_CLEAR_PRE_SELECT, () => {
+        logger.info('[Main] Clearing pre-selected device');
+        preSelectedDeviceId = null;
+        lastLoggedDeviceList = '';
+    });
+    ipcMain.on(hdShared.EOneKeyBleMessageKeys.BLE_SELECT_RESULT, (_event, deviceId) => {
+        logger.info('[Main] Received ble-select-result:', deviceId);
+        if (selectBluetoothCallback) {
+            selectBluetoothCallback(deviceId || '');
+            selectBluetoothCallback = null;
+        }
+    });
+    ipcMain.on(hdShared.EOneKeyBleMessageKeys.BLE_CANCEL_REQUEST, () => {
+        logger.info('[Main] Received cancel-bluetooth-request');
+        if (selectBluetoothCallback) {
+            selectBluetoothCallback('');
+            selectBluetoothCallback = null;
+        }
+    });
+    ipcMain.on(hdShared.EOneKeyBleMessageKeys.BLE_STOP_SCAN, () => {
+        logger.info('[Main] Received stop BLE scan request');
+        if (selectBluetoothCallback) {
+            selectBluetoothCallback('');
+            selectBluetoothCallback = null;
+        }
+    });
+    session.setBluetoothPairingHandler((details, callback) => {
+        logger.info('[Main] Bluetooth pairing request received:', details);
+        logger.info('[Main] Pairing device ID:', details.deviceId);
+        logger.info('[Main] Pairing type:', details.pairingKind);
+        bluetoothPairingCallback = callback;
+        webContents.send(hdShared.EOneKeyBleMessageKeys.BLE_PAIRING_REQUEST, details);
+    });
+    logger.info('[Main] Bluetooth pairing handler registered');
+    ipcMain.on(hdShared.EOneKeyBleMessageKeys.BLE_PAIRING_RESPONSE, (_event, response) => {
+        logger.info('[Main] Received pairing response:', response);
+        if (bluetoothPairingCallback) {
+            bluetoothPairingCallback(response);
+        }
+    });
+}
+
+exports.IPC_CHANNELS = IPC_CHANNELS;
+exports.initElectronBleBridge = initElectronBleBridge;

package/dist/types.d.ts

@@ -0,0 +1,49 @@
+export interface BluetoothPairingDetails {
+    deviceId: string;
+    pairingKind: 'confirm' | 'confirmPin' | 'providePin';
+    pin?: string;
+}
+export interface BluetoothPairingResponse {
+    confirmed: boolean;
+    pin?: string;
+}
+export interface BluetoothDevice {
+    deviceId: string;
+    deviceName: string | null;
+}
+export interface BleDevice {
+    id: string;
+    name: string;
+    paired?: boolean;
+}
+export interface BleEnumerateOptions {
+    timeout?: number;
+    forceScan?: boolean;
+}
+export interface ElectronBleAPI {
+    enumerate(options?: BleEnumerateOptions): Promise<BleDevice[]>;
+    onBleSelect(callback: (devices: BleDevice[]) => void): () => void;
+    selectBleDevice(deviceId: string): void;
+    cancelBleRequest(): void;
+    onBlePairingRequest(callback: (details: BluetoothPairingDetails) => void): () => void;
+    respondToPairing(response: BluetoothPairingResponse): void;
+    onBleDeviceDisconnected(callback: (device: {
+        id: string;
+        name: string | null;
+    }) => void): () => void;
+}
+export declare const IPC_CHANNELS: {
+    readonly BLE_ENUMERATE: "ble-enumerate";
+    readonly BLE_ENUMERATE_RESULT: "ble-enumerate-result";
+    readonly BLE_SCAN_TIMEOUT: "ble-scan-timeout";
+    readonly BLE_SELECT: "ble-select";
+    readonly BLE_SELECT_RESULT: "ble-select-result";
+    readonly BLE_PAIRING_REQUEST: "ble-pairing-request";
+    readonly BLE_PAIRING_RESPONSE: "ble-pairing-response";
+};
+declare global {
+    interface Window {
+        electronBleAPI: ElectronBleAPI;
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,SAAS,GAAG,YAAY,GAAG,YAAY,CAAC;IACrD,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,OAAO,CAAC;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAIlC,OAAO,CAAC,EAAE,MAAM,CAAC;IAIjB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAE7B,SAAS,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAG/D,WAAW,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAClE,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,gBAAgB,IAAI,IAAI,CAAC;IAGzB,mBAAmB,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IACtF,gBAAgB,CAAC,QAAQ,EAAE,wBAAwB,GAAG,IAAI,CAAC;IAG3D,uBAAuB,CACrB,QAAQ,EAAE,CAAC,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,KAAK,IAAI,GAC9D,MAAM,IAAI,CAAC;CACf;AAGD,eAAO,MAAM,YAAY;;;;;;;;CAQf,CAAC;AAEX,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,cAAc,EAAE,cAAc,CAAC;KAChC;CACF"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@onekeyfe/hd-transport-electron",
+  "version": "1.0.34-alpha.0",
+  "author": "OneKey",
+  "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneKeyHQ/hardware-js-sdk.git"
+  },
+  "scripts": {
+    "dev": "rimraf dist && rollup -c ../../build/rollup.config.js -w",
+    "build": "rimraf dist && rollup -c ../../build/rollup.config.js",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "sideEffects": false,
+  "peerDependencies": {
+    "@onekeyfe/hd-transport-web-device": "^1.0.28",
+    "electron": ">=25.0.0",
+    "electron-log": ">=4.0.0"
+  },
+  "dependencies": {
+    "@onekeyfe/hd-shared": "^1.0.34-alpha.0"
+  },
+  "devDependencies": {
+    "@types/web-bluetooth": "^0.0.17",
+    "electron": "^25.0.0",
+    "typescript": "^5.3.3"
+  },
+  "gitHead": "a910879dea6198bd96016aec81429f31b9692bf1"
+}

package/src/index.ts

@@ -0,0 +1,195 @@
+/*
+ * Electron BLE bridge helper
+ * Running in Main process only. At runtime it dynamically requires 'electron',
+ * so projects that don't use Electron will tree-shake this file out and won't bundle electron.
+ */
+
+/* eslint-disable @typescript-eslint/no-var-requires, @typescript-eslint/ban-ts-comment, import/no-extraneous-dependencies, global-require, import/no-unresolved */
+
+import { isOnekeyDevice, EOneKeyBleMessageKeys } from '@onekeyfe/hd-shared';
+import type { WebContents, IpcMainEvent, Event } from 'electron';
+
+// Export all type definitions
+export * from './types';
+
+// Internal interface definitions
+interface BluetoothDevice {
+  deviceId: string;
+  deviceName: string;
+}
+
+interface BluetoothPairingDetails {
+  deviceId: string;
+  pairingKind: 'confirm' | 'confirmPin' | 'providePin';
+  pin?: string;
+}
+
+type BluetoothPairingResponse = {
+  confirmed: boolean;
+  pin?: string;
+};
+
+export function initElectronBleBridge(webContents: WebContents) {
+  // @ts-ignore – electron is only available at runtime within an Electron app
+  const electron = require('electron');
+  const { ipcMain } = electron;
+
+  // @ts-ignore – electron-log is only available at runtime within an Electron app
+  const logger = require('electron-log');
+
+  const { session } = webContents;
+
+  let selectBluetoothCallback: ((deviceId: string) => void) | null = null;
+  let bluetoothPairingCallback: ((response: BluetoothPairingResponse) => void) | null = null;
+  let preSelectedDeviceId: string | null = null;
+
+  // Track last logged device list to avoid duplicate logs
+  let lastLoggedDeviceList = '';
+
+  // Helper function to log device list only if changed
+  const logDeviceListIfChanged = (deviceList: BluetoothDevice[]): boolean => {
+    // Sort devices by deviceId to ensure consistent comparison regardless of order
+    const sortedDevices = [...deviceList].sort((a, b) => a.deviceId.localeCompare(b.deviceId));
+    const deviceListString = JSON.stringify(
+      sortedDevices.map(d => ({
+        deviceId: d.deviceId,
+        deviceName: d.deviceName,
+      }))
+    );
+
+    // Only log if the device list has changed
+    if (deviceListString !== lastLoggedDeviceList) {
+      logger.info('[Main] Raw device list:', deviceList);
+      lastLoggedDeviceList = deviceListString;
+      return true; // Logged
+    }
+
+    return false; // Not logged (duplicate)
+  };
+
+  // 1️⃣ Device selection events
+  webContents.on(
+    'select-bluetooth-device',
+    (event: Event, deviceList: BluetoothDevice[], callback: (deviceId: string) => void) => {
+      event.preventDefault();
+
+      logger.info('[Main] select-bluetooth-device event triggered');
+
+      // Use helper function to log device list only if changed
+      const deviceListChanged = logDeviceListIfChanged(deviceList);
+
+      if (!deviceListChanged) {
+        // If device list hasn't changed, just log a simple message
+        logger.info('[Main] Device list unchanged, continuing...');
+      }
+
+      logger.info('[Main] Pre-selected device:', preSelectedDeviceId);
+
+      // Save callback for later use
+      selectBluetoothCallback = callback;
+
+      // If device list is empty, wait for next event
+      if (!deviceList.length) {
+        logger.info('[Main] Empty device list, waiting for more devices...');
+        return;
+      }
+
+      // Filter OneKey devices and send to renderer process
+      const filteredDevices = deviceList
+        .filter(d => isOnekeyDevice(d.deviceName))
+        .map(d => ({ id: d.deviceId, name: d.deviceName }));
+
+      if (filteredDevices.length > 0) {
+        // Only log found devices if the device list actually changed
+        if (deviceListChanged) {
+          logger.info('[Main] Found OneKey devices:', filteredDevices);
+        }
+
+        // If there's a pre-selected device, select it directly
+        if (preSelectedDeviceId) {
+          logger.info('[Main] Set Pre-selected device:', preSelectedDeviceId);
+          const targetDevice = filteredDevices.find(d => d.id === preSelectedDeviceId);
+          if (targetDevice) {
+            logger.info('[Main] Found pre-selected device:', targetDevice);
+            callback(targetDevice.id);
+            selectBluetoothCallback = null;
+            return;
+          }
+        }
+
+        // Continuously send newly discovered devices
+        webContents.send(EOneKeyBleMessageKeys.BLE_SELECT, filteredDevices);
+      } else if (deviceListChanged) {
+        logger.info('[Main] No OneKey devices in this batch, continue scanning...');
+      }
+    }
+  );
+
+  // Device pre-selection related
+  ipcMain.on(EOneKeyBleMessageKeys.BLE_PRE_SELECT, (_event: IpcMainEvent, deviceId: string) => {
+    logger.info('[Main] Pre-selecting device:', deviceId);
+    preSelectedDeviceId = deviceId;
+    // Reset device list tracking when pre-selecting
+    lastLoggedDeviceList = '';
+  });
+
+  ipcMain.on(EOneKeyBleMessageKeys.BLE_CLEAR_PRE_SELECT, () => {
+    logger.info('[Main] Clearing pre-selected device');
+    preSelectedDeviceId = null;
+    // Reset device list tracking when clearing pre-selection
+    lastLoggedDeviceList = '';
+  });
+
+  // Renderer process returns selection result
+  ipcMain.on(EOneKeyBleMessageKeys.BLE_SELECT_RESULT, (_event: IpcMainEvent, deviceId?: string) => {
+    logger.info('[Main] Received ble-select-result:', deviceId);
+    if (selectBluetoothCallback) {
+      selectBluetoothCallback(deviceId || '');
+      selectBluetoothCallback = null;
+    }
+  });
+
+  // Allow user to cancel
+  ipcMain.on(EOneKeyBleMessageKeys.BLE_CANCEL_REQUEST, () => {
+    logger.info('[Main] Received cancel-bluetooth-request');
+    if (selectBluetoothCallback) {
+      selectBluetoothCallback('');
+      selectBluetoothCallback = null;
+    }
+  });
+
+  // Handle stop scan requests
+  ipcMain.on(EOneKeyBleMessageKeys.BLE_STOP_SCAN, () => {
+    logger.info('[Main] Received stop BLE scan request');
+    if (selectBluetoothCallback) {
+      selectBluetoothCallback('');
+      selectBluetoothCallback = null;
+    }
+  });
+
+  // 2️⃣ PIN / Confirm handling
+  session.setBluetoothPairingHandler(
+    (details: BluetoothPairingDetails, callback: (response: BluetoothPairingResponse) => void) => {
+      logger.info('[Main] Bluetooth pairing request received:', details);
+      logger.info('[Main] Pairing device ID:', details.deviceId);
+      logger.info('[Main] Pairing type:', details.pairingKind);
+      bluetoothPairingCallback = callback;
+      webContents.send(EOneKeyBleMessageKeys.BLE_PAIRING_REQUEST, details);
+    }
+  );
+  logger.info('[Main] Bluetooth pairing handler registered');
+
+  // 3️⃣ Device disconnect handling
+  // Note: Electron doesn't provide a direct bluetooth-device-disconnected event
+  // Device disconnection should be handled at the Web Bluetooth API level in the renderer process
+
+  ipcMain.on(
+    EOneKeyBleMessageKeys.BLE_PAIRING_RESPONSE,
+    (_event: IpcMainEvent, response: BluetoothPairingResponse) => {
+      logger.info('[Main] Received pairing response:', response);
+      if (bluetoothPairingCallback) {
+        bluetoothPairingCallback(response);
+      }
+    }
+  );
+}

package/src/types.ts

@@ -0,0 +1,68 @@
+export interface BluetoothPairingDetails {
+  deviceId: string;
+  pairingKind: 'confirm' | 'confirmPin' | 'providePin';
+  pin?: string;
+}
+
+export interface BluetoothPairingResponse {
+  confirmed: boolean;
+  pin?: string;
+}
+
+export interface BluetoothDevice {
+  deviceId: string;
+  deviceName: string | null;
+}
+
+export interface BleDevice {
+  id: string;
+  name: string;
+  paired?: boolean;
+}
+
+export interface BleEnumerateOptions {
+  /**
+   * Scan timeout in milliseconds (default: 30s)
+   */
+  timeout?: number;
+  /**
+   * Whether to force a new scan even if paired devices exist
+   */
+  forceScan?: boolean;
+}
+
+export interface ElectronBleAPI {
+  // Device enumeration
+  enumerate(options?: BleEnumerateOptions): Promise<BleDevice[]>;
+
+  // Device selection
+  onBleSelect(callback: (devices: BleDevice[]) => void): () => void;
+  selectBleDevice(deviceId: string): void;
+  cancelBleRequest(): void;
+
+  // Device pairing
+  onBlePairingRequest(callback: (details: BluetoothPairingDetails) => void): () => void;
+  respondToPairing(response: BluetoothPairingResponse): void;
+
+  // Device disconnection
+  onBleDeviceDisconnected(
+    callback: (device: { id: string; name: string | null }) => void
+  ): () => void;
+}
+
+// IPC Channel Names
+export const IPC_CHANNELS = {
+  BLE_ENUMERATE: 'ble-enumerate',
+  BLE_ENUMERATE_RESULT: 'ble-enumerate-result',
+  BLE_SCAN_TIMEOUT: 'ble-scan-timeout',
+  BLE_SELECT: 'ble-select',
+  BLE_SELECT_RESULT: 'ble-select-result',
+  BLE_PAIRING_REQUEST: 'ble-pairing-request',
+  BLE_PAIRING_RESPONSE: 'ble-pairing-response',
+} as const;
+
+declare global {
+  interface Window {
+    electronBleAPI: ElectronBleAPI;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "types": [
+      "node",
+      "web-bluetooth"
+    ]
+  },
+  "include": ["./src", "../hd-transport-web-device/src/electron-ble-transport.ts"]
+}