@exodus/hw-ledger 3.9.1 → 3.9.2

package/lib/module/assets/ripple.js

@@ -1,23 +1,28 @@
-import AppXrp 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';
+"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"));
 async function createHandler(transport) {
-    const app = new AppXrp(transport);
+    const app = new hw_app_xrp_1.default(transport);
     const getAddress = async (params) => {
         const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
         return address;
     };
     const getXPub = async () => {
-        throw new XPubUnsupportedError();
+        throw new hw_common_1.XPubUnsupportedError();
     };
     const getPublicKey = async (params) => {
         const { publicKey } = await app.getAddress(params.derivationPath.replace('m/', ''));
         return Buffer.from(publicKey, 'hex');
     };
     const signTransaction = async (params) => {
-        assert(Array.isArray(params.derivationPaths) && params.derivationPaths.length === 1, 'derivationsPath array must be one element long');
+        (0, minimalistic_assert_1.default)(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);
@@ -26,7 +31,7 @@ async function createHandler(transport) {
             Account: address,
             SigningPubKey: publicKey.toUpperCase(),
         };
-        const encoded = binaryCodec.encode(txForSigning);
+        const encoded = ripple_binary_codec_1.default.encode(txForSigning);
         const signature = await app.signTransaction(derivationPath, encoded);
         return [
             {
@@ -36,7 +41,7 @@ async function createHandler(transport) {
         ];
     };
     const signMessage = async () => {
-        throw new SignMessageUnsupportedError();
+        throw new hw_common_1.SignMessageUnsupportedError();
     };
     return {
         getAddress,
@@ -47,7 +52,7 @@ async function createHandler(transport) {
     };
 }
 const metadata = {
-    applications: [applications.XRP],
+    applications: [applications_js_1.default.XRP],
     handler: createHandler,
 };
-export default metadata;
+exports.default = metadata;

package/lib/module/assets/solana.js

@@ -1,24 +1,29 @@
-import AppSolana 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';
-import applications from './applications';
+"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"));
 async function createHandler(transport) {
-    const app = new AppSolana(transport);
+    const app = new hw_app_solana_1.default(transport);
     const getAddress = async (params) => {
         const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
-        return toBase58(address);
+        return (0, base58_js_1.toBase58)(address);
     };
     const getXPub = async (params) => {
-        throw new XPubUnsupportedError();
+        throw new hw_common_1.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');
+        (0, minimalistic_assert_1.default)(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;
@@ -36,7 +41,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 RequiresBlindSigningError();
+                throw new errors_js_1.RequiresBlindSigningError();
             }
             else {
                 throw err;
@@ -51,7 +56,7 @@ async function createHandler(transport) {
         ];
     };
     const signMessage = async (params) => {
-        assert(Buffer.isBuffer(params.message.rawMessage), 'rawMessage must be a buffer');
+        (0, minimalistic_assert_1.default)(Buffer.isBuffer(params.message.rawMessage), 'rawMessage must be a buffer');
         const { signature } = await app.signOffchainMessage(params.derivationPath.replace('m/', ''), params.message.rawMessage);
         return signature;
     };
@@ -64,7 +69,7 @@ async function createHandler(transport) {
     };
 }
 const metadata = {
-    applications: [applications.Solana],
+    applications: [applications_js_1.default.Solana],
     handler: createHandler,
 };
-export default metadata;
+exports.default = metadata;

package/lib/module/assets/tronmainnet.js

@@ -1,16 +1,54 @@
-import AppTron 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';
+"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"));
 async function createHandler(transport) {
-    const app = new AppTron(transport);
+    const app = new hw_app_trx_1.default(transport);
     const getAddress = async (params) => {
         const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
         return address;
     };
     const getXPub = async (params) => {
-        throw new XPubUnsupportedError();
+        throw new hw_common_1.XPubUnsupportedError();
     };
     const getPublicKey = async (params) => {
         const { publicKey } = await app.getAddress(params.derivationPath.replace('m/', ''));
@@ -21,7 +59,7 @@ async function createHandler(transport) {
         });
     };
     const signTransaction = async (params) => {
-        assert(Array.isArray(params.derivationPaths) && params.derivationPaths.length === 1, 'derivationsPath array must be one element long');
+        (0, minimalistic_assert_1.default)(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.`);
         }
@@ -34,7 +72,7 @@ async function createHandler(transport) {
     };
     const signMessage = async (params) => {
         if (params.message.rawMessage) {
-            assert(Buffer.isBuffer(params.message.rawMessage), 'rawMessage must be a buffer');
+            (0, minimalistic_assert_1.default)(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');
         }
@@ -42,7 +80,7 @@ async function createHandler(transport) {
             throw new Error('TIP712 messages are not yet supported');
         }
         else {
-            assert(false, 'rawMessage or TIP712Message must be specified');
+            (0, minimalistic_assert_1.default)(false, 'rawMessage or TIP712Message must be specified');
         }
     };
     return {
@@ -54,7 +92,7 @@ async function createHandler(transport) {
     };
 }
 const metadata = {
-    applications: [applications.Tron],
+    applications: [applications_js_1.default.Tron],
     handler: createHandler,
 };
-export default metadata;
+exports.default = metadata;

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

@@ -1,13 +1,49 @@
-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);
+"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);
     const toSpendTxId = toSpendTx.getId();
-    if (Address.isP2SH(address)) {
+    if (bip322_js_1.Address.isP2SH(address)) {
         throw new Error('Unable to sign BIP-322 message for unimplemented address type.');
     }
-    else if (Address.isP2WPKH(address) || Address.isP2TR(address)) {
+    else if (bip322_js_1.Address.isP2WPKH(address) || bip322_js_1.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,34 +1,45 @@
-import assert from 'minimalistic-assert';
-export function splitDerivationPath(derivationPath) {
-    assert(typeof derivationPath === 'string', 'derivationPath must be string');
+"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');
     const parts = derivationPath.split('/');
-    assert(parts.length > 1, 'invalid derivationPath: must have length > 1');
-    assert(parts[0] === 'm', 'invalid derivationPath: must start with m');
+    (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');
     return parts.slice(1);
 }
-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 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 splitBip44DerivationPath(derivationPath) {
+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');
+    (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');
     return [purpose, coin, account, change, address];
 }
-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 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 buildBip44PathFromNumber(parts) {
+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}`;
 }
-export function splitBip44PathToNumber(derivationPath) {
+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.d.ts

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

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

@@ -1,3 +1,19 @@
-export * from './derivation-paths';
-export * from './xpub';
-export * from './psbt';
+"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);

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

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

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

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

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

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

package/lib/module/constants.js

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

package/lib/module/device.d.ts

@@ -1,5 +1,5 @@
 import type { EnsureDeviceReadyParams, GetAddressParams, GetPublicKeyParams, GetXPubParams, HardwareWalletDescriptor, HardwareWalletDevice, SignMessageParams, SignTransactionParams } from '@exodus/hw-common';
-import type { TransportFactory } from './types';
+import type { TransportFactory } from './types.js';
 import type { Atom } from '@exodus/atoms';
 export type Dependencies = {
     transportFactory: TransportFactory;
@@ -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").Signatures>;
+    signTransaction: (params: SignTransactionParams) => Promise<import("@exodus/hw-common", { with: { "resolution-mode": "import" } }).Signatures>;
     signMessage: (params: SignMessageParams) => Promise<Readonly<Uint8Array<ArrayBufferLike>>>;
 }