@xchainjs/xchain-doge 2.0.9 → 2.1.0

package/lib/client.d.ts

@@ -1,6 +1,6 @@
 import { AssetInfo, FeeRate } from '@xchainjs/xchain-client';
 import { Address } from '@xchainjs/xchain-util';
-import { Client as UTXOClient, PreparedTx, TxParams, UTXO, UtxoClientParams } from '@xchainjs/xchain-utxo';
+import { Client as UTXOClient, PreparedTx, TxParams, UTXO, UtxoClientParams, UtxoSelectionPreferences } from '@xchainjs/xchain-utxo';
 import * as Dogecoin from 'bitcoinjs-lib';
 import { LedgerTxInfo, LedgerTxInfoParams } from './types/ledger';
 /**
@@ -62,6 +62,7 @@ declare abstract class Client extends UTXOClient {
      * Asynchronously prepares a transaction for transfer.
      *
      * Builds a transaction (PSBT) with the specified transfer options.
+     * @deprecated Use `prepareTxEnhanced` instead for better UTXO selection and error handling.
      * @param {TxParams & { sender: Address; feeRate: FeeRate; spendPendingUTXO?: boolean }} params The transfer options including sender address, fee rate, and optional flag for spending pending UTXOs.
      * @returns {Promise<PreparedTx>} A promise that resolves to the raw unsigned transaction (PSBT).
      */
@@ -89,5 +90,59 @@ declare abstract class Client extends UTXOClient {
      * @returns {number} The calculated transaction fee.
      */
     protected getFeeFromUtxos(inputs: UTXO[], feeRate: FeeRate, data?: Buffer | null): number;
+    /**
+     * Build transaction with enhanced UTXO selection
+     * Note: Doge uses legacy P2PKH addresses (nonWitnessUtxo)
+     */
+    buildTxEnhanced({ amount, recipient, memo, feeRate, sender, spendPendingUTXO, utxoSelectionPreferences, }: TxParams & {
+        feeRate: FeeRate;
+        sender: Address;
+        spendPendingUTXO?: boolean;
+        utxoSelectionPreferences?: UtxoSelectionPreferences;
+    }): Promise<{
+        psbt: Dogecoin.Psbt;
+        utxos: UTXO[];
+        inputs: UTXO[];
+    }>;
+    /**
+     * Prepare transaction with enhanced UTXO selection
+     */
+    prepareTxEnhanced({ sender, memo, amount, recipient, spendPendingUTXO, feeRate, utxoSelectionPreferences, }: TxParams & {
+        sender: Address;
+        feeRate: FeeRate;
+        spendPendingUTXO?: boolean;
+        utxoSelectionPreferences?: UtxoSelectionPreferences;
+    }): Promise<PreparedTx>;
+    /**
+     * Send maximum possible amount (sweep)
+     */
+    sendMax({ sender, recipient, memo, feeRate, spendPendingUTXO, utxoSelectionPreferences, }: {
+        sender: Address;
+        recipient: Address;
+        memo?: string;
+        feeRate: FeeRate;
+        spendPendingUTXO?: boolean;
+        utxoSelectionPreferences?: UtxoSelectionPreferences;
+    }): Promise<{
+        psbt: Dogecoin.Psbt;
+        utxos: UTXO[];
+        inputs: UTXO[];
+        maxAmount: number;
+        fee: number;
+    }>;
+    /**
+     * Prepare max send transaction
+     */
+    prepareMaxTx({ sender, recipient, memo, feeRate, spendPendingUTXO, utxoSelectionPreferences, }: {
+        sender: Address;
+        recipient: Address;
+        memo?: string;
+        feeRate: FeeRate;
+        spendPendingUTXO?: boolean;
+        utxoSelectionPreferences?: UtxoSelectionPreferences;
+    }): 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, UtxoSelectionPreferences } from '@xchainjs/xchain-utxo';
 import { Client } from './client';
 /**
  * Custom Doge client extended to support keystore functionality
@@ -44,11 +44,36 @@ declare class ClientKeystore extends Client {
      * Asynchronously transfers Dogecoin.
      *
      * Builds, signs, and broadcasts a Dogecoin transaction with the specified parameters.
-     * @param {TxParams & { feeRate?: FeeRate }} params The transfer parameters including transaction details and optional fee rate.
-     * @returns {TxHash} A promise that resolves to the transaction hash once the transfer is completed.
+     *
+     * @param {Object} params The transfer parameters.
+     * @returns {Promise<TxHash>} The transaction hash.
      */
     transfer(params: TxParams & {
         feeRate?: FeeRate;
+        utxoSelectionPreferences?: UtxoSelectionPreferences;
     }): Promise<TxHash>;
