nyxora 1.1.8 → 1.3.0

package/README.md

@@ -18,11 +18,15 @@ With a beautiful, real-time dashboard inspired by modern control centers, Nyxora
 *   **Omnichannel Approvals**: Approve or reject pending transactions directly from the Web Dashboard's UI or via Telegram Inline Keyboard buttons on the go!
 *   **Strict API Auth**: The local Express server is protected via ephemeral Session Tokens (`x-nyxora-token`) and Strict CORS, preventing unauthorized local API requests.
 
-### ⛓️ Web3 DeFi Skills
+### ⛓️ Web3 DeFi Skills (Pro-Trader AI)
 *   **Multi-Chain Support**: Operate across Ethereum, Base, BSC, Arbitrum, Optimism, and Sepolia Testnet.
+*   **Wallet Generation**: Instruct the AI to generate new EVM wallets on the fly securely (Keys are never saved).
 *   **Native Wallet Operations**: Autonomously check balances and transfer native tokens using securely injected wallets.
-*   **Market Intelligence**: Fetch live crypto prices and 24h market movements via CoinGecko integration.
-*   **DeFi Token Swapping**: The agent can autonomously simulate liquidity routes and execute token swaps with gas fee estimations.
+*   **Advanced Market Intelligence**: Fetch live crypto prices, 24h market movements, FDV, and liquidity via CoinGecko and DexScreener integrations.
+*   **Anti-Rugpull & Security Scanner**: Nyxora can scan smart contracts via GoPlus Labs to detect Honeypots, Hidden Taxes, and malicious proxy upgrades before you buy.
+*   **PNL & Portfolio Tracking**: The AI scans your wallets and multiplies balances by live DEX prices to give you real-time Net Worth estimations.
+*   **DeFi Token Swapping & Bridging**: The agent can autonomously simulate liquidity routes and execute token swaps or cross-chain bridges with gas fee estimations.
+*   **Automated Limit Orders (Take-Profit/Cut-Loss)**: Set rules (e.g., "Sell my PEPE if price drops below $0.001"). Nyxora runs a background cron monitor and automatically executes the swap while you sleep without requiring manual approval!
 
 ### 💻 The Interface (Live Canvas)
 *   **Premium Glassmorphism UI**: A gorgeous, resizable split-pane interface.

package/SECURITY.md

@@ -14,7 +14,9 @@ Instead, please send an email to the repository owner or reach out privately. We
 When using Nyxora, you are configuring an autonomous agent that has direct access to your injected Web3 Wallet's private key.
 
 1. **Protect Your Keystore**: Your private key is encrypted and stored in `~/.nyxora/keystore.json`. While it is encrypted using `AES-256-GCM`, you must still treat it and your **Master Password** as highly sensitive. NEVER share your `keystore.json` or your Master Password with anyone.
-2. **Human-in-the-Loop Verification**: The agent is restricted from making unilateral transactions. Always review the exact details of the transaction when prompted to "Approve" or "Reject" on the Web Dashboard or Telegram Inline Keyboard before confirming.
-3. **Use Testnets**: While getting started or testing new skills, ALWAYS use a testnet (e.g., Sepolia) and a wallet containing only testnet funds.
-4. **Do Not Share Your `memory.json`**: The agent's memory may contain sensitive conversational data or addresses you've interacted with. Be cautious before sharing the `memory.json` export.
-5. **API Keys**: Treat your OpenAI, Gemini, and other LLM provider API keys as highly confidential. Rotate them immediately if you suspect a compromise.
+2. **Human-in-the-Loop Verification**: For standard actions, the agent is restricted from making unilateral transactions. Always review the exact details of the transaction when prompted to "Approve" or "Reject" on the Web Dashboard or Telegram Inline Keyboard before confirming.
+3. **Limit Order Automation Risk**: If you use the AI to create a **Limit Order** (Take-profit or Cut-loss), the system WILL execute the transaction automatically in the background when the price condition is met. This intentionally bypasses the Human-in-the-Loop verification for speed. Use this feature with caution.
+4. **Wallet Generation**: When you ask the AI to create a new wallet, it generates the Private Key and Seed Phrase locally and displays it once. It does NOT save it anywhere. You are responsible for immediately backing up this information.
+5. **Use Testnets**: While getting started or testing new skills, ALWAYS use a testnet (e.g., Sepolia) and a wallet containing only testnet funds.
+6. **Do Not Share Your `memory.json`**: The agent's memory may contain sensitive conversational data, generated seed phrases, or addresses you've interacted with. Be cautious before sharing the `memory.json` export.
+7. **API Keys**: Treat your OpenAI, Gemini, and other LLM provider API keys as highly confidential. Rotate them immediately if you suspect a compromise.

