@atomiqlabs/sdk 8.7.7 → 8.9.0

package/dist/swaps/spv_swaps/SpvFromBTCSwap.js

@@ -9,7 +9,6 @@ const BitcoinUtils_1 = require("../../utils/BitcoinUtils");
 const btc_signer_1 = require("@scure/btc-signer");
 const buffer_1 = require("buffer");
 const IBitcoinWallet_1 = require("../../bitcoin/wallet/IBitcoinWallet");
-const IntermediaryAPI_1 = require("../../intermediaries/apis/IntermediaryAPI");
 const FeeType_1 = require("../../enums/FeeType");
 const PercentagePPM_1 = require("../../types/fees/PercentagePPM");
 const TokenAmount_1 = require("../../types/TokenAmount");
@@ -334,7 +333,7 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
      * @inheritDoc
      */
     isFinished() {
-        return this._state === SpvFromBTCSwapState.CLAIMED || this._state === SpvFromBTCSwapState.QUOTE_EXPIRED || this._state === SpvFromBTCSwapState.FAILED;
+        return this.isSuccessful() || this.isFailed() || this.isQuoteExpired();
     }
     /**
      * @inheritDoc
@@ -588,7 +587,8 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
     /**
      * Returns the raw PSBT (not funded), the wallet should fund the PSBT (add its inputs) and importantly **set the nSequence field of the
      *  2nd input** (input 1 - indexing from 0) to the value returned in `in1sequence`, sign the PSBT and then pass
-     *  it back to the swap with {@link submitPsbt} function.
+     *  it back to the swap with {@link submitPsbt} function. The transaction should use at least the returned `feeRate`
+     *  sats/vB as the transaction fee.
      */
     async getPsbt() {
         const res = await this.getTransactionDetails();
@@ -623,7 +623,8 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
             psbt,
             psbtHex: serializedPsbt.toString("hex"),
             psbtBase64: serializedPsbt.toString("base64"),
-            in1sequence: res.in1sequence
+            in1sequence: res.in1sequence,
+            feeRate: this.minimumBtcFeeRate
         };
     }
     /**
@@ -637,8 +638,12 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
      * @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, feeRate, additionalOutputs) {
+    async getFundedPsbt(_bitcoinWallet, feeRate, additionalOutputs, utxos, spendFully) {
         const bitcoinWallet = (0, BitcoinWalletUtils_1.toBitcoinWallet)(_bitcoinWallet, this.wrapper._btcRpc, this.wrapper._options.bitcoinNetwork);
         if (feeRate != null) {
             if (feeRate < this.minimumBtcFeeRate)
@@ -655,7 +660,7 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
                     script: output.outputScript ?? (0, BitcoinUtils_1.toOutputScript)(this.wrapper._options.bitcoinNetwork, output.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 = [];
@@ -667,7 +672,8 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
             psbt,
             psbtHex: serializedPsbt.toString("hex"),
             psbtBase64: serializedPsbt.toString("base64"),
-            signInputs
+            signInputs,
+            feeRate
         };
     }
     /**
@@ -734,7 +740,7 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
         this.posted = true;
         await this._saveAndEmit(SpvFromBTCSwapState.SIGNED);
         try {
-            await IntermediaryAPI_1.IntermediaryAPI.initSpvFromBTC(this.chainIdentifier, this.url, {
+            await this.wrapper._lpApi.initSpvFromBTC(this.chainIdentifier, this.url, {
                 quoteId: this.quoteId,
                 psbtHex: buffer_1.Buffer.from(psbt.toPSBT(0)).toString("hex")
             });
@@ -759,8 +765,8 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
     /**
      * @inheritDoc
      */
