@xchainjs/xchain-dash 2.0.10 → 2.2.0

package/lib/client.d.ts

@@ -1,6 +1,6 @@
 import { AssetInfo, FeeRate, TxHistoryParams } from '@xchainjs/xchain-client';
 import { Address } from '@xchainjs/xchain-util';
-import { Balance, Client as UTXOClient, Tx, TxParams, TxsPage, UTXO, UtxoClientParams } from '@xchainjs/xchain-utxo';
+import { Balance, Client as UTXOClient, PreparedTx, Tx, TxParams, TxsPage, UTXO, UtxoClientParams, UtxoSelectionPreferences } from '@xchainjs/xchain-utxo';
 import { DashPreparedTx, NodeAuth, NodeUrls } from './types';
 /**
  * Default parameters for the DASH client.
@@ -59,6 +59,7 @@ declare abstract class Client extends UTXOClient {
     private insightTxToXChainTx;
     /**
      * Asynchronously prepares a transaction for sending assets.
+     * @deprecated Use `prepareTxEnhanced` instead for better UTXO selection and error handling.
      * @param {TxParams&Address&FeeRate} params - Parameters for the transaction preparation.
      * @returns {string} A promise resolving to the prepared transaction data.
      */
@@ -80,5 +81,31 @@ declare abstract class Client extends UTXOClient {
      * @returns {number} The calculated transaction fee amount.
      */
     protected getFeeFromUtxos(inputs: UTXO[], feeRate: FeeRate, data?: Buffer | null): number;
+    /**
+     * Prepare transaction with enhanced UTXO selection.
+     * Uses base class UTXO selection logic with dashcore-lib transaction building.
+     */
+    prepareTxEnhanced({ sender, memo, amount, recipient, feeRate, spendPendingUTXO, utxoSelectionPreferences, selectedUtxos, }: TxParams & {
+        sender: Address;
+        feeRate: FeeRate;
+        spendPendingUTXO?: boolean;
+        utxoSelectionPreferences?: UtxoSelectionPreferences;
+        selectedUtxos?: UTXO[];
+    }): Promise<PreparedTx>;
+    /**
+     * Prepare max send transaction
+     */
+    prepareMaxTx({ sender, recipient, memo, feeRate, spendPendingUTXO, utxoSelectionPreferences, selectedUtxos, }: {
+        sender: Address;
+        recipient: Address;
+        memo?: string;
+        feeRate: FeeRate;
+        spendPendingUTXO?: boolean;
+        utxoSelectionPreferences?: UtxoSelectionPreferences;
+        selectedUtxos?: UTXO[];
+    }): Promise<PreparedTx & {
+        maxAmount: number;
+        fee: number;
+    }>;
 }
 export { Client };

package/lib/clientKeystore.d.ts

@@ -1,6 +1,6 @@
 import { FeeRate, TxHash } from '@xchainjs/xchain-client';
 import { Address } from '@xchainjs/xchain-util';
