@originals/sdk 1.2.0 → 1.4.2

package/dist/bitcoin/transactions/commit.js

@@ -1,311 +0,0 @@
-/**
- * Commit Transaction Processing for Ordinals
- *
- * This module implements the commit transaction process for ordinals inscriptions.
- * It handles the generation of the commit address and preparation of the commit transaction.
- *
- * Ported from legacy ordinalsplus transaction infrastructure.
- */
-import * as btc from '@scure/btc-signer';
-import * as ordinals from 'micro-ordinals';
-import { schnorr } from '@noble/curves/secp256k1';
-import { calculateFee } from '../fee-calculation.js';
-import { selectUtxos } from '../utxo-selection.js';
-// Define minimum dust limit (satoshis)
-const MIN_DUST_LIMIT = 546;
-// Maximum iterations for UTXO reselection to prevent infinite loops
-const MAX_SELECTION_ITERATIONS = 5;
-/**
- * Get @scure/btc-signer network configuration
- */
-function getScureNetwork(network) {
-    switch (network) {
-        case 'mainnet':
-            return btc.NETWORK;
-        case 'testnet':
-        case 'signet':
-        case 'regtest':
-            return btc.TEST_NETWORK;
-        default:
-            return btc.NETWORK;
-    }
-}
-/**
- * Validates that a UTXO has all required fields for spending
- *
- * @param utxo - The UTXO to validate
- * @returns true if the UTXO is valid and spendable, false otherwise
- */
-function isValidSpendableUtxo(utxo) {
-    return !!(utxo.txid &&
-        typeof utxo.vout === 'number' &&
-        utxo.value > 0 &&
-        utxo.scriptPubKey &&
-        utxo.scriptPubKey.length > 0);
-}
-/**
- * Estimates the size of a commit transaction
- *
- * @param inputCount - Number of transaction inputs
- * @param outputCount - Number of transaction outputs (including commit and change)
- * @returns Estimated transaction size in virtual bytes
- */
-function estimateCommitTxSize(inputCount, outputCount) {
-    // Transaction overhead
-    const overhead = 10.5;
-    // P2WPKH inputs (assuming most common case)
-    const inputSize = 68 * inputCount;
-    // P2TR output for commit and P2WPKH for change
-    const commitOutputSize = 43; // P2TR output
-    const changeOutputSize = outputCount > 1 ? 31 * (outputCount - 1) : 0; // P2WPKH outputs for change
-    return Math.ceil(overhead + inputSize + commitOutputSize + changeOutputSize);
-}
-/**
- * Creates a commit transaction for an ordinals inscription
- *
- * This function:
- * 1. Validates and filters UTXOs to ensure they are spendable
- * 2. Creates an inscription with the provided content
- * 3. Generates a reveal keypair and script
- * 4. Creates a P2TR commit address
- * 5. Selects UTXOs to fund the transaction (with iterative reselection if needed)
- * 6. Builds a PSBT with commit output and change
- *
- * The function ensures that:
- * - All selected UTXOs have valid scriptPubKey fields
- * - Total input value always covers output value + fees
- * - UTXO selection is re-run if fee increases after accurate calculation
- *
- * @param params - Parameters for the commit transaction
- * @returns Complete information for the prepared commit transaction
- * @throws Error if no valid UTXOs are available or insufficient funds
- */
-export async function createCommitTransaction(params) {
-    const { content, contentType, utxos, changeAddress, feeRate, network, minimumCommitAmount = MIN_DUST_LIMIT, metadata, pointer } = params;
-    // Validate inputs
-    if (!utxos || utxos.length === 0) {
-        throw new Error('No UTXOs provided to fund the transaction.');
-    }
-    if (!content || content.length === 0) {
-        throw new Error('Invalid inscription: missing content.');
-    }
-    if (!contentType) {
-        throw new Error('Invalid inscription: missing content type.');
-    }
-    if (!changeAddress) {
-        throw new Error('Change address is required.');
-    }
-    if (feeRate <= 0) {
-        throw new Error(`Invalid fee rate: ${feeRate}`);
-    }
-    // CRITICAL: Pre-filter UTXOs to ensure all have valid scriptPubKey
-    // This prevents silent failures where UTXOs are selected but can't be spent
-    const validUtxos = utxos.filter(isValidSpendableUtxo);
-    if (validUtxos.length === 0) {
-        const invalidCount = utxos.length;
-        const invalidReasons = [];
-        utxos.forEach((utxo, idx) => {
-            if (!utxo.scriptPubKey || utxo.scriptPubKey.length === 0) {
-                invalidReasons.push(`UTXO ${idx} (${utxo.txid}:${utxo.vout}): missing scriptPubKey`);
-            }
-            else if (!utxo.txid) {
-                invalidReasons.push(`UTXO ${idx}: missing txid`);
-            }
-            else if (typeof utxo.vout !== 'number') {
-                invalidReasons.push(`UTXO ${idx} (${utxo.txid}): missing or invalid vout`);
-            }
-            else if (utxo.value <= 0) {
-                invalidReasons.push(`UTXO ${idx} (${utxo.txid}:${utxo.vout}): invalid value (${utxo.value})`);
-            }
-        });
-        throw new Error(`No valid spendable UTXOs available. ${invalidCount} UTXO(s) provided but all are invalid:\n` +
-            invalidReasons.slice(0, 5).join('\n') +
-            (invalidReasons.length > 5 ? `\n... and ${invalidReasons.length - 5} more` : ''));
-    }
-    // Log filtered UTXOs for debugging
-    if (validUtxos.length < utxos.length) {
-        const filteredCount = utxos.length - validUtxos.length;
-        console.warn(`Filtered out ${filteredCount} invalid UTXO(s). ${validUtxos.length} valid UTXO(s) remain.`);
-    }
-    // Step 1: Create the inscription object
-    const tags = {
-        contentType
-    };
-    // Add metadata if provided
-    if (metadata && Object.keys(metadata).length > 0) {
-        tags.metadata = metadata;
-    }
-    // Add pointer if provided
-    if (typeof pointer !== 'undefined') {
-        tags.pointer = pointer;
-    }
-    const inscription = {
-        tags,
-        body: new Uint8Array(content)
-    };
-    // Step 2: Generate a reveal keypair
-    // Use random private key for reveal transaction
-    const revealPrivateKey = schnorr.utils.randomPrivateKey();
-    const revealPublicKey = schnorr.getPublicKey(revealPrivateKey);
-    // Step 3: Create the inscription script tree using micro-ordinals
-    const scriptTree = ordinals.p2tr_ord_reveal(revealPublicKey, [inscription]);
-    // Step 4: Create P2TR address for the commit output
-    const scureNetwork = getScureNetwork(network);
-    // Create taproot output using the inscription script tree
-    // Use the reveal public key as the internal key
-    const taprootPayment = btc.p2tr(revealPublicKey, // internal key
-    scriptTree, // script tree
-    scureNetwork, false, // allowUnknownOutputs
-    [ordinals.OutOrdinalReveal] // customScripts
-    );
-    if (!taprootPayment.address) {
-        throw new Error('Failed to generate P2TR commit address');
-    }
-    const commitAddress = taprootPayment.address;
-    // Extract script information from the taproot payment
-    if (!taprootPayment.leaves || taprootPayment.leaves.length === 0) {
-        throw new Error('Failed to extract taproot leaves from P2TR payment');
-    }
-    const leaf = taprootPayment.leaves[0];
-    const leafVersion = leaf.version ?? 0xc0;
-    // Compute control block from leaf data
-    // The control block is: version byte | internal key (32 bytes) | merkle path
-    const controlBlock = btc.TaprootControlBlock.encode({
-        version: leafVersion,
-        internalKey: revealPublicKey,
-        merklePath: leaf.path
-    });
-    // Step 5: Calculate minimum amount needed for the commit output
-    const commitOutputValue = Math.max(minimumCommitAmount, MIN_DUST_LIMIT);
-    // Step 6: Iterative UTXO selection with fee recalculation
-    // This ensures that after we know the actual input count, we have enough funds
-    let selectedUtxos = [];
-    let totalInputValue = 0;
-    let estimatedFee = 0;
-    let iteration = 0;
-    // Start with initial estimate (1 input, 2 outputs)
-    let targetAmount = commitOutputValue + Number(calculateFee(estimateCommitTxSize(1, 2), feeRate));
-    while (iteration < MAX_SELECTION_ITERATIONS) {
-        iteration++;
-        // Select UTXOs based on current target amount
-        const options = {
-            targetAmount
-        };
-        try {
-            const selectionResult = selectUtxos(validUtxos, options);
-            selectedUtxos = selectionResult.selectedUtxos;
-            totalInputValue = selectionResult.totalInputValue;
-        }
-        catch (error) {
-            throw new Error(`Insufficient funds. Need ${targetAmount} sats for commit output (${commitOutputValue} sats) and estimated fees. ` +
-                `Available: ${validUtxos.reduce((sum, u) => sum + u.value, 0)} sats from ${validUtxos.length} valid UTXO(s). ` +
-                `${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-        // Calculate accurate fee based on actual selected input count
-        // Assume 2 outputs (commit + change) for now - we'll adjust later if no change
-        const actualInputCount = selectedUtxos.length;
-        const estimatedVBytes = estimateCommitTxSize(actualInputCount, 2);
-        estimatedFee = Number(calculateFee(estimatedVBytes, feeRate));
-        // Check if we need to account for no change output
-        const potentialChange = totalInputValue - commitOutputValue - estimatedFee;
-        let finalOutputCount = 2;
-        if (potentialChange < MIN_DUST_LIMIT) {
-            // No change output, recalculate fee with 1 output
-            finalOutputCount = 1;
-            const adjustedVBytes = estimateCommitTxSize(actualInputCount, finalOutputCount);
-            estimatedFee = Number(calculateFee(adjustedVBytes, feeRate));
-        }
-        // Check if we have enough funds with the accurate fee calculation
-        const requiredTotal = commitOutputValue + estimatedFee;
-        if (totalInputValue >= requiredTotal) {
-            // We have enough funds, break out of loop
-            break;
-        }
-        // Not enough funds, need to reselect with higher target
-        // Add a small buffer (5%) to account for potential fee variations
-        targetAmount = Math.ceil(requiredTotal * 1.05);
-        if (iteration >= MAX_SELECTION_ITERATIONS) {
-            throw new Error(`Unable to select sufficient UTXOs after ${MAX_SELECTION_ITERATIONS} iterations. ` +
-                `Required: ${requiredTotal} sats (commit: ${commitOutputValue}, fee: ${estimatedFee}), ` +
-                `Selected: ${totalInputValue} sats from ${selectedUtxos.length} UTXO(s). ` +
-                `Total available: ${validUtxos.reduce((sum, u) => sum + u.value, 0)} sats from ${validUtxos.length} valid UTXO(s).`);
-        }
-    }
-    // Final validation: ensure we have selected UTXOs
-    if (!selectedUtxos || selectedUtxos.length === 0) {
-        throw new Error('No UTXOs selected for the transaction after selection process.');
-    }
-    // Step 7: Create transaction using @scure/btc-signer
-    const tx = new btc.Transaction();
-    // Add inputs - all selected UTXOs are already validated to have scriptPubKey
-    for (const utxo of selectedUtxos) {
-        // This check is now redundant due to pre-filtering, but kept as defense-in-depth
-        if (!utxo.scriptPubKey) {
-            throw new Error(`CRITICAL ERROR: Selected UTXO ${utxo.txid}:${utxo.vout} is missing scriptPubKey. ` +
-                `This should never happen due to pre-filtering. Please report this bug.`);
-        }
-        tx.addInput({
-            txid: utxo.txid,
-            index: utxo.vout,
-            witnessUtxo: {
-                script: Buffer.from(utxo.scriptPubKey, 'hex'),
-                amount: BigInt(utxo.value)
-            }
-        });
-    }
-    // Verify input count matches selected UTXOs
-    if (tx.inputsLength !== selectedUtxos.length) {
-        throw new Error(`Input count mismatch: expected ${selectedUtxos.length} inputs but transaction has ${tx.inputsLength}. ` +
-            `This indicates a critical error in transaction construction.`);
-    }
-    // Step 8: Calculate final fee based on actual transaction structure
-    const actualInputCount = tx.inputsLength;
-    // Determine if we'll have a change output
-    const preliminaryChange = totalInputValue - commitOutputValue - estimatedFee;
-    const willHaveChange = preliminaryChange >= MIN_DUST_LIMIT;
-    const finalOutputCount = willHaveChange ? 2 : 1;
-    // Calculate final fee with correct output count
-    const finalVBytes = estimateCommitTxSize(actualInputCount, finalOutputCount);
-    const finalFee = Number(calculateFee(finalVBytes, feeRate));
-    // CRITICAL: Final validation that inputs cover outputs + fees
-    const finalChange = totalInputValue - commitOutputValue - finalFee;
-    if (finalChange < 0) {
-        throw new Error(`CRITICAL ERROR: Outputs exceed inputs! ` +
-            `Inputs: ${totalInputValue} sats, ` +
-            `Outputs: ${commitOutputValue} sats (commit) + ${finalFee} sats (fee) = ${commitOutputValue + finalFee} sats. ` +
-            `Deficit: ${Math.abs(finalChange)} sats. ` +
-            `This should never happen due to iterative selection. Please report this bug.`);
-    }
-    // Step 9: Add the commit output using the P2TR address
-    tx.addOutputAddress(commitAddress, BigInt(commitOutputValue), scureNetwork);
-    // Step 10: Add change output if above dust limit
-    if (finalChange >= MIN_DUST_LIMIT) {
-        tx.addOutputAddress(changeAddress, BigInt(finalChange), scureNetwork);
-    }
-    else if (finalChange > 0) {
-        // If change is below dust limit, it's effectively added to the fee
-        console.log(`Change amount ${finalChange} sats is below dust limit (${MIN_DUST_LIMIT} sats), adding to fee. ` +
-            `Final fee: ${finalFee + finalChange} sats.`);
-    }
-    // Step 11: Get the PSBT as base64
-    const txPsbt = tx.toPSBT();
-    const commitPsbtBase64 = typeof txPsbt === 'string' ? txPsbt : Buffer.from(txPsbt).toString('base64');
-    return {
-        commitAddress,
-        commitPsbtBase64,
-        commitPsbt: tx,
-        commitAmount: commitOutputValue,
-        selectedUtxos,
-        fees: {
-            // Include dust in final fee if no change output
-            commit: finalChange >= MIN_DUST_LIMIT ? finalFee : finalFee + finalChange
-        },
-        revealPrivateKey: Buffer.from(revealPrivateKey).toString('hex'),
-        revealPublicKey: Buffer.from(revealPublicKey).toString('hex'),
-        inscriptionScript: {
-            script: leaf.script,
-            controlBlock,
-            leafVersion
-        }
-    };
-}

package/dist/bitcoin/transactions/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Bitcoin Transactions
- *
- * This directory contains modules for creating and managing Bitcoin transactions,
- * particularly for Ordinals inscriptions.
- */
-export { createCommitTransaction, type CommitTransactionParams, type CommitTransactionResult } from './commit.js';

package/dist/bitcoin/transactions/index.js

@@ -1,8 +0,0 @@
-/**
- * Bitcoin Transactions
- *
- * This directory contains modules for creating and managing Bitcoin transactions,
- * particularly for Ordinals inscriptions.
- */
-// Export commit transaction functionality
-export { createCommitTransaction } from './commit.js';

package/dist/bitcoin/transfer.d.ts

@@ -1,9 +0,0 @@
-import { BitcoinTransaction, Utxo } from '../types';
-import { SelectionOptions, SelectionResult } from './utxo';
-export interface BuildTransferOptions extends Omit<SelectionOptions, 'targetAmountSats' | 'feeRateSatsPerVb'> {
-    changeAddress?: string;
-}
-export declare function buildTransferTransaction(availableUtxos: Utxo[], recipientAddress: string, amountSats: number, feeRateSatsPerVb: number, options?: BuildTransferOptions): {
-    tx: BitcoinTransaction;
-    selection: SelectionResult;
-};

package/dist/bitcoin/transfer.js

@@ -1,26 +0,0 @@
-import { DUST_LIMIT_SATS } from '../types';
-import { selectUtxos } from './utxo';
-export function buildTransferTransaction(availableUtxos, recipientAddress, amountSats, feeRateSatsPerVb, options = {}) {
-    const selection = selectUtxos(availableUtxos, {
-        targetAmountSats: amountSats,
-        feeRateSatsPerVb,
-        allowLocked: options.allowLocked,
-        forbidInscriptionBearingInputs: options.forbidInscriptionBearingInputs,
-        changeAddress: options.changeAddress,
-        feeEstimate: options.feeEstimate
-    });
-    const vin = selection.selected.map(u => ({ txid: u.txid, vout: u.vout }));
-    const outputs = [];
-    outputs.push({ value: amountSats, scriptPubKey: 'script', address: recipientAddress });
-    if (selection.changeSats >= DUST_LIMIT_SATS) {
-        const changeAddress = options.changeAddress || (selection.selected.find(u => !!u.address)?.address ?? 'change');
-        outputs.push({ value: selection.changeSats, scriptPubKey: 'script', address: changeAddress });
-    }
-    const tx = {
-        txid: '',
-        vin,
-        vout: outputs,
-        fee: selection.feeSats
-    };
-    return { tx, selection };
-}

package/dist/bitcoin/utxo-selection.d.ts

@@ -1,78 +0,0 @@
-/**
- * UTXO Selection for Ordinals Transactions
- *
- * This module implements functions for selecting UTXOs for ordinals transactions.
- * It provides a simple coin selection algorithm optimized for ordinals inscriptions.
- *
- * Ported from legacy ordinalsplus transaction infrastructure.
- */
-import { Utxo, ResourceUtxo, ResourceUtxoSelectionOptions, ResourceUtxoSelectionResult } from '../types/bitcoin.js';
-/**
- * Estimates transaction size in vbytes based on input and output counts
- * This is a simplified calculation, and actual size may vary based on script types
- *
- * @param inputCount Number of inputs in the transaction
- * @param outputCount Number of outputs in the transaction
- * @returns Estimated transaction size in vbytes
- */
-export declare function estimateTransactionSize(inputCount: number, outputCount: number): number;
-/**
- * Tags UTXOs as resource-containing or regular based on provided data
- *
- * @param utxos List of UTXOs to tag
- * @param resourceData Optional data about which UTXOs contain resources
- * @returns Tagged ResourceUtxo[] list with hasResource flags set appropriately
- */
-export declare function tagResourceUtxos(utxos: ResourceUtxo[], resourceData?: {
-    [utxoId: string]: boolean;
-}): ResourceUtxo[];
-/**
- * Options for simple UTXO selection
- */
-export interface SimpleUtxoSelectionOptions {
-    /** Target amount to reach (in satoshis) */
-    targetAmount: number;
-    /** Optional maximum amount of UTXOs to use */
-    maxNumUtxos?: number;
-    /** Optional preference for UTXO selection strategy */
-    strategy?: 'minimize_change' | 'minimize_inputs' | 'optimize_size';
-}
-/**
- * Result of simple UTXO selection
- */
-export interface SimpleUtxoSelectionResult {
-    /** Selected UTXOs for the transaction */
-    selectedUtxos: Utxo[];
-    /** Total value of selected UTXOs */
-    totalInputValue: number;
-    /** Estimated change amount (if any) */
-    changeAmount: number;
-}
-/**
- * Selects UTXOs to cover a target amount using a simplified approach.
- * This version is used specifically for commit transactions where we
- * don't need the more complex resource-aware selection.
- *
- * @param utxos - Available UTXOs
- * @param options - Target amount or detailed options
- * @returns Selected UTXOs and related information
- */
-export declare function selectUtxos(utxos: Utxo[], options: number | SimpleUtxoSelectionOptions): SimpleUtxoSelectionResult;
-/**
- * Selects UTXOs for a transaction, excluding UTXOs with resources unless explicitly allowed
- *
- * @param availableUtxos List of available UTXOs to select from
- * @param options Configuration options for the selection process
- * @returns Selection result with chosen UTXOs and fee information
- * @throws Error if insufficient funds or if all available UTXOs contain resources
- */
-export declare function selectResourceUtxos(availableUtxos: ResourceUtxo[], options: ResourceUtxoSelectionOptions): ResourceUtxoSelectionResult;
-/**
- * Convenience function to select UTXOs for a payment, explicitly avoiding resource UTXOs
- *
- * @param availableUtxos List of available UTXOs
- * @param requiredAmount Amount needed for the payment in satoshis
- * @param feeRate Fee rate in satoshis per vbyte
- * @returns Selection result with UTXOs, fee and change information
- */
-export declare function selectUtxosForPayment(availableUtxos: ResourceUtxo[], requiredAmount: number, feeRate: number): ResourceUtxoSelectionResult;

package/dist/bitcoin/utxo-selection.js

@@ -1,237 +0,0 @@
-/**
- * UTXO Selection for Ordinals Transactions
- *
- * This module implements functions for selecting UTXOs for ordinals transactions.
- * It provides a simple coin selection algorithm optimized for ordinals inscriptions.
- *
- * Ported from legacy ordinalsplus transaction infrastructure.
- */
-import { DUST_LIMIT_SATS } from '../types/bitcoin.js';
-import { calculateFee } from './fee-calculation.js';
-// Minimum dust limit for Bitcoin outputs (546 satoshis)
-const MIN_DUST_LIMIT = DUST_LIMIT_SATS;
-/**
- * Estimates transaction size in vbytes based on input and output counts
- * This is a simplified calculation, and actual size may vary based on script types
- *
- * @param inputCount Number of inputs in the transaction
- * @param outputCount Number of outputs in the transaction
- * @returns Estimated transaction size in vbytes
- */
-export function estimateTransactionSize(inputCount, outputCount) {
-    // Rough estimation based on segwit transaction format
-    // Transaction overhead: ~10 vbytes
-    // Each input: ~68 vbytes (P2WPKH)
-    // Each output: ~31 vbytes
-    return 10 + (inputCount * 68) + (outputCount * 31);
-}
-/**
- * Tags UTXOs as resource-containing or regular based on provided data
- *
- * @param utxos List of UTXOs to tag
- * @param resourceData Optional data about which UTXOs contain resources
- * @returns Tagged ResourceUtxo[] list with hasResource flags set appropriately
- */
-export function tagResourceUtxos(utxos, resourceData) {
-    return utxos.map(utxo => {
-        const utxoId = `${utxo.txid}:${utxo.vout}`;
-        const hasResource = resourceData ? !!resourceData[utxoId] : utxo.hasResource || false;
-        return {
-            ...utxo,
-            hasResource
-        };
-    });
-}
-/**
- * Selects UTXOs to cover a target amount using a simplified approach.
- * This version is used specifically for commit transactions where we
- * don't need the more complex resource-aware selection.
- *
- * @param utxos - Available UTXOs
- * @param options - Target amount or detailed options
- * @returns Selected UTXOs and related information
- */
-export function selectUtxos(utxos, options) {
-    // Handle simple number input
-    const targetAmount = typeof options === 'number'
-        ? options
-        : options.targetAmount;
-    const maxNumUtxos = typeof options === 'number'
-        ? undefined
-        : options.maxNumUtxos;
-    const strategy = typeof options === 'number'
-        ? 'minimize_inputs'
-        : options.strategy || 'minimize_inputs';
-    // Validate inputs
-    if (!utxos || utxos.length === 0) {
-        throw new Error('No UTXOs provided for selection.');
-    }
-    if (targetAmount <= 0) {
-        throw new Error(`Invalid target amount: ${targetAmount}`);
-    }
-    // Sort UTXOs based on selected strategy
-    let sortedUtxos = [...utxos];
-    if (strategy === 'minimize_inputs') {
-        // Sort by value descending to use fewest inputs
-        sortedUtxos.sort((a, b) => b.value - a.value);
-    }
-    else if (strategy === 'minimize_change') {
-        // Sort by value ascending to minimize change
-        sortedUtxos.sort((a, b) => a.value - b.value);
-    }
-    else if (strategy === 'optimize_size') {
-        // Sort by value/size ratio (value density) for optimal fee efficiency
-        // For now, just sort by value as a reasonable approximation
-        sortedUtxos.sort((a, b) => b.value - a.value);
-    }
-    const selected = [];
-    let totalValue = 0;
-    // Add UTXOs until we reach the target amount
-    for (const utxo of sortedUtxos) {
-        // Skip invalid UTXOs
-        if (!utxo.txid || utxo.vout === undefined || !utxo.value) {
-            console.warn(`Skipping invalid UTXO: ${utxo.txid}:${utxo.vout}`);
-            continue;
-        }
-        selected.push(utxo);
-        totalValue += utxo.value;
-        // Check if we've reached the target
-        if (totalValue >= targetAmount) {
-            break;
-        }
-        // Check if we've reached the maximum allowed number of UTXOs
-        if (maxNumUtxos && selected.length >= maxNumUtxos) {
-            break;
-        }
-    }
-    // Check if we have enough funds
-    if (totalValue < targetAmount) {
-        throw new Error(`Insufficient funds. Required: ${targetAmount}, Available: ${totalValue} from ${utxos.length} UTXOs.`);
-    }
-    // Calculate change amount
-    const changeAmount = totalValue - targetAmount;
-    return {
-        selectedUtxos: selected,
-        totalInputValue: totalValue,
-        changeAmount
-    };
-}
-/**
- * Selects UTXOs for a transaction, excluding UTXOs with resources unless explicitly allowed
- *
- * @param availableUtxos List of available UTXOs to select from
- * @param options Configuration options for the selection process
- * @returns Selection result with chosen UTXOs and fee information
- * @throws Error if insufficient funds or if all available UTXOs contain resources
- */
-export function selectResourceUtxos(availableUtxos, options) {
-    const { requiredAmount, feeRate, allowResourceUtxos = false, preferOlder = false, preferCloserAmount = false, avoidUtxoIds = [] } = options;
-    // Convert requiredAmount to bigint for compatibility with fee calculations
-    const requiredAmountBigInt = BigInt(requiredAmount);
-    // Filter out UTXOs to avoid and those with resources if not allowed
-    let eligibleUtxos = availableUtxos.filter(utxo => {
-        const utxoId = `${utxo.txid}:${utxo.vout}`;
-        const shouldAvoid = avoidUtxoIds.includes(utxoId);
-        const containsResource = utxo.hasResource === true;
-        // Skip this UTXO if it's in the avoid list
-        if (shouldAvoid)
-            return false;
-        // Skip this UTXO if it contains a resource and we're not allowed to use resource UTXOs
-        if (containsResource && !allowResourceUtxos)
-            return false;
-        return true;
-    });
-    if (eligibleUtxos.length === 0) {
-        // Special error message if we have UTXOs but they all contain resources
-        if (availableUtxos.length > 0 && availableUtxos.every(u => u.hasResource)) {
-            throw new Error('All available UTXOs contain resources and cannot be used for fees/payments. Please add non-resource UTXOs to your wallet.');
-        }
-        throw new Error('No eligible UTXOs available for selection');
-    }
-    // Apply sorting strategy
-    if (preferCloserAmount) {
-        // Sort by closest to required amount (but still above it)
-        eligibleUtxos.sort((a, b) => {
-            const aDiff = a.value - requiredAmount;
-            const bDiff = b.value - requiredAmount;
-            // Prioritize UTXOs that cover the amount
-            if (aDiff >= 0 && bDiff < 0)
-                return -1;
-            if (aDiff < 0 && bDiff >= 0)
-                return 1;
-            // If both cover or both don't cover, prefer the one closer to required amount
-            return Math.abs(aDiff) - Math.abs(bDiff);
-        });
-    }
-    else if (preferOlder) {
-        // Prefer older UTXOs (by txid as a proxy for age - not perfect but simple)
-        eligibleUtxos.sort((a, b) => a.txid.localeCompare(b.txid));
-    }
-    else {
-        // Default: sort by value descending (largest first)
-        eligibleUtxos.sort((a, b) => b.value - a.value);
-    }
-    // Initial fee estimation (1 input, 2 outputs - payment and change)
-    let estimatedVbytes = estimateTransactionSize(1, 2);
-    let estimatedFee = calculateFee(estimatedVbytes, feeRate);
-    // Target amount including estimated fee
-    let targetAmount = requiredAmountBigInt + estimatedFee;
-    // Select UTXOs
-    const selectedUtxos = [];
-    let totalSelectedValue = 0n;
-    // First pass: try to find a single UTXO that covers the amount
-    const singleUtxo = eligibleUtxos.find(utxo => BigInt(utxo.value) >= targetAmount);
-    if (singleUtxo) {
-        selectedUtxos.push(singleUtxo);
-        totalSelectedValue = BigInt(singleUtxo.value);
-    }
-    else {
-        // Second pass: accumulate UTXOs until we reach the target amount
-        for (const utxo of eligibleUtxos) {
-            selectedUtxos.push(utxo);
-            totalSelectedValue += BigInt(utxo.value);
-            // Recalculate fee as we add more inputs
-            estimatedVbytes = estimateTransactionSize(selectedUtxos.length, 2);
-            estimatedFee = calculateFee(estimatedVbytes, feeRate);
-            targetAmount = requiredAmountBigInt + estimatedFee;
-            if (totalSelectedValue >= targetAmount) {
-                break;
-            }
-        }
-    }
-    // Final fee calculation based on actual number of inputs
-    estimatedVbytes = estimateTransactionSize(selectedUtxos.length, 2);
-    estimatedFee = calculateFee(estimatedVbytes, feeRate);
-    // Check if we have enough funds
-    if (totalSelectedValue < requiredAmountBigInt + estimatedFee) {
-        throw new Error(`Insufficient funds. Required: ${requiredAmountBigInt + estimatedFee}, Available: ${totalSelectedValue}`);
-    }
-    // Calculate change
-    let changeAmount = totalSelectedValue - requiredAmountBigInt - estimatedFee;
-    // If change is less than dust limit, add it to the fee
-    if (changeAmount > 0n && changeAmount < BigInt(MIN_DUST_LIMIT)) {
-        estimatedFee += changeAmount;
-        changeAmount = 0n;
-    }
-    return {
-        selectedUtxos,
-        totalSelectedValue: Number(totalSelectedValue),
-        estimatedFee: Number(estimatedFee),
-        changeAmount: Number(changeAmount)
-    };
-}
-/**
- * Convenience function to select UTXOs for a payment, explicitly avoiding resource UTXOs
- *
- * @param availableUtxos List of available UTXOs
- * @param requiredAmount Amount needed for the payment in satoshis
- * @param feeRate Fee rate in satoshis per vbyte
- * @returns Selection result with UTXOs, fee and change information
- */
-export function selectUtxosForPayment(availableUtxos, requiredAmount, feeRate) {
-    return selectResourceUtxos(availableUtxos, {
-        requiredAmount,
-        feeRate,
-        allowResourceUtxos: false // Never use resource UTXOs for payments
-    });
-}