@exodus/hardware-wallets 2.1.0 → 3.0.1

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.0.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hardware-wallets@3.0.0...@exodus/hardware-wallets@3.0.1) (2025-06-17)
+
+### Bug Fixes
+
+- fix: retry logic on hardware signing (#12944)
+
+## [3.0.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hardware-wallets@2.1.0...@exodus/hardware-wallets@3.0.0) (2025-06-16)
+
+### ⚠ BREAKING CHANGES
+
+- rework hardware wallet UI signing (#12852)
+
+### Features
+
+- feat!: rework hardware wallet UI signing (#12852)
+
 ## [2.1.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hardware-wallets@2.0.5...@exodus/hardware-wallets@2.1.0) (2025-05-13)
 
 ### Features

package/lib/api/index.d.ts

@@ -21,6 +21,8 @@ declare const hardwareWalletsApiDefinition: {
             sync: ({ accountIndex: index, isMultisig }?: import("../module/interfaces.js").SyncParams) => Promise<import("../module/interfaces.js").SyncedKeysId>;
             addPublicKeysToWalletAccount: ({ walletAccount, syncedKeysId }: import("../module/interfaces.js").StoreSyncedKeysParams) => Promise<void>;
             create: ({ syncedKeysId, isMultisig }: import("../module/interfaces.js").CreateParams) => Promise<import("libraries/models/lib/index.js").WalletAccount>;
+            retrySigningRequest: (id: string) => Promise<void>;
+            cancelSigningRequest: (id: string, fromUI: boolean) => Promise<void>;
         };
     };
     readonly dependencies: readonly ["hardwareWallets", "txLogMonitors", "restoreProgressTracker"];

package/lib/api/index.js

@@ -28,6 +28,8 @@ const createHardwareWalletsApi = ({ hardwareWallets, restoreProgressTracker, txL
             sync: hardwareWallets.sync,
             addPublicKeysToWalletAccount: hardwareWallets.addPublicKeysToWalletAccount,
             create: hardwareWallets.create,
+            retrySigningRequest: hardwareWallets.retrySigningRequest,
+            cancelSigningRequest: hardwareWallets.cancelSigningRequest,
         },
     };
 };

package/lib/atoms/hardwareWalletSigningRequestsAtom.d.ts

@@ -0,0 +1,8 @@
+import type { SigningRequestState } from '../module/interfaces.js';
+export declare const hardwareWalletSigningRequestsAtomDefinition: {
+    readonly id: "hardwareWalletSigningRequestsAtom";
+    readonly type: "atom";
+    readonly factory: () => import("@exodus/atoms").Atom<SigningRequestState>;
+    readonly dependencies: readonly [];
+    readonly public: false;
+};

package/lib/atoms/hardwareWalletSigningRequestsAtom.js

@@ -0,0 +1,10 @@
+import { createInMemoryAtom } from '@exodus/atoms';
+export const hardwareWalletSigningRequestsAtomDefinition = {
+    id: 'hardwareWalletSigningRequestsAtom',
+    type: 'atom',
+    factory: () => createInMemoryAtom({
+        defaultValue: Object.create(null),
+    }),
+    dependencies: [],
+    public: false,
+};

package/lib/atoms/index.d.ts

@@ -1,3 +1,4 @@
+export { hardwareWalletSigningRequestsAtomDefinition } from './hardwareWalletSigningRequestsAtom.js';
 type WalletAccountName = string;
 type AssetName = string;
 export type WalletAccountNameToConnectedAssetNamesMap = Record<WalletAccountName, AssetName[]>;
@@ -8,4 +9,3 @@ export declare const hardwareWalletConnectedAssetNamesAtomDefinition: {
     readonly factory: ({ assetsModule, hardwareWalletPublicKeysAtom, walletAccountsAtom, }: any) => import("@exodus/atoms").ReadonlyAtom<unknown>;
     readonly dependencies: readonly ["hardwareWalletPublicKeysAtom", "assetsModule", "walletAccountsAtom"];
 };
-export {};

package/lib/atoms/index.js

@@ -1,6 +1,7 @@
 import { combine, compute } from '@exodus/atoms';
 import { memoize } from '@exodus/basic-utils';
 import { HARDENED_OFFSET } from '@exodus/bip32';
+export { hardwareWalletSigningRequestsAtomDefinition } from './hardwareWalletSigningRequestsAtom.js';
 export const createHardwareWalletConnectedAssetNamesAtom = ({ assetsModule, hardwareWalletPublicKeysAtom, walletAccountsAtom, }) => {
     const selector = memoize(({ hardwareWalletPublicKeys, walletAccounts }) => {
         const result = Object.create(null);

package/lib/index.d.ts

@@ -24,6 +24,8 @@ declare const hardwareWallets: () => {
                     sync: ({ accountIndex: index, isMultisig }?: import("./module/interfaces.js").SyncParams) => Promise<import("./module/interfaces.js").SyncedKeysId>;
                     addPublicKeysToWalletAccount: ({ walletAccount, syncedKeysId }: import("./module/interfaces.js").StoreSyncedKeysParams) => Promise<void>;
                     create: ({ syncedKeysId, isMultisig }: import("./module/interfaces.js").CreateParams) => Promise<import("libraries/models/lib/index.js").WalletAccount>;
+                    retrySigningRequest: (id: string) => Promise<void>;
+                    cancelSigningRequest: (id: string, fromUI: boolean) => Promise<void>;
                 };
             };
             readonly dependencies: readonly ["hardwareWallets", "txLogMonitors", "restoreProgressTracker"];
@@ -33,7 +35,7 @@ declare const hardwareWallets: () => {
             readonly id: "hardwareWallets";
             readonly type: "module";
             readonly factory: (opts: import("./module/hardware-wallets.js").Dependencies) => import("./module/hardware-wallets.js").HardwareWallets;
-            readonly dependencies: readonly ["assetsModule", "logger", "ledgerDiscovery", "userInterface", "publicKeyStore", "wallet", "walletAccountsAtom", "walletAccounts"];
+            readonly dependencies: readonly ["assetsModule", "logger", "ledgerDiscovery", "publicKeyStore", "hardwareWalletSigningRequestsAtom", "wallet", "walletAccountsAtom", "walletAccounts"];
             readonly public: true;
         };
     }, {
@@ -43,19 +45,28 @@ declare const hardwareWallets: () => {
             readonly factory: ({ assetsModule, hardwareWalletPublicKeysAtom, walletAccountsAtom, }: any) => import("libraries/atoms/lib/index.js").ReadonlyAtom<unknown>;
             readonly dependencies: readonly ["hardwareWalletPublicKeysAtom", "assetsModule", "walletAccountsAtom"];
         };
+    }, {
+        readonly definition: {
+            readonly id: "hardwareWalletSigningRequestsAtom";
+            readonly type: "atom";
+            readonly factory: () => import("libraries/atoms/lib/index.js").Atom<import("./module/interfaces.js").SigningRequestState>;
+            readonly dependencies: readonly [];
+            readonly public: false;
+        };
     }, {
         readonly definition: {
             readonly id: "hardwareWalletsPlugin";
             readonly type: "plugin";
-            readonly factory: ({ hardwareWalletConnectedAssetNamesAtom, port, }: {
+            readonly factory: ({ hardwareWalletConnectedAssetNamesAtom, hardwareWalletSigningRequestsAtom, port, }: {
                 hardwareWalletConnectedAssetNamesAtom: import("libraries/atoms/lib/index.js").Atom<import("./atoms/index.js").WalletAccountNameToConnectedAssetNamesMap>;
+                hardwareWalletSigningRequestsAtom: import("libraries/atoms/lib/index.js").Atom<import("./module/interfaces.js").SigningRequestState>;
                 port: import("./shared/types.js").Port;
             }) => {
                 onUnlock: () => void;
                 onLoad: () => void;
                 onStop: () => void;
             };
-            readonly dependencies: readonly ["hardwareWalletConnectedAssetNamesAtom", "port"];
+            readonly dependencies: readonly ["hardwareWalletConnectedAssetNamesAtom", "hardwareWalletSigningRequestsAtom", "port"];
         };
     }];
 };

package/lib/index.js

@@ -1,6 +1,6 @@
 import hardwareWalletsApiDefinition from './api/index.js';
 import hardwareWalletsModuleDefinition from './module/hardware-wallets.js';
-import { hardwareWalletConnectedAssetNamesAtomDefinition } from './atoms/index.js';
+import { hardwareWalletConnectedAssetNamesAtomDefinition, hardwareWalletSigningRequestsAtomDefinition, } from './atoms/index.js';
 import hardwareWalletsPluginDefinition from './plugin/index.js';
 const hardwareWallets = () => {
     return {
@@ -15,6 +15,9 @@ const hardwareWallets = () => {
             {
                 definition: hardwareWalletConnectedAssetNamesAtomDefinition,
             },
+            {
+                definition: hardwareWalletSigningRequestsAtomDefinition,
+            },
             {
                 definition: hardwareWalletsPluginDefinition,
             },

package/lib/module/hardware-wallets.d.ts

@@ -1,6 +1,6 @@
 import { WalletAccount } from '@exodus/models';
 import Emitter from '@exodus/wild-emitter';
-import type { HardwareSignerProvider, CanAccessAssetParams, CreateParams, StoreSyncedKeysParams, ScanParams, SyncParams, EnsureApplicationIsOpenedParams, SignTransactionParams, ScanResult, SyncedKeysId, GetAddressParams, RequireDeviceForParams } from './interfaces.js';
+import type { HardwareSignerProvider, CanAccessAssetParams, CreateParams, StoreSyncedKeysParams, ScanParams, SyncParams, EnsureApplicationIsOpenedParams, SignTransactionParams, ScanResult, SyncedKeysId, GetAddressParams, RequireDeviceForParams, SigningRequestState } from './interfaces.js';
 import type { HardwareWalletDiscovery, SignMessageParams } from '@exodus/hw-common';
 import type { Atom } from '@exodus/atoms';
 import type { IPublicKeyStore } from '@exodus/public-key-provider/lib/module/store/types';
@@ -9,7 +9,7 @@ export type Dependencies = {
     assetsModule: any;
     ledgerDiscovery: HardwareWalletDiscovery;
     logger: Logger;
-    userInterface: any;
+    hardwareWalletSigningRequestsAtom: Atom<SigningRequestState>;
     publicKeyStore: IPublicKeyStore;
     wallet: any;
     walletAccountsAtom: Atom<WalletAccount>;
@@ -20,7 +20,9 @@ export type Dependencies = {
 export declare class HardwareWallets implements HardwareSignerProvider {
     #private;
     readonly events: Emitter<string, any>;
-    constructor({ assetsModule, ledgerDiscovery, logger, userInterface, publicKeyStore, wallet, walletAccountsAtom, walletAccounts, }: Dependencies);
+    constructor({ assetsModule, ledgerDiscovery, logger, hardwareWalletSigningRequestsAtom, publicKeyStore, wallet, walletAccountsAtom, walletAccounts, }: Dependencies);
+    retrySigningRequest: (id: string) => Promise<void>;
+    cancelSigningRequest: (id: string, fromUI: boolean) => Promise<void>;
     signTransaction: ({ baseAssetName, unsignedTx, walletAccount, multisigData, }: SignTransactionParams) => Promise<any>;
     signMessage: ({ assetName, derivationPath, message }: SignMessageParams) => Promise<any>;
     isDeviceConnected: () => Promise<boolean>;
@@ -46,7 +48,7 @@ declare const hardwareWalletsModuleDefinition: {
     readonly id: "hardwareWallets";
     readonly type: "module";
     readonly factory: (opts: Dependencies) => HardwareWallets;
-    readonly dependencies: readonly ["assetsModule", "logger", "ledgerDiscovery", "userInterface", "publicKeyStore", "wallet", "walletAccountsAtom", "walletAccounts"];
+    readonly dependencies: readonly ["assetsModule", "logger", "ledgerDiscovery", "publicKeyStore", "hardwareWalletSigningRequestsAtom", "wallet", "walletAccountsAtom", "walletAccounts"];
     readonly public: true;
 };
 export default hardwareWalletsModuleDefinition;

package/lib/module/hardware-wallets.js

@@ -4,23 +4,26 @@ import Emitter from '@exodus/wild-emitter';
 import { randomBytes } from '@exodus/crypto/randomBytes';
 import delay from 'delay';
 import { NoDeviceFoundError, UserRefusedError } from '@exodus/hw-common';
+import restrictConcurrency from 'make-concurrent';
+import pDefer from 'p-defer';
 export class HardwareWallets {
     #assetsModule;
     #ledgerDiscovery;
     #logger;
-    #userInterface;
     #publicKeyStore;
+    #signingRequestAtom;
     #wallet;
     #walletAccountsAtom;
     #walletAccounts;
     #syncedKeysMap = new Map();
+    #signingRequest;
     events = new Emitter();
-    constructor({ assetsModule, ledgerDiscovery, logger, userInterface, publicKeyStore, wallet, walletAccountsAtom, walletAccounts, }) {
+    constructor({ assetsModule, ledgerDiscovery, logger, hardwareWalletSigningRequestsAtom, publicKeyStore, wallet, walletAccountsAtom, walletAccounts, }) {
         this.#assetsModule = assetsModule;
         this.#ledgerDiscovery = ledgerDiscovery;
         this.#logger = logger;
-        this.#userInterface = userInterface;
         this.#publicKeyStore = publicKeyStore;
+        this.#signingRequestAtom = hardwareWalletSigningRequestsAtom;
         this.#wallet = wallet;
         this.#walletAccountsAtom = walletAccountsAtom;
         this.#walletAccounts = walletAccounts;
@@ -32,66 +35,100 @@ export class HardwareWallets {
         }
         throw new NoDeviceFoundError();
     };
-    #requestUserAction = async (params) => {
-        const rpc = this.#userInterface.getRPC();
-        return rpc.callMethod('handle-hardware-wallet', params);
+    #updateSigningRequest = async (state) => {
+        this.#logger.debug(`Updating signing request state: ${JSON.stringify(state)}`);
+        await this.#signingRequestAtom.set(state);
+        this.#logger.debug(`Finished updating signing request state: ${JSON.stringify(state)}`);
     };
-    #signGeneric = async ({ baseAssetName, scenario, sign }) => {
-        let attempts = 0;
-        const MAX_ATTEMPTS = 50;
-        while (attempts < MAX_ATTEMPTS) {
+    #deleteSigningRequest = async (id) => {
+        if (this.#signingRequest?.id === id) {
+            this.#signingRequest = undefined;
+            await this.#signingRequestAtom.reset();
+            this.#logger.debug(`Signing request with id: ${id} has been deleted`);
+        }
+        else {
+            this.#logger.warn(`No signing request found for id: ${id}`);
+        }
+    };
+    retrySigningRequest = async (id) => {
+        const request = this.#signingRequest;
+        if (request?.id !== id) {
+            this.#logger.warn(`No signing request found for id: ${id}`);
+            return;
+        }
+        try {
+            this.#logger.debug(`Attempting to get selected device for signing request with id: ${id}`);
+            const { device } = await this.#getSelectedDevice();
+            this.#logger.debug(`Attempting to sign for signing request with id: ${id}`);
+            const result = await request.sign({ device });
+            await this.#deleteSigningRequest(id);
+            request.resolve(result);
+        }
+        catch (error) {
+            if (this.#signingRequest?.id !== id) {
+                this.#logger.warn(`Signing request with id: ${id} was cancelled, not retrying`);
+                return;
+            }
+            const _error = error;
+            if (['DisconnectedDevice', 'DisconnectedDeviceDuringOperation'].includes(_error.name)) {
+                this.#logger.debug(`Device disconnected during signing request, likely due to app opening: ${id}`, _error);
+                await delay(300);
+                await this.retrySigningRequest(id);
+                return;
+            }
+            if (_error.message.includes('timeout') || _error.name === 'UserRefusedError') {
+                await this.cancelSigningRequest(id, false);
+                return;
+            }
+            await this.#updateSigningRequest({
+                id,
+                scenario: 'error',
+                error: _error,
+            });
+        }
+    };
+    cancelSigningRequest = async (id, fromUI) => {
+        const request = this.#signingRequest;
+        this.#logger.debug(`Cancelling signing request for id: ${id}, fromUI: ${fromUI}`);
+        if (request?.id !== id) {
+            this.#logger.warn(`No signing request found for id: ${id}`);
+            return;
+        }
+        await this.#deleteSigningRequest(id);
+        if (fromUI) {
+            this.#logger.debug(`Cancelling signing request on device for id: ${id}`);
             try {
-                const approvePromise = this.#requestUserAction({
-                    scenario,
-                    baseAssetName,
-                });
                 const { device } = await this.#getSelectedDevice();
-                const runSign = async () => {
-                    await device.ensureApplicationIsOpened(baseAssetName);
-                    return sign({ device });
-                };
-                const result = await Promise.race([approvePromise, runSign()]);
-                if (typeof result === 'object' && result.tryAgain === false) {
-                    void device.cancelAction();
-                    throw new UserRefusedError(false);
-                }
-                void this.#requestUserAction({ scenario: 'completed' });
-                return result;
+                await device.cancelAction();
+                this.#logger.debug(`Succesfully cancelled signing request on device for id: ${id}`);
             }
             catch (error) {
-                if (error.message.includes('timeout')) {
-                    break;
-                }
-                else if (error.name === 'UserRefusedError') {
-                    void this.#requestUserAction({ scenario: 'completed' });
-                    throw error;
-                }
-                if (['DisconnectedDevice', 'DisconnectedDeviceDuringOperation'].includes(error.name)) {
-                    continue;
-                }
-                try {
-                    const { tryAgain } = await this.#requestUserAction({
-                        error,
-                        baseAssetName,
-                    });
-                    if (!tryAgain) {
-                        this.#logger.warn(error);
-                        break;
-                    }
-                }
-                catch (_error) {
-                    this.#logger.error(_error);
-                    break;
-                }
-            }
-            finally {
-                attempts++;
-                await delay(200);
+                this.#logger.error(`Failed to cancel signing request on device for id: ${id}`, error);
             }
         }
-        void this.#requestUserAction({ scenario: 'completed' });
-        throw new UserRefusedError(false);
+        request.reject(new UserRefusedError(!fromUI));
     };
+    #signGeneric = restrictConcurrency(async ({ baseAssetName, scenario, sign }) => {
+        const id = randomBytes(16).toString('hex');
+        this.#logger.debug(`Starting signing request for ${baseAssetName} with scenario: ${scenario} and id: ${id}`);
+        const deferred = pDefer();
+        this.#signingRequest = {
+            id,
+            sign: async ({ device }) => {
+                await this.#updateSigningRequest({
+                    id,
+                    baseAssetName,
+                    scenario,
+                });
+                await device.ensureApplicationIsOpened(baseAssetName);
+                return sign({ device });
+            },
+            resolve: deferred.resolve,
+            reject: deferred.reject,
+        };
+        void this.retrySigningRequest(id);
+        return deferred.promise;
+    });
     signTransaction = async ({ baseAssetName, unsignedTx, walletAccount, multisigData, }) => {
         const baseAsset = this.#assetsModule.getAsset(baseAssetName);
         const accountIndex = walletAccount.index;
@@ -345,8 +382,8 @@ const hardwareWalletsModuleDefinition = {
         'assetsModule',
         'logger',
         'ledgerDiscovery',
-        'userInterface',
         'publicKeyStore',
+        'hardwareWalletSigningRequestsAtom',
         'wallet',
         'walletAccountsAtom',
         'walletAccounts',

package/lib/module/interfaces.d.ts

@@ -81,9 +81,21 @@ export type GenericSignCallback = ({ device }: {
 }) => Promise<any>;
 export interface GenericSignParams {
     baseAssetName: string;
-    scenario: string;
+    scenario: 'signTransaction' | 'signMessage';
     sign: GenericSignCallback;
 }
+export interface SigningRequestState {
+    id: string;
+    baseAssetName?: string;
+    scenario: 'signTransaction' | 'signMessage' | 'error';
+    error?: Error;
+}
+export interface SigningRequest {
+    id: string;
+    sign: GenericSignCallback;
+    resolve: (result: any) => void;
+    reject: (error: Error) => void;
+}
 export interface SignTransactionParams {
     baseAssetName: string;
     unsignedTx: UnsignedTransaction;

package/lib/plugin/index.d.ts

@@ -1,17 +1,19 @@
 import type { Atom } from '@exodus/atoms';
 import type { Port } from '../shared/types';
 import type { WalletAccountNameToConnectedAssetNamesMap } from '../atoms/index.js';
+import type { SigningRequestState } from '../module/interfaces.js';
 declare const hardwareWalletsPluginDefinition: {
     readonly id: "hardwareWalletsPlugin";
     readonly type: "plugin";
-    readonly factory: ({ hardwareWalletConnectedAssetNamesAtom, port, }: {
+    readonly factory: ({ hardwareWalletConnectedAssetNamesAtom, hardwareWalletSigningRequestsAtom, port, }: {
         hardwareWalletConnectedAssetNamesAtom: Atom<WalletAccountNameToConnectedAssetNamesMap>;
+        hardwareWalletSigningRequestsAtom: Atom<SigningRequestState>;
         port: Port;
     }) => {
         onUnlock: () => void;
         onLoad: () => void;
         onStop: () => void;
     };
-    readonly dependencies: readonly ["hardwareWalletConnectedAssetNamesAtom", "port"];
+    readonly dependencies: readonly ["hardwareWalletConnectedAssetNamesAtom", "hardwareWalletSigningRequestsAtom", "port"];
 };
 export default hardwareWalletsPluginDefinition;

package/lib/plugin/index.js

@@ -1,11 +1,16 @@
 import { createAtomObserver } from '@exodus/atoms';
-const createHardwareWalletsPlugin = ({ hardwareWalletConnectedAssetNamesAtom, port, }) => {
+const createHardwareWalletsPlugin = ({ hardwareWalletConnectedAssetNamesAtom, hardwareWalletSigningRequestsAtom, port, }) => {
     const observers = [
         createAtomObserver({
             atom: hardwareWalletConnectedAssetNamesAtom,
             port,
             event: 'hardwareWalletConnectedAssetNames',
         }),
+        createAtomObserver({
+            atom: hardwareWalletSigningRequestsAtom,
+            port,
+            event: 'hardwareWalletSigningRequests',
+        }),
     ];
     observers.forEach((observer) => observer.register());
     const start = () => {
@@ -29,6 +34,10 @@ const hardwareWalletsPluginDefinition = {
     id: 'hardwareWalletsPlugin',
     type: 'plugin',
     factory: createHardwareWalletsPlugin,
-    dependencies: ['hardwareWalletConnectedAssetNamesAtom', 'port'],
+    dependencies: [
+        'hardwareWalletConnectedAssetNamesAtom',
+        'hardwareWalletSigningRequestsAtom',
+        'port',
+    ],
 };
 export default hardwareWalletsPluginDefinition;

package/lib/redux/index.d.ts

@@ -1,3 +1,4 @@
+import type { SigningRequestState } from '../module/interfaces.js';
 import { type HardwareWalletsState } from './initial-state.js';
 declare const hardwareWalletsReduxDefinition: {
     readonly id: "hardwareWallets";
@@ -6,14 +7,25 @@ declare const hardwareWalletsReduxDefinition: {
     readonly eventReducers: {
         readonly hardwareWalletConnectedAssetNames: (state: HardwareWalletsState, payload: boolean) => {
             walletAccountNameToConnectedAssetNamesMap: boolean;
+            signingRequests: SigningRequestState;
+        };
+        readonly hardwareWalletSigningRequests: (state: HardwareWalletsState, payload: SigningRequestState) => {
+            signingRequests: SigningRequestState;
+            walletAccountNameToConnectedAssetNamesMap: import("../atoms/index.js").WalletAccountNameToConnectedAssetNamesMap;
         };
     };
-    readonly selectorDefinitions: {
+    readonly selectorDefinitions: ({
         readonly id: "isAssetNameConnectedForWalletAccount";
         readonly selectorFactory: (selfSelector: any) => any;
         readonly dependencies: readonly [{
             readonly selector: string;
         }];
-    }[];
+    } | {
+        readonly id: "getSigningRequests";
+        readonly resultFunction: (self: HardwareWalletsState) => SigningRequestState;
+        readonly dependencies: readonly [{
+            readonly selector: string;
+        }];
+    })[];
 };
 export default hardwareWalletsReduxDefinition;

package/lib/redux/index.js

@@ -10,6 +10,10 @@ const hardwareWalletsReduxDefinition = {
             ...state,
             walletAccountNameToConnectedAssetNamesMap: payload,
         }),
+        hardwareWalletSigningRequests: (state, payload) => ({
+            ...state,
+            signingRequests: payload,
+        }),
     },
     selectorDefinitions,
 };

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

@@ -1,6 +1,8 @@
 import type { WalletAccountNameToConnectedAssetNamesMap } from '../atoms/index.js';
+import type { SigningRequestState } from '../module/interfaces.js';
 export type HardwareWalletsState = {
     walletAccountNameToConnectedAssetNamesMap: WalletAccountNameToConnectedAssetNamesMap;
+    signingRequests: SigningRequestState;
 };
 declare const initialState: HardwareWalletsState;
 export default initialState;

package/lib/redux/initial-state.js

@@ -1,4 +1,5 @@
 const initialState = {
     walletAccountNameToConnectedAssetNamesMap: Object.create(null),
+    signingRequests: Object.create(null),
 };
 export default initialState;

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

@@ -0,0 +1,9 @@
+import type { HardwareWalletsState } from '../initial-state.js';
+declare const assetDataSelectorDefinition: {
+    readonly id: "getSigningRequests";
+    readonly resultFunction: (self: HardwareWalletsState) => import("../../module/interfaces.js").SigningRequestState;
+    readonly dependencies: readonly [{
+        readonly selector: string;
+    }];
+};
+export default assetDataSelectorDefinition;

package/lib/redux/selectors/getSigningRequests.js

@@ -0,0 +1,8 @@
+import { MY_STATE } from '@exodus/redux-dependency-injection';
+const resultFunction = (self) => self.signingRequests;
+const assetDataSelectorDefinition = {
+    id: 'getSigningRequests',
+    resultFunction,
+    dependencies: [{ selector: MY_STATE }],
+};
+export default assetDataSelectorDefinition;

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

@@ -1,8 +1,14 @@
-declare const hardwareWalletsSelectors: {
+declare const hardwareWalletsSelectors: ({
     readonly id: "isAssetNameConnectedForWalletAccount";
     readonly selectorFactory: (selfSelector: any) => any;
     readonly dependencies: readonly [{
         readonly selector: string;
     }];
-}[];
+} | {
+    readonly id: "getSigningRequests";
+    readonly resultFunction: (self: import("../initial-state.js").HardwareWalletsState) => import("../../module/interfaces.js").SigningRequestState;
+    readonly dependencies: readonly [{
+        readonly selector: string;
+    }];
+})[];
 export default hardwareWalletsSelectors;

package/lib/redux/selectors/index.js

@@ -1,3 +1,7 @@
 import isAssetNameConnectedForWalletAccountSelectorDefinition from './isAssetNameConnectedForWalletAccount.js';
-const hardwareWalletsSelectors = [isAssetNameConnectedForWalletAccountSelectorDefinition];
+import getSigningRequests from './getSigningRequests.js';
+const hardwareWalletsSelectors = [
+    isAssetNameConnectedForWalletAccountSelectorDefinition,
+    getSigningRequests,
+];
 export default hardwareWalletsSelectors;

package/lib/tsconfig.build.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/index.ts","../src/types.d.ts","../src/api/index.ts","../src/atoms/hardwareWalletSigningRequestsAtom.ts","../src/atoms/index.ts","../src/module/hardware-wallets.ts","../src/module/index.ts","../src/module/interfaces.ts","../src/plugin/index.ts","../src/redux/id.ts","../src/redux/index.ts","../src/redux/initial-state.ts","../src/redux/selectors/getSigningRequests.ts","../src/redux/selectors/index.ts","../src/redux/selectors/isAssetNameConnectedForWalletAccount.ts","../src/shared/types.d.ts"],"version":"5.8.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/hardware-wallets",
-  "version": "2.1.0",
+  "version": "3.0.1",
   "description": "An Exodus SDK feature that provides a high level abstraction for interacting with hardware wallet devices",
   "author": "Exodus Movement, Inc.",
   "repository": {
@@ -37,19 +37,20 @@
     "@exodus/redux-dependency-injection": "^4.0.0",
     "@exodus/wild-emitter": "^1.1.0",
     "delay": "^5.0.0",
+    "make-concurrent": "^5.4.0",
     "minimalistic-assert": "^1.0.1",
+    "p-defer": "^4.0.1",
     "reselect": "^3.0.1"
   },
   "devDependencies": {
     "@exodus/dependency-types": "^2.1.1",
     "@exodus/key-identifier": "^1.3.0",
     "@exodus/logger": "^1.2.3",
-    "@exodus/public-key-provider": "^4.1.1",
-    "p-defer": "^4.0.1",
+    "@exodus/public-key-provider": "^4.2.0",
     "redux": "^4.2.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "889c5877fb5d799d27c4d1b756329c7c0effbeec"
+  "gitHead": "7fb146fc50144206709f1de7d08b346191ef5a13"
 }