@exodus/hw-ledger 2.9.4 → 2.10.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.10.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@2.9.5...@exodus/hw-ledger@2.10.0) (2024-09-16)
+
+### Features
+
+- add bitcoin multisig support to ledger ([#9218](https://github.com/ExodusMovement/exodus-hydra/issues/9218)) ([1b63e8a](https://github.com/ExodusMovement/exodus-hydra/commit/1b63e8a6ac7bab9cd580f602f2fd0cbff48ed01c))
+
+## [2.9.5](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@2.9.4...@exodus/hw-ledger@2.9.5) (2024-08-16)
+
+### Bug Fixes
+
+- bluetooth on scan ([#8457](https://github.com/ExodusMovement/exodus-hydra/issues/8457)) ([c6cef7a](https://github.com/ExodusMovement/exodus-hydra/commit/c6cef7a19dad315bdbe8e01ea353f108348d48e3))
+- use safe alloc ([#8467](https://github.com/ExodusMovement/exodus-hydra/issues/8467)) ([926ef36](https://github.com/ExodusMovement/exodus-hydra/commit/926ef36d1478e8fea290b56eabab5c807e7e6695))
+
 ## [2.9.4](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@2.9.3...@exodus/hw-ledger@2.9.4) (2024-08-14)
 
 ### Bug Fixes

package/lib/atoms/index.d.ts

@@ -1,7 +1,12 @@
+import type { Storage } from 'adapters/storage-interface';
+export type BluetoothStatus = {
+    type: 'Unknown' | 'Resetting' | 'Unsupported' | 'Unauthorized' | 'PoweredOff' | 'PoweredOn';
+    available: boolean;
+};
 export declare const bluetoothStatusAtomDefinition: {
     readonly id: "bluetoothStatusAtom";
     readonly type: "atom";
-    readonly factory: () => import("@exodus/atoms").Atom<boolean>;
+    readonly factory: () => import("@exodus/atoms").Atom<BluetoothStatus>;
     readonly dependencies: readonly [];
     readonly public: true;
 };
@@ -12,3 +17,14 @@ export declare const bluetoothScanningAtomDefinition: {
     readonly dependencies: readonly [];
     readonly public: true;
 };
+type Params = {
+    storage: Storage<Record<string, Buffer>>;
+};
+export declare const walletPolicyAtomDefinition: {
+    readonly id: "walletPolicyAtom";
+    readonly type: "atom";
+    readonly factory: ({ storage }: Params) => import("@exodus/atoms").Atom<Record<string, Buffer> | {}>;
+    readonly dependencies: readonly ["storage"];
+    readonly public: true;
+};
+export {};

package/lib/atoms/index.js

@@ -1,8 +1,10 @@
-import { createInMemoryAtom } from '@exodus/atoms';
+import { createInMemoryAtom, createStorageAtomFactory } from '@exodus/atoms';
 export const bluetoothStatusAtomDefinition = {
     id: 'bluetoothStatusAtom',
     type: 'atom',
-    factory: () => createInMemoryAtom({ defaultValue: false }),
+    factory: () => createInMemoryAtom({
+        defaultValue: { type: 'Unknown', available: false },
+    }),
     dependencies: [],
     public: true,
 };
@@ -13,3 +15,17 @@ export const bluetoothScanningAtomDefinition = {
     dependencies: [],
     public: true,
 };
+export const walletPolicyAtomDefinition = {
+    id: 'walletPolicyAtom',
+    type: 'atom',
+    factory: ({ storage }) => {
+        const createStorageAtom = createStorageAtomFactory({ storage });
+        return createStorageAtom({
+            key: 'walletPolicy',
+            defaultValue: {},
+            isSoleWriter: true,
+        });
+    },
+    dependencies: ['storage'],
+    public: true,
+};

package/lib/index.d.ts

@@ -5,7 +5,7 @@ declare const hardwareWalletLedger: ({ bluetoothScannerTimeout, }?: Partial<HwLe
         readonly definition: {
             readonly id: "bluetoothStatusAtom";
             readonly type: "atom";
-            readonly factory: () => import("libraries/atoms/lib").Atom<boolean>;
+            readonly factory: () => import("libraries/atoms/lib").Atom<import("./atoms").BluetoothStatus>;
             readonly dependencies: readonly [];
             readonly public: true;
         };
@@ -17,22 +17,31 @@ declare const hardwareWalletLedger: ({ bluetoothScannerTimeout, }?: Partial<HwLe
             readonly dependencies: readonly [];
             readonly public: true;
         };
+    }, {
+        readonly definition: {
+            readonly id: "walletPolicyAtom";
+            readonly type: "atom";
+            readonly factory: ({ storage }: {
+                storage: import("adapters/storage-interface").Storage<Record<string, Buffer>>;
+            }) => import("libraries/atoms/lib").Atom<Record<string, Buffer> | {}>;
+            readonly dependencies: readonly ["storage"];
+            readonly public: true;
+        };
     }, {
         readonly definition: {
             readonly id: "hardwareWalletLedgerPlugin";
             readonly type: "plugin";
-            readonly factory: ({ logger, transportsFactories, bluetoothStatusAtom, bluetoothScanningAtom, port, }: {
-                logger: import("./shared/types").Logger;
-                transportsFactories: import("./module/types").TransportFactories;
-                bluetoothStatusAtom: import("libraries/atoms/lib").Atom<import("./redux/initial-state").BluetoothStatus>;
+            readonly factory: ({ bluetoothStatusAtom, bluetoothScanningAtom, ledgerDiscovery, port, }: {
+                bluetoothStatusAtom: import("libraries/atoms/lib").Atom<import("./atoms").BluetoothStatus>;
                 bluetoothScanningAtom: import("libraries/atoms/lib").Atom<boolean>;
+                ledgerDiscovery: import("./module").LedgerDiscovery;
                 port: import("./shared/types").Port;
             }) => {
                 onUnlock: () => void;
                 onLoad: () => void;
                 onStop: () => void;
             };
-            readonly dependencies: readonly ["logger", "transportsFactories", "bluetoothStatusAtom", "bluetoothScanningAtom", "port"];
+            readonly dependencies: readonly ["bluetoothStatusAtom", "bluetoothScanningAtom", "ledgerDiscovery", "port"];
             readonly public: true;
         };
     }, {
@@ -40,7 +49,7 @@ declare const hardwareWalletLedger: ({ bluetoothScannerTimeout, }?: Partial<HwLe
             readonly id: "ledgerDiscovery";
             readonly type: "module";
             readonly factory: (deps: import("./module").Dependencies) => import("./module").LedgerDiscovery;
-            readonly dependencies: readonly ["config", "logger", "transportsFactories", "bluetoothScanningAtom"];
+            readonly dependencies: readonly ["config", "logger", "transportsFactories", "bluetoothStatusAtom", "bluetoothScanningAtom", "walletPolicyAtom"];
             readonly public: true;
         };
         readonly config: {

package/lib/index.js

@@ -1,4 +1,4 @@
-import { bluetoothStatusAtomDefinition, bluetoothScanningAtomDefinition } from './atoms';
+import { bluetoothStatusAtomDefinition, bluetoothScanningAtomDefinition, walletPolicyAtomDefinition, } from './atoms';
 import ledgerDiscoveryDefinition from './module';
 import hardwareWalletLedgerPluginDefinition from './plugin';
 const hardwareWalletLedger = ({ bluetoothScannerTimeout = 10_000, } = {}) => {
@@ -11,6 +11,9 @@ const hardwareWalletLedger = ({ bluetoothScannerTimeout = 10_000, } = {}) => {
             {
                 definition: bluetoothScanningAtomDefinition,
             },
+            {
+                definition: walletPolicyAtomDefinition,
+            },
             {
                 definition: hardwareWalletLedgerPluginDefinition,
             },

package/lib/module/assets/bitcoin.d.ts

@@ -1,4 +1,5 @@
 import type Transport from '@ledgerhq/hw-transport';
+import type { Atom } from '@exodus/atoms';
 import type { Bytes, HardwareWalletAssetHandler } from '@exodus/hw-common';
 export interface BitcoinMessage {
     rawMessage?: Bytes;
@@ -7,7 +8,7 @@ export interface BitcoinMessage {
         message: Bytes;
     };
 }
-declare function createHandler(transport: Transport): Promise<HardwareWalletAssetHandler<BitcoinMessage>>;
+declare function createHandler(transport: Transport, walletPolicyAtom?: Atom<Record<string, Buffer>>): Promise<HardwareWalletAssetHandler<BitcoinMessage>>;
 declare const metadata: {
     applications: {
         applicationName: string;

package/lib/module/assets/bitcoin.js

@@ -3,17 +3,25 @@ import { AppClient, PsbtV2 } from '@exodus/ledger-bitcoin';
 import { BIP322 } from '@exodus/bip322-js';
 import { splitBip44DerivationPath } from './utils';
 import assert from 'minimalistic-assert';
-import { assertPsbtOnlyHasAllowedDerivationPaths, tagPsbtWithDerivationPaths, getWalletPolicy, derivationPathsToWalletPolicy, addDummyInputs, } from './utils/psbt';
+import { assertPsbtOnlyHasAllowedDerivationPaths, tagPsbtWithDerivationPaths, getWalletPolicy, getMultisigWalletPolicy, derivationPathsToWalletPolicy, addDummyInputs, } from './utils/psbt';
 import { buildBip322PSBT } from './utils/bip322';
 import applications from './applications';
-async function createHandler(transport) {
+async function createHandler(transport, walletPolicyAtom) {
     const app = new AppClient(transport);
     const getAddress = async (params) => {
         const [purpose, coin, account, change, address] = splitBip44DerivationPath(params.derivationPath);
         const fpr = await app.getMasterFingerprint();
         const xpub = await app.getExtendedPubkey(`m/${purpose}/${coin}/${account}`);
-        const walletPolicy = getWalletPolicy(fpr, xpub, purpose, coin, account);
-        return app.getWalletAddress(walletPolicy, null, Number(change), Number(address), false);
+        let walletPolicy;
+        let hmac = null;
+        if (params.multisigData) {
+            walletPolicy = getMultisigWalletPolicy(fpr, xpub, purpose, coin, account, params.multisigData);
+            hmac = await registerWalletPolicy(walletPolicy);
+        }
+        else {
+            walletPolicy = getWalletPolicy(fpr, xpub, purpose, coin, account);
+        }
+        return app.getWalletAddress(walletPolicy, hmac, Number(change), Number(address), params.displayOnDevice ?? false);
     };
     const getXPub = async (params) => {
         return app.getExtendedPubkey(params.derivationPath);
@@ -28,19 +36,30 @@ async function createHandler(transport) {
         psbt.deserialize(psbtBuffer);
         const fpr = await app.getMasterFingerprint();
         const derivationPathToPublicKeyMap = Object.create(null);
+        const addressToDerivationPathMap = Object.create(null);
         for (const derivationPath of params.derivationPaths) {
-            derivationPathToPublicKeyMap[derivationPath] = await getPublicKey({
+            if (params.multisigData) {
+                const address = await getAddress({
+                    assetName: 'bitcoin',
+                    derivationPath,
+                    multisigData: params.multisigData,
+                });
+                addressToDerivationPathMap[address] = derivationPath;
+            }
+            const publicKey = await getPublicKey({
                 assetName: 'bitcoin',
                 derivationPath,
             });
+            derivationPathToPublicKeyMap[derivationPath] = publicKey;
         }
-        tagPsbtWithDerivationPaths(psbt, fpr, derivationPathToPublicKeyMap);
+        tagPsbtWithDerivationPaths(psbt, fpr, derivationPathToPublicKeyMap, addressToDerivationPathMap);
         addDummyInputs(psbt);
         assertPsbtOnlyHasAllowedDerivationPaths(psbt, fpr, params.derivationPaths);
         const signatures = [];
-        const walletPolicies = await derivationPathsToWalletPolicy(fpr, app, params.derivationPaths);
+        const walletPolicies = await derivationPathsToWalletPolicy(fpr, app, params.derivationPaths, params.multisigData);
         for (const walletPolicy of walletPolicies) {
-            const _signatures = await app.signPsbt(psbt.serialize(), walletPolicy, null);
+            const hmac = params.multisigData ? await registerWalletPolicy(walletPolicy) : null;
+            const _signatures = await app.signPsbt(psbt.serialize(), walletPolicy, hmac);
             signatures.push(..._signatures);
         }
         const result = signatures.map(([inputIndex, partialSignature]) => ({
@@ -95,6 +114,18 @@ async function createHandler(transport) {
         }
         throw new Error('rawMessage or bip322Message must be defined');
     };
+    const registerWalletPolicy = async (walletPolicy) => {
+        const walletPolicies = (await walletPolicyAtom?.get()) ?? {};
+        const id = walletPolicy.getId().toString('hex');
+        let hmac = walletPolicies[id];
+        if (!hmac) {
+            const [, h] = await app.registerWallet(walletPolicy);
+            hmac = h;
+            const updatedPolicies = { ...walletPolicies, [id]: hmac };
+            await walletPolicyAtom?.set(updatedPolicies);
+        }
+        return hmac;
+    };
     return {
         getAddress,
         getPublicKey,

package/lib/module/assets/ethereum.js

@@ -1,7 +1,7 @@
 import secp256k1 from '@exodus/secp256k1';
 import * as ethers from '@exodus/ethersproject-transactions';
 import AppEth, { ledgerService } from '@exodus/ledgerhq-hw-app-eth';
-import { TypedDataUtils, SignTypedDataVersion, } from '@metamask/eth-sig-util';
+import { TypedDataUtils, SignTypedDataVersion } from '@metamask/eth-sig-util';
 import assert from 'minimalistic-assert';
 import { buildFauxXPUB } from './utils';
 import { RequiresBlindSigningError } from '../errors';

package/lib/module/assets/index.d.ts

@@ -1,6 +1,7 @@
 import type Transport from '@ledgerhq/hw-transport';
 import type { HardwareWalletAssetHandler } from '@exodus/hw-common';
-type HandlerFactory = (transport: Transport) => Promise<HardwareWalletAssetHandler>;
+import type { Atom } from '@exodus/atoms';
+type HandlerFactory = (transport: Transport, walletPolicyAtom?: Atom<Record<string, Buffer>>) => Promise<HardwareWalletAssetHandler>;
 type AssetMetadata = {
     applications: {
         applicationName: string;

package/lib/module/assets/index.js

@@ -7,6 +7,7 @@ import applications from './applications';
 export const assetApplications = {
     basemainnet,
     bitcoin,
+    bitcoinregtest: bitcoin,
     matic,
     solana,
     ethereum,

package/lib/module/assets/utils/psbt.d.ts

@@ -1,6 +1,10 @@
-import { DefaultWalletPolicy, PsbtV2, WalletPolicy } from '@exodus/ledger-bitcoin';
+import type { PsbtV2 } from '@exodus/ledger-bitcoin';
+import { DefaultWalletPolicy, WalletPolicy } from '@exodus/ledger-bitcoin';
+import type { MultisigData } from 'libraries/hw-common/lib';
 export declare function assertPsbtOnlyHasAllowedDerivationPaths(psbt: PsbtV2, masterFingerprint: string, derivationPaths: string[]): void;
-export declare function tagPsbtWithDerivationPaths(psbt: PsbtV2, masterFingerprint: string, derivationPathToPublicKeyMap: Record<string, Buffer>): void;
+export declare function tagPsbtWithDerivationPaths(psbt: PsbtV2, masterFingerprint: string, derivationPathToPublicKeyMap: Record<string, Buffer>, addressToDerivationPathMap?: Record<string, string>): void;
 export declare const getWalletPolicy: (fpr: string, xpub: string, purpose: string, coin: string, account: string) => DefaultWalletPolicy;
-export declare function derivationPathsToWalletPolicy(fpr: string, app: any, derivationPaths: string[]): Promise<WalletPolicy[]>;
+export declare const DUMMY_TAPROOT_XPUB = "xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6QgnecKFpJFPpdzxKrwoaZoV44qAJewsc4kX9vGaCaBExuvJH57";
+export declare const getMultisigWalletPolicy: (fpr: string, xpub: string, purpose: string, coin: string, account: string, multisigData: MultisigData) => WalletPolicy;
+export declare function derivationPathsToWalletPolicy(fpr: string, app: any, derivationPaths: string[], multisigData?: MultisigData): Promise<WalletPolicy[]>;
 export declare function addDummyInputs(psbt: PsbtV2): void;

package/lib/module/assets/utils/psbt.js

@@ -1,6 +1,6 @@
 import assert from 'minimalistic-assert';
-import { DefaultWalletPolicy, } from '@exodus/ledger-bitcoin';
-import { payments } from '@exodus/bitcoinjs-lib';
+import { DefaultWalletPolicy, WalletPolicy } from '@exodus/ledger-bitcoin';
+import { payments, address as baddress } from '@exodus/bitcoinjs-lib';
 import { buildBip44PathFromNumber, assertBip44PathNumber, splitBip44PathToNumber, splitBip44DerivationPath, } from './derivation-paths';
 export function assertPsbtOnlyHasAllowedDerivationPaths(psbt, masterFingerprint, derivationPaths) {
     for (let i = 0; i < psbt.getGlobalInputCount(); i++) {
@@ -31,14 +31,21 @@ function assertAllowedDerivation(bip32Derivation, masterFingerprint, derivationP
         assert(derivationPaths.includes(derivationPath), `found unsupported derivation path: ${derivationPath}`);
     }
 }
-export function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPathToPublicKeyMap) {
+export function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPathToPublicKeyMap, addressToDerivationPathMap) {
     const masterFingerprintBuffer = Buffer.from(masterFingerprint, 'hex');
     const scriptPubKeyToDerivationPathMap = computeScriptPubKeyToDerivationPathMap(derivationPathToPublicKeyMap);
     for (let inputIndex = 0; inputIndex < psbt.getGlobalInputCount(); inputIndex++) {
         const witnessUtxo = psbt.getInputWitnessUtxo(inputIndex);
         assert(witnessUtxo, `witnessUtxo is currently the only supported type`);
         const scriptPubKey = witnessUtxo.scriptPubKey.toString('hex');
-        const derivationPath = scriptPubKeyToDerivationPathMap[scriptPubKey];
+        let derivationPath = scriptPubKeyToDerivationPathMap[scriptPubKey];
+        if (addressToDerivationPathMap && !derivationPath) {
+            try {
+                const address = baddress.fromOutputScript(witnessUtxo.scriptPubKey);
+                derivationPath = addressToDerivationPathMap[address];
+            }
+            catch { }
+        }
         if (derivationPath) {
             const publicKey = derivationPathToPublicKeyMap[derivationPath];
             assert(Buffer.isBuffer(publicKey), `no public key found for derivation path`);
@@ -53,7 +60,14 @@ export function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPa
     }
     for (let outputIndex = 0; outputIndex < psbt.getGlobalOutputCount(); outputIndex++) {
         const scriptPubKey = psbt.getOutputScript(outputIndex);
-        const derivationPath = scriptPubKeyToDerivationPathMap[scriptPubKey.toString('hex')];
+        let derivationPath = scriptPubKeyToDerivationPathMap[scriptPubKey.toString('hex')];
+        if (addressToDerivationPathMap && !derivationPath) {
+            try {
+                const address = baddress.fromOutputScript(scriptPubKey);
+                derivationPath = addressToDerivationPathMap[address];
+            }
+            catch { }
+        }
         if (derivationPath) {
             const publicKey = derivationPathToPublicKeyMap[derivationPath];
             assert(Buffer.isBuffer(publicKey), `no public key found for derivation path`);
@@ -104,7 +118,23 @@ export const getWalletPolicy = (fpr, xpub, purpose, coin, account) => {
     }[purpose];
     return new DefaultWalletPolicy(desc, `[${fpr}/${purpose}/${coin}/${account}]${xpub}`);
 };
-export async function derivationPathsToWalletPolicy(fpr, app, derivationPaths) {
+export const DUMMY_TAPROOT_XPUB = 'xpub661MyMwAqRbcEYS8w7XLSVeEsBXy79zSzH1J8vCdxAZningWLdN3zgtU6QgnecKFpJFPpdzxKrwoaZoV44qAJewsc4kX9vGaCaBExuvJH57';
+export const getMultisigWalletPolicy = (fpr, xpub, purpose, coin, account, multisigData) => {
+    let template = `tr(@0/**,sortedmulti_a(${multisigData.threshold}`;
+    const keys = [DUMMY_TAPROOT_XPUB];
+    multisigData.xpubs.forEach((xpub2, i) => {
+        if (xpub === xpub2) {
+            keys.push(`[${fpr}/${purpose}/${coin}/${account}]${xpub}`);
+        }
+        else {
+            keys.push(xpub2);
+        }
+        template += `,@${i + 1}/**`;
+    });
+    template += '))';
+    return new WalletPolicy('Multisig', template, keys);
+};
+export async function derivationPathsToWalletPolicy(fpr, app, derivationPaths, multisigData) {
     const splittedDerivationPaths = derivationPaths.map(splitBip44DerivationPath);
     const dedupedPaths = Object.values(splittedDerivationPaths.reduce((prev, splittedDerivationPath) => {
         const [purpose, coin, account] = splittedDerivationPath;
@@ -115,7 +145,12 @@ export async function derivationPathsToWalletPolicy(fpr, app, derivationPaths) {
     for (const dedupedPath of dedupedPaths) {
         const [purpose, coin, account] = dedupedPath;
         const xpub = await app.getExtendedPubkey(`m/${purpose}/${coin}/${account}`);
-        walletPolicies.push(getWalletPolicy(fpr, xpub, purpose, coin, account));
+        if (multisigData) {
+            walletPolicies.push(getMultisigWalletPolicy(fpr, xpub, purpose, coin, account, multisigData));
+        }
+        else {
+            walletPolicies.push(getWalletPolicy(fpr, xpub, purpose, coin, account));
+        }
     }
     return walletPolicies;
 }

package/lib/module/assets/utils/xpub.js

@@ -2,7 +2,7 @@ import bs58check from 'bs58check';
 export function buildFauxXPUB(publicKey, chainCode) {
     const LEN = 78;
     const XPUB_PREFIX = 0x04_88_b2_1e;
-    const buffer = Buffer.allocUnsafe(LEN);
+    const buffer = Buffer.alloc(LEN);
     const fingerprint = 0x00_00_00_00;
     const depth = 0;
     const index = 0;

package/lib/module/device.d.ts

@@ -1,13 +1,15 @@
 import type { GetAddressParams, GetPublicKeyParams, GetXPubParams, HardwareWalletDevice, SignMessageParams, SignTransactionParams } from '@exodus/hw-common';
 import type { TransportFactory } from './types';
+import type { Atom } from '@exodus/atoms';
 export type Descriptor = unknown;
 export type Dependencies = {
     transportFactory: TransportFactory;
     descriptor: Descriptor;
+    walletPolicyAtom: Atom<Record<string, Buffer>>;
 };
 export declare class LedgerDevice implements HardwareWalletDevice {
     #private;
-    constructor({ transportFactory, descriptor }: Dependencies);
+    constructor({ transportFactory, descriptor, walletPolicyAtom }: Dependencies);
     ensureApplicationIsOpened: (baseAssetName: string) => Promise<void>;
     listSupportedAssetNames: () => Promise<string[]>;
     listInstalledAssetNames: () => Promise<string[]>;

package/lib/module/device.js

@@ -6,9 +6,11 @@ import { UnsupportedVersionError, ApplicationNotFoundError } from './errors';
 export class LedgerDevice {
     #transportFactory;
     #descriptor;
-    constructor({ transportFactory, descriptor }) {
+    #walletPolicyAtom;
+    constructor({ transportFactory, descriptor, walletPolicyAtom }) {
         this.#transportFactory = transportFactory;
         this.#descriptor = descriptor;
+        this.#walletPolicyAtom = walletPolicyAtom;
     }
     #runInSession = async (operation, expectErrorWhenClosing = false) => {
         const transport = await this.#transportFactory.open(this.#descriptor);
@@ -119,7 +121,7 @@ export class LedgerDevice {
     getAddress = async (params) => {
         await this.ensureApplicationIsOpened(params.assetName);
         return this.#runInSession(async (transport) => {
-            const handler = await this.#getAssetApplication(params.assetName).handler(transport);
+            const handler = await this.#getAssetApplication(params.assetName).handler(transport, this.#walletPolicyAtom);
             return handler.getAddress(params);
         });
     };
@@ -140,7 +142,7 @@ export class LedgerDevice {
     signTransaction = async (params) => {
         await this.ensureApplicationIsOpened(params.assetName);
         return this.#runInSession(async (transport) => {
-            const handler = await this.#getAssetApplication(params.assetName).handler(transport);
+            const handler = await this.#getAssetApplication(params.assetName).handler(transport, this.#walletPolicyAtom);
             return handler.signTransaction(params);
         });
     };

package/lib/module/discovery.d.ts

@@ -1,26 +1,31 @@
-import { Logger } from '../shared/types';
+import type { Logger } from '../shared/types';
 import type { Atom } from '@exodus/atoms';
 import type { HardwareWalletDescriptor, HardwareWalletDiscovery } from '@exodus/hw-common';
 import type { HwLedgerConfig, TransportFactories } from './types';
+import type { BluetoothStatus } from '../atoms';
 export type Dependencies = {
     config: HwLedgerConfig;
     logger: Logger;
     transportsFactories: TransportFactories;
+    bluetoothStatusAtom: Atom<BluetoothStatus>;
     bluetoothScanningAtom: Atom<boolean>;
+    walletPolicyAtom: Atom<Record<string, Buffer>>;
 };
 export declare class LedgerDiscovery implements HardwareWalletDiscovery {
     #private;
-    constructor({ config, logger, transportsFactories, bluetoothScanningAtom }: Dependencies);
+    constructor({ config, logger, transportsFactories, bluetoothStatusAtom, bluetoothScanningAtom, walletPolicyAtom, }: Dependencies);
+    start: () => void;
     scan: () => Promise<void>;
     stopScan: (clearDevices?: boolean) => void;
     list: () => Promise<HardwareWalletDescriptor[]>;
     getFirstDevice: () => Promise<import("@exodus/hw-common").HardwareWalletDevice<import("@exodus/hw-common").Message>>;
+    stop: () => Promise<void>;
 }
 declare const _default: {
     readonly id: "ledgerDiscovery";
     readonly type: "module";
     readonly factory: (deps: Dependencies) => LedgerDiscovery;
-    readonly dependencies: readonly ["config", "logger", "transportsFactories", "bluetoothScanningAtom"];
+    readonly dependencies: readonly ["config", "logger", "transportsFactories", "bluetoothStatusAtom", "bluetoothScanningAtom", "walletPolicyAtom"];
     readonly public: true;
 };
 export default _default;

package/lib/module/discovery.js

@@ -7,12 +7,17 @@ export class LedgerDiscovery {
     #logger;
     #transportsFactories;
     #scannerTimeout;
+    #statusBluetooth;
+    #bluetoothStatusAtom;
     #scannerBluetooth;
     #bluetoothScanningAtom;
+    #walletPolicyAtom;
     #discoveredBluetoothDevices = Object.create(null);
-    constructor({ config, logger, transportsFactories, bluetoothScanningAtom }) {
+    constructor({ config, logger, transportsFactories, bluetoothStatusAtom, bluetoothScanningAtom, walletPolicyAtom, }) {
         this.#logger = logger;
+        this.#bluetoothStatusAtom = bluetoothStatusAtom;
         this.#bluetoothScanningAtom = bluetoothScanningAtom;
+        this.#walletPolicyAtom = walletPolicyAtom;
         if (!(typeof transportsFactories === 'object' &&
             Object.keys(transportsFactories).length > 0 &&
             Object.entries(transportsFactories).every(([transportName, transportFactory]) => ['usb', 'bluetooth', 'tcp'].includes(transportName) &&
@@ -26,7 +31,26 @@ export class LedgerDiscovery {
         this.#transportsFactories = transportsFactories;
         this.#scannerTimeout = config.bluetoothScannerTimeout;
     }
+    start = () => {
+        if (!this.#transportsFactories.bluetooth)
+            return;
+        if (this.#statusBluetooth)
+            return;
+        if (this.#transportsFactories.bluetooth.observeState) {
+            this.#statusBluetooth = this.#transportsFactories.bluetooth.observeState({
+                next: ({ type, available }) => this.#bluetoothStatusAtom.set({ type, available }),
+                error: (error) => this.#logger.error(error),
+            });
+        }
+        else if (this.#transportsFactories.bluetooth.observeAvailability) {
+            this.#statusBluetooth = this.#transportsFactories.bluetooth.observeAvailability({
+                next: (available) => this.#bluetoothStatusAtom.set({ type: 'Unknown', available }),
+                error: (error) => this.#logger.error(error),
+            });
+        }
+    };
     scan = async () => {
+        this.start();
         return new Promise((resolve, reject) => {
             if (this.#transportsFactories.bluetooth) {
                 this.stopScan(true);
@@ -79,7 +103,11 @@ export class LedgerDiscovery {
                             manufacturer: 'ledger',
                             transport: 'usb',
                             model: deviceModel?.id ?? 'unknown',
-                            get: async () => new LedgerDevice({ transportFactory, descriptor: hidDevice }),
+                            get: async () => new LedgerDevice({
+                                transportFactory,
+                                descriptor: hidDevice,
+                                walletPolicyAtom: this.#walletPolicyAtom,
+                            }),
                         };
                     });
                     descriptors.push(...usbDeviceList);
@@ -93,7 +121,11 @@ export class LedgerDiscovery {
                             manufacturer: 'ledger',
                             transport: 'bluetooth',
                             model: deviceModel?.id ?? 'unknown',
-                            get: async () => new LedgerDevice({ transportFactory, descriptor: bluetoothDevice }),
+                            get: async () => new LedgerDevice({
+                                transportFactory,
+                                descriptor: bluetoothDevice,
+                                walletPolicyAtom: this.#walletPolicyAtom,
+                            }),
                         };
                     });
                     descriptors.push(...bluetoothDeviceList);
@@ -107,6 +139,7 @@ export class LedgerDiscovery {
                         get: async () => new LedgerDevice({
                             transportFactory,
                             descriptor: { apduPort: APDU_PORT },
+                            walletPolicyAtom: this.#walletPolicyAtom,
                         }),
                     });
                     break;
@@ -123,12 +156,22 @@ export class LedgerDiscovery {
         }
         throw new NoDeviceFoundError();
     };
+    stop = async () => {
+        this.#statusBluetooth?.unsubscribe();
+    };
 }
 const createLedgerDiscovery = (deps) => new LedgerDiscovery({ ...deps });
 export default {
     id: MODULE_ID,
     type: 'module',
     factory: createLedgerDiscovery,
-    dependencies: ['config', 'logger', 'transportsFactories', 'bluetoothScanningAtom'],
+    dependencies: [
+        'config',
+        'logger',
+        'transportsFactories',
+        'bluetoothStatusAtom',
+        'bluetoothScanningAtom',
+        'walletPolicyAtom',
+    ],
     public: true,
 };

package/lib/plugin/index.d.ts

@@ -1,22 +1,21 @@
 import type { Atom } from '@exodus/atoms';
-import type { TransportFactories } from '../module/types';
-import type { Logger, Port } from '../shared/types';
-import { BluetoothStatus } from '../redux/initial-state';
+import type { Port } from '../shared/types';
+import type { BluetoothStatus } from '../atoms';
+import type { LedgerDiscovery } from '../module';
 declare const hardwareWalletLedgerPluginDefinition: {
     readonly id: "hardwareWalletLedgerPlugin";
     readonly type: "plugin";
-    readonly factory: ({ logger, transportsFactories, bluetoothStatusAtom, bluetoothScanningAtom, port, }: {
-        logger: Logger;
-        transportsFactories: TransportFactories;
+    readonly factory: ({ bluetoothStatusAtom, bluetoothScanningAtom, ledgerDiscovery, port, }: {
         bluetoothStatusAtom: Atom<BluetoothStatus>;
         bluetoothScanningAtom: Atom<boolean>;
+        ledgerDiscovery: LedgerDiscovery;
         port: Port;
     }) => {
         onUnlock: () => void;
         onLoad: () => void;
         onStop: () => void;
     };
-    readonly dependencies: readonly ["logger", "transportsFactories", "bluetoothStatusAtom", "bluetoothScanningAtom", "port"];
+    readonly dependencies: readonly ["bluetoothStatusAtom", "bluetoothScanningAtom", "ledgerDiscovery", "port"];
     readonly public: true;
 };
 export default hardwareWalletLedgerPluginDefinition;

package/lib/plugin/index.js

@@ -1,33 +1,16 @@
 import { createAtomObserver } from '@exodus/atoms';
-const createHardwareWalletLedgerPlugin = ({ logger, transportsFactories, bluetoothStatusAtom, bluetoothScanningAtom, port, }) => {
-    let subscription;
+const createHardwareWalletLedgerPlugin = ({ bluetoothStatusAtom, bluetoothScanningAtom, ledgerDiscovery, port, }) => {
     const observers = [
         createAtomObserver({ atom: bluetoothStatusAtom, port, event: 'bluetoothStatus' }),
         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: ({ type, available }) => bluetoothStatusAtom.set({ type, available }),
-                error: (error) => logger.error(error),
-            });
-        }
-        else if (transportsFactories.bluetooth.observeAvailability) {
-            subscription = transportsFactories.bluetooth.observeAvailability({
-                next: (available) => bluetoothStatusAtom.set({ type: 'Unknown', available }),
-                error: (error) => logger.error(error),
-            });
-        }
         observers.forEach((observer) => observer.start());
     };
     const stop = () => {
         observers.forEach((observer) => observer.unregister());
-        subscription?.unsubscribe();
+        ledgerDiscovery.stop();
     };
     const onUnlock = () => {
         start();
@@ -44,13 +27,7 @@ const hardwareWalletLedgerPluginDefinition = {
     id: 'hardwareWalletLedgerPlugin',
     type: 'plugin',
     factory: createHardwareWalletLedgerPlugin,
-    dependencies: [
-        'logger',
-        'transportsFactories',
-        'bluetoothStatusAtom',
-        'bluetoothScanningAtom',
-        'port',
-    ],
+    dependencies: ['bluetoothStatusAtom', 'bluetoothScanningAtom', 'ledgerDiscovery', 'port'],
     public: true,
 };
 export default hardwareWalletLedgerPluginDefinition;

package/lib/redux/index.d.ts

@@ -10,12 +10,12 @@ declare const exchangeReduxDefinition: {
         };
         readonly bluetoothScanning: (state: LedgerHardwareWalletState, payload: boolean) => {
             bluetoothScanning: boolean;
-            bluetoothStatus: import("./initial-state").BluetoothStatus;
+            bluetoothStatus: import("../atoms").BluetoothStatus;
         };
     };
     readonly selectorDefinitions: ({
         readonly id: "bluetoothStatus";
-        readonly resultFunction: (state: LedgerHardwareWalletState) => import("./initial-state").BluetoothStatus;
+        readonly resultFunction: (state: LedgerHardwareWalletState) => import("../atoms").BluetoothStatus;
         readonly dependencies: readonly [{
             readonly selector: string;
         }];

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

@@ -1,7 +1,4 @@
-export type BluetoothStatus = {
-    type: 'Unknown' | 'Resetting' | 'Unsupported' | 'Unauthorized' | 'PoweredOff' | 'PoweredOn';
-    available: boolean;
-};
+import type { BluetoothStatus } from '../atoms';
 export type LedgerHardwareWalletState = {
     bluetoothStatus: BluetoothStatus;
     bluetoothScanning: boolean;

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

@@ -1,7 +1,7 @@
 import type { LedgerHardwareWalletState } from '../initial-state';
 declare const bluetoothStatusSelectorDefinition: {
     readonly id: "bluetoothStatus";
-    readonly resultFunction: (state: LedgerHardwareWalletState) => import("../initial-state").BluetoothStatus;
+    readonly resultFunction: (state: LedgerHardwareWalletState) => import("../../atoms").BluetoothStatus;
     readonly dependencies: readonly [{
         readonly selector: string;
     }];

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

@@ -1,6 +1,6 @@
 declare const ledgerSelectors: ({
     readonly id: "bluetoothStatus";
-    readonly resultFunction: (state: import("../initial-state").LedgerHardwareWalletState) => import("../initial-state").BluetoothStatus;
+    readonly resultFunction: (state: import("../initial-state").LedgerHardwareWalletState) => import("../../atoms").BluetoothStatus;
     readonly dependencies: readonly [{
         readonly selector: string;
     }];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/hw-ledger",
-  "version": "2.9.4",
+  "version": "2.10.0",
   "description": "The ledger module",
   "author": "Exodus Movement, Inc.",
   "repository": {
@@ -25,7 +25,7 @@
     "test": "run -T jest --testMatch='**/*.unit.test.js' --coverageDirectory coverage/unit",
     "zemu:install": "docker pull zondax/builder-zemu:speculos-745fe46f81cfc18114b94a37beaefb58a09c0fcd",
     "test:integration": "yarn zemu:install && run -T jest --runInBand",
-    "lint": "run -T eslint . --ignore-path ../../.gitignore",
+    "lint": "run -T eslint .",
     "lint:fix": "yarn lint --fix",
     "prepublishOnly": "yarn run -T build --scope @exodus/hw-ledger"
   },
@@ -34,7 +34,7 @@
     "@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.1.0",
+    "@exodus/hw-common": "^2.4.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",
@@ -61,6 +61,7 @@
     "@types/jest-when": "^3.5.2",
     "@types/minimalistic-assert": "^1.0.1",
     "@types/secp256k1": "^4.0.3",
+    "@types/semver": "^7.3.5",
     "@zondax/zemu": "^0.43.1",
     "bitcoinjs-lib": "^6.1.3",
     "concurrently": "^7.6.0",
@@ -71,5 +72,5 @@
     "tiny-secp256k1": "^2.2.3",
     "ts-jest": "^29.0.3"
   },
-  "gitHead": "02011f9404194769108cec052ec27c714c19ad64"
+  "gitHead": "d035797666e173e9cec145ddce8e137fe84dfb83"
 }