nyxora 26.6.27 → 26.6.28

package/README.md

@@ -97,8 +97,21 @@ To dive deeper into the technical details of our Zero-Knowledge security archite
 
 ## 🚀 Quick Start & Installation
 
-### Option 1: Global Installation (Recommended)
-Nyxora can be installed globally via NPM, allowing you to use the `nyxora` CLI command from anywhere on your machine.
+### Option 1: One-Line Installation (Recommended)
+The fastest way to install Nyxora is via our smart installation wrapper. This script automatically prepares Node.js (if missing) and securely fetches the Nyxora daemon directly from the NPM Registry.
+
+**Linux & macOS:**
+```bash
+curl -fsSL https://nyxoraai.github.io/Nyxora/install.sh | bash
+```
+
+**Windows (PowerShell):**
+```powershell
+iwr -useb https://nyxoraai.github.io/Nyxora/install.ps1 | iex
+```
+
+### Option 2: Global Installation (NPM)
+If you already have Node.js installed, you can natively install Nyxora globally via NPM, allowing you to use the `nyxora` CLI command from anywhere on your machine.
 
 ```bash
 # Install globally
@@ -124,7 +137,7 @@ cd Nyxora
 # 1. Install Dependencies
 npm install
 
-# 2. Build the Dashboard UI
+# 2. Build the Core, MCP Server, and Dashboard UI
 npm run build
 
 # 3. Interactive Setup Wizard
@@ -138,6 +151,13 @@ npm start
 
 > **⚠️ IMPORTANT:** Whenever you re-run `nyxora setup` or manually edit the config files, you **must restart the server** for the changes to take effect.
 
+### 🧹 Uninstallation & Reset
+If you ever need to securely wipe the AI's episodic memory, delete your API keys, and completely remove Nyxora's configuration from your operating system, simply run:
+```bash
+nyxora uninstall
+```
+This acts as a master reset switch to return your environment to a clean state.
+
 ---
 
 ## ⚖️ Terms of Service

package/bin/nyxora.mjs

@@ -350,6 +350,20 @@ async function unlock() {
   }
 }
 
+async function serveMcp() {
+  const compiledMcp = path.join(projectRoot, 'packages/mcp-server/dist/server.js');
+  const useCompiled = fs.existsSync(compiledMcp);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledMcp] : ['ts-node', '-T', 'packages/mcp-server/src/server.ts'];
+  const child = spawn(cmd, args, {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    env: { ...process.env, TS_NODE_CACHE: 'false' }
+  });
+  
+  await new Promise(resolve => child.on('close', resolve));
+}
+
 async function main() {
   switch(command) {
     case 'doctor': await runDoctor(); break;
@@ -366,6 +380,7 @@ async function main() {
     case 'unlock': await unlock(); break;
     case 'clean-logs': await cleanLogs(); break;
     case 'autostart': await autostart(process.argv[3]); break;
+    case 'mcp': await serveMcp(); break;
     case '-v':
     case '--v':
     case '--version':
@@ -383,6 +398,7 @@ Commands:
   start          Start the Nyxora background daemon
   stop           Stop the running daemon
   restart        Restart the daemon
+  mcp            Start the MCP Server directly (for testing/debug)
   chat           Chat interactively with the AI in terminal
   setup          Run the interactive Setup Wizard
   dashboard      Open the dashboard in your browser

package/dist/packages/core/src/agent/web3Agent.js

@@ -69,7 +69,7 @@ async function processWeb3Intent(input, role = 'user', onProgress, sessionId) {
         const context = 'web3';
         const response = await (0, llmUtils_1.executeWithRetry)(async (client) => {
             // Debug log to find out why Gemini 400 error happens
-            console.log(`[LLM Debug] Sending ${messages.length} messages to LLM.`);
+            // console.log(`[LLM Debug] Sending ${messages.length} messages to LLM.`);
             return await client.chat({
                 model: config.llm.model,
                 temperature: config.llm.temperature,

package/dist/packages/core/src/config/marketConfigManager.js

@@ -8,8 +8,8 @@ exports.saveMarketKeys = saveMarketKeys;
 const fs_1 = __importDefault(require("fs"));
 const yaml_1 = __importDefault(require("yaml"));
 const paths_1 = require("./paths");
-const MARKET_KEYS_FILE = (0, paths_1.getPath)('market_keys.yaml');
 function loadMarketKeys() {
+    const MARKET_KEYS_FILE = (0, paths_1.getPath)('market_keys.yaml');
     if (!fs_1.default.existsSync(MARKET_KEYS_FILE)) {
         return {};
     }
@@ -34,6 +34,7 @@ function saveMarketKeys(keys) {
                 delete updated[k];
             }
         }
+        const MARKET_KEYS_FILE = (0, paths_1.getPath)('market_keys.yaml');
         fs_1.default.writeFileSync(MARKET_KEYS_FILE, yaml_1.default.stringify(updated), 'utf8');
     }
     catch (error) {

package/dist/packages/core/src/config/parser.js

@@ -150,11 +150,6 @@ function loadConfig() {
                 needsSave = true;
             parsed.integrations.telegram.bot_token = decryptDataSync(parsed.integrations.telegram.bot_token);
         }
-        if (parsed.web3?.explorer_api_key) {
-            if (parsed.web3.explorer_api_key.startsWith('ENC:'))
-                needsSave = true;
-            parsed.web3.explorer_api_key = decryptDataSync(parsed.web3.explorer_api_key);
-        }
         // Auto-migration logic: move llm.credentials to root credentials
         if (parsed.llm && parsed.llm.credentials) {
             if (!parsed.credentials) {

package/dist/packages/core/src/gateway/WebSocketManager.js

@@ -26,7 +26,8 @@ class WebSocketManager {
                     return;
                 }
                 // Validate Auth Token during Upgrade Handshake
-                if (!(0, state_1.validateToken)(token)) {
+                const validation = (0, state_1.validateToken)(token);
+                if (!validation.valid) {
                     socket.write('HTTP/1.1 403 Forbidden\r\n\r\n');
                     socket.destroy();
                     return;

package/dist/packages/core/src/gateway/server.js

@@ -211,6 +211,18 @@ app.get('/api/sessions', (req, res) => {
         res.status(500).json({ error: error.message });
     }
 });
+app.get('/api/sessions/search', (req, res) => {
+    try {
+        const q = req.query.q;
+        if (!q) {
+            return res.json(reasoning_1.logger.getSessions());
+        }
+        res.json(reasoning_1.logger.searchSessions(q));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
 app.post('/api/sessions', (req, res) => {
     try {
         const { title } = req.body;
@@ -297,16 +309,20 @@ app.get('/api/defi-keys', (req, res) => {
         const { aggregatorRegistry } = require('../web3/aggregator/providerRegistry');
         const providers = aggregatorRegistry.getAllProviders();
         const requirements = [];
+        const seenKeys = new Set();
         for (const provider of providers) {
             if (provider.manifest.requiredApiKeys) {
                 for (const req of provider.manifest.requiredApiKeys) {
-                    requirements.push({
-                        id: req.id,
-                        label: req.label,
-                        required: req.required,
-                        docsUrl: req.docsUrl,
-                        configured: !!(keys[req.envKey] || keys[req.id])
-                    });
+                    if (!seenKeys.has(req.id)) {
+                        seenKeys.add(req.id);
+                        requirements.push({
+                            id: req.id,
+                            label: req.label,
+                            required: req.required,
+                            docsUrl: req.docsUrl,
+                            configured: !!keys[req.id]
+                        });
+                    }
                 }
             }
         }
@@ -325,6 +341,17 @@ app.post('/api/defi-keys', (req, res) => {
         res.status(500).json({ error: error.message });
     }
 });
+app.delete('/api/defi-keys/:id', (req, res) => {
+    try {
+        const keys = (0, defiConfigManager_1.loadDefiKeys)();
+        delete keys[req.params.id];
+        (0, defiConfigManager_1.saveDefiKeys)(keys);
+        res.json({ success: true });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
 app.get('/api/market-keys', (req, res) => {
     try {
         const keys = (0, marketConfigManager_1.loadMarketKeys)();
@@ -834,12 +861,15 @@ app.get('/api/portfolio', async (req, res) => {
 // --- Memory Triggers ---
 let messageCounter = 0;
 let idleTimer = null;
-function resetIdleTimer() {
+function resetIdleTimer(sessionId) {
     if (idleTimer)
         clearTimeout(idleTimer);
     idleTimer = setTimeout(() => {
         console.log('[Memory] Idle trigger activated. Running Reflection Engine...');
-        reflection_1.ReflectionEngine.runReflection();
+        reflection_1.ReflectionEngine.runReflection(sessionId).then(() => {
+            const { PromotionEngine } = require('../memory/promotionEngine');
+            PromotionEngine.runPromotionAndDecay();
+        }).catch(console.error);
     }, 3 * 60 * 1000); // 3 minutes idle
 }
 app.post('/api/v1/trade', async (req, res) => {
@@ -867,13 +897,16 @@ app.post('/api/chat', async (req, res) => {
         // Process input (this will automatically add to memory)
         const response = await (0, reasoning_1.processUserInput)(message, 'user', undefined, session_id);
         // Memory Triggers
-        resetIdleTimer();
+        resetIdleTimer(session_id);
         messageCounter++;
         if (messageCounter >= 5) {
             console.log('[Memory] N-Message threshold reached. Running Reflection Engine...');
             messageCounter = 0;
             // Run asynchronously
-            reflection_1.ReflectionEngine.runReflection();
+            reflection_1.ReflectionEngine.runReflection(session_id).then(() => {
+                const { PromotionEngine } = require('../memory/promotionEngine');
+                PromotionEngine.runPromotionAndDecay();
+            }).catch(console.error);
         }
         res.json({ response });
     }
@@ -891,6 +924,17 @@ app.get('/api/memory', (req, res) => {
         res.status(500).json({ error: error.message });
     }
 });
+app.delete('/api/memory/all', (req, res) => {
+    try {
+        episodic_1.episodicDB.clearAllMemories();
+        const { PromotionEngine } = require('../memory/promotionEngine');
+        PromotionEngine.runPromotionAndDecay();
+        res.json({ success: true, message: "Episodic memory wiped completely." });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
 app.delete('/api/memory/:id', (req, res) => {
     try {
         const id = parseInt(req.params.id, 10);
@@ -1025,6 +1069,22 @@ async function startServer() {
         (0, bridgeWatcher_1.startBridgeWatcher)();
         // Start Event Listener for Limit Orders (V3)
         eventListener_1.eventListener.start();
+        // Resume Market Watch tasks
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const { getAppDir } = require('../config/paths');
+            const tasksPath = path.join(getAppDir(), 'market_tasks.json');
+            if (fs.existsSync(tasksPath)) {
+                const tasks = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
+                if (tasks.length > 0) {
+                    console.log(`[Market Watch] Resuming ${tasks.length} background watch tasks...`);
+                }
+            }
+        }
+        catch (e) {
+            console.error('[Market Watch] Failed to resume tasks:', e);
+        }
     });
     server.on('error', (e) => {
         if (e.code === 'EADDRINUSE') {

package/dist/packages/core/src/memory/episodic.js

@@ -36,16 +36,17 @@ class EpisodicMemoryDB {
     addCandidateFact(fact, confidenceScore = 0.5, category = 'general', ruleType = 'observation') {
         // Upsert logic
         const existing = this.db.prepare('SELECT id, occurrences, confidence FROM episodic_memories WHERE fact = ?').get(fact);
+        const safeScore = Math.min(1.0, confidenceScore);
         if (existing) {
             // Increment occurrences, boost confidence slightly up to max 1.0
             const newOccurrences = existing.occurrences + 1;
-            const newConfidence = Math.min(1.0, existing.confidence + (confidenceScore * 0.2)); // Dampened boost
+            const newConfidence = Math.min(1.0, existing.confidence + (safeScore * 0.2)); // Dampened boost
             const stmt = this.db.prepare('UPDATE episodic_memories SET occurrences = ?, confidence = ?, rule_type = ?, lastSeen = CURRENT_TIMESTAMP WHERE id = ?');
             stmt.run(newOccurrences, newConfidence, ruleType, existing.id);
         }
         else {
             const stmt = this.db.prepare('INSERT INTO episodic_memories (fact, confidence, category, rule_type) VALUES (?, ?, ?, ?)');
-            stmt.run(fact, confidenceScore, category, ruleType);
+            stmt.run(fact, safeScore, category, ruleType);
         }
     }
     getMemories() {
@@ -64,6 +65,10 @@ class EpisodicMemoryDB {
     `);
         stmt.run(minConfidence, daysOld);
     }
