refactor(eclair): replace reqwest/curl with bitreq and simplify test setup

Address review feedback on PR #839:
- Replace reqwest dependency with bitreq for Eclair REST client
- Replace curl shell calls with bitreq async HTTP requests
- Remove per-test docker container recreation (reuse single
  Eclair instance, unlock UTXOs between tests instead)
- Fix chmod -R 755 to u+rwX,go+rX in CLN/LND CI workflows
- Add --fail flag to curl readiness check in Eclair CI

Author: febyeji

.github/workflows/cln-integration.yml

@@ -65,7 +65,7 @@ jobs:
       - name: Set permissions for CLN data directory
         run: |
           sudo chown -R $(id -u):$(id -g) $CLN_DATA_DIR
-          sudo chmod -R 755 $CLN_DATA_DIR
+          sudo chmod -R u+rwX,go+rX $CLN_DATA_DIR
         env:
           CLN_DATA_DIR: ${{ env.CLN_DATA_DIR }}
 

.github/workflows/eclair-integration.yml

@@ -41,7 +41,7 @@ jobs:
       - name: Wait for Eclair to be ready
         run: |
           for i in $(seq 1 60); do
-            if curl -s -u :eclairpassword -X POST http://127.0.0.1:8080/getinfo > /dev/null 2>&1; then
+            if curl -sf -u :eclairpassword -X POST http://127.0.0.1:8080/getinfo > /dev/null 2>&1; then
               echo "Eclair is ready"
               exit 0
             fi

.github/workflows/lnd-integration.yml

@@ -54,7 +54,7 @@ jobs:
           }
 
       - name: Set permissions for LND data directory
-        run: sudo chmod -R 755 $LND_DATA_DIR
+        run: sudo chmod -R u+rwX,go+rX $LND_DATA_DIR
         env:
           LND_DATA_DIR: ${{ env.LND_DATA_DIR }}
 

Cargo.toml

@@ -108,9 +108,6 @@ clightningrpc = { version = "0.3.0-beta.8", default-features = false }
 lnd_grpc_rust = { version = "2.14.0", default-features = false }
 tokio = { version = "1.37", features = ["fs"] }
 
-[target.'cfg(eclair_test)'.dev-dependencies]
-reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
-
 [build-dependencies]
 uniffi = { version = "0.29.5", features = ["build"], optional = true }
 

tests/common/eclair.rs

@@ -8,26 +8,25 @@
 use std::str::FromStr;
 
 use async_trait::async_trait;
+use base64::prelude::{Engine as _, BASE64_STANDARD};
 use ldk_node::bitcoin::secp256k1::PublicKey;
 use ldk_node::lightning::ln::msgs::SocketAddress;
