nyxora 1.2.0 → 1.3.0

package/README.md

@@ -18,11 +18,15 @@ With a beautiful, real-time dashboard inspired by modern control centers, Nyxora
 *   **Omnichannel Approvals**: Approve or reject pending transactions directly from the Web Dashboard's UI or via Telegram Inline Keyboard buttons on the go!
 *   **Strict API Auth**: The local Express server is protected via ephemeral Session Tokens (`x-nyxora-token`) and Strict CORS, preventing unauthorized local API requests.
 
-### ⛓️ Web3 DeFi Skills
+### ⛓️ Web3 DeFi Skills (Pro-Trader AI)
 *   **Multi-Chain Support**: Operate across Ethereum, Base, BSC, Arbitrum, Optimism, and Sepolia Testnet.
+*   **Wallet Generation**: Instruct the AI to generate new EVM wallets on the fly securely (Keys are never saved).
 *   **Native Wallet Operations**: Autonomously check balances and transfer native tokens using securely injected wallets.
-*   **Market Intelligence**: Fetch live crypto prices and 24h market movements via CoinGecko integration.
-*   **DeFi Token Swapping**: The agent can autonomously simulate liquidity routes and execute token swaps with gas fee estimations.
+*   **Advanced Market Intelligence**: Fetch live crypto prices, 24h market movements, FDV, and liquidity via CoinGecko and DexScreener integrations.
+*   **Anti-Rugpull & Security Scanner**: Nyxora can scan smart contracts via GoPlus Labs to detect Honeypots, Hidden Taxes, and malicious proxy upgrades before you buy.
+*   **PNL & Portfolio Tracking**: The AI scans your wallets and multiplies balances by live DEX prices to give you real-time Net Worth estimations.
+*   **DeFi Token Swapping & Bridging**: The agent can autonomously simulate liquidity routes and execute token swaps or cross-chain bridges with gas fee estimations.
+*   **Automated Limit Orders (Take-Profit/Cut-Loss)**: Set rules (e.g., "Sell my PEPE if price drops below $0.001"). Nyxora runs a background cron monitor and automatically executes the swap while you sleep without requiring manual approval!
 
 ### 💻 The Interface (Live Canvas)
 *   **Premium Glassmorphism UI**: A gorgeous, resizable split-pane interface.

package/SECURITY.md

@@ -14,7 +14,9 @@ Instead, please send an email to the repository owner or reach out privately. We
 When using Nyxora, you are configuring an autonomous agent that has direct access to your injected Web3 Wallet's private key.
 
 1. **Protect Your Keystore**: Your private key is encrypted and stored in `~/.nyxora/keystore.json`. While it is encrypted using `AES-256-GCM`, you must still treat it and your **Master Password** as highly sensitive. NEVER share your `keystore.json` or your Master Password with anyone.
-2. **Human-in-the-Loop Verification**: The agent is restricted from making unilateral transactions. Always review the exact details of the transaction when prompted to "Approve" or "Reject" on the Web Dashboard or Telegram Inline Keyboard before confirming.
-3. **Use Testnets**: While getting started or testing new skills, ALWAYS use a testnet (e.g., Sepolia) and a wallet containing only testnet funds.
-4. **Do Not Share Your `memory.json`**: The agent's memory may contain sensitive conversational data or addresses you've interacted with. Be cautious before sharing the `memory.json` export.
-5. **API Keys**: Treat your OpenAI, Gemini, and other LLM provider API keys as highly confidential. Rotate them immediately if you suspect a compromise.
+2. **Human-in-the-Loop Verification**: For standard actions, the agent is restricted from making unilateral transactions. Always review the exact details of the transaction when prompted to "Approve" or "Reject" on the Web Dashboard or Telegram Inline Keyboard before confirming.
+3. **Limit Order Automation Risk**: If you use the AI to create a **Limit Order** (Take-profit or Cut-loss), the system WILL execute the transaction automatically in the background when the price condition is met. This intentionally bypasses the Human-in-the-Loop verification for speed. Use this feature with caution.
+4. **Wallet Generation**: When you ask the AI to create a new wallet, it generates the Private Key and Seed Phrase locally and displays it once. It does NOT save it anywhere. You are responsible for immediately backing up this information.
+5. **Use Testnets**: While getting started or testing new skills, ALWAYS use a testnet (e.g., Sepolia) and a wallet containing only testnet funds.
+6. **Do Not Share Your `memory.json`**: The agent's memory may contain sensitive conversational data, generated seed phrases, or addresses you've interacted with. Be cautious before sharing the `memory.json` export.
+7. **API Keys**: Treat your OpenAI, Gemini, and other LLM provider API keys as highly confidential. Rotate them immediately if you suspect a compromise.

