0xtrails 0.2.5 → 0.2.6

package/src/prepareSend.ts

@@ -1,11 +1,10 @@
 import type {
   GetIntentCallsPayloadParams,
-  GetIntentCallsPayloadsReturn,
   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 { useQuery } from "@tanstack/react-query"
 import type {
   Account,
   Chain,
@@ -13,6 +12,8 @@ import type {
   TransactionReceipt,
   WalletClient,
 } from "viem"
+import { abortControllerRegistry } from "./abortController.js"
+import { extractTrailsFeeBreakdown, type TrailsFeeBreakdown } from "./fees.js"
 import {
   createPublicClient,
   createWalletClient,
@@ -35,7 +36,6 @@ import {
   trackRelayerCallStarted,
   trackTransactionConfirmed,
 } from "./analytics.js"
-import { useAPIClient } from "./apiClient.js"
 import type { Attestation } from "./cctp.js"
 import {
   approveERC20,
@@ -51,18 +51,14 @@ import {
 import { queueCCTPTransfer } from "./cctpqueue.js"
 import { getChainInfo, getTestnetChainInfo } from "./chains.js"
 import { attemptSwitchChain } from "./chainSwitch.js"
-import {
-  getSequenceEnv,
-  getSlippageTolerance,
-  type SequenceEnv,
-} from "./config.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 { getFullErrorMessage, InsufficientBalanceError } from "./error.js"
+import { InsufficientBalanceError } from "./error.js"
 import {
   estimateGasCost,
   estimateGasCostUsd,
@@ -77,7 +73,6 @@ import {
   signIntent,
 } from "./gasless.js"
 import { getIntentEntrypointFeeOptions } from "./intentEntrypoint.js"
-import { useIndexerGatewayClient } from "./indexerClient.js"
 import {
   buildSameChainTransactionParams,
   buildCrossChainDepositParams,
@@ -92,8 +87,7 @@ import { relayerSendMetaTx } from "./metaTxns.js"
 import { findFirstPreconditionForChainId } from "./preconditions.js"
 import { calcAmountUsdPrice, getTokenPrice } from "./prices.js"
 import { getQueryParam } from "./queryParams.js"
-import type { MetaTxnReceipt, RelayerEnv } from "./relayer.js"
-import { useRelayers } from "./relayer.js"
+import type { MetaTxnReceipt } from "./relayer.js"
 import {
   executeSimpleRelayTransaction,
   getRelaySDKQuote,
@@ -111,13 +105,8 @@ import {
   formatAmountDisplay,
   formatRawAmount,
   formatUsdAmountDisplay,
-  getTokenBalancesWithPrices,
 } from "./tokenBalances.js"
-import {
-  getTokenInfo,
-  useSupportedTokens,
-  type SupportedToken,
-} from "./tokens.js"
+import { getTokenInfo, type SupportedToken } from "./tokens.js"
 import {
   TRAILS_ROUTER_PLACEHOLDER_AMOUNT,
   wrapCalldataWithTrailsRouterIfNeeded,
@@ -130,9 +119,21 @@ import { getAccountTransactionHistory, getTxTimeDiff } from "./transactions.js"
 import { requestWithTimeout } from "./utils.js"
 import type { CheckoutOnHandlers } from "./widget/hooks/useCheckout.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 { useTrailsClient } from "./trailsClient.js"
 import { updatePersistentToast } from "./toast.js"
 import {
   getDelegatorSmartAccount,
@@ -182,6 +183,7 @@ export type PrepareSendOptions = {
   refundAddress?: string
   selectedFeeToken?: any
   walletId?: string
+  abortSignal?: AbortSignal
 }
 
 export type PrepareSendFees = {
@@ -232,6 +234,7 @@ export type PrepareSendQuote = {
   destinationTokenRate: string
   quoteProvider: QuoteProviderInfo | null
   noSufficientBalance: boolean
+  trailsFeeBreakdown?: TrailsFeeBreakdown | null
 }
 
 export type PrepareSendReturn = {
@@ -363,6 +366,12 @@ function getIntentArgs(
 export async function prepareSend(
   options: PrepareSendOptions,
 ): Promise<PrepareSendReturn> {
+  // Abort all existing operations when a new quote is generated
+  logger.console.log(
+    "[trails-sdk] New quote generated - aborting all existing operations",
+  )
+  abortControllerRegistry.abortAll()
+
   const {
     account,
     originTokenAddress,
@@ -396,6 +405,7 @@ export async function prepareSend(
     checkoutOnHandlers,
     selectedFeeToken,
     walletId,
+    abortSignal,
   } = options
   let { sourceTokenPriceUsd, destinationTokenPriceUsd } = options
 
@@ -672,6 +682,7 @@ export async function prepareSend(
       originRelayer,
       mode,
       fundMethod,
+      abortSignal,
     })
   }
 
@@ -714,6 +725,7 @@ export async function prepareSend(
     checkoutOnHandlers,
     selectedFeeToken,
     walletId,
+    abortSignal,
   })
 }
 
@@ -755,6 +767,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   checkoutOnHandlers,
   selectedFeeToken,
   walletId,
+  abortSignal,
 }: {
   mainSignerAddress: string
   originChainId: number
@@ -794,6 +807,7 @@ async function sendHandlerForDifferentChainDifferentToken({
   checkoutOnHandlers?: CheckoutOnHandlers
   selectedFeeToken?: any
   walletId?: string
+  abortSignal?: AbortSignal
 }): Promise<PrepareSendReturn> {
   const testnet = isTestnetDebugMode()
   const useCctp = getUseCctp(
@@ -1207,6 +1221,7 @@ async function sendHandlerForDifferentChainDifferentToken({
     quoteProvider: intent.payloads?.quote?.quoteProvider,
     noSufficientBalance,
     estimatedGasLimit: estimatedGasLimitForQuote,
+    intent,
   })
 
   // Call onCheckoutQuote callback if provided
@@ -1417,6 +1432,7 @@ async function sendHandlerForDifferentChainDifferentToken({
             trailsClient,
             selectedFeeToken: effectiveSelectedFeeToken,
             walletId,
+            abortSignal,
           })
 
           if (!originUserTxReceipt) {
@@ -1497,10 +1513,19 @@ async function sendHandlerForDifferentChainDifferentToken({
 
         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",
@@ -1509,14 +1534,16 @@ async function sendHandlerForDifferentChainDifferentToken({
               if (response.transactions.length > 0) {
                 const tx = response.transactions[0]
                 if (!tx?.txnHash) {
-                  await new Promise((resolve) => setTimeout(resolve, 1000))
+                  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))
+                //   await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY))
                 //   continue
                 // }
                 const originDepositTxReceipt =
@@ -1541,18 +1568,29 @@ async function sendHandlerForDifferentChainDifferentToken({
             } catch (error) {
               logger.console.error("Error checking for deposit tx", error)
             }
-            await new Promise((resolve) => setTimeout(resolve, 1000))
+            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",
@@ -1561,7 +1599,12 @@ async function sendHandlerForDifferentChainDifferentToken({
                 if (response.transactions.length > 0) {
                   const tx = response.transactions[0]
                   if (!tx?.txnHash) {
-                    await new Promise((resolve) => setTimeout(resolve, 1000))
+                    await new Promise((resolve) =>
+                      setTimeout(
+                        resolve,
+                        POLLING_INTERVALS.TRANSACTION_HISTORY,
+                      ),
+                    )
                     continue
                   }
                   // const isReceive = tx.transfers.some(
@@ -1588,13 +1631,15 @@ async function sendHandlerForDifferentChainDifferentToken({
               } catch (error) {
                 logger.console.error("Error checking for deposit tx", error)
               }
-              await new Promise((resolve) => setTimeout(resolve, 1000))
+              await new Promise((resolve) =>
+                setTimeout(resolve, POLLING_INTERVALS.TRANSACTION_HISTORY),
+              )
             }
           }
 
         // Variables to store the waitForReceipt functions
         let originMetaTxnReceiptPromise:
-          | (() => Promise<MetaTxnReceipt | null>)
+          | ((abortSignal?: AbortSignal) => Promise<MetaTxnReceipt | null>)
           | null = null
         let destinationMetaTxnReceiptPromise:
           | ((abortSignal?: AbortSignal) => Promise<MetaTxnReceipt | null>)
@@ -1851,6 +1896,14 @@ async function sendHandlerForDifferentChainDifferentToken({
         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({
@@ -1861,16 +1914,38 @@ async function sendHandlerForDifferentChainDifferentToken({
                 })
                 break
               }
-              await new Promise((resolve) => setTimeout(resolve, 1000))
+              await new Promise((resolve) =>
+                setTimeout(resolve, POLLING_INTERVALS.CCTP_QUEUE),
+              )
             }
           }
         } else {
           queueCctpPromise = () => Promise.resolve()
         }
 
-        checkForDepositTx().catch((error) => {
-          logger.console.error("Error checking for deposit tx", error)
-        })
+        // 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(
@@ -1895,7 +1970,8 @@ async function sendHandlerForDifferentChainDifferentToken({
           )
           if (originMetaTxnReceiptPromise) {
             try {
-              originMetaTxnReceipt = await originMetaTxnReceiptPromise()
+              originMetaTxnReceipt =
+                await originMetaTxnReceiptPromise(abortSignal)
 
               if (originMetaTxnReceipt && transactionStates[1]) {
                 transactionStates[1] = getTransactionStateFromReceipt(
@@ -1975,12 +2051,9 @@ async function sendHandlerForDifferentChainDifferentToken({
           )
           if (destinationMetaTxnReceiptPromise) {
             try {
-              // Create abort controller for cancelling destination polling
-              const abortController = new AbortController()
-
               // Race between destination receipt and failure polling
               const destinationReceiptPromise = destinationMetaTxnReceiptPromise
-                ? destinationMetaTxnReceiptPromise(abortController.signal)
+                ? destinationMetaTxnReceiptPromise(abortSignal)
                 : Promise.resolve(null)
 
               const failurePollingPromise = new Promise<null>((resolve) => {
@@ -1997,11 +2070,13 @@ async function sendHandlerForDifferentChainDifferentToken({
                     logger.console.log(
                       "[trails-sdk] Aborting destination meta transaction due to previous transaction failure",
                     )
-                    abortController.abort()
                     resolve(null)
                   } else {
-                    // Continue polling every 1 second
-                    setTimeout(pollForFailures, 1000)
+                    // Continue polling with consistent interval
+                    setTimeout(
+                      pollForFailures,
+                      POLLING_INTERVALS.FAILURE_POLLING,
+                    )
                   }
                 }
                 pollForFailures()
@@ -2277,6 +2352,7 @@ async function sendHandlerForSameChainSameToken({
   selectedFeeToken,
   trailsClient,
   originRelayer,
+  abortSignal,
 }: {
   originTokenAddress: string
   originTokenDecimals: number
@@ -2303,6 +2379,7 @@ async function sendHandlerForSameChainSameToken({
   selectedFeeToken?: any
   trailsClient: TrailsAPIClient
   originRelayer: Relayer.RpcRelayer
+  abortSignal?: AbortSignal
 }): Promise<PrepareSendReturn> {
   logger.console.log("[trails-sdk] isToSameToken && isToSameChain")
   const testnet = isTestnetDebugMode()
@@ -2386,6 +2463,7 @@ async function sendHandlerForSameChainSameToken({
     quoteProvider: "",
     noSufficientBalance,
     estimatedGasLimit: estimatedGasLimitForQuote,
+    intent: undefined,
   })
 
   // Call onCheckoutQuote callback if provided
@@ -2519,6 +2597,7 @@ async function sendHandlerForSameChainSameToken({
               selectedFeeToken,
               trailsClient,
               originRelayer,
+              abortSignal,
             })
 
             if (receipt) {
@@ -2900,6 +2979,7 @@ async function _sendHandlerForSameChainDifferentToken({
     destinationChainId: originChainId,
     originNativeTokenPriceUsd,
     quoteProvider: "relay",
+    intent: undefined,
   })
 
   return {
@@ -3023,6 +3103,7 @@ async function attemptGaslessDeposit({
   originRelayer,
   feeOptions,
   selectedFeeToken,
+  abortSignal,
 }: {
   paymasterUrl?: string
   depositTokenAddress: string
@@ -3036,6 +3117,7 @@ async function attemptGaslessDeposit({
   originRelayer: Relayer.RpcRelayer
   feeOptions: any
   selectedFeeToken?: any
+  abortSignal?: AbortSignal
 }): Promise<TransactionReceipt | null> {
   let originUserTxReceipt: TransactionReceipt | null = null
   const originChainId = chain.id
@@ -3383,6 +3465,14 @@ async function attemptGaslessDeposit({
     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,
@@ -3405,7 +3495,9 @@ async function attemptGaslessDeposit({
         break
       }
 
-      await new Promise((resolve) => setTimeout(resolve, 1000))
+      await new Promise((resolve) =>
+        setTimeout(resolve, POLLING_INTERVALS.META_TRANSACTION),
+      )
     }
   } catch (error) {
     logger.console.error(
@@ -3766,6 +3858,7 @@ async function attemptUserDepositTx({
   trailsClient,
   selectedFeeToken,
   walletId,
+  abortSignal,
 }: {
   originTokenAddress: string
   gasless: boolean
@@ -3795,6 +3888,7 @@ async function attemptUserDepositTx({
   trailsClient: TrailsAPIClient
   selectedFeeToken?: any
   walletId?: string
+  abortSignal?: AbortSignal
 }): Promise<TransactionReceipt | null> {
   let originUserTxReceipt: TransactionReceipt | null = null
   const originChainId = chain.id
@@ -3858,6 +3952,7 @@ async function attemptUserDepositTx({
         originRelayer,
         feeOptions: feeOptions,
         selectedFeeToken: selectedFeeToken,
+        abortSignal,
       })
     } catch (error) {
       logger.console.log("[trails-sdk] gassless attempt failed", error)
@@ -4093,38 +4188,84 @@ async function sendMetaTxAndWaitForReceipt({
     waitForReceipt: async (abortSignal?: AbortSignal) => {
       let originMetaTxnReceipt: MetaTxnReceipt | null = null
 
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
-        // Check if we should abort
-        if (abortSignal?.aborted) {
+      // 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] Aborting meta transaction polling due to abort signal",
+            "[trails-sdk] polling status",
+            metaTx.id as `0x${string}`,
+            metaTx.chainId.toString(),
           )
-          return null
-        }
+          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
+          }
 
-        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")
+          // Check abort signal before waiting
+          if (abortSignal?.aborted || pollingAbortController.signal.aborted) {
+            logger.console.log(
+              "[trails-sdk] Aborting meta transaction polling before delay",
+            )
+            return null
           }
-          break
+
+          // 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 },
+            )
+          })
         }
-        await new Promise((resolve) => setTimeout(resolve, 1000))
-      }
 
-      return originMetaTxnReceipt
+        return originMetaTxnReceipt
+      } finally {
+        // Always unregister when polling completes or is aborted
+        abortControllerRegistry.unregister(pollingId)
+      }
     },
   }
 }
@@ -4285,341 +4426,18 @@ function getNeedsLifiNativeFee({
   return needsNativeFee
 }
 
-export type UseQuoteProps = {
-  walletClient?: any // TODO: fix this, has to do with viem/wagmi versions
-  fromTokenAddress?: string | null
-  fromChainId?: number | null
-  toTokenAddress?: string | null
-  toChainId?: number | null
-  toCalldata?: string | null
-  swapAmount?: string | bigint
-  toRecipient?: string | null
-  tradeType?: TradeType | null
-  slippageTolerance?: string | number | null
-  onStatusUpdate?: ((transactionStates: TransactionState[]) => void) | null
-  quoteProvider?: string | null
-  gasless?: boolean
-  paymasterUrl?: string
-  selectedFeeToken?: {
-    tokenAddress: string
-    tokenSymbol?: string
-  } | null
-}
+// 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"
 
-export type SwapReturn = {
-  originTransaction: {
-    transactionHash?: string | null
-    explorerUrl?: string | null
-    receipt: TransactionReceipt | MetaTxnReceipt | null
-  }
-  destinationTransaction: {
-    transactionHash?: string | null
-    explorerUrl?: string | null
-    receipt: MetaTxnReceipt | null
-  }
-  totalCompletionSeconds?: number
-}
-
-export type QuoteProviderInfo = {
-  id: string
-  name: string
-  url: string
-}
-
-export type Quote = {
-  fromAmount: string
-  fromAmountMin: string
-  toAmount: string
-  toAmountMin: string
-  originToken: SupportedToken
-  destinationToken: SupportedToken
-  originChain: Chain
-  destinationChain: Chain
-  fees: PrepareSendFees
-  slippageTolerance: string
-  priceImpact: string
-  completionEstimateSeconds: number
-  transactionStates?: TransactionState[]
-  originTokenRate?: string
-  quoteProvider?: QuoteProviderInfo | null
-  destinationTokenRate?: string
-  fromAmountUsdDisplay?: string
-  toAmountUsdDisplay?: string
-  gasCostUsd?: number
-  gasCostUsdDisplay?: string
-  gasCost?: string
-  gasCostFormatted?: string
-}
-
-export type UseQuoteReturn = {
-  quote: Quote | null
-  swap: (() => Promise<SwapReturn | null>) | null
-  isLoadingQuote: boolean
-  quoteError: unknown
-  refetchQuote: () => void
-}
-
-export function useQuote({
-  walletClient,
-  fromTokenAddress,
-  fromChainId,
-  toTokenAddress,
-  toChainId,
-  swapAmount,
-  tradeType,
-  toRecipient,
-  toCalldata,
-  slippageTolerance,
-  onStatusUpdate,
-  quoteProvider,
-  gasless,
-  paymasterUrl,
-  selectedFeeToken,
-  relayerEnv,
-  nodeGatewayEnv,
-}: Partial<
-  UseQuoteProps & { relayerEnv?: RelayerEnv; nodeGatewayEnv?: SequenceEnv }
-> = {}): UseQuoteReturn {
-  // Set node gateway environment override for this quote session
-  if (nodeGatewayEnv) {
-    ;(globalThis as any).__testNodeGatewayEnv = nodeGatewayEnv
-  }
-
-  const apiClient = useAPIClient()
-  const trailsClient = useTrailsClient()
-  const { getRelayer } = useRelayers({
-    env: relayerEnv || (getSequenceEnv() as RelayerEnv),
-  })
-  const indexerGatewayClient = useIndexerGatewayClient()
-
-  const { supportedTokens } = useSupportedTokens()
-
-  const { data, isLoading, error, refetch } = useQuery({
-    queryKey: [
-      "quote",
-      fromTokenAddress,
-      fromChainId,
-      toTokenAddress,
-      toChainId,
-      swapAmount?.toString(),
-      toRecipient,
-      toCalldata,
-      tradeType,
-      slippageTolerance,
-      quoteProvider,
-    ],
-    queryFn: async () => {
-      try {
-        if (
-          !walletClient ||
-          !apiClient ||
-          !trailsClient ||
-          !fromTokenAddress ||
-          !toTokenAddress ||
-          !swapAmount ||
-          !toRecipient ||
-          !fromChainId ||
-          !toChainId ||
-          !indexerGatewayClient
-        ) {
-          return null
-        }
-
-        // Get token balance using async method
-        const { balances } = await getTokenBalancesWithPrices({
-          account: walletClient.account!.address,
-          indexerGatewayClient,
-          apiClient,
-        })
-
-        const originTokenBalance = balances.find(
-          (b) =>
-            b.chainId === fromChainId &&
-            (b.contractAddress?.toLowerCase() ===
-              fromTokenAddress.toLowerCase() ||
-              (!b.contractAddress && fromTokenAddress === zeroAddress)),
-        )
-
-        const originTokenBalanceAmount = originTokenBalance?.balance ?? "0"
-        const destinationRelayer = getRelayer(toChainId)
-        const originRelayer = getRelayer(fromChainId)
-
-        // Note: Disable this check for now to allow fetching a quote even when the origin balance is zero
-        // if (originTokenBalanceAmount === "0") {
-        //   return null
-        // }
-
-        // logger.console.log("supportedTokens", supportedTokens)
-
-        const originToken = supportedTokens?.find(
-          (token) =>
-            token.contractAddress?.toLowerCase() ===
-              fromTokenAddress?.toLowerCase() && token.chainId === fromChainId,
-        )
-        const destinationToken = supportedTokens?.find(
-          (token) =>
-            token.contractAddress?.toLowerCase() ===
-              toTokenAddress?.toLowerCase() && token.chainId === toChainId,
-        )
-
-        const sourceTokenDecimals = originToken?.decimals
-        if (!sourceTokenDecimals) {
-          logger.console.error(
-            "[trails-sdk] [useQuote] Missing source token decimals:",
-            {
-              originToken,
-              fromTokenAddress,
-              fromChainId,
-            },
-          )
-          throw new Error("Source token decimals not found")
-        }
-        const destinationTokenDecimals = destinationToken?.decimals
-        if (!destinationTokenDecimals) {
-          logger.console.error(
-            "[trails-sdk] Missing destination token decimals:",
-            {
-              destinationToken,
-              toTokenAddress,
-              toChainId,
-            },
-          )
-          throw new Error("Destination token decimals not found")
-        }
-        const destinationTokenSymbol = destinationToken?.symbol ?? ""
-        const originTokenSymbol = originToken?.symbol ?? ""
-
-        const options = {
-          account: walletClient.account!,
-          originTokenAddress: fromTokenAddress,
-          originChainId: fromChainId,
-          originTokenBalance: originTokenBalanceAmount,
-          destinationChainId: toChainId,
-          recipient: toRecipient,
-          destinationTokenAddress: toTokenAddress,
-          swapAmount: swapAmount.toString(),
-          tradeType: tradeType ?? TradeType.EXACT_OUTPUT,
-          originTokenSymbol: originTokenSymbol,
-          destinationTokenSymbol: destinationTokenSymbol,
-          destinationCalldata: toCalldata as string,
-          client: walletClient,
-          apiClient,
-          trailsClient,
-          originRelayer,
-          destinationRelayer,
-          sourceTokenDecimals,
-          destinationTokenDecimals,
-          fee: "0",
-          dryMode: false,
-          onTransactionStateChange: onStatusUpdate ?? (() => {}),
-          slippageTolerance: slippageTolerance?.toString(),
-          quoteProvider: quoteProvider,
-          gasless: gasless ?? false,
-          paymasterUrl: paymasterUrl,
-          selectedFeeToken: selectedFeeToken ?? undefined,
-        }
-
-        logger.console.log("[trails-sdk] options", options)
-
-        const { quote: prepareSendQuote, send } = await prepareSend(options)
-
-        const quote = {
-          fromAmount: prepareSendQuote.originAmount,
-          toAmount: prepareSendQuote.destinationAmount,
-          fromAmountMin: prepareSendQuote.originAmountMin,
-          toAmountMin: prepareSendQuote.destinationAmountMin,
-          originToken: prepareSendQuote.originToken,
-          destinationToken: prepareSendQuote.destinationToken,
-          originChain: prepareSendQuote.originChain,
-          destinationChain: prepareSendQuote.destinationChain,
-          fees: prepareSendQuote.fees,
-          priceImpact: prepareSendQuote.priceImpact,
-          completionEstimateSeconds: prepareSendQuote.completionEstimateSeconds,
-          slippageTolerance: prepareSendQuote.slippageTolerance,
-          transactionStates: prepareSendQuote.transactionStates,
-          originTokenRate: prepareSendQuote.originTokenRate,
-          destinationTokenRate: prepareSendQuote.destinationTokenRate,
-          quoteProvider: prepareSendQuote.quoteProvider,
-          fromAmountUsdDisplay:
-            prepareSendQuote.originAmountUsdDisplay ?? undefined,
-          toAmountUsdDisplay:
-            prepareSendQuote.destinationAmountUsdDisplay ?? undefined,
-          gasCostUsd: prepareSendQuote.gasCostUsd ?? undefined,
-          gasCostUsdDisplay: prepareSendQuote.gasCostUsdDisplay ?? undefined,
-          gasCost: prepareSendQuote.gasCost ?? undefined,
-          gasCostFormatted: prepareSendQuote.gasCostFormatted ?? undefined,
-        }
-
-        const swap = async (): Promise<SwapReturn> => {
-          const {
-            originUserTxReceipt,
-            destinationMetaTxnReceipt,
-            totalCompletionSeconds,
-          } = await send({
-            selectedFeeToken: selectedFeeToken ?? undefined,
-          })
-
-          return {
-            originTransaction: {
-              transactionHash: originUserTxReceipt?.transactionHash,
-              explorerUrl: getExplorerUrl({
-                txHash: originUserTxReceipt?.transactionHash as string,
-                chainId: fromChainId,
-              }),
-              receipt: originUserTxReceipt,
-            },
-            destinationTransaction: {
-              transactionHash: destinationMetaTxnReceipt?.txnHash,
-              explorerUrl: getExplorerUrl({
-                txHash: destinationMetaTxnReceipt?.txnHash as string,
-                chainId: toChainId,
-              }),
-              receipt: destinationMetaTxnReceipt,
-            },
-            totalCompletionSeconds,
-          }
-        }
-
-        return {
-          quote,
-          swap,
-        }
-      } catch (error) {
-        logger.console.error(
-          "[trails-sdk] [useQuote] Error getting quote:",
-          error,
-        )
-        throw getFullErrorMessage(error)
-      }
-    },
-    // Prevent unnecessary refetching
-    enabled: Boolean(
-      walletClient &&
-        apiClient &&
-        fromTokenAddress &&
-        toTokenAddress &&
-        swapAmount &&
-        toRecipient &&
-        fromChainId &&
-        toChainId &&
-        indexerGatewayClient,
-    ),
-    staleTime: 30 * 1000, // Consider data fresh for 30 seconds
-    refetchOnWindowFocus: false, // Don't refetch when window regains focus
-    refetchOnMount: false, // Don't refetch on component remount if data exists
-    refetchInterval: false, // Disable automatic polling
-    retry: 2, // Limit retry attempts
-    refetchOnReconnect: true, // Refetch when network reconnects
-  })
-
-  return {
-    quote: data?.quote || null,
-    swap: data?.swap || null,
-    isLoadingQuote: isLoading,
-    quoteError: error,
-    refetchQuote: () => refetch(),
-  }
-}
+// Import QuoteProviderInfo for use in this file
+import type { QuoteProviderInfo } from "./widget/hooks/useQuote.js"
 
 export function getFeesFromIntent(
   intent: GetIntentCallsPayloadsReturn,
@@ -4746,6 +4564,7 @@ export async function getNormalizedQuoteObject({
   quoteProvider,
   noSufficientBalance,
   estimatedGasLimit,
+  intent,
 }: {
   originDepositAddress?: string
   destinationDepositAddress?: string
@@ -4770,6 +4589,7 @@ export async function getNormalizedQuoteObject({
   quoteProvider?: string
   noSufficientBalance?: boolean
   estimatedGasLimit?: bigint
+  intent?: GetIntentCallsPayloadsReturn
 }): Promise<PrepareSendQuote> {
   if (!destinationChainId) {
     throw new Error("Destination chain id is required")
@@ -4958,6 +4778,12 @@ export async function getNormalizedQuoteObject({
 
   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 || "",
@@ -5004,6 +4830,7 @@ export async function getNormalizedQuoteObject({
     ),
     quoteProvider: quoteProviderInfo,
     noSufficientBalance: noSufficientBalance || false,
+    trailsFeeBreakdown,
   }
 }