0xtrails 0.2.4 → 0.2.6

package/src/prepareSend.ts

@@ -1,10 +1,10 @@
 import type {
   GetIntentCallsPayloadParams,
-  GetIntentCallsPayloadsReturn,
   IntentPrecondition,
 } from "@0xsequence/trails-api"
+import type { GetIntentCallsPayloadsReturn } from "./intents.js"
 import type { TrailsAPIClient } from "@0xsequence/trails-api"
-import { useQuery } from "@tanstack/react-query"
+import type { Relayer } from "@0xsequence/relayer"
 import type {
   Account,
   Chain,
@@ -12,6 +12,8 @@ import type {
   TransactionReceipt,
   WalletClient,
 } from "viem"
+import { abortControllerRegistry } from "./abortController.js"
+import { extractTrailsFeeBreakdown, type TrailsFeeBreakdown } from "./fees.js"
 import {
   createPublicClient,
   createWalletClient,
@@ -34,7 +36,6 @@ import {
   trackRelayerCallStarted,
   trackTransactionConfirmed,
 } from "./analytics.js"
-import { useAPIClient } from "./apiClient.js"
 import type { Attestation } from "./cctp.js"
 import {
   approveERC20,
@@ -50,19 +51,20 @@ import {
 import { queueCCTPTransfer } from "./cctpqueue.js"
 import { getChainInfo, getTestnetChainInfo } from "./chains.js"
 import { attemptSwitchChain } from "./chainSwitch.js"
-import {
-  getSequenceEnv,
-  getSlippageTolerance,
-  type SequenceEnv,
-} from "./config.js"
+import { getSlippageTolerance } from "./config.js"
 import { TRAILS_INTENT_ENTRYPOINT_ADDRESS } from "./constants.js"
 import {
   decodeGuestModuleEvents,
   decodeTrailsTokenSweeperEvents,
 } from "./decoders.js"
 import { getERC20TransferData } from "./encoders.js"
-import { getFullErrorMessage, InsufficientBalanceError } from "./error.js"
-import { estimateGasCostUsd } from "./estimate.js"
+import { InsufficientBalanceError } from "./error.js"
+import {
+  estimateGasCost,
+  estimateGasCostUsd,
+  estimateGasLimit,
+  DEFAULT_MIN_GASLIMIT,
+} from "./estimate.js"
 import { getExplorerUrl } from "./explorer.js"
 import {
   getNeedsIntentEntrypointApproval,
@@ -71,8 +73,9 @@ import {
   signIntent,
 } from "./gasless.js"
 import { getIntentEntrypointFeeOptions } from "./intentEntrypoint.js"
-import { useIndexerGatewayClient } from "./indexerClient.js"
 import {
+  buildSameChainTransactionParams,
+  buildCrossChainDepositParams,
   commitIntentConfig,
   getIntentCallsPayloads as getIntentCallsPayloadsFromIntents,
   sendOriginTransaction,
@@ -84,8 +87,7 @@ import { relayerSendMetaTx } from "./metaTxns.js"
 import { findFirstPreconditionForChainId } from "./preconditions.js"
 import { calcAmountUsdPrice, getTokenPrice } from "./prices.js"
 import { getQueryParam } from "./queryParams.js"
-import type { MetaTxnReceipt, RelayerEnv } from "./relayer.js"
-import { useRelayers } from "./relayer.js"
+import type { MetaTxnReceipt } from "./relayer.js"
 import {
   executeSimpleRelayTransaction,
   getRelaySDKQuote,
@@ -103,13 +105,8 @@ import {
   formatAmountDisplay,
   formatRawAmount,
   formatUsdAmountDisplay,
-  getTokenBalancesWithPrices,
 } from "./tokenBalances.js"
-import {
-  getTokenInfo,
-  useSupportedTokens,
-  type SupportedToken,
-} from "./tokens.js"
+import { getTokenInfo, type SupportedToken } from "./tokens.js"
 import {
   TRAILS_ROUTER_PLACEHOLDER_AMOUNT,
   wrapCalldataWithTrailsRouterIfNeeded,
@@ -122,16 +119,27 @@ import { getAccountTransactionHistory, getTxTimeDiff } from "./transactions.js"
 import { requestWithTimeout } from "./utils.js"
 import type { CheckoutOnHandlers } from "./widget/hooks/useCheckout.js"
 import { logger } from "./logger.js"
+
+// Polling intervals for different operations
+const POLLING_INTERVALS = {
+  // Consistent interval for transaction history polling (3 seconds)
+  TRANSACTION_HISTORY: 3000,
+  // Consistent interval for meta transaction polling (2 seconds)
+  META_TRANSACTION: 2000,
+  // Consistent interval for CCTP queue polling (5 seconds)
+  CCTP_QUEUE: 5000,
+  // Consistent interval for failure polling (2 seconds)
+  FAILURE_POLLING: 2000,
+} as const
+
 import { getIsCustomCalldata } from "./contractUtils.js"
 import type { SequenceAPIClient } from "@0xsequence/api"
-import { useTrailsClient } from "./trailsClient.js"
 import { updatePersistentToast } from "./toast.js"
 import {
   getDelegatorSmartAccount,
   getPaymasterGaslessTransaction,
   sendPaymasterGaslessTransaction,
 } from "./paymasterSend.js"
-import type { RpcRelayer } from "@0xsequence/relayer"
 
 export enum TradeType {
   EXACT_INPUT = "EXACT_INPUT",
@@ -156,8 +164,8 @@ export type PrepareSendOptions = {
   dryMode: boolean
   apiClient: SequenceAPIClient
   trailsClient: TrailsAPIClient
-  originRelayer: RpcRelayer.RpcRelayer
-  destinationRelayer: RpcRelayer.RpcRelayer
+  originRelayer: Relayer.RpcRelayer
+  destinationRelayer: Relayer.RpcRelayer
   destinationCalldata?: string
   onTransactionStateChange: (transactionStates: TransactionState[]) => void
   sourceTokenPriceUsd?: number | null
@@ -174,6 +182,8 @@ export type PrepareSendOptions = {
   checkoutOnHandlers?: CheckoutOnHandlers
   refundAddress?: string
   selectedFeeToken?: any
+  walletId?: string
+  abortSignal?: AbortSignal
 }
 
 export type PrepareSendFees = {
@@ -218,10 +228,13 @@ export type PrepareSendQuote = {
   transactionStates: TransactionState[]
   gasCostUsd: number
   gasCostUsdDisplay: string
+  gasCost: string
+  gasCostFormatted: string
   originTokenRate: string
   destinationTokenRate: string
   quoteProvider: QuoteProviderInfo | null
   noSufficientBalance: boolean
+  trailsFeeBreakdown?: TrailsFeeBreakdown | null
 }
 
 export type PrepareSendReturn = {
@@ -353,6 +366,12 @@ function getIntentArgs(
 export async function prepareSend(
   options: PrepareSendOptions,
 ): Promise<PrepareSendReturn> {
+  // Abort all existing operations when a new quote is generated
+  logger.console.log(
+    "[trails-sdk] New quote generated - aborting all existing operations",
+  )
+  abortControllerRegistry.abortAll()
+
   const {
     account,
     originTokenAddress,
@@ -385,6 +404,8 @@ export async function prepareSend(
     mode,
     checkoutOnHandlers,
     selectedFeeToken,
+    walletId,
+    abortSignal,
   } = options
   let { sourceTokenPriceUsd, destinationTokenPriceUsd } = options
 
@@ -568,18 +589,20 @@ export async function prepareSend(
     label: isToSameChain && isToSameToken ? "Execute" : "Transfer",
   })
 
-  // swap (+ bridge tx)
-  transactionStates.push({
-    transactionHash: "",
-    explorerUrl: "",
-    chainId: originChainId,
-    state: "pending",
-    label: isToSameToken
-      ? "Bridge"
-      : isToSameChain && !isToSameToken
-        ? "Swap"
-        : "Swap & Bridge",
-  })
+  // swap (+ bridge tx) - skip for same-chain-same-token as there's no second transaction
+  if (!(isToSameChain && isToSameToken)) {
+    transactionStates.push({
+      transactionHash: "",
+      explorerUrl: "",
+      chainId: originChainId,
+      state: "pending",
+      label: isToSameToken
+        ? "Bridge"
+        : isToSameChain && !isToSameToken
+          ? "Swap"
+          : "Swap & Bridge",
+    })
+  }
 
   // additional execute tx on same chain if needed
   if (isToSameChain && hasCustomCalldata && !isToSameToken) {
@@ -652,6 +675,14 @@ export async function prepareSend(
       originNativeTokenPriceUsd,
       slippageTolerance,
       checkoutOnHandlers,
+      gasless,
+      paymasterUrl,
+      selectedFeeToken,
+      trailsClient,
+      originRelayer,
+      mode,
+      fundMethod,
+      abortSignal,
     })
   }
 
@@ -693,6 +724,8 @@ export async function prepareSend(
     mode,
     checkoutOnHandlers,
     selectedFeeToken,
+    walletId,
+    abortSignal,
   })
 }
 
@@ -733,6 +766,8 @@ async function sendHandlerForDifferentChainDifferentToken({
   mode,
   checkoutOnHandlers,
   selectedFeeToken,
+  walletId,
+  abortSignal,
 }: {
   mainSignerAddress: string
   originChainId: number
@@ -753,8 +788,8 @@ async function sendHandlerForDifferentChainDifferentToken({
   destinationTokenDecimals: number
   gasless: boolean
   paymasterUrl?: string
-  originRelayer: RpcRelayer.RpcRelayer
-  destinationRelayer: RpcRelayer.RpcRelayer
+  originRelayer: Relayer.RpcRelayer
+  destinationRelayer: Relayer.RpcRelayer
   walletClient: WalletClient
   publicClient: PublicClient
   chain: Chain
@@ -771,6 +806,8 @@ async function sendHandlerForDifferentChainDifferentToken({
   mode?: "pay" | "fund" | "earn" | "swap" | "receive"
   checkoutOnHandlers?: CheckoutOnHandlers
   selectedFeeToken?: any
+  walletId?: string
+  abortSignal?: AbortSignal
 }): Promise<PrepareSendReturn> {
   const testnet = isTestnetDebugMode()
   const useCctp = getUseCctp(
@@ -1120,6 +1157,42 @@ async function sendHandlerForDifferentChainDifferentToken({
     }
   }
 
+  // Estimate gas limit for the quote (same logic as in attemptNonGaslessUserDeposit)
+  const originCallParamsForEstimate = buildCrossChainDepositParams({
+    originTokenAddress,
+    originIntentAddress,
+    depositAmount: firstPreconditionMin,
+    fee,
+    originChainId,
+    chain,
+  })
+
+  logger.console.log(
+    "[trails-sdk][gas-estimation] About to estimate gas limit for cross-chain quote with params:",
+    {
+      account: account.address,
+      to: originCallParamsForEstimate.to,
+      data: originCallParamsForEstimate.data,
+      value: originCallParamsForEstimate.value,
+    },
+  )
+
+  const estimatedGasLimitForQuote = await estimateGasLimit(
+    publicClient,
+    {
+      account: account.address,
+      to: originCallParamsForEstimate.to,
+      data: originCallParamsForEstimate.data,
+      value: BigInt(originCallParamsForEstimate.value),
+    },
+    "quote",
+  )
+
+  logger.console.log(
+    "[trails-sdk][gas-estimation] Estimated gas limit for cross-chain quote:",
+    estimatedGasLimitForQuote,
+  )
+
   const quote = await getNormalizedQuoteObject({
     originDepositAddress: originIntentAddress,
     destinationDepositAddress: intent.payloads.destinationIntentAddress,
@@ -1147,6 +1220,8 @@ async function sendHandlerForDifferentChainDifferentToken({
     originNativeTokenPriceUsd,
     quoteProvider: intent.payloads?.quote?.quoteProvider,
     noSufficientBalance,
+    estimatedGasLimit: estimatedGasLimitForQuote,
+    intent,
   })
 
   // Call onCheckoutQuote callback if provided
@@ -1154,12 +1229,15 @@ async function sendHandlerForDifferentChainDifferentToken({
     checkoutOnHandlers.triggerCheckoutQuote(quote)
   }
 
-  // Get intent entrypoint fee options if supported, gasless is enabled, and fundMethod is wallet
+  // Get intent entrypoint fee options if supported and gasless is enabled
+  // Note: We fetch fee options whenever gasless is true, regardless of fundMethod,
+  // because gasless scenarios (including tests) need fee collector information
+  // Skip gasless fee options for sequence-waas wallet
   let intentEntrypointFeeOptions: any = null
-  if (gasless && fundMethod === "wallet") {
+  if (gasless && walletId !== "sequence-waas") {
     try {
       logger.console.log(
-        "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Gasless enabled and fundMethod is wallet, checking intent entrypoint support for chain:",
+        "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Gasless enabled, checking intent entrypoint support for chain:",
         originChainId,
       )
 
@@ -1181,9 +1259,13 @@ async function sendHandlerForDifferentChainDifferentToken({
         error,
       )
     }
+  } else if (walletId === "sequence-waas") {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Skipping gasless fee options for sequence-waas wallet",
+    )
   } else {
     logger.console.log(
-      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Gasless disabled or fundMethod is not wallet, skipping intent entrypoint fee options fetch",
+      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Gasless disabled, skipping intent entrypoint fee options fetch",
     )
   }
 
@@ -1349,6 +1431,8 @@ async function sendHandlerForDifferentChainDifferentToken({
             feeOptions: intentEntrypointFeeOptions,
             trailsClient,
             selectedFeeToken: effectiveSelectedFeeToken,
+            walletId,
+            abortSignal,
           })
 
           if (!originUserTxReceipt) {
@@ -1429,10 +1513,19 @@ async function sendHandlerForDifferentChainDifferentToken({
 
         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
+            }
+
             try {
               const response = await getAccountTransactionHistory({
                 chainId: originChainId,
                 accountAddress: originIntentAddress,
+                abortSignal,
               })
               logger.console.log(
                 "[trails-sdk] getAccountTransactionHistory response",
@@ -1441,14 +1534,16 @@ async function sendHandlerForDifferentChainDifferentToken({
               if (response.transactions.length > 0) {
                 const tx = response.transactions[0]
                 if (!tx?.txnHash) {
-                  await new Promise((resolve) => setTimeout(resolve, 1000))
+                  await new Promise((resolve) =>
+                    setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
+                  )
                   continue
                 }
                 // const isReceive = tx.transfers.some(
                 //   (transfer) => transfer.transferType === "RECEIVE",
                 // )
                 // if (!isReceive) {
-                //   await new Promise((resolve) => setTimeout(resolve, 1000))
+                //   await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY))
                 //   continue
                 // }
                 const originDepositTxReceipt =
@@ -1473,18 +1568,29 @@ async function sendHandlerForDifferentChainDifferentToken({
             } catch (error) {
               logger.console.error("Error checking for deposit tx", error)
             }
-            await new Promise((resolve) => setTimeout(resolve, 1000))
+            await new Promise((resolve) =>
+              setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
+            )
           }
         }
 
         const _checkForDestinationDepositTx: () => Promise<TransactionReceipt | null> =
           async () => {
             while (true) {
+              // Check if we should abort
+              if (abortSignal?.aborted) {
+                logger.console.log(
+                  "[trails-sdk] Aborting destination deposit tx check due to abort signal",
+                )
+                return null
+              }
+
               try {
                 const response = await getAccountTransactionHistory({
                   chainId: destinationChainId,
                   accountAddress: intent.payloads
                     .destinationIntentAddress as `0x${string}`,
+                  abortSignal,
                 })
                 logger.console.log(
                   "[trails-sdk] getAccountTransactionHistory response",
@@ -1493,7 +1599,12 @@ async function sendHandlerForDifferentChainDifferentToken({
                 if (response.transactions.length > 0) {
                   const tx = response.transactions[0]
                   if (!tx?.txnHash) {
-                    await new Promise((resolve) => setTimeout(resolve, 1000))
+                    await new Promise((resolve) =>
+                      setTimeout(
+                        resolve,
+                        POLLING_INTERVALS.TRANSACTION_HISTORY,
+                      ),
+                    )
                     continue
                   }
                   // const isReceive = tx.transfers.some(
@@ -1520,13 +1631,15 @@ async function sendHandlerForDifferentChainDifferentToken({
               } catch (error) {
                 logger.console.error("Error checking for deposit tx", error)
               }
-              await new Promise((resolve) => setTimeout(resolve, 1000))
+              await new Promise((resolve) =>
+                setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
+              )
             }
           }
 
         // Variables to store the waitForReceipt functions
         let originMetaTxnReceiptPromise:
-          | (() => Promise<MetaTxnReceipt | null>)
+          | ((abortSignal?: AbortSignal) => Promise<MetaTxnReceipt | null>)
           | null = null
         let destinationMetaTxnReceiptPromise:
           | ((abortSignal?: AbortSignal) => Promise<MetaTxnReceipt | null>)
@@ -1783,6 +1896,14 @@ async function sendHandlerForDifferentChainDifferentToken({
         if (isCctp) {
           queueCctpPromise = async () => {
             while (true) {
+              // Check if we should abort
+              if (abortSignal?.aborted) {
+                logger.console.log(
+                  "[trails-sdk] Aborting CCTP queue due to abort signal",
+                )
+                return
+              }
+
               const originMetaTxnHash = originMetaTxnReceipt?.txnHash
               if (originMetaTxnHash) {
                 await queueCCTPTransfer({
@@ -1793,16 +1914,38 @@ async function sendHandlerForDifferentChainDifferentToken({
                 })
                 break
               }
-              await new Promise((resolve) => setTimeout(resolve, 1000))
+              await new Promise((resolve) =>
+                setTimeout(resolve, POLLING_INTERVALS.CCTP_QUEUE),
+              )
             }
           }
         } else {
           queueCctpPromise = () => Promise.resolve()
         }
 
-        checkForDepositTx().catch((error) => {
-          console.error("Error checking for deposit tx", error)
-        })
+        // Only start polling for external deposits if needed:
+        // - QR code or exchange funding (external deposits)
+        // - Gasless flow (relayer-executed deposits)
+        const needsDepositPolling =
+          fundMethod === "qr-code" ||
+          fundMethod === "exchange" ||
+          gasless === true
+
+        if (needsDepositPolling) {
+          logger.console.log(
+            "[trails-sdk] Starting deposit polling for fundMethod:",
+            fundMethod,
+            "gasless:",
+            gasless,
+          )
+          checkForDepositTx().catch((error) => {
+            logger.console.error("Error checking for deposit tx", error)
+          })
+        } else {
+          logger.console.log(
+            "[trails-sdk] Skipping deposit polling for wallet funding with gas fees",
+          )
+        }
 
         // Phase 1: Send meta transactions and queue CCTP
         logger.console.log(
@@ -1827,7 +1970,8 @@ async function sendHandlerForDifferentChainDifferentToken({
           )
           if (originMetaTxnReceiptPromise) {
             try {
-              originMetaTxnReceipt = await originMetaTxnReceiptPromise()
+              originMetaTxnReceipt =
+                await originMetaTxnReceiptPromise(abortSignal)
 
               if (originMetaTxnReceipt && transactionStates[1]) {
                 transactionStates[1] = getTransactionStateFromReceipt(
@@ -1907,12 +2051,9 @@ async function sendHandlerForDifferentChainDifferentToken({
           )
           if (destinationMetaTxnReceiptPromise) {
             try {
-              // Create abort controller for cancelling destination polling
-              const abortController = new AbortController()
-
               // Race between destination receipt and failure polling
               const destinationReceiptPromise = destinationMetaTxnReceiptPromise
-                ? destinationMetaTxnReceiptPromise(abortController.signal)
+                ? destinationMetaTxnReceiptPromise(abortSignal)
                 : Promise.resolve(null)
 
               const failurePollingPromise = new Promise<null>((resolve) => {
@@ -1929,11 +2070,13 @@ async function sendHandlerForDifferentChainDifferentToken({
                     logger.console.log(
                       "[trails-sdk] Aborting destination meta transaction due to previous transaction failure",
                     )
-                    abortController.abort()
                     resolve(null)
                   } else {
-                    // Continue polling every 1 second
-                    setTimeout(pollForFailures, 1000)
+                    // Continue polling with consistent interval
+                    setTimeout(
+                      pollForFailures,
+                      POLLING_INTERVALS.FAILURE_POLLING,
+                    )
                   }
                 }
                 pollForFailures()
@@ -2019,11 +2162,14 @@ async function sendHandlerForDifferentChainDifferentToken({
 
                   onTransactionStateChange(transactionStates)
                 } catch (error) {
-                  console.error("Error decoding destination tx events", error)
+                  logger.console.error(
+                    "Error decoding destination tx events",
+                    error,
+                  )
                 }
               }
             } catch (error) {
-              console.error(
+              logger.console.error(
                 "[trails-sdk] Error waiting for destination receipt:",
                 error,
               )
@@ -2059,6 +2205,17 @@ async function sendHandlerForDifferentChainDifferentToken({
 
         // Track payment completion for different chain and different token
         if (originUserTxReceipt && destinationMetaTxnReceipt) {
+          // 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,
             originIntentAddress,
@@ -2079,9 +2236,9 @@ async function sendHandlerForDifferentChainDifferentToken({
               effectiveDestinationTokenAmountUsd?.toString(),
           })
 
-          // Call onCheckoutComplete callback if provided
+          // Call onCheckoutComplete callback with transaction status
           if (checkoutOnHandlers?.triggerCheckoutComplete) {
-            checkoutOnHandlers.triggerCheckoutComplete()
+            checkoutOnHandlers.triggerCheckoutComplete(txStatus)
           }
         } else {
           if (
@@ -2190,6 +2347,12 @@ async function sendHandlerForSameChainSameToken({
   checkoutOnHandlers,
   mode,
   fundMethod,
+  gasless,
+  paymasterUrl,
+  selectedFeeToken,
+  trailsClient,
+  originRelayer,
+  abortSignal,
 }: {
   originTokenAddress: string
   originTokenDecimals: number
@@ -2211,6 +2374,12 @@ async function sendHandlerForSameChainSameToken({
   checkoutOnHandlers?: CheckoutOnHandlers
   mode?: "pay" | "fund" | "earn" | "swap" | "receive"
   fundMethod?: string
+  gasless?: boolean
+  paymasterUrl?: string
+  selectedFeeToken?: any
+  trailsClient: TrailsAPIClient
+  originRelayer: Relayer.RpcRelayer
+  abortSignal?: AbortSignal
 }): Promise<PrepareSendReturn> {
   logger.console.log("[trails-sdk] isToSameToken && isToSameChain")
   const testnet = isTestnetDebugMode()
@@ -2237,6 +2406,44 @@ async function sendHandlerForSameChainSameToken({
     noSufficientBalance = true
   }
 
+  // Build origin call params and estimate gas limit for the quote
+  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
+  const originCallParamsBase = buildSameChainTransactionParams({
+    hasCustomCalldata,
+    recipient,
+    effectiveOriginTokenAddress,
+    destinationCalldata,
+    swapAmount,
+    effectiveOriginChainId,
+    effectiveOriginChain,
+  })
+
+  logger.console.log(
+    "[trails-sdk][gas-estimation] About to estimate gas limit for quote with params:",
+    {
+      account: account.address,
+      to: originCallParamsBase.to,
+      data: originCallParamsBase.data,
+      value: originCallParamsBase.value,
+    },
+  )
+
+  const estimatedGasLimitForQuote = await estimateGasLimit(
+    effectivePublicClient,
+    {
+      account: account.address,
+      to: originCallParamsBase.to,
+      data: originCallParamsBase.data,
+      value: BigInt(originCallParamsBase.value),
+    },
+    "quote",
+  )
+
+  logger.console.log(
+    "[trails-sdk][gas-estimation] Estimated gas limit for quote:",
+    estimatedGasLimitForQuote,
+  )
+
   const quote = await getNormalizedQuoteObject({
     originDepositAddress: recipient,
     destinationDepositAddress: recipient,
@@ -2255,6 +2462,8 @@ async function sendHandlerForSameChainSameToken({
     slippageTolerance,
     quoteProvider: "",
     noSufficientBalance,
+    estimatedGasLimit: estimatedGasLimitForQuote,
+    intent: undefined,
   })
 
   // Call onCheckoutQuote callback if provided
@@ -2290,26 +2499,33 @@ async function sendHandlerForSameChainSameToken({
         })
 
         const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
+
+        // Build origin call params (reusing the same logic as quote estimation)
+        const originCallParamsBase = buildSameChainTransactionParams({
+          hasCustomCalldata,
+          recipient,
+          effectiveOriginTokenAddress,
+          destinationCalldata,
+          swapAmount,
+          effectiveOriginChainId,
+          effectiveOriginChain,
+        })
+
+        // Estimate gas limit for consistency with actual transaction
+        const gasLimit = await estimateGasLimit(
+          effectivePublicClient,
+          {
+            account: account.address,
+            to: originCallParamsBase.to,
+            data: originCallParamsBase.data,
+            value: BigInt(originCallParamsBase.value),
+          },
+          "send",
+        )
+
         const originCallParams = {
-          to: hasCustomCalldata
-            ? recipient
-            : effectiveOriginTokenAddress === zeroAddress
-              ? recipient
-              : effectiveOriginTokenAddress,
-          data: hasCustomCalldata
-            ? destinationCalldata
-            : effectiveOriginTokenAddress === zeroAddress
-              ? "0x"
-              : getERC20TransferData({
-                  recipient,
-                  amount: BigInt(swapAmount),
-                }),
-          value:
-            effectiveOriginTokenAddress === zeroAddress
-              ? BigInt(swapAmount)
-              : "0",
-          chainId: effectiveOriginChainId,
-          chain: effectiveOriginChain,
+          ...originCallParamsBase,
+          gasLimit,
         }
 
         logger.console.log("[trails-sdk] origin call params", originCallParams)
@@ -2340,105 +2556,208 @@ async function sendHandlerForSameChainSameToken({
             )
           }
 
-          if (hasCustomCalldata) {
+          // For gasless transactions with custom calldata, use the gasless deposit flow
+          if (gasless && hasCustomCalldata) {
+            logger.console.log(
+              "[trails-sdk] Using gasless intent entrypoint flow for same-chain transaction with custom calldata",
+            )
+
+            // Fetch fee options for gasless deposit
+            let feeOptions: any = null
             try {
-              const needsApproval = await getNeedsApproval({
-                publicClient: effectivePublicClient,
-                token: effectiveOriginTokenAddress,
-                account: account.address,
-                spender: recipient,
-                amount: maxUint256,
+              feeOptions = await getIntentEntrypointFeeOptions({
+                trailsClient,
+                userAddress: account.address as `0x${string}`,
+                tokenAddress: effectiveOriginTokenAddress as `0x${string}`,
+                amount: swapAmount,
+                intentAddress: recipient as `0x${string}`,
+                chainId: effectiveOriginChainId,
+              })
+              logger.console.log(
+                "[trails-sdk] [GASLESS-FLOW] Fetched intent entrypoint fee options for same-chain transaction:",
+                feeOptions,
+              )
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk] [GASLESS-FLOW] Error fetching fee options for same-chain gasless transaction:",
+                error,
+              )
+            }
+
+            const receipt = await attemptGaslessDeposit({
+              account,
+              walletClient,
+              chain: effectiveOriginChain,
+              depositTokenAddress: effectiveOriginTokenAddress,
+              depositTokenAmount: swapAmount,
+              depositRecipient: recipient,
+              onOriginSend: () => {}, // No-op callback
+              feeOptions,
+              paymasterUrl,
+              selectedFeeToken,
+              trailsClient,
+              originRelayer,
+              abortSignal,
+            })
+
+            if (receipt) {
+              originUserTxReceipt = receipt
+
+              // Track the confirmed transaction
+              trackTransactionConfirmed({
+                transactionHash: receipt.transactionHash,
+                chainId: effectiveOriginChainId,
+                userAddress: account.address,
+                blockNumber: Number(receipt.blockNumber),
+                originTokenAddress,
+                depositTokenAmountUsd: depositAmountUsd?.toString(),
               })
 
-              if (needsApproval) {
-                const txHash = await approveERC20({
-                  walletClient,
-                  tokenAddress: effectiveOriginTokenAddress,
+              // Toast will be shown after transaction state analysis
+
+              // Update transaction state
+              try {
+                onTransactionStateChange([
+                  getTransactionStateFromReceipt(
+                    receipt,
+                    effectiveOriginChainId,
+                    transactionStates[0]?.label,
+                  ),
+                ])
+              } catch (error) {
+                logger.console.error(
+                  "[trails-sdk] Error calling onTransactionStateChange:",
+                  error,
+                )
+              }
+            }
+          } else {
+            // Non-gasless flow: handle approval if needed
+            if (hasCustomCalldata) {
+              try {
+                const needsApproval = await getNeedsApproval({
+                  publicClient: effectivePublicClient,
+                  token: effectiveOriginTokenAddress,
+                  account: account.address,
                   spender: recipient,
                   amount: maxUint256,
-                  chain: effectiveOriginChain,
                 })
 
-                logger.console.log("waiting for approve", txHash)
-                await effectivePublicClient.waitForTransactionReceipt({
-                  hash: txHash,
-                })
-                logger.console.log("approve done")
+                if (needsApproval) {
+                  const txHash = await approveERC20({
+                    walletClient,
+                    tokenAddress: effectiveOriginTokenAddress,
+                    spender: recipient,
+                    amount: maxUint256,
+                    chain: effectiveOriginChain,
+                  })
+
+                  logger.console.log("waiting for approve", txHash)
+                  await effectivePublicClient.waitForTransactionReceipt({
+                    hash: txHash,
+                  })
+                  logger.console.log("approve done")
+                }
+              } catch (error) {
+                logger.console.error(
+                  "[trails-sdk] Error approving ERC20",
+                  error,
+                )
               }
-            } catch (error) {
-              logger.console.error("[trails-sdk] Error approving ERC20", error)
             }
-          }
 
-          // Show persistent toast for checkout flow
-          updatePersistentToast(
-            "Payment Started",
-            "Waiting for wallet confirmation...",
-            "info",
-          )
+            // Show persistent toast for checkout flow
+            updatePersistentToast(
+              "Payment Started",
+              "Waiting for wallet confirmation...",
+              "info",
+            )
 
-          logger.console.log(
-            "[trails-sdk] origin call params",
-            originCallParams,
-          )
-          const txHash = await sendOriginTransaction(
-            account,
-            walletClient,
-            originCallParams as any,
-            {
-              depositTokenAmountUsd: depositAmountUsd?.toString(),
-            },
-          ) // TODO: Add proper type
+            logger.console.log(
+              "[trails-sdk] origin call params",
+              originCallParams,
+            )
+            const txHash = await sendOriginTransaction(
+              account,
+              walletClient,
+              originCallParams as any,
+              {
+                depositTokenAmountUsd: depositAmountUsd?.toString(),
+              },
+            ) // TODO: Add proper type
 
-          logger.console.log("[trails-sdk] origin tx", txHash)
+            logger.console.log("[trails-sdk] origin tx", txHash)
 
-          if (onOriginSend) {
-            onOriginSend()
-          }
+            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
 
-          trackTransactionConfirmed({
-            transactionHash: txHash,
-            chainId: effectiveOriginChainId,
-            userAddress: account.address,
-            blockNumber: Number(receipt.blockNumber),
-            originTokenAddress,
-            depositTokenAmountUsd: depositAmountUsd?.toString(),
-          })
+            trackTransactionConfirmed({
+              transactionHash: txHash,
+              chainId: effectiveOriginChainId,
+              userAddress: account.address,
+              blockNumber: Number(receipt.blockNumber),
+              originTokenAddress,
+              depositTokenAmountUsd: depositAmountUsd?.toString(),
+            })
 
-          // Remove persistent toast and show success
-          const chainInfo = getChainInfo(effectiveOriginChainId)
-          updatePersistentToast(
-            "Transfer Confirmed",
-            `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
-            "info",
-          )
+            // Toast will be shown after transaction state analysis
 
-          try {
-            onTransactionStateChange([
-              getTransactionStateFromReceipt(
-                originUserTxReceipt,
-                effectiveOriginChainId,
-                transactionStates[0]?.label,
-              ),
-            ])
-          } catch (error) {
-            logger.console.error(
-              "[trails-sdk] Error calling onTransactionStateChange:",
-              error,
-            )
+            try {
+              onTransactionStateChange([
+                getTransactionStateFromReceipt(
+                  originUserTxReceipt,
+                  effectiveOriginChainId,
+                  transactionStates[0]?.label,
+                ),
+              ])
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk] Error calling onTransactionStateChange:",
+                error,
+              )
+            }
+          }
+
+          // Show conditional toast based on transaction status
+          const chainInfo = getChainInfo(effectiveOriginChainId)
+          if (originUserTxReceipt) {
+            if (originUserTxReceipt?.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 (originUserTxReceipt && originUserTxReceipt.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: originUserTxReceipt.transactionHash,
@@ -2450,9 +2769,9 @@ async function sendHandlerForSameChainSameToken({
               destinationTokenAmountUsd: depositAmountUsd?.toString(), // same as deposit amount
             })
 
-            // Call onCheckoutComplete callback if provided
+            // Call onCheckoutComplete callback with transaction status
             if (checkoutOnHandlers?.triggerCheckoutComplete) {
-              checkoutOnHandlers.triggerCheckoutComplete()
+              checkoutOnHandlers.triggerCheckoutComplete(txStatus)
             }
           } else if (originUserTxReceipt) {
             trackPaymentError({
@@ -2607,7 +2926,7 @@ async function _sendHandlerForSameChainDifferentToken({
         }
       }
     } catch (error) {
-      console.error("[trails-sdk] Error decoding function data:", error)
+      logger.console.error("[trails-sdk] Error decoding function data:", error)
     }
   }
 
@@ -2660,6 +2979,7 @@ async function _sendHandlerForSameChainDifferentToken({
     destinationChainId: originChainId,
     originNativeTokenPriceUsd,
     quoteProvider: "relay",
+    intent: undefined,
   })
 
   return {
@@ -2783,6 +3103,7 @@ async function attemptGaslessDeposit({
   originRelayer,
   feeOptions,
   selectedFeeToken,
+  abortSignal,
 }: {
   paymasterUrl?: string
   depositTokenAddress: string
@@ -2793,9 +3114,10 @@ async function attemptGaslessDeposit({
   chain: Chain
   account: Account
   trailsClient: TrailsAPIClient
-  originRelayer: RpcRelayer.RpcRelayer
+  originRelayer: Relayer.RpcRelayer
   feeOptions: any
   selectedFeeToken?: any
+  abortSignal?: AbortSignal
 }): Promise<TransactionReceipt | null> {
   let originUserTxReceipt: TransactionReceipt | null = null
   const originChainId = chain.id
@@ -2900,7 +3222,7 @@ async function attemptGaslessDeposit({
       feeOptions && feeOptions.feeOptions?.length > 0,
     )
 
-    // 1. Check if we need approval - check if we have enough allowance for this transaction (deposit + fee)
+    // 1. Check if we need approval - check if we have enough allowance for this transaction (deposit + fee if same token)
     let requiredAmount = BigInt(depositTokenAmount)
 
     // Match selectedFeeToken by tokenAddress to get the latest fee amount from feeOptions
@@ -2930,14 +3252,36 @@ async function attemptGaslessDeposit({
       )
     }
 
-    if (selectedFeeOption?.amount) {
-      requiredAmount = requiredAmount + BigInt(selectedFeeOption.amount)
-      logger.console.log("[trails-sdk] Including fee in required amount:", {
-        depositAmount: depositTokenAmount,
-        feeAmount: selectedFeeOption.amount,
-        feeTokenAddress: selectedFeeOption.tokenAddress,
-        totalRequired: requiredAmount.toString(),
-      })
+    // Only include fee in required amount if the fee token is the same as the deposit token
+    if (selectedFeeOption?.amount && selectedFeeOption?.tokenAddress) {
+      const feeTokenIsSameAsDepositToken =
+        selectedFeeOption.tokenAddress.toLowerCase() ===
+        depositTokenAddress.toLowerCase()
+
+      if (feeTokenIsSameAsDepositToken) {
+        requiredAmount = requiredAmount + BigInt(selectedFeeOption.amount)
+        logger.console.log(
+          "[trails-sdk] Fee token matches deposit token, including fee in required approval amount:",
+          {
+            depositAmount: depositTokenAmount,
+            feeAmount: selectedFeeOption.amount,
+            feeTokenAddress: selectedFeeOption.tokenAddress,
+            depositTokenAddress,
+            totalRequired: requiredAmount.toString(),
+          },
+        )
+      } else {
+        logger.console.log(
+          "[trails-sdk] Fee token differs from deposit token, separate approval will be needed:",
+          {
+            depositAmount: depositTokenAmount,
+            depositTokenAddress,
+            feeAmount: selectedFeeOption.amount,
+            feeTokenAddress: selectedFeeOption.tokenAddress,
+            depositTokenRequired: requiredAmount.toString(),
+          },
+        )
+      }
     }
 
     const needsApproval = await getNeedsIntentEntrypointApproval({
@@ -2962,13 +3306,14 @@ async function attemptGaslessDeposit({
       },
     )
 
-    // 2. Get permit signature if approval needed
+    // 2. Get permit signature if approval needed for deposit token
+    // Note: Fee payment is handled by the backend/relayer, we only need permit for the deposit token
     let permitSignature: string | undefined
     let permitDeadline: number | undefined
 
     if (needsApproval) {
       logger.console.log(
-        "[trails-sdk] Getting permit signature for infinite approval",
+        "[trails-sdk] Getting permit signature for deposit token infinite approval",
       )
 
       // Use infinite approval (maxUint256) so user doesn't need to approve again
@@ -2977,6 +3322,7 @@ async function attemptGaslessDeposit({
         "[trails-sdk] Using infinite approval for gasless deposits",
         {
           depositAmount: depositTokenAmount,
+          depositTokenAddress,
           permitAmount: permitAmount.toString(),
         },
       )
@@ -2994,7 +3340,7 @@ async function attemptGaslessDeposit({
       permitSignature = permitSig.signature
       permitDeadline = Number(permitSig.deadline)
       logger.console.log(
-        "[trails-sdk] Permit signature obtained for infinite approval",
+        "[trails-sdk] Deposit token permit signature obtained for infinite approval",
       )
     }
 
@@ -3119,6 +3465,14 @@ async function attemptGaslessDeposit({
     logger.console.log("[trails-sdk] Waiting for transaction receipt")
     // eslint-disable-next-line no-constant-condition
     while (true) {
+      // Check if we should abort
+      if (abortSignal?.aborted) {
+        logger.console.log(
+          "[trails-sdk] Aborting gasless deposit polling due to abort signal",
+        )
+        return null
+      }
+
       const receipt: any = await getMetaTxStatus(
         originRelayer,
         depositData.metaTxn.id,
@@ -3141,7 +3495,9 @@ async function attemptGaslessDeposit({
         break
       }
 
-      await new Promise((resolve) => setTimeout(resolve, 1000))
+      await new Promise((resolve) =>
+        setTimeout(resolve, POLLING_INTERVALS.META_TRANSACTION),
+      )
     }
   } catch (error) {
     logger.console.error(
@@ -3221,24 +3577,31 @@ export async function attemptNonGaslessUserDeposit({
 
   logger.console.log("[trails-sdk] needsNativeFee", needsNativeFee)
 
-  const originCallParams = {
-    to:
-      originTokenAddress === zeroAddress
-        ? originIntentAddress
-        : originTokenAddress,
-    data:
-      originTokenAddress === zeroAddress
-        ? "0x"
-        : getERC20TransferData({
-            recipient: originIntentAddress,
-            amount: BigInt(firstPreconditionMin) + BigInt(fee),
-          }),
-    value:
-      originTokenAddress === zeroAddress
-        ? BigInt(firstPreconditionMin) + BigInt(fee)
-        : "0",
-    chainId: originChainId,
+  // Build origin call params
+  const originCallParamsBase = buildCrossChainDepositParams({
+    originTokenAddress,
+    originIntentAddress,
+    depositAmount: firstPreconditionMin,
+    fee,
+    originChainId,
     chain,
+  })
+
+  // Estimate gas limit for consistency with actual transaction
+  const gasLimit = await estimateGasLimit(
+    publicClient,
+    {
+      account: account.address,
+      to: originCallParamsBase.to,
+      data: originCallParamsBase.data,
+      value: BigInt(originCallParamsBase.value),
+    },
+    "deposit",
+  )
+
+  const originCallParams = {
+    ...originCallParamsBase,
+    gasLimit,
   }
 
   await attemptSwitchChain({
@@ -3494,13 +3857,15 @@ async function attemptUserDepositTx({
   feeOptions,
   trailsClient,
   selectedFeeToken,
+  walletId,
+  abortSignal,
 }: {
   originTokenAddress: string
   gasless: boolean
   paymasterUrl?: string
   chain: Chain
   account: Account
-  originRelayer: RpcRelayer.RpcRelayer
+  originRelayer: Relayer.RpcRelayer
   firstPreconditionMin: string
   originIntentAddress: string
   onOriginSend?: () => void
@@ -3522,6 +3887,8 @@ async function attemptUserDepositTx({
   feeOptions?: any
   trailsClient: TrailsAPIClient
   selectedFeeToken?: any
+  walletId?: string
+  abortSignal?: AbortSignal
 }): Promise<TransactionReceipt | null> {
   let originUserTxReceipt: TransactionReceipt | null = null
   const originChainId = chain.id
@@ -3545,6 +3912,7 @@ async function attemptUserDepositTx({
     gasless,
     feeOptions,
     selectedFeeToken,
+    walletId,
   )
   logger.console.log(
     "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] doGasless check results:",
@@ -3584,15 +3952,19 @@ async function attemptUserDepositTx({
         originRelayer,
         feeOptions: feeOptions,
         selectedFeeToken: selectedFeeToken,
+        abortSignal,
       })
     } catch (error) {
       logger.console.log("[trails-sdk] gassless attempt failed", error)
-      throw error
+      // In strict gasless mode, re-throw error instead of falling back
+      if (gasless) {
+        throw error
+      }
     }
   }
 
   // If gasless attempt failed, try to send a regular transaction
-  if (!originUserTxReceipt) {
+  if (!originUserTxReceipt && !gasless) {
     originUserTxReceipt = await attemptNonGaslessUserDeposit({
       originTokenAddress,
       firstPreconditionMin,
@@ -3626,7 +3998,16 @@ export function getDoGasless(
   gasless: boolean,
   feeOptions?: any,
   selectedFeeToken?: any,
+  walletId?: string,
 ): boolean {
+  // Don't use gasless flow for sequence-waas wallet
+  if (walletId === "sequence-waas") {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] getDoGasless: Skipping gasless flow for sequence-waas wallet",
+    )
+    return false
+  }
+
   const hasFeeOptions = Boolean(feeOptions && feeOptions.feeOptions?.length > 0)
 
   // Important: The UI passes selectedFeeToken in these states:
@@ -3763,7 +4144,7 @@ async function sendMetaTxAndWaitForReceipt({
   feeQuote,
 }: {
   metaTx: MetaTxn
-  relayer: RpcRelayer.RpcRelayer
+  relayer: Relayer.RpcRelayer
   precondition: IntentPrecondition | null
   feeQuote?: string
 }): Promise<{
@@ -3807,38 +4188,84 @@ async function sendMetaTxAndWaitForReceipt({
     waitForReceipt: async (abortSignal?: AbortSignal) => {
       let originMetaTxnReceipt: MetaTxnReceipt | null = null
 
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
-        // Check if we should abort
-        if (abortSignal?.aborted) {
+      // Create a unique ID for this polling operation
+      const pollingId = `meta-txn-${metaTx.id}-${metaTx.chainId}-${Date.now()}`
+
+      // Create an abort controller for this specific polling operation
+      const pollingAbortController = new AbortController()
+
+      // Register this polling operation with the global registry
+      abortControllerRegistry.register(pollingId, pollingAbortController)
+
+      try {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+          // Check if we should abort (either from external signal or global registry)
+          if (abortSignal?.aborted || pollingAbortController.signal.aborted) {
+            logger.console.log(
+              "[trails-sdk] Aborting meta transaction polling due to abort signal",
+            )
+            return null
+          }
+
           logger.console.log(
-            "[trails-sdk] Aborting meta transaction polling due to abort signal",
+            "[trails-sdk] polling status",
+            metaTx.id as `0x${string}`,
+            metaTx.chainId.toString(),
           )
-          return null
-        }
+          const receipt: any = await getMetaTxStatus(
+            relayer,
+            metaTx.id,
+            Number(metaTx.chainId),
+          )
+          logger.console.log("[trails-sdk] status", receipt)
+          if (receipt?.transactionHash) {
+            originMetaTxnReceipt = receipt.data?.receipt
+            if (!originMetaTxnReceipt) {
+              throw new Error("No meta txn receipt found")
+            }
+            break
+          }
 
-        logger.console.log(
-          "[trails-sdk] polling status",
-          metaTx.id as `0x${string}`,
-          metaTx.chainId.toString(),
-        )
-        const receipt: any = await getMetaTxStatus(
-          relayer,
-          metaTx.id,
-          Number(metaTx.chainId),
-        )
-        logger.console.log("[trails-sdk] status", receipt)
-        if (receipt?.transactionHash) {
-          originMetaTxnReceipt = receipt.data?.receipt
-          if (!originMetaTxnReceipt) {
-            throw new Error("No meta txn receipt found")
+          // Check abort signal before waiting
+          if (abortSignal?.aborted || pollingAbortController.signal.aborted) {
+            logger.console.log(
+              "[trails-sdk] Aborting meta transaction polling before delay",
+            )
+            return null
           }
-          break
+
+          // Use consistent delay and check abort signal during the delay
+          await new Promise((resolve) => {
+            const timeoutId = setTimeout(
+              resolve,
+              POLLING_INTERVALS.META_TRANSACTION,
+            )
+
+            // Listen for abort signal during the delay
+            const abortHandler = () => {
+              clearTimeout(timeoutId)
+              resolve(undefined)
+            }
+
+            if (abortSignal) {
+              abortSignal.addEventListener("abort", abortHandler, {
+                once: true,
+              })
+            }
+            pollingAbortController.signal.addEventListener(
+              "abort",
+              abortHandler,
+              { once: true },
+            )
+          })
         }
-        await new Promise((resolve) => setTimeout(resolve, 1000))
-      }
 
-      return originMetaTxnReceipt
+        return originMetaTxnReceipt
+      } finally {
+        // Always unregister when polling completes or is aborted
+        abortControllerRegistry.unregister(pollingId)
+      }
     },
   }
 }
@@ -3922,7 +4349,7 @@ async function checkAccountBalance({
       balanceError,
     }
   } catch (error) {
-    console.error("[trails-sdk] Error checking account balance:", error)
+    logger.console.error("[trails-sdk] Error checking account balance:", error)
     return {
       hasEnoughBalance: false,
       balance: BigInt(0),
@@ -3999,329 +4426,18 @@ function getNeedsLifiNativeFee({
   return needsNativeFee
 }
 
-export type UseQuoteProps = {
-  walletClient?: any // TODO: fix this, has to do with viem/wagmi versions
-  fromTokenAddress?: string | null
-  fromChainId?: number | null
-  toTokenAddress?: string | null
-  toChainId?: number | null
-  toCalldata?: string | null
-  swapAmount?: string | bigint
-  toRecipient?: string | null
-  tradeType?: TradeType | null
-  slippageTolerance?: string | number | null
-  onStatusUpdate?: ((transactionStates: TransactionState[]) => void) | null
-  quoteProvider?: string | null
-  gasless?: boolean
-  paymasterUrl?: string
-}
-
-export type SwapReturn = {
-  originTransaction: {
-    transactionHash?: string | null
-    explorerUrl?: string | null
-    receipt: TransactionReceipt | MetaTxnReceipt | null
-  }
-  destinationTransaction: {
-    transactionHash?: string | null
-    explorerUrl?: string | null
-    receipt: MetaTxnReceipt | null
-  }
-  totalCompletionSeconds?: number
-}
-
-export type QuoteProviderInfo = {
-  id: string
-  name: string
-  url: string
-}
-
-export type Quote = {
-  fromAmount: string
-  fromAmountMin: string
-  toAmount: string
-  toAmountMin: string
-  originToken: SupportedToken
-  destinationToken: SupportedToken
-  originChain: Chain
-  destinationChain: Chain
-  fees: PrepareSendFees
-  slippageTolerance: string
-  priceImpact: string
-  completionEstimateSeconds: number
-  transactionStates?: TransactionState[]
-  originTokenRate?: string
-  quoteProvider?: QuoteProviderInfo | null
-  destinationTokenRate?: string
-  fromAmountUsdDisplay?: string
-  toAmountUsdDisplay?: string
-  gasCostUsd?: number
-  gasCostUsdDisplay?: string
-}
-
-export type UseQuoteReturn = {
-  quote: Quote | null
-  swap: (() => Promise<SwapReturn | null>) | null
-  isLoadingQuote: boolean
-  quoteError: unknown
-  refetchQuote: () => void
-}
-
-export function useQuote({
-  walletClient,
-  fromTokenAddress,
-  fromChainId,
-  toTokenAddress,
-  toChainId,
-  swapAmount,
-  tradeType,
-  toRecipient,
-  toCalldata,
-  slippageTolerance,
-  onStatusUpdate,
-  quoteProvider,
-  gasless,
-  paymasterUrl,
-  relayerEnv,
-  nodeGatewayEnv,
-}: Partial<
-  UseQuoteProps & { relayerEnv?: RelayerEnv; nodeGatewayEnv?: SequenceEnv }
-> = {}): UseQuoteReturn {
-  // Set node gateway environment override for this quote session
-  if (nodeGatewayEnv) {
-    ;(globalThis as any).__testNodeGatewayEnv = nodeGatewayEnv
-  }
-
-  const apiClient = useAPIClient()
-  const trailsClient = useTrailsClient()
-  const { getRelayer } = useRelayers({
-    env: relayerEnv || (getSequenceEnv() as RelayerEnv),
-  })
-  const indexerGatewayClient = useIndexerGatewayClient()
-
-  const { supportedTokens } = useSupportedTokens()
-
-  const { data, isLoading, error, refetch } = useQuery({
-    queryKey: [
-      "quote",
-      fromTokenAddress,
-      fromChainId,
-      toTokenAddress,
-      toChainId,
-      swapAmount?.toString(),
-      toRecipient,
-      toCalldata,
-      tradeType,
-      slippageTolerance,
-      quoteProvider,
-    ],
-    queryFn: async () => {
-      try {
-        if (
-          !walletClient ||
-          !apiClient ||
-          !trailsClient ||
-          !fromTokenAddress ||
-          !toTokenAddress ||
-          !swapAmount ||
-          !toRecipient ||
-          !fromChainId ||
-          !toChainId ||
-          !indexerGatewayClient
-        ) {
-          return null
-        }
-
-        // Get token balance using async method
-        const { balances } = await getTokenBalancesWithPrices({
-          account: walletClient.account!.address,
-          indexerGatewayClient,
-          apiClient,
-        })
-
-        const originTokenBalance = balances.find(
-          (b) =>
-            b.chainId === fromChainId &&
-            (b.contractAddress?.toLowerCase() ===
-              fromTokenAddress.toLowerCase() ||
-              (!b.contractAddress && fromTokenAddress === zeroAddress)),
-        )
-
-        const originTokenBalanceAmount = originTokenBalance?.balance ?? "0"
-        const destinationRelayer = getRelayer(toChainId)
-        const originRelayer = getRelayer(fromChainId)
-
-        // Note: Disable this check for now to allow fetching a quote even when the origin balance is zero
-        // if (originTokenBalanceAmount === "0") {
-        //   return null
-        // }
-
-        // logger.console.log("supportedTokens", supportedTokens)
-
-        const originToken = supportedTokens?.find(
-          (token) =>
-            token.contractAddress?.toLowerCase() ===
-              fromTokenAddress?.toLowerCase() && token.chainId === fromChainId,
-        )
-        const destinationToken = supportedTokens?.find(
-          (token) =>
-            token.contractAddress?.toLowerCase() ===
-              toTokenAddress?.toLowerCase() && token.chainId === toChainId,
-        )
-
-        const sourceTokenDecimals = originToken?.decimals
-        if (!sourceTokenDecimals) {
-          logger.console.error(
-            "[trails-sdk] [useQuote] Missing source token decimals:",
-            {
-              originToken,
-              fromTokenAddress,
-              fromChainId,
-            },
-          )
-          throw new Error("Source token decimals not found")
-        }
-        const destinationTokenDecimals = destinationToken?.decimals
-        if (!destinationTokenDecimals) {
-          logger.console.error(
-            "[trails-sdk] Missing destination token decimals:",
-            {
-              destinationToken,
-              toTokenAddress,
-              toChainId,
-            },
-          )
-          throw new Error("Destination token decimals not found")
-        }
-        const destinationTokenSymbol = destinationToken?.symbol ?? ""
-        const originTokenSymbol = originToken?.symbol ?? ""
-
-        const options = {
-          account: walletClient.account!,
-          originTokenAddress: fromTokenAddress,
-          originChainId: fromChainId,
-          originTokenBalance: originTokenBalanceAmount,
-          destinationChainId: toChainId,
-          recipient: toRecipient,
-          destinationTokenAddress: toTokenAddress,
-          swapAmount: swapAmount.toString(),
-          tradeType: tradeType ?? TradeType.EXACT_OUTPUT,
-          originTokenSymbol: originTokenSymbol,
-          destinationTokenSymbol: destinationTokenSymbol,
-          destinationCalldata: toCalldata as string,
-          client: walletClient,
-          apiClient,
-          trailsClient,
-          originRelayer,
-          destinationRelayer,
-          sourceTokenDecimals,
-          destinationTokenDecimals,
-          fee: "0",
-          dryMode: false,
-          onTransactionStateChange: onStatusUpdate ?? (() => {}),
-          slippageTolerance: slippageTolerance?.toString(),
-          quoteProvider: quoteProvider,
-          gasless: gasless ?? false,
-          paymasterUrl: paymasterUrl,
-        }
-
-        logger.console.log("[trails-sdk] options", options)
-
-        const { quote: prepareSendQuote, send } = await prepareSend(options)
-
-        const quote = {
-          fromAmount: prepareSendQuote.originAmount,
-          toAmount: prepareSendQuote.destinationAmount,
-          fromAmountMin: prepareSendQuote.originAmountMin,
-          toAmountMin: prepareSendQuote.destinationAmountMin,
-          originToken: prepareSendQuote.originToken,
-          destinationToken: prepareSendQuote.destinationToken,
-          originChain: prepareSendQuote.originChain,
-          destinationChain: prepareSendQuote.destinationChain,
-          fees: prepareSendQuote.fees,
-          priceImpact: prepareSendQuote.priceImpact,
-          completionEstimateSeconds: prepareSendQuote.completionEstimateSeconds,
-          slippageTolerance: prepareSendQuote.slippageTolerance,
-          transactionStates: prepareSendQuote.transactionStates,
-          originTokenRate: prepareSendQuote.originTokenRate,
-          destinationTokenRate: prepareSendQuote.destinationTokenRate,
-          quoteProvider: prepareSendQuote.quoteProvider,
-          fromAmountUsdDisplay:
-            prepareSendQuote.originAmountUsdDisplay ?? undefined,
-          toAmountUsdDisplay:
-            prepareSendQuote.destinationAmountUsdDisplay ?? undefined,
-          gasCostUsd: prepareSendQuote.gasCostUsd ?? undefined,
-          gasCostUsdDisplay: prepareSendQuote.gasCostUsdDisplay ?? undefined,
-        }
-
-        const swap = async (): Promise<SwapReturn> => {
-          const {
-            originUserTxReceipt,
-            destinationMetaTxnReceipt,
-            totalCompletionSeconds,
-          } = await send({})
-
-          return {
-            originTransaction: {
-              transactionHash: originUserTxReceipt?.transactionHash,
-              explorerUrl: getExplorerUrl({
-                txHash: originUserTxReceipt?.transactionHash as string,
-                chainId: fromChainId,
-              }),
-              receipt: originUserTxReceipt,
-            },
-            destinationTransaction: {
-              transactionHash: destinationMetaTxnReceipt?.txnHash,
-              explorerUrl: getExplorerUrl({
-                txHash: destinationMetaTxnReceipt?.txnHash as string,
-                chainId: toChainId,
-              }),
-              receipt: destinationMetaTxnReceipt,
-            },
-            totalCompletionSeconds,
-          }
-        }
-
-        return {
-          quote,
-          swap,
-        }
-      } catch (error) {
-        logger.console.error(
-          "[trails-sdk] [useQuote] Error getting quote:",
-          error,
-        )
-        throw getFullErrorMessage(error)
-      }
-    },
-    // Prevent unnecessary refetching
-    enabled: Boolean(
-      walletClient &&
-        apiClient &&
-        fromTokenAddress &&
-        toTokenAddress &&
-        swapAmount &&
-        toRecipient &&
-        fromChainId &&
-        toChainId &&
-        indexerGatewayClient,
-    ),
-    staleTime: 30 * 1000, // Consider data fresh for 30 seconds
-    refetchOnWindowFocus: false, // Don't refetch when window regains focus
-    refetchOnMount: false, // Don't refetch on component remount if data exists
-    refetchInterval: false, // Disable automatic polling
-    retry: 2, // Limit retry attempts
-    refetchOnReconnect: true, // Refetch when network reconnects
-  })
+// Re-export useQuote types and hook from the new location
+export type {
+  UseQuoteProps,
+  Quote,
+  UseQuoteReturn,
+  SwapReturn,
+  QuoteProviderInfo,
+} from "./widget/hooks/useQuote.js"
+export { useQuote } from "./widget/hooks/useQuote.js"
 
-  return {
-    quote: data?.quote || null,
-    swap: data?.swap || null,
-    isLoadingQuote: isLoading,
-    quoteError: error,
-    refetchQuote: () => refetch(),
-  }
-}
+// Import QuoteProviderInfo for use in this file
+import type { QuoteProviderInfo } from "./widget/hooks/useQuote.js"
 
 export function getFeesFromIntent(
   intent: GetIntentCallsPayloadsReturn,
@@ -4447,6 +4563,8 @@ export async function getNormalizedQuoteObject({
   originNativeTokenPriceUsd,
   quoteProvider,
   noSufficientBalance,
+  estimatedGasLimit,
+  intent,
 }: {
   originDepositAddress?: string
   destinationDepositAddress?: string
@@ -4470,6 +4588,8 @@ export async function getNormalizedQuoteObject({
   originNativeTokenPriceUsd?: number | null
   quoteProvider?: string
   noSufficientBalance?: boolean
+  estimatedGasLimit?: bigint
+  intent?: GetIntentCallsPayloadsReturn
 }): Promise<PrepareSendQuote> {
   if (!destinationChainId) {
     throw new Error("Destination chain id is required")
@@ -4497,7 +4617,7 @@ export async function getNormalizedQuoteObject({
   const destinationChain = getChainInfo(destinationChainId)
 
   if (!originToken || !destinationToken || !originChain || !destinationChain) {
-    console.error("[trails-sdk] Token or chain not found", {
+    logger.console.error("[trails-sdk] Token or chain not found", {
       originToken,
       destinationToken,
       originChain,
@@ -4571,17 +4691,52 @@ export async function getNormalizedQuoteObject({
 
   let gasCostUsd: number = 0
   let gasCostUsdDisplay: string = "0"
+  let gasCost: string = "0"
+  let gasCostFormatted: string = "0"
   try {
     if (originNativeTokenPriceUsd) {
+      // Use the actual estimated gas limit if provided, otherwise use default
+      // This ensures the quote gas cost matches what will be used in the actual transaction
+      const gasLimitForCost = estimatedGasLimit || DEFAULT_MIN_GASLIMIT
+
+      logger.console.log(
+        "[trails-sdk][gas-estimation] Calculating gas cost for quote with gasLimit:",
+        gasLimitForCost,
+        "(estimated:",
+        estimatedGasLimit,
+        "default:",
+        DEFAULT_MIN_GASLIMIT,
+        ")",
+      )
+
+      const gasCostWei = await estimateGasCost(publicClient, gasLimitForCost)
+      gasCost = gasCostWei.toString()
+      gasCostFormatted = formatUnits(gasCostWei, 18) // Native tokens always use 18 decimals
+
+      // Calculate USD value
       gasCostUsd = await estimateGasCostUsd(
         publicClient,
         originNativeTokenPriceUsd,
-        200_000n,
+        gasLimitForCost,
       )
       gasCostUsdDisplay = formatUsdAmountDisplay(gasCostUsd)
+
+      logger.console.log(
+        "[trails-sdk][gas-estimation] Quote gas cost calculated:",
+        {
+          gasCostWei,
+          gasCost,
+          gasCostFormatted,
+          gasCostUsd,
+          gasCostUsdDisplay,
+        },
+      )
     }
   } catch (error) {
-    console.error("[trails-sdk] Error estimating gas cost", error)
+    logger.console.error(
+      "[trails-sdk][gas-estimation] Error estimating gas cost for quote display",
+      error,
+    )
   }
 
   // Calculate exchange rates
@@ -4623,6 +4778,12 @@ export async function getNormalizedQuoteObject({
 
   const priceImpactUsdDisplay = formatUsdAmountDisplay(priceImpactUsd)
 
+  // Extract fee breakdown from intent if available
+  let trailsFeeBreakdown = null
+  if (intent) {
+    trailsFeeBreakdown = await extractTrailsFeeBreakdown(intent)
+  }
+
   return {
     originDepositAddress: originDepositAddress || "",
     destinationDepositAddress: destinationDepositAddress || "",
@@ -4657,6 +4818,8 @@ export async function getNormalizedQuoteObject({
     transactionStates: transactionStates || [],
     gasCostUsd,
     gasCostUsdDisplay,
+    gasCost,
+    gasCostFormatted,
     originTokenRate: exchangeRates.originTokenRate,
     destinationTokenRate: exchangeRates.destinationTokenRate,
     originAmountDisplay: formatAmountDisplay(originAmountFormatted),
@@ -4667,6 +4830,7 @@ export async function getNormalizedQuoteObject({
     ),
     quoteProvider: quoteProviderInfo,
     noSufficientBalance: noSufficientBalance || false,
+    trailsFeeBreakdown,
   }
 }