@exodus/hw-ledger 2.5.1 → 2.7.0

package/CHANGELOG.md

@@ -3,6 +3,19 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.7.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@2.6.0...@exodus/hw-ledger@2.7.0) (2024-07-04)
+
+### Features
+
+- **ledger:** add `bluetoothScanningAtom` atom to indicate if scanning ([#7645](https://github.com/ExodusMovement/exodus-hydra/issues/7645)) ([bc377ea](https://github.com/ExodusMovement/exodus-hydra/commit/bc377ea7c4b1dd3a33b892791b80ea53e8ec2b58))
+- **ledger:** support retrieving BLE status ([#7631](https://github.com/ExodusMovement/exodus-hydra/issues/7631)) ([22eebc1](https://github.com/ExodusMovement/exodus-hydra/commit/22eebc1a059c502644f515897aefd1b4ef268cad))
+
+## [2.6.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@2.5.1...@exodus/hw-ledger@2.6.0) (2024-07-03)
+
+### Features
+
+- **ledger:** support retrieving name & model ([#7597](https://github.com/ExodusMovement/exodus-hydra/issues/7597)) ([a3210d7](https://github.com/ExodusMovement/exodus-hydra/commit/a3210d7db77b44119bca90b6e7d4507e4012b4cf))
+
 ## [2.5.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@2.5.0...@exodus/hw-ledger@2.5.1) (2024-05-27)
 
 ### Bug Fixes

package/lib/atoms/index.d.ts

@@ -0,0 +1,12 @@
+export declare const bluetoothEnabledAtomDefinition: {
+    readonly id: "bluetoothEnabledAtom";
+    readonly type: "atom";
+    readonly factory: () => import("@exodus/atoms").Atom<boolean>;
+    readonly dependencies: readonly [];
+};
+export declare const bluetoothScanningAtomDefinition: {
+    readonly id: "bluetoothScanningAtom";
+    readonly type: "atom";
+    readonly factory: () => import("@exodus/atoms").Atom<boolean>;
+    readonly dependencies: readonly [];
+};

package/lib/atoms/index.js

@@ -0,0 +1,13 @@
+import { createInMemoryAtom } from '@exodus/atoms';
+export const bluetoothEnabledAtomDefinition = {
+    id: 'bluetoothEnabledAtom',
+    type: 'atom',
+    factory: () => createInMemoryAtom({ defaultValue: false }),
+    dependencies: [],
+};
+export const bluetoothScanningAtomDefinition = {
+    id: 'bluetoothScanningAtom',
+    type: 'atom',
+    factory: () => createInMemoryAtom({ defaultValue: false }),
+    dependencies: [],
+};

package/lib/index.d.ts

@@ -1,16 +1,47 @@
 import type { HwLedgerConfig } from './module/types';
 declare const hardwareWalletLedger: ({ bluetoothScannerTimeout, }?: Partial<HwLedgerConfig>) => {
-    id: string;
-    definitions: {
-        definition: {
+    readonly id: "hardwareWalletLedger";
+    readonly definitions: readonly [{
+        readonly definition: {
             readonly id: "ledgerDiscovery";
             readonly type: "module";
             readonly factory: (deps: import("./module").Dependencies) => import("./module").LedgerDiscovery;
             readonly dependencies: readonly ["config", "logger", "transportsFactories"];
         };
-        config: {
-            bluetoothScannerTimeout: number;
+        readonly config: {
+            readonly bluetoothScannerTimeout: number;
         };
-    }[];
+    }, {
+        readonly definition: {
+            readonly id: "bluetoothEnabledAtom";
+            readonly type: "atom";
+            readonly factory: () => import("libraries/atoms/lib").Atom<boolean>;
+            readonly dependencies: readonly [];
+        };
+    }, {
+        readonly definition: {
+            readonly id: "bluetoothScanningAtom";
+            readonly type: "atom";
+            readonly factory: () => import("libraries/atoms/lib").Atom<boolean>;
+            readonly dependencies: readonly [];
+        };
+    }, {
+        readonly definition: {
+            readonly id: "hardwareWalletLedgerPlugin";
+            readonly type: "plugin";
+            readonly factory: ({ logger, transportsFactories, bluetoothEnabledAtom, bluetoothScanningAtom, port, }: {
+                logger: import("./shared/types").Logger;
+                transportsFactories: import("./module/types").TransportFactories;
+                bluetoothEnabledAtom: import("libraries/atoms/lib").Atom<boolean>;
+                bluetoothScanningAtom: import("libraries/atoms/lib").Atom<boolean>;
+                port: import("./shared/types").Port;
+            }) => {
+                onUnlock: () => void;
+                onLoad: () => void;
+                onStop: () => void;
+            };
+            readonly dependencies: readonly ["logger", "transportsFactories", "bluetoothEnabledAtom", "bluetoothScanningAtom", "port"];
+        };
+    }];
 };
 export default hardwareWalletLedger;

package/lib/index.js

@@ -1,4 +1,6 @@
+import { bluetoothEnabledAtomDefinition, bluetoothScanningAtomDefinition } from './atoms';
 import ledgerDiscoveryDefinition from './module';
+import hardwareWalletLedgerPluginDefinition from './plugin';
 const hardwareWalletLedger = ({ bluetoothScannerTimeout = 10000, } = {}) => {
     return {
         id: 'hardwareWalletLedger',
@@ -7,6 +9,15 @@ const hardwareWalletLedger = ({ bluetoothScannerTimeout = 10000, } = {}) => {
                 definition: ledgerDiscoveryDefinition,
                 config: { bluetoothScannerTimeout },
             },
+            {
+                definition: bluetoothEnabledAtomDefinition,
+            },
+            {
+                definition: bluetoothScanningAtomDefinition,
+            },
+            {
+                definition: hardwareWalletLedgerPluginDefinition,
+            },
         ],
     };
 };

package/lib/module/discovery.d.ts

@@ -1,19 +1,16 @@
-import ExodusModule from '@exodus/module';
 import { Logger } from '../shared/types';
+import type { Atom } from '@exodus/atoms';
 import type { HardwareWalletDescriptor, HardwareWalletDiscovery } from '@exodus/hw-common';
-import type { TransportFactory, HwLedgerConfig } from './types';
+import type { HwLedgerConfig, TransportFactories } from './types';
 export type Dependencies = {
     config: HwLedgerConfig;
     logger: Logger;
-    transportsFactories: {
-        usb: TransportFactory;
-        bluetooth: TransportFactory;
-        tcp: TransportFactory;
-    };
+    transportsFactories: TransportFactories;
+    bluetoothScanningAtom: Atom<boolean>;
 };
-export declare class LedgerDiscovery extends ExodusModule implements HardwareWalletDiscovery {
+export declare class LedgerDiscovery implements HardwareWalletDiscovery {
     #private;
-    constructor({ config, logger, transportsFactories }: Dependencies);
+    constructor({ config, logger, transportsFactories, bluetoothScanningAtom }: Dependencies);
     scan: () => Promise<void>;
     stopScan: (clearDevices?: boolean) => void;
     list: () => Promise<HardwareWalletDescriptor[]>;

package/lib/module/discovery.js

@@ -1,15 +1,18 @@
-import ExodusModule from '@exodus/module';
+import { getInfosForServiceUuid, identifyUSBProductId } from '@exodus/ledgerhq-devices';
 import { APDU_PORT } from './constants';
 import { LedgerDevice } from './device';
 import { NoDeviceFoundError, UnknownTransportError } from './errors';
 const MODULE_ID = 'ledgerDiscovery';
-export class LedgerDiscovery extends ExodusModule {
+export class LedgerDiscovery {
+    #logger;
     #transportsFactories;
     #scannerTimeout;
     #scannerBluetooth;
+    #bluetoothScanningAtom;
     #discoveredBluetoothDevices = Object.create(null);
-    constructor({ config, logger, transportsFactories }) {
-        super({ name: MODULE_ID, logger });
+    constructor({ config, logger, transportsFactories, bluetoothScanningAtom }) {
+        this.#logger = logger;
+        this.#bluetoothScanningAtom = bluetoothScanningAtom;
         if (!(typeof transportsFactories === 'object' &&
             Object.keys(transportsFactories).length > 0 &&
             Object.entries(transportsFactories).every(([transportName, transportFactory]) => ['usb', 'bluetooth', 'tcp'].includes(transportName) &&
@@ -35,19 +38,20 @@ export class LedgerDiscovery extends ExodusModule {
                         }
                     },
                     error: (error) => {
-                        this._logger.error(`an error occured while scanning for bluetooth devices "${error.message}"`);
+                        this.#logger.error(`an error occured while scanning for bluetooth devices "${error.message}"`);
                         this.stopScan();
                         reject(error);
                     },
                     complete: () => { },
                 });
+                this.#bluetoothScanningAtom.set(true);
                 setTimeout(() => {
                     this.stopScan();
                     resolve();
                 }, this.#scannerTimeout);
             }
             else {
-                this._logger.error(`Attempted to perform scan without having bluetooth transport factory`);
+                this.#logger.error(`Attempted to perform scan without having bluetooth transport factory`);
                 reject(new Error(`Attempted to perform scan without having bluetooth transport factory`));
             }
         });
@@ -57,6 +61,7 @@ export class LedgerDiscovery extends ExodusModule {
             this.#discoveredBluetoothDevices = Object.create(null);
         }
         if (this.#scannerBluetooth) {
+            this.#bluetoothScanningAtom.set(false);
             this.#scannerBluetooth.unsubscribe();
             this.#scannerBluetooth = undefined;
         }
@@ -67,25 +72,38 @@ export class LedgerDiscovery extends ExodusModule {
             switch (transportName) {
                 case 'usb':
                     const deviceList = await transportFactory.list();
-                    const usbDeviceList = deviceList.map((hidDevice) => ({
-                        manufacturer: 'ledger',
-                        transport: 'usb',
-                        get: async () => new LedgerDevice({ transportFactory, descriptor: hidDevice }),
-                    }));
+                    const usbDeviceList = deviceList.map((hidDevice) => {
+                        const deviceModel = identifyUSBProductId(hidDevice.productId);
+                        return {
+                            name: deviceModel?.productName ?? 'Ledger USB',
+                            manufacturer: 'ledger',
+                            transport: 'usb',
+                            model: deviceModel?.id ?? 'unknown',
+                            get: async () => new LedgerDevice({ transportFactory, descriptor: hidDevice }),
+                        };
+                    });
                     descriptors.push(...usbDeviceList);
                     break;
                 case 'bluetooth':
-                    const bluetoothDeviceList = Object.values(this.#discoveredBluetoothDevices).map((bluetoothDevice) => ({
-                        manufacturer: 'ledger',
-                        transport: 'bluetooth',
-                        get: async () => new LedgerDevice({ transportFactory, descriptor: bluetoothDevice }),
-                    }));
+                    const bluetoothDeviceList = Object.values(this.#discoveredBluetoothDevices).map((bluetoothDevice) => {
+                        const deviceModel = getInfosForServiceUuid(bluetoothDevice.serviceUUIDs?.[0] ?? '')
+                            ?.deviceModel;
+                        return {
+                            name: bluetoothDevice.localName ?? deviceModel?.productName,
+                            manufacturer: 'ledger',
+                            transport: 'bluetooth',
+                            model: deviceModel?.id ?? 'unknown',
+                            get: async () => new LedgerDevice({ transportFactory, descriptor: bluetoothDevice }),
+                        };
+                    });
                     descriptors.push(...bluetoothDeviceList);
                     break;
                 case 'tcp':
                     descriptors.push({
+                        name: 'TCP Emulator',
                         manufacturer: 'ledger',
                         transport: 'tcp',
+                        model: 'unknown',
                         get: async () => new LedgerDevice({
                             transportFactory,
                             descriptor: { apduPort: APDU_PORT },

package/lib/module/types.d.ts

@@ -1,5 +1,21 @@
 import type Transport from '@ledgerhq/hw-transport';
+import type { TransportTypes } from '@exodus/hw-common';
+import type { Subscription } from '@ledgerhq/hw-transport';
 export type TransportFactory = typeof Transport;
+export type TransportFactories = Partial<Record<TransportTypes, TransportFactory>> & {
+    bluetooth?: TransportFactory & {
+        observeAvailability?: (observer: {
+            next: (available: boolean) => void;
+            error: (err: Error) => void;
+        }) => Subscription;
+        observeState?: (observer: {
+            next: (evt: {
+                available: boolean;
+            }) => void;
+            error: (err: Error) => void;
+        }) => Subscription;
+    };
+};
 export type HwLedgerConfig = {
     bluetoothScannerTimeout: number;
 };

package/lib/plugin/index.d.ts

@@ -0,0 +1,20 @@
+import type { Atom } from '@exodus/atoms';
+import type { TransportFactories } from '../module/types';
+import type { Logger, Port } from '../shared/types';
+declare const hardwareWalletLedgerPluginDefinition: {
+    readonly id: "hardwareWalletLedgerPlugin";
+    readonly type: "plugin";
+    readonly factory: ({ logger, transportsFactories, bluetoothEnabledAtom, bluetoothScanningAtom, port, }: {
+        logger: Logger;
+        transportsFactories: TransportFactories;
+        bluetoothEnabledAtom: Atom<boolean>;
+        bluetoothScanningAtom: Atom<boolean>;
+        port: Port;
+    }) => {
+        onUnlock: () => void;
+        onLoad: () => void;
+        onStop: () => void;
+    };
+    readonly dependencies: readonly ["logger", "transportsFactories", "bluetoothEnabledAtom", "bluetoothScanningAtom", "port"];
+};
+export default hardwareWalletLedgerPluginDefinition;

package/lib/plugin/index.js

@@ -0,0 +1,59 @@
+import { createAtomObserver } from '@exodus/atoms';
+const createHardwareWalletLedgerPlugin = ({ logger, transportsFactories, bluetoothEnabledAtom, bluetoothScanningAtom, port, }) => {
+    let subscription;
+    const observers = [
+        createAtomObserver({ atom: bluetoothEnabledAtom, port, event: 'bluetoothEnabled' }),
+        createAtomObserver({ atom: bluetoothScanningAtom, port, event: 'bluetoothScanning' }),
+    ];
+    observers.forEach((observer) => observer.register());
+    const start = () => {
+        if (!transportsFactories.bluetooth)
+            return;
+        if (subscription)
+            return;
+        if (transportsFactories.bluetooth.observeState) {
+            subscription = transportsFactories.bluetooth.observeState({
+                next: (e) => {
+                    bluetoothEnabledAtom.set(!!e.available);
+                },
+                error: (error) => logger.error(error),
+            });
+        }
+        else if (transportsFactories.bluetooth.observeAvailability) {
+            subscription = transportsFactories.bluetooth.observeAvailability({
+                next: (available) => {
+                    bluetoothEnabledAtom.set(available);
+                },
+                error: (error) => logger.error(error),
+            });
+        }
+        observers.forEach((observer) => observer.start());
+    };
+    const stop = () => {
+        observers.forEach((observer) => observer.unregister());
+        subscription?.unsubscribe();
+    };
+    const onUnlock = () => {
+        start();
+    };
+    const onLoad = () => {
+        start();
+    };
+    const onStop = () => {
+        stop();
+    };
+    return { onUnlock, onLoad, onStop };
+};
+const hardwareWalletLedgerPluginDefinition = {
+    id: 'hardwareWalletLedgerPlugin',
+    type: 'plugin',
+    factory: createHardwareWalletLedgerPlugin,
+    dependencies: [
+        'logger',
+        'transportsFactories',
+        'bluetoothEnabledAtom',
+        'bluetoothScanningAtom',
+        'port',
+    ],
+};
+export default hardwareWalletLedgerPluginDefinition;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/hw-ledger",
-  "version": "2.5.1",
+  "version": "2.7.0",
   "description": "The ledger module",
   "author": "Exodus Movement, Inc.",
   "repository": {
@@ -30,11 +30,13 @@
     "prepublishOnly": "yarn run -T build --scope @exodus/hw-ledger"
   },
   "dependencies": {
+    "@exodus/atoms": "^7.5.1",
     "@exodus/bip322-js": "^1.1.0-exodus.4",
     "@exodus/bitcoinjs-lib": "^6.1.5-exodus.0",
     "@exodus/ethersproject-transactions": "^5.4.2-exodus.0",
-    "@exodus/hw-common": "^2.0.0",
+    "@exodus/hw-common": "^2.1.0",
     "@exodus/ledger-bitcoin": "^0.2.3-exodus.3",
+    "@exodus/ledgerhq-devices": "^8.1.0-exodus.3",
     "@exodus/ledgerhq-hw-app-eth": "^6.33.7-exodus.8",
     "@exodus/module": "^1.2.2",
     "@exodus/secp256k1": "^4.0.2-exodus.0",
@@ -49,7 +51,6 @@
   "devDependencies": {
     "@exodus/bip32": "^2.0.0",
     "@exodus/ethersproject-abi": "^5.4.2-exodus.3",
-    "@exodus/ledgerhq-devices": "^8.1.0-exodus.2",
     "@ledgerhq/hw-transport-node-hid": "^6.27.17",
     "@ledgerhq/hw-transport-node-speculos": "^6.27.16",
     "@solana/web3.js": "^1.78.0",
@@ -69,5 +70,5 @@
     "ts-jest": "^29.0.3",
     "typescript": "^4.7.3"
   },
-  "gitHead": "c34c770e5b16f0fe2f0edaadfa5016cce7cbd1bb"
+  "gitHead": "c53411aed8e084439cc9d1a5450fa65266f834ab"
 }