@flashnet/sdk 0.5.3 → 0.5.5

package/dist/cjs/src/client/FlashnetClient.js

@@ -11,6 +11,7 @@ var hex = require('../utils/hex.js');
 var intents = require('../utils/intents.js');
 var sparkAddress = require('../utils/spark-address.js');
 var tokenAddress = require('../utils/tokenAddress.js');
+var bigint = require('../utils/bigint.js');
 var errors = require('../types/errors.js');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -245,7 +246,8 @@ class FlashnetClient {
                 const tokenIdentifierHex = hex.getHexFromUint8Array(info.rawTokenIdentifier);
                 const tokenAddress$1 = tokenAddress.encodeSparkHumanReadableTokenIdentifier(info.rawTokenIdentifier, this.sparkNetwork);
                 tokenBalances.set(tokenPubkey, {
-                    balance: BigInt(tokenData.balance),
+                    balance: FlashnetClient.safeBigInt(tokenData.ownedBalance),
+                    availableToSendBalance: FlashnetClient.safeBigInt(tokenData.availableToSendBalance),
                     tokenInfo: {
                         tokenIdentifier: tokenIdentifierHex,
                         tokenAddress: tokenAddress$1,
@@ -258,7 +260,7 @@ class FlashnetClient {
             }
         }
         return {
-            balance: BigInt(balance.balance),
+            balance: FlashnetClient.safeBigInt(balance.balance),
             tokenBalances,
         };
     }
@@ -266,17 +268,17 @@ class FlashnetClient {
      * Check if wallet has sufficient balance for an operation
      */
     async checkBalance(params) {
-        const balance = await this.getBalance();
+        const balance = params.walletBalance ?? (await this.getBalance());
         // Check balance
         const requirements = {
             tokens: new Map(),
         };
         for (const balance of params.balancesToCheck) {
             if (balance.assetAddress === index$1.BTC_ASSET_PUBKEY) {
-                requirements.btc = BigInt(balance.amount);
+                requirements.btc = FlashnetClient.safeBigInt(balance.amount);
             }
             else {
-                requirements.tokens?.set(balance.assetAddress, BigInt(balance.amount));
+                requirements.tokens?.set(balance.assetAddress, FlashnetClient.safeBigInt(balance.amount));
             }
         }
         // Check BTC balance
@@ -294,7 +296,9 @@ class FlashnetClient {
                 const hrKey = this.toHumanReadableTokenIdentifier(tokenPubkey);
                 const effectiveTokenBalance = balance.tokenBalances.get(tokenPubkey) ??
                     balance.tokenBalances.get(hrKey);
-                const available = effectiveTokenBalance?.balance ?? 0n;
+                const available = params.useAvailableBalance
+                    ? (effectiveTokenBalance?.availableToSendBalance ?? 0n)
+                    : (effectiveTokenBalance?.balance ?? 0n);
                 if (available < requiredAmount) {
                     throw new Error([
                         params.errorPrefix ?? "",
@@ -356,6 +360,7 @@ class FlashnetClient {
                     },
                 ],
                 errorPrefix: "Insufficient balance for initial liquidity: ",
+                useAvailableBalance: params.useAvailableBalance,
             });
         }
         const poolOwnerPublicKey = params.poolOwnerPublicKey ?? this.publicKey;
@@ -415,6 +420,12 @@ class FlashnetClient {
             throw new Error(`${name} must be positive integer`);
         }
     }
+    /**
+     * Safely convert a value to BigInt. Delegates to the shared `safeBigInt` utility.
+     */
+    static safeBigInt(value, fallback = 0n) {
+        return bigint.safeBigInt(value, fallback);
+    }
     /**
      * Calculates virtual reserves for a bonding curve AMM.
      *
@@ -435,7 +446,7 @@ class FlashnetClient {
         }
         const supply = FlashnetClient.parsePositiveIntegerToBigInt(params.initialTokenSupply, "Initial token supply");
         const targetB = FlashnetClient.parsePositiveIntegerToBigInt(params.targetRaise, "Target raise");
-        const graduationThresholdPct = BigInt(params.graduationThresholdPct);
+        const graduationThresholdPct = FlashnetClient.safeBigInt(params.graduationThresholdPct);
         // Align bounds with Rust AMM (20%..95%), then check feasibility for g=1 (requires >50%).
         const MIN_PCT = 20n;
         const MAX_PCT = 95n;
@@ -485,6 +496,7 @@ class FlashnetClient {
                 },
             ],
             errorPrefix: "Insufficient balance for pool creation: ",
+            useAvailableBalance: params.useAvailableBalance,
         });
         const poolOwnerPublicKey = params.poolOwnerPublicKey ?? this.publicKey;
         // Generate intent
@@ -605,10 +617,14 @@ class FlashnetClient {
         });
         // If using free balance (V3 pools only), skip the Spark transfer
         if (params.useFreeBalance) {
-            return this.executeSwapIntent({
+            const swapResponse = await this.executeSwapIntent({
                 ...params,
                 // No transferId - triggers free balance mode
             });
+            return {
+                ...swapResponse,
+                inboundSparkTransferId: swapResponse.requestId,
+            };
         }
         // Transfer assets to pool using new address encoding
         const lpSparkAddress = sparkAddress.encodeSparkAddressNew({
@@ -619,12 +635,13 @@ class FlashnetClient {
             receiverSparkAddress: lpSparkAddress,
             assetAddress: params.assetInAddress,
             amount: params.amountIn,
-        }, "Insufficient balance for swap: ");
+        }, "Insufficient balance for swap: ", params.useAvailableBalance);
         // Execute with auto-clawback on failure
-        return this.executeWithAutoClawback(() => this.executeSwapIntent({
+        const swapResponse = await this.executeWithAutoClawback(() => this.executeSwapIntent({
             ...params,
             transferId,
         }), [transferId], params.poolId);
+        return { ...swapResponse, inboundSparkTransferId: transferId };
     }
     /**
      * Execute a swap with a pre-created transfer or using free balance.
@@ -754,7 +771,7 @@ class FlashnetClient {
             receiverSparkAddress: lpSparkAddress,
             assetAddress: params.initialAssetAddress,
             amount: params.inputAmount,
-        }, "Insufficient balance for route swap: ");
+        }, "Insufficient balance for route swap: ", params.useAvailableBalance);
         // Execute with auto-clawback on failure
         return this.executeWithAutoClawback(async () => {
             // Prepare hops for validation
@@ -877,7 +894,7 @@ class FlashnetClient {
                 assetAddress: pool.assetBAddress,
                 amount: params.assetBAmount,
             },
-        ], "Insufficient balance for adding liquidity: ");
+        ], "Insufficient balance for adding liquidity: ", params.useAvailableBalance);
         // Execute with auto-clawback on failure
         return this.executeWithAutoClawback(async () => {
             // Generate add liquidity intent
@@ -1183,6 +1200,7 @@ class FlashnetClient {
             depositAddress: createResponse.depositAddress,
             assetId: params.assetId,
             assetAmount: params.assetAmount,
+            useAvailableBalance: params.useAvailableBalance,
         });
     }
     /**
@@ -1200,6 +1218,7 @@ class FlashnetClient {
                 { assetAddress: params.assetId, amount: params.assetAmount },
             ],
             errorPrefix: "Insufficient balance to fund escrow: ",
+            useAvailableBalance: params.useAvailableBalance,
         });
         // 2. Perform transfer
         const escrowSparkAddress = sparkAddress.encodeSparkAddressNew({
@@ -1714,19 +1733,20 @@ class FlashnetClient {
     /**
      * Performs asset transfer using generalized asset address for both BTC and tokens.
      */
-    async transferAsset(recipient, checkBalanceErrorPrefix) {
-        const transferIds = await this.transferAssets([recipient], checkBalanceErrorPrefix);
+    async transferAsset(recipient, checkBalanceErrorPrefix, useAvailableBalance) {
+        const transferIds = await this.transferAssets([recipient], checkBalanceErrorPrefix, useAvailableBalance);
         return transferIds[0];
     }
     /**
      * Performs asset transfers using generalized asset addresses for both BTC and tokens.
      * Supports optional generic to hardcode recipients length so output list can be typed with same length.
      */
-    async transferAssets(recipients, checkBalanceErrorPrefix) {
+    async transferAssets(recipients, checkBalanceErrorPrefix, useAvailableBalance) {
         if (checkBalanceErrorPrefix) {
             await this.checkBalance({
                 balancesToCheck: recipients,
                 errorPrefix: checkBalanceErrorPrefix,
+                useAvailableBalance,
             });
         }
         const transferIds = [];
@@ -1741,7 +1761,7 @@ class FlashnetClient {
             else {
                 const transferId = await this._wallet.transferTokens({
                     tokenIdentifier: this.toHumanReadableTokenIdentifier(recipient.assetAddress),
-                    tokenAmount: BigInt(recipient.amount),
+                    tokenAmount: FlashnetClient.safeBigInt(recipient.amount),
                     receiverSparkAddress: recipient.receiverSparkAddress,
                 });
                 transferIds.push(transferId);
@@ -1825,38 +1845,37 @@ class FlashnetClient {
         await this.ensureInitialized();
         // Decode the invoice to get the amount
         const invoiceAmountSats = await this.decodeInvoiceAmount(invoice);
+        // Zero-amount invoice: forward-direction quoting using caller-specified tokenAmount
         if (!invoiceAmountSats || invoiceAmountSats <= 0) {
-            throw new errors.FlashnetError("Unable to decode invoice amount. Zero-amount invoices are not supported for token payments.", {
-                response: {
-                    errorCode: "FSAG-1002",
-                    errorCategory: "Validation",
-                    message: "Unable to decode invoice amount. Zero-amount invoices are not supported for token payments.",
-                    requestId: "",
-                    timestamp: new Date().toISOString(),
-                    service: "sdk",
-                    severity: "Error",
-                    remediation: "Provide a valid BOLT11 invoice with a non-zero amount.",
-                },
-            });
+            const tokenAmount = options?.tokenAmount;
+            if (!tokenAmount || BigInt(tokenAmount) <= 0n) {
+                throw new errors.FlashnetError("Zero-amount invoice requires tokenAmount in options.", {
+                    response: {
+                        errorCode: "FSAG-1002",
+                        errorCategory: "Validation",
+                        message: "Zero-amount invoice requires tokenAmount in options.",
+                        requestId: "",
+                        timestamp: new Date().toISOString(),
+                        service: "sdk",
+                        severity: "Error",
+                        remediation: "Provide tokenAmount when using a zero-amount invoice.",
+                    },
+                });
+            }
+            return this.getZeroAmountInvoiceQuote(invoice, tokenAddress, tokenAmount, options);
         }
         // Get Lightning fee estimate
         const lightningFeeEstimate = await this.getLightningFeeEstimate(invoice);
-        // Total BTC needed = invoice amount + lightning fee
-        const baseBtcNeeded = BigInt(invoiceAmountSats) + BigInt(lightningFeeEstimate);
-        // Round up to next multiple of 64 (2^6) to account for BTC variable fee bit masking.
-        // The AMM zeroes the lowest 6 bits of BTC output, so we need to request enough
-        // that after masking we still have the required amount.
-        // Example: 5014 -> masked to 4992, but if we request 5056, masked stays 5056
-        const BTC_VARIABLE_FEE_BITS = 6n;
-        const BTC_VARIABLE_FEE_MASK = 1n << BTC_VARIABLE_FEE_BITS; // 64
-        const totalBtcNeeded = ((baseBtcNeeded + BTC_VARIABLE_FEE_MASK - 1n) / BTC_VARIABLE_FEE_MASK) *
-            BTC_VARIABLE_FEE_MASK;
+        // Total BTC needed = invoice amount + lightning fee (unmasked).
+        // Bitmasking for V2 pools is handled inside findBestPoolForTokenToBtc.
+        const baseBtcNeeded = FlashnetClient.safeBigInt(invoiceAmountSats) +
+            FlashnetClient.safeBigInt(lightningFeeEstimate);
         // Check Flashnet minimum amounts early to provide clear error messages
         const minAmounts = await this.getEnabledMinAmountsMap();
         // Check BTC minimum (output from swap)
         const btcMinAmount = minAmounts.get(index$1.BTC_ASSET_PUBKEY.toLowerCase());
-        if (btcMinAmount && totalBtcNeeded < btcMinAmount) {
-            const msg = `Invoice amount too small. Minimum BTC output is ${btcMinAmount} sats, but invoice + lightning fee totals only ${totalBtcNeeded} sats.`;
+        if (btcMinAmount && baseBtcNeeded < btcMinAmount) {
+            const msg = `Invoice amount too small. Minimum BTC output is ${btcMinAmount} sats, but invoice + lightning fee totals only ${baseBtcNeeded} sats.`;
             throw new errors.FlashnetError(msg, {
                 response: {
                     errorCode: "FSAG-1003",
@@ -1870,13 +1889,14 @@ class FlashnetClient {
                 },
             });
         }
-        // Find the best pool to swap token -> BTC
-        const poolQuote = await this.findBestPoolForTokenToBtc(tokenAddress, totalBtcNeeded.toString(), options?.integratorFeeRateBps);
+        // Find the best pool to swap token -> BTC.
+        // Bitmasking is applied per-pool inside this function (V2 pools get masked, V3 pools don't).
+        const poolQuote = await this.findBestPoolForTokenToBtc(tokenAddress, baseBtcNeeded.toString(), options?.integratorFeeRateBps);
         // Check token minimum (input to swap)
         const tokenHex = this.toHexTokenIdentifier(tokenAddress).toLowerCase();
         const tokenMinAmount = minAmounts.get(tokenHex);
         if (tokenMinAmount &&
-            BigInt(poolQuote.tokenAmountRequired) < tokenMinAmount) {
+            FlashnetClient.safeBigInt(poolQuote.tokenAmountRequired) < tokenMinAmount) {
             const msg = `Token amount too small. Minimum input is ${tokenMinAmount} units, but calculated amount is only ${poolQuote.tokenAmountRequired} units.`;
             throw new errors.FlashnetError(msg, {
                 response: {
@@ -1891,13 +1911,14 @@ class FlashnetClient {
                 },
             });
         }
-        // Calculate the BTC variable fee adjustment (how much extra we're requesting)
-        const btcVariableFeeAdjustment = Number(totalBtcNeeded - baseBtcNeeded);
+        // BTC variable fee adjustment: difference between what the pool targets and unmasked base.
+        // For V3 pools this is 0 (no masking). For V2 it's the rounding overhead.
+        const btcVariableFeeAdjustment = Number(FlashnetClient.safeBigInt(poolQuote.btcAmountUsed) - baseBtcNeeded);
         return {
             poolId: poolQuote.poolId,
             tokenAddress: this.toHexTokenIdentifier(tokenAddress),
             tokenAmountRequired: poolQuote.tokenAmountRequired,
-            btcAmountRequired: totalBtcNeeded.toString(),
+            btcAmountRequired: poolQuote.btcAmountUsed,
             invoiceAmountSats: invoiceAmountSats,
             estimatedAmmFee: poolQuote.estimatedAmmFee,
             estimatedLightningFee: lightningFeeEstimate,
@@ -1907,6 +1928,138 @@ class FlashnetClient {
             tokenIsAssetA: poolQuote.tokenIsAssetA,
             poolReserves: poolQuote.poolReserves,
             warningMessage: poolQuote.warningMessage,
+            curveType: poolQuote.curveType,
+            isZeroAmountInvoice: false,
+        };
+    }
+    /**
+     * Generate a quote for a zero-amount invoice.
+     * Forward-direction: simulate swapping tokenAmount and pick the pool with the best BTC output.
+     * @private
+     */
+    async getZeroAmountInvoiceQuote(invoice, tokenAddress, tokenAmount, options) {
+        const tokenHex = this.toHexTokenIdentifier(tokenAddress);
+        const btcHex = index$1.BTC_ASSET_PUBKEY;
+        // Discover all token/BTC pools
+        const [poolsWithTokenAsA, poolsWithTokenAsB] = await Promise.all([
+            this.listPools({ assetAAddress: tokenHex, assetBAddress: btcHex }),
+            this.listPools({ assetAAddress: btcHex, assetBAddress: tokenHex }),
+        ]);
+        const poolMap = new Map();
+        for (const p of [...poolsWithTokenAsA.pools, ...poolsWithTokenAsB.pools]) {
+            if (!poolMap.has(p.lpPublicKey)) {
+                const tokenIsAssetA = p.assetAAddress?.toLowerCase() === tokenHex.toLowerCase();
+                poolMap.set(p.lpPublicKey, { pool: p, tokenIsAssetA });
+            }
+        }
+        const allPools = Array.from(poolMap.values());
+        if (allPools.length === 0) {
+            throw new errors.FlashnetError(`No liquidity pool found for token ${tokenAddress} paired with BTC`, {
+                response: {
+                    errorCode: "FSAG-4001",
+                    errorCategory: "Business",
+                    message: `No liquidity pool found for token ${tokenAddress} paired with BTC`,
+                    requestId: "",
+                    timestamp: new Date().toISOString(),
+                    service: "sdk",
+                    severity: "Error",
+                },
+            });
+        }
+        // Simulate each pool with tokenAmount as input, pick highest BTC output
+        let bestResult = null;
+        let bestBtcOut = 0n;
+        for (const { pool, tokenIsAssetA } of allPools) {
+            try {
+                const poolDetails = await this.getPool(pool.lpPublicKey);
+                const assetInAddress = tokenIsAssetA
+                    ? poolDetails.assetAAddress
+                    : poolDetails.assetBAddress;
+                const assetOutAddress = tokenIsAssetA
+                    ? poolDetails.assetBAddress
+                    : poolDetails.assetAAddress;
+                const simulation = await this.simulateSwap({
+                    poolId: pool.lpPublicKey,
+                    assetInAddress,
+                    assetOutAddress,
+                    amountIn: tokenAmount,
+                    integratorBps: options?.integratorFeeRateBps,
+                });
+                const btcOut = FlashnetClient.safeBigInt(simulation.amountOut);
+                if (btcOut > bestBtcOut) {
+                    bestBtcOut = btcOut;
+                    bestResult = {
+                        poolId: pool.lpPublicKey,
+                        tokenIsAssetA,
+                        simulation,
+                        curveType: poolDetails.curveType,
+                        poolReserves: {
+                            assetAReserve: poolDetails.assetAReserve,
+                            assetBReserve: poolDetails.assetBReserve,
+                        },
+                    };
+                }
+            }
+            catch {
+                // Skip pools that fail simulation
+            }
+        }
+        if (!bestResult || bestBtcOut <= 0n) {
+            throw new errors.FlashnetError("No pool can produce BTC output for the given token amount", {
+                response: {
+                    errorCode: "FSAG-4201",
+                    errorCategory: "Business",
+                    message: "No pool can produce BTC output for the given token amount",
+                    requestId: "",
+                    timestamp: new Date().toISOString(),
+                    service: "sdk",
+                    severity: "Error",
+                    remediation: "Try a larger token amount.",
+                },
+            });
+        }
+        // Estimate lightning fee from the BTC output
+        let lightningFeeEstimate;
+        try {
+            lightningFeeEstimate = await this.getLightningFeeEstimate(invoice);
+        }
+        catch {
+            lightningFeeEstimate = Math.max(5, Math.ceil(Number(bestBtcOut) * 0.0017));
+        }
+        // Check minimum amounts
+        const minAmounts = await this.getEnabledMinAmountsMap();
+        const btcMinAmount = minAmounts.get(index$1.BTC_ASSET_PUBKEY.toLowerCase());
+        if (btcMinAmount && bestBtcOut < btcMinAmount) {
+            const msg = `BTC output too small. Minimum is ${btcMinAmount} sats, but swap would produce only ${bestBtcOut} sats.`;
+            throw new errors.FlashnetError(msg, {
+                response: {
+                    errorCode: "FSAG-1003",
+                    errorCategory: "Validation",
+                    message: msg,
+                    requestId: "",
+                    timestamp: new Date().toISOString(),
+                    service: "sdk",
+                    severity: "Error",
+                    remediation: "Use a larger token amount.",
+                },
+            });
+        }
+        return {
+            poolId: bestResult.poolId,
+            tokenAddress: tokenHex,
+            tokenAmountRequired: tokenAmount,
+            btcAmountRequired: bestBtcOut.toString(),
+            invoiceAmountSats: 0,
+            estimatedAmmFee: bestResult.simulation.feePaidAssetIn || "0",
+            estimatedLightningFee: lightningFeeEstimate,
+            btcVariableFeeAdjustment: 0,
+            executionPrice: bestResult.simulation.executionPrice || "0",
+            priceImpactPct: bestResult.simulation.priceImpactPct || "0",
+            tokenIsAssetA: bestResult.tokenIsAssetA,
+            poolReserves: bestResult.poolReserves,
+            warningMessage: bestResult.simulation.warningMessage,
+            curveType: bestResult.curveType,
+            isZeroAmountInvoice: true,
         };
     }
     /**
@@ -1918,14 +2071,15 @@ class FlashnetClient {
      */
     async payLightningWithToken(options) {
         await this.ensureInitialized();
-        const { invoice, tokenAddress, maxSlippageBps = 500, // 5% default
+        const { invoice, tokenAddress, tokenAmount, maxSlippageBps = 500, // 5% default
         maxLightningFeeSats, preferSpark = true, integratorFeeRateBps, integratorPublicKey, transferTimeoutMs = 30000, // 30s default
-        rollbackOnFailure = false, useExistingBtcBalance = false, } = options;
+        rollbackOnFailure = false, useExistingBtcBalance = false, useAvailableBalance = false, } = options;
         try {
             // Step 1: Get a quote for the payment
             const quote = await this.getPayLightningWithTokenQuote(invoice, tokenAddress, {
                 maxSlippageBps,
                 integratorFeeRateBps,
+                tokenAmount,
             });
             // Step 2: Check token balance (always required)
             await this.checkBalance({
@@ -1936,17 +2090,8 @@ class FlashnetClient {
                     },
                 ],
                 errorPrefix: "Insufficient token balance for Lightning payment: ",
+                useAvailableBalance,
             });
-            // Determine if we can pay immediately using existing BTC balance
-            let canPayImmediately = false;
-            if (useExistingBtcBalance) {
-                const invoiceAmountSats = await this.decodeInvoiceAmount(invoice);
-                const effectiveMaxLightningFee = maxLightningFeeSats ?? quote.estimatedLightningFee;
-                const btcNeededForPayment = invoiceAmountSats + effectiveMaxLightningFee;
-                // Check if we have enough BTC (don't throw if not, just fall back to waiting)
-                const balance = await this.getBalance();
-                canPayImmediately = balance.balance >= BigInt(btcNeededForPayment);
-            }
             // Step 3: Get pool details
             const pool = await this.getPool(quote.poolId);
             // Step 4: Determine swap direction and execute
@@ -1968,6 +2113,7 @@ class FlashnetClient {
                 minAmountOut: minBtcOut,
                 integratorFeeRateBps,
                 integratorPublicKey,
+                useAvailableBalance,
             });
             if (!swapResponse.accepted || !swapResponse.outboundTransferId) {
                 return {
@@ -1977,10 +2123,20 @@ class FlashnetClient {
                     btcAmountReceived: "0",
                     swapTransferId: swapResponse.outboundTransferId || "",
                     ammFeePaid: quote.estimatedAmmFee,
+                    sparkTokenTransferId: swapResponse.inboundSparkTransferId,
                     error: swapResponse.error || "Swap was not accepted",
                 };
             }
-            // Step 5: Wait for the transfer to complete (unless paying immediately with existing BTC)
+            // Step 5: Wait for transfer (skip useExistingBtcBalance for zero-amount invoices)
+            let canPayImmediately = false;
+            if (!quote.isZeroAmountInvoice && useExistingBtcBalance) {
+                const invoiceAmountSats = await this.decodeInvoiceAmount(invoice);
+                const effectiveMaxLightningFee = maxLightningFeeSats ?? quote.estimatedLightningFee;
+                const btcNeededForPayment = invoiceAmountSats + effectiveMaxLightningFee;
+                const balance = await this.getBalance();
+                canPayImmediately =
+                    balance.balance >= FlashnetClient.safeBigInt(btcNeededForPayment);
+            }
             if (!canPayImmediately) {
                 const transferComplete = await this.waitForTransferCompletion(swapResponse.outboundTransferId, transferTimeoutMs);
                 if (!transferComplete) {
@@ -1991,20 +2147,57 @@ class FlashnetClient {
                         btcAmountReceived: swapResponse.amountOut || "0",
                         swapTransferId: swapResponse.outboundTransferId,
                         ammFeePaid: quote.estimatedAmmFee,
+                        sparkTokenTransferId: swapResponse.inboundSparkTransferId,
                         error: "Transfer did not complete within timeout",
                     };
                 }
             }
-            // Step 6: Calculate Lightning fee limit - use the quoted estimate, not a recalculation
+            // Step 6: Calculate Lightning fee and payment amount
             const effectiveMaxLightningFee = maxLightningFeeSats ?? quote.estimatedLightningFee;
-            // Step 7: Pay the Lightning invoice
             const btcReceived = swapResponse.amountOut || quote.btcAmountRequired;
+            // Step 7: Pay the Lightning invoice
             try {
-                const lightningPayment = await this._wallet.payLightningInvoice({
-                    invoice,
-                    maxFeeSats: effectiveMaxLightningFee,
-                    preferSpark,
-                });
+                let lightningPayment;
+                let invoiceAmountPaid;
+                if (quote.isZeroAmountInvoice) {
+                    // Zero-amount invoice: pay whatever BTC we received minus lightning fee
+                    const actualBtc = FlashnetClient.safeBigInt(btcReceived);
+                    const lnFee = FlashnetClient.safeBigInt(effectiveMaxLightningFee);
+                    const amountToPay = actualBtc - lnFee;
+                    if (amountToPay <= 0n) {
+                        return {
+                            success: false,
+                            poolId: quote.poolId,
+                            tokenAmountSpent: quote.tokenAmountRequired,
+                            btcAmountReceived: btcReceived,
+                            swapTransferId: swapResponse.outboundTransferId,
+                            ammFeePaid: quote.estimatedAmmFee,
+                            sparkTokenTransferId: swapResponse.inboundSparkTransferId,
+                            error: `BTC received (${btcReceived} sats) is not enough to cover lightning fee (${effectiveMaxLightningFee} sats).`,
+                        };
+                    }
+                    invoiceAmountPaid = Number(amountToPay);
+                    lightningPayment = await this._wallet.payLightningInvoice({
+                        invoice,
+                        amountSats: invoiceAmountPaid,
+                        maxFeeSats: effectiveMaxLightningFee,
+                        preferSpark,
+                    });
+                }
+                else {
+                    // Standard invoice: pay the specified amount
+                    lightningPayment = await this._wallet.payLightningInvoice({
+                        invoice,
+                        maxFeeSats: effectiveMaxLightningFee,
+                        preferSpark,
+                    });
+                }
+                // Extract the Spark transfer ID from the lightning payment result.
+                // payLightningInvoice returns LightningSendRequest | WalletTransfer:
+                //   - LightningSendRequest has .transfer?.sparkId (the Sparkscan-visible transfer ID)
+                //   - WalletTransfer (Spark-to-Spark) has .id directly as the transfer ID
+                // Note: lightningPayment.id (the SSP request ID) is already returned as lightningPaymentId
+                const sparkLightningTransferId = lightningPayment.transfer?.sparkId;
                 return {
                     success: true,
                     poolId: quote.poolId,
@@ -2014,6 +2207,9 @@ class FlashnetClient {
                     lightningPaymentId: lightningPayment.id,
                     ammFeePaid: quote.estimatedAmmFee,
                     lightningFeePaid: effectiveMaxLightningFee,
+                    invoiceAmountPaid,
+                    sparkTokenTransferId: swapResponse.inboundSparkTransferId,
+                    sparkLightningTransferId,
                 };
             }
             catch (lightningError) {
@@ -2033,6 +2229,7 @@ class FlashnetClient {
                                 btcAmountReceived: "0",
                                 swapTransferId: swapResponse.outboundTransferId,
                                 ammFeePaid: quote.estimatedAmmFee,
+                                sparkTokenTransferId: swapResponse.inboundSparkTransferId,
                                 error: `Lightning payment failed: ${lightningErrorMessage}. Funds rolled back to ${rollbackResult.tokenAmount} tokens.`,
                             };
                         }
@@ -2048,6 +2245,7 @@ class FlashnetClient {
                             btcAmountReceived: btcReceived,
                             swapTransferId: swapResponse.outboundTransferId,
                             ammFeePaid: quote.estimatedAmmFee,
+                            sparkTokenTransferId: swapResponse.inboundSparkTransferId,
                             error: `Lightning payment failed: ${lightningErrorMessage}. Rollback also failed: ${rollbackErrorMessage}. BTC remains in wallet.`,
                         };
                     }
@@ -2059,6 +2257,7 @@ class FlashnetClient {
                     btcAmountReceived: btcReceived,
                     swapTransferId: swapResponse.outboundTransferId,
                     ammFeePaid: quote.estimatedAmmFee,
+                    sparkTokenTransferId: swapResponse.inboundSparkTransferId,
                     error: `Lightning payment failed: ${lightningErrorMessage}. BTC (${btcReceived} sats) remains in wallet.`,
                 };
             }
@@ -2119,7 +2318,7 @@ class FlashnetClient {
      * Find the best pool for swapping a token to BTC
      * @private
      */
-    async findBestPoolForTokenToBtc(tokenAddress, btcAmountNeeded, integratorFeeRateBps) {
+    async findBestPoolForTokenToBtc(tokenAddress, baseBtcNeeded, integratorFeeRateBps) {
         const tokenHex = this.toHexTokenIdentifier(tokenAddress);
         const btcHex = index$1.BTC_ASSET_PUBKEY;
         // Find all pools that have this token paired with BTC
@@ -2163,8 +2362,8 @@ class FlashnetClient {
         const minAmounts = await this.getMinAmountsMap();
         const btcMinAmount = minAmounts.get(index$1.BTC_ASSET_PUBKEY.toLowerCase());
         // Check if the BTC amount needed is below the minimum
-        if (btcMinAmount && BigInt(btcAmountNeeded) < btcMinAmount) {
-            const msg = `Invoice amount too small. Minimum ${btcMinAmount} sats required, but invoice only requires ${btcAmountNeeded} sats.`;
+        if (btcMinAmount && BigInt(baseBtcNeeded) < btcMinAmount) {
+            const msg = `Invoice amount too small. Minimum ${btcMinAmount} sats required, but invoice only requires ${baseBtcNeeded} sats.`;
             throw new errors.FlashnetError(msg, {
                 response: {
                     errorCode: "FSAG-1003",
@@ -2178,60 +2377,99 @@ class FlashnetClient {
                 },
             });
         }
+        // Compute V2 masked BTC amount (round up to next multiple of 64 for bit masking)
+        const baseBtc = BigInt(baseBtcNeeded);
+        const BTC_VARIABLE_FEE_BITS = 6n;
+        const BTC_VARIABLE_FEE_MASK = 1n << BTC_VARIABLE_FEE_BITS; // 64
+        const maskedBtc = ((baseBtc + BTC_VARIABLE_FEE_MASK - 1n) / BTC_VARIABLE_FEE_MASK) *
+            BTC_VARIABLE_FEE_MASK;
         // Find the best pool (lowest token cost for the required BTC)
         let bestPool = null;
         let bestTokenAmount = BigInt(Number.MAX_SAFE_INTEGER);
+        let bestBtcTarget = 0n;
+        let bestCurveType = "";
         let bestSimulation = null;
         // Track errors for each pool to provide better diagnostics
         const poolErrors = [];
         for (const pool of allPools) {
             try {
-                // Get pool details for reserves
+                // Get pool details for reserves and curve type
                 const poolDetails = await this.getPool(pool.lpPublicKey);
-                // Calculate the token amount needed using AMM math
-                const calculation = this.calculateTokenAmountForBtcOutput(btcAmountNeeded, poolDetails.assetAReserve, poolDetails.assetBReserve, poolDetails.lpFeeBps, poolDetails.hostFeeBps, pool.tokenIsAssetA, integratorFeeRateBps);
-                const tokenAmount = BigInt(calculation.amountIn);
-                // Check if this is better than our current best
-                if (tokenAmount < bestTokenAmount) {
+                const isV3 = poolDetails.curveType === "V3_CONCENTRATED";
+                // V3 pools use exact BTC amount, V2 pools use masked amount
+                const btcTarget = isV3 ? baseBtc : maskedBtc;
+                const assetInAddress = pool.tokenIsAssetA
+                    ? poolDetails.assetAAddress
+                    : poolDetails.assetBAddress;
+                const assetOutAddress = pool.tokenIsAssetA
+                    ? poolDetails.assetBAddress
+                    : poolDetails.assetAAddress;
+                let tokenAmount;
+                let fee;
+                let executionPrice;
+                let priceImpactPct;
+                let warningMessage;
+                if (isV3) {
+                    // V3: binary search with simulateSwap
+                    const v3Result = await this.findV3TokenAmountForBtcOutput({
+                        poolId: pool.lpPublicKey,
+                        assetInAddress,
+                        assetOutAddress,
+                        desiredBtcOut: btcTarget,
+                        currentPriceAInB: poolDetails.currentPriceAInB,
+                        tokenIsAssetA: pool.tokenIsAssetA,
+                        integratorBps: integratorFeeRateBps,
+                    });
+                    tokenAmount = FlashnetClient.safeBigInt(v3Result.amountIn);
+                    fee = v3Result.totalFee;
+                    executionPrice = v3Result.simulation.executionPrice || "0";
+                    priceImpactPct = v3Result.simulation.priceImpactPct || "0";
+                    warningMessage = v3Result.simulation.warningMessage;
+                }
+                else {
+                    // V2: constant product math + simulation verification
+                    const calculation = this.calculateTokenAmountForBtcOutput(btcTarget.toString(), poolDetails.assetAReserve, poolDetails.assetBReserve, poolDetails.lpFeeBps, poolDetails.hostFeeBps, pool.tokenIsAssetA, integratorFeeRateBps);
+                    tokenAmount = FlashnetClient.safeBigInt(calculation.amountIn);
                     // Verify with simulation
                     const simulation = await this.simulateSwap({
                         poolId: pool.lpPublicKey,
-                        assetInAddress: pool.tokenIsAssetA
-                            ? poolDetails.assetAAddress
-                            : poolDetails.assetBAddress,
-                        assetOutAddress: pool.tokenIsAssetA
-                            ? poolDetails.assetBAddress
-                            : poolDetails.assetAAddress,
+                        assetInAddress,
+                        assetOutAddress,
                         amountIn: calculation.amountIn,
                         integratorBps: integratorFeeRateBps,
                     });
-                    // Verify the output is sufficient
-                    if (BigInt(simulation.amountOut) >= BigInt(btcAmountNeeded)) {
-                        bestPool = pool;
-                        bestTokenAmount = tokenAmount;
-                        bestSimulation = {
-                            amountIn: calculation.amountIn,
-                            fee: calculation.totalFee,
-                            executionPrice: simulation.executionPrice || "0",
-                            priceImpactPct: simulation.priceImpactPct || "0",
-                            warningMessage: simulation.warningMessage,
-                        };
-                    }
-                    else {
-                        // Simulation output was insufficient
+                    if (FlashnetClient.safeBigInt(simulation.amountOut) < btcTarget) {
                         const btcReserve = pool.tokenIsAssetA
                             ? poolDetails.assetBReserve
                             : poolDetails.assetAReserve;
                         poolErrors.push({
                             poolId: pool.lpPublicKey,
-                            error: `Simulation output (${simulation.amountOut} sats) < required (${btcAmountNeeded} sats)`,
+                            error: `Simulation output (${simulation.amountOut} sats) < required (${btcTarget} sats)`,
                             btcReserve,
                         });
+                        continue;
                     }
+                    fee = calculation.totalFee;
+                    executionPrice = simulation.executionPrice || "0";
+                    priceImpactPct = simulation.priceImpactPct || "0";
+                    warningMessage = simulation.warningMessage;
+                }
+                // Check if this pool offers a better rate
+                if (tokenAmount < bestTokenAmount) {
+                    bestPool = pool;
+                    bestTokenAmount = tokenAmount;
+                    bestBtcTarget = btcTarget;
+                    bestCurveType = poolDetails.curveType;
+                    bestSimulation = {
+                        amountIn: tokenAmount.toString(),
+                        fee,
+                        executionPrice,
+                        priceImpactPct,
+                        warningMessage,
+                    };
                 }
             }
             catch (e) {
-                // Capture pool errors for diagnostics
                 const errorMessage = e instanceof Error ? e.message : String(e);
                 poolErrors.push({
                     poolId: pool.lpPublicKey,
@@ -2240,7 +2478,7 @@ class FlashnetClient {
             }
         }
         if (!bestPool || !bestSimulation) {
-            let errorMessage = `No pool has sufficient liquidity for ${btcAmountNeeded} sats`;
+            let errorMessage = `No pool has sufficient liquidity for ${baseBtcNeeded} sats`;
             if (poolErrors.length > 0) {
                 const details = poolErrors
                     .map((pe) => {
@@ -2278,6 +2516,8 @@ class FlashnetClient {
                 assetBReserve: poolDetails.assetBReserve,
             },
             warningMessage: bestSimulation.warningMessage,
+            btcAmountUsed: bestBtcTarget.toString(),
+            curveType: bestCurveType,
         };
     }
     /**
@@ -2286,9 +2526,9 @@ class FlashnetClient {
      * @private
      */
     calculateTokenAmountForBtcOutput(btcAmountOut, reserveA, reserveB, lpFeeBps, hostFeeBps, tokenIsAssetA, integratorFeeBps) {
-        const amountOut = BigInt(btcAmountOut);
-        const resA = BigInt(reserveA);
-        const resB = BigInt(reserveB);
+        const amountOut = FlashnetClient.safeBigInt(btcAmountOut);
+        const resA = FlashnetClient.safeBigInt(reserveA);
+        const resB = FlashnetClient.safeBigInt(reserveB);
         const totalFeeBps = lpFeeBps + hostFeeBps + (integratorFeeBps || 0);
         const feeRate = Number(totalFeeBps) / 10000; // Convert bps to decimal
         // Token is the input asset
@@ -2345,12 +2585,133 @@ class FlashnetClient {
             };
         }
     }
+    /**
+     * Find the token amount needed to get a specific BTC output from a V3 concentrated liquidity pool.
+     * Uses binary search with simulateSwap since V3 tick-based math can't be inverted locally.
+     * @private
+     */
+    async findV3TokenAmountForBtcOutput(params) {
+        const { poolId, assetInAddress, assetOutAddress, desiredBtcOut, currentPriceAInB, tokenIsAssetA, integratorBps, } = params;
+        // Step 1: Compute initial estimate from pool price
+        let estimate;
+        if (currentPriceAInB && currentPriceAInB !== "0") {
+            const price = Number(currentPriceAInB);
+            if (tokenIsAssetA) {
+                // priceAInB = how much B (BTC) per 1 A (token), so tokenNeeded = btcOut / price
+                estimate = BigInt(Math.ceil(Number(desiredBtcOut) / price));
+            }
+            else {
+                // priceAInB = how much B (token) per 1 A (BTC), so tokenNeeded = btcOut * price
+                estimate = BigInt(Math.ceil(Number(desiredBtcOut) * price));
+            }
+            // Ensure non-zero
+            if (estimate <= 0n) {
+                estimate = desiredBtcOut * 2n;
+            }
+        }
+        else {
+            estimate = desiredBtcOut * 2n;
+        }
+        // Step 2: Find upper bound by simulating with estimate + 10% buffer
+        let upperBound = (estimate * 110n) / 100n;
+        if (upperBound <= 0n) {
+            upperBound = 1n;
+        }
+        let upperSim = null;
+        for (let attempt = 0; attempt < 3; attempt++) {
+            const sim = await this.simulateSwap({
+                poolId,
+                assetInAddress,
+                assetOutAddress,
+                amountIn: upperBound.toString(),
+                integratorBps,
+            });
+            if (FlashnetClient.safeBigInt(sim.amountOut) >= desiredBtcOut) {
+                upperSim = sim;
+                break;
+            }
+            // Double the upper bound
+            upperBound = upperBound * 2n;
+        }
+        if (!upperSim) {
+            throw new Error(`V3 pool ${poolId} has insufficient liquidity for ${desiredBtcOut} sats`);
+        }
+        // Step 3: Refine estimate via linear interpolation
+        const upperOut = FlashnetClient.safeBigInt(upperSim.amountOut);
+        // Scale proportionally: if upperBound produced upperOut, we need roughly
+        // (upperBound * desiredBtcOut / upperOut). Add +1 to avoid undershoot from truncation.
+        let refined = (upperBound * desiredBtcOut) / upperOut + 1n;
+        if (refined <= 0n) {
+            refined = 1n;
+        }
+        let bestAmountIn = upperBound;
+        let bestSim = upperSim;
+        // Check if the refined estimate is tighter
+        if (refined < upperBound) {
+            const refinedSim = await this.simulateSwap({
+                poolId,
+                assetInAddress,
+                assetOutAddress,
+                amountIn: refined.toString(),
+                integratorBps,
+            });
+            if (FlashnetClient.safeBigInt(refinedSim.amountOut) >= desiredBtcOut) {
+                bestAmountIn = refined;
+                bestSim = refinedSim;
+            }
+            else {
+                // Refined estimate was slightly too low. Keep upperBound as best,
+                // and let binary search narrow between refined (too low) and upperBound (sufficient).
+                bestAmountIn = upperBound;
+                bestSim = upperSim;
+            }
+        }
+        // Step 4: Binary search to converge on minimum amountIn
+        // Use a tight range: the interpolation is close, so search between 99.5% and 100% of best
+        let lo = bestAmountIn === upperBound
+            ? refined < upperBound
+                ? refined
+                : (bestAmountIn * 99n) / 100n
+            : (bestAmountIn * 999n) / 1000n;
+        if (lo <= 0n) {
+            lo = 1n;
+        }
+        let hi = bestAmountIn;
+        for (let i = 0; i < 6; i++) {
+            if (hi - lo <= 1n) {
+                break;
+            }
+            const mid = (lo + hi) / 2n;
+            const midSim = await this.simulateSwap({
+                poolId,
+                assetInAddress,
+                assetOutAddress,
+                amountIn: mid.toString(),
+                integratorBps,
+            });
+            if (FlashnetClient.safeBigInt(midSim.amountOut) >= desiredBtcOut) {
+                hi = mid;
+                bestAmountIn = mid;
+                bestSim = midSim;
+            }
+            else {
+                lo = mid;
+            }
+        }
+        // Compute fee from the best simulation
+        const totalFee = bestSim.feePaidAssetIn || "0";
+        return {
+            amountIn: bestAmountIn.toString(),
+            totalFee,
+            simulation: bestSim,
+        };
+    }
     /**
      * Calculate minimum amount out with slippage protection
      * @private
      */
     calculateMinAmountOut(expectedAmount, slippageBps) {
-        const amount = BigInt(expectedAmount);
+        const amount = FlashnetClient.safeBigInt(expectedAmount);
         const slippageFactor = BigInt(10000 - slippageBps);
         const minAmount = (amount * slippageFactor) / 10000n;
         return minAmount.toString();
@@ -2569,8 +2930,11 @@ class FlashnetClient {
         const map = new Map();
         for (const item of config) {
             if (item.enabled) {
+                if (item.min_amount == null) {
+                    continue;
+                }
                 const key = item.asset_identifier.toLowerCase();
-                const value = BigInt(String(item.min_amount));
+                const value = FlashnetClient.safeBigInt(item.min_amount);
                 map.set(key, value);
             }
         }
@@ -2592,8 +2956,8 @@ class FlashnetClient {
         const outHex = this.getHexAddress(params.assetOutAddress);
         const minIn = minMap.get(inHex);
         const minOut = minMap.get(outHex);
-        const amountIn = BigInt(String(params.amountIn));
-        const minAmountOut = BigInt(String(params.minAmountOut));
+        const amountIn = FlashnetClient.safeBigInt(params.amountIn);
+        const minAmountOut = FlashnetClient.safeBigInt(params.minAmountOut);
         if (minIn && minOut) {
             if (amountIn < minIn) {
                 throw new Error(`Minimum amount not met for input asset. Required \
@@ -2627,13 +2991,13 @@ ${relaxed.toString()} (50% relaxed), provided minAmountOut ${minAmountOut.toStri
         const aMin = minMap.get(aHex);
         const bMin = minMap.get(bHex);
         if (aMin) {
-            const aAmt = BigInt(String(params.assetAAmount));
+            const aAmt = FlashnetClient.safeBigInt(params.assetAAmount);
             if (aAmt < aMin) {
                 throw new Error(`Minimum amount not met for Asset A. Required ${aMin.toString()}, provided ${aAmt.toString()}`);
             }
         }
         if (bMin) {
-            const bAmt = BigInt(String(params.assetBAmount));
+            const bAmt = FlashnetClient.safeBigInt(params.assetBAmount);
             if (bAmt < bMin) {
                 throw new Error(`Minimum amount not met for Asset B. Required ${bMin.toString()}, provided ${bAmt.toString()}`);
             }
@@ -2655,14 +3019,14 @@ ${relaxed.toString()} (50% relaxed), provided minAmountOut ${minAmountOut.toStri
         const aMin = minMap.get(aHex);
         const bMin = minMap.get(bHex);
         if (aMin) {
-            const predictedAOut = BigInt(String(simulation.assetAAmount));
+            const predictedAOut = FlashnetClient.safeBigInt(simulation.assetAAmount);
             const relaxedA = aMin / 2n; // apply 50% relaxation for outputs
             if (predictedAOut < relaxedA) {
                 throw new Error(`Minimum amount not met for Asset A on withdrawal. Required at least ${relaxedA.toString()} (50% relaxed), predicted ${predictedAOut.toString()}`);
             }
         }
         if (bMin) {
-            const predictedBOut = BigInt(String(simulation.assetBAmount));
+            const predictedBOut = FlashnetClient.safeBigInt(simulation.assetBAmount);
             const relaxedB = bMin / 2n;
             if (predictedBOut < relaxedB) {
                 throw new Error(`Minimum amount not met for Asset B on withdrawal. Required at least ${relaxedB.toString()} (50% relaxed), predicted ${predictedBOut.toString()}`);
@@ -2775,20 +3139,20 @@ ${relaxed.toString()} (50% relaxed), provided minAmountOut ${minAmountOut.toStri
         const transferIds = [];
         // Transfer assets if not using free balance
         if (!params.useFreeBalance) {
-            if (BigInt(params.amountADesired) > 0n) {
+            if (FlashnetClient.safeBigInt(params.amountADesired) > 0n) {
                 assetATransferId = await this.transferAsset({
                     receiverSparkAddress: lpSparkAddress,
                     assetAddress: pool.assetAAddress,
                     amount: params.amountADesired,
-                }, "Insufficient balance for adding V3 liquidity (Asset A): ");
+                }, "Insufficient balance for adding V3 liquidity (Asset A): ", params.useAvailableBalance);
                 transferIds.push(assetATransferId);
             }
-            if (BigInt(params.amountBDesired) > 0n) {
+            if (FlashnetClient.safeBigInt(params.amountBDesired) > 0n) {
                 assetBTransferId = await this.transferAsset({
                     receiverSparkAddress: lpSparkAddress,
                     assetAddress: pool.assetBAddress,
                     amount: params.amountBDesired,
-                }, "Insufficient balance for adding V3 liquidity (Asset B): ");
+                }, "Insufficient balance for adding V3 liquidity (Asset B): ", params.useAvailableBalance);
                 transferIds.push(assetBTransferId);
             }
         }
@@ -2981,14 +3345,14 @@ ${relaxed.toString()} (50% relaxed), provided minAmountOut ${minAmountOut.toStri
                 receiverSparkAddress: lpSparkAddress,
                 assetAddress: pool.assetAAddress,
                 amount: params.additionalAmountA,
-            }, "Insufficient balance for rebalance (Asset A): ");
+            }, "Insufficient balance for rebalance (Asset A): ", params.useAvailableBalance);
         }
         if (params.additionalAmountB && BigInt(params.additionalAmountB) > 0n) {
             assetBTransferId = await this.transferAsset({
                 receiverSparkAddress: lpSparkAddress,
                 assetAddress: pool.assetBAddress,
                 amount: params.additionalAmountB,
-            }, "Insufficient balance for rebalance (Asset B): ");
+            }, "Insufficient balance for rebalance (Asset B): ", params.useAvailableBalance);
         }
         // Collect transfer IDs for potential clawback
         const transferIds = [];
@@ -3180,20 +3544,20 @@ ${relaxed.toString()} (50% relaxed), provided minAmountOut ${minAmountOut.toStri
         let assetBTransferId = "";
         const transferIds = [];
         // Transfer assets to pool
-        if (BigInt(params.amountA) > 0n) {
+        if (FlashnetClient.safeBigInt(params.amountA) > 0n) {
             assetATransferId = await this.transferAsset({
                 receiverSparkAddress: lpSparkAddress,
                 assetAddress: pool.assetAAddress,
                 amount: params.amountA,
-            }, "Insufficient balance for depositing to V3 pool (Asset A): ");
+            }, "Insufficient balance for depositing to V3 pool (Asset A): ", params.useAvailableBalance);
             transferIds.push(assetATransferId);
         }
-        if (BigInt(params.amountB) > 0n) {
+        if (FlashnetClient.safeBigInt(params.amountB) > 0n) {
             assetBTransferId = await this.transferAsset({
                 receiverSparkAddress: lpSparkAddress,
                 assetAddress: pool.assetBAddress,
                 amount: params.amountB,
-            }, "Insufficient balance for depositing to V3 pool (Asset B): ");
+            }, "Insufficient balance for depositing to V3 pool (Asset B): ", params.useAvailableBalance);
             transferIds.push(assetBTransferId);
         }
         const executeDeposit = async () => {