0xtrails 0.2.5 → 0.3.0

package/src/transactionIntent/handlers/crossChain.ts

@@ -0,0 +1,1707 @@
+import type {
+  Account,
+  Chain,
+  PublicClient,
+  WalletClient,
+  TransactionReceipt,
+} from "viem"
+import { createPublicClient, createWalletClient, http } from "viem"
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts"
+import type { TrailsAPIClient } from "@0xsequence/trails-api"
+import type { Attestation } from "../../cctp.js"
+import type { MetaTxnReceipt, PrepareSendReturn, SendReturn } from "../types.js"
+import type { TransactionState } from "../../transactions.js"
+import type { CheckoutOnHandlers } from "../../widget/hooks/useCheckout.js"
+import type {
+  Intent,
+  CommitIntentResponse,
+  DepositSignature,
+  ExecuteIntentResponse,
+} from "@0xsequence/trails-api"
+import { TradeType, type SelectedFeeToken } from "../types.js"
+import { logger } from "../../logger.js"
+import {
+  isTestnetDebugMode,
+  getTestnetOriginTokenAddress,
+} from "../utils/testnetHelpers.js"
+import { shouldUseCctp, validateCctpDestinationToken } from "../validators.js"
+import { getQueryParam } from "../../queryParams.js"
+import { getIsCustomCalldata } from "../../contractUtils.js"
+import { getNormalizedQuoteObject } from "../quote/normalizeQuote.js"
+import {
+  cctpTransfer,
+  cctpTransferWithCustomCall,
+  getCCTPRelayerCallData,
+  getMintUSDCData,
+  getMessageTransmitter,
+} from "../../cctp.js"
+import { getChainInfo, getTestnetChainInfo } from "../../chains.js"
+import { getTransactionStateFromReceipt } from "../execution/transactionState.js"
+import {
+  simpleCreateSequenceWallet,
+  sequenceSendTransaction,
+} from "../../sequenceWallet.js"
+import { getIntentArgs } from "../quote/quoteHelpers.js"
+import {
+  getIntent,
+  commitIntent,
+  buildCrossChainDepositParams,
+} from "../../intents.js"
+import { findFirstPreconditionForChainId } from "../../preconditions.js"
+import {
+  decodeTrailsTokenSweeperEvents,
+  decodeGuestModuleEvents,
+} from "../../decoders.js"
+import { updatePersistentToast } from "../../toast.js"
+import { queueCCTPTransfer } from "../../cctpqueue.js"
+import { formatRawAmount } from "../../tokenBalances.js"
+import { calcAmountUsdPrice } from "../../prices.js"
+import { checkAccountBalance } from "../utils/balanceChecker.js"
+import { estimateGasLimit } from "../../estimate.js"
+import {
+  getFeesFromIntent,
+  getPriceImpactFromIntent,
+  getPriceImpactUsdFromIntent,
+} from "../quote/feeExtractors.js"
+import { getNeedsLifiNativeFee } from "../utils/lifiHelpers.js"
+import { attemptUserDepositTx } from "../deposits/depositOrchestrator.js"
+import {
+  getAccountTransactionHistory,
+  getTxTimeDiff,
+} from "../../transactions.js"
+import { trackPaymentCompleted, trackPaymentError } from "../../analytics.js"
+import { POLLING_INTERVALS } from "../constants.js"
+import { pollIntentReceipt } from "../../intentReceiptPoller.js"
+import type { IntentReceipt } from "@0xsequence/trails-api"
+
+/**
+ * @description
+ * This handler manages cross-chain token transfers (e.g., transferring USDC to USDC on a different chain).
+ * It supports both standard transfers and custom calldata execution.
+ *
+ * Key characteristics:
+ * - Uses the Trails API with commitIntent and waitIntentReceipt for monitoring
+ * - Two transaction legs (deposit and user transfer)
+ * - Cross-chain bridging or token swapping required
+ * - More complex flow compared to same-chain scenarios
+ *
+ * Transaction Flow:
+ * 1. Create intent via createIntent (Intent object created)
+ * 2. Commit intent via commitIntent (Intent record created in backend)
+ * 3. User submits deposit transaction on origin chain
+ * 4. Poll via waitIntentReceipt API to monitor deposit transaction completion
+ * 5. User submits transfer transaction on destination chain
+ * 6. Poll via waitIntentReceipt API to monitor transfer transaction completion
+ * 7. Update transaction state and invoke callbacks
+ *
+ * Error Handling:
+ * - Balance validation before transaction submission
+ * - Gas estimation for accurate fee calculation
+ * - Proper error propagation with checkout error callbacks
+ * - Fallback logging for debugging
+ *
+ * State Management:
+ * - transactionStates[0]: Deposit transaction
+ * - transactionStates[1]: User transfer transaction
+ * - transactionStates[2]: Destination transfer transaction
+ * - Updates propagated via onTransactionStateChange callback
+ * - Analytics tracking for payment completion or errors
+ */
+export async function handleCrossChain({
+  mainSignerAddress,
+  originChainId,
+  originTokenAddress,
+  originTokenBalance,
+  destinationChainId,
+  destinationTokenAddress,
+  swapAmount,
+  originTokenSymbol,
+  destinationTokenSymbol,
+  recipient,
+  destinationCalldata,
+  trailsClient,
+  sourceTokenPriceUsd,
+  destinationTokenPriceUsd,
+  sourceTokenDecimals,
+  destinationTokenDecimals,
+  paymasterUrl,
+  walletClient,
+  publicClient,
+  chain,
+  account,
+  fee,
+  dryMode,
+  onTransactionStateChange,
+  transactionStates,
+  slippageTolerance,
+  tradeType,
+  originNativeTokenPriceUsd,
+  quoteProvider,
+  fundMethod,
+  mode,
+  checkoutOnHandlers,
+  selectedFeeToken,
+  walletId,
+  abortSignal,
+  commitIntentFn,
+  executeIntentFn,
+}: {
+  mainSignerAddress: string
+  originChainId: number
+  originTokenAddress: string
+  originTokenBalance: string
+  destinationChainId: number
+  destinationTokenAddress: string
+  swapAmount: string
+  originTokenSymbol: string
+  destinationTokenSymbol: string
+  recipient: string
+  destinationCalldata?: string
+  trailsClient: TrailsAPIClient
+  sourceTokenPriceUsd?: number | null
+  destinationTokenPriceUsd?: number | null
+  sourceTokenDecimals: number
+  destinationTokenDecimals: number
+  paymasterUrl?: string
+  walletClient: WalletClient
+  publicClient: PublicClient
+  chain: Chain
+  account: Account
+  fee: string
+  dryMode: boolean
+  onTransactionStateChange: (transactionStates: TransactionState[]) => void
+  transactionStates: TransactionState[]
+  slippageTolerance: string
+  tradeType: TradeType
+  originNativeTokenPriceUsd?: number | null
+  quoteProvider?: string | null
+  fundMethod?: string
+  mode?: "pay" | "fund" | "earn" | "swap" | "receive"
+  checkoutOnHandlers?: CheckoutOnHandlers
+  selectedFeeToken?: SelectedFeeToken
+  walletId?: string
+  abortSignal?: AbortSignal
+  commitIntentFn?: (intent: Intent) => Promise<CommitIntentResponse>
+  executeIntentFn?: (params: {
+    intentId: string
+    depositTransactionHash?: string
+    depositSignature?: DepositSignature
+  }) => Promise<ExecuteIntentResponse>
+}): Promise<PrepareSendReturn> {
+  const testnet = isTestnetDebugMode()
+  const useCctp = shouldUseCctp(
+    originTokenAddress,
+    destinationTokenAddress,
+    originChainId,
+    destinationChainId,
+  )
+
+  const cctpFlag = getQueryParam("cctp") === "true"
+  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
+
+  // Validate CCTP destination token requirement for explicit CCTP usage
+  if (useCctp && cctpFlag) {
+    validateCctpDestinationToken(
+      destinationTokenAddress,
+      destinationChainId,
+      "cctp",
+    )
+    logger.console.log("[trails-sdk] using cctp")
+
+    const quote = await getNormalizedQuoteObject({
+      destinationAddress: recipient,
+      destinationCalldata,
+      originAmount: swapAmount,
+      originTokenPriceUsd: sourceTokenPriceUsd?.toString() || null,
+      destinationAmount: swapAmount,
+      destinationTokenPriceUsd: destinationTokenPriceUsd?.toString() || null,
+      originTokenAddress: originTokenAddress,
+      destinationTokenAddress: destinationTokenAddress,
+      originChainId,
+      destinationChainId,
+      transactionStates,
+      originNativeTokenPriceUsd,
+      slippageTolerance,
+      quoteProvider: "cctp",
+    })
+
+    // Call onCheckoutQuote callback if provided
+    if (checkoutOnHandlers?.triggerCheckoutQuote) {
+      checkoutOnHandlers.triggerCheckoutQuote(quote)
+    }
+
+    return {
+      quote,
+      send: async ({
+        onOriginSend,
+        selectedFeeToken: runtimeSelectedFeeToken,
+      }: {
+        onOriginSend?: () => void
+        selectedFeeToken?: SelectedFeeToken
+      }): 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)!
+          : getChainInfo(destinationChainId)
+
+        if (!originChain || !destinationChain) {
+          logger.console.error("[trails-sdk] Invalid chain", {
+            originChain,
+            destinationChain,
+            originChainId,
+            destinationChainId,
+            chain,
+            testnet,
+          })
+          throw new Error("Invalid chain")
+        }
+
+        logger.console.log("[trails-sdk] originChain", originChain)
+        logger.console.log("[trails-sdk] destinationChain", destinationChain)
+
+        const originPublicClient = createPublicClient({
+          chain: originChain,
+          transport: http(),
+        })
+
+        let txHash: `0x${string}`
+        let waitForAttestation: () => Promise<Attestation>
+
+        if (hasCustomCalldata) {
+          const result = await cctpTransferWithCustomCall({
+            walletClient,
+            originChain,
+            destinationChain,
+            amount: BigInt(swapAmount),
+          })
+
+          txHash = result.txHash
+          waitForAttestation = result.waitForAttestation
+        } else {
+          const result = await cctpTransfer({
+            walletClient,
+            originChain,
+            destinationChain,
+            amount: BigInt(swapAmount),
+          })
+
+          txHash = result.txHash
+          waitForAttestation = result.waitForAttestation
+        }
+
+        if (onOriginSend) {
+          onOriginSend()
+        }
+
+        logger.console.log("[trails-sdk] waiting for tx", txHash)
+
+        const receipt = await originPublicClient.waitForTransactionReceipt({
+          hash: txHash,
+        })
+
+        logger.console.log("[trails-sdk] tx receipt", receipt)
+
+        transactionStates[0] = getTransactionStateFromReceipt(
+          receipt,
+          originChain.id,
+          transactionStates[0]?.label,
+        )
+        transactionStates[1] = getTransactionStateFromReceipt(
+          receipt,
+          originChain.id,
+          transactionStates[1]?.label,
+        )
+
+        onTransactionStateChange(transactionStates)
+
+        const attestation = await waitForAttestation()
+
+        if (!attestation) {
+          throw new Error("Failed to retrieve attestation")
+        }
+
+        const tokenMessenger = getMessageTransmitter(destinationChain.id)!
+
+        logger.console.log("[trails-sdk] tokenMessenger", tokenMessenger)
+        const calls: {
+          to: `0x${string}`
+          data: `0x${string}`
+          value: bigint
+        }[] = []
+
+        if (hasCustomCalldata) {
+          calls.push(
+            await getCCTPRelayerCallData({
+              attestation,
+              targetContract: recipient,
+              calldata: destinationCalldata as `0x${string}`,
+              gasLimit: 300000n,
+              destinationChain,
+            }),
+          )
+        } else {
+          calls.push(
+            await getMintUSDCData({
+              tokenMessenger,
+              attestation,
+            }),
+          )
+        }
+
+        logger.console.log("[trails-sdk] calls", calls)
+        const delegatorPrivateKey = generatePrivateKey()
+        const delegatorAccount = privateKeyToAccount(delegatorPrivateKey)
+        const delegatorClient = createWalletClient({
+          account: delegatorAccount,
+          chain: destinationChain,
+          transport: http(),
+        })
+        const destinationPublicClient = createPublicClient({
+          chain: destinationChain,
+          transport: http(),
+        })
+        logger.console.log("[trails-sdk] delegatorClient", delegatorClient)
+
+        const sequenceWalletAddress = await simpleCreateSequenceWallet(
+          delegatorAccount as any,
+        )
+        logger.console.log(
+          "[trails-sdk] sequenceWalletAddress",
+          sequenceWalletAddress,
+        )
+        const sequenceTxHash = await sequenceSendTransaction(
+          sequenceWalletAddress,
+          delegatorClient,
+          destinationPublicClient,
+          calls,
+          destinationChain,
+        )
+
+        const destinationReceipt =
+          await destinationPublicClient.waitForTransactionReceipt({
+            hash: sequenceTxHash as `0x${string}`,
+          })
+
+        logger.console.log(
+          "[trails-sdk] destinationReceipt",
+          destinationReceipt,
+        )
+
+        if (transactionStates[2]) {
+          transactionStates[2] = getTransactionStateFromReceipt(
+            destinationReceipt,
+            destinationChain.id,
+            transactionStates[2]?.label,
+          )
+        }
+
+        onTransactionStateChange(transactionStates)
+
+        return {
+          depositUserTxnReceipt: receipt,
+          originMetaTxnReceipt: null,
+          destinationMetaTxnReceipt: null,
+          totalCompletionSeconds: 0,
+        }
+      },
+    }
+  }
+
+  const destinationSalt = Date.now().toString()
+
+  const intentArgs = getIntentArgs(
+    mainSignerAddress,
+    originChainId,
+    originTokenAddress,
+    tradeType === TradeType.EXACT_OUTPUT ? originTokenBalance : swapAmount, // originTokenAmount
+    destinationChainId,
+    destinationTokenAddress,
+    tradeType === TradeType.EXACT_OUTPUT ? swapAmount : "0", // destinationTokenAmount
+    recipient,
+    destinationCalldata,
+    destinationSalt,
+    slippageTolerance,
+    tradeType,
+    quoteProvider,
+  )
+
+  logger.console.log("[trails-sdk] Creating intent with args:", intentArgs)
+
+  const { intent, gasFeeOptions } = await getIntent(trailsClient, intentArgs, {
+    originTokenSymbol,
+    destinationTokenSymbol,
+    feeTokenSymbol: originTokenSymbol,
+  })
+  logger.console.log("[trails-sdk] Got intent:", intent)
+  logger.console.log("[trails-sdk] Got gasFeeOptions:", gasFeeOptions)
+
+  if (!intent.preconditions?.length || !intent.calls?.length) {
+    throw new Error("Invalid intent")
+  }
+
+  const originIntentAddress = intent.originIntentAddress
+  logger.console.log(
+    "[trails-sdk] origin intent address:",
+    originIntentAddress.toString(),
+  )
+
+  const firstPrecondition = findFirstPreconditionForChainId(
+    intent.preconditions,
+    originChainId,
+  )
+
+  if (!firstPrecondition) {
+    throw new Error("No precondition found for origin chain")
+  }
+
+  const firstPreconditionMin = firstPrecondition?.minAmount?.toString()
+  const depositAmount = firstPreconditionMin
+
+  const quoteToAmount = intent.quote.toAmount
+  const quoteToAmountMin = intent.quote.toAmountMin
+
+  const originSendAmountFormatted = formatRawAmount(
+    depositAmount,
+    sourceTokenDecimals,
+  )
+
+  const depositAmountUsd = calcAmountUsdPrice({
+    amount: originSendAmountFormatted,
+    usdPrice: sourceTokenPriceUsd,
+  })
+
+  logger.console.log("[trails-sdk] depositAmountUsd", depositAmountUsd, {
+    amount: originSendAmountFormatted,
+    usdPrice: sourceTokenPriceUsd,
+    originTokenSymbol,
+    originSendAmountFormatted,
+  })
+
+  const effectiveDestinationTokenAmount = quoteToAmount
+  const effectiveDestinationTokenAmountFormatted = formatRawAmount(
+    effectiveDestinationTokenAmount,
+    destinationTokenDecimals,
+  )
+
+  const effectiveDestinationTokenAmountUsd = calcAmountUsdPrice({
+    amount: effectiveDestinationTokenAmountFormatted,
+    usdPrice: destinationTokenPriceUsd,
+  })
+
+  logger.console.log(
+    "[trails-sdk] effectiveDestinationTokenAmountUsd",
+    effectiveDestinationTokenAmountUsd,
+    {
+      amount: effectiveDestinationTokenAmountFormatted,
+      usdPrice: destinationTokenPriceUsd,
+      destinationTokenSymbol,
+      effectiveDestinationTokenAmount,
+      destinationTokenAddress,
+      destinationChainId,
+    },
+  )
+
+  let noSufficientBalance = false
+
+  if (!(fundMethod === "qr-code" || fundMethod === "exchange")) {
+    const { hasEnoughBalance } = await checkAccountBalance({
+      account,
+      tokenAddress: originTokenAddress,
+      depositAmount,
+      publicClient,
+    })
+
+    if (!hasEnoughBalance) {
+      noSufficientBalance = true
+    }
+  }
+
+  // Estimate gas limit for the quote (same logic as in attemptNonGaslessUserDeposit)
+  const originCallParamsForEstimate = buildCrossChainDepositParams({
+    originTokenAddress,
+    originIntentAddress,
+    depositAmount: firstPreconditionMin,
+    fee,
+    originChainId,
+    chain,
+  })
+
+  logger.console.log(
+    "[trails-sdk][gas-estimation] About to estimate gas limit for cross-chain quote with params:",
+    {
+      account: account.address,
+      to: originCallParamsForEstimate.to,
+      data: originCallParamsForEstimate.data,
+      value: originCallParamsForEstimate.value,
+    },
+  )
+
+  const estimatedGasLimitForQuote = await estimateGasLimit(
+    publicClient,
+    {
+      account: account.address,
+      to: originCallParamsForEstimate.to,
+      data: originCallParamsForEstimate.data,
+      value: BigInt(originCallParamsForEstimate.value),
+    },
+    "quote",
+  )
+
+  logger.console.log(
+    "[trails-sdk][gas-estimation] Estimated gas limit for cross-chain quote:",
+    estimatedGasLimitForQuote,
+  )
+
+  const quote = await getNormalizedQuoteObject({
+    originDepositAddress: originIntentAddress,
+    destinationDepositAddress: intent.destinationIntentAddress,
+    destinationAddress: recipient,
+    destinationCalldata,
+    originAmount: depositAmount,
+    destinationAmount: quoteToAmount.toString(),
+    originAmountMin: depositAmount,
+    destinationAmountMin: quoteToAmountMin.toString(),
+    originTokenAddress: originTokenAddress,
+    destinationTokenAddress: destinationTokenAddress,
+    originTokenPriceUsd: sourceTokenPriceUsd?.toString() || null,
+    destinationTokenPriceUsd: destinationTokenPriceUsd?.toString() || null,
+    fees: getFeesFromIntent(intent, {
+      tradeType,
+      fromAmountUsd: depositAmountUsd,
+      toAmountUsd: effectiveDestinationTokenAmountUsd,
+    }),
+    originChainId,
+    destinationChainId,
+    slippageTolerance: slippageTolerance,
+    priceImpact: getPriceImpactFromIntent(intent),
+    priceImpactUsd: getPriceImpactUsdFromIntent(intent),
+    transactionStates,
+    originNativeTokenPriceUsd,
+    quoteProvider: intent.quote?.quoteProvider,
+    noSufficientBalance,
+    estimatedGasLimit: estimatedGasLimitForQuote,
+    intent,
+  })
+
+  // Call onCheckoutQuote callback if provided
+  if (checkoutOnHandlers?.triggerCheckoutQuote) {
+    checkoutOnHandlers.triggerCheckoutQuote(quote)
+  }
+
+  // Gasless fee options are now returned in QuoteIntentResponse.gasFeeOptions
+  // and properly propagated from getIntent()
+  const effectiveGasless =
+    selectedFeeToken !== null &&
+    selectedFeeToken !== undefined &&
+    walletId !== "sequence-waas"
+  if (effectiveGasless) {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Gasless enabled. Using gasFeeOptions from QuoteIntent response",
+      { originChainId, gasFeeOptions },
+    )
+  } else if (walletId === "sequence-waas") {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Skipping gasless fee options for sequence-waas wallet",
+    )
+  } else {
+    logger.console.log(
+      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Gasless disabled",
+    )
+  }
+
+  return {
+    quote,
+    feeOptions: gasFeeOptions,
+    send: async ({
+      onOriginSend,
+      selectedFeeToken: runtimeSelectedFeeToken,
+    }: {
+      onOriginSend?: () => void
+      selectedFeeToken?: SelectedFeeToken
+    }): Promise<SendReturn> => {
+      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,
+          },
+        )
+        const commitIntentFnToUse =
+          commitIntentFn ||
+          ((intent: Intent) =>
+            commitIntent(trailsClient, intent, {
+              originTokenSymbol,
+              destinationTokenSymbol,
+            }))
+        await commitIntentFnToUse(intent)
+
+        if (!(fundMethod === "qr-code" || fundMethod === "exchange")) {
+          const { hasEnoughBalance, balanceError } = await checkAccountBalance({
+            account,
+            tokenAddress: originTokenAddress,
+            depositAmount,
+            publicClient,
+          })
+
+          if (!hasEnoughBalance) {
+            throw balanceError
+          }
+        }
+
+        logger.console.log("[trails-sdk] sending origin transaction")
+        const usingLIfi = false
+        let needsNativeFee = false
+
+        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,
+        )
+        logger.console.log(
+          "[trails-sdk] destinationTokenDecimals",
+          destinationTokenDecimals,
+        )
+
+        let depositUserTxnReceipt: 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
+
+        logger.console.log("[trails-sdk] testnet", testnet)
+
+        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)
+
+          // 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
+          }
+
+          logger.console.log(
+            "[trails-sdk] Calling attemptUserDepositTx with params:",
+            {
+              originTokenAddress: effectiveOriginTokenAddress,
+              paymasterUrl,
+              chain: effectiveOriginChain.id,
+              account: account.address,
+              firstPreconditionMin,
+              originIntentAddress,
+              fee,
+              dryMode,
+              feeOptions: gasFeeOptions,
+              selectedFeeToken: effectiveSelectedFeeToken,
+              selectedFeeTokenType: typeof effectiveSelectedFeeToken,
+              selectedFeeTokenValue: JSON.stringify(effectiveSelectedFeeToken),
+            },
+          )
+
+          depositUserTxnReceipt = await attemptUserDepositTx({
+            originTokenAddress: effectiveOriginTokenAddress,
+            paymasterUrl,
+            chain: effectiveOriginChain,
+            account,
+            firstPreconditionMin,
+            originIntentAddress,
+            onOriginSend,
+            publicClient,
+            walletClient,
+            destinationTokenDecimals,
+            sourceTokenDecimals,
+            fee,
+            dryMode,
+            sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
+            destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
+            swapAmount,
+            onTransactionStateChange,
+            transactionStates,
+            fundMethod,
+            originTokenSymbol,
+            destinationTokenSymbol,
+            depositAmountUsd,
+            feeOptions: gasFeeOptions,
+            trailsClient,
+            selectedFeeToken: effectiveSelectedFeeToken,
+            walletId,
+            abortSignal,
+            intentId: intent.intentId,
+          })
+
+          // In gasless mode, depositUserTxnReceipt will be null because the transaction
+          // is submitted to the backend and monitored via checkForDepositTx polling
+          // In non-gasless mode, we should have a receipt
+          // if (!depositUserTxnReceipt && !effectiveGasless) {
+          // throw new Error("Failed to send origin transaction")
+          // }
+
+          // Only process receipt if we have one (non-gasless mode)
+          if (depositUserTxnReceipt) {
+            transactionStates[0] = getTransactionStateFromReceipt(
+              depositUserTxnReceipt,
+              originChainId,
+              transactionStates[0]?.label,
+            )
+
+            // Call executeIntent after successful origin transaction
+            // This triggers the backend to start executing the intent
+            // In gasless mode, the executeIntent is called in attemptGaslessDeposit
+            if (depositUserTxnReceipt.status === "success" && intent.intentId) {
+              logger.console.log(
+                "[trails-sdk] Calling executeIntent with deposit transaction hash",
+                {
+                  intentId: intent.intentId,
+                  txHash: depositUserTxnReceipt.transactionHash,
+                },
+              )
+              try {
+                const executeIntentFnToUse =
+                  executeIntentFn ||
+                  trailsClient.executeIntent.bind(trailsClient)
+                await executeIntentFnToUse({
+                  intentId: intent.intentId,
+                  depositTransactionHash: depositUserTxnReceipt.transactionHash,
+                })
+                logger.console.log(
+                  "[trails-sdk] executeIntent completed successfully",
+                )
+              } catch (error) {
+                logger.console.error(
+                  "[trails-sdk] Error calling executeIntent:",
+                  error,
+                )
+              }
+            }
+
+            try {
+              transactionStates[0].decodedTrailsTokenSweeperEvents =
+                decodeTrailsTokenSweeperEvents(depositUserTxnReceipt)
+              transactionStates[0].decodedGuestModuleEvents =
+                decodeGuestModuleEvents(depositUserTxnReceipt)
+              transactionStates[0].refunded =
+                transactionStates[0].decodedTrailsTokenSweeperEvents.findIndex(
+                  (event) =>
+                    event.type === "Refund" || event.type === "RefundAndSweep",
+                ) !== -1
+              logger.console.log(
+                "[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,
+                },
+              )
+
+              // Check for transaction failure or refund
+              const hasCallFailed = (
+                transactionStates[0].decodedGuestModuleEvents || []
+              ).some((e: any) => e?.type === "CallFailed")
+
+              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,
+                  },
+                )
+
+                // Call onCheckoutError callback if provided
+                if (checkoutOnHandlers?.triggerCheckoutError) {
+                  checkoutOnHandlers.triggerCheckoutError(errorMessage)
+                }
+              }
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk] Error decoding gasless deposit events",
+                error,
+              )
+            }
+
+            onTransactionStateChange(transactionStates)
+
+            setTimeout(() => {
+              const destinationChain = getChainInfo(destinationChainId)
+              updatePersistentToast(
+                "In Progress",
+                `Your transaction to ${destinationChain?.name || "chain"} is in progress`,
+                "info",
+              )
+            }, 1000)
+          } else {
+            // Gasless mode - transaction submitted to backend via executeIntent in attemptGaslessDeposit
+            logger.console.log(
+              "[trails-sdk] Gasless mode - intent submitted to backend via executeIntent, transaction will be monitored via polling",
+            )
+          }
+
+          // Note: Unified polling will be started outside depositPromise after it completes
+        }
+
+        const checkForDepositTx = async () => {
+          while (true) {
+            // Check if we should abort
+            if (abortSignal?.aborted) {
+              logger.console.log(
+                "[trails-sdk] Aborting deposit tx check due to abort signal",
+              )
+              return null
+            }
+
+            try {
+              const response = await getAccountTransactionHistory({
+                chainId: originChainId,
+                accountAddress: originIntentAddress,
+                abortSignal,
+              })
+              logger.console.log(
+                "[trails-sdk] getAccountTransactionHistory response",
+                response,
+              )
+              if (response.transactions.length > 0) {
+                const tx = response.transactions[0]
+                if (!tx?.txnHash) {
+                  await new Promise((resolve) =>
+                    setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
+                  )
+                  continue
+                }
+                // const isReceive = tx.transfers.some(
+                //   (transfer) => transfer.transferType === "RECEIVE",
+                // )
+                // if (!isReceive) {
+                //   await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY))
+                //   continue
+                // }
+                const originDepositTxReceipt =
+                  await publicClient.getTransactionReceipt({
+                    hash: tx.txnHash as `0x${string}`,
+                  })
+
+                depositUserTxnReceipt = originDepositTxReceipt
+
+                transactionStates[0] = getTransactionStateFromReceipt(
+                  originDepositTxReceipt,
+                  originChainId,
+                  transactionStates[0]?.label,
+                )
+                onTransactionStateChange(transactionStates)
+
+                if (onOriginSend) {
+                  onOriginSend()
+                }
+                break
+              }
+            } catch (error) {
+              logger.console.error("Error checking for deposit tx", error)
+            }
+            await new Promise((resolve) =>
+              setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
+            )
+          }
+        }
+
+        const _checkForDestinationDepositTx: () => Promise<TransactionReceipt | null> =
+          async () => {
+            while (true) {
+              // Check if we should abort
+              if (abortSignal?.aborted) {
+                logger.console.log(
+                  "[trails-sdk] Aborting destination deposit tx check due to abort signal",
+                )
+                return null
+              }
+
+              try {
+                const response = await getAccountTransactionHistory({
+                  chainId: destinationChainId,
+                  accountAddress:
+                    intent.destinationIntentAddress as `0x${string}`,
+                  abortSignal,
+                })
+                logger.console.log(
+                  "[trails-sdk] getAccountTransactionHistory response",
+                  response,
+                )
+                if (response.transactions.length > 0) {
+                  const tx = response.transactions[0]
+                  if (!tx?.txnHash) {
+                    await new Promise((resolve) =>
+                      setTimeout(
+                        resolve,
+                        POLLING_INTERVALS.TRANSACTION_HISTORY,
+                      ),
+                    )
+                    continue
+                  }
+                  // const 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}`,
+                    })
+
+                  transactionStates[2] = getTransactionStateFromReceipt(
+                    destinationDepositTxReceipt,
+                    destinationChainId,
+                    transactionStates[2]?.label,
+                  )
+                  onTransactionStateChange(transactionStates)
+
+                  return destinationDepositTxReceipt
+                }
+              } catch (error) {
+                logger.console.error("Error checking for deposit tx", error)
+              }
+              await new Promise((resolve) =>
+                setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
+              )
+            }
+          }
+
+        // Variables to store the waitForReceipt functions
+        // DEPRECATED: These are no longer used - we now use the unified poller
+        // let originMetaTxnReceiptPromise:
+        //   | ((abortSignal?: AbortSignal) => Promise<MetaTxnReceipt | null>)
+        //   | null = null
+        // let destinationMetaTxnReceiptPromise:
+        //   | ((abortSignal?: AbortSignal) => Promise<MetaTxnReceipt | null>)
+        //   | ((abortSignal?: AbortSignal) => Promise<TransactionReceipt | null>)
+        //   | null = null
+
+        // Unified polling via shared poller instead of separate loops
+        let unifiedPollerAbortController: AbortController | null = null
+        let unifiedPollerPromise: Promise<IntentReceipt | null> | null = null
+
+        // Helper function to start unified polling for both origin and destination transactions
+        const startUnifiedPolling = () => {
+          if (!unifiedPollerAbortController) {
+            logger.console.log(
+              "[trails-sdk] Starting unified polling for intent",
+              {
+                intentId: intent.intentId,
+              },
+            )
+
+            unifiedPollerAbortController = new AbortController()
+            unifiedPollerPromise = pollIntentReceipt({
+              intentId: intent.intentId,
+              trailsClient,
+              abortSignal: unifiedPollerAbortController.signal,
+              callbacks: {
+                onDepositTransactionFound: async (txHash) => {
+                  logger.console.log(
+                    "[trails-sdk] Unified poller discovered deposit transaction",
+                    {
+                      txHash,
+                    },
+                  )
+
+                  // For gasless flows, the deposit transaction is the user's initial deposit
+                  // Update transactionStates[0] with the deposit transaction receipt
+                  if (transactionStates[0]) {
+                    try {
+                      const depositTxReceipt =
+                        await publicClient.getTransactionReceipt({
+                          hash: txHash as `0x${string}`,
+                        })
+                      logger.console.log(
+                        "[trails-sdk] Deposit transaction receipt fetched",
+                        {
+                          txHash,
+                          blockNumber: depositTxReceipt?.blockNumber,
+                          status: depositTxReceipt?.status,
+                        },
+                      )
+
+                      transactionStates[0] = getTransactionStateFromReceipt(
+                        depositTxReceipt,
+                        originChainId,
+                        transactionStates[0]?.label,
+                      )
+                      onTransactionStateChange(transactionStates)
+
+                      // Decode events for the deposit transaction
+                      try {
+                        transactionStates[0].decodedTrailsTokenSweeperEvents =
+                          decodeTrailsTokenSweeperEvents(depositTxReceipt)
+                        transactionStates[0].decodedGuestModuleEvents =
+                          decodeGuestModuleEvents(depositTxReceipt)
+                        transactionStates[0].refunded =
+                          transactionStates[0].decodedTrailsTokenSweeperEvents.findIndex(
+                            (event) =>
+                              event.type === "Refund" ||
+                              event.type === "RefundAndSweep",
+                          ) !== -1
+                        logger.console.log(
+                          "[trails-sdk] Deposit transaction events decoded",
+                          {
+                            chainId: originChainId,
+                            callFailed: (
+                              transactionStates[0].decodedGuestModuleEvents ||
+                              []
+                            ).filter((e: any) => e?.type === "CallFailed")
+                              .length,
+                            sweeperEvents: (
+                              transactionStates[0]
+                                .decodedTrailsTokenSweeperEvents || []
+                            ).length,
+                            refunded: transactionStates[0].refunded,
+                          },
+                        )
+
+                        const hasCallFailed = (
+                          transactionStates[0].decodedGuestModuleEvents || []
+                        ).some((e: any) => e?.type === "CallFailed")
+
+                        if (transactionStates[0].refunded || hasCallFailed) {
+                          const errorMessage = transactionStates[0].refunded
+                            ? "Deposit transaction was refunded"
+                            : "Deposit transaction call failed"
+
+                          logger.console.error(
+                            "[trails-sdk] Deposit transaction failed",
+                            {
+                              refunded: transactionStates[0].refunded,
+                              callFailed: hasCallFailed,
+                            },
+                          )
+
+                          if (checkoutOnHandlers?.triggerCheckoutError) {
+                            checkoutOnHandlers.triggerCheckoutError(
+                              errorMessage,
+                            )
+                          }
+                        }
+
+                        onTransactionStateChange(transactionStates)
+                      } catch (error) {
+                        logger.console.error(
+                          "Error decoding deposit tx events",
+                          error,
+                        )
+                      }
+                    } catch (error) {
+                      logger.console.error(
+                        "[trails-sdk] Error fetching deposit transaction receipt:",
+                        error,
+                      )
+                    }
+                  }
+                },
+                onOriginTransactionFound: async (txHash) => {
+                  logger.console.log(
+                    "[trails-sdk] Unified poller discovered origin transaction",
+                    {
+                      txHash,
+                    },
+                  )
+
+                  // Store the transaction hash
+                  originMetaTxnReceipt = { txnHash: txHash } as MetaTxnReceipt
+
+                  const originTxnReceipt =
+                    await publicClient.getTransactionReceipt({
+                      hash: txHash as `0x${string}`,
+                    })
+                  logger.console.log(
+                    "[trails-sdk] Origin transaction receipt fetched",
+                    {
+                      txHash,
+                      blockNumber: originTxnReceipt?.blockNumber,
+                      status: originTxnReceipt?.status,
+                    },
+                  )
+
+                  if (transactionStates[1]) {
+                    transactionStates[1] = getTransactionStateFromReceipt(
+                      originTxnReceipt,
+                      originChainId,
+                      transactionStates[1]?.label,
+                    )
+                    onTransactionStateChange(transactionStates)
+                  }
+
+                  // Decode events for the origin transaction
+                  try {
+                    transactionStates[1]!.decodedTrailsTokenSweeperEvents =
+                      decodeTrailsTokenSweeperEvents(originTxnReceipt)
+                    transactionStates[1]!.decodedGuestModuleEvents =
+                      decodeGuestModuleEvents(originTxnReceipt)
+                    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,
+                    })
+
+                    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,
+                        },
+                      )
+
+                      if (checkoutOnHandlers?.triggerCheckoutError) {
+                        checkoutOnHandlers.triggerCheckoutError(errorMessage)
+                      }
+                    }
+
+                    onTransactionStateChange(transactionStates)
+                  } catch (error) {
+                    logger.console.error(
+                      "Error decoding origin tx events",
+                      error,
+                    )
+                  }
+                },
+                onDestinationTransactionFound: async (txHash) => {
+                  logger.console.log(
+                    "[trails-sdk] Unified poller discovered destination transaction",
+                    {
+                      txHash,
+                    },
+                  )
+
+                  // Store the transaction hash
+                  destinationMetaTxnReceipt = {
+                    txnHash: txHash,
+                  } as MetaTxnReceipt
+
+                  const destinationTxnReceipt =
+                    await destinationPublicClient.getTransactionReceipt({
+                      hash: txHash as `0x${string}`,
+                    })
+                  logger.console.log(
+                    "[trails-sdk] Destination transaction receipt fetched",
+                    {
+                      txHash,
+                      blockNumber: destinationTxnReceipt?.blockNumber,
+                      status: destinationTxnReceipt?.status,
+                    },
+                  )
+
+                  if (transactionStates[2]) {
+                    transactionStates[2] = getTransactionStateFromReceipt(
+                      destinationTxnReceipt,
+                      destinationChainId,
+                      transactionStates[2]?.label,
+                    )
+                    onTransactionStateChange(transactionStates)
+                  }
+
+                  // Decode events for the destination transaction
+                  try {
+                    transactionStates[2]!.decodedTrailsTokenSweeperEvents =
+                      decodeTrailsTokenSweeperEvents(destinationTxnReceipt)
+                    transactionStates[2]!.decodedGuestModuleEvents =
+                      decodeGuestModuleEvents(destinationTxnReceipt)
+                    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,
+                      },
+                    )
+
+                    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,
+                        },
+                      )
+
+                      if (checkoutOnHandlers?.triggerCheckoutError) {
+                        checkoutOnHandlers.triggerCheckoutError(errorMessage)
+                      }
+                    }
+
+                    onTransactionStateChange(transactionStates)
+                  } catch (error) {
+                    logger.console.error(
+                      "Error decoding destination tx events",
+                      error,
+                    )
+                  }
+                },
+              },
+            }).then(
+              () => {
+                logger.console.log("[trails-sdk] Unified poller completed")
+                return null
+              },
+              (error) => {
+                logger.console.error("[trails-sdk] Unified poller error", error)
+                return null
+              },
+            )
+          }
+        }
+
+        // First phase: Send meta transactions and queue CCTP
+        const originSendMetaTxnPromise = async () => {
+          logger.console.log("[trails-sdk] Starting originSendMetaTxnPromise", {
+            hasMetaTxn: !!intent.metaTxns[0],
+            hasPrecondition: !!intent.preconditions[0],
+            metaTxnId: intent.metaTxns[0]?.id,
+            chainId: intent.metaTxns[0]?.chainId,
+          })
+
+          if (intent.metaTxns[0] && intent.preconditions[0]) {
+            const metaTxnId = intent.metaTxns[0].id
+            const feeQuote = undefined
+            logger.console.log("[trails-sdk] Processing origin meta txn", {
+              metaTxnId,
+              feeQuote,
+              hasFeeQuote: !!feeQuote,
+            })
+
+            logger.console.log(
+              "[trails-sdk] NOTE: Client-side meta transaction submission deprecated",
+              {
+                metaTxnId,
+                chainId: intent.metaTxns[0].chainId,
+                walletAddress: intent.metaTxns[0].walletAddress,
+                contract: intent.metaTxns[0].contract,
+                message:
+                  "Transaction submission now handled by backend via executeIntent. Monitoring via WaitIntentReceipt API.",
+              },
+            )
+
+            logger.console.log(
+              "[trails-sdk] Origin meta transaction sent successfully",
+              {
+                metaTxnId,
+              },
+            )
+
+            // Note: Unified polling will be started after deposit transaction is submitted
+          } else {
+            logger.console.warn(
+              "[trails-sdk] Skipping origin sendMetaTxn - missing metaTxn or precondition",
+              {
+                hasMetaTxn: !!intent.metaTxns[0],
+                hasPrecondition: !!intent.preconditions[0],
+              },
+            )
+          }
+        }
+
+        const destinationSendMetaTxnPromise = async () => {
+          logger.console.log(
+            "[trails-sdk] Starting destinationSendMetaTxnPromise",
+            {
+              quoteProvider: intent.quote.quoteProvider,
+              hasQuoteProviderRequestId: !!intent.quote.quoteProviderRequestId,
+              hasPrecondition1: !!intent.preconditions[1],
+              hasMetaTxn1: !!intent.metaTxns[1],
+            },
+          )
+
+          // Destination meta transactions are handled by the unified poller
+          // which will be started after the deposit transaction is submitted
+          logger.console.log(
+            "[trails-sdk] Destination meta transaction monitoring will be handled by unified poller",
+          )
+        }
+
+        let queueCctpPromise: (() => Promise<void>) | null = null
+
+        const isCctp = intent.quote.quoteProvider === "cctp"
+        if (isCctp) {
+          queueCctpPromise = async () => {
+            while (true) {
+              // Check if we should abort
+              if (abortSignal?.aborted) {
+                logger.console.log(
+                  "[trails-sdk] Aborting CCTP queue due to abort signal",
+                )
+                return
+              }
+
+              const originMetaTxnHash = (
+                originMetaTxnReceipt as MetaTxnReceipt | null
+              )?.txnHash
+              if (originMetaTxnHash) {
+                await queueCCTPTransfer({
+                  trailsClient,
+                  sourceTxHash: originMetaTxnHash,
+                  sourceChainId: originChainId,
+                  destinationChainId: destinationChainId,
+                })
+                break
+              }
+              await new Promise((resolve) =>
+                setTimeout(resolve, POLLING_INTERVALS.CCTP_QUEUE),
+              )
+            }
+          }
+        } else {
+          queueCctpPromise = () => Promise.resolve()
+        }
+
+        // Only start polling for external deposits if needed:
+        // - QR code or exchange funding (external deposits)
+        // - Gasless flow (relayer-executed deposits)
+        const needsDepositPolling =
+          fundMethod === "qr-code" ||
+          fundMethod === "exchange" ||
+          effectiveGasless === true
+
+        if (needsDepositPolling) {
+          logger.console.log(
+            "[trails-sdk] Starting deposit polling for fundMethod:",
+            fundMethod,
+            "effectiveGasless:",
+            effectiveGasless,
+          )
+          checkForDepositTx().catch((error) => {
+            logger.console.error("Error checking for deposit tx", error)
+          })
+        } else {
+          logger.console.log(
+            "[trails-sdk] Skipping deposit polling for wallet funding with gas fees",
+          )
+        }
+
+        // Phase 1: Send meta transactions and queue CCTP
+        logger.console.log(
+          "[trails-sdk] Starting Phase 1: Sending meta transactions and queuing CCTP",
+        )
+
+        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 via unified poller",
+          )
+          // The unified poller handles origin transaction discovery and decoding via callbacks
+          // We just need to wait for it to complete
+          if (unifiedPollerPromise) {
+            try {
+              await unifiedPollerPromise
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk] Error waiting for unified poller:",
+                error,
+              )
+            }
+          }
+        }
+
+        const waitForDestinationMetaTxnReceiptPromise = async () => {
+          logger.console.log(
+            "[trails-sdk] Waiting for destination meta transaction receipt via unified poller",
+          )
+          // The unified poller handles destination transaction discovery and decoding via callbacks
+          // We just need to wait for it to complete
+          if (unifiedPollerPromise) {
+            try {
+              await unifiedPollerPromise
+            } catch (error) {
+              logger.console.error(
+                "[trails-sdk] Error waiting for unified poller:",
+                error,
+              )
+            }
+          }
+        }
+
+        logger.console.log(
+          "[trails-sdk] Executing Phase 2: First executing deposit",
+        )
+        logger.console.log(
+          "[trails-sdk] About to call depositPromise - fundMethod is:",
+          fundMethod,
+        )
+
+        // Execute deposit first to get the transaction receipt and call executeIntent
+        await depositPromise()
+
+        // Start unified polling after deposit transaction is submitted and executeIntent is called
+        // This ensures the backend has received the executeIntent call before we start polling waitIntentReceipt
+        logger.console.log(
+          "[trails-sdk] Starting unified polling after executeIntent has been called",
+        )
+        startUnifiedPolling()
+
+        // Now wait for all the receipts and CCTP processing
+        logger.console.log(
+          "[trails-sdk] Waiting for origin/destination receipts and CCTP processing",
+        )
+        await Promise.all([
+          waitForOriginMetaTxnReceiptPromise(),
+          waitForDestinationMetaTxnReceiptPromise(),
+          queueCctpPromise(),
+        ])
+        logger.console.log("[trails-sdk] Phase 2 completed successfully")
+
+        // Track payment completion for different chain and different token
+        // In gasless mode, we don't have depositUserTxnReceipt since it's handled by backend
+        // For same-chain, we don't have a destination meta transaction, only origin
+        // For cross-chain, we need both origin and destination meta transactions
+        const isDestinationCrossChain = originChainId !== destinationChainId
+        const isSameChain = originChainId === destinationChainId
+        const hasRequiredReceipts =
+          (depositUserTxnReceipt || effectiveGasless) &&
+          (isDestinationCrossChain
+            ? destinationMetaTxnReceipt
+            : isSameChain
+              ? originMetaTxnReceipt
+              : destinationMetaTxnReceipt)
+
+        if (hasRequiredReceipts) {
+          // Check if any transaction failed or was refunded
+          const hasAnyCallFailed = transactionStates.some((tx) =>
+            tx?.decodedGuestModuleEvents?.some(
+              (e: any) => e?.type === "CallFailed",
+            ),
+          )
+          const hasAnyRefunded = transactionStates.some((tx) => tx?.refunded)
+          const txStatus =
+            !hasAnyCallFailed && !hasAnyRefunded ? "success" : "fail"
+
+          // Always track payment completion regardless of success/failure
+          trackPaymentCompleted({
+            userAddress: account.address,
+            originIntentAddress,
+            originTxHash: depositUserTxnReceipt
+              ? (depositUserTxnReceipt as TransactionReceipt).transactionHash
+              : undefined,
+            destinationTxHash: (
+              destinationMetaTxnReceipt as unknown as MetaTxnReceipt
+            )?.txnHash,
+            originChainId,
+            destinationChainId,
+            mode,
+            fundMethod,
+            originTokenSymbol,
+            originTokenAddress,
+            destinationTokenAddress,
+            destinationTokenSymbol,
+            depositTokenAmountUsd: depositAmountUsd?.toString(),
+            destinationTokenAmountUsd:
+              effectiveDestinationTokenAmountUsd?.toString(),
+          })
+
+          // Call onCheckoutComplete callback with transaction status
+          if (checkoutOnHandlers?.triggerCheckoutComplete) {
+            checkoutOnHandlers.triggerCheckoutComplete(
+              txStatus,
+              account.address,
+            )
+          }
+        } 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",
+            )
+          }
+        }
+
+        return {
+          depositUserTxnReceipt,
+          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
+        trackPaymentError({
+          error: errorMessage,
+          userAddress: account.address,
+          originIntentAddress,
+          mode,
+          fundMethod,
+          originChainId,
+          destinationChainId,
+          originTokenSymbol,
+          originTokenAddress,
+          destinationTokenAddress,
+          destinationTokenSymbol,
+        })
+
+        // Call onCheckoutError callback if provided
+        if (checkoutOnHandlers?.triggerCheckoutError) {
+          checkoutOnHandlers.triggerCheckoutError(errorMessage)
+        }
+
+        // Re-throw the error so caller can handle if needed
+        throw error
+      }
+    },
+  }
+}