0xtrails 0.13.2 → 0.14.0

package/src/transactionIntent/quote/normalizeQuote.ts

@@ -1,559 +0,0 @@
-import type { Intent } from "@0xtrails/api"
-import type { TransactionState } from "../../transactions.js"
-import type { PrepareSendQuote, PrepareSendFees } from "../types.js"
-import type { RouteProviderInfo } from "../../widget/hooks/useQuote.js"
-import { formatUnits } from "viem"
-import { mainnet } from "viem/chains"
-import { getTokenInfo } from "../../tokens.js"
-import { getChainInfo, getChainRpcClient } from "../../chains.js"
-import { logger } from "../../logger.js"
-import {
-  formatRawAmount,
-  formatAmount,
-  formatAmountDisplay,
-  formatAmountLocaleDisplay,
-  formatUsdAmountDisplay,
-  formatUsdAmountLocaleDisplay,
-} from "../../utils/format.js"
-import { getIsCustomCalldata } from "../../contractUtils.js"
-import { DEFAULT_MIN_GASLIMIT, getFeeData } from "../../estimate.js"
-import { extractTrailsFeeBreakdown, ROUTE_PROVIDER_INFO } from "../../fees.js"
-import { getZeroFees } from "./feeExtractors.js"
-import { formatDuration } from "../../utils/time.js"
-import { IntentProtocolVersion } from "@0xtrails/api"
-
-export function getCompletionEstimateSeconds({
-  originChainId,
-  destinationChainId,
-  esimatedDurationSeconds,
-}: {
-  originChainId: number
-  destinationChainId: number
-  esimatedDurationSeconds?: number | null
-}): number {
-  // Prefer provider-estimated route duration from QuoteIntent API when available.
-  if (
-    esimatedDurationSeconds != null &&
-    Number.isFinite(esimatedDurationSeconds) &&
-    esimatedDurationSeconds >= 0
-  ) {
-    return Math.round(esimatedDurationSeconds)
-  }
-
-  if (originChainId === mainnet.id && destinationChainId === mainnet.id) {
-    return 60
-  }
-
-  if (originChainId === mainnet.id || destinationChainId === mainnet.id) {
-    return 45
-  }
-
-  return 15
-}
-
-function getCompletionEstimateDisplay({
-  originChainId,
-  destinationChainId,
-  esimatedDurationSeconds,
-}: {
-  originChainId: number
-  destinationChainId: number
-  esimatedDurationSeconds?: number | null
-}): string {
-  return formatDuration(
-    getCompletionEstimateSeconds({
-      originChainId,
-      destinationChainId,
-      esimatedDurationSeconds,
-    }),
-  )
-}
-
-function getEsimatedDurationSeconds(intent?: Intent): number | undefined {
-  if (!intent?.quote) return undefined
-
-  const quote = intent.quote as { estimatedDuration?: unknown }
-  if (
-    typeof quote.estimatedDuration === "number" &&
-    Number.isFinite(quote.estimatedDuration)
-  ) {
-    return quote.estimatedDuration
-  }
-
-  return undefined
-}
-
-export async function getNormalizedQuoteObject({
-  originDepositAddress,
-  destinationDepositAddress,
-  destinationAddress,
-  destinationApproveAddress,
-  destinationCalldata,
-  originChainId,
-  destinationChainId,
-  originAmount,
-  originAmountMin,
-  destinationAmount,
-  destinationAmountMin,
-  originTokenAddress,
-  destinationTokenAddress,
-  originTokenPriceUsd,
-  destinationTokenPriceUsd,
-  transactionStates,
-  fees,
-  slippageTolerance,
-  priceImpact,
-  priceImpactUsd,
-  originNativeTokenPriceUsd,
-  noSufficientBalance,
-  estimatedGasLimit,
-  intent,
-  trailsApiKey,
-  trailsApiUrl,
-  sequenceMetadataUrl,
-  feeData: providedFeeData,
-}: {
-  originDepositAddress?: string
-  destinationDepositAddress?: string
-  destinationAddress?: string
-  destinationApproveAddress?: string
-  destinationCalldata?: string
-  originChainId: number
-  destinationChainId?: number
-  originAmount: string
-  originAmountMin?: string
-  destinationAmount: string
-  destinationAmountMin?: string
-  originTokenAddress: string
-  destinationTokenAddress?: string
-  originTokenPriceUsd?: string | null
-  destinationTokenPriceUsd?: string | null
-  transactionStates?: TransactionState[]
-  fees?: PrepareSendFees
-  slippageTolerance?: string | null
-  priceImpact?: string
-  priceImpactUsd?: string
-  originNativeTokenPriceUsd?: number | null
-  noSufficientBalance?: boolean
-  estimatedGasLimit?: bigint
-  intent?: Intent
-  trailsApiKey: string
-  trailsApiUrl: string
-  sequenceMetadataUrl: string
-  /** Pre-fetched fee data to avoid additional RPC calls */
-  feeData?: {
-    maxFeePerGas?: bigint
-    maxPriorityFeePerGas?: bigint
-    gasPrice?: bigint
-  }
-}): Promise<PrepareSendQuote> {
-  if (!destinationChainId) {
-    throw new Error("Destination chain id is required")
-  }
-
-  if (!destinationTokenAddress && originChainId === destinationChainId) {
-    destinationTokenAddress = originTokenAddress
-  }
-
-  if (!destinationTokenAddress && originChainId === destinationChainId) {
-    destinationTokenAddress = originTokenAddress
-  }
-
-  if (!destinationTokenAddress) {
-    throw new Error("Destination token address is required")
-  }
-
-  const originToken = await getTokenInfo(originChainId, originTokenAddress, {
-    trailsApiKey,
-    trailsApiUrl,
-    sequenceMetadataUrl,
-  })
-  const destinationToken = await getTokenInfo(
-    destinationChainId,
-    destinationTokenAddress,
-    {
-      trailsApiKey,
-      trailsApiUrl,
-      sequenceMetadataUrl,
-    },
-  )
-
-  const originChain = getChainInfo(originChainId)
-  const destinationChain = getChainInfo(destinationChainId)
-
-  if (!originToken || !destinationToken || !originChain || !destinationChain) {
-    logger.console.error("[trails-sdk] Token or chain not found", {
-      originToken,
-      destinationToken,
-      originChain,
-      destinationChain,
-    })
-    throw new Error("Token or chain not found")
-  }
-
-  // Use server quote values when available for consistency with USD calculations
-  const originAmountMinFormatted = formatRawAmount(
-    intent?.quote?.fromAmountMin?.toString() || originAmountMin || "0",
-    originToken.decimals,
-  )
-  const originAmountMinUsdFormatted = formatAmount(
-    intent?.quote?.fromAmountMinUsd || 0,
-  )
-  const originAmountMinUsdDisplay = formatUsdAmountDisplay(
-    intent?.quote?.fromAmountMinUsd || 0,
-  )
-
-  const destinationAmountMinFormatted = formatRawAmount(
-    intent?.quote?.toAmountMin?.toString() || destinationAmountMin || "0",
-    destinationToken.decimals,
-  )
-  const destinationAmountMinUsdFormatted = formatAmount(
-    intent?.quote?.toAmountMinUsd || 0,
-  )
-  const destinationAmountMinUsdDisplay = formatUsdAmountDisplay(
-    intent?.quote?.toAmountMinUsd || 0,
-  )
-
-  const originAmountFormatted = formatRawAmount(
-    intent?.quote?.fromAmount?.toString() || originAmount,
-    originToken.decimals,
-  )
-  const originAmountFormattedLocale = formatAmountLocaleDisplay(
-    formatRawAmount(
-      intent?.quote?.fromAmount?.toString() || originAmount,
-      originToken.decimals,
-    ),
-  )
-  const fromAmountUsdValue = intent?.quote?.fromAmountUsd || 0
-
-  const originAmountUsdFormatted = formatAmount(fromAmountUsdValue)
-  const originAmountUsdDisplay = formatUsdAmountDisplay(fromAmountUsdValue)
-  const originAmountUsdLocaleDisplay =
-    formatUsdAmountLocaleDisplay(fromAmountUsdValue)
-
-  const destinationAmountFormatted = formatRawAmount(
-    intent?.quote?.toAmount?.toString() || destinationAmount,
-    destinationToken.decimals,
-  )
-  const destinationAmountFormattedLocale = formatAmountLocaleDisplay(
-    formatRawAmount(
-      intent?.quote?.toAmount?.toString() || destinationAmount,
-      destinationToken.decimals,
-    ),
-  )
-  const destinationAmountUsdFormatted = formatAmount(
-    intent?.quote?.toAmountUsd || 0,
-  )
-  const destinationAmountUsdDisplay = formatUsdAmountDisplay(
-    intent?.quote?.toAmountUsd || 0,
-  )
-  const destinationAmountUsdLocaleDisplay = formatUsdAmountLocaleDisplay(
-    intent?.quote?.toAmountUsd || 0,
-  )
-
-  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-
-  const publicClient = getChainRpcClient(originChain.id)
-
-  let gasCostUsd: number = 0
-  let gasCostUsdDisplay: string = "0"
-  let gasCost: string = "0"
-  let gasCostFormatted: string = "0"
-  try {
-    if (originNativeTokenPriceUsd && (estimatedGasLimit || providedFeeData)) {
-      // Use the actual estimated gas limit if provided, otherwise use default
-      // This ensures the quote gas cost matches what will be used in the actual transaction
-      const gasLimitForCost = estimatedGasLimit || DEFAULT_MIN_GASLIMIT
-
-      logger.console.log(
-        "[trails-sdk][gas-estimation] Calculating gas cost for quote with gasLimit:",
-        gasLimitForCost,
-        "(estimated:",
-        estimatedGasLimit,
-        "default:",
-        DEFAULT_MIN_GASLIMIT,
-        ")",
-      )
-
-      // Use pre-fetched fee data if available, otherwise fetch it
-      const feeData = providedFeeData || (await getFeeData(publicClient))
-
-      // Use maxFeePerGas for EIP-1559, otherwise use legacy gas price
-      const effectiveGasPrice = feeData.maxFeePerGas || feeData.gasPrice
-
-      if (!effectiveGasPrice) {
-        throw new Error("Could not determine gas price")
-      }
-
-      // Calculate gas cost in wei: gasLimit × effectiveGasPrice
-      const gasCostWei = gasLimitForCost * effectiveGasPrice
-      gasCost = gasCostWei.toString()
-      gasCostFormatted = formatUnits(gasCostWei, 18) // Native tokens always use 18 decimals
-
-      // Calculate USD value from the same fee data
-      const gasCostInEth = parseFloat(formatUnits(gasCostWei, 18))
-      gasCostUsd = gasCostInEth * originNativeTokenPriceUsd
-      gasCostUsdDisplay = formatUsdAmountDisplay(gasCostUsd)
-
-      logger.console.log(
-        "[trails-sdk][gas-estimation] Quote gas cost calculated:",
-        {
-          gasCostWei,
-          gasCost,
-          gasCostFormatted,
-          gasCostUsd,
-          gasCostUsdDisplay,
-        },
-      )
-    }
-  } catch (error) {
-    logger.console.error(
-      "[trails-sdk][gas-estimation] Error estimating gas cost for quote display",
-      error,
-    )
-  }
-
-  // Calculate exchange rates using server-derived prices when available
-  // This ensures consistency with server-provided USD amounts (fromAmountUsd, toAmountUsd)
-  // Uses != null checks to handle 0 values correctly (not truthy checks)
-  const originTokenPrice =
-    intent?.quote?.fromAmountUsd != null && intent?.quote?.fromAmount != null
-      ? intent.quote.fromAmountUsd /
-        Number(formatUnits(intent.quote.fromAmount, originToken.decimals))
-      : originTokenPriceUsd != null
-        ? Number(originTokenPriceUsd)
-        : 0
-  const destinationTokenPrice =
-    intent?.quote?.toAmountUsd != null && intent?.quote?.toAmount != null
-      ? intent.quote.toAmountUsd /
-        Number(formatUnits(intent.quote.toAmount, destinationToken.decimals))
-      : destinationTokenPriceUsd != null
-        ? Number(destinationTokenPriceUsd)
-        : 0
-  const exchangeRates = getTokenExchangeRates(
-    originTokenPrice,
-    destinationTokenPrice,
-    originToken.symbol,
-    destinationToken.symbol,
-  )
-
-  // Build routeProviders array from intent.quote.routeProviders
-  const routeProviders: RouteProviderInfo[] =
-    intent?.quote?.routeProviders && Array.isArray(intent.quote.routeProviders)
-      ? intent.quote.routeProviders.map((provider) => {
-          const info = ROUTE_PROVIDER_INFO[provider] || {
-            name: provider,
-            url: "",
-          }
-          return {
-            id: provider,
-            name: info.name,
-            url: info.url,
-          }
-        })
-      : []
-
-  const priceImpactUsdDisplay = formatUsdAmountDisplay(priceImpactUsd)
-  const priceImpactUsdLocaleDisplay =
-    formatUsdAmountLocaleDisplay(priceImpactUsd)
-
-  // Extract fee breakdown and calculate all fee values from intent
-  // Use raw USD values to avoid parsing display strings
-  const {
-    trailsFeeBreakdown,
-    totalFeesUsd,
-    totalFeesUsdDisplay,
-    originGasUsd,
-    destinationGasUsd,
-    totalGasUsd,
-    providerFeeUsd,
-    trailsFeeUsd,
-    originGasUsdDisplay,
-    destinationGasUsdDisplay,
-    totalGasUsdDisplay,
-    providerFeeUsdDisplay,
-    trailsFeeUsdDisplay,
-    totalProviderFeesUsd,
-    totalProviderFeesUsdDisplay,
-  } = intent
-    ? await extractTrailsFeeBreakdown(
-        intent,
-        { trailsApiKey, trailsApiUrl, sequenceMetadataUrl },
-        {
-          originAmountUsd: intent?.quote?.fromAmountUsd || 0,
-          destinationAmountUsd: intent?.quote?.toAmountUsd || 0,
-          totalFeesUsd: parseFloat(
-            fees?.totalFeeAmountUsdDisplay?.replace(/[^0-9.-]/g, "") || "0",
-          ),
-        },
-      )
-    : {
-        trailsFeeBreakdown: null,
-        totalFeesUsd: 0,
-        totalFeesUsdDisplay: "$0.00",
-        originGasUsd: 0,
-        destinationGasUsd: 0,
-        totalGasUsd: 0,
-        providerFeeUsd: 0,
-        trailsFeeUsd: 0,
-        originGasUsdDisplay: "$0.00",
-        destinationGasUsdDisplay: "$0.00",
-        totalGasUsdDisplay: "$0.00",
-        providerFeeUsdDisplay: "$0.00",
-        trailsFeeUsdDisplay: "$0.00",
-        totalProviderFeesUsd: 0,
-        totalProviderFeesUsdDisplay: "$0.00",
-      }
-
-  const rawIntentProtocol = (
-    intent as { intentProtocol?: string } | null | undefined
-  )?.intentProtocol
-
-  if (!rawIntentProtocol) {
-    logger.console.log(
-      "[trails-sdk] [intent-protocol] Intent protocol version not in API response, defaulting to v1",
-    )
-  }
-  const intentProtocol =
-    rawIntentProtocol === "v1.5"
-      ? IntentProtocolVersion.v1_5
-      : IntentProtocolVersion.v1
-
-  logger.console.log(
-    "[trails-sdk] [intent-protocol] Quote normalized with version",
-    {
-      intentProtocol,
-      intentId: intent?.intentId,
-    },
-  )
-
-  const esimatedDurationSeconds = getEsimatedDurationSeconds(intent)
-
-  const completionEstimateSeconds = getCompletionEstimateSeconds({
-    originChainId,
-    destinationChainId,
-    esimatedDurationSeconds,
-  })
-
-  return {
-    intentProtocol,
-    originDepositAddress: originDepositAddress || "",
-    destinationDepositAddress: destinationDepositAddress || "",
-    destinationAddress: destinationAddress || "",
-    destinationApproveAddress,
-    destinationCalldata: hasCustomCalldata ? destinationCalldata || "" : "",
-    intentId: intent?.intentId ?? null,
-    expiresAt: intent?.expiresAt ?? null,
-    originAmount: originAmount || "0",
-    originAmountMin: originAmountMin || originAmount || "0",
-    originAmountMinUsdFormatted: originAmountMinUsdFormatted || "0",
-    originAmountMinUsdDisplay: originAmountMinUsdDisplay || "0",
-    destinationAmount: destinationAmount || "0",
-    destinationAmountMin: destinationAmountMin || destinationAmount || "0",
-    destinationAmountMinUsdFormatted: destinationAmountMinUsdFormatted || "0",
-    destinationAmountMinUsdDisplay: destinationAmountMinUsdDisplay || "0",
-    originAmountFormatted,
-    originAmountFormattedLocale,
-    originAmountUsd: intent?.quote?.fromAmountUsd || undefined,
-    fromAmountUsd: intent?.quote?.fromAmountUsd || undefined,
-    originAmountUsdFormatted,
-    originAmountUsdDisplay,
-    originAmountUsdLocaleDisplay,
-    destinationAmountFormatted,
-    destinationAmountFormattedLocale,
-    destinationAmountUsd: intent?.quote?.toAmountUsd || undefined,
-    toAmountUsd: intent?.quote?.toAmountUsd || undefined,
-    destinationAmountUsdFormatted,
-    destinationAmountUsdDisplay,
-    destinationAmountUsdLocaleDisplay,
-    originToken,
-    destinationToken,
-    fees: fees || getZeroFees(),
-    slippageTolerance: slippageTolerance || "0",
-    maxSlippage: intent?.quote?.maxSlippage ?? null, // Backend-calculated slippage (AUTO mode)
-    priceImpact: priceImpact || "0",
-    priceImpactUsd: priceImpactUsd || undefined,
-    priceImpactUsdDisplay: priceImpactUsdDisplay || "0",
-    originChain,
-    destinationChain,
-    completionEstimateSeconds,
-    completionEstimateDisplay: getCompletionEstimateDisplay({
-      originChainId,
-      destinationChainId,
-      esimatedDurationSeconds,
-    }),
-    transactionStates: transactionStates || [],
-    gasCostUsd,
-    gasCostUsdDisplay,
-    gasCost,
-    gasCostFormatted,
-    originTokenRate: exchangeRates.originTokenRate,
-    destinationTokenRate: exchangeRates.destinationTokenRate,
-    originTokenPriceUsd: originTokenPrice,
-    destinationTokenPriceUsd: destinationTokenPrice,
-    originAmountDisplay: formatAmountDisplay(originAmountFormatted),
-    destinationAmountDisplay: formatAmountDisplay(destinationAmountFormatted),
-    originAmountMinDisplay: formatAmountDisplay(originAmountMinFormatted),
-    destinationAmountMinDisplay: formatAmountDisplay(
-      destinationAmountMinFormatted,
-    ),
-    routeProviders,
-    noSufficientBalance: noSufficientBalance || false,
-    trailsFeeBreakdown,
-    totalFeesUsd,
-    totalFeesUsdDisplay,
-    originGasUsd,
-    destinationGasUsd,
-    totalGasUsd,
-    providerFeeUsd,
-    trailsFeeUsd,
-    originGasUsdDisplay,
-    destinationGasUsdDisplay,
-    totalGasUsdDisplay,
-    providerFeeUsdDisplay,
-    trailsFeeUsdDisplay,
-    totalProviderFeesUsd,
-    totalProviderFeesUsdDisplay,
-    // Locale display values
-    originGasUsdLocaleDisplay: formatUsdAmountLocaleDisplay(originGasUsd),
-    destinationGasUsdLocaleDisplay:
-      formatUsdAmountLocaleDisplay(destinationGasUsd),
-    totalGasUsdLocaleDisplay: formatUsdAmountLocaleDisplay(totalGasUsd),
-    providerFeeUsdLocaleDisplay: formatUsdAmountLocaleDisplay(providerFeeUsd),
-    trailsFeeUsdLocaleDisplay: formatUsdAmountLocaleDisplay(trailsFeeUsd),
-    totalProviderFeesUsdLocaleDisplay:
-      formatUsdAmountLocaleDisplay(totalProviderFeesUsd),
-    priceImpactUsdLocaleDisplay,
-    priceImpactDetails: intent?.quote?.priceImpactDetails ?? null,
-  }
-}
-
-function getTokenExchangeRates(
-  originTokenPrice: number,
-  destinationTokenPrice: number,
-  originTokenSymbol: string,
-  destinationTokenSymbol: string,
-): { originTokenRate: string; destinationTokenRate: string } {
-  if (originTokenPrice === 0 || destinationTokenPrice === 0) {
-    return {
-      originTokenRate: "0",
-      destinationTokenRate: "0",
-    }
-  }
-
-  const originToDestination = originTokenPrice / destinationTokenPrice
-  const destinationToOrigin = destinationTokenPrice / originTokenPrice
-
-  // Format the rates with appropriate precision
-  const originTokenRate = formatAmountDisplay(originToDestination, {
-    maxFractionDigits: destinationTokenSymbol === "USDC" ? 2 : 7,
-  })
-  const destinationTokenRate = formatAmountDisplay(destinationToOrigin, {
-    maxFractionDigits: originTokenSymbol === "USDC" ? 2 : 7,
-  })
-
-  return {
-    originTokenRate: `1 ${originTokenSymbol} = ${originTokenRate} ${destinationTokenSymbol}`,
-    destinationTokenRate: `1 ${destinationTokenSymbol} = ${destinationTokenRate} ${originTokenSymbol}`,
-  }
-}

