0xtrails 0.13.2 → 0.14.0

package/src/tokens.ts

@@ -1,1862 +0,0 @@
-import {
-  useQuery,
-  useQueryClient,
-  type QueryClient,
-} from "@tanstack/react-query"
-import { DAY_MS, retryDelay } from "./utils/time.js"
-import { queryPersister } from "./query/persister.js"
-import { erc20Abi, zeroAddress } from "viem"
-import { getChainInfo, getChainRpcClient } from "./chains.js"
-import {
-  arbitrum,
-  base,
-  optimism,
-  polygon,
-  mainnet,
-  avalanche,
-  gnosis,
-  zksync,
-  scroll,
-  blast,
-  sonic,
-  fantom,
-  hyperEvm,
-  ink,
-  katana,
-  berachain,
-  etherlink,
-  linea,
-  unichain,
-  worldchain,
-  bsc,
-  monad,
-} from "viem/chains"
-import { useReadContracts } from "wagmi"
-import { useMemo } from "react"
-import { logger } from "./logger.js"
-import {
-  addressEqual,
-  isNativeToken,
-  normalizeAddress,
-} from "./utils/address.js"
-import { somnia } from "./customChains.js"
-import { useTrails } from "./widget/providers/TrailsProvider.js"
-import { useCustomTokens } from "./customTokens.js"
-import { getTrailsClient } from "./trailsClient.js"
-import { formatBalanceFields, formatPriceFields } from "./utils/format.js"
-import { PROD_SEQUENCE_METADATA_URL } from "./constants.js"
-import { SequenceMetadata } from "@0xsequence/metadata"
-import { chainQueries } from "./query/chains.queries.js"
-import { tokenListQueries } from "./query/tokenList.queries.js"
-import { queryClient as defaultQueryClient } from "./query/client.js"
-
-// ApiTokenInfo type from trails-api (internal use only)
-interface ApiTokenInfo {
-  chainId: number
-  address: string
-  name: string
-  symbol: string
-  decimals: number
-  supportsBridging: boolean
-  logoUri?: string
-}
-
-/**
- * Unified token type for the Trails SDK.
- * This type replaces all previous token type variations (SupportedToken, TokenBalanceExtended, etc.)
- */
-export type Token = {
-  // Required properties
-  symbol: string
-  name: string
-  decimals: number
-  contractAddress: string // Use zeroAddress for native tokens
-
-  // Optional properties
-  tokenId?: string // For specific token IDs if applicable
-  chainId?: number
-  chainName?: string
-  imageUrl?: string
-  isCustomToken?: boolean // true when user inputted custom token address in search field
-  isSufficientBalance?: boolean
-  isNativeToken?: boolean
-
-  // Balance fields (raw → formatted → display)
-  balance?: string // Raw big number string (e.g., "1000000000000000000")
-  balanceFormatted?: string // Formatted number without commas (e.g., "1.0") US format
-  balanceDisplay?: string // Formatted number with commas (e.g., "1,000.00") US format
-  balanceLocaleDisplay?: string // Formatted with user's locale (e.g., "1.000,00" for DE locale)
-
-  // USD Balance fields
-  balanceUsd?: number // Raw number (e.g., 1000.50) US format
-  balanceUsdFormatted?: string // Formatted number without commas or currency symbol (e.g., "1000.50") US format
-  balanceUsdDisplay?: string // Formatted number with commas and currency symbol (e.g., "$1,000.50") US format
-  balanceUsdLocaleDisplay?: string // Formatted with user's locale (e.g., "1.000,50 $" for DE locale)
-
-  // Price fields (raw → formatted → display)
-  priceUsd?: number // Raw number (e.g., 1.50) US format
-  priceUsdFormatted?: string // Formatted number without commas or currency symbol (e.g., "1.50") US format
-  priceUsdDisplay?: string // Formatted number with commas and currency symbol (e.g., "$1.50") US format
-}
-
-// ============================================================================
-// Conversion Helper Functions
-// ============================================================================
-
-/**
- * Converts ApiTokenInfo (from trails-api) to Token
- */
-export function convertApiTokenInfoToToken(
-  tokenInfo: ApiTokenInfo,
-  options?: {
-    balance?: string
-    priceUsd?: number
-  },
-): Token {
-  const chainInfo = getChainInfo(tokenInfo.chainId)
-  const isNative = isNativeToken(tokenInfo.address) || !tokenInfo.address
-
-  const result: Token = {
-    symbol: tokenInfo.symbol,
-    name: tokenInfo.name,
-    decimals: tokenInfo.decimals,
-    contractAddress: tokenInfo.address,
-    tokenId: `${tokenInfo.symbol}-${chainInfo?.name || `chain-${tokenInfo.chainId}`}`, // Generate tokenId
-    chainId: tokenInfo.chainId,
-    chainName: chainInfo?.name || `Chain ${tokenInfo.chainId}`,
-    imageUrl:
-      tokenInfo.logoUri ||
-      getTokenImageUrl({
-        chainId: tokenInfo.chainId,
-        contractAddress: tokenInfo.address,
-        symbol: tokenInfo.symbol,
-      }),
-    isNativeToken: isNative,
-  }
-
-  // Format balance if provided
-  if (options?.balance) {
-    const balanceFields = formatBalanceFields(
-      options.balance,
-      tokenInfo.decimals,
-    )
-    result.balance = balanceFields.balance
-    result.balanceFormatted = balanceFields.balanceFormatted
-    result.balanceDisplay = balanceFields.balanceDisplay
-  }
-
-  // Format price if provided
-  if (options?.priceUsd !== undefined) {
-    const priceFields = formatPriceFields(options.priceUsd)
-    result.priceUsd = priceFields.priceUsd
-    result.priceUsdFormatted = priceFields.priceUsdFormatted
-    result.priceUsdDisplay = priceFields.priceUsdDisplay
-  }
-
-  return result
-}
-
-export const commonTokenImages: Record<string, string> = {
-  ETH: "https://assets.sequence.info/images/tokens/large/1/0x0000000000000000000000000000000000000000.webp",
-  WETH: "https://assets.sequence.info/images/tokens/large/1/0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2.webp",
-  POL: "https://assets.sequence.info/images/tokens/large/137/0x0000000000000000000000000000000000000000.webp",
-  MATIC:
-    "https://assets.sequence.info/images/tokens/large/137/0x0000000000000000000000000000000000000000.webp",
-  USDC: "https://assets.sequence.info/images/tokens/large/1/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.webp",
-  USDT: "https://assets.sequence.info/images/tokens/large/1/0xdac17f958d2ee523a2206206994597c13d831ec7.webp",
-  DAI: "https://assets.sequence.info/images/tokens/large/1/0x6b175474e89094c44da98b954eedeac495271d0f.webp",
-  WBTC: "https://assets.sequence.info/images/tokens/large/1/0x2260fac5e5542a773aa44fbcfedf7c193bc2c599.webp",
-  BAT: "https://assets.sequence.info/images/tokens/large/1/0x0d8775f648430679a709e98d2b0cb6250d2887ef.webp",
-  ARB: "https://assets.sequence.info/images/tokens/large/42161/0x912ce59144191c1204e64559fe8253a0e49e6548.webp",
-  LINK: "https://assets.sequence.info/images/tokens/large/1/0x514910771af9ca656af840dff83e8264ecf986ca.webp",
-  XTZ: "https://assets.sequence.info/images/tokens/large/42793/0x0000000000000000000000000000000000000000.webp",
-  BNB: "https://assets.sequence.info/images/tokens/large/56/0x0000000000000000000000000000000000000000.webp",
-  WXTZ: "https://assets.coingecko.com/coins/images/976/standard/Tezos-logo.png?1696502091",
-  SOMI: "https://assets.sequence.info/images/tokens/large/5031/0x0000000000000000000000000000000000000000.webp",
-  XAI: "https://assets.coingecko.com/coins/images/34258/large/round_icon_2048_px.png?1719523838",
-  APE: "https://assets.sequence.info/images/tokens/large/33139/0x0000000000000000000000000000000000000000.webp",
-  ANIME:
-    "https://assets.coingecko.com/coins/images/53575/large/anime.jpg?1736748703",
-  AVAX: "https://assets.sequence.info/images/tokens/large/43114/0x0000000000000000000000000000000000000000.webp",
-  MON: "https://assets.sequence.info/images/tokens/large/143/0x0000000000000000000000000000000000000000.webp",
-  USDT0:
-    "https://assets.coingecko.com/coins/images/53705/standard/usdt0.jpg?1737086183",
-  AUSD: "https://assets.coingecko.com/coins/images/39284/standard/Circle_Agora_White_on_Olive_1080px.png?1722961274",
-}
-
-const cacheVersion = "01"
-
-// LocalStorage cache utilities for token images
-const TOKEN_IMAGE_CACHE_KEY = `trails-sdk:token-image-cache:${cacheVersion}`
-const TOKEN_IMAGE_CACHE_EXPIRY = 7 * DAY_MS // 7 days
-
-interface TokenImageCacheEntry {
-  imageUrl: string
-  timestamp: number
-  found: boolean
-}
-
-// Token info cache utilities
-const TOKEN_INFO_CACHE_KEY = `trails-sdk:token-info-cache:${cacheVersion}`
-const TOKEN_INFO_CACHE_EXPIRY = DAY_MS
-
-// Cache entry matches Token structure (without optional fields)
-interface TokenInfoCacheEntry {
-  tokenId?: string
-  symbol: string
-  name: string
-  contractAddress: string
-  decimals: number
-  chainId: number
-  chainName?: string
-  imageUrl?: string
-  isNativeToken?: boolean
-  isCustomToken?: boolean
-  timestamp: number
-}
-
-// In-memory token info cache
-const tokenInfoCache = new Map<string, TokenInfoCacheEntry>()
-
-function getTokenInfoCache(): Record<string, TokenInfoCacheEntry> {
-  if (typeof window === "undefined") return {}
-
-  try {
-    const cached = localStorage.getItem(TOKEN_INFO_CACHE_KEY)
-    if (!cached) return {}
-
-    const parsed = JSON.parse(cached) as Record<string, TokenInfoCacheEntry>
-    const now = Date.now()
-
-    // Clean up expired entries
-    const validEntries = Object.entries(parsed).filter(([_, entry]) => {
-      return now - entry.timestamp < TOKEN_INFO_CACHE_EXPIRY
-    })
-
-    return Object.fromEntries(validEntries) as Record<
-      string,
-      TokenInfoCacheEntry
-    >
-  } catch {
-    return {}
-  }
-}
-
-function setTokenInfoCache(key: string, tokenInfo: Token): void {
-  if (typeof window === "undefined") return
-
-  try {
-    const cache = getTokenInfoCache()
-    // Ensure chainId is required for cache entry
-    if (!tokenInfo.chainId) {
-      logger.console.warn(
-        "[trails-sdk] Cannot cache token without chainId:",
-        tokenInfo,
-      )
-      return
-    }
-    const cacheEntry: TokenInfoCacheEntry = {
-      tokenId: tokenInfo.tokenId,
-      symbol: tokenInfo.symbol,
-      name: tokenInfo.name,
-      contractAddress: tokenInfo.contractAddress,
-      decimals: tokenInfo.decimals,
-      chainId: tokenInfo.chainId,
-      chainName: tokenInfo.chainName,
-      imageUrl: tokenInfo.imageUrl,
-      isNativeToken: tokenInfo.isNativeToken,
-      isCustomToken: tokenInfo.isCustomToken,
-      timestamp: Date.now(),
-    }
-    cache[key] = cacheEntry
-    localStorage.setItem(TOKEN_INFO_CACHE_KEY, JSON.stringify(cache))
-
-    // Also update in-memory cache
-    tokenInfoCache.set(key, cacheEntry)
-  } catch (error) {
-    logger.console.warn("[trails-sdk] Failed to cache token info:", error)
-  }
-}
-
-function getCachedTokenInfo(
-  chainId: number,
-  contractAddress: string,
-): Token | null {
-  const key = `${chainId}:${normalizeAddress(contractAddress)}`
-
-  // Check in-memory cache first
-  const memoryEntry = tokenInfoCache.get(key)
-  if (memoryEntry) {
-    // Convert cache entry to Token
-    return {
-      symbol: memoryEntry.symbol,
-      name: memoryEntry.name,
-      decimals: memoryEntry.decimals,
-      contractAddress: memoryEntry.contractAddress,
-      tokenId: memoryEntry.tokenId,
-      chainId: memoryEntry.chainId,
-      chainName: memoryEntry.chainName,
-      imageUrl: memoryEntry.imageUrl,
-      isNativeToken: memoryEntry.isNativeToken,
-      isCustomToken: memoryEntry.isCustomToken,
-    }
-  }
-
-  // Check localStorage cache
-  const cache = getTokenInfoCache()
-  const cachedEntry = cache[key]
-  if (cachedEntry) {
-    // Update in-memory cache
-    tokenInfoCache.set(key, cachedEntry)
-    // Convert cache entry to Token
-    return {
-      symbol: cachedEntry.symbol,
-      name: cachedEntry.name,
-      decimals: cachedEntry.decimals,
-      contractAddress: cachedEntry.contractAddress,
-      tokenId: cachedEntry.tokenId,
-      chainId: cachedEntry.chainId,
-      chainName: cachedEntry.chainName,
-      imageUrl: cachedEntry.imageUrl,
-      isNativeToken: cachedEntry.isNativeToken,
-      isCustomToken: cachedEntry.isCustomToken,
-    }
-  }
-
-  return null
-}
-
-function getTokenImageCache(): Record<string, TokenImageCacheEntry> {
-  if (typeof window === "undefined") return {}
-
-  try {
-    const cached = localStorage.getItem(TOKEN_IMAGE_CACHE_KEY)
-    if (!cached) return {}
-
-    const parsed = JSON.parse(cached) as Record<string, TokenImageCacheEntry>
-    const now = Date.now()
-
-    // Clean up expired entries
-    const validEntries = Object.entries(parsed).filter(([_, entry]) => {
-      return now - entry.timestamp < TOKEN_IMAGE_CACHE_EXPIRY
-    })
-
-    return Object.fromEntries(validEntries) as Record<
-      string,
-      TokenImageCacheEntry
-    >
-  } catch {
-    return {}
-  }
-}
-
-// Priority tokens that should appear first in the list
-const PRIORITY_TOKENS = [
-  "ETH",
-  "WETH",
-  "AVAX",
-  "WAVAX",
-  "xDAI",
-  "POL",
-  "USDC",
-  "USDT",
-  "DAI",
-  "MATIC",
-  "ARB",
-  "OP",
-  "BAT",
-  "WBTC",
-  "cbBTC",
-  "XAI",
-]
-
-// Sort function for tokens with the specified priority order
-function sortTokens(tokens: Token[]): Token[] {
-  return tokens.sort((a, b) => {
-    // 1. Priority tokens first (ETH, USDC, USDT, DAI)
-    const aPriority = PRIORITY_TOKENS.indexOf(a.symbol)
-    const bPriority = PRIORITY_TOKENS.indexOf(b.symbol)
-
-    // If both are priority tokens, sort by priority order
-    if (aPriority !== -1 && bPriority !== -1) {
-      return aPriority - bPriority
-    }
-
-    // If only one is a priority token, prioritize it
-    if (aPriority !== -1) return -1
-    if (bPriority !== -1) return 1
-
-    // 2. Tokens with imageUrl before those without
-    const aHasImage = !!a.imageUrl
-    const bHasImage = !!b.imageUrl
-
-    if (aHasImage && !bHasImage) return -1
-    if (!aHasImage && bHasImage) return 1
-
-    // 3. Alphabetical by symbol
-    const symbolComparison = a.symbol.localeCompare(b.symbol)
-    if (symbolComparison !== 0) {
-      return symbolComparison
-    }
-
-    // 4. If symbols are the same, sort by chainName
-    const aChainName = a.chainName || ""
-    const bChainName = b.chainName || ""
-    return aChainName.localeCompare(bChainName)
-  })
-}
-
-export function getCachedTokenImageUrl(
-  chainId: number,
-  contractAddress: string,
-  symbol: string,
-) {
-  const cacheKey = `${chainId}:${contractAddress}:${symbol}`
-  const cache = getTokenImageCache()
-  const cachedEntry = cache[cacheKey]
-  return cachedEntry?.imageUrl || ""
-}
-
-export async function getSupportedTokens(config: {
-  trailsApiKey: string
-  trailsApiUrl: string
-  queryClient?: QueryClient
-}): Promise<Token[]> {
-  const effectiveQueryClient = config.queryClient ?? defaultQueryClient
-  const chains = await effectiveQueryClient.ensureQueryData(
-    chainQueries.supported({
-      trailsApiUrl: config.trailsApiUrl,
-      trailsApiKey: config.trailsApiKey,
-    }),
-  )
-  const chainIds = chains.map((chain) => chain.id)
-
-  // Get trails client using provided config
-  const trailsClient = getTrailsClient({
-    apiKey: config.trailsApiKey || "",
-    hostname: config.trailsApiUrl,
-  })
-
-  // Fetch tokens from trails-api using getTokenList
-  // This is the new endpoint that replaces getFeaturedTokens
-  // It uses go-tokendirectory to fetch efficiently and cache data from token-directory
-  // includeAllListed: true returns all tokens in the index (except external) even if not featured
-  // Featured tokens are always included and sorted at the top
-  let apiTokens: Token[] = []
-  try {
-    if (config.trailsApiKey && trailsClient) {
-      // Use getTokenList to get tokens for the specified chains
-      // includeAllListed: true includes all tokens in the index, not just featured
-      // The API applies limit per chain, and lists are sorted, normalized, and deduped
-      // When filtering by a single chain, use limit of 100, otherwise use 30 per chain
-      // Type assertion needed because TrailsClient extends TrailsApi which has these methods
-      const limit = chainIds.length === 1 ? 100 : 30
-      const tokenListResponse =
-        chainIds.length > 0
-          ? await effectiveQueryClient.ensureQueryData(
-              tokenListQueries.catalog(
-                trailsClient,
-                {
-                  trailsApiUrl: config.trailsApiUrl,
-                  trailsApiKey: config.trailsApiKey,
-                },
-                {
-                  chainIds,
-                  includeAllListed: true,
-                  limit,
-                },
-              ),
-            )
-          : { tokens: [] }
-
-      // The API already handles sorting (featured first, then alphabetically) and deduplication
-      // Map ApiTokenInfo from API to Token format using conversion helper
-      apiTokens = (tokenListResponse.tokens || []).map((tokenInfo: any) => {
-        const chainInfo = getChainInfo(tokenInfo.chainId)
-        const tokenId = `${tokenInfo.symbol}-${chainInfo?.name || `chain-${tokenInfo.chainId}`}`
-        const trailsToken = convertApiTokenInfoToToken(tokenInfo, {
-          // No balance or price data from getTokenList
-        })
-        // Set tokenId for consistency
-        trailsToken.tokenId = tokenId
-        return trailsToken
-      })
-    }
-  } catch (error) {
-    logger.console.warn(
-      "[trails-sdk] Error fetching tokens from trails-api:",
-      error,
-    )
-    // Continue with empty apiTokens - will fall back to commonTokens
-    apiTokens = []
-  }
-
-  // Ensure imageUrl is set for all tokens
-  for (const token of apiTokens) {
-    if (!token.imageUrl) {
-      token.imageUrl = getTokenImageUrl({
-        chainId: token.chainId || 0,
-        contractAddress: token.contractAddress,
-        symbol: token.symbol,
-      })
-    }
-
-    // Use getTokenImageUrl directly (synchronous)
-    const imageUrl = getTokenImageUrl({
-      chainId: token.chainId || 0,
-      contractAddress: token.contractAddress,
-      symbol: token.symbol,
-    })
-    if (imageUrl) {
-      token.imageUrl = imageUrl
-    }
-  }
-
-  // Add common tokens that don't exist in API tokens
-  const additionalTokens: Token[] = []
-  for (const commonToken of commonTokens) {
-    const contractAddress = commonToken.contractAddress
-    const exists = apiTokens.some(
-      (t) =>
-        t.chainId === commonToken.chainId &&
-        addressEqual(t.contractAddress, contractAddress),
-    )
-    if (!exists) {
-      // commonTokens is now Token[], so we can use it directly
-      additionalTokens.push(commonToken)
-    }
-  }
-
-  const allTokens = [...apiTokens, ...additionalTokens]
-
-  // Filter to only include tokens from supported sequence chains
-  const supportedChainTokens = allTokens.filter((token) => {
-    // Always include Etherlink tokens
-    if (token.chainId === etherlink.id) {
-      return true
-    }
-    // Filter by sequence chains
-    return token.chainId && chainIds.includes(token.chainId)
-  })
-
-  // Remove duplicates
-  const uniqueTokens = supportedChainTokens.filter(
-    (token, index, self) =>
-      index ===
-      self.findIndex(
-        (t) =>
-          t.chainId === token.chainId &&
-          addressEqual(t.contractAddress, token.contractAddress),
-      ),
-  )
-
-  // Sort tokens according to priority order
-  const sortedTokens = sortTokens(uniqueTokens)
-
-  return sortedTokens
-}
-
-const EMPTY_TOKENS: Token[] = []
-
-export function useSupportedTokens({
-  chainId,
-  disabled = false,
-}: {
-  chainId?: number
-  disabled?: boolean
-} = {}): {
-  supportedTokens: Token[]
-  isLoadingTokens: boolean
-} {
-  const { customTokens } = useCustomTokens()
-  const trailsConfig = useTrails()
-  const queryClient = useQueryClient()
-  const { data: supportedTokens = EMPTY_TOKENS, isLoading: isLoadingTokens } =
-    useQuery({
-      queryKey: ["supportedTokens"],
-      queryFn: async () => {
-        return getSupportedTokens({
-          trailsApiKey: trailsConfig.trailsApiKey,
-          trailsApiUrl: trailsConfig.trailsApiUrl,
-          queryClient,
-        })
-      },
-      staleTime: DAY_MS,
-      gcTime: DAY_MS,
-      refetchOnMount: false,
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false,
-      enabled: !disabled,
-      persister: queryPersister.persisterFn,
-    })
-
-  // Merge custom tokens with supported tokens
-  // Only add custom tokens that don't already exist in supported tokens
-  const mergedTokens = useMemo(() => {
-    const tokenMap = new Map<string, Token>()
-
-    // Add regular supported tokens first
-    supportedTokens.forEach((token) => {
-      const key = `${token.chainId}-${normalizeAddress(token.contractAddress)}`
-      tokenMap.set(key, token)
-    })
-
-    // Only add custom tokens that don't already exist in supported tokens
-    // customTokens is already Token[]
-    customTokens.forEach((token) => {
-      const key = `${token.chainId || 0}-${normalizeAddress(token.contractAddress)}`
-      // Only add if it doesn't already exist (supported tokens take precedence)
-      if (!tokenMap.has(key)) {
-        tokenMap.set(key, token)
-      }
-    })
-
-    return Array.from(tokenMap.values())
-  }, [supportedTokens, customTokens])
-
-  const filteredTokens = useMemo(() => {
-    if (!chainId) {
-      return mergedTokens
-    }
-    return mergedTokens.filter((token) => token.chainId === chainId)
-  }, [mergedTokens, chainId])
-
-  return {
-    supportedTokens: filteredTokens || EMPTY_TOKENS,
-    isLoadingTokens,
-  }
-}
-
-const tokenNames: Record<string, string> = {
-  ETH: "Ethereum",
-  WETH: "Wrapped ETH",
-  USDC: "USDC",
-  USDT: "Tether",
-  DAI: "Dai Stablecoin",
-  OP: "Optimism",
-  ARB: "Arbitrum",
-  POL: "POL",
-  MATIC: "Matic Token",
-  BAT: "Basic Attention Token",
-}
-
-export const tokensToPrefix: Record<string, string> = {
-  USDC: "USDC",
-  ETH: "ETH",
-  POL: "POL",
-}
-
-export const tokenNamePrefixes: Record<string, string> = {
-  [optimism.id]: "Optimistic",
-  [arbitrum.id]: "Arbitrum",
-  [polygon.id]: "Polygon",
-  [etherlink.id]: "Etherlink",
-}
-
-export function getFormatttedTokenName(
-  currentName: string,
-  tokenSymbol: string,
-  chainId?: number,
-): string {
-  let name = tokenNames[tokenSymbol] || currentName || tokenSymbol
-  if (chainId) {
-    try {
-      const chainInfo = getChainInfo(chainId)
-      if (chainInfo) {
-        if (tokensToPrefix[tokenSymbol]) {
-          if (chainId !== mainnet.id) {
-            name = `${chainInfo?.name} ${tokenSymbol}`
-          }
-          const prefix = tokenNamePrefixes[chainId]
-          if (prefix) {
-            name = `${prefix} ${tokenSymbol}`
-          }
-        }
-      }
-    } catch (e) {
-      logger.console.error("[trails-sdk] Error getting chain info:", e)
-    }
-  }
-  return name
-}
-
-export async function getTokenInfo(
-  chainId: number,
-  contractAddress: string,
-  config: {
-    trailsApiKey: string
-    trailsApiUrl: string
-    sequenceMetadataUrl: string
-    queryClient?: QueryClient
-  },
-): Promise<Token | null> {
-  const normalizedAddress = normalizeAddress(contractAddress)
-
-  // Check cache first
-  const cachedInfo = getCachedTokenInfo(chainId, normalizedAddress)
-  if (cachedInfo) {
-    return cachedInfo
-  }
-
-  // Get chain info first (used in multiple places)
-  const chainInfo = getChainInfo(chainId)
-  if (!chainInfo) {
-    logger.console.warn(
-      `[trails-sdk] Chain info not found for chainId: ${chainId}`,
-    )
-    return null
-  }
-
-  // Check if it's a native token
-  if (isNativeToken(normalizedAddress)) {
-    const decimals = chainInfo.nativeCurrency.decimals ?? 18
-    const symbol = chainInfo.nativeCurrency.symbol || "Unknown"
-    const nativeToken: Token = {
-      tokenId: `${symbol}-${chainInfo.name || "Unknown"}`,
-      symbol,
-      name: chainInfo.nativeCurrency.name || "Unknown",
-      contractAddress: zeroAddress,
-      decimals,
-      chainId,
-      chainName: chainInfo.name || "Unknown",
-      // Use getTokenImageUrl for consistency
-      imageUrl: getTokenImageUrl({
-        chainId,
-        contractAddress: zeroAddress,
-        symbol,
-      }),
-      isNativeToken: true,
-    }
-
-    // Cache the native token info
-    setTokenInfoCache(`${chainId}:${normalizedAddress}`, nativeToken)
-
-    return nativeToken
-  }
-
-  // Look in supported tokens
-  const tokens = await getSupportedTokens({
-    trailsApiKey: config.trailsApiKey,
-    trailsApiUrl: config.trailsApiUrl,
-    queryClient: config.queryClient,
-  })
-  const token = tokens.find(
-    (t) =>
-      t.chainId === chainId &&
-      t.contractAddress.toLowerCase() === normalizedAddress,
-  )
-
-  if (token) {
-    // Always use getTokenImageUrl for consistency
-    token.imageUrl = getTokenImageUrl({
-      chainId,
-      contractAddress: normalizedAddress,
-      symbol: token.symbol,
-    })
-
-    // Cache the token info
-    setTokenInfoCache(`${chainId}:${normalizedAddress}`, token)
-
-    return token
-  }
-
-  // If not found in supported tokens, try Sequence metadata service first
-  try {
-    const metadataClient = new SequenceMetadata(
-      config.sequenceMetadataUrl,
-      config.trailsApiKey,
-    )
-    const { contractInfo } = await metadataClient.getContractInfo({
-      chainID: String(chainId),
-      contractAddress: normalizedAddress,
-    })
-
-    // Only return token info if it's deployed (actually an ERC20 contract)
-    if (contractInfo.deployed !== true) {
-      throw new Error(
-        `Token at ${normalizedAddress} on chain ${chainId} is not deployed`,
-      )
-    }
-
-    if (contractInfo.decimals == null) {
-      throw new Error(
-        `Token at ${normalizedAddress} on chain ${chainId} has no decimals`,
-      )
-    }
-
-    // Build token from metadata service
-    const metadataToken: Token = {
-      tokenId: `${contractInfo.symbol}-${chainInfo.name}`,
-      name: contractInfo.name,
-      symbol: contractInfo.symbol,
-      decimals: contractInfo.decimals,
-      chainId: chainId,
-      contractAddress: normalizedAddress,
-      chainName: chainInfo.name,
-      // Use getTokenImageUrl for consistency
-      imageUrl: getTokenImageUrl({
-        chainId,
-        contractAddress: normalizedAddress,
-        symbol: contractInfo.symbol,
-      }),
-      isCustomToken: true,
-    }
-
-    // Cache the token info
-    setTokenInfoCache(`${chainId}:${normalizedAddress}`, metadataToken)
-
-    logger.console.log(
-      "[trails-sdk] Fetched token info from metadata service:",
-      metadataToken,
-    )
-
-    return metadataToken
-  } catch (error) {
-    logger.console.warn(
-      "[trails-sdk] Metadata service failed, falling back to on-chain:",
-      error,
-    )
-  }
-
-  // Fallback to on-chain data if metadata service fails
-  try {
-    // Create a public client for the specific chain
-    const publicClient = getChainRpcClient(chainId)
-
-    // Read token data on-chain
-    const [name, symbol, decimals] = await Promise.all([
-      publicClient.readContract({
-        address: normalizedAddress as `0x${string}`,
-        abi: erc20Abi,
-        functionName: "name",
-      }),
-      publicClient.readContract({
-        address: normalizedAddress as `0x${string}`,
-        abi: erc20Abi,
-        functionName: "symbol",
-      }),
-      publicClient.readContract({
-        address: normalizedAddress as `0x${string}`,
-        abi: erc20Abi,
-        functionName: "decimals",
-      }),
-    ])
-
-    // Create token info from on-chain data
-    const onChainToken: Token = {
-      tokenId: `${symbol}-${chainInfo.name}`,
-      name: name,
-      symbol: symbol,
-      decimals: decimals,
-      chainId: chainId,
-      contractAddress: normalizedAddress,
-      chainName: chainInfo.name,
-      imageUrl: getTokenImageUrl({
-        chainId,
-        contractAddress: normalizedAddress,
-        symbol: symbol,
-      }),
-      isCustomToken: true,
-    }
-
-    // Cache the on-chain token info
-    setTokenInfoCache(`${chainId}:${normalizedAddress}`, onChainToken)
-
-    logger.console.log(
-      "[trails-sdk] Fetched token info on-chain:",
-      onChainToken,
-    )
-
-    return onChainToken
-  } catch (error) {
-    logger.console.error(
-      "[trails-sdk] Error fetching on-chain token info:",
-      error,
-    )
-    return null
-  }
-}
-
-/**
- * Search for a token by contract address across all chains using the
- * Sequence Metadata findContractInfo endpoint. Returns one Token per
- * chain where the contract is deployed with valid ERC-20 metadata.
- */
-export async function searchTokenByAddress(
-  contractAddress: string,
-  config: {
-    sequenceMetadataUrl: string
-    trailsApiKey: string
-  },
-): Promise<Token[]> {
-  const normalizedAddress = normalizeAddress(contractAddress)
-
-  const metadataClient = new SequenceMetadata(
-    config.sequenceMetadataUrl,
-    config.trailsApiKey,
-  )
-
-  const { contractInfoList } = await metadataClient.findContractInfo({
-    contractAddress: normalizedAddress,
-  })
-
-  return (contractInfoList || [])
-    .filter(
-      (info) =>
-        info.deployed === true && info.decimals != null && info.decimals > 0,
-    )
-    .map((info): Token => {
-      const addr = normalizeAddress(info.address)
-      const chainInfo = getChainInfo(info.chainId)
-      const token: Token = {
-        tokenId: `${info.symbol}-${chainInfo?.name || `chain-${info.chainId}`}`,
-        symbol: info.symbol,
-        name: info.name,
-        decimals: info.decimals!,
-        chainId: info.chainId,
-        contractAddress: addr,
-        chainName: chainInfo?.name || `Chain ${info.chainId}`,
-        imageUrl:
-          info.logoURI ||
-          getTokenImageUrl({
-            chainId: info.chainId,
-            contractAddress: addr,
-            symbol: info.symbol,
-          }),
-        isCustomToken: true,
-      }
-
-      setTokenInfoCache(`${info.chainId}:${addr}`, token)
-      return token
-    })
-}
-
-// Mapping of hyphenated symbols to their canonical token symbols.
-// The Sequence API returns BNB-USD, but we want to use USDT instead.
-const HYPHENATED_SYMBOL_MAP: Record<string, string> = {
-  "BNB-USD": "USDT",
-}
-
-export async function getTokenAddress(
-  chainId: number,
-  tokenSymbol: string,
-  config: {
-    trailsApiKey: string
-    trailsApiUrl: string
-    queryClient?: QueryClient
-  },
-) {
-  const chainInfo = getChainInfo(chainId)
-  // Normalize token symbol: trim whitespace and convert to uppercase for comparison
-  const normalizedTokenSymbol = tokenSymbol.trim().toUpperCase()
-
-  const nativeSymbol = (chainInfo as any)?.nativeCurrency?.symbol
-  if (nativeSymbol && normalizedTokenSymbol === nativeSymbol.toUpperCase()) {
-    return zeroAddress
-  }
-
-  const tokens = await getSupportedTokens(config)
-
-  // First try exact match (normalized)
-  let token = tokens.find(
-    (t) =>
-      t.symbol.trim().toUpperCase() === normalizedTokenSymbol &&
-      t.chainId === chainId,
-  )
-
-  // If not found, check if it's a hyphenated symbol that maps to another symbol
-  if (!token) {
-    const mappedSymbol = HYPHENATED_SYMBOL_MAP[normalizedTokenSymbol]
-    if (mappedSymbol) {
-      token = tokens.find(
-        (t) =>
-          t.symbol.trim().toUpperCase() === mappedSymbol.toUpperCase() &&
-          t.chainId === chainId,
-      )
-    }
-  }
-
-  if (token?.contractAddress) {
-    return token.contractAddress
-  }
-
-  throw new Error(
-    `Unsupported token symbol: ${tokenSymbol} for chainId: ${chainId}`,
-  )
-}
-
-type UseTokenAddressProps = {
-  chainId?: number | null
-  tokenSymbol?: string | null
-}
-
-export function useTokenAddress({
-  chainId,
-  tokenSymbol,
-}: UseTokenAddressProps) {
-  const trailsConfig = useTrails()
-  const queryClient = useQueryClient()
-  const { data: tokenAddress } = useQuery({
-    queryKey: ["tokenAddress", chainId, tokenSymbol],
-    queryFn: () =>
-      chainId && tokenSymbol
-        ? getTokenAddress(chainId, tokenSymbol, {
-            trailsApiKey: trailsConfig.trailsApiKey,
-            trailsApiUrl: trailsConfig.trailsApiUrl,
-            queryClient,
-          })
-        : null,
-    enabled: !!chainId && !!tokenSymbol,
-    staleTime: DAY_MS,
-    gcTime: DAY_MS,
-    refetchOnMount: false, // Don't refetch when cached data exists (persistence-friendly)
-    refetchOnWindowFocus: false, // Don't refetch when window regains focus
-    refetchOnReconnect: false, // Don't refetch on network reconnect
-    persister: queryPersister.persisterFn,
-  })
-
-  return tokenAddress || null
-}
-
-export function getCommonTokenImageUrl({
-  symbol,
-  contractAddress,
-  chainId,
-}: {
-  symbol?: string | null
-  contractAddress?: string | null
-  chainId?: number | null
-}) {
-  // If symbol is provided, try to get image from it directly
-  if (symbol) {
-    const symbolKey = tokenImageSymbolMap[symbol] ?? symbol
-    if (commonTokenImages[symbolKey]) {
-      return commonTokenImages[symbolKey]
-    }
-  }
-
-  // If we have contractAddress and chainId, try to look up the token
-  if (contractAddress && chainId) {
-    const token = commonTokens.find(
-      (t) =>
-        t.chainId === chainId &&
-        addressEqual(t.contractAddress, contractAddress),
-    )
-    if (token) {
-      const symbolKey = tokenImageSymbolMap[token.symbol] ?? token.symbol
-      if (commonTokenImages[symbolKey]) {
-        return commonTokenImages[symbolKey]
-      }
-    }
-  }
-
-  return ""
-}
-
-// Utility function to build Sequence metadata token image URL
-export function getSequenceMetadataTokenImageUrl({
-  chainId,
-  contractAddress,
-  fallbackImageUrl,
-  sequenceMetadataUrl,
-}: {
-  chainId: number
-  contractAddress: string
-  fallbackImageUrl?: string
-  sequenceMetadataUrl?: string
-}) {
-  const baseUrl = sequenceMetadataUrl || PROD_SEQUENCE_METADATA_URL
-  const fallbackParam = fallbackImageUrl
-    ? `?fallback=${encodeURIComponent(fallbackImageUrl)}`
-    : "?happy=true"
-  const imageUrl = `${baseUrl}/tokens/${chainId}/${normalizeAddress(contractAddress)}/image${fallbackParam}`
-  return imageUrl
-}
-
-export function getTokenImageUrl({
-  chainId,
-  contractAddress,
-  symbol,
-}: {
-  chainId?: number
-  contractAddress?: string
-  symbol?: string
-  fallbackImageUrl?: string
-}) {
-  if (!chainId || !contractAddress || !symbol) {
-    return ""
-  }
-
-  const cachedImageUrl = getCachedTokenImageUrl(
-    chainId,
-    contractAddress,
-    symbol,
-  )
-  if (cachedImageUrl) {
-    return cachedImageUrl
-  }
-
-  if (symbol) {
-    const commonImageUrl = getCommonTokenImageUrl({
-      symbol,
-      contractAddress,
-      chainId,
-    })
-    if (commonImageUrl) {
-      return commonImageUrl
-    }
-  }
-
-  // Use Sequence assets CDN format (same as metadata service)
-  // This is the proper CDN that serves token images
-  const imageUrl = `https://assets.sequence.info/images/tokens/large/${chainId}/${normalizeAddress(contractAddress)}.webp`
-
-  return imageUrl
-}
-
-// React hook that returns a configured getTokenImageUrl function
-export function useGetTokenImageUrl(): {
-  getTokenImageUrl: (params: {
-    chainId?: number
-    contractAddress?: string
-    symbol?: string
-    fallbackImageUrl?: string
-  }) => string
-} {
-  return useMemo(
-    () => ({
-      getTokenImageUrl: (params: {
-        chainId?: number
-        contractAddress?: string
-        symbol?: string
-        fallbackImageUrl?: string
-      }) => getTokenImageUrl(params),
-    }),
-    [],
-  )
-}
-
-// React hook that returns getSequenceMetadataTokenImageUrl with context
-export function useGetSequenceMetadataTokenImageUrl(): {
-  getSequenceMetadataTokenImageUrl: (params: {
-    chainId: number
-    contractAddress: string
-    fallbackImageUrl?: string
-  }) => string
-} {
-  const { sequenceMetadataUrl } = useTrails()
-
-  return useMemo(
-    () => ({
-      getSequenceMetadataTokenImageUrl: (params: {
-        chainId: number
-        contractAddress: string
-        fallbackImageUrl?: string
-      }) =>
-        getSequenceMetadataTokenImageUrl({
-          ...params,
-          sequenceMetadataUrl,
-        }),
-    }),
-    [sequenceMetadataUrl],
-  )
-}
-
-// React hook for token image fetching with caching
-export function useTokenImageUrl({
-  chainId,
-  contractAddress,
-  symbol,
-}: {
-  chainId?: number
-  contractAddress?: string
-  symbol?: string
-}): {
-  imageUrl: string
-  isLoading: boolean
-  error: Error | null
-  hasImage: boolean
-} {
-  const { getTokenImageUrl } = useGetTokenImageUrl()
-  const {
-    data: imageUrl = "",
-    isLoading,
-    error,
-  } = useQuery({
-    queryKey: ["tokenImage", chainId, contractAddress, symbol],
-    queryFn: () =>
-      Promise.resolve(getTokenImageUrl({ chainId, contractAddress, symbol })),
-    enabled: !!chainId && !!contractAddress,
-    staleTime: DAY_MS,
-    gcTime: 7 * DAY_MS,
-    retry: 2,
-    retryDelay,
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: false,
-    persister: queryPersister.persisterFn,
-  })
-
-  return {
-    imageUrl,
-    isLoading,
-    error,
-    hasImage: !!imageUrl,
-  }
-}
-
-export function useTokenList() {
-  const { supportedTokens: tokens, isLoadingTokens } = useSupportedTokens()
-
-  return {
-    tokens,
-    isLoadingTokens: isLoadingTokens,
-  }
-}
-
-export function useTokenInfo({
-  address,
-  chainId,
-}: {
-  address: string
-  chainId?: number
-}): {
-  tokenInfo: Token | null
-  isLoading: boolean
-  error: Error | null
-} {
-  // Always call hooks unconditionally
-  const { getTokenImageUrl } = useGetTokenImageUrl()
-  const isAddress = address?.startsWith("0x") ?? false
-
-  // Handle any native token (zero address) - before any blockchain calls
-  const isNativeTokenAddress = isNativeToken(address) && !!chainId
-
-  // Check cache first
-  const cachedInfo = useMemo(() => {
-    if (!isAddress || !chainId) return null
-    return getCachedTokenInfo(chainId, address)
-  }, [isAddress, chainId, address])
-
-  const contract = {
-    address: address as `0x${string}`,
-    abi: erc20Abi,
-    chainId,
-  } as const
-  const result = useReadContracts({
-    contracts:
-      !!isAddress && !!chainId && !cachedInfo && !isNativeTokenAddress
-        ? [
-            { ...contract, functionName: "name" },
-            { ...contract, functionName: "symbol" },
-            { ...contract, functionName: "decimals" },
-          ]
-        : [],
-  })
-  const error =
-    result?.error ?? result?.data?.find((r: any) => r.error)?.error ?? null
-  const [name, symbol, decimals] = result.data ?? []
-  const chainInfo = getChainInfo(chainId!)
-
-  const tokenInfo = useMemo(() => {
-    // Handle native token (zero address) for any chain
-    if (isNativeTokenAddress) {
-      const nativeSymbol = chainInfo?.nativeCurrency.symbol || "Unknown"
-      const nativeName = chainInfo?.nativeCurrency.name || "Unknown"
-      const decimals = chainInfo?.nativeCurrency.decimals ?? 18
-
-      const nativeToken: Token = {
-        tokenId: `${nativeSymbol}-${chainInfo?.name || ""}`,
-        name: nativeName,
-        symbol: nativeSymbol,
-        decimals,
-        chainId: chainId!,
-        contractAddress: zeroAddress,
-        chainName: chainInfo?.name || "",
-        imageUrl: getTokenImageUrl({
-          chainId,
-          contractAddress: zeroAddress,
-          symbol: nativeSymbol,
-        }),
-        isNativeToken: true,
-      }
-
-      // Cache the native token
-      setTokenInfoCache(`${chainId}:${normalizeAddress(address)}`, nativeToken)
-
-      return nativeToken
-    }
-
-    // If we have cached info, use it directly (already Token)
-    if (cachedInfo) {
-      return cachedInfo
-    }
-
-    // If we have blockchain data, use it and cache it
-    if (symbol?.result && name?.result && decimals?.result != null) {
-      const onChainToken: Token = {
-        tokenId: `${symbol.result}-${chainInfo?.name || ""}`,
-        name: name.result,
-        symbol: symbol.result,
-        decimals: decimals.result,
-        chainId: chainId!,
-        contractAddress: address,
-        chainName: chainInfo?.name ?? "",
-        imageUrl: getTokenImageUrl({
-          chainId,
-          contractAddress: address,
-          symbol: symbol.result,
-        }),
-      }
-
-      // Cache the result as Token
-      setTokenInfoCache(`${chainId}:${normalizeAddress(address)}`, onChainToken)
-
-      return onChainToken
-    }
-
-    return null
-  }, [
-    address,
-    chainId,
-    isNativeTokenAddress,
-    cachedInfo,
-    chainInfo?.name,
-    chainInfo?.nativeCurrency.symbol,
-    chainInfo?.nativeCurrency.name,
-    chainInfo?.nativeCurrency.decimals,
-    name?.result,
-    symbol?.result,
-    decimals?.result,
-    getTokenImageUrl,
-  ])
-
-  // Early return if not a valid address or chainId
-  if (!isAddress || !chainId) {
-    return {
-      tokenInfo: null,
-      isLoading: false,
-      error: null,
-    }
-  }
-
-  return {
-    tokenInfo,
-    isLoading: !cachedInfo && result.isLoading,
-    error: error,
-  }
-}
-
-export const tokenImageSymbolMap: Record<string, string> = {
-  ETH: "ETH",
-  cbETH: "ETH",
-  POL: "POL",
-  WPOL: "POL",
-  USDC: "USDC",
-  "USDC.e": "USDC",
-  USDT: "USDT",
-  DAI: "DAI",
-  xDAI: "DAI",
-  XDAI: "DAI",
-  WBTC: "WBTC",
-  cbBTC: "WBTC",
-  BAT: "BAT",
-  ARB: "ARB",
-  LINK: "LINK",
-  MON: "MON",
-  WMON: "MON",
-
-  // vault tokens
-  aBasUSDC: "USDC",
-  steakUSDC: "USDC",
-}
-
-export const commonTokens: Token[] = [
-  // Native tokens
-  {
-    tokenId: "ETH-ethereum",
-    symbol: "ETH",
-    name: "Ethereum",
-    contractAddress: zeroAddress,
-    decimals: 18,
-    chainId: mainnet.id,
-    chainName: mainnet.name,
-    imageUrl: commonTokenImages.ETH!,
-    isNativeToken: true,
-  },
-  {
-    tokenId: "ETH-arbitrum",
-    symbol: "ETH",
-    name: "ETH Arbitrum",
-    contractAddress: zeroAddress,
-    decimals: 18,
-    chainId: arbitrum.id,
-    chainName: arbitrum.name,
-    imageUrl: commonTokenImages.ETH!,
-    isNativeToken: true,
-  },
-  {
-    tokenId: "ETH-optimism",
-    symbol: "ETH",
-    name: "ETH Optimism",
-    contractAddress: zeroAddress,
-    decimals: 18,
-    chainId: optimism.id,
-    chainName: optimism.name,
-    imageUrl: commonTokenImages.ETH!,
-    isNativeToken: true,
-  },
-  {
-    tokenId: "ETH-base",
-    symbol: "ETH",
-    name: "ETH Base",
-    contractAddress: zeroAddress,
-    decimals: 18,
-    chainId: base.id,
-    chainName: base.name,
-    imageUrl: commonTokenImages.ETH!,
-    isNativeToken: true,
-  },
-  {
-    tokenId: "POL-polygon",
-    symbol: "POL",
-    name: "Polygon",
-    contractAddress: zeroAddress,
-    decimals: 18,
-    chainId: polygon.id,
-    chainName: polygon.name,
-    imageUrl: commonTokenImages.POL!,
-    isNativeToken: true,
-  },
-
-  // USDC
-  {
-    tokenId: "USDC-ethereum",
-    symbol: "USDC",
-    name: "USDC",
-    contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-    decimals: 6,
-    chainId: mainnet.id,
-    chainName: mainnet.name,
-    imageUrl: commonTokenImages.USDC!,
-  },
-  {
-    tokenId: "USDC-arbitrum",
-    symbol: "USDC",
-    name: "USDC Arbitrum",
-    contractAddress: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
-    decimals: 6,
-    chainId: arbitrum.id,
-    chainName: arbitrum.name,
-    imageUrl: commonTokenImages.USDC!,
-  },
-  {
-    tokenId: "USDC-avalanche",
-    symbol: "USDC",
-    name: "USDC Avalanche",
-    contractAddress: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
-    decimals: 6,
-    chainId: avalanche.id,
-    chainName: avalanche.name,
-    imageUrl: commonTokenImages.USDC!,
-  },
-  {
-    tokenId: "USDC-base",
-    symbol: "USDC",
-    name: "USDC Base",
-    contractAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    decimals: 6,
-    chainId: base.id,
-    chainName: base.name,
-    imageUrl: commonTokenImages.USDC!,
-  },
-  {
-    tokenId: "USDC-linea",
-    symbol: "USDC",
-    name: "USDC Linea",
-    contractAddress: "0x176211869cA2b568f2A7D4EE941E073a821EE1ff",
-    decimals: 6,
-    chainId: linea.id,
-    chainName: linea.name,
-    imageUrl: commonTokenImages.USDC!,
-  },
-  {
-    tokenId: "USDC-optimism",
-    symbol: "USDC",
-    name: "USDC Optimism",
-    contractAddress: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
-    decimals: 6,
-    chainId: optimism.id,
-    chainName: optimism.name,
-    imageUrl: commonTokenImages.USDC!,
-  },
-  {
-    tokenId: "USDC-polygon",
-    symbol: "USDC",
-    name: "USDC Polygon",
-    contractAddress: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
-    decimals: 6,
-    chainId: polygon.id,
-    chainName: polygon.name,
-    imageUrl: commonTokenImages.USDC!,
-  },
-  {
-    tokenId: "USDC-unichain",
-    symbol: "USDC",
-    name: "USDC Unichain",
-    contractAddress: "0x078D782b760474a361dDA0AF3839290b0EF57AD6",
-    decimals: 6,
-    chainId: unichain.id,
-    chainName: unichain.name,
-    imageUrl: commonTokenImages.USDC!,
-  },
-  {
-    tokenId: "USDC-worldchain",
-    symbol: "USDC",
-    name: "USDC WorldChain",
-    contractAddress: "0x79A02482A880bCe3F13E09da970dC34dB4cD24D1",
-    decimals: 6,
-    chainId: worldchain.id,
-    chainName: worldchain.name,
-    imageUrl: commonTokenImages.USDC!,
-  },
-
-  // Basic Attention Token
-  {
-    tokenId: "BAT-ethereum",
-    symbol: "BAT",
-    name: "Basic Attention Token",
-    contractAddress: "0x0D8775F648430679A709E98d2b0Cb6250d2887EF",
-    decimals: 18,
-    chainId: mainnet.id,
-    chainName: mainnet.name,
-    imageUrl: commonTokenImages.BAT!,
-  },
-  {
-    tokenId: "BAT-polygon",
-    symbol: "BAT",
-    name: "Basic Attention Token",
-    contractAddress: "0x3Cef98bb43d732E2F285eE605a8158cDE967D219",
-    decimals: 18,
-    chainId: polygon.id,
-    chainName: polygon.name,
-    imageUrl: commonTokenImages.BAT!,
-  },
-  {
-    tokenId: "BAT-avalanche",
-    symbol: "BAT",
-    name: "Basic Attention Token",
-    contractAddress: "0x98443B96EA4b0858FDF3219Cd13e98C7A4690588",
-    decimals: 18,
-    chainId: avalanche.id,
-    chainName: avalanche.name,
-    imageUrl: commonTokenImages.BAT!,
-  },
-
-  // ARB
-  {
-    tokenId: "ARB-arbitrum",
-    symbol: "ARB",
-    name: "Arbitrum",
-    contractAddress: "0x912CE59144191C1204E64559FE8253a0e49E6548",
-    decimals: 18,
-    chainId: arbitrum.id,
-    chainName: arbitrum.name,
-    imageUrl: commonTokenImages.ARB!,
-  },
-
-  // Chainlink
-  {
-    tokenId: "LINK-ethereum",
-    symbol: "LINK",
-    name: "Chainlink",
-    contractAddress: "0x514910771AF9Ca656af840dff83E8264EcF986CA",
-    decimals: 18,
-    chainId: mainnet.id,
-    chainName: mainnet.name,
-    imageUrl: commonTokenImages.LINK!,
-  },
-
-  // USDT (Tether)
-  {
-    tokenId: "USDT-ethereum",
-    symbol: "USDT",
-    name: "Tether USD",
-    contractAddress: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
-    decimals: 6,
-    chainId: mainnet.id,
-    chainName: mainnet.name,
-    imageUrl: commonTokenImages.USDT!,
-  },
-  {
-    tokenId: "USDT-polygon",
-    symbol: "USDT",
-    name: "Tether USD",
-    contractAddress: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
-    decimals: 6,
-    chainId: polygon.id,
-    chainName: polygon.name,
-    imageUrl: commonTokenImages.USDT!,
-  },
-  {
-    tokenId: "USDT-arbitrum",
-    symbol: "USDT",
-    name: "Tether USD",
-    contractAddress: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
-    decimals: 6,
-    chainId: arbitrum.id,
-    chainName: arbitrum.name,
-    imageUrl: commonTokenImages.USDT!,
-  },
-  {
-    tokenId: "USDT-optimism",
-    symbol: "USDT",
-    name: "Tether USD",
-    contractAddress: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58",
-    decimals: 6,
-    chainId: optimism.id,
-    chainName: optimism.name,
-    imageUrl: commonTokenImages.USDT!,
-  },
-  {
-    tokenId: "USDT-avalanche",
-    symbol: "USDT",
-    name: "Tether USD",
-    contractAddress: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
-    decimals: 6,
-    chainId: avalanche.id,
-    chainName: avalanche.name,
-    imageUrl: commonTokenImages.USDT!,
-  },
-
-  // DAI
-  {
-    tokenId: "DAI-ethereum",
-    symbol: "DAI",
-    name: "Dai Stablecoin",
-    contractAddress: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
-    decimals: 18,
-    chainId: mainnet.id,
-    chainName: mainnet.name,
-    imageUrl: commonTokenImages.DAI!,
-  },
-  {
-    tokenId: "DAI-polygon",
-    symbol: "DAI",
-    name: "Dai Stablecoin",
-    contractAddress: "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",
-    decimals: 18,
-    chainId: polygon.id,
-    chainName: polygon.name,
-    imageUrl: commonTokenImages.DAI!,
-  },
-  {
-    tokenId: "DAI-arbitrum",
-    symbol: "DAI",
-    name: "Dai Stablecoin",
-    contractAddress: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
-    decimals: 18,
-    chainId: arbitrum.id,
-    chainName: arbitrum.name,
-    imageUrl: commonTokenImages.DAI!,
-  },
-  {
-    tokenId: "DAI-optimism",
-    symbol: "DAI",
-    name: "Dai Stablecoin",
-    contractAddress: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
-    decimals: 18,
-    chainId: optimism.id,
-    chainName: optimism.name,
-    imageUrl: commonTokenImages.DAI!,
-  },
-
-  // MATIC (on Ethereum mainnet as ERC20)
-  {
-    tokenId: "MATIC-ethereum",
-    symbol: "MATIC",
-    name: "Matic Token",
-    contractAddress: "0x7D1AfA7B718fb893dB30A3aBc0Cfc608AaCfeBB0",
-    decimals: 18,
-    chainId: mainnet.id,
-    chainName: mainnet.name,
-    imageUrl: commonTokenImages.MATIC!,
-  },
-
-  // Etherlink tokens
-  {
-    tokenId: "XTZ-etherlink",
-    symbol: "XTZ",
-    name: "Tezos",
-    contractAddress: zeroAddress,
-    decimals: 18,
-    chainId: etherlink.id,
-    chainName: etherlink.name,
-    imageUrl: commonTokenImages.XTZ as string,
-    isNativeToken: true,
-  },
-  {
-    tokenId: "WXTZ-etherlink",
-    symbol: "WXTZ",
-    name: "Wrapped XTZ",
-    contractAddress: "0xc9B53AB2679f573e480d01e0f49e2B5CFB7a3EAb",
-    decimals: 18,
-    chainId: etherlink.id,
-    chainName: etherlink.name,
-    imageUrl: commonTokenImages.WXTZ as string,
-  },
-  {
-    tokenId: "USDC-etherlink",
-    symbol: "USDC",
-    name: "USD Coin",
-    contractAddress: "0x796Ea11Fa2dD751eD01b53C372fFDB4AAa8f00F9",
-    decimals: 6,
-    chainId: etherlink.id,
-    chainName: etherlink.name,
-    imageUrl: commonTokenImages.USDC as string,
-  },
-  {
-    tokenId: "WETH-etherlink",
-    symbol: "WETH",
-    name: "Wrapped ETH",
-    contractAddress: "0xfc24f770F94edBca6D6f885E12d4317320BcB401",
-    decimals: 18,
-    chainId: etherlink.id,
-    chainName: etherlink.name,
-    imageUrl: commonTokenImages.WETH as string,
-  },
-  {
-    tokenId: "USDT-etherlink",
-    symbol: "USDT",
-    name: "Bridged USDT",
-    contractAddress: "0x2C03058C8AFC06713be23e58D2febC8337dbfE6A",
-    decimals: 6,
-    chainId: etherlink.id,
-    chainName: etherlink.name,
-    imageUrl: commonTokenImages.USDT as string,
-  },
-  {
-    tokenId: "USDT-bsc",
-    symbol: "USDT",
-    name: "Tether USD",
-    contractAddress: "0x55d398326f99059ff775485246999027b3197955",
-    decimals: 18,
-    chainId: bsc.id,
-    chainName: bsc.name,
-    imageUrl: commonTokenImages.USDT as string,
-  },
-  {
-    tokenId: "USDC-bsc",
-    symbol: "USDC",
-    name: "USDC",
-    contractAddress: "0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d",
-    decimals: 18,
-    chainId: bsc.id,
-    chainName: bsc.name,
-    imageUrl: commonTokenImages.USDC as string,
-  },
-  {
-    tokenId: "DAI-bsc",
-    symbol: "DAI",
-    name: "Dai Stablecoin",
-    contractAddress: "0x1af3f329e8be154074d8769d1ffa4ee058b1dbc3",
-    decimals: 18,
-    chainId: bsc.id,
-    chainName: bsc.name,
-    imageUrl: commonTokenImages.DAI as string,
-  },
-  {
-    tokenId: "BNB-bsc",
-    symbol: "BNB",
-    name: "BNB",
-    contractAddress: zeroAddress,
-    decimals: 18,
-    chainId: bsc.id,
-    chainName: bsc.name,
-    imageUrl: commonTokenImages.BNB as string,
-    isNativeToken: true,
-  },
-  {
-    tokenId: "AVAX-bsc",
-    symbol: "AVAX",
-    name: "Avalanche Token",
-    contractAddress: "0x1ce0c2827e2ef14d5c4f29a091d735a204794041",
-    decimals: 18,
-    chainId: bsc.id,
-    chainName: bsc.name,
-    imageUrl: commonTokenImages.AVAX as string,
-  },
-
-  // Somnia
-  {
-    tokenId: "SOMI-somnia",
-    symbol: "SOMI",
-    name: "Somnia",
-    contractAddress: zeroAddress,
-    decimals: 18,
-    chainId: somnia.id,
-    chainName: somnia.name,
-    imageUrl: commonTokenImages.SOMI as string,
-    isNativeToken: true,
-  },
-
-  // Monad
-  {
-    tokenId: "MON-monad",
-    symbol: "MON",
-    name: "Monad",
-    contractAddress: zeroAddress,
-    decimals: 18,
-    chainId: monad.id,
-    chainName: monad.name,
-    imageUrl: commonTokenImages.MONAD as string,
-    isNativeToken: true,
-  },
-  {
-    tokenId: "WMON-monad",
-    symbol: "WMON",
-    name: "Wrapped MON",
-    contractAddress: "0x3bd359c1119da7da1d913d1c4d2b7c461115433a",
-    decimals: 18,
-    chainId: monad.id,
-    chainName: monad.name,
-    imageUrl: commonTokenImages.MON as string,
-  },
-  {
-    tokenId: "USDC-monad",
-    symbol: "USDC",
-    name: "USDC",
-    contractAddress: "0x754704Bc059F8C67012fEd69BC8A327a5aafb603",
-    decimals: 6,
-    chainId: monad.id,
-    chainName: monad.name,
-    imageUrl: commonTokenImages.USDC as string,
-  },
-]
-
-// wrapped-native addresses
-export const wethAddresses: Record<string, string> = {
-  [mainnet.id]: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
-  [optimism.id]: "0x4200000000000000000000000000000000000006",
-  [bsc.id]: "0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c",
-  [gnosis.id]: "0xe91d153e0b41518a2ce8dd3d7944fa863463a97d",
-  [unichain.id]: "0x4200000000000000000000000000000000000006",
-  [base.id]: "0x4200000000000000000000000000000000000006",
-  [sonic.id]: "0x039e2fb66102314ce7b64ce5ce3e5183bc94ad38",
-  [fantom.id]: "0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83",
-  [zksync.id]: "0x5aea5775959fbc2557cc8789bc1bf90a239d9a91",
-  [worldchain.id]: "0x4200000000000000000000000000000000000006",
-  [hyperEvm.id]: "0x5555555555555555555555555555555555555555",
-  [polygon.id]: "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270",
-  [ink.id]: "0x4200000000000000000000000000000000000006",
-  [linea.id]: "0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f",
-  [arbitrum.id]: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
-  [avalanche.id]: "0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7",
-  [scroll.id]: "0x5300000000000000000000000000000000000004",
-  [katana.id]: "0xee7d8bcfb72bc1880d0cf19822eb0a2e6577ab62",
-  [berachain.id]: "0x6969696969696969696969696969696969696969",
-  [blast.id]: "0x4300000000000000000000000000000000000004",
-}
-
-export function getWethAddress(chainId: number): string | null {
-  return wethAddresses[chainId] ?? null
-}