0xtrails 0.13.2 → 0.14.0

package/src/widget/hooks/useIntentTransactionHistory.ts

@@ -1,790 +0,0 @@
-import { useEffect, useCallback, useRef, useState, useMemo } from "react"
-import { useQuery } from "@tanstack/react-query"
-import type { IntentTransaction } from "../../transactions.js"
-import { getExplorerUrl } from "../../explorer.js"
-import { logger } from "../../logger.js"
-import { MINUTE_MS } from "../../utils/time.js"
-import { useTrails } from "../providers/TrailsProvider.js"
-import { getTrailsClient } from "../../trailsClient.js"
-import type { IntentHistory } from "@0xtrails/api"
-import {
-  decodeTokenSweeperEvents,
-  decodeGuestModuleEvents,
-} from "../../decoders.js"
-import { getChainRpcClient, getChainInfo } from "../../chains.js"
-import { useSupportedTokens, type Token } from "../../tokens.js"
-import { isNativeToken } from "../../utils/address.js"
-
-// ============================================================================
-// Helper Functions
-// ============================================================================
-
-/**
- * Normalizes API status to uppercase format
- */
-function normalizeApiStatus(apiStatus: string): string {
-  return apiStatus?.toUpperCase() || "UNKNOWN"
-}
-
-/**
- * Maps IntentHistory from API to IntentTransaction
- */
-function mapIntentHistoryToTransaction(
-  intentHistory: IntentHistory,
-): IntentTransaction {
-  // IntentHistory wraps the receipt data in a receipt field
-  const receipt = intentHistory.receipt
-
-  // Get transaction hashes from the transaction objects
-  const depositTransactionHash = receipt.depositTransaction?.txnHash
-  const originTransactionHash = receipt.originTransaction?.txnHash
-  const destinationTransactionHash = receipt.destinationTransaction?.txnHash
-  const refundTransactionHash = receipt.refundTransaction?.txnHash
-
-  // Get transaction statuses from the transaction objects
-  const depositStatus = receipt.depositTransaction?.status
-  const originStatus = receipt.originTransaction?.status
-  const destinationStatus = receipt.destinationTransaction?.status
-  const refundStatus = receipt.refundTransaction?.status
-
-  // Use summary if available, otherwise construct from transaction data
-  const intentId = intentHistory.intentId
-  const status = intentHistory.status
-  const ownerAddress = receipt.ownerAddress
-  const originChainId = receipt.originChainId
-  const destinationChainId = receipt.destinationChainId
-
-  // Get intent addresses from summary (not available in transaction objects)
-  const originIntentAddress = receipt.summary?.originIntentAddress || ""
-  const destinationIntentAddress =
-    receipt.summary?.destinationIntentAddress || ""
-
-  // Get token data from summary or transactions
-  const originTokenAddress =
-    receipt.summary?.originTokenAddress ||
-    receipt.originTransaction?.tokenAddress ||
-    receipt.depositTransaction?.tokenAddress ||
-    ""
-
-  const originTokenAmount =
-    receipt.summary?.originTokenAmount ||
-    receipt.originTransaction?.tokenAmount ||
-    receipt.depositTransaction?.tokenAmount ||
-    0n
-
-  const destinationTokenAddress =
-    receipt.summary?.destinationTokenAddress ||
-    receipt.destinationTransaction?.tokenAddress ||
-    ""
-
-  const destinationTokenAmount =
-    receipt.summary?.destinationTokenAmount ||
-    receipt.destinationTransaction?.tokenAmount ||
-    0n
-
-  const destinationToAddress =
-    receipt.summary?.destinationToAddress || ownerAddress
-
-  const createdAt = receipt.createdAt || intentHistory.createdAt
-
-  // Get token metadata
-  const originTokenMetadata = receipt.summary?.originTokenMetadata
-  const destinationTokenMetadata = receipt.summary?.destinationTokenMetadata
-
-  return {
-    originIntentAddress: originIntentAddress,
-    destinationIntentAddress: destinationIntentAddress,
-    mainSigner: ownerAddress,
-    intentId: intentId,
-    metaTxnId: intentId,
-    txnHash: originTransactionHash || destinationTransactionHash || undefined,
-    intentStatus: normalizeApiStatus(status),
-    executionStatus: normalizeApiStatus(status),
-    originChainId: originChainId,
-    destinationChainId: destinationChainId,
-    originTokenAddress: originTokenAddress,
-    originTokenAmount: originTokenAmount.toString(),
-    destinationTokenAddress: destinationTokenAddress || "",
-    destinationTokenAmount: (destinationTokenAmount || 0n).toString(),
-    destinationToAddress: destinationToAddress,
-    createdAt: createdAt,
-    depositTransactionHash: depositTransactionHash,
-    originTransactionHash: originTransactionHash,
-    destinationTransactionHash: destinationTransactionHash,
-    depositTransactionStatus: depositStatus,
-    originTransactionStatus: originStatus,
-    destinationTransactionStatus: destinationStatus,
-    refundTransactionHash: refundTransactionHash,
-    refundTransactionStatus: refundStatus,
-    refundTransactionChainId: receipt.refundTransaction?.chainId,
-    originToken:
-      originTokenMetadata && originTokenAddress && originTokenAddress !== ""
-        ? ({
-            symbol: originTokenMetadata.symbol || "",
-            name: originTokenMetadata.name || "",
-            decimals: originTokenMetadata.decimals ?? 18,
-            imageUrl: originTokenMetadata.logoUri ?? "",
-            chainId: originTokenMetadata.chainId,
-          } as {
-            symbol: string
-            name: string
-            decimals: number
-            imageUrl: string
-            chainId: number
-          })
-        : undefined,
-    destinationToken:
-      destinationTokenMetadata &&
-      destinationTokenAddress &&
-      destinationTokenAddress !== ""
-        ? ({
-            symbol: destinationTokenMetadata.symbol || "",
-            name: destinationTokenMetadata.name || "",
-            decimals: destinationTokenMetadata.decimals ?? 18,
-            imageUrl: destinationTokenMetadata.logoUri ?? "",
-            chainId: destinationTokenMetadata.chainId,
-          } as {
-            symbol: string
-            name: string
-            decimals: number
-            imageUrl: string
-            chainId: number
-          })
-        : undefined,
-    balances: intentHistory.balances,
-    hasBalance: intentHistory.hasBalance,
-  }
-}
-
-/**
- * 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 > MINUTE_MS
-
-  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 = getChainRpcClient(chainInfo.id)
-      const receipt = await publicClient.getTransactionReceipt({
-        hash: hash as `0x${string}`,
-      })
-
-      // Decode Trails Token Sweeper events (refunds)
-      const sweeperEvents = decodeTokenSweeperEvents(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
-
-  // Check for aborted status in transaction status fields
-  // Priority: destinationTransactionStatus > originTransactionStatus > depositTransactionStatus
-  const depositStatus = transaction.depositTransactionStatus
-  const originStatus = transaction.originTransactionStatus
-  const destinationStatus = transaction.destinationTransactionStatus
-
-  // If destinationTransactionStatus exists and is not ABORTED or UNKNOWN, use it (don't mark as aborted)
-  if (
-    destinationStatus &&
-    destinationStatus !== "ABORTED" &&
-    destinationStatus !== "UNKNOWN"
-  ) {
-    return normalizeApiStatus(destinationStatus)
-  }
-  // If destinationTransactionStatus doesn't exist but originTransactionStatus exists and is not ABORTED or UNKNOWN, use it
-  if (
-    !destinationStatus &&
-    originStatus &&
-    originStatus !== "ABORTED" &&
-    originStatus !== "UNKNOWN"
-  ) {
-    return normalizeApiStatus(originStatus)
-  }
-  // If depositTransactionStatus is ABORTED but origin/destination have non-ABORTED statuses, don't use aborted
-  if (depositStatus === "ABORTED") {
-    const hasNonAbortedOrigin = originStatus && originStatus !== "ABORTED"
-    const hasNonAbortedDestination =
-      destinationStatus && destinationStatus !== "ABORTED"
-
-    // Only mark as aborted if no non-aborted statuses exist
-    if (!hasNonAbortedOrigin && !hasNonAbortedDestination) {
-      return "ABORTED"
-    }
-  }
-  // If originTransactionStatus is ABORTED and no destination status, use aborted
-  if (originStatus === "ABORTED" && !destinationStatus) {
-    return "ABORTED"
-  }
-  // If destinationTransactionStatus is ABORTED, use aborted
-  if (destinationStatus === "ABORTED") {
-    return "ABORTED"
-  }
-
-  // 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 (but skip if it's "EXECUTING" when we know it's aborted)
-  if (
-    executionStatus &&
-    executionStatus !== "UNKNOWN" &&
-    executionStatus !== "EXECUTING"
-  ) {
-    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 * MINUTE_MS
-    : false
-
-  // Rule 1: If there's a destination intent tx, it's succeeded
-  if (txHashes.destinationIntentTxHash) {
-    return "SUCCEEDED"
-  }
-
-  // Rule 2: Only origin tx hash exists and no real destination (same-chain case)
-  if (txHashes.originIntentTxHash && originChainId && hasNoDestination) {
-    return "SUCCEEDED"
-  }
-
-  // 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 explorer URLs and effective execution status.
- * All transaction hashes come from the API response (getIntentHistory).
- * Token metadata fallback is handled separately via applyTokenMetadata.
- */
-async function enrichTransaction(
-  transaction: IntentTransaction,
-): Promise<IntentTransaction> {
-  // Check if origin and destination are the same
-  const isSameIntentAddress =
-    transaction.originIntentAddress?.toLowerCase() ===
-      transaction.destinationIntentAddress?.toLowerCase() &&
-    transaction.originChainId === transaction.destinationChainId
-
-  // Use transaction hashes from API (don't fetch from account history anymore)
-  const originIntentTxHash: string | undefined =
-    transaction.originTransactionHash
-  const 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,
-    })
-  }
-
-  // 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,
-        }
-      : {}),
-    originIntentTxHash,
-    destinationIntentTxHash,
-    originIntentTxExplorerUrl,
-    destinationIntentTxExplorerUrl,
-    originIntentDepositTxHash,
-    destinationIntentDepositTxHash,
-    originIntentDepositTxExplorerUrl,
-    destinationIntentDepositTxExplorerUrl,
-    executionStatus: effectiveExecutionStatus,
-  }
-}
-
-/**
- * Applies token metadata from supportedTokens as a fallback when API doesn't
- * provide it (e.g., for aborted intents). Sync operation used in useMemo so
- * token data updates without re-fetching the API.
- */
-function applyTokenMetadata(
-  transaction: IntentTransaction,
-  supportedTokens: Token[],
-): IntentTransaction {
-  let originToken = transaction.originToken
-  if (
-    !originToken &&
-    transaction.originTokenAddress &&
-    transaction.originChainId
-  ) {
-    let fallbackToken: Token | undefined
-
-    if (isNativeToken(transaction.originTokenAddress)) {
-      fallbackToken = supportedTokens.find(
-        (token) =>
-          token.isNativeToken && token.chainId === transaction.originChainId,
-      )
-    } else {
-      fallbackToken = supportedTokens.find(
-        (token) =>
-          token.contractAddress.toLowerCase() ===
-            transaction.originTokenAddress?.toLowerCase() &&
-          token.chainId === transaction.originChainId,
-      )
-    }
-
-    if (fallbackToken) {
-      originToken = {
-        symbol: fallbackToken.symbol,
-        name: fallbackToken.name,
-        decimals: fallbackToken.decimals,
-        imageUrl: fallbackToken.imageUrl || "",
-        chainId: transaction.originChainId,
-      }
-    }
-  }
-
-  let destinationToken = transaction.destinationToken
-  if (
-    !destinationToken &&
-    transaction.destinationTokenAddress &&
-    transaction.destinationChainId
-  ) {
-    let fallbackToken: Token | undefined
-
-    if (isNativeToken(transaction.destinationTokenAddress)) {
-      fallbackToken = supportedTokens.find(
-        (token) =>
-          token.isNativeToken &&
-          token.chainId === transaction.destinationChainId,
-      )
-    } else {
-      fallbackToken = supportedTokens.find(
-        (token) =>
-          token.contractAddress.toLowerCase() ===
-            transaction.destinationTokenAddress?.toLowerCase() &&
-          token.chainId === transaction.destinationChainId,
-      )
-    }
-
-    if (fallbackToken) {
-      destinationToken = {
-        symbol: fallbackToken.symbol,
-        name: fallbackToken.name,
-        decimals: fallbackToken.decimals,
-        imageUrl: fallbackToken.imageUrl || "",
-        chainId: transaction.destinationChainId,
-      }
-    }
-  }
-
-  if (
-    originToken === transaction.originToken &&
-    destinationToken === transaction.destinationToken
-  ) {
-    return transaction
-  }
-
-  return { ...transaction, originToken, destinationToken }
-}
-
-export type UseIntentTransactionHistoryParams = {
-  accountAddress?: string
-  pageSize?: number
-  enabled?: boolean
-  refetchInterval?: number | false
-  intentStatuses?: string[]
-}
-
-export type UseIntentTransactionHistoryReturn = {
-  transactions: IntentTransaction[]
-  loading: boolean
-  error: string | null
-  refetch: () => Promise<void>
-  loadMore: () => void
-  hasMore: boolean
-  page: number
-  nextPage: () => void
-  prevPage: () => void
-  hasPrev: boolean
-  totalPages?: number
-  resetPagination: () => void
-}
-
-// ============================================================================
-// Main Hook
-// ============================================================================
-
-export function useIntentTransactionHistory({
-  accountAddress,
-  pageSize = 10,
-  enabled = true,
-  refetchInterval,
-  intentStatuses,
-}: UseIntentTransactionHistoryParams): UseIntentTransactionHistoryReturn {
-  const trailsConfig = useTrails()
-
-  // Get cached supported tokens for fallback when API doesn't provide metadata
-  // (e.g., for aborted intents)
-  const { supportedTokens } = useSupportedTokens()
-
-  // Page state - store the full page object from API
-  const [page, setPage] = useState(0)
-  const [pageHistory, setPageHistory] = useState<any[]>([undefined]) // undefined = first page (no page param needed)
-
-  // Get current page object
-  const currentPageObject = pageHistory[page]
-
-  const { data, isLoading, error, refetch, isFetching } = useQuery({
-    queryKey: [
-      "intentTransactionHistory",
-      accountAddress,
-      pageSize,
-      page,
-      intentStatuses?.join(",") ?? "all",
-    ],
-    queryFn: async () => {
-      if (!accountAddress || !trailsConfig.trailsApiKey) {
-        throw new Error("Account address and API key required")
-      }
-
-      const trailsClient = getTrailsClient({
-        apiKey: trailsConfig.trailsApiKey,
-        hostname: trailsConfig.trailsApiUrl!,
-      })
-
-      const requestParams: any = {
-        byOwnerAddress: accountAddress,
-        includeBalances: true,
-        page: currentPageObject || { pageSize },
-      }
-
-      if (intentStatuses && intentStatuses.length > 0) {
-        requestParams.byStatuses = intentStatuses
-      }
-
-      logger.console.log(
-        "[trails-sdk] getIntentHistory request:",
-        requestParams,
-      )
-
-      const apiResult = await trailsClient.getIntentHistory(requestParams)
-
-      logger.console.log("[trails-sdk] getIntentHistory response:", {
-        intentCount: apiResult.intents?.length || 0,
-        hasNextPage: apiResult.nextPage?.more ?? false,
-      })
-
-      const mappedTransactions: IntentTransaction[] = (
-        apiResult.intents || []
-      ).map(mapIntentHistoryToTransaction)
-
-      // Catch per-transaction so RPC failures in enrichment don't kill the query
-      const enrichedTransactions = await Promise.all(
-        mappedTransactions.map(async (transaction) => {
-          try {
-            return await enrichTransaction(transaction)
-          } catch (err) {
-            logger.console.warn(
-              "[trails-sdk] Failed to enrich transaction, using raw data:",
-              err,
-            )
-            return transaction
-          }
-        }),
-      )
-
-      return {
-        transactions: enrichedTransactions,
-        nextPage: apiResult.nextPage,
-        hasMore: apiResult.nextPage?.more ?? false,
-      }
-    },
-    enabled: enabled && !!accountAddress && !!trailsConfig.trailsApiKey,
-    staleTime: 5 * MINUTE_MS, // 5 minutes
-    gcTime: 5 * MINUTE_MS, // Keep cache alive as long as data is fresh (default is 5s)
-    retry: false, // Don't retry — enrichment RPC errors shouldn't re-call the API
-    refetchInterval: refetchInterval || undefined,
-    refetchOnMount: false,
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: false,
-    placeholderData: (previousData) => previousData, // Keep previous data while fetching
-    structuralSharing: false, // Prevent false "data changed" from enrichment producing new object refs
-  })
-
-  // Apply token metadata reactively — when supportedTokens loads/changes,
-  // transactions update without re-fetching the API
-  const transactions = useMemo(() => {
-    const raw = data?.transactions ?? []
-    if (raw.length === 0 || supportedTokens.length === 0) return raw
-    return raw.map((tx) => applyTokenMetadata(tx, supportedTokens))
-  }, [data?.transactions, supportedTokens])
-  const hasMore = data?.hasMore ?? false
-  const nextPageObject = data?.nextPage
-
-  const nextPageHandler = useCallback(() => {
-    if (!hasMore || isLoading) return
-
-    // Check if next page is already cached
-    if (pageHistory[page + 1]) {
-      logger.console.log("[trails-sdk] Using cached page", page + 1)
-      setPage((p) => p + 1)
-      return
-    }
-
-    // Fetch next page by storing the nextPage object and incrementing page index
-    if (nextPageObject) {
-      setPageHistory((prev) => {
-        const newHistory = [...prev]
-        newHistory[page + 1] = nextPageObject
-        return newHistory
-      })
-      setPage((p) => p + 1)
-    }
-  }, [hasMore, isLoading, nextPageObject, page, pageHistory])
-
-  const prevPageHandler = useCallback(() => {
-    if (page <= 0 || isLoading) return
-
-    // Go back to previous page
-    logger.console.log("[trails-sdk] Going to previous page", page - 1)
-    setPage((p) => p - 1)
-  }, [page, isLoading])
-
-  const loadMoreHandler = useCallback(() => {
-    if (!hasMore || isFetching) return
-
-    if (nextPageObject) {
-      setPageHistory((prev) => {
-        const newHistory = [...prev]
-        newHistory[page + 1] = nextPageObject
-        return newHistory
-      })
-      setPage((p) => p + 1)
-    }
-  }, [hasMore, isFetching, nextPageObject, page])
-
-  const resetPagination = useCallback(() => {
-    setPage((prev) => {
-      if (prev === 0) return prev // No-op if already at page 0
-      return 0
-    })
-    setPageHistory((prev) => {
-      if (prev.length === 1 && prev[0] === undefined) return prev // No-op if already reset
-      return [undefined]
-    })
-  }, [])
-
-  // Reset on account change
-  const prevAccountRef = useRef(accountAddress)
-  useEffect(() => {
-    if (prevAccountRef.current !== accountAddress) {
-      prevAccountRef.current = accountAddress
-      resetPagination()
-    }
-  }, [accountAddress, resetPagination])
-
-  return {
-    transactions,
-    loading: isLoading || isFetching,
-    error: error instanceof Error ? error.message : null,
-    refetch: async () => {
-      await refetch()
-    },
-    loadMore: loadMoreHandler,
-    hasMore,
-    page,
-    nextPage: nextPageHandler,
-    prevPage: prevPageHandler,
-    hasPrev: page > 0,
-    resetPagination,
-  }
-}