nyxora 26.6.19 → 26.6.21

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

@@ -1,8 +1,54 @@
 import fs from 'fs';
 import { getPath } from '../config/paths';
+import { loadConfig, saveConfig } from '../config/parser';
 
 let disabledSkillsCache: string[] | null = null;
 
+const reverseSkillMapping: Record<string, { category: 'os' | 'web3', name: string }> = {
+  // OS Skills
+  'read_local_file': { category: 'os', name: 'readFile' },
+  'write_local_file': { category: 'os', name: 'writeFile' },
+  'edit_local_file': { category: 'os', name: 'editFile' },
+  'generate_excel_file': { category: 'os', name: 'generateExcel' },
+  'analyze_document': { category: 'os', name: 'analyzeDocument' },
+  'run_terminal_command': { category: 'os', name: 'executeShell' },
+  'browse_website': { category: 'os', name: 'browseWeb' },
+  'search_web': { category: 'os', name: 'searchWeb' },
+  'read_gmail_inbox': { category: 'os', name: 'readGmail' },
+  'list_calendar_events': { category: 'os', name: 'listCalendar' },
+  'append_row_to_sheets': { category: 'os', name: 'appendSheets' },
+  'read_google_docs': { category: 'os', name: 'readDocs' },
+  'read_google_form_responses': { category: 'os', name: 'readForms' },
+  'execute_git_command': { category: 'os', name: 'gitManager' },
+  'manage_twitter': { category: 'os', name: 'xManager' },
+  'manage_notion': { category: 'os', name: 'notionWorkspace' },
+  'transcribe_audio': { category: 'os', name: 'audioTranscribe' },
+  'summarize_text': { category: 'os', name: 'summarizeText' },
+  'update_security_policy': { category: 'os', name: 'updateSecurityPolicy' },
+  
+  // Web3 Skills
+  'transfer_token': { category: 'web3', name: 'transfer' },
+  'transfer_native': { category: 'web3', name: 'transfer' },
+  'swap_token': { category: 'web3', name: 'swap' },
+  'bridge_token': { category: 'web3', name: 'bridge' },
+  'mint_nft': { category: 'web3', name: 'mintNft' },
+  'custom_tx': { category: 'web3', name: 'customTx' },
+  'check_address': { category: 'web3', name: 'checkAddress' },
+  'get_my_address': { category: 'web3', name: 'getMyAddress' },
+  'check_token_security': { category: 'web3', name: 'checkSecurity' },
+  'check_portfolio': { category: 'web3', name: 'checkPortfolio' },
+  'analyze_market': { category: 'web3', name: 'marketAnalysis' },
+  'manage_custom_tokens': { category: 'web3', name: 'manageCustomTokens' },
+  'get_price': { category: 'web3', name: 'getPrice' },
+  'supply_aave': { category: 'web3', name: 'aaveSupply' },
+  'revoke_approval': { category: 'web3', name: 'revokeApproval' },
+  'deposit_yield_vault': { category: 'web3', name: 'vaultDeposit' },
+  'provide_liquidity_v3': { category: 'web3', name: 'provideLiquidity' },
+  'get_tx_history': { category: 'web3', name: 'getTxHistory' },
+  'check_registry_status': { category: 'web3', name: 'checkRegistryStatus' },
+  'create_limit_order': { category: 'web3', name: 'createLimitOrder' }
+};
+
 function getDisabledSkillsFile(): string {
   return getPath('disabled_skills.json');
 }
@@ -36,9 +82,61 @@ export function toggleSkill(skillName: string, active: boolean): void {
   }
   disabledSkillsCache = Array.from(current);
   fs.writeFileSync(getDisabledSkillsFile(), JSON.stringify(disabledSkillsCache, null, 2));
