@atomiqlabs/sdk 8.7.6 → 8.8.3

package/src/bitcoin/wallet/BitcoinWallet.ts

@@ -1,32 +1,14 @@
 import {coinSelect, maxSendable, CoinselectAddressTypes, CoinselectTxInput} from "../coinselect2";
 import {BTC_NETWORK, NETWORK, TEST_NETWORK} from "@scure/btc-signer/utils"
 import {p2wpkh, OutScript, Transaction, p2tr, Address} from "@scure/btc-signer";
-import {IBitcoinWallet} from "./IBitcoinWallet";
+import {BitcoinWalletUtxo, BitcoinWalletUtxoBase, IBitcoinWallet} from "./IBitcoinWallet";
 import {Buffer} from "buffer";
 import {randomBytes} from "../../utils/Utils";
-import {toCoinselectAddressType, toOutputScript} from "../../utils/BitcoinUtils";
+import {getDummyOutputScript, toCoinselectAddressType, toOutputScript} from "../../utils/BitcoinUtils";
 import {TransactionInputUpdate} from "@scure/btc-signer/psbt";
 import {getLogger} from "../../utils/Logger";
 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
-};
+import {utils} from "../coinselect2/utils";
 
 /**
  * Identifies the address type of a Bitcoin address
@@ -200,15 +182,18 @@ export abstract class BitcoinWallet implements IBitcoinWallet {
             addressType: CoinselectAddressTypes,
         }[],
         psbt: Transaction,
-        feeRate?: number
+        _feeRate?: number,
+        utxos?: BitcoinWalletUtxo[],
+        spendFully?: boolean
     ): Promise<{
         fee: number,
         psbt?: Transaction,
         inputAddressIndexes?: {[address: string]: number[]}
     }> {
-        if(feeRate==null) feeRate = await this.getFeeRate();
+        const feeRate = _feeRate ?? await this.getFeeRate();
+        const utxoPool: BitcoinWalletUtxo[] = utxos ?? (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
 
-        const utxoPool: BitcoinWalletUtxo[] = (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);
 
@@ -247,15 +232,26 @@ export abstract class BitcoinWallet implements IBitcoinWallet {
         }
         logger.debug("_fundPsbt(): Coinselect targets: ", targets);
 
-        let coinselectResult = coinSelect(utxoPool, targets, feeRate, sendingAccounts[0].addressType, requiredInputs);
+        let coinselectResult = spendFully
+            ? utils.finalize(requiredInputs.concat(utxoPool.filter(utxo => !utils.isDetrimentalInput(feeRate, utxo))), targets, feeRate, null)
+            : 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);
@@ -346,16 +342,59 @@ export abstract class BitcoinWallet implements IBitcoinWallet {
             addressType: CoinselectAddressTypes,
         }[],
         psbt?: Transaction,
-        feeRate?: number
+        feeRate?: number,
+        outputAddressType?: CoinselectAddressTypes,
+        utxoPool?: BitcoinWalletUtxoBase[]
     ): Promise<{
         balance: bigint,
         feeRate: number,
         totalFee: number
     }> {
         feeRate ??= await this.getFeeRate();
+        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
+        };
+    }
+
+    abstract sendTransaction(address: string, amount: bigint, feeRate?: number): Promise<string>;
+    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>;
+
+    abstract getReceiveAddress(): string;
+    abstract getBalance(): Promise<{
+        confirmedBalance: bigint,
+        unconfirmedBalance: bigint
+    }>;
+    abstract getSpendableBalance(psbt?: Transaction, feeRate?: number): Promise<{
+        balance: bigint,
+        feeRate: number,
+        totalFee: number
+    }>;
 
-        const utxoPool: BitcoinWalletUtxo[] = (await Promise.all(sendingAccounts.map(acc => this._getUtxoPool(acc.address, acc.addressType)))).flat();
+    static bitcoinNetworkToObject(network: BitcoinNetwork): BTC_NETWORK {
+        return btcNetworkMapping[network];
+    }
 
+    static getSpendableBalance(
+        utxoPool: BitcoinWalletUtxoBase[],
+        feeRate: number,
+        psbt?: Transaction,
+        outputAddressType?: CoinselectAddressTypes
+    ): {
+        balance: bigint,
+        totalFee: number
+    } {
         const requiredInputs: CoinselectTxInput[] = [];
         if(psbt!=null) for(let i=0;i<psbt.inputsLength;i++) {
             const input = psbt.getInput(i);
@@ -387,42 +426,15 @@ export abstract class BitcoinWallet implements IBitcoinWallet {
             })
         }
 
-        const target = OutScript.encode({
-            type: "wsh",
-            hash: randomBytes(32)
-        });
-
-        let coinselectResult = maxSendable(utxoPool, {script: Buffer.from(target), type: "p2wsh"}, feeRate, requiredInputs, additionalOutputs);
+        const target: Uint8Array = getDummyOutputScript(outputAddressType ?? "p2wsh");
+        let coinselectResult = maxSendable(utxoPool, {script: 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
         }
     }
 
-    abstract sendTransaction(address: string, amount: bigint, feeRate?: number): Promise<string>;
-    abstract fundPsbt(psbt: Transaction, feeRate?: number): 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>;
-
-    abstract getReceiveAddress(): string;
-    abstract getBalance(): Promise<{
-        confirmedBalance: bigint,
-        unconfirmedBalance: bigint
-    }>;
-    abstract getSpendableBalance(psbt?: Transaction, feeRate?: number): Promise<{
-        balance: bigint,
-        feeRate: number,
-        totalFee: number
-    }>;
-
-    static bitcoinNetworkToObject(network: BitcoinNetwork): BTC_NETWORK {
-        return btcNetworkMapping[network];
-    }
-
 }

package/src/bitcoin/wallet/IBitcoinWallet.ts

@@ -1,4 +1,33 @@
-import {Transaction} from "@scure/btc-signer";
+import {Address, Transaction} from "@scure/btc-signer";
+import {BTC_NETWORK} from "@scure/btc-signer/utils";
+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}
@@ -39,8 +68,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
@@ -90,10 +123,18 @@ 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/src/bitcoin/wallet/SingleAddressBitcoinWallet.ts

@@ -8,6 +8,7 @@ import {HDKey} from "@scure/bip32";
 import {entropyToMnemonic, generateMnemonic, mnemonicToSeed} from "@scure/bip39";
 import {wordlist} from "@scure/bip39/wordlists/english.js";
 import {sha256} from "@noble/hashes/sha2";
+import {BitcoinWalletUtxo, BitcoinWalletUtxoBase} from "./IBitcoinWallet";
 
 const logger = getLogger("SingleAddressBitcoinWallet: ");
 
@@ -88,8 +89,8 @@ export class SingleAddressBitcoinWallet extends BitcoinWallet {
     /**
      * @inheritDoc
      */
