nyxora 1.6.13 → 1.7.1

package/packages/core/src/system/skills/searchWeb.ts

@@ -1,43 +1,209 @@
-import { search, SafeSearchType } from 'duck-duck-scrape';
+import { loadConfig, loadApiKeys } from '../../config/parser';
 
-export async function searchWeb(query: string): Promise<string> {
-  try {
-    const searchResults = await search(query, {
-      safeSearch: SafeSearchType.MODERATE
-    });
+interface SearchQueryResult {
+  title: string;
+  url: string;
+  content: string;
+}
+
+const SEARXNG_INSTANCES = [
+  'https://search.mdosch.de',
+  'https://searx.tiekoetter.com',
+  'https://paulgo.io',
+  'https://searx.be',
+  'https://searx.fmac.network'
+];
+
+async function searchTavily(query: string, apiKey: string, depth: number = 1): Promise<SearchQueryResult[]> {
+  const searchDepth = depth > 1 ? 'advanced' : 'basic';
+  const maxResults = depth > 1 ? 15 : 8;
+  const res = await fetch('https://api.tavily.com/search', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ api_key: apiKey, query, search_depth: searchDepth, max_results: maxResults })
+  });
+  
+  if (!res.ok) {
+    const status = res.status;
+    throw new Error(`[Tavily Error] Status: ${status}`);
+  }
+  
+  const json = await res.json();
+  if (!json.results) return [];
+  
+  return json.results.map((r: any) => ({
+    title: r.title,
+    url: r.url,
+    content: r.content
+  }));
+}
 
