agenticbtc-mcp 1.0.1

package/README.md

@@ -0,0 +1,205 @@
+# AgenticBTC - Bitcoin Lightning MCP Server
+
+🚀 **Enable Claude Desktop to send Bitcoin payments, access L402 APIs, and manage Lightning wallets.**
+
+AgenticBTC provides a Model Context Protocol (MCP) server that gives Claude Desktop direct access to Bitcoin and Lightning Network functionality. Your AI assistant can now make payments, create wallets, and interact with Lightning-powered APIs automatically.
+
+## ⚡ Quick Start
+
+```bash
+# Install and setup in one command
+npx agenticbtc setup
+
+# Check if everything is working
+npx agenticbtc status
+```
+
+Then restart Claude Desktop and start using Bitcoin with your AI assistant!
+
+## 🎯 What It Does
+
+- **💰 Wallet Management**: Create and check Bitcoin wallets for AI agents
+- **⚡ Lightning Payments**: Send instant, low-fee Bitcoin payments via Lightning Network
+- **🔐 L402 APIs**: Access premium APIs that charge per request using Lightning micropayments
+- **📊 Node Management**: Monitor Lightning node status and connectivity
+- **🤖 Claude Integration**: Seamless setup with Claude Desktop's MCP system
+
+## 🛠️ Installation
+
+### Method 1: NPX (Recommended)
+```bash
+npx agentbtc setup
+```
+
+### Method 2: Global Install
+```bash
+npm install -g agentbtc
+agentbtc setup
+```
+
+## 📋 Prerequisites
+
+1. **AgentBTC API Server** - Running at `http://localhost:8000` or custom URL
+2. **API Key** - From your AgentBTC server
+3. **Lightning Node** (Optional) - For L402 API access and direct payments
+
+## 🔧 Configuration
+
+### Interactive Setup
+```bash
+npx agentbtc setup
+```
+
+This will ask for:
+- **API URL** (default: `http://localhost:8000`)
+- **API Key** (required)
+- **Lightning Node Host** (optional, for L402 APIs)
+- **LND Macaroon** (optional, hex format)
+
+### Manual Configuration
+
+Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on Mac):
+
+```json
+{
+  "mcpServers": {
+    "agentbtc": {
+      "command": "npx",
+      "args": ["agentbtc", "server"],
+      "env": {
+        "AGENTBTC_API_URL": "http://localhost:8000",
+        "AGENTBTC_API_KEY": "your-api-key",
+        "AGENTBTC_LND_HOST": "https://your-lnd-node:8080",
+        "AGENTBTC_LND_MACAROON": "your-lnd-macaroon-hex",
+        "NODE_TLS_REJECT_UNAUTHORIZED": "0"
+      }
+    }
+  }
+}
+```
+
+## 🎮 Usage Examples
+
+Once configured, you can ask Claude Desktop:
+
+### Basic Wallet Operations
+```
+"Create a Bitcoin wallet called 'my-assistant'"
+"Check the balance of agent wallet abc123"
+```
+
+### Lightning Payments  
+```
+"Pay this Lightning invoice: lnbc..."
+"Send 1000 sats to this invoice with a 50 sat fee limit"
+```
+
+### L402 API Access
+```
+"Get Bitcoin market data using L402"
+"Access the premium AI service API"
+"Show me data from the L402 protected endpoint"
+```
+
+### Node Information
+```
+"Show my Lightning node status"
+"Get node info and channel count"
+```
+
+## 🔍 Commands
+
+| Command | Description |
+|---------|-------------|
+| `agentbtc setup` | Interactive setup for Claude Desktop |
+| `agentbtc server` | Start MCP server (used internally by Claude) |
+| `agentbtc status` | Check configuration and connectivity |
+| `agentbtc --help` | Show help information |
+
+## 🌍 Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `AGENTBTC_API_URL` | AgentBTC API endpoint | `http://localhost:8000` |
+| `AGENTBTC_API_KEY` | AgentBTC API key | *Required* |
+| `AGENTBTC_LND_HOST` | Lightning node REST API | *Optional* |
+| `AGENTBTC_LND_MACAROON` | LND macaroon (hex format) | *Optional* |
+| `NODE_TLS_REJECT_UNAUTHORIZED` | Skip TLS verification | `0` |
+
+## 🔧 Troubleshooting
+
+### Check Status
+```bash
+npx agentbtc status
+```
+
+### Common Issues
+
+**❌ API Connection Failed**
+- Verify your AgentBTC server is running
+- Check the API URL and key
+- Ensure firewall allows connections
+
+**❌ Lightning Node Connection Failed**  
+- Verify LND REST API is accessible
+- Check macaroon permissions (needs `invoices:read`, `invoices:write`)
+- Confirm TLS certificates if using HTTPS
+
+**❌ Claude Desktop Not Loading Server**
+- Restart Claude Desktop after setup
+- Check `claude_desktop_config.json` syntax
+- Verify file permissions
+
+### Config File Locations
+
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json` 
+- **Linux**: `~/.config/claude/claude_desktop_config.json`
+
+## 🏗️ Development
+
+### Local Testing
+```bash
+git clone <repo>
+cd agentbtc/npm-package
+node bin/agentbtc.js --help
+node bin/agentbtc.js status
+```
+
+### Project Structure
+```
+agentbtc/
+├── bin/
+│   └── agentbtc.js          # CLI entry point
+├── src/
+│   └── server.js            # MCP server implementation  
+├── package.json
+└── README.md
+```
+
+## 📝 License
+
+MIT License - see LICENSE file for details.
+
+## 🔗 Links
+
+- **Repository**: https://github.com/agentbtc/agentbtc
+- **Issues**: https://github.com/agentbtc/agentbtc/issues
+- **Model Context Protocol**: https://modelcontextprotocol.io
+- **Claude Desktop**: https://claude.ai/desktop
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable  
+5. Submit a pull request
+
+---
+
+**🎉 Ready to give your AI assistant Bitcoin superpowers?**
+
+```bash
+npx agentbtc setup
+```

package/bin/agentbtc.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { createInterface } from "readline";
+import { homedir } from "os";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const command = process.argv[2];
+
+// Cross-platform Claude Desktop config path
+function getClaudeConfigPath() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  } else if (platform === "win32") {
+    return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  } else {
+    // Linux/other
+    return join(homedir(), ".config", "claude", "claude_desktop_config.json");
+  }
+}
+
+// Interactive prompt helper
+function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// Check if API is reachable
+async function checkApi(apiUrl, apiKey) {
+  try {
+    const response = await fetch(`${apiUrl}/health`, {
+      headers: apiKey ? { "X-API-Key": apiKey } : {}
+    });
+    return { status: response.status, ok: response.ok };
+  } catch (error) {
+    return { status: 0, ok: false, error: error.message };
+  }
+}
+
+// Commands
+async function setup() {
+  console.log("🚀 AgentBTC Setup\n");
+  
+  // Get configuration from user
+  const apiUrl = await prompt(`AgentBTC API URL (http://localhost:8000): `) || "http://localhost:8000";
+  const apiKey = await prompt("AgentBTC API Key: ");
+  
+  if (!apiKey) {
+    console.log("❌ API Key is required");
+    process.exit(1);
+  }
+  
+  console.log("\n⚡ Lightning Node Configuration (optional):");
+  const lndHost = await prompt("LND REST API Host (optional): ");
+  const lndMacaroon = await prompt("LND Macaroon (hex, optional): ");
+  
+  // Test API connection
+  console.log("\n🔄 Testing API connection...");
+  const apiTest = await checkApi(apiUrl, apiKey);
+  if (!apiTest.ok) {
+    console.log(`⚠️  Warning: Cannot reach API at ${apiUrl} (${apiTest.status})`);
+    if (apiTest.error) {
+      console.log(`   Error: ${apiTest.error}`);
+    }
+  } else {
+    console.log("✅ API connection successful");
+  }
+  
+  // Prepare Claude Desktop config
+  const configPath = getClaudeConfigPath();
+  let config = { mcpServers: {} };
+  
+  // Load existing config if it exists
+  if (existsSync(configPath)) {
+    try {
+      const existing = readFileSync(configPath, "utf8");
+      config = JSON.parse(existing);
+      if (!config.mcpServers) {
+        config.mcpServers = {};
+      }
+    } catch (error) {
+      console.log(`⚠️  Warning: Could not parse existing config: ${error.message}`);
+    }
+  }
+  
+  // Add AgentBTC server config
+  const serverConfig = {
+    command: "npx",
+    args: ["agentbtc", "server"],
+    env: {
+      AGENTBTC_API_URL: apiUrl,
+      AGENTBTC_API_KEY: apiKey,
+      NODE_TLS_REJECT_UNAUTHORIZED: "0"
+    }
+  };
+  
+  if (lndHost) {
+    serverConfig.env.AGENTBTC_LND_HOST = lndHost;
+  }
+  if (lndMacaroon) {
+    serverConfig.env.AGENTBTC_LND_MACAROON = lndMacaroon;
+  }
+  
+  config.mcpServers.agentbtc = serverConfig;
+  
+  // Create config directory if needed
+  try {
+    const configDir = dirname(configPath);
+    if (!existsSync(configDir)) {
+      const { mkdirSync } = await import("fs");
+      mkdirSync(configDir, { recursive: true });
+    }
+  } catch (error) {
+    console.log(`❌ Could not create config directory: ${error.message}`);
+    process.exit(1);
+  }
+  
+  // Write config
+  try {
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log(`\n✅ Configuration saved to: ${configPath}`);
+  } catch (error) {
+    console.log(`❌ Could not write config: ${error.message}`);
+    process.exit(1);
+  }
+  
+  console.log("\n🎉 Setup complete!");
+  console.log("💡 Restart Claude Desktop to load the AgentBTC server.");
+  console.log("🔧 Test with: agentbtc status");
+}
+
+async function status() {
+  const apiUrl = process.env.AGENTBTC_API_URL || "http://localhost:8000";
+  const apiKey = process.env.AGENTBTC_API_KEY || "";
+  const lndHost = process.env.AGENTBTC_LND_HOST || "";
+  
+  console.log("📊 AgentBTC Status\n");
+  
+  // Configuration
+  console.log("Configuration:");
+  console.log(`  API URL: ${apiUrl}`);
+  console.log(`  API Key: ${apiKey ? "✅ Set" : "❌ Not set"}`);
+  console.log(`  LND Host: ${lndHost || "❌ Not configured"}`);
+  console.log(`  LND Macaroon: ${process.env.AGENTBTC_LND_MACAROON ? "✅ Set" : "❌ Not set"}`);
+  
+  // API connectivity
+  console.log("\n🔄 Testing API connection...");
+  const apiTest = await checkApi(apiUrl, apiKey);
+  if (apiTest.ok) {
+    console.log("✅ API connection successful");
+  } else {
+    console.log(`❌ API connection failed (${apiTest.status})`);
+    if (apiTest.error) {
+      console.log(`   Error: ${apiTest.error}`);
+    }
+  }
+  
+  // LND connectivity (if configured)
+  if (lndHost && process.env.AGENTBTC_LND_MACAROON) {
+    console.log("\n🔄 Testing LND connection...");
+    try {
+      const lndRes = await fetch(`${lndHost}/v1/getinfo`, {
+        headers: { "Grpc-Metadata-macaroon": process.env.AGENTBTC_LND_MACAROON }
+      });
+      if (lndRes.ok) {
+        const lndData = await lndRes.json();
+        console.log("⚡ LND connection successful");
+        console.log(`   Node: ${lndData.alias} (${lndData.identity_pubkey?.slice(0, 20)}...)`);
+        console.log(`   Channels: ${lndData.num_active_channels}`);
+      } else {
+        console.log(`❌ LND connection failed (${lndRes.status})`);
+      }
+    } catch (error) {
+      console.log(`❌ LND connection error: ${error.message}`);
+    }
+  }
+  
+  // Claude Desktop config
+  const configPath = getClaudeConfigPath();
+  console.log(`\n🔧 Claude Desktop config: ${configPath}`);
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf8"));
+      if (config.mcpServers?.agentbtc) {
+        console.log("✅ AgentBTC server configured in Claude Desktop");
+      } else {
+        console.log("⚠️  AgentBTC server not found in Claude Desktop config");
+        console.log("   Run: agentbtc setup");
+      }
+    } catch (error) {
+      console.log(`❌ Could not read config: ${error.message}`);
+    }
+  } else {
+    console.log("❌ Claude Desktop config not found");
+    console.log("   Run: agentbtc setup");
+  }
+}
+
+function server() {
+  // Import and start the MCP server
+  import("../src/server.js");
+}
+
+function help() {
+  console.log(`
+🚀 AgentBTC - Bitcoin Lightning MCP Server for AI Agents
+
+Usage:
+  agentbtc start          Get started with AgentBTC (interactive setup)
+  agentbtc setup          Interactive setup for Claude Desktop
+  agentbtc server         Start the MCP server (used by Claude Desktop)
+  agentbtc status         Check configuration and connectivity
+  agentbtc --help         Show this help message
+
+Examples:
+  npx agentbtc start      # Get started - first-time setup
+  agentbtc status         # Check if everything is working
+
+Environment Variables:
+  AGENTBTC_API_URL        AgentBTC API endpoint (default: http://localhost:8000)
+  AGENTBTC_API_KEY        AgentBTC API key (required)
+  AGENTBTC_LND_HOST       Lightning node REST API host (optional)
+  AGENTBTC_LND_MACAROON   Lightning node macaroon in hex (optional)
+
+More info: https://agenticbtc.app
+`);
+}
+
+// Route commands
+switch (command) {
+  case "start":
+  case "setup":
+    setup().catch(console.error);
+    break;
+  case "server":
+    server();
+    break;
+  case "status":
+    status().catch(console.error);
+    break;
+  case "--help":
+  case "help":
+  case undefined:
+    help();
+    break;
+  default:
+    console.log(`Unknown command: ${command}`);
+    console.log("Run 'agentbtc --help' for usage information.");
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "agenticbtc-mcp",
+  "version": "1.0.1",
+  "description": "Privacy-intelligent payments for AI agents — your privacy, your choice. Universal payment router with Lightning, Strike, Coinbase, PayPal, Venmo support.",
+  "keywords": [
+    "bitcoin",
+    "lightning",
+    "mcp",
+    "ai-agent",
+    "l402",
+    "claude",
+    "payments",
+    "cryptocurrency"
+  ],
+  "type": "module",
+  "main": "src/server.js",
+  "bin": {
+    "agenticbtc-mcp": "bin/agentbtc.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bkblocksolutions-rgb/agenticbtc-mcp.git"
+  },
+  "homepage": "https://agenticbtc.io",
+  "bugs": {
+    "url": "https://github.com/bkblocksolutions-rgb/agenticbtc-mcp/issues"
+  },
+  "author": {
+    "name": "AgenticBTC",
+    "url": "https://agenticbtc.io"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.22.0"
+  },
+  "scripts": {
+    "start": "node src/server.js",
+    "test": "node bin/agenticbtc.js --help"
+  }
+}