package/dist/agent/limitOrderManager.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancelLimitOrderToolDefinition = exports.listLimitOrdersToolDefinition = exports.createLimitOrderToolDefinition = exports.limitOrderManager = exports.LimitOrderManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const parser_1 = require("../config/parser");
+const paths_1 = require("../config/paths");
+const tokens_1 = require("../web3/utils/tokens");
+const swapToken_1 = require("../web3/skills/swapToken");
+const transactionManager_1 = require("./transactionManager");
+const reasoning_1 = require("./reasoning");
+class LimitOrderManager {
+    filePath;
+    orders = [];
+    monitorInterval = null;
+    constructor() {
+        const config = (0, parser_1.loadConfig)();
+        this.filePath = (0, paths_1.getPath)(config.memory?.path ? config.memory.path.replace('memory.json', 'orders.json') : 'orders.json');
+        this.loadOrders();
+    }
+    loadOrders() {
+        if (fs_1.default.existsSync(this.filePath)) {
+            try {
+                const data = fs_1.default.readFileSync(this.filePath, 'utf-8');
+                this.orders = JSON.parse(data);
+            }
+            catch (error) {
+                this.orders = [];
+            }
+        }
+    }
+    saveOrders() {
+        try {
+            fs_1.default.writeFileSync(this.filePath, JSON.stringify(this.orders, null, 2));
+        }
+        catch (error) { }
+    }
+    createOrder(chainName, fromToken, toToken, amountStr, targetPriceUsd, condition) {
+        const id = `order_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`;
+        const order = {
+            id, chainName, fromToken, toToken, amountStr, targetPriceUsd, condition, status: 'pending', createdAt: Date.now()
+        };
+        this.orders.push(order);
+        this.saveOrders();
+        return `Limit order created successfully. ID: ${id}. The system will monitor ${fromToken} price on ${chainName} and execute the swap to ${toToken} when price is ${condition} $${targetPriceUsd}.`;
+    }
+    listOrders() {
+        const pending = this.orders.filter(o => o.status === 'pending');
+        if (pending.length === 0)
+            return "No active limit orders.";
+        let report = "Active Limit Orders:\n";
+        pending.forEach(o => {
+            report += `- [${o.id}] Swap ${o.amountStr} ${o.fromToken} -> ${o.toToken} on ${o.chainName} when ${o.fromToken} is ${o.condition} $${o.targetPriceUsd}\n`;
+        });
+        return report;
+    }
+    cancelOrder(id) {
+        const order = this.orders.find(o => o.id === id);
+        if (!order)
+            return `Order ${id} not found.`;
+        if (order.status !== 'pending')
+            return `Order ${id} cannot be cancelled because it is ${order.status}.`;
+        order.status = 'cancelled';
+        this.saveOrders();
+        return `Order ${id} cancelled successfully.`;
+    }
+    startMonitor() {
+        if (this.monitorInterval)
+            clearInterval(this.monitorInterval);
+        // Monitor every 60 seconds
+        this.monitorInterval = setInterval(() => this.checkOrders(), 60000);
+        console.log('[LimitOrderManager] Order monitoring started (interval: 60s)');
+    }
+    async checkOrders() {
+        const pending = this.orders.filter(o => o.status === 'pending');
+        if (pending.length === 0)
+            return;
+        for (const order of pending) {
+            try {
+                let tokenAddress = (0, tokens_1.resolveToken)(order.fromToken, order.chainName);
+                if (tokenAddress === "0x0000000000000000000000000000000000000000") {
+                    tokenAddress = (0, tokens_1.resolveToken)("W" + order.fromToken, order.chainName);
+                }
+                const res = await fetch(`https://api.dexscreener.com/latest/dex/tokens/${tokenAddress}`);
+                if (!res.ok)
+                    continue;
+                const data = await res.json();
+                if (!data.pairs || data.pairs.length === 0)
+                    continue;
+                let pair = data.pairs.find((p) => p.chainId === order.chainName) || data.pairs[0];
+                const currentPrice = parseFloat(pair.priceUsd);
+                let shouldExecute = false;
+                if (order.condition === 'above' && currentPrice >= order.targetPriceUsd)
+                    shouldExecute = true;
+                if (order.condition === 'below' && currentPrice <= order.targetPriceUsd)
+                    shouldExecute = true;
+                if (shouldExecute) {
+                    console.log(`[LimitOrderManager] Condition met for order ${order.id}. Current price $${currentPrice} is ${order.condition} $${order.targetPriceUsd}. Executing...`);
+                    // 1. Prepare Swap
+                    const prepareResult = await (0, swapToken_1.prepareSwapToken)(order.chainName, order.fromToken, order.toToken, order.amountStr, 'auto');
+                    // 2. Extract Tx ID
+                    const txMatch = prepareResult.match(/Transaction ID: ([\w-]+)\./);
+                    if (!txMatch) {
+                        order.status = 'failed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} execution failed during preparation. Output: ${prepareResult}`, 'system').catch(() => { });
+                        continue;
+                    }
+                    const txId = txMatch[1];
+                    const tx = transactionManager_1.txManager.getTransaction(txId);
+                    if (!tx)
+                        throw new Error("Transaction not found in manager");
+                    // 3. Execute Swap automatically
+                    const executeResult = await (0, swapToken_1.executeSwap)(order.chainName, tx.details);
+                    if (executeResult.includes('successful')) {
+                        transactionManager_1.txManager.updateStatus(txId, 'executed', executeResult);
+                        order.status = 'executed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} just EXECUTED automatically! Price hit $${currentPrice}. Swap result: ${executeResult}. Please notify the user immediately!`, 'system').catch(() => { });
+                    }
+                    else {
+                        transactionManager_1.txManager.updateStatus(txId, 'failed', executeResult);
+                        order.status = 'failed';
+                        this.saveOrders();
+                        (0, reasoning_1.processUserInput)(`Limit order ${order.id} FAILED to execute. Price hit $${currentPrice} but execution failed: ${executeResult}. Please notify the user.`, 'system').catch(() => { });
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`[LimitOrderManager] Error checking order ${order.id}:`, error.message);
+            }
+        }
+    }
+}
+exports.LimitOrderManager = LimitOrderManager;
+exports.limitOrderManager = new LimitOrderManager();
+exports.createLimitOrderToolDefinition = {
+    type: "function",
+    function: {
+        name: "create_limit_order",
+        description: "Creates an automatic cut-loss or take-profit limit order. The system will automatically execute the swap when the price condition is met.",
+        parameters: {
+            type: "object",
+            properties: {
+                chainName: { type: "string", enum: ["ethereum", "base", "bsc", "arbitrum", "optimism", "sepolia"] },
+                fromToken: { type: "string", description: "Token to sell" },
+                toToken: { type: "string", description: "Token to buy" },
+                amountStr: { type: "string", description: "Amount to sell" },
+                targetPriceUsd: { type: "number", description: "Target price in USD for the fromToken" },
+                condition: { type: "string", enum: ["above", "below"], description: "Trigger when price goes above (take-profit) or below (cut-loss) target" }
+            },
+            required: ["chainName", "fromToken", "toToken", "amountStr", "targetPriceUsd", "condition"],
+        },
+    },
+};
+exports.listLimitOrdersToolDefinition = {
+    type: "function",
+    function: {
+        name: "list_limit_orders",
+        description: "Lists all active automated limit orders.",
+        parameters: { type: "object", properties: {}, required: [] },
+    },
+};
+exports.cancelLimitOrderToolDefinition = {
+    type: "function",
+    function: {
+        name: "cancel_limit_order",
+        description: "Cancels an active limit order by ID.",
+        parameters: {
+            type: "object",
+            properties: { id: { type: "string" } },
+            required: ["id"],
+        },
+    },
+};

package/dist/agent/reasoning.js

@@ -14,6 +14,14 @@ 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 createWallet_1 = require("../web3/skills/createWallet");
+const checkSecurity_1 = require("../web3/skills/checkSecurity");
+const marketAnalysis_1 = require("../web3/skills/marketAnalysis");
+const checkPortfolio_1 = require("../web3/skills/checkPortfolio");
+const limitOrderManager_1 = require("./limitOrderManager");
 const paths_1 = require("../config/paths");
 exports.logger = new logger_1.Logger();
 let currentKeyIndex = 0;
@@ -140,7 +148,22 @@ 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,
+                createWallet_1.createWalletToolDefinition,
+                checkSecurity_1.checkSecurityToolDefinition,
+                marketAnalysis_1.marketAnalysisToolDefinition,
+                checkPortfolio_1.checkPortfolioToolDefinition,
+                limitOrderManager_1.createLimitOrderToolDefinition,
+                limitOrderManager_1.listLimitOrdersToolDefinition,
+                limitOrderManager_1.cancelLimitOrderToolDefinition
+            ],
             tool_choice: "auto",
         });
         const responseMessage = response.choices[0].message;
