@exodus/hw-ledger 1.0.0 → 1.2.0

package/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## [1.2.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@1.1.0...@exodus/hw-ledger@1.2.0) (2023-11-27)
+
+### Features
+
+- make hw-ledger a feature ([#4882](https://github.com/ExodusMovement/exodus-hydra/issues/4882)) ([33d93fb](https://github.com/ExodusMovement/exodus-hydra/commit/33d93fb0f4bb507e3788c0450a3e413e79815433))
+
+## [1.1.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@1.0.0...@exodus/hw-ledger@1.1.0) (2023-08-21)
+
+### Features
+
+- **hw-ledger:** add application management functions ([#2586](https://github.com/ExodusMovement/exodus-hydra/issues/2586)) ([125e9ef](https://github.com/ExodusMovement/exodus-hydra/commit/125e9efc835a56a66375e43f9072404af28f466d))
+- **hw-ledger:** add bitcoin transaction & message signing support ([#2530](https://github.com/ExodusMovement/exodus-hydra/issues/2530)) ([5d17826](https://github.com/ExodusMovement/exodus-hydra/commit/5d17826335f6e85ba3b9179bb7a2343f686751fb))
+- **hw-ledger:** add ethereum transaction signing ([#2315](https://github.com/ExodusMovement/exodus-hydra/issues/2315)) ([5b5c60e](https://github.com/ExodusMovement/exodus-hydra/commit/5b5c60e950948d24cea672e37dc171e1d7348343))
+- **hw-ledger:** add polygon support ([#2293](https://github.com/ExodusMovement/exodus-hydra/issues/2293)) ([fd66005](https://github.com/ExodusMovement/exodus-hydra/commit/fd660055b0813917dd4055c408f8731ea448ad4f))
+- **hw-ledger:** add prebuilt firmware ([#2212](https://github.com/ExodusMovement/exodus-hydra/issues/2212)) ([80667a4](https://github.com/ExodusMovement/exodus-hydra/commit/80667a4237a103c08e55dbf634a193dda0875ca0))
+- **hw-ledger:** add solana transaction & message signing ([#2357](https://github.com/ExodusMovement/exodus-hydra/issues/2357)) ([2ca2a4e](https://github.com/ExodusMovement/exodus-hydra/commit/2ca2a4e93f813b1777953355c4d271033e7d98d0))
+- **hw-ledger:** add Taproot address support ([#2442](https://github.com/ExodusMovement/exodus-hydra/issues/2442)) ([4d8350e](https://github.com/ExodusMovement/exodus-hydra/commit/4d8350ecbdca500e6b69a36ce83c7b4c63bb0e8f))
+- **hw-ledger:** automatically open the application ([#2801](https://github.com/ExodusMovement/exodus-hydra/issues/2801)) ([80e04b4](https://github.com/ExodusMovement/exodus-hydra/commit/80e04b49ee886cc3ca9b65695a567d06b0909928))
+- **hw-ledger:** bitcoin address derivation ([#2181](https://github.com/ExodusMovement/exodus-hydra/issues/2181)) ([19b77ec](https://github.com/ExodusMovement/exodus-hydra/commit/19b77ec223d998454843d82c4c47a4350e77299e))
+- **hw-ledger:** ethereum address generation ([#2213](https://github.com/ExodusMovement/exodus-hydra/issues/2213)) ([1c5b326](https://github.com/ExodusMovement/exodus-hydra/commit/1c5b326d7fbbcf66ff6cb820c35c1e1d1d127821))
+- **hw-ledger:** ethereum message signing ([#3058](https://github.com/ExodusMovement/exodus-hydra/issues/3058)) ([df07d2d](https://github.com/ExodusMovement/exodus-hydra/commit/df07d2d861cc20c1db366b47dc98802dd8e73f9c))
+- **hw-ledger:** solana address derivation ([#2211](https://github.com/ExodusMovement/exodus-hydra/issues/2211)) ([1c73d28](https://github.com/ExodusMovement/exodus-hydra/commit/1c73d28798801016966a8034a3538b9abc4cbf16))
+- **ledger:** add ethereum xpub support ([#3403](https://github.com/ExodusMovement/exodus-hydra/issues/3403)) ([7de98d2](https://github.com/ExodusMovement/exodus-hydra/commit/7de98d22080bcb46a9fe88e30d631a5ace3a923d))
+
+### Bug Fixes
+
+- **hw-ledger:** support NFT transactions on Nano S ([#2961](https://github.com/ExodusMovement/exodus-hydra/issues/2961)) ([1161a80](https://github.com/ExodusMovement/exodus-hydra/commit/1161a807c581211132d56ec2912bc27b683207d1))
+- missing dependencies ([#2408](https://github.com/ExodusMovement/exodus-hydra/issues/2408)) ([7791f2a](https://github.com/ExodusMovement/exodus-hydra/commit/7791f2aa10f318b0a3c8f932ec686fbe0cf16617))

package/lib/index.d.ts

@@ -1,2 +1,12 @@
-export * from './discovery';
-export { default } from './discovery';
+declare const hardwareWalletLedger: () => {
+    id: string;
+    definitions: {
+        definition: {
+            id: string;
+            type: string;
+            factory: (deps: import("./module").Dependencies) => import("./module").LedgerDiscovery;
+            dependencies: string[];
+        };
+    }[];
+};
+export default hardwareWalletLedger;

package/lib/index.js

@@ -1,2 +1,12 @@
-export * from './discovery';
-export { default } from './discovery';
+import ledgerDiscoveryDefinition from './module';
+const hardwareWalletLedger = () => {
+    return {
+        id: 'hardwareWalletLedger',
+        definitions: [
+            {
+                definition: ledgerDiscoveryDefinition,
+            },
+        ],
+    };
+};
+export default hardwareWalletLedger;

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

@@ -0,0 +1,9 @@
+import type Transport from '@ledgerhq/hw-transport';
+import type { HardwareWalletDevice } from '@exodus/hw-common';
+declare function createHandler(transport: Transport): Promise<HardwareWalletDevice>;
+declare const metadata: {
+    applicationName: string;
+    supportedVersions: string;
+    handler: typeof createHandler;
+};
+export default metadata;

package/lib/module/assets/bitcoin.js

@@ -0,0 +1,50 @@
+import bs58 from 'bs58';
+import { AppClient, DefaultWalletPolicy, PsbtV2 } from 'ledger-bitcoin';
+import { splitBip44DerivationPath } from './utils';
+import assert from 'minimalistic-assert';
+async function createHandler(transport) {
+    const app = new AppClient(transport);
+    const getWalletPolicy = async (purpose, coin, account) => {
+        const fpr = await app.getMasterFingerprint();
+        const xpub = await app.getExtendedPubkey(`m/${purpose}/${coin}/${account}`);
+        const desc = { "44'": 'pkh', "84'": 'wpkh', "86'": 'tr' }[purpose];
+        return new DefaultWalletPolicy(`${desc}(@0/**)`, `[${fpr}/${purpose}/${coin}/${account}]${xpub}`);
+    };
+    return {
+        getAddress: async (params) => {
+            const [purpose, coin, account, change, address] = splitBip44DerivationPath(params.derivationPath);
+            const walletPolicy = await getWalletPolicy(purpose, coin, account);
+            return app.getWalletAddress(walletPolicy, null, Number(change), Number(address), false);
+        },
+        getXPub: async (params) => {
+            return app.getExtendedPubkey(params.derivationPath);
+        },
+        getPublicKey: async (params) => {
+            return bs58.decode(await app.getExtendedPubkey(params.derivationPath)).slice(45, 45 + 33);
+        },
+        signTransaction: async (params) => {
+            assert(Buffer.isBuffer(params.unsignedTx.txData), 'unsignedTx.txData must be PSBT buffer');
+            const psbtBuffer = params.unsignedTx.txData;
+            const psbt = new PsbtV2();
+            psbt.deserialize(psbtBuffer);
+            const [purpose, coin, account] = splitBip44DerivationPath(params.derivationPaths[0]);
+            const walletPolicy = await getWalletPolicy(purpose, coin, account);
+            const signatures = await app.signPsbt(psbtBuffer, walletPolicy, null);
+            for (const [inputIndex, partialSignature] of signatures) {
+                psbt.setInputPartialSig(inputIndex, partialSignature.pubkey, partialSignature.signature);
+            }
+            return psbt.serialize();
+        },
+        signMessage: async (params) => {
+            assert(Buffer.isBuffer(params.message.rawMessage), 'rawMessage must be buffer');
+            const signedMessageHex = await app.signMessage(params.message.rawMessage, params.derivationPath);
+            return Buffer.from(signedMessageHex, 'base64');
+        },
+    };
+}
+const metadata = {
+    applicationName: 'Bitcoin',
+    supportedVersions: '^2.1.0',
+    handler: createHandler,
+};
+export default metadata;

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

@@ -0,0 +1,9 @@
+import type Transport from '@ledgerhq/hw-transport';
+import type { HardwareWalletDevice } from '@exodus/hw-common';
+declare function createHandler(transport: Transport): Promise<HardwareWalletDevice>;
+declare const metadata: {
+    applicationName: string;
+    supportedVersions: string;
+    handler: typeof createHandler;
+};
+export default metadata;

package/lib/module/assets/ethereum.js

@@ -0,0 +1,118 @@
+import secp256k1 from '@exodus/secp256k1';
+import * as ethers from '@exodus/ethersproject-transactions';
+import AppEth, { ledgerService, isEIP712Message } from '@ledgerhq/hw-app-eth';
+import { TypedDataUtils, SignTypedDataVersion, } from '@metamask/eth-sig-util';
+import assert from 'minimalistic-assert';
+import { buildFauxXPUB } from './utils';
+function hashEIP712Message(typedData) {
+    const version = SignTypedDataVersion.V4;
+    const { sanitizeData, hashStruct } = TypedDataUtils;
+    const sanitizedData = sanitizeData(typedData);
+    const domainSeparator = hashStruct('EIP712Domain', sanitizedData.domain, sanitizedData.types, version);
+    let hashStructMessage = Buffer.alloc(0);
+    if (sanitizedData.primaryType !== 'EIP712Domain') {
+        hashStructMessage = hashStruct('' + sanitizedData.primaryType, sanitizedData.message, sanitizedData.types, version);
+    }
+    return {
+        domainSeparator,
+        hashStructMessage,
+    };
+}
+async function createHandler(transport) {
+    const app = new AppEth(transport);
+    return {
+        getAddress: async (params) => {
+            const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
+            return address;
+        },
+        getXPub: async (params) => {
+            const { publicKey, chainCode } = await app.getAddress(params.derivationPath.replace('m/', ''), false, true);
+            const compressedPublicKey = Buffer.from(secp256k1.publicKeyConvert(Buffer.from(publicKey, 'hex'), true));
+            return buildFauxXPUB(compressedPublicKey, Buffer.from(chainCode, 'hex'));
+        },
+        getPublicKey: async (params) => {
+            const { publicKey } = await app.getAddress(params.derivationPath.replace('m/', ''));
+            const compressedPublicKey = secp256k1.publicKeyConvert(Buffer.from(publicKey, 'hex'), true);
+            return Buffer.from(compressedPublicKey);
+        },
+        signTransaction: async (params) => {
+            assert(Array.isArray(params.derivationPaths) && params.derivationPaths.length === 1, 'derivationsPath array must be one element long');
+            assert(params.unsignedTx.txData, 'txData must be defined');
+            const deserializedTransaction = Buffer.isBuffer(params.unsignedTx.txData)
+                ? ethers.parse(params.unsignedTx.txData)
+                : params.unsignedTx.txData;
+            delete deserializedTransaction.r;
+            delete deserializedTransaction.s;
+            delete deserializedTransaction.v;
+            const serializedTransactionHex = ethers.serialize(deserializedTransaction).slice(2);
+            const signTransaction = async ({ derivationPath, serializedTransactionHex, withNFT = true, }) => {
+                const resolution = await ledgerService.resolveTransaction(serializedTransactionHex, app.loadConfig, {
+                    externalPlugins: true,
+                    erc20: true,
+                    nft: withNFT,
+                });
+                return app.signTransaction(derivationPath, serializedTransactionHex, resolution);
+            };
+            let response = null;
+            try {
+                response = await signTransaction({
+                    derivationPath: params.derivationPaths[0],
+                    serializedTransactionHex,
+                    withNFT: true,
+                });
+            }
+            catch (err) {
+                if (err instanceof Error && err.message.includes('EthAppNftNotSupported')) {
+                    response = await signTransaction({
+                        derivationPath: params.derivationPaths[0],
+                        serializedTransactionHex,
+                        withNFT: false,
+                    });
+                }
+                else {
+                    throw err;
+                }
+            }
+            const { r, s, v } = response;
+            const serializedSignedTransaction = ethers.serialize(deserializedTransaction, {
+                r: '0x' + r,
+                s: '0x' + s,
+                v: Number.parseInt(v, 16),
+            });
+            return Buffer.from(serializedSignedTransaction.slice(2), 'hex');
+        },
+        signMessage: async (params) => {
+            const message = params.message;
+            let signingPromise;
+            if (message.rawMessage) {
+                assert(Buffer.isBuffer(params.message.rawMessage), 'rawMessage must be a buffer');
+                signingPromise = app.signPersonalMessage(params.derivationPath, Buffer.from(message.rawMessage).toString('hex'));
+            }
+            else if (message.EIP712Message) {
+                assert(isEIP712Message(message.EIP712Message), 'EIP712Message must be EIP712 conformant message');
+                signingPromise = app
+                    .signEIP712Message(params.derivationPath, message.EIP712Message)
+                    .catch((err) => {
+                    if (err.message.includes('INS_NOT_SUPPORTED')) {
+                        const { domainSeparator, hashStructMessage } = hashEIP712Message(message.EIP712Message);
+                        return app.signEIP712HashedMessage(params.derivationPath, domainSeparator.toString('hex'), hashStructMessage.toString('hex'));
+                    }
+                    throw err;
+                });
+            }
+            else {
+                assert(false, 'rawMessage or EIP712Message must be specified');
+            }
+            const { r, s, v } = await signingPromise;
+            const vNorm = (v - 27).toString(16);
+            const vHex = vNorm.length < 2 ? '0' + vNorm : vNorm;
+            return Buffer.from(`${r}${s}${vHex}`, 'hex');
+        },
+    };
+}
+const metadata = {
+    applicationName: 'Ethereum',
+    supportedVersions: '^1.10.0',
+    handler: createHandler,
+};
+export default metadata;

package/lib/{assets → module/assets}/index.d.ts

@@ -1,5 +1,10 @@
 import type Transport from '@ledgerhq/hw-transport';
 import type { HardwareWalletDevice } from '@exodus/hw-common';
 type HandlerFactory = (transport: Transport) => Promise<HardwareWalletDevice>;
-export declare const assetHandlerFactories: Record<string, HandlerFactory>;
+type AssetMetadata = {
+    applicationName: string;
+    supportedVersions: string;
+    handler: HandlerFactory;
+};
+export declare const assetApplications: Record<string, AssetMetadata>;
 export {};

package/lib/module/assets/index.js

@@ -0,0 +1,10 @@
+import bitcoin from './bitcoin';
+import ethereum from './ethereum';
+import polygon from './polygon';
+import solana from './solana';
+export const assetApplications = {
+    bitcoin,
+    ethereum,
+    polygon,
+    solana,
+};

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

@@ -0,0 +1,6 @@
+declare const metadata: {
+    applicationName: string;
+    supportedVersions: string;
+    handler: (transport: import("@ledgerhq/hw-transport").default) => Promise<import("libraries/hw-common/lib").HardwareWalletDevice>;
+};
+export default metadata;

package/lib/module/assets/polygon.js

@@ -0,0 +1,7 @@
+import ethereum from './ethereum';
+const metadata = {
+    applicationName: 'Polygon',
+    supportedVersions: '^1.10.0',
+    handler: ethereum.handler,
+};
+export default metadata;

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

@@ -0,0 +1,9 @@
+import type Transport from '@ledgerhq/hw-transport';
+import type { HardwareWalletDevice } from '@exodus/hw-common';
+declare function createHandler(transport: Transport): Promise<HardwareWalletDevice>;
+declare const metadata: {
+    applicationName: string;
+    supportedVersions: string;
+    handler: typeof createHandler;
+};
+export default metadata;

package/lib/module/assets/solana.js

@@ -0,0 +1,36 @@
+import AppSolana from '@ledgerhq/hw-app-solana';
+import assert from 'minimalistic-assert';
+import bs58 from 'bs58';
+import { XPubUnsupportedError } from '@exodus/hw-common';
+async function createHandler(transport) {
+    const app = new AppSolana(transport);
+    return {
+        getAddress: async (params) => {
+            const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
+            return bs58.encode(address);
+        },
+        getXPub: async (params) => {
+            throw new XPubUnsupportedError();
+        },
+        getPublicKey: async (params) => {
+            const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
+            return address;
+        },
+        signTransaction: async (params) => {
+            assert(Array.isArray(params.derivationPaths) && params.derivationPaths.length === 1, 'derivationsPath array must be one element long');
+            const { signature } = await app.signTransaction(params.derivationPaths[0].replace('m/', ''), params.unsignedTx.txData);
+            return signature;
+        },
+        signMessage: async (params) => {
+            assert(Buffer.isBuffer(params.message.rawMessage), 'rawMessage must be a buffer');
+            const { signature } = await app.signOffchainMessage(params.derivationPath.replace('m/', ''), params.message.rawMessage);
+            return signature;
+        },
+    };
+}
+const metadata = {
+    applicationName: 'Solana',
+    supportedVersions: '^1.4.0',
+    handler: createHandler,
+};
+export default metadata;

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare function splitDerivationPath(derivationPath: string): string[];
+type Bip44PathArray = [string, string, string, string, string];
+export declare function splitBip44DerivationPath(derivationPath: string): Bip44PathArray;
+export declare function buildFauxXPUB(publicKey: Buffer, chainCode: Buffer): string;
+export {};

package/lib/module/assets/utils.js

@@ -0,0 +1,37 @@
+import assert from 'minimalistic-assert';
+import bs58check from 'bs58check';
+export function splitDerivationPath(derivationPath) {
+    assert(typeof derivationPath === 'string', 'derivationPath must be string');
+    const parts = derivationPath.split('/');
+    assert(parts.length > 1, 'invalid derivationPath: must have length > 1');
+    assert(parts[0] === 'm', 'invalid derivationPath: must start with m');
+    return parts.slice(1);
+}
+function assertBip44Path(parts) {
+    assert(parts.length === 5, 'invalid bip44 derivation path: length must be 5');
+    assert(parts.every((part) => typeof part === 'string'));
+}
+export function splitBip44DerivationPath(derivationPath) {
+    const parts = splitDerivationPath(derivationPath);
+    assertBip44Path(parts);
+    const [purpose, coin, account, change, address] = parts;
+    assert(purpose.endsWith("'"), 'invalid derivationPath: purpose must be hardened');
+    assert(coin.endsWith("'"), 'invalid derivationPath: coin must be hardened');
+    assert(account.endsWith("'"), 'invalid derivationPath: account must be hardened');
+    return [purpose, coin, account, change, address];
+}
+export function buildFauxXPUB(publicKey, chainCode) {
+    const LEN = 78;
+    const XPUB_PREFIX = 76067358;
+    const buffer = Buffer.allocUnsafe(LEN);
+    const fingerprint = 0;
+    const depth = 0;
+    const index = 0;
+    buffer.writeUInt32BE(XPUB_PREFIX, 0);
+    buffer.writeUInt8(depth, 4);
+    buffer.writeUInt32BE(fingerprint, 5);
+    buffer.writeUInt32BE(index, 9);
+    chainCode.copy(buffer, 13);
+    publicKey.copy(buffer, 45);
+    return bs58check.encode(buffer);
+}

package/lib/{device.d.ts → module/device.d.ts}

@@ -1,10 +1,13 @@
 import type { GetAddressParams, GetPublicKeyParams, GetXPubParams, HardwareWalletDevice, SignMessageParams, SignTransactionParams } from '@exodus/hw-common';
-import type Transport from '@ledgerhq/hw-transport';
+import type { TransportFactory } from './types';
+export type Descriptor = unknown;
+export type Dependencies = {
+    transportFactory: TransportFactory;
+    descriptor: Descriptor;
+};
 export declare class LedgerDevice implements HardwareWalletDevice {
     #private;
-    constructor({ transport }: {
-        transport: Transport;
-    });
+    constructor({ transportFactory, descriptor }: Dependencies);
     getAddress: (params: GetAddressParams) => Promise<string>;
     getXPub: (params: GetXPubParams) => Promise<string>;
     getPublicKey: (params: GetPublicKeyParams) => Promise<Readonly<Uint8Array>>;

package/lib/module/device.js

@@ -0,0 +1,127 @@
+import semver from 'semver';
+import { AssetUnsupportedError, DeviceLockedError, DeviceConnectionError, UserRefusedError, } from '@exodus/hw-common';
+import { assetApplications } from './assets';
+import applicationFactory from './management/application';
+import { UnsupportedVersionError } from './errors';
+export class LedgerDevice {
+    #transportFactory;
+    #descriptor;
+    constructor({ transportFactory, descriptor }) {
+        this.#transportFactory = transportFactory;
+        this.#descriptor = descriptor;
+    }
+    #runInSession = async (operation) => {
+        const transport = await this.#transportFactory.open(this.#descriptor);
+        try {
+            return await operation(transport);
+        }
+        catch (err) {
+            throw transformToCommonError(err);
+        }
+        finally {
+            await transport.close();
+        }
+    };
+    #getAssetApplication = (assetName) => {
+        const handlerFactory = assetApplications[assetName];
+        if (!handlerFactory)
+            throw new AssetUnsupportedError(assetName);
+        return handlerFactory;
+    };
+    #listApplications = async () => {
+        return this.#runInSession(async (transport) => {
+            const handler = await applicationFactory(transport);
+            return handler.listApplications();
+        });
+    };
+    #getInformation = async () => {
+        return this.#runInSession(async (transport) => {
+            const handler = await applicationFactory(transport);
+            return handler.getInformation();
+        });
+    };
+    #openApplication = async (applicationName) => {
+        return this.#runInSession(async (transport) => {
+            const handler = await applicationFactory(transport);
+            return handler.openApplication(applicationName);
+        });
+    };
+    #quitApplication = async () => {
+        return this.#runInSession(async (transport) => {
+            const handler = await applicationFactory(transport);
+            return handler.quitApplication();
+        });
+    };
+    #ensureApplicationIsOpened = async (assetName) => {
+        const { applicationName, supportedVersions } = this.#getAssetApplication(assetName);
+        const currentApplicationInfo = await this.#getInformation();
+        let desiredApplicationInfo = null;
+        if (applicationName === currentApplicationInfo.name) {
+            desiredApplicationInfo = currentApplicationInfo;
+        }
+        else {
+            await this.#quitApplication();
+            await this.#openApplication(applicationName);
+            desiredApplicationInfo = await this.#getInformation();
+        }
+        const isSupportedVersion = semver.satisfies(desiredApplicationInfo.version, supportedVersions);
+        if (!isSupportedVersion) {
+            throw new UnsupportedVersionError(desiredApplicationInfo.version, supportedVersions);
+        }
+    };
+    getAddress = async (params) => {
+        await this.#ensureApplicationIsOpened(params.assetName);
+        return this.#runInSession(async (transport) => {
+            const handler = await this.#getAssetApplication(params.assetName).handler(transport);
+            return handler.getAddress(params);
+        });
+    };
+    getXPub = async (params) => {
+        await this.#ensureApplicationIsOpened(params.assetName);
+        return this.#runInSession(async (transport) => {
+            const handler = await this.#getAssetApplication(params.assetName).handler(transport);
+            return handler.getXPub(params);
+        });
+    };
+    getPublicKey = async (params) => {
+        await this.#ensureApplicationIsOpened(params.assetName);
+        return this.#runInSession(async (transport) => {
+            const handler = await this.#getAssetApplication(params.assetName).handler(transport);
+            return handler.getPublicKey(params);
+        });
+    };
+    signTransaction = async (params) => {
+        await this.#ensureApplicationIsOpened(params.assetName);
+        return this.#runInSession(async (transport) => {
+            const handler = await this.#getAssetApplication(params.assetName).handler(transport);
+            return handler.signTransaction(params);
+        });
+    };
+    signMessage = async (params) => {
+        await this.#ensureApplicationIsOpened(params.assetName);
+        return this.#runInSession(async (transport) => {
+            const handler = await this.#getAssetApplication(params.assetName).handler(transport);
+            return handler.signMessage(params);
+        });
+    };
+}
+function transformToCommonError(_err) {
+    const err = _err;
+    if (err.name === 'LockedDeviceError') {
+        return new DeviceLockedError();
+    }
+    if (err.name === 'UserRefusedOnDevice') {
+        return new UserRefusedError();
+    }
+    if ([
+        'HwTransportError',
+        'TransportError',
+        'TransportRaceCondition',
+        'UnresponsiveDeviceError',
+        'DisconnectedDevice',
+        'DisconnectedDeviceDuringOperation',
+    ].includes(err.name)) {
+        return new DeviceConnectionError(err);
+    }
+    return err;
+}

package/lib/{discovery.d.ts → module/discovery.d.ts}

@@ -1,8 +1,7 @@
 import ExodusModule from '@exodus/module';
-import type Transport from '@ledgerhq/hw-transport';
-import { Logger } from '~/shared/types';
+import { Logger } from '../shared/types';
 import type { HardwareWalletDescriptor, HardwareWalletDiscovery } from '@exodus/hw-common';
-type TransportFactory = typeof Transport;
+import type { TransportFactory } from './types';
 export type Dependencies = {
     logger: Logger;
     transportsFactories: {

package/lib/{discovery.js → module/discovery.js}

@@ -1,16 +1,19 @@
 import ExodusModule from '@exodus/module';
-import assert from 'minimalistic-assert';
 import { APDU_PORT } from './constants';
 import { LedgerDevice } from './device';
-const MODULE_ID = 'hardwareWalletLedger';
+import { UnknownTransportError } from './errors';
+const MODULE_ID = 'ledgerDiscovery';
 export class LedgerDiscovery extends ExodusModule {
     #transportsFactories;
     constructor({ logger, transportsFactories }) {
         super({ name: MODULE_ID, logger });
-        assert(typeof transportsFactories === 'object' &&
+        if (!(typeof transportsFactories === 'object' &&
             Object.keys(transportsFactories).length > 0 &&
             Object.entries(transportsFactories).every(([transportName, transportFactory]) => ['usb', 'bluetooth', 'tcp'].includes(transportName) &&
-                typeof transportFactory === 'object'), `invalid transports`);
+                transportFactory !== undefined &&
+                typeof transportFactory.list === 'function' &&
+                typeof transportFactory.open === 'function')))
+            throw new UnknownTransportError();
         this.#transportsFactories = transportsFactories;
     }
     list = async () => {
@@ -22,22 +25,25 @@ export class LedgerDiscovery extends ExodusModule {
                     const usbDeviceList = deviceList.map((hidDevice) => ({
                         manufacturer: 'ledger',
                         transport: 'usb',
-                        get: async () => new LedgerDevice({ transport: await transportFactory.open(hidDevice) }),
+                        get: async () => new LedgerDevice({ transportFactory, descriptor: hidDevice }),
                     }));
                     descriptors.push(...usbDeviceList);
                     break;
                 case 'bluetooth':
-                    this._logger.error(`bluetooth is not supported yet!`);
+                    this._logger.error('bluetooth is not supported yet!');
                     break;
                 case 'tcp':
                     descriptors.push({
                         manufacturer: 'ledger',
                         transport: 'tcp',
-                        get: async () => new LedgerDevice({ transport: await transportFactory.open({ apduPort: APDU_PORT }) }),
+                        get: async () => new LedgerDevice({
+                            transportFactory,
+                            descriptor: { apduPort: APDU_PORT },
+                        }),
                     });
                     break;
                 default:
-                    throw new Error(`unknown transport type ${transportName}`);
+                    throw new UnknownTransportError(transportName);
             }
         }
         return descriptors;
@@ -48,5 +54,5 @@ export default {
     id: MODULE_ID,
     type: 'module',
     factory: createLedgerDiscovery,
-    dependencies: ['logger'],
+    dependencies: ['logger', 'transportsFactories'],
 };

package/lib/module/errors.d.ts

@@ -0,0 +1,13 @@
+import { HardwareWalletError } from '@exodus/hw-common';
+export declare class UnknownTransportError extends HardwareWalletError {
+    name: string;
+    constructor(transportName?: string);
+}
+export declare class UnsupportedVersionError extends HardwareWalletError {
+    name: string;
+    constructor(actualVersion: string, supportedVersions: string);
+}
+export declare class RequiresBlindSigningError extends HardwareWalletError {
+    name: string;
+    constructor();
+}

package/lib/module/errors.js

@@ -0,0 +1,19 @@
+import { HardwareWalletError } from '@exodus/hw-common';
+export class UnknownTransportError extends HardwareWalletError {
+    name = 'UnknownTransportError';
+    constructor(transportName) {
+        super(`unknown transport type ${transportName || ''}`);
+    }
+}
+export class UnsupportedVersionError extends HardwareWalletError {
+    name = 'UnsupportedVersionError';
+    constructor(actualVersion, supportedVersions) {
+        super(`version does not meet version requirements: ${actualVersion} does not match ${supportedVersions}`);
+    }
+}
+export class RequiresBlindSigningError extends HardwareWalletError {
+    name = 'RequiresBlindSigningError';
+    constructor() {
+        super('signing operation requires that blind signing is enabled on the device');
+    }
+}

package/lib/module/index.d.ts

@@ -0,0 +1,2 @@
+export * from './discovery';
+export { default } from './discovery';

package/lib/module/index.js

@@ -0,0 +1,2 @@
+export * from './discovery';
+export { default } from './discovery';

package/lib/module/management/application.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import type Transport from '@ledgerhq/hw-transport';
+export type GetInformationResponse = {
+    name: string;
+    version: string;
+    flags: Buffer;
+};
+export type ListAppResponse = {
+    name: string;
+    hash: string;
+    hash_code_data: string;
+    blocks?: number;
+    flags?: number;
+}[];
+export default function createApplicationManager(transport: Transport): Promise<{
+    getInformation: () => Promise<GetInformationResponse>;
+    listApplications: () => Promise<ListAppResponse>;
+    openApplication: (name: string) => Promise<void>;
+    quitApplication: () => Promise<void>;
+}>;

package/lib/module/management/application.js

@@ -0,0 +1,68 @@
+export default async function createApplicationManager(transport) {
+    return {
+        getInformation: async () => {
+            const r = await transport.send(0xb0, 0x01, 0x00, 0x00);
+            let i = 0;
+            const format = r[i++];
+            if (format !== 1) {
+                throw new Error('getAppAndVersion: format not supported');
+            }
+            const nameLength = Number(r[i++]);
+            const name = r.slice(i, (i += nameLength)).toString('ascii');
+            const versionLength = Number(r[i++]);
+            const version = r.slice(i, (i += versionLength)).toString('ascii');
+            const flagLength = Number(r[i++]);
+            const flags = r.slice(i, (i += flagLength));
+            return {
+                name,
+                version,
+                flags,
+            };
+        },
+        listApplications: async () => {
+            const payload = await transport.send(0xe0, 0xde, 0, 0);
+            const apps = [];
+            let data = payload;
+            while (data.length > 2) {
+                if (payload[0] !== 0x01) {
+                    throw new Error('unknown listApps format');
+                }
+                let i = 1;
+                while (i < data.length - 2) {
+                    const length = data[i];
+                    i++;
+                    const blocks = data.readUInt16BE(i);
+                    i += 2;
+                    const flags = data.readUInt16BE(i);
+                    i += 2;
+                    const hashCodeData = data.slice(i, i + 32).toString('hex');
+                    i += 32;
+                    const hash = data.slice(i, i + 32).toString('hex');
+                    i += 32;
+                    const nameLength = Number(data[i]);
+                    i++;
+                    if (length !== nameLength + 70) {
+                        throw new Error('invalid listApps length data');
+                    }
+                    const name = data.slice(i, i + nameLength).toString('ascii');
+                    i += nameLength;
+                    apps.push({
+                        name,
+                        hash,
+                        hash_code_data: hashCodeData,
+                        blocks,
+                        flags,
+                    });
+                }
+                data = await transport.send(0xe0, 0xdf, 0, 0);
+            }
+            return apps;
+        },
+        openApplication: async (name) => {
+            await transport.send(0xe0, 0xd8, 0x00, 0x00, Buffer.from(name, 'ascii'));
+        },
+        quitApplication: async () => {
+            await transport.send(0xb0, 0xa7, 0x00, 0x00);
+        },
+    };
+}

package/lib/module/types.d.ts

@@ -0,0 +1,2 @@
+import type Transport from '@ledgerhq/hw-transport';
+export type TransportFactory = typeof Transport;

package/lib/module/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,46 +1,65 @@
 {
   "name": "@exodus/hw-ledger",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "The ledger module",
-  "author": "Exodus Movement Inc",
+  "author": "Exodus Movement Inc.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/exodus-hydra.git"
   },
-  "homepage": "https://github.com/ExodusMovement/exodus-hydra/tree/master/modules/hw-ledger",
+  "homepage": "https://github.com/ExodusMovement/exodus-hydra/tree/master/features/hw-ledger",
   "license": "UNLICENSED",
   "bugs": {
     "url": "https://github.com/ExodusMovement/exodus-hydra/issues?q=is%3Aissue+is%3Aopen+label%3Ahw-ledger"
   },
+  "main": "lib/index.js",
   "files": [
     "lib",
-    "README.md",
-    "CHANGELOG.md"
+    "./README.md",
+    "./CHANGELOG.md"
   ],
   "scripts": {
     "build": "tsc --build tsconfig.build.json",
     "build:watch": "tsc --build tsconfig.build.json && (concurrently 'tsc --build -w tsconfig.build.json')",
     "clean": "tsc --build --clean",
-    "test": "jest --runInBand",
+    "test": "jest --testMatch='**/*.unit.test.js' --coverageDirectory coverage/unit",
+    "zemu:install": "docker pull zondax/builder-zemu:speculos-745fe46f81cfc18114b94a37beaefb58a09c0fcd",
+    "test:integration": "yarn zemu:install && jest --runInBand",
     "lint": "eslint . --ignore-path ../../.gitignore",
     "lint:fix": "yarn lint --fix"
   },
   "dependencies": {
-    "@ledgerhq/hw-app-btc": "^10.0.5",
+    "@exodus/ethersproject-transactions": "^5.4.2-exodus.0",
+    "@exodus/hw-common": "^1.0.0",
+    "@exodus/secp256k1": "^4.0.2-exodus.0",
+    "@ledgerhq/hw-app-eth": "^6.33.6",
+    "@ledgerhq/hw-app-solana": "^7.0.10",
     "@ledgerhq/hw-transport": "^6.28.5",
-    "minimalistic-assert": "^1.0.1"
+    "@metamask/eth-sig-util": "^4.0.1",
+    "bs58": "^4.0.0",
+    "bs58check": "^2.1.2",
+    "ledger-bitcoin": "^0.2.2",
+    "minimalistic-assert": "^1.0.1",
+    "semver": "^7.3.5"
   },
   "devDependencies": {
-    "@exodus/hw-common": "^1.0.0",
-    "@exodus/module": "^1.2.0",
-    "@ledgerhq/hw-transport-node-hid": "^6.27.16",
+    "@exodus/bip32": "^2.0.0",
+    "@exodus/module": "^1.2.2",
+    "@ledgerhq/hw-transport-node-hid": "^6.27.17",
     "@ledgerhq/hw-transport-node-speculos": "^6.27.16",
+    "@types/bs58": "^4.0.1",
+    "@types/bs58check": "^2.1.0",
     "@types/jest-when": "^3.5.2",
     "@types/minimalistic-assert": "^1.0.1",
+    "@types/secp256k1": "^4.0.3",
+    "@zondax/zemu": "^0.43.1",
     "concurrently": "^7.6.0",
-    "eslint": "^8.33.0",
+    "eslint": "^8.44.0",
+    "istanbul-combine": "^0.3.0",
     "jest": "^29.1.2",
-    "jest-when": "^3.5.2"
+    "jest-when": "^3.5.2",
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.7.3"
   },
-  "gitHead": "3772b0c9e6727aa1ed14f0a3d703e93c08b65c8a"
+  "gitHead": "df9526a0bdc326e1a9918c3f76ba2197bf42a920"
 }

package/lib/assets/bitcoin.d.ts

@@ -1,3 +0,0 @@
-import type Transport from '@ledgerhq/hw-transport';
-import type { HardwareWalletDevice } from '@exodus/hw-common';
-export default function (transport: Transport): Promise<HardwareWalletDevice>;

package/lib/assets/bitcoin.js

@@ -1,21 +0,0 @@
-import AppBtc from '@ledgerhq/hw-app-btc';
-export default async function (transport) {
-    const app = new AppBtc({ transport });
-    return {
-        getAddress: async (params) => {
-            throw new Error('implement me');
-        },
-        getXPub: async (params) => {
-            throw new Error('implement me');
-        },
-        getPublicKey: async (params) => {
-            throw new Error('implement me');
-        },
-        signTransaction: async (params) => {
-            throw new Error('implement me');
-        },
-        signMessage: async (params) => {
-            throw new Error('implement me');
-        },
-    };
-}

package/lib/assets/index.js

@@ -1,4 +0,0 @@
-import bitcoin from './bitcoin';
-export const assetHandlerFactories = {
-    bitcoin,
-};

package/lib/device.js

@@ -1,33 +0,0 @@
-import assert from 'minimalistic-assert';
-import { assetHandlerFactories } from './assets';
-export class LedgerDevice {
-    #transport;
-    constructor({ transport }) {
-        this.#transport = transport;
-    }
-    #getAssetHandler = async (assetName) => {
-        const handlerFactory = assetHandlerFactories[assetName];
-        assert(handlerFactory, `ledger does not support ${assetName}`);
-        return handlerFactory(this.#transport);
-    };
-    getAddress = async (params) => {
-        const handler = await this.#getAssetHandler(params.assetName);
-        return handler.getAddress(params);
-    };
-    getXPub = async (params) => {
-        const handler = await this.#getAssetHandler(params.assetName);
-        return handler.getXPub(params);
-    };
-    getPublicKey = async (params) => {
-        const handler = await this.#getAssetHandler(params.assetName);
-        return handler.getPublicKey(params);
-    };
-    signTransaction = async (params) => {
-        const handler = await this.#getAssetHandler(params.assetName);
-        return handler.signTransaction(params);
-    };
-    signMessage = async (params) => {
-        const handler = await this.#getAssetHandler(params.assetName);
-        return handler.signMessage(params);
-    };
-}