@flashnet/sdk 0.5.4 → 0.5.5

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

@@ -9,6 +9,7 @@ import { getHexFromUint8Array } from '../utils/hex.js';
 import { generateConstantProductPoolInitializationIntentMessage, generatePoolInitializationIntentMessage, generatePoolConfirmInitialDepositIntentMessage, generatePoolSwapIntentMessage, generateRouteSwapIntentMessage, generateAddLiquidityIntentMessage, generateRemoveLiquidityIntentMessage, generateRegisterHostIntentMessage, generateWithdrawHostFeesIntentMessage, generateWithdrawIntegratorFeesIntentMessage, generateCreateEscrowIntentMessage, generateFundEscrowIntentMessage, generateClaimEscrowIntentMessage, generateClawbackIntentMessage, generateCreateConcentratedPoolIntentMessage, generateDecreaseLiquidityIntentMessage, generateCollectFeesIntentMessage, generateWithdrawBalanceIntentMessage, generateIncreaseLiquidityIntentMessage, generateRebalancePositionIntentMessage, generateDepositBalanceIntentMessage } from '../utils/intents.js';
 import { getSparkNetworkFromAddress, encodeSparkAddressNew } from '../utils/spark-address.js';
 import { encodeSparkHumanReadableTokenIdentifier, decodeSparkHumanReadableTokenIdentifier } from '../utils/tokenAddress.js';
