0xtrails 0.13.1 → 0.14.0

package/src/transactionIntent/handlers/intentHandler.ts

@@ -1,1596 +0,0 @@
-import type {
-  Account,
-  Chain,
-  PublicClient,
-  WalletClient,
-  TransactionReceipt,
-} from "viem"
-import { formatUnits } from "viem"
-import {
-  type FeeOption,
-  type TrailsApi,
-  type RouteProvider,
-  type Intent,
-  type CommitIntentResponse,
-  type DepositSignature,
-  type ExecuteIntentResponse,
-  type GasFeeOptions,
-  type DepositTransaction,
-  type IntentTransaction,
-  type TrailsContracts,
-  IntentProtocolVersion,
-  IntentStatus,
-} from "@0xtrails/api"
-import type { PrepareSendReturn, SendReturn, FundMethod } from "../types.js"
-import {
-  isExternalFundingMethod,
-  TradeType,
-  toApiFundMethod,
-} from "../types.js"
-import type { QueryClient } from "@tanstack/react-query"
-import type { TransactionState } from "../../transactions.js"
-import type { CheckoutOnHandlers } from "../../widget/hooks/useCheckout.js"
-import { logger } from "../../logger.js"
-import { getNormalizedQuoteObject } from "../quote/normalizeQuote.js"
-import { getChainInfo, getChainRpcClient } from "../../chains.js"
-import { getTransactionStateFromReceipt } from "../execution/transactionState.js"
-import { getIntentArgs } from "../quote/quoteHelpers.js"
-import {
-  quoteIntent,
-  commitIntent,
-  sendOriginTransaction,
-  executeIntent as executeIntentRequest,
-} from "../../intents.js"
-import {
-  decodeTokenSweeperEvents,
-  decodeGuestModuleEvents,
-} from "../../decoders.js"
-import { updatePersistentToast } from "../../toast.js"
-import { formatRawAmount, rawAmountToNumber } from "../../utils/format.js"
-import { invalidateTokenBalancesCache } from "../../query/balance.queries.js"
-import { calcAmountUsdPrice } from "../../utils/format.js"
-import { checkAccountBalance } from "../utils/balanceChecker.js"
-import { queryClient as defaultQueryClient } from "../../query/client.js"
-import {
-  getFeesFromIntent,
-  getPriceImpactFromIntent,
-  getPriceImpactUsdFromIntent,
-} from "../quote/feeExtractors.js"
-import { attemptUserDepositTx } from "../deposits/depositOrchestrator.js"
-import { getTxTimeDiff } from "../../transactions.js"
-import { pollIntentReceipt } from "../../intentReceiptPoller.js"
-import {
-  trackPaymentCompleted,
-  trackPaymentError,
-  trackTransactionConfirmed,
-} from "../../analytics.js"
-import { getFullErrorMessage, getIsAlreadyExecutingError } from "../../error.js"
-import { getIsCustomCalldata } from "../../contractUtils.js"
-import { isNativeToken } from "../../utils/address.js"
-import { ensureErc20Approval } from "../utils/erc20Approval.js"
-import { HOUR_MS } from "../../utils/time.js"
-import { attemptSwitchChain } from "../../chainSwitch.js"
-import { getDoGasless } from "../deposits/gaslessDeposit.js"
-import {
-  applyIntentReceiptToTransactionStates,
-  getNormalizedTransactionStates,
-  insertRefundTransactionState,
-  updateTransactionStateWithDecodedEvents,
-} from "../helpers/transactionStateHelpers.js"
-import { isSameChain, isSameToken } from "../validators.js"
-import { isSyntheticTransactionHash } from "../../transactions.js"
-
-/**
- * Parameters for the unified intent handler.
- */
-export interface IntentHandlerParams {
-  queryClient?: QueryClient
-  mainSignerAddress: string
-  originChainId: number
-  originTokenAddress: string
-  originTokenBalance: string
-  originTokenDecimals: number
-  originTokenSymbol: string
-  destinationChainId: number
-  destinationTokenAddress: string
-  destinationTokenSymbol: string
-  destinationTokenDecimals: number
-  swapAmount: string
-  recipient: string
-  destinationApproveAddress?: string
-  destinationCalldata?: string
-  walletClient: WalletClient
-  publicClient: PublicClient
-  account: Account
-  chain: Chain
-  onTransactionStateChange: (transactionStates: TransactionState[]) => void
-  transactionStates: TransactionState[]
-  trailsClient: TrailsApi
-  sourceTokenPriceUsd?: number | null
-  destinationTokenPriceUsd?: number | null
-  originNativeTokenPriceUsd?: number | null
-  slippageTolerance: string | null
-  tradeType?: TradeType
-  swapProvider?: RouteProvider | null
-  bridgeProvider?: RouteProvider | null
-  swapProviderFallback?: boolean
-  bridgeProviderFallback?: boolean
-  fundMethod?: FundMethod
-  mode?: "pay" | "fund" | "earn" | "swap" | "withdraw"
-  checkoutOnHandlers?: Partial<CheckoutOnHandlers>
-  paymasterUrl?: string
-  selectedFeeOption?: FeeOption | null
-  walletId?: string
-  abortSignal?: AbortSignal
-  commitIntentFn?: (intent: Intent) => Promise<CommitIntentResponse>
-  executeIntentFn?: (params: {
-    intentId: string
-    depositTransactionHash?: string
-    depositSignature?: DepositSignature
-  }) => Promise<ExecuteIntentResponse>
-  sequenceProjectAccessKey?: string
-  sequenceIndexerUrl?: string
-  isSmartWallet?: boolean
-  isSenderContractOnOrigin?: boolean | null
-  trailsApiKey?: string
-  trailsApiUrl?: string
-  sequenceMetadataUrl?: string
-  refundAddress?: string
-}
-
-function isFeeSelectionPassthroughEligible(params: {
-  selectedFeeOption: FeeOption | null | undefined
-  gasFeeOptions: GasFeeOptions | undefined
-}): boolean {
-  const { selectedFeeOption, gasFeeOptions } = params
-
-  // Undefined means no explicit user selection yet: stay conservative and use intent flow.
-  if (selectedFeeOption === undefined) {
-    return false
-  }
-
-  // Null means "native fee selected". This is only passthrough-safe if the native fee option
-  // advertised by backend is explicitly marked passthrough-eligible.
-  if (selectedFeeOption === null) {
-    const nativeFeeOption = gasFeeOptions?.feeOptions?.find((option) =>
-      isNativeToken(option.tokenAddress),
-    )
-    return nativeFeeOption?.isPassthroughEligible === true
-  }
-
-  return selectedFeeOption.isPassthroughEligible === true
-}
-
-/**
- * Execute a passthrough transaction (direct transfer, no intents).
- *
- * Used when backend marks quote passthrough-eligible and client-side fee gating allows it.
- * Handles ERC20 approval if needed for custom calldata scenarios (S4c).
- * See SPEC.md for flow decision details.
- */
-async function executePassthrough(
-  params: IntentHandlerParams,
-  depositTransaction: DepositTransaction,
-  transactionStates: TransactionState[],
-  options: {
-    onOriginSend?: () => void
-    depositTransactionHash?: string
-  },
-): Promise<SendReturn> {
-  const {
-    queryClient: paramQueryClient,
-    account,
-    walletClient,
-    onTransactionStateChange,
-    originTokenDecimals,
-    originTokenSymbol,
-    destinationTokenSymbol,
-    swapAmount,
-    destinationCalldata,
-    sourceTokenPriceUsd,
-    mode,
-    fundMethod = "wallet",
-    checkoutOnHandlers,
-    walletId,
-  } = params
-
-  const effectiveQueryClient = paramQueryClient ?? defaultQueryClient
-
-  const { onOriginSend, depositTransactionHash } = options
-
-  const effectiveOriginChain = params.chain
-  const effectiveOriginChainId = effectiveOriginChain.id
-  const effectivePublicClient =
-    params.publicClient ?? getChainRpcClient(effectiveOriginChain.id)
-
-  const depositAmountFormatted = Number(
-    formatUnits(BigInt(swapAmount), originTokenDecimals),
-  )
-  const depositAmountUsd = calcAmountUsdPrice({
-    amount: depositAmountFormatted,
-    usdPrice: sourceTokenPriceUsd,
-  })
-
-  // Update transaction state to pending
-  if (transactionStates[0]) {
-    transactionStates[0].state = "pending"
-    try {
-      onTransactionStateChange(transactionStates)
-    } catch (error) {
-      logger.console.error(
-        "[trails-sdk] Error calling onTransactionStateChange:",
-        error,
-      )
-    }
-  }
-
-  // Show persistent toast
-  updatePersistentToast(
-    "Payment Started",
-    "Waiting for wallet confirmation...",
-    "info",
-  )
-
-  // Validate chainId before sending
-  if (depositTransaction.chainId !== effectiveOriginChainId) {
-    throw new Error(
-      `Chain ID mismatch: expected ${effectiveOriginChainId}, got ${depositTransaction.chainId}`,
-    )
-  }
-
-  // Read ALL fields from passthrough depositTransaction
-  const { to, data, value, chainId } = depositTransaction
-
-  logger.console.log(
-    "[trails-sdk] Executing passthrough with depositTransaction:",
-    {
-      to,
-      data,
-      value,
-      chainId,
-    },
-  )
-
-  // Handle ERC20 approval for passthrough transactions with custom calldata.
-  // This is needed when the passthrough target contract (e.g., Aave) needs to
-  // transferFrom the user's tokens.
-  const originTokenAddress = params.originTokenAddress
-  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-  const isErc20Token = !isNativeToken(originTokenAddress)
-
-  if (isErc20Token && hasCustomCalldata) {
-    await ensureErc20Approval({
-      tokenAddress: originTokenAddress,
-      spender: to,
-      requiredAmount: BigInt(swapAmount),
-      account,
-      publicClient: effectivePublicClient,
-      walletClient,
-      chain: effectiveOriginChain,
-      depositAmountUsd,
-      checkoutOnHandlers,
-      logPrefix: "[trails-sdk] [passthrough]",
-    })
-  }
-
-  let effectiveDepositTransactionHash = depositTransactionHash
-
-  if (!effectiveDepositTransactionHash) {
-    effectiveDepositTransactionHash = await sendOriginTransaction(
-      account,
-      walletClient,
-      {
-        to,
-        data: data as `0x${string}`,
-        value: BigInt(value),
-        chain: effectiveOriginChain,
-      },
-      {
-        transactionType: "origin_call",
-        depositTokenAmountUsd: depositAmountUsd?.toString(),
-      },
-    )
-  }
-  const finalDepositTransactionHash =
-    effectiveDepositTransactionHash as `0x${string}`
-
-  if (onOriginSend) {
-    onOriginSend()
-  }
-
-  // Wait for transaction receipt
-  const receipt = await effectivePublicClient.waitForTransactionReceipt({
-    hash: finalDepositTransactionHash,
-    onReplaced: (replacement) => {
-      logger.console.log(
-        "[trails-sdk] Passthrough deposit transaction replaced",
-        {
-          reason: replacement.reason,
-          replacedHash: replacement.replacedTransaction.hash,
-          replacementHash: replacement.transaction.hash,
-        },
-      )
-    },
-  })
-  logger.console.log("[trails-sdk] Passthrough receipt:", receipt)
-
-  // Track transaction confirmation
-  trackTransactionConfirmed({
-    transactionHash: finalDepositTransactionHash,
-    chainId: effectiveOriginChainId,
-    userAddress: account.address,
-    blockNumber: Number(receipt.blockNumber),
-    originTokenAddress: params.originTokenAddress,
-    depositTokenAmountUsd: depositAmountUsd,
-  })
-
-  // Update toast
-  const chainInfo = getChainInfo(effectiveOriginChainId)
-  updatePersistentToast(
-    "Transfer Confirmed",
-    `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
-    "info",
-  )
-
-  // Update transaction state to completed with decoded events
-  const updatedStates = updateTransactionStateWithDecodedEvents(
-    transactionStates,
-    transactionStates[0]?.label || "Execute",
-    receipt,
-    effectiveOriginChainId,
-  )
-  onTransactionStateChange(updatedStates)
-
-  // Track payment completion
-  if (receipt.status === "success") {
-    trackPaymentCompleted({
-      userAddress: account.address,
-      originTxHash: receipt.transactionHash,
-      originChainId: effectiveOriginChainId,
-      mode,
-      fundMethod,
-      originTokenAddress: params.originTokenAddress,
-      originTokenSymbol,
-      originTokenAmount: swapAmount,
-      originTokenAmountFormatted: depositAmountFormatted.toString(),
-      destinationTokenAddress: params.originTokenAddress,
-      destinationTokenSymbol,
-      depositTokenAmount: swapAmount,
-      depositTokenAmountFormatted: depositAmountFormatted.toString(),
-      depositTokenAmountUsd: depositAmountUsd,
-      destinationTokenAmount: swapAmount,
-      destinationTokenAmountFormatted: depositAmountFormatted.toString(),
-      destinationTokenAmountUsd: depositAmountUsd,
-      originTokenDecimals,
-      destinationTokenDecimals: originTokenDecimals,
-      walletId,
-      destinationCalldata,
-    })
-
-    invalidateTokenBalancesCache(undefined, effectiveQueryClient)
-
-    if (checkoutOnHandlers?.triggerCheckoutComplete) {
-      checkoutOnHandlers.triggerCheckoutComplete("success", account.address)
-    }
-  } else {
-    trackPaymentError({
-      error: "Transaction failed",
-      userAddress: account.address,
-      mode,
-      fundMethod,
-      originTokenAddress: params.originTokenAddress,
-    })
-
-    invalidateTokenBalancesCache(undefined, effectiveQueryClient)
-
-    if (checkoutOnHandlers?.triggerCheckoutError) {
-      checkoutOnHandlers.triggerCheckoutError("Transaction failed")
-    }
-  }
-
-  return {
-    depositUserTxnReceipt: receipt,
-    originIntentTransaction: null,
-    destinationIntentTransaction: null,
-  }
-}
-
-/**
- * Execute an intent flow (commit, deposit, poll).
- */
-async function executeIntent(
-  params: IntentHandlerParams,
-  intent: Intent,
-  localTransactionStates: TransactionState[],
-  gasFeeOptions: GasFeeOptions | undefined,
-  trailsContracts: TrailsContracts,
-  options: {
-    onOriginSend?: () => void
-    selectedFeeOption?: FeeOption | null
-    depositTransactionHash?: string
-    skipCommit?: boolean
-  },
-): Promise<SendReturn> {
-  const {
-    queryClient: paramQueryClient,
-    account,
-    walletClient,
-    onTransactionStateChange,
-    originTokenDecimals,
-    originTokenSymbol,
-    destinationTokenSymbol,
-    swapAmount,
-    destinationCalldata,
-    sourceTokenPriceUsd,
-    destinationTokenPriceUsd,
-    mode,
-    fundMethod = "wallet",
-    checkoutOnHandlers,
-    walletId,
-    trailsClient,
-    paymasterUrl,
-    abortSignal,
-    executeIntentFn,
-    destinationTokenDecimals,
-    swapProvider,
-    bridgeProvider,
-    tradeType,
-  } = params
-
-  const effectiveQueryClient = paramQueryClient ?? defaultQueryClient
-
-  const {
-    onOriginSend,
-    selectedFeeOption: runtimeSelectedFeeOption,
-    depositTransactionHash,
-  } = options
-
-  const effectiveSelectedFeeOption = runtimeSelectedFeeOption
-
-  const effectiveOriginChain = params.chain
-  const effectiveOriginChainId = effectiveOriginChain.id
-  const effectivePublicClient = getChainRpcClient(effectiveOriginChain.id)
-  const effectiveOriginTokenAddress = params.originTokenAddress
-
-  const isToSameChain = isSameChain(
-    params.originChainId,
-    params.destinationChainId,
-  )
-  const isToSameToken = isSameToken(
-    params.originTokenAddress,
-    params.destinationTokenAddress,
-  )
-  const isSameChainSameToken = isToSameChain && isToSameToken
-
-  // API is source of truth for deposit amount
-  const depositAmount = intent.depositTransaction.amount.toString()
-
-  const depositAmountFormatted = formatRawAmount(
-    depositAmount,
-    originTokenDecimals,
-  )
-  const depositAmountNumeric = rawAmountToNumber(
-    depositAmount,
-    originTokenDecimals,
-  )
-  const depositAmountUsd = calcAmountUsdPrice({
-    amount: depositAmountNumeric,
-    usdPrice: sourceTokenPriceUsd,
-  })
-
-  let depositUserTxnReceipt: TransactionReceipt | null = null
-  let originIntentTransaction: IntentTransaction | null = null
-  let destinationIntentTransaction: IntentTransaction | null = null
-  let hasExecutedIntentEarly = false
-
-  // Create destination public client for cross-chain polling
-  const destinationPublicClient = getChainRpcClient(params.destinationChainId)
-
-  const shouldUseGaslessFlow =
-    fundMethod === "wallet" &&
-    (getDoGasless(
-      effectiveOriginTokenAddress,
-      gasFeeOptions,
-      effectiveSelectedFeeOption,
-      walletId,
-    ) ||
-      Boolean(paymasterUrl))
-
-  // Signal executeIntent immediately after commit for all funding flows.
-  if (intent.intentId && !shouldUseGaslessFlow) {
-    try {
-      if (executeIntentFn) {
-        await executeIntentFn({
-          intentId: intent.intentId,
-        })
-      } else {
-        await executeIntentRequest(trailsClient, intent.intentId, undefined)
-      }
-      hasExecutedIntentEarly = true
-      logger.console.log(
-        "[trails-sdk] executeIntent called immediately after commit",
-        {
-          intentId: intent.intentId,
-          fundMethod,
-          depositTransactionHash,
-        },
-      )
-    } catch (executeError: unknown) {
-      if (getIsAlreadyExecutingError(executeError)) {
-        hasExecutedIntentEarly = true
-        logger.console.log(
-          "[trails-sdk] Intent already executing after early executeIntent call",
-        )
-      } else {
-        throw executeError
-      }
-    }
-  } else if (intent.intentId && shouldUseGaslessFlow) {
-    logger.console.log(
-      "[trails-sdk] Skipping early executeIntent for gasless flow, waiting for deposit signature",
-      {
-        intentId: intent.intentId,
-        fundMethod,
-        hasPaymasterUrl: Boolean(paymasterUrl),
-        hasSelectedFeeOption: effectiveSelectedFeeOption !== undefined,
-      },
-    )
-  }
-
-  // External funding flows without a client-provided deposit hash should return
-  // immediately after commit/early execute. Their UI will monitor balance at the
-  // origin intent address and continue independently of this send() call.
-  const publishTransactionStates = (states: TransactionState[]) => {
-    onTransactionStateChange(states)
-    if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
-      checkoutOnHandlers.triggerCheckoutStatusUpdate(states)
-    }
-  }
-
-  if (isExternalFundingMethod(fundMethod) && !depositTransactionHash) {
-    publishTransactionStates(localTransactionStates)
-
-    logger.console.log(
-      "[trails-sdk] External funding flow: intent committed, returning early",
-      {
-        fundMethod,
-        intentId: intent.intentId,
-      },
-    )
-    return {
-      depositUserTxnReceipt: null,
-      originIntentTransaction: null,
-      destinationIntentTransaction: null,
-      totalCompletionSeconds: 0,
-    }
-  }
-
-  // Balance check for wallet fund method
-  if (fundMethod === "wallet") {
-    const { hasEnoughBalance, balanceError } = await checkAccountBalance({
-      account,
-      tokenAddress: effectiveOriginTokenAddress,
-      depositAmount,
-      publicClient: effectivePublicClient,
-    })
-
-    if (!hasEnoughBalance) {
-      throw balanceError
-    }
-  }
-
-  // Switch chain if needed
-  await attemptSwitchChain({
-    walletClient,
-    desiredChainId: effectiveOriginChainId,
-  })
-
-  // Set up transaction state tracking
-  publishTransactionStates(localTransactionStates)
-
-  if (!intent.intentProtocolVersion) {
-    logger.console.log(
-      "[trails-sdk] [intent-protocol] Intent protocol version not found in response, defaulting to v1",
-    )
-  }
-  const intentProtocolVersion =
-    intent.intentProtocolVersion ?? IntentProtocolVersion.v1
-
-  logger.console.log(
-    "[trails-sdk] [intent-protocol] === Intent Protocol Version ===",
-    {
-      version: intentProtocolVersion,
-      isV1: intentProtocolVersion === IntentProtocolVersion.v1,
-      isV1_5: intentProtocolVersion === IntentProtocolVersion.v1_5,
-      intentId: intent.intentId,
-      fundMethod,
-    },
-  )
-
-  // Execute deposit transaction
-  if (depositTransactionHash && fundMethod !== "wallet") {
-    // External deposit with provided hash (onramp-meld, direct-transfer, etc.)
-    let resolvedDepositTransactionHash = depositTransactionHash as `0x${string}`
-    depositUserTxnReceipt =
-      await effectivePublicClient.waitForTransactionReceipt({
-        hash: depositTransactionHash as `0x${string}`,
-        onReplaced: (replacement) => {
-          resolvedDepositTransactionHash = replacement.transaction.hash
-          logger.console.log(
-            "[trails-sdk] External deposit transaction replaced",
-            {
-              reason: replacement.reason,
-              replacedHash: replacement.replacedTransaction.hash,
-              replacementHash: replacement.transaction.hash,
-            },
-          )
-        },
-      })
-
-    if (depositUserTxnReceipt?.transactionHash) {
-      resolvedDepositTransactionHash =
-        depositUserTxnReceipt.transactionHash as `0x${string}`
-    }
-
-    logger.console.log("[trails-sdk] External deposit receipt resolved", {
-      providedHash: depositTransactionHash,
-      resolvedHash: resolvedDepositTransactionHash,
-      status: depositUserTxnReceipt.status,
-    })
-
-    // Update transaction state with receipt
-    if (depositUserTxnReceipt) {
-      localTransactionStates[0] = getTransactionStateFromReceipt(
-        depositUserTxnReceipt,
-        effectiveOriginChainId,
-        localTransactionStates[0]?.label,
-      )
-      publishTransactionStates(localTransactionStates)
-    }
-
-    if (depositUserTxnReceipt.status === "success" && intent.intentId) {
-      // Always signal external deposit success so UI can navigate to pending.
-      if (onOriginSend) {
-        logger.console.log(
-          "[trails-sdk] Calling onOriginSend for external deposit",
-        )
-        onOriginSend()
-      }
-
-      if (hasExecutedIntentEarly) {
-        // Intent execution was already triggered immediately after commit.
-        // Skip the duplicate executeIntent call, but continue into receipt polling.
-      } else {
-        // Try to execute the intent if early execution didn't run.
-        try {
-          if (executeIntentFn) {
-            await executeIntentFn({
-              intentId: intent.intentId,
-            })
-          } else {
-            await executeIntentRequest(trailsClient, intent.intentId, undefined)
-          }
-        } catch (executeError: unknown) {
-          // If intent is already executing, that's fine - it means the system picked it up
-          if (getIsAlreadyExecutingError(executeError)) {
-            logger.console.log(
-              "[trails-sdk] Intent already executing, continuing...",
-            )
-          } else {
-            throw executeError
-          }
-        }
-      }
-    }
-  } else if (fundMethod === "wallet") {
-    // Wallet deposit
-    depositUserTxnReceipt = await attemptUserDepositTx({
-      queryClient: effectiveQueryClient,
-      originTokenAddress: effectiveOriginTokenAddress,
-      paymasterUrl,
-      chain: effectiveOriginChain,
-      account,
-      depositAmount,
-      originIntentAddress: intent.originIntentAddress,
-      onOriginSend,
-      publicClient: effectivePublicClient,
-      walletClient,
-      destinationTokenDecimals,
-      sourceTokenDecimals: originTokenDecimals,
-      sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
-      destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
-      swapAmount,
-      onTransactionStateChange,
-      transactionStates: localTransactionStates,
-      fundMethod,
-      originTokenSymbol,
-      destinationTokenSymbol,
-      depositAmountUsd,
-      feeOptions: gasFeeOptions,
-      trailsContracts,
-      trailsClient,
-      selectedFeeOption: effectiveSelectedFeeOption,
-      walletId,
-      abortSignal,
-      checkoutOnHandlers,
-      intentId: intent.intentId,
-      executeIntentFn,
-      isSameChainSameToken,
-      destinationCalldata,
-      depositTransaction: intent.depositTransaction,
-      intentProtocolVersion,
-    })
-
-    // Update state and call executeIntent
-    if (depositUserTxnReceipt) {
-      localTransactionStates[0] = getTransactionStateFromReceipt(
-        depositUserTxnReceipt,
-        effectiveOriginChainId,
-        localTransactionStates[0]?.label,
-      )
-
-      // Decode events
-      try {
-        localTransactionStates[0].decodedTokenSweeperEvents =
-          decodeTokenSweeperEvents(depositUserTxnReceipt)
-        localTransactionStates[0].decodedGuestModuleEvents =
-          decodeGuestModuleEvents(depositUserTxnReceipt)
-        localTransactionStates[0].refunded =
-          localTransactionStates[0].decodedTokenSweeperEvents.findIndex(
-            (event) =>
-              event.type === "Refund" || event.type === "RefundAndSweep",
-          ) !== -1
-      } catch (error) {
-        logger.console.error(
-          "[trails-sdk] Error decoding deposit events",
-          error,
-        )
-      }
-
-      publishTransactionStates(localTransactionStates)
-    }
-  }
-  // Start polling for intent completion to update transaction states
-  let finalReceipt: Awaited<ReturnType<typeof pollIntentReceipt>> = null
-  let pollStartMs = 0
-  if (intent.intentId) {
-    // Determine max wait time based on route provider.
-    // OFT routes (LayerZero OFT) can take 5-10+ minutes to complete.
-    const isOFTRoute = intent.quote?.routeProviders?.some((p) => p === "LZ_OFT")
-    const maxWaitTime = isOFTRoute ? HOUR_MS : 10 * 60 * 1000 // 1 hour for OFT, 10 min for others
-
-    logger.console.log("[trails-sdk] Intent polling configuration:", {
-      isOFTRoute,
-      maxWaitTime,
-      routeProviders: intent.quote?.routeProviders,
-    })
-    try {
-      pollStartMs = Date.now()
-      finalReceipt = await pollIntentReceipt({
-        intentId: intent.intentId,
-        trailsClient,
-        abortSignal,
-        callbacks: {
-          onDepositTransactionFound: async (txHash, receipt) => {
-            logger.console.log(
-              "[trails-sdk] Deposit transaction found:",
-              txHash,
-            )
-
-            if (localTransactionStates[0]) {
-              if (isSyntheticTransactionHash(txHash)) {
-                logger.console.log(
-                  "[trails-sdk] Deposit transaction hash is synthetic, marking deposit from status",
-                  {
-                    txHash,
-                    status: receipt.depositTransaction?.status,
-                  },
-                )
-
-                if (receipt.depositTransaction?.status === "SUCCEEDED") {
-                  localTransactionStates[0] = {
-                    ...localTransactionStates[0],
-                    state: "confirmed",
-                    transactionHash: "",
-                    explorerUrl: "",
-                    txnMinedAt:
-                      receipt.depositTransaction?.txnMinedAt || undefined,
-                  }
-
-                  publishTransactionStates(localTransactionStates)
-                }
-                return
-              }
-
-              try {
-                const depositTxReceipt =
-                  await effectivePublicClient.getTransactionReceipt({
-                    hash: txHash as `0x${string}`,
-                  })
-
-                localTransactionStates[0] = getTransactionStateFromReceipt(
-                  depositTxReceipt,
-                  effectiveOriginChainId,
-                  localTransactionStates[0]?.label,
-                )
-
-                // Decode events
-                localTransactionStates[0].decodedTokenSweeperEvents =
-                  decodeTokenSweeperEvents(depositTxReceipt)
-                localTransactionStates[0].decodedGuestModuleEvents =
-                  decodeGuestModuleEvents(depositTxReceipt)
-
-                publishTransactionStates(localTransactionStates)
-              } catch (error) {
-                logger.console.error(
-                  "[trails-sdk] Error fetching deposit receipt:",
-                  error,
-                )
-              }
-            }
-          },
-          onOriginTransactionFound: async (txHash, receipt) => {
-            logger.console.log("[trails-sdk] Origin transaction found:", txHash)
-
-            originIntentTransaction = { txnHash: txHash } as IntentTransaction
-
-            try {
-              const originTxReceipt =
-                await effectivePublicClient.getTransactionReceipt({
-                  hash: txHash as `0x${string}`,
-                })
-
-              // Find the appropriate index for origin transaction
-              const originStateIndex = localTransactionStates.length > 1 ? 1 : 0
-              if (localTransactionStates[originStateIndex]) {
-                localTransactionStates[originStateIndex] =
-                  getTransactionStateFromReceipt(
-                    originTxReceipt,
-                    effectiveOriginChainId,
-                    localTransactionStates[originStateIndex]?.label,
-                  )
-
-                // Decode events
-                localTransactionStates[
-                  originStateIndex
-                ].decodedTokenSweeperEvents =
-                  decodeTokenSweeperEvents(originTxReceipt)
-                localTransactionStates[
-                  originStateIndex
-                ].decodedGuestModuleEvents =
-                  decodeGuestModuleEvents(originTxReceipt)
-
-                // Some external funding flows do not surface a distinct
-                // depositTransaction in the receipt. In those cases the origin
-                // transaction implicitly covers the deposit step as well.
-                if (
-                  !receipt.depositTransaction?.txnHash &&
-                  !receipt.depositTransaction?.status &&
-                  localTransactionStates.length > 1 &&
-                  localTransactionStates[0]
-                ) {
-                  localTransactionStates[0] = getTransactionStateFromReceipt(
-                    originTxReceipt,
-                    effectiveOriginChainId,
-                    localTransactionStates[0]?.label,
-                  )
-                  localTransactionStates[0].decodedTokenSweeperEvents =
-                    decodeTokenSweeperEvents(originTxReceipt)
-                  localTransactionStates[0].decodedGuestModuleEvents =
-                    decodeGuestModuleEvents(originTxReceipt)
-                }
-
-                publishTransactionStates(localTransactionStates)
-              }
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] Error fetching origin receipt:",
-                error,
-              )
-            }
-          },
-          onDestinationTransactionFound: async (txHash) => {
-            logger.console.log(
-              "[trails-sdk] Destination transaction found:",
-              txHash,
-            )
-
-            destinationIntentTransaction = {
-              txnHash: txHash,
-            } as IntentTransaction
-
-            try {
-              const destinationTxReceipt =
-                await destinationPublicClient.getTransactionReceipt({
-                  hash: txHash as `0x${string}`,
-                })
-
-              // Find the appropriate index for destination transaction
-              const destStateIndex = localTransactionStates.length - 1
-              if (localTransactionStates[destStateIndex]) {
-                localTransactionStates[destStateIndex] =
-                  getTransactionStateFromReceipt(
-                    destinationTxReceipt,
-                    params.destinationChainId,
-                    localTransactionStates[destStateIndex]?.label,
-                  )
-
-                // Decode events
-                localTransactionStates[
-                  destStateIndex
-                ].decodedTokenSweeperEvents =
-                  decodeTokenSweeperEvents(destinationTxReceipt)
-                localTransactionStates[
-                  destStateIndex
-                ].decodedGuestModuleEvents =
-                  decodeGuestModuleEvents(destinationTxReceipt)
-
-                publishTransactionStates(localTransactionStates)
-              }
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] Error fetching destination receipt:",
-                error,
-              )
-            }
-          },
-          onReceiptUpdate: async (receipt, done) => {
-            // Log receipt updates for debugging
-            logger.console.log("[trails-sdk] Receipt update:", {
-              status: receipt.status,
-              done,
-              hasOrigin: !!receipt.originTransaction,
-              hasDestination: !!receipt.destinationTransaction,
-              hasRefund: !!receipt.refundTransaction,
-            })
-
-            const reconciledStates = applyIntentReceiptToTransactionStates({
-              currentStates: localTransactionStates,
-              receipt,
-            })
-            if (reconciledStates.changed) {
-              localTransactionStates = reconciledStates.transactionStates
-              publishTransactionStates(localTransactionStates)
-            }
-
-            // Handle terminal status - mark pending steps as aborted/failed
-            if (
-              done &&
-              (receipt.status === "ABORTED" || receipt.status === "FAILED")
-            ) {
-              const targetState =
-                receipt.status === "ABORTED" ? "aborted" : "failed"
-              const statusReason =
-                receipt.depositTransaction?.statusReason ||
-                receipt.originTransaction?.statusReason ||
-                receipt.destinationTransaction?.statusReason
-
-              for (const state of localTransactionStates) {
-                if (state.state === "pending") {
-                  state.state = targetState as "aborted" | "failed"
-                  if (statusReason) state.statusReason = statusReason
-                }
-              }
-
-              publishTransactionStates(localTransactionStates)
-            }
-
-            // Handle deposit tx revert - mark all txs as failed
-            if (receipt.depositTransaction?.status === "REVERTED") {
-              const statusReason =
-                receipt.depositTransaction.statusReason || "deposit reverted"
-
-              for (const state of localTransactionStates) {
-                if (state.state === "pending") {
-                  state.state = "failed"
-                  state.statusReason = statusReason
-                }
-              }
-
-              publishTransactionStates(localTransactionStates)
-            }
-
-            // Insert refund transaction state if refund exists
-            if (receipt.refundTransaction) {
-              const updatedStates = insertRefundTransactionState(
-                localTransactionStates,
-                {
-                  chainId: receipt.refundTransaction.chainId,
-                  txnHash: receipt.refundTransaction.txnHash,
-                  status: receipt.refundTransaction.status,
-                },
-              )
-
-              // Check if states actually changed (length or content)
-              const statesChanged =
-                updatedStates.length !== localTransactionStates.length ||
-                JSON.stringify(updatedStates) !==
-                  JSON.stringify(localTransactionStates)
-
-              if (statesChanged) {
-                localTransactionStates.length = 0
-                localTransactionStates.push(...updatedStates)
-                publishTransactionStates(localTransactionStates)
-              }
-            }
-          },
-        },
-        maxWaitTime,
-      })
-
-      // Verify the receipt status is terminal before proceeding to success
-      const terminalStatuses: string[] = [
-        IntentStatus.SUCCEEDED,
-        IntentStatus.FAILED,
-        IntentStatus.REFUNDED,
-        IntentStatus.ABORTED,
-      ]
-      const summary = (
-        finalReceipt as unknown as { summary?: { finishedAt?: string | null } }
-      )?.summary
-      const hasFinishedMarker = Boolean(
-        summary?.finishedAt ||
-          finalReceipt?.destinationTransaction?.txnMinedAt ||
-          finalReceipt?.destinationTransaction?.txnHash,
-      )
-      const destinationSucceeded =
-        finalReceipt?.destinationTransaction?.status === "SUCCEEDED"
-      const completeViaDestinationFallback =
-        !!finalReceipt && destinationSucceeded && hasFinishedMarker
-      const isComplete =
-        !!finalReceipt &&
-        (terminalStatuses.includes(finalReceipt.status) ||
-          completeViaDestinationFallback)
-
-      if (!isComplete) {
-        const elapsedMs = pollStartMs > 0 ? Date.now() - pollStartMs : 0
-        const timedOut = elapsedMs >= maxWaitTime
-        const reason = timedOut
-          ? `Intent execution timed out after ${Math.round(maxWaitTime / 60000)} minutes.`
-          : "Unable to confirm final intent status from receipt polling."
-
-        logger.console.warn(
-          "[trails-sdk] Intent polling ended without terminal status",
-          {
-            intentId: intent.intentId,
-            status: finalReceipt?.status,
-            maxWaitTime,
-            elapsedMs,
-            timedOut,
-          },
-        )
-
-        trackPaymentError({
-          error: `${reason} Please check transaction history or query GetIntentReceipt.`,
-          userAddress: account.address,
-          mode,
-          fundMethod,
-          originTokenAddress: params.originTokenAddress,
-        })
-
-        invalidateTokenBalancesCache(undefined, effectiveQueryClient)
-
-        if (checkoutOnHandlers?.triggerCheckoutError) {
-          checkoutOnHandlers.triggerCheckoutError(
-            "Unable to confirm final transaction status",
-          )
-        }
-
-        throw new Error(
-          `${reason} Please check transaction history or query GetIntentReceipt with this intent ID.`,
-        )
-      }
-    } catch (error) {
-      logger.console.error(
-        "[trails-sdk] Error polling for intent receipt:",
-        error,
-      )
-      // Polling failed — outcome is unknown. Do not report success.
-      trackPaymentError({
-        error: `Polling failed: ${getFullErrorMessage(error)}`,
-        userAddress: account.address,
-        mode,
-        fundMethod,
-        originTokenAddress: params.originTokenAddress,
-      })
-
-      invalidateTokenBalancesCache(undefined, effectiveQueryClient)
-
-      if (checkoutOnHandlers?.triggerCheckoutError) {
-        checkoutOnHandlers.triggerCheckoutError(
-          "Unable to confirm transaction status",
-        )
-      }
-
-      throw new Error(
-        `Unable to confirm transaction status: polling for intent receipt failed: ${getFullErrorMessage(error)}`,
-      )
-    }
-  }
-
-  // Check if intent was ABORTED or FAILED
-  if (
-    finalReceipt &&
-    (finalReceipt.status === "ABORTED" || finalReceipt.status === "FAILED")
-  ) {
-    const statusReason = localTransactionStates[0]?.statusReason
-    const errorMsg = statusReason
-      ? `Transaction ${finalReceipt.status.toLowerCase()}: ${statusReason}`
-      : `Transaction ${finalReceipt.status.toLowerCase()}`
-    logger.console.error(
-      `[trails-sdk] Intent ${finalReceipt.status}:`,
-      intent.intentId,
-    )
-
-    trackPaymentError({
-      error: errorMsg,
-      userAddress: account.address,
-      mode,
-      fundMethod,
-      originTokenAddress: params.originTokenAddress,
-    })
-
-    invalidateTokenBalancesCache(undefined, effectiveQueryClient)
-
-    if (checkoutOnHandlers?.triggerCheckoutError) {
-      checkoutOnHandlers.triggerCheckoutError(errorMsg)
-    }
-
-    throw new Error(errorMsg)
-  }
-
-  // Track payment completion
-  const hasAnyCallFailed = localTransactionStates.some((tx) =>
-    tx?.decodedGuestModuleEvents?.some((e: any) => e?.type === "CallFailed"),
-  )
-  const hasAnyRefunded = localTransactionStates.some((tx) => tx?.refunded)
-  const hasAnyFailed = localTransactionStates.some(
-    (tx) => tx?.state === "failed",
-  )
-  const txStatus =
-    !hasAnyCallFailed && !hasAnyRefunded && !hasAnyFailed ? "success" : "fail"
-
-  trackPaymentCompleted({
-    userAddress: account.address,
-    originIntentAddress: intent.originIntentAddress,
-    originTxHash: depositUserTxnReceipt?.transactionHash,
-    destinationTxHash: (
-      destinationIntentTransaction as IntentTransaction | null
-    )?.txnHash,
-    originChainId: params.originChainId,
-    destinationChainId: params.destinationChainId,
-    swapProvider: swapProvider || undefined,
-    bridgeProvider: bridgeProvider || undefined,
-    mode,
-    fundMethod,
-    originTokenAddress: params.originTokenAddress,
-    originTokenSymbol,
-    originTokenAmount: depositAmount,
-    originTokenAmountFormatted: depositAmountFormatted,
-    destinationTokenAddress: params.destinationTokenAddress,
-    destinationTokenSymbol,
-    depositTokenAmount: depositAmount,
-    depositTokenAmountFormatted: depositAmountFormatted,
-    depositTokenAmountUsd: depositAmountUsd,
-    destinationTokenAmount: intent.quote?.toAmount?.toString() || depositAmount,
-    destinationTokenAmountFormatted: formatRawAmount(
-      intent.quote?.toAmount?.toString() || depositAmount,
-      destinationTokenDecimals,
-    ),
-    originTokenDecimals,
-    destinationTokenDecimals,
-    tradeType: tradeType?.toString(),
-    sourceTokenPriceUsd,
-    destinationTokenPriceUsd,
-    walletId,
-    destinationCalldata,
-  })
-
-  invalidateTokenBalancesCache(undefined, effectiveQueryClient)
-
-  if (checkoutOnHandlers?.triggerCheckoutComplete) {
-    checkoutOnHandlers.triggerCheckoutComplete(txStatus, account.address)
-  }
-
-  return {
-    depositUserTxnReceipt,
-    originIntentTransaction,
-    destinationIntentTransaction,
-    totalCompletionSeconds: await getTxTimeDiff(
-      localTransactionStates[0],
-      localTransactionStates[localTransactionStates.length - 1],
-    ),
-  }
-}
-
-/**
- * Unified intent handler that supports both passthrough and intent flows.
- * The backend decides the flow type via `intent.passthrough` flag.
- */
-export async function handleIntent(
-  params: IntentHandlerParams,
-): Promise<PrepareSendReturn> {
-  const {
-    mainSignerAddress,
-    originChainId,
-    originTokenAddress,
-    originTokenBalance,
-    originTokenDecimals,
-    originTokenSymbol,
-    destinationChainId,
-    destinationTokenAddress,
-    destinationTokenSymbol,
-    destinationTokenDecimals,
-    swapAmount,
-    recipient,
-    destinationApproveAddress,
-    destinationCalldata,
-    account,
-    chain,
-    trailsClient,
-    sourceTokenPriceUsd,
-    destinationTokenPriceUsd,
-    originNativeTokenPriceUsd,
-    slippageTolerance,
-    tradeType = TradeType.EXACT_INPUT,
-    swapProvider: initialSwapProvider,
-    bridgeProvider: initialBridgeProvider,
-    swapProviderFallback,
-    bridgeProviderFallback,
-    fundMethod: fundMethodFromParams,
-    mode,
-    checkoutOnHandlers,
-    selectedFeeOption,
-    walletId,
-    abortSignal,
-    commitIntentFn,
-    isSmartWallet,
-    isSenderContractOnOrigin,
-    trailsApiKey,
-    trailsApiUrl,
-    sequenceMetadataUrl,
-  } = params
-
-  logger.console.log("[trails-sdk] handleIntent called")
-
-  const effectiveFundMethod = fundMethodFromParams ?? "wallet"
-  const effectiveOriginChain = chain
-  const effectiveOriginTokenAddress = originTokenAddress
-  const effectivePublicClient =
-    params.publicClient ?? getChainRpcClient(effectiveOriginChain.id)
-
-  const isToSameChain = isSameChain(originChainId, destinationChainId)
-  const isToSameToken = isSameToken(originTokenAddress, destinationTokenAddress)
-  const isSameChainSameToken = isToSameChain && isToSameToken
-
-  const swapProvider = initialSwapProvider
-  const bridgeProvider = initialBridgeProvider
-
-  // SPEC: Same-chain same-token wallet scenarios (C9b/C10/C11b/C12/D9b/D10/D11b/D12) may use passthrough when native gas is selected.
-  // SPEC: Intent-only scenarios (C9a/C11a/D9a/D11a) require gasless fee options or have insufficient allowance.
-  // SPEC: Non-wallet fund methods (C13/C14/D13/D14) must use intent flow to provide deposit addresses.
-  // Balance check is done later after we know the actual deposit amount from the intent API
-  // For cross-token swaps, swapAmount is in destination token units, not origin token units
-  let noSufficientBalance = false
-
-  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-  const isNativeOriginToken = isNativeToken(effectiveOriginTokenAddress)
-
-  // Build intent args
-  // EXACT_OUTPUT: pass swapAmount for both (backend uses destination as target, origin as hint)
-  // EXACT_INPUT: pass swapAmount as origin, 0 as destination (backend calculates destination)
-  const intentArgs = await getIntentArgs(
-    mainSignerAddress,
-    originChainId,
-    originTokenAddress,
-    swapAmount,
-    destinationChainId,
-    destinationTokenAddress,
-    tradeType === TradeType.EXACT_OUTPUT ? swapAmount : "0",
-    recipient,
-    destinationApproveAddress,
-    destinationCalldata,
-    slippageTolerance,
-    tradeType,
-    swapProvider,
-    bridgeProvider,
-    swapProviderFallback,
-    bridgeProviderFallback,
-    undefined,
-    walletId,
-    isSmartWallet,
-    isSenderContractOnOrigin,
-  )
-
-  // For same-chain same-token with native calldata, add call value
-  if (isSameChainSameToken && hasCustomCalldata && isNativeOriginToken) {
-    intentArgs.destinationCallValue = BigInt(swapAmount)
-  }
-
-  // Add fundMethod to intent args for backend passthrough decision
-  intentArgs.fundMethod = toApiFundMethod(effectiveFundMethod)
-
-  logger.console.log("[trails-sdk] Creating intent with args:", intentArgs)
-
-  // Call quoteIntent first to get depositTransaction from API
-  const quoteResult = await quoteIntent(
-    trailsClient,
-    intentArgs,
-    {
-      originTokenSymbol,
-      destinationTokenSymbol,
-      feeTokenSymbol: originTokenSymbol,
-    },
-    abortSignal,
-  )
-
-  const {
-    intent,
-    gasFeeOptions,
-    trailsContracts,
-    passthrough,
-    transactionStates: apiTransactionStates,
-  } = quoteResult
-  logger.console.log("[trails-sdk] Quote intent:", intent)
-  logger.console.log("[trails-sdk] Quote intent gasFeeOptions:", gasFeeOptions)
-  logger.console.log("[trails-sdk] Quote passthrough:", passthrough)
-  logger.console.log(
-    "[trails-sdk] Quote transactionStates:",
-    apiTransactionStates,
-  )
-
-  if (!intent.originPrecondition || !intent.originCalls) {
-    throw new Error("Invalid intent")
-  }
-
-  // Determine if passthrough should be used
-  // SPEC: Only same-chain same-token with wallet fund method may use passthrough (C9b/C10/C11b/C12/D9b/D10/D11b/D12).
-  // SPEC: Cross-chain (A/B), different-token (C1-C8/D1-D8), non-wallet (C13/C14/D13/D14), and gasless (G1-G20) must always use intents.
-  // SPEC: Intent-only scenarios (C9a/C11a/D9a/D11a) cannot use passthrough due to gasless fee options.
-  // Backend sets passthrough.eligible, but we enforce structural invariants client-side as a safety net.
-  // For ERC20 passthrough with custom calldata, the SDK handles approval if insufficient (see executePassthrough).
-  const usePassthrough =
-    effectiveFundMethod === "wallet" &&
-    passthrough?.eligible === true &&
-    !!passthrough?.passthroughTransaction &&
-    isFeeSelectionPassthroughEligible({
-      selectedFeeOption,
-      gasFeeOptions,
-    })
-
-  logger.console.log("[trails-sdk] Passthrough decision:", {
-    usePassthrough,
-    isSameChainSameToken,
-    fundMethod: effectiveFundMethod,
-    passthroughEligible: passthrough?.eligible,
-    hasPassthroughTransaction: !!passthrough?.passthroughTransaction,
-    feeOptionPassthroughEligible: selectedFeeOption?.isPassthroughEligible,
-    selectedFeeOption,
-  })
-
-  // Use passthrough-specific deposit transaction and states when doing passthrough
-  const effectiveDepositTransaction: DepositTransaction | undefined =
-    usePassthrough && passthrough?.passthroughTransaction
-      ? passthrough.passthroughTransaction
-      : intent.depositTransaction
-
-  const depositAmount = effectiveDepositTransaction.amount.toString()
-  const quoteToAmount = intent.quote.toAmount.toString()
-  const quoteToAmountMin = intent.quote.toAmountMin.toString() || quoteToAmount
-
-  // Compute transaction states for both passthrough and intent flows
-  // This allows the UI to switch between them based on fee option selection
-  // SPEC: Passthrough-capable scenarios (C9b/C10/C11b/C12/D9b/D10/D11b/D12) expose passthrough transaction states; other scenarios use intent-flow states.
-  const passthroughTransactionStates = passthrough?.transactionStates?.length
-    ? getNormalizedTransactionStates({
-        transactionStates: passthrough.transactionStates,
-      })
-    : []
-
-  const intentTransactionStates = apiTransactionStates?.length
-    ? getNormalizedTransactionStates({
-        transactionStates: apiTransactionStates,
-      })
-    : []
-
-  // Use the appropriate states based on current passthrough decision
-  const transactionStates = usePassthrough
-    ? passthroughTransactionStates
-    : intentTransactionStates
-
-  // Run balance check and quote normalization in parallel to reduce latency
-  const [balanceResult, quote] = await Promise.all([
-    effectiveFundMethod === "wallet"
-      ? checkAccountBalance({
-          account,
-          tokenAddress: originTokenAddress,
-          depositAmount: depositAmount,
-          publicClient: effectivePublicClient,
-          knownBalance: originTokenBalance,
-          decimals: originTokenDecimals,
-        })
-      : Promise.resolve({ hasEnoughBalance: true }),
-    getNormalizedQuoteObject({
-      originDepositAddress: usePassthrough
-        ? recipient
-        : intent.originIntentAddress,
-      destinationDepositAddress: usePassthrough
-        ? recipient
-        : intent.destinationIntentAddress,
-      destinationAddress: recipient,
-      trailsApiKey: trailsApiKey || "",
-      trailsApiUrl: trailsApiUrl || "",
-      sequenceMetadataUrl: sequenceMetadataUrl || "",
-      destinationCalldata,
-      originAmount: depositAmount,
-      destinationAmount: quoteToAmount,
-      originAmountMin: depositAmount,
-      destinationAmountMin: quoteToAmountMin,
-      originTokenAddress,
-      destinationTokenAddress,
-      originTokenPriceUsd: sourceTokenPriceUsd?.toString() || null,
-      destinationTokenPriceUsd: destinationTokenPriceUsd?.toString() || null,
-      fees: isSameChainSameToken
-        ? undefined
-        : getFeesFromIntent(intent, {
-            tradeType,
-            fromAmountUsd: calcAmountUsdPrice({
-              amount: rawAmountToNumber(depositAmount, originTokenDecimals),
-              usdPrice: sourceTokenPriceUsd,
-            }),
-            toAmountUsd: calcAmountUsdPrice({
-              amount: rawAmountToNumber(
-                quoteToAmount,
-                destinationTokenDecimals,
-              ),
-              usdPrice: destinationTokenPriceUsd,
-            }),
-          }),
-      originChainId,
-      destinationChainId,
-      slippageTolerance,
-      priceImpact: getPriceImpactFromIntent(intent),
-      priceImpactUsd: getPriceImpactUsdFromIntent(intent),
-      transactionStates,
-      originNativeTokenPriceUsd,
-      intent: usePassthrough ? undefined : intent,
-    }),
-  ])
-
-  noSufficientBalance = !balanceResult.hasEnoughBalance
-  quote.noSufficientBalance = noSufficientBalance
-  if (effectiveFundMethod === "wallet") {
-    logger.console.log(
-      "[trails-sdk] Balance check with actual deposit amount:",
-      {
-        depositAmount,
-        originTokenAddress,
-        hasEnoughBalance: balanceResult.hasEnoughBalance,
-        noSufficientBalance,
-      },
-    )
-  }
-
-  // Add passthrough-specific fields to the quote
-  // This allows the UI to switch between passthrough and intent states based on fee option
-  // SPEC: Quote includes passthrough info for passthrough-capable scenarios (C9b/C10/C11b/C12/D9b/D10/D11b/D12) so UI can toggle flows.
-  quote.passthroughTransactionStates = passthroughTransactionStates
-  quote.passthroughEligible = passthrough?.eligible === true
-
-  // Call onCheckoutQuote callback
-  if (checkoutOnHandlers?.triggerCheckoutQuote) {
-    checkoutOnHandlers.triggerCheckoutQuote(quote)
-  }
-
-  logger.console.log(
-    "[trails-sdk] handleIntent returning quote and send function",
-  )
-
-  return {
-    quote,
-    feeOptions: gasFeeOptions,
-    send: async (options) => {
-      const { skipCommit } = options
-
-      try {
-        // Recalculate passthrough decision at send time based on fee option.
-        // This allows switching between passthrough and intent flow after quote.
-        const sendFeeOption = options.selectedFeeOption
-        const sendUsePassthrough =
-          effectiveFundMethod === "wallet" &&
-          passthrough?.eligible === true &&
-          !!passthrough?.passthroughTransaction &&
-          isFeeSelectionPassthroughEligible({
-            selectedFeeOption: sendFeeOption,
-            gasFeeOptions,
-          })
-
-        logger.console.log("[trails-sdk] Send passthrough decision:", {
-          sendUsePassthrough,
-          passthroughEligible: passthrough?.eligible,
-          hasPassthroughTransaction: !!passthrough?.passthroughTransaction,
-          sendFeeOptionPassthroughEligible:
-            sendFeeOption?.isPassthroughEligible,
-          sendFeeOption,
-        })
-
-        // Select the correct deposit transaction based on passthrough decision at send time
-        const sendDepositTransaction: DepositTransaction | undefined =
-          sendUsePassthrough && passthrough?.passthroughTransaction
-            ? passthrough.passthroughTransaction
-            : intent.depositTransaction
-
-        // Select the correct transaction states based on passthrough decision at send time
-        const sendTransactionStates = sendUsePassthrough
-          ? passthroughTransactionStates
-          : intentTransactionStates
-
-        const commitIntentIfNeeded = async () => {
-          if (skipCommit) {
-            return
-          }
-
-          try {
-            logger.console.log(
-              "[trails-sdk] intentHandler: About to commit intent",
-              {
-                hasCommitIntentFn: !!commitIntentFn,
-                intentId: intent.intentId,
-              },
-            )
-
-            const commitIntentFnToUse =
-              commitIntentFn ||
-              ((intent: Intent) =>
-                commitIntent(trailsClient, intent, {
-                  originTokenSymbol,
-                  destinationTokenSymbol,
-                }))
-            await commitIntentFnToUse(intent)
-
-            logger.console.log("[trails-sdk] Intent committed successfully")
-          } catch (error) {
-            logger.console.error("[trails-sdk] Error committing intent", error)
-            throw error
-          }
-        }
-
-        if (sendUsePassthrough && sendDepositTransaction) {
-          return executePassthrough(
-            params,
-            sendDepositTransaction,
-            sendTransactionStates,
-            options,
-          )
-        } else {
-          await commitIntentIfNeeded()
-          return executeIntent(
-            params,
-            intent,
-            sendTransactionStates,
-            gasFeeOptions,
-            trailsContracts,
-            options,
-          )
-        }
-      } catch (error) {
-        const errorMessage = getFullErrorMessage(error)
-        logger.console.error("[trails-sdk] Error in handleIntent send:", error)
-
-        trackPaymentError({
-          error: errorMessage,
-          userAddress: account.address,
-          mode,
-          fundMethod: effectiveFundMethod,
-          originTokenAddress,
-        })
-
-        if (checkoutOnHandlers?.triggerCheckoutError) {
-          checkoutOnHandlers.triggerCheckoutError(errorMessage)
-        }
-
-        throw error
-      }
-    },
-  }
-}