0xtrails 0.13.2 → 0.14.0

package/src/widget/hooks/useDefaultDestinationToken.tsx

@@ -1,179 +0,0 @@
-import { useMemo, useRef } from "react"
-import { useAccount } from "wagmi"
-import { base, arbitrum } from "viem/chains"
-import type { Address } from "ox"
-import { useSupportedTokens } from "../../tokens.js"
-import type { Token } from "../../tokens.js"
-import { useTokenBalances } from "../../query/balance.hooks.js"
-import { logger } from "../../logger.js"
-
-/**
- * Hook for intelligent default destination token selection.
- *
- * This hook calculates the best destination token based on:
- * - Origin token's chain (to minimize bridging costs)
- * - Token availability on destination chain
- * - User's existing balances for accurate balance display
- *
- * Only calculates destination when toToken/toChainId are NOT specified.
- *
- * @param originToken - The selected origin token
- * @returns defaultDestinationToken - Best destination token or null
- * @returns isLoading - Whether token data is still loading
- */
-export function useDefaultDestinationToken(originToken: Token | null) {
-  const { address } = useAccount()
-
-  // Only fetch supported tokens when we have an origin token to calculate destination
-  const { supportedTokens, isLoadingTokens } = useSupportedTokens({
-    disabled: !originToken,
-  })
-
-  // Only fetch balances when we have an origin token
-  const { sortedTokens, isLoadingSortedTokens } = useTokenBalances(
-    originToken ? (address as Address.Address) : null,
-    undefined,
-    { refetchInterval: false },
-  )
-
-  const isLoading = isLoadingTokens || isLoadingSortedTokens
-
-  // Use a ref to prevent unnecessary recalculations on balance-only updates
-  const stableDestTokenRef = useRef<Token | null>(null)
-  const lastOriginTokenKey = useRef<string>("")
-
-  const defaultDestinationToken = useMemo(() => {
-    // Don't compute destination if no origin token or still loading
-    if (!originToken || !supportedTokens?.length || !sortedTokens?.length) {
-      stableDestTokenRef.current = null
-      return null
-    }
-
-    // Create a key based on origin token identity (not balance)
-    const originTokenKey = `${originToken.symbol}-${originToken.chainId}-${originToken.contractAddress || "native"}`
-
-    // Only recalculate if origin token has actually changed
-    const shouldRecalculate =
-      originTokenKey !== lastOriginTokenKey.current ||
-      !stableDestTokenRef.current
-
-    if (!shouldRecalculate && stableDestTokenRef.current) {
-      return stableDestTokenRef.current
-    }
-
-    lastOriginTokenKey.current = originTokenKey
-
-    // Determine destination chain: Base if origin is not Base, Arbitrum if origin is Base
-    const defaultDestChainId =
-      originToken.chainId === base.id ? arbitrum.id : base.id
-
-    // Find USDC on destination chain first (preferred stable coin)
-    const usdcOnDestChain = supportedTokens.find(
-      (token: Token) =>
-        token.chainId === defaultDestChainId && token.symbol === "USDC",
-    )
-
-    let destToken: Token | null = null
-
-    if (usdcOnDestChain) {
-      destToken = usdcOnDestChain
-      logger.console.log(
-        "[trails-sdk] Selected USDC as destination token on chain:",
-        defaultDestChainId,
-      )
-    } else {
-      // Fallback: Find matching token on destination chain
-      const destChainTokens = supportedTokens.filter(
-        (token: Token) => token.chainId === defaultDestChainId,
-      )
-
-      // Try to find same symbol on destination chain first
-      const sameSymbolOnDestChain = destChainTokens.find((token: Token) => {
-        return token.symbol.toUpperCase() === originToken.symbol.toUpperCase()
-      })
-
-      if (sameSymbolOnDestChain) {
-        destToken = sameSymbolOnDestChain
-        logger.console.log(
-          "[trails-sdk] Selected same symbol token on destination chain:",
-          sameSymbolOnDestChain.symbol,
-        )
-      } else {
-        // Fallback: ETH on destination chain > first available token on destination chain
-        destToken =
-          destChainTokens.find((token: Token) => token.symbol === "ETH") ||
-          destChainTokens[0] ||
-          null
-
-        if (destToken) {
-          logger.console.log(
-            "[trails-sdk] Selected fallback token on destination chain:",
-            destToken.symbol,
-          )
-        }
-      }
-    }
-
-    if (!destToken) {
-      logger.console.log(
-        "[trails-sdk] No suitable destination token found on chain:",
-        defaultDestChainId,
-      )
-      return null
-    }
-
-    const decimals = destToken.decimals
-    if (!decimals) {
-      logger.console.warn(
-        "[trails-sdk] Missing decimals for destination token, skipping:",
-        destToken,
-      )
-      return null
-    }
-
-    // Try to find this token in user's balances to get the actual balance
-    const matchingUserToken = sortedTokens.find((t) => {
-      if (t.chainId !== destToken.chainId) return false
-
-      const isDestNative = destToken.isNativeToken ?? false
-      const isUserNative = t.isNativeToken ?? false
-
-      if (isDestNative && isUserNative) return true
-      if (isDestNative || isUserNative) return false
-
-      return (
-        t.contractAddress?.toLowerCase() ===
-        destToken.contractAddress?.toLowerCase()
-      )
-    })
-
-    const finalDestinationToken = {
-      ...destToken,
-      balance: matchingUserToken?.balance ?? "0",
-      balanceUsdFormatted: matchingUserToken?.balanceUsdFormatted ?? "0",
-      priceUsd: matchingUserToken?.priceUsd ?? 0,
-      decimals,
-    }
-
-    logger.console.log("[trails-sdk] Default destination token selection:", {
-      destination: {
-        symbol: finalDestinationToken.symbol,
-        chainId: finalDestinationToken.chainId,
-        hasUserBalance: !!matchingUserToken,
-        userBalanceUsd: matchingUserToken?.balanceUsdFormatted ?? "0",
-      },
-      originChain: originToken.chainId,
-      destinationChain: defaultDestChainId,
-    })
-
-    // Store the calculated result in ref for stability
-    stableDestTokenRef.current = finalDestinationToken
-
-    return finalDestinationToken
-  }, [originToken, supportedTokens, sortedTokens])
-
-  return {
-    defaultDestinationToken,
-    isLoading,
-  }
-}

