@atomiqlabs/sdk 8.7.6 → 8.8.3

package/dist/bitcoin/coinselect2/accumulative.d.ts

@@ -2,5 +2,6 @@ import { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput } from ".
 export declare function accumulative(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, type: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[]): {
     inputs?: CoinselectTxInput[];
     outputs?: CoinselectTxOutput[];
+    effectiveFeeRate?: number;
     fee: number;
 };

package/dist/bitcoin/coinselect2/accumulative.js

@@ -7,7 +7,7 @@ const logger = (0, Logger_1.getLogger)("CoinSelect: ");
 // add inputs until we reach or surpass the target value (or deplete)
 // worst-case: O(n)
 function accumulative(utxos, outputs, feeRate, type, requiredInputs) {
-    if (!isFinite(utils_1.utils.uintOrNaN(feeRate)))
+    if (!isFinite(utils_1.utils.numberOrNaN(feeRate)))
         throw new Error("Invalid feeRate passed!");
     const inputs = requiredInputs == null ? [] : [...requiredInputs];
     let bytesAccum = utils_1.utils.transactionBytes(inputs, outputs, type);

package/dist/bitcoin/coinselect2/blackjack.d.ts

@@ -2,5 +2,6 @@ import { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput } from ".
 export declare function blackjack(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, type: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[]): {
     inputs?: CoinselectTxInput[];
     outputs?: CoinselectTxOutput[];
+    effectiveFeeRate?: number;
     fee: number;
 };

package/dist/bitcoin/coinselect2/blackjack.js

@@ -5,7 +5,7 @@ const utils_1 = require("./utils");
 // add inputs until we reach or surpass the target value (or deplete)
 // worst-case: O(n)
 function blackjack(utxos, outputs, feeRate, type, requiredInputs) {
-    if (!isFinite(utils_1.utils.uintOrNaN(feeRate)))
+    if (!isFinite(utils_1.utils.numberOrNaN(feeRate)))
         throw new Error("Invalid feeRate passed!");
     const inputs = requiredInputs == null ? [] : [...requiredInputs];
     let bytesAccum = utils_1.utils.transactionBytes(inputs, outputs, type);

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

@@ -5,12 +5,13 @@ export { CoinselectAddressTypes, CoinselectTxInput, CoinselectTxOutput, DUST_THR
 export declare function coinSelect(utxos: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, type: CoinselectAddressTypes, requiredInputs?: CoinselectTxInput[]): {
     inputs?: CoinselectTxInput[];
     outputs?: CoinselectTxOutput[];
+    effectiveFeeRate?: number;
     fee: number;
 };
-export declare function maxSendable(utxos: CoinselectTxInput[], output: {
+export declare function maxSendable(utxos: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">[], output: {
     script: Buffer;
     type: CoinselectAddressTypes;
-}, feeRate: number, requiredInputs?: CoinselectTxInput[], additionalOutputs?: {
+}, feeRate: number, requiredInputs?: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">[], additionalOutputs?: {
     script: Buffer;
     value: number;
 }[]): {

package/dist/bitcoin/coinselect2/index.js

@@ -28,7 +28,7 @@ function coinSelect(utxos, outputs, feeRate, type, requiredInputs) {
 }
 exports.coinSelect = coinSelect;
 function maxSendable(utxos, output, feeRate, requiredInputs, additionalOutputs) {
-    if (!isFinite(utils_1.utils.uintOrNaN(feeRate)))
+    if (!isFinite(utils_1.utils.numberOrNaN(feeRate)))
         throw new Error("Invalid feeRate passed!");
     const outputs = additionalOutputs ?? [];
     const inputs = requiredInputs ?? [];
@@ -42,7 +42,7 @@ function maxSendable(utxos, output, feeRate, requiredInputs, additionalOutputs)
         const utxoFee = feeRate * utxoBytes;
         let cpfpFee = 0;
         if (utxo.cpfp != null && utxo.cpfp.txEffectiveFeeRate < feeRate)
-            cpfpFee = utxo.cpfp.txVsize * (feeRate - utxo.cpfp.txEffectiveFeeRate);
+            cpfpFee = Math.ceil(utxo.cpfp.txVsize * (feeRate - utxo.cpfp.txEffectiveFeeRate));
         const utxoValue = utils_1.utils.uintOrNaN(utxo.value);
         // skip detrimental input
         if (utxoFee + cpfpFee > utxo.value) {

package/dist/bitcoin/coinselect2/utils.d.ts

@@ -52,6 +52,7 @@ declare function transactionBytes(inputs: {
     script?: Buffer;
     type?: CoinselectAddressTypes;
 }[], changeType?: CoinselectAddressTypes): number;
+declare function numberOrNaN(v: number): number;
 declare function uintOrNaN(v: number): number;
 declare function sumForgiving(range: {
     value: number;
@@ -59,11 +60,13 @@ declare function sumForgiving(range: {
 declare function sumOrNaN(range: {
     value: number;
 }[]): number;
-declare function finalize(inputs: CoinselectTxInput[], outputs: CoinselectTxOutput[], feeRate: number, changeType: CoinselectAddressTypes, cpfpAddFee?: number): {
-    inputs?: CoinselectTxInput[];
+declare function finalize<T extends Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">>(inputs: T[], outputs: CoinselectTxOutput[], feeRate: number, changeType: CoinselectAddressTypes | null, cpfpAddFee?: number): {
+    inputs?: T[];
     outputs?: CoinselectTxOutput[];
+    effectiveFeeRate?: number;
     fee: number;
 };
+declare function isDetrimentalInput(feeRate: number, utxo: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">): boolean;
 export declare const utils: {
     dustThreshold: typeof dustThreshold;
     finalize: typeof finalize;
@@ -73,5 +76,7 @@ export declare const utils: {
     sumForgiving: typeof sumForgiving;
     transactionBytes: typeof transactionBytes;
     uintOrNaN: typeof uintOrNaN;
+    numberOrNaN: typeof numberOrNaN;
+    isDetrimentalInput: typeof isDetrimentalInput;
 };
 export {};

package/dist/bitcoin/coinselect2/utils.js

@@ -73,6 +73,15 @@ function transactionBytes(inputs, outputs, changeType) {
     }
     return Math.ceil(size);
 }
+function numberOrNaN(v) {
+    if (typeof v !== 'number')
+        return NaN;
+    if (!isFinite(v))
+        return NaN;
+    if (v < 0)
+        return NaN;
+    return v;
+}
 function uintOrNaN(v) {
     if (typeof v !== 'number')
         return NaN;
@@ -91,26 +100,50 @@ function sumOrNaN(range) {
     return range.reduce((a, x) => a + uintOrNaN(x.value), 0);
 }
 function finalize(inputs, outputs, feeRate, changeType, cpfpAddFee = 0) {
-    const bytesAccum = transactionBytes(inputs, outputs, changeType);
+    const bytesAccum = transactionBytes(inputs, outputs, changeType ?? undefined);
     logger.debug("finalize(): Transaction bytes: ", bytesAccum);
-    const feeAfterExtraOutput = (feeRate * (bytesAccum + outputBytes({ type: changeType }))) + cpfpAddFee;
-    logger.debug("finalize(): TX fee after adding change output: ", feeAfterExtraOutput);
-    const remainderAfterExtraOutput = Math.floor(sumOrNaN(inputs) - (sumOrNaN(outputs) + feeAfterExtraOutput));
-    logger.debug("finalize(): Leaves change (changeType=" + changeType + ") value: ", remainderAfterExtraOutput);
-    // is it worth a change output?
-    if (remainderAfterExtraOutput >= dustThreshold({ type: changeType })) {
-        outputs = outputs.concat({ value: remainderAfterExtraOutput, type: changeType });
+    if (changeType != null) {
+        const feeAfterExtraOutput = (feeRate * (bytesAccum + outputBytes({ type: changeType }))) + cpfpAddFee;
+        logger.debug("finalize(): TX fee after adding change output: ", feeAfterExtraOutput);
+        const remainderAfterExtraOutput = Math.floor(sumOrNaN(inputs) - (sumOrNaN(outputs) + feeAfterExtraOutput));
+        logger.debug("finalize(): Leaves change (changeType=" + changeType + ") value: ", remainderAfterExtraOutput);
+        // is it worth a change output?
+        if (remainderAfterExtraOutput >= dustThreshold({ type: changeType })) {
+            outputs = outputs.concat({ value: remainderAfterExtraOutput, type: changeType });
+        }
     }
     const fee = sumOrNaN(inputs) - sumOrNaN(outputs);
     logger.debug("finalize(): Re-calculated total fee: ", fee);
-    if (!isFinite(fee))
+    if (!isFinite(fee) || fee < 0)
         return { fee: (feeRate * bytesAccum) + cpfpAddFee };
+    let txVSize = exports.utils.transactionBytes(inputs, outputs);
+    let txFee = fee;
+    const cpfpSortedInputs = [...inputs].sort((a, b) => (b.cpfp?.txEffectiveFeeRate ?? 0) - (a.cpfp?.txEffectiveFeeRate ?? 0));
+    cpfpSortedInputs.forEach(input => {
+        if (input.cpfp == null)
+            return;
+        const currentEffectiveFeeRate = txFee / txVSize;
+        if (currentEffectiveFeeRate > input.cpfp.txEffectiveFeeRate) {
+            txVSize += input.cpfp.txVsize;
+            txFee += input.cpfp.txVsize * input.cpfp.txEffectiveFeeRate;
+        }
+    });
     return {
         inputs: inputs,
         outputs: outputs,
+        effectiveFeeRate: txFee / txVSize,
         fee: fee
     };
 }
+function isDetrimentalInput(feeRate, utxo) {
+    const utxoBytes = exports.utils.inputBytes(utxo);
+    const utxoFee = feeRate * utxoBytes;
+    let cpfpFee = 0;
+    if (utxo.cpfp != null && utxo.cpfp.txEffectiveFeeRate < feeRate)
+        cpfpFee = Math.ceil(utxo.cpfp.txVsize * (feeRate - utxo.cpfp.txEffectiveFeeRate));
+    // skip detrimental input
+    return utxoFee + cpfpFee > utxo.value;
+}
 exports.utils = {
     dustThreshold: dustThreshold,
     finalize: finalize,
@@ -119,5 +152,7 @@ exports.utils = {
     sumOrNaN: sumOrNaN,
     sumForgiving: sumForgiving,
     transactionBytes: transactionBytes,
-    uintOrNaN: uintOrNaN
+    uintOrNaN: uintOrNaN,
+    numberOrNaN: numberOrNaN,
+    isDetrimentalInput
 };

package/dist/bitcoin/wallet/BitcoinWallet.d.ts

@@ -1,29 +1,8 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { CoinselectAddressTypes } from "../coinselect2";
 import { BTC_NETWORK } from "@scure/btc-signer/utils";
 import { Transaction } from "@scure/btc-signer";
-import { IBitcoinWallet } from "./IBitcoinWallet";
-import { Buffer } from "buffer";
+import { BitcoinWalletUtxo, BitcoinWalletUtxoBase, IBitcoinWallet } from "./IBitcoinWallet";
 import { BitcoinNetwork, BitcoinRpcWithAddressIndex } from "@atomiqlabs/base";
-/**
- * UTXO data structure for Bitcoin wallets
- *
- * @category Bitcoin
- */
-export type BitcoinWalletUtxo = {
-    vout: number;
-    txId: string;
-    value: number;
-    type: CoinselectAddressTypes;
-    outputScript: Buffer;
-    address: string;
-    cpfp?: {
-        txVsize: number;
-        txEffectiveFeeRate: number;
-    };
-    confirmed: boolean;
-};
 /**
  * Identifies the address type of a Bitcoin address
  *
@@ -96,7 +75,7 @@ export declare abstract class BitcoinWallet implements IBitcoinWallet {
         pubkey: string;
         address: string;
         addressType: CoinselectAddressTypes;
-    }[], psbt: Transaction, feeRate?: number): Promise<{
+    }[], psbt: Transaction, _feeRate?: number, utxos?: BitcoinWalletUtxo[], spendFully?: boolean): Promise<{
         fee: number;
         psbt?: Transaction;
         inputAddressIndexes?: {
@@ -106,13 +85,13 @@ export declare abstract class BitcoinWallet implements IBitcoinWallet {
     protected _getSpendableBalance(sendingAccounts: {
         address: string;
         addressType: CoinselectAddressTypes;
-    }[], psbt?: Transaction, feeRate?: number): Promise<{
+    }[], psbt?: Transaction, feeRate?: number, outputAddressType?: CoinselectAddressTypes, utxoPool?: BitcoinWalletUtxoBase[]): Promise<{
         balance: bigint;
         feeRate: number;
         totalFee: number;
     }>;
     abstract sendTransaction(address: string, amount: bigint, feeRate?: number): Promise<string>;
-    abstract fundPsbt(psbt: Transaction, feeRate?: number): Promise<Transaction>;
+    abstract fundPsbt(psbt: Transaction, feeRate?: number, utxos?: BitcoinWalletUtxo[], spendFully?: boolean): Promise<Transaction>;
     abstract signPsbt(psbt: Transaction, signInputs: number[]): Promise<Transaction>;
     abstract getTransactionFee(address: string, amount: bigint, feeRate?: number): Promise<number>;
     abstract getFundedPsbtFee(psbt: Transaction, feeRate?: number): Promise<number>;
@@ -127,4 +106,8 @@ export declare abstract class BitcoinWallet implements IBitcoinWallet {
         totalFee: number;
     }>;
     static bitcoinNetworkToObject(network: BitcoinNetwork): BTC_NETWORK;
+    static getSpendableBalance(utxoPool: BitcoinWalletUtxoBase[], feeRate: number, psbt?: Transaction, outputAddressType?: CoinselectAddressTypes): {
+        balance: bigint;
+        totalFee: number;
+    };
 }

package/dist/bitcoin/wallet/BitcoinWallet.js

@@ -5,10 +5,10 @@ const coinselect2_1 = require("../coinselect2");
 const utils_1 = require("@scure/btc-signer/utils");
 const btc_signer_1 = require("@scure/btc-signer");
 const buffer_1 = require("buffer");
-const Utils_1 = require("../../utils/Utils");
 const BitcoinUtils_1 = require("../../utils/BitcoinUtils");
 const Logger_1 = require("../../utils/Logger");
 const base_1 = require("@atomiqlabs/base");
+const utils_2 = require("../coinselect2/utils");
 /**
  * Identifies the address type of a Bitcoin address
  *
@@ -135,10 +135,11 @@ class BitcoinWallet {
         });
         return this._fundPsbt(sendingAccounts, psbt, feeRate);
     }
-    async _fundPsbt(sendingAccounts, psbt, feeRate) {
-        if (feeRate == null)
-            feeRate = await this.getFeeRate();
-        const utxoPool = (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
+    async _fundPsbt(sendingAccounts, psbt, _feeRate, utxos, spendFully) {
+        const feeRate = _feeRate ?? await this.getFeeRate();
+        const utxoPool = utxos ?? (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
+        if (spendFully && utxoPool == null)
+            throw new Error("Cannot fully spend when no utxos are passed!");
         logger.debug("_fundPsbt(): fee rate: " + feeRate + " utxo pool: ", utxoPool);
         const accountPubkeys = {};
         sendingAccounts.forEach(acc => accountPubkeys[acc.address] = acc.pubkey);
@@ -177,13 +178,23 @@ class BitcoinWallet {
             });
         }
         logger.debug("_fundPsbt(): Coinselect targets: ", targets);
-        let coinselectResult = (0, coinselect2_1.coinSelect)(utxoPool, targets, feeRate, sendingAccounts[0].addressType, requiredInputs);
+        let coinselectResult = spendFully
+            ? utils_2.utils.finalize(requiredInputs.concat(utxoPool.filter(utxo => !utils_2.utils.isDetrimentalInput(feeRate, utxo))), targets, feeRate, null)
+            : (0, coinselect2_1.coinSelect)(utxoPool, targets, feeRate, sendingAccounts[0].addressType, requiredInputs);
         logger.debug("_fundPsbt(): Coinselect result: ", coinselectResult);
-        if (coinselectResult.inputs == null || coinselectResult.outputs == null) {
+        if (coinselectResult.inputs == null || coinselectResult.outputs == null || coinselectResult.effectiveFeeRate == null) {
             return {
                 fee: coinselectResult.fee
             };
         }
+        if (spendFully && feeRate != null) {
+            const maximumAllowedFeeRate = (1.5 * feeRate) + 10;
+            if (coinselectResult.effectiveFeeRate > maximumAllowedFeeRate)
+                throw new Error(`Effective fee rate too high, feeRate: ${coinselectResult.effectiveFeeRate} sats/vB, maximum: ${maximumAllowedFeeRate} sats/vB!`);
+            const minimumAllowedFeeRate = 0.9 * feeRate;
+            if (coinselectResult.effectiveFeeRate < minimumAllowedFeeRate)
+                throw new Error(`Effective fee rate too low, feeRate: ${coinselectResult.effectiveFeeRate} sats/vB, minimum: ${minimumAllowedFeeRate} sats/vB!`);
+        }
         // Remove in/outs that are already in the PSBT
         coinselectResult.inputs.splice(0, psbt.inputsLength);
         coinselectResult.outputs.splice(0, psbt.outputsLength);
@@ -264,9 +275,18 @@ class BitcoinWallet {
             inputAddressIndexes
         };
     }
-    async _getSpendableBalance(sendingAccounts, psbt, feeRate) {
+    async _getSpendableBalance(sendingAccounts, psbt, feeRate, outputAddressType, utxoPool) {
         feeRate ??= await this.getFeeRate();
-        const utxoPool = (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
+        utxoPool ??= (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
+        return {
+            ...BitcoinWallet.getSpendableBalance(utxoPool ?? (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat(), feeRate ?? await this.getFeeRate(), psbt, outputAddressType),
+            feeRate
+        };
+    }
+    static bitcoinNetworkToObject(network) {
+        return btcNetworkMapping[network];
+    }
+    static getSpendableBalance(utxoPool, feeRate, psbt, outputAddressType) {
         const requiredInputs = [];
         if (psbt != null)
             for (let i = 0; i < psbt.inputsLength; i++) {
@@ -303,20 +323,13 @@ class BitcoinWallet {
                     script: buffer_1.Buffer.from(output.script)
                 });
             }
-        const target = btc_signer_1.OutScript.encode({
-            type: "wsh",
-            hash: (0, Utils_1.randomBytes)(32)
-        });
-        let coinselectResult = (0, coinselect2_1.maxSendable)(utxoPool, { script: buffer_1.Buffer.from(target), type: "p2wsh" }, feeRate, requiredInputs, additionalOutputs);
+        const target = (0, BitcoinUtils_1.getDummyOutputScript)(outputAddressType ?? "p2wsh");
+        let coinselectResult = (0, coinselect2_1.maxSendable)(utxoPool, { script: buffer_1.Buffer.from(target), type: outputAddressType ?? "p2wsh" }, feeRate, requiredInputs, additionalOutputs);
         logger.debug("_getSpendableBalance(): Max spendable result: ", coinselectResult);
         return {
-            feeRate: feeRate,
             balance: BigInt(Math.floor(coinselectResult.value)),
             totalFee: coinselectResult.fee
         };
     }
-    static bitcoinNetworkToObject(network) {
-        return btcNetworkMapping[network];
-    }
 }
 exports.BitcoinWallet = BitcoinWallet;

package/dist/bitcoin/wallet/IBitcoinWallet.d.ts

@@ -1,4 +1,32 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import { Transaction } from "@scure/btc-signer";
+import { CoinselectAddressTypes } from "../coinselect2";
+/**
+ * UTXO data structure for Bitcoin wallets
+ *
+ * @category Bitcoin
+ */
+export type BitcoinWalletUtxo = {
+    vout: number;
+    txId: string;
+    value: number;
+    type: CoinselectAddressTypes;
+    outputScript: Buffer;
+    address: string;
+    cpfp?: {
+        txVsize: number;
+        txEffectiveFeeRate: number;
+    };
+    confirmed: boolean;
+};
+/**
+ * Base UTXO data structure used for maximum spendable balance calculation, doesn't contain all the fields necessary
+ *  for constructing the full transaction.
+ *
+ * @category Bitcoin
+ */
+export type BitcoinWalletUtxoBase = Omit<BitcoinWalletUtxo, "txId" | "vout" | "outputScript" | "address" | "confirmed">;
 /**
  * Type guard to check if an object implements {@link IBitcoinWallet}
  *
@@ -25,8 +53,12 @@ export interface IBitcoinWallet {
      *
      * @param psbt PSBT to add the inputs to
      * @param feeRate Optional fee rate in sats/vB to use for the transaction
+     * @param utxos Pre-fetched list of UTXOs to spend from
+     * @param spendFully Instructs the wallet to spend all the passed UTXOs in the transaction without creating any
+     *  change output, if the `feeRate` is passed, it will also enforce that the feeRate in sats/vB for the resulting
+     *  transaction is not more than 50% and 10 sats/vB larger (considering also the CPFP adjustments)
      */
-    fundPsbt(psbt: Transaction, feeRate?: number): Promise<Transaction>;
+    fundPsbt(psbt: Transaction, feeRate?: number, utxos?: BitcoinWalletUtxo[], spendFully?: boolean): Promise<Transaction>;
     /**
      * Signs inputs in the provided PSBT
      *
@@ -69,10 +101,16 @@ export interface IBitcoinWallet {
      *
      * @param psbt A PSBT to which additional inputs from wallet's UTXO set will be added and fee estimated
      * @param feeRate Optional fee rate in sats/vB to use for the transaction
+     * @param outputAddressType Expected output address type, if known
+     * @param utxos Optional pre-fetched UTXOs
      */
-    getSpendableBalance(psbt?: Transaction, feeRate?: number): Promise<{
+    getSpendableBalance(psbt?: Transaction, feeRate?: number, outputAddressType?: CoinselectAddressTypes, utxos?: BitcoinWalletUtxoBase[]): Promise<{
         balance: bigint;
         feeRate: number;
         totalFee: number;
     }>;
+    /**
+     * Returns a list of available UTXOs for the wallet
+     */
+    getUtxoPool?(): Promise<BitcoinWalletUtxo[]>;
 }

package/dist/bitcoin/wallet/SingleAddressBitcoinWallet.d.ts

@@ -6,6 +6,7 @@ import { Transaction } from "@scure/btc-signer";
 import { Buffer } from "buffer";
 import { BitcoinWallet } from "./BitcoinWallet";
 import { BitcoinNetwork, BitcoinRpcWithAddressIndex } from "@atomiqlabs/base";
+import { BitcoinWalletUtxo, BitcoinWalletUtxoBase } from "./IBitcoinWallet";
 /**
  * Bitcoin wallet implementation deriving a single address from a WIF encoded private key
  *
@@ -37,7 +38,7 @@ export declare class SingleAddressBitcoinWallet extends BitcoinWallet {
     /**
      * @inheritDoc
      */
-    fundPsbt(inputPsbt: Transaction, feeRate?: number): Promise<Transaction>;
+    fundPsbt(inputPsbt: Transaction, feeRate?: number, utxos?: BitcoinWalletUtxo[], spendFully?: boolean): Promise<Transaction>;
     /**
      * @inheritDoc
      */
@@ -68,11 +69,15 @@ export declare class SingleAddressBitcoinWallet extends BitcoinWallet {
     /**
      * @inheritDoc
      */
-    getSpendableBalance(psbt?: Transaction, feeRate?: number): Promise<{
+    getSpendableBalance(psbt?: Transaction, feeRate?: number, outputAddressType?: CoinselectAddressTypes, utxos?: BitcoinWalletUtxoBase[]): Promise<{
         balance: bigint;
         feeRate: number;
         totalFee: number;
     }>;
+    /**
+     * @inheritDoc
+     */
+    getUtxoPool(): Promise<BitcoinWalletUtxo[]>;
     /**
      * Generates a new random private key WIF that can be used to instantiate the bitcoin wallet instance
      *

package/dist/bitcoin/wallet/SingleAddressBitcoinWallet.js

@@ -80,8 +80,8 @@ class SingleAddressBitcoinWallet extends BitcoinWallet_1.BitcoinWallet {
     /**
      * @inheritDoc
      */
-    async fundPsbt(inputPsbt, feeRate) {
-        const { psbt } = await super._fundPsbt(this.toBitcoinWalletAccounts(), inputPsbt, feeRate);
+    async fundPsbt(inputPsbt, feeRate, utxos, spendFully) {
+        const { psbt } = await super._fundPsbt(this.toBitcoinWalletAccounts(), inputPsbt, feeRate, utxos, spendFully);
         if (psbt == null) {
             throw new Error("Not enough balance!");
         }
@@ -133,8 +133,14 @@ class SingleAddressBitcoinWallet extends BitcoinWallet_1.BitcoinWallet {
     /**
      * @inheritDoc
      */
-    getSpendableBalance(psbt, feeRate) {
-        return this._getSpendableBalance([{ address: this.address, addressType: this.addressType }], psbt, feeRate);
+    getSpendableBalance(psbt, feeRate, outputAddressType, utxos) {
+        return this._getSpendableBalance([{ address: this.address, addressType: this.addressType }], psbt, feeRate, outputAddressType, utxos);
+    }
+    /**
+     * @inheritDoc
+     */
+    async getUtxoPool() {
+        return this._getUtxoPool(this.address, this.addressType);
     }
     /**
      * Generates a new random private key WIF that can be used to instantiate the bitcoin wallet instance

package/dist/intermediaries/apis/IntermediaryAPI.d.ts

@@ -234,17 +234,27 @@ declare const SpvFromBTCPrepareResponseSchema: {
     readonly callerFeeShare: FieldTypeEnum.BigInt;
     readonly frontingFeeShare: FieldTypeEnum.BigInt;
     readonly executionFeeShare: FieldTypeEnum.BigInt;
+    readonly usedUtxoInputCalculation: FieldTypeEnum.BooleanOptional;
 };
 export type SpvFromBTCPrepareResponseType = RequestSchemaResult<typeof SpvFromBTCPrepareResponseSchema>;
 export type SpvFromBTCPrepare = SwapInit & {
     address: string;
-    amount: bigint;
+    amount: Promise<bigint>;
     gasAmount: bigint;
     gasToken: string;
     exactOut: boolean;
     callerFeeRate: Promise<bigint>;
     frontingFeeRate: bigint;
     stickyAddress?: boolean;
+    amountUtxos?: Promise<{
+        value: number;
+        vSize: number;
+        cpfp?: {
+            effectiveVSize: number;
+            effectiveFeeRate: number;
+        };
+    }[] | undefined>;
+    amountFeeRate?: Promise<number | undefined>;
 };
 declare const SpvFromBTCInitResponseSchema: {
     readonly txId: FieldTypeEnum.String;

package/dist/intermediaries/apis/IntermediaryAPI.js

@@ -123,7 +123,8 @@ const SpvFromBTCPrepareResponseSchema = {
     gasSwapFee: SchemaVerifier_1.FieldTypeEnum.BigInt,
     callerFeeShare: SchemaVerifier_1.FieldTypeEnum.BigInt,
     frontingFeeShare: SchemaVerifier_1.FieldTypeEnum.BigInt,
-    executionFeeShare: SchemaVerifier_1.FieldTypeEnum.BigInt
+    executionFeeShare: SchemaVerifier_1.FieldTypeEnum.BigInt,
+    usedUtxoInputCalculation: SchemaVerifier_1.FieldTypeEnum.BooleanOptional
 };
 const SpvFromBTCInitResponseSchema = {
     txId: SchemaVerifier_1.FieldTypeEnum.String
@@ -534,17 +535,31 @@ class IntermediaryAPI {
      * @throws {RequestError} If non-200 http response code is returned
      */
     static prepareSpvFromBTC(chainIdentifier, baseUrl, init, timeout, abortSignal, streamRequest) {
+        //We need to make sure we only send the amount parameter after the amountUtxos and amountFeeRate resolve
+        // this is needed, because in the LP code to maintain backwards compatibility the amountUtxos and amountFeeRate
+        // params are checked immediately after the amount param (and other params) are received, if amount were sent
+        // first without the amountUtxos or amountFeeRate populated these fields would've been skipped altogether
+        const amountPromise = (async () => {
+            if (init.amountUtxos != null)
+                await init.amountUtxos;
+            if (init.amountFeeRate != null)
+                await init.amountFeeRate;
+            const amount = await init.amount;
+            return amount.toString(10);
+        })();
         const responseBodyPromise = (0, StreamingFetchPromise_1.streamingFetchPromise)(baseUrl + "/frombtc_spv/getQuote?chain=" + encodeURIComponent(chainIdentifier), {
             exactOut: init.exactOut,
             ...init.additionalParams,
             address: init.address,
-            amount: init.amount.toString(10),
+            amount: amountPromise,
             token: init.token,
             gasAmount: init.gasAmount.toString(10),
             gasToken: init.gasToken,
             frontingFeeRate: init.frontingFeeRate.toString(10),
             callerFeeRate: init.callerFeeRate.then(val => val.toString(10)),
-            stickyAddress: init.stickyAddress
+            stickyAddress: init.stickyAddress,
+            amountUtxos: init.amountUtxos,
+            amountFeeRate: init.amountFeeRate
         }, {
             code: SchemaVerifier_1.FieldTypeEnum.Number,
             msg: SchemaVerifier_1.FieldTypeEnum.String,

package/dist/swapper/Swapper.d.ts

@@ -39,6 +39,8 @@ import { LNURLPay } from "../types/lnurl/LNURLPay";
 import { NotNever } from "../utils/TypeUtils";
 import { LightningInvoiceCreateService } from "../types/wallets/LightningInvoiceCreateService";
 import { SwapSide } from "../enums/SwapSide";
+import { BitcoinWalletUtxo, IBitcoinWallet } from "../bitcoin/wallet/IBitcoinWallet";
+import { MinimalBitcoinWalletInterface } from "../types/wallets/MinimalBitcoinWalletInterface";
 /**
  * Configuration options for the Swapper
  * @category Core
@@ -346,7 +348,7 @@ export declare class Swapper<T extends MultiChain> extends EventEmitter<{
      * @param additionalParams Additional parameters sent to the LP when creating the swap
      * @param options Additional options for the swap
      */
-    createFromBTCSwapNew<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, amount: bigint, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: SpvFromBTCOptions): Promise<SpvFromBTCSwap<T[ChainIdentifier]>>;
+    createFromBTCSwapNew<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, recipient: string, tokenAddress: string, amount: bigint | null, exactOut?: boolean, additionalParams?: Record<string, any> | undefined, options?: SpvFromBTCOptions): Promise<SpvFromBTCSwap<T[ChainIdentifier]>>;
     /**
      * Creates LEGACY Bitcoin -> Smart chain ({@link SwapType.FROM_BTC}) swap
      *
@@ -505,6 +507,44 @@ export declare class Swapper<T extends MultiChain> extends EventEmitter<{
     swap<C extends ChainIds<T>>(srcToken: Token<C> | string, dstToken: Token<C> | string, amount: bigint | string | undefined, exactIn: boolean | SwapAmountType, src: undefined | string | LNURLWithdraw, dst: string | LNURLPay | LightningInvoiceCreateService, options?: FromBTCLNOptions | SpvFromBTCOptions | FromBTCOptions | ToBTCOptions | (ToBTCLNOptions & {
         comment?: string;
     }) | FromBTCLNAutoOptions): Promise<ISwap<T[C]>>;
+    /**
+     * A helper function to sweep all the funds from a given wallet in a single swap, after getting the quote you can
+     *  execute the swap by passing the returned `feeRate` and `utxos` to the {@link SpvFromBTCSwap.execute},
+     *  {@link SpvFromBTCSwap.getFundedPsbt} or {@link SpvFromBTCSwap.sendBitcoinTransaction} functions along
+     *  with `spendFully=true`.
+     *
+     * @example
+     * Create the swap first using this function
+     * ```ts
+     * const {swap, utxos, btcFeeRate} = await swapper.sweepBitcoinWallet(wallet, Tokens.CITREA.CBTC, dstAddress);
+     * ```
+     * Then execute it using one of these execution paths - ensure that you supply the returned `utxos`, `btcFeeRate`
+     *  params and also set `spendFully` to `true`!
+     *
+     * a) Execute and pass the returned utxos and btcFeeRate:
+     * ```ts
+     * await swap.execute(wallet, undefined, {feeRate: btcFeeRate, utxos: utxos, spendFully: true});
+     * ```
+     *
+     * b) Get funded PSBT to sign externally:
+     * ```ts
+     * const {psbt, psbtHex, psbtBase64, signInputs} = await swap.getFundedPsbt(wallet, btcFeeRate, undefined, utxos, true);
+     * // Sign the psbt at the specified signInputs indices
+     * const signedPsbt = ...;
+     * // Then submit back to the SDK
+     * await swap.submitPsbt(signedPsbt);
+     * ```
+     *
+     * c) Only sign and send the signed PSBT with the provided wallet:
+     * ```ts
+     * await swap.sendBitcoinTransaction(wallet, btcFeeRate, utxos, true);
+     * ```
+     */
+    sweepBitcoinWallet<C extends ChainIds<T>>(srcWallet: IBitcoinWallet | MinimalBitcoinWalletInterface, _dstToken: SCToken<C> | string, dstAddress: string, options?: SpvFromBTCOptions): Promise<{
+        swap: SpvFromBTCSwap<T[C]>;
+        utxos: BitcoinWalletUtxo[];
+        btcFeeRate: number;
+    }>;
     /**
      * Returns all swaps
      */