nyxora 1.2.0 → 1.4.0

package/dist/system/skills/installSkill.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installExternalSkillToolDefinition = void 0;
+exports.installExternalSkill = installExternalSkill;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function installExternalSkill(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            return `Failed to fetch skill from URL. Status: ${response.status}`;
+        }
+        const code = await response.text();
+        // Extract a filename from URL, or generate a random one
+        let filename = url.split('/').pop() || '';
+        if (!filename.endsWith('.ts') && !filename.endsWith('.js')) {
+            filename = `skill_${Date.now()}.ts`;
+        }
+        // Ensure external_skills directory exists
+        const pluginsDir = path_1.default.join(process.cwd(), 'src', 'external_skills');
+        if (!fs_1.default.existsSync(pluginsDir)) {
+            fs_1.default.mkdirSync(pluginsDir, { recursive: true });
+        }
+        const filePath = path_1.default.join(pluginsDir, filename);
+        fs_1.default.writeFileSync(filePath, code, 'utf8');
+        return `Skill successfully downloaded and installed to ${filePath}. Please restart the server for the plugin manager to compile and load it.`;
+    }
+    catch (error) {
+        return `Failed to install skill: ${error.message}`;
+    }
+}
+exports.installExternalSkillToolDefinition = {
+    type: "function",
+    function: {
+        name: "install_external_skill",
+        description: "Downloads and installs a third-party typescript skill from a URL (e.g. GitHub Gist raw URL).",
+        parameters: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "The direct raw URL to the .ts or .js file of the skill.",
+                }
+            },
+            required: ["url"],
+        },
+    },
+};

package/dist/system/skills/readFile.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readLocalFileToolDefinition = void 0;
+exports.readLocalFile = readLocalFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function readLocalFile(filePath) {
+    try {
+        const absolutePath = path_1.default.resolve(filePath);
+        if (!fs_1.default.existsSync(absolutePath)) {
+            return `Error: File not found at ${absolutePath}`;
+        }
+        const content = fs_1.default.readFileSync(absolutePath, 'utf8');
+        return content;
+    }
+    catch (error) {
+        return `Failed to read file: ${error.message}`;
+    }
+}
+exports.readLocalFileToolDefinition = {
+    type: "function",
+    function: {
+        name: "read_local_file",
+        description: "Reads the content of a local file on the user's computer.",
+        parameters: {
+            type: "object",
+            properties: {
+                filePath: {
+                    type: "string",
+                    description: "The absolute or relative path to the file.",
+                }
+            },
+            required: ["filePath"],
+        },
+    },
+};

package/dist/system/skills/updateSecurityPolicy.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSecurityPolicyToolDefinition = void 0;
+exports.updateSecurityPolicy = updateSecurityPolicy;
+const fs_1 = __importDefault(require("fs"));
+const paths_1 = require("../../config/paths");
+function updateSecurityPolicy(rule, action) {
+    try {
+        const policyPath = (0, paths_1.getPath)('security_policy.md');
+        let existingContent = "";
+        if (fs_1.default.existsSync(policyPath)) {
+            existingContent = fs_1.default.readFileSync(policyPath, 'utf8');
+        }
+        if (action === 'clear') {
+            fs_1.default.writeFileSync(policyPath, '', 'utf8');
+            return "Security policy cleared.";
+        }
+        else if (action === 'add') {
+            const newContent = existingContent + (existingContent.endsWith('\n') || existingContent === '' ? '' : '\n') + `* ${rule}`;
+            fs_1.default.writeFileSync(policyPath, newContent, 'utf8');
+            return `Rule added to security policy: ${rule}`;
+        }
+        else if (action === 'remove') {
+            // Very basic line removal
+            const lines = existingContent.split('\n');
+            const filtered = lines.filter(l => !l.includes(rule));
+            fs_1.default.writeFileSync(policyPath, filtered.join('\n'), 'utf8');
+            return `Rule removed (if it existed).`;
+        }
+        return "Invalid action.";
+    }
+    catch (error) {
+        return `Failed to update security policy: ${error.message}`;
+    }
+}
+exports.updateSecurityPolicyToolDefinition = {
+    type: "function",
+    function: {
+        name: "update_security_policy",
+        description: "Updates the security_policy.md file to restrict your own autonomous behavior. Use this when the user explicitly forbids you from doing something (e.g. 'do not touch drive E').",
+        parameters: {
+            type: "object",
+            properties: {
+                rule: {
+                    type: "string",
+                    description: "The rule to add or remove.",
+                },
+                action: {
+                    type: "string",
+                    enum: ["add", "remove", "clear"],
+                    description: "The action to perform on the policy.",
+                }
+            },
+            required: ["rule", "action"],
+        },
+    },
+};

package/dist/system/skills/writeFile.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeLocalFileToolDefinition = void 0;
+exports.writeLocalFile = writeLocalFile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function writeLocalFile(filePath, content) {
+    try {
+        const absolutePath = path_1.default.resolve(filePath);
+        const dir = path_1.default.dirname(absolutePath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        fs_1.default.writeFileSync(absolutePath, content, 'utf8');
+        return `Success: File written to ${absolutePath}`;
+    }
+    catch (error) {
+        return `Failed to write file: ${error.message}`;
+    }
+}
+exports.writeLocalFileToolDefinition = {
+    type: "function",
+    function: {
+        name: "write_local_file",
+        description: "Writes or overwrites a local file on the user's computer with the provided content.",
+        parameters: {
+            type: "object",
+            properties: {
+                filePath: {
+                    type: "string",
+                    description: "The absolute or relative path to the file.",
+                },
+                content: {
+                    type: "string",
+                    description: "The string content to write to the file.",
+                }
+            },
+            required: ["filePath", "content"],
+        },
+    },
+};

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.4.0",
   "description": "",
   "main": "dist/gateway/cli.js",
   "files": [

package/user.md

@@ -4,6 +4,6 @@ Every time the agent reads your messages, it will read this file first as its pr
 
 Examples:
 
-* "Call me Yudha"
+* "Call me User"
 * "Use casual and slang language"
 * "Focus analysis from a technical trading perspective"