0xtrails 0.2.0 → 0.2.2

package/src/prepareSend.ts

@@ -51,8 +51,12 @@ import {
 import { queueCCTPTransfer } from "./cctpqueue.js"
 import { getChainInfo, getTestnetChainInfo } from "./chains.js"
 import { attemptSwitchChain } from "./chainSwitch.js"
-import { getSequenceEnv, getSlippageTolerance } from "./config.js"
-import { intentEntrypoints, MINIMUM_USD_AMOUNT_FOR_SWAP } from "./constants.js"
+import {
+  getSequenceEnv,
+  getSlippageTolerance,
+  type SequenceEnv,
+} from "./config.js"
+import { intentEntrypoints } from "./constants.js"
 import {
   decodeGuestModuleEvents,
   decodeTrailsTokenSweeperEvents,
@@ -65,8 +69,13 @@ import {
   getNeedsIntentEntrypointApproval,
   getPermitCalls,
   getPermitSignature,
+  getUserNonce,
   signIntent,
 } from "./gasless.js"
+import {
+  getIntentEntrypointFeeOptions,
+  isIntentEntrypointSupported,
+} from "./intentEntrypoint.js"
 import { useIndexerGatewayClient } from "./indexerClient.js"
 import {
   commitIntentConfig,
@@ -84,10 +93,6 @@ import {
 } from "./paymasterSend.js"
 import { findFirstPreconditionForChainId } from "./preconditions.js"
 import { calcAmountUsdPrice, getTokenPrice } from "./prices.js"
-import {
-  TRAILS_CONTRACT_PLACEHOLDER_AMOUNT,
-  wrapCalldataWithBalanceInjectorIfNeeded,
-} from "./balanceInjector.js"
 import { getQueryParam } from "./queryParams.js"
 import type { MetaTxnReceipt, RelayerEnv } from "./relayer.js"
 import { useRelayers } from "./relayer.js"
@@ -115,6 +120,10 @@ import {
   useSupportedTokens,
   type SupportedToken,
 } from "./tokens.js"
+import {
+  TRAILS_ROUTER_PLACEHOLDER_AMOUNT,
+  wrapCalldataWithTrailsRouterIfNeeded,
+} from "./trailsRouter.js"
 import type {
   TransactionState,
   TransactionStateStatus,
@@ -168,6 +177,7 @@ export type PrepareSendOptions = {
   mode?: "pay" | "fund" | "earn" | "swap" | "receive"
   checkoutOnHandlers?: CheckoutOnHandlers
   refundAddress?: string
+  selectedFeeToken?: any
 }
 
 export type PrepareSendFees = {
@@ -216,7 +226,6 @@ export type PrepareSendQuote = {
   destinationTokenRate: string
   quoteProvider: QuoteProviderInfo | null
   noSufficientBalance: boolean
-  minimumNotMet: boolean
 }
 
 export type PrepareSendReturn = {
@@ -224,10 +233,10 @@ export type PrepareSendReturn = {
   feeOptions?: any
   send: ({
     onOriginSend,
-    feeTokenAddress,
+    selectedFeeToken,
   }: {
     onOriginSend?: () => void
-    feeTokenAddress?: string | null
+    selectedFeeToken?: any
   }) => Promise<SendReturn>
 }
 
@@ -379,6 +388,7 @@ export async function prepareSend(
     fundMethod,
     mode,
     checkoutOnHandlers,
+    selectedFeeToken,
   } = options
   let { sourceTokenPriceUsd, destinationTokenPriceUsd } = options
 
@@ -416,14 +426,14 @@ export async function prepareSend(
     // 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 && tradeType === TradeType.EXACT_INPUT) {
-    const wrapResult = wrapCalldataWithBalanceInjectorIfNeeded({
+    const wrapResult = wrapCalldataWithTrailsRouterIfNeeded({
       token: destinationTokenAddress,
       target: effectiveDestinationAddress,
       calldata: effectiveDestinationCalldata as `0x${string}`,
@@ -435,7 +445,7 @@ export async function prepareSend(
     })
 
     if (wrapResult) {
-      effectiveDestinationAddress = wrapResult.balanceInjectorAddress
+      effectiveDestinationAddress = wrapResult.trailsRouterAddress
       effectiveDestinationCalldata = wrapResult.encodedCalldata
     }
   }
@@ -686,6 +696,7 @@ export async function prepareSend(
     fundMethod,
     mode,
     checkoutOnHandlers,
+    selectedFeeToken,
   })
 }
 
@@ -725,6 +736,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   fundMethod,
   mode,
   checkoutOnHandlers,
+  selectedFeeToken,
 }: {
   mainSignerAddress: string
   originChainId: number
@@ -762,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(
@@ -809,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)!
@@ -1085,7 +1110,6 @@ async function sendHandlerForDifferentChainDifferentToken({
   )
 
   let noSufficientBalance = false
-  let minimumNotMet = false
 
   if (!(fundMethod === "qr-code" || fundMethod === "exchange")) {
     const { hasEnoughBalance } = await checkAccountBalance({
@@ -1100,10 +1124,6 @@ async function sendHandlerForDifferentChainDifferentToken({
     }
   }
 
-  if (Number(depositAmountUsd) < Number(MINIMUM_USD_AMOUNT_FOR_SWAP)) {
-    minimumNotMet = true
-  }
-
   const quote = await getNormalizedQuoteObject({
     originDepositAddress: originIntentAddress,
     destinationDepositAddress: intent.payloads.destinationIntentAddress,
@@ -1131,7 +1151,6 @@ async function sendHandlerForDifferentChainDifferentToken({
     originNativeTokenPriceUsd,
     quoteProvider: intent.payloads?.quote?.quoteProvider,
     noSufficientBalance,
-    minimumNotMet,
   })
 
   // Call onCheckoutQuote callback if provided
@@ -1139,255 +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(
-        trailsClient,
-        mainSignerAddress,
-        intent.payloads.calls,
-        intent.payloads.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,
-          trailsClient,
-        })
-
-        if (!originUserTxReceipt) {
-          throw new Error("Failed to send origin transaction")
-        }
+            sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
+            destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
+            swapAmount,
+            onTransactionStateChange,
+            transactionStates,
+            fundMethod,
+            originTokenSymbol,
+            destinationTokenSymbol,
+            depositAmountUsd,
+            feeOptions: intentEntrypointFeeOptions,
+            trailsClient,
+            selectedFeeToken: effectiveSelectedFeeToken,
+          })
 
-        transactionStates[0] = getTransactionStateFromReceipt(
-          originUserTxReceipt,
-          originChainId,
-          transactionStates[0]?.label,
-        )
-        onTransactionStateChange(transactionStates)
+          if (!originUserTxReceipt) {
+            throw new Error("Failed to send origin transaction")
+          }
 
-        setTimeout(() => {
-          const destinationChain = getChainInfo(destinationChainId)
-          updatePersistentToast(
-            "In Progress",
-            `Your transaction to ${destinationChain?.name || "chain"} is in progress`,
-            "info",
+          transactionStates[0] = getTransactionStateFromReceipt(
+            originUserTxReceipt,
+            originChainId,
+            transactionStates[0]?.label,
           )
-        }, 1000)
-      }
 
-      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.payloads
-                  .destinationIntentAddress as `0x${string}`,
+                chainId: originChainId,
+                accountAddress: originIntentAddress,
               })
               logger.console.log(
                 "[trails-sdk] getAccountTransactionHistory response",
@@ -1406,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)
@@ -1427,206 +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.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.payloads.metaTxns[0].id
-          const feeQuote = intent.payloads.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.payloads.metaTxns[0].chainId,
-              walletAddress: intent.payloads.metaTxns[0].walletAddress,
-              contract: intent.payloads.metaTxns[0].contract,
-            },
-          )
-
-          const { waitForReceipt } = await sendMetaTxAndWaitForReceipt({
-            metaTx: intent.payloads.metaTxns[0] as MetaTxn,
-            relayer: originRelayer,
-            precondition: intent.payloads
-              .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.payloads.metaTxns[0],
-              hasPrecondition: !!intent.payloads.preconditions[0],
-            },
-          )
-        }
-      }
-
-      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],
-          },
-        )
-
-        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
-              }
-
-              const txHash = await waitForRelayDestinationTx(
-                intent.payloads.quote.quoteProviderRequestId,
-              )
-              logger.console.log(
-                "[trails-sdk] waitForRelayDestinationTx completed",
-                {
-                  txHash,
-                  quoteProviderRequestId:
-                    intent.payloads.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.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)
+              } 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.payloads.quote.quoteProvider,
-              hasMetaTxn1: !!intent.payloads.metaTxns[1],
-              hasPrecondition1: !!intent.payloads.preconditions[1],
-            },
-          )
 
