opnet 1.8.2 → 1.8.3

package/src/contracts/CallResult.ts

@@ -1,13 +1,5 @@
 import { QuantumBIP32Interface } from '@btc-vision/bip32';
-import {
-    fromBase64,
-    fromHex,
-    Network,
-    networks,
-    PsbtOutputExtended,
-    Signer,
-    toHex,
-} from '@btc-vision/bitcoin';
+import { fromBase64, fromHex, Network, networks, PsbtOutputExtended, Signer, toHex, } from '@btc-vision/bitcoin';
 import { UniversalSigner } from '@btc-vision/ecpair';
 import {
     Address,
@@ -24,6 +16,7 @@ import {
 } from '@btc-vision/transaction';
 import { UTXO } from '../bitcoin/UTXOs.js';
 import { BitcoinFees } from '../block/BlockGasParameters.js';
+import { PackageResult } from '../transactions/interfaces/BroadcastedTransactionPackage.js';
 import { decodeRevertData } from '../utils/RevertDecoder.js';
 import { RequestUTXOsParamsWithAmount } from '../utxos/interfaces/IUTXOsManager.js';
 import { CallResultSerializer, NetworkName } from './CallResultSerializer.js';
@@ -111,6 +104,23 @@ export interface InteractionTransactionReceipt {
     readonly compiledTargetScript: string | null;
 }
 
+function extractPackageFailures(packageResult: PackageResult): string[] {
+    const failures: string[] = [];
+    const results = packageResult.txResults;
+
+    for (const [submittedTxid, result] of Object.entries(results)) {
+        if (result.error) {
+            failures.push(`tx ${submittedTxid} failed: ${result.error}`);
+        }
+    }
+
+    if (failures.length === 0 && packageResult.packageMsg !== 'success') {
+        failures.push(`package rejected: ${packageResult.packageMsg}`);
+    }
+
+    return failures;
+}
+
 /**
  * Represents the result of a contract call.
  * @category Contracts
@@ -244,6 +254,13 @@ export class CallResult<
                     ),
                 );
             },
+            sendRawTransactionPackage: () => {
+                return Promise.reject(
+                    new Error(
+                        'Cannot broadcast from offline CallResult. Export signed transaction and broadcast online.',
+                    ),
+                );
+            },
             getCSV1ForAddress: () => {
                 if (!data.csvAddress) {
                     throw new Error('CSV address not available in offline data');
@@ -461,54 +478,87 @@ export class CallResult<
 
     /**
      * Broadcasts a pre-signed interaction transaction.
+     * Uses sendRawTransactionPackage for atomic broadcast when a funding tx is present,
+     * falls back to sendRawTransaction for P2WDA (interaction-only) transactions.
      * @param {SignedInteractionTransactionReceipt} signedTx - The signed transaction data.
      * @returns {Promise<InteractionTransactionReceipt>} The transaction receipt with broadcast results.
      */
     public async sendPresignedTransaction(
         signedTx: SignedInteractionTransactionReceipt,
     ): Promise<InteractionTransactionReceipt> {
-        if (!signedTx.utxoTracking.isP2WDA) {
-            if (!signedTx.fundingTransactionRaw) {
-                throw new Error('Funding transaction not created');
-            }
-
-            const tx1 = await this.#provider.sendRawTransaction(
-                signedTx.fundingTransactionRaw,
+        if (signedTx.utxoTracking.isP2WDA || !signedTx.fundingTransactionRaw) {
+            // P2WDA or no funding tx — broadcast interaction tx alone
+            const tx = await this.#provider.sendRawTransaction(
+                signedTx.interactionTransactionRaw,
                 false,
             );
 
-            if (!tx1 || tx1.error) {
-                throw new Error(`Error sending transaction: ${tx1?.error || 'Unknown error'}`);
+            if (!tx || tx.error) {
+                throw new Error(`Error sending transaction: ${tx?.error || 'Unknown error'}`);
             }
 
-            if (!tx1.success) {
-                throw new Error(`Error sending transaction: ${tx1.result || 'Unknown error'}`);
+            if (!tx.result) {
+                throw new Error('No transaction ID returned');
             }
-        }
 
-        const tx2 = await this.#provider.sendRawTransaction(
-            signedTx.interactionTransactionRaw,
-            false,
+            if (!tx.success) {
+                throw new Error(`Error sending transaction: ${tx.result || 'Unknown error'}`);
+            }
+
+            this.#processUTXOTracking(signedTx);
+
+            return {
+                interactionAddress: signedTx.interactionAddress,
+                transactionId: tx.result,
+                peerAcknowledgements: tx.peers || 0,
+                newUTXOs: signedTx.nextUTXOs,
+                estimatedFees: signedTx.estimatedFees,
+                challengeSolution: signedTx.challengeSolution,
+                rawTransaction: signedTx.interactionTransactionRaw,
+                fundingUTXOs: signedTx.fundingUTXOs,
+                fundingInputUtxos: signedTx.fundingInputUtxos,
+                compiledTargetScript: signedTx.compiledTargetScript,
+            };
+        }
+
+        // Package broadcast: [funding, interaction]
+        const result = await this.#provider.sendRawTransactionPackage(
+            [signedTx.fundingTransactionRaw, signedTx.interactionTransactionRaw],
+            true,
         );
 
-        if (!tx2 || tx2.error) {
-            throw new Error(`Error sending transaction: ${tx2?.error || 'Unknown error'}`);
+        if (!result.success) {
+            throw new Error(
+                `Error sending transaction package: ${result.error || 'Unknown error'}`,
+            );
         }
 
-        if (!tx2.result) {
-            throw new Error('No transaction ID returned');
+        // Check submitPackage per-tx failures if packageResult is present
+        if (result.packageResult) {
+            const failures = extractPackageFailures(result.packageResult);
+            if (failures.length > 0) {
+                throw new Error(`Transaction package failed:\n${failures.join('\n')}`);
+            }
         }
 
-        if (!tx2.success) {
-            throw new Error(`Error sending transaction: ${tx2.result || 'Unknown error'}`);
+        // Extract the interaction tx result (second tx in the package)
+        const interactionSeqResult = result.sequentialResults?.[1];
+        if (interactionSeqResult && !interactionSeqResult.success) {
+            throw new Error(
+                `Interaction transaction failed: ${interactionSeqResult.error || 'Unknown error'}`,
+            );
         }
 
+        const interactionTxId = interactionSeqResult?.txid || signedTx.interactionTransactionRaw;
+
+        const peers = interactionSeqResult?.peers || 0;
+
         this.#processUTXOTracking(signedTx);
 
         return {
             interactionAddress: signedTx.interactionAddress,
-            transactionId: tx2.result,
-            peerAcknowledgements: tx2.peers || 0,
+            transactionId: interactionTxId,
+            peerAcknowledgements: peers,
             newUTXOs: signedTx.nextUTXOs,
             estimatedFees: signedTx.estimatedFees,
             challengeSolution: signedTx.challengeSolution,

package/src/contracts/Contract.ts

@@ -20,7 +20,11 @@ import { BitcoinAbiTypes } from '../abi/BitcoinAbiTypes.js';
 import { BitcoinInterface } from '../abi/BitcoinInterface.js';
 import { BaseContractProperties } from '../abi/interfaces/BaseContractProperties.js';
 import { BitcoinAbiValue } from '../abi/interfaces/BitcoinAbiValue.js';
-import { BitcoinInterfaceAbi, EventBaseData, FunctionBaseData, } from '../abi/interfaces/BitcoinInterfaceAbi.js';
+import {
+    BitcoinInterfaceAbi,
+    EventBaseData,
+    FunctionBaseData,
+} from '../abi/interfaces/BitcoinInterfaceAbi.js';
 import { BlockGasParameters } from '../block/BlockGasParameters.js';
 import { DecodedCallResult } from '../common/CommonTypes.js';
 import { AbstractRpcProvider } from '../providers/AbstractRpcProvider.js';
@@ -141,7 +145,7 @@ export abstract class IBaseContract<T extends BaseContractProperties> implements
 
         return Promise.resolve(this.address);
     }
-    
+
     /**
      * Sets the sender of the transaction.
      * @param {Address} sender The sender of the transaction.
@@ -288,9 +292,12 @@ export abstract class IBaseContract<T extends BaseContractProperties> implements
         return this[key];
     }
 
-    private async getAddressOrThrow(address: string | Address, isContract: boolean): Promise<Address> {
+    private async getAddressOrThrow(
+        address: string | Address,
+        isContract: boolean,
+    ): Promise<Address> {
         const info = await this.provider.getPublicKeyInfo(address, isContract);
-        if(!info) {
+        if (!info) {
             throw new Error(`Address ${address} not found on the network.`);
         }
 

package/src/contracts/interfaces/IProviderForCallResult.ts

@@ -2,6 +2,7 @@ import { Network } from '@btc-vision/bitcoin';
 import { Address, ChallengeSolution, IP2WSHAddress } from '@btc-vision/transaction';
 import { UTXO, UTXOs } from '../../bitcoin/UTXOs.js';
 import { BroadcastedTransaction } from '../../transactions/interfaces/BroadcastedTransaction.js';
+import { BroadcastedTransactionPackage } from '../../transactions/interfaces/BroadcastedTransactionPackage.js';
 import { RequestUTXOsParamsWithAmount } from '../../utxos/interfaces/IUTXOsManager.js';
 
 /**
@@ -20,5 +21,9 @@ export interface IProviderForCallResult {
 
     getChallenge(): Promise<ChallengeSolution>;
     sendRawTransaction(tx: string, psbt: boolean): Promise<BroadcastedTransaction>;
+    sendRawTransactionPackage(
+        txs: string[],
+        isPackage?: boolean,
+    ): Promise<BroadcastedTransactionPackage>;
     getCSV1ForAddress(address: Address): IP2WSHAddress;
 }

package/src/opnet.ts

@@ -102,6 +102,7 @@ export * from './storage/StoredValue.js';
 /** Interfaces */
 export * from './contracts/interfaces/IRawContract.js';
 export * from './transactions/interfaces/BroadcastedTransaction.js';
+export * from './transactions/interfaces/BroadcastedTransactionPackage.js';
 export * from './transactions/interfaces/ITransaction.js';
 export * from './transactions/interfaces/ITransactionReceipt.js';
 export * from './transactions/metadata/TransactionReceipt.js';

package/src/providers/AbstractRpcProvider.ts

@@ -23,12 +23,20 @@ import { TransactionOutputFlags } from '../contracts/enums/TransactionFlags.js';
 import { IAccessList } from '../contracts/interfaces/IAccessList.js';
 import { ICallRequestError, ICallResult } from '../contracts/interfaces/ICallResult.js';
 import { IRawContract } from '../contracts/interfaces/IRawContract.js';
-import { ParsedSimulatedTransaction, SimulatedTransaction, } from '../contracts/interfaces/SimulatedTransaction.js';
+import {
+    ParsedSimulatedTransaction,
+    SimulatedTransaction,
+} from '../contracts/interfaces/SimulatedTransaction.js';
 import { Epoch } from '../epoch/Epoch.js';
 import { EpochWithSubmissions } from '../epoch/EpochSubmission.js';
 import { EpochTemplate } from '../epoch/EpochTemplate.js';
 import { EpochSubmissionParams } from '../epoch/interfaces/EpochSubmissionParams.js';
-import { RawEpoch, RawEpochTemplate, RawEpochWithSubmissions, RawSubmittedEpoch, } from '../epoch/interfaces/IEpoch.js';
+import {
+    RawEpoch,
+    RawEpochTemplate,
+    RawEpochWithSubmissions,
+    RawSubmittedEpoch,
+} from '../epoch/interfaces/IEpoch.js';
 import { SubmittedEpoch } from '../epoch/SubmittedEpoch.js';
 import { OPNetTransactionTypes } from '../interfaces/opnet/OPNetTransactionTypes.js';
 import { MempoolTransactionData } from '../mempool/MempoolTransactionData.js';
@@ -36,6 +44,7 @@ import { MempoolTransactionParser } from '../mempool/MempoolTransactionParser.js
 import { IStorageValue } from '../storage/interfaces/IStorageValue.js';
 import { StoredValue } from '../storage/StoredValue.js';
 import { BroadcastedTransaction } from '../transactions/interfaces/BroadcastedTransaction.js';
+import { BroadcastedTransactionPackage } from '../transactions/interfaces/BroadcastedTransactionPackage.js';
 import { ITransaction } from '../transactions/interfaces/ITransaction.js';
 import { ITransactionReceipt } from '../transactions/interfaces/ITransactionReceipt.js';
 import { TransactionReceipt } from '../transactions/metadata/TransactionReceipt.js';
@@ -54,7 +63,10 @@ import {
     JSONRpcResultError,
 } from './interfaces/JSONRpcResult.js';
 import { MempoolInfo } from './interfaces/mempool/MempoolInfo.js';
-import { IMempoolTransactionData, PendingTransactionsResult, } from './interfaces/mempool/MempoolTransactionData.js';
+import {
+    IMempoolTransactionData,
+    PendingTransactionsResult,
+} from './interfaces/mempool/MempoolTransactionData.js';
 import { AddressesInfo, IPublicKeyInfoResult } from './interfaces/PublicKeyInfo.js';
 import { ReorgInformation } from './interfaces/ReorgInformation.js';
 
@@ -124,8 +136,10 @@ export abstract class AbstractRpcProvider {
         try {
             const pubKeyInfo = await this.getPublicKeysInfo(address, isContract);
 
-            return pubKeyInfo[address] ||
-                pubKeyInfo[address.startsWith('0x') ? address.slice(2) : address];
+            return (
+                pubKeyInfo[address] ||
+                pubKeyInfo[address.startsWith('0x') ? address.slice(2) : address]
+            );
         } catch (e) {
             if (AddressVerificator.isValidPublicKey(address, this.network)) {
                 return Address.fromString(address);
@@ -708,6 +722,39 @@ export abstract class AbstractRpcProvider {
         });
     }
 
+    /**
+     * Broadcast a package of raw transactions atomically.
+     * @description Submits an ordered array of raw transactions via Bitcoin Core's submitpackage
+     * RPC for atomic acceptance, or falls back to validated sequential broadcast.
+     * @param {string[]} txs The raw transactions to send as hex strings (max 25)
+     * @param {boolean} [isPackage=true] Whether to use atomic package submission (submitpackage)
+     *        or validated sequential broadcast (testmempoolaccept + sendrawtransaction)
+     * @returns {Promise<BroadcastedTransactionPackage>} The result of the package broadcast
+     * @throws {Error} If something went wrong while broadcasting the package
+     */
+    public async sendRawTransactionPackage(
+        txs: string[],
+        isPackage: boolean = true,
+    ): Promise<BroadcastedTransactionPackage> {
+        if (!txs.length) {
+            throw new Error('sendRawTransactionPackage: txs array must not be empty');
+        }
+
+        for (let i = 0; i < txs.length; i++) {
+            if (!/^[0-9A-Fa-f]+$/.test(txs[i])) {
+                throw new Error(`sendRawTransactionPackage: txs[${i}] is not a valid hex string`);
+            }
+        }
+
+        const payload: JsonRpcPayload = this.buildJsonRpcPayload(
+            JSONRpcMethods.BROADCAST_TRANSACTION_PACKAGE,
+            [txs, isPackage],
+        );
+
+        const result: JsonRpcResult = await this.callPayloadSingle(payload);
+        return result.result as BroadcastedTransactionPackage;
+    }
+
     /**
      * Get block witnesses.
      * @description This method is used to get the witnesses of a block. This proves that the actions executed inside a block are valid and confirmed by the network. If the minimum number of witnesses are not met, the block is considered as potentially invalid.

package/src/providers/WebsocketRpcProvider.ts

@@ -424,6 +424,13 @@ export class WebSocketRpcProvider extends AbstractRpcProvider {
                     3: params[1] ?? false,
                 };
 
+            case JSONRpcMethods.BROADCAST_TRANSACTION_PACKAGE:
+                // BroadcastTransactionPackageRequest: requestId=1, transactions=2, isPackage=3
+                return {
+                    2: params[0],
+                    3: params[1] ?? true,
+                };
+
             case JSONRpcMethods.TRANSACTION_PREIMAGE:
                 return {};
 

package/src/providers/interfaces/JSONRpcMethods.ts

@@ -15,6 +15,7 @@ export enum JSONRpcMethods {
     /** Transactions */
     GET_TRANSACTION_BY_HASH = 'btc_getTransactionByHash',
     BROADCAST_TRANSACTION = 'btc_sendRawTransaction',
+    BROADCAST_TRANSACTION_PACKAGE = 'btc_sendRawTransactionPackage',
     TRANSACTION_PREIMAGE = 'btc_preimage',
 
     /** Addresses */

package/src/providers/websocket/MethodMapping.ts

@@ -60,6 +60,12 @@ export const METHOD_MAPPINGS: Partial<Record<JSONRpcMethods, MethodMapping>> = {
         requestType: 'BroadcastTransactionRequest',
         responseType: 'BroadcastTransactionResponse',
     },
+    [JSONRpcMethods.BROADCAST_TRANSACTION_PACKAGE]: {
+        requestOpcode: WebSocketRequestOpcode.BROADCAST_TRANSACTION_PACKAGE,
+        responseOpcode: WebSocketResponseOpcode.BROADCAST_PACKAGE_RESULT,
+        requestType: 'BroadcastTransactionPackageRequest',
+        responseType: 'BroadcastTransactionPackageResponse',
+    },
     [JSONRpcMethods.TRANSACTION_PREIMAGE]: {
         requestOpcode: WebSocketRequestOpcode.GET_PREIMAGE,
         responseOpcode: WebSocketResponseOpcode.PREIMAGE,

package/src/providers/websocket/types/WebSocketOpcodes.ts

@@ -19,6 +19,7 @@ export enum WebSocketRequestOpcode {
     GET_TRANSACTION_BY_HASH = 0x20,
     GET_TRANSACTION_RECEIPT = 0x21,
     BROADCAST_TRANSACTION = 0x22,
+    BROADCAST_TRANSACTION_PACKAGE = 0x27,
     GET_PREIMAGE = 0x23,
 
     // Mempool Methods (0x24 - 0x2F)
@@ -80,6 +81,7 @@ export enum WebSocketResponseOpcode {
     TRANSACTION = 0xa0,
     TRANSACTION_RECEIPT = 0xa1,
     BROADCAST_RESULT = 0xa2,
+    BROADCAST_PACKAGE_RESULT = 0xa7,
     PREIMAGE = 0xa3,
     /** Response containing aggregate mempool statistics. */
     MEMPOOL_INFO = 0xa4,

package/src/transactions/interfaces/BroadcastedTransactionPackage.ts

@@ -0,0 +1,72 @@
+export interface SequentialBroadcastTxResult {
+    /** The txid of the transaction. */
+    readonly txid: string;
+
+    /** Whether the individual transaction was successfully broadcast. */
+    readonly success: boolean;
+
+    /** Error message if this transaction failed. */
+    readonly error?: string;
+
+    /** Number of peers that received the transaction. */
+    readonly peers?: number;
+}
+
+export interface BroadcastedTransactionPackage {
+    /** Whether the overall package broadcast succeeded. */
+    readonly success: boolean;
+
+    /** Error message if the broadcast failed. */
+    readonly error?: string;
+
+    /** Present when testMempoolAccept was used (sequential or single tx path). */
+    readonly testResults?: readonly TestMempoolAcceptResult[];
+
+    /** Present when submitPackage was used successfully. */
+    readonly packageResult?: PackageResult;
+
+    /** Per-transaction results for sequential or single tx broadcasts. */
+    readonly sequentialResults?: readonly SequentialBroadcastTxResult[];
+
+    /** True when submitPackage failed and the node fell back to sequential broadcast. */
+    readonly fellBackToSequential?: boolean;
+}
+
+export interface TestMempoolAcceptResult {
+    readonly txid: string;
+    readonly wtxid: string;
+    readonly allowed?: boolean;
+    readonly vsize?: number;
+    readonly packageError?: string;
+    readonly rejectReason?: string;
+    readonly rejectDetails?: string;
+    readonly fees?: TestMempoolAcceptFees;
+}
+
+export interface TestMempoolAcceptFees {
+    readonly base: number;
+    readonly effectiveFeerate: number;
+    readonly effectiveIncludes: readonly string[];
+}
+
+export interface PackageTxResult {
+    readonly txid: string;
+    readonly otherWtxid?: string;
+    readonly vsize?: number;
+    readonly fees?: PackageTxFees;
+    readonly error?: string;
+}
+
+export interface PackageTxFees {
+    readonly base: number;
+    readonly effectiveFeerate?: number;
+    readonly effectiveIncludes?: readonly string[];
+}
+
+export interface PackageResult {
+    readonly packageMsg: string;
+    readonly txResults: {
+        readonly [wtxid: string]: PackageTxResult;
+    };
+    readonly replacedTransactions?: readonly string[];
+}

package/src/utxos/UTXOsManager.ts

@@ -40,7 +40,7 @@ interface AddressData {
  */
 export class UTXOsManager {
     /**
-     * Holds all address-specific data so we don’t mix up UTXOs between addresses/wallets.
+     * Holds all address-specific data so we don't mix up UTXOs between addresses/wallets.
      */
     private dataByAddress: Record<string, AddressData> = {};
 
@@ -97,7 +97,7 @@ export class UTXOsManager {
             );
         }
 
-        // Push the new UTXOs into this address’s pending and set their depth
+        // Push the new UTXOs into this address's pending and set their depth
         for (const nu of newUTXOs) {
             addressData.pendingUTXOs.push(nu);
             addressData.pendingUtxoDepth[utxoKey(nu)] = newDepth;
@@ -212,11 +212,14 @@ export class UTXOsManager {
      * Fetch UTXOs for a specific amount needed, from a single address,
      * merging from pending and confirmed UTXOs.
      *
+     * Prioritizes normal UTXOs first, only falling back to CSV UTXOs
+     * if the normal ones cannot cover the requested amount.
+     *
      * @param {object} options
      * @param {string} options.address The address to fetch UTXOs for
      * @param {bigint} options.amount The needed amount
      * @param {boolean} [options.optimize=true] Optimize the UTXOs
-     * @param {boolean} [options.csvAddress] Use CSV UTXOs in priority
+     * @param {boolean} [options.csvAddress] Use CSV UTXOs as fallback
      * @param {boolean} [options.mergePendingUTXOs=true] Merge pending
      * @param {boolean} [options.filterSpentUTXOs=true] Filter out spent
      * @param {boolean} [options.throwErrors=false] Throw error if insufficient
@@ -235,52 +238,46 @@ export class UTXOsManager {
         maxUTXOs = 5000,
         throwIfUTXOsLimitReached = false,
     }: RequestUTXOsParamsWithAmount): Promise<UTXOs> {
-        const utxosPromises: Promise<UTXO[]>[] = [];
-
-        if (csvAddress) {
-            utxosPromises.push(
-                this.getUTXOs({
-                    address: csvAddress,
-                    optimize: true,
-                    mergePendingUTXOs: false,
-                    filterSpentUTXOs: true,
-                    olderThan: 1n,
-                    isCSV: true,
-                }),
-            );
-        }
-
-        utxosPromises.push(
-            this.getUTXOs({
-                address,
-                optimize,
-                mergePendingUTXOs,
-                filterSpentUTXOs,
-                olderThan,
-            }),
-        );
-
-        const combinedUTXOs: UTXOs = (await Promise.all(utxosPromises)).flat();
-        const utxoUntilAmount: UTXOs = [];
-
+        const selected: UTXOs = [];
         let currentValue = 0n;
-        for (const utxo of combinedUTXOs) {
-            if (maxUTXOs && utxoUntilAmount.length >= maxUTXOs) {
-                if (throwIfUTXOsLimitReached) {
-                    throw new Error(
-                        `Woah. You must consolidate your UTXOs (${combinedUTXOs.length})! This transaction is too large.`,
-                    );
-                }
 
-                break;
-            }
+        // Fetch and greedily select from normal UTXOs first
+        const normalUTXOs: UTXOs = await this.getUTXOs({
+            address,
+            optimize,
+            mergePendingUTXOs,
+            filterSpentUTXOs,
+            olderThan,
+        });
 
-            utxoUntilAmount.push(utxo);
-            currentValue += utxo.value;
+        currentValue = this.selectUTXOsGreedily(
+            normalUTXOs,
+            selected,
+            currentValue,
+            amount,
+            maxUTXOs,
+            throwIfUTXOsLimitReached,
+        );
 
-            if (currentValue >= amount) {
-                break;
-            }
+        // Fall back to CSV UTXOs only if normal ones were insufficient
+        if (currentValue < amount && csvAddress) {
+            const csvUTXOs: UTXOs = await this.getUTXOs({
+                address: csvAddress,
+                optimize: true,
+                mergePendingUTXOs: false,
+                filterSpentUTXOs: true,
+                olderThan: 1n,
+                isCSV: true,
+            });
+
+            currentValue = this.selectUTXOsGreedily(
+                csvUTXOs,
+                selected,
+                currentValue,
+                amount,
+                maxUTXOs,
+                throwIfUTXOsLimitReached,
+            );
         }
 
         if (currentValue < amount && throwErrors) {
@@ -289,7 +286,7 @@ export class UTXOsManager {
             );
         }
 
-        return utxoUntilAmount;
+        return selected;
     }
 
     /**
@@ -388,6 +385,45 @@ export class UTXOsManager {
         return result;
     }
 
+    /**
+     * Sort UTXOs by value descending and greedily append to `selected` until
+     * `currentValue >= amount` or the pool is exhausted. Mutates `candidates`
+     * (sort in-place) and `selected` (pushes chosen UTXOs). Returns the
+     * updated cumulative value.
+     */
+    private selectUTXOsGreedily(
+        candidates: UTXOs,
+        selected: UTXOs,
+        currentValue: bigint,
+        amount: bigint,
+        maxUTXOs: number,
+        throwIfLimitReached: boolean,
+    ): bigint {
+        candidates.sort((a, b) => {
+            if (b.value > a.value) return 1;
+            if (b.value < a.value) return -1;
+            return 0;
+        });
+
+        for (const utxo of candidates) {
+            if (currentValue >= amount) break;
+
+            if (maxUTXOs && selected.length >= maxUTXOs) {
+                if (throwIfLimitReached) {
+                    throw new Error(
+                        `Woah. You must consolidate your UTXOs (${candidates.length + selected.length})! This transaction is too large.`,
+                    );
+                }
+                break;
+            }
+
+            selected.push(utxo);
+            currentValue += utxo.value;
+        }
+
+        return currentValue;
+    }
+
     /**
      * Fetch UTXOs for multiple addresses in a single batch RPC call.
      * @private