+import { safeBigInt } from '../utils/bigint.js';
 import { FlashnetError } from '../types/errors.js';
 
 /**
@@ -239,7 +240,8 @@ class FlashnetClient {
                 const tokenIdentifierHex = getHexFromUint8Array(info.rawTokenIdentifier);
                 const 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,
@@ -252,7 +254,7 @@ class FlashnetClient {
             }
         }
         return {
-            balance: BigInt(balance.balance),
+            balance: FlashnetClient.safeBigInt(balance.balance),
             tokenBalances,
         };
     }
@@ -260,17 +262,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 === 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
@@ -288,7 +290,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 ?? "",
@@ -350,6 +354,7 @@ class FlashnetClient {
                     },
                 ],
                 errorPrefix: "Insufficient balance for initial liquidity: ",
+                useAvailableBalance: params.useAvailableBalance,
             });
         }
         const poolOwnerPublicKey = params.poolOwnerPublicKey ?? this.publicKey;
@@ -409,6 +414,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 safeBigInt(value, fallback);
+    }
     /**
      * Calculates virtual reserves for a bonding curve AMM.
      *
@@ -429,7 +440,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;
@@ -479,6 +490,7 @@ class FlashnetClient {
                 },
             ],
             errorPrefix: "Insufficient balance for pool creation: ",
+            useAvailableBalance: params.useAvailableBalance,
         });
         const poolOwnerPublicKey = params.poolOwnerPublicKey ?? this.publicKey;
         // Generate intent
@@ -599,10 +611,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 = encodeSparkAddressNew({
@@ -613,12 +629,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.
@@ -748,7 +765,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
@@ -871,7 +888,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
@@ -1177,6 +1194,7 @@ class FlashnetClient {
             depositAddress: createResponse.depositAddress,
             assetId: params.assetId,
             assetAmount: params.assetAmount,
+            useAvailableBalance: params.useAvailableBalance,
         });
     }
     /**
@@ -1194,6 +1212,7 @@ class FlashnetClient {
                 { assetAddress: params.assetId, amount: params.assetAmount },
             ],
             errorPrefix: "Insufficient balance to fund escrow: ",
+            useAvailableBalance: params.useAvailableBalance,
         });
         // 2. Perform transfer
         const escrowSparkAddress = encodeSparkAddressNew({
@@ -1708,19 +1727,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 = [];
@@ -1735,7 +1755,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);
@@ -1842,7 +1862,8 @@ class FlashnetClient {
         const lightningFeeEstimate = await this.getLightningFeeEstimate(invoice);
         // Total BTC needed = invoice amount + lightning fee (unmasked).
         // Bitmasking for V2 pools is handled inside findBestPoolForTokenToBtc.
-        const baseBtcNeeded = BigInt(invoiceAmountSats) + BigInt(lightningFeeEstimate);
+        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)
@@ -1869,7 +1890,7 @@ class FlashnetClient {
         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 FlashnetError(msg, {
                 response: {
@@ -1886,7 +1907,7 @@ class FlashnetClient {
         }
         // 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(BigInt(poolQuote.btcAmountUsed) - baseBtcNeeded);
+        const btcVariableFeeAdjustment = Number(FlashnetClient.safeBigInt(poolQuote.btcAmountUsed) - baseBtcNeeded);
         return {
             poolId: poolQuote.poolId,
             tokenAddress: this.toHexTokenIdentifier(tokenAddress),
@@ -1958,7 +1979,7 @@ class FlashnetClient {
                     amountIn: tokenAmount,
                     integratorBps: options?.integratorFeeRateBps,
                 });
-                const btcOut = BigInt(simulation.amountOut);
+                const btcOut = FlashnetClient.safeBigInt(simulation.amountOut);
                 if (btcOut > bestBtcOut) {
                     bestBtcOut = btcOut;
                     bestResult = {
@@ -2046,7 +2067,7 @@ class FlashnetClient {
         await this.ensureInitialized();
         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, {
@@ -2063,6 +2084,7 @@ class FlashnetClient {
                     },
                 ],
                 errorPrefix: "Insufficient token balance for Lightning payment: ",
+                useAvailableBalance,
             });
             // Step 3: Get pool details
             const pool = await this.getPool(quote.poolId);
@@ -2085,6 +2107,7 @@ class FlashnetClient {
                 minAmountOut: minBtcOut,
                 integratorFeeRateBps,
                 integratorPublicKey,
+                useAvailableBalance,
             });
             if (!swapResponse.accepted || !swapResponse.outboundTransferId) {
                 return {
@@ -2094,6 +2117,7 @@ class FlashnetClient {
                     btcAmountReceived: "0",
                     swapTransferId: swapResponse.outboundTransferId || "",
                     ammFeePaid: quote.estimatedAmmFee,
+                    sparkTokenTransferId: swapResponse.inboundSparkTransferId,
                     error: swapResponse.error || "Swap was not accepted",
                 };
             }
@@ -2104,7 +2128,8 @@ class FlashnetClient {
                 const effectiveMaxLightningFee = maxLightningFeeSats ?? quote.estimatedLightningFee;
                 const btcNeededForPayment = invoiceAmountSats + effectiveMaxLightningFee;
                 const balance = await this.getBalance();
-                canPayImmediately = balance.balance >= BigInt(btcNeededForPayment);
+                canPayImmediately =
+                    balance.balance >= FlashnetClient.safeBigInt(btcNeededForPayment);
             }
             if (!canPayImmediately) {
                 const transferComplete = await this.waitForTransferCompletion(swapResponse.outboundTransferId, transferTimeoutMs);
@@ -2116,6 +2141,7 @@ class FlashnetClient {
                         btcAmountReceived: swapResponse.amountOut || "0",
                         swapTransferId: swapResponse.outboundTransferId,
                         ammFeePaid: quote.estimatedAmmFee,
+                        sparkTokenTransferId: swapResponse.inboundSparkTransferId,
                         error: "Transfer did not complete within timeout",
                     };
                 }
@@ -2129,8 +2155,8 @@ class FlashnetClient {
                 let invoiceAmountPaid;
                 if (quote.isZeroAmountInvoice) {
                     // Zero-amount invoice: pay whatever BTC we received minus lightning fee
-                    const actualBtc = BigInt(btcReceived);
-                    const lnFee = BigInt(effectiveMaxLightningFee);
+                    const actualBtc = FlashnetClient.safeBigInt(btcReceived);
+                    const lnFee = FlashnetClient.safeBigInt(effectiveMaxLightningFee);
                     const amountToPay = actualBtc - lnFee;
                     if (amountToPay <= 0n) {
                         return {
@@ -2140,6 +2166,7 @@ class FlashnetClient {
                             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).`,
                         };
                     }
@@ -2159,6 +2186,12 @@ class FlashnetClient {
                         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,
@@ -2169,6 +2202,8 @@ class FlashnetClient {
                     ammFeePaid: quote.estimatedAmmFee,
                     lightningFeePaid: effectiveMaxLightningFee,
                     invoiceAmountPaid,
+                    sparkTokenTransferId: swapResponse.inboundSparkTransferId,
+                    sparkLightningTransferId,
                 };
             }
             catch (lightningError) {
@@ -2188,6 +2223,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.`,
                             };
                         }
@@ -2203,6 +2239,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.`,
                         };
                     }
@@ -2214,6 +2251,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.`,
                 };
             }
@@ -2376,7 +2414,7 @@ class FlashnetClient {
                         tokenIsAssetA: pool.tokenIsAssetA,
                         integratorBps: integratorFeeRateBps,
                     });
-                    tokenAmount = BigInt(v3Result.amountIn);
+                    tokenAmount = FlashnetClient.safeBigInt(v3Result.amountIn);
                     fee = v3Result.totalFee;
                     executionPrice = v3Result.simulation.executionPrice || "0";
                     priceImpactPct = v3Result.simulation.priceImpactPct || "0";
@@ -2385,7 +2423,7 @@ class FlashnetClient {
                 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 = BigInt(calculation.amountIn);
+                    tokenAmount = FlashnetClient.safeBigInt(calculation.amountIn);
                     // Verify with simulation
                     const simulation = await this.simulateSwap({
                         poolId: pool.lpPublicKey,
@@ -2394,7 +2432,7 @@ class FlashnetClient {
                         amountIn: calculation.amountIn,
                         integratorBps: integratorFeeRateBps,
                     });
-                    if (BigInt(simulation.amountOut) < btcTarget) {
+                    if (FlashnetClient.safeBigInt(simulation.amountOut) < btcTarget) {
                         const btcReserve = pool.tokenIsAssetA
                             ? poolDetails.assetBReserve
                             : poolDetails.assetAReserve;
@@ -2482,9 +2520,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
@@ -2582,7 +2620,7 @@ class FlashnetClient {
                 amountIn: upperBound.toString(),
                 integratorBps,
             });
-            if (BigInt(sim.amountOut) >= desiredBtcOut) {
+            if (FlashnetClient.safeBigInt(sim.amountOut) >= desiredBtcOut) {
                 upperSim = sim;
                 break;
             }
@@ -2593,7 +2631,7 @@ class FlashnetClient {
             throw new Error(`V3 pool ${poolId} has insufficient liquidity for ${desiredBtcOut} sats`);
         }
         // Step 3: Refine estimate via linear interpolation
-        const upperOut = BigInt(upperSim.amountOut);
+        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;
@@ -2611,7 +2649,7 @@ class FlashnetClient {
                 amountIn: refined.toString(),
                 integratorBps,
             });
-            if (BigInt(refinedSim.amountOut) >= desiredBtcOut) {
+            if (FlashnetClient.safeBigInt(refinedSim.amountOut) >= desiredBtcOut) {
                 bestAmountIn = refined;
                 bestSim = refinedSim;
             }
@@ -2645,7 +2683,7 @@ class FlashnetClient {
                 amountIn: mid.toString(),
                 integratorBps,
             });
-            if (BigInt(midSim.amountOut) >= desiredBtcOut) {
+            if (FlashnetClient.safeBigInt(midSim.amountOut) >= desiredBtcOut) {
                 hi = mid;
                 bestAmountIn = mid;
                 bestSim = midSim;
@@ -2667,7 +2705,7 @@ class FlashnetClient {
      * @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();
@@ -2886,8 +2924,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);
             }
         }
@@ -2909,8 +2950,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 \
@@ -2944,13 +2985,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()}`);
             }
@@ -2972,14 +3013,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()}`);
@@ -3092,20 +3133,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);
             }
         }
@@ -3298,14 +3339,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 = [];
@@ -3497,20 +3538,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 () => {