@@ -160,46 +183,76 @@ async function processUserInput(input, role = 'user') {
         if (responseMessage.tool_calls && responseMessage.tool_calls.length > 0) {
             for (const _toolCall of responseMessage.tool_calls) {
                 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);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: balanceResult,
-                    });
-                }
-                else if (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);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: transferResult,
-                    });
-                }
-                else if (toolCall.function.name === 'get_price') {
-                    const args = JSON.parse(toolCall.function.arguments);
-                    const priceResult = await (0, getPrice_1.getPrice)(args.coinId);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: priceResult,
-                    });
-                }
-                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);
-                    exports.logger.addEntry({
-                        role: 'tool',
-                        tool_call_id: toolCall.id,
-                        name: toolCall.function.name,
-                        content: swapResult,
-                    });
+                let result = "";
+                const args = JSON.parse(toolCall.function.arguments);
+                const toolName = toolCall.function.name;
+                switch (toolName) {
+                    case 'get_balance': {
+                        result = await (0, getBalance_1.getBalance)(args.chainName, args.address, args.token);
+                        break;
+                    }
+                    case 'transfer_token':
+                    case 'transfer_native': {
+                        result = await (0, transfer_1.prepareTransfer)(args.chainName, args.toAddress, args.amountStr || args.amountEth, args.token);
+                        break;
+                    }
+                    case 'get_price': {
+                        result = await (0, getPrice_1.getPrice)(args.coinId);
+                        break;
+                    }
+                    case 'swap_token': {
+                        result = await (0, swapToken_1.prepareSwapToken)(args.chainName, args.fromToken, args.toToken, args.amountStr || args.amount, args.mode, args.providerName);
+                        break;
+                    }
+                    case 'bridge_token': {
+                        result = await (0, bridgeToken_1.prepareBridgeToken)(args.fromChainName, args.toChainName, args.fromToken, args.toToken, args.amountStr, args.mode, args.providerName);
+                        break;
+                    }
+                    case 'mint_nft': {
+                        result = await (0, mintNft_1.prepareMintNft)(args.chainName, args.contractAddress, args.functionSignature, args.argsStr, args.valueEth);
+                        break;
+                    }
+                    case 'custom_tx': {
+                        result = await (0, customTx_1.prepareCustomTx)(args.chainName, args.toAddress, args.dataHex, args.valueEth, args.gasLimitStr);
+                        break;
+                    }
+                    case 'create_wallet': {
+                        result = await (0, createWallet_1.createWallet)();
+                        break;
+                    }
+                    case 'check_token_security': {
+                        result = await (0, checkSecurity_1.checkTokenSecurity)(args.chainName, args.contractAddress);
+                        break;
+                    }
+                    case 'analyze_market': {
+                        result = await (0, marketAnalysis_1.analyzeMarket)(args.chainName, args.tokenAddressOrSymbol);
+                        break;
+                    }
+                    case 'check_portfolio': {
+                        result = await (0, checkPortfolio_1.checkPortfolio)(args.chainName, args.address);
+                        break;
+                    }
+                    case 'create_limit_order': {
+                        result = limitOrderManager_1.limitOrderManager.createOrder(args.chainName, args.fromToken, args.toToken, args.amountStr, args.targetPriceUsd, args.condition);
+                        break;
+                    }
+                    case 'list_limit_orders': {
+                        result = limitOrderManager_1.limitOrderManager.listOrders();
+                        break;
+                    }
+                    case 'cancel_limit_order': {
+                        result = limitOrderManager_1.limitOrderManager.cancelOrder(args.id);
+                        break;
+                    }
+                    default:
+                        result = `Error: Tool ${toolName} is not implemented.`;
                 }
