@exodus/hw-ledger 2.6.0 → 2.8.0

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.8.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@2.7.0...@exodus/hw-ledger@2.8.0) (2024-07-10)
+
+### Features
+
+- **ledger:** add redux module ([#7734](https://github.com/ExodusMovement/exodus-hydra/issues/7734)) ([a26cb0a](https://github.com/ExodusMovement/exodus-hydra/commit/a26cb0ae76730d20ad6bbbb931f7c0f28094dbf4))
+
+### Bug Fixes
+
+- **ledger:** add missing atom ([#7731](https://github.com/ExodusMovement/exodus-hydra/issues/7731)) ([34b77d5](https://github.com/ExodusMovement/exodus-hydra/commit/34b77d5f3a7a1aca97646137e94b42758e5aaa85))
+
+## [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

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: "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"];
+        };
+    }, {
+        readonly definition: {
             readonly id: "ledgerDiscovery";
             readonly type: "module";
             readonly factory: (deps: import("./module").Dependencies) => import("./module").LedgerDiscovery;
-            readonly dependencies: readonly ["config", "logger", "transportsFactories"];
+            readonly dependencies: readonly ["config", "logger", "transportsFactories", "bluetoothScanningAtom"];
         };
-        config: {
-            bluetoothScannerTimeout: number;
+        readonly config: {
+            readonly bluetoothScannerTimeout: number;
         };
-    }[];
+    }];
 };
 export default hardwareWalletLedger;

package/lib/index.js

@@ -1,8 +1,19 @@
+import { bluetoothEnabledAtomDefinition, bluetoothScanningAtomDefinition } from './atoms';
 import ledgerDiscoveryDefinition from './module';