package/dist/agent/limitOrderManager.js

@@ -0,0 +1,177 @@
+"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 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
+                    const executeResult = await (0, swapToken_1.executeSwap)(order.chainName, tx.details);
+                    if (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: ["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"],
+        },
+    },
+};
+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"],
+        },
+    },
+};

package/dist/agent/reasoning.js

@@ -17,6 +17,11 @@ const swapToken_1 = require("../web3/skills/swapToken");
 const bridgeToken_1 = require("../web3/skills/bridgeToken");
 const mintNft_1 = require("../web3/skills/mintNft");
 const customTx_1 = require("../web3/skills/customTx");
+const createWallet_1 = require("../web3/skills/createWallet");
+const checkSecurity_1 = require("../web3/skills/checkSecurity");
+const marketAnalysis_1 = require("../web3/skills/marketAnalysis");
+const checkPortfolio_1 = require("../web3/skills/checkPortfolio");
+const limitOrderManager_1 = require("./limitOrderManager");
 const paths_1 = require("../config/paths");
 exports.logger = new logger_1.Logger();
 let currentKeyIndex = 0;
@@ -150,7 +155,14 @@ async function processUserInput(input, role = 'user') {
                 swapToken_1.swapTokenToolDefinition,
                 bridgeToken_1.bridgeTokenToolDefinition,
                 mintNft_1.mintNftToolDefinition,
-                customTx_1.customTxToolDefinition
+                customTx_1.customTxToolDefinition,
+                createWallet_1.createWalletToolDefinition,
+                checkSecurity_1.checkSecurityToolDefinition,
+                marketAnalysis_1.marketAnalysisToolDefinition,
+                checkPortfolio_1.checkPortfolioToolDefinition,
+                limitOrderManager_1.createLimitOrderToolDefinition,
+                limitOrderManager_1.listLimitOrdersToolDefinition,
+                limitOrderManager_1.cancelLimitOrderToolDefinition
             ],
             tool_choice: "auto",
         });
