0xtrails 0.13.1 → 0.14.0

package/src/prepareSend.ts

@@ -1,552 +0,0 @@
-import { abortControllerRegistry } from "./abortController.js"
-import { trackPaymentError, trackPaymentStarted } from "./analytics.js"
-import { getSlippageToleranceValue } from "./widget/components/SlippageToleranceSettings.js"
-import { addressEqual, isNativeToken, isZeroAccount } from "./utils/address.js"
-import { getERC20TransferData } from "./utils.js"
-import { getTokenPrice } from "./query/price.queries.js"
-import {
-  calldataHasPlaceholder,
-  replacePlaceholderInCalldata,
-  TRAILS_ROUTER_PLACEHOLDER_AMOUNT,
-} from "./placeholder.js"
-import { IntentProtocolVersion, RouteProvider } from "@0xtrails/api"
-import { wrapCalldataWithTrailsRouterIfNeeded } from "./abis/trailsRouter.js"
-import { logger } from "./logger.js"
-import { getIsCustomCalldata } from "./contractUtils.js"
-import {
-  getChainInfo,
-  getChainRpcClient,
-  getShouldFetchVersions,
-} from "./chains.js"
-import { TRAILS_CONTRACTS } from "./constants.js"
-import {
-  TradeType,
-  type PrepareSendOptions,
-  type PrepareSendReturn,
-  handleIntent,
-  isSameChain,
-  isSameToken,
-} from "./transactionIntent/index.js"
-import { Address, Bytes, Hex } from "ox"
-import { getWethAddress } from "./tokens.js"
-import {
-  createHydratePayload,
-  encodeHydrateExecuteCalldata,
-} from "./abis/trailsHydrate.js"
-import { getAmountOffset } from "./placeholder.js"
-
-export type {
-  PrepareSendOptions,
-  PrepareSendFees,
-  PrepareSendQuote,
-  PrepareSendReturn,
-  SendReturn,
-} from "./transactionIntent/index.js"
-
-// Re-export validators for backward compatibility
-export { isSameChain, isSameToken } from "./transactionIntent/index.js"
-
-// Re-export handleIntent for direct use
-export { handleIntent } from "./transactionIntent/index.js"
-
-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,
-    originChainId,
-    originTokenBalance,
-    destinationChainId,
-    recipient,
-    destinationTokenAddress,
-    swapAmount,
-    tradeType = TradeType.EXACT_OUTPUT,
-    originTokenSymbol,
-    destinationTokenSymbol,
-    client: walletClient,
-    trailsClient,
-    destinationCalldata,
-    onTransactionStateChange,
-    sourceTokenDecimals,
-    destinationTokenDecimals,
-    paymasterUrl,
-    slippageTolerance: slippageToleranceFromOptions,
-    originNativeTokenPriceUsd,
-    swapProvider,
-    bridgeProvider,
-    swapProviderFallback,
-    bridgeProviderFallback,
-    fundMethod: fundMethodFromOptions,
-    mode,
-    checkoutOnHandlers,
-    selectedFeeOption,
-    walletId,
-    abortSignal,
-    commitIntentFn,
-    executeIntentFn,
-    sequenceProjectAccessKey,
-    sequenceIndexerUrl,
-    isSmartWallet,
-    isSenderContractOnOrigin,
-    trailsApiKey,
-    trailsApiUrl,
-    sequenceMetadataUrl,
-    onramp,
-    refundAddress,
-  } = options
-  let { sourceTokenPriceUsd, destinationTokenPriceUsd } = options
-  const fundMethod = fundMethodFromOptions ?? "wallet"
-
-  if (!originChainId) {
-    throw new Error("Origin chain ID is required")
-  }
-
-  if (!destinationChainId) {
-    throw new Error("Destination chain ID is required")
-  }
-
-  // Sanity check: verify originPublicClient chain ID matches originChainId
-  if (options.originPublicClient) {
-    const clientChainId = options.originPublicClient?.chain?.id
-    if (clientChainId !== originChainId) {
-      throw new Error(
-        `Origin public client chain ID mismatch: expected ${originChainId}, got ${clientChainId}`,
-      )
-    }
-  }
-
-  // Sanity check: verify destinationPublicClient chain ID matches destinationChainId
-  if (options.destinationPublicClient) {
-    const clientChainId = options.destinationPublicClient?.chain?.id
-    if (clientChainId !== destinationChainId) {
-      throw new Error(
-        `Destination public client chain ID mismatch: expected ${destinationChainId}, got ${clientChainId}`,
-      )
-    }
-  }
-
-  // Use slippage tolerance priority:
-  // 1. If explicitly passed as prop → use that value
-  // 2. If not passed → check localStorage via getSlippageToleranceValue
-  // 3. If localStorage has no value → fallback to "0.01"
-  const slippageTolerance =
-    slippageToleranceFromOptions !== undefined
-      ? slippageToleranceFromOptions
-      : getSlippageToleranceValue("0.01")
-
-  if (!sourceTokenDecimals) {
-    throw new Error("Source token decimals not provided")
-  }
-  if (!destinationTokenDecimals) {
-    throw new Error("Destination token decimals not provided")
-  }
-
-  let hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-
-  // Validate recipient is not zero address
-  if (isZeroAccount(recipient)) {
-    throw new Error("Recipient address cannot be zero address")
-  }
-
-  let effectiveDestinationAddress = recipient
-  let effectiveDestinationApprovalAddress: Address.Address | undefined
-  let effectiveDestinationCalldata = destinationCalldata
-  let effectiveSwapProvider = swapProvider
-
-  // Check if this is a same-chain same-token transfer (before modifying effectiveDestinationAddress)
-  const isToSameChain = isSameChain(originChainId, destinationChainId)
-  const isToSameToken = isSameToken(originTokenAddress, destinationTokenAddress)
-  const isSameChainSameToken = isToSameChain && isToSameToken
-  const chainWethAddress = getWethAddress(originChainId)
-  const isSameChainNativeWrappedPair =
-    isToSameChain &&
-    !!chainWethAddress &&
-    ((isNativeToken(originTokenAddress) &&
-      addressEqual(destinationTokenAddress, chainWethAddress)) ||
-      (addressEqual(originTokenAddress, chainWethAddress) &&
-        isNativeToken(destinationTokenAddress)))
-  const isSameChainNativeWrappedToSelf =
-    isSameChainNativeWrappedPair && addressEqual(recipient, account.address)
-
-  if (isSameChainNativeWrappedToSelf) {
-    effectiveDestinationAddress = account.address
-    effectiveSwapProvider = RouteProvider.WETH
-    // Only force empty calldata when caller did not provide custom calldata.
-    if (!hasCustomCalldata) {
-      effectiveDestinationCalldata = undefined
-      hasCustomCalldata = false
-    }
-  }
-
-  // For same-chain same-token with custom calldata:
-  // Replace any placeholder in the calldata with the actual swapAmount
-  const originalHadPlaceholder = calldataHasPlaceholder(destinationCalldata)
-
-  if (isSameChainSameToken && hasCustomCalldata && originalHadPlaceholder) {
-    effectiveDestinationCalldata = replacePlaceholderInCalldata(
-      effectiveDestinationCalldata || "",
-      swapAmount,
-    )
-
-    logger.console.log(
-      "[trails-sdk] Same-chain same-token: Replaced placeholder with actual amount in calldata",
-      { swapAmount },
-    )
-  }
-
-  // Set custom calldata for ERC20 transfers to ensure proper metatxn tracking on destination
-  // This is needed for CCTP and other ERC20 transfers where the destination needs to track the intent
-  if (
-    !hasCustomCalldata &&
-    tradeType === TradeType.EXACT_INPUT &&
-    !isNativeToken(destinationTokenAddress) &&
-    !isSameChainSameToken &&
-    !isSameChainNativeWrappedToSelf // Keep backend-owned passthrough handling for native<->WETH to-self
-  ) {
-    effectiveDestinationCalldata = getERC20TransferData(
-      recipient,
-      BigInt(TRAILS_ROUTER_PLACEHOLDER_AMOUNT),
-    )
-    effectiveDestinationAddress = destinationTokenAddress
-    hasCustomCalldata = true
-    logger.console.log(
-      "[trails-sdk] Setting ERC20 transfer calldata for destination metatxn tracking",
-    )
-  }
-
-  let intentProtocolVersion = IntentProtocolVersion.v1 // Default to v1
-
-  // Only fetch supported versions when using dev trails API environments for now
-  const shouldFetchVersions = getShouldFetchVersions()
-
-  if (shouldFetchVersions) {
-    try {
-      const supportedIntentProtocolVersions =
-        await trailsClient.getSupportedIntentProtocolVersions()
-      intentProtocolVersion =
-        supportedIntentProtocolVersions.versions[0] ?? IntentProtocolVersion.v1
-      logger.console.log(
-        "[trails-sdk] [intent-protocol] Fetched supported protocol versions from API",
-        {
-          supportedVersions: supportedIntentProtocolVersions.versions,
-          selectedVersion: intentProtocolVersion,
-        },
-      )
-    } catch (_error) {
-      // Ignore error. Assume v1
-      logger.console.log(
-        "[trails-sdk] [intent-protocol] Failed to fetch protocol versions, defaulting to v1",
-      )
-    }
-  } else {
-    logger.console.log(
-      "[trails-sdk] [intent-protocol] Skipping version fetch, using v1 default",
-      { trailsApiUrl },
-    )
-  }
-  logger.console.log(
-    "[trails-sdk] [intent-protocol] === Protocol Version Selected ===",
-    {
-      intentProtocolVersion,
-      isV1: intentProtocolVersion === IntentProtocolVersion.v1,
-      isV1_5: intentProtocolVersion === IntentProtocolVersion.v1_5,
-    },
-  )
-
-  if (hasCustomCalldata && tradeType === TradeType.EXACT_INPUT) {
-    logger.console.log(
-      "[trails-sdk] [intent-protocol] Calldata wrapping required for custom calldata",
-      {
-        intentProtocolVersion,
-        wrapperType:
-          intentProtocolVersion === "v1"
-            ? "TrailsRouter"
-            : "TrailsUtils (Hydrate)",
-      },
-    )
-
-    if (intentProtocolVersion === "v1") {
-      // @deprecated - v1 only
-
-      logger.console.log(
-        "[trails-sdk] [intent-protocol] v1: Using TrailsRouter wrapper (deprecated)",
-        {
-          destinationTokenAddress,
-          effectiveDestinationAddress,
-          effectiveDestinationCalldata,
-          swapAmount,
-          originChainId,
-          destinationChainId,
-          originTokenAddress,
-        },
-      )
-
-      const wrapResult = wrapCalldataWithTrailsRouterIfNeeded({
-        token: destinationTokenAddress,
-        target: effectiveDestinationAddress,
-        calldata: effectiveDestinationCalldata as `0x${string}`,
-        amount: swapAmount,
-        originChainId,
-        destinationChainId,
-        originTokenAddress,
-        destinationTokenAddress,
-        trailsRouterAddress: TRAILS_CONTRACTS.trailsRouterAddress,
-      })
-
-      if (wrapResult) {
-        effectiveDestinationAddress = wrapResult.trailsRouterAddress
-        effectiveDestinationCalldata = wrapResult.encodedCalldata
-      }
-    } else {
-      // v1_5
-      logger.console.log(
-        "[trails-sdk] [intent-protocol] v1.5: Using TrailsUtils + Hydrate encoding",
-      )
-      logger.console.log(
-        "[trails-sdk] [intent-protocol] v1.5: Wrapping calldata",
-        {
-          destinationTokenAddress,
-          effectiveDestinationAddress,
-          effectiveDestinationCalldata,
-          swapAmount,
-          originChainId,
-          destinationChainId,
-          originTokenAddress,
-        },
-      )
-      // Use hydrate if needed
-      if (Hex.validate(effectiveDestinationCalldata)) {
-        Hex.assert(effectiveDestinationCalldata)
-        Address.assert(effectiveDestinationAddress)
-        const amountOffset = isNativeToken(destinationTokenAddress)
-          ? 0
-          : getAmountOffset(
-              effectiveDestinationCalldata,
-              TRAILS_ROUTER_PLACEHOLDER_AMOUNT,
-            )
-
-        if (amountOffset > -1) {
-          logger.console.log("[trails-sdk] Using hydrate payload", {
-            destinationTokenAddress,
-            effectiveDestinationAddress,
-            effectiveDestinationCalldata,
-            swapAmount,
-            originChainId,
-            destinationChainId,
-            originTokenAddress,
-            amountOffset,
-          })
-
-          Address.assert(destinationTokenAddress)
-          let hydratePayload = Bytes.from([])
-          if (!isNativeToken(destinationTokenAddress)) {
-            hydratePayload = createHydratePayload(0, [
-              {
-                type: "erc20Balance",
-                token: destinationTokenAddress,
-                calldataOffset: amountOffset,
-                address: "self",
-              },
-            ])
-            // FIXME TODO Zero the calldata at amount offset to lower calldata cost
-          }
-          // FIXME Remove this when no hydrate payload is needed (i.e. native). Retained as per legacy.
-          // Always encode the hydrate execute calldata, even if there's no hydrate payload (native token)
-          const hydrateData = encodeHydrateExecuteCalldata({
-            target: effectiveDestinationAddress,
-            calldata: effectiveDestinationCalldata,
-            hydratePayload,
-          })
-          effectiveDestinationCalldata = hydrateData
-          logger.console.log("[trails-sdk] Hydrate data:", hydrateData)
-          // Approve the unwrapped destination, call TrailsUtils
-          effectiveDestinationApprovalAddress = effectiveDestinationAddress
-          logger.console.log(
-            "[trails-sdk] Effective destination approval address updated to:",
-            effectiveDestinationApprovalAddress,
-          )
-          effectiveDestinationAddress = TRAILS_CONTRACTS.trailsUtilsAddress
-        }
-      }
-    }
-  }
-
-  // Fallback price fetching if prices are 0
-  if (!sourceTokenPriceUsd) {
-    try {
-      const price = await getTokenPrice(trailsClient, {
-        tokenSymbol: originTokenAddress,
-        tokenAddress: originTokenAddress,
-        chainId: originChainId,
-      })
-      sourceTokenPriceUsd = price?.priceUsd ?? 0
-    } catch (error) {
-      logger.console.error(
-        "[trails-sdk] Error getting source token price:",
-        error,
-      )
-    }
-  }
-
-  if (!destinationTokenPriceUsd) {
-    try {
-      const price = await getTokenPrice(trailsClient, {
-        tokenSymbol: destinationTokenAddress,
-        tokenAddress: destinationTokenAddress,
-        chainId: destinationChainId,
-      })
-      destinationTokenPriceUsd = price?.priceUsd ?? 0
-    } catch (error) {
-      logger.console.error(
-        "[trails-sdk] Error getting destination token price:",
-        error,
-      )
-    }
-  }
-
-  // Track payment start
-  trackPaymentStarted({
-    userAddress: account.address,
-    originChainId,
-    destinationChainId,
-    originTokenAddress,
-    originTokenAmount:
-      tradeType === TradeType.EXACT_INPUT ? swapAmount : undefined,
-    originTokenDecimals: sourceTokenDecimals,
-    destinationTokenAddress,
-    destinationTokenSymbol: destinationTokenSymbol || "",
-    destinationTokenAmount:
-      tradeType === TradeType.EXACT_OUTPUT ? swapAmount : undefined,
-    destinationTokenDecimals: destinationTokenDecimals,
-    mode,
-    fundMethod,
-    sourceTokenPriceUsd: sourceTokenPriceUsd?.toString(),
-    destinationTokenPriceUsd: destinationTokenPriceUsd?.toString(),
-    tradeType: tradeType.toString(),
-    swapProvider: effectiveSwapProvider || undefined,
-    bridgeProvider: bridgeProvider || undefined,
-    onramp,
-    walletId,
-    destinationCalldata,
-  })
-
-  if (!walletClient) {
-    trackPaymentError({
-      error: "Wallet client not provided",
-      userAddress: account.address,
-      mode,
-      fundMethod,
-      originChainId,
-      destinationChainId,
-      originTokenAddress,
-      destinationTokenAddress,
-      destinationTokenSymbol,
-    })
-    throw new Error("Wallet client not provided")
-  }
-
-  const chain = getChainInfo(originChainId)
-  if (!chain) {
-    trackPaymentError({
-      error: `Chain ${originChainId} not found`,
-      userAddress: account.address,
-      mode,
-      fundMethod,
-      originChainId,
-      destinationChainId,
-      originTokenAddress,
-      destinationTokenAddress,
-      destinationTokenSymbol,
-    })
-    throw new Error(`Chain ${originChainId} not found`)
-  }
-
-  const publicClient =
-    options.originPublicClient ?? getChainRpcClient(originChainId)
-
-  // Call onCheckoutStart callback if provided
-  if (checkoutOnHandlers?.triggerCheckoutStart) {
-    checkoutOnHandlers.triggerCheckoutStart()
-  }
-
-  // Single unified handler for ALL cases - backend decides passthrough via intent.passthrough flag
-  return handleIntent({
-    queryClient: options.queryClient,
-    mainSignerAddress: account.address,
-    originChainId,
-    originTokenAddress,
-    originTokenBalance,
-    originTokenDecimals: sourceTokenDecimals,
-    originTokenSymbol,
-    destinationChainId,
-    destinationTokenAddress,
-    destinationTokenSymbol,
-    destinationTokenDecimals,
-    swapAmount,
-    recipient: effectiveDestinationAddress,
-    destinationApproveAddress: effectiveDestinationApprovalAddress,
-    destinationCalldata: effectiveDestinationCalldata,
-    walletClient,
-    publicClient,
-    account,
-    chain,
-    onTransactionStateChange,
-    transactionStates: [], // handleIntent computes states from API or fallback
-    trailsClient,
-    sourceTokenPriceUsd,
-    destinationTokenPriceUsd,
-    originNativeTokenPriceUsd,
-    slippageTolerance,
-    tradeType,
-    swapProvider: effectiveSwapProvider,
-    bridgeProvider,
-    swapProviderFallback,
-    bridgeProviderFallback,
-    fundMethod,
-    mode,
-    checkoutOnHandlers,
-    paymasterUrl,
-    selectedFeeOption,
-    walletId,
-    abortSignal,
-    commitIntentFn,
-    executeIntentFn,
-    sequenceProjectAccessKey,
-    sequenceIndexerUrl,
-    isSmartWallet,
-    isSenderContractOnOrigin,
-    trailsApiKey,
-    trailsApiUrl,
-    sequenceMetadataUrl,
-    refundAddress,
-  })
-}
-
-// Re-export useQuote types and hook from the new location
-export type {
-  UseQuoteProps,
-  Quote,
-  UseQuoteReturn,
-  SwapReturn,
-  RouteProviderInfo,
-} from "./widget/hooks/useQuote.js"
-export { useQuote } from "./widget/hooks/useQuote.js"
-
-// Re-export quote and fee utilities from transactionIntent for backward compatibility
-export {
-  getFeesFromIntent,
-  getSlippageToleranceFromIntent,
-  getPriceImpactFromIntent,
-  getPriceImpactUsdFromIntent,
-  getZeroFees,
-  getCompletionEstimateSeconds,
-  getNormalizedQuoteObject,
-  TradeType,
-} from "./transactionIntent/index.js"