+
+  // Sync to config.yaml
+  const mapping = reverseSkillMapping[skillName];
+  if (mapping) {
+    const config = loadConfig();
+    if (!config.skills) config.skills = { web3: [], os: [] } as any;
+    
+    const categoryArray = mapping.category === 'web3' ? config.skills!.web3 : config.skills!.os;
+    
+    if (active && !categoryArray.includes(mapping.name)) {
+      categoryArray.push(mapping.name);
+    } else if (!active) {
+      const index = categoryArray.indexOf(mapping.name);
+      if (index !== -1) {
+        categoryArray.splice(index, 1);
+      }
+    }
+    
+    saveConfig(config);
+  }
 }
 
 export function isSkillActive(skillName: string): boolean {
   const disabled = getDisabledSkills();
   return !disabled.includes(skillName);
 }
+
+export function syncAllSkillsToConfig(): void {
+  const config = loadConfig();
+  if (!config.skills) config.skills = { web3: [], os: [] } as any;
+
+  const activeWeb3 = new Set<string>();
+  const activeOs = new Set<string>();
+
+  for (const [skillName, mapping] of Object.entries(reverseSkillMapping)) {
+    if (isSkillActive(skillName)) {
+      if (mapping.category === 'web3') {
+        activeWeb3.add(mapping.name);
+      } else {
+        activeOs.add(mapping.name);
+      }
+    }
+  }
+
+  // Check if arrays are different to avoid unnecessary saves
+  const currentWeb3 = config.skills!.web3 || [];
+  const currentOs = config.skills!.os || [];
+
+  const web3Changed = currentWeb3.length !== activeWeb3.size || !currentWeb3.every(s => activeWeb3.has(s));
+  const osChanged = currentOs.length !== activeOs.size || !currentOs.every(s => activeOs.has(s));
+
+  if (web3Changed || osChanged) {
+    config.skills!.web3 = Array.from(activeWeb3);
+    config.skills!.os = Array.from(activeOs);
+    saveConfig(config);
+    console.log('[SkillManager] Automatically synchronized active skills to config.yaml');
+  }
+}

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

@@ -1,12 +1,17 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import yaml from 'yaml';
+import { getPublicClient, ChainName } from '../web3/config';
+import { getTokenMetadata } from '../web3/utils/tokens';
 
-const WHITELIST_FILE_PATH = path.join(os.homedir(), '.nyxora', 'user_whitelist.json');
+const WHITELIST_FILE_PATH = path.join(os.homedir(), '.nyxora', 'user_whitelist.yaml');
 
 export interface WhitelistedToken {
   chainName: string;
   address: string;
+  symbol?: string;
+  decimals?: number;
   source: 'manual' | 'explorer' | 'swap';
   lastSeen: number;
 }
