0xtrails 0.2.6 → 0.4.0

package/src/prepareSend.ts

@@ -1,367 +1,47 @@
-import type {
-  GetIntentCallsPayloadParams,
-  IntentPrecondition,
-} from "@0xsequence/trails-api"
-import type { GetIntentCallsPayloadsReturn } from "./intents.js"
-import type { TrailsAPIClient } from "@0xsequence/trails-api"
-import type { Relayer } from "@0xsequence/relayer"
-import type {
-  Account,
-  Chain,
-  PublicClient,
-  TransactionReceipt,
-  WalletClient,
-} from "viem"
 import { abortControllerRegistry } from "./abortController.js"
-import { extractTrailsFeeBreakdown, type TrailsFeeBreakdown } from "./fees.js"
-import {
-  createPublicClient,
-  createWalletClient,
-  decodeFunctionData,
-  erc20Abi,
-  formatUnits,
-  http,
-  maxUint256,
-  parseUnits,
-  zeroAddress,
-} from "viem"
-import { generatePrivateKey, privateKeyToAccount } from "viem/accounts"
-import { mainnet } from "viem/chains"
-import {
-  trackPaymentCompleted,
-  trackPaymentError,
-  trackPaymentStarted,
-  trackRelayerCallCompleted,
-  trackRelayerCallError,
-  trackRelayerCallStarted,
-  trackTransactionConfirmed,
-} from "./analytics.js"
-import type { Attestation } from "./cctp.js"
-import {
-  approveERC20,
-  cctpTransfer,
-  cctpTransferWithCustomCall,
-  getCCTPRelayerCallData,
-  getIsUsdcAddress,
-  getMessageTransmitter,
-  getMintUSDCData,
-  getNeedsApproval,
-  getUSDCTokenAddress,
-} from "./cctp.js"
-import { queueCCTPTransfer } from "./cctpqueue.js"
-import { getChainInfo, getTestnetChainInfo } from "./chains.js"
-import { attemptSwitchChain } from "./chainSwitch.js"
+import { createPublicClient, http, zeroAddress } from "viem"
+import { trackPaymentError, trackPaymentStarted } from "./analytics.js"
 import { getSlippageTolerance } from "./config.js"
-import { TRAILS_INTENT_ENTRYPOINT_ADDRESS } from "./constants.js"
-import {
-  decodeGuestModuleEvents,
-  decodeTrailsTokenSweeperEvents,
-} from "./decoders.js"
 import { getERC20TransferData } from "./encoders.js"
-import { InsufficientBalanceError } from "./error.js"
-import {
-  estimateGasCost,
-  estimateGasCostUsd,
-  estimateGasLimit,
-  DEFAULT_MIN_GASLIMIT,
-} from "./estimate.js"
-import { getExplorerUrl } from "./explorer.js"
-import {
-  getNeedsIntentEntrypointApproval,
-  getPermitSignature,
-  getUserNonce,
-  signIntent,
-} from "./gasless.js"
-import { getIntentEntrypointFeeOptions } from "./intentEntrypoint.js"
-import {
-  buildSameChainTransactionParams,
-  buildCrossChainDepositParams,
-  commitIntentConfig,
-  getIntentCallsPayloads as getIntentCallsPayloadsFromIntents,
-  sendOriginTransaction,
-} from "./intents.js"
-import type { IntentRequestParams } from "./intents.js"
-import type { MetaTxn } from "./metaTxnMonitor.js"
-import { getMetaTxStatus } from "./metaTxnMonitor.js"
-import { relayerSendMetaTx } from "./metaTxns.js"
-import { findFirstPreconditionForChainId } from "./preconditions.js"
-import { calcAmountUsdPrice, getTokenPrice } from "./prices.js"
-import { getQueryParam } from "./queryParams.js"
-import type { MetaTxnReceipt } from "./relayer.js"
-import {
-  executeSimpleRelayTransaction,
-  getRelaySDKQuote,
-  getTxHashFromRelayResult,
-  waitForRelayDestinationTx,
-  type RelayQuote,
-  type RelayTradeType,
-} from "./relaySdk.js"
-import {
-  sequenceSendTransaction,
-  simpleCreateSequenceWallet,
-} from "./sequenceWallet.js"
-import {
-  formatAmount,
-  formatAmountDisplay,
-  formatRawAmount,
-  formatUsdAmountDisplay,
-} from "./tokenBalances.js"
-import { getTokenInfo, type SupportedToken } from "./tokens.js"
+import { getTokenPrice } from "./prices.js"
 import {
   TRAILS_ROUTER_PLACEHOLDER_AMOUNT,
   wrapCalldataWithTrailsRouterIfNeeded,
 } from "./trailsRouter.js"
-import type {
-  TransactionState,
-  TransactionStateStatus,
-} from "./transactions.js"
-import { getAccountTransactionHistory, getTxTimeDiff } from "./transactions.js"
-import { requestWithTimeout } from "./utils.js"
-import type { CheckoutOnHandlers } from "./widget/hooks/useCheckout.js"
+import type { TransactionState } from "./transactions.js"
 import { logger } from "./logger.js"
-
-// Polling intervals for different operations
-const POLLING_INTERVALS = {
-  // Consistent interval for transaction history polling (3 seconds)
-  TRANSACTION_HISTORY: 3000,
-  // Consistent interval for meta transaction polling (2 seconds)
-  META_TRANSACTION: 2000,
-  // Consistent interval for CCTP queue polling (5 seconds)
-  CCTP_QUEUE: 5000,
-  // Consistent interval for failure polling (2 seconds)
-  FAILURE_POLLING: 2000,
-} as const
-
 import { getIsCustomCalldata } from "./contractUtils.js"
