cdk-payment-processor 0.18.0

CDK payment processor
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

# CDK Payment Processor

The cdk-payment-processor is a Rust crate that provides both a binary and a library for handling payments to and from a cdk mint. 

## Overview

### Library Components
- **Payment Processor Server**: Handles interaction with payment processor backend implementations
- **Client**: Used by mintd to query the server for payment information
- **Backend Implementations**: Supports CLN, LND, and a fake wallet (for testing)

### Features
- Modular backend system supporting multiple payment backend implementations
- Extensible design allowing for custom backend implementations

## Building from Source

### Prerequisites
1. Install Nix package manager
2. Enter development environment (use `.#regtest` for full stack including CLN/LND):
```sh
nix develop
# or for full stack:
nix develop .#regtest
```

### Configuration

The server requires different environment variables depending on your chosen payment backend.

#### Core Settings
```sh
# Choose backend: CLN, LND, or FAKEWALLET
export CDK_PAYMENT_PROCESSOR_BACKEND="CLN"

# Server configuration
export CDK_PAYMENT_PROCESSOR_LISTEN_HOST="127.0.0.1"
export CDK_PAYMENT_PROCESSOR_LISTEN_PORT="8090"
```

When mintd connects with a TLS directory, the directory must contain
`ca.pem`, `client.pem`, and `client.key`. The CA certificate verifies the
payment processor, and the client certificate and private key authenticate
mintd to an mTLS-enabled processor. Configured TLS does not fall back to an
unauthenticated client connection when either client identity file is missing.

Mintd can explicitly opt into a plaintext connection with
`[grpc_processor].allow_insecure = true`, including for a non-loopback address.
This is unsafe on an untrusted network because the connection has no transport
authentication or encryption and can be intercepted or modified. Use plaintext
only on a trusted, isolated network or through a separately authenticated and
encrypted tunnel; prefer mTLS even for internal deployments.

#### Backend-Specific Configuration

##### Core Lightning (CLN)
```sh
# Path to CLN RPC socket
export CDK_PAYMENT_PROCESSOR_CLN_RPC_PATH="/path/to/lightning-rpc"
```

##### Lightning Network Daemon (LND)
```sh
# LND connection details
export CDK_PAYMENT_PROCESSOR_LND_ADDRESS="localhost:10009"
export CDK_PAYMENT_PROCESSOR_LND_CERT_FILE="/path/to/tls.cert"
export CDK_PAYMENT_PROCESSOR_LND_MACAROON_FILE="/path/to/macaroon"
```

### Building and Running

Build and run the binary with your chosen backend:

```sh
# For CLN backend
cargo run --bin cdk-payment-processor --no-default-features --features cln

# For LND backend
cargo run --bin cdk-payment-processor --no-default-features --features lnd

# For fake wallet (testing only)
cargo run --bin cdk-payment-processor --no-default-features --features fake
```

## Development

To implement a new backend:
1. Create a new module implementing the payment processor traits
2. Add appropriate feature flags
3. Update the binary to support the new backend

For library usage examples and API documentation, refer to the crate documentation.