@atomiqlabs/sdk 8.7.6 → 8.8.3

package/dist/swaps/spv_swaps/SpvFromBTCWrapper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SpvFromBTCWrapper = void 0;
+exports.SpvFromBTCWrapper = exports.REQUIRED_SPV_SWAP_LP_ADDRESS_TYPE = exports.REQUIRED_SPV_SWAP_VAULT_ADDRESS_TYPE = void 0;
 const ISwapWrapper_1 = require("../ISwapWrapper");
 const base_1 = require("@atomiqlabs/base");
 const SpvFromBTCSwap_1 = require("./SpvFromBTCSwap");
@@ -15,6 +15,10 @@ const IntermediaryError_1 = require("../../errors/IntermediaryError");
 const btc_signer_1 = require("@scure/btc-signer");
 const RetryUtils_1 = require("../../utils/RetryUtils");
 const UserError_1 = require("../../errors/UserError");
+const utils_2 = require("../../bitcoin/coinselect2/utils");
+const BitcoinWallet_1 = require("../../bitcoin/wallet/BitcoinWallet");
+exports.REQUIRED_SPV_SWAP_VAULT_ADDRESS_TYPE = "p2tr";
+exports.REQUIRED_SPV_SWAP_LP_ADDRESS_TYPE = "p2wpkh";
 /**
  * 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
@@ -209,26 +213,21 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
      *
      * @param amountData
      * @param options Options as passed to the swap creation function
-     * @param pricePrefetch
-     * @param nativeTokenPricePrefetch
      * @param abortController
      * @param contractVersion
      * @private
      */