-import { TxParams } from '@xchainjs/xchain-utxo';
+import { TxParams, UTXO, UtxoSelectionPreferences } from '@xchainjs/xchain-utxo';
 import { ECPairInterface } from 'ecpair';
 import { Client } from './client';
 export declare class ClientKeystore extends Client {
@@ -30,10 +30,36 @@ export declare class ClientKeystore extends Client {
     getDashKeys(phrase: string, index?: number): ECPairInterface;
     /**
      * Asynchronously transfers assets between addresses.
-     * @param {TxParams & { feeRate?: FeeRate }} params - Parameters for the transfer.
+     * @param {TxParams & { feeRate?: FeeRate; utxoSelectionPreferences?: UtxoSelectionPreferences }} params - Parameters for the transfer.
      * @returns {Promise<TxHash>} A promise resolving to the transaction hash.
      */
     transfer(params: TxParams & {
         feeRate?: FeeRate;
+        utxoSelectionPreferences?: UtxoSelectionPreferences;
+        selectedUtxos?: UTXO[];
     }): Promise<TxHash>;
+    /**
+     * Transfer the maximum amount of DASH (sweep).
+     *
+     * Calculates the maximum sendable amount after fees, signs, and broadcasts the transaction.
+     * @param {Object} params The transfer parameters.
+     * @param {string} params.recipient The recipient address.
+     * @param {string} [params.memo] Optional memo for the transaction.
+     * @param {FeeRate} [params.feeRate] Optional fee rate. Defaults to 'average' rate.
+     * @param {number} [params.walletIndex] Optional wallet index. Defaults to 0.
+     * @param {UtxoSelectionPreferences} [params.utxoSelectionPreferences] Optional UTXO selection preferences.
+     * @returns {Promise<{ hash: TxHash; maxAmount: number; fee: number }>} The transaction hash, amount sent, and fee.
+     */
+    transferMax(params: {
+        recipient: Address;
+        memo?: string;
+        feeRate?: FeeRate;
+        walletIndex?: number;
+        utxoSelectionPreferences?: UtxoSelectionPreferences;
+        selectedUtxos?: UTXO[];
+    }): Promise<{
+        hash: TxHash;
+        maxAmount: number;
+        fee: number;
+    }>;
 }

package/lib/clientLedger.d.ts

@@ -1,7 +1,7 @@
 import AppBtc from '@ledgerhq/hw-app-btc';
 import { FeeRate, TxHash } from '@xchainjs/xchain-client';
 import { Address } from '@xchainjs/xchain-util';
-import { TxParams, UtxoClientParams } from '@xchainjs/xchain-utxo';
+import { TxParams, UTXO, UtxoClientParams, UtxoSelectionPreferences } from '@xchainjs/xchain-utxo';
 import { Client } from './client';
 import { NodeAuth, NodeUrls } from './types';
 /**
@@ -21,5 +21,17 @@ declare class ClientLedger extends Client {
     transfer(params: TxParams & {
         feeRate?: FeeRate;
     }): Promise<TxHash>;
+    transferMax(params: {
+        recipient: Address;
+        memo?: string;
+        feeRate?: FeeRate;
+        walletIndex?: number;
+        utxoSelectionPreferences?: UtxoSelectionPreferences;
+        selectedUtxos?: UTXO[];
+    }): Promise<{
+        hash: TxHash;
+        maxAmount: number;
+        fee: number;
+    }>;
 }
 export { ClientLedger };

package/lib/index.esm.js

@@ -2,7 +2,7 @@ import { ExplorerProvider, Network, TxType, FeeOption, checkFeeBounds } from '@x
 import { AssetType, baseAmount, assetToBase, assetAmount } from '@xchainjs/xchain-util';
 import { BlockcypherProvider, BlockcypherNetwork, BitgoProvider } from '@xchainjs/xchain-utxo-providers';
 import dashcore from '@dashevo/dashcore-lib';
-import { toBitcoinJS, Client as Client$1 } from '@xchainjs/xchain-utxo';
+import { toBitcoinJS, Client as Client$1, UtxoTransactionValidator, UtxoError } from '@xchainjs/xchain-utxo';
 import * as Dash from 'bitcoinjs-lib';
 import accumulative from 'coinselect/accumulative.js';
 import * as ecc from '@bitcoin-js/tiny-secp256k1-asmjs';
@@ -4449,6 +4449,7 @@ class Client extends Client$1 {
     }
     /**
      * Asynchronously prepares a transaction for sending assets.
+     * @deprecated Use `prepareTxEnhanced` instead for better UTXO selection and error handling.
      * @param {TxParams&Address&FeeRate} params - Parameters for the transaction preparation.
      * @returns {string} A promise resolving to the prepared transaction data.
      */
@@ -4515,6 +4516,137 @@ class Client extends Client$1 {
         // Ensure fee meets minimum requirement
         return fee > TX_MIN_FEE ? fee : TX_MIN_FEE;
     }
+    // ==================== Enhanced Transaction Methods ====================
+    /**
+     * Prepare transaction with enhanced UTXO selection.
+     * Uses base class UTXO selection logic with dashcore-lib transaction building.
+     */
+    prepareTxEnhanced(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sender, memo, amount, recipient, feeRate, spendPendingUTXO = true, utxoSelectionPreferences, selectedUtxos, }) {
+            try {
+                // Validate inputs using base class method
+                this.validateTransactionInputs({
+                    amount,
+                    recipient,
+                    memo,
+                    sender,
+                    feeRate,
+                });
+                // Use provided UTXOs (coin control) or fetch from chain
+                let utxos;
+                if (selectedUtxos && selectedUtxos.length > 0) {
+                    UtxoTransactionValidator.validateUtxoSet(selectedUtxos);
+                    utxos = selectedUtxos;
+                }
+                else {
+                    const confirmedOnly = !spendPendingUTXO;
+                    utxos = yield this.getValidatedUtxos(sender, confirmedOnly);
+                }
+                const compiledMemo = memo ? this.compileMemo(memo) : null;
+                const targetValue = amount.amount().toNumber();
+                const extraOutputs = 1 + (compiledMemo ? 1 : 0);
+                // Use base class UTXO selection
+                const selectionResult = this.selectUtxosForTransaction(utxos, targetValue, Math.ceil(feeRate), extraOutputs, utxoSelectionPreferences);
+                // Build transaction using dashcore-lib
+                const tx = new dashcore.Transaction().to(recipient, targetValue);
+                // Add selected inputs
+                for (const utxo of selectionResult.inputs) {
+                    const scriptBuffer = Buffer.from(utxo.scriptPubKey || '', 'hex');
+                    const script = new dashcore.Script(scriptBuffer);
+                    const input = new dashcore.Transaction.Input.PublicKeyHash({
+                        prevTxId: Buffer.from(utxo.hash, 'hex'),
+                        outputIndex: utxo.index,
+                        script: '',
+                        output: new dashcore.Transaction.Output({
+                            satoshis: utxo.value,
+                            script,
+                        }),
+                    });
+                    tx.uncheckedAddInput(input);
+                }
+                // Set change address
+                const senderAddress = dashcore.Address.fromString(sender, this.network);
+                tx.change(senderAddress);
+                // Add memo if provided
+                if (memo) {
+                    tx.addData(memo);
+                }
+                // ESLint disabled: Dash transaction has proper toString() method that returns hex string
+                // eslint-disable-next-line @typescript-eslint/no-base-to-string
+                return { rawUnsignedTx: tx.toString(), utxos, inputs: selectionResult.inputs };
+            }
+            catch (error) {
+                if (UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw UtxoError.fromUnknown(error, 'prepareTxEnhanced');
+            }
+        });
+    }
+    /**
+     * Prepare max send transaction
+     */
+    prepareMaxTx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sender, recipient, memo, feeRate, spendPendingUTXO = true, utxoSelectionPreferences, selectedUtxos, }) {
+            try {
+                // Validate addresses
+                if (!this.validateAddress(recipient)) {
+                    throw UtxoError.invalidAddress(recipient, this.network);
+                }
+                if (!this.validateAddress(sender)) {
+                    throw UtxoError.invalidAddress(sender, this.network);
+                }
+                // Use provided UTXOs (coin control) or fetch from chain
+                let utxos;
+                if (selectedUtxos && selectedUtxos.length > 0) {
+                    UtxoTransactionValidator.validateUtxoSet(selectedUtxos);
+                    utxos = selectedUtxos;
+                }
+                else {
+                    const confirmedOnly = !spendPendingUTXO;
+                    utxos = yield this.getValidatedUtxos(sender, confirmedOnly);
+                }
+                // Calculate max using base class method
+                const maxCalc = this.calculateMaxSendableAmount(utxos, Math.ceil(feeRate), !!memo, utxoSelectionPreferences);
+                // Build transaction using dashcore-lib
+                const tx = new dashcore.Transaction().to(recipient, maxCalc.amount);
+                // Add inputs
+                for (const utxo of maxCalc.inputs) {
+                    const scriptBuffer = Buffer.from(utxo.scriptPubKey || '', 'hex');
+                    const script = new dashcore.Script(scriptBuffer);
+                    const input = new dashcore.Transaction.Input.PublicKeyHash({
+                        prevTxId: Buffer.from(utxo.hash, 'hex'),
+                        outputIndex: utxo.index,
+                        script: '',
+                        output: new dashcore.Transaction.Output({
+                            satoshis: utxo.value,
+                            script,
+                        }),
+                    });
+                    tx.uncheckedAddInput(input);
+                }
+                // Add memo if provided
+                if (memo) {
+                    tx.addData(memo);
+                }
+                // ESLint disabled: Dash transaction has proper toString() method that returns hex string
+                // eslint-disable-next-line @typescript-eslint/no-base-to-string
+                return {
+                    rawUnsignedTx: tx.toString(),
+                    utxos,
+                    inputs: maxCalc.inputs,
+                    maxAmount: maxCalc.amount,
+                    fee: maxCalc.fee,
+                };
+            }
+            catch (error) {
+                if (UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw UtxoError.fromUnknown(error, 'prepareMaxTx');
+            }
+        });
+    }
 }
 
 /**
@@ -4605,7 +4737,7 @@ class ClientKeystore extends Client {
     }
     /**
      * Asynchronously transfers assets between addresses.
-     * @param {TxParams & { feeRate?: FeeRate }} params - Parameters for the transfer.
+     * @param {TxParams & { feeRate?: FeeRate; utxoSelectionPreferences?: UtxoSelectionPreferences }} params - Parameters for the transfer.
      * @returns {Promise<TxHash>} A promise resolving to the transaction hash.
      */
     transfer(params) {
@@ -4614,7 +4746,9 @@ class ClientKeystore extends Client {
             const feeRate = params.feeRate || (yield this.getFeeRates())[FeeOption.Average];
             checkFeeBounds(this.feeBounds, feeRate);
             const fromAddressIndex = params.walletIndex || 0;
-            const { rawUnsignedTx, utxos } = yield this.prepareTx(Object.assign(Object.assign({}, params), { feeRate, sender: yield this.getAddressAsync(fromAddressIndex) }));
+            // Merge default preferences
+            const mergedPreferences = Object.assign({ minimizeFee: true, avoidDust: true, minimizeInputs: false }, params.utxoSelectionPreferences);
+            const { rawUnsignedTx, utxos } = yield this.prepareTxEnhanced(Object.assign(Object.assign({}, params), { feeRate, sender: yield this.getAddressAsync(fromAddressIndex), utxoSelectionPreferences: mergedPreferences, selectedUtxos: params.selectedUtxos }));
             const tx = new dashcore.Transaction(rawUnsignedTx);
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             tx.inputs.forEach((input, index) => {
@@ -4646,6 +4780,65 @@ class ClientKeystore extends Client {
             });
         });
     }