-          if (intent.payloads.metaTxns[1] && intent.payloads.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.payloads.metaTxns[1].id
+            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,
@@ -1635,324 +1569,597 @@ async function sendHandlerForDifferentChainDifferentToken({
             )
 
             logger.console.log(
-              "[trails-sdk] Calling sendMetaTxAndWaitForReceipt for destination",
+              "[trails-sdk] Calling sendMetaTxAndWaitForReceipt for origin",
               {
                 metaTxnId,
-                chainId: intent.payloads.metaTxns[1].chainId,
-                walletAddress: intent.payloads.metaTxns[1].walletAddress,
-                contract: intent.payloads.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.payloads.metaTxns[1] as MetaTxn,
-              relayer: destinationRelayer,
+              metaTx: intent.payloads.metaTxns[0] as MetaTxn,
+              relayer: originRelayer,
               precondition: intent.payloads
-                .preconditions[1] as IntentPrecondition,
+                .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.payloads.metaTxns[1],
-                hasPrecondition: !!intent.payloads.preconditions[1],
+                hasMetaTxn: !!intent.payloads.metaTxns[0],
+                hasPrecondition: !!intent.payloads.preconditions[0],
               },
             )
           }
-          // } else if (intent.payloads.destinationIntentAddress) {
-          //   destinationMetaTxnReceiptPromise = checkForDestinationDepositTx
-          // }
         }