package/src/widget/hooks/useDefaultOriginToken.tsx

@@ -1,407 +0,0 @@
-import { useMemo, useRef } from "react"
-import { useAccount } from "wagmi"
-import type { Address } from "ox"
-import { useWidgetProps } from "./useWidgetProps.js"
-import { useTargetAmount } from "./useTargetAmount.js"
-import { useTokenBalances } from "../../query/balance.hooks.js"
-import type { Token } from "../../tokens.js"
-import { getChainInfo } from "../../chains.js"
-import { isNativeToken } from "../../utils/address.js"
-import { logger } from "../../logger.js"
-import { zeroAddress } from "viem"
-
-const MINIMUM_24H_VOLUME_USD = 1_000_000 // $1M
-const MINIMUM_BALANCE_USD_FOR_PRIORITIZATION = 1 // $1
-
-function getToken24hVolume(_token: Token): number {
-  // Note: price24hVol is not in Token, so we return 0
-  // This can be added to Token later if needed
-  return 0
-}
-
-function tokenMatches(
-  token: Token,
-  targetSymbolOrAddress: string,
-  targetChainId?: number,
-): boolean {
-  const tokenChainId = token.chainId || 0
-  const tokenIsNative = token.isNativeToken ?? false
-  const contractAddress = token.contractAddress
-  const symbol = token.symbol
-
-  // Check chain match first
-  const chainMatches = !targetChainId || tokenChainId === targetChainId
-  if (!chainMatches) return false
-
-  // Check if target is an address (starts with 0x and is longer than 5 chars)
-  const isTargetAddress =
-    targetSymbolOrAddress.startsWith("0x") && targetSymbolOrAddress.length > 5
-
-  if (tokenIsNative) {
-    const chainInfo = getChainInfo(tokenChainId)
-    const nativeSymbol = chainInfo?.nativeCurrency.symbol || "Unknown"
-
-    // For native tokens, check if target is zero address or matches symbol
-    if (isTargetAddress) {
-      return isNativeToken(targetSymbolOrAddress)
-    }
-
-    return nativeSymbol.toUpperCase() === targetSymbolOrAddress.toUpperCase()
-  }
-
-  // For non-native tokens, check both address and symbol
-  if (isTargetAddress) {
-    return (
-      contractAddress?.toLowerCase() === targetSymbolOrAddress.toLowerCase()
-    )
-  }
-
-  return symbol?.toUpperCase() === targetSymbolOrAddress.toUpperCase()
-}
-
-/**
- * Hook for intelligent default origin token selection in 0xtrails widget.
- *
- * When toToken and toChainId are specified (user wants specific destination):
- * 1. Same-chain, same-token with balance >= targetAmountUsd (no swap, no bridge) - FASTEST
- * 2. Same-chain, different-token with balance >= targetAmountUsd (swap only) - FAST
- *    - Ordered by: 24h volume > $1M first, then highest balance USD
- * 3. Different-chain, same-token with balance >= targetAmountUsd (bridge only) - SLOWER
- *    - Ordered by: 24h volume > $1M first, then highest balance USD
- * 4. Different-chain, different-token with balance >= targetAmountUsd (swap + bridge) - SLOWEST
- *    - Ordered by: 24h volume > $1M first, then highest balance USD
- * 5. Fallback: Any token with balance > 0 if none can cover target amount
- *
- * When toToken/toChainId NOT specified (general send/bridge):
- * - Select highest balance token with 24h volume > $1M
- * - Fallback to any token with balance > 0
- *
- * @returns defaultOriginToken - Best origin token that can cover targetAmountUsd (if specified)
- * @returns isLoading - Whether token data is still loading
- */
-export function useDefaultOriginToken() {
-  const { toToken, toChainId, fromToken, fromChainId } = useWidgetProps()
-  const { targetAmountUsd } = useTargetAmount()
-  const { address } = useAccount()
-
-  const { sortedTokens, isLoadingSortedTokens } = useTokenBalances(
-    address as Address.Address,
-    undefined,
-    { refetchInterval: false },
-  )
-
-  const isLoading = isLoadingSortedTokens
-
-  // Use a ref to prevent unnecessary recalculations on balance-only updates
-  const stableTokenRef = useRef<Token | null>(null)
-  const lastTokenListKey = useRef<string>("")
-
-  const defaultOriginToken = useMemo(() => {
-    if (!sortedTokens?.length) {
-      stableTokenRef.current = null
-      return null
-    }
-
-    // Create a key based on available tokens (not their balances)
-    const tokenListKey = sortedTokens
-      .map((t) => `${t.symbol}-${t.chainId}-${t.contractAddress || "native"}`)
-      .join(",")
-
-    // Only recalculate if the token list has actually changed (not just balances)
-    // or if meaningful selection parameters have changed
-    const shouldRecalculate =
-      tokenListKey !== lastTokenListKey.current || !stableTokenRef.current
-
-    if (!shouldRecalculate && stableTokenRef.current) {
-      return stableTokenRef.current
-    }
-
-    lastTokenListKey.current = tokenListKey
-
-    // Helper to ensure Token has required properties set
-    const ensureToken = (token: Token): Token | null => {
-      const isNative = token.isNativeToken ?? false
-      const chainInfo = getChainInfo(token.chainId || 0)
-
-      if (isNative) {
-        // Native tokens - ensure chain info is set
-        const decimals = chainInfo?.nativeCurrency.decimals ?? 18
-
-        return {
-          ...token,
-          name: token.name || chainInfo?.nativeCurrency.name || "Unknown",
-          symbol: token.symbol || chainInfo?.nativeCurrency.symbol || "Unknown",
-          balance: token.balance ?? "0",
-          imageUrl: token.imageUrl || "",
-          chainId: token.chainId ?? 0,
-          contractAddress: zeroAddress,
-          balanceUsdFormatted: token.balanceUsdFormatted ?? "0",
-          priceUsd: token.priceUsd ?? 0,
-          decimals,
-          isNativeToken: true,
-        }
-      } else {
-        // Non-native tokens - ensure required properties are set
-        if (!token.decimals) {
-          logger.console.warn("[trails-sdk] Missing decimals for token:", {
-            symbol: token.symbol,
-            chainId: token.chainId,
-          })
-          return null // Return null instead of throwing
-        }
-
-        return {
-          ...token,
-          name: token.name ?? "Unknown Token",
-          symbol: token.symbol ?? "???",
-          balance: token.balance ?? "0",
-          imageUrl: token.imageUrl || "",
-          chainId: token.chainId ?? 0,
-          balanceUsdFormatted: token.balanceUsdFormatted ?? "0",
-          priceUsd: token.priceUsd ?? 0,
-        }
-      }
-    }
-
-    // First priority: Check if fromToken and fromChainId are specified
-    if (fromToken && fromChainId) {
-      const fromChainIdNum =
-        typeof fromChainId === "string" ? Number(fromChainId) : fromChainId
-      const matchingToken = sortedTokens.find((token) =>
-        tokenMatches(token, fromToken, fromChainIdNum),
-      )
-
-      if (matchingToken) {
-        logger.console.log(
-          "[trails-sdk] Found matching fromToken for default origin selection",
-          { symbol: matchingToken.symbol, chainId: matchingToken.chainId },
-        )
-        const ensured = ensureToken(matchingToken)
-        if (ensured) {
-          stableTokenRef.current = ensured
-          return ensured
-        }
-      }
-    }
-
-    // Filter tokens with balance > 0
-    const tokensWithBalance = sortedTokens.filter((token) => {
-      const balanceUsd = token.balanceUsd ?? 0
-      return balanceUsd > 0
-    })
-
-    if (tokensWithBalance.length === 0) {
-      logger.console.log(
-        "[trails-sdk] No tokens with balance found for default origin selection",
-      )
-      return null
-    }
-
-    // Helper to sort tokens by balance USD and volume
-    const sortTokensByBalanceAndVolume = (
-      tokens: Token[],
-      targetAmount?: number,
-    ) => {
-      const sortedTokens = [...tokens].sort((a, b) => {
-        const aVolume = getToken24hVolume(a)
-        const bVolume = getToken24hVolume(b)
-        const aHighVolume = aVolume >= MINIMUM_24H_VOLUME_USD
-        const bHighVolume = bVolume >= MINIMUM_24H_VOLUME_USD
-
-        // Prioritize high volume tokens first
-        if (aHighVolume && !bHighVolume) return -1
-        if (!aHighVolume && bHighVolume) return 1
-
-        // Then sort by balance USD (highest first)
-        const aBalanceUsd = a.balanceUsd ?? 0
-        const bBalanceUsd = b.balanceUsd ?? 0
-        return bBalanceUsd - aBalanceUsd
-      })
-
-      // After initial sorting, prioritize USDC and native tokens at the top
-      const effectiveTargetAmount =
-        targetAmount ?? MINIMUM_BALANCE_USD_FOR_PRIORITIZATION
-
-      const prioritizedTokens: Token[] = []
-      const remainingTokens: Token[] = []
-
-      // Separate tokens into prioritized and remaining
-      for (const token of sortedTokens) {
-        const balanceUsd = token.balanceUsd ?? 0
-        const isNative = token.isNativeToken ?? false
-        const isUSDC = !isNative && token.symbol?.toUpperCase() === "USDC"
-
-        if ((isUSDC || isNative) && balanceUsd >= effectiveTargetAmount) {
-          prioritizedTokens.push(token)
-        } else {
-          remainingTokens.push(token)
-        }
-      }
-
-      // Sort prioritized tokens: USDC first, then native tokens
-      prioritizedTokens.sort((a, b) => {
-        const aIsNative = a.isNativeToken ?? false
-        const bIsNative = b.isNativeToken ?? false
-        const aIsUSDC = !aIsNative && a.symbol?.toUpperCase() === "USDC"
-        const bIsUSDC = !bIsNative && b.symbol?.toUpperCase() === "USDC"
-
-        // USDC comes first
-        if (aIsUSDC && !bIsUSDC) return -1
-        if (!aIsUSDC && bIsUSDC) return 1
-
-        // Then native tokens
-        if (aIsNative && !bIsNative) return -1
-        if (!aIsNative && bIsNative) return 1
-
-        // Within same type, sort by balance USD (highest first)
-        const aBalanceUsd = a.balanceUsd ?? 0
-        const bBalanceUsd = b.balanceUsd ?? 0
-        return bBalanceUsd - aBalanceUsd
-      })
-
-      // Return prioritized tokens first, then remaining tokens
-      return [...prioritizedTokens, ...remainingTokens]
-    }
-
-    // Find the best origin token using intelligent selection
-    let bestOriginToken: Token | null = null
-
-    // When toToken and toChainId are specified (user wants specific destination)
-    if (toToken && toChainId) {
-      const targetChainId = Number(toChainId)
-
-      // Use targetAmountUsd if available, otherwise use a minimal threshold when toToken is set
-      const effectiveTargetAmount = targetAmountUsd ?? 0.01
-
-      // Filter tokens that can cover the target amount
-      const tokensWithSufficientBalance = tokensWithBalance.filter(
-        (token) => (token.balanceUsd ?? 0) >= effectiveTargetAmount,
-      )
-
-      // Priority 1: Same-chain, same-token (no swap, no bridge) - FASTEST
-      const sameChainSameToken = tokensWithSufficientBalance.find((token) =>
-        tokenMatches(token, toToken, targetChainId),
-      )
-
-      if (sameChainSameToken) {
-        bestOriginToken = sameChainSameToken
-        logger.console.log(
-          "[trails-sdk] Selected same-chain, same-token (fastest)",
-        )
-      }
-
-      // Priority 2: Same-chain, different-token (swap only, no bridge) - FAST
-      if (!bestOriginToken) {
-        const sameChainTokens = tokensWithSufficientBalance.filter(
-          (token) => token.chainId === targetChainId,
-        )
-        const sortedSameChain = sortTokensByBalanceAndVolume(
-          sameChainTokens,
-          effectiveTargetAmount,
-        )
-        bestOriginToken = sortedSameChain[0] ?? null
-        if (bestOriginToken) {
-          logger.console.log(
-            "[trails-sdk] Selected same-chain, different-token (fast)",
-          )
-        }
-      }
-
-      // Priority 3: Different-chain, same-token (bridge only, no swap) - SLOWER
-      if (!bestOriginToken) {
-        const sameTokenDiffChain = tokensWithSufficientBalance.filter(
-          (token) =>
-            tokenMatches(token, toToken) && token.chainId !== targetChainId,
-        )
-        const sortedSameToken = sortTokensByBalanceAndVolume(
-          sameTokenDiffChain,
-          effectiveTargetAmount,
-        )
-        bestOriginToken = sortedSameToken[0] ?? null
-        if (bestOriginToken) {
-          logger.console.log(
-            "[trails-sdk] Selected different-chain, same-token (slower)",
-          )
-        }
-      }
-
-      // Priority 4: Different-chain, different-token (swap + bridge) - SLOWEST
-      if (!bestOriginToken) {
-        const diffChainDiffToken = tokensWithSufficientBalance.filter(
-          (token) => token.chainId !== targetChainId,
-        )
-        const sortedDiffChainDiffToken = sortTokensByBalanceAndVolume(
-          diffChainDiffToken,
-          effectiveTargetAmount,
-        )
-        bestOriginToken = sortedDiffChainDiffToken[0] ?? null
-        if (bestOriginToken) {
-          logger.console.log(
-            "[trails-sdk] Selected different-chain, different-token (slowest)",
-          )
-        }
-      }
-
-      // Fallback: If no token can cover target amount, use any token (sorted by balance/volume)
-      if (!bestOriginToken) {
-        const allTokensSorted = sortTokensByBalanceAndVolume(
-          tokensWithBalance,
-          effectiveTargetAmount,
-        )
-        bestOriginToken = allTokensSorted[0] ?? null
-        logger.console.log(
-          "[trails-sdk] Fallback: No token can cover target amount, using highest balance token",
-        )
-      }
-    } else {
-      // When no specific destination is set, select highest value token with good liquidity
-      const sortedByBalanceAndVolume = sortTokensByBalanceAndVolume(
-        tokensWithBalance,
-        MINIMUM_BALANCE_USD_FOR_PRIORITIZATION,
-      )
-      bestOriginToken = sortedByBalanceAndVolume[0] ?? null
-      logger.console.log(
-        "[trails-sdk] No destination specified, selected highest value token with best liquidity",
-      )
-    }
-
-    if (!bestOriginToken) {
-      return null
-    }
-
-    const originToken = ensureToken(bestOriginToken)
-
-    logger.console.log("[trails-sdk] Default origin token selection:", {
-      origin: originToken
-        ? {
-            symbol: originToken.symbol,
-            chainId: originToken.chainId,
-            balanceUsd: originToken.balanceUsdFormatted,
-            volume24h: getToken24hVolume(bestOriginToken),
-          }
-        : null,
-      toToken,
-      toChainId,
-      targetAmountUsd,
-      effectiveTargetAmount:
-        toToken && toChainId ? (targetAmountUsd ?? 0.01) : null,
-    })
-
-    // Store the calculated result in ref for stability
-    stableTokenRef.current = originToken
-
-    return originToken
-  }, [
-    toToken,
-    toChainId,
-    sortedTokens,
-    targetAmountUsd,
-    fromToken,
-    fromChainId,
-  ])
-
-  return {
-    defaultOriginToken,
-    isLoading,
-  }
-}

