nyxora 1.1.8 → 1.3.0

package/dist/web3/skills/bridgeToken.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bridgeTokenToolDefinition = void 0;
+exports.prepareBridgeToken = prepareBridgeToken;
+exports.executeBridge = executeBridge;
+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 prepareBridgeToken(fromChainName, toChainName, fromToken, toToken, amountStr, mode = "auto", providerName = "lifi", slippagePercent = 0.5) {
+    try {
+        const publicClient = (0, config_1.getPublicClient)(fromChainName);
+        const walletClient = (0, config_1.getWalletClient)(fromChainName);
+        const account = walletClient.account;
+        const fromChainId = CHAIN_IDS[fromChainName];
+        const toChainId = CHAIN_IDS[toChainName];
+        const fromTokenAddress = (0, tokens_1.resolveToken)(fromToken, fromChainName);
+        const toTokenAddress = (0, tokens_1.resolveToken)(toToken, toChainName);
+        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 = 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;
+            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(fromChainId, toChainId, fromTokenAddress, toTokenAddress, amountWei, account.address);
+            if (!relayQuote.steps || relayQuote.steps.length === 0)
+                throw new Error("No route found by Relay.");
+            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;
+            if (!isNativeIn && txRequest.to.toLowerCase() !== fromTokenAddress.toLowerCase()) {
+                approvalAddress = txRequest.to;
+            }
+            expectedOutputStr = relayQuote.details?.currencyOut?.amountFormatted || "Unknown";
+        }
+        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('bridge', fromChainName, {
+            txRequest,
+            needsApprove,
+            fromTokenAddress,
+            approvalAddress,
+            amountWei
+        });
+        return `TRANSACTION_PENDING: Bridge simulated via ${actualProvider.toUpperCase()}. Expected Output on ${toChainName}: ~${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 bridge. Error: ${error.message}`;
+    }
+}
+async function executeBridge(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) {
+            const approveHash = await client.writeContract({
+                account: client.account,
+                chain: client.chain,
+                address: fromTokenAddress,
+                abi: tokens_1.ERC20_ABI,
+                functionName: 'approve',
+                args: [approvalAddress, 115792089237316195423570985008687907853269984665640564039457584007913129639935n],
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveHash });
+        }
+        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
+        });
+        return `Bridge successful. Tx Hash: ${txHash}`;
+    }
+    catch (error) {
+        return `Failed to execute bridge: ${error.message}`;
+    }
+}
+exports.bridgeTokenToolDefinition = {
+    type: "function",
+    function: {
+        name: "bridge_token",
+        description: "Executes a cross-chain token bridge from one network to another using Li.Fi or Relay. Automatically simulates to fetch quotes.",
+        parameters: {
+            type: "object",
+            properties: {
+                fromChainName: {
+                    type: "string",
+                    enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+                    description: "The source blockchain network",
+                },
+                toChainName: {
+                    type: "string",
+                    enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+                    description: "The destination blockchain network",
+                },
+                fromToken: {
+                    type: "string",
+                    description: "The token symbol to sell on source chain (e.g., 'ETH', 'USDC')",
+                },
+                toToken: {
+                    type: "string",
+                    description: "The token symbol to buy on destination chain (e.g., 'USDC', 'UNI')",
+                },
+                amountStr: {
+                    type: "string",
+                    description: "The amount of fromToken to bridge",
+                },
+                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: ["fromChainName", "toChainName", "fromToken", "toToken", "amountStr"],
+        },
+    },
+};

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customTxToolDefinition = void 0;
+exports.prepareCustomTx = prepareCustomTx;
+exports.executeCustomTx = executeCustomTx;
+const viem_1 = require("viem");
+const config_1 = require("../config");
+const transactionManager_1 = require("../../agent/transactionManager");
+async function prepareCustomTx(chainName, toAddress, dataHex, valueEth = "0", gasLimitStr) {
+    try {
+        const publicClient = (0, config_1.getPublicClient)(chainName);
+        const walletClient = (0, config_1.getWalletClient)(chainName);
+        const account = walletClient.account;
+        if (!dataHex.startsWith("0x")) {
+            throw new Error("Data must start with 0x (Hex format)");
+        }
+        const valueWei = (0, viem_1.parseEther)(valueEth);
+        let gasEstimate = 0n;
+        if (gasLimitStr) {
+            gasEstimate = BigInt(gasLimitStr);
+        }
+        else {
+            gasEstimate = await publicClient.estimateGas({
+                account,
+                to: toAddress,
+                data: dataHex,
+                value: valueWei,
+            });
+        }
+        const tx = transactionManager_1.txManager.createPendingTransaction('custom', chainName, {
+            toAddress,
+            dataHex,
+            valueWei: valueWei.toString(),
+            gasEstimate: gasEstimate.toString()
+        });
+        return `TRANSACTION_PENDING: Simulated Custom Transaction successfully. Estimated gas units: ${gasEstimate}. Transaction ID: ${tx.id}. Wait for user to approve.`;
+    }
+    catch (error) {
+        return `Simulation failed! Cannot prepare custom tx. Error: ${error.message}`;
+    }
+}
+async function executeCustomTx(chainName, params) {
+    try {
+        const client = (0, config_1.getWalletClient)(chainName);
+        const { toAddress, dataHex, valueWei, gasEstimate } = params;
+        const hash = await client.sendTransaction({
+            account: client.account,
+            chain: client.chain,
+            to: toAddress,
+            data: dataHex,
+            value: BigInt(valueWei),
+            gas: gasEstimate ? BigInt(gasEstimate) * 12n / 10n : undefined, // 20% buffer
+        });
+        return `Custom transaction successful. Tx Hash: ${hash}`;
+    }
+    catch (error) {
+        return `Failed to execute custom transaction: ${error.message}`;
+    }
+}
+exports.customTxToolDefinition = {
+    type: "function",
+    function: {
+        name: "custom_tx",
+        description: "Executes a raw custom transaction with calldata (hex) on a specific blockchain network. Automatically simulates the execution.",
+        parameters: {
+            type: "object",
+            properties: {
+                chainName: {
+                    type: "string",
+                    enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"],
+                    description: "The blockchain network",
+                },
+                toAddress: {
+                    type: "string",
+                    description: "The destination contract or wallet address (0x...)",
+                },
+                dataHex: {
+                    type: "string",
+                    description: "The raw calldata payload in hex format (starting with 0x)",
+                },
+                valueEth: {
+                    type: "string",
+                    description: "The amount of native ETH/BNB to attach. Default is '0'.",
+                },
+                gasLimitStr: {
+                    type: "string",
+                    description: "Optional custom gas limit as a string. If omitted, the node will estimate it.",
+                }
+            },
+            required: ["chainName", "toAddress", "dataHex", "valueEth"],
+        },
+    },
+};

package/dist/web3/skills/getBalance.js

@@ -37,7 +37,8 @@ exports.getBalanceToolDefinition = void 0;
 exports.getBalance = getBalance;
 const viem_1 = require("viem");
 const config_1 = require("../config");
-async function getBalance(chainName, address) {
+const tokens_1 = require("../utils/tokens");
+async function getBalance(chainName, address, token) {
     try {
         const client = (0, config_1.getPublicClient)(chainName);
         let targetAddress = address;
@@ -48,9 +49,41 @@ async function getBalance(chainName, address) {
         if (!targetAddress) {
             throw new Error('Address is required but could not be resolved from private key.');
         }
-        const balanceWei = await client.getBalance({ address: targetAddress });
-        const balanceEth = (0, viem_1.formatEther)(balanceWei);
-        return `${balanceEth} on ${chainName}`;
+        if (token) {
+            const tokenAddress = (0, tokens_1.resolveToken)(token, chainName);
+            if (tokenAddress === "0x0000000000000000000000000000000000000000") {
+                const balanceWei = await client.getBalance({ address: targetAddress });
+                const balanceEth = (0, viem_1.formatEther)(balanceWei);
+                return `${balanceEth} on ${chainName}`;
+            }
+            else {
+                const [balanceWei, decimals, symbol] = await Promise.all([
+                    client.readContract({
+                        address: tokenAddress,
+                        abi: tokens_1.ERC20_ABI,
+                        functionName: 'balanceOf',
+                        args: [targetAddress],
+                    }),
+                    client.readContract({
+                        address: tokenAddress,
+                        abi: tokens_1.ERC20_ABI,
+                        functionName: 'decimals',
+                    }),
+                    client.readContract({
+                        address: tokenAddress,
+                        abi: tokens_1.ERC20_ABI,
+                        functionName: 'symbol',
+                    }).catch(() => token)
+                ]);
+                const balanceFormatted = (0, viem_1.formatUnits)(balanceWei, decimals);
+                return `${balanceFormatted} ${symbol} on ${chainName}`;
+            }
+        }
+        else {
+            const balanceWei = await client.getBalance({ address: targetAddress });
+            const balanceEth = (0, viem_1.formatEther)(balanceWei);
+            return `${balanceEth} on ${chainName}`;
+        }
     }
     catch (error) {
         return `Failed to get balance: ${error.message}`;
@@ -60,7 +93,7 @@ exports.getBalanceToolDefinition = {
     type: "function",
     function: {
         name: "get_balance",
-        description: "Get the native token balance (ETH, BNB, etc) of a wallet address on a specific chain. If address is omitted, it returns the balance of the agent's own wallet.",
+        description: "Get the native or ERC-20 token balance of a wallet address on a specific chain. If address is omitted, it returns the balance of the agent's own wallet.",
         parameters: {
             type: "object",
             properties: {
@@ -72,6 +105,10 @@ exports.getBalanceToolDefinition = {
                 address: {
                     type: "string",
                     description: "Optional. The 0x... address of the wallet. If not provided, it uses the agent's wallet."
+                },
+                token: {
+                    type: "string",
+                    description: "Optional. The token symbol (e.g. USDC, USDT, WETH) or contract address (0x...) to check. If omitted, checks the native coin (ETH/BNB)."
                 }
             },
             required: ["chainName"]