neutron-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Neutron
+
+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,263 @@
+# Neutron MCP Server
+
+Add Lightning payments, Bitcoin, USDT, and fiat transactions to your applications using AI. This MCP (Model Context Protocol) server connects Neutron's payment infrastructure to AI coding assistants like Claude, Cursor, Windsurf, and Cline.
+
+## What is this?
+
+The Neutron MCP server allows AI assistants to interact with the [Neutron API](https://docs.neutron.me) on your behalf. Simply describe what you want to build, and your AI assistant can:
+
+- Generate Bitcoin and USDT deposit addresses
+- Create Lightning payments (Bolt11, LNURL, Lightning Address)
+- Process Bitcoin on-chain transactions
+- Handle USDT transfers (ERC20/TRC20)
+- Execute fiat payouts (bank transfers, mobile money)
+- Manage webhooks for real-time notifications
+- Check balances and transaction status
+
+## Quick Start
+
+### 1. Get Your API Keys
+
+Sign up at [neutron.me](https://neutron.me) and get your API credentials from the dashboard.
+
+### 2. Install & Configure
+
+Choose your AI tool below:
+
+---
+
+### Claude Desktop
+
+Add to your config file:
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "neutron": {
+      "command": "npx",
+      "args": ["-y", "neutron-mcp"],
+      "env": {
+        "NEUTRON_ACCESS_KEY": "your_access_key",
+        "NEUTRON_SECRET_KEY": "your_secret_key"
+      }
+    }
+  }
+}
+```
+
+---
+
+### Claude Code (CLI)
+
+Add to `~/.claude.json` or your project's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "neutron": {
+      "command": "npx",
+      "args": ["-y", "neutron-mcp"],
+      "env": {
+        "NEUTRON_ACCESS_KEY": "your_access_key",
+        "NEUTRON_SECRET_KEY": "your_secret_key"
+      }
+    }
+  }
+}
+```
+
+---
+
+### Cursor
+
+Add to `.cursor/mcp.json` in your project or global config:
+
+```json
+{
+  "mcpServers": {
+    "neutron": {
+      "command": "npx",
+      "args": ["-y", "neutron-mcp"],
+      "env": {
+        "NEUTRON_ACCESS_KEY": "your_access_key",
+        "NEUTRON_SECRET_KEY": "your_secret_key"
+      }
+    }
+  }
+}
+```
+
+---
+
+### Windsurf
+
+Add to your Windsurf MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "neutron": {
+      "command": "npx",
+      "args": ["-y", "neutron-mcp"],
+      "env": {
+        "NEUTRON_ACCESS_KEY": "your_access_key",
+        "NEUTRON_SECRET_KEY": "your_secret_key"
+      }
+    }
+  }
+}
+```
+
+---
+
+### Cline (VS Code)
+
+Add to your Cline MCP settings:
+
+```json
+{
+  "mcpServers": {
+    "neutron": {
+      "command": "npx",
+      "args": ["-y", "neutron-mcp"],
+      "env": {
+        "NEUTRON_ACCESS_KEY": "your_access_key",
+        "NEUTRON_SECRET_KEY": "your_secret_key"
+      }
+    }
+  }
+}
+```
+
+---
+
+### Global Installation (Alternative)
+
+If you prefer a global install instead of `npx`:
+
+```bash
+npm install -g neutron-mcp
+```
+
+Then use `"command": "neutron-mcp"` instead of `npx` in your config.
+
+---
+
+## Usage Examples
+
+Once configured, just ask your AI assistant naturally:
+
+> "Create a Lightning invoice for 10,000 sats"
+
+> "Show me my wallet balances"
+
+> "Send 0.001 BTC to bc1q..."
+
+> "Pay this Lightning invoice: lnbc..."
+
+> "Generate a Bitcoin deposit address"
+
+> "Set up a webhook for transaction notifications"
+
+> "What banks are supported for payouts in Nigeria?"
+
+---
+
+## Available Tools
+
+### Account Management
+| Tool | Description |
+|------|-------------|
+| `neutron_get_account` | Get account information |
+| `neutron_get_wallets` | List all wallets with balances |
+| `neutron_get_wallet` | Get specific wallet details |
+
+### Receive Addresses
+| Tool | Description |
+|------|-------------|
+| `neutron_get_bitcoin_address` | Generate Bitcoin deposit address |
+| `neutron_get_usdt_address` | Generate USDT address (ERC20 or TRC20) |
+
+### Transactions
+| Tool | Description |
+|------|-------------|
+| `neutron_create_transaction` | Create payment (Lightning, on-chain, USDT, fiat) |
+| `neutron_list_transactions` | List transactions with filters |
+| `neutron_get_transaction` | Get transaction status |
+| `neutron_confirm_transaction` | Confirm pending transaction |
+| `neutron_cancel_transaction` | Cancel pending transaction |
+
+### Webhooks
+| Tool | Description |
+|------|-------------|
+| `neutron_create_webhook` | Register webhook endpoint |
+| `neutron_list_webhooks` | List all webhooks |
+| `neutron_update_webhook` | Update webhook configuration |
+| `neutron_delete_webhook` | Remove webhook |
+
+### Reference Data
+| Tool | Description |
+|------|-------------|
+| `neutron_get_fiat_institutions` | Get banks/mobile money by country |
+
+---
+
+## Supported Payment Methods
+
+| Type | Methods |
+|------|---------|
+| **Bitcoin Lightning** | Bolt11 invoices, LNURL, Lightning Address |
+| **Bitcoin On-chain** | Standard BTC transactions |
+| **Stablecoins** | USDT on Ethereum (ERC20) and Tron (TRC20) |
+| **Fiat Payouts** | Bank transfers, Mobile money |
+
+---
+
+## Example Prompts for Common Tasks
+
+### E-commerce Integration
+> "Help me add Bitcoin Lightning payments to my checkout. When a user clicks pay, generate an invoice for the cart total and show a QR code."
+
+### Subscription Service
+> "Create a payment flow where users can pay $10/month in Bitcoin. Generate a Lightning invoice and set up a webhook to activate their account when paid."
+
+### Payout System
+> "Build a function to pay out earnings to users. They can choose Lightning address, on-chain Bitcoin, or bank transfer in supported countries."
+
+### Treasury Management
+> "Show me all my wallet balances and recent transactions. Then help me consolidate funds by transferring USDT to my main wallet."
+
+---
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `NEUTRON_ACCESS_KEY` | Yes | Your Neutron API access key |
+| `NEUTRON_SECRET_KEY` | Yes | Your Neutron API secret key |
+| `NEUTRON_API_URL` | No | API URL (defaults to `https://api.neutron.me/v2`) |
+
+---
+
+## Security Notes
+
+- Never commit API keys to version control
+- Use environment variables or secure secret management
+- API keys have full access to your Neutron account - keep them safe
+- Consider using separate API keys for development and production
+
+---
+
+## Support
+
+- **Documentation**: [docs.neutron.me](https://docs.neutron.me)
+- **Issues**: [GitHub Issues](https://github.com/neutroncreative/neutron-mcp/issues)
+- **Contact**: support@neutron.me
+
+---
+
+## License
+
+MIT - see [LICENSE](LICENSE) for details.

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,646 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { NeutronClient } from "./neutron-client.js";
+// Validation schemas
+const CreateTransactionSchema = z.object({
+    sourceMethod: z.enum([
+        "lightning",
+        "lightning_address",
+        "lnurl",
+        "bolt11",
+        "on_chain",
+        "eth",
+        "tron",
+        "bank",
+        "mobile_money",
+        "internal",
+    ]),
+    sourceCurrency: z.string(),
+    sourceAmount: z.string().optional(),
+    sourceWalletId: z.string().optional(),
+    destMethod: z.enum([
+        "lightning",
+        "lightning_address",
+        "lnurl",
+        "bolt11",
+        "on_chain",
+        "eth",
+        "tron",
+        "bank",
+        "mobile_money",
+        "internal",
+    ]),
+    destCurrency: z.string(),
+    destAmount: z.string().optional(),
+    destAddress: z.string().optional(),
+    destLightningAddress: z.string().optional(),
+    destBolt11: z.string().optional(),
+    destAccountNumber: z.string().optional(),
+    destBankCode: z.string().optional(),
+    destPhoneNumber: z.string().optional(),
+    destRecipientName: z.string().optional(),
+    destCountry: z.string().optional(),
+    reference: z.string().optional(),
+});
+const ListTransactionsSchema = z.object({
+    status: z
+        .enum(["pending", "processing", "completed", "failed", "cancelled"])
+        .optional(),
+    method: z
+        .enum([
+        "lightning",
+        "lightning_address",
+        "lnurl",
+        "bolt11",
+        "on_chain",
+        "eth",
+        "tron",
+        "bank",
+        "mobile_money",
+        "internal",
+    ])
+        .optional(),
+    currency: z.string().optional(),
+    fromDate: z.string().optional(),
+    toDate: z.string().optional(),
+    limit: z.number().optional(),
+    offset: z.number().optional(),
+});
+const CreateWebhookSchema = z.object({
+    url: z.string().url(),
+    events: z.array(z.enum([
+        "transaction.created",
+        "transaction.completed",
+        "transaction.failed",
+        "transaction.cancelled",
+        "deposit.received",
+        "withdrawal.completed",
+    ])),
+});
+const UpdateWebhookSchema = z.object({
+    webhookId: z.string(),
+    url: z.string().url().optional(),
+    events: z
+        .array(z.enum([
+        "transaction.created",
+        "transaction.completed",
+        "transaction.failed",
+        "transaction.cancelled",
+        "deposit.received",
+        "withdrawal.completed",
+    ]))
+        .optional(),
+    status: z.enum(["active", "inactive"]).optional(),
+});
+// Initialize Neutron client
+function createClient() {
+    const apiUrl = process.env.NEUTRON_API_URL || "https://api.neutron.me/v2";
+    const accessKey = process.env.NEUTRON_ACCESS_KEY;
+    const secretKey = process.env.NEUTRON_SECRET_KEY;
+    if (!accessKey || !secretKey) {
+        throw new Error("NEUTRON_ACCESS_KEY and NEUTRON_SECRET_KEY environment variables are required");
+    }
+    return new NeutronClient({ apiUrl, accessKey, secretKey });
+}
+// Create MCP server
+const server = new Server({
+    name: "neutron-mcp-server",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Tool definitions
+const tools = [
+    {
+        name: "neutron_get_account",
+        description: "Get Neutron account information including name, email, and status",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: "neutron_get_wallets",
+        description: "List all wallets associated with the Neutron account with balances",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: "neutron_get_wallet",
+        description: "Get details of a specific wallet by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                walletId: {
+                    type: "string",
+                    description: "The wallet ID to retrieve",
+                },
+            },
+            required: ["walletId"],
+        },
+    },
+    {
+        name: "neutron_get_bitcoin_address",
+        description: "Generate a Bitcoin receive address for deposits",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: "neutron_get_usdt_address",
+        description: "Generate a USDT receive address for deposits (ERC20 or TRC20)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                network: {
+                    type: "string",
+                    enum: ["eth", "tron"],
+                    description: "Network for USDT address (eth for ERC20, tron for TRC20)",
+                    default: "tron",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "neutron_create_transaction",
+        description: `Create a new transaction. Supports Lightning payments (bolt11, LNURL, Lightning Address), Bitcoin on-chain, USDT (ERC20/TRC20), and fiat payouts (bank, mobile money).
+
+Examples:
+- Lightning payment: sourceMethod="internal", destMethod="lightning_address", destLightningAddress="user@wallet.me"
+- Bitcoin withdrawal: sourceMethod="internal", destMethod="on_chain", destAddress="bc1q..."
+- USDT transfer: sourceMethod="internal", destMethod="tron", destAddress="T..."
+- Bank payout: sourceMethod="internal", destMethod="bank", destAccountNumber="...", destBankCode="...", destRecipientName="..."`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                sourceMethod: {
+                    type: "string",
+                    enum: [
+                        "lightning",
+                        "lightning_address",
+                        "lnurl",
+                        "bolt11",
+                        "on_chain",
+                        "eth",
+                        "tron",
+                        "bank",
+                        "mobile_money",
+                        "internal",
+                    ],
+                    description: "Source funding method",
+                },
+                sourceCurrency: {
+                    type: "string",
+                    description: "Source currency (BTC, USDT, USD, etc.)",
+                },
+                sourceAmount: {
+                    type: "string",
+                    description: "Amount to send from source (optional if destAmount specified)",
+                },
+                sourceWalletId: {
+                    type: "string",
+                    description: "Specific wallet ID to fund from (optional)",
+                },
+                destMethod: {
+                    type: "string",
+                    enum: [
+                        "lightning",
+                        "lightning_address",
+                        "lnurl",
+                        "bolt11",
+                        "on_chain",
+                        "eth",
+                        "tron",
+                        "bank",
+                        "mobile_money",
+                        "internal",
+                    ],
+                    description: "Destination payout method",
+                },
+                destCurrency: {
+                    type: "string",
+                    description: "Destination currency",
+                },
+                destAmount: {
+                    type: "string",
+                    description: "Amount to receive at destination (optional if sourceAmount specified)",
+                },
+                destAddress: {
+                    type: "string",
+                    description: "Destination address (for on_chain, eth, tron)",
+                },
+                destLightningAddress: {
+                    type: "string",
+                    description: "Lightning address (e.g., user@wallet.me)",
+                },
+                destBolt11: {
+                    type: "string",
+                    description: "Bolt11 Lightning invoice to pay",
+                },
+                destAccountNumber: {
+                    type: "string",
+                    description: "Bank account number (for bank payouts)",
+                },
+                destBankCode: {
+                    type: "string",
+                    description: "Bank code/routing number",
+                },
+                destPhoneNumber: {
+                    type: "string",
+                    description: "Phone number (for mobile money)",
+                },
+                destRecipientName: {
+                    type: "string",
+                    description: "Recipient name for fiat payouts",
+                },
+                destCountry: {
+                    type: "string",
+                    description: "Destination country code (ISO 3166-1 alpha-2)",
+                },
+                reference: {
+                    type: "string",
+                    description: "Custom reference ID for the transaction",
+                },
+            },
+            required: ["sourceMethod", "sourceCurrency", "destMethod", "destCurrency"],
+        },
+    },
+    {
+        name: "neutron_list_transactions",
+        description: "List transactions with optional filtering by status, method, currency, and date range",
+        inputSchema: {
+            type: "object",
+            properties: {
+                status: {
+                    type: "string",
+                    enum: ["pending", "processing", "completed", "failed", "cancelled"],
+                    description: "Filter by transaction status",
+                },
+                method: {
+                    type: "string",
+                    enum: [
+                        "lightning",
+                        "lightning_address",
+                        "lnurl",
+                        "bolt11",
+                        "on_chain",
+                        "eth",
+                        "tron",
+                        "bank",
+                        "mobile_money",
+                        "internal",
+                    ],
+                    description: "Filter by transaction method",
+                },
+                currency: {
+                    type: "string",
+                    description: "Filter by currency",
+                },
+                fromDate: {
+                    type: "string",
+                    description: "Start date (ISO 8601 format)",
+                },
+                toDate: {
+                    type: "string",
+                    description: "End date (ISO 8601 format)",
+                },
+                limit: {
+                    type: "number",
+                    description: "Number of results to return (default 20)",
+                },
+                offset: {
+                    type: "number",
+                    description: "Offset for pagination",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "neutron_get_transaction",
+        description: "Get the status and details of a specific transaction",
+        inputSchema: {
+            type: "object",
+            properties: {
+                transactionId: {
+                    type: "string",
+                    description: "The transaction ID to check",
+                },
+            },
+            required: ["transactionId"],
+        },
+    },
+    {
+        name: "neutron_confirm_transaction",
+        description: "Confirm a pending transaction to proceed with execution",
+        inputSchema: {
+            type: "object",
+            properties: {
+                transactionId: {
+                    type: "string",
+                    description: "The transaction ID to confirm",
+                },
+            },
+            required: ["transactionId"],
+        },
+    },
+    {
+        name: "neutron_cancel_transaction",
+        description: "Cancel a pending transaction",
+        inputSchema: {
+            type: "object",
+            properties: {
+                transactionId: {
+                    type: "string",
+                    description: "The transaction ID to cancel",
+                },
+            },
+            required: ["transactionId"],
+        },
+    },
+    {
+        name: "neutron_create_webhook",
+        description: "Create a webhook to receive event notifications",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "The webhook endpoint URL",
+                },
+                events: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                        enum: [
+                            "transaction.created",
+                            "transaction.completed",
+                            "transaction.failed",
+                            "transaction.cancelled",
+                            "deposit.received",
+                            "withdrawal.completed",
+                        ],
+                    },
+                    description: "Events to subscribe to",
+                },
+            },
+            required: ["url", "events"],
+        },
+    },
+    {
+        name: "neutron_list_webhooks",
+        description: "List all registered webhooks",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: "neutron_update_webhook",
+        description: "Update a webhook configuration",
+        inputSchema: {
+            type: "object",
+            properties: {
+                webhookId: {
+                    type: "string",
+                    description: "The webhook ID to update",
+                },
+                url: {
+                    type: "string",
+                    description: "New webhook URL",
+                },
+                events: {
+                    type: "array",
+                    items: {
+                        type: "string",
+                        enum: [
+                            "transaction.created",
+                            "transaction.completed",
+                            "transaction.failed",
+                            "transaction.cancelled",
+                            "deposit.received",
+                            "withdrawal.completed",
+                        ],
+                    },
+                    description: "New events to subscribe to",
+                },
+                status: {
+                    type: "string",
+                    enum: ["active", "inactive"],
+                    description: "Webhook status",
+                },
+            },
+            required: ["webhookId"],
+        },
+    },
+    {
+        name: "neutron_delete_webhook",
+        description: "Delete a webhook",
+        inputSchema: {
+            type: "object",
+            properties: {
+                webhookId: {
+                    type: "string",
+                    description: "The webhook ID to delete",
+                },
+            },
+            required: ["webhookId"],
+        },
+    },
+    {
+        name: "neutron_get_fiat_institutions",
+        description: "Get list of supported fiat institutions (banks, mobile money) for a country",
+        inputSchema: {
+            type: "object",
+            properties: {
+                country: {
+                    type: "string",
+                    description: "Country code (ISO 3166-1 alpha-2, e.g., NG, KE, GH)",
+                },
+            },
+            required: ["country"],
+        },
+    },
+];
+// Handle list tools request
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools };
+});
+// Handle tool execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const client = createClient();
+    try {
+        switch (name) {
+            case "neutron_get_account": {
+                const account = await client.getAccount();
+                return {
+                    content: [{ type: "text", text: JSON.stringify(account, null, 2) }],
+                };
+            }
+            case "neutron_get_wallets": {
+                const wallets = await client.getWallets();
+                return {
+                    content: [{ type: "text", text: JSON.stringify(wallets, null, 2) }],
+                };
+            }
+            case "neutron_get_wallet": {
+                const { walletId } = args;
+                const wallet = await client.getWallet(walletId);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(wallet, null, 2) }],
+                };
+            }
+            case "neutron_get_bitcoin_address": {
+                const address = await client.getBitcoinAddress();
+                return {
+                    content: [{ type: "text", text: JSON.stringify(address, null, 2) }],
+                };
+            }
+            case "neutron_get_usdt_address": {
+                const { network } = args;
+                const address = await client.getUsdtAddress(network);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(address, null, 2) }],
+                };
+            }
+            case "neutron_create_transaction": {
+                const validated = CreateTransactionSchema.parse(args);
+                const transaction = await client.createTransaction({
+                    sourceReq: {
+                        method: validated.sourceMethod,
+                        currency: validated.sourceCurrency,
+                        amount: validated.sourceAmount,
+                        walletId: validated.sourceWalletId,
+                    },
+                    destReq: {
+                        method: validated.destMethod,
+                        currency: validated.destCurrency,
+                        amount: validated.destAmount,
+                        address: validated.destAddress,
+                        lightningAddress: validated.destLightningAddress,
+                        bolt11: validated.destBolt11,
+                        accountNumber: validated.destAccountNumber,
+                        bankCode: validated.destBankCode,
+                        phoneNumber: validated.destPhoneNumber,
+                        recipientName: validated.destRecipientName,
+                        country: validated.destCountry,
+                    },
+                    reference: validated.reference,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(transaction, null, 2) }],
+                };
+            }
+            case "neutron_list_transactions": {
+                const validated = ListTransactionsSchema.parse(args);
+                const transactions = await client.getTransactions({
+                    status: validated.status,
+                    method: validated.method,
+                    currency: validated.currency,
+                    fromDate: validated.fromDate,
+                    toDate: validated.toDate,
+                    limit: validated.limit,
+                    offset: validated.offset,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(transactions, null, 2) }],
+                };
+            }
+            case "neutron_get_transaction": {
+                const { transactionId } = args;
+                const transaction = await client.getTransactionStatus(transactionId);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(transaction, null, 2) }],
+                };
+            }
+            case "neutron_confirm_transaction": {
+                const { transactionId } = args;
+                const transaction = await client.confirmTransaction(transactionId);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(transaction, null, 2) }],
+                };
+            }
+            case "neutron_cancel_transaction": {
+                const { transactionId } = args;
+                const transaction = await client.cancelTransaction(transactionId);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(transaction, null, 2) }],
+                };
+            }
+            case "neutron_create_webhook": {
+                const validated = CreateWebhookSchema.parse(args);
+                const webhook = await client.createWebhook({
+                    url: validated.url,
+                    events: validated.events,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(webhook, null, 2) }],
+                };
+            }
+            case "neutron_list_webhooks": {
+                const webhooks = await client.getWebhooks();
+                return {
+                    content: [{ type: "text", text: JSON.stringify(webhooks, null, 2) }],
+                };
+            }
+            case "neutron_update_webhook": {
+                const validated = UpdateWebhookSchema.parse(args);
+                const webhook = await client.updateWebhook(validated.webhookId, {
+                    url: validated.url,
+                    events: validated.events,
+                    status: validated.status,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(webhook, null, 2) }],
+                };
+            }
+            case "neutron_delete_webhook": {
+                const { webhookId } = args;
+                await client.deleteWebhook(webhookId);
+                return {
+                    content: [{ type: "text", text: `Webhook ${webhookId} deleted successfully` }],
+                };
+            }
+            case "neutron_get_fiat_institutions": {
+                const { country } = args;
+                const institutions = await client.getFiatInstitutions(country);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(institutions, null, 2) }],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Neutron MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/neutron-client.d.ts

