@tongateway/mcp 0.1.0 → 0.3.0

package/README.md

@@ -0,0 +1,43 @@
+# @tongateway/mcp
+
+MCP server for [Agent Gateway](https://github.com/pewpewgogo/ton-agent-gateway) — lets AI agents request TON blockchain transfers via Model Context Protocol.
+
+## Install
+
+```bash
+npm install -g @tongateway/mcp
+```
+
+## Configure
+
+Add to your MCP client config (Claude Code, Cursor, etc.):
+
+```json
+{
+  "mcpServers": {
+    "tongateway": {
+      "command": "tongateway-mcp",
+      "env": {
+        "AGENT_GATEWAY_TOKEN": "YOUR_TOKEN_HERE",
+        "AGENT_GATEWAY_API_URL": "https://api.tongateway.ai"
+      }
+    }
+  }
+}
+```
+
+Get your token at [tongateway.ai/app.html](https://tongateway.ai/app.html).
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `request_transfer` | Request a TON transfer (to, amountNano, payloadBoc?) |
+| `get_request_status` | Check status of a request by ID |
+| `list_pending_requests` | List all pending requests |
+
+## Links
+
+- [Agent Gateway](https://github.com/pewpewgogo/ton-agent-gateway) — main repo with all links
+- [Dashboard](https://tongateway.ai) — connect wallet & manage tokens
+- [API Docs](https://api.tongateway.ai/docs) — Swagger UI

package/dist/index.js

@@ -3,17 +3,18 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 const API_URL = process.env.AGENT_GATEWAY_API_URL ?? 'https://api.tongateway.ai';
-const TOKEN = process.env.AGENT_GATEWAY_TOKEN;
-if (!TOKEN) {
-    console.error('AGENT_GATEWAY_TOKEN environment variable is required');
-    process.exit(1);
-}
+let TOKEN = process.env.AGENT_GATEWAY_TOKEN || '';
 async function apiCall(path, options = {}) {
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    if (TOKEN) {
+        headers['Authorization'] = `Bearer ${TOKEN}`;
+    }
     const res = await fetch(`${API_URL}${path}`, {
         ...options,
         headers: {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${TOKEN}`,
+            ...headers,
             ...options.headers,
         },
     });
@@ -27,11 +28,104 @@ const server = new McpServer({
     name: 'agent-gateway',
     version: '0.1.0',
 });
+server.tool('request_auth', 'Request wallet authentication. Generates a one-time link for the user to connect their TON wallet. After the user connects, use get_auth_token to retrieve the token. Use this when no token is configured.', {
+    label: z.string().optional().describe('Label for this agent session (e.g. "claude-agent")'),
+}, async ({ label }) => {
+    try {
+        const result = await fetch(`${API_URL}/v1/auth/request`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ label: label || 'agent' }),
+        });
+        const data = await result.json();
+        if (!result.ok)
+            throw new Error(data.error ?? 'Failed');
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: [
+                        `Authentication requested.`,
+                        ``,
+                        `Ask the user to open this link:`,
+                        data.authUrl,
+                        ``,
+                        `Auth ID: ${data.authId}`,
+                        `Expires: ${new Date(data.expiresAt).toISOString()}`,
+                        ``,
+                        `After the user connects their wallet, call get_auth_token with this authId to get the token.`,
+                    ].join('\n'),
+                },
+            ],
+        };
+    }
+    catch (e) {
+        return {
+            content: [{ type: 'text', text: `Error: ${e.message}` }],
+            isError: true,
+        };
+    }
+});
+server.tool('get_auth_token', 'Check if the user has completed wallet authentication and retrieve the token. Call this after request_auth once the user has opened the link and connected their wallet.', {
+    authId: z.string().describe('The authId returned by request_auth'),
+}, async ({ authId }) => {
+    try {
+        const result = await fetch(`${API_URL}/v1/auth/check/${authId}`, {
+            headers: { 'Content-Type': 'application/json' },
+        });
+        const data = await result.json();
+        if (!result.ok)
+            throw new Error(data.error ?? 'Failed');
+        if (data.status === 'pending') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: [
+                            `Authentication still pending.`,
+                            `The user has not connected their wallet yet.`,
+                            ``,
+                            `Wait a moment and try again.`,
+                        ].join('\n'),
+                    },
+                ],
+            };
+        }
+        // Store the token for future API calls
+        TOKEN = data.token;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: [
+                        `Authentication complete!`,
+                        `Token received and configured.`,
+                        `Wallet: ${data.address}`,
+                        ``,
+                        `You can now use request_transfer, get_request_status, and list_pending_requests.`,
+                    ].join('\n'),
+                },
+            ],
+        };
+    }
+    catch (e) {
+        return {
+            content: [{ type: 'text', text: `Error: ${e.message}` }],
+            isError: true,
+        };
+    }
+});
 server.tool('request_transfer', 'Request a TON transfer from the wallet owner. The request will be queued and the owner must approve it via TON Connect.', {
     to: z.string().describe('Destination TON address'),
     amountNano: z.string().describe('Amount in nanoTON (1 TON = 1000000000)'),
     payloadBoc: z.string().optional().describe('Optional BOC-encoded payload for the transaction'),
 }, async ({ to, amountNano, payloadBoc }) => {
+    if (!TOKEN) {
+        return {
+            content: [{ type: 'text', text: 'No token configured. Use request_auth first to authenticate.' }],
+            isError: true,
+        };
+    }
     try {
         const body = { to, amountNano };
         if (payloadBoc)
@@ -68,6 +162,12 @@ server.tool('request_transfer', 'Request a TON transfer from the wallet owner. T
 server.tool('get_request_status', 'Check the status of a previously submitted transfer request.', {
     id: z.string().describe('The request ID returned by request_transfer'),
 }, async ({ id }) => {
+    if (!TOKEN) {
+        return {
+            content: [{ type: 'text', text: 'No token configured. Use request_auth first to authenticate.' }],
+            isError: true,
+        };
+    }
     try {
         const result = await apiCall(`/v1/safe/tx/${id}`);
         return {
@@ -97,6 +197,12 @@ server.tool('get_request_status', 'Check the status of a previously submitted tr
     }
 });
 server.tool('list_pending_requests', 'List all pending transfer requests waiting for wallet owner approval.', {}, async () => {
+    if (!TOKEN) {
+        return {
+            content: [{ type: 'text', text: 'No token configured. Use request_auth first to authenticate.' }],
+            isError: true,
+        };
+    }
     try {
         const data = await apiCall('/v1/safe/tx/pending');
         const requests = data.requests;
@@ -122,5 +228,135 @@ server.tool('list_pending_requests', 'List all pending transfer requests waiting
         };
     }
 });
+server.tool('get_wallet_info', 'Get the connected wallet address, TON balance, and account status.', {}, async () => {
+    if (!TOKEN) {
+        return { content: [{ type: 'text', text: 'No token configured. Use request_auth first.' }], isError: true };
+    }
+    try {
+        const result = await apiCall('/v1/wallet/balance');
+        const balanceTon = (BigInt(result.balance) / 1000000000n).toString();
+        const balanceFrac = (BigInt(result.balance) % 1000000000n).toString().padStart(9, '0').replace(/0+$/, '') || '0';
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `Address: ${result.address}`,
+                        `Balance: ${balanceTon}.${balanceFrac} TON (${result.balance} nanoTON)`,
+                        `Status: ${result.status}`,
+                    ].join('\n'),
+                }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+    }
+});
+server.tool('get_jetton_balances', 'Get all jetton (token) balances in the connected wallet. Shows USDT, NOT, DOGS, and other tokens.', {}, async () => {
+    if (!TOKEN) {
+        return { content: [{ type: 'text', text: 'No token configured. Use request_auth first.' }], isError: true };
+    }
+    try {
+        const result = await apiCall('/v1/wallet/jettons');
+        if (!result.balances?.length) {
+            return { content: [{ type: 'text', text: 'No jettons found in this wallet.' }] };
+        }
+        const lines = result.balances.map((b) => {
+            const decimals = b.decimals ?? 9;
+            const raw = BigInt(b.balance);
+            const divisor = BigInt(10 ** decimals);
+            const whole = (raw / divisor).toString();
+            const frac = (raw % divisor).toString().padStart(decimals, '0').replace(/0+$/, '') || '0';
+            return `- ${b.symbol ?? b.name ?? 'Unknown'}: ${whole}.${frac} (${b.address})`;
+        });
+        return {
+            content: [{ type: 'text', text: `Jetton balances:\n${lines.join('\n')}` }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+    }
+});
+server.tool('get_transactions', 'Get recent transaction history for the connected wallet.', {
+    limit: z.number().optional().describe('Number of transactions to return (default 10)'),
+}, async ({ limit }) => {
+    if (!TOKEN) {
+        return { content: [{ type: 'text', text: 'No token configured. Use request_auth first.' }], isError: true };
+    }
+    try {
+        const result = await apiCall(`/v1/wallet/transactions?limit=${limit ?? 10}`);
+        const events = result.events ?? [];
+        if (!events.length) {
+            return { content: [{ type: 'text', text: 'No recent transactions.' }] };
+        }
+        const lines = events.map((e) => {
+            const time = new Date(e.timestamp * 1000).toISOString();
+            const actions = (e.actions ?? []).map((a) => a.type).join(', ');
+            return `- ${time}: ${actions || 'unknown'} ${e.is_scam ? '[SCAM]' : ''}`;
+        });
+        return {
+            content: [{ type: 'text', text: `Recent transactions:\n${lines.join('\n')}` }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+    }
+});
+server.tool('get_nft_items', 'List NFTs owned by the connected wallet.', {}, async () => {
+    if (!TOKEN) {
+        return { content: [{ type: 'text', text: 'No token configured. Use request_auth first.' }], isError: true };
+    }
+    try {
+        const result = await apiCall('/v1/wallet/nfts');
+        const nfts = result.nfts ?? [];
+        if (!nfts.length) {
+            return { content: [{ type: 'text', text: 'No NFTs found in this wallet.' }] };
+        }
+        const lines = nfts.map((n) => `- ${n.name ?? 'Unnamed'} ${n.collection ? `(${n.collection})` : ''} — ${n.address}`);
+        return {
+            content: [{ type: 'text', text: `NFTs (${nfts.length}):\n${lines.join('\n')}` }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+    }
+});
+server.tool('resolve_name', 'Resolve a .ton domain name to a wallet address. Use this when the user says "send to alice.ton" instead of a raw address.', {
+    domain: z.string().describe('The .ton domain name to resolve (e.g. "alice.ton")'),
+}, async ({ domain }) => {
+    try {
+        const result = await fetch(`${API_URL}/v1/dns/${encodeURIComponent(domain)}/resolve`);
+        const data = await result.json();
+        if (!result.ok)
+            throw new Error(data.error ?? 'Failed');
+        if (!data.address) {
+            return { content: [{ type: 'text', text: `Domain "${domain}" not found or has no wallet address.` }] };
+        }
+        return {
+            content: [{ type: 'text', text: `${domain} → ${data.address}` }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+    }
+});
+server.tool('get_ton_price', 'Get the current price of TON in USD and other currencies.', {
+    currencies: z.string().optional().describe('Comma-separated currencies (default "USD")'),
+}, async ({ currencies }) => {
+    try {
+        const curr = currencies || 'USD';
+        const result = await fetch(`${API_URL}/v1/market/price?tokens=TON&currencies=${curr}`);
+        const data = await result.json();
+        if (!result.ok)
+            throw new Error(data.error ?? 'Failed');
+        const tonRates = data.rates?.TON?.prices ?? {};
+        const lines = Object.entries(tonRates).map(([c, p]) => `1 TON = ${p} ${c}`);
+        return {
+            content: [{ type: 'text', text: lines.length ? lines.join('\n') : 'Price data unavailable.' }],
+        };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+    }
+});
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,21 +1,30 @@
 {
   "name": "@tongateway/mcp",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "MCP server for Agent Gateway — lets AI agents request TON blockchain transfers",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/tongateway/agent-gateway-mcp"
+    "url": "https://github.com/tongateway/mcp"
   },
-  "keywords": ["mcp", "ton", "blockchain", "agent", "ai", "wallet"],
+  "keywords": [
+    "mcp",
+    "ton",
+    "blockchain",
+    "agent",
+    "ai",
+    "wallet"
+  ],
   "type": "module",
   "bin": {
     "agent-gateway-mcp": "./dist/index.js"
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc",
-"dev": "tsx src/index.ts"
+    "dev": "tsx src/index.ts"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",