@@ -18,70 +23,74 @@ export interface UserWhitelist {
 export function getUserWhitelist(): UserWhitelist {
   try {
     if (!fs.existsSync(WHITELIST_FILE_PATH)) {
+      // Try migrating from JSON if YAML doesn't exist yet
+      const oldJsonPath = path.join(os.homedir(), '.nyxora', 'user_whitelist.json');
+      if (fs.existsSync(oldJsonPath)) {
+        const data = fs.readFileSync(oldJsonPath, 'utf-8');
+        const parsed = JSON.parse(data);
+        fs.writeFileSync(WHITELIST_FILE_PATH, yaml.stringify(parsed), 'utf-8');
+        // Rename old file so it doesn't get used again
+        fs.renameSync(oldJsonPath, `${oldJsonPath}.bak`);
+        return parsed;
+      }
       return {};
     }
     const data = fs.readFileSync(WHITELIST_FILE_PATH, 'utf-8');
-    const parsed = JSON.parse(data);
-
-    // Auto-migrate legacy format
-    let migrated = false;
-    for (const addr in parsed) {
-      if (parsed[addr] && !Array.isArray(parsed[addr])) {
-        const newArray: WhitelistedToken[] = [];
-        for (const chain in parsed[addr]) {
-          const tokens = parsed[addr][chain];
-          if (Array.isArray(tokens)) {
-            for (const t of tokens) {
-              newArray.push({
-                chainName: chain,
-                address: typeof t === 'string' ? t.toLowerCase() : (t.address || '').toLowerCase(),
-                source: 'manual',
-                lastSeen: Date.now()
-              });
-            }
-          }
-        }
-        parsed[addr] = newArray;
-        migrated = true;
-      }
-    }
-
-    if (migrated) {
-      fs.writeFileSync(WHITELIST_FILE_PATH, JSON.stringify(parsed, null, 2), 'utf-8');
-    }
-
-    return parsed;
+    return yaml.parse(data) || {};
   } catch (err) {
-    console.error('[Whitelist] Error reading user_whitelist.json', err);
+    console.error('[Whitelist] Error reading user_whitelist.yaml', err);
     return {};
   }
 }
 
-export function saveTokenToWhitelist(walletAddress: string, chainName: string, tokenAddress: string, source: 'manual' | 'explorer' | 'swap' = 'manual') {
+export async function saveTokenToWhitelist(
+  walletAddress: string, 
+  chainName: ChainName, 
+  tokenAddress: string, 
+  source: 'manual' | 'explorer' | 'swap' = 'manual',
+  symbol?: string,
+  decimals?: number
+) {
   try {
     const whitelist = getUserWhitelist();
     const addr = walletAddress.toLowerCase();
     const tokenAddr = tokenAddress.toLowerCase();
 
+    // Auto-fetch metadata if not provided
+    if (!symbol || decimals === undefined) {
+      try {
+        const client = getPublicClient(chainName);
+        const metadata = await getTokenMetadata(client, tokenAddr as `0x${string}`);
+        symbol = metadata.symbol;
+        decimals = metadata.decimals;
+      } catch (err) {
+        console.warn(`[Whitelist] Could not fetch metadata for ${tokenAddr} on ${chainName}`, err);
+      }
+    }
+
     if (!whitelist[addr]) whitelist[addr] = [];
 
     const existingIndex = whitelist[addr].findIndex(t => t.chainName === chainName && t.address === tokenAddr);
     
     if (existingIndex >= 0) {
       whitelist[addr][existingIndex].lastSeen = Date.now();
+      if (symbol) whitelist[addr][existingIndex].symbol = symbol;
+      if (decimals !== undefined) whitelist[addr][existingIndex].decimals = decimals;
     } else {
       whitelist[addr].push({
         chainName,
         address: tokenAddr,
+        symbol,
+        decimals,
         source,
         lastSeen: Date.now()
       });
-      console.log(`[Whitelist] Added ${tokenAddr} to ${chainName} for ${addr} via ${source}`);
+      console.log(`[Whitelist] Added ${symbol || tokenAddr} to ${chainName} for ${addr} via ${source}`);
     }
 
-    fs.writeFileSync(WHITELIST_FILE_PATH, JSON.stringify(whitelist, null, 2), 'utf-8');
+    fs.writeFileSync(WHITELIST_FILE_PATH, yaml.stringify(whitelist), 'utf-8');
   } catch (err) {
-    console.error('[Whitelist] Error saving token to user_whitelist.json', err);
+    console.error('[Whitelist] Error saving token to user_whitelist.yaml', err);
   }
 }
 
@@ -97,11 +106,11 @@ export function removeTokenFromWhitelist(walletAddress: string, chainName: strin
     whitelist[addr] = whitelist[addr].filter(t => !(t.chainName === chainName && t.address === tokenAddr));
     
     if (whitelist[addr].length !== initialLength) {
-      fs.writeFileSync(WHITELIST_FILE_PATH, JSON.stringify(whitelist, null, 2), 'utf-8');
-      console.log(`[Whitelist] Removed garbage token ${tokenAddr} on ${chainName} for ${addr}`);
+      fs.writeFileSync(WHITELIST_FILE_PATH, yaml.stringify(whitelist), 'utf-8');
+      console.log(`[Whitelist] Removed token ${tokenAddr} on ${chainName} for ${addr}`);
     }
   } catch (err) {
-    console.error('[Whitelist] Error removing token from user_whitelist.json', err);
+    console.error('[Whitelist] Error removing token from user_whitelist.yaml', err);
   }
 }
 

package/packages/core/src/web3/aggregator/aggregatorMainnet.ts

@@ -74,8 +74,8 @@ export async function fetchMainnetBestRoute(
     promises.push(fetchOpenOcean(fromChain, toChain, fromToken, toToken, amountInWei, userAddress, slippageTolerance, keys.openocean_key));
   }
 
-  // Provider 6: KyberSwap (Cross-chain & Same-chain)
-  if (isProviderHealthy('kyberswap')) {
+  // Provider 6: KyberSwap (Same-chain ONLY)
+  if (!isCrossChain && isProviderHealthy('kyberswap')) {
     promises.push(fetchKyberSwap(fromChain, fromToken, toToken, amountInWei, userAddress, slippageTolerance));
   }
 

package/packages/core/src/web3/aggregator/defiRouter.ts

@@ -12,6 +12,10 @@ export async function routeTransaction(
   slippageTolerance: number | "auto" = "auto"
 ): Promise<RouteQuote> {
 
+  if (!fromChain || !toChain) {
+    throw new Error("Missing source or destination chain in routing.");
+  }
+
   // Auto-correct: If one is testnet and the other is mainnet, assume they meant testnet
   if (fromChain.includes('sepolia') && !toChain.includes('sepolia')) {
     if (toChain === 'base') toChain = 'base_sepolia';

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

@@ -15,6 +15,9 @@ export async function prepareBridgeToken(
   slippagePercent?: number | "auto"
 ): Promise<string> {
   try {
+    if (!fromChain || !toChain) throw new Error("Source or destination chain not provided by AI.");
+    if (!amountStr) throw new Error("Bridge amount not provided by AI.");
+    
     const userAddress = await getAddress();
 
     // Auto-correct: If one is testnet and the other is mainnet, assume they meant testnet

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

@@ -83,3 +83,16 @@ export async function checkRegistryStatus(): Promise<{ isActive: boolean; reason
     return { isActive: true, reason: 'Registry check skipped due to network error.' };
   }
 }
+
+export const checkRegistryStatusToolDefinition = {
+  type: "function",
+  function: {
+    name: "check_registry_status",
+    description: "Internal Security Middleware: Checks the On-Chain Kill Switch Registry before executing any transaction. If the agent is deactivated, the transaction will be strictly blocked for safety.",
+    parameters: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  }
+};

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

@@ -10,6 +10,7 @@ export async function prepareCustomTx(
   description: string = "Custom transaction"
 ): Promise<string> {
   try {
+    if (!chainName || !toAddress || !data) throw new Error("Missing required parameters for custom transaction.");
     const tx = txManager.createPendingTransaction('custom', chainName, {
       toAddress,
       data,

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

@@ -31,6 +31,7 @@ const AAVE_V3_POOLS: Record<string, `0x${string}`> = {
 
 export async function prepareAaveSupply(chainName: ChainName, tokenAddressOrSymbol: string, amountStr: string): Promise<string> {
   try {
+    if (!chainName || !tokenAddressOrSymbol || !amountStr) throw new Error("Missing protocol/chain/token parameters for DeFi operation.");
     const publicClient = getPublicClient(chainName);
     const userAddress = await getAddress();
     const account = userAddress as `0x${string}`;

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

@@ -11,6 +11,10 @@ export const getPriceToolDefinition = {
         coinId: {
           type: "string",
           description: "The CoinGecko ID of the coin (e.g., 'ethereum', 'bitcoin', 'solana')."
+        },
+        currency: {
+          type: "string",
+          description: "The fiat currency to convert to (e.g., 'usd', 'idr', 'eur', 'jpy'). Defaults to 'usd'."
         }
       },
       required: ["coinId"]
@@ -18,25 +22,26 @@ export const getPriceToolDefinition = {
   }
 };
 
-export async function getPrice(coinId: string): Promise<string> {
+export async function getPrice(coinId: string, currency: string = 'usd'): Promise<string> {
   try {
-    const url = `https://api.coingecko.com/api/v3/simple/price?ids=${coinId}&vs_currencies=usd&include_24hr_change=true`;
+    const cur = currency.toLowerCase();
+    const url = `https://api.coingecko.com/api/v3/simple/price?ids=${coinId}&vs_currencies=${cur}&include_24hr_change=true`;
     const data = await safeFetchJson<any>(url);
     
     if (!data[coinId]) {
       return `❌ Could not find price data for **${coinId.toUpperCase()}**. Please verify the coin name.`;
     }
 
-    const price = data[coinId].usd;
-    const change24h = data[coinId].usd_24h_change;
+    const price = data[coinId][cur];
+    const change24h = data[coinId][`${cur}_24h_change`];
     
     const isPositive = change24h >= 0;
     const arrow = isPositive ? '📈 🟩 +' : '📉 🟥 ';
-    const priceFormatted = new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(price);
+    const priceFormatted = new Intl.NumberFormat(cur === 'idr' ? 'id-ID' : 'en-US', { style: 'currency', currency: cur.toUpperCase() }).format(price);
     const changeFormatted = change24h ? change24h.toFixed(2) : '0.00';
 
     return `💰 **Price Update for ${coinId.toUpperCase()}**\n\n` +
-           `- **Price (USD)**: \`${priceFormatted}\`\n` +
+           `- **Price (${cur.toUpperCase()})**: \`${priceFormatted}\`\n` +
            `- **24h Change**: ${arrow}${changeFormatted}%`;
   } catch (error: any) {
     return `❌ **Failed to fetch price:** ${error.message}`;

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

@@ -1,13 +1,12 @@
-import fs from 'fs';
-import path from 'path';
-import { getPath } from '../../config/paths';
 import { SUPPORTED_CHAIN_NAMES, ChainName } from '../config';
+import { saveTokenToWhitelist, removeTokenFromWhitelist } from '../../utils/userWhitelistManager';
+import { getAddress } from '../utils/vaultClient';
 
 export const manageCustomTokensDefinition = {
   type: 'function',
   function: {
     name: 'manage_custom_tokens',
-    description: 'Add or remove a custom ERC-20 token (like a memecoin or specific token) from the user\'s local portfolio watcher.',
+    description: 'Add or remove a custom ERC-20 token (like a memecoin or specific token) from the user\'s local portfolio watcher and swap whitelist.',
     parameters: {
       type: 'object',
       properties: {
@@ -27,10 +26,10 @@ export const manageCustomTokensDefinition = {
         },
         contract_address: {
           type: 'string',
-          description: 'The smart contract address of the token. Only required for "add" action.'
+          description: 'The smart contract address of the token. Required for "add" action or "remove" action.'
         }
       },
-      required: ['action', 'chain_name', 'symbol']
+      required: ['action', 'chain_name', 'symbol', 'contract_address']
     }
   }
 };
@@ -38,43 +37,33 @@ export const manageCustomTokensDefinition = {
 export async function executeManageCustomTokens(args: any): Promise<string> {
   const { action, chain_name, symbol, contract_address } = args;
 
-  if (!SUPPORTED_CHAIN_NAMES.includes(chain_name)) {
-    return `Error: Unsupported chain ${chain_name}.`;
+  if (!chain_name) {
+    throw new Error("Chain name is required.");
   }
 
-  const customTokensPath = getPath('custom_tokens.json');
-  let customTokens: Record<string, Record<string, string>> = {};
-
-  if (fs.existsSync(customTokensPath)) {
-    try {
-      const data = fs.readFileSync(customTokensPath, 'utf8');
-      customTokens = JSON.parse(data);
-    } catch (e) {
-      console.error('Error parsing custom_tokens.json', e);
-    }
+  if (!symbol) {
+    throw new Error("Token symbol is required.");
   }
 
-  if (!customTokens[chain_name]) {
-    customTokens[chain_name] = {};
+  if (!SUPPORTED_CHAIN_NAMES.includes(chain_name as ChainName)) {
+    return `Error: Unsupported chain ${chain_name}.`;
   }
 
   const upperSymbol = symbol.toUpperCase();
+  const userAddress = await getAddress();
 
   if (action === 'add') {
     if (!contract_address || !contract_address.startsWith('0x')) {
       return `Error: Invalid or missing contract_address.`;
     }
-    customTokens[chain_name][upperSymbol] = contract_address;
-    fs.writeFileSync(customTokensPath, JSON.stringify(customTokens, null, 2));
-    return `Successfully added custom token ${upperSymbol} to the ${chain_name} portfolio tracker.`;
+    await saveTokenToWhitelist(userAddress, chain_name as ChainName, contract_address, 'manual', upperSymbol);
+    return `Successfully added custom token ${upperSymbol} to the ${chain_name} portfolio tracker and swap whitelist.`;
   } else if (action === 'remove') {
-    if (customTokens[chain_name][upperSymbol]) {
-      delete customTokens[chain_name][upperSymbol];
-      fs.writeFileSync(customTokensPath, JSON.stringify(customTokens, null, 2));
-      return `Successfully removed custom token ${upperSymbol} from the ${chain_name} portfolio tracker.`;
-    } else {
-      return `Warning: Token ${upperSymbol} was not found in the custom portfolio tracker for ${chain_name}.`;
+    if (!contract_address || !contract_address.startsWith('0x')) {
+      return `Error: Invalid or missing contract_address for removal.`;
     }
+    removeTokenFromWhitelist(userAddress, chain_name, contract_address);
+    return `Successfully removed custom token ${upperSymbol} from the ${chain_name} whitelist.`;
   }
 
   return `Error: Invalid action.`;

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

@@ -47,7 +47,7 @@ async function fetchDexData(query: string, isCa: boolean, chainName?: ChainName)
     if (data && data.pairs && data.pairs.length > 0) {
         let pairs = data.pairs;
         if (chainName) {
-            pairs = pairs.filter((p: any) => p.chainId.toLowerCase() === chainName.toLowerCase());
+            pairs = pairs.filter((p: any) => p.chainId?.toLowerCase() === chainName?.toLowerCase());
             if (pairs.length === 0) pairs = data.pairs;
         }
         return pairs.sort((a: any, b: any) => (b.volume?.h24 || 0) - (a.volume?.h24 || 0))[0];
@@ -82,6 +82,7 @@ async function fetchCexMomentum(symbol: string, currentP: number) {
 
 export async function analyzeMarket(chainName: ChainName, tokenAddressOrSymbol: string): Promise<string> {
   try {
+    if (!tokenAddressOrSymbol) throw new Error("Token symbol is invalid.");
     const cleanInput = tokenAddressOrSymbol.replace('$', '').toLowerCase();
     const isAddress = cleanInput.startsWith('0x') && cleanInput.length === 42;
     

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

@@ -10,6 +10,7 @@ export async function prepareMintNft(
   valueEth: string = "0"
 ): Promise<string> {
   try {
+    if (!chainName || !contractAddress || !functionSignature) throw new Error("Missing required parameters to mint NFT.");
     const publicClient = getPublicClient(chainName);
     const userAddress = await getAddress();
     const account = userAddress as `0x${string}`;

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

@@ -62,6 +62,7 @@ export async function prepareProvideLiquidity(
     slippagePercent?: number | "auto"
 ): Promise<string> {
   try {
+    if (!chainName || !token0AddressOrSymbol || !token1AddressOrSymbol || !amount0Str || !amount1Str) throw new Error("Missing protocol/chain/token parameters for DeFi operation.");
     let actualSlippage = slippagePercent;
     if (actualSlippage === undefined || actualSlippage === null || actualSlippage === "auto") {
       try {

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

@@ -7,6 +7,7 @@ import { resolveToken, ERC20_ABI, getTokenMetadata } from '../utils/tokens';
 
 export async function prepareRevokeApproval(chainName: ChainName, tokenAddressOrSymbol: string, spenderAddress: `0x${string}`): Promise<string> {
   try {
+    if (!chainName || !tokenAddressOrSymbol || !spenderAddress) throw new Error("Missing required parameters for revoking approval.");
     const publicClient = getPublicClient(chainName);
     const userAddress = await getAddress();
     const account = userAddress as `0x${string}`;

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

@@ -16,6 +16,7 @@ export async function prepareSwapToken(
   slippagePercent?: number | "auto"
 ): Promise<string> {
   try {
+    if (!chainName || !fromToken || !toToken || !amountStr) throw new Error("Missing required parameters for swap (chain, tokens, or amount).");
     const userAddress = await getAddress();
     
     const fromTokenAddress = resolveToken(fromToken, chainName);
@@ -23,9 +24,9 @@ export async function prepareSwapToken(
     const isNativeIn = fromTokenAddress === "0x0000000000000000000000000000000000000000";
 
     // Auto-save to Degen Whitelist
-    if (!isNativeIn) saveTokenToWhitelist(userAddress, chainName, fromTokenAddress, 'swap');
+    if (!isNativeIn) await saveTokenToWhitelist(userAddress, chainName, fromTokenAddress, 'swap');
     if (toTokenAddress !== "0x0000000000000000000000000000000000000000") {
-      saveTokenToWhitelist(userAddress, chainName, toTokenAddress, 'swap');
+      await saveTokenToWhitelist(userAddress, chainName, toTokenAddress, 'swap');
     }
 
     // Default to 18 decimals for formatting input, though Aggregator handles this if we pass raw

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

@@ -6,6 +6,7 @@ import { submitTransaction } from '../utils/vaultClient';
 
 export async function prepareTransfer(chainName: ChainName, toAddress: `0x${string}`, amountStr: string, token?: string): Promise<string> {
   try {
+    if (!chainName || !toAddress || !amountStr) throw new Error("Missing required parameters for transfer (chain, recipient, or amount).");
     const publicClient = getPublicClient(chainName);
     const userAddress = await getAddress();
     const account = userAddress as `0x${string}`;

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

@@ -23,6 +23,7 @@ const VAULT_ABI = [
 
 export async function prepareVaultDeposit(chainName: ChainName, protocol: string, vaultAddress: `0x${string}`, tokenAddressOrSymbol: string, amountStr: string): Promise<string> {
   try {
+    if (!chainName || !vaultAddress || !tokenAddressOrSymbol || !amountStr) throw new Error("Missing protocol/chain/token parameters for DeFi operation.");
     const publicClient = getPublicClient(chainName);
     const userAddress = await getAddress();
     const account = userAddress as `0x${string}`;

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

@@ -1,4 +1,5 @@
 import { ChainName } from '../config';
+import { getUserWhitelist } from '../../utils/userWhitelistManager';
 
 export const ERC20_ABI = [
   {
@@ -72,7 +73,7 @@ export const TOKEN_MAP: Record<ChainName, Record<string, `0x${string}`>> = {
     ETH: "0x0000000000000000000000000000000000000000",
     WETH: "0x4200000000000000000000000000000000000006",
     USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    USDT: "0xf55BEC9cbd4732f1F4143f647652e924540d9d64"
+    USDT: "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2"
   },
   optimism: {
     ETH: "0x0000000000000000000000000000000000000000",
@@ -127,6 +128,13 @@ export function resolveToken(tokenSymbolOrAddress: string, chainName: ChainName)
     return chainTokens[symbolUpper];
   }
 
+  const whitelistData = getUserWhitelist();
+  for (const addr in whitelistData) {
+    const tokens = whitelistData[addr];
+    const match = tokens.find(t => t.chainName === chainName && t.symbol === symbolUpper);
+    if (match) return match.address as `0x${string}`;
+  }
+
   throw new Error(`Token "${tokenSymbolOrAddress}" pada chain ${chainName} tidak ditemukan. Silakan gunakan alamat kontrak langsung (0x...).`);
 }