@@ -171,76 +183,76 @@ async function processUserInput(input, role = 'user') {
         if (responseMessage.tool_calls && responseMessage.tool_calls.length > 0) {
             for (const _toolCall of responseMessage.tool_calls) {
                 const toolCall = _toolCall;
-                if (toolCall.function.name === 'get_balance') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const balanceResult = await (0, getBalance_1.getBalance)(args.chainName, args.address, args.token);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: balanceResult,
-                    });
-                }
-                else if (toolCall.function.name === 'transfer_token' || toolCall.function.name === 'transfer_native') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const transferResult = await (0, transfer_1.prepareTransfer)(args.chainName, args.toAddress, args.amountStr || args.amountEth, args.token);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: transferResult,
-                    });
-                }
-                else if (toolCall.function.name === 'get_price') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const priceResult = await (0, getPrice_1.getPrice)(args.coinId);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: priceResult,
-                    });
-                }
-                else if (toolCall.function.name === 'swap_token') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const swapResult = await (0, swapToken_1.prepareSwapToken)(args.chainName, args.fromToken, args.toToken, args.amountStr || args.amount, args.mode, args.providerName);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: swapResult,
-                    });
-                }
-                else if (toolCall.function.name === 'bridge_token') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const bridgeResult = await (0, bridgeToken_1.prepareBridgeToken)(args.fromChainName, args.toChainName, args.fromToken, args.toToken, args.amountStr, args.mode, args.providerName);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: bridgeResult,
-                    });
-                }
-                else if (toolCall.function.name === 'mint_nft') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const mintResult = await (0, mintNft_1.prepareMintNft)(args.chainName, args.contractAddress, args.functionSignature, args.argsStr, args.valueEth);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: mintResult,
-                    });
-                }
-                else if (toolCall.function.name === 'custom_tx') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const customResult = await (0, customTx_1.prepareCustomTx)(args.chainName, args.toAddress, args.dataHex, args.valueEth, args.gasLimitStr);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: customResult,
-                    });
+                let result = "";
+                const args = JSON.parse(toolCall.function.arguments);
+                const toolName = toolCall.function.name;
+                switch (toolName) {
+                    case 'get_balance': {
+                        result = await (0, getBalance_1.getBalance)(args.chainName, args.address, args.token);
+                        break;
+                    }
+                    case 'transfer_token':
+                    case 'transfer_native': {
+                        result = await (0, transfer_1.prepareTransfer)(args.chainName, args.toAddress, args.amountStr || args.amountEth, args.token);
+                        break;
+                    }
+                    case 'get_price': {
+                        result = await (0, getPrice_1.getPrice)(args.coinId);
+                        break;
+                    }
+                    case 'swap_token': {
+                        result = await (0, swapToken_1.prepareSwapToken)(args.chainName, args.fromToken, args.toToken, args.amountStr || args.amount, args.mode, args.providerName);
+                        break;
+                    }
+                    case 'bridge_token': {
+                        result = await (0, bridgeToken_1.prepareBridgeToken)(args.fromChainName, args.toChainName, args.fromToken, args.toToken, args.amountStr, args.mode, args.providerName);
+                        break;
+                    }
+                    case 'mint_nft': {
+                        result = await (0, mintNft_1.prepareMintNft)(args.chainName, args.contractAddress, args.functionSignature, args.argsStr, args.valueEth);
+                        break;
+                    }
+                    case 'custom_tx': {
+                        result = await (0, customTx_1.prepareCustomTx)(args.chainName, args.toAddress, args.dataHex, args.valueEth, args.gasLimitStr);
+                        break;
+                    }
+                    case 'create_wallet': {
+                        result = await (0, createWallet_1.createWallet)();
+                        break;
+                    }
+                    case 'check_token_security': {
+                        result = await (0, checkSecurity_1.checkTokenSecurity)(args.chainName, args.contractAddress);
+                        break;
+                    }
+                    case 'analyze_market': {
+                        result = await (0, marketAnalysis_1.analyzeMarket)(args.chainName, args.tokenAddressOrSymbol);
+                        break;
+                    }
+                    case 'check_portfolio': {
+                        result = await (0, checkPortfolio_1.checkPortfolio)(args.chainName, args.address);
+                        break;
+                    }
+                    case 'create_limit_order': {
+                        result = limitOrderManager_1.limitOrderManager.createOrder(args.chainName, args.fromToken, args.toToken, args.amountStr, args.targetPriceUsd, args.condition);
+                        break;
+                    }
+                    case 'list_limit_orders': {
+                        result = limitOrderManager_1.limitOrderManager.listOrders();
+                        break;
+                    }
+                    case 'cancel_limit_order': {
+                        result = limitOrderManager_1.limitOrderManager.cancelOrder(args.id);
+                        break;
+                    }
+                    default:
+                        result = `Error: Tool ${toolName} is not implemented.`;
                 }
