iflow-mcp_breez-breez-mcp 0.1.0__py3-none-any.whl

iflow_mcp_breez_breez_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,279 @@
+Metadata-Version: 2.4
+Name: iflow-mcp_breez-breez-mcp
+Version: 0.1.0
+Summary: Breez MCP Server - FastMCP implementation for Lightning wallet functionality
+Author: Breez MCP Contributors
+License: MIT
+Project-URL: Homepage, https://github.com/breez/breez-mcp
+Project-URL: Repository, https://github.com/breez/breez-mcp
+Project-URL: Documentation, https://github.com/breez/breez-mcp#readme
+Keywords: mcp,lightning,breez,bitcoin,wallet
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: fastmcp>=0.4.0
+Requires-Dist: breez-sdk-spark>=0.2.7
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: uvicorn[standard]>=0.24.0
+
+# Breez MCP Server — FastMCP Implementation
+
+A unified MCP server that exposes Lightning functionality through the Breez SDK (Spark implementation) using FastMCP. Supports both stdio and HTTP transport modes.
+
+## Prerequisites
+
+- Python 3.11+ (for local development or `uvx`)
+- [Docker](https://docs.docker.com/get-docker/) (optional, for container workflows)
+- [uv](https://github.com/astral-sh/uv) (optional, for ephemeral environments)
+- Breez API key which you can request [here](https://breez.technology/request-api-key/#contact-us-form-sdk)
+
+## Configure Credentials
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env` with your secrets. Required variables:
+
+| Variable | Required | Default | Purpose |
+|----------|----------|---------|---------|
+| `BREEZ_API_KEY` | ✅ | – | Breez Spark API key |
+| `BREEZ_MNEMONIC` | ✅ | – | 12-word mnemonic controlling the wallet |
+| `BREEZ_NETWORK` | ❌ | `mainnet` | Set to `testnet` for sandbox usage |
+| `BREEZ_DATA_DIR` | ❌ | `./data` | Wallet storage directory |
+| `BREEZ_TRANSPORT_MODE` | ❌ | `stdio` | Transport mode: `stdio`, `http`, or `asgi` |
+| `BREEZ_HTTP_HOST` | ❌ | `0.0.0.0` | HTTP server host (HTTP mode only) |
+| `BREEZ_HTTP_PORT` | ❌ | `8000` | HTTP server port (HTTP mode only) |
+| `BREEZ_HTTP_PATH` | ❌ | `/mcp` | HTTP endpoint path (HTTP mode only) |
+
+## Run the Server
+
+Choose the runtime that transport mode that fits your workflow.
+
+### STDIO Mode (Default for MCP clients)
+
+For use with Claude Desktop and other MCP clients:
+
+```bash
+# Local virtualenv
+python -m venv .venv
+source .venv/bin/activate  # Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+python -m src.main
+
+# Or with uvx (no persistent venv)
+uvx --from . breez-mcp
+```
+
+### HTTP Mode (for web API access)
+
+For accessing the MCP server via HTTP API:
+
+```bash
+# Set environment variable
+export BREEZ_TRANSPORT_MODE=http
+
+# Or add to .env file
+echo "BREEZ_TRANSPORT_MODE=http" >> .env
+
+# Run the server
+python -m src.main
+```
+
+The server will be available at `http://localhost:8000/mcp`
+
+### ASGI Mode (for external ASGI servers)
+
+For deployment with external ASGI servers like Gunicorn:
+
+```bash
+# Set environment variable
+export BREEZ_TRANSPORT_MODE=asgi
+
+# Run with uvicorn
+uvicorn src.main:app --host 0.0.0.0 --port 8000
+
+# Or with Gunicorn (production)
+gunicorn src.main:app -w 4 -k uvicorn.workers.UvicornWorker
+```
+
+### Docker Compose
+
+Run both modes simultaneously:
+
+```bash
+# STDIO mode
+docker compose --profile stdio up -d
+docker compose logs -f breez-mcp-stdio
+
+# HTTP mode
+docker compose --profile http up -d
+docker compose logs -f breez-mcp-http
+
+# Stop
+docker compose --profile http down
+docker compose --profile stdio down
+```
+
+### Docker (direct)
+
+```bash
+# Build image
+docker build -t breez-mcp .
+
+# STDIO mode (default)
+docker run --rm \
+  -e BREEZ_API_KEY="$BREEZ_API_KEY" \
+  -e BREEZ_MNEMONIC="$BREEZ_MNEMONIC" \
+  -v $(pwd)/data:/app/data \
+  breez-mcp
+
+# HTTP mode
+docker run --rm -p 8000:8000 \
+  -e BREEZ_TRANSPORT_MODE=http \
+  -e BREEZ_API_KEY="$BREEZ_API_KEY" \
+  -e BREEZ_MNEMONIC="$BREEZ_MNEMONIC" \
+  -v $(pwd)/data:/app/data \
+  breez-mcp
+```
+
+To keep STDIN/STDOUT attached for Claude Desktop, add `-i` to the `docker run` command.
+
+
+## Claude Desktop Integration
+
+### Quick install
+
+```bash
+mcp install src.main --name "breez-mcp"
+```
+
+Use `-f .env` or `-v KEY=value` to supply credentials during installation if desired.
+
+
+### Docker from Claude Desktop
+
+Ensure the image exists (`docker build -t breez-mcp .`), then configure:
+
+```json
+{
+  "mcpServers": {
+    "breez": {
+      "command": "docker",
+      "args": [
+        "run", "--rm", "-i",
+        "-e", "BREEZ_API_KEY",
+        "-e", "BREEZ_MNEMONIC",
+        "-e", "BREEZ_TRANSPORT_MODE=stdio",
+        "-v", "/absolute/path/to/breez-mcp/data:/app/data",
+        "breez-mcp"
+      ],
+      "cwd": "/absolute/path/to/breez-mcp",
+      "env": {
+        "BREEZ_API_KEY": "${env:BREEZ_API_KEY}",
+        "BREEZ_MNEMONIC": "${env:BREEZ_MNEMONIC}",
+        "BREEZ_NETWORK": "mainnet"
+      }
+    }
+  }
+}
+```
+
+Docker's `-e VAR` syntax reads the value of `VAR` from the environment supplied via the `env` block.
+
+### uvx from Claude Desktop
+
+```json
+{
+  "mcpServers": {
+    "breez": {
+      "command": "uvx",
+      "args": ["--from", ".", "breez-mcp"],
+      "cwd": "/absolute/path/to/breez-mcp",
+      "env": {
+        "BREEZ_API_KEY": "${env:BREEZ_API_KEY}",
+        "BREEZ_MNEMONIC": "${env:BREEZ_MNEMONIC}",
+      }
+    }
+  }
+}
+```
+
+### Verification
+
+- Restart Claude Desktop after adding the configuration.
+- Run `mcp list` to ensure the server registered.
+- Ask Claude prompts like “Check my wallet balance” or “Create an invoice for 1000 sats” to validate tool routing.
+
+## Available Tools
+
+- `get_balance` — comprehensive wallet balance with limits and formatted amounts
+- `get_node_info` — detailed node information including capabilities and sync status
+- `send_payment` — send a Lightning payment with complete transaction details
+- `create_invoice` — generate a BOLT11 invoice with all invoice data
+- `list_payments` — comprehensive payment history with full details
+
+## Example Prompts
+
+- "Check my wallet balance"
+- "Create an invoice for 1000 sats for coffee"
+- "Send payment to lnbc1…"
+- "Show me my recent payments"
+
+## HTTP API Usage (HTTP Mode)
+
+When running in HTTP mode, you can interact with the MCP server via HTTP requests:
+
+### Health Check
+```bash
+curl http://localhost:8000/health
+```
+
+### List Available Tools
+```bash
+curl http://localhost:8000/mcp/tools/list
+```
+
+### Call a Tool (MCP Protocol)
+The HTTP mode follows the MCP protocol over HTTP. You'll need to send properly formatted MCP JSON-RPC requests to `http://localhost:8000/mcp`.
+
+Example using MCP Inspector or other MCP clients:
+```json
+{
+  "jsonrpc": "2.0",
+  "method": "tools/call",
+  "params": {
+    "name": "get_balance",
+    "arguments": {}
+  },
+  "id": 1
+}
+```
+
+Send to:
+```bash
+curl -X POST http://localhost:8000/mcp \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"get_balance","arguments":{}},"id":1}'
+```
+
+## Security Notes
+
+- Never commit `.env`; keep secrets in your shell or a secrets manager.
+- Treat the mnemonic as the wallet’s private key. Rotate immediately if leaked.
+- Default network is `mainnet`. For experimentation, explicitly set `BREEZ_NETWORK=testnet`.
+- When using containers, mount `./data` to preserve state between runs and prevent secret leakage in container layers.
+
+## Troubleshooting
+
+- **Missing environment variables** — ensure `.env` exists or export the required variables before starting.
+- **SDK connection failures** — verify required env vars, try `python list_payments_cli.py --limit 1 --verbose` to confirm SDK connectivity, and check `http://localhost:8000/health` in HTTP mode.
+- **Claude Desktop cannot find the server** — double-check absolute paths in `cwd` and restart the application after configuration changes.

iflow_mcp_breez_breez_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/config.py,sha256=FREmEXQhoIA9TzZCev6ugdMOBMLB86J0hDK1uyEBiOQ,1036
+src/main.py,sha256=9DIdkrnelcAA7dlOqCLxnRBfBLOSYeq6hCDZ8TewhWk,9897
+src/sdk_manager.py,sha256=oFpRq_uwo-ZP2coyKtLKrGnQJo5umK8YD6hSYs-4n5Q,3696
+iflow_mcp_breez_breez_mcp-0.1.0.dist-info/METADATA,sha256=XV3HUgXiHQ3h2rWQWl-8Ap42Dd2x0rS_tLNZafGANxQ,8065
+iflow_mcp_breez_breez_mcp-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+iflow_mcp_breez_breez_mcp-0.1.0.dist-info/entry_points.txt,sha256=l-_HAtPeY_tPHtsSmFsPIZaEjSJ9ockY1-_CqnYVSvY,59
+iflow_mcp_breez_breez_mcp-0.1.0.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+iflow_mcp_breez_breez_mcp-0.1.0.dist-info/RECORD,,

iflow_mcp_breez_breez_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

iflow_mcp_breez_breez_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+iflow-mcp_breez-breez-mcp = src.main:run

iflow_mcp_breez_breez_mcp-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

src/config.py

@@ -0,0 +1,25 @@
+import os
+from dotenv import load_dotenv
+from breez_sdk_spark import Network
+
+load_dotenv()
+
+class Config:
+    def __init__(self):
+        # Check if we're in test mode
+        self.test_mode = os.getenv("BREEZ_TEST_MODE", "false").lower() == "true"
+        
+        if self.test_mode:
+            # In test mode, use dummy values
+            self.api_key = "test_api_key"
+            self.mnemonic = "test mnemonic word1 word2 word3 word4 word5 word6 word7 word8 word9 word10 word11 word12"
+        else:
+            # In production mode, require real values
+            self.api_key = os.getenv("BREEZ_API_KEY")
+            self.mnemonic = os.getenv("BREEZ_MNEMONIC")
+            
+            if not all([self.api_key, self.mnemonic]):
+                raise ValueError("Missing required environment variables: BREEZ_API_KEY, BREEZ_MNEMONIC")
+        
+        self.network = Network.TESTNET if os.getenv("BREEZ_NETWORK", "mainnet").lower() == "testnet" else Network.MAINNET
+        self.data_dir = os.getenv("BREEZ_DATA_DIR", "./data")

src/main.py

@@ -0,0 +1,282 @@
+import asyncio
+import logging
+import os
+import sys
+import json
+from contextlib import asynccontextmanager
+from typing import Annotated, Dict, Any, List
+
+# Import standard MCP SDK
+from mcp.server.stdio import stdio_server
+from mcp.server import Server
+from mcp.types import Tool, TextContent
+from pydantic import Field
+
+from .config import Config
+from .sdk_manager import SDKManager
+
+# Global SDK manager
+sdk_manager = None
+
+# Create MCP server
+server = Server("breez-mcp")
+
+async def initialize_sdk():
+    """Initialize SDK"""
+    global sdk_manager
+    logging.info("Starting Breez MCP server...")
+    sdk_manager = SDKManager()
+    await sdk_manager.connect()
+
+async def cleanup_sdk():
+    """Cleanup SDK"""
+    global sdk_manager
+    if sdk_manager:
+        await sdk_manager.disconnect()
+        logging.info("Server shutdown complete")
+
+@server.list_tools()
+async def list_tools() -> List[Tool]:
+    """List available tools"""
+    return [
+        Tool(
+            name="get_balance",
+            description="Get wallet balance with limits and formatted amounts",
+            inputSchema={"type": "object", "properties": {}}
+        ),
+        Tool(
+            name="get_node_info", 
+            description="Get detailed node information including capabilities and sync status",
+            inputSchema={"type": "object", "properties": {}}
+        ),
+        Tool(
+            name="send_payment",
+            description="Send a Lightning payment with complete transaction details",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "invoice": {
+                        "type": "string",
+                        "description": "BOLT11 invoice to pay"
+                    }
+                },
+                "required": ["invoice"]
+            }
+        ),
+        Tool(
+            name="create_invoice",
+            description="Generate a BOLT11 invoice with all invoice data",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "amount_sats": {
+                        "type": "integer",
+                        "description": "Amount in satoshis",
+                        "minimum": 1
+                    },
+                    "description": {
+                        "type": "string",
+                        "description": "Payment description",
+                        "default": "MCP Payment"
+                    }
+                },
+                "required": ["amount_sats"]
+            }
+        ),
+        Tool(
+            name="list_payments",
+            description="List recent payments with full details",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "limit": {
+                        "type": "integer",
+                        "description": "Number of payments to return",
+                        "minimum": 1,
+                        "maximum": 100,
+                        "default": 10
+                    }
+                }
+            }
+        )
+    ]
+
+@server.call_tool()
+async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+    """Call a tool"""
+    if not sdk_manager:
+        return [TextContent(type="text", text="SDK not initialized")]
+    
+    try:
+        if name == "get_balance":
+            result = await get_balance()
+            return [TextContent(type="text", text=json.dumps(result, indent=2))]
+        
+        elif name == "get_node_info":
+            result = await get_node_info()
+            return [TextContent(type="text", text=json.dumps(result, indent=2))]
+        
+        elif name == "send_payment":
+            invoice = arguments.get("invoice")
+            result = await send_payment(invoice)
+            return [TextContent(type="text", text=json.dumps(result, indent=2))]
+        
+        elif name == "create_invoice":
+            amount_sats = arguments.get("amount_sats")
+            description = arguments.get("description", "MCP Payment")
+            result = await create_invoice(amount_sats, description)
+            return [TextContent(type="text", text=json.dumps(result, indent=2))]
+        
+        elif name == "list_payments":
+            limit = arguments.get("limit", 10)
+            result = await list_payments(limit)
+            return [TextContent(type="text", text=json.dumps(result, indent=2))]
+        
+        else:
+            return [TextContent(type="text", text=f"Unknown tool: {name}")]
+    
+    except Exception as e:
+        logging.error(f"Error calling tool {name}: {e}")
+        return [TextContent(type="text", text=json.dumps({"error": str(e)}))]
+
+async def get_balance() -> Dict[str, Any]:
+    """Get wallet balance"""
+    from breez_sdk_spark import GetInfoRequest
+    info = await sdk_manager.get_sdk().get_info(request=GetInfoRequest(ensure_synced=True))
+
+    balance = {
+        "balance_sat": getattr(info, 'balance_sats', 0) if hasattr(info, 'balance_sats') else 0,
+        "pending_incoming_sat": getattr(info, 'pending_incoming_sats', 0) if hasattr(info, 'pending_incoming_sats') else 0,
+        "pending_outgoing_sat": getattr(info, 'pending_outgoing_sats', 0) if hasattr(info, 'pending_outgoing_sats') else 0,
+    }
+
+    if hasattr(info, 'max_payable_sats'):
+        balance["max_payable_sat"] = info.max_payable_sats
+    if hasattr(info, 'max_receivable_sats'):
+        balance["max_receivable_sat"] = info.max_receivable_sats
+
+    balance["balance_formatted"] = f"{balance['balance_sat']:,} sats"
+    return balance
+
+async def get_node_info() -> Dict[str, Any]:
+    """Get node information"""
+    from breez_sdk_spark import GetInfoRequest
+    info = await sdk_manager.get_sdk().get_info(request=GetInfoRequest(ensure_synced=True))
+
+    node_info = {}
+    for attr in ['id', 'node_id', 'nodeId', 'pubkey', 'public_key', 'node_pubkey']:
+        if hasattr(info, attr):
+            node_info["node_id"] = getattr(info, attr)
+            break
+
+    node_info["network"] = str(getattr(info, 'network', 'unknown')) if hasattr(info, 'network') else 'unknown'
+    node_info["channels_count"] = len(info.channels) if hasattr(info, 'channels') and info.channels else 0
+    node_info["synced"] = getattr(info, 'synced', True) if hasattr(info, 'synced') else True
+
+    if hasattr(info, 'balance_sats'):
+        node_info["balance_sat"] = info.balance_sats
+        node_info["balance_formatted"] = f"{info.balance_sats:,} sats"
+
+    return node_info
+
+async def send_payment(invoice: str) -> Dict[str, Any]:
+    """Send a Lightning payment"""
+    from breez_sdk_spark import PrepareSendPaymentRequest, SendPaymentRequest
+
+    sdk = sdk_manager.get_sdk()
+    prepare_request = PrepareSendPaymentRequest(payment_request=invoice)
+    prepare_response = await sdk.prepare_send_payment(request=prepare_request)
+
+    send_request = SendPaymentRequest(prepare_response=prepare_response)
+    send_response = await sdk.send_payment(request=send_request)
+
+    result = {"status": "success", "message": "Payment sent successfully"}
+
+    if hasattr(send_response, 'payment') and send_response.payment:
+        payment = send_response.payment
+        result["id"] = getattr(payment, 'id', None)
+        result["amount_sat"] = getattr(payment, 'amount', None)
+        result["tx_id"] = getattr(payment, 'tx_id', None)
+
+    if hasattr(send_response, 'payment_hash'):
+        result["txid"] = send_response.payment_hash
+
+    return result
+
+async def create_invoice(amount_sats: int, description: str = "MCP Payment") -> Dict[str, Any]:
+    """Create a Lightning invoice"""
+    from breez_sdk_spark import ReceivePaymentRequest, ReceivePaymentMethod
+
+    sdk = sdk_manager.get_sdk()
+    payment_method = ReceivePaymentMethod.BOLT11_INVOICE(
+        description=description,
+        amount_sats=amount_sats
+    )
+    request = ReceivePaymentRequest(payment_method=payment_method)
+    response = await sdk.receive_payment(request=request)
+
+    result = {
+        "status": "success",
+        "message": "Invoice created successfully",
+        "amount_sat": amount_sats,
+        "description": description
+    }
+
+    if hasattr(response, 'payment_request'):
+        result["invoice"] = response.payment_request
+    if hasattr(response, 'payment_hash'):
+        result["payment_hash"] = response.payment_hash
+
+    return result
+
+async def list_payments(limit: int = 10) -> Dict[str, Any]:
+    """List recent payments"""
+    from breez_sdk_spark import ListPaymentsRequest
+
+    sdk = sdk_manager.get_sdk()
+    request = ListPaymentsRequest(limit=limit, sort_ascending=False)
+    response = await sdk.list_payments(request=request)
+
+    result = {"payments": [], "total_count": 0}
+
+    if hasattr(response, 'payments') and response.payments:
+        result["total_count"] = len(response.payments)
+        for payment in response.payments:
+            payment_data = {
+                'id': getattr(payment, 'id', None),
+                'timestamp': getattr(payment, 'timestamp', None),
+                'amount_sat': getattr(payment, 'amount', None),
+                'status': str(getattr(payment, 'status', 'UNKNOWN')),
+            }
+            result["payments"].append(payment_data)
+
+    return result
+
+def run():
+    """Entry point for setuptools - runs the async main function"""
+    asyncio.run(main())
+
+async def main():
+    """Main entry point"""
+    # Setup logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        stream=sys.stdout
+    )
+
+    # Initialize SDK
+    await initialize_sdk()
+
+    try:
+        async with stdio_server() as (read_stream, write_stream):
+            await server.run(
+                read_stream,
+                write_stream,
+                server.create_initialization_options()
+            )
+    finally:
+        await cleanup_sdk()
+
+if __name__ == "__main__":
+    run()