+    /**
+     * Transfer the maximum amount of Dogecoin (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 'fast' 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;
+    }): Promise<{
+        hash: TxHash;
+        maxAmount: number;
+        fee: number;
+    }>;
 }
 export { ClientKeystore };

package/lib/index.esm.js

@@ -4,7 +4,7 @@ import { getSeed } from '@xchainjs/xchain-crypto';
 import * as Dogecoin from 'bitcoinjs-lib';
 import { ECPairFactory } from 'ecpair';
 import { HDKey } from '@scure/bip32';
-import { toBitcoinJS, Client as Client$1 } from '@xchainjs/xchain-utxo';
+import { toBitcoinJS, Client as Client$1, UtxoError } from '@xchainjs/xchain-utxo';
 import accumulative from 'coinselect/accumulative.js';
 import { AssetType } from '@xchainjs/xchain-util';
 import { SochainProvider, SochainNetwork, BlockcypherProvider, BlockcypherNetwork, BitgoProvider } from '@xchainjs/xchain-utxo-providers';
@@ -340,6 +340,7 @@ class Client extends Client$1 {
      * Asynchronously prepares a transaction for transfer.
      *
      * Builds a transaction (PSBT) with the specified transfer options.
+     * @deprecated Use `prepareTxEnhanced` instead for better UTXO selection and error handling.
      * @param {TxParams & { sender: Address; feeRate: FeeRate; spendPendingUTXO?: boolean }} params The transfer options including sender address, fee rate, and optional flag for spending pending UTXOs.
      * @returns {Promise<PreparedTx>} A promise that resolves to the raw unsigned transaction (PSBT).
      */
@@ -398,6 +399,167 @@ class Client extends Client$1 {
         // Ensure the fee is not less than the minimum transaction fee
         return fee > MIN_TX_FEE ? fee : MIN_TX_FEE;
     }