+    clearAllMemories() {
+        const stmt = this.db.prepare('DELETE FROM episodic_memories');
+        stmt.run();
+    }
     close() {
         try {
             this.db.close();

package/dist/packages/core/src/memory/logger.js

@@ -150,6 +150,16 @@ class Logger {
     renameSession(sessionId, newTitle) {
         this.db.prepare('UPDATE sessions SET title = ? WHERE id = ?').run(newTitle, sessionId);
     }
+    searchSessions(query) {
+        const term = `%${query}%`;
+        return this.db.prepare(`
+      SELECT DISTINCT s.* 
+      FROM sessions s
+      LEFT JOIN messages m ON s.id = m.session_id
+      WHERE s.title LIKE ? OR m.content LIKE ?
+      ORDER BY s.timestamp DESC
+    `).all(term, term);
+    }
     getHistory(sessionId, limit = 40) {
         let rows;
         // Phase 2: Sliding Window Algorithm (LLM Context Limit)

package/dist/packages/core/src/memory/reflection.js

@@ -7,24 +7,27 @@ const logger_1 = require("./logger");
 const validator_1 = require("./validator");
 const episodic_1 = require("./episodic");
 class ReflectionEngine {
-    static async runReflection() {
+    static async runReflection(sessionId) {
         try {
             // 1. Get recent session history
-            const history = logger_1.logger.getHistory();
-            if (history.length === 0)
+            const history = logger_1.logger.getHistory(sessionId);
+            if (history.length === 0) {
+                console.log('[ReflectionEngine] History is empty. Aborting reflection.');
                 return;
-            // Extract just the user and assistant text
+            }
+            // Extract just the user and assistant text, ignoring tool messages
             const recentChat = history
+                .filter(msg => msg.role !== 'tool')
                 .map(msg => `[${msg.role}]: ${msg.content}`)
                 .join('\n');
             const config = (0, parser_1.loadConfig)();
             const model = config.llm?.model || 'gpt-4o';
-            const openai = await (0, llmUtils_1.getOpenAI)();
+            const llm = await (0, llmUtils_1.getLLMClient)();
             // 2. Build the heavily constrained System Prompt
             const systemPrompt = `
 You are the Self-Reflection Engine for a Web3 AI Agent.
 Your job is to analyze the following recent conversation and extract user habits, preferences, or corrections.
-You MUST output ONLY valid JSON in the exact format specified.
+You MUST output ONLY valid JSON in the exact format specified. Do not include markdown code blocks around the JSON.
 
 CRITICAL RULES:
 1. DO NOT extract or remember any Private Keys, Seed Phrases, Mnemonic Words, Passwords, API Keys, or Session Tokens.
@@ -48,19 +51,20 @@ Return a JSON object with an array "memories":
 - rule_type "permanent": A strict reprimand or absolute preference (e.g., "Never use Ethereum!").
 `;
             // 3. Query LLM
-            const response = await openai.chat.completions.create({
+            const response = await llm.chat({
                 model: model,
                 messages: [
                     { role: 'system', content: systemPrompt },
                     { role: 'user', content: recentChat }
                 ],
-                response_format: { type: 'json_object' },
                 temperature: 0.1
             });
-            const content = response.choices[0]?.message?.content;
+            const content = response.message?.content;
             if (!content)
                 return;
-            const data = JSON.parse(content);
+            // Strip markdown codeblocks if LLM incorrectly formatted it
+            const cleanContent = content.replace(/```json/gi, '').replace(/```/g, '').trim();
+            const data = JSON.parse(cleanContent);
             const memories = data.memories || [];
             // 4. Validate and Store
             let addedCount = 0;
@@ -74,7 +78,7 @@ Return a JSON object with an array "memories":
                         // Fast-Track Override Logic
                         let confidence = 0.5; // default for observation
                         if (mem.rule_type === 'permanent')
-                            confidence = 2.0; // Fast-track override
+                            confidence = 1.0; // Fast-track override
                         if (mem.rule_type === 'temporary')
                             confidence = 0.8;
                         episodic_1.episodicDB.addCandidateFact(safeFact, confidence, mem.category || 'general', mem.rule_type || 'observation');

package/dist/packages/core/src/memory/validator.js

@@ -16,18 +16,7 @@ class MemoryValidator {
         if (privateKeyRegex.test(text)) {
             throw new Error('SECURITY VIOLATION: Potential Private Key detected in memory extraction.');
         }
-        // 2. Check for typical 12-24 word BIP-39 Mnemonic patterns.
-        // We do a rough heuristic: 12-24 lowercase words separated by spaces in a single block.
-        // This is hard to do perfectly with regex, so we look for sequences of 12+ words
-        const words = text.toLowerCase().match(/\b[a-z]+\b/g) || [];
-        if (words.length >= 12) {
-            // Very basic check: are there exactly 12 or 24 words in a continuous string?
-            const mnemonicRegex = /\b([a-z]+(?:\s+[a-z]+){11,23})\b/g;
-            if (mnemonicRegex.test(text.toLowerCase())) {
-                // Log it as suspicious, but we'll reject it to be safe if it looks like a seed phrase
-                throw new Error('SECURITY VIOLATION: Potential Seed Phrase detected in memory extraction.');
-            }
-        }
+        // Removed overly aggressive 12-word mnemonic check to avoid false positives in conversational languages
         // 3. Check for API/Bot Tokens (e.g., Telegram token format: 123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11)
         const telegramTokenRegex = /\b\d{8,10}:[a-zA-Z0-9_-]{35}\b/g;
         if (telegramTokenRegex.test(text)) {

package/dist/packages/core/src/web3/aggregator/providers/OpenOceanProvider.js

@@ -62,7 +62,7 @@ class OpenOceanProvider {
             routeId: `openocean-${crypto_1.default.randomUUID()}`,
             fromChainId: chainId,
             toChainId: chainId,
-            inputAmount: BigInt(amount),
+            inputAmount: BigInt(request.amountInWei || "0"),
             outputAmount: BigInt(data.outAmount),
             executable: true,
             expiresAt: Date.now() + 60000,

package/dist/packages/core/src/web3/skills/createMarketWatchAgent.js

@@ -1,12 +1,38 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMarketWatchAgentToolDefinition = void 0;
 exports.createMarketWatchAgent = createMarketWatchAgent;
 const config_1 = require("../config");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../../config/paths");
 async function createMarketWatchAgent(chainName, contractAddress, rules, durationDays) {
     // In a real production environment, this would push a job to Redis/Celery 
     // or instantiate a background worker. For now, we simulate the agent spawning.
     const jobId = `watch-${contractAddress.substring(0, 8)}-${Date.now()}`;
+    // Save to persistence disk
+    try {
+        const tasksPath = path_1.default.join((0, paths_1.getAppDir)(), 'market_tasks.json');
+        let tasks = [];
+        if (fs_1.default.existsSync(tasksPath)) {
+            tasks = JSON.parse(fs_1.default.readFileSync(tasksPath, 'utf8'));
+        }
+        tasks.push({
+            jobId,
+            chainName,
+            contractAddress,
+            rules,
+            durationDays,
+            createdAt: Date.now()
+        });
+        fs_1.default.writeFileSync(tasksPath, JSON.stringify(tasks, null, 2), 'utf8');
+    }
+    catch (e) {
+        console.error('Failed to persist market watch task', e);
+    }
     let report = `✅ **Autonomous Watchdog Agent Deployed!**\n\n`;
     report += `**Job ID:** \`${jobId}\`\n`;
     report += `**Target:** \`${contractAddress}\` on ${chainName.toUpperCase()}\n`;

package/dist/packages/core/src/web3/skills/getTxHistory.js

@@ -27,7 +27,7 @@ async function getTxHistory(chainName, address, days = 30) {
         }
         const apiUrl = `https://api.etherscan.io/v2/api?chainid=${chainId}`;
         const config = (0, parser_1.loadConfig)();
-        const apiKey = config.web3?.explorer_api_key || 'YourApiKeyToken'; // Public fallback
+        const apiKey = config.web3?.explorer_api_key || ''; // Public fallback with no key
         const apiKeyParam = apiKey ? `&apikey=${apiKey}` : '';
         const startTimestamp = Math.floor(Date.now() / 1000) - (days * 24 * 60 * 60);
         // Fetch Native Txs

package/dist/packages/core/src/web3/skills/provideLiquidity.js

@@ -67,9 +67,15 @@ async function prepareProvideLiquidity(chainName, token0AddressOrSymbol, token1A
         }
         if (typeof actualSlippage !== 'number' || isNaN(actualSlippage))
             actualSlippage = 0.5;
-        // CRITICAL SAFETY REQUIREMENT: AI MUST ASK USER FOR TICKS
-        if (tickLower === undefined || tickUpper === undefined) {
-            return `ACTION REQUIRED: I cannot calculate the Uniswap V3 price range (tickLower and tickUpper) autonomously for safety reasons. Please ask the user to provide the exact tickLower and tickUpper values they want for this liquidity pool before I can prepare the transaction.`;
+        // If ticks are not provided, default to Full Range based on tickSpacing
+        let tLower = tickLower;
+        let tUpper = tickUpper;
+        if (tLower === undefined || tUpper === undefined) {
+            const MIN_TICK = -887272;
+            const MAX_TICK = 887272;
+            const tickSpacing = feeTier === 100 ? 1 : feeTier === 500 ? 10 : feeTier === 3000 ? 60 : 200;
+            tLower = Math.ceil(MIN_TICK / tickSpacing) * tickSpacing;
+            tUpper = Math.floor(MAX_TICK / tickSpacing) * tickSpacing;
         }
         const publicClient = (0, config_1.getPublicClient)(chainName);
         const userAddress = await (0, config_1.getAddress)();
@@ -126,7 +132,7 @@ async function prepareProvideLiquidity(chainName, token0AddressOrSymbol, token1A
         const amount0Min = (amount0Wei * (10000n - slippageFactor)) / 10000n;
         const amount1Min = (amount1Wei * (10000n - slippageFactor)) / 10000n;
         const mintParams = {
-            token0, token1, fee: feeTier, tickLower, tickUpper,
+            token0, token1, fee: feeTier, tickLower: tLower, tickUpper: tUpper,
             amount0Desired: amount0Wei, amount1Desired: amount1Wei,
             amount0Min, amount1Min,
             recipient: account, deadline
@@ -147,7 +153,7 @@ async function prepareProvideLiquidity(chainName, token0AddressOrSymbol, token1A
             return `Simulation failed! Cannot mint liquidity position. Check if ticks are valid for fee tier. Error: ${simError.message}`;
         }
         const tx = transactionManager_1.txManager.createPendingTransaction('univ3Mint', chainName, {
-            positionManagerAddress, token0, token1, amount0, amount1, tickLower, tickUpper,
+            positionManagerAddress, token0, token1, amount0, amount1, tickLower: tLower, tickUpper: tUpper,
             gasEstimate: gasEstimate.toString()
         });
         return `⏳ **Add Liquidity queued:** ${amount0} ${meta0.symbol} & ${amount1} ${meta1.symbol} | ${chainName.toUpperCase()} | Approve below.`;
@@ -170,8 +176,8 @@ exports.provideLiquidityToolDefinition = {
                 amount0Str: { type: "string" },
                 amount1Str: { type: "string" },
                 feeTier: { type: "number", description: "Uniswap fee tier (e.g. 500 for 0.05%, 3000 for 0.3%, 10000 for 1%)" },
-                tickLower: { type: "number", description: "MUST BE PROVIDED BY USER." },
-                tickUpper: { type: "number", description: "MUST BE PROVIDED BY USER." }
+                tickLower: { type: "number", description: "Optional. Leave empty for Full Range." },
+                tickUpper: { type: "number", description: "Optional. Leave empty for Full Range." }
             },
             required: ["chainName", "token0AddressOrSymbol", "token1AddressOrSymbol", "amount0Str", "amount1Str", "feeTier"]
         }

package/dist/packages/core/src/web3/utils/marketEngine.js

@@ -29,7 +29,12 @@ async function analyzeMarketEngine(chainName, tokenAddressOrSymbol) {
         }
     }
     catch (e) {
-        console.warn("CoinGecko analysis failed, falling back to CMC...", e);
+        if (keys.cmc_key) {
+            console.warn("CoinGecko analysis failed, falling back to CMC...", e.message);
+        }
+        else {
+            console.warn("CoinGecko analysis failed, falling back to DexScreener...", e.message);
+        }
     }
     // Tier 1 & 2: CoinMarketCap (Pro if key exists)
     // Note: CMC doesn't have a truly open public endpoint like CG without keys, 
@@ -54,7 +59,7 @@ async function analyzeMarketEngine(chainName, tokenAddressOrSymbol) {
             }
         }
         catch (e) {
-            console.warn("CMC analysis failed, falling back to DexScreener...", e);
+            console.warn("CMC analysis failed, falling back to DexScreener...", e.message);
         }
     }
     // Tier 2: Ultimate Fallback Engine: DexScreener Cross-Chain Search
@@ -70,7 +75,7 @@ async function analyzeMarketEngine(chainName, tokenAddressOrSymbol) {
     try {
         const data = await (0, httpClient_1.safeFetchJson)(dexSearchUrl);
         if (!data.pairs || data.pairs.length === 0) {
-            return `No market data found for '${tokenAddressOrSymbol}' on CMC, CoinGecko, or DexScreener across any chain.`;
+            return `❌ Market Engine Error: The token '${tokenAddressOrSymbol}' does not exist on CoinGecko, CoinMarketCap, or DexScreener across any supported chain. Please inform the user that this token is either not launched, completely dead, or the symbol is incorrect.`;
         }
         let pair = data.pairs.find((p) => p.chainId === chainName);
         if (!pair)

package/dist/packages/core/src/web3/utils/rpcEngine.js

@@ -24,7 +24,7 @@ function getPublicClient(chainName) {
         }
     }
     // Fallback public RPCs (Top tier from Chainlist.org prioritized)
-    if (!customRpcRaw) {
+    if (transports.length === 0) {
         if (chainName === 'ethereum') {
             transports.push((0, viem_1.http)('https://rpc.mevblocker.io', { timeout: 5000, batch: { batchSize: 100 } })); // Primary MEV protection
             transports.push((0, viem_1.http)('https://rpc.flashbots.net', { timeout: 5000, batch: { batchSize: 100 } })); // Secondary MEV protection
@@ -63,6 +63,10 @@ function getPublicClient(chainName) {
             transports.push((0, viem_1.http)('https://optimism-sepolia-rpc.publicnode.com', { timeout: 5000 }));
             transports.push((0, viem_1.http)('https://sepolia.optimism.io', { timeout: 5000 }));
         }
+        else if (chainName === 'base_sepolia') {
+            transports.push((0, viem_1.http)('https://base-sepolia-rpc.publicnode.com', { timeout: 5000 }));
+            transports.push((0, viem_1.http)('https://sepolia.base.org', { timeout: 5000 }));
+        }
     }
     // Always append the default public RPC (like cloudflare) as the last resort
     transports.push((0, viem_1.http)(undefined, { timeout: 5000 }));
@@ -111,6 +115,8 @@ function getWsClient(chainName) {
             wsUrl = 'wss://arbitrum-sepolia-rpc.publicnode.com';
         else if (chainName === 'optimism_sepolia')
             wsUrl = 'wss://optimism-sepolia-rpc.publicnode.com';
+        else if (chainName === 'base_sepolia')
+            wsUrl = 'wss://base-sepolia-rpc.publicnode.com';
     }
     // If WSS is totally unavailable, fallback to HTTP polling transparently
     if (!wsUrl) {