-      }
-
-      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,
-              })
-              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,
+                    },
+                  )
 
-      await Promise.all([
-        originSendMetaTxnPromise(),
-        destinationSendMetaTxnPromise(),
-      ])
+                  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],
+              },
+            )
 
-      logger.console.log("[trails-sdk] Phase 1 completed successfully")
+            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,
+                },
+              )
 
-      // Phase 2: Wait for receipts and execute deposit
-      logger.console.log(
-        "[trails-sdk] Starting Phase 2: Waiting for receipts and executing deposit",
-      )
+              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,
+                },
+              )
 
-      const waitForOriginMetaTxnReceiptPromise = async () => {
-        logger.console.log(
-          "[trails-sdk] Waiting for origin meta transaction receipt",
-        )
-        if (originMetaTxnReceiptPromise) {
-          try {
-            originMetaTxnReceipt = await originMetaTxnReceiptPromise()
+              const { waitForReceipt } = await sendMetaTxAndWaitForReceipt({
+                metaTx: intent.payloads.metaTxns[1] as MetaTxn,
+                relayer: destinationRelayer,
+                precondition: intent.payloads
+                  .preconditions[1] as IntentPrecondition,
+                feeQuote: feeQuote,
+              })
 
-            if (originMetaTxnReceipt && transactionStates[1]) {
-              transactionStates[1] = getTransactionStateFromReceipt(
-                originMetaTxnReceipt,
-                originChainId,
-                transactionStates[1]?.label,
+              logger.console.log(
+                "[trails-sdk] Destination meta transaction sent successfully",
+                {
+                  metaTxnId,
+                },
               )
-              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,
+              // 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],
+                },
+              )
+            }
+            // } else if (intent.payloads.destinationIntentAddress) {
+            //   destinationMetaTxnReceiptPromise = checkForDestinationDepositTx
+            // }
+          }
+        }
+
+        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,
                 })
-                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(),
+        ])
+
+        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()
 
-            destinationMetaTxnReceipt = (await Promise.race([
-              destinationReceiptPromise,
-              failurePollingPromise,
-            ])) as MetaTxnReceipt
+              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",
             )
+          }
+        }
 
