rook-wallet-mcp 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * ROOK MCP Server
+ *
+ * AI Agent'ların ROOK Wallet'ı kullanması için MCP (Model Context Protocol) server.
+ * Bu server LOKAL olarak kullanıcının bilgisayarında çalışır.
+ *
+ * Kurulum:
+ * 1. npm install -g @rook/mcp-server
+ * 2. .env dosyası oluştur (ROOK_PRIVATE_KEY, ROOK_DAILY_LIMIT, vs.)
+ * 3. Claude Desktop config'e ekle
+ *
+ * %100 Non-Custodial - Tüm işlemler kullanıcının bilgisayarında gerçekleşir.
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,500 @@
+#!/usr/bin/env node
+/**
+ * ROOK MCP Server
+ *
+ * AI Agent'ların ROOK Wallet'ı kullanması için MCP (Model Context Protocol) server.
+ * Bu server LOKAL olarak kullanıcının bilgisayarında çalışır.
+ *
+ * Kurulum:
+ * 1. npm install -g @rook/mcp-server
+ * 2. .env dosyası oluştur (ROOK_PRIVATE_KEY, ROOK_DAILY_LIMIT, vs.)
+ * 3. Claude Desktop config'e ekle
+ *
+ * %100 Non-Custodial - Tüm işlemler kullanıcının bilgisayarında gerçekleşir.
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { ethers } from "ethers";
+function loadConfig() {
+    const privateKey = process.env.ROOK_PRIVATE_KEY;
+    if (!privateKey) {
+        throw new Error("ROOK_PRIVATE_KEY environment variable is required");
+    }
+    return {
+        privateKey,
+        dailyLimitMON: parseFloat(process.env.ROOK_DAILY_LIMIT || "10"),
+        perTxLimitMON: parseFloat(process.env.ROOK_PER_TX_LIMIT || "1"),
+        contractWhitelist: process.env.ROOK_WHITELIST?.split(",").filter(Boolean) || [],
+        rpcUrl: process.env.ROOK_RPC_URL || "https://testnet-rpc.monad.xyz",
+        chainId: parseInt(process.env.ROOK_CHAIN_ID || "10143"),
+        explorerUrl: process.env.ROOK_EXPLORER_URL || "https://monad-testnet.socialscan.io",
+    };
+}
+class SpendingTracker {
+    history = [];
+    getTodayDate() {
+        return new Date().toISOString().split("T")[0];
+    }
+    getSpentToday() {
+        const today = this.getTodayDate();
+        return this.history
+            .filter((r) => r.date === today)
+            .reduce((sum, r) => sum + r.amount, 0);
+    }
+    record(amount, txHash, to) {
+        this.history.push({
+            date: this.getTodayDate(),
+            amount,
+            txHash,
+            to,
+            timestamp: Date.now(),
+        });
+    }
+    getHistory() {
+        return [...this.history];
+    }
+}
+// ============================================================
+// ROOK WALLET SERVICE
+// ============================================================
+class RookWalletService {
+    config;
+    wallet;
+    provider;
+    tracker;
+    constructor(config) {
+        this.config = config;
+        this.tracker = new SpendingTracker();
+        this.provider = new ethers.JsonRpcProvider(config.rpcUrl, {
+            chainId: config.chainId,
+            name: "Monad Testnet",
+        });
+        this.wallet = new ethers.Wallet(config.privateKey, this.provider);
+    }
+    get address() {
+        return this.wallet.address;
+    }
+    async getBalance() {
+        const balance = await this.provider.getBalance(this.wallet.address);
+        return ethers.formatEther(balance);
+    }
+    getRemainingDailyLimit() {
+        const spent = this.tracker.getSpentToday();
+        return Math.max(0, this.config.dailyLimitMON - spent);
+    }
+    getSpentToday() {
+        return this.tracker.getSpentToday();
+    }
+    validateTransaction(to, amountMON) {
+        // Check per-tx limit
+        if (amountMON > this.config.perTxLimitMON) {
+            return {
+                valid: false,
+                reason: `Amount ${amountMON} MON exceeds per-transaction limit of ${this.config.perTxLimitMON} MON`,
+            };
+        }
+        // Check daily limit
+        const remaining = this.getRemainingDailyLimit();
+        if (amountMON > remaining) {
+            return {
+                valid: false,
+                reason: `Would exceed daily limit. Remaining today: ${remaining.toFixed(4)} MON`,
+            };
+        }
+        // Check whitelist
+        if (this.config.contractWhitelist.length > 0) {
+            const isWhitelisted = this.config.contractWhitelist.some((addr) => addr.toLowerCase() === to.toLowerCase());
+            if (!isWhitelisted) {
+                return {
+                    valid: false,
+                    reason: "Recipient address is not in the allowed addresses list",
+                };
+            }
+        }
+        return { valid: true };
+    }
+    async send(to, amountMON) {
+        const amount = parseFloat(amountMON);
+        // Validate
+        const validation = this.validateTransaction(to, amount);
+        if (!validation.valid) {
+            return { success: false, error: validation.reason };
+        }
+        // Validate address
+        if (!ethers.isAddress(to)) {
+            return { success: false, error: "Invalid recipient address" };
+        }
+        try {
+            const tx = await this.wallet.sendTransaction({
+                to,
+                value: ethers.parseEther(amountMON),
+            });
+            await tx.wait();
+            // Record spending
+            this.tracker.record(amount, tx.hash, to);
+            return { success: true, txHash: tx.hash };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Transaction failed";
+            return { success: false, error: message };
+        }
+    }
+    getStatus() {
+        return {
+            address: this.wallet.address,
+            dailyLimit: this.config.dailyLimitMON,
+            perTxLimit: this.config.perTxLimitMON,
+            spentToday: this.getSpentToday(),
+            remainingToday: this.getRemainingDailyLimit(),
+            whitelistEnabled: this.config.contractWhitelist.length > 0,
+            whitelistCount: this.config.contractWhitelist.length,
+            network: "Monad Testnet",
+            chainId: this.config.chainId,
+            explorerUrl: this.config.explorerUrl,
+        };
+    }
+    getTransactionHistory() {
+        return this.tracker.getHistory();
+    }
+    getExplorerUrl(txHash) {
+        return `${this.config.explorerUrl}/tx/${txHash}`;
+    }
+}
+// ============================================================
+// MCP SERVER
+// ============================================================
+async function main() {
+    // Load configuration
+    const config = loadConfig();
+    const walletService = new RookWalletService(config);
+    console.error(`🏰 ROOK MCP Server starting...`);
+    console.error(`   Address: ${walletService.address}`);
+    console.error(`   Daily Limit: ${config.dailyLimitMON} MON`);
+    console.error(`   Per-TX Limit: ${config.perTxLimitMON} MON`);
+    console.error(`   Network: Monad Testnet (Chain ID: ${config.chainId})`);
+    // Create MCP server
+    const server = new Server({
+        name: "rook-wallet",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+            resources: {},
+            prompts: {},
+        },
+    });
+    // ============================================================
+    // TOOLS
+    // ============================================================
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                {
+                    name: "send_mon",
+                    description: `Send MON cryptocurrency to an address. This wallet has spending limits:
+- Daily limit: ${config.dailyLimitMON} MON
+- Per-transaction limit: ${config.perTxLimitMON} MON
+${config.contractWhitelist.length > 0 ? `- Can only send to whitelisted addresses` : "- Can send to any address"}
+
+Use this when you need to make a payment or transfer MON.`,
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            to: {
+                                type: "string",
+                                description: "The recipient wallet address (must start with 0x)",
+                            },
+                            amount: {
+                                type: "string",
+                                description: "Amount of MON to send (e.g., '0.5' or '1.0')",
+                            },
+                        },
+                        required: ["to", "amount"],
+                    },
+                },
+                {
+                    name: "get_balance",
+                    description: "Get the current MON balance of this wallet.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
+                },
+                {
+                    name: "get_wallet_status",
+                    description: "Get detailed status of the wallet including spending limits, today's spending, and remaining allowance.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
+                },
+                {
+                    name: "check_spending_limit",
+                    description: "Check if a specific amount can be sent without exceeding limits.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            amount: {
+                                type: "string",
+                                description: "Amount of MON to check",
+                            },
+                            to: {
+                                type: "string",
+                                description: "Optional: recipient address to check against whitelist",
+                            },
+                        },
+                        required: ["amount"],
+                    },
+                },
+                {
+                    name: "get_transaction_history",
+                    description: "Get the history of all transactions sent from this wallet during the current session. Shows amounts, recipients, timestamps, and explorer links.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
+                },
+            ],
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        switch (name) {
+            case "send_mon": {
+                const to = String(args?.to || "");
+                const amount = String(args?.amount || "0");
+                const result = await walletService.send(to, amount);
+                if (result.success) {
+                    const explorerUrl = walletService.getExplorerUrl(result.txHash);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Transaction successful!\n\nSent: ${amount} MON\nTo: ${to}\nTx Hash: ${result.txHash}\n\nView on explorer: ${explorerUrl}\n\nRemaining daily limit: ${walletService.getRemainingDailyLimit().toFixed(4)} MON`,
+                            },
+                        ],
+                    };
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `❌ Transaction failed: ${result.error}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            }
+            case "get_balance": {
+                const balance = await walletService.getBalance();
+                const status = walletService.getStatus();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `💰 Wallet Balance\n\nAddress: ${status.address}\nBalance: ${balance} MON\n\nDaily Limit: ${status.dailyLimit} MON\nSpent Today: ${status.spentToday.toFixed(4)} MON\nRemaining: ${status.remainingToday.toFixed(4)} MON`,
+                        },
+                    ],
+                };
+            }
+            case "get_wallet_status": {
+                const balance = await walletService.getBalance();
+                const status = walletService.getStatus();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `🏰 ROOK Wallet Status\n\n` +
+                                `Address: ${status.address}\n` +
+                                `Balance: ${balance} MON\n` +
+                                `Network: ${status.network} (Chain ID: ${status.chainId})\n\n` +
+                                `📊 Spending Limits:\n` +
+                                `- Daily Limit: ${status.dailyLimit} MON\n` +
+                                `- Per-TX Limit: ${status.perTxLimit} MON\n` +
+                                `- Spent Today: ${status.spentToday.toFixed(4)} MON\n` +
+                                `- Remaining Today: ${status.remainingToday.toFixed(4)} MON\n\n` +
+                                `🔒 Whitelist: ${status.whitelistEnabled ? `Enabled (${status.whitelistCount} addresses)` : "Disabled (can send to any address)"}\n\n` +
+                                `🔗 Explorer: ${status.explorerUrl}`,
+                        },
+                    ],
+                };
+            }
+            case "check_spending_limit": {
+                const amount = parseFloat(String(args?.amount || "0"));
+                const to = args?.to ? String(args.to) : "";
+                const validation = walletService.validateTransaction(to || "0x0000000000000000000000000000000000000000", amount);
+                if (validation.valid) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `✅ Amount ${amount} MON is within limits.\n\nRemaining daily limit after this: ${(walletService.getRemainingDailyLimit() - amount).toFixed(4)} MON`,
+                            },
+                        ],
+                    };
+                }
+                else {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `❌ Cannot send ${amount} MON: ${validation.reason}`,
+                            },
+                        ],
+                    };
+                }
+            }
+            case "get_transaction_history": {
+                const history = walletService.getTransactionHistory();
+                if (history.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "No transactions have been sent in this session yet.",
+                            },
+                        ],
+                    };
+                }
+                const lines = history.map((record, i) => {
+                    const explorerUrl = walletService.getExplorerUrl(record.txHash);
+                    const time = new Date(record.timestamp).toLocaleTimeString();
+                    return `${i + 1}. ${record.amount} MON -> ${record.to}\n   Time: ${time}\n   TX: ${record.txHash}\n   Explorer: ${explorerUrl}`;
+                });
+                const totalSpent = history.reduce((sum, r) => sum + r.amount, 0);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Transaction History (${history.length} transactions)\n\n${lines.join("\n\n")}\n\nTotal spent this session: ${totalSpent.toFixed(4)} MON\nRemaining daily limit: ${walletService.getRemainingDailyLimit().toFixed(4)} MON`,
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    });
+    // ============================================================
+    // RESOURCES
+    // ============================================================
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        return {
+            resources: [
+                {
+                    uri: "rook://wallet/info",
+                    name: "Wallet Information",
+                    description: "Current wallet address, balance, and spending limits",
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        const { uri } = request.params;
+        if (uri === "rook://wallet/info") {
+            const balance = await walletService.getBalance();
+            const status = walletService.getStatus();
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: "application/json",
+                        text: JSON.stringify({
+                            ...status,
+                            balance,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        throw new Error(`Unknown resource: ${uri}`);
+    });
+    // ============================================================
+    // PROMPTS
+    // ============================================================
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        return {
+            prompts: [
+                {
+                    name: "send-payment",
+                    description: "Guide through sending a MON payment with safety checks. Checks balance and limits before sending.",
+                    arguments: [
+                        {
+                            name: "to",
+                            description: "Recipient wallet address (0x...)",
+                            required: true,
+                        },
+                        {
+                            name: "amount",
+                            description: "Amount of MON to send",
+                            required: true,
+                        },
+                    ],
+                },
+                {
+                    name: "wallet-overview",
+                    description: "Get a comprehensive overview of wallet status, spending limits, and transaction history.",
+                },
+            ],
+        };
+    });
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        switch (name) {
+            case "send-payment": {
+                const to = args?.to || "<recipient_address>";
+                const amount = args?.amount || "<amount>";
+                return {
+                    description: `Send ${amount} MON to ${to} with safety checks`,
+                    messages: [
+                        {
+                            role: "user",
+                            content: {
+                                type: "text",
+                                text: `I want to send ${amount} MON to ${to}. Please follow these steps:
+
+1. First, use get_wallet_status to check the current wallet balance and spending limits.
+2. Then, use check_spending_limit with amount "${amount}" and to "${to}" to verify the transaction is within limits.
+3. If the check passes, use send_mon to send ${amount} MON to ${to}.
+4. After sending, use get_balance to confirm the updated balance.
+5. Provide a summary of the transaction.`,
+                            },
+                        },
+                    ],
+                };
+            }
+            case "wallet-overview": {
+                return {
+                    description: "Comprehensive wallet overview",
+                    messages: [
+                        {
+                            role: "user",
+                            content: {
+                                type: "text",
+                                text: `Please give me a comprehensive overview of my ROOK wallet:
+
+1. Use get_wallet_status to get the current status, balance, and spending limits.
+2. Use get_transaction_history to see all transactions from this session.
+3. Summarize everything clearly: balance, daily spending progress, remaining limits, and recent activity.`,
+                            },
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown prompt: ${name}`);
+        }
+    });
+    // Start server
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("🏰 ROOK MCP Server running");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "rook-wallet-mcp",
+  "version": "0.1.0",
+  "description": "ROOK Wallet MCP Server - AI Agent Wallet with Spending Limits on Monad",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "rook-wallet-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "ethers": "^6.13.4",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.6.0"
+  },
+  "keywords": ["mcp", "wallet", "ai-agent", "monad", "crypto"],
+  "license": "MIT"
+}