+import hardwareWalletLedgerPluginDefinition from './plugin';
 const hardwareWalletLedger = ({ bluetoothScannerTimeout = 10000, } = {}) => {
     return {
         id: 'hardwareWalletLedger',
         definitions: [
+            {
+                definition: bluetoothEnabledAtomDefinition,
+            },
+            {
+                definition: bluetoothScanningAtomDefinition,
+            },
+            {
+                definition: hardwareWalletLedgerPluginDefinition,
+            },
             {
                 definition: ledgerDiscoveryDefinition,
                 config: { bluetoothScannerTimeout },

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[]>;
@@ -23,6 +20,6 @@ declare const _default: {
     readonly id: "ledgerDiscovery";
     readonly type: "module";
     readonly factory: (deps: Dependencies) => LedgerDiscovery;
-    readonly dependencies: readonly ["config", "logger", "transportsFactories"];
+    readonly dependencies: readonly ["config", "logger", "transportsFactories", "bluetoothScanningAtom"];
 };
 export default _default;

package/lib/module/discovery.js

@@ -1,16 +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) &&
@@ -36,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`));
             }
         });
@@ -58,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;
         }
@@ -125,5 +129,5 @@ export default {
     id: MODULE_ID,
     type: 'module',
     factory: createLedgerDiscovery,
-    dependencies: ['config', 'logger', 'transportsFactories'],
+    dependencies: ['config', 'logger', 'transportsFactories', 'bluetoothScanningAtom'],
 };

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/lib/redux/id.d.ts

@@ -0,0 +1,2 @@
+declare const id = "hardwareWalletLedger";
+export default id;

package/lib/redux/id.js

@@ -0,0 +1,2 @@
+const id = 'hardwareWalletLedger';
+export default id;

package/lib/redux/index.d.ts

@@ -0,0 +1,30 @@
+import { type LedgerHardwareWalletState } from './initial-state';
+declare const exchangeReduxDefinition: {
+    readonly id: "hardwareWalletLedger";
+    readonly type: "redux-module";
+    readonly initialState: LedgerHardwareWalletState;
+    readonly eventReducers: {
+        readonly bluetoothEnabled: (state: LedgerHardwareWalletState, payload: boolean) => {
+            bluetoothEnabled: boolean;
+            bluetoothScanning: boolean;
+        };
+        readonly bluetoothScanning: (state: LedgerHardwareWalletState, payload: boolean) => {
+            bluetoothScanning: boolean;
+            bluetoothEnabled: boolean;
+        };
+    };
+    readonly selectorDefinitions: ({
+        readonly id: "bluetoothEnabled";
+        readonly resultFunction: (bluetoothEnabled: LedgerHardwareWalletState) => LedgerHardwareWalletState;
+        readonly dependencies: readonly [{
+            readonly selector: "bluetoothEnabled";
+        }];
+    } | {
+        readonly id: "bluetoothScanning";
+        readonly resultFunction: (bluetoothScanning: LedgerHardwareWalletState) => LedgerHardwareWalletState;
+        readonly dependencies: readonly [{
+            readonly selector: "bluetoothScanning";
+        }];
+    })[];
+};
+export default exchangeReduxDefinition;

package/lib/redux/index.js

@@ -0,0 +1,20 @@
+import id from './id';
+import initialState from './initial-state';
+import selectorDefinitions from './selectors';
+const exchangeReduxDefinition = {
+    id,
+    type: 'redux-module',
+    initialState,
+    eventReducers: {
+        bluetoothEnabled: (state, payload) => ({
+            ...state,
+            bluetoothEnabled: payload,
+        }),
+        bluetoothScanning: (state, payload) => ({
+            ...state,
+            bluetoothScanning: payload,
+        }),
+    },
+    selectorDefinitions,
+};
+export default exchangeReduxDefinition;

package/lib/redux/initial-state.d.ts

@@ -0,0 +1,6 @@
+export type LedgerHardwareWalletState = {
+    bluetoothEnabled: boolean;
+    bluetoothScanning: boolean;
+};
+declare const initialState: LedgerHardwareWalletState;
+export default initialState;

package/lib/redux/initial-state.js

@@ -0,0 +1,5 @@
+const initialState = {
+    bluetoothEnabled: false,
+    bluetoothScanning: false,
+};
+export default initialState;

package/lib/redux/selectors/bluetoothEnabled.d.ts

@@ -0,0 +1,9 @@
+import type { LedgerHardwareWalletState } from '../initial-state';
+declare const bluetoothEnabledSelectorDefinition: {
+    readonly id: "bluetoothEnabled";
+    readonly resultFunction: (bluetoothEnabled: LedgerHardwareWalletState) => LedgerHardwareWalletState;
+    readonly dependencies: readonly [{
+        readonly selector: "bluetoothEnabled";
+    }];
+};
+export default bluetoothEnabledSelectorDefinition;

package/lib/redux/selectors/bluetoothEnabled.js

@@ -0,0 +1,7 @@
+const resultFunction = (bluetoothEnabled) => bluetoothEnabled;
+const bluetoothEnabledSelectorDefinition = {
+    id: 'bluetoothEnabled',
+    resultFunction,
+    dependencies: [{ selector: 'bluetoothEnabled' }],
+};
+export default bluetoothEnabledSelectorDefinition;

package/lib/redux/selectors/bluetoothScanning.d.ts

@@ -0,0 +1,9 @@
+import type { LedgerHardwareWalletState } from '../initial-state';
+declare const bluetoothScanningSelectorDefinition: {
+    readonly id: "bluetoothScanning";
+    readonly resultFunction: (bluetoothScanning: LedgerHardwareWalletState) => LedgerHardwareWalletState;
+    readonly dependencies: readonly [{
+        readonly selector: "bluetoothScanning";
+    }];
+};
+export default bluetoothScanningSelectorDefinition;

package/lib/redux/selectors/bluetoothScanning.js

@@ -0,0 +1,7 @@
+const resultFunction = (bluetoothScanning) => bluetoothScanning;
+const bluetoothScanningSelectorDefinition = {
+    id: 'bluetoothScanning',
+    resultFunction,
+    dependencies: [{ selector: 'bluetoothScanning' }],
+};
+export default bluetoothScanningSelectorDefinition;

package/lib/redux/selectors/index.d.ts

@@ -0,0 +1,14 @@
+declare const ledgerSelectors: ({
+    readonly id: "bluetoothEnabled";
+    readonly resultFunction: (bluetoothEnabled: import("../initial-state").LedgerHardwareWalletState) => import("../initial-state").LedgerHardwareWalletState;
+    readonly dependencies: readonly [{
+        readonly selector: "bluetoothEnabled";
+    }];
+} | {
+    readonly id: "bluetoothScanning";
+    readonly resultFunction: (bluetoothScanning: import("../initial-state").LedgerHardwareWalletState) => import("../initial-state").LedgerHardwareWalletState;
+    readonly dependencies: readonly [{
+        readonly selector: "bluetoothScanning";
+    }];
+})[];
+export default ledgerSelectors;

package/lib/redux/selectors/index.js

@@ -0,0 +1,4 @@
+import bluetoothEnabledSelectorDefinition from './bluetoothEnabled';
+import bluetoothScanningSelectorDefinition from './bluetoothScanning';
+const ledgerSelectors = [bluetoothEnabledSelectorDefinition, bluetoothScanningSelectorDefinition];
+export default ledgerSelectors;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/hw-ledger",
-  "version": "2.6.0",
+  "version": "2.8.0",
   "description": "The ledger module",
   "author": "Exodus Movement, Inc.",
   "repository": {
@@ -30,6 +30,7 @@
     "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",
@@ -69,5 +70,5 @@
     "ts-jest": "^29.0.3",
     "typescript": "^4.7.3"
   },
-  "gitHead": "2ac1721860b9d11c2ebbf365f7a8ecd123e9ed40"
+  "gitHead": "7c0905f9185d9c00a8f3d4897991f596e226867a"
 }