-    async fundPsbt(inputPsbt: Transaction, feeRate?: number): Promise<Transaction> {
-        const {psbt} = await super._fundPsbt(this.toBitcoinWalletAccounts(), inputPsbt, feeRate);
+    async fundPsbt(inputPsbt: Transaction, feeRate?: number, utxos?: BitcoinWalletUtxo[], spendFully?: boolean): Promise<Transaction> {
+        const {psbt} = await super._fundPsbt(this.toBitcoinWalletAccounts(), inputPsbt, feeRate, utxos, spendFully);
         if(psbt==null) {
             throw new Error("Not enough balance!");
         }
@@ -150,12 +151,19 @@ export 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
     }> {
-        return this._getSpendableBalance([{address: this.address, addressType: this.addressType}], psbt, feeRate);
+        return this._getSpendableBalance([{address: this.address, addressType: this.addressType}], psbt, feeRate, outputAddressType, utxos);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    async getUtxoPool(): Promise<BitcoinWalletUtxo[]> {
+        return this._getUtxoPool(this.address, this.addressType);
     }
 
     /**

package/src/intermediaries/apis/IntermediaryAPI.ts

@@ -298,20 +298,24 @@ const SpvFromBTCPrepareResponseSchema = {
 
     callerFeeShare: FieldTypeEnum.BigInt,
     frontingFeeShare: FieldTypeEnum.BigInt,
-    executionFeeShare: FieldTypeEnum.BigInt
+    executionFeeShare: FieldTypeEnum.BigInt,
+
+    usedUtxoInputCalculation: FieldTypeEnum.BooleanOptional
 } as const;
 
 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
+    stickyAddress?: boolean,
+    amountUtxos?: Promise<{ value: number, vSize: number, cpfp?: { effectiveVSize: number, effectiveFeeRate: number }}[] | undefined>,
+    amountFeeRate?: Promise<number | undefined>
 }
 
 const SpvFromBTCInitResponseSchema = {
@@ -870,17 +874,29 @@ export class IntermediaryAPI {
         abortSignal?: AbortSignal,
         streamRequest?: boolean
     ): Promise<SpvFromBTCPrepareResponseType> {
+        //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 = 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: FieldTypeEnum.Number,
             msg: FieldTypeEnum.String,

package/src/swapper/Swapper.ts

@@ -65,6 +65,9 @@ import {NotNever} from "../utils/TypeUtils";
 import {IEscrowSwap} from "../swaps/escrow_swaps/IEscrowSwap";
 import {LightningInvoiceCreateService, isLightningInvoiceCreateService} from "../types/wallets/LightningInvoiceCreateService";
 import {SwapSide} from "../enums/SwapSide";
+import {BitcoinWalletUtxo, BitcoinWalletUtxoBase, IBitcoinWallet} from "../bitcoin/wallet/IBitcoinWallet";
+import {MinimalBitcoinWalletInterface} from "../types/wallets/MinimalBitcoinWalletInterface";
+import {toBitcoinWallet} from "../utils/BitcoinWalletUtils";
 
 /**
  * Configuration options for the Swapper
@@ -745,7 +748,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
             quote: Promise<S>,
             intermediary: Intermediary
         }[]>,
-        amountData: AmountData,
+        amountData: { amount?: bigint, token: string, exactIn: boolean },
         swapType: SwapType,
         maxWaitTimeMS: number = 2000
     ): Promise<S> {
@@ -755,7 +758,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
 
         const inBtc: boolean = swapType===SwapType.TO_BTCLN || swapType===SwapType.TO_BTC ? !amountData.exactIn : amountData.exactIn;
 
-        if(!inBtc) {
+        if(!inBtc || amountData.amount==null) {
             //Get candidates not based on the amount
             candidates = this.intermediaryDiscovery.getSwapCandidates(chainIdentifier, swapType, amountData.token);
         } else {
@@ -769,7 +772,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
             await this.intermediaryDiscovery.reloadIntermediaries();
             swapLimitsChanged = true;
 
-            if(!inBtc) {
+            if(!inBtc || amountData.amount==null) {
                 //Get candidates not based on the amount
                 candidates = this.intermediaryDiscovery.getSwapCandidates(chainIdentifier, swapType, amountData.token);
             } else {
@@ -859,8 +862,10 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
                         }
                         if(min!=null && max!=null) {
                             let msg = "Swap amount too high or too low! Try swapping a different amount.";
-                            if(min > amountData.amount) msg = "Swap amount too low! Try swapping a higher amount.";
-                            if(max < amountData.amount) msg = "Swap amount too high! Try swapping a lower amount.";
+                            if(amountData.amount!=null) {
+                                if(min > amountData.amount) msg = "Swap amount too low! Try swapping a higher amount.";
+                                if(max < amountData.amount) msg = "Swap amount too high! Try swapping a lower amount.";
+                            }
                             reject(new OutOfBoundsError(msg, 400, min, max));
                             return;
                         }
@@ -1102,16 +1107,17 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
         chainIdentifier: ChainIdentifier,
         recipient: string,
         tokenAddress: string,
-        amount: bigint,
+        amount: bigint | null,
         exactOut: boolean = false,
         additionalParams: Record<string, any> | undefined = this.options.defaultAdditionalParameters,
         options?: SpvFromBTCOptions
     ): Promise<SpvFromBTCSwap<T[ChainIdentifier]>> {
         if(this._chains[chainIdentifier]==null) throw new Error("Invalid chain identifier! Unknown chain: "+chainIdentifier);
+        if(this._chains[chainIdentifier].wrappers[SwapType.SPV_VAULT_FROM_BTC]==null) throw new Error("Chain "+chainIdentifier+" doesn't support new BTC swap protocol (spv vault swaps)!");
         if(!this._chains[chainIdentifier].chainInterface.isValidAddress(recipient, true)) throw new Error("Invalid "+chainIdentifier+" address");
         recipient = this._chains[chainIdentifier].chainInterface.normalizeAddress(recipient);
         const amountData = {
-            amount,
+            amount: amount ?? undefined,
             token: tokenAddress,
             exactIn: !exactOut
         };
@@ -1285,6 +1291,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
         options?: FromBTCLNAutoOptions
     ): Promise<FromBTCLNAutoSwap<T[ChainIdentifier]>> {
         if(this._chains[chainIdentifier]==null) throw new Error("Invalid chain identifier! Unknown chain: "+chainIdentifier);
+        if(this._chains[chainIdentifier].wrappers[SwapType.FROM_BTCLN_AUTO]==null) throw new Error("Chain "+chainIdentifier+" doesn't support new lightning swap protocol (from btcln auto)!");
         if(!this._chains[chainIdentifier].chainInterface.isValidAddress(recipient, true)) throw new Error("Invalid "+chainIdentifier+" address");
         recipient = this._chains[chainIdentifier].chainInterface.normalizeAddress(recipient);
         const amountData = {
@@ -1331,6 +1338,7 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
         options?: FromBTCLNAutoOptions
     ): Promise<FromBTCLNAutoSwap<T[ChainIdentifier]>> {
         if(this._chains[chainIdentifier]==null) throw new Error("Invalid chain identifier! Unknown chain: "+chainIdentifier);
+        if(this._chains[chainIdentifier].wrappers[SwapType.FROM_BTCLN_AUTO]==null) throw new Error("Chain "+chainIdentifier+" doesn't support new lightning swap protocol (from btcln auto)!");
         if(typeof(lnurl)==="string" && !this.Utils.isValidLNURL(lnurl)) throw new Error("Invalid LNURL-withdraw link");
         if(!this._chains[chainIdentifier].chainInterface.isValidAddress(recipient, true)) throw new Error("Invalid "+chainIdentifier+" address");
         recipient = this._chains[chainIdentifier].chainInterface.normalizeAddress(recipient);
@@ -1573,6 +1581,73 @@ export class Swapper<T extends MultiChain> extends EventEmitter<{
         throw new Error("Unsupported swap type");
     }
 
+    /**
+     * 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);
+     * ```
+     */
+    async 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
+    }> {
+        const dstToken = typeof(_dstToken)==="string" ? this.getToken(_dstToken) as Token<C> : _dstToken;
+        if(!isSCToken<C>(dstToken)) throw new Error("Destination token must be a smart chain token!");
+
+        const wallet = toBitcoinWallet(srcWallet, this._bitcoinRpc, this.bitcoinNetwork);
+        if(wallet.getUtxoPool==null) throw new Error("Wallet needs to support the `getUtxoPool()` function!");
+
+        const walletUtxosPromise = wallet.getUtxoPool();
+        const bitcoinFeeRatePromise = options?.bitcoinFeeRate ?? wallet.getFeeRate();
+
+        const swap = await this.createFromBTCSwapNew(
+            dstToken.chainId, dstAddress, dstToken.address, null, false, undefined, {
+                ...options,
+                sourceWalletUtxos: walletUtxosPromise,
+                bitcoinFeeRate: bitcoinFeeRatePromise
+            }
+        );
+
+        return {
+            swap,
+            utxos: await walletUtxosPromise,
+            btcFeeRate: Math.max(swap.minimumBtcFeeRate, await bitcoinFeeRatePromise)
+        };
+    }
+
     /**
      * Returns all swaps
      */

package/src/swaps/spv_swaps/SpvFromBTCSwap.ts

@@ -16,7 +16,7 @@ import {parsePsbtTransaction, toCoinselectAddressType, toOutputScript} from "../
 import {getInputType, Transaction} from "@scure/btc-signer";
 import {Buffer} from "buffer";
 import {Fee} from "../../types/fees/Fee";
-import {IBitcoinWallet, isIBitcoinWallet} from "../../bitcoin/wallet/IBitcoinWallet";
+import {BitcoinWalletUtxo, IBitcoinWallet, isIBitcoinWallet} from "../../bitcoin/wallet/IBitcoinWallet";
 import {IntermediaryAPI} from "../../intermediaries/apis/IntermediaryAPI";
 import {IBTCWalletSwap} from "../IBTCWalletSwap";
 import {ISwapWithGasDrop} from "../ISwapWithGasDrop";
@@ -877,11 +877,17 @@ export class SpvFromBTCSwap<T extends ChainType>
      * @param _bitcoinWallet Sender's bitcoin wallet
      * @param feeRate Optional fee rate in sats/vB for the transaction
      * @param additionalOutputs additional outputs to add to the PSBT - can be used to collect fees from users
+     * @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)
      */
     async getFundedPsbt(
         _bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface,
         feeRate?: number,
-        additionalOutputs?: ({amount: bigint, outputScript: Uint8Array} | {amount: bigint, address: string})[]
+        additionalOutputs?: ({amount: bigint, outputScript: Uint8Array} | {amount: bigint, address: string})[],
+        utxos?: BitcoinWalletUtxo[],
+        spendFully?: boolean
     ): Promise<{
         psbt: Transaction,
         psbtHex: string,
@@ -901,7 +907,7 @@ export class SpvFromBTCSwap<T extends ChainType>
                 script: (output as {outputScript: Uint8Array}).outputScript ?? toOutputScript(this.wrapper._options.bitcoinNetwork, (output as {address: string}).address)
             });
         });