@@ -0,0 +1,25 @@
+import type { NeutronConfig, Account, Wallet, ReceiveAddress, Transaction, CreateTransactionRequest, TransactionListParams, TransactionListResponse, Webhook, CreateWebhookRequest, UpdateWebhookRequest, FiatInstitution } from "./types.js";
+export declare class NeutronClient {
+    private config;
+    private token;
+    private tokenExpiry;
+    constructor(config: NeutronConfig);
+    private generateSignature;
+    private request;
+    authenticate(): Promise<void>;
+    getAccount(): Promise<Account>;
+    getWallets(): Promise<Wallet[]>;
+    getWallet(walletId: string): Promise<Wallet>;
+    getBitcoinAddress(): Promise<ReceiveAddress>;
+    getUsdtAddress(network?: "eth" | "tron"): Promise<ReceiveAddress>;
+    createTransaction(request: CreateTransactionRequest): Promise<Transaction>;
+    getTransactions(params?: TransactionListParams): Promise<TransactionListResponse>;
+    getTransactionStatus(transactionId: string): Promise<Transaction>;
+    confirmTransaction(transactionId: string): Promise<Transaction>;
+    cancelTransaction(transactionId: string): Promise<Transaction>;
+    createWebhook(request: CreateWebhookRequest): Promise<Webhook>;
+    getWebhooks(): Promise<Webhook[]>;
+    updateWebhook(webhookId: string, request: UpdateWebhookRequest): Promise<Webhook>;
+    deleteWebhook(webhookId: string): Promise<void>;
+    getFiatInstitutions(country: string): Promise<FiatInstitution[]>;
+}

