nyxora 1.1.8 → 1.2.0

package/dist/agent/reasoning.js

@@ -14,6 +14,9 @@ const getBalance_1 = require("../web3/skills/getBalance");
 const transfer_1 = require("../web3/skills/transfer");
 const getPrice_1 = require("../web3/skills/getPrice");
 const swapToken_1 = require("../web3/skills/swapToken");
+const bridgeToken_1 = require("../web3/skills/bridgeToken");
+const mintNft_1 = require("../web3/skills/mintNft");
+const customTx_1 = require("../web3/skills/customTx");
 const paths_1 = require("../config/paths");
 exports.logger = new logger_1.Logger();
 let currentKeyIndex = 0;
@@ -140,7 +143,15 @@ async function processUserInput(input, role = 'user') {
             model: config.llm.model,
             temperature: config.llm.temperature,
             messages: messages,
-            tools: [getBalance_1.getBalanceToolDefinition, transfer_1.transferToolDefinition, getPrice_1.getPriceToolDefinition, swapToken_1.swapTokenToolDefinition],
+            tools: [
+                getBalance_1.getBalanceToolDefinition,
+                transfer_1.transferToolDefinition,
+                getPrice_1.getPriceToolDefinition,
+                swapToken_1.swapTokenToolDefinition,
+                bridgeToken_1.bridgeTokenToolDefinition,
+                mintNft_1.mintNftToolDefinition,
+                customTx_1.customTxToolDefinition
+            ],
             tool_choice: "auto",
         });
         const responseMessage = response.choices[0].message;
