0xtrails 0.8.2 → 0.8.3

package/src/transactionIntent/handlers/sameChainSameToken.ts

@@ -42,6 +42,7 @@ import { pollIntentReceipt } from "../../intentReceiptPoller.js"
 import { isNativeToken } from "../../utils.js"
 import { getAccountTransactionHistory } from "../../transactions.js"
 import { POLLING_INTERVALS } from "../constants.js"
+import { invalidateTokenBalancesCache } from "../../tokenBalances.js"
 
 export async function handleSameChainSameToken({
   mainSignerAddress,
@@ -54,7 +55,6 @@ export async function handleSameChainSameToken({
   recipient,
   walletClient,
   onTransactionStateChange,
-  dryMode,
   account,
   chain,
   transactionStates,
@@ -77,6 +77,7 @@ export async function handleSameChainSameToken({
   isSmartWallet,
   trailsApiKey,
   trailsApiUrl,
+  tradeType = TradeType.EXACT_INPUT,
 }: {
   mainSignerAddress: string
   originTokenAddress: string
@@ -89,14 +90,13 @@ export async function handleSameChainSameToken({
   originChainId: number
   walletClient: WalletClient
   onTransactionStateChange: (transactionStates: TransactionState[]) => void
-  dryMode: boolean
   account: Account
   chain: Chain
   transactionStates: TransactionState[]
   sourceTokenPriceUsd?: number | null
   destinationTokenPriceUsd?: number | null
   originNativeTokenPriceUsd?: number | null
-  slippageTolerance: string
+  slippageTolerance: string | null
   swapProvider?: RouteProvider | null
   checkoutOnHandlers?: Partial<CheckoutOnHandlers>
   mode?: "pay" | "fund" | "earn" | "swap"
@@ -116,6 +116,8 @@ export async function handleSameChainSameToken({
   isSmartWallet?: boolean
   trailsApiKey?: string
   trailsApiUrl?: string
+  /** Trade type for the transaction. Defaults to EXACT_INPUT. */
+  tradeType?: TradeType
 }): Promise<PrepareSendReturn> {
   logger.console.log("[trails-sdk] isToSameToken && isToSameChain")
   const testnet = isTestnetDebugMode()
@@ -273,143 +275,145 @@ export async function handleSameChainSameToken({
 
           let originUserTxReceipt: TransactionReceipt | null = null
 
-          if (!dryMode) {
-            // Update transaction state to pending
-            try {
-              onTransactionStateChange([
-                {
-                  transactionHash: "",
-                  explorerUrl: "",
-                  chainId: effectiveOriginChainId,
-                  state: "pending",
-                  label: "Execute",
-                },
-              ])
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] Error calling onTransactionStateChange:",
-                error,
-              )
-            }
-
-            // Show persistent toast for checkout flow
-            updatePersistentToast(
-              "Payment Started",
-              "Waiting for wallet confirmation...",
-              "info",
-            )
-
-            logger.console.log(
-              "[trails-sdk] origin call params",
-              originCallParams,
-            )
-
-            // Use sendOriginTransaction helper which handles gas estimation, fee boosting, and tracking
-            const txHash = await sendOriginTransaction(
-              account,
-              walletClient,
-              originCallParams as any,
+          // Update transaction state to pending
+          try {
+            onTransactionStateChange([
               {
-                depositTokenAmountUsd: depositAmountUsd?.toString(),
+                transactionHash: "",
+                explorerUrl: "",
+                chainId: effectiveOriginChainId,
+                state: "pending",
+                label: "Execute",
               },
+            ])
+          } catch (error) {
+            logger.console.error(
+              "[trails-sdk] Error calling onTransactionStateChange:",
+              error,
             )
+          }
 
-            logger.console.log("[trails-sdk] origin tx", txHash)
+          // Show persistent toast for checkout flow
+          updatePersistentToast(
+            "Payment Started",
+            "Waiting for wallet confirmation...",
+            "info",
+          )
 
-            if (onOriginSend) {
-              onOriginSend()
-            }
+          logger.console.log(
+            "[trails-sdk] origin call params",
+            originCallParams,
+          )
+
+          // Use sendOriginTransaction helper which handles gas estimation, fee boosting, and tracking
+          const txHash = await sendOriginTransaction(
+            account,
+            walletClient,
+            originCallParams as any,
+            {
+              depositTokenAmountUsd: depositAmountUsd?.toString(),
+            },
+          )
+
+          logger.console.log("[trails-sdk] origin tx", txHash)
+
+          if (onOriginSend) {
+            onOriginSend()
+          }
+
+          // Wait for transaction receipt
+          const receipt = await effectivePublicClient.waitForTransactionReceipt(
+            {
+              hash: txHash,
+            },
+          )
+          logger.console.log("[trails-sdk] receipt", receipt)
+          originUserTxReceipt = receipt
 
-            // Wait for transaction receipt
-            const receipt =
-              await effectivePublicClient.waitForTransactionReceipt({
-                hash: txHash,
-              })
-            logger.console.log("[trails-sdk] receipt", receipt)
-            originUserTxReceipt = receipt
-
-            // Track transaction confirmation
-            trackTransactionConfirmed({
-              transactionHash: txHash,
-              chainId: effectiveOriginChainId,
+          // Track transaction confirmation
+          trackTransactionConfirmed({
+            transactionHash: txHash,
+            chainId: effectiveOriginChainId,
+            userAddress: account.address,
+            blockNumber: Number(receipt.blockNumber),
+            originTokenAddress: effectiveOriginTokenAddress,
+            depositTokenAmountUsd: depositAmountUsd?.toString(),
+          })
+
+          // Remove persistent toast and show success
+          const chainInfo = getChainInfo(effectiveOriginChainId)
+          updatePersistentToast(
+            "Transfer Confirmed",
+            `Your transaction on ${(chainInfo as any)?.name || "chain"} has been confirmed`,
+            "info",
+          )
+
+          // Update transaction state to completed
+          try {
+            onTransactionStateChange([
+              getTransactionStateFromReceipt(
+                originUserTxReceipt,
+                effectiveOriginChainId,
+                transactionStates[0]?.label || "Execute",
+              ),
+            ])
+          } catch (error) {
+            logger.console.error(
+              "[trails-sdk] Error calling onTransactionStateChange:",
+              error,
+            )
+          }
+
+          // Track payment completion for same-chain same-token transaction
+          if (originUserTxReceipt && originUserTxReceipt.status === "success") {
+            trackPaymentCompleted({
               userAddress: account.address,
-              blockNumber: Number(receipt.blockNumber),
+              originTxHash: originUserTxReceipt.transactionHash,
+              originChainId: effectiveOriginChainId,
+              mode,
+              fundMethod,
               originTokenAddress: effectiveOriginTokenAddress,
+              originTokenSymbol,
+              originTokenAmount: swapAmount,
+              originTokenAmountFormatted: depositAmountFormatted.toString(),
+              destinationTokenAddress: effectiveOriginTokenAddress, // same chain same token
+              destinationTokenSymbol: destinationTokenSymbol,
+              depositTokenAmount: swapAmount,
+              depositTokenAmountFormatted: depositAmountFormatted.toString(),
               depositTokenAmountUsd: depositAmountUsd?.toString(),
+              destinationTokenAmount: swapAmount, // same as deposit amount
+              destinationTokenAmountFormatted:
+                depositAmountFormatted.toString(), // same as deposit amount
+              destinationTokenAmountUsd: depositAmountUsd?.toString(), // same as deposit amount
+              originTokenDecimals: originTokenDecimals,
+              destinationTokenDecimals: originTokenDecimals, // same chain same token
             })
 
-            // Remove persistent toast and show success
-            const chainInfo = getChainInfo(effectiveOriginChainId)
-            updatePersistentToast(
-              "Transfer Confirmed",
-              `Your transaction on ${(chainInfo as any)?.name || "chain"} has been confirmed`,
-              "info",
-            )
+            // Invalidate token balances cache on successful transactions
+            invalidateTokenBalancesCache(account.address)
 
-            // Update transaction state to completed
-            try {
-              onTransactionStateChange([
-                getTransactionStateFromReceipt(
-                  originUserTxReceipt,
-                  effectiveOriginChainId,
-                  transactionStates[0]?.label || "Execute",
-                ),
-              ])
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] Error calling onTransactionStateChange:",
-                error,
+            // Call onCheckoutComplete callback if provided
+            if (checkoutOnHandlers?.triggerCheckoutComplete) {
+              checkoutOnHandlers.triggerCheckoutComplete(
+                "success",
+                account.address,
               )
             }
+          } else if (originUserTxReceipt) {
+            trackPaymentError({
+              error: "Transaction failed",
+              userAddress: account.address,
+              mode,
+              fundMethod,
+              originTokenAddress: effectiveOriginTokenAddress,
+            })
 
-            // Track payment completion for same-chain same-token transaction
-            if (
-              originUserTxReceipt &&
-              originUserTxReceipt.status === "success"
-            ) {
-              trackPaymentCompleted({
-                userAddress: account.address,
-                originTxHash: originUserTxReceipt.transactionHash,
-                originChainId: effectiveOriginChainId,
-                mode,
-                fundMethod,
-                originTokenAddress: effectiveOriginTokenAddress,
-                originTokenSymbol,
-                originTokenAmount: swapAmount,
-                originTokenAmountFormatted: depositAmountFormatted.toString(),
-                destinationTokenAddress: effectiveOriginTokenAddress, // same chain same token
-                destinationTokenSymbol: destinationTokenSymbol,
-                depositTokenAmount: swapAmount,
-                depositTokenAmountFormatted: depositAmountFormatted.toString(),
-                depositTokenAmountUsd: depositAmountUsd?.toString(),
-                destinationTokenAmount: swapAmount, // same as deposit amount
-                destinationTokenAmountFormatted:
-                  depositAmountFormatted.toString(), // same as deposit amount
-                destinationTokenAmountUsd: depositAmountUsd?.toString(), // same as deposit amount
-                originTokenDecimals: originTokenDecimals,
-                destinationTokenDecimals: originTokenDecimals, // same chain same token
-              })
-
-              // Call onCheckoutComplete callback if provided
-              if (checkoutOnHandlers?.triggerCheckoutComplete) {
-                checkoutOnHandlers.triggerCheckoutComplete(
-                  "success",
-                  account.address,
-                )
-              }
-            } else if (originUserTxReceipt) {
-              trackPaymentError({
-                error: "Transaction failed",
-                userAddress: account.address,
-                mode,
-                fundMethod,
-                originTokenAddress: effectiveOriginTokenAddress,
-              })
-
-              // Call onCheckoutError callback if provided
-              if (checkoutOnHandlers?.triggerCheckoutError) {
-                checkoutOnHandlers.triggerCheckoutError("Transaction failed")
-              }
+            // Invalidate token balances cache even on failure (gas was spent)
+            invalidateTokenBalancesCache(account.address)
+
+            // Call onCheckoutError callback if provided
+            if (checkoutOnHandlers?.triggerCheckoutError) {
+              checkoutOnHandlers.triggerCheckoutError("Transaction failed")
             }
           }
 
@@ -450,18 +454,20 @@ export async function handleSameChainSameToken({
   }
 
   // For same-chain transactions, use Intent flow to support gasless deposits
+  // When using EXACT_OUTPUT, both origin and destination amounts should be swapAmount
+  // since it's same-chain same-token (no swap happening)
   const intentArgs = await getIntentArgs(
     mainSignerAddress,
     effectiveOriginChainId,
     effectiveOriginTokenAddress,
-    swapAmount, // originTokenAmount
+    swapAmount, // originTokenAmount - same for both trade types in same-chain same-token
     effectiveOriginChainId, // same chain
     effectiveOriginTokenAddress, // same token
-    "0", // destinationTokenAmount (exact input)
+    tradeType === TradeType.EXACT_OUTPUT ? swapAmount : "0", // destinationTokenAmount
     recipient,
     destinationCalldata,
     slippageTolerance,
-    TradeType.EXACT_INPUT,
+    tradeType,
     swapProvider,
     null,
     undefined, // connector - not available in this context
@@ -691,487 +697,548 @@ export async function handleSameChainSameToken({
           walletClient,
           desiredChainId: effectiveOriginChainId,
         })
-        if (!dryMode) {
-          // For gasless flows on same-chain same-token, we need to track 2 transactions:
-          // [0] = Deposit transaction (relayed)
-          // [1] = Origin intent transaction (executed on chain after deposit is confirmed)
-
-          // Initialize local transaction states for gasless flows to track both deposit and execute
-          const createInitialStates = (): TransactionState[] => {
-            const depositState: TransactionState = {
-              transactionHash: "",
-              explorerUrl: "",
-              chainId: effectiveOriginChainId,
-              state: "pending",
-              label: "Deposit",
-            }
 
-            const executeState: TransactionState = {
-              transactionHash: "",
-              explorerUrl: "",
-              chainId: effectiveOriginChainId,
-              state: "pending",
-              label: "Execute",
-            }
+        // For gasless flows on same-chain same-token, we need to track 2 transactions:
+        // [0] = Deposit transaction (relayed)
+        // [1] = Origin intent transaction (executed on chain after deposit is confirmed)
+
+        // Initialize local transaction states for gasless flows to track both deposit and execute
+        const createInitialStates = (): TransactionState[] => {
+          const depositState: TransactionState = {
+            transactionHash: "",
+            explorerUrl: "",
+            chainId: effectiveOriginChainId,
+            state: "pending",
+            label: "Deposit",
+          }
 
-            return effectiveGasless
-              ? [depositState, executeState]
-              : [depositState]
+          const executeState: TransactionState = {
+            transactionHash: "",
+            explorerUrl: "",
+            chainId: effectiveOriginChainId,
+            state: "pending",
+            label: "Execute",
           }
 
-          const localTransactionStates = createInitialStates()
+          return effectiveGasless
+            ? [depositState, executeState]
+            : [depositState]
+        }
 
-          try {
-            onTransactionStateChange(localTransactionStates)
-            // Also trigger checkout status update if handler is provided
-            if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
-              checkoutOnHandlers.triggerCheckoutStatusUpdate(
-                localTransactionStates,
-              )
-            }
-          } catch (error) {
-            logger.console.error(
-              "[trails-sdk] Error calling onTransactionStateChange:",
-              error,
+        const localTransactionStates = createInitialStates()
+
+        try {
+          onTransactionStateChange(localTransactionStates)
+          // Also trigger checkout status update if handler is provided
+          if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
+            checkoutOnHandlers.triggerCheckoutStatusUpdate(
+              localTransactionStates,
             )
           }
+        } catch (error) {
+          logger.console.error(
+            "[trails-sdk] Error calling onTransactionStateChange:",
+            error,
+          )
+        }
 
-          // For gasless flows, pass the localTransactionStates instead of the input parameter
-          // This ensures we track both deposit and execute transactions
-          const statesForDeposit = effectiveGasless
-            ? localTransactionStates
-            : transactionStates
+        // For gasless flows, pass the localTransactionStates instead of the input parameter
+        // This ensures we track both deposit and execute transactions
+        const statesForDeposit = effectiveGasless
+          ? localTransactionStates
+          : transactionStates
+
+        // Use attemptUserDepositTx which handles both gasless and non-gasless flows
+        // For non-gasless same-chain same-token, pass recipient to send directly to user instead of intent contract
+        depositUserTxnReceipt = await attemptUserDepositTx({
+          originTokenAddress: effectiveOriginTokenAddress,
+          paymasterUrl,
+          chain: effectiveOriginChain,
+          account,
+          depositAmount: swapAmount,
+          originIntentAddress: intent.originIntentAddress,
+          onOriginSend,
+          publicClient: effectivePublicClient,
+          walletClient,
+          destinationTokenDecimals: originTokenDecimals,
+          sourceTokenDecimals: originTokenDecimals,
+          sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
+          destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
+          swapAmount,
+          onTransactionStateChange,
+          transactionStates: statesForDeposit,
+          fundMethod,
+          originTokenSymbol,
+          destinationTokenSymbol,
+          depositAmountUsd,
+          feeOptions: gasFeeOptions,
+          trailsContracts,
+          trailsClient,
+          selectedFeeOption: effectiveSelectedFeeOption,
+          walletId,
+          abortSignal,
+          checkoutOnHandlers,
+          intentId: intent.intentId,
+          executeIntentFn,
+          depositRecipientOverride: recipient,
+          isSameChainSameToken: true,
+          destinationCalldata,
+        })
 
-          // Use attemptUserDepositTx which handles both gasless and non-gasless flows
-          // For non-gasless same-chain same-token, pass recipient to send directly to user instead of intent contract
-          depositUserTxnReceipt = await attemptUserDepositTx({
-            originTokenAddress: effectiveOriginTokenAddress,
-            paymasterUrl,
-            chain: effectiveOriginChain,
-            account,
-            depositAmount: swapAmount,
-            originIntentAddress: intent.originIntentAddress,
-            onOriginSend,
-            publicClient: effectivePublicClient,
-            walletClient,
-            destinationTokenDecimals: originTokenDecimals,
-            sourceTokenDecimals: originTokenDecimals,
-            fee: "0",
-            dryMode,
-            sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
-            destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
-            swapAmount,
-            onTransactionStateChange,
-            transactionStates: statesForDeposit,
-            fundMethod,
-            originTokenSymbol,
-            destinationTokenSymbol,
-            depositAmountUsd,
-            feeOptions: gasFeeOptions,
-            trailsContracts,
-            trailsClient,
-            selectedFeeOption: effectiveSelectedFeeOption,
-            walletId,
-            abortSignal,
-            checkoutOnHandlers,
-            intentId: intent.intentId,
-            executeIntentFn,
-            depositRecipientOverride: recipient,
-            isSameChainSameToken: true,
-            destinationCalldata,
-          })
+        // attemptUserDepositTx handles both gasless and non-gasless flows
+        // Transaction state updates and toasts are handled within that function
+        logger.console.log("[trails-sdk] Deposit transaction completed", {
+          hasReceipt: !!depositUserTxnReceipt,
+          isGasless: effectiveGasless,
+        })
 
-          // attemptUserDepositTx handles both gasless and non-gasless flows
-          // Transaction state updates and toasts are handled within that function
-          logger.console.log("[trails-sdk] Deposit transaction completed", {
-            hasReceipt: !!depositUserTxnReceipt,
-            isGasless: effectiveGasless,
-          })
+        // For QR code mode, we need to detect the deposit first, call executeIntent, then start polling
+        // For gasless flows, we can start polling immediately
+        if (fundMethod === "qr-code" || fundMethod === "exchange") {
+          logger.console.log(
+            "[trails-sdk] QR code mode: waiting for deposit transaction before starting polling",
+          )
+          // Use the same approach as cross-chain: check for deposit via indexer
+          const checkForDepositTx = async () => {
+            while (true) {
+              // Check if we should abort
+              if (abortSignal?.aborted) {
+                logger.console.log(
+                  "[trails-sdk] Aborting deposit tx check due to abort signal",
+                )
+                return null
+              }
 
-          // For QR code mode, we need to detect the deposit first, call executeIntent, then start polling
-          // For gasless flows, we can start polling immediately
-          if (fundMethod === "qr-code" || fundMethod === "exchange") {
-            logger.console.log(
-              "[trails-sdk] QR code mode: waiting for deposit transaction before starting polling",
-            )
-            // Use the same approach as cross-chain: check for deposit via indexer
-            const checkForDepositTx = async () => {
-              while (true) {
-                // Check if we should abort
-                if (abortSignal?.aborted) {
-                  logger.console.log(
-                    "[trails-sdk] Aborting deposit tx check due to abort signal",
+              try {
+                if (!sequenceIndexerUrl) {
+                  throw new Error(
+                    "sequenceIndexerUrl is required for QR code mode",
                   )
-                  return null
                 }
-
-                try {
-                  if (!sequenceIndexerUrl) {
-                    throw new Error(
-                      "sequenceIndexerUrl is required for QR code mode",
-                    )
-                  }
-                  if (!sequenceProjectAccessKey) {
-                    throw new Error(
-                      "sequenceProjectAccessKey is required for QR code mode",
-                    )
-                  }
-                  const response = await getAccountTransactionHistory({
-                    chainId: effectiveOriginChainId,
-                    accountAddress: intent.originIntentAddress,
-                    abortSignal,
-                    apiKey: sequenceProjectAccessKey,
-                    indexerUrl: sequenceIndexerUrl,
-                  })
-                  logger.console.log(
-                    "[trails-sdk] getAccountTransactionHistory response",
-                    response,
+                if (!sequenceProjectAccessKey) {
+                  throw new Error(
+                    "sequenceProjectAccessKey is required for QR code mode",
                   )
-                  if (response.transactions.length > 0) {
-                    const tx = response.transactions[0]
-                    if (!tx?.txnHash) {
-                      await new Promise((resolve) =>
-                        setTimeout(
-                          resolve,
-                          POLLING_INTERVALS.TRANSACTION_HISTORY,
-                        ),
-                      )
-                      continue
-                    }
-                    const depositTxReceipt =
-                      await effectivePublicClient.getTransactionReceipt({
-                        hash: tx.txnHash as `0x${string}`,
-                      })
-
-                    // Validate that the deposit amount is sufficient before proceeding
-                    logger.console.log(
-                      "[trails-sdk] Checking if deposit amount is sufficient",
-                      {
-                        depositAddress: intent.originIntentAddress,
-                        requiredAmount: quote.originAmount,
-                        tokenAddress: effectiveOriginTokenAddress,
-                      },
+                }
+                const response = await getAccountTransactionHistory({
+                  chainId: effectiveOriginChainId,
+                  accountAddress: intent.originIntentAddress,
+                  abortSignal,
+                  apiKey: sequenceProjectAccessKey,
+                  indexerUrl: sequenceIndexerUrl,
+                })
+                logger.console.log(
+                  "[trails-sdk] getAccountTransactionHistory response",
+                  response,
+                )
+                if (response.transactions.length > 0) {
+                  const tx = response.transactions[0]
+                  if (!tx?.txnHash) {
+                    await new Promise((resolve) =>
+                      setTimeout(
+                        resolve,
+                        POLLING_INTERVALS.TRANSACTION_HISTORY,
+                      ),
                     )
+                    continue
+                  }
+                  const depositTxReceipt =
+                    await effectivePublicClient.getTransactionReceipt({
+                      hash: tx.txnHash as `0x${string}`,
+                    })
 
-                    const balanceCheck = await checkAccountBalance({
-                      account: {
-                        address: intent.originIntentAddress as `0x${string}`,
-                      } as Account,
+                  // Validate that the deposit amount is sufficient before proceeding
+                  logger.console.log(
+                    "[trails-sdk] Checking if deposit amount is sufficient",
+                    {
+                      depositAddress: intent.originIntentAddress,
+                      requiredAmount: quote.originAmount,
                       tokenAddress: effectiveOriginTokenAddress,
-                      depositAmount: quote.originAmount,
-                      publicClient: effectivePublicClient,
-                    })
+                    },
+                  )
 
-                    if (!balanceCheck.hasEnoughBalance) {
-                      logger.console.warn(
-                        "[trails-sdk] Deposit amount is insufficient, continuing to poll",
-                        {
-                          balance: balanceCheck.balanceFormatted,
-                          required: balanceCheck.requiredAmountFormatted,
-                          percentComplete: (
-                            (Number(balanceCheck.balance) /
-                              Number(balanceCheck.requiredAmount)) *
-                            100
-                          ).toFixed(2),
-                        },
-                      )
-                      // Continue polling - don't break out of the loop yet
-                      await new Promise((resolve) =>
-                        setTimeout(
-                          resolve,
-                          POLLING_INTERVALS.TRANSACTION_HISTORY,
-                        ),
-                      )
-                      continue
-                    }
+                  const balanceCheck = await checkAccountBalance({
+                    account: {
+                      address: intent.originIntentAddress as `0x${string}`,
+                    } as Account,
+                    tokenAddress: effectiveOriginTokenAddress,
+                    depositAmount: quote.originAmount,
+                    publicClient: effectivePublicClient,
+                  })
 
-                    logger.console.log(
-                      "[trails-sdk] Deposit amount is sufficient, proceeding",
+                  if (!balanceCheck.hasEnoughBalance) {
+                    logger.console.warn(
+                      "[trails-sdk] Deposit amount is insufficient, continuing to poll",
                       {
                         balance: balanceCheck.balanceFormatted,
                         required: balanceCheck.requiredAmountFormatted,
+                        percentComplete: (
+                          (Number(balanceCheck.balance) /
+                            Number(balanceCheck.requiredAmount)) *
+                          100
+                        ).toFixed(2),
                       },
                     )
+                    // Continue polling - don't break out of the loop yet
+                    await new Promise((resolve) =>
+                      setTimeout(
+                        resolve,
+                        POLLING_INTERVALS.TRANSACTION_HISTORY,
+                      ),
+                    )
+                    continue
+                  }
 
-                    depositUserTxnReceipt = depositTxReceipt
+                  logger.console.log(
+                    "[trails-sdk] Deposit amount is sufficient, proceeding",
+                    {
+                      balance: balanceCheck.balanceFormatted,
+                      required: balanceCheck.requiredAmountFormatted,
+                    },
+                  )
+
+                  depositUserTxnReceipt = depositTxReceipt
 
-                    localTransactionStates[0] = getTransactionStateFromReceipt(
-                      depositTxReceipt,
-                      effectiveOriginChainId,
-                      localTransactionStates[0]?.label,
+                  localTransactionStates[0] = getTransactionStateFromReceipt(
+                    depositTxReceipt,
+                    effectiveOriginChainId,
+                    localTransactionStates[0]?.label,
+                  )
+                  onTransactionStateChange(localTransactionStates)
+                  if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
+                    checkoutOnHandlers.triggerCheckoutStatusUpdate(
+                      localTransactionStates,
                     )
-                    onTransactionStateChange(localTransactionStates)
-                    if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
-                      checkoutOnHandlers.triggerCheckoutStatusUpdate(
-                        localTransactionStates,
-                      )
-                    }
+                  }
 
-                    // Call executeIntent after detecting deposit transaction (for QR code mode)
-                    // This triggers the backend to start executing the intent
-                    // Must be called BEFORE waitIntentReceipt polling starts
-                    if (
-                      depositTxReceipt.status === "success" &&
-                      intent.intentId
-                    ) {
+                  // Call executeIntent after detecting deposit transaction (for QR code mode)
+                  // This triggers the backend to start executing the intent
+                  // Must be called BEFORE waitIntentReceipt polling starts
+                  if (
+                    depositTxReceipt.status === "success" &&
+                    intent.intentId
+                  ) {
+                    logger.console.log(
+                      "[trails-sdk] Calling executeIntent with detected deposit transaction hash (QR code mode)",
+                      {
+                        intentId: intent.intentId,
+                        txHash: depositTxReceipt.transactionHash,
+                        fundMethod,
+                      },
+                    )
+                    try {
+                      const executeIntentFnToUse =
+                        executeIntentFn ||
+                        trailsClient.executeIntent.bind(trailsClient)
+                      await executeIntentFnToUse({
+                        intentId: intent.intentId,
+                        depositTransactionHash:
+                          depositTxReceipt.transactionHash,
+                      })
                       logger.console.log(
-                        "[trails-sdk] Calling executeIntent with detected deposit transaction hash (QR code mode)",
-                        {
-                          intentId: intent.intentId,
-                          txHash: depositTxReceipt.transactionHash,
-                          fundMethod,
-                        },
+                        "[trails-sdk] executeIntent completed successfully (QR code mode)",
                       )
-                      try {
-                        const executeIntentFnToUse =
-                          executeIntentFn ||
-                          trailsClient.executeIntent.bind(trailsClient)
-                        await executeIntentFnToUse({
-                          intentId: intent.intentId,
-                          depositTransactionHash:
-                            depositTxReceipt.transactionHash,
-                        })
-                        logger.console.log(
-                          "[trails-sdk] executeIntent completed successfully (QR code mode)",
-                        )
 
-                        // Now start polling for intent receipt
-                        break
-                      } catch (error) {
-                        logger.console.error(
-                          "[trails-sdk] Error calling executeIntent (QR code mode):",
-                          error,
-                        )
-                      }
+                      // Now start polling for intent receipt
+                      break
+                    } catch (error) {
+                      logger.console.error(
+                        "[trails-sdk] Error calling executeIntent (QR code mode):",
+                        error,
+                      )
                     }
+                  }
 
-                    if (onOriginSend) {
-                      onOriginSend()
-                    }
-                    break
+                  if (onOriginSend) {
+                    onOriginSend()
                   }
-                } catch (error) {
-                  logger.console.error("Error checking for deposit tx", error)
+                  break
                 }
-                await new Promise((resolve) =>
-                  setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
-                )
+              } catch (error) {
+                logger.console.error("Error checking for deposit tx", error)
               }
+              await new Promise((resolve) =>
+                setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
+              )
             }
+          }
 
-            // Wait for deposit and executeIntent
-            await checkForDepositTx()
+          // Wait for deposit and executeIntent
+          await checkForDepositTx()
 
-            // Now start polling for intent receipt after executeIntent has been called
-            logger.console.log(
-              "[trails-sdk] Starting polling for intent receipt after executeIntent (QR code mode)",
-            )
-            try {
-              await pollIntentReceipt({
-                intentId: intent.intentId,
-                trailsClient,
-                callbacks: {
-                  onOriginTransactionFound: async (originTxHash) => {
-                    logger.console.log(
-                      "[trails-sdk] Origin intent transaction discovered for same-chain QR code flow",
-                      { originTxHash },
-                    )
+          // Now start polling for intent receipt after executeIntent has been called
+          logger.console.log(
+            "[trails-sdk] Starting polling for intent receipt after executeIntent (QR code mode)",
+          )
+          try {
+            await pollIntentReceipt({
+              intentId: intent.intentId,
+              trailsClient,
+              callbacks: {
+                onOriginTransactionFound: async (originTxHash) => {
+                  logger.console.log(
+                    "[trails-sdk] Origin intent transaction discovered for same-chain QR code flow",
+                    { originTxHash },
+                  )
+
+                  if (localTransactionStates[1]) {
+                    try {
+                      const originTxReceipt =
+                        await effectivePublicClient.getTransactionReceipt({
+                          hash: originTxHash as `0x${string}`,
+                        })
 
-                    if (localTransactionStates[1]) {
-                      try {
-                        const originTxReceipt =
-                          await effectivePublicClient.getTransactionReceipt({
-                            hash: originTxHash as `0x${string}`,
-                          })
-
-                        localTransactionStates[1] =
-                          getTransactionStateFromReceipt(
-                            originTxReceipt,
-                            effectiveOriginChainId,
-                            localTransactionStates[1]?.label,
-                          )
-                        onTransactionStateChange(localTransactionStates)
-                        if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
-                          checkoutOnHandlers.triggerCheckoutStatusUpdate(
-                            localTransactionStates,
-                          )
-                        }
-
-                        originIntentTransaction = {
-                          txnHash: originTxHash,
-                        } as IntentTransaction
-                      } catch (error) {
-                        logger.console.error(
-                          "[trails-sdk] Error fetching origin transaction receipt:",
-                          error,
+                      localTransactionStates[1] =
+                        getTransactionStateFromReceipt(
+                          originTxReceipt,
+                          effectiveOriginChainId,
+                          localTransactionStates[1]?.label,
+                        )
+                      onTransactionStateChange(localTransactionStates)
+                      if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
+                        checkoutOnHandlers.triggerCheckoutStatusUpdate(
+                          localTransactionStates,
                         )
                       }
+
+                      originIntentTransaction = {
+                        txnHash: originTxHash,
+                      } as IntentTransaction
+                    } catch (error) {
+                      logger.console.error(
+                        "[trails-sdk] Error fetching origin transaction receipt:",
+                        error,
+                      )
                     }
-                  },
+                  }
                 },
-                maxWaitTime: 120000, // 120 seconds max wait
-              })
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] Error polling for intent receipt (QR code mode):",
-                error,
-              )
-            }
-          } else if (effectiveGasless && !depositUserTxnReceipt) {
-            // For gasless flows (non-QR code), start polling immediately
-            logger.console.log(
-              "[trails-sdk] Starting unified polling for gasless same-chain transaction with 2 states",
+              },
+              maxWaitTime: 120000, // 120 seconds max wait
+            })
+          } catch (error) {
+            logger.console.error(
+              "[trails-sdk] Error polling for intent receipt (QR code mode):",
+              error,
             )
-            try {
-              await pollIntentReceipt({
-                intentId: intent.intentId,
-                trailsClient,
-                callbacks: {
-                  onDepositTransactionFound: async (txHash) => {
-                    logger.console.log(
-                      "[trails-sdk] Deposit transaction discovered for same-chain gasless flow",
-                      { txHash },
-                    )
+          }
+        } else if (effectiveGasless && !depositUserTxnReceipt) {
+          // For gasless flows (non-QR code), start polling immediately
+          logger.console.log(
+            "[trails-sdk] Starting unified polling for gasless same-chain transaction with 2 states",
+          )
+          try {
+            await pollIntentReceipt({
+              intentId: intent.intentId,
+              trailsClient,
+              callbacks: {
+                onDepositTransactionFound: async (txHash) => {
+                  logger.console.log(
+                    "[trails-sdk] Deposit transaction discovered for same-chain gasless flow",
+                    { txHash },
+                  )
+
+                  if (localTransactionStates[0]) {
+                    try {
+                      const depositTxReceipt =
+                        await effectivePublicClient.getTransactionReceipt({
+                          hash: txHash as `0x${string}`,
+                        })
 
-                    if (localTransactionStates[0]) {
-                      try {
-                        const depositTxReceipt =
-                          await effectivePublicClient.getTransactionReceipt({
-                            hash: txHash as `0x${string}`,
-                          })
-
-                        localTransactionStates[0] =
-                          getTransactionStateFromReceipt(
-                            depositTxReceipt,
-                            effectiveOriginChainId,
-                            localTransactionStates[0]?.label,
-                          )
-                        onTransactionStateChange(localTransactionStates)
-                        if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
-                          checkoutOnHandlers.triggerCheckoutStatusUpdate(
-                            localTransactionStates,
-                          )
-                        }
-
-                        depositUserTxnReceipt = depositTxReceipt
-                      } catch (error) {
-                        logger.console.error(
-                          "[trails-sdk] Error fetching deposit transaction receipt:",
-                          error,
+                      localTransactionStates[0] =
+                        getTransactionStateFromReceipt(
+                          depositTxReceipt,
+                          effectiveOriginChainId,
+                          localTransactionStates[0]?.label,
+                        )
+                      onTransactionStateChange(localTransactionStates)
+                      if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
+                        checkoutOnHandlers.triggerCheckoutStatusUpdate(
+                          localTransactionStates,
                         )
                       }
+
+                      depositUserTxnReceipt = depositTxReceipt
+                    } catch (error) {
+                      logger.console.error(
+                        "[trails-sdk] Error fetching deposit transaction receipt:",
+                        error,
+                      )
                     }
-                  },
-                  onOriginTransactionFound: async (originTxHash) => {
-                    logger.console.log(
-                      "[trails-sdk] Origin intent transaction discovered for same-chain gasless flow",
-                      { originTxHash },
-                    )
+                  }
+                },
+                onOriginTransactionFound: async (originTxHash) => {
+                  logger.console.log(
+                    "[trails-sdk] Origin intent transaction discovered for same-chain gasless flow",
+                    { originTxHash },
+                  )
 
-                    if (localTransactionStates[1]) {
-                      try {
-                        const originTxReceipt =
-                          await effectivePublicClient.getTransactionReceipt({
-                            hash: originTxHash as `0x${string}`,
-                          })
-
-                        localTransactionStates[1] =
-                          getTransactionStateFromReceipt(
-                            originTxReceipt,
-                            effectiveOriginChainId,
-                            localTransactionStates[1]?.label,
-                          )
-                        onTransactionStateChange(localTransactionStates)
-                        if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
-                          checkoutOnHandlers.triggerCheckoutStatusUpdate(
-                            localTransactionStates,
-                          )
-                        }
-
-                        originIntentTransaction = {
-                          txnHash: originTxHash,
-                        } as IntentTransaction
-                      } catch (error) {
-                        logger.console.error(
-                          "[trails-sdk] Error fetching origin transaction receipt:",
-                          error,
+                  if (localTransactionStates[1]) {
+                    try {
+                      const originTxReceipt =
+                        await effectivePublicClient.getTransactionReceipt({
+                          hash: originTxHash as `0x${string}`,
+                        })
+
+                      localTransactionStates[1] =
+                        getTransactionStateFromReceipt(
+                          originTxReceipt,
+                          effectiveOriginChainId,
+                          localTransactionStates[1]?.label,
+                        )
+                      onTransactionStateChange(localTransactionStates)
+                      if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
+                        checkoutOnHandlers.triggerCheckoutStatusUpdate(
+                          localTransactionStates,
                         )
                       }
+
+                      originIntentTransaction = {
+                        txnHash: originTxHash,
+                      } as IntentTransaction
+                    } catch (error) {
+                      logger.console.error(
+                        "[trails-sdk] Error fetching origin transaction receipt:",
+                        error,
+                      )
                     }
-                  },
+                  }
                 },
-                maxWaitTime: 120000, // 120 seconds max wait for both transactions
-              })
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] Error polling for gasless same-chain transactions:",
-                error,
-              )
-            }
+              },
+              maxWaitTime: 120000, // 120 seconds max wait for both transactions
+            })
+          } catch (error) {
+            logger.console.error(
+              "[trails-sdk] Error polling for gasless same-chain transactions:",
+              error,
+            )
           }
+        }
 
-          // For non-gasless flows, update the transaction state with the deposit receipt
-          // For gasless flows, skip this as localTransactionStates is already maintained by polling
-          if (depositUserTxnReceipt && !effectiveGasless) {
-            try {
-              const updatedStates = [
-                getTransactionStateFromReceipt(
-                  depositUserTxnReceipt,
-                  effectiveOriginChainId,
-                  transactionStates[0]?.label,
-                ),
-              ]
-              onTransactionStateChange(updatedStates)
-              // Also trigger checkout status update if handler is provided
-              if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
-                checkoutOnHandlers.triggerCheckoutStatusUpdate(updatedStates)
-              }
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] Error calling onTransactionStateChange:",
-                error,
-              )
+        // For non-gasless flows, update the transaction state with the deposit receipt
+        // For gasless flows, skip this as localTransactionStates is already maintained by polling
+        if (depositUserTxnReceipt && !effectiveGasless) {
+          try {
+            const updatedStates = [
+              getTransactionStateFromReceipt(
+                depositUserTxnReceipt,
+                effectiveOriginChainId,
+                transactionStates[0]?.label,
+              ),
+            ]
+            onTransactionStateChange(updatedStates)
+            // Also trigger checkout status update if handler is provided
+            if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
+              checkoutOnHandlers.triggerCheckoutStatusUpdate(updatedStates)
             }
+          } catch (error) {
+            logger.console.error(
+              "[trails-sdk] Error calling onTransactionStateChange:",
+              error,
+            )
           }
+        }
 
-          // Show conditional toast based on transaction status
-          const chainInfo = getChainInfo(effectiveOriginChainId)
-          if (depositUserTxnReceipt) {
-            if (depositUserTxnReceipt?.status === "success") {
-              updatePersistentToast(
-                "Transfer Confirmed",
-                `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
-                "info",
-              )
-            } else {
-              updatePersistentToast(
-                "Transfer Failed",
-                `Your transaction on ${chainInfo?.name || "chain"} failed`,
-                "error",
-              )
-            }
+        // Show conditional toast based on transaction status
+        const chainInfo = getChainInfo(effectiveOriginChainId)
+        if (depositUserTxnReceipt) {
+          if (depositUserTxnReceipt?.status === "success") {
+            updatePersistentToast(
+              "Transfer Confirmed",
+              `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
+              "info",
+            )
+          } else {
+            updatePersistentToast(
+              "Transfer Failed",
+              `Your transaction on ${chainInfo?.name || "chain"} failed`,
+              "error",
+            )
           }
+        }
 
-          // Track payment completion for same-chain same-token transaction
-          if (
-            depositUserTxnReceipt &&
-            depositUserTxnReceipt.status === "success"
-          ) {
-            // Check if any transaction failed or was refunded
-            const hasAnyCallFailed = transactionStates.some((tx) =>
-              tx?.decodedGuestModuleEvents?.some(
-                (e: any) => e?.type === "CallFailed",
-              ),
+        // Track payment completion for same-chain same-token transaction
+        if (
+          depositUserTxnReceipt &&
+          depositUserTxnReceipt.status === "success"
+        ) {
+          // Check if any transaction failed or was refunded
+          const hasAnyCallFailed = transactionStates.some((tx) =>
+            tx?.decodedGuestModuleEvents?.some(
+              (e: any) => e?.type === "CallFailed",
+            ),
+          )
+          const hasAnyRefunded = transactionStates.some((tx) => tx?.refunded)
+          const txStatus =
+            !hasAnyCallFailed && !hasAnyRefunded ? "success" : "fail"
+
+          // Always track payment completion regardless of success/failure
+          trackPaymentCompleted({
+            userAddress: account.address,
+            originTxHash: depositUserTxnReceipt.transactionHash,
+            originChainId: effectiveOriginChainId, // Same chain
+            mode,
+            fundMethod,
+            originTokenAddress,
+            originTokenSymbol,
+            originTokenAmount: swapAmount,
+            originTokenAmountFormatted: depositAmountFormatted.toString(),
+            destinationTokenAddress: originTokenAddress, // same chain same token
+            destinationTokenSymbol: destinationTokenSymbol,
+            depositTokenAmount: swapAmount,
+            depositTokenAmountFormatted: depositAmountFormatted.toString(),
+            depositTokenAmountUsd: depositAmountUsd?.toString(),
+            destinationTokenAmount: swapAmount, // same as deposit amount
+            destinationTokenAmountFormatted: depositAmountFormatted.toString(), // same as deposit amount
+            destinationTokenAmountUsd: depositAmountUsd?.toString(), // same as deposit amount
+            originTokenDecimals: originTokenDecimals,
+            destinationTokenDecimals: originTokenDecimals, // same chain same token
+          })
+
+          // Invalidate token balances cache after transaction (success or failure - gas was spent)
+          invalidateTokenBalancesCache(account.address)
+
+          // Call onCheckoutComplete callback with transaction status
+          if (checkoutOnHandlers?.triggerCheckoutComplete) {
+            checkoutOnHandlers.triggerCheckoutComplete(
+              txStatus,
+              account.address,
+            )
+          }
+        } else if (depositUserTxnReceipt) {
+          trackPaymentError({
+            error: "Transaction failed",
+            userAddress: account.address,
+            mode,
+            fundMethod,
+            originTokenAddress,
+          })
+
+          // Invalidate token balances cache even on failure (gas was spent)
+          invalidateTokenBalancesCache(account.address)
+
+          // Call onCheckoutError callback if provided
+          if (checkoutOnHandlers?.triggerCheckoutError) {
+            checkoutOnHandlers.triggerCheckoutError("Transaction failed")
+          }
+        } else if (effectiveGasless && !depositUserTxnReceipt) {
+          // For gasless flows with polling, check if both transactions are confirmed
+          const depositConfirmed =
+            localTransactionStates[0]?.state === "confirmed"
+          const originConfirmed =
+            localTransactionStates[1]?.state === "confirmed"
+
+          if (depositConfirmed && originConfirmed) {
+            logger.console.log(
+              "[trails-sdk] Gasless same-chain transaction fully completed via polling",
             )
-            const hasAnyRefunded = transactionStates.some((tx) => tx?.refunded)
-            const txStatus =
-              !hasAnyCallFailed && !hasAnyRefunded ? "success" : "fail"
+            const txStatus = "success"
 
-            // Always track payment completion regardless of success/failure
             trackPaymentCompleted({
               userAddress: account.address,
-              originTxHash: depositUserTxnReceipt.transactionHash,
-              originChainId: effectiveOriginChainId, // Same chain
+              originTxHash:
+                localTransactionStates[0]?.transactionHash ||
+                localTransactionStates[1]?.transactionHash,
+              originChainId: effectiveOriginChainId,
               mode,
               fundMethod,
               originTokenAddress,
@@ -1186,11 +1253,14 @@ export async function handleSameChainSameToken({
               destinationTokenAmount: swapAmount, // same as deposit amount
               destinationTokenAmountFormatted:
                 depositAmountFormatted.toString(), // same as deposit amount
-              destinationTokenAmountUsd: depositAmountUsd?.toString(), // same as deposit amount
+              destinationTokenAmountUsd: depositAmountUsd?.toString(),
               originTokenDecimals: originTokenDecimals,
               destinationTokenDecimals: originTokenDecimals, // same chain same token
             })
 
+            // Invalidate token balances cache after transaction (success or failure - gas was spent)
+            invalidateTokenBalancesCache(account.address)
+
             // Call onCheckoutComplete callback with transaction status
             if (checkoutOnHandlers?.triggerCheckoutComplete) {
               checkoutOnHandlers.triggerCheckoutComplete(
@@ -1198,69 +1268,10 @@ export async function handleSameChainSameToken({
                 account.address,
               )
             }
-          } else if (depositUserTxnReceipt) {
-            trackPaymentError({
-              error: "Transaction failed",
-              userAddress: account.address,
-              mode,
-              fundMethod,
-              originTokenAddress,
-            })
-
-            // Call onCheckoutError callback if provided
-            if (checkoutOnHandlers?.triggerCheckoutError) {
-              checkoutOnHandlers.triggerCheckoutError("Transaction failed")
-            }
-          } else if (effectiveGasless && !depositUserTxnReceipt) {
-            // For gasless flows with polling, check if both transactions are confirmed
-            const depositConfirmed =
-              localTransactionStates[0]?.state === "confirmed"
-            const originConfirmed =
-              localTransactionStates[1]?.state === "confirmed"
-
-            if (depositConfirmed && originConfirmed) {
-              logger.console.log(
-                "[trails-sdk] Gasless same-chain transaction fully completed via polling",
-              )
-              const txStatus = "success"
-
-              trackPaymentCompleted({
-                userAddress: account.address,
-                originTxHash:
-                  localTransactionStates[0]?.transactionHash ||
-                  localTransactionStates[1]?.transactionHash,
-                originChainId: effectiveOriginChainId,
-                mode,
-                fundMethod,
-                originTokenAddress,
-                originTokenSymbol,
-                originTokenAmount: swapAmount,
-                originTokenAmountFormatted: depositAmountFormatted.toString(),
-                destinationTokenAddress: originTokenAddress, // same chain same token
-                destinationTokenSymbol: destinationTokenSymbol,
-                depositTokenAmount: swapAmount,
-                depositTokenAmountFormatted: depositAmountFormatted.toString(),
-                depositTokenAmountUsd: depositAmountUsd?.toString(),
-                destinationTokenAmount: swapAmount, // same as deposit amount
-                destinationTokenAmountFormatted:
-                  depositAmountFormatted.toString(), // same as deposit amount
-                destinationTokenAmountUsd: depositAmountUsd?.toString(),
-                originTokenDecimals: originTokenDecimals,
-                destinationTokenDecimals: originTokenDecimals, // same chain same token
-              })
-
-              // Call onCheckoutComplete callback with transaction status
-              if (checkoutOnHandlers?.triggerCheckoutComplete) {
-                checkoutOnHandlers.triggerCheckoutComplete(
-                  txStatus,
-                  account.address,
-                )
-              }
-            } else if (depositConfirmed) {
-              logger.console.log(
-                "[trails-sdk] Gasless same-chain deposit confirmed, waiting for origin transaction",
-              )
-            }
+          } else if (depositConfirmed) {
+            logger.console.log(
+              "[trails-sdk] Gasless same-chain deposit confirmed, waiting for origin transaction",
+            )
           }
         }