moltlaunch 2.0.0 → 2.0.2

package/worker/src/agents.ts

@@ -1,755 +0,0 @@
-// ERC-8004 Agent Discovery
-// Reads agents from the Identity Registry on Base
-
-import type { Env } from './types';
-
-// ERC-8004 Identity Registry on Base
-const IDENTITY_REGISTRY = '0x8004A169FB4a3325136EB29fA0ceB6D2e539a432';
-const REPUTATION_REGISTRY = '0x8004BAa17C55a88189AE136b182e5fdA19dE9b63';
-
-// MandateEscrow contracts - V3 for historical data, V4 for new escrows
-const ESCROW_V3 = '0x893a388d253dc8509877b1b4529b7eaa17597b40';
-const ESCROW_V4 = '0x2c46054b4577b4fcdde28cb613dc2ba4b1127b0c';
-
-// Flaunch API for token market data
-const FLAUNCH_API = 'https://api.flayerlabs.xyz/v1/base';
-
-// Metadata keys stored in ERC-8004
-const METADATA_KEYS = {
-  FLAUNCH_TOKEN: 'flaunchToken',
-  SKILLS: 'skills',
-  ENDPOINT: 'endpoint',
-  PRICE_WEI: 'priceWei',
-};
-
-// Agent type returned by the API
-export interface Agent {
-  id: string; // agentId as hex string
-  agentIdBigInt: string; // Original bigint as string for display
-  owner: string;
-  agentURI: string;
-  agentWallet: string;
-  name: string;
-  description: string;
-  skills: string[];
-  endpoint: string;
-  priceWei: string;
-  flaunchToken?: string;
-  // Reputation from ERC-8004
-  reputation: {
-    count: number;
-    summaryValue: number;
-    summaryValueDecimals: number;
-  };
-  // Market data (Flaunch + DexScreener)
-  marketCapUSD?: number;
-  volume24hUSD?: number;
-  priceChange24h?: number;
-  liquidityUSD?: number;
-  holders?: number;
-  image?: string;
-  symbol?: string;
-  flaunchUrl?: string;
-  // Revenue tracking from escrow contract
-  totalBurnedETH?: number;  // ETH used to buyback & burn tokens
-  totalBurnedUSD?: number;
-  totalBurnedTokens?: number; // Tokens sent to burn address
-  // Stats from worker (included in enriched responses)
-  completedTasks?: number;
-  totalEarningsETH?: number;
-}
-
-// Minimal ABI for reading from Identity Registry
-const IDENTITY_ABI = {
-  ownerOf: 'function ownerOf(uint256 tokenId) view returns (address)',
-  tokenURI: 'function tokenURI(uint256 tokenId) view returns (string)',
-  getAgentWallet: 'function getAgentWallet(uint256 agentId) view returns (address)',
-  getMetadata: 'function getMetadata(uint256 agentId, string metadataKey) view returns (bytes)',
-  balanceOf: 'function balanceOf(address owner) view returns (uint256)',
-};
-
-const REPUTATION_ABI = {
-  getSummary: 'function getSummary(uint256 agentId, address[] clientAddresses, string tag1, string tag2) view returns (uint64 count, int128 summaryValue, uint8 summaryValueDecimals)',
-};
-
-// Function selectors (keccak256 of signature, first 4 bytes)
-const SELECTORS = {
-  ownerOf: '0x6352211e',
-  tokenURI: '0xc87b56dd',
-  getAgentWallet: '0xf3ea1f13', // getAgentWallet(uint256)
-  getMetadata: '0xcb4799f2', // getMetadata(uint256,string)
-  getSummary: '0x81bbba58', // getSummary(uint256,address[],string,string)
-  getClients: '0x42dd519c', // getClients(uint256)
-};
-
-// Encode uint256 for RPC call
-function encodeUint256(value: bigint): string {
-  return value.toString(16).padStart(64, '0');
-}
-
-// Encode string for RPC call (offset + length + data)
-function encodeString(str: string): string {
-  const encoder = new TextEncoder();
-  const bytes = encoder.encode(str);
-  let hex = '';
-  for (const b of bytes) {
-    hex += b.toString(16).padStart(2, '0');
-  }
-  const len = bytes.length.toString(16).padStart(64, '0');
-  const padded = hex.padEnd(Math.ceil(hex.length / 64) * 64, '0');
-  return len + padded;
-}
-
-// Decode hex string to UTF-8
-function decodeString(hex: string): string {
-  if (!hex || hex === '0x' || hex === '') return '';
-  const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
-  if (clean.length === 0) return '';
-  const bytes = new Uint8Array(clean.length / 2);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16);
-  }
-  const decoder = new TextDecoder('utf-8');
-  return decoder.decode(bytes).replace(/\0/g, '');
-}
-
-// Decode hex to bigint
-function decodeBigInt(hex: string): bigint {
-  if (!hex || hex === '0x' || hex === '') return 0n;
-  const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
-  if (clean.length === 0) return 0n;
-  return BigInt('0x' + clean);
-}
-
-// Make eth_call
-async function ethCall(rpcUrl: string, to: string, data: string): Promise<string> {
-  console.log('[ethCall] Calling:', to, data.substring(0, 20) + '...');
-  const res = await fetch(rpcUrl, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      jsonrpc: '2.0',
-      method: 'eth_call',
-      params: [{ to, data }, 'latest'],
-      id: 1,
-    }),
-  });
-  const json = await res.json() as { result?: string; error?: { message: string } };
-  console.log('[ethCall] Response:', json.error ? 'ERROR: ' + json.error.message : 'OK');
-  if (json.error) throw new Error(json.error.message);
-  return json.result || '0x';
-}
-
-// Get ETH balance of an address
-async function getBalance(rpcUrl: string, address: string): Promise<number> {
-  try {
-    const res = await fetch(rpcUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        method: 'eth_getBalance',
-        params: [address, 'latest'],
-        id: 1,
-      }),
-    });
-    const json = await res.json() as { result?: string; error?: { message: string } };
-    if (json.error || !json.result) return 0;
-    return Number(BigInt(json.result)) / 1e18;
-  } catch {
-    return 0;
-  }
-}
-
-// Get total ETH burned for a token from escrow BuybackBurned events
-// Event: BuybackBurned(bytes32 indexed taskId, address indexed token, uint256 ethAmount)
-async function getTotalBurned(rpcUrl: string, tokenAddress: string): Promise<number> {
-  const topic0 = '0xd348d018935f8254a4d4a03b887cc0f0a0cdd7c6afd4414feb31b6af57c95bbc';
-  const topic2 = '0x000000000000000000000000' + tokenAddress.slice(2).toLowerCase();
-
-  let totalWei = 0n;
-
-  // Query from both V3 and V4 contracts
-  for (const contractAddr of [ESCROW_V3, ESCROW_V4]) {
-    try {
-      const res = await fetch(rpcUrl, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          jsonrpc: '2.0',
-          method: 'eth_getLogs',
-          params: [{
-            address: contractAddr,
-            topics: [topic0, null, topic2],
-            fromBlock: '0x0',
-            toBlock: 'latest',
-          }],
-          id: 1,
-        }),
-      });
-
-      const json = await res.json() as {
-        result?: Array<{ data: string }>;
-        error?: { message: string };
-      };
-
-      if (json.error || !json.result) continue;
-
-      for (const log of json.result) {
-        const amount = BigInt(log.data);
-        totalWei += amount;
-      }
-    } catch {
-      // Continue with other contract if one fails
-    }
-  }
-
-  return Number(totalWei) / 1e18;
-}
-
-// Get total tokens sent to burn address (0xdead) for a token
-// Uses Transfer(from, to, value) events where to=0xdead
-async function getTotalTokensBurned(rpcUrl: string, tokenAddress: string): Promise<number> {
-  // keccak256("Transfer(address,address,uint256)")
-  const topic0 = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';
-  const deadTopic = '0x000000000000000000000000000000000000000000000000000000000000dead';
-
-  try {
-    const res = await fetch(rpcUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        method: 'eth_getLogs',
-        params: [{
-          address: tokenAddress,
-          topics: [topic0, null, deadTopic],
-          fromBlock: '0x0',
-          toBlock: 'latest',
-        }],
-        id: 1,
-      }),
-    });
-
-    const json = await res.json() as {
-      result?: Array<{ data: string }>;
-      error?: { message: string };
-    };
-
-    if (json.error || !json.result) return 0;
-
-    let totalWei = 0n;
-    for (const log of json.result) {
-      totalWei += BigInt(log.data);
-    }
-
-    return Number(totalWei) / 1e18;
-  } catch {
-    return 0;
-  }
-}
-
-// Get logs for Registered events with pagination
-async function getRegisteredEvents(rpcUrl: string): Promise<Array<{ agentId: bigint; owner: string }>> {
-  // Topic0 for Registered event from ERC-8004
-  const topic0 = '0xca52e62c367d81bb2e328eb795f7c7ba24afb478408a26c0e201d155c449bc4a';
-
-  // Query in chunks to avoid RPC limits (max 10000 logs per query)
-  const allLogs: Array<{ agentId: bigint; owner: string }> = [];
-
-  // Get current block number
-  const blockRes = await fetch(rpcUrl, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      jsonrpc: '2.0',
-      method: 'eth_blockNumber',
-      params: [],
-      id: 1,
-    }),
-  });
-  const blockJson = await blockRes.json() as { result?: string };
-  const latestBlock = parseInt(blockJson.result || '0x0', 16);
-
-  // Query in chunks of 100000 blocks
-  const chunkSize = 100000;
-  let fromBlock = 0;
-
-  while (fromBlock < latestBlock) {
-    const toBlock = Math.min(fromBlock + chunkSize - 1, latestBlock);
-
-    const res = await fetch(rpcUrl, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        method: 'eth_getLogs',
-        params: [{
-          address: IDENTITY_REGISTRY,
-          topics: [topic0],
-          fromBlock: '0x' + fromBlock.toString(16),
-          toBlock: '0x' + toBlock.toString(16),
-        }],
-        id: 1,
-      }),
-    });
-
-    const json = await res.json() as {
-      result?: Array<{ topics: string[]; data: string }>;
-      error?: { message: string };
-    };
-
-    if (json.error) {
-      console.log(`[getRegisteredEvents] Error querying blocks ${fromBlock}-${toBlock}:`, json.error.message);
-      // If we get an error (like too many results), try smaller chunks
-      if (json.error.message.includes('exceed') || json.error.message.includes('limit')) {
-        // Skip this range for now
-        fromBlock = toBlock + 1;
-        continue;
-      }
-      throw new Error(json.error.message);
-    }
-
-    const logs = json.result || [];
-    console.log(`[getRegisteredEvents] Found ${logs.length} events in blocks ${fromBlock}-${toBlock}`);
-
-    for (const log of logs) {
-      allLogs.push({
-        agentId: BigInt(log.topics[1]),
-        owner: '0x' + log.topics[2].slice(-40),
-      });
-    }
-
-    fromBlock = toBlock + 1;
-  }
-
-  console.log(`[getRegisteredEvents] Total events: ${allLogs.length}`);
-  return allLogs;
-}
-
-// Get agent details from ERC-8004
-async function getAgentFromContract(rpcUrl: string, agentId: bigint): Promise<Agent | null> {
-  console.log('[getAgentFromContract] Starting for agentId:', agentId.toString());
-  try {
-    const agentIdHex = encodeUint256(agentId);
-    console.log('[getAgentFromContract] agentIdHex:', agentIdHex);
-
-    // Get owner
-    const ownerData = SELECTORS.ownerOf + agentIdHex;
-    console.log('[getAgentFromContract] Calling ownerOf...');
-    const ownerResult = await ethCall(rpcUrl, IDENTITY_REGISTRY, ownerData);
-    console.log('[getAgentFromContract] ownerResult:', ownerResult);
-    const owner = '0x' + ownerResult.slice(-40);
-    console.log('[getAgentFromContract] owner:', owner);
-
-    // Get tokenURI
-    const uriData = SELECTORS.tokenURI + agentIdHex;
-    const uriResult = await ethCall(rpcUrl, IDENTITY_REGISTRY, uriData);
-    // Decode ABI-encoded string response
-    let agentURI = '';
-    if (uriResult && uriResult.length > 130) {
-      const strOffset = parseInt(uriResult.slice(2, 66), 16) * 2;
-      const strLen = parseInt(uriResult.slice(66, 130), 16);
-      agentURI = decodeString(uriResult.slice(130, 130 + strLen * 2));
-    }
-
-    // Get agent wallet (optional - may not be set)
-    let agentWallet = owner;
-    try {
-      const walletData = SELECTORS.getAgentWallet + agentIdHex;
-      const walletResult = await ethCall(rpcUrl, IDENTITY_REGISTRY, walletData);
-      if (walletResult && walletResult !== '0x' + '0'.repeat(64)) {
-        agentWallet = '0x' + walletResult.slice(-40);
-      }
-    } catch {
-      // Agent wallet not set, use owner
-      console.log('[getAgentFromContract] No agentWallet set, using owner');
-    }
-
-    // Get metadata - skills (optional)
-    let skills: string[] = [];
-    try {
-      const skillsKey = encodeString(METADATA_KEYS.SKILLS);
-      const skillsData = SELECTORS.getMetadata + agentIdHex + '0000000000000000000000000000000000000000000000000000000000000040' + skillsKey;
-      const skillsResult = await ethCall(rpcUrl, IDENTITY_REGISTRY, skillsData);
-      if (skillsResult && skillsResult.length > 130) {
-        const strLen = parseInt(skillsResult.slice(66, 130), 16);
-        const skillsStr = decodeString(skillsResult.slice(130, 130 + strLen * 2));
-        skills = skillsStr.split(',').filter(Boolean);
-      }
-    } catch {
-      console.log('[getAgentFromContract] No skills metadata');
-    }
-
-    // Get metadata - endpoint (optional)
-    let endpoint = '';
-    try {
-      const endpointKey = encodeString(METADATA_KEYS.ENDPOINT);
-      const endpointData = SELECTORS.getMetadata + agentIdHex + '0000000000000000000000000000000000000000000000000000000000000040' + endpointKey;
-      const endpointResult = await ethCall(rpcUrl, IDENTITY_REGISTRY, endpointData);
-      if (endpointResult && endpointResult.length > 130) {
-        const strLen = parseInt(endpointResult.slice(66, 130), 16);
-        endpoint = decodeString(endpointResult.slice(130, 130 + strLen * 2));
-      }
-    } catch {
-      console.log('[getAgentFromContract] No endpoint metadata');
-    }
-
-    // Get metadata - priceWei (optional)
-    let priceWei = '0';
-    try {
-      const priceKey = encodeString(METADATA_KEYS.PRICE_WEI);
-      const priceData = SELECTORS.getMetadata + agentIdHex + '0000000000000000000000000000000000000000000000000000000000000040' + priceKey;
-      const priceResult = await ethCall(rpcUrl, IDENTITY_REGISTRY, priceData);
-      // bytes response: offset (32 bytes) + length (32 bytes) + data
-      // priceWei is stored as 32-byte bigint
-      if (priceResult && priceResult.length >= 194) {
-        const dataLen = parseInt(priceResult.slice(66, 130), 16);
-        if (dataLen === 32) {
-          // Extract the 32-byte bigint from data section
-          const priceHex = priceResult.slice(130, 194);
-          priceWei = decodeBigInt('0x' + priceHex).toString();
-        }
-      }
-    } catch {
-      console.log('[getAgentFromContract] No priceWei metadata');
-    }
-
-    // Get metadata - flaunchToken (optional)
-    let flaunchToken: string | undefined;
-    try {
-      const flaunchKey = encodeString(METADATA_KEYS.FLAUNCH_TOKEN);
-      const flaunchData = SELECTORS.getMetadata + agentIdHex + '0000000000000000000000000000000000000000000000000000000000000040' + flaunchKey;
-      const flaunchResult = await ethCall(rpcUrl, IDENTITY_REGISTRY, flaunchData);
-      // bytes response: offset (32 bytes) + length (32 bytes) + data (padded)
-      // For address: length=20, data starts at position 130 (after 0x + 64 + 64)
-      if (flaunchResult && flaunchResult.length >= 194) {
-        const dataLen = parseInt(flaunchResult.slice(66, 130), 16);
-        if (dataLen === 20) {
-          // It's an address - read first 40 hex chars of data (not last!)
-          const tokenAddr = '0x' + flaunchResult.slice(130, 170).toLowerCase();
-          if (tokenAddr !== '0x0000000000000000000000000000000000000000') {
-            flaunchToken = tokenAddr;
-          }
-        }
-      }
-    } catch (e) {
-      console.log('[getAgentFromContract] No flaunchToken metadata:', e);
-    }
-
-    // Get reputation from Reputation Registry
-    // Step 1: getClients(agentId) to get addresses who left feedback
-    // Step 2: getSummary(agentId, clients, '', '') with those addresses
-    let reputation = { count: 0, summaryValue: 0, summaryValueDecimals: 0 };
-    try {
-      const clientsData = SELECTORS.getClients + agentIdHex;
-      const clientsResult = await ethCall(rpcUrl, REPUTATION_REGISTRY, clientsData);
-
-      // Decode address[] response: offset (32) + length (32) + addresses (32 each)
-      let clients: string[] = [];
-      if (clientsResult && clientsResult.length > 130) {
-        const arrLen = parseInt(clientsResult.slice(66, 130), 16);
-        for (let i = 0; i < arrLen; i++) {
-          const start = 130 + i * 64;
-          clients.push(clientsResult.slice(start + 24, start + 64)); // last 20 bytes
-        }
-      }
-
-      if (clients.length > 0) {
-        // Build getSummary calldata with client addresses
-        // Head: agentId + offset_addr[] + offset_tag1 + offset_tag2
-        const addrArrayOffset = (4 * 32).toString(16).padStart(64, '0'); // 0x80
-        const addrDataSize = (1 + clients.length) * 32; // length word + address words
-        const tag1Offset = (4 * 32 + addrDataSize).toString(16).padStart(64, '0');
-        const tag2Offset = (4 * 32 + addrDataSize + 32).toString(16).padStart(64, '0');
-
-        let summaryData = SELECTORS.getSummary + agentIdHex +
-          addrArrayOffset + tag1Offset + tag2Offset;
-
-        // Address array: length + each address padded to 32 bytes
-        summaryData += clients.length.toString(16).padStart(64, '0');
-        for (const addr of clients) {
-          summaryData += addr.padStart(64, '0');
-        }
-
-        // Empty tag1 and tag2
-        summaryData += '0000000000000000000000000000000000000000000000000000000000000000';
-        summaryData += '0000000000000000000000000000000000000000000000000000000000000000';
-
-        const repResult = await ethCall(rpcUrl, REPUTATION_REGISTRY, summaryData);
-        if (repResult && repResult.length >= 194) {
-          reputation = {
-            count: parseInt(repResult.slice(2, 66), 16),
-            summaryValue: parseInt(repResult.slice(66, 130), 16),
-            summaryValueDecimals: parseInt(repResult.slice(130, 194), 16),
-          };
-        }
-      }
-    } catch {
-      // Reputation might not exist yet
-    }
-
-    // Parse name/description from agentURI
-    let name = `Agent #${agentId}`;
-    let description = '';
-
-    if (agentURI.startsWith('data:application/json')) {
-      try {
-        let jsonStr: string;
-        if (agentURI.includes(';base64,')) {
-          const base64 = agentURI.split(';base64,')[1];
-          jsonStr = atob(base64);
-        } else {
-          jsonStr = decodeURIComponent(agentURI.split(',')[1]);
-        }
-        const meta = JSON.parse(jsonStr);
-        name = meta.name || name;
-        description = meta.description || '';
-      } catch {
-        // Couldn't parse, use defaults
-      }
-    }
-
-    return {
-      id: '0x' + agentId.toString(16),
-      agentIdBigInt: agentId.toString(),
-      owner,
-      agentURI,
-      agentWallet,
-      name,
-      description,
-      skills,
-      endpoint,
-      priceWei,
-      flaunchToken,
-      reputation,
-    };
-  } catch (err) {
-    console.error(`Error fetching agent ${agentId}:`, err);
-    return null;
-  }
-}
-
-// ETH price cache for USD conversion
-let ethPriceCache: { price: number; fetchedAt: number } | null = null;
-const ETH_PRICE_CACHE_TTL = 60_000; // 1 minute
-
-async function getEthPrice(): Promise<number> {
-  const now = Date.now();
-  if (ethPriceCache && now - ethPriceCache.fetchedAt < ETH_PRICE_CACHE_TTL) {
-    return ethPriceCache.price;
-  }
-  try {
-    const res = await fetch('https://api.coingecko.com/api/v3/simple/price?ids=ethereum&vs_currencies=usd');
-    if (!res.ok) return ethPriceCache?.price ?? 2500;
-    const data = await res.json() as { ethereum: { usd: number } };
-    const price = data.ethereum.usd;
-    ethPriceCache = { price, fetchedAt: now };
-    return price;
-  } catch {
-    return ethPriceCache?.price ?? 2500;
-  }
-}
-
-// Fetch market data from Flaunch + DexScreener
-async function getFlaunchData(tokenAddress: string): Promise<{
-  marketCapUSD: number;
-  volume24hUSD: number;
-  priceChange24h: number;
-  holders: number;
-  image: string;
-  symbol: string;
-  liquidityUSD: number;
-} | null> {
-  try {
-    // Fetch from Flaunch (image, symbol, holders), DexScreener (volume, priceChange), and ETH price in parallel
-    const [detailsRes, holdersRes, dexRes, ethPrice] = await Promise.all([
-      fetch(`${FLAUNCH_API}/tokens/${tokenAddress}`),
-      fetch(`${FLAUNCH_API}/tokens/${tokenAddress}/holders?limit=1`),
-      fetch(`https://api.dexscreener.com/latest/dex/tokens/${tokenAddress}`),
-      getEthPrice(),
-    ]);
-
-    if (!detailsRes.ok) return null;
-
-    const details = await detailsRes.json() as {
-      tokenAddress: string;
-      symbol: string;
-      name: string;
-      image: string;
-      marketCapETH?: string;
-    };
-
-    let holders = 0;
-    if (holdersRes.ok) {
-      const holdersData = await holdersRes.json() as { totalHolders?: string };
-      holders = parseInt(holdersData.totalHolders || '0', 10);
-    }
-
-    // Get volume and price change from DexScreener
-    let volume24hUSD = 0;
-    let priceChange24h = 0;
-    let liquidityUSD = 0;
-    if (dexRes.ok) {
-      const dexData = await dexRes.json() as {
-        pairs?: Array<{
-          priceChange?: { h24?: number };
-          volume?: { h24?: number };
-          liquidity?: { usd?: number };
-        }>;
-      };
-      const pair = dexData.pairs?.[0];
-      if (pair) {
-        volume24hUSD = pair.volume?.h24 || 0;
-        priceChange24h = pair.priceChange?.h24 || 0;
-        liquidityUSD = pair.liquidity?.usd || 0;
-      }
-    }
-
-    // Convert marketCap from ETH to USD
-    const marketCapETH = Number(details.marketCapETH || '0') / 1e18;
-    const marketCapUSD = marketCapETH * ethPrice;
-
-    return {
-      marketCapUSD,
-      volume24hUSD,
-      priceChange24h,
-      holders,
-      image: details.image || '',
-      symbol: details.symbol || '',
-      liquidityUSD,
-    };
-  } catch {
-    return null;
-  }
-}
-
-// Cache for agents (5 minute TTL)
-let agentsCache: { agents: Agent[]; fetchedAt: number } | null = null;
-const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-
-/**
- * Get all Moltlaunch agents (from KV index)
- */
-export async function getAllAgents(env: Env): Promise<Agent[]> {
-  const now = Date.now();
-  if (agentsCache && now - agentsCache.fetchedAt < CACHE_TTL) {
-    return agentsCache.agents;
-  }
-
-  const rpcUrl = env.ALCHEMY_RPC || env.BASE_RPC || 'https://mainnet.base.org';
-
-  try {
-    // Get agent IDs from our KV index
-    const indexKey = 'moltlaunch:agents';
-    const indexRaw = await env.TASKS_KV.get(indexKey);
-    const agentIds: string[] = indexRaw ? JSON.parse(indexRaw) : [];
-
-    console.log(`[getAllAgents] Found ${agentIds.length} agents in KV index`);
-
-    if (agentIds.length === 0) {
-      return [];
-    }
-
-    // Fetch details for each agent
-    const agents: Agent[] = [];
-
-    for (const agentId of agentIds) {
-      const agent = await getAgentFromContract(rpcUrl, BigInt(agentId));
-      if (agent) {
-        // Fetch Flaunch market data and burn stats if available
-        if (agent.flaunchToken) {
-          const [flaunchData, totalBurnedETH, totalBurnedTokens, ethPrice] = await Promise.all([
-            getFlaunchData(agent.flaunchToken),
-            getTotalBurned(rpcUrl, agent.flaunchToken),
-            getTotalTokensBurned(rpcUrl, agent.flaunchToken),
-            getEthPrice(),
-          ]);
-          if (flaunchData) {
-            agent.marketCapUSD = flaunchData.marketCapUSD;
-            agent.volume24hUSD = flaunchData.volume24hUSD;
-            agent.priceChange24h = flaunchData.priceChange24h;
-            agent.liquidityUSD = flaunchData.liquidityUSD;
-            agent.holders = flaunchData.holders;
-            agent.image = flaunchData.image;
-            agent.symbol = flaunchData.symbol;
-            agent.flaunchUrl = `https://flaunch.gg/base/coin/${agent.flaunchToken}`;
-          }
-          if (totalBurnedETH > 0) {
-            agent.totalBurnedETH = totalBurnedETH;
-            agent.totalBurnedUSD = totalBurnedETH * ethPrice;
-          }
-          if (totalBurnedTokens > 0) {
-            agent.totalBurnedTokens = totalBurnedTokens;
-          }
-        }
-        agents.push(agent);
-      }
-    }
-
-    // Sort by market cap (if available) or agent ID
-    agents.sort((a, b) => {
-      if (a.marketCapUSD && b.marketCapUSD) {
-        return b.marketCapUSD - a.marketCapUSD;
-      }
-      if (a.marketCapUSD) return -1;
-      if (b.marketCapUSD) return 1;
-      return parseInt(b.agentIdBigInt) - parseInt(a.agentIdBigInt);
-    });
-
-    agentsCache = { agents, fetchedAt: now };
-    return agents;
-  } catch (err) {
-    console.error('Error fetching agents:', err);
-    return agentsCache?.agents ?? [];
-  }
-}
-
-/**
- * Get a single agent by ID
- */
-export async function getAgentById(env: Env, agentId: string): Promise<Agent | null> {
-  const rpcUrl = env.ALCHEMY_RPC || env.BASE_RPC || 'https://mainnet.base.org';
-  console.log('[getAgentById] Using RPC:', rpcUrl.substring(0, 50) + '...');
-  console.log('[getAgentById] Looking for agent:', agentId);
-
-  try {
-    // Parse agentId (can be hex or decimal)
-    const id = agentId.startsWith('0x') ? BigInt(agentId) : BigInt(agentId);
-    console.log('[getAgentById] Parsed ID:', id.toString());
-
-    const agent = await getAgentFromContract(rpcUrl, id);
-    console.log('[getAgentById] Got agent:', agent ? 'yes' : 'null');
-
-    if (agent && agent.flaunchToken) {
-      const [flaunchData, totalBurnedETH, totalBurnedTokens, ethPrice] = await Promise.all([
-        getFlaunchData(agent.flaunchToken),
-        getTotalBurned(rpcUrl, agent.flaunchToken),
-        getTotalTokensBurned(rpcUrl, agent.flaunchToken),
-        getEthPrice(),
-      ]);
-      if (flaunchData) {
-        agent.marketCapUSD = flaunchData.marketCapUSD;
-        agent.volume24hUSD = flaunchData.volume24hUSD;
-        agent.priceChange24h = flaunchData.priceChange24h;
-        agent.liquidityUSD = flaunchData.liquidityUSD;
-        agent.holders = flaunchData.holders;
-        agent.image = flaunchData.image;
-        agent.symbol = flaunchData.symbol;
-        agent.flaunchUrl = `https://flaunch.gg/base/coin/${agent.flaunchToken}`;
-      }
-      if (totalBurnedETH > 0) {
-        agent.totalBurnedETH = totalBurnedETH;
-        agent.totalBurnedUSD = totalBurnedETH * ethPrice;
-      }
-      if (totalBurnedTokens > 0) {
-        agent.totalBurnedTokens = totalBurnedTokens;
-      }
-    }
-
-    return agent;
-  } catch (err) {
-    console.error(`Error fetching agent ${agentId}:`, err);
-    return null;
-  }
-}