0xtrails 0.2.5 → 0.3.0

package/src/transactionIntent/handlers/index.ts

@@ -0,0 +1,3 @@
+export * from "./sameChainSameToken.js"
+export * from "./sameChainDifferentToken.js"
+export * from "./crossChain.js"

package/src/transactionIntent/handlers/sameChainDifferentToken.ts

@@ -0,0 +1,323 @@
+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,
+      }
+    },
+  }
+}