-    async sendBitcoinTransaction(wallet, feeRate) {
-        const { psbt, psbtBase64, psbtHex, signInputs } = await this.getFundedPsbt(wallet, feeRate);
+    async sendBitcoinTransaction(wallet, feeRate, utxos, spendFully) {
+        const { psbt, psbtBase64, psbtHex, signInputs } = await this.getFundedPsbt(wallet, feeRate, undefined, utxos, spendFully);
         let signedPsbt;
         if ((0, IBitcoinWallet_1.isIBitcoinWallet)(wallet)) {
             signedPsbt = await wallet.signPsbt(psbt, signInputs);
@@ -795,7 +801,7 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
         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);
         }
@@ -816,32 +822,267 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
         throw new Error("Unexpected state reached!");
     }
     /**
-     * @inheritDoc
-     *
-     * @param options.bitcoinFeeRate Optional fee rate to use for the created Bitcoin transaction
-     * @param options.bitcoinWallet Optional bitcoin wallet address specification to return a funded PSBT,
-     *  if not provided a raw PSBT is returned instead which necessitates the implementor to manually add
-     *  inputs to the bitcoin transaction and **set the nSequence field of the 2nd input** (input 1 -
-     *  indexing from 0) to the value returned in `in1sequence`
+     * @internal
      */
