0xtrails 0.5.0 → 0.6.0

package/src/transactionIntent/handlers/sameChainDifferentToken.ts

@@ -1,323 +0,0 @@
-import type { Account, PublicClient, WalletClient } from "viem"
-import { zeroAddress, decodeFunctionData, erc20Abi, formatUnits } from "viem"
-import type { TransactionState } from "../../transactions.js"
-import type { PrepareSendReturn, SendReturn, TradeType } from "../types.js"
-import { logger } from "../../logger.js"
-import { getIsCustomCalldata } from "../../contractUtils.js"
-import {
-  getRelaySDKQuote,
-  executeSimpleRelayTransaction,
-  getTxHashFromRelayResult,
-  type RelayTradeType,
-} from "../../relaySdk.js"
-import { getNormalizedQuoteObject } from "../quote/normalizeQuote.js"
-import {
-  getFeesFromRelaySdkQuote,
-  getSlippageToleranceFromRelaySdkQuote,
-  getPriceImpactFromRelaySdkQuote,
-  getPriceImpactUsdFromRelaySdkQuote,
-} from "../quote/feeExtractors.js"
-import { checkAccountBalance } from "../utils/balanceChecker.js"
-import { attemptSwitchChain } from "../../chainSwitch.js"
-import { getTransactionStateFromReceipt } from "../execution/transactionState.js"
-import { calcAmountUsdPrice } from "../../prices.js"
-import { trackPaymentCompleted, trackPaymentError } from "../../analytics.js"
-import { TradeType as LocalTradeType } from "../types.js"
-
-/**
- * @description
- * This handler manages same-chain token swaps (e.g., ETH to WETH on the same chain).
- * It leverages the Relay SDK for quote and transaction execution.
- *
- * Key characteristics:
- * - Uses Relay SDK directly for quote fetching and transaction execution
- * - Single transaction leg (swap on origin chain)
- * - No cross-chain bridging required
- * - Supports various token pair combinations on the same chain
- *
- * Transaction Flow:
- * 1. Fetch quote via getRelaySDKQuote (Relay SDK API)
- * 2. Create intent via createIntent (Intent object created)
- * 3. Execute swap via executeSimpleRelayTransaction (User submits swap transaction)
- * 4. Monitor via waitIntentReceipt API for transaction completion
- * 5. Update transaction state and invoke callbacks
- *
- * Relay SDK Integration:
- * - Direct integration with Relay SDK for quote and transaction submission
- * - Transaction hash extracted via getTxHashFromRelayResult
- * - Receipt polling via Trails API for consistent monitoring
- *
- * Error Handling:
- * - Balance validation before transaction submission
- * - Chain switching if user is on wrong network
- * - Relay SDK error handling with proper error propagation
- * - Checkout error callbacks for UI feedback
- *
- * State Management:
- * - transactionStates[0]: Swap transaction
- * - Updates propagated via onTransactionStateChange callback
- * - Analytics tracking for payment completion or errors
- */
-export async function handleSameChainDifferentToken({
-  originTokenAddress,
-  originTokenDecimals,
-  swapAmount,
-  destinationTokenAddress,
-  destinationTokenDecimals,
-  destinationCalldata,
-  recipient,
-  originChainId,
-  walletClient,
-  publicClient,
-  account,
-  tradeType = LocalTradeType.EXACT_OUTPUT,
-  slippageTolerance,
-  onTransactionStateChange,
-  transactionStates,
-  sourceTokenPriceUsd,
-  destinationTokenPriceUsd,
-  originNativeTokenPriceUsd,
-  mode,
-  fundMethod,
-  originTokenSymbol,
-  destinationTokenSymbol,
-}: {
-  originTokenAddress: string
-  originTokenDecimals: number
-  swapAmount: string
-  destinationTokenAddress: string
-  destinationTokenDecimals: number
-  destinationCalldata?: string
-  recipient: string
-  originChainId: number
-  walletClient: WalletClient
-  publicClient: PublicClient
-  account: Account
-  tradeType?: TradeType
-  slippageTolerance?: string
-  onTransactionStateChange: (transactionStates: TransactionState[]) => void
-  transactionStates: TransactionState[]
-  sourceTokenPriceUsd?: number | null
-  destinationTokenPriceUsd?: number | null
-  originNativeTokenPriceUsd?: number | null
-  mode?: "pay" | "fund" | "earn" | "swap" | "receive"
-  fundMethod?: string
-  originTokenSymbol: string
-  destinationTokenSymbol: string
-}): Promise<PrepareSendReturn> {
-  const destinationTxs: { to: string; value: string; data: string }[] = []
-  const hasCustomCalldata = getIsCustomCalldata(destinationCalldata)
-  if (hasCustomCalldata && tradeType === LocalTradeType.EXACT_OUTPUT) {
-    destinationTxs.push({
-      to: recipient,
-      value: destinationTokenAddress === zeroAddress ? swapAmount : "0",
-      data: destinationCalldata as `0x${string}`,
-    })
-  } else if (hasCustomCalldata && tradeType === LocalTradeType.EXACT_INPUT) {
-    destinationTxs.push({
-      to: recipient,
-      value: "0",
-      data: destinationCalldata as `0x${string}`,
-    })
-  }
-
-  const quote = await getRelaySDKQuote({
-    wallet: walletClient,
-    chainId: originChainId,
-    amount: swapAmount,
-    currency: originTokenAddress,
-    toCurrency: destinationTokenAddress,
-    txs: destinationTxs,
-    tradeType: tradeType as unknown as RelayTradeType,
-    slippageTolerance: slippageTolerance,
-    recipient: hasCustomCalldata ? recipient : undefined,
-  })
-
-  logger.console.log("[trails-sdk] relaysdk quote", quote)
-  let depositAmount = "0"
-  let destinationTokenAmount = "0"
-
-  if (tradeType === LocalTradeType.EXACT_INPUT) {
-    depositAmount = swapAmount
-    destinationTokenAmount = quote?.details?.currencyOut?.amount?.toString()
-  } else {
-    try {
-      destinationTokenAmount = swapAmount
-      depositAmount = quote.steps?.[0]?.items?.[0]?.data?.value
-      if (originTokenAddress !== zeroAddress) {
-        const decoded = decodeFunctionData({
-          abi: erc20Abi,
-          data: quote.steps?.[0]?.items?.[0]?.data?.data,
-        })
-        if (decoded.functionName === "approve") {
-          depositAmount = decoded.args[1].toString()
-        }
-        if (decoded.functionName === "transfer") {
-          depositAmount = decoded.args[1].toString()
-        }
-      }
-    } catch (error) {
-      logger.console.error("[trails-sdk] Error decoding function data:", error)
-    }
-  }
-
-  const depositOriginAddress =
-    quote?.steps?.[quote?.steps?.length - 1]?.items?.[
-      quote?.steps?.[quote?.steps?.length - 1]?.items?.length - 1
-    ]?.data?.to
-
-  if (
-    quote?.details?.currencyIn?.amountFormatted &&
-    quote?.details?.currencyIn?.amountUsd
-  ) {
-    const quoteProviderSourceTokenPriceUsd =
-      Number(quote.details.currencyIn.amountUsd) /
-      Number(quote.details.currencyIn.amountFormatted)
-    if (quoteProviderSourceTokenPriceUsd) {
-      sourceTokenPriceUsd = quoteProviderSourceTokenPriceUsd
-    }
-  }
-
-  if (
-    quote?.details?.currencyOut?.amountFormatted &&
-    quote?.details?.currencyOut?.amountUsd
-  ) {
-    const quoteProviderDestinationTokenPriceUsd =
-      Number(quote.details.currencyOut.amountUsd) /
-      Number(quote.details.currencyOut.amountFormatted)
-    if (quoteProviderDestinationTokenPriceUsd) {
-      destinationTokenPriceUsd = quoteProviderDestinationTokenPriceUsd
-    }
-  }
-
-  const normalizedQuote = await getNormalizedQuoteObject({
-    originDepositAddress: depositOriginAddress,
-    destinationDepositAddress: recipient,
-    destinationAddress: recipient,
-    destinationCalldata,
-    originAmount: depositAmount,
-    destinationAmount: destinationTokenAmount,
-    originTokenAddress: originTokenAddress,
-    destinationTokenAddress: destinationTokenAddress,
-    originTokenPriceUsd: sourceTokenPriceUsd?.toString() || null,
-    destinationTokenPriceUsd: destinationTokenPriceUsd?.toString() || null,
-    fees: getFeesFromRelaySdkQuote(quote),
-    slippageTolerance: getSlippageToleranceFromRelaySdkQuote(quote),
-    priceImpact: getPriceImpactFromRelaySdkQuote(quote),
-    priceImpactUsd: getPriceImpactUsdFromRelaySdkQuote(quote),
-    transactionStates,
-    originChainId,
-    destinationChainId: originChainId,
-    originNativeTokenPriceUsd,
-    quoteProvider: "relay",
-    intent: undefined,
-  })
-
-  return {
-    quote: normalizedQuote,
-    send: async ({
-      onOriginSend,
-    }: {
-      onOriginSend?: () => void
-    }): Promise<SendReturn> => {
-      const { hasEnoughBalance, balanceError } = await checkAccountBalance({
-        account,
-        tokenAddress: originTokenAddress,
-        depositAmount,
-        publicClient,
-      })
-
-      if (!hasEnoughBalance) {
-        throw balanceError
-      }
-
-      await attemptSwitchChain({
-        walletClient,
-        desiredChainId: originChainId,
-      })
-
-      const result = await executeSimpleRelayTransaction(quote, walletClient)
-      logger.console.log("[trails-sdk] relaysdk result", result)
-
-      const txHash = getTxHashFromRelayResult(result)
-
-      if (onOriginSend) {
-        onOriginSend()
-      }
-
-      const depositUserTxnReceipt =
-        await publicClient.waitForTransactionReceipt({
-          hash: txHash as `0x${string}`,
-        })
-
-      transactionStates[0] = getTransactionStateFromReceipt(
-        depositUserTxnReceipt,
-        originChainId,
-        transactionStates[0]?.label,
-      )
-
-      try {
-        onTransactionStateChange(transactionStates)
-      } catch (error) {
-        logger.console.error(
-          "[trails-sdk] Error calling onTransactionStateChange:",
-          error,
-        )
-      }
-
-      const depositAmountFormatted = Number(
-        formatUnits(BigInt(depositAmount), originTokenDecimals),
-      )
-
-      const depositAmountUsd = calcAmountUsdPrice({
-        amount: depositAmountFormatted,
-        usdPrice: sourceTokenPriceUsd,
-      })
-
-      const destinationTokenAmountFormatted = Number(
-        formatUnits(BigInt(destinationTokenAmount), destinationTokenDecimals),
-      )
-
-      const destinationTokenAmountUsd = calcAmountUsdPrice({
-        amount: Number(destinationTokenAmountFormatted),
-        usdPrice: destinationTokenPriceUsd,
-      })
-
-      // Track payment completion for same-chain different-token transaction
-      if (depositUserTxnReceipt && depositUserTxnReceipt.status === "success") {
-        trackPaymentCompleted({
-          userAddress: account.address,
-          originTxHash: depositUserTxnReceipt.transactionHash,
-          originChainId,
-          destinationChainId: originChainId, // Same chain
-          mode,
-          fundMethod,
-          originTokenAddress,
-          originTokenSymbol,
-          destinationTokenAddress,
-          destinationTokenSymbol,
-          depositTokenAmountUsd: depositAmountUsd?.toString(),
-          destinationTokenAmountUsd: destinationTokenAmountUsd?.toString(),
-        })
-      } else if (depositUserTxnReceipt) {
-        trackPaymentError({
-          error: "Relay transaction failed",
-          userAddress: account.address,
-          mode,
-          fundMethod,
-          originTokenAddress,
-          originTokenSymbol,
-          destinationTokenAddress,
-          destinationTokenSymbol,
-        })
-      }
-
-      return {
-        depositUserTxnReceipt: depositUserTxnReceipt,
-        originMetaTxnReceipt: null,
-        destinationMetaTxnReceipt: null,
-        totalCompletionSeconds: 0,
-      }
-    },
-  }
-}

