0xtrails 0.2.4 → 0.2.5

package/src/prepareSend.ts

@@ -4,6 +4,7 @@ import type {
   IntentPrecondition,
 } from "@0xsequence/trails-api"
 import type { TrailsAPIClient } from "@0xsequence/trails-api"
+import type { Relayer } from "@0xsequence/relayer"
 import { useQuery } from "@tanstack/react-query"
 import type {
   Account,
@@ -62,7 +63,12 @@ import {
 } from "./decoders.js"
 import { getERC20TransferData } from "./encoders.js"
 import { getFullErrorMessage, InsufficientBalanceError } from "./error.js"
-import { estimateGasCostUsd } from "./estimate.js"
+import {
+  estimateGasCost,
+  estimateGasCostUsd,
+  estimateGasLimit,
+  DEFAULT_MIN_GASLIMIT,
+} from "./estimate.js"
 import { getExplorerUrl } from "./explorer.js"
 import {
   getNeedsIntentEntrypointApproval,
@@ -73,6 +79,8 @@ import {
 import { getIntentEntrypointFeeOptions } from "./intentEntrypoint.js"
 import { useIndexerGatewayClient } from "./indexerClient.js"
 import {
+  buildSameChainTransactionParams,
+  buildCrossChainDepositParams,
   commitIntentConfig,
   getIntentCallsPayloads as getIntentCallsPayloadsFromIntents,
   sendOriginTransaction,
@@ -131,7 +139,6 @@ import {
   getPaymasterGaslessTransaction,
   sendPaymasterGaslessTransaction,
 } from "./paymasterSend.js"
-import type { RpcRelayer } from "@0xsequence/relayer"
 
 export enum TradeType {
   EXACT_INPUT = "EXACT_INPUT",
@@ -156,8 +163,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 +181,7 @@ export type PrepareSendOptions = {
   checkoutOnHandlers?: CheckoutOnHandlers
   refundAddress?: string
   selectedFeeToken?: any
+  walletId?: string
 }
 
 export type PrepareSendFees = {
@@ -218,6 +226,8 @@ export type PrepareSendQuote = {
   transactionStates: TransactionState[]
   gasCostUsd: number
   gasCostUsdDisplay: string
+  gasCost: string
+  gasCostFormatted: string
   originTokenRate: string
   destinationTokenRate: string
   quoteProvider: QuoteProviderInfo | null
@@ -385,6 +395,7 @@ export async function prepareSend(
     mode,
     checkoutOnHandlers,
     selectedFeeToken,
+    walletId,
   } = options
   let { sourceTokenPriceUsd, destinationTokenPriceUsd } = options
 
@@ -568,18 +579,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 +665,13 @@ export async function prepareSend(
       originNativeTokenPriceUsd,
       slippageTolerance,
       checkoutOnHandlers,
+      gasless,
+      paymasterUrl,
+      selectedFeeToken,
+      trailsClient,
+      originRelayer,
+      mode,
+      fundMethod,
     })
   }
 
@@ -693,6 +713,7 @@ export async function prepareSend(
     mode,
     checkoutOnHandlers,
     selectedFeeToken,
+    walletId,
   })
 }
 
@@ -733,6 +754,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   mode,
   checkoutOnHandlers,
   selectedFeeToken,
+  walletId,
 }: {
   mainSignerAddress: string
   originChainId: number
@@ -753,8 +775,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 +793,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   mode?: "pay" | "fund" | "earn" | "swap" | "receive"
   checkoutOnHandlers?: CheckoutOnHandlers
   selectedFeeToken?: any
+  walletId?: string
 }): Promise<PrepareSendReturn> {
   const testnet = isTestnetDebugMode()
   const useCctp = getUseCctp(
@@ -1120,6 +1143,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 +1206,7 @@ async function sendHandlerForDifferentChainDifferentToken({
     originNativeTokenPriceUsd,
     quoteProvider: intent.payloads?.quote?.quoteProvider,
     noSufficientBalance,
+    estimatedGasLimit: estimatedGasLimitForQuote,
   })
 
   // Call onCheckoutQuote callback if provided
@@ -1154,12 +1214,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 +1244,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 +1416,7 @@ async function sendHandlerForDifferentChainDifferentToken({
             feeOptions: intentEntrypointFeeOptions,
             trailsClient,
             selectedFeeToken: effectiveSelectedFeeToken,
+            walletId,
           })
 
           if (!originUserTxReceipt) {
@@ -1801,7 +1869,7 @@ async function sendHandlerForDifferentChainDifferentToken({
         }
 
         checkForDepositTx().catch((error) => {
-          console.error("Error checking for deposit tx", error)
+          logger.console.error("Error checking for deposit tx", error)
         })
 
         // Phase 1: Send meta transactions and queue CCTP
@@ -2019,11 +2087,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 +2130,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 +2161,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 +2272,11 @@ async function sendHandlerForSameChainSameToken({
   checkoutOnHandlers,
   mode,
   fundMethod,
+  gasless,
+  paymasterUrl,
+  selectedFeeToken,
+  trailsClient,
+  originRelayer,
 }: {
   originTokenAddress: string
   originTokenDecimals: number
@@ -2211,6 +2298,11 @@ async function sendHandlerForSameChainSameToken({
   checkoutOnHandlers?: CheckoutOnHandlers
   mode?: "pay" | "fund" | "earn" | "swap" | "receive"
   fundMethod?: string
+  gasless?: boolean
+  paymasterUrl?: string
+  selectedFeeToken?: any
+  trailsClient: TrailsAPIClient
+  originRelayer: Relayer.RpcRelayer
 }): Promise<PrepareSendReturn> {
   logger.console.log("[trails-sdk] isToSameToken && isToSameChain")
   const testnet = isTestnetDebugMode()
@@ -2237,6 +2329,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 +2385,7 @@ async function sendHandlerForSameChainSameToken({
     slippageTolerance,
     quoteProvider: "",
     noSufficientBalance,
+    estimatedGasLimit: estimatedGasLimitForQuote,
   })
 
   // Call onCheckoutQuote callback if provided
@@ -2290,26 +2421,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 +2478,207 @@ 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,
+            })
+
+            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 +2690,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 +2847,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)
     }
   }
 
@@ -2793,7 +3033,7 @@ async function attemptGaslessDeposit({
   chain: Chain
   account: Account
   trailsClient: TrailsAPIClient
-  originRelayer: RpcRelayer.RpcRelayer
+  originRelayer: Relayer.RpcRelayer
   feeOptions: any
   selectedFeeToken?: any
 }): Promise<TransactionReceipt | null> {
@@ -2900,7 +3140,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 +3170,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 +3224,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 +3240,7 @@ async function attemptGaslessDeposit({
         "[trails-sdk] Using infinite approval for gasless deposits",
         {
           depositAmount: depositTokenAmount,
+          depositTokenAddress,
           permitAmount: permitAmount.toString(),
         },
       )
@@ -2994,7 +3258,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",
       )
     }
 
@@ -3221,24 +3485,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 +3765,14 @@ async function attemptUserDepositTx({
   feeOptions,
   trailsClient,
   selectedFeeToken,
+  walletId,
 }: {
   originTokenAddress: string
   gasless: boolean
   paymasterUrl?: string
   chain: Chain
   account: Account
-  originRelayer: RpcRelayer.RpcRelayer
+  originRelayer: Relayer.RpcRelayer
   firstPreconditionMin: string
   originIntentAddress: string
   onOriginSend?: () => void
@@ -3522,6 +3794,7 @@ async function attemptUserDepositTx({
   feeOptions?: any
   trailsClient: TrailsAPIClient
   selectedFeeToken?: any
+  walletId?: string
 }): Promise<TransactionReceipt | null> {
   let originUserTxReceipt: TransactionReceipt | null = null
   const originChainId = chain.id
@@ -3545,6 +3818,7 @@ async function attemptUserDepositTx({
     gasless,
     feeOptions,
     selectedFeeToken,
+    walletId,
   )
   logger.console.log(
     "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] doGasless check results:",
@@ -3587,12 +3861,15 @@ async function attemptUserDepositTx({
       })
     } 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 +3903,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 +4049,7 @@ async function sendMetaTxAndWaitForReceipt({
   feeQuote,
 }: {
   metaTx: MetaTxn
-  relayer: RpcRelayer.RpcRelayer
+  relayer: Relayer.RpcRelayer
   precondition: IntentPrecondition | null
   feeQuote?: string
 }): Promise<{
@@ -3922,7 +4208,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),
@@ -4014,6 +4300,10 @@ export type UseQuoteProps = {
   quoteProvider?: string | null
   gasless?: boolean
   paymasterUrl?: string
+  selectedFeeToken?: {
+    tokenAddress: string
+    tokenSymbol?: string
+  } | null
 }
 
 export type SwapReturn = {
@@ -4057,6 +4347,8 @@ export type Quote = {
   toAmountUsdDisplay?: string
   gasCostUsd?: number
   gasCostUsdDisplay?: string
+  gasCost?: string
+  gasCostFormatted?: string
 }
 
 export type UseQuoteReturn = {
@@ -4082,6 +4374,7 @@ export function useQuote({
   quoteProvider,
   gasless,
   paymasterUrl,
+  selectedFeeToken,
   relayerEnv,
   nodeGatewayEnv,
 }: Partial<
@@ -4223,6 +4516,7 @@ export function useQuote({
           quoteProvider: quoteProvider,
           gasless: gasless ?? false,
           paymasterUrl: paymasterUrl,
+          selectedFeeToken: selectedFeeToken ?? undefined,
         }
 
         logger.console.log("[trails-sdk] options", options)
@@ -4252,6 +4546,8 @@ export function useQuote({
             prepareSendQuote.destinationAmountUsdDisplay ?? undefined,
           gasCostUsd: prepareSendQuote.gasCostUsd ?? undefined,
           gasCostUsdDisplay: prepareSendQuote.gasCostUsdDisplay ?? undefined,
+          gasCost: prepareSendQuote.gasCost ?? undefined,
+          gasCostFormatted: prepareSendQuote.gasCostFormatted ?? undefined,
         }
 
         const swap = async (): Promise<SwapReturn> => {
@@ -4259,7 +4555,9 @@ export function useQuote({
             originUserTxReceipt,
             destinationMetaTxnReceipt,
             totalCompletionSeconds,
-          } = await send({})
+          } = await send({
+            selectedFeeToken: selectedFeeToken ?? undefined,
+          })
 
           return {
             originTransaction: {
@@ -4447,6 +4745,7 @@ export async function getNormalizedQuoteObject({
   originNativeTokenPriceUsd,
   quoteProvider,
   noSufficientBalance,
+  estimatedGasLimit,
 }: {
   originDepositAddress?: string
   destinationDepositAddress?: string
@@ -4470,6 +4769,7 @@ export async function getNormalizedQuoteObject({
   originNativeTokenPriceUsd?: number | null
   quoteProvider?: string
   noSufficientBalance?: boolean
+  estimatedGasLimit?: bigint
 }): Promise<PrepareSendQuote> {
   if (!destinationChainId) {
     throw new Error("Destination chain id is required")
@@ -4497,7 +4797,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 +4871,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
@@ -4657,6 +4992,8 @@ export async function getNormalizedQuoteObject({
     transactionStates: transactionStates || [],
     gasCostUsd,
     gasCostUsdDisplay,
+    gasCost,
+    gasCostFormatted,
     originTokenRate: exchangeRates.originTokenRate,
     destinationTokenRate: exchangeRates.destinationTokenRate,
     originAmountDisplay: formatAmountDisplay(originAmountFormatted),