+    // ==================== Enhanced Transaction Methods ====================
+    /**
+     * Build transaction with enhanced UTXO selection
+     * Note: Doge uses legacy P2PKH addresses (nonWitnessUtxo)
+     */
+    buildTxEnhanced(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ amount, recipient, memo, feeRate, sender, spendPendingUTXO = true, utxoSelectionPreferences, }) {
+            try {
+                this.validateTransactionInputs({
+                    amount,
+                    recipient,
+                    memo,
+                    sender,
+                    feeRate,
+                });
+                const confirmedOnly = !spendPendingUTXO;
+                const utxos = yield this.getValidatedUtxos(sender, confirmedOnly);
+                const compiledMemo = memo ? this.compileMemo(memo) : null;
+                const targetValue = amount.amount().toNumber();
+                const extraOutputs = 1 + (compiledMemo ? 1 : 0);
+                const selectionResult = this.selectUtxosForTransaction(utxos, targetValue, Math.ceil(feeRate), extraOutputs, utxoSelectionPreferences);
+                const psbt = new Dogecoin.Psbt({ network: dogeNetwork(this.network) });
+                psbt.setMaximumFeeRate(7500000);
+                // Add inputs - Doge uses nonWitnessUtxo (legacy P2PKH)
+                for (const utxo of selectionResult.inputs) {
+                    psbt.addInput({
+                        hash: utxo.hash,
+                        index: utxo.index,
+                        nonWitnessUtxo: Buffer.from(utxo.txHex || '', 'hex'),
+                    });
+                }
+                // Add recipient output
+                psbt.addOutput({
+                    address: recipient,
+                    value: targetValue,
+                });
+                // Add change output if needed
+                if (selectionResult.changeAmount > 0) {
+                    psbt.addOutput({
+                        address: sender,
+                        value: selectionResult.changeAmount,
+                    });
+                }
+                // Add memo output if present
+                if (compiledMemo) {
+                    psbt.addOutput({ script: compiledMemo, value: 0 });
+                }
+                return { psbt, utxos, inputs: selectionResult.inputs };
+            }
+            catch (error) {
+                if (UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw UtxoError.fromUnknown(error, 'buildTxEnhanced');
+            }
+        });
+    }
+    /**
+     * Prepare transaction with enhanced UTXO selection
+     */
+    prepareTxEnhanced(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sender, memo, amount, recipient, spendPendingUTXO = true, feeRate, utxoSelectionPreferences, }) {
+            try {
+                const { psbt, utxos, inputs } = yield this.buildTxEnhanced({
+                    sender,
+                    recipient,
+                    amount,
+                    feeRate,
+                    memo,
+                    spendPendingUTXO,
+                    utxoSelectionPreferences,
+                });
+                return { rawUnsignedTx: psbt.toBase64(), utxos, inputs };
+            }
+            catch (error) {
+                if (UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw UtxoError.fromUnknown(error, 'prepareTxEnhanced');
+            }
+        });
+    }
+    /**
+     * Send maximum possible amount (sweep)
+     */
+    sendMax(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sender, recipient, memo, feeRate, spendPendingUTXO = true, utxoSelectionPreferences, }) {
+            try {
+                if (!this.validateAddress(recipient)) {
+                    throw UtxoError.invalidAddress(recipient, this.network);
+                }
+                if (!this.validateAddress(sender)) {
+                    throw UtxoError.invalidAddress(sender, this.network);
+                }
+                const confirmedOnly = !spendPendingUTXO;
+                const utxos = yield this.getValidatedUtxos(sender, confirmedOnly);
+                const maxCalc = this.calculateMaxSendableAmount(utxos, Math.ceil(feeRate), !!memo, utxoSelectionPreferences);
+                const compiledMemo = memo ? this.compileMemo(memo) : null;
+                const psbt = new Dogecoin.Psbt({ network: dogeNetwork(this.network) });
+                psbt.setMaximumFeeRate(7500000);
+                // Add inputs - Doge uses nonWitnessUtxo
+                for (const utxo of maxCalc.inputs) {
+                    psbt.addInput({
+                        hash: utxo.hash,
+                        index: utxo.index,
+                        nonWitnessUtxo: Buffer.from(utxo.txHex || '', 'hex'),
+                    });
+                }
+                psbt.addOutput({
+                    address: recipient,
+                    value: maxCalc.amount,
+                });
+                if (compiledMemo) {
+                    psbt.addOutput({ script: compiledMemo, value: 0 });
+                }
+                return {
+                    psbt,
+                    utxos,
+                    inputs: maxCalc.inputs,
+                    maxAmount: maxCalc.amount,
+                    fee: maxCalc.fee,
+                };
+            }
+            catch (error) {
+                if (UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw UtxoError.fromUnknown(error, 'sendMax');
+            }
+        });
+    }
+    /**
+     * Prepare max send transaction
+     */
+    prepareMaxTx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sender, recipient, memo, feeRate, spendPendingUTXO = true, utxoSelectionPreferences, }) {
+            try {
+                const { psbt, utxos, inputs, maxAmount, fee } = yield this.sendMax({
+                    sender,
+                    recipient,
+                    memo,
+                    feeRate,
+                    spendPendingUTXO,
+                    utxoSelectionPreferences,
+                });
+                return {
+                    rawUnsignedTx: psbt.toBase64(),
+                    utxos,
+                    inputs,
+                    maxAmount,
+                    fee,
+                };
+            }
+            catch (error) {
+                if (UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw UtxoError.fromUnknown(error, 'prepareMaxTx');
+            }
+        });
+    }
 }
 
 const ECPair = ECPairFactory(ecc);
