helius-mcp 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Helius Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,150 @@
+# Helius MCP Server
+
+Official Model Context Protocol (MCP) server for Helius - Complete Solana blockchain data access for Claude.
+
+## Features
+
+**29 Tools Covering:**
+- ✅ Digital Asset Standard (DAS) API - NFTs, tokens, compressed NFTs
+- ✅ RPC Methods - Balances, accounts, signatures
+- ✅ Enhanced Transactions - Human-readable parsing
+- ✅ Priority Fees - Real-time fee estimation
+- ✅ Webhooks - Event monitoring and notifications
+- ✅ Enhanced WebSockets - Real-time streaming (1.5-2× faster)
+- ✅ Laserstream gRPC - Lowest latency streaming with 24h replay
+
+**Network Support:**
+- Mainnet Beta
+- Devnet
+
+## Installation
+
+```bash
+npm install -g @helius-labs/mcp-server
+```
+
+## Quick Start
+
+### 1. Get Helius API Key
+
+Sign up at [helius.dev](https://www.helius.dev) and create an API key.
+
+### 2. Configure Claude Desktop
+
+Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+
+```json
+{
+  "mcpServers": {
+    "helius": {
+      "command": "helius-mcp",
+      "env": {
+        "HELIUS_API_KEY": "your-api-key-here",
+        "HELIUS_NETWORK": "mainnet-beta"
+      }
+    }
+  }
+}
+```
+
+### 3. Restart Claude Desktop
+
+The Helius tools will now be available in Claude.
+
+## Usage Examples
+
+**Check wallet balance:**
+```
+What's the SOL balance for vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg?
+```
+
+**Get NFT information:**
+```
+Show me details for NFT FKZJkqv2YbXmcGWbp2RJfhVmpE6PnSaq6dMj1DKXgj1m
+```
+
+**Monitor transactions:**
+```
+Set up a webhook to track transactions for wallet ABC...XYZ
+```
+
+**Real-time streaming:**
+```
+Show me how to subscribe to Raydium swap transactions
+```
+
+## Available Tools
+
+### Config (1 tool)
+- `setHeliusApiKey` - Configure API key and network
+
+### DAS API (12 tools)
+- `getAsset` - NFT/token details
+- `getAssetBatch` - Batch fetch assets
+- `getAssetsByOwner` - Wallet's assets
+- `getAssetsByGroup` - Collection NFTs
+- `getAssetsByCreator` - Creator's assets
+- `getAssetsByAuthority` - Authority's assets
+- `searchAssets` - Advanced search
+- `getAssetProof` - cNFT Merkle proof
+- `getAssetProofBatch` - Batch proofs
+- `getSignaturesForAsset` - cNFT transaction history
+- `getNftEditions` - Edition NFTs
+- `getTokenAccounts` - Token account queries
+
+### RPC Methods (4 tools)
+- `getBalance` - SOL balance
+- `getAccountInfo` - Account details
+- `getMultipleAccounts` - Batch account lookups
+- `getSignaturesForAddress` - Transaction signatures
+
+### Enhanced Transactions (1 tool)
+- `parseTransactions` - Human-readable parsing
+
+### Priority Fees (1 tool)
+- `getPriorityFeeEstimate` - Optimal fees
+
+### Webhooks (5 tools)
+- `getAllWebhooks` - List webhooks
+- `getWebhookByID` - Webhook details
+- `createWebhook` - Create webhook
+- `updateWebhook` - Update webhook
+- `deleteWebhook` - Delete webhook
+
+### Enhanced WebSockets (3 tools)
+- `transactionSubscribe` - Real-time transaction streaming
+- `accountSubscribe` - Real-time account monitoring
+- `getEnhancedWebSocketInfo` - WebSocket service info
+
+### Laserstream gRPC (2 tools)
+- `laserstreamSubscribe` - High-performance gRPC streaming
+- `getLaserstreamInfo` - Laserstream service info
+
+## Plan Requirements
+
+### Enhanced WebSockets
+- Free/Developer: ❌ Not available
+- Business: ✅ 250 connections
+- Professional: ✅ 250 connections
+
+### Laserstream gRPC
+- Free: ❌ Not available
+- Developer: ✅ Devnet only
+- Business: ✅ Devnet only
+- Professional: ✅ Mainnet + Devnet
+
+## Documentation
+
+- [Helius API Documentation](https://docs.helius.dev)
+- [Enhanced WebSockets](https://docs.helius.dev/enhanced-websockets)
+- [Laserstream gRPC](https://docs.helius.dev/laserstream)
+- [MCP Protocol](https://modelcontextprotocol.io)
+
+## Support
+
+- GitHub Issues: [helius-labs/helius-mcp-server](https://github.com/helius-labs/helius-mcp-server/issues)
+- Discord: [Helius Discord](https://discord.gg/aYYStRz3YX)
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerTools } from './tools/index.js';
+import { setApiKey } from './utils/helius.js';
+const server = new McpServer({
+    name: 'helius-claude-plugin',
+    version: '0.3.0'
+});
+// Register all tools
+registerTools(server);
+// Start the server
+async function main() {
+    // Auto-configure API key from environment if available
+    if (process.env.HELIUS_API_KEY) {
+        setApiKey(process.env.HELIUS_API_KEY);
+        console.error('✅ Helius API key loaded from environment');
+    }
+    else {
+        console.error('ℹ️  No API key found. Use setHeliusApiKey tool or set HELIUS_API_KEY environment variable');
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('🚀 Helius MCP Server v0.3.0 running (20 tools)');
+}
+main().catch((error) => {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+});

package/dist/tools/accounts.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAccountTools(server: McpServer): void;

package/dist/tools/accounts.js

@@ -0,0 +1,197 @@
+import { z } from 'zod';
+import { getHeliusClient, hasApiKey } from '../utils/helius.js';
+import { formatAddress, formatSol } from '../utils/formatters.js';
+import { noApiKeyResponse } from './shared.js';
+export function registerAccountTools(server) {
+    // Get multiple account balances at once
+    server.tool('getMultipleAccounts', 'Get account info for multiple addresses in a single call (up to 100 addresses). More efficient than calling getBalance repeatedly. Returns SOL balance, owner, executable status, and rent epoch for each account.', {
+        addresses: z.array(z.string()).describe('Array of Solana addresses (max 100)'),
+        commitment: z.enum(['processed', 'confirmed', 'finalized']).optional().default('confirmed')
+    }, async ({ addresses, commitment }) => {
+        if (!hasApiKey())
+            return noApiKeyResponse();
+        if (addresses.length > 100) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: '**Error**\n\nMaximum 100 addresses allowed per request'
+                    }],
+                isError: true
+            };
+        }
+        try {
+            const helius = getHeliusClient();
+            const connection = helius.connection;
+            if (!connection || !connection.getMultipleAccountsInfo) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: '**Error**\n\nMultiple account lookup not available'
+                        }],
+                    isError: true
+                };
+            }
+            const accountsInfo = await connection.getMultipleAccountsInfo(addresses, { commitment });
+            const lines = [
+                `**Account Info (${addresses.length} addresses)**`,
+                ``
+            ];
+            addresses.forEach((addr, i) => {
+                const info = accountsInfo[i];
+                if (!info) {
+                    lines.push(`${i + 1}. ${formatAddress(addr)} - Account does not exist`);
+                    return;
+                }
+                lines.push(`${i + 1}. ${formatAddress(addr)}`);
+                lines.push(`   Balance: ${formatSol(info.lamports)}`);
+                lines.push(`   Owner: ${formatAddress(info.owner.toBase58())}`);
+                if (info.executable) {
+                    lines.push(`   ⚡ Executable program`);
+                }
+                lines.push(``);
+            });
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `**Error**\n\n${error.message}` }],
+                isError: true
+            };
+        }
+    });
+    // Get program accounts
+    server.tool('getProgramAccounts', 'Query all accounts owned by a program. Use filters to narrow results (e.g., token accounts for a specific mint, PDAs with certain data). Returns account addresses and data. Warning: Can be slow for programs with many accounts.', {
+        programId: z.string().describe('Program address to query'),
+        filters: z.array(z.object({
+            memcmp: z.object({
+                offset: z.number(),
+                bytes: z.string()
+            }).optional(),
+            dataSize: z.number().optional()
+        })).optional().describe('Optional filters to narrow results'),
+        limit: z.number().optional().default(10).describe('Max accounts to return')
+    }, async ({ programId, filters, limit }) => {
+        if (!hasApiKey())
+            return noApiKeyResponse();
+        try {
+            const helius = getHeliusClient();
+            const connection = helius.connection;
+            if (!connection || !connection.getProgramAccounts) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: '**Error**\n\nProgram account lookup not available'
+                        }],
+                    isError: true
+                };
+            }
+            const config = {};
+            if (filters && filters.length > 0) {
+                config.filters = filters;
+            }
+            const accounts = await connection.getProgramAccounts(programId, config);
+            if (!accounts || accounts.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `**No Accounts Found**\n\nProgram: ${formatAddress(programId)}`
+                        }]
+                };
+            }
+            const lines = [
+                `**Program Accounts**`,
+                ``,
+                `Program: ${formatAddress(programId)}`,
+                `Total: ${accounts.length} accounts`,
+                ``
+            ];
+            const displayAccounts = accounts.slice(0, limit);
+            displayAccounts.forEach((account, i) => {
+                const pubkey = account.pubkey.toBase58();
+                const lamports = account.account.lamports;
+                const dataLength = account.account.data.length;
+                lines.push(`${i + 1}. ${formatAddress(pubkey)}`);
+                lines.push(`   Balance: ${formatSol(lamports)}`);
+                lines.push(`   Data: ${dataLength} bytes`);
+            });
+            if (accounts.length > limit) {
+                lines.push(``);
+                lines.push(`💡 Showing first ${limit} of ${accounts.length} accounts`);
+            }
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `**Error**\n\n${error.message}` }],
+                isError: true
+            };
+        }
+    });
+    // Get account info
+    server.tool('getAccountInfo', 'Get detailed information about a single Solana account including balance, owner, data, executable status, and rent epoch. Use this for inspecting program accounts, PDAs, or any on-chain account.', {
+        address: z.string().describe('Solana address to query'),
+        encoding: z.enum(['base58', 'base64', 'jsonParsed']).optional().default('base64')
+    }, async ({ address, encoding }) => {
+        if (!hasApiKey())
+            return noApiKeyResponse();
+        try {
+            const helius = getHeliusClient();
+            const connection = helius.connection;
+            if (!connection || !connection.getAccountInfo) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: '**Error**\n\nAccount info lookup not available'
+                        }],
+                    isError: true
+                };
+            }
+            const accountInfo = await connection.getAccountInfo(address, { encoding });
+            if (!accountInfo) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `**Account Not Found**\n\n${formatAddress(address)}\n\nThis account does not exist or has been closed.`
+                        }]
+                };
+            }
+            const lines = [
+                `**Account Info**`,
+                ``,
+                `Address: ${formatAddress(address)}`,
+                `Balance: ${formatSol(accountInfo.lamports)}`,
+                `Owner: ${formatAddress(accountInfo.owner.toBase58())}`,
+                `Data Length: ${accountInfo.data.length} bytes`,
+                `Rent Epoch: ${accountInfo.rentEpoch}`,
+                ``
+            ];
+            if (accountInfo.executable) {
+                lines.push(`⚡ **Executable Program**`);
+                lines.push(``);
+            }
+            if (encoding === 'jsonParsed' && accountInfo.data.parsed) {
+                lines.push(`**Parsed Data:**`);
+                lines.push('```json');
+                lines.push(JSON.stringify(accountInfo.data.parsed, null, 2));
+                lines.push('```');
+            }
+            else if (accountInfo.data.length > 0 && accountInfo.data.length <= 100) {
+                lines.push(`**Data (first 100 bytes):**`);
+                lines.push(`${accountInfo.data.toString('hex').slice(0, 200)}...`);
+            }
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `**Error**\n\n${error.message}` }],
+                isError: true
+            };
+        }
+    });
+}

