nyxora 1.5.8 → 1.5.9

package/README.md

@@ -1,13 +1,13 @@
 # Nyxora Agent 🤖
 **Production-Grade Secure AI Execution Framework for Web3 Agents.**
 
-[![Version](https://img.shields.io/badge/version-1.5.8-blue.svg)](https://github.com/perasyudha/Nyxora)
+[![Version](https://img.shields.io/badge/version-1.5.9-blue.svg)](https://github.com/perasyudha/Nyxora)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Security: Production-Grade](https://img.shields.io/badge/Security-Production--Grade-blue.svg)](#️-advanced-security-threat-model)
 [![Execution: Cryptographic Approval](https://img.shields.io/badge/Execution-Cryptographic--Approval-orange.svg)](#️-advanced-security-threat-model)
 [![Privacy: Local-Only Keys](https://img.shields.io/badge/Privacy-Local--Only--Keys-success.svg)](#️-advanced-security-threat-model)
 
-Nyxora (v1.5.8) is a **secure, non-custodial runtime infrastructure for autonomous onchain agents** built with a robust Monorepo architecture (Node.js & React). Designed for autonomous workflows with a premium Glassmorphism UI dashboard and strict client-side key isolation. 
+Nyxora (v1.5.9) is a **secure, non-custodial runtime infrastructure for autonomous onchain agents** built with a robust Monorepo architecture (Node.js & React). Designed for autonomous workflows with a premium Glassmorphism UI dashboard and strict client-side key isolation. 
 
 It operates under an institutional-grade **Cryptographically Bound Human-in-the-Loop** execution model, ensuring that Remote AIs (LLMs) never have unilateral access to your funds.
 
@@ -15,7 +15,7 @@ It operates under an institutional-grade **Cryptographically Bound Human-in-the-
 
 ## 🔥 Key Features
 
-### Advanced Security Architecture (v1.5.8)
+### Advanced Security Architecture (v1.5.9)
 *   **3-Tier IPC Architecture**: Nyxora is split into isolated processes: **Core** (LLM Runtime), **Policy Engine** (Guardrails on port 3001), and **Signer Vault** (Isolated Key Manager on Unix Sockets).
 *   **Cryptographically Bound Approval**: Policy changes and transactions requested by the AI are drafted as hashes (`sha256`). Approval via the UI requires a challenge nonce, preventing Man-in-the-Middle (MITM) attacks.
 *   **Immutable Policy Guardrails**: Transaction limits (e.g. `max_usd_per_tx`) are strictly enforced by the Policy Engine. The LLM has zero write-access to bypass these rules.
@@ -57,7 +57,7 @@ To dive deeper into the technical details of our Zero-Knowledge security archite
 ## 🚀 Quick Start & Installation
 
 ### Local Development & Execution
-With the new v1.5.8 Monorepo architecture, launching Nyxora is completely automated via the internal `launcher.ts` orchestrator.
+With the new v1.5.9 Monorepo architecture, launching Nyxora is completely automated via the internal `launcher.ts` orchestrator.
 
 ```bash
 git clone https://github.com/perasyudha/Nyxora.git

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nyxora",
-  "version": "1.5.8",
+  "version": "1.5.9",
   "workspaces": [
     "packages/*"
   ],

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nyxora/core",
-  "version": "1.5.8",
+  "version": "1.5.9",
   "private": true,
   "main": "src/gateway/server.ts",
   "dependencies": {

package/packages/core/src/agent/limitOrderManager.ts

@@ -0,0 +1,193 @@
+import fs from 'fs';
+import path from 'path';
+import { loadConfig } from '../config/parser';
+import { getPath } from '../config/paths';
+import { ChainName } from '../web3/config';
+import { resolveToken } from '../web3/utils/tokens';
+import { prepareSwapToken, executeSwap } from '../web3/skills/swapToken';
+import { txManager } from './transactionManager';
+import { processUserInput } from './reasoning';
+
+export interface LimitOrder {
+  id: string;
+  chainName: ChainName;
+  fromToken: string;
+  toToken: string;
+  amountStr: string;
+  targetPriceUsd: number;
+  condition: 'above' | 'below';
+  status: 'pending' | 'executed' | 'cancelled' | 'failed';
+  createdAt: number;
+}
+
+export class LimitOrderManager {
+  private filePath: string;
+  private orders: LimitOrder[] = [];
+  private monitorInterval: NodeJS.Timeout | null = null;
+
+  constructor() {
+    const config = loadConfig();
+    this.filePath = getPath(config.memory?.path ? config.memory.path.replace('memory.json', 'orders.json') : 'orders.json');
+    this.loadOrders();
+  }
+
+  private loadOrders() {
+    if (fs.existsSync(this.filePath)) {
+      try {
+        const data = fs.readFileSync(this.filePath, 'utf-8');
+        this.orders = JSON.parse(data);
+      } catch (error) {
+        this.orders = [];
+      }
+    }
+  }
+
+  private saveOrders() {
+    try {
+      fs.writeFileSync(this.filePath, JSON.stringify(this.orders, null, 2));
+    } catch (error) {}
+  }
+
+  public createOrder(chainName: ChainName, fromToken: string, toToken: string, amountStr: string, targetPriceUsd: number, condition: 'above' | 'below'): string {
+    const id = `order_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`;
+    const order: LimitOrder = {
+      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}.`;
+  }
+
+  public listOrders(): string {
+    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;
+  }
+
+  public cancelOrder(id: string): string {
+    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.`;
+  }
+
+  public 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)');
+  }
+
+  private async checkOrders() {
+    const pending = this.orders.filter(o => o.status === 'pending');
+    if (pending.length === 0) return;
+
+    for (const order of pending) {
+      try {
+        let tokenAddress = resolveToken(order.fromToken, order.chainName);
+        if (tokenAddress === "0x0000000000000000000000000000000000000000") {
+          tokenAddress = 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: any) => 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 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();
+            processUserInput(`Limit order ${order.id} execution failed during preparation. Output: ${prepareResult}`, 'system').catch(() => {});
+            continue;
+          }
+
+          const txId = txMatch[1];
+          const tx = 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 executeSwap(order.chainName, tx.details, true);
+          
+          if (executeResult.includes('executed') || executeResult.includes('successful')) {
+            txManager.updateStatus(txId, 'executed', executeResult);
+            order.status = 'executed';
+            this.saveOrders();
+            processUserInput(`Limit order ${order.id} just EXECUTED automatically! Price hit $${currentPrice}. Swap result: ${executeResult}. Please notify the user immediately!`, 'system').catch(() => {});
+          } else {
+            txManager.updateStatus(txId, 'failed', executeResult);
+            order.status = 'failed';
+            this.saveOrders();
+            processUserInput(`Limit order ${order.id} FAILED to execute. Price hit $${currentPrice} but execution failed: ${executeResult}. Please notify the user.`, 'system').catch(() => {});
+          }
+        }
+      } catch (error: any) {
+        console.error(`[LimitOrderManager] Error checking order ${order.id}:`, error.message);
+      }
+    }
+  }
+}
+
+export const limitOrderManager = new LimitOrderManager();
+
+export const 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: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"] },
+        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"],
+    },
+  },
+};
+
+export const listLimitOrdersToolDefinition = {
+  type: "function",
+  function: {
+    name: "list_limit_orders",
+    description: "Lists all active automated limit orders.",
+    parameters: { type: "object", properties: {}, required: [] },
+  },
+};
+
+export const 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"],
+    },
+  },
+};

package/packages/core/src/agent/reasoning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasoning.d.ts","sourceRoot":"","sources":["reasoning.ts"],"names":[],"mappings":"AAkBA,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAmFrE"}