@@ -474,33 +636,60 @@ class ClientKeystore extends Client {
      * Asynchronously transfers Dogecoin.
      *
      * Builds, signs, and broadcasts a Dogecoin transaction with the specified parameters.
-     * @param {TxParams & { feeRate?: FeeRate }} params The transfer parameters including transaction details and optional fee rate.
-     * @returns {TxHash} A promise that resolves to the transaction hash once the transfer is completed.
+     *
+     * @param {Object} params The transfer parameters.
+     * @returns {Promise<TxHash>} The transaction hash.
      */
     transfer(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Determine the fee rate for the transaction, using provided fee rate or fetching it from the network
             const feeRate = params.feeRate || (yield this.getFeeRates())[FeeOption.Fast];
-            // Check if the fee rate is within the specified fee bounds
             checkFeeBounds(this.feeBounds, feeRate);
-            // Get the index of the sender's address or use the default index (0)
             const fromAddressIndex = (params === null || params === void 0 ? void 0 : params.walletIndex) || 0;
-            // Prepare the transaction by building it with the specified parameters
-            const { rawUnsignedTx } = yield this.prepareTx(Object.assign(Object.assign({}, params), { feeRate, sender: yield this.getAddressAsync(fromAddressIndex) }));
-            // Get the Dogecoin keys for signing the transaction
+            const sender = yield this.getAddressAsync(fromAddressIndex);
             const dogeKeys = this.getDogeKeys(this.phrase, fromAddressIndex);
-            // Create a Partially Signed Bitcoin Transaction (PSBT) from the raw unsigned transaction
+            const mergedPreferences = Object.assign({ minimizeFee: true, avoidDust: true, minimizeInputs: false }, params.utxoSelectionPreferences);
+            const { rawUnsignedTx } = yield this.prepareTxEnhanced(Object.assign(Object.assign({}, params), { feeRate,
+                sender, utxoSelectionPreferences: mergedPreferences }));
             const psbt = Dogecoin.Psbt.fromBase64(rawUnsignedTx, { maximumFeeRate: 7500000 });
-            // Sign all inputs of the transaction with the Dogecoin keys
             psbt.signAllInputs(dogeKeys);
-            // Finalize all inputs of the transaction
             psbt.finalizeAllInputs();
-            // Extract the signed transaction and format it to hexadecimal
             const txHex = psbt.extractTransaction().toHex();
-            // Broadcast the signed transaction to the Dogecoin network and return the transaction hash
             return yield this.roundRobinBroadcastTx(txHex);
         });
     }
+    /**
+     * Transfer the maximum amount of Dogecoin (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 'fast' 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* () {
+            const feeRate = params.feeRate || (yield this.getFeeRates())[FeeOption.Fast];
+            checkFeeBounds(this.feeBounds, feeRate);
+            const fromAddressIndex = params.walletIndex || 0;
+            const sender = yield this.getAddressAsync(fromAddressIndex);
+            const { psbt, maxAmount, fee } = yield this.sendMax({
+                sender,
+                recipient: params.recipient,
+                memo: params.memo,
+                feeRate,
+                utxoSelectionPreferences: params.utxoSelectionPreferences,
+            });
+            const dogeKeys = this.getDogeKeys(this.phrase, fromAddressIndex);
+            psbt.signAllInputs(dogeKeys);
+            psbt.finalizeAllInputs();
+            const txHex = psbt.extractTransaction().toHex();
+            const hash = yield this.roundRobinBroadcastTx(txHex);
+            return { hash, maxAmount, fee };
+        });
+    }
 }
 
 /**

package/lib/index.js

@@ -367,6 +367,7 @@ class Client extends xchainUtxo.Client {
      * Asynchronously prepares a transaction for transfer.
      *
      * Builds a transaction (PSBT) with the specified transfer options.
+     * @deprecated Use `prepareTxEnhanced` instead for better UTXO selection and error handling.
      * @param {TxParams & { sender: Address; feeRate: FeeRate; spendPendingUTXO?: boolean }} params The transfer options including sender address, fee rate, and optional flag for spending pending UTXOs.
      * @returns {Promise<PreparedTx>} A promise that resolves to the raw unsigned transaction (PSBT).
      */