package/src/transactionIntent/quote/quoteHelpers.ts

@@ -1,117 +0,0 @@
-import type { QuoteIntentRequest, RouteProvider } from "@0xtrails/api"
-import type { Connector } from "wagmi"
-import { getIsCustomCalldata } from "../../contractUtils.js"
-import {
-  isSequenceWallet,
-  isSequenceWalletById,
-  isSmartContractWallet,
-} from "../../walletUtils.js"
-import { TradeType } from "../types.js"
-import { logger } from "../../logger.js"
-
-type QuoteIntentRequestOptionsWithFallback = NonNullable<
-  QuoteIntentRequest["options"]
-> & {
-  swapProviderFallback?: boolean
-  bridgeProviderFallback?: boolean
-}
-
-export async function getIntentArgs(
-  mainSignerAddress: string,
-  originChainId: number,
-  originTokenAddress: string,
-  originTokenAmount: string,
-  destinationChainId: number,
-  destinationTokenAddress: string,
-  destinationTokenAmount: string,
-  recipient: string,
-  destinationApproveAddress: string | undefined,
-  destinationCalldata: string | undefined,
-  slippageTolerance: string | null, // 0.03 = 3%, null = AUTO mode (backend returns optimal)
-  tradeType: TradeType,
-  swapProvider?: RouteProvider | null,
-  bridgeProvider?: RouteProvider | null,
-  swapProviderFallback?: boolean,
-  bridgeProviderFallback?: boolean,
-  connector?: Connector | undefined,
-  walletId?: string | undefined,
-  isSmartWallet?: boolean,
-  isSenderContractOnOrigin?: boolean | null,
-): Promise<QuoteIntentRequest> {
-  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-
-  // Check if wallet is Sequence wallet (via connector or walletId)
-  const isSequence = connector
-    ? isSequenceWallet(connector)
-    : isSequenceWalletById(walletId)
-
-  // Use cached value if available, otherwise make RPC call
-  let isSmartContract: boolean
-  if (isSenderContractOnOrigin != null) {
-    isSmartContract = isSenderContractOnOrigin
-  } else {
-    isSmartContract = await isSmartContractWallet(
-      mainSignerAddress,
-      originChainId,
-    )
-  }
-
-  // Set onlyNativeGasFee to true if:
-  // 1. isSmartWallet prop is explicitly set to true, OR
-  // 2. wallet is Sequence or smart contract
-  const onlyNativeGasFee =
-    isSmartWallet === true || isSequence || isSmartContract
-
-  logger.console.log("[trails-sdk] Wallet check for onlyNativeGasFee:", {
-    isSequence,
-    isSmartContract,
-    isSmartWallet,
-    onlyNativeGasFee,
-    walletId,
-    connectorName: connector?.name,
-    usedCachedValue: isSenderContractOnOrigin != null,
-  })
-
-  // Validate originTokenAmount for EXACT_INPUT trade type
-  if (
-    tradeType === TradeType.EXACT_INPUT &&
-    (!originTokenAmount || originTokenAmount === "0")
-  ) {
-    throw new Error(
-      "originTokenAmount cannot be zero for EXACT_INPUT trade type",
-    )
-  }
-
-  const options: QuoteIntentRequestOptionsWithFallback = {
-    // When slippageTolerance is null (AUTO mode), don't send it so backend calculates optimal slippage
-    slippageTolerance:
-      slippageTolerance !== null ? Number(slippageTolerance) : undefined,
-    swapProvider: swapProvider || undefined,
-    bridgeProvider: bridgeProvider || undefined,
-  }
-  if (swapProviderFallback !== undefined) {
-    options.swapProviderFallback = swapProviderFallback
-  }
-  if (bridgeProviderFallback !== undefined) {
-    options.bridgeProviderFallback = bridgeProviderFallback
-  }
-
-  const intentArgs: QuoteIntentRequest = {
-    ownerAddress: mainSignerAddress,
-    originChainId,
-    originTokenAddress,
-    originTokenAmount: BigInt(originTokenAmount),
-    destinationChainId,
-    destinationToAddress: recipient,
-    destinationTokenAddress: destinationTokenAddress,
-    destinationTokenAmount: BigInt(destinationTokenAmount),
-    destinationApproveAddress,
-    destinationCallData: hasCustomCalldata ? destinationCalldata : "0x",
-    destinationCallValue: BigInt("0"),
-    onlyNativeGasFee,
-    options,
-    tradeType,
-  }
-
-  return intentArgs
-}