LDK MCP Server

Real-time Lightning Development Kit (LDK) expertise for accelerating iOS Lightning wallet development. This MCP server provides instant access to LDK APIs, Swift patterns with proper Bindings namespace usage, comprehensive event handling, NetworkGraph with RapidGossipSync, and multiple chain synchronization methods.

🚀 Features

Lightning Development Tools

Invoice Generation - Create real Lightning invoices with proper encoding
Payment Processing - Test payment flows with simulated Lightning operations
Channel Management - Open, monitor, and close Lightning channels
Balance Tracking - Monitor channel liquidity and wallet balances
Fee Estimation - Calculate routing fees and on-chain costs

iOS Development Integration

Keychain Security - iOS Keychain patterns for secure key storage
Background Processing - Lightning sync in iOS background tasks
Push Notifications - Payment notification implementation
Biometric Auth - Touch/Face ID integration for Lightning operations

Architecture & Best Practices

Swift Code Examples - Production-ready LDK Swift implementations
Project Structure - Recommended iOS Lightning wallet architecture
Security Patterns - Best practices for key management and crypto
Testing Scenarios - Complete test scenarios for Lightning operations

📦 Installation

Clone the repository:

git clone https://github.com/StevenGeller/ldk-mcp.git
cd ldk-mcp

Install dependencies:

npm install

Build the project:

npm run build

Configure MCP Client:

Add to your MCP client configuration file:

Configuration varies by MCP client. For example configurations, see the documentation.

{
  "mcpServers": {
    "ldk-mcp": {
      "command": "node",
      "args": ["/path/to/ldk-mcp/dist/index.js"],
      "env": {
        "NETWORK": "testnet"
      }
    }
  }
}

Restart Claude Desktop

🛠️ Available Tools

Lightning Operations

`ldk_generate_invoice`

Generate Lightning invoices for testing payment flows.

await ldk_generate_invoice({
  amountSats: 10000,
  description: "Test payment",
  expirySeconds: 3600
})

`ldk_pay_invoice`

Simulate Lightning payments for development.

await ldk_pay_invoice({
  invoice: "lnbc10000n1...",
  maxFeeSats: 50
})

`ldk_create_channel`

Open Lightning channels with configuration options.

await ldk_create_channel({
  remotePubkey: "02abc...",
  capacitySats: 1000000,
  pushSats: 100000,
  isPublic: false
})

`ldk_channel_status`

Monitor channel states and balances.

await ldk_channel_status({
  includeOffline: true
})

iOS Integration Tools

`ios_keychain_test`

Test iOS Keychain integration for secure storage.

await ios_keychain_test({
  keyType: "seed",
  testValue: "test_data"
})

`ios_background_test`

Implement Lightning background sync.

await ios_background_test({
  taskType: "sync"
})

`ios_biometric_auth`

Integrate Touch/Face ID with Lightning operations.

await ios_biometric_auth({
  operation: "send_payment",
  requireAuth: true
})

Development Helpers

`ldk_get_swift_code`

Get production-ready Swift code examples.

await ldk_get_swift_code({
  operation: "channel_manager_setup"
})

`ldk_get_architecture`

Access architectural patterns and best practices.

await ldk_get_architecture({
  topic: "security_architecture"
})

`ldk_test_scenario`

Run complete Lightning development scenarios.

await ldk_test_scenario({
  scenario: "multi_hop_payment"
})

💡 Usage Examples

Quick Start: Building a Lightning Invoice Feature

// 1. Use MCP to generate a test invoice
const invoice = await ldk_generate_invoice({
  amountSats: 5000,
  description: "Coffee payment"
})

// 2. Get the Swift implementation
const swiftCode = await ldk_get_swift_code({
  operation: "payment_handling"
})

// 3. The MCP server provides complete SwiftUI code with:
// - QR code generation
// - Invoice display
// - Payment handling
// - Error management

Advanced: Implementing Channel Management

// 1. Get architecture guidance
const architecture = await ldk_get_architecture({
  topic: "channel_management"
})

// 2. Create test channel
const channel = await ldk_create_channel({
  remotePubkey: "02...",
  capacitySats: 500000
})

// 3. Run test scenarios
const test = await ldk_test_scenario({
  scenario: "channel_lifecycle"
})

🏗️ Development Workflow

1. Initial Setup

# Request initial setup
"Help me set up a new iOS Lightning wallet project"

# MCP provides:
# - Complete project structure
# - LDK initialization code  
# - Security setup
# - Basic UI components

2. Feature Implementation

# Request specific features
"Implement Lightning payment sending with biometric authentication"

# MCP provides:
# - Swift implementation
# - Security best practices
# - UI/UX patterns
# - Test scenarios

3. Testing & Validation

# Test your implementation
"Run a multi-hop payment test scenario"

# MCP provides:
# - Test setup code
# - Mock Lightning network
# - Validation steps
# - Debugging guidance

🔧 Configuration

Environment Variables

NETWORK - Bitcoin network: mainnet, testnet, or regtest (default: testnet)
LOG_LEVEL - Logging verbosity: debug, info, warn, error (default: info)

Custom Configuration

Create a .env file in the project root:

NETWORK=testnet
LOG_LEVEL=debug

🧪 Testing

Run the test suite:

npm test

Run specific test scenarios:

npm test -- --testNamePattern="Lightning payment"

📚 Documentation

Swift/iOS Integration

Lightning Development

🤝 Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

Lightning Dev Kit for the amazing Lightning implementation
Bitcoin Dev Kit for on-chain wallet functionality
The Lightning Network community for protocol development

💬 Support

Issues: GitHub Issues
Discussions: GitHub Discussions
Lightning Dev Chat: LDK Discord

Built with ⚡ for the Lightning Network community