@@ -425,6 +426,167 @@ class Client extends xchainUtxo.Client {
         // Ensure the fee is not less than the minimum transaction fee
         return fee > MIN_TX_FEE ? fee : MIN_TX_FEE;
     }
+    // ==================== Enhanced Transaction Methods ====================
+    /**
+     * Build transaction with enhanced UTXO selection
+     * Note: Doge uses legacy P2PKH addresses (nonWitnessUtxo)
+     */
+    buildTxEnhanced(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ amount, recipient, memo, feeRate, sender, spendPendingUTXO = true, utxoSelectionPreferences, }) {
+            try {
+                this.validateTransactionInputs({
+                    amount,
+                    recipient,
+                    memo,
+                    sender,
+                    feeRate,
+                });
+                const confirmedOnly = !spendPendingUTXO;
+                const utxos = yield this.getValidatedUtxos(sender, confirmedOnly);
+                const compiledMemo = memo ? this.compileMemo(memo) : null;
+                const targetValue = amount.amount().toNumber();
+                const extraOutputs = 1 + (compiledMemo ? 1 : 0);
+                const selectionResult = this.selectUtxosForTransaction(utxos, targetValue, Math.ceil(feeRate), extraOutputs, utxoSelectionPreferences);
+                const psbt = new Dogecoin__namespace.Psbt({ network: dogeNetwork(this.network) });
+                psbt.setMaximumFeeRate(7500000);
+                // Add inputs - Doge uses nonWitnessUtxo (legacy P2PKH)
+                for (const utxo of selectionResult.inputs) {
+                    psbt.addInput({
+                        hash: utxo.hash,
+                        index: utxo.index,
+                        nonWitnessUtxo: Buffer.from(utxo.txHex || '', 'hex'),
+                    });
+                }
+                // Add recipient output
+                psbt.addOutput({
+                    address: recipient,
+                    value: targetValue,
+                });
+                // Add change output if needed
+                if (selectionResult.changeAmount > 0) {
+                    psbt.addOutput({
+                        address: sender,
+                        value: selectionResult.changeAmount,
+                    });
+                }
+                // Add memo output if present
+                if (compiledMemo) {
+                    psbt.addOutput({ script: compiledMemo, value: 0 });
+                }
+                return { psbt, utxos, inputs: selectionResult.inputs };
+            }
+            catch (error) {
+                if (xchainUtxo.UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw xchainUtxo.UtxoError.fromUnknown(error, 'buildTxEnhanced');
+            }
+        });
+    }
+    /**
+     * Prepare transaction with enhanced UTXO selection
+     */
+    prepareTxEnhanced(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sender, memo, amount, recipient, spendPendingUTXO = true, feeRate, utxoSelectionPreferences, }) {
+            try {
+                const { psbt, utxos, inputs } = yield this.buildTxEnhanced({
+                    sender,
+                    recipient,
+                    amount,
+                    feeRate,
+                    memo,
+                    spendPendingUTXO,
+                    utxoSelectionPreferences,
+                });
+                return { rawUnsignedTx: psbt.toBase64(), utxos, inputs };
+            }
+            catch (error) {
+                if (xchainUtxo.UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw xchainUtxo.UtxoError.fromUnknown(error, 'prepareTxEnhanced');
+            }
+        });
+    }
+    /**
+     * Send maximum possible amount (sweep)
+     */
+    sendMax(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sender, recipient, memo, feeRate, spendPendingUTXO = true, utxoSelectionPreferences, }) {
+            try {
+                if (!this.validateAddress(recipient)) {
+                    throw xchainUtxo.UtxoError.invalidAddress(recipient, this.network);
+                }
+                if (!this.validateAddress(sender)) {
+                    throw xchainUtxo.UtxoError.invalidAddress(sender, this.network);
+                }
+                const confirmedOnly = !spendPendingUTXO;
+                const utxos = yield this.getValidatedUtxos(sender, confirmedOnly);
+                const maxCalc = this.calculateMaxSendableAmount(utxos, Math.ceil(feeRate), !!memo, utxoSelectionPreferences);
+                const compiledMemo = memo ? this.compileMemo(memo) : null;
+                const psbt = new Dogecoin__namespace.Psbt({ network: dogeNetwork(this.network) });
+                psbt.setMaximumFeeRate(7500000);
+                // Add inputs - Doge uses nonWitnessUtxo
+                for (const utxo of maxCalc.inputs) {
+                    psbt.addInput({
+                        hash: utxo.hash,
+                        index: utxo.index,
+                        nonWitnessUtxo: Buffer.from(utxo.txHex || '', 'hex'),
+                    });
+                }
+                psbt.addOutput({
+                    address: recipient,
+                    value: maxCalc.amount,
+                });
+                if (compiledMemo) {
+                    psbt.addOutput({ script: compiledMemo, value: 0 });
+                }
+                return {
+                    psbt,
+                    utxos,
+                    inputs: maxCalc.inputs,
+                    maxAmount: maxCalc.amount,
+                    fee: maxCalc.fee,
+                };
+            }
+            catch (error) {
+                if (xchainUtxo.UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw xchainUtxo.UtxoError.fromUnknown(error, 'sendMax');
+            }
+        });
+    }
+    /**
+     * Prepare max send transaction
+     */
+    prepareMaxTx(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ sender, recipient, memo, feeRate, spendPendingUTXO = true, utxoSelectionPreferences, }) {
+            try {
+                const { psbt, utxos, inputs, maxAmount, fee } = yield this.sendMax({
+                    sender,
+                    recipient,
+                    memo,
+                    feeRate,
+                    spendPendingUTXO,
+                    utxoSelectionPreferences,
+                });
+                return {
+                    rawUnsignedTx: psbt.toBase64(),
+                    utxos,
+                    inputs,
+                    maxAmount,
+                    fee,
+                };
+            }
+            catch (error) {
+                if (xchainUtxo.UtxoError.isUtxoError(error)) {
+                    throw error;
+                }
+                throw xchainUtxo.UtxoError.fromUnknown(error, 'prepareMaxTx');
+            }
+        });
+    }
 }
 
 const ECPair = ecpair.ECPairFactory(ecc__namespace);
