@exodus/hardware-wallets 1.5.1 → 1.7.0

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.
 
+## [1.7.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hardware-wallets@1.6.0...@exodus/hardware-wallets@1.7.0) (2024-11-13)
+
+### Features
+
+- feat: add isAssetNameConnectedForWalletAccountSelector (#10416)
+
+## [1.6.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hardware-wallets@1.5.1...@exodus/hardware-wallets@1.6.0) (2024-10-22)
+
+### Features
+
+- support cancelling an action on the ledger device ([#10105](https://github.com/ExodusMovement/exodus-hydra/issues/10105)) ([f1c1fbf](https://github.com/ExodusMovement/exodus-hydra/commit/f1c1fbff6ec70b7ddc68dd700ffb556b673b7a5a))
+
+### Bug Fixes
+
+- catch xpub key identifier errrors ([#10124](https://github.com/ExodusMovement/exodus-hydra/issues/10124)) ([7cd681d](https://github.com/ExodusMovement/exodus-hydra/commit/7cd681deec14adfa9c3e7613f276f2745f1df441))
+
 ## [1.5.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hardware-wallets@1.5.0...@exodus/hardware-wallets@1.5.1) (2024-10-17)
 
 ### Bug Fixes

package/lib/atoms/index.d.ts

@@ -0,0 +1,11 @@
+type WalletAccountName = string;
+type AssetName = string;
+export type WalletAccountNameToConnectedAssetNamesMap = Record<WalletAccountName, AssetName[]>;
+export declare const createHardwareWalletConnectedAssetNamesAtom: ({ assetsModule, hardwareWalletPublicKeysAtom, walletAccountsAtom, }: any) => import("@exodus/atoms").ReadonlyAtom<unknown>;
+export declare const hardwareWalletConnectedAssetNamesAtomDefinition: {
+    readonly id: "hardwareWalletConnectedAssetNamesAtom";
+    readonly type: "atom";
+    readonly factory: ({ assetsModule, hardwareWalletPublicKeysAtom, walletAccountsAtom, }: any) => import("@exodus/atoms").ReadonlyAtom<unknown>;
+    readonly dependencies: readonly ["hardwareWalletPublicKeysAtom", "assetsModule", "walletAccountsAtom"];
+};
+export {};

package/lib/atoms/index.js

@@ -0,0 +1,43 @@
+import { combine, compute } from '@exodus/atoms';
+import { memoize } from '@exodus/basic-utils';
+import { HARDENED_OFFSET } from '@exodus/bip32';
+export const createHardwareWalletConnectedAssetNamesAtom = ({ assetsModule, hardwareWalletPublicKeysAtom, walletAccountsAtom, }) => {
+    const selector = memoize(({ hardwareWalletPublicKeys, walletAccounts }) => {
+        const result = Object.create(null);
+        const assets = assetsModule.getAssets();
+        for (const [walletAccountName, walletAccount] of Object.entries(walletAccounts)) {
+            if (!walletAccount.isHardware) {
+                continue;
+            }
+            const derivationPaths = Object.keys(hardwareWalletPublicKeys[walletAccountName] ?? Object.create(null));
+            if (derivationPaths.length === 0) {
+                continue;
+            }
+            const bip44Regex = /^m\/\d+'\/(\d+)'/u;
+            const bip44Values = new Set(derivationPaths
+                .map((path) => {
+                const match = path.match(bip44Regex);
+                return match ? match[1] : null;
+            })
+                .filter(Boolean));
+            const syncedAssetNames = Object.values(assets)
+                .filter((asset) => bip44Values.has(String(asset.baseAsset.bip44 - HARDENED_OFFSET)))
+                .map((asset) => asset.name);
+            result[walletAccountName] = syncedAssetNames;
+        }
+        return result;
+    }, (deps) => JSON.stringify(deps));
+    return compute({
+        atom: combine({
+            hardwareWalletPublicKeys: hardwareWalletPublicKeysAtom,
+            walletAccounts: walletAccountsAtom,
+        }),
+        selector,
+    });
+};
+export const hardwareWalletConnectedAssetNamesAtomDefinition = {
+    id: 'hardwareWalletConnectedAssetNamesAtom',
+    type: 'atom',
+    factory: createHardwareWalletConnectedAssetNamesAtom,
+    dependencies: ['hardwareWalletPublicKeysAtom', 'assetsModule', 'walletAccountsAtom'],
+};

package/lib/index.d.ts

@@ -36,6 +36,27 @@ declare const hardwareWallets: () => {
             readonly dependencies: readonly ["assetsModule", "logger", "ledgerDiscovery", "userInterface", "publicKeyStore", "wallet", "walletAccountsAtom", "walletAccounts"];
             readonly public: true;
         };
+    }, {
+        readonly definition: {
+            readonly id: "hardwareWalletConnectedAssetNamesAtom";
+            readonly type: "atom";
+            readonly factory: ({ assetsModule, hardwareWalletPublicKeysAtom, walletAccountsAtom, }: any) => import("libraries/atoms/lib/index.js").ReadonlyAtom<unknown>;
+            readonly dependencies: readonly ["hardwareWalletPublicKeysAtom", "assetsModule", "walletAccountsAtom"];
+        };
+    }, {
+        readonly definition: {
+            readonly id: "hardwareWalletsPlugin";
+            readonly type: "plugin";
+            readonly factory: ({ hardwareWalletConnectedAssetNamesAtom, port, }: {
+                hardwareWalletConnectedAssetNamesAtom: import("libraries/atoms/lib/index.js").Atom<import("./atoms/index.js").WalletAccountNameToConnectedAssetNamesMap>;
+                port: import("./shared/types.js").Port;
+            }) => {
+                onUnlock: () => void;
+                onLoad: () => void;
+                onStop: () => void;
+            };
+            readonly dependencies: readonly ["hardwareWalletConnectedAssetNamesAtom", "port"];
+        };
     }];
 };
 export type HardwareWalletsApi = ReturnType<typeof hardwareWalletsApiDefinition.factory>;

package/lib/index.js

@@ -1,5 +1,7 @@
 import hardwareWalletsApiDefinition from './api/index.js';
 import hardwareWalletsModuleDefinition from './module/hardware-wallets.js';
+import { hardwareWalletConnectedAssetNamesAtomDefinition } from './atoms/index.js';
+import hardwareWalletsPluginDefinition from './plugin/index.js';
 const hardwareWallets = () => {
     return {
         id: 'hardwareWallets',
@@ -10,6 +12,12 @@ const hardwareWallets = () => {
             {
                 definition: hardwareWalletsModuleDefinition,
             },
+            {
+                definition: hardwareWalletConnectedAssetNamesAtomDefinition,
+            },
+            {
+                definition: hardwareWalletsPluginDefinition,
+            },
         ],
     };
 };

package/lib/module/hardware-wallets.js

@@ -1,7 +1,7 @@
 import assert from 'minimalistic-assert';
 import { WalletAccount } from '@exodus/models';
 import Emitter from '@exodus/wild-emitter';
-import randomBytes from 'randombytes';
+import { randomBytes } from '@exodus/crypto/randomBytes';
 import delay from 'delay';
 import { NoDeviceFoundError, UserRefusedError } from '@exodus/hw-common';
 export class HardwareWallets {
@@ -52,6 +52,7 @@ export class HardwareWallets {
                 };
                 const result = await Promise.race([approvePromise, runSign()]);
                 if (typeof result === 'object' && result.tryAgain === false) {
+                    device.cancelAction();
                     throw new UserRefusedError(false);
                 }
                 this.#requestUserAction({ scenario: 'completed' });
@@ -183,28 +184,32 @@ export class HardwareWallets {
         });
     };
     #getXPUB = async ({ device, baseAsset, purpose, accountIndex, }) => {
-        const keyIdentifier = baseAsset.api.getKeyIdentifier({
-            compatibilityMode: 'ledger',
-            purpose,
-            accountIndex,
-            chainIndex: undefined,
-            addressIndex: undefined,
-        });
-        const { derivationPath } = keyIdentifier;
-        const xpub = await device
-            .getXPub({
-            assetName: baseAsset.name,
-            derivationPath,
-        })
-            .catch((error) => {
-            if (error.name === 'XPubUnsupportedError') {
-                this.#logger.warn(`Retrieving XPUBs for ${baseAsset.name} is not supported`, error);
+        try {
+            const keyIdentifier = baseAsset.api.getKeyIdentifier({
+                compatibilityMode: 'ledger',
+                purpose,
+                accountIndex,
+                chainIndex: undefined,
+                addressIndex: undefined,
+            });
+            const { derivationPath } = keyIdentifier;
+            const xpub = await device.getXPub({
+                assetName: baseAsset.name,
+                derivationPath,
+            });
+            if (xpub) {
+                return { keyIdentifier, xpub };
             }
-            else {
-                throw error;
+            return null;
+        }
+        catch (error) {
+            if (error.name === 'XPubUnsupportedError' ||
+                error.message.includes(`XPUB derivation is not allowed`)) {
+                this.#logger.warn(`Retrieving XPUBs for ${baseAsset.name} is not supported`, error);
+                return null;
             }
-        });
-        return xpub ? { keyIdentifier, xpub } : null;
+            throw error;
+        }
     };
     #getPublicKey = async ({ device, baseAsset, purpose, accountIndex, }) => {
         const keyIdentifier = baseAsset.api.getKeyIdentifier({

package/lib/module/interfaces.d.ts

@@ -17,6 +17,7 @@ export interface HardwareSignerProvider {
 type Asset = {
     name: string;
     baseAsset: Asset;
+    bip44: number;
     api: {
         getKeyIdentifier(params: {
             purpose: number;

package/lib/plugin/index.d.ts

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

package/lib/plugin/index.js

@@ -0,0 +1,34 @@
+import { createAtomObserver } from '@exodus/atoms';
+const createHardwareWalletsPlugin = ({ hardwareWalletConnectedAssetNamesAtom, port, }) => {
+    const observers = [
+        createAtomObserver({
+            atom: hardwareWalletConnectedAssetNamesAtom,
+            port,
+            event: 'hardwareWalletConnectedAssetNames',
+        }),
+    ];
+    observers.forEach((observer) => observer.register());
+    const start = () => {
+        observers.forEach((observer) => observer.start());
+    };
+    const stop = () => {
+        observers.forEach((observer) => observer.unregister());
+    };
+    const onUnlock = () => {
+        start();
+    };
+    const onLoad = () => {
+        start();
+    };
+    const onStop = () => {
+        stop();
+    };
+    return { onUnlock, onLoad, onStop };
+};
+const hardwareWalletsPluginDefinition = {
+    id: 'hardwareWalletsPlugin',
+    type: 'plugin',
+    factory: createHardwareWalletsPlugin,
+    dependencies: ['hardwareWalletConnectedAssetNamesAtom', 'port'],
+};
+export default hardwareWalletsPluginDefinition;

package/lib/redux/id.d.ts

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

package/lib/redux/id.js

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

package/lib/redux/index.d.ts

@@ -0,0 +1,22 @@
+import { type HardwareWalletsState } from './initial-state.js';
+declare const hardwareWalletsReduxDefinition: {
+    readonly id: "hardwareWallets";
+    readonly type: "redux-module";
+    readonly initialState: HardwareWalletsState;
+    readonly eventReducers: {
+        readonly hardwareWalletConnectedAssetNames: (state: HardwareWalletsState, payload: boolean) => {
+            walletAccountNameToConnectedAssetNamesMap: boolean;
+        };
+    };
+    readonly selectorDefinitions: {
+        readonly id: "isAssetNameConnectedForWalletAccount";
+        readonly selectorFactory: (selfSelector: any) => ({ walletAccountName, assetName }: {
+            walletAccountName: string;
+            assetName: string;
+        }) => import("reselect").OutputSelector<unknown, boolean, (res: HardwareWalletsState) => boolean>;
+        readonly dependencies: readonly [{
+            readonly selector: string;
+        }];
+    }[];
+};
+export default hardwareWalletsReduxDefinition;

package/lib/redux/index.js

@@ -0,0 +1,16 @@
+import id from './id.js';
+import initialState from './initial-state.js';
+import selectorDefinitions from './selectors/index.js';
+const hardwareWalletsReduxDefinition = {
+    id,
+    type: 'redux-module',
+    initialState,
+    eventReducers: {
+        hardwareWalletConnectedAssetNames: (state, payload) => ({
+            ...state,
+            walletAccountNameToConnectedAssetNamesMap: payload,
+        }),
+    },
+    selectorDefinitions,
+};
+export default hardwareWalletsReduxDefinition;

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

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

package/lib/redux/initial-state.js

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

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

@@ -0,0 +1,11 @@
+declare const hardwareWalletsSelectors: {
+    readonly id: "isAssetNameConnectedForWalletAccount";
+    readonly selectorFactory: (selfSelector: any) => ({ walletAccountName, assetName }: {
+        walletAccountName: string;
+        assetName: string;
+    }) => import("reselect").OutputSelector<unknown, boolean, (res: import("../initial-state.js").HardwareWalletsState) => boolean>;
+    readonly dependencies: readonly [{
+        readonly selector: string;
+    }];
+}[];
+export default hardwareWalletsSelectors;

package/lib/redux/selectors/index.js

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

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

@@ -0,0 +1,13 @@
+import type { HardwareWalletsState } from '../initial-state.js';
+type isAssetNameConnectedForWalletAccountParams = {
+    walletAccountName: string;
+    assetName: string;
+};
+declare const isAssetNameConnectedForWalletAccountSelectorDefinition: {
+    readonly id: "isAssetNameConnectedForWalletAccount";
+    readonly selectorFactory: (selfSelector: any) => ({ walletAccountName, assetName }: isAssetNameConnectedForWalletAccountParams) => import("reselect").OutputSelector<unknown, boolean, (res: HardwareWalletsState) => boolean>;
+    readonly dependencies: readonly [{
+        readonly selector: string;
+    }];
+};
+export default isAssetNameConnectedForWalletAccountSelectorDefinition;

package/lib/redux/selectors/isAssetNameConnectedForWalletAccount.js

@@ -0,0 +1,9 @@
+import { MY_STATE } from '@exodus/redux-dependency-injection';
+import { createSelector } from 'reselect';
+const selectorFactory = (selfSelector) => ({ walletAccountName, assetName }) => createSelector(selfSelector, ({ walletAccountNameToConnectedAssetNamesMap }) => walletAccountNameToConnectedAssetNamesMap[walletAccountName]?.includes(assetName) ?? false);
+const isAssetNameConnectedForWalletAccountSelectorDefinition = {
+    id: 'isAssetNameConnectedForWalletAccount',
+    selectorFactory,
+    dependencies: [{ selector: MY_STATE }],
+};
+export default isAssetNameConnectedForWalletAccountSelectorDefinition;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/hardware-wallets",
-  "version": "1.5.1",
+  "version": "1.7.0",
   "description": "An Exodus SDK feature that provides a high level abstraction for interacting with hardware wallet devices",
   "author": "Exodus Movement, Inc.",
   "repository": {
@@ -28,21 +28,25 @@
     "prepublishOnly": "yarn run -T build --scope @exodus/hardware-wallets"
   },
   "dependencies": {
-    "@exodus/hw-common": "^3.0.0",
+    "@exodus/atoms": "^9.0.0",
+    "@exodus/basic-utils": "^3.2.0",
+    "@exodus/bip32": "^3.3.0",
+    "@exodus/crypto": "^1.0.0-rc.18",
+    "@exodus/hw-common": "^3.1.0",
     "@exodus/models": "^12.0.1",
+    "@exodus/redux-dependency-injection": "^4.0.0",
     "@exodus/wild-emitter": "^1.1.0",
     "delay": "^5.0.0",
     "minimalistic-assert": "^1.0.1",
-    "randombytes": "^2.1.0"
+    "reselect": "^3.0.1"
   },
   "devDependencies": {
-    "@exodus/atoms": "^9.0.0",
-    "@exodus/dependency-types": "^2.1.0",
+    "@exodus/dependency-types": "^2.1.1",
     "@exodus/key-identifier": "^1.3.0",
-    "@exodus/logger": "^1.2.2",
-    "@exodus/public-key-provider": "^3.0.0",
-    "@types/randombytes": "^2.0.3",
-    "p-defer": "^4.0.1"
+    "@exodus/logger": "^1.2.3",
+    "@exodus/public-key-provider": "^4.0.0",
+    "p-defer": "^4.0.1",
+    "redux": "^4.2.1"
   },
-  "gitHead": "c74a9968861467c805398c25b4017985e976ba31"
+  "gitHead": "68e51f95fefb4e6f0135e71685337676790c665d"
 }