+                exports.logger.addEntry({
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    name: toolName,
+                    content: result,
+                });
             }
             // Second call to get the final answer after tool execution
             const secondMessages = [

package/dist/gateway/server.js

@@ -12,12 +12,14 @@ const reasoning_1 = require("../agent/reasoning");
 const parser_1 = require("../config/parser");
 const tracker_1 = require("./tracker");
 const transactionManager_1 = require("../agent/transactionManager");
+const limitOrderManager_1 = require("../agent/limitOrderManager");
 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 +96,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 +115,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
@@ -167,6 +181,7 @@ app.use((req, res, next) => {
     }
 });
 function startServer() {
+    limitOrderManager_1.limitOrderManager.startMonitor();
     const PORT = process.env.PORT || 3000;
     app.listen(PORT, () => {
         console.log(`🤖 Nyxora API Server running on port ${PORT}`);

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)();
@@ -25,6 +28,11 @@ function startTelegramBot() {
             const text = msg.text;
             if (!text)
                 return;
+            if (text === '/clear') {
+                reasoning_1.logger.clear();
+                bot.sendMessage(chatId, '✅ Memori AI telah dihapus. Mari kita mulai obrolan baru!');
+                return;
+            }
             // Log incoming message
             console.log(`[Telegram] Received from ${msg.from?.first_name}: ${text}`);
             // Send typing action to Telegram
@@ -73,10 +81,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);