npm - nyxora - Versions diffs - 26.6.19 → 26.6.21 - Mend

nyxora 26.6.19 → 26.6.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (83) hide show

package/packages/dashboard/dist/index.html CHANGED Viewed

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Nyxora Dashboard</title>
-    <script type="module" crossorigin src="/assets/index-BAXifdMN.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DnQrbB4c.css">
+    <script type="module" crossorigin src="/assets/index-Di9x08yk.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CQNHWZtN.css">
   </head>
   <body>
     <div id="root"></div>

package/packages/dashboard/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "nyxora-dashboard",
   "private": true,
-  "version": "26.6.19",
+  "version": "26.6.21",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/packages/mcp-server/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "nyxora-mcp-server",
-  "version": "26.6.19",
+  "version": "26.6.21",
   "description": "Nyxora MCP Subserver, for external AI clients",
   "main": "dist/server.js",
   "scripts": {

package/packages/policy/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "nyxora-policy-engine",
-  "version": "26.6.19",
+  "version": "26.6.21",
   "private": true,
   "main": "src/server.ts",
   "dependencies": {

package/packages/signer/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "nyxora-signer",
-  "version": "26.6.19",
+  "version": "26.6.21",
   "private": true,
   "main": "src/server.ts",
   "dependencies": {

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

@@ -1,124 +0,0 @@
-"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 transactionManager_1 = require("./transactionManager");
-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 txDetails = {
-            id,
-            fromToken,
-            toToken,
-            amountStr,
-            targetPriceUsd,
-            condition
-        };
-        // Instead of saving directly, we push it to txManager to trigger the Approval Gate UX
-        transactionManager_1.txManager.createPendingTransaction('limit_order', chainName, txDetails);
-        return `Prepared limit order: Sell ${amountStr} ${fromToken} for ${toToken} when price is ${condition} $${targetPriceUsd}. I have pushed this to the Transaction Manager. Please wait for user approval on the Dashboard/Telegram. Do not say it's created yet.`;
-    }
-    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) {
-        // Note: To truly cancel a 1inch limit order, we need to call 1inch API to cancel the hash.
-        // For now, we mark it cancelled locally.
-        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 locally.`;
-    }
-    // Polling logic removed as per Phase 2 Migration to 1inch Off-Chain Protocol
-    startMonitor() {
-        console.log('[LimitOrderManager] Local polling disabled. Delegating to 1inch Limit Order Protocol.');
-    }
-    // We can add a method to save the 1inch hash after the user approves it
-    recordApprovedOrder(orderMetadata) {
-        this.orders.push(orderMetadata);
-        this.saveOrders();
-    }
-}
-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"],
-        },
-    },
-};

package/dist/packages/core/src/system/pluginManager.js DELETED Viewed

@@ -1,91 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pluginManager = exports.PluginManager = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const isolated_vm_1 = __importDefault(require("isolated-vm"));
-const paths_1 = require("../config/paths");
-class PluginManager {
-    skills = new Map();
-    async loadPlugins() {
-        const pluginsDir = path_1.default.join((0, paths_1.getAppDir)(), 'plugins');
-        if (!fs_1.default.existsSync(pluginsDir)) {
-            fs_1.default.mkdirSync(pluginsDir, { recursive: true });
-            return;
-        }
-        const files = fs_1.default.readdirSync(pluginsDir);
-        for (const file of files) {
-            if (file.endsWith('.js') || file.endsWith('.ts')) {
-                try {
-                    const absolutePath = path_1.default.resolve(pluginsDir, file);
-                    const code = fs_1.default.readFileSync(absolutePath, 'utf8');
-                    const isolate = new isolated_vm_1.default.Isolate({ memoryLimit: 128 });
-                    const context = isolate.createContextSync();
-                    const jail = context.global;
-                    jail.setSync('global', jail.derefInto());
-                    // Inject a safe fetch
-                    const safeFetch = new isolated_vm_1.default.Reference(async (url, options) => {
-                        if (url.includes('127.0.0.1') || url.includes('localhost') || url.includes('::1')) {
-                            throw new Error("SSRF Protection: Access to localhost is blocked.");
-                        }
-                        const res = await fetch(url, options);
-                        const text = await res.text();
-                        return text; // Only return text to avoid passing complex Response objects
-                    });
-                    jail.setSync('fetchText', safeFetch);
-                    // Inject console
-                    const logCallback = new isolated_vm_1.default.Reference((...args) => console.log('[Plugin]', ...args));
-                    jail.setSync('log', logCallback);
-                    const scriptCode = `
-             const console = { log: (...args) => log(...args) };
-             const fetch = async (url, options) => {
-                const text = await fetchText.apply(undefined, [url, options], { arguments: { copy: true }, result: { promise: true } });
-                return { text: async () => text, json: async () => JSON.parse(text) };
-             };
-             const module = { exports: {} };
-             const exports = module.exports;
-             ${code}
-             module.exports;
-          `;
-                    const script = isolate.compileScriptSync(scriptCode, { filename: file });
-                    const moduleExportsRef = script.runSync(context);
-                    const toolDefinition = moduleExportsRef.getSync('toolDefinition');
-                    const executeRef = moduleExportsRef.getSync('execute');
-                    if (toolDefinition && executeRef && typeof executeRef === 'object') {
-                        const toolName = toolDefinition.function.name;
-                        const safeExecute = async (args) => {
-                            const result = await executeRef.apply(undefined, [args], { arguments: { copy: true }, result: { promise: true, copy: true } });
-                            return result;
-                        };
-                        this.skills.set(toolName, { toolDefinition, execute: safeExecute });
-                        console.log(`[PluginManager] Loaded sandboxed external skill: ${toolName}`);
-                    }
-                    moduleExportsRef.release();
-                }
-                catch (error) {
-                    console.error(`[PluginManager] Failed to load sandboxed plugin ${file}:`, error.message);
-                }
-            }
-        }
-    }
-    getToolDefinitions() {
-        return Array.from(this.skills.values()).map(skill => skill.toolDefinition);
-    }
-    async executeTool(toolName, args) {
-        const skill = this.skills.get(toolName);
-        if (skill) {
-            try {
-                return await skill.execute(args);
-            }
-            catch (error) {
-                return `External skill ${toolName} failed: ${error.message}`;
-            }
-        }
-        return null; // Tool not found in external skills
-    }
-}
-exports.PluginManager = PluginManager;
-exports.pluginManager = new PluginManager();

package/dist/packages/core/src/system/skills/installSkill.js DELETED Viewed

@@ -1,52 +0,0 @@
-"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"));
-const paths_1 = require("../../config/paths");
-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((0, paths_1.getAppDir)(), 'plugins');
-        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/packages/core/src/test-all-routers.js DELETED Viewed

@@ -1,81 +0,0 @@
-"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 });
-const swapToken_1 = require("./web3/skills/swapToken");
-const configModule = __importStar(require("./web3/config"));
-// Mock getAddress to bypass Vault lock
-configModule.getAddress = async () => "0x28C6c06298d514Db089934071355E22Af1257125"; // dummy address
-const CHAINS = ["ethereum", "bsc", "base", "arbitrum", "optimism", "polygon"];
-const ROUTERS = ["auto", "lifi", "relay", "uniswap_v2", "uniswap_v3", "pancakeswap", "1inch", "cowswap"];
-// Helper to get native and stablecoin addresses per chain
-const TOKENS = {
-    ethereum: { in: "0x0000000000000000000000000000000000000000", out: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" }, // ETH to USDC
-    bsc: { in: "0x0000000000000000000000000000000000000000", out: "0x55d398326f99059fF775485246999027B3197955" }, // BNB to USDT
-    base: { in: "0x0000000000000000000000000000000000000000", out: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" }, // ETH to USDC
-    arbitrum: { in: "0x0000000000000000000000000000000000000000", out: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831" }, // ETH to USDC
-    optimism: { in: "0x0000000000000000000000000000000000000000", out: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85" }, // ETH to USDC
-    polygon: { in: "0x0000000000000000000000000000000000000000", out: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359" } // MATIC to USDC
-};
-async function runAllTests() {
-    console.log("=== COMPREHENSIVE ROUTER TEST ===");
-    for (const chain of CHAINS) {
-        console.log(`\n--- 🌐 Testing Chain: ${chain.toUpperCase()} ---`);
-        const { in: fromToken, out: toToken } = TOKENS[chain];
-        const providers = [
-            "1inch",
-            "0x",
-            "lifi",
-            "openocean",
-            "kyberswap"
-        ];
-        for (const router of providers) {
-            try {
-                const res = await (0, swapToken_1.prepareSwapToken)(chain, fromToken, toToken, "0.01", "manual", router);
-                // Extract just the success info to keep logs readable
-                const outputMatch = res.match(/Expected Output: ~([\d.]+) /);
-                if (outputMatch) {
-                    console.log(`[✅ SUCCESS] ${router.padEnd(15)} -> Quote: ~${outputMatch[1]} USDC/USDT`);
-                }
-                else {
-                    console.log(`[⚠️ PENDING] ${router.padEnd(15)} -> ${res.substring(0, 50)}...`);
-                }
-            }
-            catch (err) {
-                console.log(`[❌ FAILED]  ${router.padEnd(15)} -> ${err.message.split('\\n')[0]}`);
-            }
-        }
-    }
-}
-runAllTests();

package/dist/packages/core/src/test-router.js DELETED Viewed

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const swapToken_1 = require("./web3/skills/swapToken");
-async function runTest() {
-    console.log("=== Testing Native Routers ===");
-    try {
-        // 1. Test Uniswap V2
-        // 1. Test 1inch
-        console.log("\n[Test 1] Testing 1inch route (ETH to USDC on Base)...");
-        const resV2 = await (0, swapToken_1.prepareSwapToken)("base", // chain
-        "0x0000000000000000000000000000000000000000", // ETH native
-        "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC on Base
-        "0.001", // amount
-        "manual", // mode
-        "1inch" // providerName
-        );
-        console.log("Result 1 (1inch):", resV2);
-        // 2. Test 0x
-        console.log("\n[Test 2] Testing 0x route (WETH to USDT on Ethereum)...");
-        const resCow = await (0, swapToken_1.prepareSwapToken)("ethereum", // chain
-        "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
-        "0xdAC17F958D2ee523a2206206994597C13D831ec7", // USDT
-        "0.1", // 0.1 ETH
-        "auto", // mode
-        "0x" // providerName
-        );
-        console.log("Result 0x:", resCow);
-        // 3. Test Auto
-        console.log("\n[Test 3] Testing Auto route...");
-        const resAuto = await (0, swapToken_1.prepareSwapToken)("base", "0x0000000000000000000000000000000000000000", "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", "0.001", "auto");
-        console.log("Result Auto:", resAuto);
-        console.log("\\nAll tests completed!");
-    }
-    catch (error) {
-        console.error("\\nTEST FAILED:", error.message);
-    }
-}
-runTest();

package/dist/packages/core/src/web3/skills/autonomousDefi.js DELETED Viewed

@@ -1,191 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeDynamicDefiToolDefinition = exports.fetchContractAbiToolDefinition = void 0;
-exports.executeFetchContractAbi = executeFetchContractAbi;
-exports.executeDynamicDefi = executeDynamicDefi;
-const viem_1 = require("viem");
-const chains_1 = require("viem/chains");
-const protocolRegistry_1 = require("../utils/protocolRegistry");
-const parser_1 = require("../../config/parser");
-// The API key will be fetched dynamically inside the function
-const ETHERSCAN_URLS = {
-    1: 'https://api.etherscan.io/api',
-    11155111: 'https://api-sepolia.etherscan.io/api',
-    8453: 'https://api.basescan.org/api',
-    56: 'https://api.bscscan.com/api',
-    42161: 'https://api.arbiscan.io/api'
-};
-function getChainConfig(chainId) {
-    switch (chainId) {
-        case 1: return chains_1.mainnet;
-        case 11155111: return chains_1.sepolia;
-        case 8453: return chains_1.base;
-        case 56: return chains_1.bsc;
-        case 42161: return chains_1.arbitrum;
-        default: throw new Error(`Unsupported chain ID: ${chainId}`);
-    }
-}
-async function fetchABIFromEtherscan(chainId, address) {
-    const config = (0, parser_1.loadConfig)();
-    const apiKey = config.web3?.explorer_api_key || process.env.ETHERSCAN_API_KEY || '';
-    let url = '';
-    // Etherscan has migrated to V2 API for Mainnet and Sepolia
-    if (chainId === 1 || chainId === 11155111) {
-        url = `https://api.etherscan.io/v2/api?chainid=${chainId}&module=contract&action=getabi&address=${address}&apikey=${apiKey}`;
-    }
-    else {
-        const baseUrl = ETHERSCAN_URLS[chainId];
-        if (!baseUrl)
-            throw new Error(`No Etherscan URL for chain ${chainId}`);
-        url = `${baseUrl}?module=contract&action=getabi&address=${address}&apikey=${apiKey}`;
-    }
-    const response = await fetch(url);
-    const data = await response.json();
-    if (data.status !== '1') {
-        throw new Error(`Etherscan API Error: ${data.result}`);
-    }
-    return JSON.parse(data.result);
-}
-async function verifySecurity(address) {
-    console.log(`[Lapis 2] Verifying security for ${address} via GoPlus/DeFiLlama...`);
-    return true;
-}
-async function executeFetchContractAbi(args) {
-    try {
-        const { protocolName, chainId, contractAddress } = args;
-        console.log(`[Autonomous DeFi] Fetching ABI for ${protocolName} at ${contractAddress} on chain ${chainId}`);
-        const isSafe = await verifySecurity(contractAddress);
-        if (!isSafe) {
-            return `SECURITY ALERT: Contract ${contractAddress} is flagged as potentially malicious. Aborting.`;
-        }
-        let abi = await fetchABIFromEtherscan(chainId, contractAddress);
-        let implementationAddress = contractAddress;
-        const hasUpgradeTo = abi.some((item) => item.name === 'upgradeTo' || item.name === 'implementation');
-        if (hasUpgradeTo) {
-            console.log(`[Autonomous DeFi] Proxy pattern detected for ${contractAddress}. Resolving implementation...`);
-            const publicClient = (0, viem_1.createPublicClient)({
-                chain: getChainConfig(chainId),
-                transport: (0, viem_1.http)()
-            });
-            try {
-                // @ts-ignore: Dynamic ABI causes strict type inference issues in viem
-                const impl = await publicClient.readContract({
-                    address: (0, viem_1.getAddress)(contractAddress),
-                    abi: abi,
-                    functionName: 'implementation'
-                });
-                if (impl && impl !== '0x0000000000000000000000000000000000000000') {
-                    console.log(`[Autonomous DeFi] Implementation found at ${impl}. Fetching true ABI...`);
-                    implementationAddress = impl;
-                    abi = await fetchABIFromEtherscan(chainId, impl);
-                }
-            }
-            catch (err) {
-                console.log(`[Autonomous DeFi] Could not read implementation(): ${err}`);
-            }
-        }
-        const registryEntry = (0, protocolRegistry_1.getProtocol)(protocolName) || {
-            chainId,
-            contracts: {},
-            verifiedFunctions: {},
-            abiCache: {}
-        };
-        registryEntry.contracts['main'] = contractAddress;
-        registryEntry.abiCache = registryEntry.abiCache || {};
-        registryEntry.abiCache[contractAddress] = abi;
-        (0, protocolRegistry_1.updateProtocol)(protocolName, registryEntry);
-        return `Success! ABI fetched and resolved. True implementation is ${implementationAddress}.
-Available functions: ${abi.filter(a => a.type === 'function').map(a => a.name).join(', ')}.
-You can now use 'execute_dynamic_defi' to interact with it.`;
-    }
-    catch (error) {
-        return `Failed to fetch ABI: ${error.message}`;
-    }
-}
-async function executeDynamicDefi(args) {
-    try {
-        const { protocolName, contractAddress, targetFunction, inputs, requiresAllowance, tokenDecimals } = args;
-        const registryEntry = (0, protocolRegistry_1.getProtocol)(protocolName);
-        if (!registryEntry || !registryEntry.abiCache || !registryEntry.abiCache[contractAddress]) {
-            return `Error: ABI not found in registry for ${contractAddress}. Please run fetch_contract_abi first.`;
-        }
-        const abi = registryEntry.abiCache[contractAddress];
-        const formattedArgs = inputs.map(input => {
-            if (input.type.includes('uint') && tokenDecimals && !input.name.toLowerCase().includes('id')) {
-                return (0, viem_1.parseUnits)(input.value, tokenDecimals);
-            }
-            return input.value;
-        });
-        let allowanceNotice = "";
-        if (requiresAllowance) {
-            allowanceNotice = `\n[INTERCEPTOR] This action requires token allowance. The system will automatically bundle an 'approve()' transaction before the main execution.`;
-        }
-        const calldata = (0, viem_1.encodeFunctionData)({
-            abi: abi,
-            functionName: targetFunction,
-            args: formattedArgs
-        });
-        console.log(`[Lapis 3] Simulating transaction via Tenderly Engine...`);
-        registryEntry.verifiedFunctions[`${targetFunction}`] = {
-            verifiedAt: new Date().toISOString(),
-            safetyApproved: true
-        };
-        (0, protocolRegistry_1.updateProtocol)(protocolName, registryEntry);
-        return `Simulation Success! ${allowanceNotice}
-Target: ${contractAddress}
-Function: ${targetFunction}
-Calldata: ${calldata}
-The AI has securely encoded the parameters.`;
-    }
-    catch (error) {
-        return `Execution failed: ${error.message}`;
-    }
-}
-exports.fetchContractAbiToolDefinition = {
-    type: "function",
-    function: {
-        name: "fetch_contract_abi",
-        description: "Autonomous Universal DeFi Engine: Fetches the ABI of any smart contract. Automatically resolves EIP-1967/EIP-897 proxy patterns to find the true implementation ABI.",
-        parameters: {
-            type: "object",
-            properties: {
-                protocolName: { type: "string", description: "The name of the protocol (e.g. puffer-finance)" },
-                chainId: { type: "number", description: "Chain ID (e.g. 1 for Mainnet, 11155111 for Sepolia)" },
-                contractAddress: { type: "string", description: "The contract address to fetch" }
-            },
-            required: ["protocolName", "chainId", "contractAddress"]
-        }
-    }
-};
-exports.executeDynamicDefiToolDefinition = {
-    type: "function",
-    function: {
-        name: "execute_dynamic_defi",
-        description: "Autonomous Universal DeFi Engine: Executes a transaction on a contract using structured JSON. Ensure you have fetched the ABI first.",
-        parameters: {
-            type: "object",
-            properties: {
-                protocolName: { type: "string", description: "The name of the protocol" },
-                contractAddress: { type: "string", description: "The contract address to execute on" },
-                targetFunction: { type: "string", description: "The exact function name to call (e.g. 'deposit')" },
-                inputs: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        properties: {
-                            name: { type: "string" },
-                            type: { type: "string" },
-                            value: { type: "string", description: "Human readable string value (e.g. '100' for 100 USDC)." }
-                        },
-                        required: ["name", "type", "value"]
-                    },
-                    description: "Array of structured input arguments"
-                },
-                requiresAllowance: { type: "boolean", description: "True if this function transfers ERC20 tokens from the user" },
-                tokenDecimals: { type: "number", description: "Optional. Required if parsing token amounts for decimal scaling" }
-            },
-            required: ["protocolName", "contractAddress", "targetFunction", "inputs", "requiresAllowance"]
-        }
-    }
-};

package/dist/packages/core/src/web3/skills/createWallet.js DELETED Viewed

@@ -1,34 +0,0 @@
-"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: [],
-        },
-    },
-};