-    if (!searchResults.results || searchResults.results.length === 0) {
-      return "No results found for your query.";
+async function searchBrave(query: string, apiKey: string, depth: number = 1): Promise<SearchQueryResult[]> {
+  const q = encodeURIComponent(query);
+  const count = depth > 1 ? 15 : 8;
+  const res = await fetch(`https://api.search.brave.com/res/v1/web/search?q=${q}&count=${count}`, {
+    headers: {
+      'Accept': 'application/json',
+      'X-Subscription-Token': apiKey
     }
+  });
+  
+  if (!res.ok) {
+    const status = res.status;
+    throw new Error(`[Brave Error] Status: ${status}`);
+  }
+  
+  const json = await res.json();
+  if (!json.web || !json.web.results) return [];
+  
+  return json.web.results.map((r: any) => ({
+    title: r.title,
+    url: r.url,
+    content: r.description || r.title
+  }));
+}
 
-    // Limit to top 8 results
-    const topResults = searchResults.results.slice(0, 8);
-    
-    let responseText = `Search Results for "${query}":\n\n`;
-    
-    topResults.forEach((result, index) => {
-      responseText += `${index + 1}. ${result.title}\n`;
-      responseText += `URL: ${result.url}\n`;
-      responseText += `Snippet: ${result.description}\n\n`;
-    });
+async function searchSearxng(query: string, depth: number = 1): Promise<SearchQueryResult[]> {
+  const q = encodeURIComponent(query);
+  const maxResults = depth > 1 ? 15 : 8;
+  for (const url of SEARXNG_INSTANCES) {
+    try {
+      const res = await fetch(`${url}/search?q=${q}&format=json`, {
+        headers: { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)' },
+        signal: AbortSignal.timeout(4000)
+      });
+      
+      if (res.ok) {
+        const json = await res.json();
+        if (!json.results || json.results.length === 0) continue;
+        
+        return json.results.slice(0, maxResults).map((r: any) => ({
+          title: r.title || 'No title',
+          url: r.url || '#',
+          content: r.content || r.snippet || r.description || 'No description available'
+        }));
+      }
+    } catch (e) {
+      continue;
+    }
+  }
+  throw new Error('[SearXNG Error] All decentralized instances failed.');
+}
+
+const searchCache = new Map<string, {data: SearchQueryResult[], timestamp: number}>();
+
+export async function searchWeb(query: string, depth: number = 1): Promise<string> {
+  // Auto-inject current year for time-sensitive queries
+  const lowerQuery = query.toLowerCase();
+  const currentYear = new Date().getFullYear().toString();
+  let finalQuery = query;
+  
+  if ((lowerQuery.includes('hari ini') || lowerQuery.includes('sekarang') || lowerQuery.includes('today') || lowerQuery.includes('saat ini') || lowerQuery.includes('terbaru')) && !lowerQuery.includes(currentYear)) {
+    finalQuery = `${query} ${currentYear}`;
+    console.log(`[WebSearch] Auto-injected current year: "${finalQuery}"`);
+  }
 
+  const cacheKey = `${finalQuery.trim().toLowerCase()}_depth_${depth}`;
+  const cached = searchCache.get(cacheKey);
+  if (cached && (Date.now() - cached.timestamp < 300000)) {
+    console.log(`[WebSearch] Returning cached results for: "${finalQuery}" (Depth: ${depth})`);
+    let responseText = `Search Results for "${query}" (Cached):\n\n`;
+    cached.data.forEach((r, index) => {
+      responseText += `${index + 1}. ${r.title}\n`;
+      responseText += `URL: ${r.url}\n`;
+      responseText += `Snippet: ${r.content}\n\n`;
+    });
     return responseText.trim();
-  } catch (error: any) {
-    return `Failed to search the web: ${error.message}`;
   }
+
+  const config = loadConfig();
+  const provider = config.web_search?.provider || 'mesh';
+  const vaultKeys = await loadApiKeys();
+  const creds = Object.keys(vaultKeys).length > 0 ? vaultKeys : (config.credentials || {});
+  
+  let results: SearchQueryResult[] = [];
+  
+  try {
+    if (provider === 'tavily' && creds.tavily_key) {
+      try {
+        results = await searchTavily(finalQuery, creds.tavily_key, depth);
+      } catch (e: any) {
+        if (e.message.includes('401') || e.message.includes('429')) {
+          console.warn('[WebSearch] Primary provider (Tavily) failed with 429/401. Switching to backup provider (Brave Search)...');
+          if (creds.brave_key) {
+            try {
+              results = await searchBrave(finalQuery, creds.brave_key, depth);
+            } catch (e2: any) {
+              console.warn('[WebSearch] Backup provider (Brave) failed. Falling back to SearXNG Mesh...');
+              results = await searchSearxng(finalQuery, depth);
+            }
+          } else {
+            console.warn('[WebSearch] No backup provider found. Falling back to SearXNG Mesh...');
+            results = await searchSearxng(finalQuery, depth);
+          }
+        } else {
+          throw e;
+        }
+      }
+    } else if (provider === 'brave' && creds.brave_key) {
+      try {
+        results = await searchBrave(finalQuery, creds.brave_key, depth);
+      } catch (e: any) {
+        if (e.message.includes('403') || e.message.includes('429')) {
+          console.warn('[WebSearch] Primary provider (Brave) failed with 429/403. Switching to backup provider (Tavily)...');
+          if (creds.tavily_key) {
+            try {
+              results = await searchTavily(finalQuery, creds.tavily_key, depth);
+            } catch (e2: any) {
+              console.warn('[WebSearch] Backup provider (Tavily) failed. Falling back to SearXNG Mesh...');
+              results = await searchSearxng(finalQuery, depth);
+            }
+          } else {
+            console.warn('[WebSearch] No backup provider found. Falling back to SearXNG Mesh...');
+            results = await searchSearxng(finalQuery, depth);
+          }
+        } else {
+          throw e;
+        }
+      }
+    } else {
+      results = await searchSearxng(finalQuery, depth);
+    }
+  } catch (e: any) {
+    return `Failed to search the web: ${e.message}`;
+  }
+  
+  if (results.length > 0) {
+    searchCache.set(cacheKey, { data: results, timestamp: Date.now() });
+  } else {
+    return `Search Results for "${query}": No results found.`;
+  }
+  
+  let responseText = `Search Results for "${query}":\n\n`;
+  results.forEach((r, index) => {
+    responseText += `${index + 1}. ${r.title}\n`;
+    responseText += `URL: ${r.url}\n`;
+    responseText += `Snippet: ${r.content}\n\n`;
+  });
+  
+  return responseText.trim();
 }
 
 export const searchWebToolDefinition = {
   type: "function",
   function: {
     name: "search_web",
-    description: "Searches the internet for information using a search engine. Returns top titles, snippets, and URLs. Use this to find current events, documentation, or general facts.",
+    description: "Searches the internet for information using a search engine. Returns top titles, snippets, and URLs. Use this to find current events, documentation, or general facts. If the user asks for deep/comprehensive research, pass depth: 2 or 3.",
     parameters: {
       type: "object",
       properties: {
         query: {
           type: "string",
           description: "The search query to look up.",
+        },
+        depth: {
+          type: "number",
+          description: "Depth of the search (1 for basic, 2 or 3 for deep comprehensive research). Default is 1.",
         }
       },
       required: ["query"],

package/packages/core/src/utils/formatter.ts

@@ -1,6 +1,6 @@
 import { PendingTransaction } from '../agent/transactionManager';
 
-export function formatTransactionSuccess(tx: PendingTransaction, rawResult: string): string {
+export function formatTransactionSuccess(tx: PendingTransaction, rawResult: string, isIndonesian: boolean = false): string {
   let txHash = 'N/A';
   
   try {
@@ -15,13 +15,20 @@ export function formatTransactionSuccess(tx: PendingTransaction, rawResult: stri
 
   const chainFormatted = tx.chainName.charAt(0).toUpperCase() + tx.chainName.slice(1);
 
+  let actionText = '';
   if (tx.type === 'swap') {
-    return `Alright, I have completed the swap from ${tx.details.amount} ${tx.details.fromToken.toUpperCase()} to ${tx.details.toToken.toUpperCase()}.\n\nChain: ${chainFormatted}\nTx Hash:\n${txHash}`;
+    actionText = isIndonesian ? `Swap ${tx.details.amount} ${tx.details.fromToken.toUpperCase()} ke ${tx.details.toToken.toUpperCase()}` : `Swapped ${tx.details.amount} ${tx.details.fromToken.toUpperCase()} to ${tx.details.toToken.toUpperCase()}`;
   } else if (tx.type === 'transfer') {
-    return `Alright, I have completed the transfer of ${tx.details.amountEth} tokens to ${tx.details.toAddress}.\n\nChain: ${chainFormatted}\nTx Hash:\n${txHash}`;
+    actionText = isIndonesian ? `Transfer ${tx.details.amountEth} token ke <code>${tx.details.toAddress}</code>` : `Transferred ${tx.details.amountEth} tokens to <code>${tx.details.toAddress}</code>`;
+  } else {
+    actionText = isIndonesian ? 'Aksi Berhasil' : 'Action Successful';
+  }
+
+  if (isIndonesian) {
+    return `**Nama Chain:** ${chainFormatted}\n**Status:** Sukses (${actionText})\n**Tx Hash:** <code>${txHash}</code>`;
+  } else {
+    return `**Chain Name:** ${chainFormatted}\n**Status:** Success (${actionText})\n**Tx Hash:** <code>${txHash}</code>`;
   }
-  
-  return `Transaction successful!\n\nChain: ${chainFormatted}\nTx Hash:\n${txHash}`;
 }
 
 export function formatTransactionError(tx: PendingTransaction, errorMsg: string): string {

package/packages/core/src/web3/config.ts

@@ -1,5 +1,5 @@
 import { createPublicClient, http, fallback, PublicClient, Transport } from 'viem';
-import { mainnet, base, bsc, arbitrum, optimism, sepolia } from 'viem/chains';
+import { mainnet, base, bsc, arbitrum, optimism, sepolia, polygon } from 'viem/chains';
 import { loadConfig } from '../config/parser';
 
 export const supportedChains = {
@@ -9,8 +9,10 @@ export const supportedChains = {
   arbitrum: arbitrum,
   optimism: optimism,
   sepolia: sepolia,
+  polygon: polygon,
 };
 
+export const SUPPORTED_CHAIN_NAMES = Object.keys(supportedChains);
 export type ChainName = keyof typeof supportedChains;
 
 export function getPublicClient(chainName: ChainName): PublicClient {
@@ -53,6 +55,10 @@ export function getPublicClient(chainName: ChainName): PublicClient {
     } else if (chainName === 'sepolia') {
       transports.push(http('https://ethereum-sepolia-rpc.publicnode.com', { timeout: 5000 }));
       transports.push(http('https://rpc.sepolia.org', { timeout: 5000 }));
+    } else if (chainName === 'polygon') {
+      transports.push(http('https://polygon-rpc.publicnode.com', { timeout: 5000 }));
+      transports.push(http('https://polygon.llamarpc.com', { timeout: 5000 }));
+      transports.push(http('https://polygon-rpc.com', { timeout: 5000 }));
     }
   }
 

package/packages/core/src/web3/skills/bridgeToken.ts

@@ -1,5 +1,5 @@
 import { parseUnits, formatUnits } from 'viem';
-import { getPublicClient, getAddress, ChainName } from '../config';
+import { getPublicClient, getAddress, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { txManager } from '../../agent/transactionManager';
 import { resolveToken, ERC20_ABI } from '../utils/tokens';
 
@@ -10,6 +10,7 @@ const CHAIN_IDS: Record<ChainName, number> = {
   arbitrum: 42161,
   optimism: 10,
   sepolia: 11155111,
+  polygon: 137,
 };
 
 async function getLifiQuote(fromChainId: number, toChainId: number, fromToken: string, toToken: string, amountWei: string, userAddress: string, slippage: number) {
@@ -210,12 +211,12 @@ export const bridgeTokenToolDefinition = {
       properties: {
         fromChainName: {
           type: "string",
-          enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+          enum: SUPPORTED_CHAIN_NAMES,
           description: "The source blockchain network",
         },
         toChainName: {
           type: "string",
-          enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+          enum: SUPPORTED_CHAIN_NAMES,
           description: "The destination blockchain network",
         },
         fromToken: {

package/packages/core/src/web3/skills/checkAddress.ts

@@ -1,5 +1,5 @@
 import { isAddress } from 'viem';
-import { getPublicClient, ChainName } from '../config';
+import { getPublicClient, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 
 export async function checkAddress(chainName: ChainName, address: string): Promise<string> {
   try {
@@ -40,7 +40,7 @@ export const checkAddressToolDefinition = {
       properties: {
         chainName: {
           type: "string",
-          enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+          enum: SUPPORTED_CHAIN_NAMES,
           description: "The name of the blockchain to check the address on."
         },
         address: {

package/packages/core/src/web3/skills/checkPortfolio.ts

@@ -1,5 +1,5 @@
 import { formatEther, formatUnits } from 'viem';
-import { getPublicClient, ChainName } from '../config';
+import { getPublicClient, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { TOKEN_MAP, ERC20_ABI } from '../utils/tokens';
 
 const portfolioCache: Record<string, { data: string, timestamp: number }> = {};
@@ -60,51 +60,67 @@ export async function checkPortfolio(chainName: ChainName, address?: `0x${string
     let report = `📊 **Portfolio for ${targetAddress} on ${chainName.toUpperCase()}**\n\n`;
     let totalUsdValue = 0;
 
-    // We will do Promise.all for balances
-    const balancePromises = tokensToScan.map(async (t) => {
-      let balanceNum = 0;
+    // We will do True On-Chain Multicall with Chunking (max 30 tokens / 60 calls per batch)
+    const MULTICALL3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11';
+    const MULTICALL3_ABI = [{
+      inputs: [{ name: 'addr', type: 'address' }],
+      name: 'getEthBalance',
+      outputs: [{ name: 'balance', type: 'uint256' }],
+      stateMutability: 'view',
+      type: 'function',
+    }] as const;
+
+    const contracts: any[] = [];
+    for (const t of tokensToScan) {
       if (t.isNative) {
-        const bal = await client.getBalance({ address: targetAddress as `0x${string}` });
-        balanceNum = parseFloat(formatEther(bal));
+        contracts.push({ address: MULTICALL3_ADDRESS, abi: MULTICALL3_ABI, functionName: 'getEthBalance', args: [targetAddress as `0x${string}`] });
       } else {
-        try {
-          const [balanceWei, decimals] = await Promise.all([
-            // @ts-ignore
-            client.readContract({
-              address: t.address,
-              abi: ERC20_ABI,
-              functionName: 'balanceOf',
-              args: [targetAddress as `0x${string}`],
-            }) as Promise<bigint>,
-            // @ts-ignore
-            client.readContract({
-              address: t.address,
-              abi: ERC20_ABI,
-              functionName: 'decimals',
-            }) as Promise<number>
-          ]);
-          balanceNum = parseFloat(formatUnits(balanceWei, decimals));
-        } catch (e) {
-          balanceNum = 0;
-        }
+        contracts.push({ address: t.address, abi: ERC20_ABI, functionName: 'balanceOf', args: [targetAddress as `0x${string}`] });
+        contracts.push({ address: t.address, abi: ERC20_ABI, functionName: 'decimals' });
       }
-      return { ...t, balanceNum };
-    });
-
-    const timeoutPromise = new Promise<any[]>((_, reject) => 
-      setTimeout(() => reject(new Error('RPC request timed out')), 3000)
-    );
+    }
 
-    let balances: any[];
+    const CHUNK_SIZE = 60; // 30 tokens (2 calls per token)
+    const multicallResults: any[] = [];
+    
     try {
-      balances = await Promise.race([
-        Promise.all(balancePromises),
-        timeoutPromise
-      ]);
+      // Create a timeout promise for 5 seconds (more tolerant for large portfolios)
+      const timeoutPromise = new Promise<never>((_, reject) => 
+        setTimeout(() => reject(new Error('RPC request timed out')), 5000)
+      );
+
+      const executionPromise = (async () => {
+        for (let i = 0; i < contracts.length; i += CHUNK_SIZE) {
+          const chunk = contracts.slice(i, i + CHUNK_SIZE);
+          const res = await client.multicall({ contracts: chunk, allowFailure: true } as any);
+          multicallResults.push(...res);
+        }
+      })();
+
+      await Promise.race([executionPromise, timeoutPromise]);
     } catch (e: any) {
-      return `⚠️ **${chainName.toUpperCase()} Network is experiencing high latency.**\nThe public RPC failed to respond within 3 seconds. Please try again later.`;
+      return `⚠️ **${chainName.toUpperCase()} Network is experiencing high latency.**\nThe public RPC failed to respond. Please try again later.`;
     }
 
+    // Map results back to tokens
+    let resultIndex = 0;
+    const balances = tokensToScan.map((t) => {
+      let balanceNum = 0;
+      if (t.isNative) {
+        const balResult = multicallResults[resultIndex++];
+        if (balResult?.status === 'success' && balResult.result) {
+          balanceNum = parseFloat(formatEther(balResult.result as bigint));
+        }
+      } else {
+        const balResult = multicallResults[resultIndex++];
+        const decResult = multicallResults[resultIndex++];
+        if (balResult?.status === 'success' && balResult.result !== undefined && decResult?.status === 'success' && decResult.result !== undefined) {
+          balanceNum = parseFloat(formatUnits(balResult.result as bigint, Number(decResult.result)));
+        }
+      }
+      return { ...t, balanceNum };
+    });
+
     const nonZeroBalances = balances.filter(b => b.balanceNum > 0);
 
     if (nonZeroBalances.length === 0) {
@@ -165,7 +181,7 @@ export const checkPortfolioToolDefinition = {
       properties: {
         chainName: {
           type: "string",
-          enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+          enum: SUPPORTED_CHAIN_NAMES,
           description: "The blockchain network",
         },
         address: {

package/packages/core/src/web3/skills/checkSecurity.ts

@@ -1,4 +1,4 @@
-import { ChainName } from '../config';
+import { ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 
 const CHAIN_IDS: Record<ChainName, number> = {
   ethereum: 1,
@@ -7,6 +7,7 @@ const CHAIN_IDS: Record<ChainName, number> = {
   arbitrum: 42161,
   optimism: 10,
   sepolia: 11155111,
+  polygon: 137,
 };
 
 export async function checkTokenSecurity(chainName: ChainName, contractAddress: string): Promise<string> {
@@ -57,7 +58,7 @@ export const checkSecurityToolDefinition = {
       properties: {
         chainName: {
           type: "string",
-          enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+          enum: SUPPORTED_CHAIN_NAMES,
           description: "The blockchain network",
         },
         contractAddress: {

package/packages/core/src/web3/skills/customTx.ts

@@ -1,5 +1,5 @@
 import { parseEther } from 'viem';
-import { getPublicClient, getAddress, ChainName } from '../config';
+import { getPublicClient, getAddress, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { txManager } from '../../agent/transactionManager';
 
 export async function prepareCustomTx(
@@ -91,7 +91,7 @@ export const customTxToolDefinition = {
       properties: {
         chainName: {
           type: "string",
-          enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+          enum: SUPPORTED_CHAIN_NAMES,
           description: "The blockchain network",
         },
         toAddress: {

package/packages/core/src/web3/skills/getBalance.ts

@@ -1,5 +1,5 @@
 import { formatEther, formatUnits } from 'viem';
-import { getPublicClient, ChainName } from '../config';
+import { getPublicClient, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { ERC20_ABI, resolveToken } from '../utils/tokens';
 import { saveTokenToWhitelist } from '../../utils/userWhitelistManager';
 
@@ -72,8 +72,8 @@ export const getBalanceToolDefinition = {
       properties: {
         chainName: {
           type: "string",
-          enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
-          description: "The name of the blockchain to check."
+          enum: SUPPORTED_CHAIN_NAMES,
+          description: "The blockchain network"
         },
         address: {
           type: "string",

package/packages/core/src/web3/skills/marketAnalysis.ts

@@ -1,4 +1,4 @@
-import { ChainName } from '../config';
+import { ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { resolveToken } from '../utils/tokens';
 
 export async function analyzeMarket(chainName: ChainName, tokenAddressOrSymbol: string): Promise<string> {
@@ -85,7 +85,7 @@ export const marketAnalysisToolDefinition = {
       properties: {
         chainName: {
           type: "string",
-          enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+          enum: SUPPORTED_CHAIN_NAMES,
           description: "The blockchain network",
         },
         tokenAddressOrSymbol: {

package/packages/core/src/web3/skills/mintNft.ts

@@ -1,5 +1,5 @@
 import { parseAbi, parseEther } from 'viem';
-import { getPublicClient, getAddress, ChainName } from '../config';
+import { getPublicClient, getAddress, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { txManager } from '../../agent/transactionManager';
 
 export async function prepareMintNft(
@@ -120,7 +120,7 @@ export const mintNftToolDefinition = {
       properties: {
         chainName: {
           type: "string",
-          enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+          enum: SUPPORTED_CHAIN_NAMES,
           description: "The blockchain network",
         },
         contractAddress: {

package/packages/core/src/web3/skills/swapToken.ts

@@ -1,17 +1,18 @@
 import { parseUnits, formatUnits } from 'viem';
-import { getPublicClient, getAddress, ChainName } from '../config';
+import { getPublicClient, getAddress, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { txManager } from '../../agent/transactionManager';
 import { resolveToken, ERC20_ABI } from '../utils/tokens';
 import { saveTokenToWhitelist } from '../../utils/userWhitelistManager';
 import crypto from 'crypto';
 
-const CHAIN_IDS: Record<ChainName, number> = {
+const CHAIN_IDS: Record<string, number> = {
   ethereum: 1,
   base: 8453,
   bsc: 56,
   arbitrum: 42161,
   optimism: 10,
   sepolia: 11155111,
+  polygon: 137,
 };
 
 async function getLifiQuote(fromChainId: number, toChainId: number, fromToken: string, toToken: string, amountWei: string, userAddress: string, slippage: number) {
@@ -231,7 +232,7 @@ export const swapTokenToolDefinition = {
       properties: {
         chainName: {
           type: "string",
-          enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+          enum: SUPPORTED_CHAIN_NAMES,
           description: "The blockchain network",
         },
         fromToken: {

package/packages/core/src/web3/skills/transfer.ts

@@ -1,5 +1,5 @@
 import { parseEther, parseUnits } from 'viem';
-import { getPublicClient, getAddress, ChainName } from '../config';
+import { getPublicClient, getAddress, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { txManager } from '../../agent/transactionManager';
 import { resolveToken, ERC20_ABI } from '../utils/tokens';
 
@@ -120,7 +120,7 @@ export const transferToolDefinition = {
       properties: {
         chainName: {
           type: "string",
-          enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+          enum: SUPPORTED_CHAIN_NAMES,
           description: "The name of the blockchain to execute the transfer on."
         },
         toAddress: {

package/packages/core/src/web3/utils/tokens.ts

@@ -91,6 +91,14 @@ export const TOKEN_MAP: Record<ChainName, Record<string, `0x${string}`>> = {
     WETH: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
     USDC: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238", // Circle Faucet Sepolia USDC
     USDT: "0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0"  // Common Sepolia USDT
+  },
+  polygon: {
+    MATIC: "0x0000000000000000000000000000000000000000",
+    POL: "0x0000000000000000000000000000000000000000",
+    WMATIC: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+    WPOL: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+    USDC: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+    USDT: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F"
   }
 };