-use reqwest::Client;
 use serde_json::Value;
 
 use super::external_node::{ExternalChannel, ExternalNode, TestFailure};
 
 pub(crate) struct TestEclairNode {
-	client: Client,
 	base_url: String,
-	password: String,
+	auth_header: String,
 	listen_addr: SocketAddress,
 }
 
 impl TestEclairNode {
 	pub(crate) fn new(base_url: &str, password: &str, listen_addr: SocketAddress) -> Self {
+		let credentials = BASE64_STANDARD.encode(format!(":{}", password));
 		Self {
-			client: Client::new(),
 			base_url: base_url.to_string(),
-			password: password.to_string(),
+			auth_header: format!("Basic {}", credentials),
 			listen_addr,
 		}
 	}
@@ -46,27 +45,36 @@ impl TestEclairNode {
 
 	async fn post(&self, endpoint: &str, params: &[(&str, &str)]) -> Result<Value, TestFailure> {
 		let url = format!("{}{}", self.base_url, endpoint);
-		let response = self
-			.client
-			.post(&url)
-			.basic_auth("", Some(&self.password))
-			.form(params)
-			.send()
-			.await
-			.map_err(|e| self.make_error(format!("request to {} failed: {}", endpoint, e)))?;
+		let body = params.iter().map(|(k, v)| format!("{}={}", k, v)).collect::<Vec<_>>().join("&");
 
-		let status = response.status();
-		let body = response
-			.text()
+		let request = bitreq::post(&url)
+			.with_header("Authorization", &self.auth_header)
+			.with_header("Content-Type", "application/x-www-form-urlencoded")
+			.with_body(body)
+			.with_timeout(30);
+
+		let response = request
+			.send_async()
 			.await
-			.map_err(|e| self.make_error(format!("reading response from {}: {}", endpoint, e)))?;
+			.map_err(|e| self.make_error(format!("request to {} failed: {}", endpoint, e)))?;
 
-		if !status.is_success() {
-			return Err(self.make_error(format!("{} returned {}: {}", endpoint, status, body)));
+		if response.status_code < 200 || response.status_code >= 300 {
+			let body_str = response.as_str().unwrap_or("(non-utf8 body)");
+			return Err(self.make_error(format!(
+				"{} returned {}: {}",
+				endpoint, response.status_code, body_str
+			)));
 		}
 
-		serde_json::from_str(&body).map_err(|e| {
-			self.make_error(format!("parsing response from {}: {} (body: {})", endpoint, e, body))
+		let body_str = response
+			.as_str()
+			.map_err(|e| self.make_error(format!("reading response from {}: {}", endpoint, e)))?;
+
+		serde_json::from_str(body_str).map_err(|e| {
+			self.make_error(format!(
+				"parsing response from {}: {} (body: {})",
+				endpoint, e, body_str
+			))
 		})
 	}
 
@@ -297,13 +305,11 @@ impl ExternalNode for TestEclairNode {
 			let commitments = &ch["data"]["commitments"];
 
 			// Eclair 0.10+ uses commitments.active[] array (splice support).
-			let active_commitment =
-				commitments["active"].as_array().and_then(|a| a.first()).ok_or_else(|| {
-					self.make_error(format!(
-						"list_channels: missing commitments.active[] for channel {}",
-						channel_id
-					))
-				})?;
+			// Closed/closing channels may lack active commitments — skip them.
+			let active_commitment = match commitments["active"].as_array().and_then(|a| a.first()) {
+				Some(c) => c,
+				None => continue,
+			};
 
 			let capacity_sat =
 				active_commitment["fundingTx"]["amountSatoshis"].as_u64().unwrap_or(0);

tests/integration_tests_eclair.rs

@@ -11,6 +11,7 @@ mod common;
 
 use std::str::FromStr;
 
+use base64::prelude::{Engine as _, BASE64_STANDARD};
 use common::eclair::TestEclairNode;
 use common::external_node::ExternalNode;
 use common::scenarios::channel::{
@@ -31,13 +32,17 @@ use electrsd::corepc_node::Client as BitcoindClient;
 use electrum_client::Client as ElectrumClient;
 use ldk_node::{Builder, Event};
 
-/// Run a shell command via `spawn_blocking` to avoid blocking the tokio runtime.
-async fn run_cmd(program: &str, args: &[&str]) -> std::io::Result<std::process::Output> {
-	let program = program.to_string();
-	let args: Vec<String> = args.iter().map(|s| s.to_string()).collect();
-	tokio::task::spawn_blocking(move || std::process::Command::new(&program).args(&args).output())
-		.await
-		.expect("spawn_blocking panicked")
+/// Unlock all UTXOs in the given bitcoind wallet via JSON-RPC.
+async fn unlock_utxos(wallet_url: &str, user: &str, pass: &str) {
+	let auth = BASE64_STANDARD.encode(format!("{}:{}", user, pass));
+	let body = r#"{"jsonrpc":"1.0","method":"lockunspent","params":[true]}"#;
+	let _ = bitreq::post(wallet_url)
+		.with_header("Authorization", format!("Basic {}", auth))
+		.with_header("Content-Type", "text/plain")
+		.with_body(body)
+		.with_timeout(5)
+		.send_async()
+		.await;
 }
 
 async fn setup_clients() -> (BitcoindClient, ElectrumClient, TestEclairNode) {
@@ -53,99 +58,8 @@ async fn setup_clients() -> (BitcoindClient, ElectrumClient, TestEclairNode) {
 	.unwrap();
 	let electrs = ElectrumClient::new("tcp://127.0.0.1:50001").unwrap();
 
-	// Recreate the Eclair container between tests to give a fresh /data
-	// directory, a new seed, and a clean initialization against the current
-	// chain tip.
-	let container_name =
-		std::env::var("ECLAIR_CONTAINER_NAME").unwrap_or_else(|_| "ldk-node-eclair-1".to_string());
-	run_cmd("docker", &["rm", "-f", &container_name]).await.ok();
-
-	// Unlock UTXOs and start Eclair, retrying if locked UTXOs remain.
-	// Force-close transactions can lock new UTXOs between the unlock call
-	// and Eclair startup, so we may need multiple attempts.
-	let deadline = std::time::Instant::now() + std::time::Duration::from_secs(90);
-	let mut attempt = 0;
-	loop {
-		// Unlock any UTXOs left locked in the Eclair wallet.
-		run_cmd(
-			"curl",
-			&[
-				"-s",
-				"--max-time",
-				"5",
-				"--user",
-				"user:pass",
-				"--data-binary",
-				r#"{"jsonrpc":"1.0","method":"lockunspent","params":[true]}"#,
-				"-H",
-				"content-type: text/plain;",
-				"http://127.0.0.1:18443/wallet/eclair",
-			],
-		)
-		.await
-		.ok();
-
-		if attempt > 0 {
-			// On retry, recreate the container since Eclair exited.
-			run_cmd("docker", &["rm", "-f", &container_name]).await.ok();
-		}
-		let output = run_cmd(
-			"docker",
-			&["compose", "-f", "docker-compose-eclair.yml", "up", "-d", "eclair"],
-		)
-		.await
-		.expect("failed to spawn docker compose");
-		assert!(
-			output.status.success(),
-			"docker compose up failed (exit {}): {}",
-			output.status,
-			String::from_utf8_lossy(&output.stderr),
-		);
-
-		// Wait for Eclair to become ready.
-		let mut ready = false;
-		for _ in 0..30 {
-			if std::time::Instant::now() >= deadline {
-				let logs = run_cmd("docker", &["logs", "--tail", "50", &container_name]).await.ok();
-				if let Some(l) = logs {
-					eprintln!(
-						"=== Eclair container logs ===\n{}{}",
-						String::from_utf8_lossy(&l.stdout),
-						String::from_utf8_lossy(&l.stderr)
-					);
-				}
-				panic!("Eclair did not start within 90s (after {} attempts)", attempt + 1);
-			}
-			tokio::time::sleep(std::time::Duration::from_secs(1)).await;
-			ready = run_cmd(
-				"curl",
-				&[
-					"-s",
-					"--max-time",
-					"2",
-					"-u",
-					":eclairpassword",
-					"-X",
-					"POST",
-					"http://127.0.0.1:8080/getinfo",
-				],
-			)
-			.await
-			.map(|o| o.status.success() && !o.stdout.is_empty())
-			.unwrap_or(false);
-			if ready {
-				break;
-			}
-		}
-
-		if ready {
-			break;
-		}
-
-		// Eclair likely failed due to locked UTXOs — retry.
-		attempt += 1;
-		eprintln!("Eclair failed to start (attempt {}), retrying after lockunspent...", attempt);
-	}
+	// Unlock any UTXOs left locked by previous force-close tests.
+	unlock_utxos("http://127.0.0.1:18443/wallet/eclair", "user", "pass").await;
 
 	let eclair = TestEclairNode::from_env();
 	(bitcoind, electrs, eclair)