nyxora 1.1.8 → 1.3.0

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/mintNft.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mintNftToolDefinition = void 0;
+exports.prepareMintNft = prepareMintNft;
+exports.executeMintNft = executeMintNft;
+const viem_1 = require("viem");
+const config_1 = require("../config");
+const transactionManager_1 = require("../../agent/transactionManager");
+async function prepareMintNft(chainName, contractAddress, functionSignature, argsStr, valueEth = "0") {
+    try {
+        const publicClient = (0, config_1.getPublicClient)(chainName);
+        const walletClient = (0, config_1.getWalletClient)(chainName);
+        const account = walletClient.account;
+        // Parse arguments from JSON or comma separated
+        let parsedArgs = [];
+        try {
+            parsedArgs = JSON.parse(argsStr);
+            if (!Array.isArray(parsedArgs)) {
+                parsedArgs = [parsedArgs];
+            }
+        }
+        catch (e) {
+            if (argsStr.includes(",")) {
+                parsedArgs = argsStr.split(",").map(i => i.trim());
+            }
+            else {
+                parsedArgs = [argsStr.trim()];
+            }
+        }
+        let cleanSig = functionSignature.trim();
+        if (!cleanSig.startsWith("function ")) {
+            cleanSig = `function ${cleanSig}`;
+        }
+        // ensure it's payable or nonpayable properly. Viem parseAbi requires it to be payable if we send value
+        if (valueEth !== "0" && !cleanSig.includes("payable")) {
+            cleanSig = `${cleanSig} payable`;
+        }
+        const abi = (0, viem_1.parseAbi)([cleanSig]);
+        // Extract function name
+        const match = cleanSig.match(/function\s+([a-zA-Z0-9_]+)\s*\(/);
+        if (!match)
+            throw new Error("Invalid function signature format. Use e.g. 'mint(uint256)'");
+        const functionName = match[1];
+        const valueWei = (0, viem_1.parseEther)(valueEth);
+        const { request } = await publicClient.simulateContract({
+            account,
+            address: contractAddress,
+            abi,
+            functionName,
+            args: parsedArgs,
+            value: valueWei,
+        });
+        // @ts-ignore
+        const gasEstimate = request.gas || 100000n;
+        const tx = transactionManager_1.txManager.createPendingTransaction('mint', chainName, {
+            contractAddress,
+            abi,
+            functionName,
+            parsedArgs,
+            valueWei: valueWei.toString(),
+            gasEstimate: gasEstimate.toString()
+        });
+        return `TRANSACTION_PENDING: Simulated NFT Minting successfully. Estimated gas units: ${gasEstimate}. Transaction ID: ${tx.id}. Wait for user to approve.`;
+    }
+    catch (error) {
+        return `Simulation failed! Cannot prepare mint. Error: ${error.message}`;
+    }
+}
+async function executeMintNft(chainName, params) {
+    try {
+        const client = (0, config_1.getWalletClient)(chainName);
+        const { contractAddress, abi, functionName, parsedArgs, valueWei } = params;
+        // @ts-ignore
+        const hash = await client.writeContract({
+            account: client.account,
+            chain: client.chain,
+            address: contractAddress,
+            abi,
+            functionName,
+            args: parsedArgs,
+            value: BigInt(valueWei),
+        });
+        return `Mint successful. Tx Hash: ${hash}`;
+    }
+    catch (error) {
+        return `Failed to execute mint: ${error.message}`;
+    }
+}
+exports.mintNftToolDefinition = {
+    type: "function",
+    function: {
+        name: "mint_nft",
+        description: "Mint an NFT by calling a specific smart contract function. Automatically simulates the transaction first.",
+        parameters: {
+            type: "object",
+            properties: {
+                chainName: {
+                    type: "string",
+                    enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+                    description: "The blockchain network",
+                },
+                contractAddress: {
+                    type: "string",
+                    description: "The NFT smart contract address (0x...)",
+                },
+                functionSignature: {
+                    type: "string",
+                    description: "The function signature to call, e.g., 'mint(uint256)' or 'claim(address,uint256)'",
+                },
+                argsStr: {
+                    type: "string",
+                    description: "A JSON array of arguments for the function, e.g., '[1]' or '[\"0x123...\", 2]'",
+                },
+                valueEth: {
+                    type: "string",
+                    description: "The amount of native ETH/BNB to send as payment for the mint. Use '0' if it's a free mint.",
+                }
+            },
+            required: ["chainName", "contractAddress", "functionSignature", "argsStr", "valueEth"],
+        },
+    },
+};

package/dist/web3/skills/swapToken.js

@@ -1,77 +1,217 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.swapTokenToolDefinition = void 0;
-exports.swapToken = swapToken;
+exports.prepareSwapToken = prepareSwapToken;
 exports.executeSwap = executeSwap;
+const viem_1 = require("viem");
+const config_1 = require("../config");
+const transactionManager_1 = require("../../agent/transactionManager");
+const tokens_1 = require("../utils/tokens");
+const CHAIN_IDS = {
+    ethereum: 1,
+    base: 8453,
+    bsc: 56,
+    arbitrum: 42161,
+    optimism: 10,
+    sepolia: 11155111,
+};
+async function getLifiQuote(fromChainId, toChainId, fromToken, toToken, amountWei, userAddress, slippage) {
+    const url = new URL('https://li.quest/v1/quote');
+    url.searchParams.append('fromChain', fromChainId.toString());
+    url.searchParams.append('toChain', toChainId.toString());
+    url.searchParams.append('fromToken', fromToken);
+    url.searchParams.append('toToken', toToken);
+    url.searchParams.append('fromAmount', amountWei);
+    url.searchParams.append('fromAddress', userAddress);
+    url.searchParams.append('slippage', slippage.toString());
+    const res = await fetch(url.toString());
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new Error(`Li.Fi API Error: ${err.message || res.statusText}`);
+    }
+    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,
+        destinationChainId: toChainId,
+        originCurrency: fromToken,
+        destinationCurrency: toToken,
+        amount: amountWei,
+        tradeType: "EXACT_INPUT"
+    };
+    const res = await fetch(`${baseUrl}/quote`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new Error(`Relay API Error: ${err.message || res.statusText}`);
+    }
+    return await res.json();
+}
+async function prepareSwapToken(chainName, fromToken, toToken, amountStr, mode = "auto", providerName = "lifi", slippagePercent = 0.5) {
+    try {
+        const publicClient = (0, config_1.getPublicClient)(chainName);
+        const walletClient = (0, config_1.getWalletClient)(chainName);
+        const account = walletClient.account;
+        const chainId = CHAIN_IDS[chainName];
+        const fromTokenAddress = (0, tokens_1.resolveToken)(fromToken, chainName);
+        const toTokenAddress = (0, tokens_1.resolveToken)(toToken, chainName);
+        const isNativeIn = fromTokenAddress === "0x0000000000000000000000000000000000000000";
+        // Get decimals
+        let decimals = 18;
+        if (!isNativeIn) {
+            decimals = await publicClient.readContract({
+                address: fromTokenAddress,
+                abi: tokens_1.ERC20_ABI,
+                functionName: 'decimals',
+            });
+        }
+        const amountWei = (0, viem_1.parseUnits)(amountStr, decimals).toString();
+        let txRequest = null;
+        let approvalAddress = null;
+        let expectedOutputStr = "";
+        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;
+            approvalAddress = quote.estimate.approvalAddress;
+            const toDecimals = quote.action.toToken.decimals;
+            expectedOutputStr = (0, viem_1.formatUnits)(BigInt(quote.estimate.toAmount), toDecimals);
+        }
+        else if (actualProvider === "relay") {
+            const relayQuote = await getRelayQuote(chainId, chainId, fromTokenAddress, toTokenAddress, amountWei, account.address);
+            if (!relayQuote.steps || relayQuote.steps.length === 0)
+                throw new Error("No route found by Relay.");
+            // Relay returns steps. We need to find the main transaction step.
+            const txStep = relayQuote.steps.find((s) => s.id === "execute");
+            if (!txStep || !txStep.items || txStep.items.length === 0)
+                throw new Error("Relay steps invalid.");
+            const item = txStep.items[0];
+            txRequest = item.data;
+            // Usually Relay route approval to `txRequest.to` if it's not native
+            if (!isNativeIn && txRequest.to.toLowerCase() !== fromTokenAddress.toLowerCase()) {
+                approvalAddress = txRequest.to;
+            }
+            expectedOutputStr = relayQuote.details?.currencyOut?.amountFormatted || "Unknown";
+        }
+        // Check allowance early so we know if we need to auto-approve
+        let needsApprove = false;
+        if (!isNativeIn && approvalAddress && approvalAddress !== "0x0000000000000000000000000000000000000000") {
+            const allowance = await publicClient.readContract({
+                address: fromTokenAddress,
+                abi: tokens_1.ERC20_ABI,
+                functionName: 'allowance',
+                args: [account.address, approvalAddress],
+            });
+            if (allowance < BigInt(amountWei)) {
+                needsApprove = true;
+            }
+        }
+        const tx = transactionManager_1.txManager.createPendingTransaction('swap', chainName, {
+            txRequest,
+            needsApprove,
+            fromTokenAddress,
+            approvalAddress,
+            amountWei
+        });
+        return `TRANSACTION_PENDING: Swap simulated via ${actualProvider.toUpperCase()}. Expected Output: ~${expectedOutputStr} ${toToken.toUpperCase()}. ${needsApprove ? '(Auto-Approve required) ' : ''}Gas est: ${txRequest.gasLimit || 'auto'}. Transaction ID: ${tx.id}. Wait for user to approve.`;
+    }
+    catch (error) {
+        return `Simulation failed! Cannot prepare swap. Error: ${error.message}`;
+    }
+}
+async function executeSwap(chainName, params) {
+    try {
+        const client = (0, config_1.getWalletClient)(chainName);
+        const publicClient = (0, config_1.getPublicClient)(chainName);
+        const { txRequest, needsApprove, fromTokenAddress, approvalAddress, amountWei } = params;
+        if (needsApprove) {
+            // Auto-Approve Transaction
+            const approveHash = await client.writeContract({
+                account: client.account,
+                chain: client.chain,
+                address: fromTokenAddress,
+                abi: tokens_1.ERC20_ABI,
+                functionName: 'approve',
+                // Max Uint256
+                args: [approvalAddress, 115792089237316195423570985008687907853269984665640564039457584007913129639935n],
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveHash });
+        }
+        // Execute Swap
+        // @ts-ignore
+        const txHash = await client.sendTransaction({
+            account: client.account,
+            chain: client.chain,
+            to: txRequest.to,
+            data: txRequest.data,
+            value: txRequest.value ? BigInt(txRequest.value) : 0n,
+            gas: txRequest.gasLimit ? (BigInt(txRequest.gasLimit) * 12n / 10n) : undefined // 20% buffer
+        });
+        return `Swap successful. Tx Hash: ${txHash}`;
+    }
+    catch (error) {
+        return `Failed to execute swap: ${error.message}`;
+    }
+}
 exports.swapTokenToolDefinition = {
     type: "function",
     function: {
         name: "swap_token",
-        description: "Executes a decentralized token swap (DEX) to exchange one cryptocurrency for another.",
+        description: "Executes a decentralized token swap (DEX) to exchange one cryptocurrency for another using Li.Fi or Relay. Automatically simulates the swap to fetch quotes.",
         parameters: {
             type: "object",
             properties: {
                 chainName: {
                     type: "string",
-                    description: "The blockchain network (e.g., 'ethereum', 'base', 'arbitrum', 'sepolia')",
+                    enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+                    description: "The blockchain network",
                 },
                 fromToken: {
                     type: "string",
-                    description: "The token symbol to sell/swap from (e.g., 'ETH', 'USDC')",
+                    description: "The token symbol to sell (e.g., 'ETH', 'USDC')",
                 },
                 toToken: {
                     type: "string",
-                    description: "The token symbol to buy/swap to (e.g., 'USDC', 'UNI')",
+                    description: "The token symbol to buy (e.g., 'USDC', 'UNI')",
                 },
-                amount: {
-                    type: "number",
+                amountStr: {
+                    type: "string",
                     description: "The amount of fromToken to swap",
                 },
+                mode: {
+                    type: "string",
+                    enum: ["auto", "manual"],
+                    description: "auto uses lifi. manual uses the specified provider."
+                },
+                providerName: {
+                    type: "string",
+                    enum: ["lifi", "relay"],
+                    description: "Used if mode is manual."
+                }
             },
-            required: ["chainName", "fromToken", "toToken", "amount"],
+            required: ["chainName", "fromToken", "toToken", "amountStr"],
         },
     },
 };
-const transactionManager_1 = require("../../agent/transactionManager");
-async function swapToken(chainName, fromToken, toToken, amount) {
-    const tx = transactionManager_1.txManager.createPendingTransaction('swap', chainName, { fromToken, toToken, amount });
-    return `TRANSACTION_PENDING: I have prepared the token swap. Transaction ID: ${tx.id}. Wait for user to approve.`;
-}
-async function executeSwap(chainName, fromToken, toToken, amount) {
-    try {
-        // Generate simulated exchange rate for testnet/demo purposes
-        let rate = 1.0;
-        // Simple mock rates based on common pairs
-        if (fromToken.toUpperCase() === 'ETH' && toToken.toUpperCase() === 'USDC')
-            rate = 3200;
-        if (fromToken.toUpperCase() === 'USDC' && toToken.toUpperCase() === 'ETH')
-            rate = 1 / 3200;
-        if (fromToken.toUpperCase() === 'ETH' && toToken.toUpperCase() === 'LINK')
-            rate = 200;
-        if (fromToken.toUpperCase() === 'SOL' && toToken.toUpperCase() === 'USDC')
-            rate = 150;
-        // Add a slight random variance (±1%) to simulate live market slippage
-        const variance = 1 + (Math.random() * 0.02 - 0.01);
-        const finalRate = rate * variance;
-        const toAmount = amount * finalRate;
-        // Simulate transaction execution delay
-        await new Promise(resolve => setTimeout(resolve, 2500));
-        // Generate mock transaction hash
-        const txHash = '0x' + Array.from({ length: 64 }, () => Math.floor(Math.random() * 16).toString(16)).join('');
-        const swapResult = {
-            chain: chainName,
-            fromToken: fromToken.toUpperCase(),
-            toToken: toToken.toUpperCase(),
-            fromAmount: amount.toFixed(4),
-            toAmount: toAmount.toFixed(4),
-            exchangeRate: finalRate.toFixed(6),
-            gasFee: (Math.random() * 0.005).toFixed(4) + ' ETH',
-            txHash: txHash,
-            status: 'SUCCESS'
-        };
-        return JSON.stringify(swapResult);
-    }
-    catch (error) {
-        return JSON.stringify({ error: `Failed to execute swap: ${error.message}` });
-    }
-}

package/dist/web3/skills/transfer.js

@@ -1,35 +1,109 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transferToolDefinition = void 0;
-exports.transferNative = transferNative;
+exports.prepareTransfer = prepareTransfer;
 exports.executeTransfer = executeTransfer;
 const viem_1 = require("viem");
 const config_1 = require("../config");
 const transactionManager_1 = require("../../agent/transactionManager");
-async function transferNative(chainName, toAddress, amountEth) {
-    const tx = transactionManager_1.txManager.createPendingTransaction('transfer', chainName, { toAddress, amountEth });
-    return `TRANSACTION_PENDING: I have prepared the transfer. Transaction ID: ${tx.id}. Wait for user to approve.`;
+const tokens_1 = require("../utils/tokens");
+async function prepareTransfer(chainName, toAddress, amountStr, token) {
+    try {
+        const publicClient = (0, config_1.getPublicClient)(chainName);
+        const walletClient = (0, config_1.getWalletClient)(chainName);
+        const account = walletClient.account;
+        let tokenAddress = "0x0000000000000000000000000000000000000000";
+        let isNative = true;
+        let decimals = 18;
+        let symbol = "ETH/BNB"; // Generic fallback for native
+        if (token) {
+            tokenAddress = (0, tokens_1.resolveToken)(token, chainName);
+            isNative = tokenAddress === "0x0000000000000000000000000000000000000000";
+        }
+        let gasEstimate = 0n;
+        if (isNative) {
+            // Simulate Native Transfer
+            const value = (0, viem_1.parseEther)(amountStr);
+            gasEstimate = await publicClient.estimateGas({
+                account,
+                to: toAddress,
+                value,
+            });
+        }
+        else {
+            // Simulate ERC-20 Transfer
+            decimals = await publicClient.readContract({
+                address: tokenAddress,
+                abi: tokens_1.ERC20_ABI,
+                functionName: 'decimals',
+            });
+            symbol = await publicClient.readContract({
+                address: tokenAddress,
+                abi: tokens_1.ERC20_ABI,
+                functionName: 'symbol',
+            }).catch(() => token || "TOKEN");
+            const value = (0, viem_1.parseUnits)(amountStr, decimals);
+            const { request } = await publicClient.simulateContract({
+                account,
+                address: tokenAddress,
+                abi: tokens_1.ERC20_ABI,
+                functionName: 'transfer',
+                args: [toAddress, value],
+            });
+            // @ts-ignore
+            gasEstimate = request.gas || 50000n;
+        }
+        const tx = transactionManager_1.txManager.createPendingTransaction('transfer', chainName, {
+            toAddress,
+            amountStr,
+            tokenAddress,
+            isNative,
+            decimals,
+            gasEstimate: gasEstimate.toString()
+        });
+        const tokenName = isNative ? "Native Token" : symbol;
+        return `TRANSACTION_PENDING: I have prepared the ${tokenName} transfer and simulated it successfully. Estimated gas units: ${gasEstimate}. Transaction ID: ${tx.id}. Wait for user to approve.`;
+    }
+    catch (error) {
+        return `Simulation failed! Cannot prepare transfer. Error: ${error.message}`;
+    }
 }
-async function executeTransfer(chainName, toAddress, amountEth) {
+async function executeTransfer(chainName, params) {
     try {
         const client = (0, config_1.getWalletClient)(chainName);
-        const hash = await client.sendTransaction({
-            account: client.account,
-            chain: client.chain,
-            to: toAddress,
-            value: (0, viem_1.parseEther)(amountEth),
-        });
+        const { toAddress, amountStr, tokenAddress, isNative, decimals } = params;
+        let hash;
+        if (isNative) {
+            hash = await client.sendTransaction({
+                account: client.account,
+                chain: client.chain,
+                to: toAddress,
+                value: (0, viem_1.parseEther)(amountStr),
+            });
+        }
+        else {
+            const value = (0, viem_1.parseUnits)(amountStr, decimals);
+            // @ts-ignore
+            hash = await client.writeContract({
+                account: client.account,
+                chain: client.chain,
+                address: tokenAddress,
+                abi: tokens_1.ERC20_ABI,
+                functionName: 'transfer',
+                args: [toAddress, value],
+            });
+        }
         return `Transaction successful. Hash: ${hash}`;
     }
     catch (error) {
-        return `Failed to transfer: ${error.message}`;
+        return `Failed to execute transfer: ${error.message}`;
     }
 }
 exports.transferToolDefinition = {
     type: "function",
     function: {
-        name: "transfer_native",
-        description: "Transfer native tokens (ETH, BNB, etc.) from the agent's wallet to a destination address.",
+        name: "transfer_token",
+        description: "Transfer native tokens (ETH, BNB, etc.) or ERC-20 tokens from the agent's wallet to a destination address. Automatically performs on-chain simulation before requesting user approval.",
         parameters: {
             type: "object",
             properties: {
@@ -42,12 +116,16 @@ exports.transferToolDefinition = {
                     type: "string",
                     description: "The destination 0x... wallet address."
                 },
-                amountEth: {
+                amountStr: {
+                    type: "string",
+                    description: "The amount of tokens to send (e.g. '0.01')."
+                },
+                token: {
                     type: "string",
-                    description: "The amount of tokens to send in ETH units (e.g. '0.01')."
+                    description: "Optional. The token symbol (e.g. USDC, USDT) or contract address (0x...). If omitted, sends the native coin."
                 }
             },
-            required: ["chainName", "toAddress", "amountEth"]
+            required: ["chainName", "toAddress", "amountStr"]
         }
     }
 };