nyxora 26.6.20 → 26.6.21

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/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...).`);
 }