package/dist/tools/assets-extended.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerExtendedAssetTools(server: McpServer): void;

package/dist/tools/assets-extended.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { getHeliusClient, hasApiKey } from '../utils/helius.js';
+import { formatAddress } from '../utils/formatters.js';
+import { noApiKeyResponse } from './shared.js';
+export function registerExtendedAssetTools(server) {
+    server.tool('getAssetsByGroup', 'Get NFTs in a collection', { groupKey: z.string(), groupValue: z.string(), page: z.number().optional().default(1), limit: z.number().optional().default(20) }, async ({ groupKey, groupValue, page, limit }) => {
+        if (!hasApiKey())
+            return noApiKeyResponse();
+        const response = await getHeliusClient().getAssetsByGroup({ groupKey, groupValue, page, limit });
+        const items = response.items || [];
+        const total = response.total || 0;
+        if (items.length === 0)
+            return { content: [{ type: 'text', text: 'No assets found' }] };
+        const lines = [`**Collection: ${total} total**`, ``];
+        items.slice(0, 15).forEach((a, i) => {
+            const name = a.content && a.content.metadata && a.content.metadata.name ? a.content.metadata.name : 'Unnamed';
+            lines.push(`${i + 1}. ${name}`);
+            lines.push(`   ${formatAddress(a.id)}`);
+        });
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    });
+    server.tool('searchAssets', 'Search NFTs with filters', { creatorAddress: z.string().optional(), ownerAddress: z.string().optional(), burnt: z.boolean().optional(), page: z.number().optional().default(1), limit: z.number().optional().default(20) }, async (params) => {
+        if (!hasApiKey())
+            return noApiKeyResponse();
+        const response = await getHeliusClient().searchAssets(params);
+        const items = response.items || [];
+        if (items.length === 0)
+            return { content: [{ type: 'text', text: 'No results' }] };
+        const lines = [`**Found ${response.total || 0} assets**`, ``];
+        items.slice(0, 10).forEach((a, i) => {
+            const name = a.content && a.content.metadata && a.content.metadata.name ? a.content.metadata.name : 'Unnamed';
+            lines.push(`${i + 1}. ${name}`);
+        });
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    });
+    server.tool('getAssetProof', 'Get Merkle proof for cNFT', { id: z.string() }, async ({ id }) => {
+        if (!hasApiKey())
+            return noApiKeyResponse();
+        const proof = await getHeliusClient().getAssetProof({ id });
+        return { content: [{ type: 'text', text: `**Proof for ${formatAddress(id)}**\n\nLength: ${proof.proof ? proof.proof.length : 0} nodes` }] };
+    });
+    server.tool('getAssetsByCreator', 'Get NFTs by creator', { creatorAddress: z.string(), page: z.number().optional().default(1), limit: z.number().optional().default(20) }, async (params) => {
+        if (!hasApiKey())
+            return noApiKeyResponse();
+        const response = await getHeliusClient().getAssetsByCreator(params);
+        const items = response.items || [];
+        const lines = [`**${response.total || 0} assets by creator**`, ``];
+        items.slice(0, 10).forEach((a, i) => {
+            const name = a.content && a.content.metadata && a.content.metadata.name ? a.content.metadata.name : 'Unnamed';
+            lines.push(`${i + 1}. ${name}`);
+        });
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    });
+}