package/src/widget/hooks/useDepositMonitor.ts

@@ -1,118 +0,0 @@
-import { useEffect, useState } from "react"
-import { SECOND_MS } from "../../utils/time.js"
-import { checkAccountBalance } from "../../transactionIntent/utils/balanceChecker.js"
-import { getChainRpcClient } from "../../chains.js"
-import type { Account } from "viem"
-import { logger } from "../../logger.js"
-export interface UseDepositMonitorParams {
-  chainId?: number
-  depositAddress?: string
-  tokenAddress?: string
-  requiredAmount?: string
-  enabled?: boolean
-}
-
-export interface UseDepositMonitorReturn {
-  hasSufficientDeposit: boolean
-  depositBalance: string | null
-  depositBalanceFormatted: string | null
-  percentageComplete: number
-}
-
-/**
- * Hook to monitor deposits at a specific address and check if sufficient balance is available.
- * Uses current balance only. External funding flows are committed/executed
- * before this hook is used, so monitoring is strictly for progress and UI state.
- */
-export function useDepositMonitor({
-  chainId,
-  depositAddress,
-  tokenAddress,
-  requiredAmount,
-  enabled = true,
-}: UseDepositMonitorParams): UseDepositMonitorReturn {
-  const [hasSufficientDeposit, setHasSufficientDeposit] = useState(false)
-  const [depositBalance, setDepositBalance] = useState<string | null>(null)
-  const [depositBalanceFormatted, setDepositBalanceFormatted] = useState<
-    string | null
-  >(null)
-  const [percentageComplete, setPercentageComplete] = useState(0)
-
-  useEffect(() => {
-    if (
-      !enabled ||
-      !chainId ||
-      !depositAddress ||
-      !tokenAddress ||
-      !requiredAmount
-    ) {
-      return
-    }
-
-    const checkBalance = async () => {
-      try {
-        const publicClient = getChainRpcClient(chainId)
-        if (!publicClient) {
-          logger.console.warn(
-            "[useDepositMonitor] No public client available for chain",
-            chainId,
-          )
-          return
-        }
-
-        const balanceCheck = await checkAccountBalance({
-          account: {
-            address: depositAddress as `0x${string}`,
-          } as Account,
-          tokenAddress,
-          depositAmount: requiredAmount,
-          publicClient,
-        })
-
-        setHasSufficientDeposit(balanceCheck.hasEnoughBalance)
-        setDepositBalance(balanceCheck.balance?.toString() || null)
-        setDepositBalanceFormatted(balanceCheck.balanceFormatted)
-
-        const percentage =
-          balanceCheck.balance && balanceCheck.requiredAmount
-            ? (Number(balanceCheck.balance) /
-                Number(balanceCheck.requiredAmount)) *
-              100
-            : 0
-        setPercentageComplete(Math.min(percentage, 100))
-
-        logger.console.log("[useDepositMonitor] Balance check result", {
-          depositAddress,
-          hasEnoughBalance: balanceCheck.hasEnoughBalance,
-          balance: balanceCheck.balanceFormatted,
-          required: balanceCheck.requiredAmountFormatted,
-          percentComplete: `${(
-            (Number(balanceCheck.balance) /
-              Number(balanceCheck.requiredAmount)) *
-              100
-          ).toFixed(2)}%`,
-        })
-      } catch (error) {
-        logger.console.error(
-          "[useDepositMonitor] Error checking balance",
-          error,
-        )
-      }
-    }
-
-    // Check balance immediately
-    checkBalance()
-
-    // Set up polling interval for balance checks
-    const interval = setInterval(checkBalance, 15 * SECOND_MS) // Check every 15 seconds
-
-    return () => clearInterval(interval)
-  }, [enabled, chainId, depositAddress, tokenAddress, requiredAmount])
-
-  return {
-    hasSufficientDeposit,
-    depositBalance,
-    depositBalanceFormatted,
-    percentageComplete,
-  }
-}