nyxora 26.6.5 → 26.6.7

package/CHANGELOG.md

@@ -5,6 +5,69 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepashangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [26.6.7] - Unreleased
+### Enterprise Features & Web3 Enhancements
+- **Enterprise Portfolio Scanner**: Integrated a fully decentralized, real-time Dashboard UI (Nord Theme) to scan all native and ERC-20 token balances across 8 EVM chains natively, without relying on centralized third-party APIs.
+- **Real-Time USD Valuation**: Integrated DexScreener API into the Portfolio Scanner backend to actively compute and display USD portfolio values in real-time. Features an adaptive 2-minute memory cache system to ensure complete immunity against API rate-limits and eliminate LLM token consumption.
+- **Official Web3 Branding**: Integrated TrustWallet and CovalentHQ CDNs to automatically resolve and render official Native Chain icons and ERC-20 Token logos with dynamic address casing, delivering an authentic Tier-1 exchange aesthetic.
+- **Custom Token Management (AI Skill)**: Deployed the new `manage_custom_tokens` Web3 skill. The AI agent can now autonomously recognize, store, and manage user-specified custom token addresses (e.g., obscure/degen tokens) to `~/.nyxora/custom_tokens.json`. These are instantly synced with the Portfolio Scanner.
+- **MEV-Blocker Integration**: Upgraded the Ethereum mainnet routing core in `config.ts` to strictly prioritize `rpc.mevblocker.io` and `rpc.flashbots.net` as primary transports. All user transactions are now forcefully routed through Private Mempools, establishing complete immunity against sandwich attacks and front-running bots.
+- **System Diagnosis (`nyxora doctor`)**: Added a new CLI tool `nyxora doctor` to automatically verify OS requirements, node versions, filesystem permissions, SQLite database r/w access, Keyring vault security, and network port availability for seamless troubleshooting.
+
+### Security & UX Updates
+- **CLI Wallet Management (`nyxora wallet update`)**: Added a highly requested sub-command to allow users to securely overwrite their OS Keyring Web3 wallet directly via the CLI without having to re-run the full LLM setup wizard. Features an aggressive visual confirmation step to prevent accidental Private Key destruction.
+- **Terminal UI Resilience**: Replaced dynamic `note()` text rendering with static linear console logs in the `nyxora setup` wizard. This completely eliminates a UI truncation bug where the `clack` prompter would swallow the 12-word mnemonic phrase on small terminal windows.
+- **Helmet CSP Optimization**: Adjusted the Gateway Server's Content Security Policy (CSP) to securely whitelist decentralized image repositories (GitHub raw, CovalentHQ) without compromising strict anti-XSS protection protocols.
+- **BIP-39 Mnemonic Generation**: Upgraded the `nyxora setup` CLI wizard. When auto-generating a new wallet, the system now provides a standard 12-word Seed Phrase (Mnemonic) instead of a raw hex Private Key, vastly improving user security and cross-wallet compatibility (e.g., MetaMask). The private key is still autonomously extracted and locked in the OS Keyring.
+- **One-Liner Install Script**: Added a new hacker-style `curl | bash` installation method at `https://nyxoraai.github.io/Nyxora/install.sh` for Linux/macOS, and a native PowerShell script `install.ps1` for Windows, providing an instant, frictionless setup experience across all major operating systems.
+- **Global Localization Standardization**: Swept and translated the entire AI reasoning log engine (`reasoning.ts`) from Indonesian to standardized English to maintain strict international professional standards across console output and UI feedback.
+
+### Bug Fixes & Optimizations
+- **ERC-20 Decimals Resolution**: Completely eradicated a critical math bug where all custom tokens were assumed to have 18 decimals. The backend now executes parallel `decimals()` on-chain queries alongside `balanceOf()`, guaranteeing 100% mathematical precision for tokens like USDC/USDT (6 decimals).
+- **NPM Monorepo Build Fix**: Fixed the `packages/core` workspace `package.json` to correctly include the `"build": "tsc"` script and aligned its internal versioning (`v26.6.7`). This resolves the NPM workspace lifecycle crash during global build triggers.
+- **NPM Optimization**: Added official keywords (`web3`, `ai`, `agent`, `crypto`, `mcp`, `automation`, `defi`, `zero-trust`) to the root `package.json` to significantly improve Nyxora's discoverability and SEO on the NPM Registry.
+
+## [26.6.6] - 2026-06-05
+### Enterprise Stability Upgrades
+- **Strict LLM Output Validation**: Added robust try-catch parsing for LLM tool arguments in `reasoning.ts`. If the AI outputs malformed JSON, the error is fed back into the reasoning loop, allowing the model to autonomously self-correct without crashing the agent pipeline.
+- **Transaction Simulation (Dry-Run)**: Integrated `publicClient.estimateGas` in the Signer Vault before broadcasting transactions. This ensures all Web3 transactions are simulated at the node level, preventing users from wasting gas fees on reverted transactions (e.g., due to insufficient slippage or balance).
+- **Graceful Shutdown (Keyring Security)**: Replaced `SIGKILL` with `SIGTERM` in `launcher.ts` and added explicit process termination listeners in the Signer server. When a user exits the CLI using `Ctrl+C`, the system elegantly clears the in-memory `vaultPrivateKey` reference and unlinks unix sockets, securing the local Keyring vault before terminating.
+- **Undefined Function Fix**: Fixed a silent `TypeError` bug in `reasoning.ts` where a failed LLM parsing attempt would call an undefined `executeReasoningLoop` function. Now gracefully loops via standard `logger.addEntry` continuation.
+
+### Bug Fixes & UX Enhancements
+- **Destructive Config Overwrite Fix**: Fixed a critical bug in `/api/config` where saving settings via the Dashboard UI would silently delete the user's Telegram Bot token and system permissions. The API now performs a deep merge with `config.yaml`.
+- **Asynchronous Transaction UI**: Detached the Web3 transaction execution loop from the Dashboard UI `/approve` endpoint. Approvals now instantly return a success state to the UI (preventing 3-minute freezes) while the transaction safely confirms in the background and reports back via chat.
+
+### Performance & Speed Optimizations
+- **SQLite Indexing (O(1) Lookup)**: Added an automatic `CREATE INDEX` for `session_id` in the memory logger database, drastically reducing query latency from O(n) full table scans to instantaneous lookups for large chat histories.
+- **Sliding Window Context Limit**: Overhauled `getHistory()` with an SQL subquery `LIMIT 40` approach. The agent now only feeds the most recent 40 messages to the LLM context, massively reducing API token costs and preventing latency bloat.
+- **Pre-Compiled Runtime (ts-node Elimination)**: Replaced on-the-fly TypeScript compilation (`ts-node`) with ahead-of-time compilation (`tsc`). `launcher.ts` and `nyxora.mjs` now natively detect and execute compiled `.js` files from the `dist/` directory, resulting in near-instant daemon startup times.
+- **Global Token Metadata Cache (OOM Protected)**: Implemented an in-memory Bounded LRU Cache (max 1000 items) in `tokens.ts` for caching `decimals` and `symbol`. This eliminates repetitive RPC calls for immutable token data, shielding the system from Out-Of-Memory crashes if spammed with fake tokens.
+- **Web3 RPC Parallelization**: Refactored `transfer.ts`, `swapToken.ts`, `bridgeToken.ts`, and `getBalance.ts` to replace slow, sequential `readContract` calls with `Promise.all` fetching via `getTokenMetadata()`. Web3 action preparation latency has been reduced to near 0ms for cached tokens.
+
+## [26.6.5-1.0] - 2026-06-05
+### Bug Fixes & Improvements
+- **Transaction Stability**: Added 30-second `AbortSignal` timeout safety net across all Web3 skills (`swapToken`, `transfer`, `bridgeToken`, `mintNft`, `customTx`) to prevent UI hanging when RPC nodes are unresponsive.
+- **Multi-Session Transaction Logs**: Fixed an issue where Web3 transaction status messages (Approve/Reject/Success/Failure) were logged to the `default` session instead of the user's active session window, by attaching the correct `sessionId` with `Content-Type: application/json` headers in dashboard API requests.
+- **UI Tool Rendering Bug**: Fixed a React rendering bug in `App.tsx` where the AI's internal tool execution notification (green bubble) would be hidden if the AI generated both conversational text and a tool execution in the same response.
+- **Base Sepolia Support**: Officially added `base_sepolia` testnet to the supported networks list and `bridgeToken` mappings to prevent AI confusion when resolving bridge destinations.
+- **Default Policy Override (Plug & Play)**: Adjusted the default `config.yaml` template and internal Policy Engine defaults to set `allow_transfer`, `allow_swap`, `allow_shell_execution`, and `allow_file_write` to `true`. Also uncapped `max_usd_per_tx` to `$999,999,999` by default, ensuring a seamless "plug and play" experience for new users without needing manual configuration edits.
+- **Viem RPC Timeout**: Injected a strict 15-second timeout inside the `signer` vault's `viem` HTTP transport to prevent indefinite freezing during blockchain gas estimation when the node is heavily rate-limited.
+- **Auto-Approve Signature Fix**: Added internal HMAC signature generation across all Web3 transaction execution modules (Transfer, Bridge, Mint, CustomTx) to resolve the `Missing internal signature for autoApprove` error during manual dashboard approvals or policy bypasses.
+- **LayerZero Testnet Route**: Upgraded the testnet Bridge mock implementation to utilize LayerZero's V2 Endpoint router (`0x1a44...`) for simulated testnet bridging transactions.
+- **Transaction Result Formatting**: Fixed an issue where the AI would output raw JSON stringified payloads for successful transactions. The chat notification is now properly formatted to clearly display the transaction hash.
+- **Base Sepolia UI Integration**: Synchronized the Dashboard's Network Selector dropdown and Default Web3 Chain settings menu to include the newly added `Base Sepolia (Testnet)` network.
+- **LayerZero Mainnet Removal (Stargate V2)**: Completely removed the experimental LayerZero/Stargate V2 integration from the core bridging engine to prevent interaction with potentially outdated or unverified mainnet smart contracts. Removed the corresponding "LayerZero" routing option from the Dashboard UI dropdown to ensure a highly stable and secure bridging experience exclusively via Li.Fi and Relay.
+- **Relay MEV Protection (Slippage)**: Hardened the `getRelayQuote` HTTP POST request by injecting a strict `slippageTolerance` parameter (default 0.5%). This closes a critical vulnerability where unbounded Relay executions could expose user funds to front-running and MEV attacks during volatile market conditions.
+- **Strict NLP Exactness (Rule 8)**: Injected CRITICAL RULE 8 into the core reasoning pipeline (`reasoning.ts`). The AI is now strictly forbidden from hallucinating or guessing ambiguous transaction parameters (tokens, amounts, or destination networks). It will automatically halt and politely ask the user for explicit clarification before constructing any Web3 payloads.
+- **NLP Context Override System**: Documented the NLP fallback override mechanism in `README.md` and Vitepress documentation to clarify how explicit user chat instructions dynamically bypass Dashboard configurations.
+
+### UI/UX Fixes
+- **Pending Transactions Widget**: Fixed a rendering bug where the Approve/Reject popup was not being injected into the DOM, preventing users from signing transactions.
+
+### Core AI Engine
+- **Strict Language Matching**: Optimized CRITICAL RULE 2 in the System Prompt. The AI now completely ignores historical chat language context and strictly matches the language of the user's latest prompt.
+
 ## [26.6.5] - 2026-06-04 (Hotfix Patch)
 ### Fixed
 - **NPM Monorepo Resolution:** Synced `@inquirer/search` and `duck-duck-scrape` to root `package.json` to prevent `MODULE_NOT_FOUND` and `ERR_CONNECTION_REFUSED` on global installations.