-    async preFetchCallerFeeShare(amountData, options, pricePrefetch, nativeTokenPricePrefetch, abortController, contractVersion) {
+    async preFetchCallerFeeInNativeToken(amountData, options, abortController, contractVersion) {
         if (options.unsafeZeroWatchtowerFee)
             return 0n;
         if (amountData.amount === 0n)
             return 0n;
         try {
-            const [feePerBlock, btcRelayData, currentBtcBlock, claimFeeRate, nativeTokenPrice] = await Promise.all([
+            const [feePerBlock, btcRelayData, currentBtcBlock, claimFeeRate] = await Promise.all([
                 this.btcRelay(contractVersion).getFeePerBlock(),
                 this.btcRelay(contractVersion).getTipData(),
                 this._btcRpc.getTipHeight(),
-                this._contract(contractVersion).getClaimFee(this._chain.randomAddress()),
-                nativeTokenPricePrefetch ?? (amountData.token === this._chain.getNativeCurrencyAddress() ?
-                    pricePrefetch :
-                    this._prices.preFetchPrice(this.chainIdentifier, this._chain.getNativeCurrencyAddress(), abortController.signal))
+                this._contract(contractVersion).getClaimFee(this._chain.randomAddress())
             ]);
             if (btcRelayData == null)
                 throw new Error("Btc relay doesn't seem to be initialized!");
@@ -236,35 +235,58 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
             const blockDelta = Math.max(currentBtcBlock - currentBtcRelayBlock + this._options.maxConfirmations, 0);
             const totalFeeInNativeToken = ((BigInt(blockDelta) * feePerBlock) +
                 (claimFeeRate * BigInt(this._options.maxTransactionsDelta))) * BigInt(Math.floor(options.feeSafetyFactor * 1000000)) / 1000000n;
-            let payoutAmount;
-            if (amountData.exactIn) {
-                //Convert input amount in BTC to
-                const amountInNativeToken = await this._prices.getFromBtcSwapAmount(this.chainIdentifier, amountData.amount, this._chain.getNativeCurrencyAddress(), abortController.signal, nativeTokenPrice);
-                payoutAmount = amountInNativeToken - totalFeeInNativeToken;
-            }
-            else {
-                if (amountData.token === this._chain.getNativeCurrencyAddress()) {
-                    //Both amounts in same currency
-                    payoutAmount = amountData.amount;
-                }
-                else {
-                    //Need to convert both to native currency
-                    const btcAmount = await this._prices.getToBtcSwapAmount(this.chainIdentifier, amountData.amount, amountData.token, abortController.signal, await pricePrefetch);
-                    payoutAmount = await this._prices.getFromBtcSwapAmount(this.chainIdentifier, btcAmount, this._chain.getNativeCurrencyAddress(), abortController.signal, nativeTokenPrice);
-                }
-            }
-            this.logger.debug("preFetchCallerFeeShare(): Caller fee in native token: " + totalFeeInNativeToken.toString(10) + " total payout in native token: " + payoutAmount.toString(10));
-            const callerFeeShare = ((totalFeeInNativeToken * 100000n) + payoutAmount - 1n) / payoutAmount; //Make sure to round up here
-            if (callerFeeShare < 0n)
-                return 0n;
-            if (callerFeeShare >= 2n ** 20n)
-                return 2n ** 20n - 1n;
-            return callerFeeShare;
+            return totalFeeInNativeToken;
         }
         catch (e) {
             abortController.abort(e);
         }
     }
+    /**
+     * 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
+     */
+    async computeCallerFeeShare(amountPrefetch, totalFeeInNativeTokenPrefetch, amountData, options, pricePrefetch, nativeTokenPricePrefetch, abortSignal) {
+        if (options.unsafeZeroWatchtowerFee)
+            return 0n;
+        const amount = await (0, Utils_1.throwIfUndefined)(amountPrefetch, "Cannot get swap amount!");
+        if (amount === 0n)
+            return 0n;
+        const totalFeeInNativeToken = await (0, Utils_1.throwIfUndefined)(totalFeeInNativeTokenPrefetch, "Cannot get total fee in native token!");
+        const nativeTokenPrice = await nativeTokenPricePrefetch;
+        let payoutAmount;
+        if (amountData.exactIn) {
+            //Convert input amount in BTC to
+            const amountInNativeToken = await this._prices.getFromBtcSwapAmount(this.chainIdentifier, amount, this._chain.getNativeCurrencyAddress(), abortSignal, nativeTokenPrice);
+            payoutAmount = amountInNativeToken - totalFeeInNativeToken;
+        }
+        else {
+            if (amountData.token === this._chain.getNativeCurrencyAddress()) {
+                //Both amounts in same currency
+                payoutAmount = amount;
+            }
+            else {
+                //Need to convert both to native currency
+                const btcAmount = await this._prices.getToBtcSwapAmount(this.chainIdentifier, amount, amountData.token, abortSignal, await pricePrefetch);
+                payoutAmount = await this._prices.getFromBtcSwapAmount(this.chainIdentifier, btcAmount, this._chain.getNativeCurrencyAddress(), abortSignal, nativeTokenPrice);
+            }
+        }
+        this.logger.debug("computeCallerFeeShare(): Caller fee in native token: " + totalFeeInNativeToken.toString(10) + " total payout in native token: " + payoutAmount.toString(10));
+        const callerFeeShare = ((totalFeeInNativeToken * 100000n) + payoutAmount - 1n) / payoutAmount; //Make sure to round up here
+        if (callerFeeShare < 0n)
+            return 0n;
+        if (callerFeeShare >= 2n ** 20n)
+            return 2n ** 20n - 1n;
+        return callerFeeShare;
+    }
     /**
      * Verifies response returned from intermediary
      *
@@ -273,13 +295,14 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.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
      */
-    async verifyReturnedData(resp, amountData, lp, options, callerFeeShare, bitcoinFeeRatePromise, abortSignal) {
-        const btcFeeRate = await (0, Utils_1.throwIfUndefined)(bitcoinFeeRatePromise, "Bitcoin fee rate promise failed!");
+    async verifyReturnedData(resp, amountData, lp, options, callerFeeShare, maxBitcoinFeeRatePromise, bitcoinFeeRatePromise, abortSignal) {
+        const btcFeeRate = await (0, Utils_1.throwIfUndefined)(maxBitcoinFeeRatePromise, "Bitcoin fee rate promise failed!");
         abortSignal.throwIfAborted();
         if (btcFeeRate != null && resp.btcFeeRate > btcFeeRate)
             throw new IntermediaryError_1.IntermediaryError(`Required bitcoin fee rate returned from the LP is too high! Maximum accepted: ${btcFeeRate} sats/vB, required by LP: ${resp.btcFeeRate} sats/vB`);
@@ -288,11 +311,13 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
         let vaultScript;
         let vaultAddressType;
         let btcAddressScript;
+        let btcAddressType;
         //Ensure valid btc addresses returned
         try {
             vaultScript = (0, BitcoinUtils_1.toOutputScript)(this._options.bitcoinNetwork, resp.vaultBtcAddress);
             vaultAddressType = (0, BitcoinUtils_1.toCoinselectAddressType)(vaultScript);
             btcAddressScript = (0, BitcoinUtils_1.toOutputScript)(this._options.bitcoinNetwork, resp.btcAddress);
+            btcAddressType = (0, BitcoinUtils_1.toCoinselectAddressType)(btcAddressScript);
         }
         catch (e) {
             throw new IntermediaryError_1.IntermediaryError("Invalid btc address data returned", e);
@@ -302,7 +327,8 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
             resp.vaultId < 0n || //Ensure vaultId is not negative
             vaultScript == null || //Make sure vault script is parsable and of known type
             btcAddressScript == null || //Make sure btc address script is parsable and of known type
-            vaultAddressType === "p2pkh" || vaultAddressType === "p2sh-p2wpkh" || //Constrain the vault script type to witness types
+            btcAddressType !== exports.REQUIRED_SPV_SWAP_LP_ADDRESS_TYPE || //Constrain the btc address script type
+            vaultAddressType !== exports.REQUIRED_SPV_SWAP_VAULT_ADDRESS_TYPE || //Constrain the vault script type
             decodedUtxo.length !== 2 || decodedUtxo[0].length !== 64 || isNaN(parseInt(decodedUtxo[1])) || //Check valid UTXO
             resp.btcFeeRate < 1 || resp.btcFeeRate > 10000 //Sanity check on the returned BTC fee rate
         )
@@ -345,8 +371,24 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
                 const tokenData = vault.getTokenData();
                 //Amounts - make sure the amounts match
                 if (amountData.exactIn) {
-                    if (resp.btcAmount !== amountData.amount)
-                        throw new IntermediaryError_1.IntermediaryError("Invalid amount returned");
+                    if (!resp.usedUtxoInputCalculation) {
+                        //Legacy calculation
+                        if (resp.btcAmount !== amountData.amount)
+                            throw new IntermediaryError_1.IntermediaryError("Invalid amount returned");
+                    }
+                    else {
+                        //Implies the raw UTXOs were passed for amount derivation
+                        //Verify the derivation was done correctly
+                        if (options.sourceWalletUtxos == null)
+                            throw new IntermediaryError_1.IntermediaryError("Invalid usedUtxoInputCalcuation return value");
+                        if (bitcoinFeeRatePromise == null)
+                            throw new Error("bitcoinFeeRatePromise must be passed for UTXO-based input amount calculation checks");
+                        const walletUtxos = await options.sourceWalletUtxos;
+                        const bitcoinFeeRate = await (0, Utils_1.throwIfUndefined)(bitcoinFeeRatePromise, "Failed to fetch bitcoin fee rate!");
+                        const { balance } = BitcoinWallet_1.BitcoinWallet.getSpendableBalance(walletUtxos, Math.max(resp.btcFeeRate, bitcoinFeeRate), this.getDummySwapPsbt(options.gasAmount !== 0n), exports.REQUIRED_SPV_SWAP_LP_ADDRESS_TYPE);
+                        if (resp.btcAmount !== balance)
+                            throw new IntermediaryError_1.IntermediaryError(`Invalid amount returned, expected: ${balance.toString(10)}, got: ${resp.btcAmount.toString(10)}`);
+                    }
                 }
                 else {
                     //Check the difference between amount adjusted due to scaling to raw amount
@@ -447,6 +489,58 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
             vaultUtxoValue
         };
     }
+    async amountPrefetch(amountData, bitcoinFeeRatePromise, walletUtxosPromise, includeGas, abortController) {
+        if (amountData.amount != null)
+            return amountData.amount;
+        try {
+            const bitcoinFeeRate = await (0, Utils_1.throwIfUndefined)(bitcoinFeeRatePromise, "Cannot fetch Bitcoin fee rate!");
+            if (walletUtxosPromise == null)
+                throw new UserError_1.UserError("Cannot use empty amount without passing UTXOs!");
+            const walletUtxos = await walletUtxosPromise;
+            if (walletUtxos.length === 0)
+                throw new UserError_1.UserError("Wallet doesn't have any BTC balance");
+            const spendableBalance = await BitcoinWallet_1.BitcoinWallet.getSpendableBalance(walletUtxos, bitcoinFeeRate, this.getDummySwapPsbt(includeGas), exports.REQUIRED_SPV_SWAP_LP_ADDRESS_TYPE);
+            return spendableBalance.balance;
+        }
+        catch (e) {
+            abortController.abort(e);
+        }
+    }
+    bitcoinFeeRatePrefetch(options, abortController) {
+        let bitcoinFeeRatePromise;
+        if (options?.sourceWalletUtxos != null) {
+            if (options.bitcoinFeeRate != null) {
+                bitcoinFeeRatePromise = options.bitcoinFeeRate.then(value => {
+                    if (options.maxAllowedBitcoinFeeRate != Infinity && options.maxAllowedBitcoinFeeRate < value)
+                        throw new Error("Passed `maxAllowedBitcoinFeeRate` cannot be lower than `bitcoinFeeRate`");
+                    return value;
+                });
+            }
+            else {
+                bitcoinFeeRatePromise = this._btcRpc.getFeeRate().then(value => {
+                    if (options.maxAllowedBitcoinFeeRate != Infinity && value > options.maxAllowedBitcoinFeeRate)
+                        return options.maxAllowedBitcoinFeeRate;
+                    return value;
+                });
+            }
+            bitcoinFeeRatePromise = bitcoinFeeRatePromise.catch(e => {
+                abortController.abort(e);
+                return undefined;
+            });
+        }
+        const maxBitcoinFeeRatePromise = options.maxAllowedBitcoinFeeRate != Infinity
+            ? Promise.resolve(options.maxAllowedBitcoinFeeRate)
+            : (0, Utils_1.throwIfUndefined)(bitcoinFeeRatePromise ?? options.bitcoinFeeRate ?? this._btcRpc.getFeeRate())
+                .then(x => this._options.maxBtcFeeOffset + (x * this._options.maxBtcFeeMultiplier))
+                .catch(e => {
+                abortController.abort(e);
+                return undefined;
+            });
+        return {
+            bitcoinFeeRatePromise,
+            maxBitcoinFeeRatePromise
+        };
+    }
     /**
      * 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
@@ -464,13 +558,25 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
             gasAmount: this.parseGasAmount(options?.gasAmount),
             unsafeZeroWatchtowerFee: options?.unsafeZeroWatchtowerFee ?? false,
             feeSafetyFactor: options?.feeSafetyFactor ?? 1.25,
-            maxAllowedBitcoinFeeRate: options?.maxAllowedBitcoinFeeRate ?? options?.maxAllowedNetworkFeeRate ?? Infinity
+            maxAllowedBitcoinFeeRate: options?.maxAllowedBitcoinFeeRate ?? options?.maxAllowedNetworkFeeRate ?? Infinity,
+            sourceWalletUtxos: options?.sourceWalletUtxos == undefined
+                ? undefined
+                : options?.sourceWalletUtxos instanceof Promise ? options.sourceWalletUtxos : Promise.resolve(options.sourceWalletUtxos),
+            bitcoinFeeRate: options?.bitcoinFeeRate == undefined
+                ? undefined
+                : options?.bitcoinFeeRate instanceof Promise ? options.bitcoinFeeRate : Promise.resolve(options.bitcoinFeeRate),
         };
         if (_options.gasAmount !== 0n &&
             (this._chain.shouldGetNativeTokenDrop != null
                 ? !this._chain.shouldGetNativeTokenDrop(amountData.token)
                 : amountData.token === this._chain.getNativeCurrencyAddress()))
             throw new UserError_1.UserError("Cannot specify `gasAmount` for swaps to a native token!");
+        if (amountData.amount == null && options?.sourceWalletUtxos == null)
+            throw new UserError_1.UserError("Source wallet UTXOs need to be passed when amount is null!");
+        if (amountData.amount == null && !amountData.exactIn)
+            throw new UserError_1.UserError("Amount can be null only for exactIn swaps!");
+        if (amountData.amount != null && options?.sourceWalletUtxos != null)
+            throw new UserError_1.UserError("Source wallet UTXOs cannot be passed while specifying an input amount!");
         const lpVersions = Intermediary_1.Intermediary.getContractVersionsForLps(this.chainIdentifier, lps);
         const _abortController = (0, Utils_1.extendAbortController)(abortSignal);
         const pricePrefetchPromise = this.preFetchPrice(amountData, _abortController.signal);
@@ -481,14 +587,10 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
             undefined :
             this.preFetchPrice({ token: nativeTokenAddress }, _abortController.signal);
         const callerFeePrefetchPromise = (0, Utils_1.mapArrayToObject)(lpVersions, (contractVersion) => {
-            return this.preFetchCallerFeeShare(amountData, _options, pricePrefetchPromise, gasTokenPricePrefetchPromise, _abortController, contractVersion);
+            return this.preFetchCallerFeeInNativeToken(amountData, _options, _abortController, contractVersion);
         });
-        const bitcoinFeeRatePromise = _options.maxAllowedBitcoinFeeRate != Infinity ?
-            Promise.resolve(_options.maxAllowedBitcoinFeeRate) :
-            this._btcRpc.getFeeRate().then(x => this._options.maxBtcFeeOffset + (x * this._options.maxBtcFeeMultiplier)).catch(e => {
-                _abortController.abort(e);
-                return undefined;
-            });
+        const { maxBitcoinFeeRatePromise, bitcoinFeeRatePromise } = this.bitcoinFeeRatePrefetch(_options, _abortController);
+        const amountPromise = this.amountPrefetch(amountData, maxBitcoinFeeRatePromise, _options.sourceWalletUtxos, _options.gasAmount !== 0n, _abortController);
         return lps.map(lp => {
             return {
                 intermediary: lp,
@@ -497,29 +599,46 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
                         throw new Error("LP service for processing spv vault swaps not found!");
                     const version = lp.getContractVersion(this.chainIdentifier);
                     const abortController = (0, Utils_1.extendAbortController)(_abortController.signal);
+                    const callerFeeRatePromise = this.computeCallerFeeShare(amountPromise, callerFeePrefetchPromise[version], amountData, _options, pricePrefetchPromise, gasTokenPricePrefetchPromise, abortController.signal);
                     try {
                         const resp = await (0, RetryUtils_1.tryWithRetries)(async (retryCount) => {
                             return await IntermediaryAPI_1.IntermediaryAPI.prepareSpvFromBTC(this.chainIdentifier, lp.url, {
                                 address: recipient,
-                                amount: amountData.amount,
+                                amount: (0, Utils_1.throwIfUndefined)(amountPromise, "Failed to compute swap amount"),
                                 token: amountData.token.toString(),
                                 exactOut: !amountData.exactIn,
                                 gasToken: nativeTokenAddress,
                                 gasAmount: _options.gasAmount,
-                                callerFeeRate: (0, Utils_1.throwIfUndefined)(callerFeePrefetchPromise[version], "Caller fee prefetch failed!"),
+                                callerFeeRate: (0, Utils_1.throwIfUndefined)(callerFeeRatePromise, "Caller fee prefetch failed!"),
                                 frontingFeeRate: 0n,
                                 stickyAddress: options?.stickyAddress,
+                                amountUtxos: _options.sourceWalletUtxos != null
+                                    ? _options.sourceWalletUtxos.then(utxos => {
+                                        if (utxos.length === 0)
+                                            return undefined;
+                                        return utxos.map(utxo => ({
+                                            value: utxo.value,
+                                            vSize: utils_2.utils.inputBytes({ type: utxo.type }),
+                                            cpfp: utxo.cpfp == null ? undefined : { effectiveVSize: utxo.cpfp?.txVsize, effectiveFeeRate: utxo.cpfp?.txEffectiveFeeRate }
+                                        }));
+                                    })
+                                    : undefined,
+                                amountFeeRate: bitcoinFeeRatePromise,
                                 additionalParams
                             }, this._options.postRequestTimeout, abortController.signal, retryCount > 0 ? false : undefined);
                         }, undefined, e => e instanceof RequestError_1.RequestError, abortController.signal);
                         this.logger.debug("create(" + lp.url + "): LP response: ", resp);
-                        const callerFeeShare = (await callerFeePrefetchPromise[version]);
+                        const callerFeeShare = await callerFeeRatePromise;
+                        const amount = await (0, Utils_1.throwIfUndefined)(amountPromise);
                         const [pricingInfo, gasPricingInfo, { vault, vaultUtxoValue }] = await Promise.all([
                             this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.SPV_VAULT_FROM_BTC], false, resp.btcAmountSwap, resp.total * (100000n + callerFeeShare) / 100000n, amountData.token, { swapFeeBtc: resp.swapFeeBtc }, pricePrefetchPromise, usdPricePrefetchPromise, abortController.signal),
                             _options.gasAmount === 0n ? Promise.resolve(undefined) : this.verifyReturnedPrice({ ...lp.services[SwapType_1.SwapType.SPV_VAULT_FROM_BTC], swapBaseFee: 0 }, //Base fee should be charged only on the amount, not on gas
                             false, resp.btcAmountGas, resp.totalGas * (100000n + callerFeeShare) / 100000n, nativeTokenAddress, { swapFeeBtc: resp.gasSwapFeeBtc }, gasTokenPricePrefetchPromise, usdPricePrefetchPromise, abortController.signal),
-                            this.verifyReturnedData(resp, amountData, lp, _options, callerFeeShare, bitcoinFeeRatePromise, abortController.signal)
+                            this.verifyReturnedData(resp, { ...amountData, amount }, lp, _options, callerFeeShare, maxBitcoinFeeRatePromise, bitcoinFeeRatePromise, abortController.signal)
                         ]);
+                        let minimumBtcFeeRate = resp.btcFeeRate;
+                        if (bitcoinFeeRatePromise != null)
+                            minimumBtcFeeRate = Math.max(minimumBtcFeeRate, await (0, Utils_1.throwIfUndefined)(bitcoinFeeRatePromise));
                         const swapInit = {
                             pricingInfo,
                             url: lp.url,
@@ -540,7 +659,7 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
                             btcAmount: resp.btcAmount,
                             btcAmountSwap: resp.btcAmountSwap,
                             btcAmountGas: resp.btcAmountGas,
-                            minimumBtcFeeRate: resp.btcFeeRate,
+                            minimumBtcFeeRate,
                             outputTotalSwap: resp.total,
                             outputSwapToken: amountData.token,
                             outputTotalGas: resp.totalGas,
@@ -558,6 +677,12 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
                         return quote;
                     }
                     catch (e) {
+                        if (e instanceof RequestError_1.OutOfBoundsError) {
+                            const amountResult = await amountPromise.catch(() => undefined);
+                            if (_options.sourceWalletUtxos != null && amountResult != null && amountResult <= 0n) {
+                                e = new UserError_1.UserError("Wallet doesn't have enough BTC balance to cover transaction fees");
+                            }
+                        }
                         abortController.abort(e);
                         throw e;
                     }
@@ -682,7 +807,7 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
             allowLegacyWitnessUtxo: true,
             allowUnknownOutputs: true
         });
-        const randomVaultOutScript = btc_signer_1.OutScript.encode({ type: "tr", pubkey: Buffer.from("0101010101010101010101010101010101010101010101010101010101010101", "hex") });
+        const randomVaultOutScript = (0, BitcoinUtils_1.getDummyOutputScript)(exports.REQUIRED_SPV_SWAP_VAULT_ADDRESS_TYPE);
         psbt.addInput({
             txid: (0, Utils_1.randomBytes)(32),
             index: 0,

package/dist/utils/BitcoinUtils.d.ts

@@ -7,6 +7,8 @@ import { CoinselectAddressTypes } from "../bitcoin/coinselect2";
 export declare function fromOutputScript(network: BTC_NETWORK, outputScriptHex: string): string;
 export declare function toOutputScript(network: BTC_NETWORK, address: string): Buffer;
 export declare function toCoinselectAddressType(outputScript: Uint8Array): CoinselectAddressTypes;
+export declare function getDummyOutputScript(type: CoinselectAddressTypes): Uint8Array;
+export declare function getDummyAddress(network: BTC_NETWORK, type: CoinselectAddressTypes): string;
 /**
  * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
  * @param _psbt

package/dist/utils/BitcoinUtils.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePsbtTransaction = exports.toCoinselectAddressType = exports.toOutputScript = exports.fromOutputScript = void 0;
+exports.parsePsbtTransaction = exports.getDummyAddress = exports.getDummyOutputScript = exports.toCoinselectAddressType = exports.toOutputScript = exports.fromOutputScript = void 0;
 const utils_1 = require("@scure/btc-signer/utils");
 const buffer_1 = require("buffer");
 const btc_signer_1 = require("@scure/btc-signer");
+const Utils_1 = require("./Utils");
 function fromOutputScript(network, outputScriptHex) {
     return (0, btc_signer_1.Address)(network).encode(btc_signer_1.OutScript.decode(buffer_1.Buffer.from(outputScriptHex, "hex")));
 }
@@ -71,6 +72,44 @@ function toCoinselectAddressType(outputScript) {
     throw new Error("Unrecognized address type!");
 }
 exports.toCoinselectAddressType = toCoinselectAddressType;
+function getDummySpec(type) {
+    switch (type) {
+        case "p2pkh":
+            return {
+                type: "pkh",
+                hash: (0, Utils_1.randomBytes)(20)
+            };
+        case "p2sh-p2wpkh":
+            return {
+                type: "sh",
+                hash: (0, Utils_1.randomBytes)(20)
+            };
+        case "p2wpkh":
+            return {
+                type: "wpkh",
+                hash: (0, Utils_1.randomBytes)(20)
+            };
+        case "p2wsh":
+            return {
+                type: "wsh",
+                hash: (0, Utils_1.randomBytes)(32)
+            };
+        case "p2tr":
+            return {
+                type: "tr",
+                pubkey: buffer_1.Buffer.from("0101010101010101010101010101010101010101010101010101010101010101", "hex")
+            };
+    }
+    throw new Error("Unrecognized address type!");
+}
+function getDummyOutputScript(type) {
+    return btc_signer_1.OutScript.encode(getDummySpec(type));
+}
+exports.getDummyOutputScript = getDummyOutputScript;
+function getDummyAddress(network, type) {
+    return (0, btc_signer_1.Address)(network).encode(getDummySpec(type));
+}
+exports.getDummyAddress = getDummyAddress;
 /**
  * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
  * @param _psbt

package/dist/utils/BitcoinWalletUtils.d.ts

@@ -1,7 +1,7 @@
 import { IBitcoinWallet } from "../bitcoin/wallet/IBitcoinWallet";
 import { BTC_NETWORK } from "@scure/btc-signer/utils";
-import { BitcoinRpcWithAddressIndex } from "@atomiqlabs/base";
+import { BitcoinNetwork, BitcoinRpcWithAddressIndex } from "@atomiqlabs/base";
 export declare function toBitcoinWallet(_bitcoinWallet: IBitcoinWallet | {
     address: string;
     publicKey: string;
-}, btcRpc: BitcoinRpcWithAddressIndex<any>, bitcoinNetwork: BTC_NETWORK): IBitcoinWallet;
+}, btcRpc: BitcoinRpcWithAddressIndex<any>, bitcoinNetwork: BTC_NETWORK | BitcoinNetwork): IBitcoinWallet;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/sdk",
-  "version": "8.7.6",
+  "version": "8.8.3",
   "description": "atomiq labs SDK for cross-chain swaps between smart chains and bitcoin",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

package/src/bitcoin/coinselect2/accumulative.ts

@@ -15,9 +15,10 @@ export function accumulative (
 ): {
     inputs?: CoinselectTxInput[],
     outputs?: CoinselectTxOutput[],
+    effectiveFeeRate?: number,
     fee: number
 } {
-    if (!isFinite(utils.uintOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
+    if (!isFinite(utils.numberOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
 
     const inputs = requiredInputs==null ? [] : [...requiredInputs];
     let bytesAccum = utils.transactionBytes(inputs, outputs, type);

package/src/bitcoin/coinselect2/blackjack.ts

@@ -11,9 +11,10 @@ export function blackjack (
 ): {
     inputs?: CoinselectTxInput[],
     outputs?: CoinselectTxOutput[],
+    effectiveFeeRate?: number,
     fee: number
 } {
-    if (!isFinite(utils.uintOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
+    if (!isFinite(utils.numberOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
 
     const inputs = requiredInputs==null ? [] : [...requiredInputs];
     let bytesAccum = utils.transactionBytes(inputs, outputs, type);

package/src/bitcoin/coinselect2/index.ts

@@ -20,6 +20,7 @@ export function coinSelect (
 ): {
     inputs?: CoinselectTxInput[],
     outputs?: CoinselectTxOutput[],
+    effectiveFeeRate?: number,
     fee: number
 } {
     // order by descending value, minus the inputs approximate fee
@@ -38,16 +39,16 @@ export function coinSelect (
 }
 
 export function maxSendable (
-    utxos: CoinselectTxInput[],
+    utxos: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">[],
     output: {script: Buffer, type: CoinselectAddressTypes},
     feeRate: number,
-    requiredInputs?: CoinselectTxInput[],
+    requiredInputs?: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">[],
     additionalOutputs?: {script: Buffer, value: number}[],
 ): {
     value: number,
     fee: number
 } {
-    if (!isFinite(utils.uintOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
+    if (!isFinite(utils.numberOrNaN(feeRate))) throw new Error("Invalid feeRate passed!");
 
     const outputs = additionalOutputs ?? [];
     const inputs = requiredInputs ?? [];
@@ -61,7 +62,7 @@ export function maxSendable (
         const utxoBytes = utils.inputBytes(utxo);
         const utxoFee = feeRate * utxoBytes;
         let cpfpFee = 0;
-        if(utxo.cpfp!=null && utxo.cpfp.txEffectiveFeeRate<feeRate) cpfpFee = utxo.cpfp.txVsize*(feeRate - utxo.cpfp.txEffectiveFeeRate);
+        if(utxo.cpfp!=null && utxo.cpfp.txEffectiveFeeRate<feeRate) cpfpFee = Math.ceil(utxo.cpfp.txVsize*(feeRate - utxo.cpfp.txEffectiveFeeRate));
         const utxoValue = utils.uintOrNaN(utxo.value);
 
         // skip detrimental input

package/src/bitcoin/coinselect2/utils.ts

@@ -132,6 +132,13 @@ function transactionBytes (
     return Math.ceil(size);
 }
 
+function numberOrNaN(v: number): number {
+    if (typeof v !== 'number') return NaN;
+    if (!isFinite(v)) return NaN;
+    if (v < 0) return NaN;
+    return v;
+}
+
 function uintOrNaN(v: number): number {
   if (typeof v !== 'number') return NaN;
   if (!isFinite(v)) return NaN;
@@ -148,41 +155,73 @@ function sumOrNaN(range: {value: number}[]): number {
   return range.reduce((a, x)  => a + uintOrNaN(x.value), 0);
 }
 
-function finalize(
-    inputs: CoinselectTxInput[],
+function finalize<T extends Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">>(
+    inputs: T[],
     outputs: CoinselectTxOutput[],
     feeRate: number,
-    changeType: CoinselectAddressTypes,
+    changeType: CoinselectAddressTypes | null,
     cpfpAddFee: number = 0
 ): {
-    inputs?: CoinselectTxInput[],
+    inputs?: T[],
     outputs?: CoinselectTxOutput[],
+    effectiveFeeRate?: number,
     fee: number
 } {
-  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);
+  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 })
+      // 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)) return { fee: (feeRate * bytesAccum) + cpfpAddFee }
+  if (!isFinite(fee) || fee<0) return { fee: (feeRate * bytesAccum) + cpfpAddFee }
+
+  let txVSize = 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: number,
+    utxo: Omit<CoinselectTxInput, "txId" | "address" | "vout" | "outputScript">
+) {
+    const utxoBytes = 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;
+}
+
 export const utils = {
   dustThreshold: dustThreshold,
   finalize: finalize,
@@ -191,5 +230,7 @@ export const utils = {
   sumOrNaN: sumOrNaN,
   sumForgiving: sumForgiving,
   transactionBytes: transactionBytes,
-  uintOrNaN: uintOrNaN
+  uintOrNaN: uintOrNaN,
+  numberOrNaN: numberOrNaN,
+  isDetrimentalInput
 };