-            if (destinationMetaTxnReceipt && transactionStates[2]) {
-              transactionStates[2] = getTransactionStateFromReceipt(
+        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
+
+              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",
-                  ) !== -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,
-                })
+              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.payloads.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 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(),
-        })
+        // 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,
@@ -1967,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
       }
     },
   }
@@ -2040,7 +2238,6 @@ async function sendHandlerForSameChainSameToken({
   })
 
   let noSufficientBalance = false
-  const minimumNotMet = false
 
   const { hasEnoughBalance } = await checkAccountBalance({
     account,
@@ -2071,7 +2268,6 @@ async function sendHandlerForSameChainSameToken({
     slippageTolerance,
     quoteProvider: "",
     noSufficientBalance,
-    minimumNotMet,
   })
 
   // Call onCheckoutQuote callback if provided
@@ -2085,198 +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 hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
+        const originCallParams = {
+          to: hasCustomCalldata
+            ? recipient
+            : effectiveOriginTokenAddress === zeroAddress
+              ? recipient
+              : effectiveOriginTokenAddress,
+          data: hasCustomCalldata
+            ? destinationCalldata
+            : effectiveOriginTokenAddress === zeroAddress
+              ? "0x"
+              : getERC20TransferData({
+                  recipient,
+                  amount: BigInt(swapAmount),
+                }),
+          value:
+            effectiveOriginTokenAddress === zeroAddress
+              ? BigInt(swapAmount)
+              : "0",
+          chainId: effectiveOriginChainId,
+          chain: effectiveOriginChain,
+        }
+
+        logger.console.log("[trails-sdk] origin call params", originCallParams)
+
+        let originUserTxReceipt: TransactionReceipt | null = null
+        const originMetaTxnReceipt: MetaTxnReceipt | null = null
+        const destinationMetaTxnReceipt: MetaTxnReceipt | null = null
+
+        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,
+            )
+          }
+
+          if (hasCustomCalldata) {
+            try {
+              const needsApproval = await getNeedsApproval({
+                publicClient: effectivePublicClient,
+                token: effectiveOriginTokenAddress,
+                account: account.address,
+                spender: recipient,
+                amount: maxUint256,
+              })
+
+              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)
+            }
+          }
 
-      const depositAmountFormatted = Number(
-        formatUnits(BigInt(swapAmount), originTokenDecimals),
-      )
-      const depositAmountUsd = calcAmountUsdPrice({
-        amount: depositAmountFormatted,
-        usdPrice: sourceTokenPriceUsd,
-      })
+          // Show persistent toast for checkout flow
+          updatePersistentToast(
+            "Payment Started",
+            "Waiting for wallet confirmation...",
+            "info",
+          )
 
-      const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-      const originCallParams = {
-        to: hasCustomCalldata
-          ? recipient
-          : effectiveOriginTokenAddress === zeroAddress
-            ? recipient
-            : effectiveOriginTokenAddress,
-        data: hasCustomCalldata
-          ? destinationCalldata
-          : effectiveOriginTokenAddress === zeroAddress
-            ? "0x"
-            : getERC20TransferData({
-                recipient,
-                amount: BigInt(swapAmount),
-              }),
-        value:
-          effectiveOriginTokenAddress === zeroAddress
-            ? BigInt(swapAmount)
-            : "0",
-        chainId: effectiveOriginChainId,
-        chain: effectiveOriginChain,
-      }
+          logger.console.log(
+            "[trails-sdk] origin call params",
+            originCallParams,
+          )
+          const txHash = await sendOriginTransaction(
+            account,
+            walletClient,
+            originCallParams as any,
+            {
+              depositTokenAmountUsd: depositAmountUsd?.toString(),
+            },
+          ) // TODO: Add proper type
 
-      logger.console.log("[trails-sdk] origin call params", originCallParams)
+          logger.console.log("[trails-sdk] origin tx", txHash)
 
-      let originUserTxReceipt: TransactionReceipt | null = null
-      const originMetaTxnReceipt: MetaTxnReceipt | null = null
-      const destinationMetaTxnReceipt: MetaTxnReceipt | null = null
+          if (onOriginSend) {
+            onOriginSend()
+          }
 