package/README.md

@@ -1,5 +1,5 @@
-# Nyxora Agent 🤖
-**Dual-Engine AI Agent: Bridging On-Chain Execution with Off-Chain Automation.**
+# Nyxora Agent <img src="./packages/dashboard/public/favicon.svg" width="36" align="top" />
+**Your Personal Web3 Assistant.**
 
 
 [![MCP Supported](https://img.shields.io/badge/MCP-Supported-blue.svg)](#)
@@ -27,6 +27,7 @@ It operates under an institutional-grade **Cryptographically Bound Human-in-the-
 
 ### 🌐 Web3 Skills (On-Chain)
 *   **Security Scanner**: Nyxora can scan smart contracts via GoPlus Labs to detect Honeypots, Hidden Taxes, and malicious proxy upgrades before you buy.
+*   **Anti-MEV Slippage Protection**: Hardened routing engine with dynamic Slippage Tolerance (default 0.5%) for Relay and Li.Fi. You can manually adjust slippage via the UI or dynamically override it using natural language (e.g., "Swap 1 ETH to PEPE with 10% slippage").
 *   **Automated Take Profit (TP) & Cut Loss (CL)**: The trader's holy grail. Set natural language rules (e.g., "Sell my PEPE if price drops below $0.001"). Nyxora runs a background cron monitor and executes the swap while you sleep.
 *   **Cross-Chain Hybrid Market Scanner**: Real-time asset tracking combining CoinGecko global data with DexScreener on-chain metrics across Ethereum, Base, Solana, BSC, and more.
 *   **"Lean Degen" Auto-Whitelist**: Automatically intercepts Contract Addresses (CAs) whenever you check balances or swap tokens, saving them to your localized `user_whitelist.json` for future tracking.
@@ -42,6 +43,7 @@ It operates under an institutional-grade **Cryptographically Bound Human-in-the-
 *   **Dynamic Trending Tokens**: Live top 5 crypto assets feed directly injected into the dashboard, completely clickable for instant AI market analysis.
 *   **Premium Utility-Centric UI**: A sleek, dark-themed dashboard built for high readability and professional Web3 execution, featuring Pseudo-Generative UI widgets (`<BalanceWidget>`, `<MarketWidget>`, `<SwapWidget>`).
 *   **Massive 2026 Model Roster**: Out-of-the-box support for cutting-edge models via Google Gemini, OpenAI, Groq, Mistral, xAI, DeepSeek, OpenRouter, and local Ollama, equipped with a searchable CLI prompt to instantly find your favorite model.
+*   **Strict NLP Exactness (Rule 8)**: The AI is rigorously instructed never to hallucinate or guess missing transaction parameters (like destination chains or swap amounts). It halts and requests human clarification, guaranteeing 100% precision.
 *   **Context Overrides Defaults (NLP Intelligence)**: The Dashboard configuration (default chain & router) acts only as a safety net. If you issue an explicit command via Telegram (e.g., *"Swap 10 USDC to USDT on Arbitrum using Li.Fi"*), the NLP engine dynamically bypasses the default settings and executes exactly what you asked for, ensuring maximum flexibility.
 *   **Deep Personalization**: Feed the agent custom rules via `user.md` and define its core persona via `IDENTITY.md`.
 
@@ -73,9 +75,23 @@ To dive deeper into the technical details of our Zero-Knowledge security archite
 ### Global Installation via NPM (Recommended)
 The easiest and fastest way to use Nyxora is to install it globally via NPM. This ensures you get the latest version and can run Nyxora from anywhere on your machine.
 
+The fastest way to install Nyxora is via our automated installation script:
+
+**For Linux & macOS (Bash):**
+```bash
+curl -fsSL https://nyxoraai.github.io/Nyxora/install.sh | bash
+```
+
+**For Windows (PowerShell):**
+```powershell
+iwr https://nyxoraai.github.io/Nyxora/install.ps1 -useb | iex
+```
+
+Alternatively, you can install it manually on any operating system using NPM:
+
 ```bash
-# 1. Install Nyxora globally
 npm install -g nyxora@latest
+```
 
 # 2. Run the Interactive Setup Wizard (API Keys, Wallet, Telegram)
 nyxora setup
@@ -107,10 +123,10 @@ npm run build
 # 3. Interactive Setup Wizard (API Keys, Wallet, Telegram)
 npm run setup
 
-# 4. Start the Development Server (Single-Command Boot)
-# This will start the backend vault/services and the frontend Dashboard simultaneously
-npm run dev
+# 4. Start the Application
+npm start
 ```
+*(If you are actively developing and modifying the source code, use `npm run dev` to enable hot-reloading for the frontend and backend).*
 > **⚠️ IMPORTANT:** Whenever you re-run `npm run setup` or manually edit the config files, you **must restart the dev server** for the changes to take effect.
 
 ---

package/SECURITY.md

@@ -78,7 +78,16 @@ To prevent Supply Chain Attacks, the sandbox **permanently blacklists** critical
 *   `child_process`: Plugins cannot spawn silent background terminals or malicious `curl | bash` supply chain payloads.
 *   `os`, `net`, `cluster`: Blocked to prevent network-level exploitation.
 
-## 5. Reporting Vulnerabilities
+## 5. Anti-MEV & Slippage Defense
+
+To protect user funds from front-running and Maximal Extractable Value (MEV) attacks, Nyxora strictly enforces a **Default Slippage Tolerance of 0.5%** for all decentralized exchange (DEX) routing via Li.Fi and Relay.
+
+Unlike typical web3 interfaces that might expose you to unlimited slippage if left unconfigured, Nyxora's backend hardcodes this protection layer into the API payload. 
+If an AI agent attempts to execute a swap without explicit slippage instructions, the `swapToken` and `bridgeToken` engines will automatically inject the `0.5%` boundary. 
+
+Users can safely override this limit globally via the Dashboard UI Settings or dynamically via NLP chat commands for specific high-volatility pairs (e.g., "Swap with 10% slippage").
+
+## 6. Reporting Vulnerabilities
 
 If you discover a vulnerability in the Nyxora architecture, please DO NOT open a public issue.
 Instead, email the core maintainer directly at **ainyxor@gmail.com**.

package/bin/nyxora.mjs

@@ -63,7 +63,14 @@ async function start() {
     } catch(e) {}
   }
 
-  const child = spawn('npx', ['ts-node', '-T', 'launcher.ts'], {
+  const compiledLauncher = path.join(projectRoot, 'dist', 'launcher.js');
+  const useCompiled = fs.existsSync(compiledLauncher);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledLauncher] : ['ts-node', '-T', 'launcher.ts'];
+
+  if (useCompiled) console.log('⚡ Using pre-compiled JS for blazing fast startup...');
+
+  const child = spawn(cmd, args, {
     cwd: projectRoot,
     detached: true,
     stdio: ['ignore', out, err],
@@ -199,7 +206,53 @@ Comment=Start Nyxora in the background
 
 async function setup() {
   console.log("Running Nyxora Setup Wizard...");
-  const child = spawn('npx', ['ts-node', '-T', 'packages/core/src/gateway/setup-cli.ts'], {
+  const compiledSetup = path.join(projectRoot, 'dist', 'packages/core/src/gateway/setup-cli.js');
+  const useCompiled = fs.existsSync(compiledSetup);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledSetup] : ['ts-node', '-T', 'packages/core/src/gateway/setup-cli.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 clearMemory(cliArgs) {
+  const compiledCli = path.join(projectRoot, 'dist', 'packages/core/src/gateway/cli.js');
+  const useCompiled = fs.existsSync(compiledCli);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledCli, 'clear', ...cliArgs] : ['ts-node', '-T', 'packages/core/src/gateway/cli.ts', 'clear', ...cliArgs];
+  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 setKey(cliArgs) {
+  const compiledCli = path.join(projectRoot, 'dist', 'packages/core/src/gateway/cli.js');
+  const useCompiled = fs.existsSync(compiledCli);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledCli, 'set-key', ...cliArgs] : ['ts-node', '-T', 'packages/core/src/gateway/cli.ts', 'set-key', ...cliArgs];
+  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 wallet(cliArgs) {
+  const compiledCli = path.join(projectRoot, 'dist', 'packages/core/src/gateway/cli.js');
+  const useCompiled = fs.existsSync(compiledCli);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledCli, 'wallet', ...cliArgs] : ['ts-node', '-T', 'packages/core/src/gateway/cli.ts', 'wallet', ...cliArgs];
+  const child = spawn(cmd, args, {
     cwd: projectRoot,
     stdio: 'inherit',
     env: { ...process.env, TS_NODE_CACHE: 'false' }
@@ -208,8 +261,12 @@ async function setup() {
   await new Promise(resolve => child.on('close', resolve));
 }
 
-async function clearMemory(args) {
-  const child = spawn('npx', ['ts-node', '-T', 'packages/core/src/gateway/cli.ts', 'clear', ...args], {
+async function runDoctor() {
+  const compiledCli = path.join(projectRoot, 'dist', 'packages/core/src/gateway/doctor.js');
+  const useCompiled = fs.existsSync(compiledCli);
+  const cmd = useCompiled ? 'node' : 'npx';
+  const args = useCompiled ? [compiledCli] : ['ts-node', '-T', 'packages/core/src/gateway/doctor.ts'];
+  const child = spawn(cmd, args, {
     cwd: projectRoot,
     stdio: 'inherit',
     env: { ...process.env, TS_NODE_CACHE: 'false' }
@@ -220,8 +277,11 @@ async function clearMemory(args) {
 
 async function main() {
   switch (command) {
+    case 'doctor': await runDoctor(); break;
     case 'setup': await setup(); break;
     case 'clear': await clearMemory(process.argv.slice(3)); break;
+    case 'set-key': await setKey(process.argv.slice(3)); break;
+    case 'wallet': await wallet(process.argv.slice(3)); break;
     case 'start': await start(); break;
     case 'stop': await stop(); break;
     case 'restart': await restart(); break;
@@ -238,7 +298,7 @@ async function main() {
       break;
     default:
       console.log(`
-Nyxora CLI Manager
+Nyxora CLI Manager - Your Personal Web3 Assistant
 Usage: nyxora <command>
 
 Commands:
@@ -247,12 +307,16 @@ Commands:
   restart        Restart the daemon
   setup          Run the interactive Setup Wizard
   dashboard      Open the dashboard in your browser
+  doctor         Run system diagnostics and check requirements
   clear          Atomically clear the AI's short/long-term memory SQLite database
   clean-logs     Clear the daemon logs
   autostart      Enable/disable autostart on boot (usage: nyxora autostart enable)
+  set-key        Securely save API Key (usage: nyxora set-key <provider> <key>)
+  wallet         Manage your Web3 Wallet (usage: nyxora wallet update)
 
 Options:
   -v, --version  Show current version
+  -h, --help     Show this help menu
 `);
   }
 }

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

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelLimitOrderToolDefinition = exports.listLimitOrdersToolDefinition = exports.createLimitOrderToolDefinition = exports.limitOrderManager = exports.LimitOrderManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const parser_1 = require("../config/parser");
+const paths_1 = require("../config/paths");
+const config_1 = require("../web3/config");
+const tokens_1 = require("../web3/utils/tokens");
+const swapToken_1 = require("../web3/skills/swapToken");
+const transactionManager_1 = require("./transactionManager");
+const reasoning_1 = require("./reasoning");
+class LimitOrderManager {
+    filePath;
+    orders = [];
+    monitorInterval = null;
+    constructor() {
+        const config = (0, parser_1.loadConfig)();
+        this.filePath = (0, paths_1.getPath)(config.memory?.path ? config.memory.path.replace('memory.json', 'orders.json') : 'orders.json');
+        this.loadOrders();
+    }
+    loadOrders() {
+        if (fs_1.default.existsSync(this.filePath)) {
+            try {
+                const data = fs_1.default.readFileSync(this.filePath, 'utf-8');
+                this.orders = JSON.parse(data);
+            }
+            catch (error) {
+                this.orders = [];
+            }
+        }
+    }
+    saveOrders() {
+        try {
+            fs_1.default.writeFileSync(this.filePath, JSON.stringify(this.orders, null, 2));
+        }
+        catch (error) { }
+    }
+    createOrder(chainName, fromToken, toToken, amountStr, targetPriceUsd, condition) {
+        const id = `order_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`;
+        const order = {
+            id, chainName, fromToken, toToken, amountStr, targetPriceUsd, condition, status: 'pending', createdAt: Date.now()
+        };
+        this.orders.push(order);
+        this.saveOrders();
+        return `Limit order created successfully. ID: ${id}. The system will monitor ${fromToken} price on ${chainName} and execute the swap to ${toToken} when price is ${condition} $${targetPriceUsd}.`;
+    }
+    listOrders() {
+        const pending = this.orders.filter(o => o.status === 'pending');
+        if (pending.length === 0)
+            return "No active limit orders.";
+        let report = "Active Limit Orders:\n";
+        pending.forEach(o => {
+            report += `- [${o.id}] Swap ${o.amountStr} ${o.fromToken} -> ${o.toToken} on ${o.chainName} when ${o.fromToken} is ${o.condition} $${o.targetPriceUsd}\n`;
+        });
+        return report;
+    }
+    cancelOrder(id) {
+        const order = this.orders.find(o => o.id === id);
+        if (!order)
+            return `Order ${id} not found.`;
+        if (order.status !== 'pending')
+            return `Order ${id} cannot be cancelled because it is ${order.status}.`;
+        order.status = 'cancelled';
+        this.saveOrders();
+        return `Order ${id} cancelled successfully.`;
+    }
+    startMonitor() {
+        if (this.monitorInterval)
+            clearInterval(this.monitorInterval);
+        // Monitor every 60 seconds
+        this.monitorInterval = setInterval(() => this.checkOrders(), 60000);
+        console.log('[LimitOrderManager] Order monitoring started (interval: 60s)');
+    }
+    async checkOrders() {
+        const pending = this.orders.filter(o => o.status === 'pending');
+        if (pending.length === 0)
+            return;
+        for (const order of pending) {
+            try {
+                let tokenAddress = (0, tokens_1.resolveToken)(order.fromToken, order.chainName);
+                if (tokenAddress === "0x0000000000000000000000000000000000000000") {
+                    tokenAddress = (0, tokens_1.resolveToken)("W" + order.fromToken, order.chainName);
+                }
+                const res = await fetch(`https://api.dexscreener.com/latest/dex/tokens/${tokenAddress}`);
+                if (!res.ok)
+                    continue;
+                const data = await res.json();
+                if (!data.pairs || data.pairs.length === 0)
+                    continue;
+                let pair = data.pairs.find((p) => p.chainId === order.chainName) || data.pairs[0];
+                const currentPrice = parseFloat(pair.priceUsd);
+                let shouldExecute = false;
+                if (order.condition === 'above' && currentPrice >= order.targetPriceUsd)
+                    shouldExecute = true;
+                if (order.condition === 'below' && currentPrice <= order.targetPriceUsd)
+                    shouldExecute = true;
+                if (shouldExecute) {
+                    console.log(`[LimitOrderManager] Condition met for order ${order.id}. Current price $${currentPrice} is ${order.condition} $${order.targetPriceUsd}. Executing...`);
+                    // 1. Prepare Swap
+                    const prepareResult = await (0, swapToken_1.prepareSwapToken)(order.chainName, order.fromToken, order.toToken, order.amountStr, 'auto');
+                    // 2. Extract Tx ID
+                    const txMatch = prepareResult.match(/Transaction ID: ([\w-]+)\./);
+                    if (!txMatch) {
+                        order.status = 'failed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} execution failed during preparation. Output: ${prepareResult}`, 'system').catch(() => { });
+                        continue;
+                    }
+                    const txId = txMatch[1];
+                    const tx = transactionManager_1.txManager.getTransaction(txId);
+                    if (!tx)
+                        throw new Error("Transaction not found in manager");
+                    // 3. Execute Swap automatically (bypass policy with autoApprove: true)
+                    const executeResult = await (0, swapToken_1.executeSwap)(order.chainName, tx.details, true);
+                    if (executeResult.includes('executed') || executeResult.includes('successful')) {
+                        transactionManager_1.txManager.updateStatus(txId, 'executed', executeResult);
+                        order.status = 'executed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} just EXECUTED automatically! Price hit $${currentPrice}. Swap result: ${executeResult}. Please notify the user immediately!`, 'system').catch(() => { });
+                    }
+                    else {
+                        transactionManager_1.txManager.updateStatus(txId, 'failed', executeResult);
+                        order.status = 'failed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} FAILED to execute. Price hit $${currentPrice} but execution failed: ${executeResult}. Please notify the user.`, 'system').catch(() => { });
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`[LimitOrderManager] Error checking order ${order.id}:`, error.message);
+            }
+        }
+    }
+}
+exports.LimitOrderManager = LimitOrderManager;
+exports.limitOrderManager = new LimitOrderManager();
+exports.createLimitOrderToolDefinition = {
+    type: "function",
+    function: {
+        name: "create_limit_order",
+        description: "Creates an automatic cut-loss or take-profit limit order. The system will automatically execute the swap when the price condition is met.",
+        parameters: {
+            type: "object",
+            properties: {
+                chainName: { type: "string", enum: config_1.SUPPORTED_CHAIN_NAMES },
+                fromToken: { type: "string", description: "Token to sell" },
+                toToken: { type: "string", description: "Token to buy" },
+                amountStr: { type: "string", description: "Amount to sell" },
+                targetPriceUsd: { type: "number", description: "Target price in USD for the fromToken" },
+                condition: { type: "string", enum: ["above", "below"], description: "Trigger when price goes above (take-profit) or below (cut-loss) target" }
+            },
+            required: ["chainName", "fromToken", "toToken", "amountStr", "targetPriceUsd", "condition"],
+        },
+    },
+};
+exports.listLimitOrdersToolDefinition = {
+    type: "function",
+    function: {
+        name: "list_limit_orders",
+        description: "Lists all active automated limit orders.",
+        parameters: { type: "object", properties: {}, required: [] },
+    },
+};
+exports.cancelLimitOrderToolDefinition = {
+    type: "function",
+    function: {
+        name: "cancel_limit_order",
+        description: "Cancels an active limit order by ID.",
+        parameters: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"],
+        },
+    },
+};