+    /**
+     * Transfer the maximum amount of DASH (sweep).
+     *
+     * Calculates the maximum sendable amount after fees, signs, and broadcasts the transaction.
+     * @param {Object} params The transfer parameters.
+     * @param {string} params.recipient The recipient address.
+     * @param {string} [params.memo] Optional memo for the transaction.
+     * @param {FeeRate} [params.feeRate] Optional fee rate. Defaults to 'average' rate.
+     * @param {number} [params.walletIndex] Optional wallet index. Defaults to 0.
+     * @param {UtxoSelectionPreferences} [params.utxoSelectionPreferences] Optional UTXO selection preferences.
+     * @returns {Promise<{ hash: TxHash; maxAmount: number; fee: number }>} The transaction hash, amount sent, and fee.
+     */
+    transferMax(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const feeRate = params.feeRate || (yield this.getFeeRates())[FeeOption.Average];
+            checkFeeBounds(this.feeBounds, feeRate);
+            const fromAddressIndex = params.walletIndex || 0;
+            const sender = yield this.getAddressAsync(fromAddressIndex);
+            const { rawUnsignedTx, utxos, maxAmount, fee } = yield this.prepareMaxTx({
+                sender,
+                recipient: params.recipient,
+                memo: params.memo,
+                feeRate,
+                utxoSelectionPreferences: params.utxoSelectionPreferences,
+                selectedUtxos: params.selectedUtxos,
+            });
+            const tx = new dashcore.Transaction(rawUnsignedTx);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            tx.inputs.forEach((input, index) => {
+                const insightUtxo = utxos.find((utxo) => {
+                    return utxo.hash === input.prevTxId.toString('hex') && utxo.index == input.outputIndex;
+                });
+                if (!insightUtxo) {
+                    throw new Error('Unable to match accumulative inputs with insight utxos');
+                }
+                const scriptBuffer = Buffer.from(insightUtxo.scriptPubKey || '', 'hex');
+                const script = new dashcore.Script(scriptBuffer);
+                tx.inputs[index] = new dashcore.Transaction.Input.PublicKeyHash({
+                    prevTxId: Buffer.from(insightUtxo.hash, 'hex'),
+                    outputIndex: insightUtxo.index,
+                    script: '',
+                    output: new dashcore.Transaction.Output({
+                        satoshis: insightUtxo.value,
+                        script,
+                    }),
+                });
+            });
+            const dashKeys = this.getDashKeys(this.phrase, fromAddressIndex);
+            tx.sign(`${(_a = dashKeys.privateKey) === null || _a === void 0 ? void 0 : _a.toString('hex')}`);
+            const txHex = tx.checkedSerialize({});
+            const hash = yield broadcastTx({
+                txHex,
+                nodeUrl: this.nodeUrls[this.network],
+                auth: this.nodeAuth,
+            });
+            return { hash, maxAmount, fee };
+        });
+    }
 }
 
 /**
@@ -4738,6 +4931,58 @@ class ClientLedger extends Client {
             return txHash;
         });
     }
+    // Transfer max DASH from Ledger (sweep transaction)
+    transferMax(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const app = yield this.getApp();
+            const fromAddressIndex = (params === null || params === void 0 ? void 0 : params.walletIndex) || 0;
+            const feeRate = params.feeRate || (yield this.getFeeRates())[FeeOption.Fast];
+            checkFeeBounds(this.feeBounds, feeRate);
+            const sender = yield this.getAddressAsync(fromAddressIndex);
+            const { rawUnsignedTx, inputs, maxAmount, fee } = yield this.prepareMaxTx({
+                sender,
+                recipient: params.recipient,
+                memo: params.memo,
+                feeRate,
+                utxoSelectionPreferences: params.utxoSelectionPreferences,
+                selectedUtxos: params.selectedUtxos,
+            });
+            const tx = new dashcore.Transaction(rawUnsignedTx);
+            const ledgerInputs = [];
+            for (const input of tx.inputs) {
+                const insightUtxo = inputs.find((utxo) => {
+                    return utxo.hash === input.prevTxId.toString('hex') && utxo.index == input.outputIndex;
+                });
+                if (!insightUtxo) {
+                    throw new Error('Unable to match accumulative inputs with insight utxos');
+                }
+                const txHex = yield getRawTx({ txid: insightUtxo.hash, network: this.network });
+                const utxoTx = new dashcore.Transaction(txHex);
+                const splittedTx = app.splitTransaction(utxoTx.toString());
+                ledgerInputs.push([splittedTx, input.outputIndex, null, null]);
+            }
+            const associatedKeysets = tx.inputs.map(() => this.getFullDerivationPath(fromAddressIndex));
+            const newTx = app.splitTransaction(tx.toString(), true);
+            const outputScriptHex = app.serializeTransactionOutputs(newTx).toString('hex');
+            const txHex = yield app.createPaymentTransaction({
+                inputs: ledgerInputs,
+                associatedKeysets,
+                outputScriptHex,
+                segwit: false,
+                useTrustedInputForSegwit: false,
+                additionals: [],
+            });
+            const hash = yield broadcastTx({
+                txHex,
+                nodeUrl: this.nodeUrls[this.network],
+                auth: this.nodeAuth,
+            });
+            if (!hash) {
+                throw Error('No Tx hash');
+            }
+            return { hash, maxAmount, fee };
+        });
+    }
 }
 
 export { AssetDASH, BitgoProviders, BlockcypherDataProviders, ClientKeystore as Client, ClientKeystore, ClientLedger, DASHChain, DASH_DECIMAL, DASH_SYMBOL, DEFAULT_FEE_RATE, LOWER_FEE_BOUND, MIN_TX_FEE, UPPER_FEE_BOUND, buildTx, defaultDashParams, explorerProviders, getPrefix, validateAddress };

package/lib/index.js

@@ -4477,6 +4477,7 @@ class Client extends xchainUtxo.Client {
     }
     /**
      * Asynchronously prepares a transaction for sending assets.
+     * @deprecated Use `prepareTxEnhanced` instead for better UTXO selection and error handling.
      * @param {TxParams&Address&FeeRate} params - Parameters for the transaction preparation.
      * @returns {string} A promise resolving to the prepared transaction data.
      */