-      await attemptSwitchChain({
-        walletClient,
-        desiredChainId: effectiveOriginChainId,
-      })
-      if (!dryMode) {
-        try {
-          onTransactionStateChange([
+          // Wait for transaction receipt
+          const receipt = await effectivePublicClient.waitForTransactionReceipt(
             {
-              transactionHash: "",
-              explorerUrl: "",
-              chainId: effectiveOriginChainId,
-              state: "pending",
-              label: "Execute",
+              hash: txHash,
             },
-          ])
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error calling onTransactionStateChange:",
-            error,
           )
-        }
+          logger.console.log("[trails-sdk] receipt", receipt)
+          originUserTxReceipt = receipt
 
-        if (hasCustomCalldata) {
-          try {
-            const needsApproval = await getNeedsApproval({
-              publicClient: effectivePublicClient,
-              token: effectiveOriginTokenAddress,
-              account: account.address,
-              spender: recipient,
-              amount: maxUint256,
-            })
+          trackTransactionConfirmed({
+            transactionHash: txHash,
+            chainId: effectiveOriginChainId,
+            userAddress: account.address,
+            blockNumber: Number(receipt.blockNumber),
+            originTokenAddress,
+            depositTokenAmountUsd: depositAmountUsd?.toString(),
+          })
 
-            if (needsApproval) {
-              const txHash = await approveERC20({
-                walletClient,
-                tokenAddress: effectiveOriginTokenAddress,
-                spender: recipient,
-                amount: maxUint256,
-                chain: effectiveOriginChain,
-              })
+          // Remove persistent toast and show success
+          const chainInfo = getChainInfo(effectiveOriginChainId)
+          updatePersistentToast(
+            "Transfer Confirmed",
+            `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
+            "info",
+          )
 
-              logger.console.log("waiting for approve", txHash)
-              await effectivePublicClient.waitForTransactionReceipt({
-                hash: txHash,
-              })
-              logger.console.log("approve done")
-            }
+          try {
+            onTransactionStateChange([
+              getTransactionStateFromReceipt(
+                originUserTxReceipt,
+                effectiveOriginChainId,
+                transactionStates[0]?.label,
+              ),
+            ])
           } catch (error) {
-            logger.console.error("[trails-sdk] Error approving ERC20", error)
+            logger.console.error(
+              "[trails-sdk] Error calling onTransactionStateChange:",
+              error,
+            )
           }
-        }
 
-        // Show persistent toast for checkout flow
-        updatePersistentToast(
-          "Payment Started",
-          "Waiting for wallet confirmation...",
-          "info",
-        )
-
-        logger.console.log("[trails-sdk] origin call params", originCallParams)
-        const txHash = await sendOriginTransaction(
-          account,
-          walletClient,
-          originCallParams as any,
-          {
-            depositTokenAmountUsd: depositAmountUsd?.toString(),
-          },
-        ) // TODO: Add proper type
+          // 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
+            })
 
-        logger.console.log("[trails-sdk] origin tx", txHash)
+            // Call onCheckoutComplete callback if provided
+            if (checkoutOnHandlers?.triggerCheckoutComplete) {
+              checkoutOnHandlers.triggerCheckoutComplete()
+            }
+          } else if (originUserTxReceipt) {
+            trackPaymentError({
+              error: "Transaction failed",
+              userAddress: account.address,
+              mode,
+              fundMethod,
+              originTokenAddress,
+            })
 
-        if (onOriginSend) {
-          onOriginSend()
+            // Call onCheckoutError callback if provided
+            if (checkoutOnHandlers?.triggerCheckoutError) {
+              checkoutOnHandlers.triggerCheckoutError("Transaction failed")
+            }
+          }
         }
 
-        // Wait for transaction receipt
-        const receipt = await effectivePublicClient.waitForTransactionReceipt({
-          hash: txHash,
-        })
-        logger.console.log("[trails-sdk] receipt", receipt)
-        originUserTxReceipt = receipt
+        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,
+        )
 
-        trackTransactionConfirmed({
-          transactionHash: txHash,
-          chainId: effectiveOriginChainId,
+        // Track payment error
+        trackPaymentError({
+          error: errorMessage,
           userAddress: account.address,
-          blockNumber: Number(receipt.blockNumber),
+          mode,
+          fundMethod,
           originTokenAddress,
-          depositTokenAmountUsd: depositAmountUsd?.toString(),
         })
 
-        // Remove persistent toast and show success
-        const chainInfo = getChainInfo(effectiveOriginChainId)
-        updatePersistentToast(
-          "Transfer Confirmed",
-          `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
-          "info",
-        )
-
-        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
-          })
-        } else if (originUserTxReceipt) {
-          trackPaymentError({
-            error: "Transaction failed",
-            userAddress: account.address,
-            mode,
-            fundMethod,
-            originTokenAddress,
-          })
+        // Call onCheckoutError callback if provided
+        if (checkoutOnHandlers?.triggerCheckoutError) {
+          checkoutOnHandlers.triggerCheckoutError(errorMessage)
         }
-      }
 
-      return {
-        originUserTxReceipt,
-        originMetaTxnReceipt,
-        destinationMetaTxnReceipt,
-        totalCompletionSeconds: 0,
+        // Re-throw the error so caller can handle if needed
+        throw error
       }
     },
   }
