nyxora 26.7.2 → 26.7.3

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

@@ -1,10 +1,11 @@
 import { parseUnits, formatUnits } from 'viem';
-import { ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
+import { ChainName, SUPPORTED_CHAIN_NAMES, normalizeChainName } from '../config';
 import { getAddress, submitTransaction } from '../utils/vaultClient';
 import { txManager } from '../../agent/transactionManager';
 import { resolveToken } from '../utils/tokens';
 import { routeTransaction } from '../aggregator/defiRouter';
-
+import { logger } from '../../memory/logger';
+import { loadConfig } from '../../config/parser';
 export async function prepareBridgeToken(
   fromChain: ChainName, 
   toChain: ChainName, 
@@ -15,8 +16,8 @@ export async function prepareBridgeToken(
   slippagePercent?: number | "auto"
 ): Promise<string> {
   try {
-    fromChain = String(fromChain || "") as ChainName;
-    toChain = String(toChain || "") as ChainName;
+    fromChain = normalizeChainName(fromChain);
+    toChain = normalizeChainName(toChain);
     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.");
     
@@ -52,8 +53,21 @@ export async function prepareBridgeToken(
     }
 
     const amountWei = parseUnits(amountStr, decimals).toString(); 
-    const slippage = slippagePercent || "auto"; 
-
+    
+    // Front-to-Back Slippage Architecture
+    const userProfile = logger.getUserProfile();
+    const maxSlippage = userProfile?.max_slippage || 1.0;
+    const config = loadConfig();
+    const cfgSlippage = (config.agent as any)?.default_slippage;
+    
+    let finalSlippage = slippagePercent;
+    if (finalSlippage === undefined || finalSlippage === null || finalSlippage === "auto") {
+        finalSlippage = (cfgSlippage === "auto" || !cfgSlippage) ? 0.5 : parseFloat(cfgSlippage as string);
+    }
+    
+    if (typeof finalSlippage !== 'number' || isNaN(finalSlippage)) finalSlippage = 0.5;
+    if (finalSlippage > maxSlippage) finalSlippage = maxSlippage;
+    const slippage = finalSlippage;
     // --- Pre-flight Balance Check ---
     const { validateTransactionBalances } = await import('../utils/balanceChecker');
     const balanceCheck = await validateTransactionBalances(fromChain, userAddress, fromTokenAddress, amountWei);
@@ -111,7 +125,7 @@ export const bridgeTokenToolDefinition = {
         tokenSymbol: { type: "string" },
         amountStr: { type: "string" },
         mode: { type: "string", enum: ["auto", "manual"], default: "auto" },
-        providerName: { type: "string", enum: ["auto", "lifi", "relay"], default: "auto" },
+        providerName: { type: "string", enum: ["auto", "lifi", "relay", "op_bridge_testnet", "arbitrum_bridge_testnet"], default: "auto", description: "The preferred provider. Use 'op_bridge_testnet' (for OP/Base Sepolia), 'arbitrum_bridge_testnet' (for Arb Sepolia), or 'relay' (testnet fallback)." },
         slippagePercent: { type: "number" }
       },
       required: ["fromChain", "toChain", "tokenSymbol", "amountStr"],

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

@@ -1,8 +1,10 @@
+import { normalizeChainName } from '../utils/chains';
 import { isAddress } from 'viem';
 import { getPublicClient, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 
 export async function checkAddress(chainName: ChainName, address: string): Promise<string> {
   try {
+    chainName = normalizeChainName(chainName);
     if (!isAddress(address)) {
       return `Address validation failed: '${address}' is not a valid Web3 address format.`;
     }

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

@@ -1,3 +1,4 @@
+import { normalizeChainName } from '../utils/chains';
 import { formatEther, formatUnits } from 'viem';
 import { getPublicClient, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { TOKEN_MAP, ERC20_ABI } from '../utils/tokens';
@@ -8,6 +9,7 @@ const CACHE_TTL = 5000; // 5 seconds TTL
 
 export async function checkPortfolio(chainName: ChainName, address?: `0x${string}`): Promise<string> {
   try {
+    chainName = normalizeChainName(chainName);
     const client = getPublicClient(chainName);
     
     let targetAddress = address;
@@ -139,9 +141,28 @@ export async function checkPortfolio(chainName: ChainName, address?: `0x${string
       try {
         const data = await safeFetchJson<any>(url);
         if (data.pairs) {
+          data.pairs.sort((a: any, b: any) => (b.liquidity?.usd || 0) - (a.liquidity?.usd || 0));
+          const chainMatched = new Set<string>();
+
           data.pairs.forEach((p: any) => {
-            if (!priceMap[String(p.baseToken.address).toLowerCase()]) {
-               priceMap[String(p.baseToken.address).toLowerCase()] = parseFloat(p.priceUsd);
+            const baseAddr = String(p.baseToken?.address || "").toLowerCase();
+            const quoteAddr = String(p.quoteToken?.address || "").toLowerCase();
+            const priceUsd = parseFloat(p.priceUsd || "0");
+            const priceNative = parseFloat(p.priceNative || "0");
+
+            if (baseAddr && priceUsd > 0) {
+               if (!priceMap[baseAddr] || (!chainMatched.has(baseAddr) && p.chainId === chainName)) {
+                 priceMap[baseAddr] = priceUsd;
+                 if (p.chainId === chainName) chainMatched.add(baseAddr);
+               }
+            }
+            
+            if (quoteAddr && priceUsd > 0 && priceNative > 0) {
+               const quotePriceUsd = priceUsd / priceNative;
+               if (!priceMap[quoteAddr] || (!chainMatched.has(quoteAddr) && p.chainId === chainName)) {
+                 priceMap[quoteAddr] = quotePriceUsd;
+                 if (p.chainId === chainName) chainMatched.add(quoteAddr);
+               }
             }
           });
         }

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

@@ -1,3 +1,4 @@
+import { normalizeChainName } from '../utils/chains';
 import { ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { safeFetchJson } from '../../utils/httpClient';
 
@@ -16,6 +17,7 @@ const CHAIN_IDS: Record<ChainName, number> = {
 
 export async function checkTokenSecurity(chainName: ChainName, contractAddress: string): Promise<string> {
   try {
+    chainName = normalizeChainName(chainName);
     const chainId = CHAIN_IDS[chainName];
     if (chainName === 'sepolia') {
       return `Security check API (GoPlus) does not support Sepolia testnet. Try a mainnet token.`;

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

@@ -78,7 +78,7 @@ export const confirmPendingTxToolDefinition = {
   type: "function",
   function: {
     name: "confirm_pending_tx",
-    description: "Approve or reject a pending transaction. Use this tool when a transaction has been queued and the user replies with a confirmation (like 'Yes' or 'Ya') or a rejection (like 'No' or 'Tidak').",
+    description: "Approve or reject a pending transaction. Use this tool when a transaction has been queued and the user replies with a confirmation (like 'Yes' or 'Ya') or a rejection (like 'No' or 'Tidak'). CRITICAL RULE: DO NOT call any other tool (like write_local_file) simultaneously with this one. Output ONLY this tool.",
     parameters: {
       type: "object",
       properties: {

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

@@ -1,6 +1,7 @@
+import { normalizeChainName } from '../utils/chains';
 import { logger } from '../../memory/logger';
 import { txManager } from '../../agent/transactionManager';
-
+import { loadConfig } from '../../config/parser';
 export async function createLimitOrder(
   tokenSymbol: string,
   tokenAddress: string,
@@ -11,6 +12,20 @@ export async function createLimitOrder(
   slippageTolerance?: number
 ): Promise<string> {
   try {
+    // Front-to-Back Slippage Architecture
+    const userProfile = logger.getUserProfile();
+    const maxSlippage = userProfile?.max_slippage || 1.0;
+    const config = loadConfig();
+    const cfgSlippage = (config.agent as any)?.default_slippage;
+    
+    let finalSlippage = slippageTolerance;
+    if (finalSlippage === undefined || finalSlippage === null) {
+        finalSlippage = (cfgSlippage === "auto" || !cfgSlippage) ? 0.5 : parseFloat(cfgSlippage as string);
+    }
+    
+    if (typeof finalSlippage !== 'number' || isNaN(finalSlippage)) finalSlippage = 0.5;
+    if (finalSlippage > maxSlippage) finalSlippage = maxSlippage;
+    
     const orderData = {
       token_symbol: tokenSymbol,
       token_address: tokenAddress,
@@ -18,7 +33,7 @@ export async function createLimitOrder(
       trigger_price_usd: triggerPriceUsd,
       action,
       amount_usd: amountUsd,
-      slippage_tolerance: slippageTolerance || 5.0
+      slippage_tolerance: finalSlippage
     };
 
     const orderId = logger.createLimitOrder(orderData);

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

@@ -1,3 +1,4 @@
+import { normalizeChainName } from '../utils/chains';
 import { ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { txManager } from '../../agent/transactionManager';
 import { submitTransaction } from '../utils/vaultClient';
@@ -10,6 +11,7 @@ export async function prepareCustomTx(
   description: string = "Custom transaction"
 ): Promise<string> {
   try {
+    chainName = normalizeChainName(chainName);
     if (!chainName || !toAddress || !data) throw new Error("Missing required parameters for custom transaction.");
     const { getAddress } = await import('../utils/vaultClient');
     const userAddress = await getAddress();
@@ -56,6 +58,7 @@ export const customTxToolDefinition = {
 };
 
 export async function executeCustomTx(chainName: string, details: any, autoApprove: boolean = false): Promise<string> {
+    chainName = normalizeChainName(chainName);
   // Fix HMAC mismatch by guaranteeing amountWei exists to match valueWei 
   const processedDetails = {
     ...details,

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

@@ -1,3 +1,4 @@
+import { normalizeChainName } from '../utils/chains';
 import { parseUnits } from 'viem';
 import { getPublicClient, getAddress, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { txManager } from '../../agent/transactionManager';
@@ -31,6 +32,7 @@ const AAVE_V3_POOLS: Record<string, `0x${string}`> = {
 
 export async function prepareAaveSupply(chainName: ChainName, tokenAddressOrSymbol: string, amountStr: string): Promise<string> {
   try {
+    chainName = normalizeChainName(chainName);
     if (!chainName || !tokenAddressOrSymbol || !amountStr) throw new Error("Missing protocol/chain/token parameters for DeFi operation.");
     const publicClient = getPublicClient(chainName);
     const userAddress = await getAddress();

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

@@ -1,3 +1,4 @@
+import { normalizeChainName } from '../utils/chains';
 import { formatEther, formatUnits } from 'viem';
 import { getPublicClient, ChainName, SUPPORTED_CHAIN_NAMES } from '../config';
 import { ERC20_ABI, resolveToken, getTokenMetadata } from '../utils/tokens';
@@ -5,6 +6,7 @@ import { saveTokenToWhitelist } from '../../utils/userWhitelistManager';
 
 export async function getBalance(chainName: ChainName, address?: `0x${string}`, token?: string): Promise<string> {
   try {
+    chainName = normalizeChainName(chainName);
     const client = getPublicClient(chainName);
     
     let targetAddress = address;

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

@@ -1,21 +1,26 @@
 import { safeFetchJson } from '../../utils/httpClient';
 import { loadMarketKeys } from '../../config/marketConfigManager';
+import { loadConfig } from '../../config/parser';
 
 export const getPriceToolDefinition = {
   type: "function",
   function: {
-    name: "get_price",
-    description: "Fetches the current price of a cryptocurrency.",
+    name: "get_price_and_fiat_value",
+    description: "Fetches the current price of a cryptocurrency and performs perfect fiat/amount conversion.",
     parameters: {
       type: "object",
       properties: {
         coinId: {
           type: "string",
-          description: "The CoinGecko ID of the coin (e.g., 'ethereum', 'bitcoin', 'solana')."
+          description: "The CoinGecko ID of the coin, its symbol, or its exact Contract Address (e.g., 'ethereum', 'bitcoin', 'jrny', '0x123...'). For low-cap/DEX tokens, ALWAYS use the Contract Address if available."
         },
         currency: {
           type: "string",
-          description: "The fiat currency to convert to (e.g., 'usd', 'idr', 'eur', 'jpy'). Defaults to 'usd'."
+          description: "The fiat currency to convert to (e.g., 'usd', 'idr', 'eur', 'jpy'). If omitted, it automatically defaults to the user's configured base fiat."
+        },
+        amount: {
+          type: "number",
+          description: "Optional. The number of tokens. If provided, the tool calculates the total fiat value exactly."
         }
       },
       required: ["coinId"]
@@ -23,34 +28,133 @@ export const getPriceToolDefinition = {
   }
 };
 
-export async function getPrice(coinId: string, currency: string = 'usd'): Promise<string> {
-  try {
-    const keys = loadMarketKeys();
-    const isPro = !!keys.coingecko_key;
-    const baseUrl = isPro ? 'https://pro-api.coingecko.com/api/v3' : 'https://api.coingecko.com/api/v3';
-    const headers = isPro ? { 'x-cg-pro-api-key': keys.coingecko_key } : undefined;
-
-    const cur = String(currency || "").toLowerCase();
-    const url = `${baseUrl}/simple/price?ids=${coinId}&vs_currencies=${cur}&include_24hr_change=true`;
-    
-    const data = await safeFetchJson<any>(url, { headers });
-    
-    if (!data[coinId]) {
-      return `❌ Could not find price data for **${coinId.toUpperCase()}**. Please verify the coin name.`;
+export async function getPrice(coinId: string, currency?: string, amount?: number): Promise<string> {
+  const config = loadConfig();
+  const defaultFiat = config.agent?.base_fiat || 'usd';
+  const cur = String(currency || defaultFiat).toLowerCase();
+  const curUpper = cur.toUpperCase();
+  const keys = loadMarketKeys();
+
+  // Helper to fetch USDT -> Target Fiat rate
+  async function getUsdtToFiatRate(): Promise<number> {
+    if (cur === 'usd' || cur === 'usdt') return 1;
+    // Tier 1 for Fiat: CoinGecko
+    try {
+      const isPro = !!keys.coingecko_key;
+      const baseUrl = isPro ? 'https://pro-api.coingecko.com/api/v3' : 'https://api.coingecko.com/api/v3';
+      const headers = isPro ? { 'x-cg-pro-api-key': keys.coingecko_key } : undefined;
+      const data = await safeFetchJson<any>(`${baseUrl}/simple/price?ids=tether&vs_currencies=${cur}`, { headers });
+      if (data && data.tether && data.tether[cur]) return data.tether[cur];
+    } catch (e) {}
+    // Tier 2 for Fiat: CoinMarketCap
+    if (keys.cmc_key) {
+      try {
+        const data = await safeFetchJson<any>(`https://pro-api.coinmarketcap.com/v2/cryptocurrency/quotes/latest?slug=tether&convert=${curUpper}`, {
+          headers: { 'X-CMC_PRO_API_KEY': keys.cmc_key }
+        });
+        const coinList = Object.values(data?.data || {});
+        if (coinList[0] && (coinList[0] as any).quote[curUpper]) return (coinList[0] as any).quote[curUpper].price;
+      } catch (e) {}
     }
+    return 0; 
+  }
+
+  const fiatRate = await getUsdtToFiatRate();
+  if (fiatRate === 0 && cur !== 'usd') {
+    return `❌ **Failed to fetch fiat exchange rate** for **USDT -> ${curUpper}**.`;
+  }
+
+  let tokenUsdPrice = 0;
+  let change24h = 0;
+  let source = '';
+  let tokenName = coinId.toUpperCase();
+
+  // TIER 1: CoinMarketCap (Token -> USD)
+  if (keys.cmc_key && tokenUsdPrice === 0) {
+    try {
+      const url = `https://pro-api.coinmarketcap.com/v2/cryptocurrency/quotes/latest?slug=${coinId.toLowerCase()}&convert=USD`;
+      const data = await safeFetchJson<any>(url, { headers: { 'X-CMC_PRO_API_KEY': keys.cmc_key } });
+      const coin: any = Object.values(data?.data || {})[0];
+      if (coin && coin.quote && coin.quote.USD) {
+        tokenUsdPrice = coin.quote.USD.price;
+        change24h = coin.quote.USD.percent_change_24h;
+        tokenName = coin.symbol;
+        source = 'CoinMarketCap Pro';
+      }
+    } catch(e) {}
+  }
+
+  // TIER 2: CoinGecko (Token -> USD)
+  if (tokenUsdPrice === 0) {
+    try {
+      const isPro = !!keys.coingecko_key;
+      const baseUrl = isPro ? 'https://pro-api.coingecko.com/api/v3' : 'https://api.coingecko.com/api/v3';
+      const headers = isPro ? { 'x-cg-pro-api-key': keys.coingecko_key } : undefined;
+      const url = `${baseUrl}/simple/price?ids=${coinId}&vs_currencies=usd&include_24hr_change=true`;
+      const data = await safeFetchJson<any>(url, { headers });
+      if (data && data[coinId]) {
+        tokenUsdPrice = data[coinId].usd;
+        change24h = data[coinId].usd_24h_change || 0;
+        source = `CoinGecko ${isPro ? 'Pro' : 'Public'}`;
+      }
+    } catch(e) {}
+  }
 
-    const price = data[coinId][cur];
-    const change24h = data[coinId][`${cur}_24h_change`];
-    
-    const isPositive = change24h >= 0;
-    const arrow = isPositive ? '📈 🟩 +' : '📉 🟥 ';
-    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';
+  // TIER 3: Nyxora Python ML Engine (For obscure/low-cap DEX tokens)
+  if (tokenUsdPrice === 0) {
+    try {
+      const mlData = await safeFetchJson<any>(`http://localhost:8000/web3/analyze?query=${coinId}&chain=ethereum`);
+      if (mlData && mlData.currentPrice) {
+        tokenUsdPrice = mlData.currentPrice;
+        change24h = mlData.priceChange24h || 0;
+        tokenName = mlData.officialSymbol || coinId.toUpperCase();
+        source = 'ML Engine (On-Chain/DEX Routing)';
+      }
+    } catch(e) {}
+  }
 
-    return `💰 **Price Update for ${coinId.toUpperCase()}**\n\n` +
-           `- **Price (${cur.toUpperCase()})**: \`${priceFormatted}\`\n` +
-           `- **24h Change**: ${arrow}${changeFormatted}%`;
-  } catch (error: any) {
-    return `❌ **Failed to fetch price:** ${error.message}`;
+  // TIER 4: DexScreener (Direct CA or Symbol Search)
+  if (tokenUsdPrice === 0) {
+    try {
+      const data = await safeFetchJson<any>(`https://api.dexscreener.com/latest/dex/search?q=${coinId}`);
+      if (data.pairs && data.pairs.length > 0) {
+        const pair = data.pairs[0];
+        tokenUsdPrice = Number(pair.priceUsd);
+        change24h = pair.priceChange?.h24 || 0;
+        tokenName = pair.baseToken.symbol;
+        source = 'DexScreener';
+      }
+    } catch(e) {}
   }
+
+  if (tokenUsdPrice === 0) {
+    return `❌ **Failed to fetch price:** Could not find price data for **${coinId.toUpperCase()}** on CMC, CoinGecko, or DexScreener.`;
+  }
+
+  // Final Math: Amount * Token(USD) * USDT(Fiat Rate)
+  const finalPricePerUnit = tokenUsdPrice * fiatRate;
+  const isPositive = change24h >= 0;
+  const arrow = isPositive ? '📈 🟩 +' : '📉 🟥 ';
+  
+  const formatter = new Intl.NumberFormat(cur === 'idr' ? 'id-ID' : 'en-US', { style: 'currency', currency: curUpper });
+  const priceFormatted = formatter.format(finalPricePerUnit);
+  const changeFormatted = change24h ? change24h.toFixed(2) : '0.00';
+
+  let report = `💰 **Price Update for ${tokenName}**\n\n`;
+  if (amount !== undefined && amount !== null) {
+    const totalVal = amount * finalPricePerUnit;
+    const totalFormatted = formatter.format(totalVal);
+    report += `- **Amount**: ${amount} ${tokenName}\n`;
+    report += `- **Price per Unit (${curUpper})**: \`${priceFormatted}\`\n`;
+    report += `- **Total Value**: \`${totalFormatted}\`\n`;
+  } else {
+    report += `- **Price (${curUpper})**: \`${priceFormatted}\`\n`;
+  }
+  report += `- **24h Change**: ${arrow}${changeFormatted}%\n`;
+  if (cur !== 'usd' && cur !== 'usdt') {
+    report += `- **USDT Rate**: \`${formatter.format(fiatRate)}\` / USDT\n`;
+  }
+  report += `_Source: ${source} (Token) | Live Fiat Oracle (USDT Rate)_`;
+
+  return report;
 }

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

@@ -1,3 +1,4 @@
+import { normalizeChainName } from '../utils/chains';
 import { loadConfig } from '../../config/parser';
 import { getAddress, ChainName } from '../config';
 import { formatUnits } from 'viem';
@@ -18,6 +19,7 @@ const CHAIN_IDS: Record<string, number> = {
 
 export async function getTxHistory(chainName: ChainName, address?: string, days: number = 30): Promise<string> {
   try {
+    chainName = normalizeChainName(chainName);
     const targetAddress = address || await getAddress();
     const chainId = CHAIN_IDS[chainName];
     if (!chainId) {