0xtrails 0.13.2 → 0.14.0

package/src/widget/hooks/useQuote.ts

@@ -1,1239 +0,0 @@
-import { useQuery, useQueryClient } from "@tanstack/react-query"
-import { useRef, useMemo, useState, useEffect } from "react"
-import type { TransactionReceipt } from "viem"
-import { zeroAddress, erc20Abi, parseUnits } from "viem"
-import { etherlink } from "viem/chains"
-import { useAccount } from "wagmi"
-import { useIndexerGatewayClient } from "../../indexerClient.js"
-import { balanceQueries } from "../../query/balance.queries.js"
-import { isNetworkError } from "../../query/helpers.js"
-import { logger } from "../../logger.js"
-import { useSupportedTokens } from "../../tokens.js"
-import { findSupportedToken } from "../utils/tokens.js"
-import { useTrailsClient } from "../../trailsClient.js"
-import { useTrails } from "../../widget/providers/TrailsProvider.js"
-import { getExplorerUrl } from "../../explorer.js"
-import { getFullErrorMessage, getPrettifiedErrorMessage } from "../../error.js"
-import { prepareSend } from "../../prepareSend.js"
-import { abortControllerRegistry } from "../../abortController.js"
-import { TradeType } from "../../prepareSend.js"
-import { getChainInfo } from "../../chains.js"
-import { useChainRpcClient } from "../../query/chains.hooks.js"
-import { getIsContract } from "../../contractUtils.js"
-import type { IntentTransaction } from "@0xtrails/api"
-import type {
-  PrepareSendOptions,
-  FundMethod,
-} from "../../transactionIntent/types.js"
-import type { Chain } from "../../chains.js"
-import type { Token } from "../../tokens.js"
-import type { TransactionState } from "../../transactions.js"
-import type { PrepareSendFees } from "../../prepareSend.js"
-import type { TrailsFeeBreakdown } from "../../fees.js"
-import { getTokenPrice } from "../../query/price.queries.js"
-import { useCommitIntent, useExecuteIntent } from "../../mutations.js"
-import type { CheckoutOnHandlers } from "./useCheckout.js"
-import type {
-  FeeOption,
-  RouteProvider,
-  PriceImpactDetails,
-} from "@0xtrails/api"
-import type { OnrampTrackingData } from "../types/analytics.js"
-import { isZeroOrInvalidAmount } from "../../utils/validation.js"
-import { addressEqual } from "../../utils/address.js"
-import { HOUR_MS } from "../../utils/time.js"
-
-/**
- * Configuration options for the `useQuote` hook.
- *
- * All parameters are optional, but the hook will not fetch a quote until all required
- * parameters are provided (walletClient, fromTokenAddress, fromChainId, toTokenAddress,
- * toChainId, swapAmount, toAddress, toApprove).
- */
-export type UseQuoteProps = {
-  /** The wallet client from wagmi (e.g., from `useWalletClient()`). Required for quote fetching. */
-  walletClient?: any // TODO: fix this, has to do with viem/wagmi versions
-  /** The contract address of the origin token. */
-  fromTokenAddress?: string | null
-  /** The chain ID of the origin chain */
-  fromChainId?: number | null
-  /** The contract address of the destination token. */
-  toTokenAddress?: string | null
-  /** The chain ID of the destination chain. */
-  toChainId?: number | null
-  /** Optional address to approve the destination token to. If not specified, the to address will be used. */
-  toApprove?: string | null
-  /** Optional custom calldata for the destination chain. Used for executing arbitrary contract calls. */
-  toCalldata?: string | null
-  /** The amount to swap, as a string or bigint in the token's smallest unit (wei/smallest unit). For example, 1 USDC (6 decimals) = '1000000'. */
-  swapAmount?: string | bigint
-  /** The recipient address for the destination token. */
-  toAddress?: string | null
-  /**
-   * @deprecated Use `toAddress` instead. This will be removed in a future version.
-   */
-  toRecipient?: string | null
-  /** The trade type: `TradeType.EXACT_INPUT` (you specify input amount) or `TradeType.EXACT_OUTPUT` (you specify output amount). Defaults to `EXACT_OUTPUT`. */
-  tradeType?: TradeType | null
-  /** Slippage tolerance as a decimal string or number (e.g., '0.005' for 0.5%, '0.01' for 1%). Defaults to a reasonable value if not provided. */
-  slippageTolerance?: string | number | null
-  /** Optional callback function that receives transaction state updates during swap execution. */
-  onStatusUpdate?: ((transactionStates: TransactionState[]) => void) | null
-  /** Optional quote swap provider ID to use. If not specified, the best available provider will be selected. */
-  swapProvider?: RouteProvider | null
-  /** Optional quote bridge provider ID to use. If not specified, the best available provider will be selected. */
-  bridgeProvider?: RouteProvider | null
-  /** Optional swap provider fallback flag passed to QuoteIntent request options. */
-  swapProviderFallback?: boolean
-  /** Optional bridge provider fallback flag passed to QuoteIntent request options. */
-  bridgeProviderFallback?: boolean
-  /**
-   * Optional checkout event handlers for tracking the states of a Trails transaction.
-   *
-   * @example
-   * ```ts
-   * checkoutOnHandlers: {
-   *   triggerCheckoutStart: () => {
-   *     console.log('Checkout started')
-   *   },
-   *   triggerCheckoutQuote: (quote) => {
-   *     console.log('Quote received:', quote)
-   *   },
-   *   triggerCheckoutComplete: (status, accountAddress) => {
-   *     console.log('Checkout completed:', status, accountAddress)
-   *   }
-   * }
-   * ```
-   *
-   * Available handlers:
-   * - `triggerCheckoutStart`
-   * - `triggerCheckoutQuote`
-   * - `triggerCheckoutSignatureRequest`
-   * - `triggerCheckoutSignatureConfirmed`
-   * - `triggerCheckoutSignatureRejected`
-   * - `triggerCheckoutComplete`
-   * - `triggerCheckoutError`
-   * - `triggerCheckoutStatusUpdate`
-   */
-  checkoutOnHandlers?: Partial<CheckoutOnHandlers>
-  /** Optional paymaster URL for gasless ERC-4337 transactions. */
-  paymasterUrl?: string
-  /** Optional fee option selection (e.g., user selects USDC as the fee token instead of ETH) */
-  selectedFeeOption?: FeeOption | null
-  /** Optional AbortSignal to cancel the quote request. */
-  abortSignal?: AbortSignal
-  /** Optional API key override for Trails API access. */
-  apiKey?: string | null
-  /** Optional environment override for node gateway ('prod' | 'dev' | 'local' | 'cors-anywhere'). */
-  nodeGatewayEnv?: "prod" | "dev" | "local" | "cors-anywhere"
-  /** Optional flag to indicate if the wallet is a smart wallet. */
-  isSmartWallet?: boolean | null
-  /** Optional fund method (e.g., 'wallet', 'direct-transfer', 'onramp-mesh', 'onramp-meld'). Used to determine default balance for external deposit flows. */
-  fundMethod?: FundMethod | null
-  /** Optional onramp tracking data for analytics */
-  onramp?: OnrampTrackingData | null
-  /** Optional mode for analytics tracking ('pay' | 'fund' | 'earn' | 'swap') */
-  mode?: "pay" | "fund" | "earn" | "swap" | "withdraw" | null
-}
-
-/**
- * Return type for the `swap` function returned by {@link useQuote}.
- *
- * Contains information about both the origin and destination transactions,
- * including transaction hashes, explorer URLs, and receipts.
- */
-export type SwapReturn = {
-  originTransaction: {
-    transactionHash?: string | null
-    explorerUrl?: string | null
-    receipt: TransactionReceipt | IntentTransaction | null
-  }
-  destinationTransaction: {
-    transactionHash?: string | null
-    explorerUrl?: string | null
-    receipt: IntentTransaction | null
-  }
-  totalCompletionSeconds?: number
-}
-
-/**
- * Information about a quote provider (LiFi, CCTP, Relay, etc.) used for routing the swap.
- */
-export type RouteProviderInfo = {
-  id: string
-  name: string
-  url: string
-}
-
-/**
- * A quote object containing all the details about a Trails intent transaction.
- *
- * Includes token amounts, fees, price impact, estimated completion time,
- * and other relevant information for displaying to the user.
- */
-export type Quote = {
-  // Kept for backward compatibility (use origin*/destination* versions)
-  fromAmount: string
-  fromAmountMin: string
-  toAmount: string
-  toAmountMin: string
-  fromAmountUsdDisplay: string
-  toAmountUsdDisplay: string
-  toAmountMinUsdDisplay: string
-  // PrepareSendQuote compatible names
-  originAmount: string
-  originAmountMin: string
-  destinationAmount: string
-  destinationAmountMin: string
-  originAmountUsdDisplay: string
-  destinationAmountUsdDisplay: string
-  originAmountDisplay: string
-  destinationAmountDisplay: string
-  originAmountMinDisplay: string
-  originAmountMinUsdFormatted: string
-  originAmountMinUsdDisplay: string
-  destinationAmountMinDisplay: string
-  destinationAmountMinUsdFormatted: string
-  destinationAmountMinUsdDisplay: string
-  originAmountUsdFormatted: string
-  destinationAmountUsdFormatted: string
-  // Locale display fields
-  intentProtocol: string
-  originAmountFormattedLocale?: string
-  originAmountUsdLocaleDisplay?: string
-  destinationAmountFormattedLocale?: string
-  destinationAmountUsdLocaleDisplay?: string
-  originAmountUsd?: number
-  fromAmountUsd?: number
-  // Common fields
-  originToken: Token
-  destinationToken: Token
-  originChain: Chain
-  destinationChain: Chain
-  fees: PrepareSendFees
-  slippageTolerance: string
-  priceImpact: string
-  priceImpactUsd: string | null
-  priceImpactUsdDisplay: string
-  priceImpactUsdLocaleDisplay?: string
-  completionEstimateSeconds: number
-  completionEstimateDisplay: string
-  transactionStates: TransactionState[]
-  originTokenRate: string
-  routeProviders: RouteProviderInfo[]
-  destinationTokenRate: string
-  originTokenPriceUsd: number
-  destinationTokenPriceUsd: number
-  gasCostUsd: number | null
-  gasCostUsdDisplay: string
-  gasCost: string
-  gasCostFormatted: string
-  totalFeesUsd: number | null
-  totalFeesUsdDisplay: string
-  totalGasUsd: number | null
-  totalGasUsdDisplay: string
-  intentId: string | null
-  originAmountFormatted: string
-  destinationAmountFormatted: string
-  originDepositAddress: string
-  destinationDepositAddress: string
-  destinationAddress: string
-  destinationApproveAddress: string
-  destinationCalldata: string
-  trailsFeeBreakdown: TrailsFeeBreakdown | null
-  originGasUsd: number | null
-  originGasUsdDisplay: string
-  destinationGasUsd: number | null
-  destinationGasUsdDisplay: string
-  providerFeeUsd: number | null
-  providerFeeUsdDisplay: string
-  trailsFeeUsd: number | null
-  trailsFeeUsdDisplay: string
-  totalProviderFeesUsd: number | null
-  totalProviderFeesUsdDisplay: string
-  // Locale display fields for fees
-  totalGasUsdLocaleDisplay?: string
-  originGasUsdLocaleDisplay?: string
-  destinationGasUsdLocaleDisplay?: string
-  totalProviderFeesUsdLocaleDisplay?: string
-  providerFeeUsdLocaleDisplay?: string
-  trailsFeeUsdLocaleDisplay?: string
-  noSufficientBalance: boolean
-  expiresAt: string | null
-  priceImpactDetails: PriceImpactDetails | null
-  // Passthrough fields for UI switching
-  passthroughEligible?: boolean
-  passthroughTransactionStates?: TransactionState[]
-}
-
-/**
- * Return type for the {@link useQuote} hook.
- *
- * Provides the quote data, send function, loading state, error information,
- * and utility functions for managing the quote lifecycle.
- */
-export type SendOptions = {
-  /** Override the fee option for this transaction (e.g., pay gas in USDC instead of ETH). */
-  selectedFeeOption?: FeeOption | null
-  /** Callback called when the wallet signature is confirmed and transaction is submitted. */
-  onOriginSend?: () => void
-  /** For onramp-meld flow, provide the deposit transaction hash directly. */
-  depositTransactionHash?: string
-  /** Skip committing the intent (used when intent is already committed). */
-  skipCommit?: boolean
-}
-
-export type UseQuoteReturn = {
-  /** The quote object with transaction details, or `null` if not available. */
-  quote: Quote | null
-  /** A function to execute the transaction, or `null` if not available. Returns a Promise that resolves to transaction result with receipts. Accepts optional SendOptions to override fee option. */
-  send: ((options?: SendOptions) => Promise<SwapReturn | null>) | null
-  /**
-   * @deprecated Use `send` instead. This will be removed in a future version.
-   */
-  swap: ((options?: SendOptions) => Promise<SwapReturn | null>) | null
-  /** Boolean indicating if a quote is currently being fetched. */
-  isLoadingQuote: boolean
-  /** Any error that occurred while fetching the quote, or `null`. */
-  quoteError: unknown
-  /** A user-friendly error message string. */
-  quoteErrorPrettified: string
-  /** Function to manually refetch the quote (useful for refreshing stale quotes). */
-  refetchQuote: () => Promise<void>
-  /** Function to abort any in-flight quote requests. */
-  abort: () => void
-  /** Fee options available for this quote (e.g., pay gas in different tokens). */
-  feeOptions: FeeOption[]
-  /** Whether the recipient address is a contract (null if not yet checked). */
-  isRecipientContract: boolean | null
-  /** Whether the sender address is a contract on the origin chain (null if not yet checked). */
-  isSenderContractOnOrigin: boolean | null
-  /** Whether the sender address is a contract on the destination chain (null if not yet checked). */
-  isSenderContractOnDestination: boolean | null
-}
-
-// TODO: consolidate useSendForm, prepareSend, and useQuote hooks into a single hook
-
-/**
- * React hook for fetching quotes and executing cross-chain or same-chain intent transactions.
- *
- * This hook provides a simple interface to get quotes for intent transactions and execute them.
- * It handles both cross-chain and same-chain intent transactions, automatically fetching token balances,
- * calculating fees, and providing transaction state updates.
- *
- * @example
- * Cross-chain swap example:
- * ```tsx
- * import { useQuote, TradeType } from '0xtrails'
- * import { useEffect } from 'react'
- * import { useWalletClient, useAccount } from 'wagmi'
- *
- * export const Swap = () => {
- *   const { data: walletClient } = useWalletClient()
- *   const { address } = useAccount()
- *
- *   const { quote, send, isLoadingQuote, quoteError, refetchQuote } = useQuote({
- *     walletClient,
- *     fromTokenAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', // USDC
- *     fromChainId: 1, // Ethereum
- *     toTokenAddress: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913', // USDC
- *     toChainId: 8453, // Base
- *     swapAmount: '1000000', // 1 USDC (6 decimals)
- *     tradeType: TradeType.EXACT_INPUT,
- *     toAddress: address,
- *     slippageTolerance: '0.005', // 0.5%
- *     onStatusUpdate: (states) => {
- *       console.log('Transaction states:', states)
- *     }
- *   })
- *
- *   // Quotes can become stale; refetch every ~30 seconds
- *   useEffect(() => {
- *     const id = setInterval(() => {
- *       refetchQuote?.()
- *     }, 30000)
- *     return () => clearInterval(id)
- *   }, [refetchQuote])
- *
- *   const handleSend = async () => {
- *     if (!send) return
- *
- *     try {
- *       const result = await send()
- *       console.log('Transaction completed:', result)
- *     } catch (error) {
- *       console.error('Transaction failed:', error)
- *     }
- *   }
- *
- *   if (isLoadingQuote) return <div>Getting quote...</div>
- *   if (quoteError) return <div>Error: {String(quoteError)}</div>
- *   if (!quote) return <div>No quote available</div>
- *
- *   return (
- *     <div>
- *       <div>From: {quote.fromAmount} {quote.originToken.symbol}</div>
- *       <div>To: {quote.toAmount} {quote.destinationToken.symbol}</div>
- *       <button onClick={handleSend}>Send</button>
- *     </div>
- *   )
- * }
- * ```
- *
- * @param props - Configuration options for the quote
- * @param props.walletClient - The wallet client from wagmi (e.g., from `useWalletClient()`)
- * @param props.fromTokenAddress - The contract address of the token to swap from.
- * @param props.fromChainId - The chain ID of the origin chain
- * @param props.toTokenAddress - The contract address of the token to swap to. Use `zeroAddress` for native tokens
- * @param props.toChainId - The chain ID of the destination chain
- * @param props.swapAmount - The amount to swap, as a string or bigint in the token's smallest unit (wei/smallest unit). For example, 1 USDC (6 decimals) = '1000000'
- * @param props.tradeType - The trade type: `TradeType.EXACT_INPUT` (you specify input amount) or `TradeType.EXACT_OUTPUT` (you specify output amount). Defaults to `EXACT_OUTPUT`
- * @param props.toAddress - The recipient address for the destination token.
- * @param props.slippageTolerance - Slippage tolerance as a decimal string or number (e.g., '0.005' for 0.5%, '0.01' for 1%). Defaults to a reasonable value if not provided
- * @param props.toCalldata - Optional custom calldata for the destination chain. Used for executing arbitrary contract calls (e.g., swap and mint an NFT on destination chain)
- * @param props.onStatusUpdate - Optional callback function that receives transaction state updates during swap execution
- * @param props.swapProvider - Optional swap provider ID to use (auto, lifi, relay, cctp, direct). If not specified, the best available provider will be selected
- * @param props.bridgeProvider - Optional bridge provider ID to use (auto, lifi, relay, cctp, direct). If not specified, the best available provider will be selected
- * @param props.checkoutOnHandlers - Optional event handlers for tracking checkout/transaction lifecycle events
- * @param props.paymasterUrl - Optional paymaster URL for gasless ERC-4337 transactions
- * @param props.selectedFeeOption - Optional fee option selection (e.g., user selects USDC as the fee token instead of ETH)
- * @param props.abortSignal - Optional AbortSignal to cancel the quote request
- * @param props.apiKey - Optional API key override for Trails API access
- * @param props.nodeGatewayEnv - Optional environment override ('prod' | 'dev' | 'local' | 'cors-anywhere')
- * @param props.isSmartWallet - Optional flag to indicate if the wallet is a smart wallet
- *
- * @returns An object containing:
- * - `quote` - The quote object with transaction details, or `null` if not available
- * - `send` - A function to execute the transaction, or `null` if not available. Returns a Promise that resolves to transaction result with receipts
- * - `isLoadingQuote` - Boolean indicating if a quote is currently being fetched
- * - `quoteError` - Any error that occurred while fetching the quote, or `null`
- * - `quoteErrorPrettified` - A user-friendly error message string
- * - `refetchQuote` - Function to manually refetch the quote (useful for refreshing stale quotes)
- * - `abort` - Function to abort any in-flight quote requests
- *
- * @remarks
- * - The hook uses React Query internally, so quotes are cached and automatically refetched based on query key changes
- * - Quotes are considered stale after 30 seconds. You may want to periodically call `refetchQuote()` to keep quotes fresh
- * - The hook will not fetch a quote until all required parameters are provided (walletClient, token addresses, chain IDs, swap amount, recipient)
- * - For native tokens (ETH, MATIC, etc.), use the zero address (`0x0000000000000000000000000000000000000000`)
- *
- * @see {@link TradeType} for available trade types
- * @see {@link Quote} for the quote object structure
- * @see {@link SwapReturn} for the swap result structure
- *
- * For more information go to {@link https://docs.trails.build/sdk/hooks#usequote-hook}
- */
-export function useQuote({
-  walletClient,
-  fromTokenAddress,
-  fromChainId,
-  toTokenAddress,
-  toChainId,
-  swapAmount,
-  tradeType,
-  toAddress,
-  toRecipient,
-  toApprove,
-  toCalldata,
-  slippageTolerance,
-  onStatusUpdate,
-  checkoutOnHandlers,
-  swapProvider,
-  bridgeProvider,
-  swapProviderFallback,
-  bridgeProviderFallback,
-  paymasterUrl,
-  selectedFeeOption,
-  nodeGatewayEnv,
-  abortSignal: externalAbortSignal,
-  apiKey,
-  isSmartWallet,
-  fundMethod,
-  onramp,
-  mode,
-}: Partial<UseQuoteProps> = {}): UseQuoteReturn {
-  // Handle deprecated toRecipient prop - prefer toAddress
-  if (toRecipient && !toAddress) {
-    logger.console.warn(
-      "[trails-sdk] [useQuote] Warning: 'toRecipient' is deprecated, use 'toAddress' instead",
-    )
-  }
-  const effectiveToAddress = toAddress ?? toRecipient
-
-  // Generate a unique session ID for this hook instance to ensure fresh quotes on mount
-  // This forces React Query to treat this as a new query even if parameters are identical
-  const quoteSessionId = useMemo(() => Date.now(), [])
-
-  // Set node gateway environment override for this quote session
-  if (nodeGatewayEnv) {
-    ;(globalThis as any).__testNodeGatewayEnv = nodeGatewayEnv
-  }
-
-  // Create abort controller for this hook instance
-  const abortControllerRef = useRef<AbortController>(new AbortController())
-
-  // Combine external abort signal with internal abort controller
-  const combinedAbortSignal = externalAbortSignal
-    ? (() => {
-        const controller = new AbortController()
-
-        // Listen to external abort signal
-        externalAbortSignal.addEventListener("abort", () => {
-          controller.abort()
-          abortControllerRef.current?.abort()
-        })
-
-        // Listen to internal abort controller
-        abortControllerRef.current?.signal.addEventListener("abort", () => {
-          controller.abort()
-        })
-
-        return controller.signal
-      })()
-    : abortControllerRef.current.signal
-
-  // Debounce swapAmount to prevent excessive API calls while user is typing
-  // Skip debounce for onramp-meld to get instant quotes after Meld quote is received
-  const [debouncedSwapAmount, setDebouncedSwapAmount] = useState(swapAmount)
-  useEffect(() => {
-    // No debounce for onramp-meld - instant quote fetching
-    if (fundMethod === "onramp-meld") {
-      setDebouncedSwapAmount(swapAmount)
-      return
-    }
-
-    const timer = setTimeout(() => {
-      setDebouncedSwapAmount(swapAmount)
-    }, 300)
-    return () => clearTimeout(timer)
-  }, [swapAmount, fundMethod])
-
-  const {
-    trailsApiKey,
-    trailsApiUrl,
-    sequenceIndexerUrl,
-    sequenceMetadataUrl,
-  } = useTrails()
-  // trailsApiKey is the same as sequenceProjectAccessKey
-  const sequenceProjectAccessKey = trailsApiKey
-
-  // Get wallet ID from wagmi
-  const { connector } = useAccount()
-  const walletId = connector?.id
-
-  const trailsClient = useTrailsClient({
-    apiKey: trailsApiKey,
-    hostname: trailsApiUrl,
-  })
-  const indexerGatewayClient = useIndexerGatewayClient()
-
-  // Get RPC clients for known chainIds using hooks (reads from TrailsProvider context)
-  const originPublicClient = useChainRpcClient(fromChainId ?? undefined)
-  const destinationPublicClient = useChainRpcClient(toChainId ?? undefined)
-
-  const { supportedTokens } = useSupportedTokens({
-    disabled: !!toTokenAddress || !!fromTokenAddress,
-  })
-
-  // Get mutation hooks for passing to prepareSend
-  const commitIntentMutation = useCommitIntent()
-  const executeIntentMutation = useExecuteIntent()
-
-  // Auto-detect swap/bridge provider for etherlink chains
-  const effectiveSwapProvider =
-    !swapProvider &&
-    (fromChainId === etherlink.id || toChainId === etherlink.id)
-      ? ("lifi" as RouteProvider)
-      : (swapProvider ?? null)
-
-  const effectiveBridgeProvider =
-    !bridgeProvider &&
-    (fromChainId === etherlink.id || toChainId === etherlink.id)
-      ? ("lifi" as RouteProvider)
-      : (bridgeProvider ?? null)
-
-  // - If address IS a contract: cache untill refresh
-  // - If address is NOT a contract: don't cache, keep checking
-
-  const queryClient = useQueryClient()
-
-  const senderAddress = walletClient?.account?.address?.toLowerCase()
-  const recipientAddress = effectiveToAddress?.toLowerCase()
-
-  // Check if sender and recipient are the same address (case-insensitive)
-  const isSameAddress =
-    senderAddress && recipientAddress && senderAddress === recipientAddress
-  // Check if origin and destination chains are the same
-  const isSameChain = fromChainId && toChainId && fromChainId === toChainId
-
-  // Helper to check if we already have a confirmed contract result cached
-  const hasCachedContractResult = (
-    address: string | undefined,
-    chainId: number | undefined,
-  ) => {
-    if (!address || !chainId) return false
-    const cached = queryClient.getQueryData(["isContract", address, chainId])
-    return cached === true // Only skip if we've confirmed it's a contract
-  }
-
-  // Query for sender on origin chain
-  const { data: senderOnOriginResult } = useQuery({
-    queryKey: ["isContract", senderAddress, fromChainId],
-    queryFn: async () => {
-      if (!senderAddress || !fromChainId) return null
-      return getIsContract(senderAddress as `0x${string}`, fromChainId)
-    },
-    enabled:
-      !!senderAddress &&
-      !!fromChainId &&
-      !hasCachedContractResult(senderAddress, fromChainId),
-    staleTime: (query) => (query.state.data === true ? Infinity : 0),
-    gcTime: HOUR_MS,
-  })
-
-  // Query for sender on destination chain - skip if same chain as origin (reuse origin result)
-  const { data: senderOnDestinationResult } = useQuery({
-    queryKey: ["isContract", senderAddress, toChainId],
-    queryFn: async () => {
-      if (!senderAddress || !toChainId) return null
-      return getIsContract(senderAddress as `0x${string}`, toChainId)
-    },
-    // Skip if same chain OR if we already have a cached contract result
-    enabled:
-      !!senderAddress &&
-      !!toChainId &&
-      !isSameChain &&
-      !hasCachedContractResult(senderAddress, toChainId),
-    staleTime: (query) => (query.state.data === true ? Infinity : 0),
-    gcTime: HOUR_MS,
-  })
-
-  // Query for recipient on destination chain - skip if same address as sender (reuse sender result)
-  const { data: recipientOnDestinationResult } = useQuery({
-    queryKey: ["isContract", recipientAddress, toChainId],
-    queryFn: async () => {
-      if (!recipientAddress || !toChainId) return null
-      return getIsContract(recipientAddress as `0x${string}`, toChainId)
-    },
-    // Skip if same address as sender OR if we already have a cached contract result
-    enabled:
-      !!recipientAddress &&
-      !!toChainId &&
-      !isSameAddress &&
-      !hasCachedContractResult(recipientAddress, toChainId),
-    staleTime: (query) => (query.state.data === true ? Infinity : 0),
-    gcTime: HOUR_MS,
-  })
-
-  // Derive the final values, reusing results where addresses/chains match
-  const isSenderContractOnOrigin = senderOnOriginResult ?? null
-  const isSenderContractOnDestination = isSameChain
-    ? senderOnOriginResult // Same chain, reuse origin result
-    : (senderOnDestinationResult ?? null)
-  const isRecipientContract = isSameAddress
-    ? isSameChain
-      ? senderOnOriginResult
-      : senderOnDestinationResult // Same address, reuse sender result
-    : (recipientOnDestinationResult ?? null)
-
-  const prepareSendEnabled = Boolean(
-    walletClient &&
-      trailsClient &&
-      fromTokenAddress &&
-      toTokenAddress &&
-      debouncedSwapAmount &&
-      !isZeroOrInvalidAmount(debouncedSwapAmount) &&
-      effectiveToAddress &&
-      fromChainId &&
-      toChainId &&
-      indexerGatewayClient,
-  )
-
-  logger.console.log("[trails-sdk] [useQuote] prepareSend enabled check:", {
-    enabled: prepareSendEnabled,
-    walletClient: !!walletClient,
-    trailsClient: !!trailsClient,
-    fromTokenAddress: !!fromTokenAddress,
-    toTokenAddress: !!toTokenAddress,
-    debouncedSwapAmount: !!debouncedSwapAmount,
-    isZeroOrInvalid: isZeroOrInvalidAmount(debouncedSwapAmount),
-    effectiveToAddress: !!effectiveToAddress,
-    fromChainId: !!fromChainId,
-    toChainId: !!toChainId,
-    indexerGatewayClient: !!indexerGatewayClient,
-  })
-
-  const { data, isFetching, error, refetch } = useQuery({
-    queryKey: [
-      "prepareSend",
-      fromTokenAddress,
-      fromChainId,
-      toTokenAddress,
-      toChainId,
-      debouncedSwapAmount?.toString(),
-      effectiveToAddress,
-      toCalldata,
-      tradeType,
-      slippageTolerance,
-      swapProvider,
-      bridgeProvider,
-      swapProviderFallback,
-      bridgeProviderFallback,
-      apiKey,
-      isSmartWallet,
-      fundMethod,
-      quoteSessionId, // Include session ID to force fresh query on mount
-    ],
-    queryFn: async () => {
-      try {
-        logger.console.log(
-          "[trails-sdk] [useQuote] prepareSend queryFn entered",
-        )
-
-        // Reset the abort controller for new queries to ensure fresh state
-        if (abortControllerRef.current.signal.aborted) {
-          logger.console.log(
-            "[trails-sdk] Resetting aborted controller for new query",
-          )
-          abortControllerRef.current = new AbortController()
-        }
-
-        if (
-          !walletClient ||
-          !trailsClient ||
-          !fromTokenAddress ||
-          !toTokenAddress ||
-          !debouncedSwapAmount ||
-          isZeroOrInvalidAmount(debouncedSwapAmount) ||
-          !effectiveToAddress ||
-          !fromChainId ||
-          !toChainId ||
-          !indexerGatewayClient
-        ) {
-          logger.console.log(
-            "[trails-sdk] [useQuote] prepareSend queryFn guard failed, returning null",
-          )
-          return null
-        }
-
-        // Create a 20-second timeout
-        const timeoutId = setTimeout(() => {
-          logger.console.warn(
-            "[trails-sdk] [useQuote] Quote request timed out after 20 seconds",
-          )
-          abortControllerRef.current.abort()
-        }, 20000) // 20 seconds
-
-        try {
-          const originChain = getChainInfo(fromChainId)
-          const nativeTokenSymbol = originChain?.nativeCurrency?.symbol ?? ""
-
-          const balanceResult = await queryClient
-            .ensureQueryData(
-              balanceQueries.withPrices(
-                walletClient.account!.address,
-                indexerGatewayClient,
-                trailsClient,
-              ),
-            )
-            .catch((balanceError: unknown) => {
-              if (isNetworkError(balanceError)) {
-                logger.console.warn(
-                  "[trails-sdk] [useQuote] Network error fetching balances, proceeding with quote using zero balance:",
-                  {
-                    error: balanceError,
-                    account: walletClient.account!.address,
-                  },
-                )
-                return { balances: [] }
-              }
-              throw balanceError
-            })
-
-          const balances = balanceResult.balances
-          const nativeTokenFromBalances = balances.find(
-            (b: any) =>
-              b.chainId === fromChainId &&
-              (addressEqual(b.contractAddress, zeroAddress) || b.isNativeToken),
-          )
-          let originNativeTokenPriceUsd = nativeTokenFromBalances?.priceUsd ?? 0
-
-          // Reuse the price already fetched by balanceQueries.withPrices.
-          // Fallback only when native token is missing from the balances payload.
-          if (!originNativeTokenPriceUsd && nativeTokenSymbol) {
-            const nativePriceResult = await getTokenPrice(trailsClient, {
-              tokenSymbol: nativeTokenSymbol,
-              tokenAddress: zeroAddress,
-              chainId: fromChainId,
-            }).catch((error) => {
-              logger.console.error(
-                "[trails-sdk] [useQuote] Error getting origin native token price:",
-                error,
-              )
-              return null
-            })
-            originNativeTokenPriceUsd = nativePriceResult?.priceUsd ?? 0
-          }
-
-          if (originNativeTokenPriceUsd) {
-            logger.console.log(
-              "[trails-sdk] [useQuote] Origin native token price:",
-              {
-                chainId: fromChainId,
-                symbol: nativeTokenSymbol,
-                priceUsd: originNativeTokenPriceUsd,
-              },
-            )
-          }
-
-          const originTokenBalance = balances.find(
-            (b: any) =>
-              b.chainId === fromChainId &&
-              (b.contractAddress?.toLowerCase() ===
-                fromTokenAddress.toLowerCase() ||
-                (!b.contractAddress && fromTokenAddress === zeroAddress)),
-          )
-
-          const originTokenBalanceAmount = originTokenBalance?.balance ?? "0"
-
-          // Helper function to fetch decimals on-chain if not found in token list
-          const fetchDecimalsOnChain = async (
-            tokenAddress: string,
-            chainId: number,
-          ): Promise<number | null> => {
-            try {
-              // Use the hook-based RPC clients that are already available
-              const publicClient =
-                chainId === fromChainId
-                  ? originPublicClient
-                  : chainId === toChainId
-                    ? destinationPublicClient
-                    : null
-
-              if (!publicClient) {
-                logger.console.warn(
-                  `[trails-sdk] No RPC client available for chain ${chainId}`,
-                )
-                return null
-              }
-
-              // For native tokens, return 18 decimals
-              if (addressEqual(tokenAddress, zeroAddress)) {
-                const chainInfo = getChainInfo(chainId)
-                return chainInfo?.nativeCurrency.decimals ?? 18
-              }
-
-              const decimals = await publicClient.readContract({
-                address: tokenAddress as `0x${string}`,
-                abi: erc20Abi,
-                functionName: "decimals",
-              })
-
-              logger.console.log(
-                `[trails-sdk] Fetched decimals on-chain for token ${tokenAddress} on chain ${chainId}: ${decimals}`,
-              )
-              return decimals
-            } catch (error) {
-              logger.console.error(
-                `[trails-sdk] Error fetching decimals on-chain for token ${tokenAddress} on chain ${chainId}:`,
-                error,
-              )
-              return null
-            }
-          }
-
-          const originToken = findSupportedToken(
-            supportedTokens,
-            fromTokenAddress,
-            fromChainId,
-          )
-          const destinationToken = findSupportedToken(
-            supportedTokens,
-            toTokenAddress,
-            toChainId,
-          )
-
-          let sourceTokenDecimals = originToken?.decimals
-          if (!sourceTokenDecimals && fromTokenAddress && fromChainId) {
-            logger.console.warn(
-              "[trails-sdk] [useQuote] Source token decimals not found in token list, fetching on-chain:",
-              {
-                originToken,
-                fromTokenAddress,
-                fromChainId,
-              },
-            )
-            const onChainDecimals = await fetchDecimalsOnChain(
-              fromTokenAddress,
-              fromChainId,
-            )
-            if (onChainDecimals !== null) {
-              sourceTokenDecimals = onChainDecimals
-            }
-          }
-          if (!sourceTokenDecimals) {
-            logger.console.error(
-              "[trails-sdk] [useQuote] Source token decimals not found:",
-              {
-                originToken,
-                fromTokenAddress,
-                fromChainId,
-              },
-            )
-            throw new Error("Source token decimals not found")
-          }
-          let destinationTokenDecimals = destinationToken?.decimals
-          if (!destinationTokenDecimals && toTokenAddress && toChainId) {
-            logger.console.warn(
-              "[trails-sdk] Destination token decimals not found in token list, fetching on-chain:",
-              {
-                destinationToken,
-                toTokenAddress,
-                toChainId,
-              },
-            )
-            const onChainDecimals = await fetchDecimalsOnChain(
-              toTokenAddress,
-              toChainId,
-            )
-            if (onChainDecimals !== null) {
-              destinationTokenDecimals = onChainDecimals
-            }
-          }
-          if (!destinationTokenDecimals) {
-            logger.console.error(
-              "[trails-sdk] Destination token decimals not found:",
-              {
-                destinationToken,
-                toTokenAddress,
-                toChainId,
-              },
-            )
-            throw new Error("Destination token decimals not found")
-          }
-          const destinationTokenSymbol = destinationToken?.symbol ?? ""
-          const originTokenSymbol = originToken?.symbol ?? ""
-
-          // For onramp, qr-code and exchange fund methods, use a default amount of 100 tokens
-          // since the user will deposit from an external wallet/onramp provider (their connected wallet balance may be 0)
-          const effectiveOriginTokenBalance =
-            fundMethod === "direct-transfer" ||
-            fundMethod === "onramp-mesh" ||
-            fundMethod === "onramp-meld"
-              ? parseUnits("100", sourceTokenDecimals).toString()
-              : originTokenBalanceAmount
-
-          const options: PrepareSendOptions = {
-            queryClient,
-            account: walletClient.account!,
-            originTokenAddress: fromTokenAddress,
-            originChainId: fromChainId,
-            originTokenBalance: effectiveOriginTokenBalance,
-            destinationChainId: toChainId,
-            recipient: effectiveToAddress,
-            destinationApproveAddress: toApprove ?? undefined,
-            destinationTokenAddress: toTokenAddress,
-            swapAmount: debouncedSwapAmount.toString(),
-            tradeType: tradeType ?? TradeType.EXACT_OUTPUT,
-            originTokenSymbol: originTokenSymbol,
-            destinationTokenSymbol: destinationTokenSymbol,
-            destinationCalldata: toCalldata as string,
-            client: walletClient,
-            trailsClient,
-            sourceTokenDecimals,
-            destinationTokenDecimals,
-            onTransactionStateChange: onStatusUpdate ?? (() => {}),
-            slippageTolerance: slippageTolerance?.toString(),
-            swapProvider: effectiveSwapProvider,
-            bridgeProvider: effectiveBridgeProvider,
-            swapProviderFallback,
-            bridgeProviderFallback,
-            paymasterUrl: paymasterUrl,
-            selectedFeeOption: selectedFeeOption ?? null,
-            abortSignal: combinedAbortSignal,
-            originNativeTokenPriceUsd: originNativeTokenPriceUsd,
-            commitIntentFn: (intent) =>
-              commitIntentMutation.mutateAsync(intent),
-            executeIntentFn: executeIntentMutation.mutateAsync,
-            checkoutOnHandlers,
-            sequenceIndexerUrl,
-            sequenceProjectAccessKey,
-            originPublicClient: originPublicClient ?? undefined,
-            destinationPublicClient: destinationPublicClient ?? undefined,
-            isSmartWallet: isSmartWallet ?? undefined,
-            isSenderContractOnOrigin: isSenderContractOnOrigin ?? undefined,
-            trailsApiKey,
-            trailsApiUrl,
-            sequenceMetadataUrl,
-            fundMethod: fundMethod ?? "wallet",
-            onramp: onramp ?? undefined,
-            mode: mode ?? undefined,
-            walletId: walletId ?? undefined,
-          }
-
-          logger.console.log("[trails-sdk] options", options)
-
-          const {
-            quote: prepareSendQuote,
-            send: prepareSendSend,
-            feeOptions: prepareSendFeeOptions,
-          } = await prepareSend(options)
-
-          const quote: Quote = {
-            // Backward compatible fields
-            fromAmount: prepareSendQuote.originAmount,
-            toAmount: prepareSendQuote.destinationAmount,
-            fromAmountMin: prepareSendQuote.originAmountMin,
-            toAmountMin: prepareSendQuote.destinationAmountMin,
-            fromAmountUsdDisplay: prepareSendQuote.originAmountUsdDisplay ?? "",
-            toAmountUsdDisplay:
-              prepareSendQuote.destinationAmountUsdDisplay ?? "",
-            toAmountMinUsdDisplay:
-              prepareSendQuote.destinationAmountMinUsdDisplay ?? "",
-            // PrepareSendQuote compatible fields
-            originAmount: prepareSendQuote.originAmount,
-            originAmountMin: prepareSendQuote.originAmountMin,
-            destinationAmount: prepareSendQuote.destinationAmount,
-            destinationAmountMin: prepareSendQuote.destinationAmountMin,
-            originAmountUsdDisplay:
-              prepareSendQuote.originAmountUsdDisplay ?? "",
-            destinationAmountUsdDisplay:
-              prepareSendQuote.destinationAmountUsdDisplay ?? "",
-            originAmountDisplay: prepareSendQuote.originAmountDisplay ?? "",
-            destinationAmountDisplay:
-              prepareSendQuote.destinationAmountDisplay ?? "",
-            originAmountMinDisplay:
-              prepareSendQuote.originAmountMinDisplay ?? "",
-            originAmountMinUsdFormatted:
-              prepareSendQuote.originAmountMinUsdFormatted ?? "",
-            originAmountMinUsdDisplay:
-              prepareSendQuote.originAmountMinUsdDisplay ?? "",
-            destinationAmountMinDisplay:
-              prepareSendQuote.destinationAmountMinDisplay ?? "",
-            destinationAmountMinUsdFormatted:
-              prepareSendQuote.destinationAmountMinUsdFormatted ?? "",
-            destinationAmountMinUsdDisplay:
-              prepareSendQuote.destinationAmountMinUsdDisplay ?? "",
-            originAmountUsdFormatted:
-              prepareSendQuote.originAmountUsdFormatted ?? "",
-            destinationAmountUsdFormatted:
-              prepareSendQuote.destinationAmountUsdFormatted ?? "",
-            // Locale display fields
-            originAmountFormattedLocale:
-              prepareSendQuote.originAmountFormattedLocale,
-            originAmountUsdLocaleDisplay:
-              prepareSendQuote.originAmountUsdLocaleDisplay,
-            destinationAmountFormattedLocale:
-              prepareSendQuote.destinationAmountFormattedLocale,
-            destinationAmountUsdLocaleDisplay:
-              prepareSendQuote.destinationAmountUsdLocaleDisplay,
-            originAmountUsd: prepareSendQuote.originAmountUsd,
-            fromAmountUsd: prepareSendQuote.fromAmountUsd,
-            // Common fields
-            originToken: prepareSendQuote.originToken,
-            destinationToken: prepareSendQuote.destinationToken,
-            originChain: prepareSendQuote.originChain,
-            destinationChain: prepareSendQuote.destinationChain,
-            fees: prepareSendQuote.fees,
-            priceImpact: prepareSendQuote.priceImpact,
-            priceImpactUsd: prepareSendQuote.priceImpactUsd ?? null,
-            priceImpactUsdDisplay: prepareSendQuote.priceImpactUsdDisplay ?? "",
-            priceImpactUsdLocaleDisplay:
-              prepareSendQuote.priceImpactUsdLocaleDisplay,
-            completionEstimateSeconds:
-              prepareSendQuote.completionEstimateSeconds,
-            completionEstimateDisplay:
-              prepareSendQuote.completionEstimateDisplay ?? "",
-            slippageTolerance: prepareSendQuote.slippageTolerance,
-            transactionStates: prepareSendQuote.transactionStates ?? [],
-            originTokenRate: prepareSendQuote.originTokenRate ?? "",
-            destinationTokenRate: prepareSendQuote.destinationTokenRate ?? "",
-            originTokenPriceUsd: prepareSendQuote.originTokenPriceUsd ?? 0,
-            destinationTokenPriceUsd:
-              prepareSendQuote.destinationTokenPriceUsd ?? 0,
-            routeProviders: prepareSendQuote.routeProviders ?? [],
-            gasCostUsd: prepareSendQuote.gasCostUsd ?? null,
-            gasCostUsdDisplay: prepareSendQuote.gasCostUsdDisplay ?? "",
-            gasCost: prepareSendQuote.gasCost ?? "",
-            gasCostFormatted: prepareSendQuote.gasCostFormatted ?? "",
-            totalFeesUsd: prepareSendQuote.totalFeesUsd ?? null,
-            totalFeesUsdDisplay: prepareSendQuote.totalFeesUsdDisplay ?? "",
-            totalGasUsd: prepareSendQuote.totalGasUsd ?? null,
-            totalGasUsdDisplay: prepareSendQuote.totalGasUsdDisplay ?? "",
-            intentId: prepareSendQuote.intentId ?? null,
-            originAmountFormatted: prepareSendQuote.originAmountFormatted ?? "",
-            destinationAmountFormatted:
-              prepareSendQuote.destinationAmountFormatted ?? "",
-            originDepositAddress: prepareSendQuote.originDepositAddress ?? "",
-            destinationDepositAddress:
-              prepareSendQuote.destinationDepositAddress ?? "",
-            destinationAddress: prepareSendQuote.destinationAddress ?? "",
-            destinationApproveAddress:
-              prepareSendQuote.destinationApproveAddress ?? "",
-            destinationCalldata: prepareSendQuote.destinationCalldata ?? "",
-            intentProtocol: prepareSendQuote.intentProtocol,
-            // Fee breakdown fields
-            trailsFeeBreakdown: prepareSendQuote.trailsFeeBreakdown ?? null,
-            originGasUsd: prepareSendQuote.originGasUsd ?? null,
-            originGasUsdDisplay: prepareSendQuote.originGasUsdDisplay ?? "",
-            destinationGasUsd: prepareSendQuote.destinationGasUsd ?? null,
-            destinationGasUsdDisplay:
-              prepareSendQuote.destinationGasUsdDisplay ?? "",
-            providerFeeUsd: prepareSendQuote.providerFeeUsd ?? null,
-            providerFeeUsdDisplay: prepareSendQuote.providerFeeUsdDisplay ?? "",
-            trailsFeeUsd: prepareSendQuote.trailsFeeUsd ?? null,
-            trailsFeeUsdDisplay: prepareSendQuote.trailsFeeUsdDisplay ?? "",
-            totalProviderFeesUsd: prepareSendQuote.totalProviderFeesUsd ?? null,
-            totalProviderFeesUsdDisplay:
-              prepareSendQuote.totalProviderFeesUsdDisplay ?? "",
-            // Locale display fields for fees
-            totalGasUsdLocaleDisplay: prepareSendQuote.totalGasUsdLocaleDisplay,
-            originGasUsdLocaleDisplay:
-              prepareSendQuote.originGasUsdLocaleDisplay,
-            destinationGasUsdLocaleDisplay:
-              prepareSendQuote.destinationGasUsdLocaleDisplay,
-            totalProviderFeesUsdLocaleDisplay:
-              prepareSendQuote.totalProviderFeesUsdLocaleDisplay,
-            providerFeeUsdLocaleDisplay:
-              prepareSendQuote.providerFeeUsdLocaleDisplay,
-            trailsFeeUsdLocaleDisplay:
-              prepareSendQuote.trailsFeeUsdLocaleDisplay,
-            noSufficientBalance: prepareSendQuote.noSufficientBalance ?? false,
-            expiresAt: prepareSendQuote.expiresAt ?? null,
-            priceImpactDetails: prepareSendQuote.priceImpactDetails ?? null,
-            // Passthrough fields for UI switching
-            passthroughEligible: prepareSendQuote.passthroughEligible,
-            passthroughTransactionStates:
-              prepareSendQuote.passthroughTransactionStates,
-          }
-
-          const sendTransaction = async (
-            options?: SendOptions,
-          ): Promise<SwapReturn> => {
-            // Use fee option from send() call if provided, otherwise fall back to prop value
-            const effectiveFeeOption =
-              options?.selectedFeeOption !== undefined
-                ? options.selectedFeeOption
-                : (selectedFeeOption ?? null)
-
-            const {
-              depositUserTxnReceipt,
-              destinationIntentTransaction,
-              totalCompletionSeconds,
-            } = await prepareSendSend({
-              selectedFeeOption: effectiveFeeOption,
-              onOriginSend: options?.onOriginSend,
-              depositTransactionHash: options?.depositTransactionHash,
-              skipCommit: options?.skipCommit,
-            })
-
-            return {
-              originTransaction: {
-                transactionHash: depositUserTxnReceipt?.transactionHash,
-                explorerUrl: getExplorerUrl({
-                  txHash: depositUserTxnReceipt?.transactionHash as string,
-                  chainId: fromChainId,
-                }),
-                receipt: depositUserTxnReceipt,
-              },
-              destinationTransaction: {
-                transactionHash: destinationIntentTransaction?.txnHash,
-                explorerUrl: getExplorerUrl({
-                  txHash: destinationIntentTransaction?.txnHash as string,
-                  chainId: toChainId,
-                }),
-                receipt: destinationIntentTransaction,
-              },
-              totalCompletionSeconds,
-            }
-          }
-
-          // Clear the timeout on successful completion
-          clearTimeout(timeoutId)
-
-          return {
-            quote,
-            send: sendTransaction,
-            feeOptions: prepareSendFeeOptions?.feeOptions ?? [],
-          }
-        } finally {
-          // Always clear the timeout
-          clearTimeout(timeoutId)
-        }
-      } catch (error) {
-        const isAbortError =
-          error instanceof Error && error.name === "AbortError"
-
-        // Check if this was aborted due to timeout
-        if (isAbortError || abortControllerRef.current.signal.aborted) {
-          logger.console.error(
-            "[trails-sdk] [useQuote] Quote request timed out:",
-            error,
-          )
-          throw new Error("No route available")
-        }
-
-        logger.console.error(
-          "[trails-sdk] [useQuote] Error getting quote:",
-          error,
-        )
-        throw new Error(getFullErrorMessage(error))
-      }
-    },
-    // Prevent unnecessary refetching
-    enabled: prepareSendEnabled,
-    staleTime: 0, // Always refetch when returning to a previously-queried amount
-    refetchOnWindowFocus: false, // Don't refetch when window regains focus
-    refetchOnMount: "always", // Always refetch on component remount to ensure fresh quote
-    refetchInterval: false, // Disable automatic polling
-    retry: false, // Disable automatic retries - only make 1 request
-    refetchOnReconnect: true, // Refetch when network reconnects
-  })
-
-  const sendFn = data?.send || null
-
-  // Create deprecated swap wrapper
-  const swapFn = sendFn
-    ? async (options?: SendOptions) => {
-        logger.console.warn(
-          "[trails-sdk] [useQuote] Warning: 'swap' is deprecated, use 'send' instead",
-        )
-        return sendFn(options)
-      }
-    : null
-
-  return {
-    quote: data?.quote || null,
-    send: sendFn,
-    swap: swapFn,
-    isLoadingQuote: isFetching,
-    quoteError: error,
-    quoteErrorPrettified: getPrettifiedErrorMessage(error),
-    refetchQuote: async () => {
-      await refetch()
-    },
-    abort: () => {
-      logger.console.log("[trails-sdk] useQuote abort() called")
-      logger.console.log(
-        "[trails-sdk] Active operations before abort:",
-        abortControllerRegistry.getAll(),
-      )
-
-      // Abort the internal abort controller
-      abortControllerRef.current.abort()
-
-      // Also abort all active polling operations in prepareSend
-      abortControllerRegistry.abortAll()
-
-      logger.console.log(
-        "[trails-sdk] Abort completed, active operations:",
-        abortControllerRegistry.getAll(),
-      )
-    },
-    feeOptions: data?.feeOptions || [],
-    // Contract detection results
-    isRecipientContract: isRecipientContract ?? null,
-    isSenderContractOnOrigin: isSenderContractOnOrigin ?? null,
-    isSenderContractOnDestination: isSenderContractOnDestination ?? null,
-  }
-}