@@ -162,7 +173,7 @@ async function processUserInput(input, role = 'user') {
                 const toolCall = _toolCall;
                 if (toolCall.function.name === 'get_balance') {
                     const args = JSON.parse(toolCall.function.arguments);
-                    const balanceResult = await (0, getBalance_1.getBalance)(args.chainName, args.address);
+                    const balanceResult = await (0, getBalance_1.getBalance)(args.chainName, args.address, args.token);
                     exports.logger.addEntry({
                         role: 'tool',
                         tool_call_id: toolCall.id,
@@ -170,9 +181,9 @@ async function processUserInput(input, role = 'user') {
                         content: balanceResult,
                     });
                 }
-                else if (toolCall.function.name === 'transfer_native') {
+                else if (toolCall.function.name === 'transfer_token' || toolCall.function.name === 'transfer_native') {
                     const args = JSON.parse(toolCall.function.arguments);
-                    const transferResult = await (0, transfer_1.transferNative)(args.chainName, args.toAddress, args.amountEth);
+                    const transferResult = await (0, transfer_1.prepareTransfer)(args.chainName, args.toAddress, args.amountStr || args.amountEth, args.token);
                     exports.logger.addEntry({
                         role: 'tool',
                         tool_call_id: toolCall.id,
@@ -192,7 +203,7 @@ async function processUserInput(input, role = 'user') {
                 }
                 else if (toolCall.function.name === 'swap_token') {
                     const args = JSON.parse(toolCall.function.arguments);
-                    const swapResult = await (0, swapToken_1.swapToken)(args.chainName, args.fromToken, args.toToken, args.amount);
+                    const swapResult = await (0, swapToken_1.prepareSwapToken)(args.chainName, args.fromToken, args.toToken, args.amountStr || args.amount, args.mode, args.providerName);
                     exports.logger.addEntry({
                         role: 'tool',
                         tool_call_id: toolCall.id,
@@ -200,6 +211,36 @@ async function processUserInput(input, role = 'user') {
                         content: swapResult,
                     });
                 }
+                else if (toolCall.function.name === 'bridge_token') {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    const bridgeResult = await (0, bridgeToken_1.prepareBridgeToken)(args.fromChainName, args.toChainName, args.fromToken, args.toToken, args.amountStr, args.mode, args.providerName);
+                    exports.logger.addEntry({
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        name: toolCall.function.name,
+                        content: bridgeResult,
+                    });
+                }
+                else if (toolCall.function.name === 'mint_nft') {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    const mintResult = await (0, mintNft_1.prepareMintNft)(args.chainName, args.contractAddress, args.functionSignature, args.argsStr, args.valueEth);
+                    exports.logger.addEntry({
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        name: toolCall.function.name,
+                        content: mintResult,
+                    });
+                }
+                else if (toolCall.function.name === 'custom_tx') {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    const customResult = await (0, customTx_1.prepareCustomTx)(args.chainName, args.toAddress, args.dataHex, args.valueEth, args.gasLimitStr);
+                    exports.logger.addEntry({
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        name: toolCall.function.name,
+                        content: customResult,
+                    });
+                }
             }
             // Second call to get the final answer after tool execution
             const secondMessages = [

package/dist/gateway/server.js

@@ -15,9 +15,10 @@ const transactionManager_1 = require("../agent/transactionManager");
 const transfer_1 = require("../web3/skills/transfer");
 const swapToken_1 = require("../web3/skills/swapToken");
 const getBalance_1 = require("../web3/skills/getBalance");
-const transfer_2 = require("../web3/skills/transfer");
 const getPrice_1 = require("../web3/skills/getPrice");
-const swapToken_2 = require("../web3/skills/swapToken");
+const bridgeToken_1 = require("../web3/skills/bridgeToken");
+const mintNft_1 = require("../web3/skills/mintNft");
+const customTx_1 = require("../web3/skills/customTx");
 const telegram_1 = require("./telegram");
 const formatter_1 = require("../utils/formatter");
 // Intercept console.log and console.error
@@ -94,9 +95,12 @@ app.get('/api/logs', (req, res) => {
 app.get('/api/skills', (req, res) => {
     res.json([
         getBalance_1.getBalanceToolDefinition,
-        transfer_2.transferToolDefinition,
+        transfer_1.transferToolDefinition,
         getPrice_1.getPriceToolDefinition,
-        swapToken_2.swapTokenToolDefinition
+        swapToken_1.swapTokenToolDefinition,
+        bridgeToken_1.bridgeTokenToolDefinition,
+        mintNft_1.mintNftToolDefinition,
+        customTx_1.customTxToolDefinition
     ]);
 });
 app.get('/api/transactions', (req, res) => {
@@ -110,10 +114,19 @@ app.post('/api/transactions/:id/approve', async (req, res) => {
     try {
         let result = '';
         if (tx.type === 'transfer') {
-            result = await (0, transfer_1.executeTransfer)(tx.chainName, tx.details.toAddress, tx.details.amountEth);
+            result = await (0, transfer_1.executeTransfer)(tx.chainName, tx.details);
         }
         else if (tx.type === 'swap') {
-            result = await (0, swapToken_1.executeSwap)(tx.chainName, tx.details.fromToken, tx.details.toToken, tx.details.amount);
+            result = await (0, swapToken_1.executeSwap)(tx.chainName, tx.details);
+        }
+        else if (tx.type === 'bridge') {
+            result = await (0, bridgeToken_1.executeBridge)(tx.chainName, tx.details);
+        }
+        else if (tx.type === 'mint') {
+            result = await (0, mintNft_1.executeMintNft)(tx.chainName, tx.details);
+        }
+        else if (tx.type === 'custom') {
+            result = await (0, customTx_1.executeCustomTx)(tx.chainName, tx.details);
         }
         transactionManager_1.txManager.updateStatus(id, 'executed', result);
         // Add programmatic beautiful message directly to chat

package/dist/gateway/telegram.js

@@ -10,6 +10,9 @@ const parser_1 = require("../config/parser");
 const transactionManager_1 = require("../agent/transactionManager");
 const transfer_1 = require("../web3/skills/transfer");
 const swapToken_1 = require("../web3/skills/swapToken");
+const bridgeToken_1 = require("../web3/skills/bridgeToken");
+const mintNft_1 = require("../web3/skills/mintNft");
+const customTx_1 = require("../web3/skills/customTx");
 const formatter_1 = require("../utils/formatter");
 function startTelegramBot() {
     const config = (0, parser_1.loadConfig)();
@@ -73,10 +76,19 @@ function startTelegramBot() {
                 try {
                     let result = '';
                     if (tx.type === 'transfer') {
-                        result = await (0, transfer_1.executeTransfer)(tx.chainName, tx.details.toAddress, tx.details.amountEth);
+                        result = await (0, transfer_1.executeTransfer)(tx.chainName, tx.details);
                     }
                     else if (tx.type === 'swap') {
-                        result = await (0, swapToken_1.executeSwap)(tx.chainName, tx.details.fromToken, tx.details.toToken, tx.details.amount);
+                        result = await (0, swapToken_1.executeSwap)(tx.chainName, tx.details);
+                    }
+                    else if (tx.type === 'bridge') {
+                        result = await (0, bridgeToken_1.executeBridge)(tx.chainName, tx.details);
+                    }
+                    else if (tx.type === 'mint') {
+                        result = await (0, mintNft_1.executeMintNft)(tx.chainName, tx.details);
+                    }
+                    else if (tx.type === 'custom') {
+                        result = await (0, customTx_1.executeCustomTx)(tx.chainName, tx.details);
                     }
                     transactionManager_1.txManager.updateStatus(txId, 'executed', result);
                     const prettyMsg = (0, formatter_1.formatTransactionSuccess)(tx, result);

package/dist/web3/skills/bridgeToken.js

@@ -0,0 +1,199 @@
+"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 body = {
+        user: userAddress,
+        originChainId: fromChainId,
+        destinationChainId: toChainId,
+        originCurrency: fromToken,
+        destinationCurrency: toToken,
+        amount: amountWei,
+        tradeType: "EXACT_INPUT"
+    };
+    const res = await fetch("https://api.relay.link/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 = "";
+        const actualProvider = mode === "auto" ? "lifi" : providerName;
+        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/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"]

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,200 @@
 "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 body = {
+        user: userAddress,
+        originChainId: fromChainId,
+        destinationChainId: toChainId,
+        originCurrency: fromToken,
+        destinationCurrency: toToken,
+        amount: amountWei,
+        tradeType: "EXACT_INPUT"
+    };
+    const res = await fetch("https://api.relay.link/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 = "";
+        const actualProvider = mode === "auto" ? "lifi" : providerName;
+        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"]
         }
     }
 };

package/dist/web3/utils/tokens.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_MAP = exports.ERC20_ABI = void 0;
+exports.resolveToken = resolveToken;
+exports.ERC20_ABI = [
+    {
+        type: 'function',
+        name: 'balanceOf',
+        inputs: [{ name: 'account', type: 'address' }],
+        outputs: [{ type: 'uint256' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'transfer',
+        inputs: [
+            { name: 'to', type: 'address' },
+            { name: 'value', type: 'uint256' }
+        ],
+        outputs: [{ type: 'bool' }],
+        stateMutability: 'nonpayable',
+    },
+    {
+        type: 'function',
+        name: 'approve',
+        inputs: [
+            { name: 'spender', type: 'address' },
+            { name: 'value', type: 'uint256' }
+        ],
+        outputs: [{ type: 'bool' }],
+        stateMutability: 'nonpayable',
+    },
+    {
+        type: 'function',
+        name: 'allowance',
+        inputs: [
+            { name: 'owner', type: 'address' },
+            { name: 'spender', type: 'address' }
+        ],
+        outputs: [{ type: 'uint256' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'decimals',
+        inputs: [],
+        outputs: [{ type: 'uint8' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'symbol',
+        inputs: [],
+        outputs: [{ type: 'string' }],
+        stateMutability: 'view',
+    }
+];
+exports.TOKEN_MAP = {
+    ethereum: {
+        ETH: "0x0000000000000000000000000000000000000000",
+        WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        USDC: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        USDT: "0xdAC17F958D2ee523a2206206994597C13D831ec7"
+    },
+    arbitrum: {
+        ETH: "0x0000000000000000000000000000000000000000",
+        WETH: "0x82aF49447D8a07e3bd95BD0d56f352415231Cl11",
+        USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+        "USDC.E": "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
+        USDT: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"
+    },
+    base: {
+        ETH: "0x0000000000000000000000000000000000000000",
+        WETH: "0x4200000000000000000000000000000000000006",
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        USDT: "0xf55BEC9cbd4732f1F4143f647652e924540d9d64"
+    },
+    optimism: {
+        ETH: "0x0000000000000000000000000000000000000000",
+        WETH: "0x4200000000000000000000000000000000000006",
+        USDC: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+        USDT: "0x94b008aA00579c1307b0EF2c499aD98a8ce58e58"
+    },
+    bsc: {
+        BNB: "0x0000000000000000000000000000000000000000",
+        WBNB: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+        USDC: "0x8AC76a51cc950d9822D68b83fE1Ad97B32CD580d",
+        USDT: "0x55d398326f99059fF775485246999027B3197955"
+    },
+    sepolia: {
+        ETH: "0x0000000000000000000000000000000000000000",
+        WETH: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
+        USDC: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238" // Circle Faucet Sepolia USDC
+    }
+};
+function resolveToken(tokenSymbolOrAddress, chainName) {
+    if (tokenSymbolOrAddress.startsWith("0x") && tokenSymbolOrAddress.length === 42) {
+        return tokenSymbolOrAddress;
+    }
+    const symbolUpper = tokenSymbolOrAddress.toUpperCase().trim();
+    if (["ETH", "MATIC", "POL", "BNB", "AVAX", "NATIVE"].includes(symbolUpper)) {
+        return "0x0000000000000000000000000000000000000000";
+    }
+    const chainTokens = exports.TOKEN_MAP[chainName];
+    if (chainTokens && chainTokens[symbolUpper]) {
+        return chainTokens[symbolUpper];
+    }
+    throw new Error(`Token "${tokenSymbolOrAddress}" pada chain ${chainName} tidak ditemukan. Silakan gunakan alamat kontrak langsung (0x...).`);
+}

package/package.json

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