@@ -4543,6 +4544,137 @@ class Client extends xchainUtxo.Client {
         // Ensure fee meets minimum requirement
         return fee > TX_MIN_FEE ? fee : TX_MIN_FEE;
     }
+    // ==================== Enhanced Transaction Methods ====================
+    /**
+     * Prepare transaction with enhanced UTXO selection.
+     * Uses base class UTXO selection logic with dashcore-lib transaction building.
+     */
+    prepareTxEnhanced(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sender, memo, amount, recipient, feeRate, spendPendingUTXO = true, utxoSelectionPreferences, selectedUtxos, }) {
+            try {
+                // Validate inputs using base class method
+                this.validateTransactionInputs({
+                    amount,
+                    recipient,
+                    memo,
+                    sender,
+                    feeRate,
+                });
+                // Use provided UTXOs (coin control) or fetch from chain
+                let utxos;
+                if (selectedUtxos && selectedUtxos.length > 0) {
+                    xchainUtxo.UtxoTransactionValidator.validateUtxoSet(selectedUtxos);
+                    utxos = selectedUtxos;
+                }
+                else {
+                    const confirmedOnly = !spendPendingUTXO;
+                    utxos = yield this.getValidatedUtxos(sender, confirmedOnly);
+                }
+                const compiledMemo = memo ? this.compileMemo(memo) : null;
+                const targetValue = amount.amount().toNumber();
+                const extraOutputs = 1 + (compiledMemo ? 1 : 0);
+                // Use base class UTXO selection
+                const selectionResult = this.selectUtxosForTransaction(utxos, targetValue, Math.ceil(feeRate), extraOutputs, utxoSelectionPreferences);
+                // Build transaction using dashcore-lib
+                const tx = new dashcore__default.default.Transaction().to(recipient, targetValue);
+                // Add selected inputs
+                for (const utxo of selectionResult.inputs) {
+                    const scriptBuffer = Buffer.from(utxo.scriptPubKey || '', 'hex');
+                    const script = new dashcore__default.default.Script(scriptBuffer);
+                    const input = new dashcore__default.default.Transaction.Input.PublicKeyHash({
+                        prevTxId: Buffer.from(utxo.hash, 'hex'),
+                        outputIndex: utxo.index,
+                        script: '',
+                        output: new dashcore__default.default.Transaction.Output({
+                            satoshis: utxo.value,
+                            script,
+                        }),
+                    });
+                    tx.uncheckedAddInput(input);
+                }
+                // Set change address
+                const senderAddress = dashcore__default.default.Address.fromString(sender, this.network);
+                tx.change(senderAddress);
+                // Add memo if provided
+                if (memo) {
+                    tx.addData(memo);
+                }
+                // ESLint disabled: Dash transaction has proper toString() method that returns hex string
+                // eslint-disable-next-line @typescript-eslint/no-base-to-string
+                return { rawUnsignedTx: tx.toString(), utxos, inputs: selectionResult.inputs };
+            }
+            catch (error) {
+                if (xchainUtxo.UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw xchainUtxo.UtxoError.fromUnknown(error, 'prepareTxEnhanced');
+            }
+        });
+    }
+    /**
+     * Prepare max send transaction
+     */
+    prepareMaxTx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sender, recipient, memo, feeRate, spendPendingUTXO = true, utxoSelectionPreferences, selectedUtxos, }) {
+            try {
+                // Validate addresses
+                if (!this.validateAddress(recipient)) {
+                    throw xchainUtxo.UtxoError.invalidAddress(recipient, this.network);
+                }
+                if (!this.validateAddress(sender)) {
+                    throw xchainUtxo.UtxoError.invalidAddress(sender, this.network);
+                }
+                // Use provided UTXOs (coin control) or fetch from chain
+                let utxos;
+                if (selectedUtxos && selectedUtxos.length > 0) {
+                    xchainUtxo.UtxoTransactionValidator.validateUtxoSet(selectedUtxos);
+                    utxos = selectedUtxos;
+                }
+                else {
+                    const confirmedOnly = !spendPendingUTXO;
+                    utxos = yield this.getValidatedUtxos(sender, confirmedOnly);
+                }
+                // Calculate max using base class method
+                const maxCalc = this.calculateMaxSendableAmount(utxos, Math.ceil(feeRate), !!memo, utxoSelectionPreferences);
+                // Build transaction using dashcore-lib
+                const tx = new dashcore__default.default.Transaction().to(recipient, maxCalc.amount);
+                // Add inputs
+                for (const utxo of maxCalc.inputs) {
+                    const scriptBuffer = Buffer.from(utxo.scriptPubKey || '', 'hex');
+                    const script = new dashcore__default.default.Script(scriptBuffer);
+                    const input = new dashcore__default.default.Transaction.Input.PublicKeyHash({
+                        prevTxId: Buffer.from(utxo.hash, 'hex'),
+                        outputIndex: utxo.index,
+                        script: '',
+                        output: new dashcore__default.default.Transaction.Output({
+                            satoshis: utxo.value,
+                            script,
+                        }),
+                    });
+                    tx.uncheckedAddInput(input);
+                }
+                // Add memo if provided
+                if (memo) {
+                    tx.addData(memo);
+                }
+                // ESLint disabled: Dash transaction has proper toString() method that returns hex string
+                // eslint-disable-next-line @typescript-eslint/no-base-to-string
+                return {
+                    rawUnsignedTx: tx.toString(),
+                    utxos,
+                    inputs: maxCalc.inputs,
+                    maxAmount: maxCalc.amount,
+                    fee: maxCalc.fee,
+                };
+            }
+            catch (error) {
+                if (xchainUtxo.UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw xchainUtxo.UtxoError.fromUnknown(error, 'prepareMaxTx');
+            }
+        });
+    }
 }
 
 /**
@@ -4633,7 +4765,7 @@ class ClientKeystore extends Client {
     }
     /**
      * Asynchronously transfers assets between addresses.
-     * @param {TxParams & { feeRate?: FeeRate }} params - Parameters for the transfer.
+     * @param {TxParams & { feeRate?: FeeRate; utxoSelectionPreferences?: UtxoSelectionPreferences }} params - Parameters for the transfer.
      * @returns {Promise<TxHash>} A promise resolving to the transaction hash.
      */
     transfer(params) {
@@ -4642,7 +4774,9 @@ class ClientKeystore extends Client {
             const feeRate = params.feeRate || (yield this.getFeeRates())[xchainClient.FeeOption.Average];
             xchainClient.checkFeeBounds(this.feeBounds, feeRate);
             const fromAddressIndex = params.walletIndex || 0;
-            const { rawUnsignedTx, utxos } = yield this.prepareTx(Object.assign(Object.assign({}, params), { feeRate, sender: yield this.getAddressAsync(fromAddressIndex) }));
+            // Merge default preferences
+            const mergedPreferences = Object.assign({ minimizeFee: true, avoidDust: true, minimizeInputs: false }, params.utxoSelectionPreferences);
+            const { rawUnsignedTx, utxos } = yield this.prepareTxEnhanced(Object.assign(Object.assign({}, params), { feeRate, sender: yield this.getAddressAsync(fromAddressIndex), utxoSelectionPreferences: mergedPreferences, selectedUtxos: params.selectedUtxos }));
             const tx = new dashcore__default.default.Transaction(rawUnsignedTx);
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             tx.inputs.forEach((input, index) => {
@@ -4674,6 +4808,65 @@ class ClientKeystore extends Client {
             });
         });
     }
