0xtrails 0.5.0 → 0.6.0

package/src/widget/hooks/useIntentTransactionHistory.ts

@@ -1,14 +1,708 @@
 import { useState, useEffect, useCallback } from "react"
 import {
-  getIntentTransactionHistory,
   getAccountTransactionHistory,
   type IntentTransaction,
-  type IntentTransactionHistoryResponse,
 } from "../../transactions.js"
 import { getTokenInfo, getSupportedTokens } from "../../tokens.js"
 import { getExplorerUrl } from "../../explorer.js"
 import { logger } from "../../logger.js"
 import { useTrails } from "../providers/TrailsProvider.js"
+import { commonTokenImages } from "../../tokens.js"
+import { getTrailsClient } from "../../trailsClient.js"
+import { SortOrder, type IntentSummary } from "@0xsequence/trails-api"
+import {
+  decodeTrailsTokenSweeperEvents,
+  decodeGuestModuleEvents,
+} from "../../decoders.js"
+import { getPublicRpcClient } from "../../chains.js"
+import { getChainInfo } from "../../chains.js"
+import { isNativeToken } from "../../utils.js"
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Maps API status to UI status format
+ */
+function mapApiStatusToUiStatus(apiStatus: string): string {
+  const status = apiStatus?.toUpperCase() || "UNKNOWN"
+  switch (status) {
+    case "SUCCEEDED":
+      return "completed"
+    case "EXECUTING":
+      return "processing"
+    case "PENDING":
+      return "pending"
+    case "FAILED":
+      return "failed"
+    case "CREATED":
+      return "created"
+    default:
+      return apiStatus?.toLowerCase() || "unknown"
+  }
+}
+
+/**
+ * Maps IntentSummary from API to IntentTransaction
+ */
+function mapIntentSummaryToTransaction(
+  intent: IntentSummary,
+): IntentTransaction {
+  return {
+    originIntentAddress: intent.originIntentAddress,
+    destinationIntentAddress: intent.destinationIntentAddress,
+    mainSigner: intent.ownerAddress,
+    metaTxnId: intent.intentId,
+    txnHash:
+      intent.originTransactionHash ||
+      intent.destinationTransactionHash ||
+      undefined,
+    executionStatus: mapApiStatusToUiStatus(intent.status),
+    originChainId: intent.originChainId,
+    destinationChainId: intent.destinationChainId,
+    originTokenAddress: intent.originTokenAddress,
+    originTokenAmount: intent.originTokenAmount.toString(),
+    destinationTokenAddress: intent.destinationTokenAddress,
+    destinationTokenAmount: intent.destinationTokenAmount.toString(),
+    destinationToAddress: intent.ownerAddress,
+    createdAt: intent.createdAt,
+    originTransactionHash: intent.originTransactionHash,
+    destinationTransactionHash: intent.destinationTransactionHash,
+    originToken: intent.originTokenMetadata
+      ? ({
+          symbol: intent.originTokenMetadata.symbol || "",
+          name: intent.originTokenMetadata.name || "",
+          decimals: intent.originTokenMetadata.decimals ?? 18,
+          imageUrl: intent.originTokenMetadata.logoUri ?? "",
+          chainId: intent.originTokenMetadata.chainId,
+        } as {
+          symbol: string
+          name: string
+          decimals: number
+          imageUrl: string
+          chainId: number
+        })
+      : undefined,
+    destinationToken: intent.destinationTokenMetadata
+      ? ({
+          symbol: intent.destinationTokenMetadata.symbol || "",
+          name: intent.destinationTokenMetadata.name || "",
+          decimals: intent.destinationTokenMetadata.decimals ?? 18,
+          imageUrl: intent.destinationTokenMetadata.logoUri ?? "",
+          chainId: intent.destinationTokenMetadata.chainId,
+        } as {
+          symbol: string
+          name: string
+          decimals: number
+          imageUrl: string
+          chainId: number
+        })
+      : undefined,
+  }
+}
+
+/**
+ * Gets token info for a given token address and chain ID
+ */
+async function getTokenInfoForTransaction(
+  tokenAddress: string,
+  chainId: number,
+  supportedTokens: Awaited<ReturnType<typeof getSupportedTokens>>,
+): Promise<
+  | {
+      symbol: string
+      name: string
+      decimals: number
+      imageUrl: string
+      chainId: number
+    }
+  | undefined
+> {
+  if (isNativeToken(tokenAddress)) {
+    const nativeToken = supportedTokens.find(
+      (token) =>
+        token.contractAddress.toLowerCase() === tokenAddress.toLowerCase() &&
+        token.chainId === chainId,
+    )
+
+    if (nativeToken) {
+      return {
+        symbol: nativeToken.symbol,
+        name: nativeToken.name,
+        decimals: nativeToken.decimals,
+        imageUrl: nativeToken.imageUrl,
+        chainId: nativeToken.chainId,
+      }
+    }
+
+    // Fallback for native token
+    return {
+      symbol: "ETH",
+      name: "Native Token",
+      decimals: 18,
+      imageUrl: commonTokenImages.ETH as string,
+      chainId,
+    }
+  }
+
+  // For ERC20 tokens, check supported tokens first
+  const supportedToken = supportedTokens.find(
+    (token) =>
+      token.contractAddress.toLowerCase() === tokenAddress.toLowerCase() &&
+      token.chainId === chainId,
+  )
+
+  if (supportedToken) {
+    return {
+      symbol: supportedToken.symbol,
+      name: supportedToken.name,
+      decimals: supportedToken.decimals,
+      imageUrl: supportedToken.imageUrl,
+      chainId: supportedToken.chainId,
+    }
+  }
+
+  // Fallback to on-chain lookup
+  try {
+    const tokenInfo = await getTokenInfo(chainId, tokenAddress)
+    if (tokenInfo) {
+      return {
+        symbol: tokenInfo.symbol,
+        name: tokenInfo.name,
+        decimals: tokenInfo.decimals,
+        imageUrl: tokenInfo.imageUrl,
+        chainId: tokenInfo.chainId,
+      }
+    }
+  } catch (error) {
+    logger.console.warn(
+      "[trails-sdk] Failed to get token info for:",
+      tokenAddress,
+      "on chain",
+      chainId,
+      error,
+    )
+  }
+
+  return undefined
+}
+
+/**
+ * Gets origin intent transaction hashes from account history
+ */
+async function getOriginIntentTransactionHashes(
+  transaction: IntentTransaction,
+  trailsConfig: ReturnType<typeof useTrails>,
+): Promise<{
+  originIntentTxHash?: string
+  originIntentTxExplorerUrl?: string
+  originIntentDepositTxHash?: string
+  originIntentDepositTxExplorerUrl?: string
+}> {
+  if (
+    !transaction.originIntentAddress ||
+    !transaction.originChainId ||
+    transaction.originTransactionHash
+  ) {
+    return {}
+  }
+
+  try {
+    const originHistory = await getAccountTransactionHistory({
+      chainId: transaction.originChainId,
+      accountAddress: transaction.originIntentAddress,
+      pageSize: 10,
+      page: 0,
+      includeMetadata: true,
+      apiKey: trailsConfig.trailsApiKey || "",
+      indexerUrl: trailsConfig.sequenceIndexerUrl!,
+    })
+
+    if (
+      !originHistory?.transactions ||
+      originHistory.transactions.length === 0
+    ) {
+      return {}
+    }
+
+    const intentAddress = transaction.originIntentAddress.toLowerCase()
+    const result: {
+      originIntentTxHash?: string
+      originIntentTxExplorerUrl?: string
+      originIntentDepositTxHash?: string
+      originIntentDepositTxExplorerUrl?: string
+    } = {}
+
+    // Find first deposit tx (transfer TO intent address)
+    const depositTx = originHistory.transactions.find((tx) =>
+      tx.transfers?.some(
+        (transfer) => transfer.to.toLowerCase() === intentAddress,
+      ),
+    )
+    if (depositTx) {
+      result.originIntentDepositTxHash = depositTx.txnHash
+      result.originIntentDepositTxExplorerUrl = getExplorerUrl({
+        txHash: depositTx.txnHash,
+        chainId: transaction.originChainId,
+      })
+    }
+
+    // Find first action tx (transfer FROM intent address)
+    const actionTx = originHistory.transactions.find((tx) =>
+      tx.transfers?.some(
+        (transfer) => transfer.from.toLowerCase() === intentAddress,
+      ),
+    )
+    if (actionTx) {
+      result.originIntentTxHash = actionTx.txnHash
+      result.originIntentTxExplorerUrl = getExplorerUrl({
+        txHash: actionTx.txnHash,
+        chainId: transaction.originChainId,
+      })
+    }
+
+    return result
+  } catch (error) {
+    logger.console.warn(
+      "[trails-sdk] Failed to get origin intent transaction hashes for:",
+      transaction.originIntentAddress,
+      "on chain",
+      transaction.originChainId,
+      error,
+    )
+    return {}
+  }
+}
+
+/**
+ * Gets destination intent transaction hashes from account history
+ */
+async function getDestinationIntentTransactionHashes(
+  transaction: IntentTransaction,
+  isSameIntentAddress: boolean,
+  trailsConfig: ReturnType<typeof useTrails>,
+): Promise<{
+  destinationIntentTxHash?: string
+  destinationIntentTxExplorerUrl?: string
+  destinationIntentDepositTxHash?: string
+  destinationIntentDepositTxExplorerUrl?: string
+}> {
+  if (
+    transaction.destinationTransactionHash ||
+    isSameIntentAddress ||
+    !transaction.destinationIntentAddress ||
+    !transaction.destinationChainId
+  ) {
+    return {}
+  }
+
+  try {
+    const destinationHistory = await getAccountTransactionHistory({
+      chainId: transaction.destinationChainId,
+      accountAddress: transaction.destinationIntentAddress,
+      pageSize: 10,
+      page: 0,
+      includeMetadata: true,
+      apiKey: trailsConfig.trailsApiKey || "",
+      indexerUrl: trailsConfig.sequenceIndexerUrl!,
+    })
+
+    if (
+      !destinationHistory?.transactions ||
+      destinationHistory.transactions.length === 0
+    ) {
+      return {}
+    }
+
+    const intentAddress = transaction.destinationIntentAddress.toLowerCase()
+    const result: {
+      destinationIntentTxHash?: string
+      destinationIntentTxExplorerUrl?: string
+      destinationIntentDepositTxHash?: string
+      destinationIntentDepositTxExplorerUrl?: string
+    } = {}
+
+    // Find first deposit tx (transfer TO intent address)
+    const depositTx = destinationHistory.transactions.find((tx) =>
+      tx.transfers?.some(
+        (transfer) => transfer.to.toLowerCase() === intentAddress,
+      ),
+    )
+    if (depositTx) {
+      result.destinationIntentDepositTxHash = depositTx.txnHash
+      result.destinationIntentDepositTxExplorerUrl = getExplorerUrl({
+        txHash: depositTx.txnHash,
+        chainId: transaction.destinationChainId,
+      })
+    }
+
+    // Find first action tx (transfer FROM intent address)
+    const actionTx = destinationHistory.transactions.find((tx) =>
+      tx.transfers?.some(
+        (transfer) => transfer.from.toLowerCase() === intentAddress,
+      ),
+    )
+    if (actionTx) {
+      result.destinationIntentTxHash = actionTx.txnHash
+      result.destinationIntentTxExplorerUrl = getExplorerUrl({
+        txHash: actionTx.txnHash,
+        chainId: transaction.destinationChainId,
+      })
+    }
+
+    return result
+  } catch (error) {
+    logger.console.warn(
+      "[trails-sdk] Failed to get destination intent transaction hashes for:",
+      transaction.destinationIntentAddress,
+      "on chain",
+      transaction.destinationChainId,
+      error,
+    )
+    return {}
+  }
+}
+
+/**
+ * Decodes transaction events to detect refunds or failures
+ */
+async function decodeTransactionEvents(
+  transaction: IntentTransaction,
+  txHashes: {
+    originIntentTxHash?: string
+    destinationIntentTxHash?: string
+    originIntentDepositTxHash?: string
+    destinationIntentDepositTxHash?: string
+  },
+): Promise<{ refunded: boolean; failed: boolean }> {
+  const isExecuting =
+    transaction.executionStatus === "executing" ||
+    transaction.executionStatus === "processing"
+  const createdAtTime = transaction.createdAt
+    ? new Date(transaction.createdAt).getTime()
+    : null
+  const isExecutingOver1Minute =
+    isExecuting && createdAtTime && Date.now() - createdAtTime > 60 * 1000
+
+  if (!isExecutingOver1Minute) {
+    return { refunded: false, failed: false }
+  }
+
+  // Collect all transaction hashes to check
+  const txHashesToCheck: Array<{ hash: string; chainId: number }> = []
+
+  if (txHashes.originIntentTxHash && transaction.originChainId) {
+    txHashesToCheck.push({
+      hash: txHashes.originIntentTxHash,
+      chainId: transaction.originChainId,
+    })
+  }
+  if (txHashes.originIntentDepositTxHash && transaction.originChainId) {
+    txHashesToCheck.push({
+      hash: txHashes.originIntentDepositTxHash,
+      chainId: transaction.originChainId,
+    })
+  }
+  if (txHashes.destinationIntentTxHash && transaction.destinationChainId) {
+    txHashesToCheck.push({
+      hash: txHashes.destinationIntentTxHash,
+      chainId: transaction.destinationChainId,
+    })
+  }
+  if (
+    txHashes.destinationIntentDepositTxHash &&
+    transaction.destinationChainId
+  ) {
+    txHashesToCheck.push({
+      hash: txHashes.destinationIntentDepositTxHash,
+      chainId: transaction.destinationChainId,
+    })
+  }
+  if (transaction.originTransactionHash && transaction.originChainId) {
+    txHashesToCheck.push({
+      hash: transaction.originTransactionHash,
+      chainId: transaction.originChainId,
+    })
+  }
+  if (
+    transaction.destinationTransactionHash &&
+    transaction.destinationChainId
+  ) {
+    txHashesToCheck.push({
+      hash: transaction.destinationTransactionHash,
+      chainId: transaction.destinationChainId,
+    })
+  }
+
+  // Decode events from all known transaction hashes
+  for (const { hash, chainId } of txHashesToCheck) {
+    try {
+      const chainInfo = getChainInfo(chainId)
+      if (!chainInfo) {
+        continue
+      }
+
+      const publicClient = getPublicRpcClient(chainInfo)
+      const receipt = await publicClient.getTransactionReceipt({
+        hash: hash as `0x${string}`,
+      })
+
+      // Decode Trails Token Sweeper events (refunds)
+      const sweeperEvents = decodeTrailsTokenSweeperEvents(receipt)
+      const hasRefund = sweeperEvents.some(
+        (event) => event.type === "Refund" || event.type === "RefundAndSweep",
+      )
+
+      // Decode Guest Module events (failures)
+      const guestModuleEvents = decodeGuestModuleEvents(receipt)
+      const hasCallFailed = guestModuleEvents.some(
+        (event) => event.type === "CallFailed",
+      )
+
+      if (hasRefund) {
+        logger.console.log("[trails-sdk] Found refund event in transaction", {
+          hash,
+          chainId,
+        })
+        return { refunded: true, failed: false }
+      }
+
+      if (hasCallFailed) {
+        logger.console.log(
+          "[trails-sdk] Found CallFailed event in transaction",
+          { hash, chainId },
+        )
+        return { refunded: false, failed: true }
+      }
+    } catch (error) {
+      logger.console.warn(
+        "[trails-sdk] Failed to decode events for transaction",
+        { hash, chainId, error },
+      )
+      // Continue checking other transactions
+    }
+  }
+
+  return { refunded: false, failed: false }
+}
+
+/**
+ * Calculates effective execution status based on transaction state and decoded events
+ */
+function getEffectiveExecutionStatus(
+  transaction: IntentTransaction,
+  txHashes: {
+    originIntentTxHash?: string
+    destinationIntentTxHash?: string
+    originIntentDepositTxHash?: string
+    destinationIntentDepositTxHash?: string
+  },
+  decodedEvents: { refunded: boolean; failed: boolean },
+): string {
+  const {
+    executionStatus,
+    originChainId,
+    destinationChainId,
+    originIntentAddress,
+    destinationIntentAddress,
+    createdAt,
+  } = transaction
+
+  // If we decoded a refund, return "refunded"
+  if (decodedEvents.refunded) {
+    return "refunded"
+  }
+
+  // If we decoded a failure, return "failed"
+  if (decodedEvents.failed) {
+    return "failed"
+  }
+
+  // If API provided a status, use it
+  if (executionStatus && executionStatus !== "unknown") {
+    return executionStatus
+  }
+
+  // Check if this is a same-chain transaction
+  const isSameChain =
+    originIntentAddress?.toLowerCase() ===
+      destinationIntentAddress?.toLowerCase() &&
+    originChainId === destinationChainId
+
+  // Check if there's no destination
+  const hasNoDestination =
+    !destinationIntentAddress || !destinationChainId || isSameChain
+
+  // Check if it's been over 5 minutes since creation
+  const isOver5Minutes = createdAt
+    ? Date.now() - new Date(createdAt).getTime() > 5 * 60 * 1000
+    : false
+
+  // Rule 1: If there's a destination intent tx, it's completed
+  if (txHashes.destinationIntentTxHash) {
+    return "completed"
+  }
+
+  // Rule 2: Only origin tx hash exists and no real destination (same-chain case)
+  if (txHashes.originIntentTxHash && originChainId && hasNoDestination) {
+    return "completed"
+  }
+
+  // Rule 3: If there's a deposit but no action yet, status is pending
+  if (txHashes.originIntentDepositTxHash && !txHashes.originIntentTxHash) {
+    return "pending"
+  }
+
+  // Rule 4: Cross-chain with origin tx but no destination tx
+  if (
+    txHashes.originIntentTxHash &&
+    !txHashes.destinationIntentTxHash &&
+    originChainId &&
+    destinationChainId &&
+    !isSameChain &&
+    destinationIntentAddress
+  ) {
+    return isOver5Minutes ? "failed" : "pending"
+  }
+
+  // Otherwise, use the original execution status or default to unknown
+  return executionStatus || "unknown"
+}
+
+/**
+ * Enriches a single transaction with token info, transaction hashes, and status
+ */
+async function enrichTransaction(
+  transaction: IntentTransaction,
+  supportedTokens: Awaited<ReturnType<typeof getSupportedTokens>>,
+  trailsConfig: ReturnType<typeof useTrails>,
+): Promise<IntentTransaction> {
+  // Get token info
+  const originToken =
+    transaction.originTokenAddress && transaction.originChainId
+      ? await getTokenInfoForTransaction(
+          transaction.originTokenAddress,
+          transaction.originChainId,
+          supportedTokens,
+        )
+      : undefined
+
+  const destinationToken =
+    transaction.destinationTokenAddress && transaction.destinationChainId
+      ? await getTokenInfoForTransaction(
+          transaction.destinationTokenAddress,
+          transaction.destinationChainId,
+          supportedTokens,
+        )
+      : undefined
+
+  // Check if origin and destination are the same
+  const isSameIntentAddress =
+    transaction.originIntentAddress?.toLowerCase() ===
+      transaction.destinationIntentAddress?.toLowerCase() &&
+    transaction.originChainId === transaction.destinationChainId
+
+  // Get transaction hashes from API or fetch from account history
+  let originIntentTxHash: string | undefined = transaction.originTransactionHash
+  let destinationIntentTxHash: string | undefined =
+    transaction.destinationTransactionHash
+  let originIntentTxExplorerUrl: string | undefined
+  let destinationIntentTxExplorerUrl: string | undefined
+  let originIntentDepositTxHash: string | undefined
+  let destinationIntentDepositTxHash: string | undefined
+  let originIntentDepositTxExplorerUrl: string | undefined
+  let destinationIntentDepositTxExplorerUrl: string | undefined
+
+  // Generate explorer URLs for API-provided transaction hashes
+  if (originIntentTxHash && transaction.originChainId) {
+    originIntentTxExplorerUrl = getExplorerUrl({
+      txHash: originIntentTxHash,
+      chainId: transaction.originChainId,
+    })
+  }
+  if (destinationIntentTxHash && transaction.destinationChainId) {
+    destinationIntentTxExplorerUrl = getExplorerUrl({
+      txHash: destinationIntentTxHash,
+      chainId: transaction.destinationChainId,
+    })
+  }
+
+  // Get origin intent transaction hashes if not provided by API
+  const originHashes = await getOriginIntentTransactionHashes(
+    transaction,
+    trailsConfig,
+  )
+  if (originHashes.originIntentTxHash) {
+    originIntentTxHash = originHashes.originIntentTxHash
+    originIntentTxExplorerUrl = originHashes.originIntentTxExplorerUrl
+  }
+  if (originHashes.originIntentDepositTxHash) {
+    originIntentDepositTxHash = originHashes.originIntentDepositTxHash
+    originIntentDepositTxExplorerUrl =
+      originHashes.originIntentDepositTxExplorerUrl
+  }
+
+  // Get destination intent transaction hashes if not provided by API
+  const destinationHashes = await getDestinationIntentTransactionHashes(
+    transaction,
+    isSameIntentAddress,
+    trailsConfig,
+  )
+  if (destinationHashes.destinationIntentTxHash) {
+    destinationIntentTxHash = destinationHashes.destinationIntentTxHash
+    destinationIntentTxExplorerUrl =
+      destinationHashes.destinationIntentTxExplorerUrl
+  }
+  if (destinationHashes.destinationIntentDepositTxHash) {
+    destinationIntentDepositTxHash =
+      destinationHashes.destinationIntentDepositTxHash
+    destinationIntentDepositTxExplorerUrl =
+      destinationHashes.destinationIntentDepositTxExplorerUrl
+  }
+
+  // Decode events for executing transactions
+  const decodedEvents = await decodeTransactionEvents(transaction, {
+    originIntentTxHash,
+    destinationIntentTxHash,
+    originIntentDepositTxHash,
+    destinationIntentDepositTxHash,
+  })
+
+  // Calculate effective execution status
+  const effectiveExecutionStatus = getEffectiveExecutionStatus(
+    transaction,
+    {
+      originIntentTxHash,
+      destinationIntentTxHash,
+      originIntentDepositTxHash,
+      destinationIntentDepositTxHash,
+    },
+    decodedEvents,
+  )
+
+  // Return enriched transaction
+  return {
+    ...transaction,
+    ...(isSameIntentAddress
+      ? {
+          destinationIntentAddress: "",
+          destinationChainId: undefined,
+        }
+      : {}),
+    originToken,
+    destinationToken,
+    originIntentTxHash,
+    destinationIntentTxHash,
+    originIntentTxExplorerUrl,
+    destinationIntentTxExplorerUrl,
+    originIntentDepositTxHash,
+    destinationIntentDepositTxHash,
+    originIntentDepositTxExplorerUrl,
+    destinationIntentDepositTxExplorerUrl,
+    executionStatus: effectiveExecutionStatus,
+  }
+}
 
 export type UseIntentTransactionHistoryParams = {
   accountAddress?: string
@@ -42,6 +736,73 @@ export function useIntentTransactionHistory({
   const [page, setPage] = useState(0)
   const [hasMore, setHasMore] = useState(false)
 
+  /**
+   * Fetches intent transaction history from the API
+   */
+  const fetchIntentTransactionHistoryFromApi = useCallback(
+    async (
+      accountAddress: string,
+      pageSize: number,
+      pageNum: number,
+      apiKey: string,
+      apiUrl: string,
+    ) => {
+      if (!apiKey) {
+        throw new Error("Trails api key is required")
+      }
+
+      const trailsClient = getTrailsClient({ apiKey, hostname: apiUrl })
+
+      const requestParams = {
+        byOwnerAddress: accountAddress,
+        page: {
+          pageSize,
+          sort: [
+            {
+              column: "created_at",
+              order: SortOrder.DESC,
+            },
+          ],
+        },
+      }
+
+      logger.console.log(
+        "[trails-sdk] getIntentTransactionHistory request:",
+        requestParams,
+      )
+
+      const apiResult =
+        await trailsClient.getIntentTransactionHistory(requestParams)
+
+      logger.console.log("[trails-sdk] getIntentTransactionHistory response:", {
+        intentCount: apiResult.intents?.length || 0,
+        hasNextPage: !!apiResult.nextPage,
+        firstIntent: apiResult.intents?.[0],
+      })
+
+      // Map API response to IntentTransaction
+      const mappedTransactions: IntentTransaction[] = (
+        apiResult.intents || []
+      ).map(mapIntentSummaryToTransaction)
+
+      return {
+        transactions: mappedTransactions,
+        page: apiResult.nextPage
+          ? {
+              page: pageNum,
+              pageSize,
+              more: apiResult.nextPage.more || false,
+            }
+          : {
+              page: pageNum,
+              pageSize,
+              more: false,
+            },
+      }
+    },
+    [],
+  )
+
   const fetchTransactions = useCallback(
     async (pageNum: number = 0, append: boolean = false) => {
       if (!accountAddress || !enabled) return
@@ -50,423 +811,26 @@ export function useIntentTransactionHistory({
       setError(null)
 
       try {
-        const result: IntentTransactionHistoryResponse =
-          await getIntentTransactionHistory({
-            accountAddress,
-            pageSize,
-            page: pageNum,
-            apiKey: trailsConfig.trailsApiKey,
-            apiUrl: trailsConfig.trailsApiUrl!,
-          })
-
-        // Enrich transactions with token information
-        const enrichedTransactions = await Promise.all(
-          (result.transactions || []).map(async (transaction) => {
-            let originToken:
-              | {
-                  symbol: string
-                  name: string
-                  decimals: number
-                  imageUrl: string
-                  chainId: number
-                }
-              | undefined
-            let destinationToken:
-              | {
-                  symbol: string
-                  name: string
-                  decimals: number
-                  imageUrl: string
-                  chainId: number
-                }
-              | undefined
-
-            // Get supported tokens once for lookup
-            const supportedTokens = await getSupportedTokens()
-
-            // Get origin token info
-            if (transaction.originTokenAddress && transaction.originChainId) {
-              const isNativeOrigin =
-                transaction.originTokenAddress ===
-                "0x0000000000000000000000000000000000000000"
-
-              if (isNativeOrigin) {
-                // For native tokens, find the matching native token by chain ID and address
-                const nativeToken = supportedTokens.find(
-                  (token) =>
-                    token.contractAddress.toLowerCase() ===
-                      transaction.originTokenAddress!.toLowerCase() &&
-                    token.chainId === transaction.originChainId,
-                )
-
-                if (nativeToken) {
-                  originToken = {
-                    symbol: nativeToken.symbol,
-                    name: nativeToken.name,
-                    decimals: nativeToken.decimals,
-                    imageUrl: nativeToken.imageUrl,
-                    chainId: nativeToken.chainId,
-                  }
-                } else {
-                  // Fallback for native token - use chain-specific default
-                  originToken = {
-                    symbol: "ETH", // Could be improved to detect chain-specific native tokens
-                    name: "Native Token",
-                    decimals: 18,
-                    imageUrl:
-                      "https://assets.sequence.info/images/tokens/large/1/0x0000000000000000000000000000000000000000.webp",
-                    chainId: transaction.originChainId,
-                  }
-                }
-              } else {
-                // For ERC20 tokens, first check supported tokens by address and chain
-                const supportedToken = supportedTokens.find(
-                  (token) =>
-                    token.contractAddress.toLowerCase() ===
-                      transaction.originTokenAddress!.toLowerCase() &&
-                    token.chainId === transaction.originChainId,
-                )
-
-                if (supportedToken) {
-                  originToken = {
-                    symbol: supportedToken.symbol,
-                    name: supportedToken.name,
-                    decimals: supportedToken.decimals,
-                    imageUrl: supportedToken.imageUrl,
-                    chainId: supportedToken.chainId,
-                  }
-                } else {
-                  // Fallback to getTokenInfo for on-chain lookup with the specific chain ID
-                  try {
-                    const tokenInfo = await getTokenInfo(
-                      transaction.originChainId,
-                      transaction.originTokenAddress,
-                    )
-                    if (tokenInfo) {
-                      originToken = {
-                        symbol: tokenInfo.symbol,
-                        name: tokenInfo.name,
-                        decimals: tokenInfo.decimals,
-                        imageUrl: tokenInfo.imageUrl,
-                        chainId: tokenInfo.chainId,
-                      }
-                    }
-                  } catch (error) {
-                    logger.console.warn(
-                      "[trails-sdk] Failed to get origin token info for:",
-                      transaction.originTokenAddress,
-                      "on chain",
-                      transaction.originChainId,
-                      error,
-                    )
-                  }
-                }
-              }
-            }
-
-            // Get destination token info
-            if (
-              transaction.destinationTokenAddress &&
-              transaction.destinationChainId
-            ) {
-              const isNativeDestination =
-                transaction.destinationTokenAddress ===
-                "0x0000000000000000000000000000000000000000"
-
-              if (isNativeDestination) {
-                // For native tokens, find the matching native token by chain ID and address
-                const nativeToken = supportedTokens.find(
-                  (token) =>
-                    token.contractAddress.toLowerCase() ===
-                      transaction.destinationTokenAddress!.toLowerCase() &&
-                    token.chainId === transaction.destinationChainId,
-                )
-
-                if (nativeToken) {
-                  destinationToken = {
-                    symbol: nativeToken.symbol,
-                    name: nativeToken.name,
-                    decimals: nativeToken.decimals,
-                    imageUrl: nativeToken.imageUrl,
-                    chainId: nativeToken.chainId,
-                  }
-                } else {
-                  // Fallback for native token - use chain-specific default
-                  destinationToken = {
-                    symbol: "ETH", // Could be improved to detect chain-specific native tokens
-                    name: "Native Token",
-                    decimals: 18,
-                    imageUrl:
-                      "https://assets.sequence.info/images/tokens/large/1/0x0000000000000000000000000000000000000000.webp",
-                    chainId: transaction.destinationChainId,
-                  }
-                }
-              } else {
-                // For ERC20 tokens, first check supported tokens by address and chain
-                const supportedToken = supportedTokens.find(
-                  (token) =>
-                    token.contractAddress.toLowerCase() ===
-                      transaction.destinationTokenAddress!.toLowerCase() &&
-                    token.chainId === transaction.destinationChainId,
-                )
-
-                if (supportedToken) {
-                  destinationToken = {
-                    symbol: supportedToken.symbol,
-                    name: supportedToken.name,
-                    decimals: supportedToken.decimals,
-                    imageUrl: supportedToken.imageUrl,
-                    chainId: supportedToken.chainId,
-                  }
-                } else {
-                  // Fallback to getTokenInfo for on-chain lookup with the specific chain ID
-                  try {
-                    const tokenInfo = await getTokenInfo(
-                      transaction.destinationChainId,
-                      transaction.destinationTokenAddress,
-                    )
-                    if (tokenInfo) {
-                      destinationToken = {
-                        symbol: tokenInfo.symbol,
-                        name: tokenInfo.name,
-                        decimals: tokenInfo.decimals,
-                        imageUrl: tokenInfo.imageUrl,
-                        chainId: tokenInfo.chainId,
-                      }
-                    }
-                  } catch (error) {
-                    logger.console.warn(
-                      "[trails-sdk] Failed to get destination token info for:",
-                      transaction.destinationTokenAddress,
-                      "on chain",
-                      transaction.destinationChainId,
-                      error,
-                    )
-                  }
-                }
-              }
-            }
-
-            // Check if origin and destination are the same
-            const isSameIntentAddress =
-              transaction.originIntentAddress?.toLowerCase() ===
-                transaction.destinationIntentAddress?.toLowerCase() &&
-              transaction.originChainId === transaction.destinationChainId
-
-            // Fetch intent wallet transaction hashes
-            let originIntentTxHash: string | undefined
-            let destinationIntentTxHash: string | undefined
-            let originIntentTxExplorerUrl: string | undefined
-            let destinationIntentTxExplorerUrl: string | undefined
-            let originIntentDepositTxHash: string | undefined
-            let destinationIntentDepositTxHash: string | undefined
-            let originIntentDepositTxExplorerUrl: string | undefined
-            let destinationIntentDepositTxExplorerUrl: string | undefined
-
-            // Get origin intent transaction hashes (both deposit and action)
-            if (transaction.originIntentAddress && transaction.originChainId) {
-              try {
-                const originHistory = await getAccountTransactionHistory({
-                  chainId: transaction.originChainId,
-                  accountAddress: transaction.originIntentAddress,
-                  pageSize: 10, // Fetch more to find both deposit and action txs
-                  page: 0,
-                  includeMetadata: true, // Need metadata to check transfer direction
-                  apiKey: trailsConfig.trailsApiKey,
-                  indexerUrl: trailsConfig.sequenceIndexerUrl!,
-                })
-                if (
-                  originHistory?.transactions &&
-                  originHistory.transactions.length > 0
-                ) {
-                  const intentAddress =
-                    transaction.originIntentAddress.toLowerCase()
-
-                  // Find first deposit tx (transfer TO intent address)
-                  const depositTx = originHistory.transactions.find((tx) =>
-                    tx.transfers?.some(
-                      (transfer) => transfer.to.toLowerCase() === intentAddress,
-                    ),
-                  )
-                  if (depositTx) {
-                    originIntentDepositTxHash = depositTx.txnHash
-                    originIntentDepositTxExplorerUrl = getExplorerUrl({
-                      txHash: depositTx.txnHash,
-                      chainId: transaction.originChainId,
-                    })
-                  }
-
-                  // Find first action tx (transfer FROM intent address)
-                  const actionTx = originHistory.transactions.find((tx) =>
-                    tx.transfers?.some(
-                      (transfer) =>
-                        transfer.from.toLowerCase() === intentAddress,
-                    ),
-                  )
-                  if (actionTx) {
-                    originIntentTxHash = actionTx.txnHash
-                    originIntentTxExplorerUrl = getExplorerUrl({
-                      txHash: actionTx.txnHash,
-                      chainId: transaction.originChainId,
-                    })
-                  }
-                }
-              } catch (error) {
-                logger.console.warn(
-                  "[trails-sdk] Failed to get origin intent transaction hashes for:",
-                  transaction.originIntentAddress,
-                  "on chain",
-                  transaction.originChainId,
-                  error,
-                )
-              }
-            }
-
-            // Get destination intent transaction hashes (only if different from origin)
-            if (
-              !isSameIntentAddress &&
-              transaction.destinationIntentAddress &&
-              transaction.destinationChainId
-            ) {
-              try {
-                const destinationHistory = await getAccountTransactionHistory({
-                  chainId: transaction.destinationChainId,
-                  accountAddress: transaction.destinationIntentAddress,
-                  pageSize: 10, // Fetch more to find both deposit and action txs
-                  page: 0,
-                  includeMetadata: true, // Need metadata to check transfer direction
-                  apiKey: trailsConfig.trailsApiKey,
-                  indexerUrl: trailsConfig.sequenceIndexerUrl!,
-                })
-                if (
-                  destinationHistory?.transactions &&
-                  destinationHistory.transactions.length > 0
-                ) {
-                  const intentAddress =
-                    transaction.destinationIntentAddress.toLowerCase()
-
-                  // Find first deposit tx (transfer TO intent address)
-                  const depositTx = destinationHistory.transactions.find((tx) =>
-                    tx.transfers?.some(
-                      (transfer) => transfer.to.toLowerCase() === intentAddress,
-                    ),
-                  )
-                  if (depositTx) {
-                    destinationIntentDepositTxHash = depositTx.txnHash
-                    destinationIntentDepositTxExplorerUrl = getExplorerUrl({
-                      txHash: depositTx.txnHash,
-                      chainId: transaction.destinationChainId,
-                    })
-                  }
-
-                  // Find first action tx (transfer FROM intent address)
-                  const actionTx = destinationHistory.transactions.find((tx) =>
-                    tx.transfers?.some(
-                      (transfer) =>
-                        transfer.from.toLowerCase() === intentAddress,
-                    ),
-                  )
-                  if (actionTx) {
-                    destinationIntentTxHash = actionTx.txnHash
-                    destinationIntentTxExplorerUrl = getExplorerUrl({
-                      txHash: actionTx.txnHash,
-                      chainId: transaction.destinationChainId,
-                    })
-                  }
-                }
-              } catch (error) {
-                logger.console.warn(
-                  "[trails-sdk] Failed to get destination intent transaction hashes for:",
-                  transaction.destinationIntentAddress,
-                  "on chain",
-                  transaction.destinationChainId,
-                  error,
-                )
-              }
-            }
+        const apiKey = trailsConfig.trailsApiKey || ""
+        const apiUrl = trailsConfig.trailsApiUrl!
+
+        // Fetch intent transaction history from API
+        const result = await fetchIntentTransactionHistoryFromApi(
+          accountAddress,
+          pageSize,
+          pageNum,
+          apiKey,
+          apiUrl,
+        )
 
-            // Calculate effective execution status
-            const getEffectiveStatus = (): string => {
-              const {
-                executionStatus,
-                originChainId,
-                destinationChainId,
-                originIntentAddress,
-                destinationIntentAddress,
-                createdAt,
-              } = transaction
-
-              // Check if this is a same-chain transaction (same address and chain)
-              const isSameChain =
-                originIntentAddress?.toLowerCase() ===
-                  destinationIntentAddress?.toLowerCase() &&
-                originChainId === destinationChainId
-
-              // Check if there's no destination (same-chain or no destination intent)
-              const hasNoDestination =
-                !destinationIntentAddress || !destinationChainId || isSameChain
-
-              // Check if it's been over 5 minutes since creation
-              const isOver5Minutes = createdAt
-                ? Date.now() - new Date(createdAt).getTime() > 5 * 60 * 1000
-                : false
-
-              // Rule 1: If there's a destination intent tx, it's completed
-              if (destinationIntentTxHash) {
-                return "completed"
-              }
-
-              // Rule 2: Only origin tx hash exists and no real destination (same-chain case)
-              if (originIntentTxHash && originChainId && hasNoDestination) {
-                return "completed"
-              }
-
-              // Rule 3: If there's a deposit but no action yet, status is pending
-              if (originIntentDepositTxHash && !originIntentTxHash) {
-                return "pending"
-              }
-
-              // Rule 4: Cross-chain with origin tx but no destination tx
-              // If over 5 minutes, consider it failed; otherwise pending
-              if (
-                originIntentTxHash &&
-                !destinationIntentTxHash &&
-                originChainId &&
-                destinationChainId &&
-                !isSameChain &&
-                destinationIntentAddress
-              ) {
-                return isOver5Minutes ? "failed" : "pending"
-              }
-
-              // Otherwise, use the original execution status
-              return executionStatus || "unknown"
-            }
+        // Get supported tokens once for all transactions
+        const supportedTokens = await getSupportedTokens()
 
-            const effectiveExecutionStatus = getEffectiveStatus()
-
-            // If same intent address, omit destination address/chain to avoid duplication
-            return {
-              ...transaction,
-              ...(isSameIntentAddress
-                ? {
-                    destinationIntentAddress: "",
-                    destinationChainId: undefined,
-                  }
-                : {}),
-              originToken,
-              destinationToken,
-              originIntentTxHash,
-              destinationIntentTxHash,
-              originIntentTxExplorerUrl,
-              destinationIntentTxExplorerUrl,
-              originIntentDepositTxHash,
-              destinationIntentDepositTxHash,
-              originIntentDepositTxExplorerUrl,
-              destinationIntentDepositTxExplorerUrl,
-              executionStatus: effectiveExecutionStatus,
-            }
-          }),
+        // Enrich transactions with token information, transaction hashes, and status
+        const enrichedTransactions = await Promise.all(
+          (result.transactions || []).map(async (transaction) =>
+            enrichTransaction(transaction, supportedTokens, trailsConfig),
+          ),
         )
 
         if (append) {
@@ -491,7 +855,13 @@ export function useIntentTransactionHistory({
         setLoading(false)
       }
     },
-    [accountAddress, enabled, pageSize, trailsConfig],
+    [
+      accountAddress,
+      enabled,
+      pageSize,
+      trailsConfig,
+      fetchIntentTransactionHistoryFromApi,
+    ],
   )
 
   const refetch = () => {