@@ -501,33 +663,60 @@ class ClientKeystore extends Client {
      * Asynchronously transfers Dogecoin.
      *
      * Builds, signs, and broadcasts a Dogecoin transaction with the specified parameters.
-     * @param {TxParams & { feeRate?: FeeRate }} params The transfer parameters including transaction details and optional fee rate.
-     * @returns {TxHash} A promise that resolves to the transaction hash once the transfer is completed.
+     *
+     * @param {Object} params The transfer parameters.
+     * @returns {Promise<TxHash>} The transaction hash.
      */
     transfer(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Determine the fee rate for the transaction, using provided fee rate or fetching it from the network
             const feeRate = params.feeRate || (yield this.getFeeRates())[xchainClient.FeeOption.Fast];
-            // Check if the fee rate is within the specified fee bounds
             xchainClient.checkFeeBounds(this.feeBounds, feeRate);
-            // Get the index of the sender's address or use the default index (0)
             const fromAddressIndex = (params === null || params === void 0 ? void 0 : params.walletIndex) || 0;
-            // Prepare the transaction by building it with the specified parameters
-            const { rawUnsignedTx } = yield this.prepareTx(Object.assign(Object.assign({}, params), { feeRate, sender: yield this.getAddressAsync(fromAddressIndex) }));
-            // Get the Dogecoin keys for signing the transaction
+            const sender = yield this.getAddressAsync(fromAddressIndex);
             const dogeKeys = this.getDogeKeys(this.phrase, fromAddressIndex);
-            // Create a Partially Signed Bitcoin Transaction (PSBT) from the raw unsigned transaction
+            const mergedPreferences = Object.assign({ minimizeFee: true, avoidDust: true, minimizeInputs: false }, params.utxoSelectionPreferences);
+            const { rawUnsignedTx } = yield this.prepareTxEnhanced(Object.assign(Object.assign({}, params), { feeRate,
+                sender, utxoSelectionPreferences: mergedPreferences }));
             const psbt = Dogecoin__namespace.Psbt.fromBase64(rawUnsignedTx, { maximumFeeRate: 7500000 });
-            // Sign all inputs of the transaction with the Dogecoin keys
             psbt.signAllInputs(dogeKeys);
-            // Finalize all inputs of the transaction
             psbt.finalizeAllInputs();
-            // Extract the signed transaction and format it to hexadecimal
             const txHex = psbt.extractTransaction().toHex();
-            // Broadcast the signed transaction to the Dogecoin network and return the transaction hash
             return yield this.roundRobinBroadcastTx(txHex);
         });
     }