-    async txsExecute(options) {
-        if (this._state === SpvFromBTCSwapState.CREATED) {
-            if (!await this._verifyQuoteValid())
-                throw new Error("Quote already expired or close to expiry!");
-            return [
+    async _getExecutionStatus(options) {
+        const state = this._state;
+        const now = Date.now();
+        let confirmations;
+        let bitcoinPaymentStatus = "inactive";
+        let destinationSettlementStatus = "inactive";
+        let buildCurrentAction = async () => undefined;
+        switch (state) {
+            case SpvFromBTCSwapState.QUOTE_EXPIRED:
+            case SpvFromBTCSwapState.DECLINED:
+            case SpvFromBTCSwapState.FAILED:
+                bitcoinPaymentStatus = "expired";
+                break;
+            case SpvFromBTCSwapState.CREATED: {
+                const quoteValid = await this._verifyQuoteValid();
+                bitcoinPaymentStatus = quoteValid ? "awaiting" : "soft_expired";
+                if (quoteValid) {
+                    buildCurrentAction = this._buildDepositPsbtAction.bind(this);
+                }
+                break;
+            }
+            case SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED:
+            case SpvFromBTCSwapState.SIGNED:
+            case SpvFromBTCSwapState.POSTED:
+            case SpvFromBTCSwapState.BROADCASTED:
+            case SpvFromBTCSwapState.FRONTED: {
+                const bitcoinPayment = await this.getBitcoinPayment();
+                let bitcoinConfirmationDelay = -1;
+                let knownBitcoinPaymentStatus;
+                if (bitcoinPayment != null) {
+                    if (bitcoinPayment.confirmations >= bitcoinPayment.targetConfirmations) {
+                        knownBitcoinPaymentStatus = "confirmed";
+                    }
+                    else {
+                        const result = await this.wrapper._btcRpc.getConfirmationDelay(bitcoinPayment.btcTx, bitcoinPayment.targetConfirmations);
+                        confirmations = {
+                            current: bitcoinPayment.confirmations,
+                            target: bitcoinPayment.targetConfirmations,
+                            etaSeconds: result ?? -1
+                        };
+                        knownBitcoinPaymentStatus = "received";
+                        bitcoinConfirmationDelay = result ?? -1;
+                    }
+                }
+                if (state === SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED)
+                    bitcoinPaymentStatus = knownBitcoinPaymentStatus ?? "soft_expired";
+                if (state === SpvFromBTCSwapState.POSTED || state === SpvFromBTCSwapState.SIGNED)
+                    bitcoinPaymentStatus = knownBitcoinPaymentStatus ?? "awaiting";
+                if (state === SpvFromBTCSwapState.BROADCASTED)
+                    bitcoinPaymentStatus = knownBitcoinPaymentStatus ?? "received";
+                destinationSettlementStatus = "inactive";
+                if (state === SpvFromBTCSwapState.FRONTED) {
+                    bitcoinPaymentStatus = knownBitcoinPaymentStatus ?? "received";
+                    destinationSettlementStatus = "settled";
+                }
+                if (state === SpvFromBTCSwapState.SIGNED ||
+                    state === SpvFromBTCSwapState.POSTED ||
+                    state === SpvFromBTCSwapState.BROADCASTED) {
+                    buildCurrentAction = this._buildWaitBitcoinConfirmationsAction.bind(this, bitcoinConfirmationDelay);
+                }
+                break;
+            }
+            case SpvFromBTCSwapState.BTC_TX_CONFIRMED:
+                bitcoinPaymentStatus = "confirmed";
+                if (this.btcTxConfirmedAt == null ||
+                    options?.maxWaitTillAutomaticSettlementSeconds === 0 ||
+                    (now - this.btcTxConfirmedAt) > (options?.maxWaitTillAutomaticSettlementSeconds ?? 60) * 1000) {
+                    destinationSettlementStatus = "awaiting_manual";
+                    buildCurrentAction = this._buildClaimSmartChainTxAction.bind(this);
+                }
+                else {
+                    destinationSettlementStatus = "awaiting_automatic";
+                    buildCurrentAction = this._buildWaitSettlementAction.bind(this, options?.maxWaitTillAutomaticSettlementSeconds);
+                }
+                break;
+            case SpvFromBTCSwapState.CLAIMED:
+                bitcoinPaymentStatus = "confirmed";
+                destinationSettlementStatus = "settled";
+                break;
+            case SpvFromBTCSwapState.CLOSED:
+                bitcoinPaymentStatus = "confirmed";
+                destinationSettlementStatus = "expired";
+                break;
+        }
+        if (bitcoinPaymentStatus === "confirmed") {
+            confirmations = {
+                current: this.getRequiredConfirmationsCount(),
+                target: this.getRequiredConfirmationsCount(),
+                etaSeconds: 0
+            };
+        }
+        return {
+            steps: [
                 {
-                    name: "Payment",
-                    description: "Send funds to the bitcoin swap address",
+                    type: "Payment",
+                    side: "source",
                     chain: "BITCOIN",
-                    txs: [
-                        options?.bitcoinWallet == null
-                            ? { ...await this.getPsbt(), type: "RAW_PSBT" }
-                            : { ...await this.getFundedPsbt(options.bitcoinWallet, options?.bitcoinFeeRate), type: "FUNDED_PSBT" }
-                    ]
+                    title: "Bitcoin payment",
+                    description: "Sign and submit the Bitcoin swap PSBT, then wait for the bitcoin transaction to confirm",
+                    status: bitcoinPaymentStatus,
+                    confirmations,
+                    initTxId: this._data?.btcTx?.txid,
+                    settleTxId: bitcoinPaymentStatus === "confirmed" ? this._data?.btcTx?.txid : undefined
+                },
+                {
+                    type: "Settlement",
+                    side: "destination",
+                    chain: this.chainIdentifier,
+                    title: "Destination settlement",
+                    description: `Wait for automatic settlement on the ${this.chainIdentifier} side, or settle manually if it takes too long`,
+                    status: destinationSettlementStatus,
+                    initTxId: this._frontTxId ?? this._claimTxId,
+                    settleTxId: this._frontTxId ?? this._claimTxId
+                }
+            ],
+            buildCurrentAction,
+            state
+        };
+    }
+    /**
+     * @inheritDoc
+     * @internal
+     */
+    async _submitExecutionTransactions(txs, abortSignal, requiredStates, idempotent) {
+        if (txs.length === 0)
+            throw new Error("Need to submit at least 1 transaction in the array, submitted empty array of transactions!");
+        // Handle idempotent calls
+        if (idempotent) {
+            let idempotencyTriggered = false;
+            const txIds = [];
+            for (let tx of txs) {
+                let parsedTx;
+                if (typeof (tx) === "string") {
+                    try {
+                        parsedTx = await this.wrapper._chain.deserializeSignedTx(tx);
+                    }
+                    catch (e) { }
+                    try {
+                        parsedTx = (0, BitcoinUtils_1.parsePsbtTransaction)(tx);
+                    }
+                    catch (e) { }
+                }
+                else {
+                    parsedTx = tx;
                 }
-            ];
+                if (parsedTx == null) {
+                    this.logger.debug("_submitExecutionTransactions(): Failed to parse provided execution transaction: ", tx);
+                    continue;
+                }
+                if (parsedTx instanceof btc_signer_1.Transaction) {
+                    // Bitcoin tx
+                    const btcTx = await this.wrapper._btcRpc.parseTransaction(buffer_1.Buffer.from(parsedTx.toBytes(true)).toString("hex"));
+                    if (btcTx.txid === this._data?.getTxId()) {
+                        if (this._state !== SpvFromBTCSwapState.SIGNED && this._state !== SpvFromBTCSwapState.DECLINED)
+                            idempotencyTriggered = true;
+                    }
+                    txIds.push(btcTx.txid);
+                }
+                else {
+                    // SC tx
+                    if (this.wrapper._chain.getTxId != null) {
+                        const txId = await this.wrapper._chain.getTxId(parsedTx);
+                        if (this._claimTxId === txId)
+                            idempotencyTriggered = true;
+                        txIds.push(txId);
+                    }
+                }
+            }
+            if (idempotencyTriggered)
+                return txIds;
+        }
+        if (requiredStates != null && !requiredStates.includes(this._state))
+            throw new Error("Swap state has changed before transactions were submitted!");
+        if (this._state === SpvFromBTCSwapState.CREATED || this._state === SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED) {
+            let psbt;
+            if (txs.length !== 1)
+                throw new Error("Need to submit exactly 1 signed PSBT!");
+            if (typeof (txs[0]) !== "string" && !(txs[0] instanceof btc_signer_1.Transaction))
+                throw new Error("Must submit a valid PSBT as hex/base64 string or `@scure/btc-signer` Transaction object!");
+            psbt = txs[0];
+            return [await this.submitPsbt(psbt)];
+        }
+        if (this._state === SpvFromBTCSwapState.BTC_TX_CONFIRMED) {
+            const parsedTxs = [];
+            for (let tx of txs) {
+                parsedTxs.push(typeof (tx) === "string" ? await this.wrapper._chain.deserializeSignedTx(tx) : tx);
+            }
+            const txIds = await this.wrapper._chain.sendSignedAndConfirm(parsedTxs, true, abortSignal, false);
+            await this.waitTillClaimed(undefined, abortSignal);
+            return txIds;
         }
-        throw new Error("Invalid swap state to obtain execution txns, required CREATED");
+        throw new Error("Invalid swap state for transaction submission!");
+    }
+    /**
+     * @internal
+     */
+    async _buildDepositPsbtAction(actionOptions) {
+        return {
+            type: "SignPSBT",
+            name: "Deposit on Bitcoin",
+            description: "Send funds to the bitcoin swap address",
+            chain: "BITCOIN",
+            txs: [
+                actionOptions?.bitcoinWallet == null
+                    ? { ...await this.getPsbt(), type: "RAW_PSBT" }
+                    : { ...await this.getFundedPsbt(actionOptions.bitcoinWallet, actionOptions?.bitcoinFeeRate), type: "FUNDED_PSBT" }
+            ],
+            submitPsbt: async (signedPsbt, idempotent) => {
+                return this._submitExecutionTransactions(Array.isArray(signedPsbt) ? signedPsbt : [signedPsbt], undefined, [SpvFromBTCSwapState.CREATED, SpvFromBTCSwapState.QUOTE_SOFT_EXPIRED], idempotent);
+            }
+        };
+    }
+    /**
+     * @internal
+     */
+    async _buildWaitBitcoinConfirmationsAction(confirmationDelay) {
+        return {
+            type: "Wait",
+            name: "Bitcoin confirmations",
+            description: "Wait for bitcoin transaction to confirm",
+            pollTimeSeconds: 10,
+            expectedTimeSeconds: confirmationDelay === -1 ? -1 : Math.floor(confirmationDelay / 1000),
+            wait: async (maxWaitTimeSeconds, pollIntervalSeconds, abortSignal, btcConfirmationsCallback) => {
+                const abortController = (0, Utils_1.extendAbortController)(abortSignal, maxWaitTimeSeconds, "Timed out waiting for bitcoin transaction");
+                await this.waitForBitcoinTransaction(btcConfirmationsCallback, pollIntervalSeconds, abortController.signal);
+            }
+        };
+    }
+    /**
+     * @internal
+     */
+    async _buildWaitSettlementAction(maxWaitTillAutomaticSettlementSeconds) {
+        return {
+            type: "Wait",
+            name: "Automatic settlement",
+            description: "Wait for bitcoin transaction to confirm",
+            pollTimeSeconds: 5,
+            expectedTimeSeconds: 10,
+            wait: async (maxWaitTimeSeconds, pollIntervalSeconds, abortSignal) => {
+                await this.waitTillClaimedOrFronted(maxWaitTimeSeconds ?? maxWaitTillAutomaticSettlementSeconds ?? 60, abortSignal, pollIntervalSeconds);
+            }
+        };
+    }
+    /**
+     * @internal
+     */
+    async _buildClaimSmartChainTxAction(actionOptions) {
+        const signerAddress = await this.wrapper._getSignerAddress(actionOptions?.manualSettlementSmartChainSigner);
+        return {
+            type: "SignSmartChainTransaction",
+            name: "Settle manually",
+            description: "Manually settle the swap on the destination smart chain",
+            chain: this.chainIdentifier,
+            txs: await this.prepareTransactions(this.txsClaim(actionOptions?.manualSettlementSmartChainSigner)),
+            submitTransactions: async (txs, abortSignal, idempotent) => {
+                return this._submitExecutionTransactions(txs, abortSignal, [SpvFromBTCSwapState.BTC_TX_CONFIRMED], idempotent);
+            },
+            requiredSigner: signerAddress ?? this._getInitiator()
+        };
     }
     /**
      * @inheritDoc
@@ -855,26 +1096,26 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
      * @param options.maxWaitTillAutomaticSettlementSeconds Maximum time to wait for an automatic settlement after
      *  the bitcoin transaction is confirmed (defaults to 60 seconds)
      */
-    async getCurrentActions(options) {
-        if (this._state === SpvFromBTCSwapState.CREATED) {
-            try {
-                return await this.txsExecute(options);
-            }
-            catch (e) { }
-        }
-        if (this._state === SpvFromBTCSwapState.BTC_TX_CONFIRMED) {
-            if (this.btcTxConfirmedAt == null ||
-                options?.maxWaitTillAutomaticSettlementSeconds === 0 ||
-                (Date.now() - this.btcTxConfirmedAt) > (options?.maxWaitTillAutomaticSettlementSeconds ?? 60) * 1000) {
-                return [{
-                        name: "Claim",
-                        description: "Manually settle (claim) the swap on the destination smart chain",
-                        chain: this.chainIdentifier,
-                        txs: await this.txsClaim(options?.manualSettlementSmartChainSigner)
-                    }];
-            }
-        }
-        return [];
+    async getExecutionAction(options) {
+        const executionStatus = await this._getExecutionStatus(options);
+        return executionStatus.buildCurrentAction(options);
+    }
+    /**
+     * @inheritDoc
+     */
+    async getExecutionStatus(options) {
+        const executionStatus = await this._getExecutionStatus(options);
+        return {
+            steps: executionStatus.steps,
+            currentAction: options?.skipBuildingAction ? undefined : await executionStatus.buildCurrentAction(options),
+            stateInfo: this._getStateInfo(executionStatus.state)
+        };
+    }
+    /**
+     * @inheritDoc
+     */
+    async getExecutionSteps(options) {
+        return (await this._getExecutionStatus(options)).steps;
     }
     //////////////////////////////
     //// Bitcoin tx listener
@@ -892,6 +1133,7 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
             txId: result.txid,
             confirmations: result.confirmations ?? 0,
             targetConfirmations: this.vaultRequiredConfirmations,
+            btcTx: result,
             inputAddresses: result.inputAddresses
         };
     }
@@ -1049,11 +1291,11 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
     /**
      * Periodically checks the chain to see whether the swap was finished (claimed or refunded)
      *
-     * @param abortSignal
      * @param interval How often to check (in seconds), default to 5s
+     * @param abortSignal
      * @internal
      */
-    async watchdogWaitTillResult(abortSignal, interval = 5) {
+    async watchdogWaitTillResult(interval = 5, abortSignal) {
         if (this._data == null)
             throw new Error("Cannot await the result before the btc transaction is sent!");
         let status = { type: base_1.SpvWithdrawalStateType.NOT_FOUND };
@@ -1095,11 +1337,12 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
      * @param maxWaitTimeSeconds Maximum time in seconds to wait for the swap to be settled (by default
      *  it waits indefinitely)
      * @param abortSignal Abort signal
+     * @param pollIntervalSeconds How often to poll via the watchdog
      *
      * @returns {boolean} whether the swap was claimed or fronted automatically or not, if the swap was not claimed
      *  the user can claim manually through the {@link claim} function
      */
-    async waitTillClaimedOrFronted(maxWaitTimeSeconds, abortSignal) {
+    async waitTillClaimedOrFronted(maxWaitTimeSeconds, abortSignal, pollIntervalSeconds) {
         if (this._state === SpvFromBTCSwapState.CLAIMED || this._state === SpvFromBTCSwapState.FRONTED)
             return Promise.resolve(true);
         const abortController = (0, Utils_1.extendAbortController)(abortSignal);
@@ -1114,7 +1357,7 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
         let res;
         try {
             res = await Promise.race([
-                this.watchdogWaitTillResult(abortController.signal),
+                this.watchdogWaitTillResult(pollIntervalSeconds, abortController.signal),
                 this.waitTillState(SpvFromBTCSwapState.CLAIMED, "eq", abortController.signal).then(() => 0),
                 this.waitTillState(SpvFromBTCSwapState.FRONTED, "eq", abortController.signal).then(() => 1),
                 this.waitTillState(SpvFromBTCSwapState.FAILED, "eq", abortController.signal).then(() => 2),

package/dist/swaps/spv_swaps/SpvFromBTCWrapper.d.ts

@@ -9,11 +9,13 @@ import { UnifiedSwapEventListener } from "../../events/UnifiedSwapEventListener"
 import { ISwapPrice } from "../../prices/abstract/ISwapPrice";
 import { EventEmitter } from "events";
 import { Intermediary } from "../../intermediaries/Intermediary";
+import { IntermediaryAPI } from "../../intermediaries/apis/IntermediaryAPI";
+import { CoinselectAddressTypes } from "../../bitcoin/coinselect2";
 import { Transaction } from "@scure/btc-signer";
 import { ISwap } from "../ISwap";
 import { IClaimableSwapWrapper } from "../IClaimableSwapWrapper";
-import { AmountData } from "../../types/AmountData";
 import { AllOptional } from "../../utils/TypeUtils";
+import { BitcoinWalletUtxoBase } from "../../bitcoin/wallet/IBitcoinWallet";
 export type SpvFromBTCOptions = {
     /**
      * Optional additional native token to receive as an output of the swap (e.g. STRK on Starknet or cBTC on Citrea).
@@ -53,6 +55,16 @@ export type SpvFromBTCOptions = {
      *  whitelist-only wallets
      */
     stickyAddress?: boolean;
+    /**
+     * A bitcoin wallet UTXOs to fully use as an input for this swap, use this option along with passing `amount` as
+     *  `undefined` when you want to swap the full BTC balance of the wallet in a single swap
+     */
+    sourceWalletUtxos?: BitcoinWalletUtxoBase[] | Promise<BitcoinWalletUtxoBase[]>;
+    /**
+     * Bitcoin fee rate to use when deriving `maxAllowedBitcoinFeeRate` and when calculating the input amount based
+     *  on the `sourceWalletUtxos`
+     */
+    bitcoinFeeRate?: Promise<number> | number;
     /**
      * @deprecated Use `maxAllowedBitcoinFeeRate` instead!
      */
@@ -68,6 +80,8 @@ export type SpvFromBTCWrapperOptions = ISwapWrapperOptions & {
     maxBtcFeeOffset: number;
 };
 export type SpvFromBTCTypeDefinition<T extends ChainType> = SwapTypeDefinition<T, SpvFromBTCWrapper<T>, SpvFromBTCSwap<T>>;
+export declare const REQUIRED_SPV_SWAP_VAULT_ADDRESS_TYPE: CoinselectAddressTypes;
+export declare const REQUIRED_SPV_SWAP_LP_ADDRESS_TYPE: CoinselectAddressTypes;
 /**
  * New spv vault (UTXO-controlled vault) based swaps for Bitcoin -> Smart chain swaps not requiring
  *  any initiation on the destination chain, and with the added possibility for the user to receive
@@ -125,6 +139,7 @@ export declare class SpvFromBTCWrapper<T extends ChainType> extends ISwapWrapper
      * @param versionedContracts
      * @param versionedSynchronizer
      * @param btcRpc Bitcoin RPC which also supports getting transactions by txoHash
+     * @param lpApi
      * @param options
      * @param events Instance to use for emitting events
      */
@@ -138,7 +153,7 @@ export declare class SpvFromBTCWrapper<T extends ChainType> extends ISwapWrapper
         [version: string]: {
             synchronizer: RelaySynchronizer<any, T["TX"], any>;
         };
-    }, btcRpc: BitcoinRpcWithAddressIndex<any>, options?: AllOptional<SpvFromBTCWrapperOptions>, events?: EventEmitter<{
+    }, btcRpc: BitcoinRpcWithAddressIndex<any>, lpApi: IntermediaryAPI, options?: AllOptional<SpvFromBTCWrapperOptions>, events?: EventEmitter<{
         swapState: [ISwap];
     }>);
     private processEventFront;
@@ -162,13 +177,25 @@ export declare class SpvFromBTCWrapper<T extends ChainType> extends ISwapWrapper
      *
      * @param amountData
      * @param options Options as passed to the swap creation function
-     * @param pricePrefetch
-     * @param nativeTokenPricePrefetch
      * @param abortController
      * @param contractVersion
      * @private
      */
-    private preFetchCallerFeeShare;
+    private preFetchCallerFeeInNativeToken;
+    /**
+     * Pre-fetches caller (watchtower) bounty data for the swap. Doesn't throw, instead returns null and aborts the
+     *  provided abortController
+     *
+     * @param amountPrefetch
+     * @param totalFeeInNativeTokenPrefetch
+     * @param amountData
+     * @param options Options as passed to the swap creation function
+     * @param pricePrefetch
+     * @param nativeTokenPricePrefetch
+     * @param abortSignal
+     * @private
+     */
+    private computeCallerFeeShare;
     /**
      * Verifies response returned from intermediary
      *
@@ -177,12 +204,15 @@ export declare class SpvFromBTCWrapper<T extends ChainType> extends ISwapWrapper
      * @param lp Intermediary
      * @param options Options as passed to the swap creation function
      * @param callerFeeShare
-     * @param bitcoinFeeRatePromise Maximum accepted fee rate from the LPs
+     * @param maxBitcoinFeeRatePromise Maximum accepted fee rate from the LPs
+     * @param bitcoinFeeRatePromise
      * @param abortSignal
      * @private
      * @throws {IntermediaryError} in case the response is invalid
      */
     private verifyReturnedData;
+    private amountPrefetch;
+    private bitcoinFeeRatePrefetch;
     /**
      * Returns a newly created Bitcoin -> Smart chain swap using the SPV vault (UTXO-controlled vault) swap protocol,
      *  with the passed amount. Also allows specifying additional "gas drop" native token that the receipient receives
@@ -195,7 +225,11 @@ export declare class SpvFromBTCWrapper<T extends ChainType> extends ISwapWrapper
      * @param additionalParams Optional additional parameters sent to the LP when creating the swap
      * @param abortSignal Abort signal
      */
-    create(recipient: string, amountData: AmountData, lps: Intermediary[], options?: SpvFromBTCOptions, additionalParams?: Record<string, any>, abortSignal?: AbortSignal): {
+    create(recipient: string, amountData: {
+        amount?: bigint;
+        token: string;
+        exactIn: boolean;
+    }, lps: Intermediary[], options?: SpvFromBTCOptions, additionalParams?: Record<string, any>, abortSignal?: AbortSignal): {
         quote: Promise<SpvFromBTCSwap<T>>;
         intermediary: Intermediary;
     }[];