@exodus/hw-ledger 3.9.2 → 4.0.0

package/lib/module/assets/ripple.js

@@ -1,28 +1,24 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const hw_app_xrp_1 = __importDefault(require("@ledgerhq/hw-app-xrp"));
-const minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
-const hw_common_1 = require("@exodus/hw-common");
-const ripple_binary_codec_1 = __importDefault(require("@exodus/ripple-binary-codec"));
-const applications_js_1 = __importDefault(require("./applications.js"));
+import AppXrpImport from '@ledgerhq/hw-app-xrp';
+import assert from 'minimalistic-assert';
+import { XPubUnsupportedError, SignMessageUnsupportedError } from '@exodus/hw-common';
+import binaryCodec from '@exodus/ripple-binary-codec';
+import applications from './applications.js';
+const AppXrp = (AppXrpImport.default ?? AppXrpImport);
 async function createHandler(transport) {
-    const app = new hw_app_xrp_1.default(transport);
+    const app = new AppXrp(transport);
     const getAddress = async (params) => {
         const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
         return address;
     };
     const getXPub = async () => {
-        throw new hw_common_1.XPubUnsupportedError();
+        throw new XPubUnsupportedError();
     };
     const getPublicKey = async (params) => {
         const { publicKey } = await app.getAddress(params.derivationPath.replace('m/', ''));
         return Buffer.from(publicKey, 'hex');
     };
     const signTransaction = async (params) => {
-        (0, minimalistic_assert_1.default)(Array.isArray(params.derivationPaths) && params.derivationPaths.length === 1, 'derivationsPath array must be one element long');
+        assert(Array.isArray(params.derivationPaths) && params.derivationPaths.length === 1, 'derivationsPath array must be one element long');
         const { txData } = params.signableTransaction;
         const derivationPath = params.derivationPaths[0].replace('m/', '');
         const { address, publicKey } = await app.getAddress(derivationPath);
@@ -31,7 +27,7 @@ async function createHandler(transport) {
             Account: address,
             SigningPubKey: publicKey.toUpperCase(),
         };
-        const encoded = ripple_binary_codec_1.default.encode(txForSigning);
+        const encoded = binaryCodec.encode(txForSigning);
         const signature = await app.signTransaction(derivationPath, encoded);
         return [
             {
@@ -41,7 +37,7 @@ async function createHandler(transport) {
         ];
     };
     const signMessage = async () => {
-        throw new hw_common_1.SignMessageUnsupportedError();
+        throw new SignMessageUnsupportedError();
     };
     return {
         getAddress,
@@ -52,7 +48,7 @@ async function createHandler(transport) {
     };
 }
 const metadata = {
-    applications: [applications_js_1.default.XRP],
+    applications: [applications.XRP],
     handler: createHandler,
 };
-exports.default = metadata;
+export default metadata;

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

@@ -1,5 +1,5 @@
-import type Transport from '@ledgerhq/hw-transport';
 import type { HardwareWalletAssetHandler } from '@exodus/hw-common';
+import type { Transport } from '../types.js';
 declare function createHandler(transport: Transport): Promise<HardwareWalletAssetHandler>;
 declare const metadata: {
     applications: {

package/lib/module/assets/solana.js

@@ -1,29 +1,26 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const hw_app_solana_1 = __importDefault(require("@ledgerhq/hw-app-solana"));
-const minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
-const base58_js_1 = require("@exodus/bytes/base58.js");
-const hw_common_1 = require("@exodus/hw-common");
-const errors_js_1 = require("../errors.js");
-const applications_js_1 = __importDefault(require("./applications.js"));
+import AppSolanaImport from '@ledgerhq/hw-app-solana';
+import assert from 'minimalistic-assert';
+import { toBase58 } from '@exodus/bytes/base58.js';
+import { XPubUnsupportedError } from '@exodus/hw-common';
+import { RequiresBlindSigningError } from '../errors.js';
+import applications from './applications.js';
+const AppSolana = (AppSolanaImport.default ??
+    AppSolanaImport);
 async function createHandler(transport) {
-    const app = new hw_app_solana_1.default(transport);
+    const app = new AppSolana(transport);
     const getAddress = async (params) => {
         const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
-        return (0, base58_js_1.toBase58)(address);
+        return toBase58(address);
     };
     const getXPub = async (params) => {
-        throw new hw_common_1.XPubUnsupportedError();
+        throw new XPubUnsupportedError();
     };
     const getPublicKey = async (params) => {
         const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
         return address;
     };
     const signTransaction = async (params) => {
-        (0, minimalistic_assert_1.default)(Array.isArray(params.derivationPaths) && params.derivationPaths.length === 1, 'derivationsPath array must be one element long');
+        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;
@@ -41,7 +38,7 @@ async function createHandler(transport) {
             .signTransaction(params.derivationPaths[0].replace('m/', ''), serializedTransaction)
             .catch((err) => {
             if (err.message.includes('Try enabling blind signature in the app')) {
-                throw new errors_js_1.RequiresBlindSigningError();
+                throw new RequiresBlindSigningError();
             }
             else {
                 throw err;
@@ -56,7 +53,7 @@ async function createHandler(transport) {
         ];
     };
     const signMessage = async (params) => {
-        (0, minimalistic_assert_1.default)(Buffer.isBuffer(params.message.rawMessage), 'rawMessage must be a buffer');
+        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;
     };
@@ -69,7 +66,7 @@ async function createHandler(transport) {
     };
 }
 const metadata = {
-    applications: [applications_js_1.default.Solana],
+    applications: [applications.Solana],
     handler: createHandler,
 };
-exports.default = metadata;
+export default metadata;

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

@@ -1,5 +1,5 @@
-import type Transport from '@ledgerhq/hw-transport';
 import type { Bytes, HardwareWalletAssetHandler } from '@exodus/hw-common';
+import type { Transport } from '../types.js';
 export interface TronMessage {
     rawMessage?: Bytes;
     TIP712Message?: {

package/lib/module/assets/tronmainnet.js

@@ -1,54 +1,18 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const hw_app_trx_1 = __importDefault(require("@ledgerhq/hw-app-trx"));
-const minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
-const hw_common_1 = require("@exodus/hw-common");
-const secp256k1 = __importStar(require("@exodus/crypto/secp256k1"));
-const applications_js_1 = __importDefault(require("./applications.js"));
+import AppTronImport from '@ledgerhq/hw-app-trx';
+import assert from 'minimalistic-assert';
+import { XPubUnsupportedError } from '@exodus/hw-common';
+import * as secp256k1 from '@exodus/crypto/secp256k1';
+import applications from './applications.js';
+const AppTron = (AppTronImport.default ??
+    AppTronImport);
 async function createHandler(transport) {
-    const app = new hw_app_trx_1.default(transport);
+    const app = new AppTron(transport);
     const getAddress = async (params) => {
         const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
         return address;
     };
     const getXPub = async (params) => {
-        throw new hw_common_1.XPubUnsupportedError();
+        throw new XPubUnsupportedError();
     };
     const getPublicKey = async (params) => {
         const { publicKey } = await app.getAddress(params.derivationPath.replace('m/', ''));
@@ -59,7 +23,7 @@ async function createHandler(transport) {
         });
     };
     const signTransaction = async (params) => {
-        (0, minimalistic_assert_1.default)(Array.isArray(params.derivationPaths) && params.derivationPaths.length === 1, 'derivationsPath array must be one element long');
+        assert(Array.isArray(params.derivationPaths) && params.derivationPaths.length === 1, 'derivationsPath array must be one element long');
         if (!Buffer.isBuffer(params.signableTransaction)) {
             throw new TypeError(`signableTransaction must be Buffer or serializable to a Buffer.`);
         }
@@ -72,7 +36,7 @@ async function createHandler(transport) {
     };
     const signMessage = async (params) => {
         if (params.message.rawMessage) {
-            (0, minimalistic_assert_1.default)(Buffer.isBuffer(params.message.rawMessage), 'rawMessage must be a buffer');
+            assert(Buffer.isBuffer(params.message.rawMessage), 'rawMessage must be a buffer');
             const signature = await app.signPersonalMessage(params.derivationPath.replace('m/', ''), params.message.rawMessage.toString('hex'));
             return Buffer.from(signature, 'hex');
         }
@@ -80,7 +44,7 @@ async function createHandler(transport) {
             throw new Error('TIP712 messages are not yet supported');
         }
         else {
-            (0, minimalistic_assert_1.default)(false, 'rawMessage or TIP712Message must be specified');
+            assert(false, 'rawMessage or TIP712Message must be specified');
         }
     };
     return {
@@ -92,7 +56,7 @@ async function createHandler(transport) {
     };
 }
 const metadata = {
-    applications: [applications_js_1.default.Tron],
+    applications: [applications.Tron],
     handler: createHandler,
 };
-exports.default = metadata;
+export default metadata;

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

@@ -1,49 +1,13 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildBip322PSBT = buildBip322PSBT;
-const bitcoin = __importStar(require("@exodus/bitcoinjs"));
-const bip322_js_1 = require("@exodus/bip322-js");
-function buildBip322PSBT(message, address) {
-    const scriptPubKey = bip322_js_1.Address.convertAdressToScriptPubkey(address);
-    const toSpendTx = bip322_js_1.BIP322.buildToSpendTx(message, scriptPubKey);
+import * as bitcoin from '@exodus/bitcoinjs';
+import { BIP322, Address } from '@exodus/bip322-js';
+export function buildBip322PSBT(message, address) {
+    const scriptPubKey = Address.convertAdressToScriptPubkey(address);
+    const toSpendTx = BIP322.buildToSpendTx(message, scriptPubKey);
     const toSpendTxId = toSpendTx.getId();
-    if (bip322_js_1.Address.isP2SH(address)) {
+    if (Address.isP2SH(address)) {
         throw new Error('Unable to sign BIP-322 message for unimplemented address type.');
     }
-    else if (bip322_js_1.Address.isP2WPKH(address) || bip322_js_1.Address.isP2TR(address)) {
+    else if (Address.isP2WPKH(address) || Address.isP2TR(address)) {
         return buildToSignNativeSegwitOrTaproot(toSpendTxId, scriptPubKey);
     }
     throw new Error('Unable to sign BIP-322 message for unsupported address type.');

package/lib/module/assets/utils/derivation-paths.js

@@ -1,45 +1,34 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitDerivationPath = splitDerivationPath;
-exports.assertBip44Path = assertBip44Path;
-exports.splitBip44DerivationPath = splitBip44DerivationPath;
-exports.assertBip44PathNumber = assertBip44PathNumber;
-exports.buildBip44PathFromNumber = buildBip44PathFromNumber;
-exports.splitBip44PathToNumber = splitBip44PathToNumber;
-const minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
-function splitDerivationPath(derivationPath) {
-    (0, minimalistic_assert_1.default)(typeof derivationPath === 'string', 'derivationPath must be string');
+import assert from 'minimalistic-assert';
+export function splitDerivationPath(derivationPath) {
+    assert(typeof derivationPath === 'string', 'derivationPath must be string');
     const parts = derivationPath.split('/');
-    (0, minimalistic_assert_1.default)(parts.length > 1, 'invalid derivationPath: must have length > 1');
-    (0, minimalistic_assert_1.default)(parts[0] === 'm', 'invalid derivationPath: must start with m');
+    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) {
-    (0, minimalistic_assert_1.default)(parts.length === 5, 'invalid bip44 derivation path: length must be 5');
-    (0, minimalistic_assert_1.default)(parts.every((part) => typeof part === 'string'), 'Invalid parts');
+export function assertBip44Path(parts) {
+    assert(parts.length === 5, 'invalid bip44 derivation path: length must be 5');
+    assert(parts.every((part) => typeof part === 'string'), 'Invalid parts');
 }
-function splitBip44DerivationPath(derivationPath) {
+export function splitBip44DerivationPath(derivationPath) {
     const parts = splitDerivationPath(derivationPath);
     assertBip44Path(parts);
     const [purpose, coin, account, change, address] = parts;
-    (0, minimalistic_assert_1.default)(purpose.endsWith("'"), 'invalid derivationPath: purpose must be hardened');
-    (0, minimalistic_assert_1.default)(coin.endsWith("'"), 'invalid derivationPath: coin must be hardened');
-    (0, minimalistic_assert_1.default)(account.endsWith("'"), 'invalid derivationPath: account must be hardened');
+    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];
 }
-function assertBip44PathNumber(parts) {
-    (0, minimalistic_assert_1.default)(parts.length === 5, 'invalid bip44 derivation path: length must be 5');
-    (0, minimalistic_assert_1.default)(parts.every((part) => typeof part === 'number'), 'Invalid parts');
+export function assertBip44PathNumber(parts) {
+    assert(parts.length === 5, 'invalid bip44 derivation path: length must be 5');
+    assert(parts.every((part) => typeof part === 'number'), 'Invalid parts');
 }
-function buildBip44PathFromNumber(parts) {
+export function buildBip44PathFromNumber(parts) {
     const [purpose, coin, account, chainIndex, addressIndex] = parts;
     const HARDENED_OFFSET = 0x80_00_00_00;
     return `m/${purpose - HARDENED_OFFSET}'/${coin - HARDENED_OFFSET}'/${account - HARDENED_OFFSET}'/${chainIndex}/${addressIndex}`;
 }
-function splitBip44PathToNumber(derivationPath) {
+export function splitBip44PathToNumber(derivationPath) {
     const [purpose, coin, account, change, address] = splitBip44DerivationPath(derivationPath);
     const HARDENED_OFFSET = 0x80_00_00_00;
     return [

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

@@ -1,19 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./derivation-paths.js"), exports);
-__exportStar(require("./xpub.js"), exports);
-__exportStar(require("./psbt.js"), exports);
+export * from './derivation-paths.js';
+export * from './xpub.js';
+export * from './psbt.js';

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

@@ -1,18 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMultisigWalletPolicy = exports.getWalletPolicy = void 0;
-exports.assertPsbtOnlyHasAllowedDerivationPaths = assertPsbtOnlyHasAllowedDerivationPaths;
-exports.tagPsbtWithDerivationPaths = tagPsbtWithDerivationPaths;
-exports.derivationPathsToWalletPolicy = derivationPathsToWalletPolicy;
-exports.addDummyInputs = addDummyInputs;
-const minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
-const ledger_bitcoin_1 = require("@exodus/ledger-bitcoin");
-const bitcoinjs_1 = require("@exodus/bitcoinjs");
-const derivation_paths_js_1 = require("./derivation-paths.js");
-function assertPsbtOnlyHasAllowedDerivationPaths(psbt, masterFingerprint, derivationPaths) {
+import assert from 'minimalistic-assert';
+import { DefaultWalletPolicy, WalletPolicy } from '@exodus/ledger-bitcoin';
+import { payments, address as baddress, Transaction } from '@exodus/bitcoinjs';
+import { buildBip44PathFromNumber, assertBip44PathNumber, splitBip44PathToNumber, splitBip44DerivationPath, } from './derivation-paths.js';
+export function assertPsbtOnlyHasAllowedDerivationPaths(psbt, masterFingerprint, derivationPaths) {
     for (let i = 0; i < psbt.getGlobalInputCount(); i++) {
         const BIP32_DERIVATION = 6;
         const TAP_BIP32_DERIVATION = 22;
@@ -36,12 +26,12 @@ function assertAllowedDerivation(bip32Derivation, masterFingerprint, derivationP
     const masterFingerprintToCheck = bip32Derivation.masterFingerprint.toString('hex');
     const isOurMasterFingerprint = masterFingerprintToCheck === masterFingerprint;
     if (isOurMasterFingerprint) {
-        (0, derivation_paths_js_1.assertBip44PathNumber)(bip32Derivation.path);
-        const derivationPath = (0, derivation_paths_js_1.buildBip44PathFromNumber)(bip32Derivation.path);
-        (0, minimalistic_assert_1.default)(derivationPaths.includes(derivationPath), `found unsupported derivation path: ${derivationPath}`);
+        assertBip44PathNumber(bip32Derivation.path);
+        const derivationPath = buildBip44PathFromNumber(bip32Derivation.path);
+        assert(derivationPaths.includes(derivationPath), `found unsupported derivation path: ${derivationPath}`);
     }
 }
-function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPathToPublicKeyMap, addressToDerivationPathMap) {
+export function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPathToPublicKeyMap, addressToDerivationPathMap) {
     const masterFingerprintBuffer = Buffer.from(masterFingerprint, 'hex');
     const scriptPubKeyToDerivationPathMap = computeScriptPubKeyToDerivationPathMap(derivationPathToPublicKeyMap);
     const derivationPathsToSignFor = [];
@@ -54,7 +44,7 @@ function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPathToPub
         }
         else if (nonWitnessUtxo) {
             const prevOutputIndex = psbt.getInputOutputIndex(inputIndex);
-            const decodedTransaction = bitcoinjs_1.Transaction.fromBuffer(nonWitnessUtxo);
+            const decodedTransaction = Transaction.fromBuffer(nonWitnessUtxo);
             scriptPubKey = decodedTransaction.outs[prevOutputIndex].script;
         }
         else {
@@ -63,15 +53,15 @@ function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPathToPub
         let derivationPath = scriptPubKeyToDerivationPathMap[scriptPubKey.toString('hex')];
         if (addressToDerivationPathMap && !derivationPath) {
             try {
-                const address = bitcoinjs_1.address.fromOutputScript(scriptPubKey);
+                const address = baddress.fromOutputScript(scriptPubKey);
                 derivationPath = addressToDerivationPathMap[address];
             }
             catch { }
         }
         if (derivationPath) {
             const publicKey = derivationPathToPublicKeyMap[derivationPath];
-            (0, minimalistic_assert_1.default)(Buffer.isBuffer(publicKey), `no public key found for derivation path`);
-            const derivationPathNumerical = (0, derivation_paths_js_1.splitBip44PathToNumber)(derivationPath);
+            assert(Buffer.isBuffer(publicKey), `no public key found for derivation path`);
+            const derivationPathNumerical = splitBip44PathToNumber(derivationPath);
             if (isTaproot(scriptPubKey)) {
                 psbt.setInputTapBip32Derivation(inputIndex, publicKey.slice(1), [], masterFingerprintBuffer, derivationPathNumerical);
             }
@@ -86,15 +76,15 @@ function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPathToPub
         let derivationPath = scriptPubKeyToDerivationPathMap[scriptPubKey.toString('hex')];
         if (addressToDerivationPathMap && !derivationPath) {
             try {
-                const address = bitcoinjs_1.address.fromOutputScript(scriptPubKey);
+                const address = baddress.fromOutputScript(scriptPubKey);
                 derivationPath = addressToDerivationPathMap[address];
             }
             catch { }
         }
         if (derivationPath) {
             const publicKey = derivationPathToPublicKeyMap[derivationPath];
-            (0, minimalistic_assert_1.default)(Buffer.isBuffer(publicKey), `no public key found for derivation path`);
-            const derivationPathNumerical = (0, derivation_paths_js_1.splitBip44PathToNumber)(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);
             }
@@ -108,37 +98,37 @@ function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPathToPub
 function computeScriptPubKeyToDerivationPathMap(derivationPathToPublicKeyMap) {
     return Object.entries(derivationPathToPublicKeyMap).reduce((acc, [derivationPath, publicKey]) => {
         if (derivationPath.startsWith('m/44')) {
-            const p2pkh = bitcoinjs_1.payments.p2pkh({
+            const p2pkh = payments.p2pkh({
                 pubkey: publicKey,
             }).output;
-            (0, minimalistic_assert_1.default)(p2pkh, 'failed to compute p2pkh scriptPubKey');
+            assert(p2pkh, 'failed to compute p2pkh scriptPubKey');
             Object.assign(acc, {
                 [p2pkh.toString('hex')]: derivationPath,
             });
         }
         else if (derivationPath.startsWith('m/49')) {
-            const nestedSegwit = bitcoinjs_1.payments.p2sh({
-                redeem: bitcoinjs_1.payments.p2wpkh({ pubkey: publicKey }),
+            const nestedSegwit = payments.p2sh({
+                redeem: payments.p2wpkh({ pubkey: publicKey }),
             }).output;
-            (0, minimalistic_assert_1.default)(nestedSegwit, 'failed to compute p2sh scriptPubKey');
+            assert(nestedSegwit, 'failed to compute p2sh scriptPubKey');
             Object.assign(acc, {
                 [nestedSegwit.toString('hex')]: derivationPath,
             });
         }
         else if (derivationPath.startsWith('m/84')) {
-            const p2wpkh = bitcoinjs_1.payments.p2wpkh({
+            const p2wpkh = payments.p2wpkh({
                 pubkey: publicKey,
             }).output;
-            (0, minimalistic_assert_1.default)(p2wpkh, 'failed to compute p2wpkh scriptPubKey');
+            assert(p2wpkh, 'failed to compute p2wpkh scriptPubKey');
             Object.assign(acc, {
                 [p2wpkh.toString('hex')]: derivationPath,
             });
         }
         else if (derivationPath.startsWith('m/86')) {
-            const p2tr = bitcoinjs_1.payments.p2tr({
+            const p2tr = payments.p2tr({
                 internalPubkey: publicKey.slice(1),
             }).output;
-            (0, minimalistic_assert_1.default)(p2tr, 'failed to compute p2tr scriptPubKey');
+            assert(p2tr, 'failed to compute p2tr scriptPubKey');
             Object.assign(acc, {
                 [p2tr.toString('hex')]: derivationPath,
             });
@@ -149,17 +139,16 @@ function computeScriptPubKeyToDerivationPathMap(derivationPathToPublicKeyMap) {
 function isTaproot(scriptPubKey) {
     return scriptPubKey.length === 34 && scriptPubKey.at(0) === 0x51 && scriptPubKey.at(1) === 0x20;
 }
-const getWalletPolicy = (fpr, xpub, purpose, coin, account) => {
+export const getWalletPolicy = (fpr, xpub, purpose, coin, account) => {
     const desc = {
         "44'": 'pkh(@0/**)',
         "49'": 'sh(wpkh(@0/**))',
         "84'": 'wpkh(@0/**)',
         "86'": 'tr(@0/**)',
     }[purpose];
-    return new ledger_bitcoin_1.DefaultWalletPolicy(desc, `[${fpr}/${purpose}/${coin}/${account}]${xpub}`);
+    return new DefaultWalletPolicy(desc, `[${fpr}/${purpose}/${coin}/${account}]${xpub}`);
 };
-exports.getWalletPolicy = getWalletPolicy;
-const getMultisigWalletPolicy = (fpr, xpub, purpose, coin, account, multisigData) => {
+export const getMultisigWalletPolicy = (fpr, xpub, purpose, coin, account, multisigData) => {
     let template = `tr(@0/**,sortedmulti_a(${multisigData.threshold}`;
     const keys = [multisigData.internalXpub];
     multisigData.xpubs.forEach((xpub2, i) => {
@@ -172,11 +161,10 @@ const getMultisigWalletPolicy = (fpr, xpub, purpose, coin, account, multisigData
         template += `,@${i + 1}/**`;
     });
     template += '))';
-    return new ledger_bitcoin_1.WalletPolicy('Multisig', template, keys);
+    return new WalletPolicy('Multisig', template, keys);
 };
-exports.getMultisigWalletPolicy = getMultisigWalletPolicy;
-async function derivationPathsToWalletPolicy(fpr, app, derivationPaths, multisigData) {
-    const splittedDerivationPaths = derivationPaths.map(derivation_paths_js_1.splitBip44DerivationPath);
+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;
         prev[[purpose, coin, account].toString()] = [purpose, coin, account];
@@ -187,10 +175,10 @@ async function derivationPathsToWalletPolicy(fpr, app, derivationPaths, multisig
         const [purpose, coin, account] = dedupedPath;
         const xpub = await app.getExtendedPubkey(`m/${purpose}/${coin}/${account}`);
         if (multisigData) {
-            walletPolicies.push((0, exports.getMultisigWalletPolicy)(fpr, xpub, purpose, coin, account, multisigData));
+            walletPolicies.push(getMultisigWalletPolicy(fpr, xpub, purpose, coin, account, multisigData));
         }
         else {
-            walletPolicies.push((0, exports.getWalletPolicy)(fpr, xpub, purpose, coin, account));
+            walletPolicies.push(getWalletPolicy(fpr, xpub, purpose, coin, account));
         }
     }
     return walletPolicies;
@@ -206,7 +194,7 @@ function canModifyInputs(psbt) {
     }
     return true;
 }
-function addDummyInputs(psbt) {
+export function addDummyInputs(psbt) {
     const canAddDummy = canModifyInputs(psbt);
     if (!canAddDummy) {
         return;

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

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildFauxXPUB = buildFauxXPUB;
-const base58check_js_1 = require("@exodus/bytes/base58check.js");
-function buildFauxXPUB(publicKey, chainCode) {
+import { toBase58checkSync } from '@exodus/bytes/base58check.js';
+export function buildFauxXPUB(publicKey, chainCode) {
     const LEN = 78;
     const XPUB_PREFIX = 0x04_88_b2_1e;
     const buffer = Buffer.alloc(LEN);
@@ -15,5 +12,5 @@ function buildFauxXPUB(publicKey, chainCode) {
     buffer.writeUInt32BE(index, 9);
     chainCode.copy(buffer, 13);
     publicKey.copy(buffer, 45);
-    return (0, base58check_js_1.toBase58checkSync)(buffer);
+    return toBase58checkSync(buffer);
 }

package/lib/module/constants.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.APDU_PORT = void 0;
-exports.APDU_PORT = 40_000;
+export const APDU_PORT = 40_000;

package/lib/module/device.d.ts

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