Detect a Token's Chain from Contract Address

curl "https://api.mobula.io/api/2/fast-search?input=0xdAC17F958D2ee523a2206206994597C13D831ec7"

{
  "data": [
    {
      "address": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
      "chainId": "evm:1",
      "symbol": "USDT",
      "name": "Tether USD",
      "priceUSD": 0.9999,
      ...
    }
  ]
}

interface TokenResult {
  address: string;
  chainId: string;
  symbol: string | null;
  name: string | null;
  priceUSD: number;
  // ... many more fields
}

interface SearchResponse {
  data: TokenResult[];
}

async function detectChain(contractAddress: string): Promise<string | null> {
  const response = await fetch(
    `https://api.mobula.io/api/2/fast-search?input=${contractAddress}`,
    {
      headers: {
        'Authorization': `Bearer ${process.env.MOBULA_API_KEY}`,
      },
    }
  );
  
  const result: SearchResponse = await response.json();
  
  if (result.data.length === 0) {
    return null; // Token not found
  }
  
  return result.data[0].chainId;
}

// Usage
const chainId = await detectChain('0xdAC17F958D2ee523a2206206994597C13D831ec7');
console.log(`Token is on chain: ${chainId}`); // Output: "evm:1"

import requests
from typing import Optional

def detect_chain(contract_address: str, api_key: str = None) -> Optional[str]:
    """Detect which blockchain a contract address belongs to."""
    
    headers = {}
    if api_key:
        headers["Authorization"] = f"Bearer {api_key}"
    
    response = requests.get(
        f"https://api.mobula.io/api/2/fast-search?input={contract_address}",
        headers=headers
    )
    
    data = response.json()
    
    if not data.get("data"):
        return None
        
    return data["data"][0]["chainId"]


# Usage
chain_id = detect_chain("0xdAC17F958D2ee523a2206206994597C13D831ec7")
print(f"Token is on chain: {chain_id}")  # Output: "evm:1"

# Solana example
chain_id = detect_chain("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v")
print(f"Token is on chain: {chain_id}")  # Output: "solana:solana"

async function getTokenWithChainDetection(contractAddress: string) {
  // Step 1: Detect chain from address
  const searchResponse = await fetch(
    `https://api.mobula.io/api/2/fast-search?input=${contractAddress}&limit=1`
  );
  const searchResult = await searchResponse.json();
  
  if (searchResult.data.length === 0) {
    throw new Error('Token not found');
  }
  
  const { chainId, address } = searchResult.data[0];
  
  // Step 2: Fetch full token details
  const detailsResponse = await fetch(
    `https://api.mobula.io/api/2/token/details?blockchain=${chainId}&address=${address}`
  );
  
  return detailsResponse.json();
}

// Usage
const tokenData = await getTokenWithChainDetection('0xdAC17F958D2ee523a2206206994597C13D831ec7');
console.log(tokenData);

async function findTokenAcrossChains(contractAddress: string) {
  const response = await fetch(
    `https://api.mobula.io/api/2/fast-search?input=${contractAddress}&limit=20`
  );
  const result = await response.json();
  
  // Group by chain
  const byChain = new Map<string, any>();
  for (const token of result.data) {
    if (!byChain.has(token.chainId)) {
      byChain.set(token.chainId, token);
    }
  }
  
  return byChain;
}

async function findTokenOnSpecificChains(
  address: string, 
  preferredChains: string[]
): Promise<TokenResult | null> {
  const response = await fetch(
    `https://api.mobula.io/api/2/fast-search?input=${address}&limit=10`
  );
  const result = await response.json();
  
  // Find token on preferred chain first
  for (const chain of preferredChains) {
    const match = result.data.find((t: TokenResult) => t.chainId === chain);
    if (match) return match;
  }
  
  // Fallback to most active (first result)
  return result.data[0] || null;
}

const chainCache = new Map<string, string>();

async function detectChainCached(address: string): Promise<string | null> {
  const normalizedAddress = address.toLowerCase();
  
  if (chainCache.has(normalizedAddress)) {
    return chainCache.get(normalizedAddress)!;
  }
  
  const chainId = await detectChain(address);
  if (chainId) {
    chainCache.set(normalizedAddress, chainId);
  }
  
  return chainId;
}

const response = await fetch(
  `https://api.mobula.io/api/2/fast-search?input=${address}&filters={"blockchains":"1,8453,solana"}`
);