-        psbt = await bitcoinWallet.fundPsbt(psbt, feeRate);
+        psbt = await bitcoinWallet.fundPsbt(psbt, feeRate, utxos, spendFully);
         psbt.updateInput(1, {sequence: in1sequence});
         //Sign every input except the first one
         const signInputs: number[] = [];
@@ -1024,8 +1030,13 @@ export class SpvFromBTCSwap<T extends ChainType>
     /**
      * @inheritDoc
      */
-    async sendBitcoinTransaction(wallet: IBitcoinWallet | MinimalBitcoinWalletInterfaceWithSigner, feeRate?: number): Promise<string> {
-        const {psbt, psbtBase64, psbtHex, signInputs} = await this.getFundedPsbt(wallet, feeRate);
+    async sendBitcoinTransaction(
+        wallet: IBitcoinWallet | MinimalBitcoinWalletInterfaceWithSigner,
+        feeRate?: number,
+        utxos?: BitcoinWalletUtxo[],
+        spendFully?: boolean
+    ): Promise<string> {
+        const {psbt, psbtBase64, psbtHex, signInputs} = await this.getFundedPsbt(wallet, feeRate, undefined, utxos, spendFully);
         let signedPsbt: Transaction | string;
         if(isIBitcoinWallet(wallet)) {
             signedPsbt = await wallet.signPsbt(psbt, signInputs);
@@ -1060,7 +1071,9 @@ export class SpvFromBTCSwap<T extends ChainType>
             feeRate?: number,
             abortSignal?: AbortSignal,
             btcTxCheckIntervalSeconds?: number,
-            maxWaitTillAutomaticSettlementSeconds?: number
+            maxWaitTillAutomaticSettlementSeconds?: number,
+            utxos?: BitcoinWalletUtxo[],
+            spendFully?: boolean
         }
     ): Promise<boolean> {
         if(this._state===SpvFromBTCSwapState.CLOSED) throw new Error("Swap encountered a catastrophic failure!");
@@ -1070,7 +1083,7 @@ export class SpvFromBTCSwap<T extends ChainType>
         if(this._state===SpvFromBTCSwapState.CLAIMED || this._state===SpvFromBTCSwapState.FRONTED) throw new Error("Swap already settled or fronted!");
 
         if(this._state===SpvFromBTCSwapState.CREATED) {
-            const txId = await this.sendBitcoinTransaction(wallet, options?.feeRate);
+            const txId = await this.sendBitcoinTransaction(wallet, options?.feeRate, options?.utxos, options?.spendFully);
             if(callbacks?.onSourceTransactionSent!=null) callbacks.onSourceTransactionSent(txId);
         }
         if(this._state===SpvFromBTCSwapState.POSTED || this._state===SpvFromBTCSwapState.BROADCASTED) {