package/src/transactionIntent/utils/lifiHelpers.ts

@@ -1,68 +0,0 @@
-import { formatUnits, zeroAddress } from "viem"
-import { calcAmountUsdPrice } from "../../prices.js"
-import { logger } from "../../logger.js"
-
-// ETH fee required by some bridges for low token amounts
-// TODO: update backend API to return the native fee requirement, if any
-export function getNeedsLifiNativeFee({
-  originTokenAddress,
-  destinationTokenAmount,
-  destinationTokenDecimals,
-  sourceTokenDecimals,
-  sourceTokenPriceUsd,
-  destinationTokenPriceUsd,
-  depositAmount,
-}: {
-  originTokenAddress: string
-  destinationTokenAmount: string
-  destinationTokenDecimals: number
-  sourceTokenDecimals: number
-  sourceTokenPriceUsd: number | null
-  destinationTokenPriceUsd: number | null
-  depositAmount: string
-}): boolean {
-  let needsNativeFee = false
-  if (
-    originTokenAddress !== zeroAddress &&
-    sourceTokenPriceUsd &&
-    destinationTokenPriceUsd &&
-    depositAmount &&
-    destinationTokenDecimals !== undefined &&
-    sourceTokenDecimals !== undefined
-  ) {
-    // Convert from wei to token units using formatUnits
-    const destinationAmount = Number(
-      formatUnits(BigInt(destinationTokenAmount), destinationTokenDecimals),
-    )
-    const depositAmountFormatted = Number(
-      formatUnits(BigInt(depositAmount), sourceTokenDecimals),
-    )
-    logger.console.log("[trails-sdk] destinationAmount", destinationAmount)
-    logger.console.log(
-      "[trails-sdk] depositAmountFormatted",
-      depositAmountFormatted,
-    )
-    const destinationAmountUsd = calcAmountUsdPrice({
-      amount: destinationAmount,
-      usdPrice: destinationTokenPriceUsd,
-    })
-    const depositAmountUsd = calcAmountUsdPrice({
-      amount: depositAmountFormatted,
-      usdPrice: sourceTokenPriceUsd,
-    })
-    const diff = depositAmountUsd - destinationAmountUsd
-    logger.console.log(
-      "[trails-sdk] destinationAmountUsd",
-      destinationAmountUsd,
-      "[trails-sdk] depositAmountUsd",
-      depositAmountUsd,
-      "[trails-sdk] diff",
-      diff,
-    )
-    if (diff >= 0 && diff <= 0.02) {
-      needsNativeFee = true
-    }
-  }
-
-  return needsNativeFee
-}

