helius-mcp 0.2.0

package/dist/tools/balance.js

@@ -0,0 +1,169 @@
+import { z } from 'zod';
+import { getHeliusClient, hasApiKey } from '../utils/helius.js';
+import { formatSol, formatAddress } from '../utils/formatters.js';
+import { noApiKeyResponse } from './shared.js';
+export function registerBalanceTools(server) {
+    // Get SOL Balance
+    server.tool('getBalance', 'Get native SOL balance for a Solana wallet address. Returns balance in both SOL and lamports (1 SOL = 1 billion lamports). Use this for checking how much SOL a wallet has. For token balances, use getTokenBalances instead.', {
+        address: z.string().describe('Solana wallet address (base58 encoded, e.g. Gh4tdJhLP1s55xGfghHHvPNPPrNtaDjc6dzZJ374DGHJ)')
+    }, async ({ address }) => {
+        if (!hasApiKey())
+            return noApiKeyResponse();
+        const helius = getHeliusClient();
+        const balance = await helius.getBalance(address);
+        const lamports = Number(balance.value);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `**SOL Balance for ${formatAddress(address)}**\n\n${formatSol(lamports)} (${lamports.toLocaleString()} lamports)`
+                }]
+        };
+    });
+    // Get Token Balances
+    server.tool('getTokenBalances', 'Get all SPL token balances for a Solana wallet with full token info: names, symbols, properly formatted amounts with decimals, and USD prices (when available). Includes fungible tokens like USDC, BONK, JUP, etc. Does NOT include NFTs — use getAssetsByOwner for NFTs. For native SOL balance, use getBalance instead. Automatically paginates to fetch all tokens using parallel requests for speed.', {
+        address: z.string().describe('Solana wallet address (base58 encoded)')
+    }, async ({ address }) => {
+        if (!hasApiKey())
+            return noApiKeyResponse();
+        const helius = getHeliusClient();
+        const PAGE_SIZE = 10;
+        const MAX_ASSETS = 500;
+        const MAX_PAGES = 100;
+        // Helper to fetch a single page with retry on "too big" errors
+        async function fetchPage(page, limit = PAGE_SIZE) {
+            let currentLimit = limit;
+            while (currentLimit >= 1) {
+                try {
+                    const response = await helius.getAssetsByOwner({
+                        ownerAddress: address,
+                        page,
+                        limit: currentLimit,
+                        displayOptions: { showFungible: true }
+                    });
+                    const items = response.items || [];
+                    return { items, hasMore: items.length === currentLimit };
+                }
+                catch (err) {
+                    const errorMsg = err instanceof Error ? err.message : String(err);
+                    if (errorMsg.includes('too big') || errorMsg.includes('Response is too big')) {
+                        if (currentLimit > 5)
+                            currentLimit = 5;
+                        else if (currentLimit > 2)
+                            currentLimit = 2;
+                        else if (currentLimit > 1)
+                            currentLimit = 1;
+                        else
+                            return { items: [], hasMore: false };
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+            return { items: [], hasMore: false };
+        }
+        // Step 1: Fetch first page to probe
+        const firstResult = await fetchPage(1);
+        const allAssets = [...firstResult.items];
+        if (allAssets.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `**Token Balances for ${formatAddress(address)}**\n\nNo tokens found.`
+                    }]
+            };
+        }
+        // Step 2: If first page is full, fetch remaining pages in parallel
+        // Strategy: fetch pages 2-15 in parallel (covers most wallets), then continue if needed
+        if (firstResult.hasMore && allAssets.length < MAX_ASSETS) {
+            let currentPage = 2;
+            let hasMorePages = true;
+            const BATCH_SIZE = 15; // Conservative batch size
+            while (hasMorePages && allAssets.length < MAX_ASSETS && currentPage <= MAX_PAGES) {
+                const batchPages = Array.from({ length: Math.min(BATCH_SIZE, MAX_PAGES - currentPage + 1) }, (_, i) => currentPage + i);
+                const results = await Promise.allSettled(batchPages.map(page => fetchPage(page)));
+                let pagesWithData = 0;
+                let lastPageWithData = -1;
+                for (let i = 0; i < results.length; i++) {
+                    const result = results[i];
+                    if (result.status === 'fulfilled' && result.value.items.length > 0) {
+                        allAssets.push(...result.value.items);
+                        pagesWithData++;
+                        lastPageWithData = i;
+                    }
+                }
+                // Stop if no pages had data, or if we found empty pages after data (reached end)
+                hasMorePages = pagesWithData > 0 && lastPageWithData === batchPages.length - 1;
+                currentPage += batchPages.length;
+            }
+        }
+        const fungibleTokens = allAssets.filter((asset) => asset.interface === 'FungibleToken' || asset.interface === 'FungibleAsset');
+        if (fungibleTokens.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `**Token Balances for ${formatAddress(address)}**\n\nNo fungible tokens found.`
+                    }]
+            };
+        }
+        // Enrich tokens missing name/symbol by fetching full asset data
+        const unknownTokens = fungibleTokens.filter((asset) => !asset.token_info?.symbol && !asset.content?.metadata?.symbol && !asset.content?.metadata?.name);
+        if (unknownTokens.length > 0 && unknownTokens.length <= 10) {
+            const enrichedData = await Promise.allSettled(unknownTokens.map((asset) => helius.getAsset({ id: asset.id })));
+            enrichedData.forEach((result, idx) => {
+                if (result.status === 'fulfilled' && result.value) {
+                    const enriched = result.value;
+                    const original = unknownTokens[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 = [];
+        let totalUsdValue = 0;
+        let tokensWithPrice = 0;
+        fungibleTokens.forEach((asset) => {
+            const symbol = asset.token_info?.symbol || asset.content?.metadata?.symbol;
+            const name = asset.content?.metadata?.name;
+            const decimals = asset.token_info?.decimals ?? 0;
+            const balance = asset.token_info?.balance ?? 0;
+            const totalPrice = asset.token_info?.price_info?.total_price;
+            const formattedAmount = decimals > 0
+                ? (balance / Math.pow(10, decimals)).toLocaleString(undefined, { maximumFractionDigits: Math.min(decimals, 6) })
+                : balance.toLocaleString();
+            const displayName = symbol || name || formatAddress(asset.id);
+            let line = `- **${displayName}**: ${formattedAmount}`;
+            if (totalPrice !== undefined && totalPrice > 0) {
+                totalUsdValue += totalPrice;
+                tokensWithPrice++;
+                line += ` ($${totalPrice.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })})`;
+            }
+            if (!symbol && !name) {
+                line += ` — ${formatAddress(asset.id)}`;
+            }
+            lines.push(line);
+        });
+        let header = `**Token Balances for ${formatAddress(address)}** (${fungibleTokens.length} tokens)`;
+        if (allAssets.length >= MAX_ASSETS) {
+            header += ` — showing first ${MAX_ASSETS} assets`;
+        }
+        if (totalUsdValue > 0) {
+            header += `\n**Total Value:** $${totalUsdValue.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+            if (tokensWithPrice < fungibleTokens.length) {
+                header += ` (${tokensWithPrice}/${fungibleTokens.length} tokens have price data)`;
+            }
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `${header}\n\n${lines.join('\n')}`
+                }]
+        };
+    });
+}

package/dist/tools/config.d.ts

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

package/dist/tools/config.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { setApiKey, setNetwork, rpcRequest } from '../utils/helius.js';
+export function registerConfigTools(server) {
+    server.tool('setHeliusApiKey', 'Configure the Helius API key for this session. Required before using any blockchain data tools. Get your API key from https://dashboard.helius.dev/api-keys. The key is validated by making a test request.', {
+        apiKey: z.string().describe('Your Helius API key'),
+        network: z.enum(['mainnet-beta', 'devnet']).optional().default('mainnet-beta').describe('Network to use (default: mainnet-beta)')
+    }, async ({ apiKey, network }) => {
+        try {
+            setApiKey(apiKey);
+            if (network) {
+                setNetwork(network);
+            }
+            // Validate with test request
+            await rpcRequest('getBlockHeight');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Helius API key configured for ${network}!\n\nYou can now query the Solana blockchain.`
+                    }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `❌ Failed to configure API key: ${errorMsg}\n\nPlease check your key at https://dashboard.helius.dev/api-keys`
+                    }],
+                isError: true
+            };
+        }
+    });
+}