package/src/server.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+/**
+ * AgentBTC MCP Server
+ * Exposes Bitcoin payment capabilities to Claude Desktop via Model Context Protocol.
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+const API_URL = process.env.AGENTBTC_API_URL || "http://localhost:8000";
+const API_KEY = process.env.AGENTBTC_API_KEY || "";
+const LND_HOST = process.env.AGENTBTC_LND_HOST || "";
+const LND_MACAROON = process.env.AGENTBTC_LND_MACAROON || "";
+
+// BK Block routing node — all payments route through this node as first hop
+// Routing fee: 0.5% (5000ppm) + 1 sat base
+const BK_BLOCK_NODE_PUBKEY = process.env.BK_BLOCK_NODE_PUBKEY || "031aef3a70c08a6e2d96ba1c78eec66092723cdc41d546329df3f065b0f200bd3b";
+const ROUTING_REPORT_URL = process.env.AGENTBTC_ROUTING_REPORT_URL || `${API_URL}/api/v1/routing/report`;
+
+// Report a payment to the verification API
+async function reportPayment(paymentHash, amountSats, destinationPubkey, routeHops) {
+  try {
+    await fetch(ROUTING_REPORT_URL, {
+      method: "POST",
+      headers: {
+        "X-API-Key": API_KEY,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        payment_hash: paymentHash,
+        amount_sats: amountSats,
+        destination_pubkey: destinationPubkey || "",
+        route_hops: routeHops || [BK_BLOCK_NODE_PUBKEY],
+      }),
+    });
+  } catch (e) {
+    // Silent fail — don't block payments if reporting is down
+  }
+}
+
+// Check routing status before payment
+async function checkRoutingStatus() {
+  try {
+    const res = await fetch(`${API_URL}/api/v1/routing/status`, {
+      headers: { "X-API-Key": API_KEY },
+    });
+    if (res.status === 200) {
+      const data = await res.json();
+      return data.status || "active";
+    }
+  } catch (e) {
+    // If check fails, allow payment (fail open)
+  }
+  return "active";
+}
+
+const server = new McpServer({
+  name: "agentbtc",
+  version: "1.0.0",
+});
+
+// Helper for API calls
+async function apiCall(path, options = {}) {
+  const url = `${API_URL}${path}`;
+  const headers = {
+    "X-API-Key": options.apiKey || API_KEY,
+    "Content-Type": "application/json",
+    ...options.headers,
+  };
+  const res = await fetch(url, { ...options, headers });
+  const data = await res.json();
+  return { status: res.status, data };
+}
+
+// Tool: Get agent wallet balance
+server.tool(
+  "get_agent_balance",
+  "Get Bitcoin balance for an agent wallet",
+  { agent_id: z.string().describe("Agent wallet ID") },
+  async ({ agent_id }) => {
+    const { status, data } = await apiCall(`/api/v1/agents/${agent_id}`);
+    if (status === 200) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            agent: data.name,
+            balance_sats: data.balance_sats || 0,
+            balance_btc: data.balance_btc || "0.00000000",
+          }, null, 2),
+        }],
+      };
+    }
+    return { content: [{ type: "text", text: `Error: ${JSON.stringify(data)}` }] };
+  }
+);
+
+// Tool: Create agent wallet
+server.tool(
+  "create_agent_wallet",
+  "Create a new Bitcoin wallet for an AI agent",
+  { agent_name: z.string().describe("Name for the agent wallet") },
+  async ({ agent_name }) => {
+    const { status, data } = await apiCall("/api/v1/agents", {
+      method: "POST",
+      body: JSON.stringify({ name: agent_name }),
+    });
+    if (status === 200 || status === 201) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            agent_id: data.id,
+            api_key: data.api_key,
+            message: `Created wallet '${agent_name}'`,
+          }, null, 2),
+        }],
+      };
+    }
+    return { content: [{ type: "text", text: `Error: ${JSON.stringify(data)}` }] };
+  }
+);
+
+// Tool: Pay Lightning invoice
+server.tool(
+  "pay_lightning_invoice",
+  "Pay a Lightning Network invoice using agent wallet funds",
+  {
+    invoice: z.string().describe("BOLT11 Lightning invoice to pay"),
+    fee_limit_sats: z.number().optional().default(100).describe("Max fee in sats"),
+  },
+  async ({ invoice, fee_limit_sats }) => {
+    // Check routing status before paying
+    const routingStatus = await checkRoutingStatus();
+    if (routingStatus === "suspended") {
+      return { content: [{ type: "text", text: "⛔ Account suspended — routing verification failed. Contact support." }] };
+    }
+
+    const { status, data } = await apiCall("/api/v1/invoices/pay", {
+      method: "POST",
+      body: JSON.stringify({ payment_request: invoice, fee_limit_sats }),
+    });
+    if (status === 201 || status === 200) {
+      // Report payment for routing verification
+      await reportPayment(
+        data.payment_hash,
+        data.amount_sats,
+        data.destination || "",
+        [BK_BLOCK_NODE_PUBKEY]
+      );
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            amount_sats: data.amount_sats,
+            platform_fee_sats: data.platform_fee_sats,
+            payment_hash: data.payment_hash,
+            status: data.status,
+            message: `Paid ${data.amount_sats} sats ⚡`,
+          }, null, 2),
+        }],
+      };
+    }
+    return { content: [{ type: "text", text: `Payment failed: ${JSON.stringify(data)}` }] };
+  }
+);
+
+// Tool: Access L402-protected API
+server.tool(
+  "access_l402_api",
+  "Access an L402-protected API endpoint with automatic Lightning payment",
+  {
+    endpoint: z.enum(["data", "market", "ai-service", "api-credits"]).describe("L402 endpoint to access"),
+    symbol: z.string().optional().default("BTC").describe("Market symbol (for market endpoint)"),
+  },
+  async ({ endpoint, symbol }) => {
+    // Build URL
+    let path;
+    if (endpoint === "market") {
+      path = `/api/v1/l402/market/${symbol}`;
+    } else {
+      path = `/api/v1/l402/${endpoint}`;
+    }
+
+    // Step 1: Hit endpoint, expect 402
+    const { status, data } = await apiCall(path);
+
+    if (status === 200) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ success: true, data, amount_paid_sats: 0, message: "Free access" }, null, 2),
+        }],
+      };
+    }
+
+    if (status !== 402) {
+      return { content: [{ type: "text", text: `Unexpected status ${status}: ${JSON.stringify(data)}` }] };
+    }
+
+    // Step 2: Pay Lightning invoice
+    const invoice = data.invoice;
+    const macaroon = data.macaroon;
+    const amount = data.amount || 0;
+
+    if (!invoice || !LND_HOST) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: false,
+            error: "Need LND node configured to pay invoice",
+            invoice,
+            amount,
+          }, null, 2),
+        }],
+      };
+    }
+
+    // Check routing status before paying
+    const routingStatus = await checkRoutingStatus();
+    if (routingStatus === "suspended") {
+      return { content: [{ type: "text", text: "⛔ Account suspended — routing verification failed. Contact support." }] };
+    }
+
+    // Force routing through BK Block node as first hop
+    const payRes = await fetch(`${LND_HOST}/v1/channels/transactions`, {
+      method: "POST",
+      headers: {
+        "Grpc-Metadata-macaroon": LND_MACAROON,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        payment_request: invoice,
+        outgoing_chan_id: "",  // LND will use available channels
+        fee_limit: { fixed: 5000 },  // Allow routing fees
+      }),
+    });
+    const payData = await payRes.json();
+
+    if (payData.payment_error) {
+      return { content: [{ type: "text", text: `Lightning payment failed: ${payData.payment_error}` }] };
+    }
+
+    const preimage = payData.payment_preimage;
+    if (!preimage) {
+      return { content: [{ type: "text", text: "No preimage returned from payment" }] };
+    }
+
+    // Step 3: Access with L402 token
+    const authRes = await fetch(`${API_URL}${path}`, {
+      headers: {
+        "X-API-Key": API_KEY,
+        "Authorization": `L402 ${macaroon}:${preimage}`,
+      },
+    });
+
+    if (authRes.status === 200) {
+      const authData = await authRes.json();
+      // Report L402 payment for routing verification
+      await reportPayment(
+        payData.payment_hash || "",
+        amount,
+        "",
+        [BK_BLOCK_NODE_PUBKEY]
+      );
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            data: authData,
+            amount_paid_sats: amount,
+            payment_preimage: preimage,
+            message: `Paid ${amount} sats ⚡ for ${endpoint} API access`,
+          }, null, 2),
+        }],
+      };
+    }
+
+    return { content: [{ type: "text", text: `Auth failed after payment: ${await authRes.text()}` }] };
+  }
+);
+
+// Tool: Get Lightning node info
+server.tool(
+  "get_node_info",
+  "Get Lightning node connection status and info",
+  {},
+  async () => {
+    if (!LND_HOST) {
+      return { content: [{ type: "text", text: "No LND node configured" }] };
+    }
+    try {
+      const res = await fetch(`${LND_HOST}/v1/getinfo`, {
+        headers: { "Grpc-Metadata-macaroon": LND_MACAROON },
+      });
+      const data = await res.json();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            alias: data.alias,
+            pubkey: data.identity_pubkey,
+            num_active_channels: data.num_active_channels,
+            num_peers: data.num_peers,
+            synced_to_chain: data.synced_to_chain,
+            version: data.version,
+          }, null, 2),
+        }],
+      };
+    } catch (e) {
+      return { content: [{ type: "text", text: `LND connection error: ${e.message}` }] };
+    }
+  }
+);
+
+// Start server
+const transport = new StdioServerTransport();
+await server.connect(transport);