-import type { SequenceAPIClient } from "@0xsequence/api"
-import { updatePersistentToast } from "./toast.js"
-import {
-  getDelegatorSmartAccount,
-  getPaymasterGaslessTransaction,
-  sendPaymasterGaslessTransaction,
-} from "./paymasterSend.js"
-
-export enum TradeType {
-  EXACT_INPUT = "EXACT_INPUT",
-  EXACT_OUTPUT = "EXACT_OUTPUT",
-}
-
-export type PrepareSendOptions = {
-  account: Account
-  originTokenAddress: string
-  originChainId: number
-  originTokenBalance: string
-  destinationChainId: number
-  recipient: string
-  destinationTokenAddress: string
-  swapAmount: string
-  tradeType?: TradeType
-  originTokenSymbol: string
-  destinationTokenSymbol: string
-  sequenceProjectAccessKey?: string
-  fee: string
-  client?: WalletClient
-  dryMode: boolean
-  apiClient: SequenceAPIClient
-  trailsClient: TrailsAPIClient
-  originRelayer: Relayer.RpcRelayer
-  destinationRelayer: Relayer.RpcRelayer
-  destinationCalldata?: string
-  onTransactionStateChange: (transactionStates: TransactionState[]) => void
-  sourceTokenPriceUsd?: number | null
-  destinationTokenPriceUsd?: number | null
-  sourceTokenDecimals: number
-  destinationTokenDecimals: number
-  paymasterUrl?: string
-  gasless?: boolean
-  slippageTolerance?: string
-  originNativeTokenPriceUsd?: number | null
-  quoteProvider?: string | null
-  fundMethod?: string
-  mode?: "pay" | "fund" | "earn" | "swap" | "receive"
-  checkoutOnHandlers?: CheckoutOnHandlers
-  refundAddress?: string
-  selectedFeeToken?: any
-  walletId?: string
-  abortSignal?: AbortSignal
-}
-
-export type PrepareSendFees = {
-  feeTokenAddress: string | null
-  totalFeeAmount: string | null
-  totalFeeAmountUsd: string | null
-  totalFeeAmountUsdDisplay: string | null
-}
-
-export type PrepareSendQuote = {
-  originDepositAddress: string
-  destinationDepositAddress: string
-  destinationAddress: string
-  destinationCalldata: string
-  originChain: Chain
-  destinationChain: Chain
-  originAmount: string
-  originAmountDisplay: string
-  originAmountMin: string
-  originAmountMinDisplay: string
-  originAmountMinUsdFormatted: string
-  originAmountMinUsdDisplay: string
-  destinationAmount: string
-  destinationAmountDisplay: string
-  destinationAmountMin: string
-  destinationAmountMinDisplay: string
-  destinationAmountMinUsdFormatted: string
-  destinationAmountMinUsdDisplay: string
-  originAmountFormatted: string
-  originAmountUsdFormatted: string
-  originAmountUsdDisplay: string
-  destinationAmountFormatted: string
-  destinationAmountUsdFormatted: string
-  destinationAmountUsdDisplay: string
-  originToken: SupportedToken
-  destinationToken: SupportedToken
-  fees: PrepareSendFees
-  slippageTolerance: string
-  priceImpact: string
-  priceImpactUsdDisplay: string
-  completionEstimateSeconds: number
-  transactionStates: TransactionState[]
-  gasCostUsd: number
-  gasCostUsdDisplay: string
-  gasCost: string
-  gasCostFormatted: string
-  originTokenRate: string
-  destinationTokenRate: string
-  quoteProvider: QuoteProviderInfo | null
-  noSufficientBalance: boolean
-  trailsFeeBreakdown?: TrailsFeeBreakdown | null
-}
-
-export type PrepareSendReturn = {
-  quote: PrepareSendQuote
-  feeOptions?: any
-  send: ({
-    onOriginSend,
-    selectedFeeToken,
-  }: {
-    onOriginSend?: () => void
-    selectedFeeToken?: any
-  }) => Promise<SendReturn>
-}
-
-export type SendReturn = {
-  originUserTxReceipt: TransactionReceipt | null
-  originMetaTxnReceipt: MetaTxnReceipt | null
-  destinationMetaTxnReceipt: MetaTxnReceipt | null
-  totalCompletionSeconds?: number
-}
-
-export function getIsToSameChain(
-  originChainId: number,
-  destinationChainId: number,
-): boolean {
-  return originChainId?.toString() === destinationChainId?.toString()
-}
-
-export function getIsToSameToken(
-  originTokenAddress: string,
-  destinationTokenAddress: string,
-): boolean {
-  return (
-    originTokenAddress?.toLowerCase() === destinationTokenAddress?.toLowerCase()
-  )
-}
-
-export function getIsToSameChainAndToken(
-  originChainId: number,
-  originTokenAddress: string,
-  destinationChainId: number,
-  destinationTokenAddress: string,
-): boolean {
-  return (
-    getIsToSameChain(originChainId, destinationChainId) &&
-    getIsToSameToken(originTokenAddress, destinationTokenAddress)
-  )
-}
-
-export function getUseCctp(
-  originTokenAddress: string,
-  destinationTokenAddress: string,
-  originChainId: number,
-  destinationChainId: number,
-) {
-  return (
-    getIsUsdcAddress(originTokenAddress, originChainId) &&
-    getIsUsdcAddress(destinationTokenAddress, destinationChainId)
-  )
-}
-
-export function validateCctpDestinationToken(
-  destinationTokenAddress: string,
-  destinationChainId: number,
-  quoteProvider?: string | null,
-): void {
-  // If CCTP provider is selected, destination token must be USDC
-  if (
-    quoteProvider === "cctp" &&
-    !getIsUsdcAddress(destinationTokenAddress, destinationChainId)
-  ) {
-    throw new Error(
-      `CCTP provider requires destination token to be USDC. Current destination token: ${destinationTokenAddress} on chain ${destinationChainId}. Please ensure the destination token is USDC as listed in the Circle CCTP documentation.`,
-    )
-  }
-}
-
-function isTestnetDebugMode(): boolean {
-  return getQueryParam("testnet") === "true"
-}
-
-function getTestnetOriginTokenAddress(testnetChainId: number): string {
-  return getUSDCTokenAddress(testnetChainId)!
-}
-
-function getIntentArgs(
-  mainSignerAddress: string,
-  originChainId: number,
-  originTokenAddress: string,
-  originTokenAmount: string,
-  destinationChainId: number,
-  destinationTokenAddress: string,
-  destinationTokenAmount: string,
-  destinationTokenSymbol: string,
-  recipient: string,
-  destinationCalldata: string | undefined,
-  destinationSalt: string = Date.now().toString(),
-  slippageTolerance: string, // 0.03 = 3%
-  tradeType: TradeType,
-  provider?: string | null,
-): GetIntentCallsPayloadParams {
-  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-
-  if (!provider || provider === "auto") {
-    provider = undefined
-  }
-
-  const intentArgs = {
-    userAddress: mainSignerAddress,
-    originChainId,
-    originTokenAddress,
-    originTokenAmount: originTokenAmount, // max amount for exact_output
-    destinationChainId,
-    destinationToAddress: recipient,
-    destinationTokenAddress: destinationTokenAddress,
-    destinationTokenAmount: destinationTokenAmount,
-    destinationTokenSymbol: destinationTokenSymbol,
-    destinationCallData: hasCustomCalldata ? destinationCalldata : "0x",
-    destinationCallValue: "0",
-    destinationSalt,
-    slippageTolerance: Number(slippageTolerance),
-    tradeType,
-    provider,
-  }
+import { getChainInfo } from "./chains.js"
 
-  return intentArgs
-}
+// Import from transactionIntent module
+import {
+  TradeType,
+  type PrepareSendOptions,
+  type PrepareSendReturn,
+  handleSameChainSameToken,
+  handleCrossChain,
+  isSameChain,
+  isSameToken,
+  validateCctpDestinationToken,
+} from "./transactionIntent/index.js"
+
+// Re-export types for backward compatibility
+export { TradeType } from "./transactionIntent/index.js"
+export type {
+  PrepareSendOptions,
+  PrepareSendFees,
+  PrepareSendQuote,
+  PrepareSendReturn,
+  SendReturn,
+  SelectedFeeToken,
+} from "./transactionIntent/index.js"
+
+// Re-export validators for backward compatibility
+export {
+  isSameChain,
+  isSameToken,
+  validateCctpDestinationToken,
+} from "./transactionIntent/index.js"
 
 export async function prepareSend(
   options: PrepareSendOptions,
@@ -387,16 +67,12 @@ export async function prepareSend(
     fee,
     client: walletClient,
     dryMode = false,
-    apiClient,
     trailsClient,
-    originRelayer,
-    destinationRelayer,
     destinationCalldata,
     onTransactionStateChange,
     sourceTokenDecimals,
     destinationTokenDecimals,
     paymasterUrl,
-    gasless = false,
     slippageTolerance = getSlippageTolerance(),
     originNativeTokenPriceUsd,
     quoteProvider,
@@ -406,6 +82,8 @@ export async function prepareSend(
     selectedFeeToken,
     walletId,
     abortSignal,
+    commitIntentFn,
+    executeIntentFn,
   } = options
   let { sourceTokenPriceUsd, destinationTokenPriceUsd } = options
 
@@ -474,12 +152,12 @@ export async function prepareSend(
         originTokenAddress,
         originChainId,
       })
-      const price = await getTokenPrice(apiClient, {
-        tokenId: originTokenAddress,
-        contractAddress: originTokenAddress,
+      const price = await getTokenPrice(trailsClient, {
+        tokenSymbol: originTokenAddress,
+        tokenAddress: originTokenAddress,
         chainId: originChainId,
       })
-      sourceTokenPriceUsd = price?.price?.value ?? 0
+      sourceTokenPriceUsd = price?.priceUsd ?? 0
       logger.console.log(
         "[trails-sdk] source token price:",
         sourceTokenPriceUsd,
@@ -498,12 +176,12 @@ export async function prepareSend(
         destinationTokenAddress,
         destinationChainId,
       })
-      const price = await getTokenPrice(apiClient, {
-        tokenId: destinationTokenAddress,
-        contractAddress: destinationTokenAddress,
+      const price = await getTokenPrice(trailsClient, {
+        tokenSymbol: destinationTokenAddress,
+        tokenAddress: destinationTokenAddress,
         chainId: destinationChainId,
       })
-      destinationTokenPriceUsd = price?.price?.value ?? 0
+      destinationTokenPriceUsd = price?.priceUsd ?? 0
       logger.console.log(
         "[trails-sdk] destination token price:",
         destinationTokenPriceUsd,
@@ -566,11 +244,8 @@ export async function prepareSend(
     })
     throw new Error(`Chain ${originChainId} not found`)
   }
-  const isToSameChain = getIsToSameChain(originChainId, destinationChainId)
-  const isToSameToken = getIsToSameToken(
-    originTokenAddress,
-    destinationTokenAddress,
-  )
+  const isToSameChain = isSameChain(originChainId, destinationChainId)
+  const isToSameToken = isSameToken(originTokenAddress, destinationTokenAddress)
 
   logger.console.log("[trails-sdk] isToSameChain", isToSameChain)
   logger.console.log("[trails-sdk] isToSameToken", isToSameToken)
@@ -656,15 +331,17 @@ export async function prepareSend(
   // }
 
   if (isToSameToken && isToSameChain) {
-    return await sendHandlerForSameChainSameToken({
+    return await handleSameChainSameToken({
+      mainSignerAddress,
       originTokenAddress,
       originTokenDecimals: sourceTokenDecimals,
+      originTokenSymbol,
+      destinationTokenSymbol,
       swapAmount,
       destinationCalldata: effectiveDestinationCalldata,
       recipient: effectiveDestinationAddress,
       originChainId,
       walletClient,
-      publicClient,
       onTransactionStateChange,
       dryMode,
       account,
@@ -673,20 +350,21 @@ export async function prepareSend(
       sourceTokenPriceUsd,
       destinationTokenPriceUsd,
       originNativeTokenPriceUsd,
-      slippageTolerance,
+      slippageTolerance: slippageTolerance,
       checkoutOnHandlers,
-      gasless,
       paymasterUrl,
       selectedFeeToken,
+      walletId,
       trailsClient,
-      originRelayer,
       mode,
       fundMethod,
       abortSignal,
+      commitIntentFn,
+      executeIntentFn,
     })
   }
 
-  return await sendHandlerForDifferentChainDifferentToken({
+  return await handleCrossChain({
     mainSignerAddress,
     originChainId,
     originTokenAddress,
@@ -698,16 +376,12 @@ export async function prepareSend(
     destinationTokenSymbol,
     recipient: effectiveDestinationAddress,
     destinationCalldata: effectiveDestinationCalldata,
-    apiClient,
     trailsClient,
     sourceTokenPriceUsd,
     destinationTokenPriceUsd,
     sourceTokenDecimals,
     destinationTokenDecimals,
-    gasless,
     paymasterUrl,
-    originRelayer,
-    destinationRelayer,
     walletClient,
     publicClient,
     chain,
@@ -726,4140 +400,32 @@ export async function prepareSend(
     selectedFeeToken,
     walletId,
     abortSignal,
+    commitIntentFn,
+    executeIntentFn,
   })
 }
 
-async function sendHandlerForDifferentChainDifferentToken({
-  mainSignerAddress,
-  originChainId,
-  originTokenAddress,
-  originTokenBalance,
-  destinationChainId,
-  destinationTokenAddress,
-  swapAmount,
-  originTokenSymbol,
-  destinationTokenSymbol,
-  recipient,
-  destinationCalldata,
-  trailsClient,
-  sourceTokenPriceUsd,
-  destinationTokenPriceUsd,
-  sourceTokenDecimals,
-  destinationTokenDecimals,
-  gasless,
-  paymasterUrl,
-  originRelayer,
-  destinationRelayer,
-  walletClient,
-  publicClient,
-  chain,
-  account,
-  fee,
-  dryMode,
-  onTransactionStateChange,
-  transactionStates,
-  slippageTolerance,
-  tradeType,
-  originNativeTokenPriceUsd,
-  quoteProvider,
-  fundMethod,
-  mode,
-  checkoutOnHandlers,
-  selectedFeeToken,
-  walletId,
-  abortSignal,
-}: {
-  mainSignerAddress: string
-  originChainId: number
-  originTokenAddress: string
-  originTokenBalance: string
-  destinationChainId: number
-  destinationTokenAddress: string
-  swapAmount: string
-  originTokenSymbol: string
-  destinationTokenSymbol: string
-  recipient: string
-  destinationCalldata?: string
-  apiClient: SequenceAPIClient
-  trailsClient: TrailsAPIClient
-  sourceTokenPriceUsd?: number | null
-  destinationTokenPriceUsd?: number | null
-  sourceTokenDecimals: number
-  destinationTokenDecimals: number
-  gasless: boolean
-  paymasterUrl?: string
-  originRelayer: Relayer.RpcRelayer
-  destinationRelayer: Relayer.RpcRelayer
-  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?: any
-  walletId?: string
-  abortSignal?: AbortSignal
-}): Promise<PrepareSendReturn> {
-  const testnet = isTestnetDebugMode()
-  const useCctp = getUseCctp(
-    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?: any
-      }): Promise<SendReturn> => {
-        // Use runtime selectedFeeToken if provided, otherwise fall back to the one from prepareSend
-        const effectiveSelectedFeeToken =
-          runtimeSelectedFeeToken ?? selectedFeeToken
-        logger.console.log(
-          "[trails-sdk] [FEE-SELECT] [GASLESS-FLOW] send() called (LEGACY PATH):",
-          {
-            runtimeSelectedFeeToken,
-            prepareTimeSelectedFeeToken: selectedFeeToken,
-            effectiveSelectedFeeToken,
-          },
-        )
-        const originChain = testnet ? getTestnetChainInfo(chain)! : chain
-        const destinationChain = testnet
-          ? getTestnetChainInfo(destinationChainId)!
-          : 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 {
-          originUserTxReceipt: 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
-    destinationTokenSymbol,
-    recipient,
-    destinationCalldata,
-    destinationSalt,
-    slippageTolerance,
-    tradeType,
-    quoteProvider,
-  )
-
-  logger.console.log("[trails-sdk] Creating intent with args:", intentArgs)
-
-  const intent = await getIntentCallsPayloadsFromIntents(
-    trailsClient,
-    {
-      params: intentArgs,
-    },
-    {
-      originTokenSymbol,
-      destinationTokenSymbol,
-      feeTokenSymbol: originTokenSymbol,
-    },
-  )
-  logger.console.log("[trails-sdk] Got intent:", intent)
-
-  if (
-    !intent.payloads.preconditions?.length ||
-    !intent.payloads.calls?.length
-  ) {
-    throw new Error("Invalid intent")
-  }
-
-  const originIntentAddress = intent.payloads.originIntentAddress
-  logger.console.log(
-    "[trails-sdk] origin intent address:",
-    originIntentAddress.toString(),
-  )
-
-  const firstPrecondition = findFirstPreconditionForChainId(
-    intent.payloads.preconditions,
-    originChainId,
-  )
-
-  if (!firstPrecondition) {
-    throw new Error("No precondition found for origin chain")
-  }
-
-  const firstPreconditionMin = firstPrecondition?.data?.min?.toString()
-  const depositAmount = firstPreconditionMin
-
-  const quoteToAmount = intent.payloads.quote.toAmount
-  const quoteToAmountMin = intent.payloads.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.payloads.destinationIntentAddress,
-    destinationAddress: recipient,
-    destinationCalldata,
-    originAmount: depositAmount,
-    destinationAmount: quoteToAmount,
-    originAmountMin: depositAmount,
-    destinationAmountMin: quoteToAmountMin,
-    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.payloads?.quote?.quoteProvider,
-    noSufficientBalance,
-    estimatedGasLimit: estimatedGasLimitForQuote,
-    intent,
-  })
-
-  // Call onCheckoutQuote callback if provided
-  if (checkoutOnHandlers?.triggerCheckoutQuote) {
-    checkoutOnHandlers.triggerCheckoutQuote(quote)
-  }
-
-  // Get intent entrypoint fee options if supported and gasless is enabled
-  // Note: We fetch fee options whenever gasless is true, regardless of fundMethod,
-  // because gasless scenarios (including tests) need fee collector information
-  // Skip gasless fee options for sequence-waas wallet
-  let intentEntrypointFeeOptions: any = null
-  if (gasless && walletId !== "sequence-waas") {
-    try {
-      logger.console.log(
-        "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Gasless enabled, checking intent entrypoint support for chain:",
-        originChainId,
-      )
-
-      intentEntrypointFeeOptions = await getIntentEntrypointFeeOptions({
-        trailsClient,
-        userAddress: mainSignerAddress as `0x${string}`,
-        tokenAddress: originTokenAddress as `0x${string}`,
-        amount: depositAmount,
-        intentAddress: originIntentAddress as `0x${string}`,
-        chainId: originChainId,
-      })
-      logger.console.log(
-        "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Intent entrypoint fee options:",
-        intentEntrypointFeeOptions,
-      )
-    } catch (error) {
-      logger.console.error(
-        "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Error getting intent entrypoint fee options:",
-        error,
-      )
-    }
-  } else if (walletId === "sequence-waas") {
-    logger.console.log(
-      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Skipping gasless fee options for sequence-waas wallet",
-    )
-  } else {
-    logger.console.log(
-      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] Gasless disabled, skipping intent entrypoint fee options fetch",
-    )
-  }
-
-  return {
-    quote,
-    feeOptions: intentEntrypointFeeOptions,
-    send: async ({
-      onOriginSend,
-      selectedFeeToken: runtimeSelectedFeeToken,
-    }: {
-      onOriginSend?: () => void
-      selectedFeeToken?: any
-    }): 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,
-          },
-        )
-        await commitIntentConfig(
-          trailsClient,
-          mainSignerAddress,
-          intent.payloads.calls,
-          intent.payloads.preconditions,
-          {
-            originTokenSymbol,
-            destinationTokenSymbol,
-          },
-          intentArgs as IntentRequestParams,
-        )
-
-        if (!(fundMethod === "qr-code" || fundMethod === "exchange")) {
-          const { hasEnoughBalance, balanceError } = await checkAccountBalance({
-            account,
-            tokenAddress: originTokenAddress,
-            depositAmount,
-            publicClient,
-          })
-
-          if (!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 originUserTxReceipt: TransactionReceipt | null = null
-        let originMetaTxnReceipt: MetaTxnReceipt | null = null
-        let destinationMetaTxnReceipt: MetaTxnReceipt | null = null
-
-        const testnet = isTestnetDebugMode()
-        const effectiveOriginChain = testnet
-          ? getTestnetChainInfo(chain)!
-          : chain
-        const effectiveOriginTokenAddress = testnet
-          ? getTestnetOriginTokenAddress(effectiveOriginChain.id)
-          : originTokenAddress
-
-        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,
-              gasless,
-              paymasterUrl,
-              chain: effectiveOriginChain.id,
-              account: account.address,
-              firstPreconditionMin,
-              originIntentAddress,
-              fee,
-              dryMode,
-              feeOptions: intentEntrypointFeeOptions,
-              selectedFeeToken: effectiveSelectedFeeToken,
-              selectedFeeTokenType: typeof effectiveSelectedFeeToken,
-              selectedFeeTokenValue: JSON.stringify(effectiveSelectedFeeToken),
-            },
-          )
-
-          originUserTxReceipt = await attemptUserDepositTx({
-            originTokenAddress: effectiveOriginTokenAddress,
-            gasless,
-            paymasterUrl,
-            chain: effectiveOriginChain,
-            account,
-            originRelayer,
-            firstPreconditionMin,
-            originIntentAddress,
-            onOriginSend,
-            publicClient,
-            walletClient,
-            destinationTokenDecimals,
-            sourceTokenDecimals,
-            fee,
-            dryMode,
-            sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
-            destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
-            swapAmount,
-            onTransactionStateChange,
-            transactionStates,
-            fundMethod,
-            originTokenSymbol,
-            destinationTokenSymbol,
-            depositAmountUsd,
-            feeOptions: intentEntrypointFeeOptions,
-            trailsClient,
-            selectedFeeToken: effectiveSelectedFeeToken,
-            walletId,
-            abortSignal,
-          })
-
-          if (!originUserTxReceipt) {
-            throw new Error("Failed to send origin transaction")
-          }
-
-          transactionStates[0] = getTransactionStateFromReceipt(
-            originUserTxReceipt,
-            originChainId,
-            transactionStates[0]?.label,
-          )
-
-          try {
-            transactionStates[0].decodedTrailsTokenSweeperEvents =
-              decodeTrailsTokenSweeperEvents(originUserTxReceipt)
-            transactionStates[0].decodedGuestModuleEvents =
-              decodeGuestModuleEvents(originUserTxReceipt)
-            transactionStates[0].refunded =
-              transactionStates[0].decodedTrailsTokenSweeperEvents.findIndex(
-                (event) =>
-                  event.type === "Refund" || event.type === "RefundAndSweep",
-              ) !== -1
-            logger.console.log(
-              "[trails-sdk] [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)
-        }
-
-        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}`,
-                  })
-
-                originUserTxReceipt = 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.payloads
-                    .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
-        let originMetaTxnReceiptPromise:
-          | ((abortSignal?: AbortSignal) => Promise<MetaTxnReceipt | null>)
-          | null = null
-        let destinationMetaTxnReceiptPromise:
-          | ((abortSignal?: AbortSignal) => Promise<MetaTxnReceipt | null>)
-          | ((abortSignal?: AbortSignal) => Promise<TransactionReceipt | null>)
-          | null = null
-
-        // First phase: Send meta transactions and queue CCTP
-        const originSendMetaTxnPromise = async () => {
-          logger.console.log("[trails-sdk] Starting originSendMetaTxnPromise", {
-            hasMetaTxn: !!intent.payloads.metaTxns[0],
-            hasPrecondition: !!intent.payloads.preconditions[0],
-            metaTxnId: intent.payloads.metaTxns[0]?.id,
-            chainId: intent.payloads.metaTxns[0]?.chainId,
-          })
-
-          if (intent.payloads.metaTxns[0] && intent.payloads.preconditions[0]) {
-            // Extract fee quote from intent response using metatxnid as key
-            const metaTxnId = intent.payloads.metaTxns[0].id
-            const feeQuote = intent.payloads.feeQuotes?.[metaTxnId]
-            logger.console.log(
-              "[trails-sdk] Extracted fee quote for origin meta txn",
-              {
-                metaTxnId,
-                feeQuote,
-                hasFeeQuote: !!feeQuote,
-              },
-            )
-
-            logger.console.log(
-              "[trails-sdk] Calling sendMetaTxAndWaitForReceipt for origin",
-              {
-                metaTxnId,
-                chainId: intent.payloads.metaTxns[0].chainId,
-                walletAddress: intent.payloads.metaTxns[0].walletAddress,
-                contract: intent.payloads.metaTxns[0].contract,
-              },
-            )
-
-            const { waitForReceipt } = await sendMetaTxAndWaitForReceipt({
-              metaTx: intent.payloads.metaTxns[0] as MetaTxn,
-              relayer: originRelayer,
-              precondition: intent.payloads
-                .preconditions[0] as IntentPrecondition,
-              feeQuote: feeQuote,
-            })
-
-            logger.console.log(
-              "[trails-sdk] Origin meta transaction sent successfully",
-              {
-                metaTxnId,
-              },
-            )
+// Re-export useQuote types and hook from the new location
+export type {
+  UseQuoteProps,
+  Quote,
+  UseQuoteReturn,
+  SwapReturn,
+  QuoteProviderInfo,
+} from "./widget/hooks/useQuote.js"
+export { useQuote } from "./widget/hooks/useQuote.js"
 
-            // Store the waitForReceipt function for later use
-            originMetaTxnReceiptPromise = waitForReceipt
-          } else {
-            logger.console.warn(
-              "[trails-sdk] Skipping origin sendMetaTxn - missing metaTxn or precondition",
-              {
-                hasMetaTxn: !!intent.payloads.metaTxns[0],
-                hasPrecondition: !!intent.payloads.preconditions[0],
-              },
-            )
-          }
-        }
-
-        const destinationSendMetaTxnPromise = async () => {
-          logger.console.log(
-            "[trails-sdk] Starting destinationSendMetaTxnPromise",
-            {
-              quoteProvider: intent.payloads.quote.quoteProvider,
-              hasQuoteProviderRequestId:
-                !!intent.payloads.quote.quoteProviderRequestId,
-              hasPrecondition1: !!intent.payloads.preconditions[1],
-              hasMetaTxn1: !!intent.payloads.metaTxns[1],
-            },
-          )
-
-          if (
-            intent.payloads.quote.quoteProvider === "relay" &&
-            intent.payloads.quote.quoteProviderRequestId &&
-            !intent.payloads.preconditions[1] &&
-            !intent.payloads.metaTxns[1]
-          ) {
-            logger.console.log(
-              "[trails-sdk] Setting up relay destination promise",
-              {
-                quoteProviderRequestId:
-                  intent.payloads.quote.quoteProviderRequestId,
-              },
-            )
-            // For relay, we'll wait for the receipt in the wait phase
-            // Just store the requestId for later use
-            destinationMetaTxnReceiptPromise = async (
-              abortSignal?: AbortSignal,
-            ) => {
-              logger.console.log(
-                "[trails-sdk] waitForRelayDestinationTx starting",
-                {
-                  quoteProviderRequestId:
-                    intent.payloads.quote.quoteProviderRequestId,
-                  aborted: abortSignal?.aborted,
-                },
-              )
-              try {
-                // Check if we should abort before starting
-                if (abortSignal?.aborted) {
-                  logger.console.log(
-                    "[trails-sdk] Aborting relay destination tx due to abort signal",
-                  )
-                  return null
-                }
-
-                const txHash = await waitForRelayDestinationTx(
-                  intent.payloads.quote.quoteProviderRequestId,
-                )
-                logger.console.log(
-                  "[trails-sdk] waitForRelayDestinationTx completed",
-                  {
-                    txHash,
-                    quoteProviderRequestId:
-                      intent.payloads.quote.quoteProviderRequestId,
-                  },
-                )
-                if (txHash) {
-                  logger.console.log(
-                    "[trails-sdk] Fetching transaction receipt for relay destination",
-                    {
-                      txHash,
-                      chainId: destinationChainId,
-                    },
-                  )
-
-                  const destinationTxnReceipt =
-                    await destinationPublicClient.getTransactionReceipt({
-                      hash: txHash as `0x${string}`,
-                    })
-                  logger.console.log(
-                    "[trails-sdk] relay destinationTxnReceipt received",
-                    {
-                      txHash,
-                      blockNumber: destinationTxnReceipt?.blockNumber,
-                      status: destinationTxnReceipt?.status,
-                      gasUsed: destinationTxnReceipt?.gasUsed,
-                    },
-                  )
-                  if (transactionStates[2]) {
-                    transactionStates[2] = getTransactionStateFromReceipt(
-                      destinationTxnReceipt,
-                      destinationChainId,
-                      transactionStates[2]?.label,
-                    )
-                  }
-                  onTransactionStateChange(transactionStates)
-                  return destinationTxnReceipt
-                } else {
-                  logger.console.warn(
-                    "[trails-sdk] No txHash returned from waitForRelayDestinationTx",
-                    {
-                      quoteProviderRequestId:
-                        intent.payloads.quote.quoteProviderRequestId,
-                    },
-                  )
-                }
-              } catch (error: unknown) {
-                logger.console.error(
-                  "[trails-sdk] Error waiting for relay destination tx",
-                  {
-                    error:
-                      error instanceof Error ? error.message : String(error),
-                    quoteProviderRequestId:
-                      intent.payloads.quote.quoteProviderRequestId,
-                  },
-                )
-                if (transactionStates?.[2]) {
-                  transactionStates[2].state = "failed"
-                  onTransactionStateChange(transactionStates)
-                }
-                throw error
-              }
-              return null
-            }
-          } else {
-            logger.console.log(
-              "[trails-sdk] Setting up destination meta transaction promise (non-relay)",
-              {
-                quoteProvider: intent.payloads.quote.quoteProvider,
-                hasMetaTxn1: !!intent.payloads.metaTxns[1],
-                hasPrecondition1: !!intent.payloads.preconditions[1],
-              },
-            )
-
-            if (
-              intent.payloads.metaTxns[1] &&
-              intent.payloads.preconditions[1]
-            ) {
-              // Extract fee quote from intent response using metatxnid as key
-              const metaTxnId = intent.payloads.metaTxns[1].id
-              const feeQuote = intent.payloads.feeQuotes?.[metaTxnId]
-              logger.console.log(
-                "[trails-sdk] Extracted fee quote for destination meta txn",
-                {
-                  metaTxnId,
-                  feeQuote,
-                  hasFeeQuote: !!feeQuote,
-                },
-              )
-
-              logger.console.log(
-                "[trails-sdk] Calling sendMetaTxAndWaitForReceipt for destination",
-                {
-                  metaTxnId,
-                  chainId: intent.payloads.metaTxns[1].chainId,
-                  walletAddress: intent.payloads.metaTxns[1].walletAddress,
-                  contract: intent.payloads.metaTxns[1].contract,
-                },
-              )
-
-              const { waitForReceipt } = await sendMetaTxAndWaitForReceipt({
-                metaTx: intent.payloads.metaTxns[1] as MetaTxn,
-                relayer: destinationRelayer,
-                precondition: intent.payloads
-                  .preconditions[1] as IntentPrecondition,
-                feeQuote: feeQuote,
-              })
-
-              logger.console.log(
-                "[trails-sdk] Destination meta transaction sent successfully",
-                {
-                  metaTxnId,
-                },
-              )
-
-              // Store the waitForReceipt function for later use
-              destinationMetaTxnReceiptPromise = waitForReceipt
-            } else {
-              logger.console.warn(
-                "[trails-sdk] Skipping destination sendMetaTxn - missing metaTxn or precondition",
-                {
-                  hasMetaTxn: !!intent.payloads.metaTxns[1],
-                  hasPrecondition: !!intent.payloads.preconditions[1],
-                },
-              )
-            }
-            // } else if (intent.payloads.destinationIntentAddress) {
-            //   destinationMetaTxnReceiptPromise = checkForDestinationDepositTx
-            // }
-          }
-        }
-
-        let queueCctpPromise: (() => Promise<void>) | null = null
-
-        const isCctp = intent.payloads.quote.quoteProvider === "cctp"
-        if (isCctp) {
-          queueCctpPromise = async () => {
-            while (true) {
-              // Check if we should abort
-              if (abortSignal?.aborted) {
-                logger.console.log(
-                  "[trails-sdk] Aborting CCTP queue due to abort signal",
-                )
-                return
-              }
-
-              const originMetaTxnHash = originMetaTxnReceipt?.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" ||
-          gasless === true
-
-        if (needsDepositPolling) {
-          logger.console.log(
-            "[trails-sdk] Starting deposit polling for fundMethod:",
-            fundMethod,
-            "gasless:",
-            gasless,
-          )
-          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",
-          )
-          if (originMetaTxnReceiptPromise) {
-            try {
-              originMetaTxnReceipt =
-                await originMetaTxnReceiptPromise(abortSignal)
-
-              if (originMetaTxnReceipt && transactionStates[1]) {
-                transactionStates[1] = getTransactionStateFromReceipt(
-                  originMetaTxnReceipt,
-                  originChainId,
-                  transactionStates[1]?.label,
-                )
-                onTransactionStateChange(transactionStates)
-
-                try {
-                  const receipt = await publicClient.getTransactionReceipt({
-                    hash: originMetaTxnReceipt.txnHash as `0x${string}`,
-                  })
-                  transactionStates[1].decodedTrailsTokenSweeperEvents =
-                    decodeTrailsTokenSweeperEvents(receipt)
-                  transactionStates[1].decodedGuestModuleEvents =
-                    decodeGuestModuleEvents(receipt)
-                  transactionStates[1].refunded =
-                    transactionStates[1].decodedTrailsTokenSweeperEvents.findIndex(
-                      (event) =>
-                        event.type === "Refund" ||
-                        event.type === "RefundAndSweep",
-                    ) !== -1
-                  logger.console.log("[trails-sdk] Origin meta-tx events", {
-                    chainId: originChainId,
-                    callFailed: (
-                      transactionStates[1].decodedGuestModuleEvents || []
-                    ).filter((e: any) => e?.type === "CallFailed").length,
-                    sweeperEvents: (
-                      transactionStates[1].decodedTrailsTokenSweeperEvents || []
-                    ).length,
-                    refunded: transactionStates[1].refunded,
-                  })
-
-                  // Check for transaction failure or refund
-                  const hasCallFailed = (
-                    transactionStates[1].decodedGuestModuleEvents || []
-                  ).some((e: any) => e?.type === "CallFailed")
-
-                  if (transactionStates[1].refunded || hasCallFailed) {
-                    const errorMessage = transactionStates[1].refunded
-                      ? "Origin transaction was refunded"
-                      : "Origin transaction call failed"
-
-                    logger.console.error("[trails-sdk] Origin meta-tx failed", {
-                      refunded: transactionStates[1].refunded,
-                      callFailed: hasCallFailed,
-                    })
-
-                    // Call onCheckoutError callback if provided
-                    if (checkoutOnHandlers?.triggerCheckoutError) {
-                      checkoutOnHandlers.triggerCheckoutError(errorMessage)
-                    }
-                  }
-
-                  onTransactionStateChange(transactionStates)
-                } catch (error) {
-                  logger.console.error("Error decoding origin tx events", error)
-                }
-              }
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] Error waiting for origin receipt:",
-                error,
-              )
-            }
-          } else {
-            logger.console.log(
-              "[trails-sdk] No origin meta transaction receipt promise to wait for",
-            )
-          }
-        }
-
-        const waitForDestinationMetaTxnReceiptPromise = async () => {
-          logger.console.log(
-            "[trails-sdk] Waiting for destination meta transaction receipt",
-          )
-          if (destinationMetaTxnReceiptPromise) {
-            try {
-              // Race between destination receipt and failure polling
-              const destinationReceiptPromise = destinationMetaTxnReceiptPromise
-                ? destinationMetaTxnReceiptPromise(abortSignal)
-                : Promise.resolve(null)
-
-              const failurePollingPromise = new Promise<null>((resolve) => {
-                const pollForFailures = () => {
-                  const isPreviousTxCallFailed =
-                    transactionStates?.some((tx) => tx.state === "failed") ||
-                    transactionStates?.some((tx) =>
-                      tx?.decodedGuestModuleEvents?.some(
-                        (event) => event.type === "CallFailed",
-                      ),
-                    )
-
-                  if (isPreviousTxCallFailed) {
-                    logger.console.log(
-                      "[trails-sdk] Aborting destination meta transaction due to previous transaction failure",
-                    )
-                    resolve(null)
-                  } else {
-                    // Continue polling with consistent interval
-                    setTimeout(
-                      pollForFailures,
-                      POLLING_INTERVALS.FAILURE_POLLING,
-                    )
-                  }
-                }
-                pollForFailures()
-              })
-
-              destinationMetaTxnReceipt = (await Promise.race([
-                destinationReceiptPromise,
-                failurePollingPromise,
-              ])) as MetaTxnReceipt
-
-              logger.console.log(
-                "[trails-sdk] destinationMetaTxnReceipt",
-                destinationMetaTxnReceipt,
-              )
-
-              if (destinationMetaTxnReceipt && transactionStates[2]) {
-                transactionStates[2] = getTransactionStateFromReceipt(
-                  destinationMetaTxnReceipt,
-                  destinationChainId,
-                  transactionStates[2]?.label,
-                )
-                onTransactionStateChange(transactionStates)
-
-                try {
-                  const receipt =
-                    await destinationPublicClient.getTransactionReceipt({
-                      hash: destinationMetaTxnReceipt.txnHash as `0x${string}`,
-                    })
-                  transactionStates[2].decodedTrailsTokenSweeperEvents =
-                    decodeTrailsTokenSweeperEvents(receipt)
-                  transactionStates[2].decodedGuestModuleEvents =
-                    decodeGuestModuleEvents(receipt)
-                  transactionStates[2].refunded =
-                    transactionStates[2].decodedTrailsTokenSweeperEvents.findIndex(
-                      (event) =>
-                        event.type === "Refund" ||
-                        event.type === "RefundAndSweep",
-                    ) !== -1 ||
-                    (transactionStates[2].decodedTrailsTokenSweeperEvents.findIndex(
-                      (event) => event.type === "Sweep",
-                    ) !== -1 &&
-                      transactionStates[2].decodedGuestModuleEvents.findIndex(
-                        (event) => event.type === "CallFailed",
-                      ) !== -1)
-                  logger.console.log(
-                    "[trails-sdk] Destination meta-tx events",
-                    {
-                      chainId: destinationChainId,
-                      callFailed: (
-                        transactionStates[2].decodedGuestModuleEvents || []
-                      ).filter((e: any) => e?.type === "CallFailed").length,
-                      sweeperEvents: (
-                        transactionStates[2].decodedTrailsTokenSweeperEvents ||
-                        []
-                      ).length,
-                      refunded: transactionStates[2].refunded,
-                    },
-                  )
-
-                  // Check for transaction failure or refund
-                  const hasCallFailed = (
-                    transactionStates[2].decodedGuestModuleEvents || []
-                  ).some((e: any) => e?.type === "CallFailed")
-
-                  if (transactionStates[2].refunded || hasCallFailed) {
-                    const errorMessage = transactionStates[2].refunded
-                      ? "Destination transaction was refunded"
-                      : "Destination transaction call failed"
-
-                    logger.console.error(
-                      "[trails-sdk] Destination meta-tx failed",
-                      {
-                        refunded: transactionStates[2].refunded,
-                        callFailed: hasCallFailed,
-                      },
-                    )
-
-                    // Call onCheckoutError callback if provided
-                    if (checkoutOnHandlers?.triggerCheckoutError) {
-                      checkoutOnHandlers.triggerCheckoutError(errorMessage)
-                    }
-                  }
-
-                  onTransactionStateChange(transactionStates)
-                } catch (error) {
-                  logger.console.error(
-                    "Error decoding destination tx events",
-                    error,
-                  )
-                }
-              }
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] Error waiting for destination receipt:",
-                error,
-              )
-              // For relay transactions, this might be expected if still waiting
-              if (intent.payloads.quote.quoteProvider === "relay") {
-                logger.console.log(
-                  "[trails-sdk] Relay transaction still waiting, this is normal",
-                )
-              }
-            }
-          } else {
-            logger.console.log(
-              "[trails-sdk] No destination meta transaction receipt promise to wait for",
-            )
-          }
-        }
-
-        logger.console.log(
-          "[trails-sdk] Executing Phase 2 Promise.all with deposit",
-        )
-        logger.console.log(
-          "[trails-sdk] About to call depositPromise - fundMethod is:",
-          fundMethod,
-        )
-
-        await Promise.all([
-          depositPromise(),
-          waitForOriginMetaTxnReceiptPromise(),
-          waitForDestinationMetaTxnReceiptPromise(),
-          queueCctpPromise(),
-        ])
-        logger.console.log("[trails-sdk] Phase 2 completed successfully")
-
-        // Track payment completion for different chain and different token
-        if (originUserTxReceipt && destinationMetaTxnReceipt) {
-          // Check if any transaction failed or was refunded
-          const hasAnyCallFailed = transactionStates.some((tx) =>
-            tx?.decodedGuestModuleEvents?.some(
-              (e: any) => e?.type === "CallFailed",
-            ),
-          )
-          const hasAnyRefunded = transactionStates.some((tx) => tx?.refunded)
-          const txStatus =
-            !hasAnyCallFailed && !hasAnyRefunded ? "success" : "fail"
-
-          // Always track payment completion regardless of success/failure
-          trackPaymentCompleted({
-            userAddress: account.address,
-            originIntentAddress,
-            originTxHash: (originUserTxReceipt as TransactionReceipt)
-              .transactionHash,
-            destinationTxHash: (destinationMetaTxnReceipt as MetaTxnReceipt)
-              ?.txnHash,
-            originChainId,
-            destinationChainId,
-            mode,
-            fundMethod,
-            originTokenSymbol,
-            originTokenAddress,
-            destinationTokenAddress,
-            destinationTokenSymbol,
-            depositTokenAmountUsd: depositAmountUsd?.toString(),
-            destinationTokenAmountUsd:
-              effectiveDestinationTokenAmountUsd?.toString(),
-          })
-
-          // Call onCheckoutComplete callback with transaction status
-          if (checkoutOnHandlers?.triggerCheckoutComplete) {
-            checkoutOnHandlers.triggerCheckoutComplete(txStatus)
-          }
-        } 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 {
-          originUserTxReceipt,
-          originMetaTxnReceipt,
-          destinationMetaTxnReceipt,
-          totalCompletionSeconds: await getTxTimeDiff(
-            transactionStates[0],
-            transactionStates[2],
-          ),
-        }
-      } catch (error) {
-        const errorMessage =
-          error instanceof Error
-            ? error.message
-            : "Unknown error occurred during transaction"
-        logger.console.error(
-          "[trails-sdk] Error in sendHandlerForDifferentChainDifferentToken:",
-          error,
-        )
-
-        // Track payment error
-        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
-      }
-    },
-  }
-}
-
-async function sendHandlerForSameChainSameToken({
-  originTokenAddress,
-  originTokenDecimals,
-  swapAmount,
-  destinationCalldata,
-  recipient,
-  walletClient,
-  onTransactionStateChange,
-  dryMode,
-  account,
-  chain,
-  transactionStates,
-  sourceTokenPriceUsd,
-  destinationTokenPriceUsd,
-  originNativeTokenPriceUsd,
-  slippageTolerance,
-  checkoutOnHandlers,
-  mode,
-  fundMethod,
-  gasless,
-  paymasterUrl,
-  selectedFeeToken,
-  trailsClient,
-  originRelayer,
-  abortSignal,
-}: {
-  originTokenAddress: string
-  originTokenDecimals: number
-  swapAmount: string
-  destinationCalldata?: string
-  recipient: string
-  originChainId: number
-  walletClient: WalletClient
-  publicClient: PublicClient
-  onTransactionStateChange: (transactionStates: TransactionState[]) => void
-  dryMode: boolean
-  account: Account
-  chain: Chain
-  transactionStates: TransactionState[]
-  sourceTokenPriceUsd?: number | null
-  destinationTokenPriceUsd?: number | null
-  originNativeTokenPriceUsd?: number | null
-  slippageTolerance?: string
-  checkoutOnHandlers?: CheckoutOnHandlers
-  mode?: "pay" | "fund" | "earn" | "swap" | "receive"
-  fundMethod?: string
-  gasless?: boolean
-  paymasterUrl?: string
-  selectedFeeToken?: any
-  trailsClient: TrailsAPIClient
-  originRelayer: Relayer.RpcRelayer
-  abortSignal?: AbortSignal
-}): Promise<PrepareSendReturn> {
-  logger.console.log("[trails-sdk] isToSameToken && isToSameChain")
-  const testnet = isTestnetDebugMode()
-  const effectiveOriginChain = testnet ? getTestnetChainInfo(chain)! : chain
-  const effectiveOriginChainId = effectiveOriginChain.id
-  const effectiveOriginTokenAddress = testnet
-    ? getTestnetOriginTokenAddress(effectiveOriginChainId)
-    : originTokenAddress
-  const effectivePublicClient = createPublicClient({
-    chain: effectiveOriginChain,
-    transport: http(),
-  })
-
-  let noSufficientBalance = false
-
-  const { hasEnoughBalance } = await checkAccountBalance({
-    account,
-    tokenAddress: originTokenAddress,
-    depositAmount: swapAmount,
-    publicClient: effectivePublicClient,
-  })
-
-  if (!hasEnoughBalance) {
-    noSufficientBalance = true
-  }
-
-  // Build origin call params and estimate gas limit for the quote
-  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-  const originCallParamsBase = buildSameChainTransactionParams({
-    hasCustomCalldata,
-    recipient,
-    effectiveOriginTokenAddress,
-    destinationCalldata,
-    swapAmount,
-    effectiveOriginChainId,
-    effectiveOriginChain,
-  })
-
-  logger.console.log(
-    "[trails-sdk][gas-estimation] About to estimate gas limit for quote with params:",
-    {
-      account: account.address,
-      to: originCallParamsBase.to,
-      data: originCallParamsBase.data,
-      value: originCallParamsBase.value,
-    },
-  )
-
-  const estimatedGasLimitForQuote = await estimateGasLimit(
-    effectivePublicClient,
-    {
-      account: account.address,
-      to: originCallParamsBase.to,
-      data: originCallParamsBase.data,
-      value: BigInt(originCallParamsBase.value),
-    },
-    "quote",
-  )
-
-  logger.console.log(
-    "[trails-sdk][gas-estimation] Estimated gas limit for quote:",
-    estimatedGasLimitForQuote,
-  )
-
-  const quote = await getNormalizedQuoteObject({
-    originDepositAddress: recipient,
-    destinationDepositAddress: recipient,
-    destinationAddress: recipient,
-    destinationCalldata,
-    originAmount: swapAmount, // fromAmount is same as toAmount for same chain same token
-    destinationAmount: swapAmount,
-    originTokenPriceUsd: sourceTokenPriceUsd?.toString() || null,
-    destinationTokenPriceUsd: destinationTokenPriceUsd?.toString() || null,
-    originTokenAddress: effectiveOriginTokenAddress,
-    destinationTokenAddress: effectiveOriginTokenAddress,
-    transactionStates,
-    originChainId: effectiveOriginChainId,
-    destinationChainId: effectiveOriginChainId,
-    originNativeTokenPriceUsd,
-    slippageTolerance,
-    quoteProvider: "",
-    noSufficientBalance,
-    estimatedGasLimit: estimatedGasLimitForQuote,
-    intent: undefined,
-  })
-
-  // Call onCheckoutQuote callback if provided
-  if (checkoutOnHandlers?.triggerCheckoutQuote) {
-    checkoutOnHandlers.triggerCheckoutQuote(quote)
-  }
-
-  return {
-    quote,
-    send: async ({
-      onOriginSend,
-    }: {
-      onOriginSend?: () => void
-    }): Promise<SendReturn> => {
-      try {
-        const { hasEnoughBalance, balanceError } = await checkAccountBalance({
-          account,
-          tokenAddress: effectiveOriginTokenAddress,
-          depositAmount: swapAmount,
-          publicClient: effectivePublicClient,
-        })
-
-        if (!hasEnoughBalance) {
-          throw balanceError
-        }
-
-        const depositAmountFormatted = Number(
-          formatUnits(BigInt(swapAmount), originTokenDecimals),
-        )
-        const depositAmountUsd = calcAmountUsdPrice({
-          amount: depositAmountFormatted,
-          usdPrice: sourceTokenPriceUsd,
-        })
-
-        const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-
-        // Build origin call params (reusing the same logic as quote estimation)
-        const originCallParamsBase = buildSameChainTransactionParams({
-          hasCustomCalldata,
-          recipient,
-          effectiveOriginTokenAddress,
-          destinationCalldata,
-          swapAmount,
-          effectiveOriginChainId,
-          effectiveOriginChain,
-        })
-
-        // Estimate gas limit for consistency with actual transaction
-        const gasLimit = await estimateGasLimit(
-          effectivePublicClient,
-          {
-            account: account.address,
-            to: originCallParamsBase.to,
-            data: originCallParamsBase.data,
-            value: BigInt(originCallParamsBase.value),
-          },
-          "send",
-        )
-
-        const originCallParams = {
-          ...originCallParamsBase,
-          gasLimit,
-        }
-
-        logger.console.log("[trails-sdk] origin call params", originCallParams)
-
-        let originUserTxReceipt: TransactionReceipt | null = null
-        const originMetaTxnReceipt: MetaTxnReceipt | null = null
-        const destinationMetaTxnReceipt: MetaTxnReceipt | null = null
-
-        await attemptSwitchChain({
-          walletClient,
-          desiredChainId: effectiveOriginChainId,
-        })
-        if (!dryMode) {
-          try {
-            onTransactionStateChange([
-              {
-                transactionHash: "",
-                explorerUrl: "",
-                chainId: effectiveOriginChainId,
-                state: "pending",
-                label: "Execute",
-              },
-            ])
-          } catch (error) {
-            logger.console.error(
-              "[trails-sdk] Error calling onTransactionStateChange:",
-              error,
-            )
-          }
-
-          // For gasless transactions with custom calldata, use the gasless deposit flow
-          if (gasless && hasCustomCalldata) {
-            logger.console.log(
-              "[trails-sdk] Using gasless intent entrypoint flow for same-chain transaction with custom calldata",
-            )
-
-            // Fetch fee options for gasless deposit
-            let feeOptions: any = null
-            try {
-              feeOptions = await getIntentEntrypointFeeOptions({
-                trailsClient,
-                userAddress: account.address as `0x${string}`,
-                tokenAddress: effectiveOriginTokenAddress as `0x${string}`,
-                amount: swapAmount,
-                intentAddress: recipient as `0x${string}`,
-                chainId: effectiveOriginChainId,
-              })
-              logger.console.log(
-                "[trails-sdk] [GASLESS-FLOW] Fetched intent entrypoint fee options for same-chain transaction:",
-                feeOptions,
-              )
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] [GASLESS-FLOW] Error fetching fee options for same-chain gasless transaction:",
-                error,
-              )
-            }
-
-            const receipt = await attemptGaslessDeposit({
-              account,
-              walletClient,
-              chain: effectiveOriginChain,
-              depositTokenAddress: effectiveOriginTokenAddress,
-              depositTokenAmount: swapAmount,
-              depositRecipient: recipient,
-              onOriginSend: () => {}, // No-op callback
-              feeOptions,
-              paymasterUrl,
-              selectedFeeToken,
-              trailsClient,
-              originRelayer,
-              abortSignal,
-            })
-
-            if (receipt) {
-              originUserTxReceipt = receipt
-
-              // Track the confirmed transaction
-              trackTransactionConfirmed({
-                transactionHash: receipt.transactionHash,
-                chainId: effectiveOriginChainId,
-                userAddress: account.address,
-                blockNumber: Number(receipt.blockNumber),
-                originTokenAddress,
-                depositTokenAmountUsd: depositAmountUsd?.toString(),
-              })
-
-              // Toast will be shown after transaction state analysis
-
-              // Update transaction state
-              try {
-                onTransactionStateChange([
-                  getTransactionStateFromReceipt(
-                    receipt,
-                    effectiveOriginChainId,
-                    transactionStates[0]?.label,
-                  ),
-                ])
-              } catch (error) {
-                logger.console.error(
-                  "[trails-sdk] Error calling onTransactionStateChange:",
-                  error,
-                )
-              }
-            }
-          } else {
-            // Non-gasless flow: handle approval if needed
-            if (hasCustomCalldata) {
-              try {
-                const needsApproval = await getNeedsApproval({
-                  publicClient: effectivePublicClient,
-                  token: effectiveOriginTokenAddress,
-                  account: account.address,
-                  spender: recipient,
-                  amount: maxUint256,
-                })
-
-                if (needsApproval) {
-                  const txHash = await approveERC20({
-                    walletClient,
-                    tokenAddress: effectiveOriginTokenAddress,
-                    spender: recipient,
-                    amount: maxUint256,
-                    chain: effectiveOriginChain,
-                  })
-
-                  logger.console.log("waiting for approve", txHash)
-                  await effectivePublicClient.waitForTransactionReceipt({
-                    hash: txHash,
-                  })
-                  logger.console.log("approve done")
-                }
-              } catch (error) {
-                logger.console.error(
-                  "[trails-sdk] Error approving ERC20",
-                  error,
-                )
-              }
-            }
-
-            // Show persistent toast for checkout flow
-            updatePersistentToast(
-              "Payment Started",
-              "Waiting for wallet confirmation...",
-              "info",
-            )
-
-            logger.console.log(
-              "[trails-sdk] origin call params",
-              originCallParams,
-            )
-            const txHash = await sendOriginTransaction(
-              account,
-              walletClient,
-              originCallParams as any,
-              {
-                depositTokenAmountUsd: depositAmountUsd?.toString(),
-              },
-            ) // TODO: Add proper type
-
-            logger.console.log("[trails-sdk] origin tx", txHash)
-
-            if (onOriginSend) {
-              onOriginSend()
-            }
-
-            // Wait for transaction receipt
-            const receipt =
-              await effectivePublicClient.waitForTransactionReceipt({
-                hash: txHash,
-              })
-            logger.console.log("[trails-sdk] receipt", receipt)
-            originUserTxReceipt = receipt
-
-            trackTransactionConfirmed({
-              transactionHash: txHash,
-              chainId: effectiveOriginChainId,
-              userAddress: account.address,
-              blockNumber: Number(receipt.blockNumber),
-              originTokenAddress,
-              depositTokenAmountUsd: depositAmountUsd?.toString(),
-            })
-
-            // Toast will be shown after transaction state analysis
-
-            try {
-              onTransactionStateChange([
-                getTransactionStateFromReceipt(
-                  originUserTxReceipt,
-                  effectiveOriginChainId,
-                  transactionStates[0]?.label,
-                ),
-              ])
-            } catch (error) {
-              logger.console.error(
-                "[trails-sdk] Error calling onTransactionStateChange:",
-                error,
-              )
-            }
-          }
-
-          // Show conditional toast based on transaction status
-          const chainInfo = getChainInfo(effectiveOriginChainId)
-          if (originUserTxReceipt) {
-            if (originUserTxReceipt?.status === "success") {
-              updatePersistentToast(
-                "Transfer Confirmed",
-                `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
-                "info",
-              )
-            } else {
-              updatePersistentToast(
-                "Transfer Failed",
-                `Your transaction on ${chainInfo?.name || "chain"} failed`,
-                "error",
-              )
-            }
-          }
-
-          // Track payment completion for same-chain same-token transaction
-          if (originUserTxReceipt && originUserTxReceipt.status === "success") {
-            // Check if any transaction failed or was refunded
-            const hasAnyCallFailed = transactionStates.some((tx) =>
-              tx?.decodedGuestModuleEvents?.some(
-                (e: any) => e?.type === "CallFailed",
-              ),
-            )
-            const hasAnyRefunded = transactionStates.some((tx) => tx?.refunded)
-            const txStatus =
-              !hasAnyCallFailed && !hasAnyRefunded ? "success" : "fail"
-
-            // Always track payment completion regardless of success/failure
-            trackPaymentCompleted({
-              userAddress: account.address,
-              originTxHash: originUserTxReceipt.transactionHash,
-              originChainId: effectiveOriginChainId, // Same chain
-              mode,
-              fundMethod,
-              originTokenAddress,
-              depositTokenAmountUsd: depositAmountUsd?.toString(),
-              destinationTokenAmountUsd: depositAmountUsd?.toString(), // same as deposit amount
-            })
-
-            // Call onCheckoutComplete callback with transaction status
-            if (checkoutOnHandlers?.triggerCheckoutComplete) {
-              checkoutOnHandlers.triggerCheckoutComplete(txStatus)
-            }
-          } else if (originUserTxReceipt) {
-            trackPaymentError({
-              error: "Transaction failed",
-              userAddress: account.address,
-              mode,
-              fundMethod,
-              originTokenAddress,
-            })
-
-            // Call onCheckoutError callback if provided
-            if (checkoutOnHandlers?.triggerCheckoutError) {
-              checkoutOnHandlers.triggerCheckoutError("Transaction failed")
-            }
-          }
-        }
-
-        return {
-          originUserTxReceipt,
-          originMetaTxnReceipt,
-          destinationMetaTxnReceipt,
-          totalCompletionSeconds: 0,
-        }
-      } catch (error) {
-        const errorMessage =
-          error instanceof Error
-            ? error.message
-            : "Unknown error occurred during transaction"
-        logger.console.error(
-          "[trails-sdk] Error in sendHandlerForSameChainSameToken:",
-          error,
-        )
-
-        // Track payment error
-        trackPaymentError({
-          error: errorMessage,
-          userAddress: account.address,
-          mode,
-          fundMethod,
-          originTokenAddress,
-        })
-
-        // Call onCheckoutError callback if provided
-        if (checkoutOnHandlers?.triggerCheckoutError) {
-          checkoutOnHandlers.triggerCheckoutError(errorMessage)
-        }
-
-        // Re-throw the error so caller can handle if needed
-        throw error
-      }
-    },
-  }
-}
-
-// This handler uses relay sdk directly
-async function _sendHandlerForSameChainDifferentToken({
-  originTokenAddress,
-  originTokenDecimals,
-  swapAmount,
-  destinationTokenAddress,
-  destinationTokenDecimals,
-  destinationCalldata,
-  recipient,
-  originChainId,
-  walletClient,
-  publicClient,
-  account,
-  tradeType = TradeType.EXACT_OUTPUT,
-  slippageTolerance,
-  onTransactionStateChange,
-  transactionStates,
-  sourceTokenPriceUsd,
-  destinationTokenPriceUsd,
-  originNativeTokenPriceUsd,
-  mode,
-  fundMethod,
-  originTokenSymbol,
-  destinationTokenSymbol,
-}: {
-  originTokenAddress: string
-  originTokenDecimals: number
-  swapAmount: string
-  destinationTokenAddress: string
-  destinationTokenDecimals: number
-  destinationCalldata?: string
-  recipient: string
-  originChainId: number
-  walletClient: WalletClient
-  publicClient: PublicClient
-  account: Account
-  tradeType?: TradeType
-  slippageTolerance?: string
-  onTransactionStateChange: (transactionStates: TransactionState[]) => void
-  transactionStates: TransactionState[]
-  sourceTokenPriceUsd?: number | null
-  destinationTokenPriceUsd?: number | null
-  originNativeTokenPriceUsd?: number | null
-  mode?: "pay" | "fund" | "earn" | "swap" | "receive"
-  fundMethod?: string
-  originTokenSymbol: string
-  destinationTokenSymbol: string
-}): Promise<PrepareSendReturn> {
-  const destinationTxs: { to: string; value: string; data: string }[] = []
-  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-  if (hasCustomCalldata && tradeType === TradeType.EXACT_OUTPUT) {
-    destinationTxs.push({
-      to: recipient,
-      value: destinationTokenAddress === zeroAddress ? swapAmount : "0",
-      data: destinationCalldata as `0x${string}`,
-    })
-  } else if (hasCustomCalldata && tradeType === TradeType.EXACT_INPUT) {
-    destinationTxs.push({
-      to: recipient,
-      value: "0",
-      data: destinationCalldata as `0x${string}`,
-    })
-  }
-
-  const quote = await getRelaySDKQuote({
-    wallet: walletClient,
-    chainId: originChainId,
-    amount: swapAmount,
-    currency: originTokenAddress,
-    toCurrency: destinationTokenAddress,
-    txs: destinationTxs,
-    tradeType: tradeType as unknown as RelayTradeType,
-    slippageTolerance: slippageTolerance,
-    recipient: hasCustomCalldata ? recipient : undefined,
-  })
-
-  logger.console.log("[trails-sdk] relaysdk quote", quote)
-  let depositAmount = "0"
-  let destinationTokenAmount = "0"
-
-  if (tradeType === TradeType.EXACT_INPUT) {
-    depositAmount = swapAmount
-    destinationTokenAmount = quote?.details?.currencyOut?.amount?.toString()
-  } else {
-    try {
-      destinationTokenAmount = swapAmount
-      depositAmount = quote.steps?.[0]?.items?.[0]?.data?.value
-      if (originTokenAddress !== zeroAddress) {
-        const decoded = decodeFunctionData({
-          abi: erc20Abi,
-          data: quote.steps?.[0]?.items?.[0]?.data?.data,
-        })
-        if (decoded.functionName === "approve") {
-          depositAmount = decoded.args[1].toString()
-        }
-        if (decoded.functionName === "transfer") {
-          depositAmount = decoded.args[1].toString()
-        }
-      }
-    } catch (error) {
-      logger.console.error("[trails-sdk] Error decoding function data:", error)
-    }
-  }
-
-  const depositOriginAddress =
-    quote?.steps?.[quote?.steps?.length - 1]?.items?.[
-      quote?.steps?.[quote?.steps?.length - 1]?.items?.length - 1
-    ]?.data?.to
-
-  if (
-    quote?.details?.currencyIn?.amountFormatted &&
-    quote?.details?.currencyIn?.amountUsd
-  ) {
-    const quoteProviderSourceTokenPriceUsd =
-      Number(quote.details.currencyIn.amountUsd) /
-      Number(quote.details.currencyIn.amountFormatted)
-    if (quoteProviderSourceTokenPriceUsd) {
-      sourceTokenPriceUsd = quoteProviderSourceTokenPriceUsd
-    }
-  }
-
-  if (
-    quote?.details?.currencyOut?.amountFormatted &&
-    quote?.details?.currencyOut?.amountUsd
-  ) {
-    const quoteProviderDestinationTokenPriceUsd =
-      Number(quote.details.currencyOut.amountUsd) /
-      Number(quote.details.currencyOut.amountFormatted)
-    if (quoteProviderDestinationTokenPriceUsd) {
-      destinationTokenPriceUsd = quoteProviderDestinationTokenPriceUsd
-    }
-  }
-
-  const normalizedQuote = await getNormalizedQuoteObject({
-    originDepositAddress: depositOriginAddress,
-    destinationDepositAddress: recipient,
-    destinationAddress: recipient,
-    destinationCalldata,
-    originAmount: depositAmount,
-    destinationAmount: destinationTokenAmount,
-    originTokenAddress: originTokenAddress,
-    destinationTokenAddress: destinationTokenAddress,
-    originTokenPriceUsd: sourceTokenPriceUsd?.toString() || null,
-    destinationTokenPriceUsd: destinationTokenPriceUsd?.toString() || null,
-    fees: getFeesFromRelaySdkQuote(quote),
-    slippageTolerance: getSlippageToleranceFromRelaySdkQuote(quote),
-    priceImpact: getPriceImpactFromRelaySdkQuote(quote),
-    priceImpactUsd: getPriceImpactUsdFromRelaySdkQuote(quote),
-    transactionStates,
-    originChainId,
-    destinationChainId: originChainId,
-    originNativeTokenPriceUsd,
-    quoteProvider: "relay",
-    intent: undefined,
-  })
-
-  return {
-    quote: normalizedQuote,
-    send: async ({
-      onOriginSend,
-    }: {
-      onOriginSend?: () => void
-    }): Promise<SendReturn> => {
-      const { hasEnoughBalance, balanceError } = await checkAccountBalance({
-        account,
-        tokenAddress: originTokenAddress,
-        depositAmount,
-        publicClient,
-      })
-
-      if (!hasEnoughBalance) {
-        throw balanceError
-      }
-
-      await attemptSwitchChain({
-        walletClient,
-        desiredChainId: originChainId,
-      })
-
-      const result = await executeSimpleRelayTransaction(quote, walletClient)
-      logger.console.log("[trails-sdk] relaysdk result", result)
-
-      const txHash = getTxHashFromRelayResult(result)
-
-      if (onOriginSend) {
-        onOriginSend()
-      }
-
-      const originUserTxReceipt = await publicClient.waitForTransactionReceipt({
-        hash: txHash as `0x${string}`,
-      })
-
-      transactionStates[0] = getTransactionStateFromReceipt(
-        originUserTxReceipt,
-        originChainId,
-        transactionStates[0]?.label,
-      )
-
-      try {
-        onTransactionStateChange(transactionStates)
-      } catch (error) {
-        logger.console.error(
-          "[trails-sdk] Error calling onTransactionStateChange:",
-          error,
-        )
-      }
-
-      const depositAmountFormatted = Number(
-        formatUnits(BigInt(depositAmount), originTokenDecimals),
-      )
-
-      const depositAmountUsd = calcAmountUsdPrice({
-        amount: depositAmountFormatted,
-        usdPrice: sourceTokenPriceUsd,
-      })
-
-      const destinationTokenAmountFormatted = Number(
-        formatUnits(BigInt(destinationTokenAmount), destinationTokenDecimals),
-      )
-
-      const destinationTokenAmountUsd = calcAmountUsdPrice({
-        amount: Number(destinationTokenAmountFormatted),
-        usdPrice: destinationTokenPriceUsd,
-      })
-
-      // Track payment completion for same-chain different-token transaction
-      if (originUserTxReceipt && originUserTxReceipt.status === "success") {
-        trackPaymentCompleted({
-          userAddress: account.address,
-          originTxHash: originUserTxReceipt.transactionHash,
-          originChainId,
-          destinationChainId: originChainId, // Same chain
-          mode,
-          fundMethod,
-          originTokenAddress,
-          originTokenSymbol,
-          destinationTokenAddress,
-          destinationTokenSymbol,
-          depositTokenAmountUsd: depositAmountUsd?.toString(),
-          destinationTokenAmountUsd: destinationTokenAmountUsd?.toString(),
-        })
-      } else if (originUserTxReceipt) {
-        trackPaymentError({
-          error: "Relay transaction failed",
-          userAddress: account.address,
-          mode,
-          fundMethod,
-          originTokenAddress,
-          originTokenSymbol,
-          destinationTokenAddress,
-          destinationTokenSymbol,
-        })
-      }
-
-      return {
-        originUserTxReceipt: originUserTxReceipt,
-        originMetaTxnReceipt: null,
-        destinationMetaTxnReceipt: null,
-        totalCompletionSeconds: 0,
-      }
-    },
-  }
-}
-
-async function attemptGaslessDeposit({
-  paymasterUrl,
-  depositTokenAddress,
-  depositTokenAmount,
-  depositRecipient,
-  onOriginSend,
-  walletClient,
-  chain,
-  account,
-  trailsClient,
-  originRelayer,
-  feeOptions,
-  selectedFeeToken,
-  abortSignal,
-}: {
-  paymasterUrl?: string
-  depositTokenAddress: string
-  depositTokenAmount: string
-  depositRecipient: string
-  onOriginSend?: () => void
-  walletClient: WalletClient
-  chain: Chain
-  account: Account
-  trailsClient: TrailsAPIClient
-  originRelayer: Relayer.RpcRelayer
-  feeOptions: any
-  selectedFeeToken?: any
-  abortSignal?: AbortSignal
-}): Promise<TransactionReceipt | null> {
-  let originUserTxReceipt: TransactionReceipt | null = null
-  const originChainId = chain.id
-
-  logger.console.log(
-    "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] attemptGaslessDeposit called with:",
-    {
-      originChainId,
-      depositTokenAddress,
-      depositTokenAmount,
-      depositRecipient,
-      hasFeeOptions: !!feeOptions,
-      feeOptionsLength: feeOptions?.feeOptions?.length,
-      selectedFeeToken,
-      hasSelectedFeeToken: !!selectedFeeToken,
-      paymasterUrl,
-    },
-  )
-
-  const publicClient = createPublicClient({
-    chain,
-    transport: http(),
-  })
-
-  logger.console.log("[trails-sdk] [GASLESS-FLOW] Intent entrypoint check:", {
-    chainId: chain.id,
-    chainName: chain.name,
-    intentEntrypoint: TRAILS_INTENT_ENTRYPOINT_ADDRESS,
-  })
-
-  // NEW FLOW: Use Intent Entrypoint API with permit2 support
-  logger.console.log(
-    "[trails-sdk] Using Intent Entrypoint API flow with permit2 support for gasless deposit",
-  )
-
-  // Switch to correct chain before requesting signatures
-  logger.console.log(
-    "[trails-sdk] [GASLESS-FLOW] Switching to chain before permit/intent signatures",
-    { originChainId },
-  )
-  await attemptSwitchChain({
-    walletClient,
-    desiredChainId: originChainId,
-  })
-
-  try {
-    if (paymasterUrl) {
-      logger.console.log(
-        "[trails-sdk] [GASLESS-FLOW] doing gasless with paymaster",
-      )
-
-      // Switch to correct chain before requesting signatures
-      logger.console.log(
-        "[trails-sdk] [GASLESS-FLOW] Switching chain for paymaster flow",
-      )
-      await attemptSwitchChain({
-        walletClient,
-        desiredChainId: originChainId,
-      })
-
-      const delegatorSmartAccount = await getDelegatorSmartAccount({
-        publicClient,
-      })
-
-      const calls: Array<{
-        to: string
-        data: string
-        value: string
-      }> = await getPaymasterGaslessTransaction({
-        walletClient,
-        chain,
-        tokenAddress: depositTokenAddress as `0x${string}`,
-        amount: BigInt(depositTokenAmount),
-        recipient: depositRecipient as `0x${string}`,
-        delegatorSmartAccount,
-      })
-
-      logger.console.log("[trails-sdk] calls", calls)
-
-      const txHash = await sendPaymasterGaslessTransaction({
-        walletClient,
-        publicClient,
-        chain,
-        paymasterUrl,
-        delegatorSmartAccount,
-        calls,
-      })
-
-      if (onOriginSend) {
-        onOriginSend()
-      }
-
-      const receipt = await publicClient.waitForTransactionReceipt({
-        hash: txHash as `0x${string}`,
-      })
-      logger.console.log("[trails-sdk] receipt", receipt)
-      return receipt
-    }
-
-    const deadline = Math.floor(Date.now() / 1000) + 3600 // 1 hour from now
-    const hasFeeOptions = Boolean(
-      feeOptions && feeOptions.feeOptions?.length > 0,
-    )
-
-    // 1. Check if we need approval - check if we have enough allowance for this transaction (deposit + fee if same token)
-    let requiredAmount = BigInt(depositTokenAmount)
-
-    // Match selectedFeeToken by tokenAddress to get the latest fee amount from feeOptions
-    let selectedFeeOption = null
-    if (selectedFeeToken && hasFeeOptions) {
-      // Find matching fee option by tokenAddress to get latest amount
-      selectedFeeOption = feeOptions.feeOptions.find(
-        (opt: any) =>
-          opt.tokenAddress?.toLowerCase() ===
-          selectedFeeToken.tokenAddress?.toLowerCase(),
-      )
-      logger.console.log(
-        "[trails-sdk] Matched selectedFeeToken to latest fee option:",
-        {
-          selectedFeeToken,
-          matchedOption: selectedFeeOption,
-        },
-      )
-    }
-
-    // Fallback to first fee option if no match or no selectedFeeToken
-    if (!selectedFeeOption && hasFeeOptions) {
-      selectedFeeOption = feeOptions.feeOptions[0]
-      logger.console.log(
-        "[trails-sdk] Using first fee option as fallback:",
-        selectedFeeOption,
-      )
-    }
-
-    // Only include fee in required amount if the fee token is the same as the deposit token
-    if (selectedFeeOption?.amount && selectedFeeOption?.tokenAddress) {
-      const feeTokenIsSameAsDepositToken =
-        selectedFeeOption.tokenAddress.toLowerCase() ===
-        depositTokenAddress.toLowerCase()
-
-      if (feeTokenIsSameAsDepositToken) {
-        requiredAmount = requiredAmount + BigInt(selectedFeeOption.amount)
-        logger.console.log(
-          "[trails-sdk] Fee token matches deposit token, including fee in required approval amount:",
-          {
-            depositAmount: depositTokenAmount,
-            feeAmount: selectedFeeOption.amount,
-            feeTokenAddress: selectedFeeOption.tokenAddress,
-            depositTokenAddress,
-            totalRequired: requiredAmount.toString(),
-          },
-        )
-      } else {
-        logger.console.log(
-          "[trails-sdk] Fee token differs from deposit token, separate approval will be needed:",
-          {
-            depositAmount: depositTokenAmount,
-            depositTokenAddress,
-            feeAmount: selectedFeeOption.amount,
-            feeTokenAddress: selectedFeeOption.tokenAddress,
-            depositTokenRequired: requiredAmount.toString(),
-          },
-        )
-      }
-    }
-
-    const needsApproval = await getNeedsIntentEntrypointApproval({
-      client: publicClient,
-      token: depositTokenAddress as `0x${string}`,
-      account: account.address,
-      entrypoint: TRAILS_INTENT_ENTRYPOINT_ADDRESS,
-      amount: requiredAmount, // Check if we have enough allowance for this specific transaction
-    })
-
-    logger.console.log(
-      "[trails-sdk] [GASLESS-FLOW] Checking permit requirements",
-      {
-        userAddress: account.address,
-        tokenAddress: depositTokenAddress,
-        depositAmount: depositTokenAmount,
-        requiredAmount: requiredAmount.toString(),
-        intentAddress: depositRecipient,
-        chainID: originChainId,
-        deadline,
-        needsApproval,
-      },
-    )
-
-    // 2. Get permit signature if approval needed for deposit token
-    // Note: Fee payment is handled by the backend/relayer, we only need permit for the deposit token
-    let permitSignature: string | undefined
-    let permitDeadline: number | undefined
-
-    if (needsApproval) {
-      logger.console.log(
-        "[trails-sdk] Getting permit signature for deposit token infinite approval",
-      )
-
-      // Use infinite approval (maxUint256) so user doesn't need to approve again
-      const permitAmount = maxUint256
-      logger.console.log(
-        "[trails-sdk] Using infinite approval for gasless deposits",
-        {
-          depositAmount: depositTokenAmount,
-          depositTokenAddress,
-          permitAmount: permitAmount.toString(),
-        },
-      )
-
-      const permitSig = await getPermitSignature({
-        publicClient,
-        walletClient,
-        signer: account.address,
-        spender: TRAILS_INTENT_ENTRYPOINT_ADDRESS,
-        tokenAddress: depositTokenAddress as `0x${string}`,
-        amount: permitAmount, // Infinite approval
-        chain,
-        deadline: BigInt(deadline),
-      })
-      permitSignature = permitSig.signature
-      permitDeadline = Number(permitSig.deadline)
-      logger.console.log(
-        "[trails-sdk] Deposit token permit signature obtained for infinite approval",
-      )
-    }
-
-    // 3. Get current nonce for the user
-    logger.console.log("[trails-sdk] Getting user nonce")
-    const nonce = await getUserNonce({
-      publicClient,
-      userAddress: account.address,
-      intentEntrypoint: TRAILS_INTENT_ENTRYPOINT_ADDRESS,
-    })
-    logger.console.log("[trails-sdk] User nonce:", nonce.toString())
-
-    // 4. Get intent signature
-    logger.console.log("[trails-sdk] Requesting intent signature via EIP-712")
-    // Get fee collector address from fee options response, or use selected fee option's collector
-    const feeCollectorAddress = (selectedFeeOption?.feeCollector ||
-      feeOptions?.feeCollector) as `0x${string}` | undefined
-
-    // Validate that we have a valid fee collector address
-    if (!feeCollectorAddress || feeCollectorAddress === zeroAddress) {
-      throw new Error(
-        "[trails-sdk] Fee collector address not provided by API. Cannot proceed with gasless deposit. " +
-          "Please ensure the API is returning feeCollector in the fee options response.",
-      )
-    }
-
-    logger.console.log(
-      "[trails-sdk] Using fee collector address:",
-      feeCollectorAddress,
-    )
-
-    const { signature: intentSignature } = await signIntent({
-      client: walletClient,
-      intentParams: {
-        user: account.address,
-        token: depositTokenAddress as `0x${string}`,
-        amount: BigInt(depositTokenAmount),
-        intentAddress: depositRecipient as `0x${string}`,
-        deadline: BigInt(deadline),
-        chainId: originChainId,
-        contractAddress: TRAILS_INTENT_ENTRYPOINT_ADDRESS,
-        nonce,
-        feeAmount: BigInt(selectedFeeOption?.amount || "0"),
-        feeCollector: feeCollectorAddress,
-      },
-    })
-    logger.console.log("[trails-sdk] Intent signature received")
-
-    // 5. Call the deposit endpoint with permit support and optional fee
-    logger.console.log(
-      "[trails-sdk] Calling getIntentEntrypointDeposit with permit enabled",
-      { usePermit: needsApproval, hasFee: !!feeOptions },
-    )
-
-    // selectedFeeOption was already determined at the start of the try block
-
-    logger.console.log(
-      "[trails-sdk] Calling getIntentEntrypointDeposit with params:",
-      {
-        userAddress: account.address,
-        tokenAddress: depositTokenAddress,
-        amount: depositTokenAmount,
-        intentAddress: depositRecipient,
-        chainID: originChainId,
-        deadline,
-        usePermit: needsApproval,
-        hasPermitSignature: !!permitSignature,
-        feeAmount: selectedFeeOption?.amount,
-        feeTokenSymbol: selectedFeeOption?.tokenSymbol,
-        selectedFeeToken,
-        usingSelectedFeeToken: !!selectedFeeToken,
-      },
-    )
-
-    const depositDataResponse = await trailsClient.getIntentEntrypointDeposit({
-      params: {
-        userAddress: account.address,
-        tokenAddress: depositTokenAddress,
-        amount: depositTokenAmount,
-        intentAddress: depositRecipient,
-        chainID: originChainId,
-        deadline,
-        intentSignature,
-        usePermit: needsApproval, // Use permit if approval needed
-        permitAmount: needsApproval ? maxUint256.toString() : undefined, // Pass infinite approval amount
-        permitSignature,
-        permitDeadline,
-        feeAmount: selectedFeeOption?.amount || undefined,
-      },
-    })
-
-    const depositData = depositDataResponse.result
-    logger.console.log("[trails-sdk] Deposit data received:", {
-      depositWalletAddress: depositData.depositWalletAddress,
-      entrypointAddress: depositData.entrypointAddress,
-      metaTxnId: depositData.metaTxn?.id,
-      usedPermit2: needsApproval,
-    })
-
-    // 5. Send meta transaction via relayer
-    logger.console.log("[trails-sdk] Sending meta transaction to relayer")
-    const feeQuoteObj = depositData.feeQuote
-      ? ({
-          _tag: "FeeQuote",
-          _quote: { toJSON: () => depositData.feeQuote },
-        } as any)
-      : undefined
-
-    const opHash = await relayerSendMetaTx(
-      originRelayer,
-      depositData.metaTxn as any,
-      [], // No preconditions for gasless deposit
-      feeQuoteObj,
-    )
-    logger.console.log("[trails-sdk] Meta transaction sent, opHash:", opHash)
-
-    if (onOriginSend) {
-      onOriginSend()
-    }
-
-    // 6. Wait for transaction receipt
-    logger.console.log("[trails-sdk] Waiting for transaction receipt")
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      // Check if we should abort
-      if (abortSignal?.aborted) {
-        logger.console.log(
-          "[trails-sdk] Aborting gasless deposit polling due to abort signal",
-        )
-        return null
-      }
-
-      const receipt: any = await getMetaTxStatus(
-        originRelayer,
-        depositData.metaTxn.id,
-        Number(depositData.metaTxn.chainId),
-      )
-      logger.console.log("[trails-sdk] Meta transaction status:", receipt)
-
-      if (receipt?.transactionHash) {
-        const metaTxnReceipt = receipt.data?.receipt
-        if (!metaTxnReceipt) {
-          throw new Error("No meta txn receipt found")
-        }
-
-        // Get the full transaction receipt
-        const txReceipt = await publicClient.getTransactionReceipt({
-          hash: receipt.transactionHash as `0x${string}`,
-        })
-        logger.console.log("[trails-sdk] Transaction receipt:", txReceipt)
-        originUserTxReceipt = txReceipt
-        break
-      }
-
-      await new Promise((resolve) =>
-        setTimeout(resolve, POLLING_INTERVALS.META_TRANSACTION),
-      )
-    }
-  } catch (error) {
-    logger.console.error(
-      "[trails-sdk] Error in Intent Entrypoint gasless deposit with permit2:",
-      error,
-    )
-    throw error
-  }
-
-  return originUserTxReceipt
-}
-
-export async function attemptNonGaslessUserDeposit({
-  originTokenAddress,
-  firstPreconditionMin,
-  onOriginSend,
-  publicClient,
-  walletClient,
-  originChainId,
-  chain,
-  account,
-  fee,
-  dryMode,
-  sourceTokenPriceUsd,
-  destinationTokenPriceUsd,
-  swapAmount,
-  destinationTokenDecimals,
-  sourceTokenDecimals,
-  originIntentAddress,
-  onTransactionStateChange,
-  transactionStates,
-  originTokenSymbol,
-  destinationTokenSymbol,
-  depositAmountUsd,
-}: {
-  originTokenAddress: string
-  firstPreconditionMin: string
-  onOriginSend?: () => void
-  publicClient: PublicClient
-  walletClient: WalletClient
-  originChainId: number
-  chain: Chain
-  account: Account
-  fee: string
-  dryMode: boolean
-  sourceTokenPriceUsd?: number | null
-  destinationTokenPriceUsd?: number | null
-  swapAmount: string
-  destinationTokenDecimals: number
-  sourceTokenDecimals: number
-  originIntentAddress: string
-  onTransactionStateChange: (transactionStates: TransactionState[]) => void
-  transactionStates: TransactionState[]
-  originTokenSymbol: string
-  destinationTokenSymbol: string
-  depositAmountUsd: number
-}): Promise<TransactionReceipt | null> {
-  let originUserTxReceipt: TransactionReceipt | null = null
-  const usingLIfi = false
-  let needsNativeFee = false
-
-  if (usingLIfi) {
-    needsNativeFee = await getNeedsLifiNativeFee({
-      originTokenAddress,
-      destinationTokenAmount: swapAmount,
-      destinationTokenDecimals,
-      sourceTokenDecimals,
-      sourceTokenPriceUsd: sourceTokenPriceUsd ?? null,
-      destinationTokenPriceUsd: destinationTokenPriceUsd ?? null,
-      depositAmount: firstPreconditionMin,
-    })
-  }
-  let nativeFee = parseUnits("0.00005", 18).toString()
-  if (originChainId === 137) {
-    nativeFee = parseUnits("1.5", 18).toString()
-  }
-
-  logger.console.log("[trails-sdk] needsNativeFee", needsNativeFee)
-
-  // Build origin call params
-  const originCallParamsBase = buildCrossChainDepositParams({
-    originTokenAddress,
-    originIntentAddress,
-    depositAmount: firstPreconditionMin,
-    fee,
-    originChainId,
-    chain,
-  })
-
-  // Estimate gas limit for consistency with actual transaction
-  const gasLimit = await estimateGasLimit(
-    publicClient,
-    {
-      account: account.address,
-      to: originCallParamsBase.to,
-      data: originCallParamsBase.data,
-      value: BigInt(originCallParamsBase.value),
-    },
-    "deposit",
-  )
-
-  const originCallParams = {
-    ...originCallParamsBase,
-    gasLimit,
-  }
-
-  await attemptSwitchChain({
-    walletClient,
-    desiredChainId: originChainId,
-  })
-
-  let useSendCalls = false
-  const moreThan1Tx = needsNativeFee
-
-  if (moreThan1Tx) {
-    try {
-      // the reason for the timeout is some users experience this call to hang indefinitely on metamask on all chains.
-      // not sure why this is happening, but it happens.
-      const capabilities = await requestWithTimeout<Record<string, any>>(
-        walletClient,
-        [
-          {
-            method: "wallet_getCapabilities",
-            params: [account.address],
-          },
-        ],
-        10000,
-      )
-
-      logger.console.log("[trails-sdk] capabilities", capabilities)
-
-      // Check if the chain supports atomic transactions
-      const chainHex = `0x${originChainId.toString(16)}` as const
-      const chainCapabilities = capabilities[chainHex]
-      useSendCalls = chainCapabilities?.atomic?.status === "supported"
-    } catch (error) {
-      logger.console.error("[trails-sdk] Error getting capabilities", error)
-    }
-  }
-
-  if (dryMode) {
-    logger.console.log("[trails-sdk] dry mode, skipping send calls")
-  }
-
-  if (useSendCalls) {
-    logger.console.log("[trails-sdk] using sendCalls")
-  } else {
-    logger.console.log("[trails-sdk] using sendTransaction")
-  }
-
-  if (useSendCalls) {
-    if (!dryMode) {
-      const calls: Array<{
-        to: `0x${string}`
-        data: `0x${string}`
-        value?: `0x${string}`
-      }> = []
-      if (needsNativeFee) {
-        calls.push({
-          to: originIntentAddress as `0x${string}`,
-          data: "0x00",
-          value: `0x${BigInt(nativeFee).toString(16)}` as `0x${string}`,
-        })
-      }
-
-      // Add the origin call
-      calls.push({
-        to: originCallParams.to as `0x${string}`,
-        data: originCallParams.data as `0x${string}`,
-        value: originCallParams.value
-          ? `0x${BigInt(originCallParams.value).toString(16)}`
-          : "0x0",
-      })
-
-      // Update persistent toast before wallet interaction
-      updatePersistentToast(
-        "Waiting for Confirmation",
-        "Please confirm the transaction in your wallet...",
-        "info",
-      )
-
-      // Send the batched call via EIP-7702
-      const result = (await walletClient.request({
-        method: "wallet_sendCalls",
-        params: [
-          {
-            version: "2.0.0",
-            chainId: `0x${originChainId.toString(16)}`,
-            atomicRequired: true,
-            calls,
-          },
-        ],
-      })) as { requestId: `0x${string}` }
-
-      logger.console.log("[trails-sdk] sendCalls result", result)
-      const requestId = result.requestId || (result as any).id
-
-      // Poll to check if the tx has been submitted
-      let txHash: `0x${string}` | undefined
-      while (!txHash) {
-        const status = (await walletClient.request({
-          method: "wallet_getCallsStatus",
-          params: [requestId],
-        })) as {
-          status: "pending" | "submitted" | "failed"
-          transactionHash?: `0x${string}`
-          error?: string
-        }
-
-        logger.console.log("[trails-sdk] getCallsStatus result", status)
-        const receipt = (status as any)?.receipts?.[0]
-
-        if ((status as any).status === 200 && receipt?.transactionHash) {
-          txHash = receipt.transactionHash
-          break
-        } else if ((status as any).status === 500) {
-          throw new Error(`Transaction failed: ${status.error}`)
-        }
-
-        // wait a bit before polling again
-        await new Promise((r) => setTimeout(r, 2000))
-      }
-
-      if (onOriginSend) {
-        onOriginSend()
-      }
-
-      // Update persistent toast after transaction sent
-      const chainInfo = getChainInfo(originChainId)
-      updatePersistentToast(
-        "Transaction Submitted",
-        `Waiting for confirmation on ${chainInfo?.name || "chain"}...`,
-        "info",
-      )
-
-      const receipt = await publicClient.waitForTransactionReceipt({
-        hash: txHash as `0x${string}`,
-      })
-      logger.console.log("[trails-sdk] receipt", receipt)
-      originUserTxReceipt = receipt
-    }
-  } else {
-    if (!dryMode) {
-      if (needsNativeFee) {
-        const txHashNativeFee = await sendOriginTransaction(
-          account,
-          walletClient,
-          {
-            to: originIntentAddress,
-            data: "0x00",
-            value: nativeFee,
-            chainId: originChainId,
-            chain,
-          } as any,
-          {
-            depositTokenAmountUsd: depositAmountUsd?.toString(),
-          },
-        ) // TODO: Add proper type
-        logger.console.log("[trails-sdk] origin tx native fee", txHashNativeFee)
-        // Wait for transaction receipt
-        const feeReceipt = await publicClient.waitForTransactionReceipt({
-          hash: txHashNativeFee,
-        })
-        logger.console.log("[trails-sdk] nativeFeeReceipt", feeReceipt)
-      }
-
-      // Show persistent toast for checkout flow
-      updatePersistentToast(
-        "Payment Started",
-        "Waiting for wallet confirmation...",
-        "info",
-      )
-
-      const txHash = await sendOriginTransaction(
-        account,
-        walletClient,
-        originCallParams as any,
-        {
-          depositTokenAmountUsd: depositAmountUsd?.toString(),
-        },
-      ) // TODO: Add proper type
-      logger.console.log("[trails-sdk] origin tx", txHash)
-
-      if (onOriginSend) {
-        onOriginSend()
-      }
-
-      if (transactionStates[0]) {
-        transactionStates[0].state = "pending"
-
-        try {
-          onTransactionStateChange(transactionStates)
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error calling onTransactionStateChange:",
-            error,
-          )
-        }
-      }
-
-      // Wait for transaction receipt
-      const receipt = await publicClient.waitForTransactionReceipt({
-        hash: txHash,
-      })
-
-      const chainInfo = getChainInfo(originChainId)
-      updatePersistentToast(
-        "Transfer Confirmed",
-        `Your transaction on ${chainInfo?.name || "chain"} has been confirmed`,
-        "info",
-      )
-
-      trackTransactionConfirmed({
-        transactionHash: txHash,
-        chainId: originChainId,
-        userAddress: account.address,
-        blockNumber: Number(receipt.blockNumber),
-        originIntentAddress,
-        originTokenSymbol,
-        destinationTokenSymbol,
-        depositTokenAmountUsd: depositAmountUsd?.toString(),
-      })
-
-      logger.console.log("[trails-sdk] receipt", receipt)
-      originUserTxReceipt = receipt
-    }
-  }
-
-  return originUserTxReceipt
-}
-
-async function attemptUserDepositTx({
-  originTokenAddress,
-  gasless,
-  paymasterUrl,
-  chain,
-  account,
-  originRelayer,
-  firstPreconditionMin,
-  originIntentAddress,
-  onOriginSend,
-  publicClient,
-  walletClient,
-  destinationTokenDecimals,
-  sourceTokenDecimals,
-  fee,
-  dryMode,
-  sourceTokenPriceUsd,
-  destinationTokenPriceUsd,
-  swapAmount,
-  onTransactionStateChange,
-  transactionStates,
-  fundMethod,
-  originTokenSymbol,
-  destinationTokenSymbol,
-  depositAmountUsd,
-  feeOptions,
-  trailsClient,
-  selectedFeeToken,
-  walletId,
-  abortSignal,
-}: {
-  originTokenAddress: string
-  gasless: boolean
-  paymasterUrl?: string
-  chain: Chain
-  account: Account
-  originRelayer: Relayer.RpcRelayer
-  firstPreconditionMin: string
-  originIntentAddress: string
-  onOriginSend?: () => void
-  publicClient: PublicClient
-  walletClient: WalletClient
-  destinationTokenDecimals: number
-  sourceTokenDecimals: number
-  swapAmount: string
-  dryMode: boolean
-  sourceTokenPriceUsd: number | null
-  destinationTokenPriceUsd: number | null
-  fee: string
-  onTransactionStateChange: (transactionStates: TransactionState[]) => void
-  transactionStates: TransactionState[]
-  fundMethod?: string
-  originTokenSymbol: string
-  destinationTokenSymbol: string
-  depositAmountUsd: number
-  feeOptions?: any
-  trailsClient: TrailsAPIClient
-  selectedFeeToken?: any
-  walletId?: string
-  abortSignal?: AbortSignal
-}): Promise<TransactionReceipt | null> {
-  let originUserTxReceipt: TransactionReceipt | null = null
-  const originChainId = chain.id
-
-  logger.console.log(
-    "[trails-sdk] attemptUserDepositTx called with fundMethod:",
-    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 null
-  }
-
-  const doGasless = getDoGasless(
-    originTokenAddress,
-    gasless,
-    feeOptions,
-    selectedFeeToken,
-    walletId,
-  )
-  logger.console.log(
-    "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] doGasless check results:",
-    {
-      doGasless,
-      paymasterUrl,
-      hasFeeOptions: !!feeOptions,
-      feeOptionsCount: feeOptions?.feeOptions?.length || 0,
-      selectedFeeToken,
-      selectedFeeTokenSet:
-        selectedFeeToken !== null && selectedFeeToken !== undefined,
-      originTokenAddress,
-      gasless,
-      isNotNative: originTokenAddress !== zeroAddress,
-    },
-  )
-  if (doGasless || paymasterUrl) {
-    logger.console.log(
-      "[trails-sdk] [GASLESS-FLOW] Entering gasless deposit flow",
-      {
-        doGasless,
-        hasPaymasterUrl: !!paymasterUrl,
-        paymasterUrl,
-      },
-    )
-    try {
-      originUserTxReceipt = await attemptGaslessDeposit({
-        paymasterUrl,
-        depositTokenAddress: originTokenAddress,
-        depositTokenAmount: firstPreconditionMin,
-        depositRecipient: originIntentAddress,
-        onOriginSend,
-        walletClient,
-        chain,
-        account,
-        trailsClient,
-        originRelayer,
-        feeOptions: feeOptions,
-        selectedFeeToken: selectedFeeToken,
-        abortSignal,
-      })
-    } catch (error) {
-      logger.console.log("[trails-sdk] gassless attempt failed", error)
-      // In strict gasless mode, re-throw error instead of falling back
-      if (gasless) {
-        throw error
-      }
-    }
-  }
-
-  // If gasless attempt failed, try to send a regular transaction
-  if (!originUserTxReceipt && !gasless) {
-    originUserTxReceipt = await attemptNonGaslessUserDeposit({
-      originTokenAddress,
-      firstPreconditionMin,
-      originIntentAddress,
-      onOriginSend,
-      publicClient,
-      walletClient,
-      originChainId,
-      chain,
-      account,
-      fee,
-      dryMode,
-      sourceTokenPriceUsd,
-      destinationTokenPriceUsd,
-      swapAmount,
-      destinationTokenDecimals,
-      sourceTokenDecimals,
-      onTransactionStateChange,
-      transactionStates,
-      originTokenSymbol,
-      destinationTokenSymbol,
-      depositAmountUsd,
-    })
-  }
-
-  return originUserTxReceipt
-}
-
-export function getDoGasless(
-  originTokenAddress: string,
-  gasless: boolean,
-  feeOptions?: any,
-  selectedFeeToken?: any,
-  walletId?: string,
-): boolean {
-  // Don't use gasless flow for sequence-waas wallet
-  if (walletId === "sequence-waas") {
-    logger.console.log(
-      "[trails-sdk] [GASLESS-FLOW] getDoGasless: Skipping gasless flow for sequence-waas wallet",
-    )
-    return false
-  }
-
-  const hasFeeOptions = Boolean(feeOptions && feeOptions.feeOptions?.length > 0)
-
-  // Important: The UI passes selectedFeeToken in these states:
-  // - null: User explicitly chose "Pay with native gas"
-  // - {object}: User selected a fee token OR it was auto-selected
-  // - undefined: Should not happen (initial state auto-selects if options exist)
-
-  // If selectedFeeToken is null, user explicitly chose native gas
-  if (selectedFeeToken === null) {
-    logger.console.log(
-      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless: User explicitly selected native gas (null)",
-    )
-    return false
-  }
-
-  // If selectedFeeToken is undefined and no fee options, can't do gasless
-  if (!selectedFeeToken && !hasFeeOptions) {
-    logger.console.log(
-      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless: No fee token selected and no fee options available",
-    )
-    return false
-  }
-
-  // If selectedFeeToken is undefined but fee options exist, use first ERC20 option
-  let effectiveFeeToken = selectedFeeToken
-  if (!effectiveFeeToken && hasFeeOptions) {
-    const firstFeeOption = feeOptions.feeOptions[0]
-
-    // Check if first option is native gas
-    const isFirstOptionNative =
-      firstFeeOption?.tokenAddress === zeroAddress ||
-      firstFeeOption?.tokenAddress?.toLowerCase() === zeroAddress ||
-      firstFeeOption?.isNative === true
-
-    if (!isFirstOptionNative && firstFeeOption?.tokenAddress) {
-      // First fee option is ERC20, use it
-      effectiveFeeToken = firstFeeOption
-      logger.console.log(
-        "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless: No fee token selected, using first ERC20 fee option",
-        {
-          feeOption: effectiveFeeToken,
-        },
-      )
-    } else {
-      logger.console.log(
-        "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless: First fee option is native gas, skipping gasless",
-      )
-      return false
-    }
-  }
-
-  // Check if the effective fee token is native gas
-  const isNativeGasFee =
-    !effectiveFeeToken ||
-    effectiveFeeToken.tokenAddress === zeroAddress ||
-    effectiveFeeToken.tokenAddress?.toLowerCase() === zeroAddress ||
-    effectiveFeeToken.isNative === true
-
-  // Don't use gasless if origin token is native (sending ETH)
-  if (originTokenAddress === zeroAddress) {
-    logger.console.log(
-      "[trails-sdk] [GASLESS-FLOW] getDoGasless: Origin token is native, skipping gasless",
-    )
-    return false
-  }
-
-  // Don't use gasless if fee token is native
-  if (isNativeGasFee) {
-    logger.console.log(
-      "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless: Fee token is native gas, skipping gasless",
-      {
-        effectiveFeeToken,
-      },
-    )
-    return false
-  }
-
-  // Don't use gasless if disabled
-  if (!gasless) {
-    logger.console.log(
-      "[trails-sdk] [GASLESS-FLOW] getDoGasless: Gasless disabled",
-    )
-    return false
-  }
-
-  // All conditions met, use gasless with ERC20 fee token
-  logger.console.log(
-    "[trails-sdk] [GASLESS-FLOW] [FEE-SELECT] getDoGasless decision: Using gasless",
-    {
-      originTokenAddress,
-      gasless,
-      hasFeeOptions,
-      selectedFeeToken,
-      effectiveFeeToken,
-      feeOptionsCount: feeOptions?.feeOptions?.length || 0,
-    },
-  )
-
-  return true
-}
-
-function getTransactionStateFromReceipt(
-  receipt: TransactionReceipt | MetaTxnReceipt,
-  chainId: number,
-  label: string = "Transaction",
-): TransactionState {
-  let txHash: string = ""
-  let state: TransactionStateStatus = "pending"
-  let blockNumber: number = 0
-  if ("transactionHash" in receipt) {
-    txHash = receipt.transactionHash
-    state = receipt.status === "success" ? "confirmed" : "failed"
-    blockNumber = Number(receipt.blockNumber)
-  } else if ("txnHash" in receipt) {
-    txHash = receipt.txnHash
-    state = receipt.status === "SUCCEEDED" ? "confirmed" : "failed"
-    blockNumber = Number(receipt.blockNumber)
-  }
-
-  return {
-    transactionHash: txHash,
-    explorerUrl: getExplorerUrl({ txHash, chainId }),
-    chainId,
-    blockNumber,
-    state,
-    label,
-  }
-}
-
-async function sendMetaTxAndWaitForReceipt({
-  metaTx,
-  relayer,
-  precondition,
-  feeQuote,
-}: {
-  metaTx: MetaTxn
-  relayer: Relayer.RpcRelayer
-  precondition: IntentPrecondition | null
-  feeQuote?: string
-}): Promise<{
-  waitForReceipt: (abortSignal?: AbortSignal) => Promise<MetaTxnReceipt | null>
-}> {
-  try {
-    logger.console.log("[trails-sdk] metaTx", metaTx)
-    trackRelayerCallStarted({
-      walletAddress: metaTx.walletAddress as `0x${string}`,
-      contractAddress: metaTx.contract as `0x${string}`,
-      chainId: Number(metaTx.chainId),
-    })
-    const feeQuoteObj = feeQuote
-      ? ({ _tag: "FeeQuote", _quote: { toJSON: () => feeQuote } } as any)
-      : undefined
-    logger.console.log("[trails-sdk] feeQuote", feeQuoteObj)
-    const opHash = await relayerSendMetaTx(
-      relayer,
-      metaTx,
-      precondition ? [precondition] : ([] as IntentPrecondition[]),
-      feeQuoteObj,
-    )
-    logger.console.log("[trails-sdk] opHash", opHash)
-
-    trackRelayerCallCompleted({
-      walletAddress: metaTx.walletAddress as `0x${string}`,
-      contractAddress: metaTx.contract as `0x${string}`,
-      chainId: Number(metaTx.chainId),
-    })
-  } catch (error) {
-    trackRelayerCallError({
-      walletAddress: metaTx.walletAddress as `0x${string}`,
-      contractAddress: metaTx.contract as `0x${string}`,
-      chainId: Number(metaTx.chainId),
-      error: error instanceof Error ? error.message : "Unknown error",
-    })
-    throw error
-  }
-
-  return {
-    waitForReceipt: async (abortSignal?: AbortSignal) => {
-      let originMetaTxnReceipt: MetaTxnReceipt | null = null
-
-      // Create a unique ID for this polling operation
-      const pollingId = `meta-txn-${metaTx.id}-${metaTx.chainId}-${Date.now()}`
-
-      // Create an abort controller for this specific polling operation
-      const pollingAbortController = new AbortController()
-
-      // Register this polling operation with the global registry
-      abortControllerRegistry.register(pollingId, pollingAbortController)
-
-      try {
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
-          // Check if we should abort (either from external signal or global registry)
-          if (abortSignal?.aborted || pollingAbortController.signal.aborted) {
-            logger.console.log(
-              "[trails-sdk] Aborting meta transaction polling due to abort signal",
-            )
-            return null
-          }
-
-          logger.console.log(
-            "[trails-sdk] polling status",
-            metaTx.id as `0x${string}`,
-            metaTx.chainId.toString(),
-          )
-          const receipt: any = await getMetaTxStatus(
-            relayer,
-            metaTx.id,
-            Number(metaTx.chainId),
-          )
-          logger.console.log("[trails-sdk] status", receipt)
-          if (receipt?.transactionHash) {
-            originMetaTxnReceipt = receipt.data?.receipt
-            if (!originMetaTxnReceipt) {
-              throw new Error("No meta txn receipt found")
-            }
-            break
-          }
-
-          // Check abort signal before waiting
-          if (abortSignal?.aborted || pollingAbortController.signal.aborted) {
-            logger.console.log(
-              "[trails-sdk] Aborting meta transaction polling before delay",
-            )
-            return null
-          }
-
-          // Use consistent delay and check abort signal during the delay
-          await new Promise((resolve) => {
-            const timeoutId = setTimeout(
-              resolve,
-              POLLING_INTERVALS.META_TRANSACTION,
-            )
-
-            // Listen for abort signal during the delay
-            const abortHandler = () => {
-              clearTimeout(timeoutId)
-              resolve(undefined)
-            }
-
-            if (abortSignal) {
-              abortSignal.addEventListener("abort", abortHandler, {
-                once: true,
-              })
-            }
-            pollingAbortController.signal.addEventListener(
-              "abort",
-              abortHandler,
-              { once: true },
-            )
-          })
-        }
-
-        return originMetaTxnReceipt
-      } finally {
-        // Always unregister when polling completes or is aborted
-        abortControllerRegistry.unregister(pollingId)
-      }
-    },
-  }
-}
-
-/**
- * Check if the account has enough balance for the deposit amount
- */
-async function checkAccountBalance({
-  account,
-  tokenAddress,
-  depositAmount,
-  publicClient,
-}: {
-  account: Account
-  tokenAddress: string
-  depositAmount: string
-  publicClient: PublicClient
-}): Promise<{
-  hasEnoughBalance: boolean
-  balance: bigint
-  requiredAmount: bigint
-  balanceFormatted: string
-  requiredAmountFormatted: string
-  balanceError: Error | null
-}> {
-  try {
-    let balance: bigint
-
-    if (tokenAddress === zeroAddress) {
-      // Native token balance
-      balance = await publicClient.getBalance({ address: account.address })
-    } else {
-      // ERC20 token balance
-      balance = await publicClient.readContract({
-        address: tokenAddress as `0x${string}`,
-        abi: erc20Abi,
-        functionName: "balanceOf",
-        args: [account.address],
-      })
-    }
-
-    const requiredAmount = BigInt(depositAmount)
-
-    logger.console.log("[trails-sdk] balance", balance)
-    logger.console.log("[trails-sdk] requiredAmount", requiredAmount)
-    const hasEnoughBalance = balance >= requiredAmount
-    logger.console.log("[trails-sdk] hasEnoughBalance", hasEnoughBalance)
-
-    let balanceFormatted = ""
-    let requiredAmountFormatted = ""
-    if (tokenAddress === zeroAddress) {
-      balanceFormatted = formatUnits(balance, 18)
-      requiredAmountFormatted = formatUnits(requiredAmount, 18)
-    } else {
-      // ERC20 token balance
-      const decimals = await publicClient.readContract({
-        address: tokenAddress as `0x${string}`,
-        abi: erc20Abi,
-        functionName: "decimals",
-      })
-      if (!decimals) {
-        throw new Error("Decimals not found")
-      }
-      balanceFormatted = formatUnits(balance, decimals)
-      requiredAmountFormatted = formatUnits(requiredAmount, decimals)
-    }
-
-    let balanceError = null
-    if (!hasEnoughBalance) {
-      balanceError = new InsufficientBalanceError(
-        `Insufficient balance: Need ${formatAmount(requiredAmountFormatted)} ${tokenAddress} for ${account.address} on ${publicClient.chain?.name} but only have ${formatAmount(balanceFormatted)} ${tokenAddress}`,
-      )
-    }
-
-    return {
-      hasEnoughBalance,
-      balance,
-      balanceFormatted,
-      requiredAmount,
-      requiredAmountFormatted,
-      balanceError,
-    }
-  } catch (error) {
-    logger.console.error("[trails-sdk] Error checking account balance:", error)
-    return {
-      hasEnoughBalance: false,
-      balance: BigInt(0),
-      balanceFormatted: "0",
-      requiredAmount: BigInt(0),
-      requiredAmountFormatted: "0",
-      balanceError: error instanceof Error ? error : null,
-    }
-  }
-}
-
-// ETH fee required by some bridges for low token amounts
-// TODO: update backend API to return the native fee requirement, if any
-function getNeedsLifiNativeFee({
-  originTokenAddress,
-  destinationTokenAmount,
-  destinationTokenDecimals,
-  sourceTokenDecimals,
-  sourceTokenPriceUsd,
-  destinationTokenPriceUsd,
-  depositAmount,
-}: {
-  originTokenAddress: string
-  destinationTokenAmount: string
-  destinationTokenDecimals: number
-  sourceTokenDecimals: number
-  sourceTokenPriceUsd: number | null
-  destinationTokenPriceUsd: number | null
-  depositAmount: string
-}): boolean {
-  let needsNativeFee = false
-  if (
-    originTokenAddress !== zeroAddress &&
-    sourceTokenPriceUsd &&
-    destinationTokenPriceUsd &&
-    depositAmount &&
-    destinationTokenDecimals !== undefined &&
-    sourceTokenDecimals !== undefined
-  ) {
-    // Convert from wei to token units using formatUnits
-    const destinationAmount = Number(
-      formatUnits(BigInt(destinationTokenAmount), destinationTokenDecimals),
-    )
-    const depositAmountFormatted = Number(
-      formatUnits(BigInt(depositAmount), sourceTokenDecimals),
-    )
-    logger.console.log("[trails-sdk] destinationAmount", destinationAmount)
-    logger.console.log(
-      "[trails-sdk] depositAmountFormatted",
-      depositAmountFormatted,
-    )
-    const destinationAmountUsd = calcAmountUsdPrice({
-      amount: destinationAmount,
-      usdPrice: destinationTokenPriceUsd,
-    })
-    const depositAmountUsd = calcAmountUsdPrice({
-      amount: depositAmountFormatted,
-      usdPrice: sourceTokenPriceUsd,
-    })
-    const diff = depositAmountUsd - destinationAmountUsd
-    logger.console.log(
-      "[trails-sdk] destinationAmountUsd",
-      destinationAmountUsd,
-      "[trails-sdk] depositAmountUsd",
-      depositAmountUsd,
-      "[trails-sdk] diff",
-      diff,
-    )
-    if (diff >= 0 && diff <= 0.02) {
-      needsNativeFee = true
-    }
-  }
-
-  return needsNativeFee
-}
-
-// Re-export useQuote types and hook from the new location
-export type {
-  UseQuoteProps,
-  Quote,
-  UseQuoteReturn,
-  SwapReturn,
-  QuoteProviderInfo,
-} from "./widget/hooks/useQuote.js"
-export { useQuote } from "./widget/hooks/useQuote.js"
-
-// Import QuoteProviderInfo for use in this file
-import type { QuoteProviderInfo } from "./widget/hooks/useQuote.js"
-
-export function getFeesFromIntent(
-  intent: GetIntentCallsPayloadsReturn,
-  {
-    tradeType,
-    fromAmountUsd,
-    toAmountUsd,
-  }: { tradeType: TradeType; fromAmountUsd: number; toAmountUsd: number },
-): PrepareSendFees {
-  const totalFeeAmountUsd = intent.payloads?.trailsFee?.totalFeeUSD ?? 0
-  const totalFeeAmountUsdDisplay = formatUsdAmountDisplay(totalFeeAmountUsd)
-
-  logger.console.log("[trails-sdk] getFeesFromIntent", {
-    tradeType,
-    fromAmountUsd,
-    toAmountUsd,
-    totalFeeAmountUsd,
-    totalFeeAmountUsdDisplay,
-  })
-
-  return {
-    feeTokenAddress: intent.payloads.trailsFee?.feeToken ?? zeroAddress,
-    totalFeeAmount: intent.payloads.trailsFee?.totalFeeAmount ?? "0",
-    totalFeeAmountUsd: totalFeeAmountUsd.toString(),
-    totalFeeAmountUsdDisplay,
-  }
-}
-
-export function getSlippageToleranceFromIntent(
-  intent: GetIntentCallsPayloadsReturn,
-): string {
-  return intent.payloads.quote?.maxSlippage?.toString() ?? "0"
-}
-
-export function getPriceImpactFromIntent(
-  intent: GetIntentCallsPayloadsReturn,
-): string {
-  return intent.payloads?.quote?.priceImpact?.toString() ?? "0"
-}
-
-export function getPriceImpactUsdFromIntent(
-  intent: GetIntentCallsPayloadsReturn,
-): string {
-  // Temporary type assertion until API types are regenerated
-  return (intent.payloads?.quote as any)?.priceImpactUsd?.toString() ?? "0"
-}
-
-export function getFeesFromRelaySdkQuote(quote: RelayQuote): PrepareSendFees {
-  const totalFeeAmountUsd = quote?.fees?.relayer?.amount ?? 0
-  const totalFeeAmountUsdDisplay = formatUsdAmountDisplay(totalFeeAmountUsd)
-  return {
-    feeTokenAddress: quote?.fees?.relayer?.currency?.address ?? zeroAddress,
-    totalFeeAmount: quote?.fees?.relayer?.amount ?? "0",
-    totalFeeAmountUsd: totalFeeAmountUsd.toString(),
-    totalFeeAmountUsdDisplay,
-  }
-}
-
-export function getSlippageToleranceFromRelaySdkQuote(
-  quote: RelayQuote,
-): string {
-  return (
-    Number(quote?.details?.slippageTolerance?.origin?.percent ?? "0") / 100
-  ).toString()
-}
-
-export function getPriceImpactFromRelaySdkQuote(quote: RelayQuote): string {
-  return (quote?.details?.swapImpact?.percent ?? 0).toString()
-}
-
-export function getPriceImpactUsdFromRelaySdkQuote(quote: RelayQuote): string {
-  return (quote?.details?.swapImpact?.usd ?? 0).toString()
-}
-
-export function getZeroFees(): PrepareSendFees {
-  return {
-    feeTokenAddress: zeroAddress,
-    totalFeeAmount: "0",
-    totalFeeAmountUsd: "0",
-    totalFeeAmountUsdDisplay: formatUsdAmountDisplay(0),
-  }
-}
-
-// TODO: make this dyanamic
-export function getCompletionEstimateSeconds({
-  originChainId,
-  destinationChainId,
-}: {
-  originChainId: number
-  destinationChainId: number
-}): number {
-  if (originChainId === mainnet.id && destinationChainId === mainnet.id) {
-    return 60
-  }
-
-  if (originChainId === mainnet.id || destinationChainId === mainnet.id) {
-    return 45
-  }
-
-  return 15
-}
-
-export async function getNormalizedQuoteObject({
-  originDepositAddress,
-  destinationDepositAddress,
-  destinationAddress,
-  destinationCalldata,
-  originChainId,
-  destinationChainId,
-  originAmount,
-  originAmountMin,
-  destinationAmount,
-  destinationAmountMin,
-  originTokenAddress,
-  destinationTokenAddress,
-  originTokenPriceUsd,
-  destinationTokenPriceUsd,
-  transactionStates,
-  fees,
-  slippageTolerance,
-  priceImpact,
-  priceImpactUsd,
-  originNativeTokenPriceUsd,
-  quoteProvider,
-  noSufficientBalance,
-  estimatedGasLimit,
-  intent,
-}: {
-  originDepositAddress?: string
-  destinationDepositAddress?: string
-  destinationAddress?: string
-  destinationCalldata?: string
-  originChainId: number
-  destinationChainId?: number
-  originAmount: string
-  originAmountMin?: string
-  destinationAmount: string
-  destinationAmountMin?: string
-  originTokenAddress: string
-  destinationTokenAddress?: string
-  originTokenPriceUsd?: string | null
-  destinationTokenPriceUsd?: string | null
-  transactionStates?: TransactionState[]
-  fees?: PrepareSendFees
-  slippageTolerance?: string
-  priceImpact?: string
-  priceImpactUsd?: string
-  originNativeTokenPriceUsd?: number | null
-  quoteProvider?: string
-  noSufficientBalance?: boolean
-  estimatedGasLimit?: bigint
-  intent?: GetIntentCallsPayloadsReturn
-}): Promise<PrepareSendQuote> {
-  if (!destinationChainId) {
-    throw new Error("Destination chain id is required")
-  }
-
-  if (!destinationTokenAddress && originChainId === destinationChainId) {
-    destinationTokenAddress = originTokenAddress
-  }
-
-  if (!destinationTokenAddress && originChainId === destinationChainId) {
-    destinationTokenAddress = originTokenAddress
-  }
-
-  if (!destinationTokenAddress) {
-    throw new Error("Destination token address is required")
-  }
-
-  const originToken = await getTokenInfo(originChainId, originTokenAddress)
-  const destinationToken = await getTokenInfo(
-    destinationChainId,
-    destinationTokenAddress,
-  )
-
-  const originChain = getChainInfo(originChainId)
-  const destinationChain = getChainInfo(destinationChainId)
-
-  if (!originToken || !destinationToken || !originChain || !destinationChain) {
-    logger.console.error("[trails-sdk] Token or chain not found", {
-      originToken,
-      destinationToken,
-      originChain,
-      destinationChain,
-    })
-    throw new Error("Token or chain not found")
-  }
-
-  const originAmountMinFormatted = formatRawAmount(
-    originAmountMin || "0",
-    originToken.decimals,
-  )
-  const originAmountMinUsdFormatted = formatAmount(
-    calcAmountUsdPrice({
-      amount: originAmountMinFormatted,
-      usdPrice: originTokenPriceUsd,
-    }),
-  )
-  const originAmountMinUsdDisplay = formatUsdAmountDisplay(
-    originAmountMinUsdFormatted,
-  )
-
-  const destinationAmountMinFormatted = formatRawAmount(
-    destinationAmountMin || "0",
-    destinationToken.decimals,
-  )
-  const destinationAmountMinUsdFormatted = formatAmount(
-    calcAmountUsdPrice({
-      amount: destinationAmountMinFormatted,
-      usdPrice: destinationTokenPriceUsd,
-    }),
-  )
-  const destinationAmountMinUsdDisplay = formatUsdAmountDisplay(
-    destinationAmountMinUsdFormatted,
-  )
-
-  const originAmountFormatted = formatRawAmount(
-    originAmount,
-    originToken.decimals,
-  )
-  const originAmountUsdFormatted = formatAmount(
-    calcAmountUsdPrice({
-      amount: originAmountFormatted,
-      usdPrice: originTokenPriceUsd,
-    }),
-  )
-  const originAmountUsdDisplay = formatUsdAmountDisplay(
-    originAmountUsdFormatted,
-  )
-
-  const destinationAmountFormatted = formatRawAmount(
-    destinationAmount,
-    destinationToken.decimals,
-  )
-  const destinationAmountUsdFormatted = formatAmount(
-    calcAmountUsdPrice({
-      amount: destinationAmountFormatted,
-      usdPrice: destinationTokenPriceUsd,
-    }),
-  )
-  const destinationAmountUsdDisplay = formatUsdAmountDisplay(
-    destinationAmountUsdFormatted,
-  )
-
-  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-
-  const publicClient = createPublicClient({
-    chain: originChain,
-    transport: http(),
-  })
-
-  let gasCostUsd: number = 0
-  let gasCostUsdDisplay: string = "0"
-  let gasCost: string = "0"
-  let gasCostFormatted: string = "0"
-  try {
-    if (originNativeTokenPriceUsd) {
-      // Use the actual estimated gas limit if provided, otherwise use default
-      // This ensures the quote gas cost matches what will be used in the actual transaction
-      const gasLimitForCost = estimatedGasLimit || DEFAULT_MIN_GASLIMIT
-
-      logger.console.log(
-        "[trails-sdk][gas-estimation] Calculating gas cost for quote with gasLimit:",
-        gasLimitForCost,
-        "(estimated:",
-        estimatedGasLimit,
-        "default:",
-        DEFAULT_MIN_GASLIMIT,
-        ")",
-      )
-
-      const gasCostWei = await estimateGasCost(publicClient, gasLimitForCost)
-      gasCost = gasCostWei.toString()
-      gasCostFormatted = formatUnits(gasCostWei, 18) // Native tokens always use 18 decimals
-
-      // Calculate USD value
-      gasCostUsd = await estimateGasCostUsd(
-        publicClient,
-        originNativeTokenPriceUsd,
-        gasLimitForCost,
-      )
-      gasCostUsdDisplay = formatUsdAmountDisplay(gasCostUsd)
-
-      logger.console.log(
-        "[trails-sdk][gas-estimation] Quote gas cost calculated:",
-        {
-          gasCostWei,
-          gasCost,
-          gasCostFormatted,
-          gasCostUsd,
-          gasCostUsdDisplay,
-        },
-      )
-    }
-  } catch (error) {
-    logger.console.error(
-      "[trails-sdk][gas-estimation] Error estimating gas cost for quote display",
-      error,
-    )
-  }
-
-  // Calculate exchange rates
-  const originTokenPrice = originTokenPriceUsd ? Number(originTokenPriceUsd) : 0
-  const destinationTokenPrice = destinationTokenPriceUsd
-    ? Number(destinationTokenPriceUsd)
-    : 0
-  const exchangeRates = getTokenExchangeRates(
-    originTokenPrice,
-    destinationTokenPrice,
-    originToken.symbol,
-    destinationToken.symbol,
-  )
-
-  let quoteProviderUrl = ""
-  if (quoteProvider === "cctp") {
-    quoteProviderUrl = "https://www.circle.com/"
-  } else if (quoteProvider === "relay") {
-    quoteProviderUrl = "https://relay.link/"
-  } else if (quoteProvider === "lifi") {
-    quoteProviderUrl = "https://li.fi/"
-  }
-
-  const quoteProviderNames = {
-    cctp: "Circle CCTP",
-    relay: "Relay",
-    lifi: "LiFi",
-  }
-
-  const quoteProviderName =
-    quoteProviderNames[quoteProvider as keyof typeof quoteProviderNames] ||
-    quoteProvider ||
-    ""
-  const quoteProviderInfo: QuoteProviderInfo = {
-    id: quoteProvider || "",
-    name: quoteProviderName || "",
-    url: quoteProviderUrl || "",
-  }
-
-  const priceImpactUsdDisplay = formatUsdAmountDisplay(priceImpactUsd)
-
-  // Extract fee breakdown from intent if available
-  let trailsFeeBreakdown = null
-  if (intent) {
-    trailsFeeBreakdown = await extractTrailsFeeBreakdown(intent)
-  }
-
-  return {
-    originDepositAddress: originDepositAddress || "",
-    destinationDepositAddress: destinationDepositAddress || "",
-    destinationAddress: destinationAddress || "",
-    destinationCalldata: hasCustomCalldata ? destinationCalldata || "" : "",
-    originAmount: originAmount || "0",
-    originAmountMin: originAmountMin || originAmount || "0",
-    originAmountMinUsdFormatted: originAmountMinUsdFormatted || "0",
-    originAmountMinUsdDisplay: originAmountMinUsdDisplay || "0",
-    destinationAmount: destinationAmount || "0",
-    destinationAmountMin: destinationAmountMin || destinationAmount || "0",
-    destinationAmountMinUsdFormatted: destinationAmountMinUsdFormatted || "0",
-    destinationAmountMinUsdDisplay: destinationAmountMinUsdDisplay || "0",
-    originAmountFormatted,
-    originAmountUsdFormatted,
-    originAmountUsdDisplay,
-    destinationAmountFormatted,
-    destinationAmountUsdFormatted,
-    destinationAmountUsdDisplay,
-    originToken,
-    destinationToken,
-    fees: fees || getZeroFees(),
-    slippageTolerance: slippageTolerance || "0",
-    priceImpact: priceImpact || "0",
-    priceImpactUsdDisplay: priceImpactUsdDisplay || "0",
-    originChain,
-    destinationChain,
-    completionEstimateSeconds: getCompletionEstimateSeconds({
-      originChainId,
-      destinationChainId,
-    }),
-    transactionStates: transactionStates || [],
-    gasCostUsd,
-    gasCostUsdDisplay,
-    gasCost,
-    gasCostFormatted,
-    originTokenRate: exchangeRates.originTokenRate,
-    destinationTokenRate: exchangeRates.destinationTokenRate,
-    originAmountDisplay: formatAmountDisplay(originAmountFormatted),
-    destinationAmountDisplay: formatAmountDisplay(destinationAmountFormatted),
-    originAmountMinDisplay: formatAmountDisplay(originAmountMinFormatted),
-    destinationAmountMinDisplay: formatAmountDisplay(
-      destinationAmountMinFormatted,
-    ),
-    quoteProvider: quoteProviderInfo,
-    noSufficientBalance: noSufficientBalance || false,
-    trailsFeeBreakdown,
-  }
-}
-
-function getTokenExchangeRates(
-  originTokenPrice: number,
-  destinationTokenPrice: number,
-  originTokenSymbol: string,
-  destinationTokenSymbol: string,
-): { originTokenRate: string; destinationTokenRate: string } {
-  if (originTokenPrice === 0 || destinationTokenPrice === 0) {
-    return {
-      originTokenRate: "0",
-      destinationTokenRate: "0",
-    }
-  }
-
-  const originToDestination = originTokenPrice / destinationTokenPrice
-  const destinationToOrigin = destinationTokenPrice / originTokenPrice
-
-  // Format the rates with appropriate precision
-  const originTokenRate = formatAmountDisplay(originToDestination, {
-    maxFractionDigits: destinationTokenSymbol === "USDC" ? 2 : 7,
-  })
-  const destinationTokenRate = formatAmountDisplay(destinationToOrigin, {
-    maxFractionDigits: originTokenSymbol === "USDC" ? 2 : 7,
-  })
-
-  return {
-    originTokenRate: `1 ${originTokenSymbol} = ${originTokenRate} ${destinationTokenSymbol}`,
-    destinationTokenRate: `1 ${destinationTokenSymbol} = ${destinationTokenRate} ${originTokenSymbol}`,
-  }
-}
+// Re-export quote and fee utilities from transactionIntent for backward compatibility
+export {
+  getFeesFromIntent,
+  getSlippageToleranceFromIntent,
+  getPriceImpactFromIntent,
+  getPriceImpactUsdFromIntent,
+  getFeesFromRelaySdkQuote,
+  getSlippageToleranceFromRelaySdkQuote,
+  getPriceImpactFromRelaySdkQuote,
+  getPriceImpactUsdFromRelaySdkQuote,
+  getZeroFees,
+  getCompletionEstimateSeconds,
+  getNormalizedQuoteObject,
+} from "./transactionIntent/index.js"