src/sdk_manager.py

@@ -0,0 +1,125 @@
+import asyncio
+import logging
+import os
+from breez_sdk_spark import (
+    BreezSdk,
+    connect,
+    ConnectRequest,
+    default_config,
+    Seed
+)
+from .config import Config
+
+# Mock SDK for testing
+class MockBreezSdk:
+    def __init__(self):
+        self.connected = True
+
+    async def disconnect(self):
+        self.connected = False
+
+    async def get_info(self, request=None):
+        return MockNodeInfo()
+
+    async def prepare_send_payment(self, request=None):
+        return MockPrepareResponse()
+
+    async def send_payment(self, request=None):
+        return MockSendPaymentResponse()
+
+    async def receive_payment(self, request=None):
+        return MockReceivePaymentResponse()
+
+    async def list_payments(self, request=None):
+        return MockListPaymentsResponse()
+
+class MockNodeInfo:
+    def __init__(self):
+        self.id = "test_node_id_123456789"
+        self.balance_sats = 1000000
+        self.pending_incoming_sats = 0
+        self.pending_outgoing_sats = 50000
+        self.max_payable_sats = 950000
+        self.max_receivable_sats = 2000000
+        self.network = "mainnet"
+        self.channels = []
+        self.synced = True
+        self.block_height = 800000
+
+class MockPrepareResponse:
+    def __init__(self):
+        pass
+
+class MockSendPaymentResponse:
+    def __init__(self):
+        self.payment = MockPayment()
+        self.payment_hash = "test_payment_hash_123"
+
+class MockReceivePaymentResponse:
+    def __init__(self):
+        self.payment_request = "lnbc1000n1p3knh2dpp5jfqh5..."
+        self.payment_hash = "test_invoice_hash_456"
+        self.fee_sats = 1
+
+class MockPayment:
+    def __init__(self):
+        self.id = "test_payment_id_123"
+        self.timestamp = 1234567890
+        self.amount = 1000
+        self.fees = 10
+        self.payment_type = "PaymentType.SEND"
+        self.status = "PaymentStatus.COMPLETED"
+        self.destination = "lnbc..."
+        self.tx_id = "test_tx_id_789"
+        self.details = MockPaymentDetails()
+
+class MockPaymentDetails:
+    def __init__(self):
+        self.payment_hash = "test_payment_hash_123"
+        self.preimage = "test_preimage_abc"
+        self.description = "Test payment"
+        self.invoice = "lnbc1000n1p3knh2d..."
+
+class MockListPaymentsResponse:
+    def __init__(self):
+        self.payments = [MockPayment()]
+
+class SDKManager:
+    def __init__(self):
+        self.config = Config()
+        self.sdk: BreezSdk = None
+        self.test_mode = os.getenv("BREEZ_TEST_MODE", "false").lower() == "true"
+
+    async def connect(self):
+        try:
+            if self.test_mode:
+                # Use mock SDK for testing
+                self.sdk = MockBreezSdk()
+                logging.info("Connected to Mock Breez SDK (test mode)")
+            else:
+                # Use real SDK
+                seed = Seed.MNEMONIC(mnemonic=self.config.mnemonic, passphrase=None)
+                config = default_config(network=self.config.network)
+                config.api_key = self.config.api_key
+
+                self.sdk = await connect(
+                    request=ConnectRequest(
+                        config=config,
+                        seed=seed,
+                        storage_dir=self.config.data_dir
+                    )
+                )
+                logging.info("Connected to Breez SDK")
+        except Exception as e:
+            logging.error(f"Failed to connect: {e}")
+            raise
+
+    async def disconnect(self):
+        if self.sdk:
+            await self.sdk.disconnect()
+            logging.info("Disconnected from Breez SDK")
+
+    def get_sdk(self) -> BreezSdk:
+        if not self.sdk:
+            raise RuntimeError("SDK not connected")
+        return self.sdk