+                exports.logger.addEntry({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    name: toolName,
+                    content: result,
+                });
             }
             // Second call to get the final answer after tool execution
             const secondMessages = [

package/dist/gateway/server.js

@@ -12,6 +12,7 @@ const reasoning_1 = require("../agent/reasoning");
 const parser_1 = require("../config/parser");
 const tracker_1 = require("./tracker");
 const transactionManager_1 = require("../agent/transactionManager");
+const limitOrderManager_1 = require("../agent/limitOrderManager");
 const transfer_1 = require("../web3/skills/transfer");
 const swapToken_1 = require("../web3/skills/swapToken");
 const getBalance_1 = require("../web3/skills/getBalance");
@@ -180,6 +181,7 @@ app.use((req, res, next) => {
     }
 });
 function startServer() {
+    limitOrderManager_1.limitOrderManager.startMonitor();
     const PORT = process.env.PORT || 3000;
     app.listen(PORT, () => {
         console.log(`🤖 Nyxora API Server running on port ${PORT}`);

package/dist/gateway/telegram.js

@@ -28,6 +28,11 @@ function startTelegramBot() {
             const text = msg.text;
             if (!text)
                 return;
+            if (text === '/clear') {
+                reasoning_1.logger.clear();
+                bot.sendMessage(chatId, '✅ Memori AI telah dihapus. Mari kita mulai obrolan baru!');
+                return;
+            }
             // Log incoming message
             console.log(`[Telegram] Received from ${msg.from?.first_name}: ${text}`);
             // Send typing action to Telegram

package/dist/web3/skills/bridgeToken.js

@@ -32,6 +32,8 @@ async function getLifiQuote(fromChainId, toChainId, fromToken, toToken, amountWe
     return await res.json();
 }
 async function getRelayQuote(fromChainId, toChainId, fromToken, toToken, amountWei, userAddress) {
+    const isTestnet = fromChainId === 11155111 || toChainId === 11155111;
+    const baseUrl = isTestnet ? "https://api.testnets.relay.link" : "https://api.relay.link";
     const body = {
         user: userAddress,
         originChainId: fromChainId,
@@ -41,7 +43,7 @@ async function getRelayQuote(fromChainId, toChainId, fromToken, toToken, amountW
         amount: amountWei,
         tradeType: "EXACT_INPUT"
     };
-    const res = await fetch("https://api.relay.link/quote", {
+    const res = await fetch(`${baseUrl}/quote`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(body)
@@ -75,7 +77,22 @@ async function prepareBridgeToken(fromChainName, toChainName, fromToken, toToken
         let txRequest = null;
         let approvalAddress = null;
         let expectedOutputStr = "";
-        const actualProvider = mode === "auto" ? "lifi" : providerName;
+        let actualProvider = mode === "auto" ? "lifi" : providerName;
+        const isTestnet = fromChainId === 11155111 || toChainId === 11155111;
+        // --- SEPOLIA TESTNET MOCK ---
+        if (isTestnet) {
+            const mockGasLimit = "150000";
+            expectedOutputStr = "MOCK_TEST_AMOUNT";
+            const tx = transactionManager_1.txManager.createPendingTransaction('bridge', fromChainName, {
+                txRequest: { to: fromTokenAddress, data: "0x", value: amountWei, gasLimit: mockGasLimit },
+                needsApprove: false,
+                fromTokenAddress,
+                approvalAddress: null,
+                amountWei
+            });
+            return `TRANSACTION_PENDING: Bridge simulated via TESTNET_MOCK. Expected Output on ${toChainName}: ~${expectedOutputStr} ${toToken.toUpperCase()}. Gas est: ${mockGasLimit}. Transaction ID: ${tx.id}. Wait for user to approve.`;
+        }
+        // --- END MOCK ---
         if (actualProvider === "lifi") {
             const quote = await getLifiQuote(fromChainId, toChainId, fromTokenAddress, toTokenAddress, amountWei, account.address, slippagePercent / 100);
             txRequest = quote.transactionRequest;

package/dist/web3/skills/checkPortfolio.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPortfolioToolDefinition = void 0;
+exports.checkPortfolio = checkPortfolio;
+const viem_1 = require("viem");
+const config_1 = require("../config");
+const tokens_1 = require("../utils/tokens");
+async function checkPortfolio(chainName, address) {
+    try {
+        const client = (0, config_1.getPublicClient)(chainName);
+        let targetAddress = address;
+        if (!targetAddress) {
+            const { getAddress } = await Promise.resolve().then(() => __importStar(require('../config')));
+            targetAddress = getAddress();
+        }
+        if (!targetAddress) {
+            throw new Error('Address is required but could not be resolved from private key.');
+        }
+        const tokensToScan = [
+            { symbol: 'Native', address: '0x0000000000000000000000000000000000000000', isNative: true }
+        ];
+        const chainTokens = tokens_1.TOKEN_MAP[chainName];
+        if (chainTokens) {
+            for (const [sym, addr] of Object.entries(chainTokens)) {
+                if (addr !== "0x0000000000000000000000000000000000000000") {
+                    tokensToScan.push({ symbol: sym, address: addr, isNative: false });
+                }
+            }
+        }
+        let report = `📊 **Portfolio for ${targetAddress} on ${chainName.toUpperCase()}**\n\n`;
+        let totalUsdValue = 0;
+        // We will do Promise.all for balances
+        const balancePromises = tokensToScan.map(async (t) => {
+            let balanceNum = 0;
+            if (t.isNative) {
+                const bal = await client.getBalance({ address: targetAddress });
+                balanceNum = parseFloat((0, viem_1.formatEther)(bal));
+            }
+            else {
+                try {
+                    const [balWei, dec] = await Promise.all([
+                        client.readContract({
+                            address: t.address,
+                            abi: tokens_1.ERC20_ABI,
+                            functionName: 'balanceOf',
+                            args: [targetAddress],
+                        }),
+                        client.readContract({
+                            address: t.address,
+                            abi: tokens_1.ERC20_ABI,
+                            functionName: 'decimals',
+                        })
+                    ]);
+                    balanceNum = parseFloat((0, viem_1.formatUnits)(balWei, dec));
+                }
+                catch (e) {
+                    balanceNum = 0;
+                }
+            }
+            return { ...t, balanceNum };
+        });
+        const balances = await Promise.all(balancePromises);
+        const nonZeroBalances = balances.filter(b => b.balanceNum > 0);
+        if (nonZeroBalances.length === 0) {
+            return report + `No funds found for standard tokens on this chain. Net Worth: $0.00`;
+        }
+        // Now fetch prices from Dexscreener
+        // Prepare addresses to fetch
+        const addressesToFetch = nonZeroBalances.map(b => b.isNative ? (chainTokens?.WETH || chainTokens?.WBNB) : b.address).filter(Boolean);
+        const priceMap = {};
+        if (addressesToFetch.length > 0) {
+            const url = `https://api.dexscreener.com/latest/dex/tokens/${addressesToFetch.join(',')}`;
+            try {
+                const res = await fetch(url);
+                const data = await res.json();
+                if (data.pairs) {
+                    data.pairs.forEach((p) => {
+                        if (!priceMap[p.baseToken.address.toLowerCase()]) {
+                            priceMap[p.baseToken.address.toLowerCase()] = parseFloat(p.priceUsd);
+                        }
+                    });
+                }
+            }
+            catch (e) { }
+        }
+        for (const b of nonZeroBalances) {
+            const lookupAddr = (b.isNative ? (chainTokens?.WETH || chainTokens?.WBNB) : b.address)?.toLowerCase() || "";
+            const price = priceMap[lookupAddr] || 0;
+            const usdValue = b.balanceNum * price;
+            totalUsdValue += usdValue;
+            report += `- **${b.symbol}**: ${b.balanceNum.toFixed(4)} (~$${usdValue.toFixed(2)})\n`;
+        }
+        report += `\n💰 **Estimated Net Worth: $${totalUsdValue.toFixed(2)}**`;
+        return report;
+    }
+    catch (error) {
+        return `Failed to check portfolio: ${error.message}`;
+    }
+}
+exports.checkPortfolioToolDefinition = {
+    type: "function",
+    function: {
+        name: "check_portfolio",
+        description: "Scans the user's wallet for common tokens on a specific chain and calculates their total USD Net Worth (PNL proxy) using live prices.",
+        parameters: {
+            type: "object",
+            properties: {
+                chainName: {
+                    type: "string",
+                    enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+                    description: "The blockchain network",
+                },
+                address: {
+                    type: "string",
+                    description: "Optional wallet address. If omitted, uses the AI agent's own wallet.",
+                }
+            },
+            required: ["chainName"],
+        },
+    },
+};

package/dist/web3/skills/checkSecurity.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSecurityToolDefinition = void 0;
+exports.checkTokenSecurity = checkTokenSecurity;
+const CHAIN_IDS = {
+    ethereum: 1,
+    base: 8453,
+    bsc: 56,
+    arbitrum: 42161,
+    optimism: 10,
+    sepolia: 11155111,
+};
+async function checkTokenSecurity(chainName, contractAddress) {
+    try {
+        const chainId = CHAIN_IDS[chainName];
+        if (chainName === 'sepolia') {
+            return `Security check API (GoPlus) does not support Sepolia testnet. Try a mainnet token.`;
+        }
+        const url = `https://api.gopluslabs.io/api/v1/token_security/${chainId}?contract_addresses=${contractAddress}`;
+        const res = await fetch(url);
+        if (!res.ok) {
+            throw new Error(`GoPlus API Error: ${res.statusText}`);
+        }
+        const data = await res.json();
+        if (data.code !== 1 || !data.result) {
+            throw new Error(`API returned error: ${data.message || 'Unknown error'}`);
+        }
+        const tokenData = data.result[contractAddress.toLowerCase()];
+        if (!tokenData) {
+            return `Token security data not found for ${contractAddress} on ${chainName}.`;
+        }
+        let report = `Security Analysis for ${tokenData.token_name || 'Unknown'} (${tokenData.token_symbol || 'Unknown'}):\n`;
+        report += `- Is Honeypot: ${tokenData.is_honeypot === "1" ? "⚠️ YES (DANGER)" : "✅ NO"}\n`;
+        report += `- Buy Tax: ${tokenData.buy_tax ? (parseFloat(tokenData.buy_tax) * 100).toFixed(2) + '%' : 'Unknown'}\n`;
+        report += `- Sell Tax: ${tokenData.sell_tax ? (parseFloat(tokenData.sell_tax) * 100).toFixed(2) + '%' : 'Unknown'}\n`;
+        report += `- Cannot Sell All: ${tokenData.cannot_sell_all === "1" ? "⚠️ YES" : "✅ NO"}\n`;
+        report += `- Is Proxy Contract: ${tokenData.is_proxy === "1" ? "⚠️ YES (Can be upgraded)" : "✅ NO"}\n`;
+        report += `- Owner Can Change Balance: ${tokenData.owner_change_balance === "1" ? "⚠️ YES" : "✅ NO"}\n`;
+        report += `- Is Open Source: ${tokenData.is_open_source === "1" ? "✅ YES" : "⚠️ NO (Code is hidden)"}\n`;
+        return report;
+    }
+    catch (error) {
+        return `Failed to check token security: ${error.message}`;
+    }
+}
+exports.checkSecurityToolDefinition = {
+    type: "function",
+    function: {
+        name: "check_token_security",
+        description: "Check a token's smart contract for honeypot, rugpull risks, and buy/sell tax using GoPlus Security API.",
+        parameters: {
+            type: "object",
+            properties: {
+                chainName: {
+                    type: "string",
+                    enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+                    description: "The blockchain network",
+                },
+                contractAddress: {
+                    type: "string",
+                    description: "The token smart contract address (0x...)",
+                }
+            },
+            required: ["chainName", "contractAddress"],
+        },
+    },
+};

package/dist/web3/skills/createWallet.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWalletToolDefinition = void 0;
+exports.createWallet = createWallet;
+const accounts_1 = require("viem/accounts");
+async function createWallet() {
+    try {
+        const mnemonic = (0, accounts_1.generateMnemonic)(accounts_1.english);
+        const account = (0, accounts_1.mnemonicToAccount)(mnemonic);
+        return `[WALLET_CREATED_SUCCESSFULLY]
+A new EVM wallet has been generated. Please instruct the user to back up these details immediately as they will not be saved anywhere else:
+
+Address: ${account.address}
+Private Key: ${account.getHdKey().privateKey ? '0x' + Buffer.from(account.getHdKey().privateKey).toString('hex') : 'Unavailable'}
+Seed Phrase: ${mnemonic}
+
+IMPORTANT: Do not store this data in your AI memory. Only display it once.`;
+    }
+    catch (error) {
+        return `Failed to generate wallet: ${error.message}`;
+    }
+}
+exports.createWalletToolDefinition = {
+    type: "function",
+    function: {
+        name: "create_wallet",
+        description: "Generates a new EVM wallet address, private key, and 12-word seed phrase.",
+        parameters: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+};

package/dist/web3/skills/marketAnalysis.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketAnalysisToolDefinition = void 0;
+exports.analyzeMarket = analyzeMarket;
+const tokens_1 = require("../utils/tokens");
+async function analyzeMarket(chainName, tokenAddressOrSymbol) {
+    try {
+        let tokenAddress = tokenAddressOrSymbol;
+        try {
+            tokenAddress = (0, tokens_1.resolveToken)(tokenAddressOrSymbol, chainName);
+            if (tokenAddress === "0x0000000000000000000000000000000000000000") {
+                // For native token, we should pass WETH / wrapped version to Dexscreener usually, 
+                // because native token itself doesn't have a pair on most DEXes directly.
+                tokenAddress = (0, tokens_1.resolveToken)("W" + tokenAddressOrSymbol, chainName); // e.g. WETH, WBNB
+            }
+        }
+        catch (e) {
+            // If it fails to resolve, assume it's already an address or let DexScreener handle it (though DexScreener needs exact address)
+        }
+        const url = `https://api.dexscreener.com/latest/dex/tokens/${tokenAddress}`;
+        const res = await fetch(url);
+        if (!res.ok) {
+            throw new Error(`DexScreener API Error: ${res.statusText}`);
+        }
+        const data = await res.json();
+        if (!data.pairs || data.pairs.length === 0) {
+            return `No market data found for token ${tokenAddressOrSymbol} on DexScreener.`;
+        }
+        // Filter pairs by chain if possible, Dexscreener chain IDs are strings like 'ethereum', 'bsc', 'base', 'arbitrum', 'optimism'
+        let pair = data.pairs.find((p) => p.chainId === chainName);
+        if (!pair) {
+            pair = data.pairs[0]; // Fallback to the most liquid pair anywhere
+        }
+        let report = `📈 **Market Analysis for ${pair.baseToken.name} (${pair.baseToken.symbol})** on ${pair.chainId.toUpperCase()}\n\n`;
+        report += `**Price:** $${pair.priceUsd}\n`;
+        report += `**Liquidity (USD):** $${Number(pair.liquidity?.usd || 0).toLocaleString()}\n`;
+        report += `**FDV:** $${Number(pair.fdv || 0).toLocaleString()}\n`;
+        report += `**24h Volume:** $${Number(pair.volume?.h24 || 0).toLocaleString()}\n\n`;
+        report += `**Price Change:**\n`;
+        report += `- 5m:  ${pair.priceChange?.m5}% \n`;
+        report += `- 1h:  ${pair.priceChange?.h1}% \n`;
+        report += `- 24h: ${pair.priceChange?.h24}% \n\n`;
+        report += `**DEX:** ${pair.dexId} (${pair.url})\n`;
+        return report;
+    }
+    catch (error) {
+        return `Failed to analyze market: ${error.message}`;
+    }
+}
+exports.marketAnalysisToolDefinition = {
+    type: "function",
+    function: {
+        name: "analyze_market",
+        description: "Fetches live market data (Price, Liquidity, Volume, FDV, Price Change) for a token using DexScreener.",
+        parameters: {
+            type: "object",
+            properties: {
+                chainName: {
+                    type: "string",
+                    enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+                    description: "The blockchain network",
+                },
+                tokenAddressOrSymbol: {
+                    type: "string",
+                    description: "The token symbol (e.g. USDC, PEPE) or contract address to analyze.",
+                }
+            },
+            required: ["chainName", "tokenAddressOrSymbol"],
+        },
+    },
+};

package/dist/web3/skills/swapToken.js

@@ -32,6 +32,8 @@ async function getLifiQuote(fromChainId, toChainId, fromToken, toToken, amountWe
     return await res.json();
 }
 async function getRelayQuote(fromChainId, toChainId, fromToken, toToken, amountWei, userAddress) {
+    const isTestnet = fromChainId === 11155111 || toChainId === 11155111;
+    const baseUrl = isTestnet ? "https://api.testnets.relay.link" : "https://api.relay.link";
     const body = {
         user: userAddress,
         originChainId: fromChainId,
@@ -41,7 +43,7 @@ async function getRelayQuote(fromChainId, toChainId, fromToken, toToken, amountW
         amount: amountWei,
         tradeType: "EXACT_INPUT"
     };
-    const res = await fetch("https://api.relay.link/quote", {
+    const res = await fetch(`${baseUrl}/quote`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify(body)
@@ -74,7 +76,22 @@ async function prepareSwapToken(chainName, fromToken, toToken, amountStr, mode =
         let txRequest = null;
         let approvalAddress = null;
         let expectedOutputStr = "";
-        const actualProvider = mode === "auto" ? "lifi" : providerName;
+        let actualProvider = mode === "auto" ? "lifi" : providerName;
+        const isTestnet = chainId === 11155111;
+        // --- SEPOLIA TESTNET MOCK ---
+        if (isTestnet) {
+            const mockGasLimit = "150000";
+            expectedOutputStr = "MOCK_TEST_AMOUNT";
+            const tx = transactionManager_1.txManager.createPendingTransaction('swap', chainName, {
+                txRequest: { to: fromTokenAddress, data: "0x", value: amountWei, gasLimit: mockGasLimit },
+                needsApprove: false,
+                fromTokenAddress,
+                approvalAddress: null,
+                amountWei
+            });
+            return `TRANSACTION_PENDING: Swap simulated via TESTNET_MOCK. Expected Output: ~${expectedOutputStr} ${toToken.toUpperCase()}. Gas est: ${mockGasLimit}. Transaction ID: ${tx.id}. Wait for user to approve.`;
+        }
+        // --- END MOCK ---
         if (actualProvider === "lifi") {
             const quote = await getLifiQuote(chainId, chainId, fromTokenAddress, toTokenAddress, amountWei, account.address, slippagePercent / 100);
             txRequest = quote.transactionRequest;

package/dist/web3/utils/tokens.js

@@ -90,7 +90,8 @@ exports.TOKEN_MAP = {
     sepolia: {
         ETH: "0x0000000000000000000000000000000000000000",
         WETH: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
-        USDC: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238" // Circle Faucet Sepolia USDC
+        USDC: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238", // Circle Faucet Sepolia USDC
+        USDT: "0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0" // Common Sepolia USDT
     }
 };
 function resolveToken(tokenSymbolOrAddress, chainName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nyxora",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "",
   "main": "dist/gateway/cli.js",
   "files": [