+    /**
+     * Transfer the maximum amount of Dogecoin (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 'fast' 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* () {
+            const feeRate = params.feeRate || (yield this.getFeeRates())[xchainClient.FeeOption.Fast];
+            xchainClient.checkFeeBounds(this.feeBounds, feeRate);
+            const fromAddressIndex = params.walletIndex || 0;
+            const sender = yield this.getAddressAsync(fromAddressIndex);
+            const { psbt, maxAmount, fee } = yield this.sendMax({
+                sender,
+                recipient: params.recipient,
+                memo: params.memo,
+                feeRate,
+                utxoSelectionPreferences: params.utxoSelectionPreferences,
+            });
+            const dogeKeys = this.getDogeKeys(this.phrase, fromAddressIndex);
+            psbt.signAllInputs(dogeKeys);
+            psbt.finalizeAllInputs();
+            const txHex = psbt.extractTransaction().toHex();
+            const hash = yield this.roundRobinBroadcastTx(txHex);
+            return { hash, maxAmount, fee };
+        });
+    }
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xchainjs/xchain-doge",
-  "version": "2.0.9",
+  "version": "2.1.0",
   "description": "Custom Doge client and utilities used by XChain clients",
   "keywords": [
     "Xchain",
@@ -36,18 +36,18 @@
     "@bitcoin-js/tiny-secp256k1-asmjs": "^2.2.3",
     "@ledgerhq/hw-app-btc": "^10.9.0",
     "@scure/bip32": "^1.7.0",
-    "@xchainjs/xchain-client": "2.0.9",
+    "@xchainjs/xchain-client": "2.0.10",
     "@xchainjs/xchain-crypto": "1.0.6",
     "@xchainjs/xchain-util": "2.0.5",
-    "@xchainjs/xchain-utxo": "2.0.9",
-    "@xchainjs/xchain-utxo-providers": "2.0.9",
+    "@xchainjs/xchain-utxo": "2.1.0",
+    "@xchainjs/xchain-utxo-providers": "2.0.10",
     "bitcoinjs-lib": "^6.1.7",
     "coinselect": "3.1.12",
     "ecpair": "2.1.0"
   },
   "devDependencies": {
     "@ledgerhq/hw-transport-node-hid": "^6.28.6",
-    "axios": "1.12.1",
+    "axios": "1.13.5",
     "axios-mock-adapter": "^2.1.0"
   },
   "publishConfig": {