Replace protobuf with JSON everywhere

Protobuf added complexity without much benefit for our use case — the
binary encoding is opaque, hard to debug with standard HTTP tools, and
requires proto toolchain maintenance. JSON is human-readable, widely
supported, and sufficient for our throughput needs.

This removes prost and all .proto files entirely, renaming the
ldk-server-protos crate to ldk-server-json-models. Types are rewritten
as hand-written Rust structs and enums with serde derives rather than
prost-generated code. Fixed-size byte fields (hashes, channel IDs,
public keys) use [u8; 32] and [u8; 33] with hex serde instead of
String, giving type safety at the model layer.

Several proto-era patterns are cleaned up: wrapper structs that only
existed because protobuf wraps oneof in a message are removed, fields
that were Option only because proto message fields are nullable are
made required where the server always provides them, and the
EventEnvelope wrapper is dropped in favor of using Event directly.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: benthecarman

.github/workflows/check-protos.yml

@@ -9,7 +9,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for build commands, testing, code style,
 - **ldk-server** - Main daemon server (entry point: `src/main.rs`)
 - **ldk-server-cli** - CLI client using clap
 - **ldk-server-client** - Reqwest-based client library
-- **ldk-server-protos** - Protocol buffer definitions and generated Rust code
+- **ldk-server-json-models** - Shared JSON request/response types with serde
 
 ## Development Rules
 

CLAUDE.md

@@ -37,18 +37,11 @@ cargo clippy --all-features -- -D warnings -A clippy::drop_non_drop  # Lint (CI
 - Hard tabs, max width 100 chars
 - Imports grouped: std, external crates, local crates
 
-## Protocol Buffer Generation
-
-```bash
-RUSTFLAGS="--cfg genproto" cargo build -p ldk-server-protos
-cargo fmt --all
-```
-
 ## Adding a New API Endpoint
 
-1. Define request/response messages in `ldk-server-protos/src/proto/api.proto`
-2. Regenerate protos (see above)
-3. Create handler in `ldk-server/src/api/` (follow existing patterns)
+1. Define request/response types in `ldk-server-json-models/src/api.rs`
+2. Create handler in `ldk-server/src/api/` (follow existing patterns)
+3. Add endpoint constant in `ldk-server-json-models/src/endpoints.rs`
 4. Add route in `ldk-server/src/service.rs`
 5. Add CLI command in `ldk-server-cli/src/main.rs`
 

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 [workspace]
 resolver = "2"
-members = ["ldk-server-cli", "ldk-server-client", "ldk-server-protos", "ldk-server"]
+members = ["ldk-server-cli", "ldk-server-client", "ldk-server-json-models", "ldk-server"]
 exclude = ["e2e-tests"]
 
 [profile.release]

Cargo.lock

@@ -7,15 +7,15 @@
 
 The primary goal of LDK Server is to provide an efficient, stable, and API-first solution for deploying and managing
 a Lightning Network node. With its streamlined setup, LDK Server enables users to easily set up, configure, and run
