@exodus/hw-ledger 1.3.2 → 2.0.0

package/CHANGELOG.md

@@ -3,6 +3,30 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.0.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@1.3.2...@exodus/hw-ledger@2.0.0) (2023-12-19)
+
+### ⚠ BREAKING CHANGES
+
+- simplify transaction signing api for ledger (#4979)
+
+### Features
+
+- add nested segwit to bitcoin ([#4981](https://github.com/ExodusMovement/exodus-hydra/issues/4981)) ([3721b60](https://github.com/ExodusMovement/exodus-hydra/commit/3721b607ea5176ad8461d4b97ac803e179f8a48f))
+- add psbt tagging & sanitization to ledger ([#5059](https://github.com/ExodusMovement/exodus-hydra/issues/5059)) ([9e38c3b](https://github.com/ExodusMovement/exodus-hydra/commit/9e38c3b33c6beb67b1feee6eaf939c5a500da94a))
+- simplify transaction signing api for ledger ([#4979](https://github.com/ExodusMovement/exodus-hydra/issues/4979)) ([30b1d45](https://github.com/ExodusMovement/exodus-hydra/commit/30b1d45602614c8b37cff926acaf830142fbf197))
+
+### Bug Fixes
+
+- bump ledger packages ([#4990](https://github.com/ExodusMovement/exodus-hydra/issues/4990)) ([a3f60fc](https://github.com/ExodusMovement/exodus-hydra/commit/a3f60fc6dca2c0bbbdb37e6446d3b4f4438e2753))
+- change polygon asset name to matic ([#4955](https://github.com/ExodusMovement/exodus-hydra/issues/4955)) ([e3d5ec3](https://github.com/ExodusMovement/exodus-hydra/commit/e3d5ec3e0d7e3f1a31082ca7bb77a13bb0ca3207))
+
+## [1.3.3](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@1.3.2...@exodus/hw-ledger@1.3.3) (2023-12-11)
+
+### Bug Fixes
+
+- bump ledger packages ([#4990](https://github.com/ExodusMovement/exodus-hydra/issues/4990)) ([a3f60fc](https://github.com/ExodusMovement/exodus-hydra/commit/a3f60fc6dca2c0bbbdb37e6446d3b4f4438e2753))
+- change polygon asset name to matic ([#4955](https://github.com/ExodusMovement/exodus-hydra/issues/4955)) ([e3d5ec3](https://github.com/ExodusMovement/exodus-hydra/commit/e3d5ec3e0d7e3f1a31082ca7bb77a13bb0ca3207))
+
 ## [1.3.2](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@1.3.1...@exodus/hw-ledger@1.3.2) (2023-12-05)
 
 ### Bug Fixes

package/README.md

@@ -59,29 +59,40 @@ If you're on Linux then it's highly likely that you'll want to setup your udev r
 
 ### Installing Ledger Emulator (Recommended)
 
-Get the Docker images
+Clone the speculos repository & change your current working directory
 
 ```bash
-docker pull ghcr.io/ledgerhq/speculos
-docker image tag ghcr.io/ledgerhq/speculos speculos
+git clone https://github.com/LedgerHQ/speculos.git --branch v0.3.5 --single-branch --depth 1 speculos-0.3.5
+cd speculos-0.3.5
 ```
 
-Clone the speculos repository & change your current working directory
+Get the Docker image
+
+```bash
+docker image pull ghcr.io/ledgerhq/speculos:sha-8241dc2 # v0.3.5
+docker image tag ghcr.io/ledgerhq/speculos:sha-8241dc2 speculos
+```
+
+Get the Docker image for ARM (M1/M2)
 
 ```bash
-git clone https://github.com/LedgerHQ/speculos.git
-cd speculos
+docker image build -t ghcr.io/ledgerhq/speculos-builder:latest -f build.Dockerfile .
+docker image build -t speculos:latest .
 ```
 
 Launch the emulator while within the `speculos` directory
 
 ```bash
-docker run --rm -it -v "$(pwd)"/apps:/speculos/apps \
--p 1234:1234 -p 5000:5000 -p 40000:40000 -p 41000:41000 speculos \
---model nanos ./apps/btc.elf --sdk 2.0 --seed "secret" --display headless --apdu-port 40000 --vnc-port 41000
+docker container run --rm -it -v "$(pwd)"/apps:/speculos/apps:ro \
+-p 127.0.0.1:4000:4000 -p 127.0.0.1:40000:40000 speculos \
+--display headless --api-port 4000 --apdu-port 40000 --seed "secret" --model nanos --sdk 2.0 ./apps/btc.elf
 ```
 
-Now visit http://127.0.0.1:5000 to interact with the emulator.
+Now visit http://127.0.0.1:4000 to interact with the emulator.
+
+### MacOS launch issues:
+
+- `port XXXX is already in use`: re-map any available host port ([doc](https://docs.docker.com/network/#published-ports))
 
 ### Install udev rules for real devices (Linux only)
 

package/lib/module/assets/bitcoin.js

@@ -1,45 +1,69 @@
 import bs58 from 'bs58';
-import { AppClient, DefaultWalletPolicy, PsbtV2 } from '@exodus/ledger-bitcoin';
+import { AppClient, DefaultWalletPolicy, PsbtV2, } from '@exodus/ledger-bitcoin';
 import { splitBip44DerivationPath } from './utils';
 import assert from 'minimalistic-assert';
+import { assertPsbtOnlyHasAllowedDerivationPaths, tagPsbtWithDerivationPaths } from './utils/psbt';
 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}`);
+        const desc = {
+            "44'": 'pkh(@0/**)',
+            "49'": 'sh(wpkh(@0/**))',
+            "84'": 'wpkh(@0/**)',
+            "86'": 'tr(@0/**)',
+        }[purpose];
+        return new DefaultWalletPolicy(desc, `[${fpr}/${purpose}/${coin}/${account}]${xpub}`);
+    };
+    const 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);
+    };
+    const getXPub = async (params) => {
+        return app.getExtendedPubkey(params.derivationPath);
+    };
+    const getPublicKey = async (params) => {
+        return bs58.decode(await app.getExtendedPubkey(params.derivationPath)).slice(45, 45 + 33);
+    };
+    const signTransaction = async (params) => {
+        assert(Buffer.isBuffer(params.signableTransaction), 'signableTransaction must be PSBT buffer');
+        const psbtBuffer = params.signableTransaction;
+        const psbt = new PsbtV2();
+        psbt.deserialize(psbtBuffer);
+        const [purpose, coin, account] = splitBip44DerivationPath(params.derivationPaths[0]);
+        const fpr = await app.getMasterFingerprint();
+        const walletPolicy = await getWalletPolicy(purpose, coin, account);
+        const derivationPathToPublicKeyMap = Object.create(null);
+        for (const derivationPath of params.derivationPaths) {
+            derivationPathToPublicKeyMap[derivationPath] = await getPublicKey({
+                assetName: 'bitcoin',
+                derivationPath,
+            });
+        }
+        tagPsbtWithDerivationPaths(psbt, fpr, derivationPathToPublicKeyMap);
+        assertPsbtOnlyHasAllowedDerivationPaths(psbt, fpr, params.derivationPaths);
+        const signatures = await app.signPsbt(psbt.serialize(), walletPolicy, null);
+        const result = signatures.map(([inputIndex, partialSignature]) => ({
+            inputIndex,
+            publicKey: partialSignature.pubkey,
+            signature: partialSignature.signature,
+            tapleafHash: partialSignature.tapleafHash,
+        }));
+        return result;
+    };
+    const 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');
     };
     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');
-        },
+        getAddress,
+        getPublicKey,
+        getXPub,
+        signTransaction,
+        signMessage,
     };
 }
 const metadata = {

package/lib/module/assets/ethereum.js

@@ -44,10 +44,8 @@ async function createHandler(transport) {
         },
         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;
+            assert(Buffer.isBuffer(params.signableTransaction), 'signableTransaction must be Buffer');
+            const deserializedTransaction = ethers.parse(params.signableTransaction);
             delete deserializedTransaction.r;
             delete deserializedTransaction.s;
             delete deserializedTransaction.v;
@@ -80,13 +78,16 @@ async function createHandler(transport) {
                     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');
+            const { v, r, s } = response;
+            return [
+                {
+                    signature: Buffer.concat([
+                        Buffer.from(v, 'hex'),
+                        Buffer.from(r, 'hex'),
+                        Buffer.from(s, 'hex'),
+                    ]),
+                },
+            ];
         },
         signMessage: async (params) => {
             const message = params.message;

package/lib/module/assets/index.js

@@ -1,11 +1,11 @@
 import bitcoin from './bitcoin';
 import ethereum from './ethereum';
-import polygon from './polygon';
+import matic from './matic';
 import solana from './solana';
 export const assetApplications = {
     bitcoin,
     ethereum,
-    polygon,
+    matic,
     solana,
 };
 export const supportedBaseAssetNames = Object.keys(assetApplications);

package/lib/module/assets/solana.js

@@ -4,28 +4,52 @@ import bs58 from 'bs58';
 import { XPubUnsupportedError } from '@exodus/hw-common';
 async function createHandler(transport) {
     const app = new AppSolana(transport);
+    const getAddress = async (params) => {
+        const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
+        return bs58.encode(address);
+    };
+    const getXPub = async (params) => {
+        throw new XPubUnsupportedError();
+    };
+    const getPublicKey = async (params) => {
+        const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
+        return address;
+    };
+    const signTransaction = async (params) => {
+        assert(Array.isArray(params.derivationPaths) && params.derivationPaths.length === 1, 'derivationsPath array must be one element long');
+        let serializedTransaction;
+        if (Buffer.isBuffer(params.signableTransaction)) {
+            serializedTransaction = params.signableTransaction;
+        }
+        else if (params.signableTransaction instanceof Uint8Array) {
+            serializedTransaction = Buffer.from(params.signableTransaction);
+        }
+        else if (params.signableTransaction.serialize) {
+            serializedTransaction = Buffer.from(params.signableTransaction.serialize());
+        }
+        if (!Buffer.isBuffer(serializedTransaction)) {
+            throw new TypeError(`signableTransaction must be Buffer or serializable to a Buffer.`);
+        }
+        const { signature } = await app.signTransaction(params.derivationPaths[0].replace('m/', ''), serializedTransaction);
+        const { address: publicKey } = await app.getAddress(params.derivationPaths[0].replace('m/', ''));
+        return [
+            {
+                publicKey,
+                signature,
+            },
+        ];
+    };
+    const 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;
+    };
     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;
-        },
+        getAddress,
+        getPublicKey,
+        getXPub,
+        signTransaction,
+        signMessage,
     };
 }
 const metadata = {

package/lib/module/assets/utils/derivation-paths.d.ts

@@ -0,0 +1,8 @@
+export declare function splitDerivationPath(derivationPath: string): string[];
+export type Bip44PathArray = [string, string, string, string, string];
+export type Bip44PathArrayNumber = [number, number, number, number, number];
+export declare function assertBip44Path(parts: string[]): asserts parts is Bip44PathArray;
+export declare function splitBip44DerivationPath(derivationPath: string): Bip44PathArray;
+export declare function assertBip44PathNumber(parts: readonly number[]): asserts parts is Bip44PathArrayNumber;
+export declare function buildBip44PathFromNumber(parts: Bip44PathArrayNumber): string;
+export declare function splitBip44PathToNumber(derivationPath: string): Bip44PathArrayNumber;

package/lib/module/assets/{utils.js → utils/derivation-paths.js}

@@ -1,5 +1,4 @@
 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('/');
@@ -7,7 +6,7 @@ export function splitDerivationPath(derivationPath) {
     assert(parts[0] === 'm', 'invalid derivationPath: must start with m');
     return parts.slice(1);
 }
-function assertBip44Path(parts) {
+export function assertBip44Path(parts) {
     assert(parts.length === 5, 'invalid bip44 derivation path: length must be 5');
     assert(parts.every((part) => typeof part === 'string'));
 }
@@ -20,18 +19,23 @@ export function splitBip44DerivationPath(derivationPath) {
     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);
+export function assertBip44PathNumber(parts) {
+    assert(parts.length === 5, 'invalid bip44 derivation path: length must be 5');
+    assert(parts.every((part) => typeof part === 'number'));
+}
+export function buildBip44PathFromNumber(parts) {
+    const [purpose, coin, account, chainIndex, addressIndex] = parts;
+    const HARDENED_OFFSET = 2147483648;
+    return `m/${purpose - HARDENED_OFFSET}'/${coin - HARDENED_OFFSET}'/${account - HARDENED_OFFSET}'/${chainIndex}/${addressIndex}`;
+}
+export function splitBip44PathToNumber(derivationPath) {
+    const [purpose, coin, account, change, address] = splitBip44DerivationPath(derivationPath);
+    const HARDENED_OFFSET = 2147483648;
+    return [
+        Number(purpose.replaceAll(`'`, '')) + HARDENED_OFFSET,
+        Number(coin.replaceAll(`'`, '')) + HARDENED_OFFSET,
+        Number(account.replaceAll(`'`, '')) + HARDENED_OFFSET,
+        Number(change),
+        Number(address),
+    ];
 }

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

@@ -0,0 +1,3 @@
+export * from './derivation-paths';
+export * from './xpub';
+export * from './psbt';

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

@@ -0,0 +1,3 @@
+export * from './derivation-paths';
+export * from './xpub';
+export * from './psbt';

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

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { PsbtV2 } from '@exodus/ledger-bitcoin';
+export declare function assertPsbtOnlyHasAllowedDerivationPaths(psbt: PsbtV2, masterFingerprint: string, derivationPaths: string[]): void;
+export declare function tagPsbtWithDerivationPaths(psbt: PsbtV2, masterFingerprint: string, derivationPathToPublicKeyMap: Record<string, Buffer>): void;

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

@@ -0,0 +1,96 @@
+import assert from 'minimalistic-assert';
+import { payments } from '@exodus/bitcoinjs-lib';
+import { buildBip44PathFromNumber, assertBip44PathNumber, splitBip44PathToNumber, } from './derivation-paths';
+export function assertPsbtOnlyHasAllowedDerivationPaths(psbt, masterFingerprint, derivationPaths) {
+    for (let i = 0; i < psbt.getGlobalInputCount(); i++) {
+        const BIP32_DERIVATION = 6;
+        const TAP_BIP32_DERIVATION = 22;
+        const publicKeysNormal = psbt.getInputKeyDatas(i, BIP32_DERIVATION);
+        const publicKeysTap = psbt.getInputKeyDatas(i, TAP_BIP32_DERIVATION);
+        for (const publicKey of publicKeysNormal) {
+            const bip32Derivation = psbt.getInputBip32Derivation(i, publicKey);
+            if (bip32Derivation) {
+                assertAllowedDerivation(bip32Derivation, masterFingerprint, derivationPaths);
+            }
+        }
+        for (const publicKey of publicKeysTap) {
+            const tapBip32Derivation = psbt.getInputTapBip32Derivation(i, publicKey);
+            if (tapBip32Derivation) {
+                assertAllowedDerivation(tapBip32Derivation, masterFingerprint, derivationPaths);
+            }
+        }
+    }
+}
+function assertAllowedDerivation(bip32Derivation, masterFingerprint, derivationPaths) {
+    const masterFingerprintToCheck = bip32Derivation.masterFingerprint.toString('hex');
+    const isOurMasterFingerprint = masterFingerprintToCheck === masterFingerprint;
+    if (isOurMasterFingerprint) {
+        assertBip44PathNumber(bip32Derivation.path);
+        const derivationPath = buildBip44PathFromNumber(bip32Derivation.path);
+        assert(derivationPaths.includes(derivationPath), `found unsupported derivation path: ${derivationPath}`);
+    }
+}
+export function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPathToPublicKeyMap) {
+    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];
+        if (derivationPath) {
+            const publicKey = derivationPathToPublicKeyMap[derivationPath];
+            assert(Buffer.isBuffer(publicKey), `no public key found for derivation path`);
+            const derivationPathNumerical = splitBip44PathToNumber(derivationPath);
+            if (isTaproot(witnessUtxo.scriptPubKey)) {
+                psbt.setInputTapBip32Derivation(inputIndex, publicKey.slice(1), [], masterFingerprintBuffer, derivationPathNumerical);
+            }
+            else {
+                psbt.setInputBip32Derivation(inputIndex, publicKey, masterFingerprintBuffer, derivationPathNumerical);
+            }
+        }
+    }
+    for (let outputIndex = 0; outputIndex < psbt.getGlobalOutputCount(); outputIndex++) {
+        const scriptPubKey = psbt.getOutputScript(outputIndex);
+        const derivationPath = scriptPubKeyToDerivationPathMap[scriptPubKey.toString('hex')];
+        if (derivationPath) {
+            const publicKey = derivationPathToPublicKeyMap[derivationPath];
+            assert(Buffer.isBuffer(publicKey), `no public key found for derivation path`);
+            const derivationPathNumerical = splitBip44PathToNumber(derivationPath);
+            if (isTaproot(scriptPubKey)) {
+                psbt.setOutputTapBip32Derivation(outputIndex, publicKey.slice(1), [], masterFingerprintBuffer, derivationPathNumerical);
+            }
+            else {
+                psbt.setOutputBip32Derivation(outputIndex, publicKey, masterFingerprintBuffer, derivationPathNumerical);
+            }
+        }
+    }
+}
+function computeScriptPubKeyToDerivationPathMap(derivationPathToPublicKeyMap) {
+    return Object.entries(derivationPathToPublicKeyMap).reduce((acc, [derivationPath, publicKey]) => {
+        if (derivationPath.startsWith('m/84')) {
+            const segwitV0 = payments.p2wpkh({
+                pubkey: publicKey,
+            }).output;
+            if (segwitV0) {
+                Object.assign(acc, {
+                    [segwitV0.toString('hex')]: derivationPath,
+                });
+            }
+        }
+        else if (derivationPath.startsWith('m/86')) {
+            const taproot = payments.p2tr({
+                internalPubkey: publicKey.slice(1),
+            }).output;
+            if (taproot) {
+                Object.assign(acc, {
+                    [taproot.toString('hex')]: derivationPath,
+                });
+            }
+        }
+        return acc;
+    }, Object.create(null));
+}
+function isTaproot(scriptPubKey) {
+    return scriptPubKey.length === 34 && scriptPubKey.at(0) === 0x51 && scriptPubKey.at(1) === 0x20;
+}

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

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function buildFauxXPUB(publicKey: Buffer, chainCode: Buffer): string;

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

@@ -0,0 +1,16 @@
+import bs58check from 'bs58check';
+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/module/device.d.ts

@@ -14,6 +14,6 @@ export declare class LedgerDevice implements HardwareWalletDevice {
     getAddress: (params: GetAddressParams) => Promise<string>;
     getXPub: (params: GetXPubParams) => Promise<string>;
     getPublicKey: (params: GetPublicKeyParams) => Promise<Readonly<Uint8Array>>;
-    signTransaction: (params: SignTransactionParams) => Promise<Readonly<Uint8Array>>;
+    signTransaction: (params: SignTransactionParams) => Promise<import("@exodus/hw-common").Signatures>;
     signMessage: (params: SignMessageParams) => Promise<Readonly<Uint8Array>>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/hw-ledger",
-  "version": "1.3.2",
+  "version": "2.0.0",
   "description": "The ledger module",
   "author": "Exodus Movement Inc.",
   "repository": {
@@ -26,14 +26,16 @@
     "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"
+    "lint:fix": "yarn lint --fix",
+    "prepublishOnly": "yarn run -T build --scope @exodus/hw-ledger"
   },
   "dependencies": {
+    "@exodus/bitcoinjs-lib": "^6.1.5-exodus.0",
     "@exodus/ethersproject-abi": "^5.4.2-exodus.2",
     "@exodus/ethersproject-transactions": "^5.4.2-exodus.0",
-    "@exodus/hw-common": "^1.2.1",
+    "@exodus/hw-common": "^2.0.0",
     "@exodus/ledger-bitcoin": "^0.2.3-exodus.0",
-    "@exodus/ledgerhq-hw-app-eth": "^6.33.7-exodus.0",
+    "@exodus/ledgerhq-hw-app-eth": "^6.33.7-exodus.3",
     "@exodus/secp256k1": "^4.0.2-exodus.0",
     "@ledgerhq/hw-app-solana": "^7.0.10",
     "@ledgerhq/hw-transport": "^6.28.5",
@@ -45,11 +47,13 @@
   },
   "devDependencies": {
     "@exodus/bip32": "^2.0.0",
+    "@exodus/ledgerhq-devices": "^8.1.0-exodus.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/create-hash": "^1.2.6",
     "@types/jest-when": "^3.5.2",
     "@types/minimalistic-assert": "^1.0.1",
     "@types/secp256k1": "^4.0.3",
@@ -59,8 +63,9 @@
     "istanbul-combine": "^0.3.0",
     "jest": "^29.1.2",
     "jest-when": "^3.5.2",
+    "tiny-secp256k1": "^2.2.3",
     "ts-jest": "^29.0.3",
     "typescript": "^4.7.3"
   },
-  "gitHead": "d8f26958c3e7cf55de5bc2cbe4f4ae2a075e5051"
+  "gitHead": "bd3c7a6093ef581c8c0d694761cde1114a486c75"
 }

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

@@ -1,6 +0,0 @@
-/// <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 {};