Implement Eclair ExternalNode via reqwest REST API

- Implement ExternalNode trait with 60s request timeout and settlement polling for pay_invoice/send_keysend
- Override wait_for_block_sync() to poll /getinfo until chain tip is reached

Author: febyeji

Cargo.toml

@@ -106,6 +106,9 @@ 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 }
 
@@ -124,6 +127,7 @@ check-cfg = [
 	"cfg(tokio_unstable)",
 	"cfg(cln_test)",
 	"cfg(lnd_test)",
+	"cfg(eclair_test)",
 	"cfg(cycle_tests)",
 ]
 

tests/common/eclair.rs

@@ -0,0 +1,329 @@
+// This file is Copyright its original authors, visible in version control history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
+// accordance with one or both of these licenses.
+
+use std::str::FromStr;
+
+use async_trait::async_trait;
+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,
+	listen_addr: SocketAddress,
+}
+
+impl TestEclairNode {
+	pub(crate) fn new(base_url: &str, password: &str, listen_addr: SocketAddress) -> Self {
+		Self {
+			client: Client::new(),
+			base_url: base_url.to_string(),
+			password: password.to_string(),
+			listen_addr,
+		}
+	}
+
+	pub(crate) fn from_env() -> Self {
+		let base_url =
+			std::env::var("ECLAIR_API_URL").unwrap_or_else(|_| "http://127.0.0.1:8080".to_string());
+		let password =
+			std::env::var("ECLAIR_API_PASSWORD").unwrap_or_else(|_| "eclairpassword".to_string());
+		let listen_addr: SocketAddress = std::env::var("ECLAIR_P2P_ADDR")
+			.unwrap_or_else(|_| "127.0.0.1:9736".to_string())
+			.parse()
+			.unwrap();
+		Self::new(&base_url, &password, listen_addr)
+	}
+
+	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 status = response.status();
+		let body = response
+			.text()
+			.await
+			.map_err(|e| self.make_error(format!("reading response from {}: {}", endpoint, e)))?;
+
+		if !status.is_success() {
+			return Err(self.make_error(format!("{} returned {}: {}", endpoint, status, body)));
+		}
+
+		serde_json::from_str(&body).map_err(|e| {
+			self.make_error(format!("parsing response from {}: {} (body: {})", endpoint, e, body))
+		})
+	}
+
+	fn make_error(&self, detail: String) -> TestFailure {
+		TestFailure::ExternalNodeError { node: "Eclair".to_string(), detail }
+	}
+
+	/// Poll /getsentinfo until the payment settles or fails.
+	/// Eclair's pay/keysend APIs are fire-and-forget, so without polling
+	/// the caller would hang on the LDK event timeout when a payment fails.
+	async fn poll_payment_settlement(
+		&self, payment_id: &str, label: &str,
+	) -> Result<String, TestFailure> {
+		let timeout_secs = super::INTEROP_TIMEOUT_SECS;
+		let deadline = tokio::time::Instant::now() + tokio::time::Duration::from_secs(timeout_secs);
+		loop {
+			if tokio::time::Instant::now() >= deadline {
+				return Err(self.make_error(format!(
+					"{} {} did not settle within {}s",
+					label, payment_id, timeout_secs
+				)));
+			}
+			tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
+			let info = self.post("/getsentinfo", &[("id", payment_id)]).await?;
+			if let Some(attempts) = info.as_array() {
+				if let Some(last) = attempts.last() {
+					let status = last["status"]["type"].as_str().unwrap_or("");
+					if status == "sent" {
+						return Ok(payment_id.to_string());
+					} else if status == "failed" {
+						let failure = last["status"]["failures"]
+							.as_array()
+							.and_then(|f| f.last())
+							.and_then(|f| f["failureMessage"].as_str())
+							.unwrap_or("unknown");
+						return Err(self
+							.make_error(format!("{} {} failed: {}", label, payment_id, failure)));
+					}
+				}
+			}
+		}
+	}
+}
+
+#[async_trait]
+impl ExternalNode for TestEclairNode {
+	fn name(&self) -> &str {
+		"Eclair"
+	}
+
+	async fn get_node_id(&self) -> Result<PublicKey, TestFailure> {
+		let info = self.post("/getinfo", &[]).await?;
+		let node_id_str = info["nodeId"]
+			.as_str()
+			.ok_or_else(|| self.make_error("missing nodeId in getinfo response".to_string()))?;
+		PublicKey::from_str(node_id_str)
+			.map_err(|e| self.make_error(format!("parse nodeId: {}", e)))
+	}
+
+	async fn get_listening_address(&self) -> Result<SocketAddress, TestFailure> {
+		Ok(self.listen_addr.clone())
+	}
+
+	async fn get_block_height(&self) -> Result<u64, TestFailure> {
+		let info = self.post("/getinfo", &[]).await?;
+		info["blockHeight"]
+			.as_u64()
+			.ok_or_else(|| self.make_error("missing blockHeight in getinfo response".to_string()))
+	}
+
+	async fn wait_for_block_sync(&self, min_height: u64) -> Result<(), TestFailure> {
+		for i in 0..60 {
+			match self.get_block_height().await {
+				Ok(h) if h >= min_height => return Ok(()),
+				Ok(h) => {
+					if i % 10 == 0 {
+						println!(
+							"Waiting for {} to reach height {} (currently at {})...",
+							self.name(),
+							min_height,
+							h
+						);
+					}
+				},
+				Err(e) => {
+					if i % 10 == 0 {
+						eprintln!("wait_for_block_sync: get_block_height error: {}", e);
+					}
+				},
+			}
+			tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+		}
+		Err(self.make_error(format!("did not reach height {} after 60s", min_height)))
+	}
+
+	async fn connect_peer(
+		&self, peer_id: PublicKey, addr: SocketAddress,
+	) -> Result<(), TestFailure> {
+		let uri = format!("{}@{}", peer_id, addr);
+		self.post("/connect", &[("uri", &uri)]).await?;
+		Ok(())
+	}
+
+	async fn disconnect_peer(&self, peer_id: PublicKey) -> Result<(), TestFailure> {
+		self.post("/disconnect", &[("nodeId", &peer_id.to_string())]).await?;
+		Ok(())
+	}
+
+	async fn open_channel(
+		&self, peer_id: PublicKey, _addr: SocketAddress, capacity_sat: u64, push_msat: Option<u64>,
+	) -> Result<String, TestFailure> {
+		let node_id = peer_id.to_string();
+		let capacity = capacity_sat.to_string();
+		let push_str = push_msat.map(|m| m.to_string());
+
+		let mut params = vec![("nodeId", node_id.as_str()), ("fundingSatoshis", capacity.as_str())];
+		if let Some(ref push) = push_str {
+			params.push(("pushMsat", push.as_str()));
+		}
+
+		let result = self.post("/open", &params).await?;
+		let channel_id = result
+			.as_str()
+			.map(|s| s.to_string())
+			.or_else(|| result["channelId"].as_str().map(|s| s.to_string()))
+			.ok_or_else(|| {
+				self.make_error(format!("open did not return channel id: {}", result))
+			})?;
+		Ok(channel_id)
+	}
+
+	async fn close_channel(&self, channel_id: &str) -> Result<(), TestFailure> {
+		self.post("/close", &[("channelId", channel_id)]).await?;
+		Ok(())
+	}
+
+	async fn force_close_channel(&self, channel_id: &str) -> Result<(), TestFailure> {
+		self.post("/forceclose", &[("channelId", channel_id)]).await?;
+		Ok(())
+	}
+
+	async fn create_invoice(
+		&self, amount_msat: u64, description: &str,
+	) -> Result<String, TestFailure> {
+		let amount_str = amount_msat.to_string();
+		let result = self
+			.post("/createinvoice", &[("amountMsat", &amount_str), ("description", description)])
+			.await?;
+		let invoice = result["serialized"]
+			.as_str()
+			.ok_or_else(|| self.make_error("missing serialized in invoice response".to_string()))?;
+		Ok(invoice.to_string())
+	}
+
+	async fn pay_invoice(&self, invoice: &str) -> Result<String, TestFailure> {
+		let result = self.post("/payinvoice", &[("invoice", invoice)]).await?;
+		let payment_id = result
+			.as_str()
+			.filter(|s| !s.is_empty())
+			.ok_or_else(|| self.make_error("payinvoice did not return payment id".to_string()))?
+			.to_string();
+		self.poll_payment_settlement(&payment_id, "payment").await
+	}
+
+	async fn send_keysend(
+		&self, peer_id: PublicKey, amount_msat: u64,
+	) -> Result<String, TestFailure> {
+		let amount_str = amount_msat.to_string();
+		let node_id_str = peer_id.to_string();
+		let result = self
+			.post("/sendtonode", &[("nodeId", &node_id_str), ("amountMsat", &amount_str)])
+			.await?;
+		let payment_id = result
+			.as_str()
+			.filter(|s| !s.is_empty())
+			.ok_or_else(|| self.make_error("sendtonode did not return payment id".to_string()))?
+			.to_string();
+		self.poll_payment_settlement(&payment_id, "keysend").await
+	}
+
+	async fn get_funding_address(&self) -> Result<String, TestFailure> {
+		let result = self.post("/getnewaddress", &[]).await?;
+		result
+			.as_str()
+			.map(|s| s.to_string())
+			.ok_or_else(|| self.make_error("getnewaddress did not return string".to_string()))
+	}
+
+	async fn splice_in(&self, channel_id: &str, amount_sat: u64) -> Result<(), TestFailure> {
+		let amount_str = amount_sat.to_string();
+		self.post("/splicein", &[("channelId", channel_id), ("amountIn", &amount_str)]).await?;
+		Ok(())
+	}
+
+	async fn splice_out(
+		&self, channel_id: &str, amount_sat: u64, address: Option<&str>,
+	) -> Result<(), TestFailure> {
+		let addr = address
+			.ok_or_else(|| self.make_error("Eclair splice_out requires an address".to_string()))?;
+		let amount_str = amount_sat.to_string();
+		self.post(
+			"/spliceout",
+			&[("channelId", channel_id), ("amountOut", &amount_str), ("address", addr)],
+		)
+		.await?;
+		Ok(())
+	}
+
+	async fn list_channels(&self) -> Result<Vec<ExternalChannel>, TestFailure> {
+		let result = self.post("/channels", &[]).await?;
+		let channels_arr = result
+			.as_array()
+			.ok_or_else(|| self.make_error("/channels did not return array".to_string()))?;
+
+		let mut channels = Vec::new();
+		for ch in channels_arr {
+			let channel_id = ch["channelId"]
+				.as_str()
+				.ok_or_else(|| self.make_error("list_channels: missing channelId".to_string()))?
+				.to_string();
+			let node_id_str = ch["nodeId"]
+				.as_str()
+				.ok_or_else(|| self.make_error("list_channels: missing nodeId".to_string()))?;
+			let peer_id = PublicKey::from_str(node_id_str).map_err(|e| {
+				self.make_error(format!("list_channels: invalid nodeId '{}': {}", node_id_str, e))
+			})?;
+			let state_str = ch["state"].as_str().unwrap_or("");
+			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
+					))
+				})?;
+
+			let capacity_sat =
+				active_commitment["fundingTx"]["amountSatoshis"].as_u64().unwrap_or(0);
+			let funding_txid =
+				active_commitment["fundingTx"]["txid"].as_str().map(|s| s.to_string());
+			let local_balance_msat =
+				active_commitment["localCommit"]["spec"]["toLocal"].as_u64().unwrap_or(0);
+			let remote_balance_msat =
+				active_commitment["localCommit"]["spec"]["toRemote"].as_u64().unwrap_or(0);
+
+			channels.push(ExternalChannel {
+				channel_id,
+				peer_id,
+				capacity_sat,
+				local_balance_msat,
+				remote_balance_msat,
+				funding_txid,
+				is_active: state_str == "NORMAL",
+			});
+		}
+		Ok(channels)
+	}
+}

tests/common/mod.rs

@@ -11,6 +11,8 @@
 pub(crate) mod external_node;
 pub(crate) mod logging;
 
+#[cfg(eclair_test)]
+pub(crate) mod eclair;
 #[cfg(lnd_test)]
 pub(crate) mod lnd;