package/dist/neutron-client.js

@@ -0,0 +1,110 @@
+import crypto from "crypto";
+export class NeutronClient {
+    config;
+    token = null;
+    tokenExpiry = 0;
+    constructor(config) {
+        this.config = config;
+    }
+    generateSignature(method, path, timestamp, body) {
+        const payload = `${method}${path}${timestamp}${body || ""}`;
+        return crypto
+            .createHmac("sha256", this.config.secretKey)
+            .update(payload)
+            .digest("hex");
+    }
+    async request(method, path, body) {
+        const timestamp = Date.now().toString();
+        const bodyString = body ? JSON.stringify(body) : undefined;
+        const signature = this.generateSignature(method, path, timestamp, bodyString);
+        const headers = {
+            "Content-Type": "application/json",
+            "X-Access-Key": this.config.accessKey,
+            "X-Timestamp": timestamp,
+            "X-Signature": signature,
+        };
+        // Add bearer token if authenticated
+        if (this.token && Date.now() < this.tokenExpiry) {
+            headers["Authorization"] = `Bearer ${this.token}`;
+        }
+        const response = await fetch(`${this.config.apiUrl}${path}`, {
+            method,
+            headers,
+            body: bodyString,
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            throw new Error(`API Error: ${response.status} - ${error.message || response.statusText}`);
+        }
+        const result = (await response.json());
+        if (!result.success && result.error) {
+            throw new Error(`${result.error.code}: ${result.error.message}`);
+        }
+        return result.data;
+    }
+    // Authentication
+    async authenticate() {
+        const result = await this.request("POST", "/authenticate");
+        this.token = result.token;
+        this.tokenExpiry = Date.now() + result.expiresIn * 1000;
+    }
+    // Account Management
+    async getAccount() {
+        return this.request("GET", "/account");
+    }
+    async getWallets() {
+        return this.request("GET", "/account/wallets");
+    }
+    async getWallet(walletId) {
+        return this.request("GET", `/wallet/${walletId}`);
+    }
+    // Receive Addresses
+    async getBitcoinAddress() {
+        return this.request("GET", "/bitcoin/receive-address");
+    }
+    async getUsdtAddress(network = "tron") {
+        return this.request("GET", `/usdt/receive-address?network=${network}`);
+    }
+    // Transactions
+    async createTransaction(request) {
+        return this.request("POST", "/transaction", request);
+    }
+    async getTransactions(params) {
+        const queryParams = new URLSearchParams();
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    queryParams.append(key, String(value));
+                }
+            });
+        }
+        const query = queryParams.toString();
+        return this.request("GET", `/transactions${query ? `?${query}` : ""}`);
+    }
+    async getTransactionStatus(transactionId) {
+        return this.request("GET", `/transaction/${transactionId}/status`);
+    }
+    async confirmTransaction(transactionId) {
+        return this.request("PUT", `/transaction/${transactionId}/confirm`);
+    }
+    async cancelTransaction(transactionId) {
+        return this.request("PATCH", `/transaction/${transactionId}`);
+    }
+    // Webhooks
+    async createWebhook(request) {
+        return this.request("POST", "/webhook", request);
+    }
+    async getWebhooks() {
+        return this.request("GET", "/webhooks");
+    }
+    async updateWebhook(webhookId, request) {
+        return this.request("PUT", `/webhook/${webhookId}`, request);
+    }
+    async deleteWebhook(webhookId) {
+        await this.request("DELETE", `/webhook/${webhookId}`);
+    }
+    // Reference Data
+    async getFiatInstitutions(country) {
+        return this.request("GET", `/fiat-institutions/${country}`);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,126 @@
+export interface NeutronConfig {
+    apiUrl: string;
+    accessKey: string;
+    secretKey: string;
+}
+export interface Account {
+    id: string;
+    name: string;
+    email: string;
+    status: string;
+    createdAt: string;
+}
+export interface Wallet {
+    id: string;
+    currency: string;
+    balance: string;
+    availableBalance: string;
+    status: string;
+}
+export interface ReceiveAddress {
+    address: string;
+    currency: string;
+    network?: string;
+    expiresAt?: string;
+}
+export type TransactionMethod = "lightning" | "lightning_address" | "lnurl" | "bolt11" | "on_chain" | "eth" | "tron" | "bank" | "mobile_money" | "internal";
+export type TransactionStatus = "pending" | "processing" | "completed" | "failed" | "cancelled";
+export interface TransactionSource {
+    method: TransactionMethod;
+    currency: string;
+    amount?: string;
+    walletId?: string;
+}
+export interface TransactionDestination {
+    method: TransactionMethod;
+    currency: string;
+    amount?: string;
+    address?: string;
+    lightningAddress?: string;
+    bolt11?: string;
+    accountNumber?: string;
+    bankCode?: string;
+    phoneNumber?: string;
+    recipientName?: string;
+    country?: string;
+}
+export interface CreateTransactionRequest {
+    sourceReq: TransactionSource;
+    destReq: TransactionDestination;
+    reference?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface Transaction {
+    id: string;
+    reference: string;
+    status: TransactionStatus;
+    source: {
+        method: TransactionMethod;
+        currency: string;
+        amount: string;
+    };
+    destination: {
+        method: TransactionMethod;
+        currency: string;
+        amount: string;
+        address?: string;
+    };
+    fees: {
+        amount: string;
+        currency: string;
+    };
+    exchangeRate?: string;
+    paymentRequest?: string;
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TransactionListParams {
+    status?: TransactionStatus;
+    method?: TransactionMethod;
+    currency?: string;
+    fromDate?: string;
+    toDate?: string;
+    limit?: number;
+    offset?: number;
+}
+export interface TransactionListResponse {
+    transactions: Transaction[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+export type WebhookEvent = "transaction.created" | "transaction.completed" | "transaction.failed" | "transaction.cancelled" | "deposit.received" | "withdrawal.completed";
+export interface Webhook {
+    id: string;
+    url: string;
+    events: WebhookEvent[];
+    secret: string;
+    status: "active" | "inactive";
+    createdAt: string;
+}
+export interface CreateWebhookRequest {
+    url: string;
+    events: WebhookEvent[];
+}
+export interface UpdateWebhookRequest {
+    url?: string;
+    events?: WebhookEvent[];
+    status?: "active" | "inactive";
+}
+export interface FiatInstitution {
+    code: string;
+    name: string;
+    country: string;
+    type: "bank" | "mobile_money";
+    supportedCurrencies: string[];
+}
+export interface ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+    };
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+// Neutron API Types
+export {};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "neutron-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Neutron - Lightning payments, Bitcoin, USDT, and fiat transactions for AI-powered applications",
+  "main": "dist/index.js",
+  "bin": {
+    "neutron-mcp": "dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "neutron",
+    "neutronpay",
+    "lightning",
+    "bitcoin",
+    "payments",
+    "usdt",
+    "stablecoin",
+    "fintech",
+    "ai",
+    "claude",
+    "cursor",
+    "windsurf",
+    "cline"
+  ],
+  "author": "Neutron <support@neutron.me>",
+  "license": "MIT",
+  "homepage": "https://neutron.me",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/neutroncreative/neutron-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/neutroncreative/neutron-mcp/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
+  }
+}