package/src/widget/hooks/useSelectedFeeToken.tsx

@@ -1,288 +0,0 @@
-import React, {
-  createContext,
-  useContext,
-  useState,
-  useCallback,
-  useEffect,
-  useMemo,
-  type ReactNode,
-} from "react"
-import { logger } from "../../logger.js"
-import { ethAddress, zeroAddress } from "viem"
-import { formatUsdAmountDisplay } from "../../tokenBalances.js"
-
-const ZERO_ADDRESS = zeroAddress.toLowerCase()
-const ETH_ADDRESS = ethAddress.toLowerCase()
-
-const normalizeAddress = (address?: string | null): string =>
-  (address ?? "").toLowerCase()
-
-const isNativeTokenAddress = (address?: string | null): boolean => {
-  const normalized = normalizeAddress(address)
-  return normalized === ZERO_ADDRESS || normalized === ETH_ADDRESS
-}
-
-// Define the FeeOption interface with balance check properties
-export interface FeeOption {
-  tokenAddress: string
-  tokenSymbol: string
-  tokenDecimals: number
-  amount: string
-  amountUSD: number
-  notEnoughBalance?: boolean
-  tokenImageUrl?: string
-  chainId?: number
-  amountUsdDisplay?: string // Formatted USD display like "≈ $0.39"
-}
-
-// Token type with balance information
-export interface TokenWithBalance {
-  chainId: number
-  contractAddress?: string
-  balance?: string
-  imageUrl?: string
-}
-
-interface SelectedFeeTokenContextType {
-  selectedFeeToken: FeeOption | null
-  setSelectedFeeToken: (token: FeeOption | null) => void
-  clearSelectedFeeToken: () => void
-  processedFeeOptions: FeeOption[]
-  setRawFeeOptions: (
-    feeOptions: any[] | null | undefined,
-    originChainId: number | undefined,
-    availableTokens: TokenWithBalance[],
-  ) => void
-}
-
-const SelectedFeeTokenContext = createContext<
-  SelectedFeeTokenContextType | undefined
->(undefined)
-
-interface SelectedFeeTokenProviderProps {
-  children: ReactNode
-  initialToken?: FeeOption | null
-}
-
-export const SelectedFeeTokenProvider: React.FC<
-  SelectedFeeTokenProviderProps
-> = ({ children, initialToken = null }) => {
-  const [selectedFeeToken, setSelectedFeeTokenInternalRaw] =
-    useState<FeeOption | null>(initialToken)
-  const [hasUserSelectedFeeOption, setHasUserSelectedFeeOption] =
-    useState(false)
-  const [rawFeeOptions, setRawFeeOptionsInternal] = useState<any[]>([])
-  const [originTokenChainId, setOriginTokenChainId] = useState<
-    number | undefined
-  >(undefined)
-  const [availableTokens, setAvailableTokens] = useState<TokenWithBalance[]>([])
-
-  // Wrapper to log all state changes to selectedFeeToken
-  const setSelectedFeeTokenInternal = useCallback((token: FeeOption | null) => {
-    logger.console.log(
-      "[trails-sdk] [FEE-SELECT] selectedFeeToken state changing:",
-      {
-        to: token,
-        toNull: token === null,
-      },
-    )
-    setSelectedFeeTokenInternalRaw(token)
-  }, [])
-
-  // Wrapper to track when user makes an explicit selection
-  const setSelectedFeeToken = useCallback(
-    (token: FeeOption | null) => {
-      logger.console.log(
-        "[trails-sdk] [FEE-SELECT] setSelectedFeeToken called (user selection):",
-        {
-          token,
-          isNull: token === null,
-          isUndefined: token === undefined,
-        },
-      )
-      setSelectedFeeTokenInternal(token)
-      setHasUserSelectedFeeOption(true)
-    },
-    [setSelectedFeeTokenInternal],
-  )
-
-  const clearSelectedFeeToken = useCallback(() => {
-    logger.console.log("[trails-sdk] [FEE-SELECT] Clearing selected fee token")
-    setSelectedFeeTokenInternal(null)
-    setHasUserSelectedFeeOption(false)
-  }, [setSelectedFeeTokenInternal])
-
-  // Process raw fee options with balance checks
-  const processedFeeOptions = useMemo(() => {
-    if (!rawFeeOptions || rawFeeOptions.length === 0) {
-      return []
-    }
-
-    logger.console.log("[trails-sdk] [FEE-SELECT] Processing fee options:", {
-      rawFeeOptions,
-      originTokenChainId,
-      availableTokensCount: availableTokens.length,
-    })
-
-    // Add balance check and additional properties to each fee option
-    const feeOptionsWithBalanceCheck = rawFeeOptions.map((option: any) => {
-      // For native token (zero/ETH address), check if user has enough native balance
-      if (isNativeTokenAddress(option.tokenAddress)) {
-        // Find the native token balance for the origin chain
-        const nativeTokenInfo = availableTokens.find(
-          (token) =>
-            token.chainId === originTokenChainId &&
-            (isNativeTokenAddress(token.contractAddress) ||
-              !token.contractAddress),
-        )
-
-        const nativeBalance = nativeTokenInfo?.balance || "0"
-        const requiredAmount = option.amount
-        const notEnoughBalance = BigInt(nativeBalance) < BigInt(requiredAmount)
-
-        return {
-          ...option,
-          notEnoughBalance,
-          tokenImageUrl: nativeTokenInfo?.imageUrl,
-          chainId: originTokenChainId, // Native token is on the same chain as origin
-          amountUsdDisplay: formatUsdAmountDisplay(option.amountUsd),
-          amountUSD: option.amountUsd, // Normalize to uppercase for consistency
-        }
-      }
-
-      // For ERC-20 tokens, check user's token balances
-      const userTokenBalance = availableTokens.find(
-        (token) =>
-          token.contractAddress?.toLowerCase() ===
-            option.tokenAddress.toLowerCase() &&
-          token.chainId === originTokenChainId,
-      )
-
-      if (userTokenBalance) {
-        const userBalance = userTokenBalance.balance || "0"
-        const requiredAmount = option.amount
-        const notEnoughBalance = BigInt(userBalance) < BigInt(requiredAmount)
-
-        return {
-          ...option,
-          notEnoughBalance,
-          tokenImageUrl: userTokenBalance.imageUrl,
-          chainId: userTokenBalance.chainId, // Use the actual token's chain ID
-          amountUsdDisplay: formatUsdAmountDisplay(option.amountUsd),
-          amountUSD: option.amountUsd, // Normalize to uppercase for consistency
-        }
-      }
-
-      // If token balance not found, assume insufficient balance
-      return {
-        ...option,
-        notEnoughBalance: true,
-        tokenImageUrl: undefined,
-        chainId: originTokenChainId, // Fallback to origin chain
-        amountUsdDisplay: formatUsdAmountDisplay(option.amountUsd),
-        amountUSD: option.amountUsd, // Normalize to uppercase for consistency
-      }
-    })
-
-    // Sort fee options: available options first, then disabled options at the bottom
-    const sortedFeeOptions = feeOptionsWithBalanceCheck.sort(
-      (a: FeeOption, b: FeeOption) => {
-        // If both have the same balance status, maintain original order
-        if (a.notEnoughBalance === b.notEnoughBalance) {
-          return 0
-        }
-        // Put available options (notEnoughBalance: false) before disabled options (notEnoughBalance: true)
-        return a.notEnoughBalance ? 1 : -1
-      },
-    )
-
-    logger.console.log(
-      "[trails-sdk] [FEE-SELECT] Processed and sorted fee options:",
-      sortedFeeOptions,
-    )
-
-    return sortedFeeOptions
-  }, [rawFeeOptions, originTokenChainId, availableTokens])
-
-  // Auto-select first ERC20 fee option with sufficient balance
-  // Only auto-select if user hasn't made an explicit selection yet
-  useEffect(() => {
-    if (
-      processedFeeOptions.length > 0 &&
-      !hasUserSelectedFeeOption &&
-      !selectedFeeToken
-    ) {
-      // Find first token option with sufficient balance
-      const firstValidOption = processedFeeOptions.find(
-        (option: FeeOption) => !option.notEnoughBalance,
-      )
-
-      if (firstValidOption) {
-        logger.console.log(
-          "[trails-sdk] [FEE-SELECT] Auto-selecting first valid fee option:",
-          firstValidOption,
-        )
-        // Use internal setter to avoid marking as user selection
-        setSelectedFeeTokenInternal({
-          tokenAddress: firstValidOption.tokenAddress,
-          tokenSymbol: firstValidOption.tokenSymbol,
-          tokenDecimals: firstValidOption.tokenDecimals,
-          amount: firstValidOption.amount,
-          amountUSD: firstValidOption.amountUSD,
-        })
-      }
-    }
-  }, [
-    processedFeeOptions,
-    selectedFeeToken,
-    hasUserSelectedFeeOption,
-    setSelectedFeeTokenInternal,
-  ])
-
-  // Function to set raw fee options and process them
-  const setRawFeeOptions = useCallback(
-    (
-      feeOptions: any[] | null | undefined,
-      originChainId: number | undefined,
-      tokens: TokenWithBalance[],
-    ) => {
-      const apiFeeOptions = feeOptions ?? []
-      setRawFeeOptionsInternal(apiFeeOptions)
-      setOriginTokenChainId(originChainId)
-      setAvailableTokens(tokens)
-
-      logger.console.log("[trails-sdk] [FEE-SELECT] Raw fee options set:", {
-        feeOptionsCount: apiFeeOptions.length,
-        originChainId: originChainId,
-        tokensCount: tokens.length,
-      })
-    },
-    [],
-  )
-
-  const value: SelectedFeeTokenContextType = {
-    selectedFeeToken,
-    setSelectedFeeToken,
-    clearSelectedFeeToken,
-    processedFeeOptions,
-    setRawFeeOptions,
-  }
-
-  return (
-    <SelectedFeeTokenContext.Provider value={value}>
-      {children}
-    </SelectedFeeTokenContext.Provider>
-  )
-}
-
-export const useSelectedFeeToken = (): SelectedFeeTokenContextType => {
-  const context = useContext(SelectedFeeTokenContext)
-
-  if (context === undefined) {
-    throw new Error(
-      "useSelectedFeeToken must be used within a SelectedFeeTokenProvider",
-    )
-  }
-
-  return context
-}