@atomiqlabs/sdk 8.7.1 → 8.7.3

package/dist/SmartChainAssets.d.ts

@@ -3,6 +3,16 @@
  * @category Tokens
  */
 export declare const SmartChainAssets: {
+    readonly _TESTNET_strkBTC: {
+        readonly pricing: {
+            readonly binancePair: "$fixed-100000000";
+            readonly okxPair: "$fixed-100000000";
+            readonly coinGeckoCoinId: "$fixed-100000000";
+            readonly coinPaprikaCoinId: "$fixed-100000000";
+            readonly krakenPair: "$fixed-100000000";
+        };
+        readonly name: "strkBTC (dev)";
+    };
     readonly _TESTNET_WBTC_VESU: {
         readonly pricing: {
             readonly binancePair: "WBTCBTC";
@@ -23,6 +33,16 @@ export declare const SmartChainAssets: {
         };
         readonly name: "pegBTC (dev)";
     };
+    readonly strkBTC: {
+        readonly pricing: {
+            readonly binancePair: "$fixed-100000000";
+            readonly okxPair: "$fixed-100000000";
+            readonly coinGeckoCoinId: "$fixed-100000000";
+            readonly coinPaprikaCoinId: "$fixed-100000000";
+            readonly krakenPair: "$fixed-100000000";
+        };
+        readonly name: "strkBTC";
+    };
     readonly WBTC: {
         readonly pricing: {
             readonly binancePair: "WBTCBTC";

package/dist/SmartChainAssets.js

@@ -6,6 +6,16 @@ exports.SmartChainAssets = void 0;
  * @category Tokens
  */
 exports.SmartChainAssets = {
+    _TESTNET_strkBTC: {
+        pricing: {
+            binancePair: "$fixed-100000000",
+            okxPair: "$fixed-100000000",
+            coinGeckoCoinId: "$fixed-100000000",
+            coinPaprikaCoinId: "$fixed-100000000",
+            krakenPair: "$fixed-100000000"
+        },
+        name: "strkBTC (dev)"
+    },
     _TESTNET_WBTC_VESU: {
         pricing: {
             binancePair: "WBTCBTC",
@@ -26,6 +36,16 @@ exports.SmartChainAssets = {
         },
         name: "pegBTC (dev)"
     },
+    strkBTC: {
+        pricing: {
+            binancePair: "$fixed-100000000",
+            okxPair: "$fixed-100000000",
+            coinGeckoCoinId: "$fixed-100000000",
+            coinPaprikaCoinId: "$fixed-100000000",
+            krakenPair: "$fixed-100000000"
+        },
+        name: "strkBTC"
+    },
     WBTC: {
         pricing: {
             binancePair: "WBTCBTC",

package/dist/bitcoin/wallet/SingleAddressBitcoinWallet.js

@@ -5,10 +5,12 @@ const utils_1 = require("@scure/btc-signer/utils");
 const btc_signer_1 = require("@scure/btc-signer");
 const buffer_1 = require("buffer");
 const BitcoinWallet_1 = require("./BitcoinWallet");
+const base_1 = require("@atomiqlabs/base");
 const bip32_1 = require("@scure/bip32");
 const bip39_1 = require("@scure/bip39");
 const english_js_1 = require("@scure/bip39/wordlists/english.js");
 const sha2_1 = require("@noble/hashes/sha2");
+const logger = (0, base_1.getLogger)("SingleAddressBitcoinWallet: ");
 /**
  * Bitcoin wallet implementation deriving a single address from a WIF encoded private key
  *
@@ -32,12 +34,24 @@ class SingleAddressBitcoinWallet extends BitcoinWallet_1.BitcoinWallet {
             if (address == null)
                 throw new Error("Failed to generate p2wpkh address from the provided private key!");
             this.address = address;
+            this.addressType = (0, BitcoinWallet_1.identifyAddressType)(this.address, network);
         }
         else {
             this.address = addressDataOrWIF.address;
+            this.addressType = (0, BitcoinWallet_1.identifyAddressType)(this.address, network);
             this.pubkey = buffer_1.Buffer.from(addressDataOrWIF.publicKey, "hex");
+            // Some wallets seem to be returning a full 33-byte compressed pubkey instead of a taproot
+            //  32-byte long X-only key. Handle these cases here
+            if (this.addressType === "p2tr") {
+                if (this.pubkey.length !== 33)
+                    return;
+                const leadingByte = this.pubkey[0];
+                if (leadingByte !== 0x03 && leadingByte !== 0x02)
+                    throw new Error("Invalid public key passed for taproot bitcoin wallet, expected an X-only 32-byte public key, or a compressed 33-byte public key");
+                logger.debug(`constructor(): Converting compressed public key ${addressDataOrWIF.publicKey} to taproot X-only 32-byte public key`);
+                this.pubkey = this.pubkey.slice(1);
+            }
         }
-        this.addressType = (0, BitcoinWallet_1.identifyAddressType)(this.address, network);
     }
     /**
      * Returns all the wallet addresses controlled by the wallet

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

@@ -244,6 +244,7 @@ export type SpvFromBTCPrepare = SwapInit & {
     exactOut: boolean;
     callerFeeRate: Promise<bigint>;
     frontingFeeRate: bigint;
+    stickyAddress?: boolean;
 };
 declare const SpvFromBTCInitResponseSchema: {
     readonly txId: FieldTypeEnum.String;

package/dist/intermediaries/apis/IntermediaryAPI.js

@@ -543,7 +543,8 @@ class IntermediaryAPI {
             gasAmount: init.gasAmount.toString(10),
             gasToken: init.gasToken,
             frontingFeeRate: init.frontingFeeRate.toString(10),
-            callerFeeRate: init.callerFeeRate.then(val => val.toString(10))
+            callerFeeRate: init.callerFeeRate.then(val => val.toString(10)),
+            stickyAddress: init.stickyAddress
         }, {
             code: SchemaVerifier_1.FieldTypeEnum.Number,
             msg: SchemaVerifier_1.FieldTypeEnum.String,

package/dist/prices/abstract/ISwapPrice.d.ts

@@ -64,8 +64,9 @@ export declare abstract class ISwapPrice<T extends MultiChain = MultiChain> {
      * @param tokenAddress Token address to be paid
      * @param abortSignal
      * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     * @param realSwapFeeSats
      */
-    isValidAmountSend<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, paidToken: bigint, tokenAddress: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null): Promise<PriceInfoType>;
+    isValidAmountSend<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, paidToken: bigint, tokenAddress: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null, realSwapFeeSats?: bigint): Promise<PriceInfoType>;
     /**
      * Recomputes pricing info without fetching the current price
      *
@@ -88,8 +89,9 @@ export declare abstract class ISwapPrice<T extends MultiChain = MultiChain> {
      * @param tokenAddress Token address to be received
      * @param abortSignal
      * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     * @param realSwapFeeSats
      */
-    isValidAmountReceive<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, tokenAddress: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null): Promise<PriceInfoType>;
+    isValidAmountReceive<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, tokenAddress: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null, realSwapFeeSats?: bigint): Promise<PriceInfoType>;
     /**
      * Pre-fetches the pricing data for a given token, such that further calls to {@link isValidAmountReceive} or
      *  {@link isValidAmountSend} are quicker and don't need to wait for the price fetch

package/dist/prices/abstract/ISwapPrice.js

@@ -59,10 +59,14 @@ class ISwapPrice {
      * @param tokenAddress Token address to be paid
      * @param abortSignal
      * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     * @param realSwapFeeSats
      */
-    async isValidAmountSend(chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, tokenAddress, abortSignal, preFetchedPrice) {
-        const totalSats = (amountSats * (1000000n + feePPM) / 1000000n)
-            + satsBaseFee;
+    async isValidAmountSend(chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, tokenAddress, abortSignal, preFetchedPrice, realSwapFeeSats) {
+        if (realSwapFeeSats != undefined && realSwapFeeSats < 0)
+            throw new Error("Invalid swap fee! Swap fee cannot be negative!");
+        const totalSats = realSwapFeeSats != undefined
+            ? amountSats + realSwapFeeSats
+            : (amountSats * (1000000n + feePPM) / 1000000n) + satsBaseFee;
         const totalUSats = totalSats * 1000000n;
         const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, tokenAddress))) / paidToken;
         if (this.shouldIgnore(chainIdentifier, tokenAddress))
@@ -122,10 +126,18 @@ class ISwapPrice {
      * @param tokenAddress Token address to be received
      * @param abortSignal
      * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     * @param realSwapFeeSats
      */
-    async isValidAmountReceive(chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, tokenAddress, abortSignal, preFetchedPrice) {
-        const totalSats = (amountSats * (1000000n - feePPM) / 1000000n)
-            - satsBaseFee;
+    async isValidAmountReceive(chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, tokenAddress, abortSignal, preFetchedPrice, realSwapFeeSats) {
+        if (realSwapFeeSats != undefined) {
+            if (realSwapFeeSats >= amountSats)
+                throw new Error("Invalid swap fee! Larger than or equal to total output amount!");
+            if (realSwapFeeSats < 0)
+                throw new Error("Invalid swap fee! Must be non-negative!");
+        }
+        const totalSats = realSwapFeeSats != undefined
+            ? amountSats - realSwapFeeSats
+            : (amountSats * (1000000n - feePPM) / 1000000n) - satsBaseFee;
         const totalUSats = totalSats * 1000000n;
         const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, tokenAddress))) / receiveToken;
         if (this.shouldIgnore(chainIdentifier, tokenAddress))

package/dist/swaps/ISwap.js

@@ -166,16 +166,21 @@ class ISwap {
         if (this.pricingInfo == null)
             return;
         const priceUsdPerBtc = this.pricingInfo.realPriceUsdPerBitcoin;
-        const input = this.getInput();
         const output = this.getOutput();
-        if (input.isUnknown || output.isUnknown)
+        if (output.isUnknown)
             return;
-        if ((0, Token_1.isSCToken)(input.token) && this.getDirection() === SwapDirection_1.SwapDirection.TO_BTC) {
-            this.pricingInfo = await this.wrapper._prices.isValidAmountSend(this.chainIdentifier, output.rawAmount, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, input.rawAmount, input.token.address);
+        if ((0, Token_1.isSCToken)(this.getInputToken()) && this.getDirection() === SwapDirection_1.SwapDirection.TO_BTC) {
+            const input = this.getInputWithoutFee();
+            if (input.isUnknown)
+                return;
+            this.pricingInfo = await this.wrapper._prices.isValidAmountSend(this.chainIdentifier, output.rawAmount, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, input.rawAmount + this.swapFee, input.token.address, undefined, undefined, this.swapFeeBtc);
             this.pricingInfo.realPriceUsdPerBitcoin = priceUsdPerBtc;
         }
         else if ((0, Token_1.isSCToken)(output.token) && this.getDirection() === SwapDirection_1.SwapDirection.FROM_BTC) {
-            this.pricingInfo = await this.wrapper._prices.isValidAmountReceive(this.chainIdentifier, input.rawAmount, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, output.rawAmount, output.token.address);
+            const input = this.getInput();
+            if (input.isUnknown)
+                return;
+            this.pricingInfo = await this.wrapper._prices.isValidAmountReceive(this.chainIdentifier, input.rawAmount, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, output.rawAmount, output.token.address, undefined, undefined, this.swapFeeBtc);
             this.pricingInfo.realPriceUsdPerBitcoin = priceUsdPerBtc;
         }
     }

package/dist/swaps/ISwapWrapper.d.ts

@@ -194,6 +194,7 @@ export declare abstract class ISwapWrapper<T extends ChainType, D extends SwapTy
         swapFeePPM: number;
     }, send: boolean, amountSats: bigint, amountToken: bigint, token: string, feeData: {
         networkFee?: bigint;
+        swapFeeBtc?: bigint;
     }, pricePrefetchPromise?: Promise<bigint | undefined>, usdPricePrefetchPromise?: Promise<number | undefined>, abortSignal?: AbortSignal): Promise<PriceInfoType>;
     /**
      * Processes a single smart chain on-chain event

package/dist/swaps/ISwapWrapper.js

@@ -114,8 +114,8 @@ class ISwapWrapper {
             amountToken = amountToken - feeData.networkFee;
         const [isValidAmount, usdPrice] = await Promise.all([
             send ?
-                this._prices.isValidAmountSend(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise) :
-                this._prices.isValidAmountReceive(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise),
+                this._prices.isValidAmountSend(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise, feeData.swapFeeBtc) :
+                this._prices.isValidAmountReceive(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise, feeData.swapFeeBtc),
             usdPricePrefetchPromise.then(value => {
                 if (value != null)
                     return value;

package/dist/swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper.js

@@ -221,10 +221,11 @@ class FromBTCLNWrapper extends IFromBTCLNWrapper_1.IFromBTCLNWrapper {
                     if (decodedPr.timeExpireDate == null)
                         throw new IntermediaryError_1.IntermediaryError("Invalid returned swap invoice, no expiry date field");
                     const amountIn = (BigInt(decodedPr.millisatoshis) + 999n) / 1000n;
+                    const swapFeeBtc = resp.swapFee * amountIn / (resp.total - resp.swapFee);
                     try {
                         this.verifyReturnedData(resp, amountData, lp, _options, decodedPr, paymentHash);
                         const [pricingInfo] = await Promise.all([
-                            this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.FROM_BTCLN], false, amountIn, resp.total, amountData.token, {}, _preFetches.pricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal),
+                            this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.FROM_BTCLN], false, amountIn, resp.total, amountData.token, { swapFeeBtc }, _preFetches.pricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal),
                             this.verifyIntermediaryLiquidity(resp.total, (0, Utils_1.throwIfUndefined)(liquidityPromise)),
                             lnCapacityPromise != null ? this.verifyLnNodeCapacity(lp, decodedPr, lnCapacityPromise, abortController.signal) : Promise.resolve()
                         ]);
@@ -233,7 +234,7 @@ class FromBTCLNWrapper extends IFromBTCLNWrapper_1.IFromBTCLNWrapper {
                             url: lp.url,
                             expiry: decodedPr.timeExpireDate * 1000,
                             swapFee: resp.swapFee,
-                            swapFeeBtc: resp.swapFee * amountIn / (resp.total - resp.swapFee),
+                            swapFeeBtc,
                             feeRate: (await _preFetches.feeRatePromise[version]),
                             initialSwapData: await this._contract(version).createSwapData(base_1.ChainSwapType.HTLC, lp.getAddress(this.chainIdentifier), recipient, amountData.token, resp.total, _hash[version], this.getRandomSequence(), BigInt(Math.floor(Date.now() / 1000)), false, true, resp.securityDeposit, 0n, nativeTokenAddress),
                             pr: resp.pr,

package/dist/swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoSwap.js

@@ -206,7 +206,7 @@ class FromBTCLNAutoSwap extends IEscrowSwap_1.IEscrowSwap {
         if (this.pricingInfo == null || this.btcAmountSwap == null)
             return;
         const usdPricePerBtc = this.pricingInfo.realPriceUsdPerBitcoin;
-        this.pricingInfo = await this.wrapper._prices.isValidAmountReceive(this.chainIdentifier, this.btcAmountSwap, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, this.getOutputAmountWithoutFee(), this.getSwapData().getToken());
+        this.pricingInfo = await this.wrapper._prices.isValidAmountReceive(this.chainIdentifier, this.btcAmountSwap, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, this.getOutputAmountWithoutFee(), this.getSwapData().getToken(), undefined, undefined, this.swapFeeBtc);
         this.pricingInfo.realPriceUsdPerBitcoin = usdPricePerBtc;
     }
     //////////////////////////////

package/dist/swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoWrapper.js

@@ -301,9 +301,9 @@ class FromBTCLNAutoWrapper extends IFromBTCLNWrapper_1.IFromBTCLNWrapper {
                     try {
                         this.verifyReturnedData(resp, amountData, lp, _options, decodedPr, paymentHash, claimerBounty);
                         const [pricingInfo, gasPricingInfo] = await Promise.all([
-                            this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.FROM_BTCLN_AUTO], false, resp.btcAmountSwap, resp.total, amountData.token, {}, _preFetches.pricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal),
+                            this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.FROM_BTCLN_AUTO], false, resp.btcAmountSwap, resp.total, amountData.token, { swapFeeBtc: resp.swapFeeBtc }, _preFetches.pricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal),
                             _options.gasAmount === 0n ? Promise.resolve(undefined) : this.verifyReturnedPrice({ ...lp.services[SwapType_1.SwapType.FROM_BTCLN_AUTO], swapBaseFee: 0 }, //Base fee should be charged only on the amount, not on gas
-                            false, resp.btcAmountGas, resp.totalGas + resp.claimerBounty, nativeTokenAddress, {}, _preFetches.gasTokenPricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal),
+                            false, resp.btcAmountGas, resp.totalGas + resp.claimerBounty, nativeTokenAddress, { swapFeeBtc: resp.gasSwapFeeBtc }, _preFetches.gasTokenPricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal),
                             this.verifyIntermediaryLiquidity(resp.total, (0, Utils_1.throwIfUndefined)(liquidityPromise)),
                             _options.unsafeSkipLnNodeCheck ? Promise.resolve() : this.verifyLnNodeCapacity(lp, decodedPr, lnCapacityPromise, abortController.signal)
                         ]);

package/dist/swaps/escrow_swaps/frombtc/onchain/FromBTCWrapper.js

@@ -335,10 +335,11 @@ class FromBTCWrapper extends IFromBTCWrapper_1.IFromBTCWrapper {
                         }, undefined, e => e instanceof RequestError_1.RequestError, abortController.signal);
                         const data = new (this._swapDataDeserializer(version))(resp.data);
                         data.setClaimer(recipient);
+                        const swapFeeBtc = resp.swapFee * resp.amount / (data.getAmount() - resp.swapFee);
                         this.verifyReturnedData(recipient, resp, amountData, lp, _options, data, sequence, (await claimerBountyPrefetchPromise[version]), nativeTokenAddress);
                         const [pricingInfo, signatureExpiry] = await Promise.all([
                             //Get intermediary's liquidity
-                            this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.FROM_BTC], false, resp.amount, resp.total, amountData.token, {}, pricePrefetchPromise, usdPricePrefetchPromise, abortController.signal),
+                            this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.FROM_BTC], false, resp.amount, resp.total, amountData.token, { swapFeeBtc }, pricePrefetchPromise, usdPricePrefetchPromise, abortController.signal),
                             this.verifyReturnedSignature(recipient, data, resp, feeRatePromise[version], signDataPromise, version, abortController.signal),
                             this.verifyIntermediaryLiquidity(data.getAmount(), (0, Utils_1.throwIfUndefined)(liquidityPromise)),
                         ]);
@@ -347,7 +348,7 @@ class FromBTCWrapper extends IFromBTCWrapper_1.IFromBTCWrapper {
                             url: lp.url,
                             expiry: signatureExpiry,
                             swapFee: resp.swapFee,
-                            swapFeeBtc: resp.swapFee * resp.amount / (data.getAmount() - resp.swapFee),
+                            swapFeeBtc,
                             feeRate: (await feeRatePromise[version]),
                             signatureData: resp,
                             data,

package/dist/swaps/escrow_swaps/tobtc/ln/ToBTCLNWrapper.js

@@ -181,15 +181,15 @@ class ToBTCLNWrapper extends IToBTCWrapper_1.IToBTCWrapper {
             const data = new (this._swapDataDeserializer(version))(resp.data);
             data.setOfferer(signer);
             await this.verifyReturnedData(signer, resp, parsedPr, amountData.token, lp, calculatedOptions, data);
+            const swapFeeBtc = resp.swapFee * amountOut / (data.getAmount() - totalFee);
             const [pricingInfo, signatureExpiry, reputation] = await Promise.all([
-                this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.TO_BTCLN], true, amountOut, data.getAmount(), amountData.token, { networkFee: resp.maxFee }, preFetches.pricePreFetchPromise, preFetches.usdPricePrefetchPromise, abortController.signal),
+                this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.TO_BTCLN], true, amountOut, data.getAmount(), amountData.token, { networkFee: resp.maxFee, swapFeeBtc }, preFetches.pricePreFetchPromise, preFetches.usdPricePrefetchPromise, abortController.signal),
                 this.verifyReturnedSignature(signer, data, resp, preFetches.feeRatePromise[version], signDataPromise, version, abortController.signal),
                 reputationPromise
             ]);
             abortController.signal.throwIfAborted();
             if (reputation != null)
                 lp.reputation[amountData.token.toString()] = reputation;
-            const swapFeeBtc = resp.swapFee * amountOut / (data.getAmount() - totalFee);
             const quote = new ToBTCLNSwap_1.ToBTCLNSwap(this, {
                 pricingInfo,
                 url: lp.url,
@@ -339,15 +339,15 @@ class ToBTCLNWrapper extends IToBTCWrapper_1.IToBTCWrapper {
             const data = new (this._swapDataDeserializer(version))(resp.data);
             data.setOfferer(signer);
             await this.verifyReturnedData(signer, resp, parsedInvoice, amountData.token, lp, calculatedOptions, data, amountData.amount);
+            const swapFeeBtc = resp.swapFee * amountOut / (data.getAmount() - totalFee);
             const [pricingInfo, signatureExpiry, reputation] = await Promise.all([
-                this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.TO_BTCLN], true, prepareResp.amount, data.getAmount(), amountData.token, { networkFee: resp.maxFee }, preFetches.pricePreFetchPromise, preFetches.usdPricePrefetchPromise, abortSignal),
+                this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.TO_BTCLN], true, prepareResp.amount, data.getAmount(), amountData.token, { networkFee: resp.maxFee, swapFeeBtc }, preFetches.pricePreFetchPromise, preFetches.usdPricePrefetchPromise, abortSignal),
                 this.verifyReturnedSignature(signer, data, resp, preFetches.feeRatePromise[version], signDataPromise, version, abortController.signal),
                 reputationPromise
             ]);
             abortController.signal.throwIfAborted();
             if (reputation != null)
                 lp.reputation[amountData.token.toString()] = reputation;
-            const swapFeeBtc = resp.swapFee * amountOut / (data.getAmount() - totalFee);
             const quote = new ToBTCLNSwap_1.ToBTCLNSwap(this, {
                 pricingInfo,
                 url: lp.url,

package/dist/swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper.js

@@ -200,18 +200,18 @@ class ToBTCWrapper extends IToBTCWrapper_1.IToBTCWrapper {
                         let hash = _hash?.[version] ?? this._contract(version).getHashForOnchain(outputScript, resp.amount, _options.confirmations, nonce).toString("hex");
                         const data = new (this._swapDataDeserializer(version))(resp.data);
                         data.setOfferer(signer);
+                        const inputWithoutFees = data.getAmount() - resp.swapFee - resp.networkFee;
+                        const swapFeeBtc = resp.swapFee * resp.amount / inputWithoutFees;
+                        const networkFeeBtc = resp.networkFee * resp.amount / inputWithoutFees;
                         this.verifyReturnedData(signer, resp, amountData, lp, _options, data, hash);
                         const [pricingInfo, signatureExpiry, reputation] = await Promise.all([
-                            this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.TO_BTC], true, resp.amount, data.getAmount(), amountData.token, resp, pricePreFetchPromise, usdPricePrefetchPromise, abortController.signal),
+                            this.verifyReturnedPrice(lp.services[SwapType_1.SwapType.TO_BTC], true, resp.amount, data.getAmount(), amountData.token, { networkFee: resp.networkFee, swapFeeBtc }, pricePreFetchPromise, usdPricePrefetchPromise, abortController.signal),
                             this.verifyReturnedSignature(signer, data, resp, feeRatePromise[version], signDataPromise, version, abortController.signal),
                             reputationPromise
                         ]);
                         abortController.signal.throwIfAborted();
                         if (reputation != null)
                             lp.reputation[amountData.token.toString()] = reputation;
-                        const inputWithoutFees = data.getAmount() - resp.swapFee - resp.networkFee;
-                        const swapFeeBtc = resp.swapFee * resp.amount / inputWithoutFees;
-                        const networkFeeBtc = resp.networkFee * resp.amount / inputWithoutFees;
                         const quote = new ToBTCSwap_1.ToBTCSwap(this, {
                             pricingInfo,
                             url: lp.url,

package/dist/swaps/spv_swaps/SpvFromBTCSwap.js

@@ -255,7 +255,7 @@ class SpvFromBTCSwap extends ISwap_1.ISwap {
         if (this.pricingInfo == null)
             return;
         const usdPricePerBtc = this.pricingInfo.realPriceUsdPerBitcoin;
-        this.pricingInfo = await this.wrapper._prices.isValidAmountReceive(this.chainIdentifier, this.btcAmountSwap, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, this.getOutputWithoutFee().rawAmount, this.outputSwapToken);
+        this.pricingInfo = await this.wrapper._prices.isValidAmountReceive(this.chainIdentifier, this.btcAmountSwap, this.pricingInfo.satsBaseFee, this.pricingInfo.feePPM, this.getOutputWithoutFee().rawAmount, this.outputSwapToken, undefined, undefined, this.swapFeeBtc);
         this.pricingInfo.realPriceUsdPerBitcoin = usdPricePerBtc;
     }
     //////////////////////////////

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

@@ -46,6 +46,13 @@ export type SpvFromBTCOptions = {
      *  the settlement gas fee cost)
      */
     feeSafetyFactor?: number;
+    /**
+     * Instruct the LP to create a "sticky address" for your destination wallet address. After the first successful
+     *  swap with that LP, the used bitcoin address will be permanently linked to your destination wallet address. So
+     *  all subsequent swaps to the same address will yield the same LP deposit bitcoin address. Useful for corporate
+     *  whitelist-only wallets
+     */
+    stickyAddress?: boolean;
     /**
      * @deprecated Use `maxAllowedBitcoinFeeRate` instead!
      */

package/dist/swaps/spv_swaps/SpvFromBTCWrapper.js

@@ -505,15 +505,16 @@ class SpvFromBTCWrapper extends ISwapWrapper_1.ISwapWrapper {
                                 gasAmount: _options.gasAmount,
                                 callerFeeRate: (0, Utils_1.throwIfUndefined)(callerFeePrefetchPromise[version], "Caller fee prefetch failed!"),
                                 frontingFeeRate: 0n,
+                                stickyAddress: options?.stickyAddress,
                                 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 [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, {}, pricePrefetchPromise, usdPricePrefetchPromise, abortController.signal),
+                            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, {}, gasTokenPricePrefetchPromise, usdPricePrefetchPromise, abortController.signal),
+                            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)
                         ]);
                         const swapInit = {

package/dist/swaps/trusted/ln/LnForGasWrapper.js

@@ -62,7 +62,7 @@ class LnForGasWrapper extends ISwapWrapper_1.ISwapWrapper {
             throw new IntermediaryError_1.IntermediaryError("Invalid total returned");
         const pricingInfo = await this.verifyReturnedPrice(typeof (lpOrUrl) === "string" || lpOrUrl.services[SwapType_1.SwapType.TRUSTED_FROM_BTCLN] == null ?
             { swapFeePPM: 10000, swapBaseFee: 10 } :
-            lpOrUrl.services[SwapType_1.SwapType.TRUSTED_FROM_BTCLN], false, amountIn, amount, token, {});
+            lpOrUrl.services[SwapType_1.SwapType.TRUSTED_FROM_BTCLN], false, amountIn, amount, token, { swapFeeBtc: resp.swapFeeSats });
         const quoteInit = {
             pr: resp.pr,
             outputAmount: resp.total,

package/dist/swaps/trusted/onchain/OnchainForGasWrapper.js

@@ -69,7 +69,7 @@ class OnchainForGasWrapper extends ISwapWrapper_1.ISwapWrapper {
             throw new IntermediaryError_1.IntermediaryError("Invalid total returned");
         const pricingInfo = await this.verifyReturnedPrice(typeof (lpOrUrl) === "string" || lpOrUrl.services[SwapType_1.SwapType.TRUSTED_FROM_BTC] == null ?
             { swapFeePPM: 10000, swapBaseFee: 10 } :
-            lpOrUrl.services[SwapType_1.SwapType.TRUSTED_FROM_BTC], false, resp.amountSats, amount, this._chain.getNativeCurrencyAddress(), {});
+            lpOrUrl.services[SwapType_1.SwapType.TRUSTED_FROM_BTC], false, resp.amountSats, amount, this._chain.getNativeCurrencyAddress(), { swapFeeBtc: resp.swapFeeSats });
         const quote = new OnchainForGasSwap_1.OnchainForGasSwap(this, {
             paymentHash: resp.paymentHash,
             sequence: resp.sequence,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/sdk",
-  "version": "8.7.1",
+  "version": "8.7.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/SmartChainAssets.ts

@@ -4,6 +4,16 @@
  * @category Tokens
  */
 export const SmartChainAssets = {
+    _TESTNET_strkBTC: {
+        pricing: {
+            binancePair: "$fixed-100000000",
+            okxPair: "$fixed-100000000",
+            coinGeckoCoinId: "$fixed-100000000",
+            coinPaprikaCoinId: "$fixed-100000000",
+            krakenPair: "$fixed-100000000"
+        },
+        name: "strkBTC (dev)"
+    },
     _TESTNET_WBTC_VESU: {
         pricing: {
             binancePair: "WBTCBTC",
@@ -24,6 +34,16 @@ export const SmartChainAssets = {
         },
         name: "pegBTC (dev)"
     },
+    strkBTC: {
+        pricing: {
+            binancePair: "$fixed-100000000",
+            okxPair: "$fixed-100000000",
+            coinGeckoCoinId: "$fixed-100000000",
+            coinPaprikaCoinId: "$fixed-100000000",
+            krakenPair: "$fixed-100000000"
+        },
+        name: "strkBTC"
+    },
     WBTC: {
         pricing: {
             binancePair: "WBTCBTC",

package/src/bitcoin/wallet/SingleAddressBitcoinWallet.ts

@@ -3,12 +3,14 @@ import {BTC_NETWORK, NETWORK, pubECDSA, randomPrivateKeyBytes, TEST_NETWORK} fro
 import {getAddress, Transaction, WIF} from "@scure/btc-signer";
 import {Buffer} from "buffer";
 import {identifyAddressType, BitcoinWallet} from "./BitcoinWallet";
-import {BitcoinNetwork, BitcoinRpcWithAddressIndex} from "@atomiqlabs/base";
+import {BitcoinNetwork, BitcoinRpcWithAddressIndex, getLogger} from "@atomiqlabs/base";
 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";
 
+const logger = getLogger("SingleAddressBitcoinWallet: ");
+
 /**
  * Bitcoin wallet implementation deriving a single address from a WIF encoded private key
  *
@@ -42,11 +44,21 @@ export class SingleAddressBitcoinWallet extends BitcoinWallet {
             const address = getAddress("wpkh", this.privKey, network);
             if(address==null) throw new Error("Failed to generate p2wpkh address from the provided private key!");
             this.address = address;
+            this.addressType = identifyAddressType(this.address, network);
         } else {
             this.address = addressDataOrWIF.address;
+            this.addressType = identifyAddressType(this.address, network);
             this.pubkey = Buffer.from(addressDataOrWIF.publicKey, "hex");
+            // Some wallets seem to be returning a full 33-byte compressed pubkey instead of a taproot
+            //  32-byte long X-only key. Handle these cases here
+            if(this.addressType==="p2tr") {
+                if(this.pubkey.length!==33) return;
+                const leadingByte = this.pubkey[0];
+                if(leadingByte!==0x03 && leadingByte!==0x02) throw new Error("Invalid public key passed for taproot bitcoin wallet, expected an X-only 32-byte public key, or a compressed 33-byte public key");
+                logger.debug(`constructor(): Converting compressed public key ${addressDataOrWIF.publicKey} to taproot X-only 32-byte public key`);
+                this.pubkey = this.pubkey.slice(1);
+            }
         }
-        this.addressType = identifyAddressType(this.address, network);
     }
 
     /**

package/src/intermediaries/apis/IntermediaryAPI.ts

@@ -310,7 +310,8 @@ export type SpvFromBTCPrepare = SwapInit & {
     gasToken: string,
     exactOut: boolean,
     callerFeeRate: Promise<bigint>,
-    frontingFeeRate: bigint
+    frontingFeeRate: bigint,
+    stickyAddress?: boolean
 }
 
 const SpvFromBTCInitResponseSchema = {
@@ -878,7 +879,8 @@ export class IntermediaryAPI {
             gasAmount: init.gasAmount.toString(10),
             gasToken: init.gasToken,
             frontingFeeRate: init.frontingFeeRate.toString(10),
-            callerFeeRate: init.callerFeeRate.then(val => val.toString(10))
+            callerFeeRate: init.callerFeeRate.then(val => val.toString(10)),
+            stickyAddress: init.stickyAddress
         }, {
             code: FieldTypeEnum.Number,
             msg: FieldTypeEnum.String,

package/src/prices/abstract/ISwapPrice.ts

@@ -100,6 +100,7 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
      * @param tokenAddress Token address to be paid
      * @param abortSignal
      * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     * @param realSwapFeeSats
      */
     public async isValidAmountSend<C extends ChainIds<T>>(
         chainIdentifier: C,
@@ -109,11 +110,15 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
         paidToken: bigint,
         tokenAddress: string,
         abortSignal?: AbortSignal,
-        preFetchedPrice?: bigint | null
+        preFetchedPrice?: bigint | null,
+        realSwapFeeSats?: bigint
     ): Promise<PriceInfoType> {
-        const totalSats = (amountSats * (1000000n + feePPM) / 1000000n)
-            + satsBaseFee;
+        if(realSwapFeeSats!=undefined && realSwapFeeSats<0) throw new Error("Invalid swap fee! Swap fee cannot be negative!");
+        const totalSats = realSwapFeeSats!=undefined
+            ? amountSats + realSwapFeeSats
+            : (amountSats * (1000000n + feePPM) / 1000000n) + satsBaseFee;
         const totalUSats = totalSats * 1000000n;
+
         const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, tokenAddress))) / paidToken;
 
         if(this.shouldIgnore(chainIdentifier, tokenAddress)) return {
@@ -185,6 +190,7 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
      * @param tokenAddress Token address to be received
      * @param abortSignal
      * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     * @param realSwapFeeSats
      */
     public async isValidAmountReceive<C extends ChainIds<T>>(
         chainIdentifier: C,
@@ -194,11 +200,18 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
         receiveToken: bigint,
         tokenAddress: string,
         abortSignal?: AbortSignal,
-        preFetchedPrice?: bigint | null
+        preFetchedPrice?: bigint | null,
+        realSwapFeeSats?: bigint
     ): Promise<PriceInfoType> {
-        const totalSats = (amountSats * (1000000n - feePPM) / 1000000n)
-            - satsBaseFee;
+        if(realSwapFeeSats!=undefined) {
+            if(realSwapFeeSats>=amountSats) throw new Error("Invalid swap fee! Larger than or equal to total output amount!");
+            if(realSwapFeeSats<0) throw new Error("Invalid swap fee! Must be non-negative!");
+        }
+        const totalSats = realSwapFeeSats!=undefined
+            ? amountSats - realSwapFeeSats
+            : (amountSats * (1000000n - feePPM) / 1000000n) - satsBaseFee;
         const totalUSats = totalSats * 1000000n;
+
         const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, tokenAddress))) / receiveToken;
 
         if(this.shouldIgnore(chainIdentifier, tokenAddress)) return {

package/src/swaps/ISwap.ts

@@ -322,28 +322,39 @@ export abstract class ISwap<
     public async refreshPriceData(): Promise<void> {
         if(this.pricingInfo==null) return;
         const priceUsdPerBtc = this.pricingInfo.realPriceUsdPerBitcoin;
-        const input = this.getInput();
         const output = this.getOutput();
-        if(input.isUnknown || output.isUnknown) return;
+        if(output.isUnknown) return;
+
+        if(isSCToken(this.getInputToken()) && this.getDirection()===SwapDirection.TO_BTC) {
+            const input = this.getInputWithoutFee();
+            if(input.isUnknown) return;
 
-        if(isSCToken(input.token) && this.getDirection()===SwapDirection.TO_BTC) {
             this.pricingInfo = await this.wrapper._prices.isValidAmountSend(
                 this.chainIdentifier,
                 output.rawAmount!,
                 this.pricingInfo.satsBaseFee,
                 this.pricingInfo.feePPM,
-                input.rawAmount!,
-                input.token.address
+                input.rawAmount! + this.swapFee,
+                input.token.address,
+                undefined,
+                undefined,
+                this.swapFeeBtc
             );
             this.pricingInfo.realPriceUsdPerBitcoin = priceUsdPerBtc;
         } else if(isSCToken(output.token) && this.getDirection()===SwapDirection.FROM_BTC) {
+            const input = this.getInput();
+            if(input.isUnknown) return;
+
             this.pricingInfo = await this.wrapper._prices.isValidAmountReceive(
                 this.chainIdentifier,
                 input.rawAmount!,
                 this.pricingInfo.satsBaseFee,
                 this.pricingInfo.feePPM,
                 output.rawAmount!,
-                output.token.address
+                output.token.address,
+                undefined,
+                undefined,
+                this.swapFeeBtc
             );
             this.pricingInfo.realPriceUsdPerBitcoin = priceUsdPerBtc;
         }

package/src/swaps/ISwapWrapper.ts

@@ -259,7 +259,8 @@ export abstract class ISwapWrapper<
         amountToken: bigint,
         token: string,
         feeData: {
-            networkFee?: bigint
+            networkFee?: bigint,
+            swapFeeBtc?: bigint
         },
         pricePrefetchPromise: Promise<bigint | undefined> = Promise.resolve(undefined),
         usdPricePrefetchPromise: Promise<number | undefined> = Promise.resolve(undefined),
@@ -271,8 +272,8 @@ export abstract class ISwapWrapper<
 
         const [isValidAmount, usdPrice] = await Promise.all([
             send ?
-                this._prices.isValidAmountSend(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise) :
-                this._prices.isValidAmountReceive(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise),
+                this._prices.isValidAmountSend(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise, feeData.swapFeeBtc) :
+                this._prices.isValidAmountReceive(this.chainIdentifier, amountSats, swapBaseFee, swapFeePPM, amountToken, token, abortSignal, await pricePrefetchPromise, feeData.swapFeeBtc),
             usdPricePrefetchPromise.then(value => {
                 if(value!=null) return value;
                 return this._prices.preFetchUsdPrice(abortSignal);

package/src/swaps/escrow_swaps/frombtc/ln/FromBTCLNWrapper.ts

@@ -342,12 +342,14 @@ export class FromBTCLNWrapper<
                     if(decodedPr.timeExpireDate==null) throw new IntermediaryError("Invalid returned swap invoice, no expiry date field");
                     const amountIn = (BigInt(decodedPr.millisatoshis) + 999n) / 1000n;
 
+                    const swapFeeBtc = resp.swapFee * amountIn / (resp.total - resp.swapFee);
+
                     try {
                         this.verifyReturnedData(resp, amountData, lp, _options, decodedPr, paymentHash);
                         const [pricingInfo] = await Promise.all([
                             this.verifyReturnedPrice(
                                 lp.services[SwapType.FROM_BTCLN], false, amountIn, resp.total,
-                                amountData.token, {}, _preFetches.pricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal
+                                amountData.token, {swapFeeBtc}, _preFetches.pricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal
                             ),
                             this.verifyIntermediaryLiquidity(resp.total, throwIfUndefined(liquidityPromise)),
                             lnCapacityPromise!=null ? this.verifyLnNodeCapacity(lp, decodedPr, lnCapacityPromise, abortController.signal) : Promise.resolve()
@@ -358,7 +360,7 @@ export class FromBTCLNWrapper<
                             url: lp.url,
                             expiry: decodedPr.timeExpireDate*1000,
                             swapFee: resp.swapFee,
-                            swapFeeBtc: resp.swapFee * amountIn / (resp.total - resp.swapFee),
+                            swapFeeBtc,
                             feeRate: (await _preFetches.feeRatePromise[version])!,
                             initialSwapData: await this._contract(version).createSwapData(
                                 ChainSwapType.HTLC, lp.getAddress(this.chainIdentifier), recipient, amountData.token,

package/src/swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoSwap.ts

@@ -309,7 +309,10 @@ export class FromBTCLNAutoSwap<T extends ChainType = ChainType>
             this.pricingInfo.satsBaseFee,
             this.pricingInfo.feePPM,
             this.getOutputAmountWithoutFee(),
-            this.getSwapData().getToken()
+            this.getSwapData().getToken(),
+            undefined,
+            undefined,
+            this.swapFeeBtc
         );
         this.pricingInfo.realPriceUsdPerBitcoin = usdPricePerBtc;
     }

package/src/swaps/escrow_swaps/frombtc/ln_auto/FromBTCLNAutoWrapper.ts

@@ -468,13 +468,13 @@ export class FromBTCLNAutoWrapper<
                                 lp.services[SwapType.FROM_BTCLN_AUTO],
                                 false, resp.btcAmountSwap,
                                 resp.total,
-                                amountData.token, {}, _preFetches.pricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal
+                                amountData.token, {swapFeeBtc: resp.swapFeeBtc}, _preFetches.pricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal
                             ),
                             _options.gasAmount===0n ? Promise.resolve(undefined) : this.verifyReturnedPrice(
                                 {...lp.services[SwapType.FROM_BTCLN_AUTO], swapBaseFee: 0}, //Base fee should be charged only on the amount, not on gas
                                 false, resp.btcAmountGas,
                                 resp.totalGas + resp.claimerBounty,
-                                nativeTokenAddress, {}, _preFetches.gasTokenPricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal
+                                nativeTokenAddress, {swapFeeBtc: resp.gasSwapFeeBtc}, _preFetches.gasTokenPricePrefetchPromise, _preFetches.usdPricePrefetchPromise, abortController.signal
                             ),
                             this.verifyIntermediaryLiquidity(resp.total, throwIfUndefined(liquidityPromise)),
                             _options.unsafeSkipLnNodeCheck ? Promise.resolve() : this.verifyLnNodeCapacity(lp, decodedPr, lnCapacityPromise, abortController.signal)

package/src/swaps/escrow_swaps/frombtc/onchain/FromBTCWrapper.ts

@@ -528,12 +528,14 @@ export class FromBTCWrapper<
                         const data: T["Data"] = new (this._swapDataDeserializer(version))(resp.data);
                         data.setClaimer(recipient);
 
+                        const swapFeeBtc = resp.swapFee * resp.amount / (data.getAmount() - resp.swapFee);
+
                         this.verifyReturnedData(recipient, resp, amountData, lp, _options, data, sequence, (await claimerBountyPrefetchPromise[version])!, nativeTokenAddress);
                         const [pricingInfo, signatureExpiry] = await Promise.all([
                             //Get intermediary's liquidity
                             this.verifyReturnedPrice(
                                 lp.services[SwapType.FROM_BTC], false, resp.amount, resp.total,
-                                amountData.token, {}, pricePrefetchPromise, usdPricePrefetchPromise, abortController.signal
+                                amountData.token, {swapFeeBtc}, pricePrefetchPromise, usdPricePrefetchPromise, abortController.signal
                             ),
                             this.verifyReturnedSignature(recipient, data, resp, feeRatePromise[version], signDataPromise, version, abortController.signal),
                             this.verifyIntermediaryLiquidity(data.getAmount(), throwIfUndefined(liquidityPromise)),
@@ -544,7 +546,7 @@ export class FromBTCWrapper<
                             url: lp.url,
                             expiry: signatureExpiry,
                             swapFee: resp.swapFee,
-                            swapFeeBtc: resp.swapFee * resp.amount / (data.getAmount() - resp.swapFee),
+                            swapFeeBtc,
                             feeRate: (await feeRatePromise[version])!,
                             signatureData: resp,
                             data,

package/src/swaps/escrow_swaps/tobtc/ln/ToBTCLNWrapper.ts

@@ -315,10 +315,12 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
 
             await this.verifyReturnedData(signer, resp, parsedPr, amountData.token, lp, calculatedOptions, data);
 
+            const swapFeeBtc = resp.swapFee * amountOut / (data.getAmount() - totalFee);
+
             const [pricingInfo, signatureExpiry, reputation] = await Promise.all([
                 this.verifyReturnedPrice(
                     lp.services[SwapType.TO_BTCLN], true, amountOut, data.getAmount(),
-                    amountData.token, {networkFee: resp.maxFee},
+                    amountData.token, {networkFee: resp.maxFee, swapFeeBtc},
                     preFetches.pricePreFetchPromise, preFetches.usdPricePrefetchPromise, abortController.signal
                 ),
                 this.verifyReturnedSignature(
@@ -330,8 +332,6 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
 
             if(reputation!=null) lp.reputation[amountData.token.toString()] = reputation;
 
-            const swapFeeBtc = resp.swapFee * amountOut / (data.getAmount() - totalFee);
-
             const quote = new ToBTCLNSwap<T>(this, {
                 pricingInfo,
                 url: lp.url,
@@ -528,10 +528,12 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
 
             await this.verifyReturnedData(signer, resp, parsedInvoice, amountData.token, lp, calculatedOptions, data, amountData.amount);
 
+            const swapFeeBtc = resp.swapFee * amountOut / (data.getAmount() - totalFee);
+
             const [pricingInfo, signatureExpiry, reputation] = await Promise.all([
                 this.verifyReturnedPrice(
                     lp.services[SwapType.TO_BTCLN], true, prepareResp.amount, data.getAmount(),
-                    amountData.token, {networkFee: resp.maxFee},
+                    amountData.token, {networkFee: resp.maxFee, swapFeeBtc},
                     preFetches.pricePreFetchPromise, preFetches.usdPricePrefetchPromise, abortSignal
                 ),
                 this.verifyReturnedSignature(
@@ -543,8 +545,6 @@ export class ToBTCLNWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCL
 
             if(reputation!=null) lp.reputation[amountData.token.toString()] = reputation;
 
-            const swapFeeBtc = resp.swapFee * amountOut / (data.getAmount() - totalFee);
-
             const quote = new ToBTCLNSwap<T>(this, {
                 pricingInfo,
                 url: lp.url,

package/src/swaps/escrow_swaps/tobtc/onchain/ToBTCWrapper.ts

@@ -304,11 +304,15 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
                         const data: T["Data"] = new (this._swapDataDeserializer(version))(resp.data);
                         data.setOfferer(signer);
 
+                        const inputWithoutFees = data.getAmount() - resp.swapFee - resp.networkFee;
+                        const swapFeeBtc = resp.swapFee * resp.amount / inputWithoutFees;
+                        const networkFeeBtc = resp.networkFee * resp.amount / inputWithoutFees;
+
                         this.verifyReturnedData(signer, resp, amountData, lp, _options, data, hash);
                         const [pricingInfo, signatureExpiry, reputation] = await Promise.all([
                             this.verifyReturnedPrice(
                                 lp.services[SwapType.TO_BTC], true, resp.amount, data.getAmount(),
-                                amountData.token, resp, pricePreFetchPromise, usdPricePrefetchPromise, abortController.signal
+                                amountData.token, {networkFee: resp.networkFee, swapFeeBtc}, pricePreFetchPromise, usdPricePrefetchPromise, abortController.signal
                             ),
                             this.verifyReturnedSignature(signer, data, resp, feeRatePromise[version], signDataPromise, version, abortController.signal),
                             reputationPromise
@@ -317,10 +321,6 @@ export class ToBTCWrapper<T extends ChainType> extends IToBTCWrapper<T, ToBTCDef
 
                         if(reputation!=null) lp.reputation[amountData.token.toString()] = reputation;
 
-                        const inputWithoutFees = data.getAmount() - resp.swapFee - resp.networkFee;
-                        const swapFeeBtc = resp.swapFee * resp.amount / inputWithoutFees;
-                        const networkFeeBtc = resp.networkFee * resp.amount / inputWithoutFees
-
                         const quote = new ToBTCSwap<T>(this, {
                             pricingInfo,
                             url: lp.url,

package/src/swaps/spv_swaps/SpvFromBTCSwap.ts

@@ -402,7 +402,10 @@ export class SpvFromBTCSwap<T extends ChainType>
             this.pricingInfo.satsBaseFee,
             this.pricingInfo.feePPM,
             this.getOutputWithoutFee().rawAmount,
-            this.outputSwapToken
+            this.outputSwapToken,
+            undefined,
+            undefined,
+            this.swapFeeBtc
         );
         this.pricingInfo.realPriceUsdPerBitcoin = usdPricePerBtc;
     }

package/src/swaps/spv_swaps/SpvFromBTCWrapper.ts

@@ -68,6 +68,13 @@ export type SpvFromBTCOptions = {
      *  the settlement gas fee cost)
      */
     feeSafetyFactor?: number,
+    /**
+     * Instruct the LP to create a "sticky address" for your destination wallet address. After the first successful
+     *  swap with that LP, the used bitcoin address will be permanently linked to your destination wallet address. So
+     *  all subsequent swaps to the same address will yield the same LP deposit bitcoin address. Useful for corporate
+     *  whitelist-only wallets
+     */
+    stickyAddress?: boolean,
 
     /**
      * @deprecated Use `maxAllowedBitcoinFeeRate` instead!
@@ -681,6 +688,7 @@ export class SpvFromBTCWrapper<
                                     gasAmount: _options.gasAmount,
                                     callerFeeRate: throwIfUndefined(callerFeePrefetchPromise[version], "Caller fee prefetch failed!"),
                                     frontingFeeRate: 0n,
+                                    stickyAddress: options?.stickyAddress,
                                     additionalParams
                                 },
                                 this._options.postRequestTimeout, abortController.signal, retryCount>0 ? false : undefined
@@ -700,13 +708,13 @@ export class SpvFromBTCWrapper<
                                 lp.services[SwapType.SPV_VAULT_FROM_BTC],
                                 false, resp.btcAmountSwap,
                                 resp.total * (100_000n + callerFeeShare) / 100_000n,
-                                amountData.token, {}, pricePrefetchPromise, usdPricePrefetchPromise, abortController.signal
+                                amountData.token, {swapFeeBtc: resp.swapFeeBtc}, pricePrefetchPromise, usdPricePrefetchPromise, abortController.signal
                             ),
                             _options.gasAmount===0n ? Promise.resolve(undefined) : this.verifyReturnedPrice(
                                 {...lp.services[SwapType.SPV_VAULT_FROM_BTC], swapBaseFee: 0}, //Base fee should be charged only on the amount, not on gas
                                 false, resp.btcAmountGas,
                                 resp.totalGas * (100_000n + callerFeeShare) / 100_000n,
-                                nativeTokenAddress, {}, gasTokenPricePrefetchPromise, usdPricePrefetchPromise, abortController.signal
+                                nativeTokenAddress, {swapFeeBtc: resp.gasSwapFeeBtc}, gasTokenPricePrefetchPromise, usdPricePrefetchPromise, abortController.signal
                             ),
                             this.verifyReturnedData(resp, amountData, lp, _options, callerFeeShare, bitcoinFeeRatePromise, abortController.signal)
                         ]);

package/src/swaps/trusted/ln/LnForGasWrapper.ts

@@ -68,7 +68,7 @@ export class LnForGasWrapper<T extends ChainType> extends ISwapWrapper<T, LnForG
                 {swapFeePPM: 10000, swapBaseFee: 10} :
                 lpOrUrl.services[SwapType.TRUSTED_FROM_BTCLN],
             false, amountIn,
-            amount, token, {}
+            amount, token, {swapFeeBtc: resp.swapFeeSats}
         );
 
         const quoteInit: LnForGasSwapInit = {

package/src/swaps/trusted/onchain/OnchainForGasWrapper.ts

@@ -105,7 +105,7 @@ export class OnchainForGasWrapper<T extends ChainType> extends ISwapWrapper<T, O
                 {swapFeePPM: 10000, swapBaseFee: 10} :
                 lpOrUrl.services[SwapType.TRUSTED_FROM_BTC],
             false, resp.amountSats,
-            amount, this._chain.getNativeCurrencyAddress(), {}
+            amount, this._chain.getNativeCurrencyAddress(), {swapFeeBtc: resp.swapFeeSats}
         );
 
         const quote = new OnchainForGasSwap(this, {