@tongateway/mcp 0.2.0 → 0.4.0

package/dist/index.js

@@ -2,8 +2,29 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
 const API_URL = process.env.AGENT_GATEWAY_API_URL ?? 'https://api.tongateway.ai';
-let TOKEN = process.env.AGENT_GATEWAY_TOKEN || '';
+const TOKEN_FILE = join(homedir(), '.tongateway', 'token');
+function loadToken() {
+    if (process.env.AGENT_GATEWAY_TOKEN)
+        return process.env.AGENT_GATEWAY_TOKEN;
+    try {
+        return readFileSync(TOKEN_FILE, 'utf-8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+function saveToken(token) {
+    try {
+        mkdirSync(join(homedir(), '.tongateway'), { recursive: true });
+        writeFileSync(TOKEN_FILE, token, 'utf-8');
+    }
+    catch { }
+}
+let TOKEN = loadToken();
 async function apiCall(path, options = {}) {
     const headers = {
         'Content-Type': 'application/json',
@@ -91,8 +112,9 @@ server.tool('get_auth_token', 'Check if the user has completed wallet authentica
                 ],
             };
         }
-        // Store the token for future API calls
+        // Store the token for future API calls and persist to disk
         TOKEN = data.token;
+        saveToken(TOKEN);
         return {
             content: [
                 {
@@ -228,5 +250,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,6 +1,6 @@
 {
   "name": "@tongateway/mcp",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "MCP server for Agent Gateway — lets AI agents request TON blockchain transfers",
   "license": "MIT",
   "repository": {