package/dist/tools/das.d.ts

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

package/dist/tools/das.js

@@ -0,0 +1,428 @@
+import { z } from 'zod';
+import { dasRequest } from '../utils/helius.js';
+import { formatAddress } from '../utils/formatters.js';
+export function registerDasTools(server) {
+    // getAsset - Get single asset details
+    server.tool('getAsset', 'Get comprehensive information about any Solana NFT, token, or compressed NFT by its mint address. Returns metadata, owner, creators, authorities, royalties, supply, and price data (for top 10k tokens by 24h volume). Supports all token standards including cNFTs and pNFTs.', {
+        id: z.string().describe('Asset mint address (base58 encoded)')
+    }, async ({ id }) => {
+        try {
+            const asset = await dasRequest('getAsset', { id });
+            const lines = [
+                `**${asset.content?.metadata?.name || asset.token_info?.symbol || 'Asset'}**`,
+                '',
+                `**Mint:** ${formatAddress(asset.id)}`,
+                `**Type:** ${asset.interface}`,
+            ];
+            if (asset.ownership?.owner) {
+                lines.push(`**Owner:** ${formatAddress(asset.ownership.owner)}`);
+            }
+            if (asset.content?.metadata?.symbol || asset.token_info?.symbol) {
+                lines.push(`**Symbol:** ${asset.content?.metadata?.symbol || asset.token_info?.symbol}`);
+            }
+            if (asset.creators?.length > 0) {
+                lines.push('', '**Creators:**');
+                asset.creators.forEach((c) => {
+                    lines.push(`- ${formatAddress(c.address)} (${c.share}%) ${c.verified ? '✓' : ''}`);
+                });
+            }
+            if (asset.token_info) {
+                lines.push('', '**Token Info:**');
+                if (asset.token_info.supply) {
+                    const supply = asset.token_info.decimals
+                        ? (asset.token_info.supply / Math.pow(10, asset.token_info.decimals)).toLocaleString()
+                        : asset.token_info.supply.toLocaleString();
+                    lines.push(`- Supply: ${supply}`);
+                }
+                if (asset.token_info.decimals !== undefined) {
+                    lines.push(`- Decimals: ${asset.token_info.decimals}`);
+                }
+                if (asset.token_info.price_info?.price_per_token) {
+                    lines.push(`- Price: $${asset.token_info.price_info.price_per_token.toFixed(6)}`);
+                }
+            }
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+    // getAssetBatch - Fetch multiple assets (up to 1000)
+    server.tool('getAssetBatch', 'Fetch multiple assets in a single request (up to 1000 assets). Much faster than calling getAsset multiple times. Returns full asset data for each mint address provided.', {
+        ids: z.array(z.string()).describe('Array of asset mint addresses (up to 1000)')
+    }, async ({ ids }) => {
+        try {
+            if (ids.length > 1000) {
+                return {
+                    content: [{ type: 'text', text: '❌ Maximum 1000 assets per batch' }],
+                    isError: true
+                };
+            }
+            const assets = await dasRequest('getAssetBatch', { ids });
+            const lines = [`**Batch Assets** (${assets.length} assets)`, ''];
+            assets.slice(0, 20).forEach((asset, i) => {
+                const name = asset.content?.metadata?.name || asset.token_info?.symbol || formatAddress(asset.id);
+                lines.push(`${i + 1}. **${name}** (${asset.interface})`);
+            });
+            if (assets.length > 20) {
+                lines.push(`\n... and ${assets.length - 20} more assets`);
+            }
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+    // getAssetsByOwner - Get wallet's assets
+    server.tool('getAssetsByOwner', 'Get all digital assets (NFTs, cNFTs, tokens) owned by a wallet address. Supports pagination and filtering by collection or token type. Returns asset names, types, and mint addresses.', {
+        ownerAddress: z.string().describe('Wallet address'),
+        page: z.number().optional().default(1).describe('Page number (starts at 1)'),
+        limit: z.number().optional().default(20).describe('Results per page (max 1000)'),
+        showFungible: z.boolean().optional().default(false).describe('Include fungible tokens'),
+        showNativeBalance: z.boolean().optional().default(false).describe('Include SOL balance')
+    }, async ({ ownerAddress, page, limit, showFungible, showNativeBalance }) => {
+        try {
+            const result = await dasRequest('getAssetsByOwner', {
+                ownerAddress,
+                page,
+                limit,
+                displayOptions: {
+                    showFungible,
+                    showNativeBalance
+                }
+            });
+            if (!result.items || result.items.length === 0) {
+                return {
+                    content: [{ type: 'text', text: `**Assets for ${formatAddress(ownerAddress)}**\n\nNo assets found.` }]
+                };
+            }
+            const lines = [`**Assets for ${formatAddress(ownerAddress)}** (${result.total} total, page ${page})`, ''];
+            result.items.forEach((asset, i) => {
+                const name = asset.content?.metadata?.name || asset.token_info?.symbol || 'Unnamed';
+                lines.push(`${i + 1}. **${name}** (${asset.interface})`);
+                lines.push(`   ID: ${formatAddress(asset.id)}`);
+            });
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+    // getAssetsByGroup - Get collection NFTs
+    server.tool('getAssetsByGroup', 'Get all NFTs in a collection by group key/value. Use this for questions like "show me all Mad Lads NFTs" or "how many Claynosaurz are there". The groupKey is usually "collection" and groupValue is the collection mint address.', {
+        groupKey: z.string().describe('Group key (usually "collection")'),
+        groupValue: z.string().describe('Collection mint address'),
+        page: z.number().optional().default(1).describe('Page number'),
+        limit: z.number().optional().default(20).describe('Results per page (max 1000)')
+    }, async ({ groupKey, groupValue, page, limit }) => {
+        try {
+            const result = await dasRequest('getAssetsByGroup', {
+                groupKey,
+                groupValue,
+                page,
+                limit
+            });
+            if (!result.items || result.items.length === 0) {
+                return {
+                    content: [{ type: 'text', text: `**Collection ${formatAddress(groupValue)}**\n\nNo assets found.` }]
+                };
+            }
+            const lines = [`**Collection** (${result.total} total, page ${page})`, ''];
+            result.items.slice(0, 20).forEach((asset, i) => {
+                const name = asset.content?.metadata?.name || 'Unnamed';
+                lines.push(`${i + 1}. **${name}**`);
+                lines.push(`   Owner: ${formatAddress(asset.ownership?.owner || 'Unknown')}`);
+            });
+            if (result.items.length > 20) {
+                lines.push(`\n... and ${result.items.length - 20} more`);
+            }
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+    // getAssetsByCreator - Get assets by creator address
+    server.tool('getAssetsByCreator', 'Find all assets created by a specific creator address. Useful for finding all NFTs or tokens deployed by a particular creator.', {
+        creatorAddress: z.string().describe('Creator wallet address'),
+        onlyVerified: z.boolean().optional().default(false).describe('Only return verified creators'),
+        page: z.number().optional().default(1).describe('Page number'),
+        limit: z.number().optional().default(20).describe('Results per page (max 1000)')
+    }, async ({ creatorAddress, onlyVerified, page, limit }) => {
+        try {
+            const result = await dasRequest('getAssetsByCreator', {
+                creatorAddress,
+                onlyVerified,
+                page,
+                limit
+            });
+            if (!result.items || result.items.length === 0) {
+                return {
+                    content: [{ type: 'text', text: `**Assets by ${formatAddress(creatorAddress)}**\n\nNo assets found.` }]
+                };
+            }
+            const lines = [`**Assets by ${formatAddress(creatorAddress)}** (${result.total} total)`, ''];
+            result.items.forEach((asset, i) => {
+                const name = asset.content?.metadata?.name || asset.token_info?.symbol || 'Unnamed';
+                lines.push(`${i + 1}. **${name}** (${asset.interface})`);
+            });
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+    // getAssetsByAuthority - Get assets by authority
+    server.tool('getAssetsByAuthority', 'Get all assets controlled by a specific authority address. Authority addresses have special permissions over assets (update, freeze, etc).', {
+        authorityAddress: z.string().describe('Authority wallet address'),
+        page: z.number().optional().default(1).describe('Page number'),
+        limit: z.number().optional().default(20).describe('Results per page (max 1000)')
+    }, async ({ authorityAddress, page, limit }) => {
+        try {
+            const result = await dasRequest('getAssetsByAuthority', {
+                authorityAddress,
+                page,
+                limit
+            });
+            if (!result.items || result.items.length === 0) {
+                return {
+                    content: [{ type: 'text', text: `**Assets by authority ${formatAddress(authorityAddress)}**\n\nNo assets found.` }]
+                };
+            }
+            const lines = [`**Assets by authority ${formatAddress(authorityAddress)}** (${result.total} total)`, ''];
+            result.items.forEach((asset, i) => {
+                const name = asset.content?.metadata?.name || asset.token_info?.symbol || 'Unnamed';
+                lines.push(`${i + 1}. **${name}** (${asset.interface})`);
+            });
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+    // searchAssets - Advanced asset search
+    server.tool('searchAssets', 'Advanced search for digital assets with complex filters. Search by name, royalties, burned status, frozen status, and more. Much more powerful than other DAS methods.', {
+        query: z.string().optional().describe('Search query string'),
+        ownerAddress: z.string().optional().describe('Filter by owner'),
+        creatorAddress: z.string().optional().describe('Filter by creator'),
+        burnt: z.boolean().optional().describe('Filter burnt assets'),
+        frozen: z.boolean().optional().describe('Filter frozen assets'),
+        page: z.number().optional().default(1).describe('Page number'),
+        limit: z.number().optional().default(20).describe('Results per page (max 1000)')
+    }, async (params) => {
+        try {
+            const result = await dasRequest('searchAssets', params);
+            if (!result.items || result.items.length === 0) {
+                return {
+                    content: [{ type: 'text', text: `**Search Results**\n\nNo assets found matching criteria.` }]
+                };
+            }
+            const lines = [`**Search Results** (${result.total} total, page ${params.page})`, ''];
+            result.items.forEach((asset, i) => {
+                const name = asset.content?.metadata?.name || asset.token_info?.symbol || 'Unnamed';
+                lines.push(`${i + 1}. **${name}** (${asset.interface})`);
+            });
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+    // getAssetProof - Get Merkle proof for compressed NFT
+    server.tool('getAssetProof', 'Get the Merkle proof for a compressed NFT (cNFT). Required for transferring or burning compressed NFTs. Returns the proof tree, root, and leaf data.', {
+        id: z.string().describe('Compressed NFT mint address')
+    }, async ({ id }) => {
+        try {
+            const proof = await dasRequest('getAssetProof', { id });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `**Merkle Proof for ${formatAddress(id)}**\n\n**Root:** ${formatAddress(proof.root)}\n**Leaf:** ${formatAddress(proof.leaf)}\n**Tree ID:** ${formatAddress(proof.tree_id)}\n**Proof Length:** ${proof.proof.length} nodes`
+                    }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+    // getAssetProofBatch - Batch Merkle proofs
+    server.tool('getAssetProofBatch', 'Get Merkle proofs for multiple compressed NFTs in one request (up to 1000). Much faster than calling getAssetProof multiple times.', {
+        ids: z.array(z.string()).describe('Array of cNFT mint addresses (up to 1000)')
+    }, async ({ ids }) => {
+        try {
+            if (ids.length > 1000) {
+                return {
+                    content: [{ type: 'text', text: '❌ Maximum 1000 proofs per batch' }],
+                    isError: true
+                };
+            }
+            const proofs = await dasRequest('getAssetProofBatch', { ids });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `**Batch Merkle Proofs** (${proofs.length} proofs)\n\n${proofs.map((p, i) => `${i + 1}. ${formatAddress(ids[i])}\n   Root: ${formatAddress(p.root)}`).join('\n\n')}`
+                    }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+    // getSignaturesForAsset - Get transaction history for compressed NFT
+    server.tool('getSignaturesForAsset', 'Get all transaction signatures for a compressed NFT. Shows the complete history of transfers, burns, and other operations on a cNFT.', {
+        id: z.string().describe('Compressed NFT mint address'),
+        page: z.number().optional().default(1).describe('Page number'),
+        limit: z.number().optional().default(20).describe('Results per page (max 1000)')
+    }, async ({ id, page, limit }) => {
+        try {
+            const result = await dasRequest('getSignaturesForAsset', {
+                id,
+                page,
+                limit
+            });
+            if (!result.items || result.items.length === 0) {
+                return {
+                    content: [{ type: 'text', text: `**Signatures for ${formatAddress(id)}**\n\nNo transactions found.` }]
+                };
+            }
+            const lines = [`**Signatures for ${formatAddress(id)}** (${result.total} total)`, ''];
+            result.items.forEach((sig, i) => {
+                lines.push(`${i + 1}. ${sig.signature}`);
+                if (sig.blockTime) {
+                    const date = new Date(sig.blockTime * 1000).toLocaleString();
+                    lines.push(`   Time: ${date}`);
+                }
+            });
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+    // getNftEditions - Get edition NFTs for master
+    server.tool('getNftEditions', 'Get all edition NFTs for a master NFT. Master NFTs can have multiple editions (copies) with specific edition numbers.', {
+        mint: z.string().describe('Master NFT mint address'),
+        page: z.number().optional().default(1).describe('Page number'),
+        limit: z.number().optional().default(20).describe('Results per page (max 1000)')
+    }, async ({ mint, page, limit }) => {
+        try {
+            const result = await dasRequest('getNftEditions', {
+                mint,
+                page,
+                limit
+            });
+            if (!result.editions || result.editions.length === 0) {
+                return {
+                    content: [{ type: 'text', text: `**Editions for ${formatAddress(mint)}**\n\nNo editions found.` }]
+                };
+            }
+            const lines = [`**Editions for ${formatAddress(mint)}** (${result.total} total)`, ''];
+            result.editions.forEach((edition, i) => {
+                lines.push(`${i + 1}. Edition #${edition.edition_number}`);
+                lines.push(`   Mint: ${formatAddress(edition.mint)}`);
+                if (edition.owner) {
+                    lines.push(`   Owner: ${formatAddress(edition.owner)}`);
+                }
+            });
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+    // getTokenAccounts - Query token accounts
+    server.tool('getTokenAccounts', 'Query token accounts with advanced filters. Can filter by mint, owner, amount, delegate, frozen status, and more.', {
+        mint: z.string().optional().describe('Filter by mint address'),
+        owner: z.string().optional().describe('Filter by owner address'),
+        page: z.number().optional().default(1).describe('Page number'),
+        limit: z.number().optional().default(20).describe('Results per page (max 1000)')
+    }, async (params) => {
+        try {
+            const result = await dasRequest('getTokenAccounts', params);
+            if (!result.token_accounts || result.token_accounts.length === 0) {
+                return {
+                    content: [{ type: 'text', text: `**Token Accounts**\n\nNo accounts found matching criteria.` }]
+                };
+            }
+            const lines = [`**Token Accounts** (${result.total} total)`, ''];
+            result.token_accounts.forEach((account, i) => {
+                lines.push(`${i + 1}. ${formatAddress(account.address)}`);
+                lines.push(`   Owner: ${formatAddress(account.owner)}`);
+                lines.push(`   Mint: ${formatAddress(account.mint)}`);
+                lines.push(`   Balance: ${account.amount}`);
+            });
+            return {
+                content: [{ type: 'text', text: lines.join('\n') }]
+            };
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `❌ Error: ${errorMsg}` }],
+                isError: true
+            };
+        }
+    });
+}

package/dist/tools/enhanced-transactions.d.ts

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