package/dist/tools/assets.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAssetTools(server: McpServer): void;

package/dist/tools/assets.js

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+import { getHeliusClient, hasApiKey } from '../utils/helius.js';
+import { formatAddress } from '../utils/formatters.js';
+import { noApiKeyResponse } from './shared.js';
+export function registerAssetTools(server) {
+    // Get Assets by Owner (NFTs and tokens via DAS)
+    server.tool('getAssetsByOwner', 'Get all NFTs and digital assets owned by a Solana wallet using the DAS (Digital Asset Standard) API. Returns asset names, types (NFT, cNFT, Fungible, etc.), and mint addresses. Supports both regular NFTs and compressed NFTs (cNFTs). Use this to see what NFTs/collectibles a wallet owns. For fungible token balances, use getTokenBalances instead.', {
+        address: z.string().describe('Solana wallet address (base58 encoded)'),
+        limit: z.number().optional().default(20).describe('Number of assets to return (default 20). Increase for wallets with many NFTs.')
+    }, async ({ address, limit }) => {
+        if (!hasApiKey())
+            return noApiKeyResponse();
+        const helius = getHeliusClient();
+        const response = await helius.getAssetsByOwner({
+            ownerAddress: address,
+            page: 1,
+            limit
+        });
+        if (!response.items || response.items.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `**Assets for ${formatAddress(address)}**\n\nNo assets found.`
+                    }]
+            };
+        }
+        const items = response.items;
+        // Enrich assets missing name/symbol
+        const unknownAssets = items.filter((asset) => !asset.content?.metadata?.name && !asset.content?.metadata?.symbol && !asset.token_info?.symbol);
+        if (unknownAssets.length > 0 && unknownAssets.length <= 10) {
+            const enrichedData = await Promise.allSettled(unknownAssets.map((asset) => helius.getAsset({ id: asset.id })));
+            enrichedData.forEach((result, idx) => {
+                if (result.status === 'fulfilled' && result.value) {
+                    const enriched = result.value;
+                    const original = unknownAssets[idx];
+                    if (enriched.content?.metadata) {
+                        original.content = original.content || {};
+                        original.content.metadata = enriched.content.metadata;
+                    }
+                    if (enriched.token_info?.symbol) {
+                        original.token_info = original.token_info || {};
+                        original.token_info.symbol = enriched.token_info.symbol;
+                    }
+                }
+            });
+        }
+        const lines = [`**Assets for ${formatAddress(address)}** (${response.total} total)`, ''];
+        items.forEach((asset) => {
+            const name = asset.content?.metadata?.name || asset.content?.metadata?.symbol || asset.token_info?.symbol || 'Unnamed';
+            lines.push(`- **${name}** (${asset.interface})`);
+            lines.push(`  ID: ${formatAddress(asset.id)}`);
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: lines.join('\n')
+                }]
+        };
+    });
+    // Get Single Asset Details
+    server.tool('getAsset', 'Get detailed information about a specific NFT, token, or digital asset by its mint address. Returns name, symbol, description, image URL, current owner, creators/deployer addresses, authorities, token supply, decimals, royalties, and whether the token is mutable. Use this to find who created/deployed a token, verify token details, or get full NFT metadata.', {
+        id: z.string().describe('Asset mint address / ID (base58 encoded). This is the unique identifier for the NFT or token.')
+    }, async ({ id }) => {
+        if (!hasApiKey())
+            return noApiKeyResponse();
+        const helius = getHeliusClient();
+        const asset = await helius.getAsset({ id });
+        if (!asset) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Asset ${formatAddress(id)} not found.`
+                    }]
+            };
+        }
+        const metadata = asset.content?.metadata;
+        const tokenInfo = asset.token_info;
+        const lines = [
+            `**Asset: ${metadata?.name || tokenInfo?.symbol || 'Unnamed'}**`,
+            '',
+            `**Mint Address:** ${asset.id}`,
+            `**Type:** ${asset.interface}`,
+        ];
+        if (metadata?.symbol || tokenInfo?.symbol) {
+            lines.push(`**Symbol:** ${metadata?.symbol || tokenInfo?.symbol}`);
+        }
+        if (asset.ownership?.owner) {
+            lines.push(`**Owner:** ${formatAddress(asset.ownership.owner)}`);
+        }
+        if (metadata?.description) {
+            lines.push(`**Description:** ${metadata.description}`);
+        }
+        // Creators/Deployer info
+        if (asset.creators && asset.creators.length > 0) {
+            lines.push('', '**Creators:**');
+            asset.creators.forEach((creator) => {
+                const verified = creator.verified ? '✓' : '✗';
+                lines.push(`- ${formatAddress(creator.address)} (${creator.share}% share) ${verified}`);
+            });
+        }
+        // Authorities
+        if (asset.authorities && asset.authorities.length > 0) {
+            lines.push('', '**Authorities:**');
+            asset.authorities.forEach((auth) => {
+                lines.push(`- ${formatAddress(auth.address)} [${auth.scopes.join(', ')}]`);
+            });
+        }
+        // Token info (for fungible tokens)
+        if (tokenInfo) {
+            lines.push('', '**Token Info:**');
+            if (tokenInfo.decimals !== undefined) {
+                lines.push(`- Decimals: ${tokenInfo.decimals}`);
+            }
+            if (tokenInfo.supply !== undefined) {
+                const formattedSupply = tokenInfo.decimals
+                    ? (tokenInfo.supply / Math.pow(10, tokenInfo.decimals)).toLocaleString()
+                    : tokenInfo.supply.toLocaleString();
+                lines.push(`- Supply: ${formattedSupply}`);
+            }
+            if (tokenInfo.token_program) {
+                const programName = tokenInfo.token_program === 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
+                    ? 'SPL Token'
+                    : tokenInfo.token_program === 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb'
+                        ? 'Token-2022'
+                        : formatAddress(tokenInfo.token_program);
+                lines.push(`- Program: ${programName}`);
+            }
+            if (tokenInfo.price_info?.price_per_token) {
+                lines.push(`- Price: $${tokenInfo.price_info.price_per_token.toFixed(6)} ${tokenInfo.price_info.currency || 'USD'}`);
+            }
+        }
+        if (asset.content?.links?.image) {
+            lines.push(`**Image:** ${asset.content.links.image}`);
+        }
+        if (asset.royalty && asset.royalty.percent > 0) {
+            lines.push(`**Royalty:** ${asset.royalty.percent}%`);
+        }
+        // Mutable/burnt status
+        const flags = [];
+        if (asset.mutable === false)
+            flags.push('Immutable');
+        if (asset.mutable === true)
+            flags.push('Mutable');
+        if (asset.burnt)
+            flags.push('Burnt');
+        if (flags.length > 0) {
+            lines.push(`**Status:** ${flags.join(', ')}`);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: lines.join('\n')
+                }]
+        };
+    });
+}

package/dist/tools/balance.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerBalanceTools(server: McpServer): void;