@@ -2443,7 +2681,6 @@ async function _sendHandlerForSameChainDifferentToken({
       onOriginSend,
     }: {
       onOriginSend?: () => void
-      feeTokenAddress?: string | null
     }): Promise<SendReturn> => {
       const { hasEnoughBalance, balanceError } = await checkAccountBalance({
         account,
@@ -2557,6 +2794,8 @@ async function attemptGaslessDeposit({
   account,
   trailsClient,
   originRelayer,
+  feeOptions,
+  selectedFeeToken,
 }: {
   paymasterUrl?: string
   depositTokenAddress: string
@@ -2569,11 +2808,25 @@ async function attemptGaslessDeposit({
   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,
@@ -2581,12 +2834,20 @@ async function attemptGaslessDeposit({
   })
 
   const intentEntrypoint = intentEntrypoints[chain.id]
-  logger.console.log("[trails-sdk] intentEntrypoint", intentEntrypoint)
+  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.log(
-      "[trails-sdk] No intent entrypoint for chain, using fallback flow",
+    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<{
@@ -2596,7 +2857,19 @@ async function attemptGaslessDeposit({
     }> = []
 
     if (paymasterUrl) {
-      logger.console.log("[trails-sdk] doing gasless with paymaster")
+      logger.console.log(
+        "[trails-sdk] [GASLESS-FLOW] doing gasless with paymaster",
+      )
+
+      // Switch to correct chain before requesting signatures
+      logger.console.log(
+        "[trails-sdk] [GASLESS-FLOW] Switching chain for paymaster flow",
+      )
+      await attemptSwitchChain({
+        walletClient,
+        desiredChainId: originChainId,
+      })
+
       const delegatorSmartAccount = await getDelegatorSmartAccount({
         publicClient,
       })
@@ -2631,7 +2904,9 @@ async function attemptGaslessDeposit({
       logger.console.log("[trails-sdk] receipt", receipt)
       return receipt
     } else {
-      logger.console.log("[trails-sdk] doing gasless with sequence wallet")
+      logger.console.log(
+        "[trails-sdk] [GASLESS-FLOW] doing gasless with sequence wallet",
+      )
       const delegatorPrivateKey = generatePrivateKey()
       const delegatorAccount = privateKeyToAccount(delegatorPrivateKey)
       const delegatorClient = createWalletClient({
@@ -2702,56 +2977,148 @@ async function attemptGaslessDeposit({
     "[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(),
+      })
+    }
 
-    // 1. Check if we need approval for permit2
     const needsApproval = await getNeedsIntentEntrypointApproval({
       client: publicClient,
       token: depositTokenAddress as `0x${string}`,
       account: account.address,
       entrypoint: intentEntrypoint as `0x${string}`,
-      amount: BigInt(depositTokenAmount),
+      amount: requiredAmount, // Check if we have enough allowance for this specific transaction
     })
 
-    logger.console.log("[trails-sdk] Checking permit2 requirements", {
-      userAddress: account.address,
-      tokenAddress: depositTokenAddress,
-      amount: depositTokenAmount,
-      intentAddress: depositRecipient,
-      chainID: originChainId,
-      deadline,
-      needsApproval,
-    })
+    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 approval")
-      // NOTE: Currently signing for exact deposit amount because API encodes permitAmount = amount
-      // TODO: Update API to accept permitAmount parameter, then change to maxUint256 for unlimited approval
+      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: BigInt(depositTokenAmount), // Sign for exact amount to match API encoding
+        amount: permitAmount, // Infinite approval
         chain,
         deadline: BigInt(deadline),
       })
       permitSignature = permitSig.signature
       permitDeadline = Number(permitSig.deadline)
       logger.console.log(
-        "[trails-sdk] Permit signature obtained for amount:",
-        depositTokenAmount,
+        "[trails-sdk] Permit signature obtained for infinite approval",
       )
     }
 
-    // 3. Get intent signature
+    // 3. Get current nonce for the user
+    logger.console.log("[trails-sdk] Getting user nonce")
+    const nonce = await getUserNonce({
+      publicClient,
+      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: {
@@ -2762,15 +3129,39 @@ async function attemptGaslessDeposit({
         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")
 
-    // 4. Call the deposit endpoint with permit2 support
+    // 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 permit2 enabled",
-      { usePermit: needsApproval },
+      "[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,
@@ -2780,9 +3171,11 @@ async function attemptGaslessDeposit({
         chainID: originChainId,
         deadline,
         intentSignature,
-        usePermit: needsApproval, // Use permit2 if approval needed
+        usePermit: needsApproval, // Use permit if approval needed
+        permitAmount: needsApproval ? maxUint256.toString() : undefined, // Pass infinite approval amount
         permitSignature,
         permitDeadline,
+        feeAmount: selectedFeeOption?.amount || undefined,
       },
     })
 
@@ -3192,8 +3585,8 @@ async function attemptUserDepositTx({
   destinationTokenSymbol,
   depositAmountUsd,
   feeOptions,
-  feeTokenAddress,
   trailsClient,
+  selectedFeeToken,
 }: {
   originTokenAddress: string
   gasless: boolean
@@ -3220,8 +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
@@ -3240,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,
@@ -3257,11 +3675,12 @@ async function attemptUserDepositTx({
         account,
         trailsClient,
         originRelayer,
-        feeOptions,
-        feeTokenAddress: feeTokenAddress || "",
+        feeOptions: feeOptions,
+        selectedFeeToken: selectedFeeToken,
       })
     } catch (error) {
       logger.console.log("[trails-sdk] gassless attempt failed", error)
+      throw error
     }
   }
 
@@ -3298,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(
@@ -3659,11 +4175,20 @@ export function useQuote({
   quoteProvider,
   gasless,
   paymasterUrl,
-}: Partial<UseQuoteProps> = {}): UseQuoteReturn {
+  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()
 
@@ -3738,10 +4263,26 @@ export function useQuote({
 
       const sourceTokenDecimals = originToken?.decimals
       if (!sourceTokenDecimals) {
+        logger.console.error(
+          "[trails-sdk] [useQuote] Missing source token decimals:",
+          {
+            originToken,
+            fromTokenAddress,
+            fromChainId,
+          },
+        )
         throw new Error("Source token decimals not found")
       }
       const destinationTokenDecimals = destinationToken?.decimals
       if (!destinationTokenDecimals) {
+        logger.console.error(
+          "[trails-sdk] Missing destination token decimals:",
+          {
+            destinationToken,
+            toTokenAddress,
+            toChainId,
+          },
+        )
         throw new Error("Destination token decimals not found")
       }
       const destinationTokenSymbol = destinationToken?.symbol ?? ""
@@ -3991,7 +4532,6 @@ export async function getNormalizedQuoteObject({
   originNativeTokenPriceUsd,
   quoteProvider,
   noSufficientBalance,
-  minimumNotMet,
 }: {
   originDepositAddress?: string
   destinationDepositAddress?: string
@@ -4015,7 +4555,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")
@@ -4213,7 +4752,6 @@ export async function getNormalizedQuoteObject({
     ),
     quoteProvider: quoteProviderInfo,
     noSufficientBalance: noSufficientBalance || false,
-    minimumNotMet: minimumNotMet || false,
   }
 }