+    /**
+     * Transfer the maximum amount of DASH (sweep).
+     *
+     * Calculates the maximum sendable amount after fees, signs, and broadcasts the transaction.
+     * @param {Object} params The transfer parameters.
+     * @param {string} params.recipient The recipient address.
+     * @param {string} [params.memo] Optional memo for the transaction.
+     * @param {FeeRate} [params.feeRate] Optional fee rate. Defaults to 'average' rate.
+     * @param {number} [params.walletIndex] Optional wallet index. Defaults to 0.
+     * @param {UtxoSelectionPreferences} [params.utxoSelectionPreferences] Optional UTXO selection preferences.
+     * @returns {Promise<{ hash: TxHash; maxAmount: number; fee: number }>} The transaction hash, amount sent, and fee.
+     */
+    transferMax(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const feeRate = params.feeRate || (yield this.getFeeRates())[xchainClient.FeeOption.Average];
+            xchainClient.checkFeeBounds(this.feeBounds, feeRate);
+            const fromAddressIndex = params.walletIndex || 0;
+            const sender = yield this.getAddressAsync(fromAddressIndex);
+            const { rawUnsignedTx, utxos, maxAmount, fee } = yield this.prepareMaxTx({
+                sender,
+                recipient: params.recipient,
+                memo: params.memo,
+                feeRate,
+                utxoSelectionPreferences: params.utxoSelectionPreferences,
+                selectedUtxos: params.selectedUtxos,
+            });
+            const tx = new dashcore__default.default.Transaction(rawUnsignedTx);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            tx.inputs.forEach((input, index) => {
+                const insightUtxo = utxos.find((utxo) => {
+                    return utxo.hash === input.prevTxId.toString('hex') && utxo.index == input.outputIndex;
+                });
+                if (!insightUtxo) {
+                    throw new Error('Unable to match accumulative inputs with insight utxos');
+                }
+                const scriptBuffer = Buffer.from(insightUtxo.scriptPubKey || '', 'hex');
+                const script = new dashcore__default.default.Script(scriptBuffer);
+                tx.inputs[index] = new dashcore__default.default.Transaction.Input.PublicKeyHash({
+                    prevTxId: Buffer.from(insightUtxo.hash, 'hex'),
+                    outputIndex: insightUtxo.index,
+                    script: '',
+                    output: new dashcore__default.default.Transaction.Output({
+                        satoshis: insightUtxo.value,
+                        script,
+                    }),
+                });
+            });
+            const dashKeys = this.getDashKeys(this.phrase, fromAddressIndex);
+            tx.sign(`${(_a = dashKeys.privateKey) === null || _a === void 0 ? void 0 : _a.toString('hex')}`);
+            const txHex = tx.checkedSerialize({});
+            const hash = yield broadcastTx({
+                txHex,
+                nodeUrl: this.nodeUrls[this.network],
+                auth: this.nodeAuth,
+            });
+            return { hash, maxAmount, fee };
+        });
+    }
 }
 
 /**
@@ -4766,6 +4959,58 @@ class ClientLedger extends Client {
             return txHash;
         });
     }
+    // Transfer max DASH from Ledger (sweep transaction)
+    transferMax(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const app = yield this.getApp();
+            const fromAddressIndex = (params === null || params === void 0 ? void 0 : params.walletIndex) || 0;
+            const feeRate = params.feeRate || (yield this.getFeeRates())[xchainClient.FeeOption.Fast];
+            xchainClient.checkFeeBounds(this.feeBounds, feeRate);
+            const sender = yield this.getAddressAsync(fromAddressIndex);
+            const { rawUnsignedTx, inputs, maxAmount, fee } = yield this.prepareMaxTx({
+                sender,
+                recipient: params.recipient,
+                memo: params.memo,
+                feeRate,
+                utxoSelectionPreferences: params.utxoSelectionPreferences,
+                selectedUtxos: params.selectedUtxos,
+            });
+            const tx = new dashcore__default.default.Transaction(rawUnsignedTx);
+            const ledgerInputs = [];
+            for (const input of tx.inputs) {
+                const insightUtxo = inputs.find((utxo) => {
+                    return utxo.hash === input.prevTxId.toString('hex') && utxo.index == input.outputIndex;
+                });
+                if (!insightUtxo) {
+                    throw new Error('Unable to match accumulative inputs with insight utxos');
+                }
+                const txHex = yield getRawTx({ txid: insightUtxo.hash, network: this.network });
+                const utxoTx = new dashcore__default.default.Transaction(txHex);
+                const splittedTx = app.splitTransaction(utxoTx.toString());
+                ledgerInputs.push([splittedTx, input.outputIndex, null, null]);
+            }
+            const associatedKeysets = tx.inputs.map(() => this.getFullDerivationPath(fromAddressIndex));
+            const newTx = app.splitTransaction(tx.toString(), true);
+            const outputScriptHex = app.serializeTransactionOutputs(newTx).toString('hex');
+            const txHex = yield app.createPaymentTransaction({
+                inputs: ledgerInputs,
+                associatedKeysets,
+                outputScriptHex,
+                segwit: false,
+                useTrustedInputForSegwit: false,
+                additionals: [],
+            });
+            const hash = yield broadcastTx({
+                txHex,
+                nodeUrl: this.nodeUrls[this.network],
+                auth: this.nodeAuth,
+            });
+            if (!hash) {
+                throw Error('No Tx hash');
+            }
+            return { hash, maxAmount, fee };
+        });
+    }
 }
 
 exports.AssetDASH = AssetDASH;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-dash",
-  "version": "2.0.10",
+  "version": "2.2.0",
   "description": "Custom Dash client and utilities used by XChainJS clients",
   "keywords": [
     "XChain",
@@ -40,7 +40,7 @@
     "@xchainjs/xchain-client": "2.0.10",
     "@xchainjs/xchain-crypto": "1.0.6",
     "@xchainjs/xchain-util": "2.0.5",
-    "@xchainjs/xchain-utxo": "2.0.10",
+    "@xchainjs/xchain-utxo": "2.2.0",
     "@xchainjs/xchain-utxo-providers": "2.0.10",
     "bitcoinjs-lib": "^6.1.7",
     "coinselect": "3.1.12",