0xtrails 0.8.2 → 0.8.3

package/src/widget/hooks/useSendForm.ts

@@ -8,24 +8,13 @@ import {
   isAddress,
   parseUnits,
   type WalletClient,
-  zeroAddress,
 } from "viem"
 import { useAccount } from "wagmi"
-import {
-  getChainInfo,
-  useSupportedChains,
-  useChainRpcClient,
-} from "../../chains.js"
-import { getFullErrorMessage, getPrettifiedErrorMessage } from "../../error.js"
-import {
-  prepareSend,
-  TradeType,
-  type PrepareSendReturn,
-  type PrepareSendQuote,
-} from "../../prepareSend.js"
+import { getChainInfo, useSupportedChains } from "../../chains.js"
+import { getFullErrorMessage } from "../../error.js"
+import { TradeType, type PrepareSendQuote } from "../../prepareSend.js"
 import type { TransactionState } from "../../transactions.js"
-import { getTokenPrice, useTokenPrices, normalizeNumber } from "../../prices.js"
-import { useQueryParams } from "../../queryParams.js"
+import { useTokenPrices, normalizeNumber } from "../../prices.js"
 import {
   formatRawAmount,
   formatUsdAmountDisplay,
@@ -42,9 +31,7 @@ import {
 } from "../../tokens.js"
 import type { CheckoutOnHandlers } from "./useCheckout.js"
 import { useResolveEnsAddress } from "../../ens.js"
-import { etherlink } from "viem/chains"
 import { logger } from "../../logger.js"
-import { getIsContract } from "../../contractUtils.js"
 import { useTrailsClient } from "../../trailsClient.js"
 import { useTrails } from "../providers/TrailsProvider.js"
 import { useTokenList } from "./useTokenList.js"
@@ -54,6 +41,7 @@ import {
 } from "./useSelectedFeeOption.js"
 import { useWidgetProps } from "./useWidgetProps.js"
 import { useCustomTokens } from "../../customTokens.js"
+import { useQuote } from "./useQuote.js"
 
 type ChainInfo = {
   id: number
@@ -164,7 +152,7 @@ export function useSendForm({
   toChainId, // Custom specified destination chain id
   toToken, // Custom specified destination token address or symbol
   toCalldata, // Custom specified destination calldata
-  refundAddress, // Custom specified refund address
+  refundAddress: _refundAddress, // Custom specified refund address (unused - useQuote handles this internally)
   walletClient,
   onTransactionStateChange,
   onError,
@@ -182,39 +170,15 @@ export function useSendForm({
   mode,
   onNavigateToOnramp,
   checkoutOnHandlers,
-  refetchTrigger = 0,
+  refetchTrigger: _refetchTrigger = 0, // Unused - useQuote handles quote refreshing via React Query
 }: UseSendProps): UseSendReturn {
-  // Get the active wallet ID from wagmi
-  const { connector } = useAccount()
-  const walletId = connector?.id
+  // Get the active wallet ID from wagmi (currently unused - useQuote handles this internally)
+  const { connector: _connector } = useAccount()
 
   // Read isSmartWallet from widget props
   const { isSmartWallet } = useWidgetProps()
 
-  // Auto-set swapProvider and bridgeProvider to "lifi" if either from or to chain is etherlink
-  const effectiveSwapProvider = useMemo(() => {
-    if (!swapProvider || swapProvider === "auto") {
-      if (
-        selectedToken?.chainId === etherlink.id ||
-        toChainId === etherlink.id
-      ) {
-        return "lifi"
-      }
-    }
-    return swapProvider
-  }, [swapProvider, selectedToken?.chainId, toChainId])
-
-  const effectiveBridgeProvider = useMemo(() => {
-    if (!bridgeProvider || bridgeProvider === "auto") {
-      if (
-        selectedToken?.chainId === etherlink.id ||
-        toChainId === etherlink.id
-      ) {
-        return "lifi"
-      }
-    }
-    return bridgeProvider
-  }, [bridgeProvider, selectedToken?.chainId, toChainId])
+  // Note: swapProvider and bridgeProvider auto-detection for etherlink is now handled in useQuote
 
   const [amount, setAmount] = useState(
     tradeType === TradeType.EXACT_INPUT ? "" : (toAmount ?? ""),
@@ -222,10 +186,6 @@ export function useSendForm({
   const [recipientInput, setRecipientInput] = useState(toRecipient ?? "")
   const [recipient, setRecipient] = useState(toRecipient ?? "")
   const [error, setError] = useState<string | null>(null)
-  const [quoteError, setQuoteError] = useState<string | null>(null)
-  const [quoteErrorPrettified, setQuoteErrorPrettified] = useState<
-    string | null
-  >(null)
   const { supportedChains } = useSupportedChains()
   const { ensAddress } = useResolveEnsAddress({
     textInput: recipientInput,
@@ -282,115 +242,7 @@ export function useSendForm({
     refetchOnReconnect: false,
   })
 
-  // Get RPC clients for known chainIds using hooks (reads from TrailsProvider context)
-  const destinationChainPublicClient = useChainRpcClient(
-    selectedDestinationChain?.id,
-  )
-  const originChainPublicClient = useChainRpcClient(selectedToken?.chainId)
-
-  // Check if recipient is a contract address
-  useEffect(() => {
-    const checkRecipientContract = async () => {
-      if (
-        recipient &&
-        isAddress(recipient) &&
-        selectedDestinationChain?.id &&
-        destinationChainPublicClient
-      ) {
-        try {
-          const isContract = await getIsContract(
-            recipient as `0x${string}`,
-            selectedDestinationChain.id,
-            destinationChainPublicClient,
-          )
-          logger.console.log("[trails-sdk] isRecipientContract:", isContract)
-          setIsRecipientContract(isContract)
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error checking if recipient is contract:",
-            error,
-          )
-          setIsRecipientContract(false)
-        }
-      } else {
-        setIsRecipientContract(false)
-      }
-    }
-
-    checkRecipientContract()
-  }, [recipient, selectedDestinationChain?.id, destinationChainPublicClient])
-
-  // Check if sender is a contract address on origin chain
-  useEffect(() => {
-    const checkSenderContractOnOrigin = async () => {
-      if (
-        account?.address &&
-        selectedToken?.chainId &&
-        originChainPublicClient
-      ) {
-        try {
-          const isContract = await getIsContract(
-            account.address as `0x${string}`,
-            selectedToken.chainId,
-            originChainPublicClient,
-          )
-          logger.console.log(
-            "[trails-sdk] isSenderContractOnOrigin:",
-            isContract,
-          )
-          setIsSenderContractOnOrigin(isContract)
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error checking if sender is contract on origin:",
-            error,
-          )
-          setIsSenderContractOnOrigin(false)
-        }
-      } else {
-        setIsSenderContractOnOrigin(false)
-      }
-    }
-
-    checkSenderContractOnOrigin()
-  }, [account?.address, selectedToken?.chainId, originChainPublicClient])
-
-  // Check if sender is a contract address on destination chain
-  useEffect(() => {
-    const checkSenderContractOnDestination = async () => {
-      if (
-        account?.address &&
-        selectedDestinationChain?.id &&
-        destinationChainPublicClient
-      ) {
-        try {
-          const isContract = await getIsContract(
-            account.address as `0x${string}`,
-            selectedDestinationChain.id,
-            destinationChainPublicClient,
-          )
-          logger.console.log(
-            "[trails-sdk] isSenderContractOnDestination:",
-            isContract,
-          )
-          setIsSenderContractOnDestination(isContract)
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error checking if sender is contract on destination:",
-            error,
-          )
-          setIsSenderContractOnDestination(false)
-        }
-      } else {
-        setIsSenderContractOnDestination(false)
-      }
-    }
-
-    checkSenderContractOnDestination()
-  }, [
-    account?.address,
-    selectedDestinationChain?.id,
-    destinationChainPublicClient,
-  ])
+  // Note: Contract detection is now handled in useQuote
 
   const isCustomToken = useMemo(() => toToken?.startsWith("0x"), [toToken])
 
@@ -538,8 +390,12 @@ export function useSendForm({
     }
   }, [selectedDestToken, defaultDestToken])
 
-  const trailsClient = useTrailsClient()
-  const { trailsApiKey, sequenceIndexerUrl } = useTrails()
+  // These are handled internally by useQuote via TrailsProvider context
+  const _trailsClient = useTrailsClient()
+  const {
+    trailsApiKey: _trailsApiKey,
+    sequenceIndexerUrl: _sequenceIndexerUrl,
+  } = useTrails()
 
   // Get user's token balances for balance checking
   const { filteredTokensFormatted } = useTokenList({
@@ -645,12 +501,6 @@ export function useSendForm({
   const [isSubmitting, setIsSubmitting] = useState(false)
   const [isWaitingForWalletConfirm, setIsWaitingForWalletConfirm] =
     useState(false)
-  const [isLoadingQuote, setIsLoadingQuote] = useState(false)
-  const [prepareSendResult, setPrepareSendResult] =
-    useState<PrepareSendReturn | null>(null)
-  const latestResolvedIntentIdRef = useRef<string | null>(null)
-  const quoteInputsFingerprintRef = useRef<string | null>(null)
-  const preparedQuoteFingerprintRef = useRef<string | null>(null)
 
   // Create a stable callback for transaction state changes
   const handleTransactionStateChange = useCallback(
@@ -696,14 +546,8 @@ export function useSendForm({
     setFeeOptions,
   } = useSelectedFeeOption()
 
-  const [isRecipientContract, setIsRecipientContract] = useState(false)
-  const [isSenderContractOnOrigin, setIsSenderContractOnOrigin] =
-    useState(false)
-  const [isSenderContractOnDestination, setIsSenderContractOnDestination] =
-    useState(false)
-
-  const { hasParam } = useQueryParams()
-  const isDryMode = hasParam("dryMode", "true")
+  // Note: Contract detection (isRecipientContract, isSenderContractOnOrigin, isSenderContractOnDestination)
+  // is now handled in useQuote and returned from there
 
   const destinationTokenAddressFromTokenSymbol = useTokenAddress({
     chainId: selectedDestinationChain?.id,
@@ -765,24 +609,31 @@ export function useSendForm({
       return "0"
     }
 
-    if (tradeType === TradeType.EXACT_INPUT && !selectedToken?.decimals) {
-      logger.console.warn(
-        "[trails-sdk] Missing source token decimals for quote",
-        {
-          selectedToken,
-          tradeType,
-        },
-      )
-      return "0"
-    } else if (!selectedDestToken?.decimals) {
-      logger.console.warn(
-        "[trails-sdk] Missing destination token decimals for quote",
-        {
-          selectedDestToken,
-          tradeType,
-        },
-      )
-      return "0"
+    // For EXACT_INPUT: we only need source token decimals (user enters source amount)
+    // For EXACT_OUTPUT: we only need destination token decimals (user enters destination amount)
+    if (tradeType === TradeType.EXACT_INPUT) {
+      if (!selectedToken?.decimals) {
+        logger.console.warn(
+          "[trails-sdk] Missing source token decimals for quote",
+          {
+            selectedToken,
+            tradeType,
+          },
+        )
+        return "0"
+      }
+    } else {
+      // EXACT_OUTPUT mode
+      if (!selectedDestToken?.decimals) {
+        logger.console.warn(
+          "[trails-sdk] Missing destination token decimals for quote",
+          {
+            selectedDestToken,
+            tradeType,
+          },
+        )
+        return "0"
+      }
     }
 
     // For EXACT_INPUT: use source token decimals (user enters source amount)
@@ -816,522 +667,76 @@ export function useSendForm({
     tradeType,
   ])
 
-  const buildQuoteInputsFingerprint = useCallback(
-    () =>
-      JSON.stringify({
-        originTokenAddress: selectedToken?.contractAddress?.toLowerCase() ?? "",
-        originChainId: selectedToken?.chainId ?? "",
-        destinationTokenSymbol: selectedDestToken?.symbol ?? "",
-        destinationChainId: selectedDestinationChain?.id ?? "",
-        destinationTokenAddress: destinationTokenAddress?.toLowerCase() ?? "",
-        amount: amount || "",
-        amountRaw: amountRaw || "",
-        recipient: recipient?.toLowerCase() ?? "",
-        tradeType,
-        toCalldata: toCalldata ?? "",
-      }),
-    [
-      amount,
-      amountRaw,
-      destinationTokenAddress,
-      recipient,
-      selectedDestinationChain?.id,
-      selectedDestToken?.symbol,
-      selectedToken?.chainId,
-      selectedToken?.contractAddress,
-      toCalldata,
-      tradeType,
-    ],
-  )
+  // Determine paymaster URL for the origin chain
+  const paymasterUrl = useMemo(() => {
+    return paymasterUrls?.find(
+      (p) => p.chainId.toString() === (selectedToken?.chainId || 0).toString(),
+    )?.url
+  }, [paymasterUrls, selectedToken?.chainId])
 
-  // Get quote automatically when inputs change
-  const getQuote = useCallback(async () => {
-    // Debug log: comprehensive state check
-    const debugState = {
-      account: account ? { address: account.address } : null,
-      amount,
-      amountRaw,
-      destinationTokenAddress,
-      destinationTokenAddressFromTokenSymbol,
-      isValidRecipient,
-      selectedDestToken: selectedDestToken
-        ? {
-            symbol: selectedDestToken.symbol,
-            name: selectedDestToken.name,
-            decimals: selectedDestToken.decimals,
-          }
-        : null,
-      selectedDestinationChain: selectedDestinationChain
-        ? {
-            id: selectedDestinationChain.id,
-            name: selectedDestinationChain.name,
-          }
-        : null,
-      selectedToken: selectedToken
-        ? {
-            symbol: selectedToken.symbol,
-            contractAddress: selectedToken.contractAddress,
-            chainId: selectedToken.chainId || 0,
-          }
-        : null,
-      recipient,
-      conditions: {
-        hasAccount: !!account,
-        hasAmount: !!amount,
-        hasAmountRaw: !!amountRaw,
-        amountNotZero: amount !== "0",
-        amountRawNotZero: amountRaw !== "0",
-        hasDestinationTokenAddress: !!destinationTokenAddress,
-        hasDestinationTokenAddressFromSymbol:
-          !!destinationTokenAddressFromTokenSymbol,
-        isValidRecipientValue: isValidRecipient,
-        hasSelectedDestToken: !!selectedDestToken,
-        hasSelectedDestinationChain: !!selectedDestinationChain,
-        hasSelectedToken: !!selectedToken,
-      },
-      allConditionsMet:
-        !!account &&
-        !!amount &&
-        !!destinationTokenAddress &&
-        isValidRecipient &&
-        !!selectedDestToken &&
-        !!selectedDestinationChain &&
-        amount !== "0" &&
-        !!amountRaw &&
-        amountRaw !== "0" &&
-        !!selectedToken,
-    }
-
-    logger.console.log("[trails-sdk] [DEBUG] getQuote state check", debugState)
-
-    // Only get quote if all required inputs are present
-    // Skip quote if origin and destination tokens are the same
-    const isSameToken =
-      selectedToken?.chainId === selectedDestinationChain?.id &&
-      selectedToken?.contractAddress?.toLowerCase() ===
-        destinationTokenAddress?.toLowerCase()
-    const isSenderSameAsRecipient =
-      account?.address?.toLowerCase() === recipient?.toLowerCase()
-
-    if (
-      !account ||
-      !amount ||
-      !destinationTokenAddress ||
-      !isValidRecipient ||
-      !selectedDestToken ||
-      !selectedDestinationChain ||
-      amount === "0" ||
-      !amountRaw ||
-      amountRaw === "0" ||
-      !selectedToken ||
-      (isSameToken &&
-        isSenderSameAsRecipient &&
-        (mode === "swap" || mode === "fund"))
-    ) {
-      logger.console.log(
-        "[trails-sdk] Skipping quote because of missing inputs or same token",
-        {
-          amount,
-          destinationTokenAddress,
-          isValidRecipient,
-          selectedDestToken,
-          selectedDestinationChain,
-          amountRaw,
-          selectedToken,
-          isSameToken,
-          debugState,
-        },
-      )
-      setQuoteError(null)
-      setPrepareSendResult(null)
-      preparedQuoteFingerprintRef.current = null
-      return
-    }
-
-    latestResolvedIntentIdRef.current = null
-    let requestFingerprint = quoteInputsFingerprintRef.current
-    if (!requestFingerprint) {
-      requestFingerprint = buildQuoteInputsFingerprint()
-      quoteInputsFingerprintRef.current = requestFingerprint
-    }
-    try {
-      setIsLoadingQuote(true)
-      setError(null)
-      setQuoteError(null)
-
-      const sourceTokenDecimals = selectedToken.decimals || 18
-      const destinationTokenDecimals = selectedDestToken.decimals || 18
-
-      if (!sourceTokenDecimals || !destinationTokenDecimals) {
-        logger.console.warn("[trails-sdk] Missing token decimals for quote", {
-          sourceTokenDecimals,
-          destinationTokenDecimals,
-          selectedToken,
-          selectedDestToken,
-          tradeType,
-        })
-        setPrepareSendResult(null)
-        preparedQuoteFingerprintRef.current = null
-        latestResolvedIntentIdRef.current = null
-        setIsLoadingQuote(false)
-        return
-      }
-
-      let sourceTokenPriceUsd = selectedToken.priceUsd ?? null
-      let destinationTokenPriceUsd = destTokenPrices?.[0]?.priceUsd ?? null
-
-      if (!sourceTokenPriceUsd) {
-        try {
-          const price = await getTokenPrice(trailsClient, {
-            tokenAddress: selectedToken.contractAddress,
-            tokenSymbol: selectedToken.symbol,
-            chainId: selectedToken.chainId || 0,
-          })
-          sourceTokenPriceUsd = price?.priceUsd ?? null
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error getting source token price:",
-            error,
-          )
-        }
-      }
-
-      if (!destinationTokenPriceUsd) {
-        try {
-          const price = await getTokenPrice(trailsClient, {
-            tokenSymbol: selectedDestToken.symbol,
-            tokenAddress: destinationTokenAddress ?? "",
-            chainId: selectedDestinationChain.id,
-          })
-          destinationTokenPriceUsd = price?.priceUsd ?? null
-        } catch (error) {
-          logger.console.error(
-            "[trails-sdk] Error getting destination token price:",
-            error,
-          )
-        }
-      }
-
-      if (
-        !destinationTokenPriceUsd &&
-        selectedToken.symbol === selectedDestToken.symbol
-      ) {
-        destinationTokenPriceUsd = sourceTokenPriceUsd
-      }
-      if (
-        !sourceTokenPriceUsd &&
-        selectedToken.symbol === selectedDestToken.symbol
-      ) {
-        sourceTokenPriceUsd = destinationTokenPriceUsd
-      }
-
-      if (!sourceTokenPriceUsd || !destinationTokenPriceUsd) {
-        logger.console.warn("[trails-sdk] Missing token prices for quote", {
-          sourceTokenPriceUsd,
-          destinationTokenPriceUsd,
-        })
-      }
-
-      let nativeTokenPriceUsd = 0
-      if (
-        selectedToken.contractAddress === zeroAddress &&
-        sourceTokenPriceUsd
-      ) {
-        nativeTokenPriceUsd = sourceTokenPriceUsd
-      } else {
-        const originChain = getChainInfo(selectedToken.chainId || 0)
-        const nativeTokenSymbol = originChain?.nativeCurrency?.symbol ?? ""
-        const nativePrice = await getTokenPrice(trailsClient, {
-          tokenSymbol: nativeTokenSymbol,
-          tokenAddress: zeroAddress,
-          chainId: selectedToken.chainId || 0,
-        })
-        nativeTokenPriceUsd = nativePrice?.priceUsd ?? 0
-      }
-
-      const options = {
-        account,
-        originTokenAddress: selectedToken.contractAddress,
-        originChainId: selectedToken.chainId || 0,
-        originTokenBalance:
-          fundMethod === "qr-code" || fundMethod === "exchange"
-            ? parseUnits("100", selectedToken.decimals ?? 18).toString() // needs to be an amount that is greater than the minimum amount for the swap
-            : selectedToken.balance || "0",
-        destinationChainId: selectedDestinationChain.id,
-        recipient,
-        destinationTokenAddress,
-        swapAmount: amountRaw,
-        tradeType,
-        originTokenSymbol: selectedToken.symbol,
-        destinationTokenSymbol: selectedDestToken.symbol,
-        fee: "0",
-        client: walletClient,
-        trailsClient,
-        destinationCalldata: toCalldata,
-        refundAddress,
-        dryMode: isDryMode,
-        onTransactionStateChange: handleTransactionStateChange,
-        sourceTokenPriceUsd,
-        destinationTokenPriceUsd,
-        sourceTokenDecimals,
-        destinationTokenDecimals,
-        paymasterUrl:
-          paymasterUrls?.find(
-            (p) =>
-              p.chainId.toString() === (selectedToken.chainId || 0).toString(),
-          )?.url ?? undefined,
-        originNativeTokenPriceUsd: nativeTokenPriceUsd,
-        swapProvider: effectiveSwapProvider as RouteProvider | null | undefined,
-        bridgeProvider: effectiveBridgeProvider as
-          | RouteProvider
-          | null
-          | undefined,
-        mode,
-        fundMethod,
-        checkoutOnHandlers,
-        selectedFeeOption: selectedFeeOption ?? null,
-        walletId,
-        sequenceIndexerUrl,
-        sequenceProjectAccessKey: trailsApiKey,
-        originPublicClient: originChainPublicClient ?? undefined,
-        destinationPublicClient: destinationChainPublicClient ?? undefined,
-        isSmartWallet,
-        trailsApiKey,
-        trailsApiUrl: trailsConfig.trailsApiUrl,
-      }
-
-      logger.console.log(
-        "[trails-sdk] [FEE-SELECT] getQuote using selectedFeeOption:",
-        {
-          selectedFeeOption,
-        },
-      )
-
-      const result = await prepareSend(options)
-
-      if (requestFingerprint !== quoteInputsFingerprintRef.current) {
-        logger.console.log(
-          "[trails-sdk] Ignoring stale quote result (fingerprint mismatch)",
-          {
-            requestFingerprint,
-            currentFingerprint: quoteInputsFingerprintRef.current,
-          },
-        )
-        return
-      }
-
-      logger.console.log("[trails-sdk] prepareSend quote:", result.quote)
-
-      // Track the intentId returned by the most recent quote so we never execute a stale CommitIntent
-      // even when the quote inputs (fingerprint) are identical between retries.
-      const quoteIntentId = result.quote.intentId ?? null
-
-      logger.console.log("[trails-sdk] Resolved quote intentId:", quoteIntentId)
-
-      latestResolvedIntentIdRef.current = quoteIntentId
-      setPrepareSendResult(result)
-      preparedQuoteFingerprintRef.current = requestFingerprint
-      setIsLoadingQuote(false)
-    } catch (error) {
-      if (requestFingerprint !== quoteInputsFingerprintRef.current) {
-        logger.console.log(
-          "[trails-sdk] Ignoring quote error (fingerprint mismatch)",
-          {
-            requestFingerprint,
-            currentFingerprint: quoteInputsFingerprintRef.current,
-          },
-        )
-        return
-      }
-
-      logger.console.error("[trails-sdk] Error getting quote:", error)
-      const errorMessage = getFullErrorMessage(error)
-      setQuoteError(errorMessage)
-      setPrepareSendResult(null)
-      preparedQuoteFingerprintRef.current = null
-      latestResolvedIntentIdRef.current = null
-      setIsLoadingQuote(false)
-    }
-  }, [
-    trailsApiKey,
-    tradeType,
-    isDryMode,
-    account,
+  // Use the centralized useQuote hook for quote fetching
+  const {
+    quote: quoteResult,
+    send: sendFn,
+    isLoadingQuote: quoteIsLoading,
+    quoteError: rawQuoteError,
+    quoteErrorPrettified: rawQuoteErrorPrettified,
+    feeOptions: quoteFeeOptions,
+    // Contract detection from useQuote
+    isRecipientContract: quoteIsRecipientContract,
+    isSenderContractOnOrigin: quoteIsSenderContractOnOrigin,
+    isSenderContractOnDestination: quoteIsSenderContractOnDestination,
+  } = useQuote({
     walletClient,
-    trailsClient,
-    selectedDestToken?.decimals,
-    recipient,
-    destinationTokenAddress,
-    destinationTokenAddressFromTokenSymbol,
-    sequenceIndexerUrl,
-    selectedDestToken?.symbol,
-    selectedDestinationChain?.id,
-    selectedToken?.contractAddress,
-    selectedToken?.chainId,
-    selectedToken?.balance,
-    selectedToken?.priceUsd,
+    fromTokenAddress: selectedToken?.contractAddress ?? null,
+    fromChainId: selectedToken?.chainId ?? null,
+    toTokenAddress: destinationTokenAddress ?? null,
+    toChainId: selectedDestinationChain?.id ?? null,
+    swapAmount: amountRaw !== "0" ? amountRaw : undefined,
+    tradeType,
+    toAddress: isValidRecipient ? recipient : null,
     toCalldata,
-    refundAddress,
-    paymasterUrls,
-    handleTransactionStateChange,
-    isValidRecipient,
-    destTokenPrices?.[0]?.priceUsd,
-    amount,
-    selectedDestToken,
-    selectedDestinationChain,
-    selectedToken,
-    effectiveSwapProvider,
-    effectiveBridgeProvider,
-    fundMethod,
-    amountRaw,
+    onStatusUpdate: handleTransactionStateChange,
+    swapProvider: swapProvider as RouteProvider | null | undefined,
+    bridgeProvider: bridgeProvider as RouteProvider | null | undefined,
     checkoutOnHandlers,
-    mode,
-    selectedFeeOption,
-    walletId,
-    buildQuoteInputsFingerprint,
-    originChainPublicClient,
-    destinationChainPublicClient,
+    paymasterUrl,
+    selectedFeeOption: selectedFeeOption ?? null,
     isSmartWallet,
-    trailsConfig.trailsApiUrl,
-  ])
+    fundMethod,
+  })
 
-  // Auto-fetch quotes when inputs change (debounced)
-  // biome-ignore lint/correctness/useExhaustiveDependencies: getQuote is intentionally excluded to prevent infinite loop
-  useEffect(() => {
-    // Only trigger if we have the essential inputs
-    // Block empty string or exactly "0"
-    // Skip quote if origin and destination tokens are the same
-    const isSameToken =
-      selectedToken?.chainId === selectedDestinationChain?.id &&
-      selectedToken?.contractAddress?.toLowerCase() ===
-        destinationTokenAddress?.toLowerCase()
-
-    const isSenderSameAsRecipient =
-      account?.address?.toLowerCase() === recipient?.toLowerCase()
-
-    const conditions = {
-      hasAmount: !!amount,
-      amountNotZero: amount !== "0",
-      hasDestinationTokenAddress: !!destinationTokenAddress,
-      isValidRecipient,
-      hasSelectedDestTokenSymbol: !!selectedDestToken?.symbol,
-      hasSelectedDestinationChain: !!selectedDestinationChain?.id,
-      hasSelectedToken: !!selectedToken,
-      isSameToken,
-      isSenderSameAsRecipient,
-      mode,
-    }
+  // Map useQuote outputs for backward compatibility with existing code
+  // This allows gradual migration without breaking existing functionality
+  const isLoadingQuote = quoteIsLoading
+  const quoteError = rawQuoteError ? getFullErrorMessage(rawQuoteError) : null
+  const quoteErrorPrettified = rawQuoteErrorPrettified || null
 
-    logger.console.log(
-      "[trails-sdk] [CUSTOM-TOKEN] Quote trigger conditions check:",
-      {
-        ...conditions,
-        selectedDestToken: selectedDestToken
-          ? {
-              symbol: selectedDestToken.symbol,
-              decimals: selectedDestToken.decimals,
-              contractAddress: selectedDestToken.contractAddress,
-            }
-          : null,
-        destinationTokenAddress,
-        amount,
-        recipient,
-      },
-    )
+  // Create a compatibility layer for prepareSendResult
+  // This maps the useQuote output to the shape expected by existing code
+  const prepareSendResult = useMemo(() => {
+    if (!quoteResult || !sendFn) return null
 
-    if (
-      !amount ||
-      amount === "0" ||
-      !destinationTokenAddress ||
-      !isValidRecipient ||
-      !selectedDestToken?.symbol ||
-      !selectedDestinationChain?.id ||
-      !selectedToken ||
-      (isSameToken &&
-        isSenderSameAsRecipient &&
-        (mode === "swap" || mode === "fund"))
-    ) {
-      logger.console.log(
-        "[trails-sdk] [CUSTOM-TOKEN] Quote blocked - missing conditions:",
-        {
-          blockedReasons: {
-            noAmount: !amount || amount === "0",
-            noDestinationTokenAddress: !destinationTokenAddress,
-            invalidRecipient: !isValidRecipient,
-            noSelectedDestTokenSymbol: !selectedDestToken?.symbol,
-            noSelectedDestinationChain: !selectedDestinationChain?.id,
-            noSelectedToken: !selectedToken,
-            sameTokenAndRecipient:
-              isSameToken &&
-              isSenderSameAsRecipient &&
-              (mode === "swap" || mode === "fund"),
-          },
-          conditions,
-        },
-      )
-      setPrepareSendResult(null)
-      latestResolvedIntentIdRef.current = null
-      quoteInputsFingerprintRef.current = null
-      preparedQuoteFingerprintRef.current = null
-      setIsLoadingQuote(false)
-      return
-    }
+    // Quote type now has all PrepareSendQuote fields with proper defaults
+    const quote = { ...quoteResult } as PrepareSendQuote
 
-    const nextQuoteInputsFingerprint = buildQuoteInputsFingerprint()
-
-    logger.console.log("[trails-sdk] [CUSTOM-TOKEN] Quote fingerprint check:", {
-      currentFingerprint: quoteInputsFingerprintRef.current,
-      nextFingerprint: nextQuoteInputsFingerprint,
-      willTrigger:
-        quoteInputsFingerprintRef.current !== nextQuoteInputsFingerprint,
-    })
-
-    // Fingerprint all quote-driving inputs so we can invalidate debounced quotes immediately when
-    // the user switches tokens; this fixes the stale quote so that it stays loading until the new quote is ready.
-    if (quoteInputsFingerprintRef.current !== nextQuoteInputsFingerprint) {
-      logger.console.log(
-        "[trails-sdk] [CUSTOM-TOKEN] Quote fingerprint changed, triggering quote fetch",
-      )
-      quoteInputsFingerprintRef.current = nextQuoteInputsFingerprint
-      latestResolvedIntentIdRef.current = null
-      setPrepareSendResult(null)
-      preparedQuoteFingerprintRef.current = null
-      setIsLoadingQuote(true)
+    return {
+      quote,
+      feeOptions: { feeOptions: quoteFeeOptions },
+      // Note: send function is handled separately via sendFn
     }
-
-    const timeoutId = setTimeout(() => {
-      logger.console.log(
-        "[trails-sdk] [CUSTOM-TOKEN] Debounce timeout completed, calling getQuote",
-      )
-      getQuote()
-    }, 500) // Debounce by 500ms
-
-    return () => clearTimeout(timeoutId)
-  }, [
-    amount,
-    destinationTokenAddress,
-    isValidRecipient,
-    selectedDestToken?.symbol,
-    selectedDestinationChain?.id,
-    toCalldata,
-    refetchTrigger,
-    amountRaw,
-    tradeType,
-    selectedToken?.contractAddress,
-    selectedToken?.chainId,
-    selectedToken?.balance,
-    selectedToken?.priceUsd,
-    recipient, // Add recipient to trigger quote re-fetch when it changes
-    // selectedFeeOption is passed to send() at execution time, not needed here
-    buildQuoteInputsFingerprint,
-  ])
+  }, [quoteResult, sendFn, quoteFeeOptions])
 
   // Calculate destination amount from quote if available
   const quotedDestinationAmount = useMemo(() => {
-    if (prepareSendResult) {
-      return prepareSendResult.quote.destinationAmountFormatted
+    const currentDestAmount =
+      prepareSendResult?.quote?.destinationAmountFormatted
+
+    if (currentDestAmount && currentDestAmount !== "0") {
+      return currentDestAmount
     }
 
+    // Fall back to toAmount prop (for EXACT_OUTPUT mode)
     return toAmountFormatted
   }, [prepareSendResult, toAmountFormatted])
 
@@ -1370,58 +775,24 @@ export function useSendForm({
     logger.console.log("[trails-sdk] processSend called", {
       fundMethod,
       hasOnNavigateToOnramp: !!onNavigateToOnramp,
-      hasPrepareSendResult: !!prepareSendResult,
+      hasQuote: !!prepareSendResult,
+      hasSend: !!sendFn,
     })
     try {
-      if (!prepareSendResult) {
+      if (!prepareSendResult || !sendFn) {
         setError("No quote available. Please wait for quote to load.")
         return
       }
 
-      const currentQuoteInputsFingerprint = buildQuoteInputsFingerprint()
-      if (
-        !preparedQuoteFingerprintRef.current ||
-        preparedQuoteFingerprintRef.current !== currentQuoteInputsFingerprint
-      ) {
-        logger.console.warn(
-          "[trails-sdk] Blocking send because quote fingerprint is stale",
-          {
-            prepared: preparedQuoteFingerprintRef.current,
-            current: currentQuoteInputsFingerprint,
-          },
-        )
-        setPrepareSendResult(null)
-        preparedQuoteFingerprintRef.current = null
-        latestResolvedIntentIdRef.current = null
-        setIsLoadingQuote(true)
-        return
-      }
-
-      const quoteIntentId = prepareSendResult.quote.intentId ?? null
-      if (
-        quoteIntentId &&
-        latestResolvedIntentIdRef.current !== quoteIntentId
-      ) {
-        logger.console.error(
-          "[trails-sdk] Quote intentId has changed, waiting for latest quote",
-          {
-            current: latestResolvedIntentIdRef.current,
-            prepareSend: quoteIntentId,
-          },
-        )
-        setError("Quote is updating. Please wait for the latest quote.")
-        return
-      }
+      // React Query handles quote staleness via its caching mechanism,
+      // so we no longer need fingerprint checks
 
       setError(null)
       setIsSubmitting(true)
 
-      const { quote, send } = prepareSendResult
+      const quote = prepareSendResult.quote
 
-      logger.console.log(
-        "[trails-sdk] Using prepared send result quote:",
-        quote,
-      )
+      logger.console.log("[trails-sdk] Using quote from useQuote:", quote)
 
       function onOriginSend() {
         logger.console.log("[trails-sdk] onOriginSend called")
@@ -1435,10 +806,10 @@ export function useSendForm({
 
       async function handleSend() {
         logger.console.log(
-          "[trails-sdk] [FEE-SELECT] [GASLESS-FLOW] handleSend called, about to call send()",
+          "[trails-sdk] [FEE-SELECT] [GASLESS-FLOW] handleSend called, about to call sendFn()",
         )
         logger.console.log(
-          "[trails-sdk] [FEE-SELECT] [GASLESS-FLOW] selectedFeeOption value at send() call time:",
+          "[trails-sdk] [FEE-SELECT] [GASLESS-FLOW] selectedFeeOption value at swap() call time:",
           {
             selectedFeeOption,
             isNull: selectedFeeOption === null,
@@ -1447,24 +818,20 @@ export function useSendForm({
             stringified: JsonEncode(selectedFeeOption),
           },
         )
-        // Wait for full send to complete
-        const {
-          depositUserTxnReceipt,
-          originIntentTransaction,
-          destinationIntentTransaction,
-        } = await send({
-          onOriginSend,
-          selectedFeeOption: selectedFeeOption ?? null, // Pass current value at execution time
-        })
-        logger.console.log("[trails-sdk] send() completed, receipts:", {
-          depositUserTxnReceipt,
-          originIntentTransaction,
-          destinationIntentTransaction,
+
+        // Execute the swap via useQuote's send function
+        // sendFn is guaranteed to be non-null here due to the check at the top of processSend
+        // Pass the current selectedFeeOption so gasless flow uses the correct fee token
+        // Pass onOriginSend as callback to be called when wallet signature is confirmed
+        const sendResult = await sendFn!({
+          selectedFeeOption: selectedFeeOption ?? null,
+          onOriginSend, // Called when wallet signature is confirmed, before tx completes
         })
+        logger.console.log("[trails-sdk] sendFn() completed:", sendResult)
 
         // Move to receipt screen
         onComplete({
-          transactionStates: quote.transactionStates,
+          transactionStates: quote.transactionStates ?? [],
         })
       }
 
@@ -1484,7 +851,7 @@ export function useSendForm({
 
         const toTokenSymbol = quote?.originToken?.symbol // Onramp will deposit origin token
         const toTokenAmount = normalizeNumber(
-          quote.originAmountFormatted,
+          quote.originAmountFormatted ?? "0",
         ).toString() // Onramp will deposit origin token amount
         const toChainId = quote?.originChain?.id // Onramp will deposit to origin chain
         const toRecipientAddress = quote.originDepositAddress // Onramp will deposit to origin address
@@ -1577,6 +944,7 @@ export function useSendForm({
     setIsWaitingForWalletConfirm(false)
   }, [
     prepareSendResult,
+    sendFn,
     amount,
     onSend,
     onConfirm,
@@ -1588,7 +956,6 @@ export function useSendForm({
     fundMethod,
     onNavigateToOnramp,
     selectedFeeOption, // Include so handleSend captures latest value
-    buildQuoteInputsFingerprint,
   ])
 
   const handleSubmit = async (e: React.FormEvent) => {
@@ -1709,14 +1076,6 @@ export function useSendForm({
     fundMethod,
   ])
 
-  useEffect(() => {
-    if (quoteError) {
-      setQuoteErrorPrettified(getPrettifiedErrorMessage(quoteError))
-    } else {
-      setQuoteErrorPrettified(null)
-    }
-  }, [quoteError])
-
   return {
     amount,
     amountRaw,
@@ -1762,8 +1121,8 @@ export function useSendForm({
     prepareSendQuote: prepareSendResult?.quote ?? null,
     quoteError,
     quoteErrorPrettified,
-    isRecipientContract,
-    isSenderContractOnOrigin,
-    isSenderContractOnDestination,
+    isRecipientContract: quoteIsRecipientContract ?? false,
+    isSenderContractOnOrigin: quoteIsSenderContractOnOrigin ?? false,
+    isSenderContractOnDestination: quoteIsSenderContractOnDestination ?? false,
   }
 }