0xtrails 0.1.13 → 0.2.1

package/src/prepareSend.ts

@@ -1,9 +1,9 @@
 import type {
-  GetIntentCallsPayloadsArgs,
+  GetIntentCallsPayloadParams,
   GetIntentCallsPayloadsReturn,
   IntentPrecondition,
-  SequenceAPIClient,
 } from "@0xsequence/trails-api"
+import type { TrailsAPIClient } from "@0xsequence/trails-api"
 import type { Relayer } from "@0xsequence/wallet-core"
 import { useQuery } from "@tanstack/react-query"
 import type {
@@ -52,11 +52,11 @@ import { queueCCTPTransfer } from "./cctpqueue.js"
 import { getChainInfo, getTestnetChainInfo } from "./chains.js"
 import { attemptSwitchChain } from "./chainSwitch.js"
 import {
-  getSameChainSwapDifferentIntentAddresses,
   getSequenceEnv,
   getSlippageTolerance,
+  type SequenceEnv,
 } from "./config.js"
-import { intentEntrypoints, MINIMUM_USD_AMOUNT_FOR_SWAP } from "./constants.js"
+import { intentEntrypoints } from "./constants.js"
 import {
   decodeGuestModuleEvents,
   decodeTrailsTokenSweeperEvents,
@@ -66,10 +66,16 @@ import { InsufficientBalanceError } from "./error.js"
 import { estimateGasCostUsd } from "./estimate.js"
 import { getExplorerUrl } from "./explorer.js"
 import {
-  getDepositToIntentCalls,
+  getNeedsIntentEntrypointApproval,
   getPermitCalls,
   getPermitSignature,
+  getUserNonce,
+  signIntent,
 } from "./gasless.js"
+import {
+  getIntentEntrypointFeeOptions,
+  isIntentEntrypointSupported,
+} from "./intentEntrypoint.js"
 import { useIndexerGatewayClient } from "./indexerClient.js"
 import {
   commitIntentConfig,
@@ -87,10 +93,6 @@ import {
 } from "./paymasterSend.js"
 import { findFirstPreconditionForChainId } from "./preconditions.js"
 import { calcAmountUsdPrice, getTokenPrice } from "./prices.js"
-import {
-  TRAILS_CONTRACT_PLACEHOLDER_AMOUNT,
-  wrapCalldataWithProxyCallerIfNeeded,
-} from "./proxyCaller.js"
 import { getQueryParam } from "./queryParams.js"
 import type { MetaTxnReceipt, RelayerEnv } from "./relayer.js"
 import { useRelayers } from "./relayer.js"
@@ -118,6 +120,10 @@ import {
   useSupportedTokens,
   type SupportedToken,
 } from "./tokens.js"
+import {
+  TRAILS_ROUTER_PLACEHOLDER_AMOUNT,
+  wrapCalldataWithTrailsRouterIfNeeded,
+} from "./trailsRouter.js"
 import type {
   TransactionState,
   TransactionStateStatus,
@@ -127,6 +133,9 @@ import { requestWithTimeout } from "./utils.js"
 import type { CheckoutOnHandlers } from "./widget/hooks/useCheckout.js"
 import { logger } from "./logger.js"
 import { getIsCustomCalldata } from "./contractUtils.js"
+import type { SequenceAPIClient } from "@0xsequence/api"
+import { useTrailsClient } from "./trailsClient.js"
+import { updatePersistentToast } from "./toast.js"
 
 export enum TradeType {
   EXACT_INPUT = "EXACT_INPUT",
@@ -150,6 +159,7 @@ export type PrepareSendOptions = {
   client?: WalletClient
   dryMode: boolean
   apiClient: SequenceAPIClient
+  trailsClient: TrailsAPIClient
   originRelayer: Relayer.Standard.Rpc.RpcRelayer
   destinationRelayer: Relayer.Standard.Rpc.RpcRelayer
   destinationCalldata?: string
@@ -167,6 +177,7 @@ export type PrepareSendOptions = {
   mode?: "pay" | "fund" | "earn" | "swap" | "receive"
   checkoutOnHandlers?: CheckoutOnHandlers
   refundAddress?: string
+  selectedFeeToken?: any
 }
 
 export type PrepareSendFees = {
@@ -215,7 +226,6 @@ export type PrepareSendQuote = {
   destinationTokenRate: string
   quoteProvider: QuoteProviderInfo | null
   noSufficientBalance: boolean
-  minimumNotMet: boolean
 }
 
 export type PrepareSendReturn = {
@@ -223,10 +233,10 @@ export type PrepareSendReturn = {
   feeOptions?: any
   send: ({
     onOriginSend,
-    feeTokenAddress,
+    selectedFeeToken,
   }: {
     onOriginSend?: () => void
-    feeTokenAddress?: string | null
+    selectedFeeToken?: any
   }) => Promise<SendReturn>
 }
 
@@ -316,7 +326,7 @@ function getIntentArgs(
   slippageTolerance: string, // 0.03 = 3%
   tradeType: TradeType,
   provider?: string | null,
-): GetIntentCallsPayloadsArgs {
+): GetIntentCallsPayloadParams {
   const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
 
   if (!provider || provider === "auto") {
@@ -363,6 +373,7 @@ export async function prepareSend(
     client: walletClient,
     dryMode = false,
     apiClient,
+    trailsClient,
     originRelayer,
     destinationRelayer,
     destinationCalldata,
@@ -377,13 +388,26 @@ export async function prepareSend(
     fundMethod,
     mode,
     checkoutOnHandlers,
+    selectedFeeToken,
   } = options
   let { sourceTokenPriceUsd, destinationTokenPriceUsd } = options
 
+  if (!sourceTokenDecimals) {
+    throw new Error("Source token decimals not provided")
+  }
+  if (!destinationTokenDecimals) {
+    throw new Error("Destination token decimals not provided")
+  }
+
   let hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
   const mainSignerAddress = account.address
   const transactionStates: TransactionState[] = []
 
+  // Validate recipient is not zero address
+  if (recipient === zeroAddress) {
+    throw new Error("Recipient address cannot be zero address")
+  }
+
   // Validate CCTP destination token requirement
   validateCctpDestinationToken(
     destinationTokenAddress,
@@ -394,22 +418,22 @@ export async function prepareSend(
   let effectiveDestinationAddress = recipient
   let effectiveDestinationCalldata = destinationCalldata
 
-  if (!hasCustomCalldata && tradeType === TradeType.EXACT_INPUT) {
+  if (
+    !hasCustomCalldata &&
+    tradeType === TradeType.EXACT_INPUT &&
+    destinationTokenAddress !== zeroAddress
+  ) {
     // we need to set custom calldata for the cctp transfer in order to have destination intent adddress execution needed for metatxn tracking
     effectiveDestinationCalldata = getERC20TransferData({
       recipient,
-      amount: BigInt(TRAILS_CONTRACT_PLACEHOLDER_AMOUNT),
+      amount: BigInt(TRAILS_ROUTER_PLACEHOLDER_AMOUNT),
     })
     effectiveDestinationAddress = destinationTokenAddress
     hasCustomCalldata = true
   }
 
-  if (
-    hasCustomCalldata &&
-    destinationTokenAddress !== zeroAddress &&
-    tradeType === TradeType.EXACT_INPUT
-  ) {
-    const wrapResult = wrapCalldataWithProxyCallerIfNeeded({
+  if (hasCustomCalldata && tradeType === TradeType.EXACT_INPUT) {
+    const wrapResult = wrapCalldataWithTrailsRouterIfNeeded({
       token: destinationTokenAddress,
       target: effectiveDestinationAddress,
       calldata: effectiveDestinationCalldata as `0x${string}`,
@@ -421,7 +445,7 @@ export async function prepareSend(
     })
 
     if (wrapResult) {
-      effectiveDestinationAddress = wrapResult.proxyCallerAddress
+      effectiveDestinationAddress = wrapResult.trailsRouterAddress
       effectiveDestinationCalldata = wrapResult.encodedCalldata
     }
   }
@@ -562,13 +586,7 @@ export async function prepareSend(
   })
 
   // additional execute tx on same chain if needed
-  if (
-    isToSameChain &&
-    hasCustomCalldata &&
-    !isToSameToken &&
-    // TODO: remove this once it's stable https://github.com/0xsequence/stack/pull/1273
-    getSameChainSwapDifferentIntentAddresses()
-  ) {
+  if (isToSameChain && hasCustomCalldata && !isToSameToken) {
     transactionStates.push({
       transactionHash: "",
       explorerUrl: "",
@@ -654,6 +672,7 @@ export async function prepareSend(
     recipient: effectiveDestinationAddress,
     destinationCalldata: effectiveDestinationCalldata,
     apiClient,
+    trailsClient,
     sourceTokenPriceUsd,
     destinationTokenPriceUsd,
     sourceTokenDecimals,
@@ -677,6 +696,7 @@ export async function prepareSend(
     fundMethod,
     mode,
     checkoutOnHandlers,
+    selectedFeeToken,
   })
 }
 
@@ -692,7 +712,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   destinationTokenSymbol,
   recipient,
   destinationCalldata,
-  apiClient,
+  trailsClient,
   sourceTokenPriceUsd,
   destinationTokenPriceUsd,
   sourceTokenDecimals,
@@ -716,6 +736,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   fundMethod,
   mode,
   checkoutOnHandlers,
+  selectedFeeToken,
 }: {
   mainSignerAddress: string
   originChainId: number
@@ -729,6 +750,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   recipient: string
   destinationCalldata?: string
   apiClient: SequenceAPIClient
+  trailsClient: TrailsAPIClient
   sourceTokenPriceUsd?: number | null
   destinationTokenPriceUsd?: number | null
   sourceTokenDecimals: number
@@ -752,6 +774,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   fundMethod?: string
   mode?: "pay" | "fund" | "earn" | "swap" | "receive"
   checkoutOnHandlers?: CheckoutOnHandlers
+  selectedFeeToken?: any
 }): Promise<PrepareSendReturn> {
   const testnet = isTestnetDebugMode()
   const useCctp = getUseCctp(
@@ -799,10 +822,22 @@ async function sendHandlerForDifferentChainDifferentToken({
       quote,
       send: async ({
         onOriginSend,
+        selectedFeeToken: runtimeSelectedFeeToken,
       }: {
         onOriginSend?: () => void
-        feeTokenAddress?: string | null
+        selectedFeeToken?: any
       }): Promise<SendReturn> => {
+        // Use runtime selectedFeeToken if provided, otherwise fall back to the one from prepareSend
+        const effectiveSelectedFeeToken =
+          runtimeSelectedFeeToken ?? selectedFeeToken
+        logger.console.log(
+          "[trails-sdk] [FEE-SELECT] [GASLESS-FLOW] send() called (LEGACY PATH):",
+          {
+            runtimeSelectedFeeToken,
+            prepareTimeSelectedFeeToken: selectedFeeToken,
+            effectiveSelectedFeeToken,
+          },
+        )
         const originChain = testnet ? getTestnetChainInfo(chain)! : chain
         const destinationChain = testnet
           ? getTestnetChainInfo(destinationChainId)!
@@ -993,8 +1028,10 @@ async function sendHandlerForDifferentChainDifferentToken({
   logger.console.log("[trails-sdk] Creating intent with args:", intentArgs)
 
   const intent = await getIntentCallsPayloadsFromIntents(
-    apiClient,
-    intentArgs,
+    trailsClient,
+    {
+      params: intentArgs,
+    },
     {
       originTokenSymbol,
       destinationTokenSymbol,
@@ -1003,18 +1040,21 @@ async function sendHandlerForDifferentChainDifferentToken({
   )
   logger.console.log("[trails-sdk] Got intent:", intent)
 
-  if (!intent.preconditions?.length || !intent.calls?.length) {
+  if (
+    !intent.payloads.preconditions?.length ||
+    !intent.payloads.calls?.length
+  ) {
     throw new Error("Invalid intent")
   }
 
-  const originIntentAddress = intent.originIntentAddress
+  const originIntentAddress = intent.payloads.originIntentAddress
   logger.console.log(
     "[trails-sdk] origin intent address:",
     originIntentAddress.toString(),
   )
 
   const firstPrecondition = findFirstPreconditionForChainId(
-    intent.preconditions,
+    intent.payloads.preconditions,
     originChainId,
   )
 
@@ -1025,8 +1065,8 @@ async function sendHandlerForDifferentChainDifferentToken({
   const firstPreconditionMin = firstPrecondition?.data?.min?.toString()
   const depositAmount = firstPreconditionMin
 
-  const quoteToAmount = intent.quote.toAmount
-  const quoteToAmountMin = intent.quote.toAmountMin
+  const quoteToAmount = intent.payloads.quote.toAmount
+  const quoteToAmountMin = intent.payloads.quote.toAmountMin
 
   const originSendAmountFormatted = formatRawAmount(
     depositAmount,
@@ -1070,7 +1110,6 @@ async function sendHandlerForDifferentChainDifferentToken({
   )
 
   let noSufficientBalance = false
-  let minimumNotMet = false
 
   if (!(fundMethod === "qr-code" || fundMethod === "exchange")) {
     const { hasEnoughBalance } = await checkAccountBalance({
@@ -1085,13 +1124,9 @@ async function sendHandlerForDifferentChainDifferentToken({
     }
   }
 
-  if (Number(depositAmountUsd) < Number(MINIMUM_USD_AMOUNT_FOR_SWAP)) {
-    minimumNotMet = true
-  }
-
   const quote = await getNormalizedQuoteObject({
     originDepositAddress: originIntentAddress,
-    destinationDepositAddress: intent.destinationIntentAddress,
+    destinationDepositAddress: intent.payloads.destinationIntentAddress,
     destinationAddress: recipient,
     destinationCalldata,
     originAmount: depositAmount,
@@ -1114,9 +1149,8 @@ async function sendHandlerForDifferentChainDifferentToken({
     priceImpactUsd: getPriceImpactUsdFromIntent(intent),
     transactionStates,
     originNativeTokenPriceUsd,
-    quoteProvider: intent?.quote?.quoteProvider,
+    quoteProvider: intent.payloads?.quote?.quoteProvider,
     noSufficientBalance,
-    minimumNotMet,
   })
 
   // Call onCheckoutQuote callback if provided
@@ -1124,245 +1158,294 @@ async function sendHandlerForDifferentChainDifferentToken({
     checkoutOnHandlers.triggerCheckoutQuote(quote)
   }
 
-  // let feeOptions: any = null
-
-  // try {
-  //   feeOptions = await getFeeOptions(
-  //     originRelayer,
-  //     intentAddress!,
-  //     originChainId,
-  //     [
-  //       {
-  //         to: intentAddress,
-  //         value: BigInt(0),
-  //         data: getERC20TransferData({
-  //           recipient,
-  //           amount: BigInt(swapAmount),
-  //         }),
-  //         gasLimit: BigInt(0),
-  //         delegateCall: false,
-  //         onlyFallback: false,
-  //         behaviorOnError: "revert",
-  //       },
-  //     ] as Payload.Call[],
-  //   )
-  // } catch (error) {
-  //   console.error("[trails-sdk] Error getting fee options", error)
-  // }
-
-  // logger.console.log("[trails-sdk] prepareSend feeOptions", feeOptions)
+  // Get intent entrypoint fee options if supported, gasless is enabled, and fundMethod is wallet
+  let intentEntrypointFeeOptions: any = null
+  if (gasless && fundMethod === "wallet") {
+    try {
+      logger.console.log(
+        "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Gasless enabled and fundMethod is wallet, checking intent entrypoint support for chain:",
+        originChainId,
+      )
+      if (isIntentEntrypointSupported(originChainId)) {
+        logger.console.log(
+          "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Chain supported, fetching fee options...",
+        )
+        intentEntrypointFeeOptions = await getIntentEntrypointFeeOptions({
+          trailsClient,
+          userAddress: mainSignerAddress as `0x${string}`,
+          tokenAddress: originTokenAddress as `0x${string}`,
+          amount: depositAmount,
+          intentAddress: originIntentAddress as `0x${string}`,
+          chainId: originChainId,
+        })
+        logger.console.log(
+          "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Intent entrypoint fee options:",
+          intentEntrypointFeeOptions,
+        )
+      } else {
+        logger.console.log(
+          "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Chain not supported for intent entrypoint:",
+          originChainId,
+        )
+      }
+    } catch (error) {
+      logger.console.error(
+        "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Error getting intent entrypoint fee options:",
+        error,
+      )
+    }
+  } else {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Gasless disabled or fundMethod is not wallet, skipping intent entrypoint fee options fetch",
+    )
+  }
 
   return {
     quote,
+    feeOptions: intentEntrypointFeeOptions,
     send: async ({
       onOriginSend,
+      selectedFeeToken: runtimeSelectedFeeToken,
     }: {
       onOriginSend?: () => void
-      feeTokenAddress?: string | null
+      selectedFeeToken?: any
     }): Promise<SendReturn> => {
-      await commitIntentConfig(
-        apiClient,
-        mainSignerAddress,
-        intent.calls,
-        intent.preconditions,
-        {
-          originTokenSymbol,
-          destinationTokenSymbol,
-        },
-        intentArgs as IntentRequestParams,
-      )
+      try {
+        // Use runtime selectedFeeToken if provided, otherwise fall back to the one from prepareSend
+        const effectiveSelectedFeeToken =
+          runtimeSelectedFeeToken ?? selectedFeeToken
+        logger.console.log(
+          "[trails-sdk] [FEE-SELECT] [GASLESS-FLOW] send() called with:",
+          {
+            runtimeSelectedFeeToken,
+            prepareTimeSelectedFeeToken: selectedFeeToken,
+            effectiveSelectedFeeToken,
+          },
+        )
+        await commitIntentConfig(
+          trailsClient,
+          mainSignerAddress,
+          intent.payloads.calls,
+          intent.payloads.preconditions,
+          {
+            originTokenSymbol,
+            destinationTokenSymbol,
+          },
+          intentArgs as IntentRequestParams,
+        )
 
-      if (!(fundMethod === "qr-code" || fundMethod === "exchange")) {
-        const { hasEnoughBalance, balanceError } = await checkAccountBalance({
-          account,
-          tokenAddress: originTokenAddress,
-          depositAmount,
-          publicClient,
-        })
+        if (!(fundMethod === "qr-code" || fundMethod === "exchange")) {
+          const { hasEnoughBalance, balanceError } = await checkAccountBalance({
+            account,
+            tokenAddress: originTokenAddress,
+            depositAmount,
+            publicClient,
+          })
 
-        if (!hasEnoughBalance) {
-          throw balanceError
+          if (!hasEnoughBalance) {
+            throw balanceError
+          }
         }
-      }
 
-      logger.console.log("[trails-sdk] sending origin transaction")
-      const usingLIfi = false
-      let needsNativeFee = false
+        logger.console.log("[trails-sdk] sending origin transaction")
+        const usingLIfi = false
+        let needsNativeFee = false
 
-      if (usingLIfi) {
-        needsNativeFee = getNeedsLifiNativeFee({
-          originTokenAddress,
-          destinationTokenAmount: swapAmount,
-          destinationTokenDecimals,
+        if (usingLIfi) {
+          needsNativeFee = getNeedsLifiNativeFee({
+            originTokenAddress,
+            destinationTokenAmount: swapAmount,
+            destinationTokenDecimals,
+            sourceTokenDecimals,
+            sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
+            destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
+            depositAmount,
+          })
+        }
+
+        logger.console.log("[trails-sdk] needsNativeFee", needsNativeFee)
+        logger.console.log(
+          "[trails-sdk] sourceTokenPriceUsd",
+          sourceTokenPriceUsd,
+        )
+        logger.console.log(
+          "[trails-sdk] destinationTokenPriceUsd",
+          destinationTokenPriceUsd,
+        )
+        logger.console.log(
+          "[trails-sdk] sourceTokenDecimals",
           sourceTokenDecimals,
-          sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
-          destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
-          depositAmount,
-        })
-      }
+        )
+        logger.console.log(
+          "[trails-sdk] destinationTokenDecimals",
+          destinationTokenDecimals,
+        )
 
-      logger.console.log("[trails-sdk] needsNativeFee", needsNativeFee)
-      logger.console.log(
-        "[trails-sdk] sourceTokenPriceUsd",
-        sourceTokenPriceUsd,
-      )
-      logger.console.log(
-        "[trails-sdk] destinationTokenPriceUsd",
-        destinationTokenPriceUsd,
-      )
-      logger.console.log(
-        "[trails-sdk] sourceTokenDecimals",
-        sourceTokenDecimals,
-      )
-      logger.console.log(
-        "[trails-sdk] destinationTokenDecimals",
-        destinationTokenDecimals,
-      )
+        let originUserTxReceipt: TransactionReceipt | null = null
+        let originMetaTxnReceipt: MetaTxnReceipt | null = null
+        let destinationMetaTxnReceipt: MetaTxnReceipt | null = null
 
-      let originUserTxReceipt: TransactionReceipt | null = null
-      let originMetaTxnReceipt: MetaTxnReceipt | null = null
-      let destinationMetaTxnReceipt: MetaTxnReceipt | null = null
+        const testnet = isTestnetDebugMode()
+        const effectiveOriginChain = testnet
+          ? getTestnetChainInfo(chain)!
+          : chain
+        const effectiveOriginTokenAddress = testnet
+          ? getTestnetOriginTokenAddress(effectiveOriginChain.id)
+          : originTokenAddress
 
-      const testnet = isTestnetDebugMode()
-      const effectiveOriginChain = testnet ? getTestnetChainInfo(chain)! : chain
-      const effectiveOriginTokenAddress = testnet
-        ? getTestnetOriginTokenAddress(effectiveOriginChain.id)
-        : originTokenAddress
+        logger.console.log("[trails-sdk] testnet", testnet)
 
-      logger.console.log("[trails-sdk] testnet", testnet)
+        const destinationPublicClient = createPublicClient({
+          chain: getChainInfo(destinationChainId)!,
+          transport: http(),
+        })
 
-      const destinationPublicClient = createPublicClient({
-        chain: getChainInfo(destinationChainId)!,
-        transport: http(),
-      })
+        const depositPromise = async () => {
+          logger.console.log(
+            "[trails-sdk] depositPromise called - starting deposit transaction",
+          )
+          logger.console.log("[trails-sdk] fundMethod value:", fundMethod)
 
-      const depositPromise = async () => {
-        logger.console.log(
-          "[trails-sdk] depositPromise called - starting deposit transaction",
-        )
-        logger.console.log("[trails-sdk] fundMethod value:", fundMethod)
+          // Skip wallet deposit if fund method is qr-code
+          if (fundMethod === "qr-code" || fundMethod === "exchange") {
+            logger.console.log(
+              "[trails-sdk] Skipping wallet deposit for QR code mode - fundMethod is:",
+              fundMethod,
+            )
+            return
+          }
 
-        // Skip wallet deposit if fund method is qr-code
-        if (fundMethod === "qr-code" || fundMethod === "exchange") {
           logger.console.log(
-            "[trails-sdk] Skipping wallet deposit for QR code mode - fundMethod is:",
-            fundMethod,
+            "[trails-sdk] Calling attemptUserDepositTx with params:",
+            {
+              originTokenAddress: effectiveOriginTokenAddress,
+              gasless,
+              paymasterUrl,
+              chain: effectiveOriginChain.id,
+              account: account.address,
+              firstPreconditionMin,
+              originIntentAddress,
+              fee,
+              dryMode,
+              feeOptions: intentEntrypointFeeOptions,
+              selectedFeeToken: effectiveSelectedFeeToken,
+              selectedFeeTokenType: typeof effectiveSelectedFeeToken,
+              selectedFeeTokenValue: JSON.stringify(effectiveSelectedFeeToken),
+            },
           )
-          return
-        }
 
-        logger.console.log(
-          "[trails-sdk] Calling attemptUserDepositTx with params:",
-          {
+          originUserTxReceipt = await attemptUserDepositTx({
             originTokenAddress: effectiveOriginTokenAddress,
             gasless,
             paymasterUrl,
-            chain: effectiveOriginChain.id,
-            account: account.address,
+            chain: effectiveOriginChain,
+            account,
+            originRelayer,
             firstPreconditionMin,
             originIntentAddress,
+            onOriginSend,
+            publicClient,
+            walletClient,
+            destinationTokenDecimals,
+            sourceTokenDecimals,
             fee,
             dryMode,
-          },
-        )
-
-        originUserTxReceipt = await attemptUserDepositTx({
-          originTokenAddress: effectiveOriginTokenAddress,
-          gasless,
-          paymasterUrl,
-          chain: effectiveOriginChain,
-          account,
-          originRelayer,
-          firstPreconditionMin,
-          originIntentAddress,
-          onOriginSend,
-          publicClient,
-          walletClient,
-          destinationTokenDecimals,
-          sourceTokenDecimals,
-          fee,
-          dryMode,
-          sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
-          destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
-          swapAmount,
-          onTransactionStateChange,
-          transactionStates,
-          fundMethod,
-          originTokenSymbol,
-          destinationTokenSymbol,
-          depositAmountUsd,
-        })
+            sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
+            destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
+            swapAmount,
+            onTransactionStateChange,
+            transactionStates,
+            fundMethod,
+            originTokenSymbol,
+            destinationTokenSymbol,
+            depositAmountUsd,
+            feeOptions: intentEntrypointFeeOptions,
+            trailsClient,
+            selectedFeeToken: effectiveSelectedFeeToken,
+          })
 
-        if (!originUserTxReceipt) {
-          throw new Error("Failed to send origin transaction")
-        }
+          if (!originUserTxReceipt) {
+            throw new Error("Failed to send origin transaction")
+          }
 
-        transactionStates[0] = getTransactionStateFromReceipt(
-          originUserTxReceipt,
-          originChainId,
-          transactionStates[0]?.label,
-        )
-        onTransactionStateChange(transactionStates)
-      }
+          transactionStates[0] = getTransactionStateFromReceipt(
+            originUserTxReceipt,
+            originChainId,
+            transactionStates[0]?.label,
+          )
 
-      const checkForDepositTx = async () => {
-        while (true) {
           try {
-            const response = await getAccountTransactionHistory({
-              chainId: originChainId,
-              accountAddress: originIntentAddress,
-            })
+            transactionStates[0].decodedTrailsTokenSweeperEvents =
+              decodeTrailsTokenSweeperEvents(originUserTxReceipt)
+            transactionStates[0].decodedGuestModuleEvents =
+              decodeGuestModuleEvents(originUserTxReceipt)
+            transactionStates[0].refunded =
+              transactionStates[0].decodedTrailsTokenSweeperEvents.findIndex(
+                (event) =>
+                  event.type === "Refund" || event.type === "RefundAndSweep",
+              ) !== -1
             logger.console.log(
-              "[trails-sdk] getAccountTransactionHistory response",
-              response,
+              "[trails-sdk] [GASLESS-FLOW] Gasless deposit events decoded",
+              {
+                chainId: originChainId,
+                callFailed: (
+                  transactionStates[0].decodedGuestModuleEvents || []
+                ).filter((e: any) => e?.type === "CallFailed").length,
+                sweeperEvents: (
+                  transactionStates[0].decodedTrailsTokenSweeperEvents || []
+                ).length,
+                refunded: transactionStates[0].refunded,
+              },
             )
-            if (response.transactions.length > 0) {
-              const tx = response.transactions[0]
-              if (!tx?.txnHash) {
-                await new Promise((resolve) => setTimeout(resolve, 1000))
-                continue
-              }
-              // const isReceive = tx.transfers.some(
-              //   (transfer) => transfer.transferType === "RECEIVE",
-              // )
-              // if (!isReceive) {
-              //   await new Promise((resolve) => setTimeout(resolve, 1000))
-              //   continue
-              // }
-              const originDepositTxReceipt =
-                await publicClient.getTransactionReceipt({
-                  hash: tx.txnHash as `0x${string}`,
-                })
 
-              originUserTxReceipt = originDepositTxReceipt
+            // Check for transaction failure or refund
+            const hasCallFailed = (
+              transactionStates[0].decodedGuestModuleEvents || []
+            ).some((e: any) => e?.type === "CallFailed")
 
-              transactionStates[0] = getTransactionStateFromReceipt(
-                originDepositTxReceipt,
-                originChainId,
-                transactionStates[0]?.label,
+            if (transactionStates[0].refunded || hasCallFailed) {
+              const errorMessage = transactionStates[0].refunded
+                ? "Transaction was refunded"
+                : "Transaction call failed"
+
+              logger.console.error(
+                "[trails-sdk] [GASLESS-FLOW] Deposit transaction failed",
+                {
+                  refunded: transactionStates[0].refunded,
+                  callFailed: hasCallFailed,
+                },
               )
-              onTransactionStateChange(transactionStates)
 
-              if (onOriginSend) {
-                onOriginSend()
+              // Call onCheckoutError callback if provided
+              if (checkoutOnHandlers?.triggerCheckoutError) {
+                checkoutOnHandlers.triggerCheckoutError(errorMessage)
               }
-              break
             }
           } catch (error) {
-            logger.console.error("Error checking for deposit tx", error)
+            logger.console.error(
+              "[trails-sdk] Error decoding gasless deposit events",
+              error,
+            )
           }
-          await new Promise((resolve) => setTimeout(resolve, 1000))
+
+          onTransactionStateChange(transactionStates)
+
+          setTimeout(() => {
+            const destinationChain = getChainInfo(destinationChainId)
+            updatePersistentToast(
+              "In Progress",
+              `Your transaction to ${destinationChain?.name || "chain"} is in progress`,
+              "info",
+            )
+          }, 1000)
         }
-      }
 
-      const _checkForDestinationDepositTx: () => Promise<TransactionReceipt | null> =
-        async () => {
+        const checkForDepositTx = async () => {
           while (true) {
             try {
               const response = await getAccountTransactionHistory({
-                chainId: destinationChainId,
-                accountAddress:
-                  intent.destinationIntentAddress as `0x${string}`,
+                chainId: originChainId,
+                accountAddress: originIntentAddress,
               })
               logger.console.log(
                 "[trails-sdk] getAccountTransactionHistory response",
@@ -1381,19 +1464,24 @@ async function sendHandlerForDifferentChainDifferentToken({
                 //   await new Promise((resolve) => setTimeout(resolve, 1000))
                 //   continue
                 // }
-                const destinationDepositTxReceipt =
-                  await destinationPublicClient.getTransactionReceipt({
+                const originDepositTxReceipt =
+                  await publicClient.getTransactionReceipt({
                     hash: tx.txnHash as `0x${string}`,
                   })
 
-                transactionStates[2] = getTransactionStateFromReceipt(
-                  destinationDepositTxReceipt,
-                  destinationChainId,
-                  transactionStates[2]?.label,
+                originUserTxReceipt = originDepositTxReceipt
+
+                transactionStates[0] = getTransactionStateFromReceipt(
+                  originDepositTxReceipt,
+                  originChainId,
+                  transactionStates[0]?.label,
                 )
                 onTransactionStateChange(transactionStates)
 
-                return destinationDepositTxReceipt
+                if (onOriginSend) {
+                  onOriginSend()
+                }
+                break
               }
             } catch (error) {
               logger.console.error("Error checking for deposit tx", error)
@@ -1402,199 +1490,77 @@ async function sendHandlerForDifferentChainDifferentToken({
           }
         }
 
-      // Variables to store the waitForReceipt functions
-      let originMetaTxnReceiptPromise:
-        | (() => Promise<MetaTxnReceipt | null>)
-        | null = null
-      let destinationMetaTxnReceiptPromise:
-        | ((abortSignal?: AbortSignal) => Promise<MetaTxnReceipt | null>)
-        | ((abortSignal?: AbortSignal) => Promise<TransactionReceipt | null>)
-        | null = null
-
-      // First phase: Send meta transactions and queue CCTP
-      const originSendMetaTxnPromise = async () => {
-        logger.console.log("[trails-sdk] Starting originSendMetaTxnPromise", {
-          hasMetaTxn: !!intent.metaTxns[0],
-          hasPrecondition: !!intent.preconditions[0],
-          metaTxnId: intent.metaTxns[0]?.id,
-          chainId: intent.metaTxns[0]?.chainId,
-        })
-
-        if (intent.metaTxns[0] && intent.preconditions[0]) {
-          // Extract fee quote from intent response using metatxnid as key
-          const metaTxnId = intent.metaTxns[0].id
-          const feeQuote = intent.feeQuotes?.[metaTxnId]
-          logger.console.log(
-            "[trails-sdk] Extracted fee quote for origin meta txn",
-            {
-              metaTxnId,
-              feeQuote,
-              hasFeeQuote: !!feeQuote,
-            },
-          )
-
-          logger.console.log(
-            "[trails-sdk] Calling sendMetaTxAndWaitForReceipt for origin",
-            {
-              metaTxnId,
-              chainId: intent.metaTxns[0].chainId,
-              walletAddress: intent.metaTxns[0].walletAddress,
-              contract: intent.metaTxns[0].contract,
-            },
-          )
-
-          const { waitForReceipt } = await sendMetaTxAndWaitForReceipt({
-            metaTx: intent.metaTxns[0] as MetaTxn,
-            relayer: originRelayer,
-            precondition: intent.preconditions[0] as IntentPrecondition,
-            feeQuote: feeQuote,
-          })
-
-          logger.console.log(
-            "[trails-sdk] Origin meta transaction sent successfully",
-            {
-              metaTxnId,
-            },
-          )
-
-          // Store the waitForReceipt function for later use
-          originMetaTxnReceiptPromise = waitForReceipt
-        } else {
-          logger.console.warn(
-            "[trails-sdk] Skipping origin sendMetaTxn - missing metaTxn or precondition",
-            {
-              hasMetaTxn: !!intent.metaTxns[0],
-              hasPrecondition: !!intent.preconditions[0],
-            },
-          )
-        }
-      }
-
-      const destinationSendMetaTxnPromise = async () => {
-        logger.console.log(
-          "[trails-sdk] Starting destinationSendMetaTxnPromise",
-          {
-            quoteProvider: intent.quote.quoteProvider,
-            hasQuoteProviderRequestId: !!intent.quote.quoteProviderRequestId,
-            hasPrecondition1: !!intent.preconditions[1],
-            hasMetaTxn1: !!intent.metaTxns[1],
-          },
-        )
-
-        if (
-          intent.quote.quoteProvider === "relay" &&
-          intent.quote.quoteProviderRequestId &&
-          !intent.preconditions[1] &&
-          !intent.metaTxns[1]
-        ) {
-          logger.console.log(
-            "[trails-sdk] Setting up relay destination promise",
-            {
-              quoteProviderRequestId: intent.quote.quoteProviderRequestId,
-            },
-          )
-          // For relay, we'll wait for the receipt in the wait phase
-          // Just store the requestId for later use
-          destinationMetaTxnReceiptPromise = async (
-            abortSignal?: AbortSignal,
-          ) => {
-            logger.console.log(
-              "[trails-sdk] waitForRelayDestinationTx starting",
-              {
-                quoteProviderRequestId: intent.quote.quoteProviderRequestId,
-                aborted: abortSignal?.aborted,
-              },
-            )
-            try {
-              // Check if we should abort before starting
-              if (abortSignal?.aborted) {
-                logger.console.log(
-                  "[trails-sdk] Aborting relay destination tx due to abort signal",
-                )
-                return null
-              }
-
-              const txHash = await waitForRelayDestinationTx(
-                intent.quote.quoteProviderRequestId,
-              )
-              logger.console.log(
-                "[trails-sdk] waitForRelayDestinationTx completed",
-                {
-                  txHash,
-                  quoteProviderRequestId: intent.quote.quoteProviderRequestId,
-                },
-              )
-              if (txHash) {
+        const _checkForDestinationDepositTx: () => Promise<TransactionReceipt | null> =
+          async () => {
+            while (true) {
+              try {
+                const response = await getAccountTransactionHistory({
+                  chainId: destinationChainId,
+                  accountAddress: intent.payloads
+                    .destinationIntentAddress as `0x${string}`,
+                })
                 logger.console.log(
-                  "[trails-sdk] Fetching transaction receipt for relay destination",
-                  {
-                    txHash,
-                    chainId: destinationChainId,
-                  },
+                  "[trails-sdk] getAccountTransactionHistory response",
+                  response,
                 )
+                if (response.transactions.length > 0) {
+                  const tx = response.transactions[0]
+                  if (!tx?.txnHash) {
+                    await new Promise((resolve) => setTimeout(resolve, 1000))
+                    continue
+                  }
+                  // const isReceive = tx.transfers.some(
+                  //   (transfer) => transfer.transferType === "RECEIVE",
+                  // )
+                  // if (!isReceive) {
+                  //   await new Promise((resolve) => setTimeout(resolve, 1000))
+                  //   continue
+                  // }
+                  const destinationDepositTxReceipt =
+                    await destinationPublicClient.getTransactionReceipt({
+                      hash: tx.txnHash as `0x${string}`,
+                    })
 
-                const destinationTxnReceipt =
-                  await destinationPublicClient.getTransactionReceipt({
-                    hash: txHash as `0x${string}`,
-                  })
-                logger.console.log(
-                  "[trails-sdk] relay destinationTxnReceipt received",
-                  {
-                    txHash,
-                    blockNumber: destinationTxnReceipt?.blockNumber,
-                    status: destinationTxnReceipt?.status,
-                    gasUsed: destinationTxnReceipt?.gasUsed,
-                  },
-                )
-                if (transactionStates[2]) {
                   transactionStates[2] = getTransactionStateFromReceipt(
-                    destinationTxnReceipt,
+                    destinationDepositTxReceipt,
                     destinationChainId,
                     transactionStates[2]?.label,
                   )
+                  onTransactionStateChange(transactionStates)
+
+                  return destinationDepositTxReceipt
                 }
-                onTransactionStateChange(transactionStates)
-                return destinationTxnReceipt
-              } else {
-                logger.console.warn(
-                  "[trails-sdk] No txHash returned from waitForRelayDestinationTx",
-                  {
-                    quoteProviderRequestId: intent.quote.quoteProviderRequestId,
-                  },
-                )
-              }
-            } catch (error: unknown) {
-              logger.console.error(
-                "[trails-sdk] Error waiting for relay destination tx",
-                {
-                  error: error instanceof Error ? error.message : String(error),
-                  quoteProviderRequestId: intent.quote.quoteProviderRequestId,
-                },
-              )
-              if (transactionStates?.[2]) {
-                transactionStates[2].state = "failed"
-                onTransactionStateChange(transactionStates)
+              } catch (error) {
+                logger.console.error("Error checking for deposit tx", error)
               }
-              throw error
+              await new Promise((resolve) => setTimeout(resolve, 1000))
             }
-            return null
           }
-        } else {
-          logger.console.log(
-            "[trails-sdk] Setting up destination meta transaction promise (non-relay)",
-            {
-              quoteProvider: intent.quote.quoteProvider,
-              hasMetaTxn1: !!intent.metaTxns[1],
-              hasPrecondition1: !!intent.preconditions[1],
-            },
-          )
 
-          if (intent.metaTxns[1] && intent.preconditions[1]) {
+        // Variables to store the waitForReceipt functions
+        let originMetaTxnReceiptPromise:
+          | (() => Promise<MetaTxnReceipt | null>)
+          | null = null
+        let destinationMetaTxnReceiptPromise:
+          | ((abortSignal?: AbortSignal) => Promise<MetaTxnReceipt | null>)
+          | ((abortSignal?: AbortSignal) => Promise<TransactionReceipt | null>)
+          | null = null
+
+        // First phase: Send meta transactions and queue CCTP
+        const originSendMetaTxnPromise = async () => {
+          logger.console.log("[trails-sdk] Starting originSendMetaTxnPromise", {
+            hasMetaTxn: !!intent.payloads.metaTxns[0],
+            hasPrecondition: !!intent.payloads.preconditions[0],
+            metaTxnId: intent.payloads.metaTxns[0]?.id,
+            chainId: intent.payloads.metaTxns[0]?.chainId,
+          })
+
+          if (intent.payloads.metaTxns[0] && intent.payloads.preconditions[0]) {
             // Extract fee quote from intent response using metatxnid as key
-            const metaTxnId = intent.metaTxns[1].id
-            const feeQuote = intent.feeQuotes?.[metaTxnId]
+            const metaTxnId = intent.payloads.metaTxns[0].id
+            const feeQuote = intent.payloads.feeQuotes?.[metaTxnId]
             logger.console.log(
-              "[trails-sdk] Extracted fee quote for destination meta txn",
+              "[trails-sdk] Extracted fee quote for origin meta txn",
               {
                 metaTxnId,
                 feeQuote,
@@ -1603,318 +1569,597 @@ async function sendHandlerForDifferentChainDifferentToken({
             )
 
             logger.console.log(
-              "[trails-sdk] Calling sendMetaTxAndWaitForReceipt for destination",
+              "[trails-sdk] Calling sendMetaTxAndWaitForReceipt for origin",
               {
                 metaTxnId,
-                chainId: intent.metaTxns[1].chainId,
-                walletAddress: intent.metaTxns[1].walletAddress,
-                contract: intent.metaTxns[1].contract,
+                chainId: intent.payloads.metaTxns[0].chainId,
+                walletAddress: intent.payloads.metaTxns[0].walletAddress,
+                contract: intent.payloads.metaTxns[0].contract,
               },
             )
 
             const { waitForReceipt } = await sendMetaTxAndWaitForReceipt({
-              metaTx: intent.metaTxns[1] as MetaTxn,
-              relayer: destinationRelayer,
-              precondition: intent.preconditions[1] as IntentPrecondition,
+              metaTx: intent.payloads.metaTxns[0] as MetaTxn,
+              relayer: originRelayer,
+              precondition: intent.payloads
+                .preconditions[0] as IntentPrecondition,
               feeQuote: feeQuote,
             })
 
             logger.console.log(
-              "[trails-sdk] Destination meta transaction sent successfully",
+              "[trails-sdk] Origin meta transaction sent successfully",
               {
                 metaTxnId,
               },
             )
 
             // Store the waitForReceipt function for later use
-            destinationMetaTxnReceiptPromise = waitForReceipt
+            originMetaTxnReceiptPromise = waitForReceipt
           } else {
             logger.console.warn(
-              "[trails-sdk] Skipping destination sendMetaTxn - missing metaTxn or precondition",
+              "[trails-sdk] Skipping origin sendMetaTxn - missing metaTxn or precondition",
               {
-                hasMetaTxn: !!intent.metaTxns[1],
-                hasPrecondition: !!intent.preconditions[1],
+                hasMetaTxn: !!intent.payloads.metaTxns[0],
+                hasPrecondition: !!intent.payloads.preconditions[0],
               },
             )
           }
-          // } else if (intent.destinationIntentAddress) {
-          //   destinationMetaTxnReceiptPromise = checkForDestinationDepositTx
-          // }
         }
-      }
 
-      let queueCctpPromise: (() => Promise<void>) | null = null
-
-      const isCctp = intent.quote.quoteProvider === "cctp"
-      if (isCctp) {
-        queueCctpPromise = async () => {
-          while (true) {
-            const originMetaTxnHash = originMetaTxnReceipt?.txnHash
-            if (originMetaTxnHash) {
-              await queueCCTPTransfer({
-                apiClient,
-                sourceTxHash: originMetaTxnHash,
-                sourceChainId: originChainId,
-                destinationChainId: destinationChainId,
-              })
-              break
-            }
-            await new Promise((resolve) => setTimeout(resolve, 1000))
-          }
-        }
-      } else {
-        queueCctpPromise = () => Promise.resolve()
-      }
+        const destinationSendMetaTxnPromise = async () => {
+          logger.console.log(
+            "[trails-sdk] Starting destinationSendMetaTxnPromise",
+            {
+              quoteProvider: intent.payloads.quote.quoteProvider,
+              hasQuoteProviderRequestId:
+                !!intent.payloads.quote.quoteProviderRequestId,
+              hasPrecondition1: !!intent.payloads.preconditions[1],
+              hasMetaTxn1: !!intent.payloads.metaTxns[1],
+            },
+          )
 
-      checkForDepositTx().catch((error) => {
-        console.error("Error checking for deposit tx", error)
-      })
+          if (
+            intent.payloads.quote.quoteProvider === "relay" &&
+            intent.payloads.quote.quoteProviderRequestId &&
+            !intent.payloads.preconditions[1] &&
+            !intent.payloads.metaTxns[1]
+          ) {
+            logger.console.log(
+              "[trails-sdk] Setting up relay destination promise",
+              {
+                quoteProviderRequestId:
+                  intent.payloads.quote.quoteProviderRequestId,
+              },
+            )
+            // For relay, we'll wait for the receipt in the wait phase
+            // Just store the requestId for later use
+            destinationMetaTxnReceiptPromise = async (
+              abortSignal?: AbortSignal,
+            ) => {
+              logger.console.log(
+                "[trails-sdk] waitForRelayDestinationTx starting",
+                {
+                  quoteProviderRequestId:
+                    intent.payloads.quote.quoteProviderRequestId,
+                  aborted: abortSignal?.aborted,
+                },
+              )
+              try {
+                // Check if we should abort before starting
+                if (abortSignal?.aborted) {
+                  logger.console.log(
+                    "[trails-sdk] Aborting relay destination tx due to abort signal",
+                  )
+                  return null
+                }
 
-      // Phase 1: Send meta transactions and queue CCTP
-      logger.console.log(
-        "[trails-sdk] Starting Phase 1: Sending meta transactions and queuing CCTP",
-      )
+                const txHash = await waitForRelayDestinationTx(
+                  intent.payloads.quote.quoteProviderRequestId,
+                )
+                logger.console.log(
+                  "[trails-sdk] waitForRelayDestinationTx completed",
+                  {
+                    txHash,
+                    quoteProviderRequestId:
+                      intent.payloads.quote.quoteProviderRequestId,
+                  },
+                )
+                if (txHash) {
+                  logger.console.log(
+                    "[trails-sdk] Fetching transaction receipt for relay destination",
+                    {
+                      txHash,
+                      chainId: destinationChainId,
+                    },
+                  )
+
+                  const destinationTxnReceipt =
+                    await destinationPublicClient.getTransactionReceipt({
+                      hash: txHash as `0x${string}`,
+                    })
+                  logger.console.log(
+                    "[trails-sdk] relay destinationTxnReceipt received",
+                    {
+                      txHash,
+                      blockNumber: destinationTxnReceipt?.blockNumber,
+                      status: destinationTxnReceipt?.status,
+                      gasUsed: destinationTxnReceipt?.gasUsed,
+                    },
+                  )
+                  if (transactionStates[2]) {
+                    transactionStates[2] = getTransactionStateFromReceipt(
+                      destinationTxnReceipt,
+                      destinationChainId,
+                      transactionStates[2]?.label,
+                    )
+                  }
+                  onTransactionStateChange(transactionStates)
+                  return destinationTxnReceipt
+                } else {
+                  logger.console.warn(
+                    "[trails-sdk] No txHash returned from waitForRelayDestinationTx",
+                    {
+                      quoteProviderRequestId:
+                        intent.payloads.quote.quoteProviderRequestId,
+                    },
+                  )
+                }
+              } catch (error: unknown) {
+                logger.console.error(
+                  "[trails-sdk] Error waiting for relay destination tx",
+                  {
+                    error:
+                      error instanceof Error ? error.message : String(error),
+                    quoteProviderRequestId:
+                      intent.payloads.quote.quoteProviderRequestId,
+                  },
+                )
+                if (transactionStates?.[2]) {
+                  transactionStates[2].state = "failed"
+                  onTransactionStateChange(transactionStates)
+                }
+                throw error
+              }
+              return null
+            }
+          } else {
+            logger.console.log(
+              "[trails-sdk] Setting up destination meta transaction promise (non-relay)",
+              {
+                quoteProvider: intent.payloads.quote.quoteProvider,
+                hasMetaTxn1: !!intent.payloads.metaTxns[1],
+                hasPrecondition1: !!intent.payloads.preconditions[1],
+              },
+            )
 
-      await Promise.all([
-        originSendMetaTxnPromise(),
-        destinationSendMetaTxnPromise(),
-      ])
+            if (
+              intent.payloads.metaTxns[1] &&
+              intent.payloads.preconditions[1]
+            ) {
+              // Extract fee quote from intent response using metatxnid as key
+              const metaTxnId = intent.payloads.metaTxns[1].id
+              const feeQuote = intent.payloads.feeQuotes?.[metaTxnId]
+              logger.console.log(
+                "[trails-sdk] Extracted fee quote for destination meta txn",
+                {
+                  metaTxnId,
+                  feeQuote,
+                  hasFeeQuote: !!feeQuote,
+                },
+              )
 
-      logger.console.log("[trails-sdk] Phase 1 completed successfully")
+              logger.console.log(
+                "[trails-sdk] Calling sendMetaTxAndWaitForReceipt for destination",
+                {
+                  metaTxnId,
+                  chainId: intent.payloads.metaTxns[1].chainId,
+                  walletAddress: intent.payloads.metaTxns[1].walletAddress,
+                  contract: intent.payloads.metaTxns[1].contract,
+                },
+              )
 
-      // Phase 2: Wait for receipts and execute deposit
-      logger.console.log(
-        "[trails-sdk] Starting Phase 2: Waiting for receipts and executing deposit",
-      )
+              const { waitForReceipt } = await sendMetaTxAndWaitForReceipt({
+                metaTx: intent.payloads.metaTxns[1] as MetaTxn,
+                relayer: destinationRelayer,
+                precondition: intent.payloads
+                  .preconditions[1] as IntentPrecondition,
+                feeQuote: feeQuote,
+              })
 
-      const waitForOriginMetaTxnReceiptPromise = async () => {
-        logger.console.log(
-          "[trails-sdk] Waiting for origin meta transaction receipt",
-        )
-        if (originMetaTxnReceiptPromise) {
-          try {
-            originMetaTxnReceipt = await originMetaTxnReceiptPromise()
+              logger.console.log(
+                "[trails-sdk] Destination meta transaction sent successfully",
+                {
+                  metaTxnId,
+                },
+              )
 
-            if (originMetaTxnReceipt && transactionStates[1]) {
-              transactionStates[1] = getTransactionStateFromReceipt(
-                originMetaTxnReceipt,
-                originChainId,
-                transactionStates[1]?.label,
+              // Store the waitForReceipt function for later use
+              destinationMetaTxnReceiptPromise = waitForReceipt
+            } else {
+              logger.console.warn(
+                "[trails-sdk] Skipping destination sendMetaTxn - missing metaTxn or precondition",
+                {
+                  hasMetaTxn: !!intent.payloads.metaTxns[1],
+                  hasPrecondition: !!intent.payloads.preconditions[1],
+                },
               )
-              onTransactionStateChange(transactionStates)
+            }
+            // } else if (intent.payloads.destinationIntentAddress) {
+            //   destinationMetaTxnReceiptPromise = checkForDestinationDepositTx
+            // }
+          }
+        }
 
-              try {
-                const receipt = await publicClient.getTransactionReceipt({
-                  hash: originMetaTxnReceipt.txnHash as `0x${string}`,
+        let queueCctpPromise: (() => Promise<void>) | null = null
+
+        const isCctp = intent.payloads.quote.quoteProvider === "cctp"
+        if (isCctp) {
+          queueCctpPromise = async () => {
+            while (true) {
+              const originMetaTxnHash = originMetaTxnReceipt?.txnHash
+              if (originMetaTxnHash) {
+                await queueCCTPTransfer({
+                  trailsClient,
+                  sourceTxHash: originMetaTxnHash,
+                  sourceChainId: originChainId,
+                  destinationChainId: destinationChainId,
                 })
-                transactionStates[1].decodedTrailsTokenSweeperEvents =
-                  decodeTrailsTokenSweeperEvents(receipt)
-                transactionStates[1].decodedGuestModuleEvents =
-                  decodeGuestModuleEvents(receipt)
-                transactionStates[1].refunded =
-                  transactionStates[1].decodedTrailsTokenSweeperEvents.findIndex(
-                    (event) =>
-                      event.type === "Refund" ||
-                      event.type === "RefundAndSweep",
-                  ) !== -1
-                logger.console.log("[trails-sdk] Origin meta-tx events", {
-                  chainId: originChainId,
-                  callFailed: (
-                    transactionStates[1].decodedGuestModuleEvents || []
-                  ).filter((e: any) => e?.type === "CallFailed").length,
-                  sweeperEvents: (
-                    transactionStates[1].decodedTrailsTokenSweeperEvents || []
-                  ).length,
-                  refunded: transactionStates[1].refunded,
-                })
-                onTransactionStateChange(transactionStates)
-              } catch (error) {
-                logger.console.error("Error decoding origin tx events", error)
+                break
               }
+              await new Promise((resolve) => setTimeout(resolve, 1000))
             }
-          } catch (error) {
-            logger.console.error(
-              "[trails-sdk] Error waiting for origin receipt:",
-              error,
-            )
           }
         } else {
-          logger.console.log(
-            "[trails-sdk] No origin meta transaction receipt promise to wait for",
-          )
+          queueCctpPromise = () => Promise.resolve()
         }
-      }
 
-      const waitForDestinationMetaTxnReceiptPromise = async () => {
+        checkForDepositTx().catch((error) => {
+          console.error("Error checking for deposit tx", error)
+        })
+
+        // Phase 1: Send meta transactions and queue CCTP
         logger.console.log(
-          "[trails-sdk] Waiting for destination meta transaction receipt",
+          "[trails-sdk] Starting Phase 1: Sending meta transactions and queuing CCTP",
         )
-        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)
-              : Promise.resolve(null)
-
-            const failurePollingPromise = new Promise<null>((resolve) => {
-              const pollForFailures = () => {
-                const isPreviousTxCallFailed =
-                  transactionStates?.some((tx) => tx.state === "failed") ||
-                  transactionStates?.some((tx) =>
-                    tx?.decodedGuestModuleEvents?.some(
-                      (event) => event.type === "CallFailed",
-                    ),
-                  )
 
-                if (isPreviousTxCallFailed) {
-                  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)
-                }
-              }
-              pollForFailures()
-            })
+        await Promise.all([
+          originSendMetaTxnPromise(),
+          destinationSendMetaTxnPromise(),
+        ])
 
-            destinationMetaTxnReceipt = (await Promise.race([
-              destinationReceiptPromise,
-              failurePollingPromise,
-            ])) as MetaTxnReceipt
+        logger.console.log("[trails-sdk] Phase 1 completed successfully")
 
+        // Phase 2: Wait for receipts and execute deposit
+        logger.console.log(
+          "[trails-sdk] Starting Phase 2: Waiting for receipts and executing deposit",
+        )
+
+        const waitForOriginMetaTxnReceiptPromise = async () => {
+          logger.console.log(
+            "[trails-sdk] Waiting for origin meta transaction receipt",
+          )
+          if (originMetaTxnReceiptPromise) {
+            try {
+              originMetaTxnReceipt = await originMetaTxnReceiptPromise()
+
+              if (originMetaTxnReceipt && transactionStates[1]) {
+                transactionStates[1] = getTransactionStateFromReceipt(
+                  originMetaTxnReceipt,
+                  originChainId,
+                  transactionStates[1]?.label,
+                )
+                onTransactionStateChange(transactionStates)
+
+                try {
+                  const receipt = await publicClient.getTransactionReceipt({
+                    hash: originMetaTxnReceipt.txnHash as `0x${string}`,
+                  })
+                  transactionStates[1].decodedTrailsTokenSweeperEvents =
+                    decodeTrailsTokenSweeperEvents(receipt)
+                  transactionStates[1].decodedGuestModuleEvents =
+                    decodeGuestModuleEvents(receipt)
+                  transactionStates[1].refunded =
+                    transactionStates[1].decodedTrailsTokenSweeperEvents.findIndex(
+                      (event) =>
+                        event.type === "Refund" ||
+                        event.type === "RefundAndSweep",
+                    ) !== -1
+                  logger.console.log("[trails-sdk] Origin meta-tx events", {
+                    chainId: originChainId,
+                    callFailed: (
+                      transactionStates[1].decodedGuestModuleEvents || []
+                    ).filter((e: any) => e?.type === "CallFailed").length,
+                    sweeperEvents: (
+                      transactionStates[1].decodedTrailsTokenSweeperEvents || []
+                    ).length,
+                    refunded: transactionStates[1].refunded,
+                  })
+
+                  // Check for transaction failure or refund
+                  const hasCallFailed = (
+                    transactionStates[1].decodedGuestModuleEvents || []
+                  ).some((e: any) => e?.type === "CallFailed")
+
+                  if (transactionStates[1].refunded || hasCallFailed) {
+                    const errorMessage = transactionStates[1].refunded
+                      ? "Origin transaction was refunded"
+                      : "Origin transaction call failed"
+
+                    logger.console.error("[trails-sdk] Origin meta-tx failed", {
+                      refunded: transactionStates[1].refunded,
+                      callFailed: hasCallFailed,
+                    })
+
+                    // Call onCheckoutError callback if provided
+                    if (checkoutOnHandlers?.triggerCheckoutError) {
+                      checkoutOnHandlers.triggerCheckoutError(errorMessage)
+                    }
+                  }
+
+                  onTransactionStateChange(transactionStates)
+                } catch (error) {
+                  logger.console.error("Error decoding origin tx events", error)
+                }
+              }
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk] Error waiting for origin receipt:",
+                error,
+              )
+            }
+          } else {
             logger.console.log(
-              "[trails-sdk] destinationMetaTxnReceipt",
-              destinationMetaTxnReceipt,
+              "[trails-sdk] No origin meta transaction receipt promise to wait for",
             )
+          }
+        }
+
+        const waitForDestinationMetaTxnReceiptPromise = async () => {
+          logger.console.log(
+            "[trails-sdk] Waiting for destination meta transaction receipt",
+          )
+          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)
+                : Promise.resolve(null)
+
+              const failurePollingPromise = new Promise<null>((resolve) => {
+                const pollForFailures = () => {
+                  const isPreviousTxCallFailed =
+                    transactionStates?.some((tx) => tx.state === "failed") ||
+                    transactionStates?.some((tx) =>
+                      tx?.decodedGuestModuleEvents?.some(
+                        (event) => event.type === "CallFailed",
+                      ),
+                    )
+
+                  if (isPreviousTxCallFailed) {
+                    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)
+                  }
+                }
+                pollForFailures()
+              })
+
+              destinationMetaTxnReceipt = (await Promise.race([
+                destinationReceiptPromise,
+                failurePollingPromise,
+              ])) as MetaTxnReceipt
 
-            if (destinationMetaTxnReceipt && transactionStates[2]) {
-              transactionStates[2] = getTransactionStateFromReceipt(
+              logger.console.log(
+                "[trails-sdk] destinationMetaTxnReceipt",
                 destinationMetaTxnReceipt,
-                destinationChainId,
-                transactionStates[2]?.label,
               )
-              onTransactionStateChange(transactionStates)
 
-              try {
-                const receipt =
-                  await destinationPublicClient.getTransactionReceipt({
-                    hash: destinationMetaTxnReceipt.txnHash as `0x${string}`,
-                  })
-                transactionStates[2].decodedTrailsTokenSweeperEvents =
-                  decodeTrailsTokenSweeperEvents(receipt)
-                transactionStates[2].decodedGuestModuleEvents =
-                  decodeGuestModuleEvents(receipt)
-                transactionStates[2].refunded =
-                  transactionStates[2].decodedTrailsTokenSweeperEvents.findIndex(
-                    (event) =>
-                      event.type === "Refund" ||
-                      event.type === "RefundAndSweep" ||
-                      event.type === "Sweep",
-                  ) !== -1
-                logger.console.log("[trails-sdk] Destination meta-tx events", {
-                  chainId: destinationChainId,
-                  callFailed: (
-                    transactionStates[2].decodedGuestModuleEvents || []
-                  ).filter((e: any) => e?.type === "CallFailed").length,
-                  sweeperEvents: (
-                    transactionStates[2].decodedTrailsTokenSweeperEvents || []
-                  ).length,
-                  refunded: transactionStates[2].refunded,
-                })
+              if (destinationMetaTxnReceipt && transactionStates[2]) {
+                transactionStates[2] = getTransactionStateFromReceipt(
+                  destinationMetaTxnReceipt,
+                  destinationChainId,
+                  transactionStates[2]?.label,
+                )
                 onTransactionStateChange(transactionStates)
-              } catch (error) {
-                console.error("Error decoding destination tx events", error)
+
+                try {
+                  const receipt =
+                    await destinationPublicClient.getTransactionReceipt({
+                      hash: destinationMetaTxnReceipt.txnHash as `0x${string}`,
+                    })
+                  transactionStates[2].decodedTrailsTokenSweeperEvents =
+                    decodeTrailsTokenSweeperEvents(receipt)
+                  transactionStates[2].decodedGuestModuleEvents =
+                    decodeGuestModuleEvents(receipt)
+                  transactionStates[2].refunded =
+                    transactionStates[2].decodedTrailsTokenSweeperEvents.findIndex(
+                      (event) =>
+                        event.type === "Refund" ||
+                        event.type === "RefundAndSweep",
+                    ) !== -1 ||
+                    (transactionStates[2].decodedTrailsTokenSweeperEvents.findIndex(
+                      (event) => event.type === "Sweep",
+                    ) !== -1 &&
+                      transactionStates[2].decodedGuestModuleEvents.findIndex(
+                        (event) => event.type === "CallFailed",
+                      ) !== -1)
+                  logger.console.log(
+                    "[trails-sdk] Destination meta-tx events",
+                    {
+                      chainId: destinationChainId,
+                      callFailed: (
+                        transactionStates[2].decodedGuestModuleEvents || []
+                      ).filter((e: any) => e?.type === "CallFailed").length,
+                      sweeperEvents: (
+                        transactionStates[2].decodedTrailsTokenSweeperEvents ||
+                        []
+                      ).length,
+                      refunded: transactionStates[2].refunded,
+                    },
+                  )
+
+                  // Check for transaction failure or refund
+                  const hasCallFailed = (
+                    transactionStates[2].decodedGuestModuleEvents || []
+                  ).some((e: any) => e?.type === "CallFailed")
+
+                  if (transactionStates[2].refunded || hasCallFailed) {
+                    const errorMessage = transactionStates[2].refunded
+                      ? "Destination transaction was refunded"
+                      : "Destination transaction call failed"
+
+                    logger.console.error(
+                      "[trails-sdk] Destination meta-tx failed",
+                      {
+                        refunded: transactionStates[2].refunded,
+                        callFailed: hasCallFailed,
+                      },
+                    )
+
+                    // Call onCheckoutError callback if provided
+                    if (checkoutOnHandlers?.triggerCheckoutError) {
+                      checkoutOnHandlers.triggerCheckoutError(errorMessage)
+                    }
+                  }
+
+                  onTransactionStateChange(transactionStates)
+                } catch (error) {
+                  console.error("Error decoding destination tx events", error)
+                }
               }
-            }
-          } catch (error) {
-            console.error(
-              "[trails-sdk] Error waiting for destination receipt:",
-              error,
-            )
-            // For relay transactions, this might be expected if still waiting
-            if (intent.quote.quoteProvider === "relay") {
-              logger.console.log(
-                "[trails-sdk] Relay transaction still waiting, this is normal",
+            } catch (error) {
+              console.error(
+                "[trails-sdk] Error waiting for destination receipt:",
+                error,
               )
+              // For relay transactions, this might be expected if still waiting
+              if (intent.payloads.quote.quoteProvider === "relay") {
+                logger.console.log(
+                  "[trails-sdk] Relay transaction still waiting, this is normal",
+                )
+              }
             }
+          } else {
+            logger.console.log(
+              "[trails-sdk] No destination meta transaction receipt promise to wait for",
+            )
           }
-        } else {
-          logger.console.log(
-            "[trails-sdk] No destination meta transaction receipt promise to wait for",
-          )
         }
-      }
 
-      logger.console.log(
-        "[trails-sdk] Executing Phase 2 Promise.all with deposit",
-      )
-      logger.console.log(
-        "[trails-sdk] About to call depositPromise - fundMethod is:",
-        fundMethod,
-      )
+        logger.console.log(
+          "[trails-sdk] Executing Phase 2 Promise.all with deposit",
+        )
+        logger.console.log(
+          "[trails-sdk] About to call depositPromise - fundMethod is:",
+          fundMethod,
+        )
 
-      await Promise.all([
-        depositPromise(),
-        waitForOriginMetaTxnReceiptPromise(),
-        waitForDestinationMetaTxnReceiptPromise(),
-        queueCctpPromise(),
-      ])
-      logger.console.log("[trails-sdk] Phase 2 completed successfully")
+        await Promise.all([
+          depositPromise(),
+          waitForOriginMetaTxnReceiptPromise(),
+          waitForDestinationMetaTxnReceiptPromise(),
+          queueCctpPromise(),
+        ])
+        logger.console.log("[trails-sdk] Phase 2 completed successfully")
 
-      // Track payment completion
-      if (originUserTxReceipt && destinationMetaTxnReceipt) {
-        trackPaymentCompleted({
-          userAddress: account.address,
-          originIntentAddress,
-          originTxHash: (originUserTxReceipt as TransactionReceipt)
-            .transactionHash,
-          destinationTxHash: (destinationMetaTxnReceipt as MetaTxnReceipt)
-            ?.txnHash,
-          originChainId,
-          destinationChainId,
-          mode,
-          fundMethod,
-          originTokenSymbol,
-          originTokenAddress,
-          destinationTokenAddress,
-          destinationTokenSymbol,
-          depositTokenAmountUsd: depositAmountUsd?.toString(),
-          destinationTokenAmountUsd:
-            effectiveDestinationTokenAmountUsd?.toString(),
-        })
+        // Track payment completion for different chain and different token
+        if (originUserTxReceipt && destinationMetaTxnReceipt) {
+          trackPaymentCompleted({
+            userAddress: account.address,
+            originIntentAddress,
+            originTxHash: (originUserTxReceipt as TransactionReceipt)
+              .transactionHash,
+            destinationTxHash: (destinationMetaTxnReceipt as MetaTxnReceipt)
+              ?.txnHash,
+            originChainId,
+            destinationChainId,
+            mode,
+            fundMethod,
+            originTokenSymbol,
+            originTokenAddress,
+            destinationTokenAddress,
+            destinationTokenSymbol,
+            depositTokenAmountUsd: depositAmountUsd?.toString(),
+            destinationTokenAmountUsd:
+              effectiveDestinationTokenAmountUsd?.toString(),
+          })
 
-        // Call onCheckoutComplete callback if provided
-        if (checkoutOnHandlers?.triggerCheckoutComplete) {
-          checkoutOnHandlers.triggerCheckoutComplete()
-        }
-      } else {
-        if (
-          transactionStates[1] &&
-          transactionStates[1]?.transactionHash === "" &&
-          transactionStates[1]?.state === "pending"
-        ) {
-          transactionStates[1].state = "aborted"
-          onTransactionStateChange(transactionStates)
+          // Call onCheckoutComplete callback if provided
+          if (checkoutOnHandlers?.triggerCheckoutComplete) {
+            checkoutOnHandlers.triggerCheckoutComplete()
+          }
+        } else {
+          if (
+            transactionStates[1] &&
+            transactionStates[1]?.transactionHash === "" &&
+            transactionStates[1]?.state === "pending"
+          ) {
+            transactionStates[1].state = "aborted"
+            onTransactionStateChange(transactionStates)
+          }
+          if (
+            transactionStates[2] &&
+            transactionStates[2]?.transactionHash === "" &&
+            transactionStates[2]?.state === "pending"
+          ) {
+            transactionStates[2].state = "aborted"
+            onTransactionStateChange(transactionStates)
+          }
+
+          // Track payment error if transactions didn't complete successfully
+          trackPaymentError({
+            error:
+              "Payment transactions possibly did not complete successfully. Was not able to receive both origin and destination meta transaction receipts. May be an API error.",
+            userAddress: account.address,
+            originIntentAddress,
+            mode,
+            fundMethod,
+            originChainId,
+            destinationChainId,
+            originTokenSymbol,
+            originTokenAddress,
+            destinationTokenAddress,
+            destinationTokenSymbol,
+          })
+
+          // Call onCheckoutError callback if provided
+          if (checkoutOnHandlers?.triggerCheckoutError) {
+            checkoutOnHandlers.triggerCheckoutError(
+              "Payment transactions did not complete successfully",
+            )
+          }
         }
-        if (
-          transactionStates[2] &&
-          transactionStates[2]?.transactionHash === "" &&
-          transactionStates[2]?.state === "pending"
-        ) {
-          transactionStates[2].state = "aborted"
-          onTransactionStateChange(transactionStates)
+
+        return {
+          originUserTxReceipt,
+          originMetaTxnReceipt,
+          destinationMetaTxnReceipt,
+          totalCompletionSeconds: await getTxTimeDiff(
+            transactionStates[0],
+            transactionStates[2],
+          ),
         }
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error
+            ? error.message
+            : "Unknown error occurred during transaction"
+        logger.console.error(
+          "[trails-sdk] Error in sendHandlerForDifferentChainDifferentToken:",
+          error,
+        )
 
-        // Track payment error if transactions didn't complete successfully
+        // Track payment error
         trackPaymentError({
-          error:
-            "Payment transactions possibly did not complete successfully. Was not able to receive both origin and destination meta transaction receipts. May be an API error.",
+          error: errorMessage,
           userAddress: account.address,
           originIntentAddress,
           mode,
@@ -1929,20 +2174,11 @@ async function sendHandlerForDifferentChainDifferentToken({
 
         // Call onCheckoutError callback if provided
         if (checkoutOnHandlers?.triggerCheckoutError) {
-          checkoutOnHandlers.triggerCheckoutError(
-            "Payment transactions did not complete successfully",
-          )
+          checkoutOnHandlers.triggerCheckoutError(errorMessage)
         }
-      }
 
-      return {
-        originUserTxReceipt,
-        originMetaTxnReceipt,
-        destinationMetaTxnReceipt,
-        totalCompletionSeconds: await getTxTimeDiff(
-          transactionStates[0],
-          transactionStates[2],
-        ),
+        // Re-throw the error so caller can handle if needed
+        throw error
       }
     },
   }
@@ -2002,7 +2238,6 @@ async function sendHandlerForSameChainSameToken({
   })
 
   let noSufficientBalance = false
-  const minimumNotMet = false
 
   const { hasEnoughBalance } = await checkAccountBalance({
     account,
@@ -2033,7 +2268,6 @@ async function sendHandlerForSameChainSameToken({
     slippageTolerance,
     quoteProvider: "",
     noSufficientBalance,
-    minimumNotMet,
   })
 
   // Call onCheckoutQuote callback if provided
@@ -2047,183 +2281,240 @@ async function sendHandlerForSameChainSameToken({
       onOriginSend,
     }: {
       onOriginSend?: () => void
-      feeTokenAddress?: string | null
     }): Promise<SendReturn> => {
-      const { hasEnoughBalance, balanceError } = await checkAccountBalance({
-        account,
-        tokenAddress: effectiveOriginTokenAddress,
-        depositAmount: swapAmount,
-        publicClient: effectivePublicClient,
-      })
+      try {
+        const { hasEnoughBalance, balanceError } = await checkAccountBalance({
+          account,
+          tokenAddress: effectiveOriginTokenAddress,
+          depositAmount: swapAmount,
+          publicClient: effectivePublicClient,
+        })
 
-      if (!hasEnoughBalance) {
-        throw balanceError
-      }
+        if (!hasEnoughBalance) {
+          throw balanceError
+        }
 
-      const depositAmountFormatted = Number(
-        formatUnits(BigInt(swapAmount), originTokenDecimals),
-      )
-      const depositAmountUsd = calcAmountUsdPrice({
-        amount: depositAmountFormatted,
-        usdPrice: sourceTokenPriceUsd,
-      })
+        const depositAmountFormatted = Number(
+          formatUnits(BigInt(swapAmount), originTokenDecimals),
+        )
+        const depositAmountUsd = calcAmountUsdPrice({
+          amount: depositAmountFormatted,
+          usdPrice: sourceTokenPriceUsd,
+        })
 
-      const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-      const originCallParams = {
-        to: hasCustomCalldata
-          ? recipient
-          : effectiveOriginTokenAddress === zeroAddress
+        const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
+        const originCallParams = {
+          to: hasCustomCalldata
             ? recipient
-            : effectiveOriginTokenAddress,
-        data: hasCustomCalldata
-          ? destinationCalldata
-          : effectiveOriginTokenAddress === zeroAddress
-            ? "0x"
-            : getERC20TransferData({
-                recipient,
-                amount: BigInt(swapAmount),
-              }),
-        value:
-          effectiveOriginTokenAddress === zeroAddress
-            ? BigInt(swapAmount)
-            : "0",
-        chainId: effectiveOriginChainId,
-        chain: effectiveOriginChain,
-      }
-
-      logger.console.log("[trails-sdk] origin call params", originCallParams)
+            : 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,
+        }
 
-      let originUserTxReceipt: TransactionReceipt | null = null
-      const originMetaTxnReceipt: MetaTxnReceipt | null = null
-      const destinationMetaTxnReceipt: MetaTxnReceipt | null = null
+        logger.console.log("[trails-sdk] origin call params", originCallParams)
 
-      await attemptSwitchChain({
-        walletClient,
-        desiredChainId: effectiveOriginChainId,
-      })
-      if (!dryMode) {
-        try {
-          onTransactionStateChange([
-            {
-              transactionHash: "",
-              explorerUrl: "",
-              chainId: effectiveOriginChainId,
-              state: "pending",
-              label: "Execute",
-            },
-          ])
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error calling onTransactionStateChange:",
-            error,
-          )
-        }
+        let originUserTxReceipt: TransactionReceipt | null = null
+        const originMetaTxnReceipt: MetaTxnReceipt | null = null
+        const destinationMetaTxnReceipt: MetaTxnReceipt | null = null
 
-        if (hasCustomCalldata) {
+        await attemptSwitchChain({
+          walletClient,
+          desiredChainId: effectiveOriginChainId,
+        })
+        if (!dryMode) {
           try {
-            const needsApproval = await getNeedsApproval({
-              publicClient: effectivePublicClient,
-              token: effectiveOriginTokenAddress,
-              account: account.address,
-              spender: recipient,
-              amount: BigInt(swapAmount),
-            })
+            onTransactionStateChange([
+              {
+                transactionHash: "",
+                explorerUrl: "",
+                chainId: effectiveOriginChainId,
+                state: "pending",
+                label: "Execute",
+              },
+            ])
+          } catch (error) {
+            logger.console.error(
+              "[trails-sdk] Error calling onTransactionStateChange:",
+              error,
+            )
+          }
 
-            if (needsApproval) {
-              const txHash = await approveERC20({
-                walletClient,
-                tokenAddress: effectiveOriginTokenAddress,
+          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)
           }
-        }
-
-        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)
+          // Show persistent toast for checkout flow
+          updatePersistentToast(
+            "Payment Started",
+            "Waiting for wallet confirmation...",
+            "info",
+          )
 
-        if (onOriginSend) {
-          onOriginSend()
-        }
+          logger.console.log(
+            "[trails-sdk] origin call params",
+            originCallParams,
+          )
+          const txHash = await sendOriginTransaction(
+            account,
+            walletClient,
+            originCallParams as any,
+            {
+              depositTokenAmountUsd: depositAmountUsd?.toString(),
+            },
+          ) // TODO: Add proper type
 
-        // Wait for transaction receipt
-        const receipt = await effectivePublicClient.waitForTransactionReceipt({
-          hash: txHash,
-        })
-        logger.console.log("[trails-sdk] receipt", receipt)
-        originUserTxReceipt = receipt
+          logger.console.log("[trails-sdk] origin tx", txHash)
 
-        trackTransactionConfirmed({
-          transactionHash: txHash,
-          chainId: effectiveOriginChainId,
-          userAddress: account.address,
-          blockNumber: Number(receipt.blockNumber),
-          originTokenAddress,
-          depositTokenAmountUsd: depositAmountUsd?.toString(),
-        })
+          if (onOriginSend) {
+            onOriginSend()
+          }
 
-        try {
-          onTransactionStateChange([
-            getTransactionStateFromReceipt(
-              originUserTxReceipt,
-              effectiveOriginChainId,
-              transactionStates[0]?.label,
-            ),
-          ])
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error calling onTransactionStateChange:",
-            error,
+          // Wait for transaction receipt
+          const receipt = await effectivePublicClient.waitForTransactionReceipt(
+            {
+              hash: txHash,
+            },
           )
-        }
+          logger.console.log("[trails-sdk] receipt", receipt)
+          originUserTxReceipt = receipt
 
-        // Track payment completion for same-chain same-token transaction
-        if (originUserTxReceipt && originUserTxReceipt.status === "success") {
-          trackPaymentCompleted({
+          trackTransactionConfirmed({
+            transactionHash: txHash,
+            chainId: effectiveOriginChainId,
             userAddress: account.address,
-            originTxHash: originUserTxReceipt.transactionHash,
-            originChainId: effectiveOriginChainId, // Same chain
-            mode,
-            fundMethod,
+            blockNumber: Number(receipt.blockNumber),
             originTokenAddress,
             depositTokenAmountUsd: depositAmountUsd?.toString(),
-            destinationTokenAmountUsd: depositAmountUsd?.toString(), // same as deposit amount
-          })
-        } else if (originUserTxReceipt) {
-          trackPaymentError({
-            error: "Transaction failed",
-            userAddress: account.address,
-            mode,
-            fundMethod,
-            originTokenAddress,
           })
+
+          // Remove persistent toast and show success
+          const chainInfo = getChainInfo(effectiveOriginChainId)
+          updatePersistentToast(
+            "Transfer Confirmed",
+            `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
+            "info",
+          )
+
+          try {
+            onTransactionStateChange([
+              getTransactionStateFromReceipt(
+                originUserTxReceipt,
+                effectiveOriginChainId,
+                transactionStates[0]?.label,
+              ),
+            ])
+          } catch (error) {
+            logger.console.error(
+              "[trails-sdk] Error calling onTransactionStateChange:",
+              error,
+            )
+          }
+
+          // Track payment completion for same-chain same-token transaction
+          if (originUserTxReceipt && originUserTxReceipt.status === "success") {
+            trackPaymentCompleted({
+              userAddress: account.address,
+              originTxHash: originUserTxReceipt.transactionHash,
+              originChainId: effectiveOriginChainId, // Same chain
+              mode,
+              fundMethod,
+              originTokenAddress,
+              depositTokenAmountUsd: depositAmountUsd?.toString(),
+              destinationTokenAmountUsd: depositAmountUsd?.toString(), // same as deposit amount
+            })
+
+            // Call onCheckoutComplete callback if provided
+            if (checkoutOnHandlers?.triggerCheckoutComplete) {
+              checkoutOnHandlers.triggerCheckoutComplete()
+            }
+          } else if (originUserTxReceipt) {
+            trackPaymentError({
+              error: "Transaction failed",
+              userAddress: account.address,
+              mode,
+              fundMethod,
+              originTokenAddress,
+            })
+
+            // Call onCheckoutError callback if provided
+            if (checkoutOnHandlers?.triggerCheckoutError) {
+              checkoutOnHandlers.triggerCheckoutError("Transaction failed")
+            }
+          }
         }
-      }
 
-      return {
-        originUserTxReceipt,
-        originMetaTxnReceipt,
-        destinationMetaTxnReceipt,
-        totalCompletionSeconds: 0,
+        return {
+          originUserTxReceipt,
+          originMetaTxnReceipt,
+          destinationMetaTxnReceipt,
+          totalCompletionSeconds: 0,
+        }
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error
+            ? error.message
+            : "Unknown error occurred during transaction"
+        logger.console.error(
+          "[trails-sdk] Error in sendHandlerForSameChainSameToken:",
+          error,
+        )
+
+        // Track payment error
+        trackPaymentError({
+          error: errorMessage,
+          userAddress: account.address,
+          mode,
+          fundMethod,
+          originTokenAddress,
+        })
+
+        // Call onCheckoutError callback if provided
+        if (checkoutOnHandlers?.triggerCheckoutError) {
+          checkoutOnHandlers.triggerCheckoutError(errorMessage)
+        }
+
+        // Re-throw the error so caller can handle if needed
+        throw error
       }
     },
   }
@@ -2390,7 +2681,6 @@ async function _sendHandlerForSameChainDifferentToken({
       onOriginSend,
     }: {
       onOriginSend?: () => void
-      feeTokenAddress?: string | null
     }): Promise<SendReturn> => {
       const { hasEnoughBalance, balanceError } = await checkAccountBalance({
         account,
@@ -2502,6 +2792,10 @@ async function attemptGaslessDeposit({
   walletClient,
   chain,
   account,
+  trailsClient,
+  originRelayer,
+  feeOptions,
+  selectedFeeToken,
 }: {
   paymasterUrl?: string
   depositTokenAddress: string
@@ -2511,46 +2805,75 @@ async function attemptGaslessDeposit({
   walletClient: WalletClient
   chain: Chain
   account: Account
+  trailsClient: TrailsAPIClient
   originRelayer: Relayer.Standard.Rpc.RpcRelayer
   feeOptions: any
-  feeTokenAddress?: string
+  selectedFeeToken?: any
 }): Promise<TransactionReceipt | null> {
   let originUserTxReceipt: TransactionReceipt | null = null
   const originChainId = chain.id
-  logger.console.log("[trails-sdk] originChainId", originChainId)
+
+  logger.console.log(
+    "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] attemptGaslessDeposit called with:",
+    {
+      originChainId,
+      depositTokenAddress,
+      depositTokenAmount,
+      depositRecipient,
+      hasFeeOptions: !!feeOptions,
+      feeOptionsLength: feeOptions?.feeOptions?.length,
+      selectedFeeToken,
+      hasSelectedFeeToken: !!selectedFeeToken,
+      paymasterUrl,
+    },
+  )
 
   const publicClient = createPublicClient({
     chain,
     transport: http(),
   })
 
-  const intentEntrypoint = intentEntrypoints[chain.id]
-  logger.console.log("[trails-sdk] intentEntrypoint", intentEntrypoint)
+  const intentEntrypoint = intentEntrypoints[chain.id]
+  logger.console.log("[trails-sdk] [GASLESS-FLOW] Intent entrypoint check:", {
+    chainId: chain.id,
+    chainName: chain.name,
+    intentEntrypoint,
+    hasIntentEntrypoint: !!intentEntrypoint,
+    availableChains: Object.keys(intentEntrypoints).map(Number),
+  })
+
+  // If intent entrypoint is not available, fall back to old flow
+  if (!intentEntrypoint) {
+    logger.console.warn(
+      `[trails-sdk] ⚠️ No intent entrypoint configured for chain ${chain.id} (${chain.name}). ` +
+        `Gasless deposits with fee options are only supported on chains: ${Object.keys(intentEntrypoints).join(", ")}. ` +
+        `Falling back to old flow (permit2/paymaster).`,
+    )
+
+    let calls: Array<{
+      to: string
+      data: string
+      value: string
+    }> = []
 
-  let calls: Array<{
-    to: string
-    data: string
-    value: string
-  }> = []
+    if (paymasterUrl) {
+      logger.console.log(
+        "[trails-sdk] [GASLESS-FLOW] doing gasless with paymaster",
+      )
 
-  if (paymasterUrl) {
-    logger.console.log("[trails-sdk] doing gasless with paymaster")
-    const delegatorSmartAccount = await getDelegatorSmartAccount({
-      publicClient,
-    })
+      // Switch to correct chain before requesting signatures
+      logger.console.log(
+        "[trails-sdk] [GASLESS-FLOW] Switching chain for paymaster flow",
+      )
+      await attemptSwitchChain({
+        walletClient,
+        desiredChainId: originChainId,
+      })
 
-    if (intentEntrypoint) {
-      calls = await getDepositToIntentCalls({
+      const delegatorSmartAccount = await getDelegatorSmartAccount({
         publicClient,
-        walletClient,
-        account,
-        intentEntrypoint,
-        depositTokenAddress: depositTokenAddress as `0x${string}`,
-        depositTokenAmount: BigInt(depositTokenAmount),
-        depositRecipient: depositRecipient as `0x${string}`,
-        chain,
       })
-    } else {
+
       calls = await getPaymasterGaslessTransaction({
         walletClient,
         chain,
@@ -2559,65 +2882,54 @@ async function attemptGaslessDeposit({
         recipient: depositRecipient as `0x${string}`,
         delegatorSmartAccount,
       })
-    }
-
-    logger.console.log("[trails-sdk] calls", calls)
-
-    const txHash = await sendPaymasterGaslessTransaction({
-      walletClient,
-      publicClient,
-      chain,
-      paymasterUrl,
-      delegatorSmartAccount,
-      calls,
-    })
 
-    if (onOriginSend) {
-      onOriginSend()
-    }
+      logger.console.log("[trails-sdk] calls", calls)
 
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash: txHash as `0x${string}`,
-    })
-    logger.console.log("[trails-sdk] receipt", receipt)
-    originUserTxReceipt = receipt
-  } else {
-    logger.console.log("[trails-sdk] doing gasless with sequence wallet")
-    const delegatorPrivateKey = generatePrivateKey()
-    const delegatorAccount = privateKeyToAccount(delegatorPrivateKey)
-    const delegatorClient = createWalletClient({
-      account: delegatorAccount,
-      chain,
-      transport: http(),
-    })
+      const txHash = await sendPaymasterGaslessTransaction({
+        walletClient,
+        publicClient,
+        chain,
+        paymasterUrl,
+        delegatorSmartAccount,
+        calls,
+      })
 
-    logger.console.log("[trails-sdk] attempting to switch chain")
-    await attemptSwitchChain({
-      walletClient,
-      desiredChainId: originChainId,
-    })
+      if (onOriginSend) {
+        onOriginSend()
+      }
 
-    logger.console.log("[trails-sdk] creating sequence wallet")
-    const sequenceWalletAddress = await simpleCreateSequenceWallet(
-      delegatorAccount as any,
-    )
-    logger.console.log(
-      "[trails-sdk] sequenceWalletAddress",
-      sequenceWalletAddress,
-    )
+      const receipt = await publicClient.waitForTransactionReceipt({
+        hash: txHash as `0x${string}`,
+      })
+      logger.console.log("[trails-sdk] receipt", receipt)
+      return receipt
+    } else {
+      logger.console.log(
+        "[trails-sdk] [GASLESS-FLOW] doing gasless with sequence wallet",
+      )
+      const delegatorPrivateKey = generatePrivateKey()
+      const delegatorAccount = privateKeyToAccount(delegatorPrivateKey)
+      const delegatorClient = createWalletClient({
+        account: delegatorAccount,
+        chain,
+        transport: http(),
+      })
 
-    if (intentEntrypoint) {
-      calls = await getDepositToIntentCalls({
-        publicClient,
+      logger.console.log("[trails-sdk] attempting to switch chain")
+      await attemptSwitchChain({
         walletClient,
-        account,
-        intentEntrypoint,
-        depositTokenAddress: depositTokenAddress as `0x${string}`,
-        depositTokenAmount: BigInt(depositTokenAmount),
-        depositRecipient: depositRecipient as `0x${string}`,
-        chain,
+        desiredChainId: originChainId,
       })
-    } else {
+
+      logger.console.log("[trails-sdk] creating sequence wallet")
+      const sequenceWalletAddress = await simpleCreateSequenceWallet(
+        delegatorAccount as any,
+      )
+      logger.console.log(
+        "[trails-sdk] sequenceWalletAddress",
+        sequenceWalletAddress,
+      )
+
       const { signature, deadline } = await getPermitSignature({
         publicClient,
         walletClient,
@@ -2637,44 +2949,299 @@ async function attemptGaslessDeposit({
         depositRecipient as `0x${string}`,
         depositTokenAddress as `0x${string}`,
       )
+
+      logger.console.log("[trails-sdk] calls", calls)
+
+      const sequenceTxHash = await sequenceSendTransaction(
+        sequenceWalletAddress,
+        delegatorClient,
+        publicClient,
+        calls,
+        chain,
+      )
+      logger.console.log("[trails-sdk] sequenceTxHash", sequenceTxHash)
+      if (onOriginSend) {
+        onOriginSend()
+      }
+
+      const receipt = await publicClient.waitForTransactionReceipt({
+        hash: sequenceTxHash as `0x${string}`,
+      })
+      logger.console.log("[trails-sdk] receipt", receipt)
+      return receipt
+    }
+  }
+
+  // NEW FLOW: Use Intent Entrypoint API with permit2 support
+  logger.console.log(
+    "[trails-sdk] Using Intent Entrypoint API flow with permit2 support for gasless deposit",
+  )
+
+  // Switch to correct chain before requesting signatures
+  logger.console.log(
+    "[trails-sdk] [GASLESS-FLOW] Switching to chain before permit/intent signatures",
+    { originChainId },
+  )
+  await attemptSwitchChain({
+    walletClient,
+    desiredChainId: originChainId,
+  })
+
+  try {
+    const deadline = Math.floor(Date.now() / 1000) + 3600 // 1 hour from now
+    const hasFeeOptions = Boolean(
+      feeOptions && feeOptions.feeOptions?.length > 0,
+    )
+
+    // 1. Check if we need approval - check if we have enough allowance for this transaction (deposit + fee)
+    let requiredAmount = BigInt(depositTokenAmount)
+
+    // Match selectedFeeToken by tokenAddress to get the latest fee amount from feeOptions
+    let selectedFeeOption = null
+    if (selectedFeeToken && hasFeeOptions) {
+      // Find matching fee option by tokenAddress to get latest amount
+      selectedFeeOption = feeOptions.feeOptions.find(
+        (opt: any) =>
+          opt.tokenAddress?.toLowerCase() ===
+          selectedFeeToken.tokenAddress?.toLowerCase(),
+      )
+      logger.console.log(
+        "[trails-sdk] Matched selectedFeeToken to latest fee option:",
+        {
+          selectedFeeToken,
+          matchedOption: selectedFeeOption,
+        },
+      )
+    }
+
+    // Fallback to first fee option if no match or no selectedFeeToken
+    if (!selectedFeeOption && hasFeeOptions) {
+      selectedFeeOption = feeOptions.feeOptions[0]
+      logger.console.log(
+        "[trails-sdk] Using first fee option as fallback:",
+        selectedFeeOption,
+      )
+    }
+
+    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(),
+      })
+    }
+
+    const needsApproval = await getNeedsIntentEntrypointApproval({
+      client: publicClient,
+      token: depositTokenAddress as `0x${string}`,
+      account: account.address,
+      entrypoint: intentEntrypoint as `0x${string}`,
+      amount: requiredAmount, // Check if we have enough allowance for this specific transaction
+    })
+
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] Checking permit requirements",
+      {
+        userAddress: account.address,
+        tokenAddress: depositTokenAddress,
+        depositAmount: depositTokenAmount,
+        requiredAmount: requiredAmount.toString(),
+        intentAddress: depositRecipient,
+        chainID: originChainId,
+        deadline,
+        needsApproval,
+      },
+    )
+
+    // 2. Get permit signature if approval needed
+    let permitSignature: string | undefined
+    let permitDeadline: number | undefined
+
+    if (needsApproval) {
+      logger.console.log(
+        "[trails-sdk] Getting permit signature for infinite approval",
+      )
+
+      // Use infinite approval (maxUint256) so user doesn't need to approve again
+      const permitAmount = maxUint256
+      logger.console.log(
+        "[trails-sdk] Using infinite approval for gasless deposits",
+        {
+          depositAmount: depositTokenAmount,
+          permitAmount: permitAmount.toString(),
+        },
+      )
+
+      const permitSig = await getPermitSignature({
+        publicClient,
+        walletClient,
+        signer: account.address,
+        spender: intentEntrypoint as `0x${string}`,
+        tokenAddress: depositTokenAddress as `0x${string}`,
+        amount: permitAmount, // Infinite approval
+        chain,
+        deadline: BigInt(deadline),
+      })
+      permitSignature = permitSig.signature
+      permitDeadline = Number(permitSig.deadline)
+      logger.console.log(
+        "[trails-sdk] Permit signature obtained for infinite approval",
+      )
     }
 
-    logger.console.log("[trails-sdk] calls", calls)
-
-    // const feeOptions = await getFeeOptions(
-    //   originRelayer,
-    //   sequenceWalletAddress,
-    //   originChainId,
-    //   calls.map((call) => ({
-    //     to: call.to,
-    //     value: BigInt(call.value),
-    //     data: call.data,
-    //     gasLimit: BigInt(0),
-    //     delegateCall: false,
-    //     onlyFallback: false,
-    //     behaviorOnError: "revert",
-    //   })) as Payload.Call[],
-    // )
-
-    // logger.console.log("[trails-sdk] feeOptions", feeOptions)
-
-    const sequenceTxHash = await sequenceSendTransaction(
-      sequenceWalletAddress,
-      delegatorClient,
+    // 3. Get current nonce for the user
+    logger.console.log("[trails-sdk] Getting user nonce")
+    const nonce = await getUserNonce({
       publicClient,
-      calls,
-      chain,
+      userAddress: account.address,
+      intentEntrypoint: intentEntrypoint as `0x${string}`,
+    })
+    logger.console.log("[trails-sdk] User nonce:", nonce.toString())
+
+    // 4. Get intent signature
+    logger.console.log("[trails-sdk] Requesting intent signature via EIP-712")
+    // Get fee collector address from fee options response, or use selected fee option's collector
+    const feeCollectorAddress = (selectedFeeOption?.feeCollector ||
+      feeOptions?.feeCollector) as `0x${string}` | undefined
+
+    // Validate that we have a valid fee collector address
+    if (!feeCollectorAddress || feeCollectorAddress === zeroAddress) {
+      throw new Error(
+        "[trails-sdk] Fee collector address not provided by API. Cannot proceed with gasless deposit. " +
+          "Please ensure the API is returning feeCollector in the fee options response.",
+      )
+    }
+
+    logger.console.log(
+      "[trails-sdk] Using fee collector address:",
+      feeCollectorAddress,
+    )
+
+    const { signature: intentSignature } = await signIntent({
+      client: walletClient,
+      intentParams: {
+        user: account.address,
+        token: depositTokenAddress as `0x${string}`,
+        amount: BigInt(depositTokenAmount),
+        intentAddress: depositRecipient as `0x${string}`,
+        deadline: BigInt(deadline),
+        chainId: originChainId,
+        contractAddress: intentEntrypoint as `0x${string}`,
+        nonce,
+        feeAmount: BigInt(selectedFeeOption?.amount || "0"),
+        feeCollector: feeCollectorAddress,
+      },
+    })
+    logger.console.log("[trails-sdk] Intent signature received")
+
+    // 5. Call the deposit endpoint with permit support and optional fee
+    logger.console.log(
+      "[trails-sdk] Calling getIntentEntrypointDeposit with permit enabled",
+      { usePermit: needsApproval, hasFee: !!feeOptions },
+    )
+
+    // selectedFeeOption was already determined at the start of the try block
+
+    logger.console.log(
+      "[trails-sdk] Calling getIntentEntrypointDeposit with params:",
+      {
+        userAddress: account.address,
+        tokenAddress: depositTokenAddress,
+        amount: depositTokenAmount,
+        intentAddress: depositRecipient,
+        chainID: originChainId,
+        deadline,
+        usePermit: needsApproval,
+        hasPermitSignature: !!permitSignature,
+        feeAmount: selectedFeeOption?.amount,
+        feeTokenSymbol: selectedFeeOption?.tokenSymbol,
+        selectedFeeToken,
+        usingSelectedFeeToken: !!selectedFeeToken,
+      },
+    )
+
+    const depositDataResponse = await trailsClient.getIntentEntrypointDeposit({
+      params: {
+        userAddress: account.address,
+        tokenAddress: depositTokenAddress,
+        amount: depositTokenAmount,
+        intentAddress: depositRecipient,
+        chainID: originChainId,
+        deadline,
+        intentSignature,
+        usePermit: needsApproval, // Use permit if approval needed
+        permitAmount: needsApproval ? maxUint256.toString() : undefined, // Pass infinite approval amount
+        permitSignature,
+        permitDeadline,
+        feeAmount: selectedFeeOption?.amount || undefined,
+      },
+    })
+
+    const depositData = depositDataResponse.result
+    logger.console.log("[trails-sdk] Deposit data received:", {
+      depositWalletAddress: depositData.depositWalletAddress,
+      entrypointAddress: depositData.entrypointAddress,
+      metaTxnId: depositData.metaTxn?.id,
+      usedPermit2: needsApproval,
+    })
+
+    // 5. Send meta transaction via relayer
+    logger.console.log("[trails-sdk] Sending meta transaction to relayer")
+    const feeQuoteObj = depositData.feeQuote
+      ? ({
+          _tag: "FeeQuote",
+          _quote: { toJSON: () => depositData.feeQuote },
+        } as any)
+      : undefined
+
+    const opHash = await relayerSendMetaTx(
+      originRelayer,
+      depositData.metaTxn as any,
+      [], // No preconditions for gasless deposit
+      feeQuoteObj,
     )
-    logger.console.log("[trails-sdk] sequenceTxHash", sequenceTxHash)
+    logger.console.log("[trails-sdk] Meta transaction sent, opHash:", opHash)
+
     if (onOriginSend) {
       onOriginSend()
     }
 
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash: sequenceTxHash as `0x${string}`,
-    })
-    logger.console.log("[trails-sdk] receipt", receipt)
-    originUserTxReceipt = receipt
+    // 6. Wait for transaction receipt
+    logger.console.log("[trails-sdk] Waiting for transaction receipt")
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const receipt: any = await getMetaTxStatus(
+        originRelayer,
+        depositData.metaTxn.id,
+        Number(depositData.metaTxn.chainId),
+      )
+      logger.console.log("[trails-sdk] Meta transaction status:", receipt)
+
+      if (receipt?.transactionHash) {
+        const metaTxnReceipt = receipt.data?.receipt
+        if (!metaTxnReceipt) {
+          throw new Error("No meta txn receipt found")
+        }
+
+        // Get the full transaction receipt
+        const txReceipt = await publicClient.getTransactionReceipt({
+          hash: receipt.transactionHash as `0x${string}`,
+        })
+        logger.console.log("[trails-sdk] Transaction receipt:", txReceipt)
+        originUserTxReceipt = txReceipt
+        break
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 1000))
+    }
+  } catch (error) {
+    logger.console.error(
+      "[trails-sdk] Error in Intent Entrypoint gasless deposit with permit2:",
+      error,
+    )
+    throw error
   }
 
   return originUserTxReceipt
@@ -2835,6 +3402,13 @@ export async function attemptNonGaslessUserDeposit({
           : "0x0",
       })
 
+      // Update persistent toast before wallet interaction
+      updatePersistentToast(
+        "Waiting for Confirmation",
+        "Please confirm the transaction in your wallet...",
+        "info",
+      )
+
       // Send the batched call via EIP-7702
       const result = (await walletClient.request({
         method: "wallet_sendCalls",
@@ -2881,6 +3455,14 @@ export async function attemptNonGaslessUserDeposit({
         onOriginSend()
       }
 
+      // Update persistent toast after transaction sent
+      const chainInfo = getChainInfo(originChainId)
+      updatePersistentToast(
+        "Transaction Submitted",
+        `Waiting for confirmation on ${chainInfo?.name || "chain"}...`,
+        "info",
+      )
+
       const receipt = await publicClient.waitForTransactionReceipt({
         hash: txHash as `0x${string}`,
       })
@@ -2912,6 +3494,13 @@ export async function attemptNonGaslessUserDeposit({
         logger.console.log("[trails-sdk] nativeFeeReceipt", feeReceipt)
       }
 
+      // Show persistent toast for checkout flow
+      updatePersistentToast(
+        "Payment Started",
+        "Waiting for wallet confirmation...",
+        "info",
+      )
+
       const txHash = await sendOriginTransaction(
         account,
         walletClient,
@@ -2944,6 +3533,13 @@ export async function attemptNonGaslessUserDeposit({
         hash: txHash,
       })
 
+      const chainInfo = getChainInfo(originChainId)
+      updatePersistentToast(
+        "Transfer Confirmed",
+        `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
+        "info",
+      )
+
       trackTransactionConfirmed({
         transactionHash: txHash,
         chainId: originChainId,
@@ -2989,7 +3585,8 @@ async function attemptUserDepositTx({
   destinationTokenSymbol,
   depositAmountUsd,
   feeOptions,
-  feeTokenAddress,
+  trailsClient,
+  selectedFeeToken,
 }: {
   originTokenAddress: string
   gasless: boolean
@@ -3016,7 +3613,8 @@ async function attemptUserDepositTx({
   destinationTokenSymbol: string
   depositAmountUsd: number
   feeOptions?: any
-  feeTokenAddress?: string | null
+  trailsClient: TrailsAPIClient
+  selectedFeeToken?: any
 }): Promise<TransactionReceipt | null> {
   let originUserTxReceipt: TransactionReceipt | null = null
   const originChainId = chain.id
@@ -3035,11 +3633,36 @@ async function attemptUserDepositTx({
     return null
   }
 
-  const doGasless =
-    getDoGasless(originTokenAddress, gasless, paymasterUrl) ||
-    (feeOptions && feeTokenAddress)
-  logger.console.log("[trails-sdk] doGasless", doGasless, paymasterUrl)
-  if (doGasless) {
+  const doGasless = getDoGasless(
+    originTokenAddress,
+    gasless,
+    feeOptions,
+    selectedFeeToken,
+  )
+  logger.console.log(
+    "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] doGasless check results:",
+    {
+      doGasless,
+      paymasterUrl,
+      hasFeeOptions: !!feeOptions,
+      feeOptionsCount: feeOptions?.feeOptions?.length || 0,
+      selectedFeeToken,
+      selectedFeeTokenSet:
+        selectedFeeToken !== null && selectedFeeToken !== undefined,
+      originTokenAddress,
+      gasless,
+      isNotNative: originTokenAddress !== zeroAddress,
+    },
+  )
+  if (doGasless || paymasterUrl) {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] Entering gasless deposit flow",
+      {
+        doGasless,
+        hasPaymasterUrl: !!paymasterUrl,
+        paymasterUrl,
+      },
+    )
     try {
       originUserTxReceipt = await attemptGaslessDeposit({
         paymasterUrl,
@@ -3050,12 +3673,14 @@ async function attemptUserDepositTx({
         walletClient,
         chain,
         account,
+        trailsClient,
         originRelayer,
-        feeOptions,
-        feeTokenAddress: feeTokenAddress || "",
+        feeOptions: feeOptions,
+        selectedFeeToken: selectedFeeToken,
       })
     } catch (error) {
       logger.console.log("[trails-sdk] gassless attempt failed", error)
+      throw error
     }
   }
 
@@ -3092,11 +3717,108 @@ async function attemptUserDepositTx({
 export function getDoGasless(
   originTokenAddress: string,
   gasless: boolean,
-  paymasterUrl?: string,
+  feeOptions?: any,
+  selectedFeeToken?: any,
 ): boolean {
-  return Boolean(
-    originTokenAddress !== zeroAddress && (gasless || paymasterUrl),
+  const hasFeeOptions = Boolean(feeOptions && feeOptions.feeOptions?.length > 0)
+
+  // Important: The UI passes selectedFeeToken in these states:
+  // - null: User explicitly chose "Pay with native gas"
+  // - {object}: User selected a fee token OR it was auto-selected
+  // - undefined: Should not happen (initial state auto-selects if options exist)
+
+  // If selectedFeeToken is null, user explicitly chose native gas
+  if (selectedFeeToken === null) {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless: User explicitly selected native gas (null)",
+    )
+    return false
+  }
+
+  // If selectedFeeToken is undefined and no fee options, can't do gasless
+  if (!selectedFeeToken && !hasFeeOptions) {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless: No fee token selected and no fee options available",
+    )
+    return false
+  }
+
+  // If selectedFeeToken is undefined but fee options exist, use first ERC20 option
+  let effectiveFeeToken = selectedFeeToken
+  if (!effectiveFeeToken && hasFeeOptions) {
+    const firstFeeOption = feeOptions.feeOptions[0]
+
+    // Check if first option is native gas
+    const isFirstOptionNative =
+      firstFeeOption?.tokenAddress === zeroAddress ||
+      firstFeeOption?.tokenAddress?.toLowerCase() === zeroAddress ||
+      firstFeeOption?.isNative === true
+
+    if (!isFirstOptionNative && firstFeeOption?.tokenAddress) {
+      // First fee option is ERC20, use it
+      effectiveFeeToken = firstFeeOption
+      logger.console.log(
+        "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless: No fee token selected, using first ERC20 fee option",
+        {
+          feeOption: effectiveFeeToken,
+        },
+      )
+    } else {
+      logger.console.log(
+        "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless: First fee option is native gas, skipping gasless",
+      )
+      return false
+    }
+  }
+
+  // Check if the effective fee token is native gas
+  const isNativeGasFee =
+    !effectiveFeeToken ||
+    effectiveFeeToken.tokenAddress === zeroAddress ||
+    effectiveFeeToken.tokenAddress?.toLowerCase() === zeroAddress ||
+    effectiveFeeToken.isNative === true
+
+  // Don't use gasless if origin token is native (sending ETH)
+  if (originTokenAddress === zeroAddress) {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] getDoGasless: Origin token is native, skipping gasless",
+    )
+    return false
+  }
+
+  // Don't use gasless if fee token is native
+  if (isNativeGasFee) {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless: Fee token is native gas, skipping gasless",
+      {
+        effectiveFeeToken,
+      },
+    )
+    return false
+  }
+
+  // Don't use gasless if disabled
+  if (!gasless) {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] getDoGasless: Gasless disabled",
+    )
+    return false
+  }
+
+  // All conditions met, use gasless with ERC20 fee token
+  logger.console.log(
+    "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless decision: Using gasless",
+    {
+      originTokenAddress,
+      gasless,
+      hasFeeOptions,
+      selectedFeeToken,
+      effectiveFeeToken,
+      feeOptionsCount: feeOptions?.feeOptions?.length || 0,
+    },
   )
+
+  return true
 }
 
 function getTransactionStateFromReceipt(
@@ -3270,6 +3992,9 @@ async function checkAccountBalance({
         abi: erc20Abi,
         functionName: "decimals",
       })
+      if (!decimals) {
+        throw new Error("Decimals not found")
+      }
       balanceFormatted = formatUnits(balance, decimals)
       requiredAmountFormatted = formatUnits(requiredAmount, decimals)
     }
@@ -3335,7 +4060,7 @@ function getNeedsLifiNativeFee({
       formatUnits(BigInt(destinationTokenAmount), destinationTokenDecimals),
     )
     const depositAmountFormatted = Number(
-      formatUnits(BigInt(depositAmount), destinationTokenDecimals),
+      formatUnits(BigInt(depositAmount), sourceTokenDecimals),
     )
     logger.console.log("[trails-sdk] destinationAmount", destinationAmount)
     logger.console.log(
@@ -3380,6 +4105,8 @@ export type UseQuoteProps = {
   slippageTolerance?: string | number | null
   onStatusUpdate?: ((transactionStates: TransactionState[]) => void) | null
   quoteProvider?: string | null
+  gasless?: boolean
+  paymasterUrl?: string
 }
 
 export type SwapReturn = {
@@ -3421,6 +4148,8 @@ export type Quote = {
   destinationTokenRate?: string
   fromAmountUsdDisplay?: string
   toAmountUsdDisplay?: string
+  gasCostUsd?: number
+  gasCostUsdDisplay?: string
 }
 
 export type UseQuoteReturn = {
@@ -3444,10 +4173,22 @@ export function useQuote({
   slippageTolerance,
   onStatusUpdate,
   quoteProvider,
-}: Partial<UseQuoteProps> = {}): UseQuoteReturn {
+  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: getSequenceEnv() as RelayerEnv,
+    env: relayerEnv || (getSequenceEnv() as RelayerEnv),
   })
   const indexerGatewayClient = useIndexerGatewayClient()
 
@@ -3471,6 +4212,7 @@ export function useQuote({
       if (
         !walletClient ||
         !apiClient ||
+        !trailsClient ||
         !fromTokenAddress ||
         !toTokenAddress ||
         !swapAmount ||
@@ -3506,19 +4248,27 @@ export function useQuote({
       //   return null
       // }
 
+      // logger.console.log("supportedTokens", supportedTokens)
+
       const originToken = supportedTokens?.find(
         (token) =>
-          token.contractAddress === fromTokenAddress &&
-          token.chainId === fromChainId,
+          token.contractAddress?.toLowerCase() ===
+            fromTokenAddress?.toLowerCase() && token.chainId === fromChainId,
       )
       const destinationToken = supportedTokens?.find(
         (token) =>
-          token.contractAddress === toTokenAddress &&
-          token.chainId === toChainId,
+          token.contractAddress?.toLowerCase() ===
+            toTokenAddress?.toLowerCase() && token.chainId === toChainId,
       )
 
-      const sourceTokenDecimals = originToken?.decimals ?? 18
-      const destinationTokenDecimals = destinationToken?.decimals ?? 18
+      const sourceTokenDecimals = originToken?.decimals
+      if (!sourceTokenDecimals) {
+        throw new Error("Source token decimals not found")
+      }
+      const destinationTokenDecimals = destinationToken?.decimals
+      if (!destinationTokenDecimals) {
+        throw new Error("Destination token decimals not found")
+      }
       const destinationTokenSymbol = destinationToken?.symbol ?? ""
       const originTokenSymbol = originToken?.symbol ?? ""
 
@@ -3537,6 +4287,7 @@ export function useQuote({
         destinationCalldata: toCalldata as string,
         client: walletClient,
         apiClient,
+        trailsClient,
         originRelayer,
         destinationRelayer,
         sourceTokenDecimals,
@@ -3546,6 +4297,8 @@ export function useQuote({
         onTransactionStateChange: onStatusUpdate ?? (() => {}),
         slippageTolerance: slippageTolerance?.toString(),
         quoteProvider: quoteProvider,
+        gasless: gasless ?? false,
+        paymasterUrl: paymasterUrl,
       }
 
       logger.console.log("[trails-sdk] options", options)
@@ -3573,6 +4326,8 @@ export function useQuote({
           prepareSendQuote.originAmountUsdDisplay ?? undefined,
         toAmountUsdDisplay:
           prepareSendQuote.destinationAmountUsdDisplay ?? undefined,
+        gasCostUsd: prepareSendQuote.gasCostUsd ?? undefined,
+        gasCostUsdDisplay: prepareSendQuote.gasCostUsdDisplay ?? undefined,
       }
 
       const swap = async (): Promise<SwapReturn> => {
@@ -3645,7 +4400,7 @@ export function getFeesFromIntent(
     toAmountUsd,
   }: { tradeType: TradeType; fromAmountUsd: number; toAmountUsd: number },
 ): PrepareSendFees {
-  const totalFeeAmountUsd = intent?.trailsFee?.totalFeeUSD ?? 0
+  const totalFeeAmountUsd = intent.payloads?.trailsFee?.totalFeeUSD ?? 0
   const totalFeeAmountUsdDisplay = formatUsdAmountDisplay(totalFeeAmountUsd)
 
   logger.console.log("[trails-sdk] getFeesFromIntent", {
@@ -3657,8 +4412,8 @@ export function getFeesFromIntent(
   })
 
   return {
-    feeTokenAddress: intent.trailsFee?.feeToken ?? zeroAddress,
-    totalFeeAmount: intent.trailsFee?.totalFeeAmount ?? "0",
+    feeTokenAddress: intent.payloads.trailsFee?.feeToken ?? zeroAddress,
+    totalFeeAmount: intent.payloads.trailsFee?.totalFeeAmount ?? "0",
     totalFeeAmountUsd: totalFeeAmountUsd.toString(),
     totalFeeAmountUsdDisplay,
   }
@@ -3667,20 +4422,20 @@ export function getFeesFromIntent(
 export function getSlippageToleranceFromIntent(
   intent: GetIntentCallsPayloadsReturn,
 ): string {
-  return intent.quote?.maxSlippage?.toString() ?? "0"
+  return intent.payloads.quote?.maxSlippage?.toString() ?? "0"
 }
 
 export function getPriceImpactFromIntent(
   intent: GetIntentCallsPayloadsReturn,
 ): string {
-  return intent?.quote?.priceImpact?.toString() ?? "0"
+  return intent.payloads?.quote?.priceImpact?.toString() ?? "0"
 }
 
 export function getPriceImpactUsdFromIntent(
   intent: GetIntentCallsPayloadsReturn,
 ): string {
   // Temporary type assertion until API types are regenerated
-  return (intent?.quote as any)?.priceImpactUsd?.toString() ?? "0"
+  return (intent.payloads?.quote as any)?.priceImpactUsd?.toString() ?? "0"
 }
 
 export function getFeesFromRelaySdkQuote(quote: RelayQuote): PrepareSendFees {
@@ -3761,7 +4516,6 @@ export async function getNormalizedQuoteObject({
   originNativeTokenPriceUsd,
   quoteProvider,
   noSufficientBalance,
-  minimumNotMet,
 }: {
   originDepositAddress?: string
   destinationDepositAddress?: string
@@ -3785,7 +4539,6 @@ export async function getNormalizedQuoteObject({
   originNativeTokenPriceUsd?: number | null
   quoteProvider?: string
   noSufficientBalance?: boolean
-  minimumNotMet?: boolean
 }): Promise<PrepareSendQuote> {
   if (!destinationChainId) {
     throw new Error("Destination chain id is required")
@@ -3983,7 +4736,6 @@ export async function getNormalizedQuoteObject({
     ),
     quoteProvider: quoteProviderInfo,
     noSufficientBalance: noSufficientBalance || false,
-    minimumNotMet: minimumNotMet || false,
   }
 }