-a Lightning node while exposing a robust, language-agnostic API via [Protocol Buffers (Protobuf)](https://protobuf.dev/).
+a Lightning node while exposing a robust, language-agnostic REST API with JSON.
 
 ### Features
 
 - **Out-of-the-Box Lightning Node**:
     - Deploy a Lightning Network node with minimal configuration, no coding required.
 
 - **API-First Design**:
-    - Exposes a well-defined API using Protobuf, allowing seamless integration with HTTP-clients or applications.
+    - Exposes a well-defined JSON REST API, allowing seamless integration with HTTP-clients or applications.
 
 - **Powered by LDK**:
     - Built on top of LDK-Node, leveraging the modular, reliable, and high-performance architecture of LDK.

Cargo.toml

@@ -8,10 +8,9 @@ corepc-node = { version = "0.10", features = ["download", "29_0"] }
 tempfile = "3"
 tokio = { version = "1.38.0", features = ["rt-multi-thread", "macros", "time"] }
 ldk-server-client = { path = "../ldk-server-client" }
-ldk-server-protos = { path = "../ldk-server-protos", features = ["serde"] }
+ldk-server-json-models = { path = "../ldk-server-json-models" }
 serde_json = "1.0"
 hex-conservative = { version = "0.2", features = ["std"] }
 lapin = { version = "2.4.0", features = ["rustls"], default-features = false }
-prost = { version = "0.11.6", default-features = false, features = ["std"] }
 futures-util = "0.3"
 ldk-node = { git = "https://github.com/lightningdevkit/ldk-node", rev = "d1bbf978c8b7abe87ae2e40793556c1fe4e7ea49" }

README.md

@@ -45,6 +45,6 @@ fn main() {
 	println!("cargo:rerun-if-changed=../ldk-server/Cargo.toml");
 	println!("cargo:rerun-if-changed=../ldk-server-cli/src");
 	println!("cargo:rerun-if-changed=../ldk-server-cli/Cargo.toml");
-	println!("cargo:rerun-if-changed=../ldk-server-protos/src");
-	println!("cargo:rerun-if-changed=../ldk-server-protos/Cargo.toml");
+	println!("cargo:rerun-if-changed=../ldk-server-json-models/src");
+	println!("cargo:rerun-if-changed=../ldk-server-json-models/Cargo.toml");
 }

e2e-tests/Cargo.lock

@@ -16,9 +16,9 @@ use std::time::Duration;
 use corepc_node::Node;
 use hex_conservative::DisplayHex;
 use ldk_server_client::client::LdkServerClient;
-use ldk_server_client::ldk_server_protos::api::{GetNodeInfoRequest, GetNodeInfoResponse};
-use ldk_server_protos::api::{
-	GetBalancesRequest, ListChannelsRequest, OnchainReceiveRequest, OpenChannelRequest,
+use ldk_server_json_models::api::{
+	GetBalancesRequest, GetNodeInfoRequest, GetNodeInfoResponse, ListChannelsRequest,
+	OnchainReceiveRequest, OpenChannelRequest,
 };
 
 /// Wrapper around a managed bitcoind process for regtest.
@@ -92,7 +92,7 @@ pub struct LdkServerHandle {
 	pub storage_dir: PathBuf,
 	pub api_key: String,
 	pub tls_cert_path: PathBuf,
-	pub node_id: String,
+	pub node_id: [u8; 33],
 	pub exchange_name: String,
 	client: LdkServerClient,
 }
@@ -201,7 +201,7 @@ client_trusts_lsp = true
 			storage_dir,
 			api_key,
 			tls_cert_path,
-			node_id: String::new(),
+			node_id: [0u8; 33],
 			exchange_name,
 			client,
 		};
@@ -217,7 +217,7 @@ client_trusts_lsp = true
 		&self.client
 	}
 
-	pub fn node_id(&self) -> &str {
+	pub fn node_id(&self) -> &[u8; 33] {
 		&self.node_id
 	}
 
@@ -325,16 +325,14 @@ pub async fn mine_and_sync(
 		let start = std::time::Instant::now();
 		loop {
 			if let Ok(info) = client.get_node_info(GetNodeInfoRequest {}).await {
-				if info.current_best_block.as_ref().map(|b| b.height).unwrap_or(0)
-					>= expected_height as u32
-				{
+				if info.current_best_block.height >= expected_height as u32 {
 					break;
 				}
 			}
 			if start.elapsed() > timeout {
 				panic!(
 					"Timed out waiting for server {} to sync to height {}",
-					server.node_id(),
+					server.node_id().to_lower_hex_string(),
 					expected_height
 				);
 			}
@@ -409,7 +407,7 @@ pub async fn setup_funded_channel(
 	let open_resp = server_a
 		.client()
 		.open_channel(OpenChannelRequest {
-			node_pubkey: server_b.node_id().to_string(),
+			node_pubkey: *server_b.node_id(),
 			address: format!("127.0.0.1:{}", server_b.p2p_port),
 			channel_amount_sats,
 			push_to_counterparty_msat: None,
@@ -502,17 +500,16 @@ impl RabbitMqEventConsumer {
 	/// Consume up to `count` events, waiting up to `timeout` for each.
 	pub async fn consume_events(
 		&mut self, count: usize, timeout: Duration,
-	) -> Vec<ldk_server_protos::events::EventEnvelope> {
+	) -> Vec<ldk_server_json_models::events::Event> {
 		use futures_util::StreamExt;
 		use lapin::options::BasicAckOptions;
-		use prost::Message;
 
 		let mut events = Vec::new();
 		for _ in 0..count {
 			match tokio::time::timeout(timeout, self.consumer.next()).await {
 				Ok(Some(Ok(delivery))) => {
-					let event = ldk_server_protos::events::EventEnvelope::decode(&*delivery.data)
-						.expect("Failed to decode event");
+					let event: ldk_server_json_models::events::Event =
+						serde_json::from_slice(&delivery.data).expect("Failed to decode event");
 					self.channel
 						.basic_ack(delivery.delivery_tag, BasicAckOptions::default())
 						.await