feat: implement LND integration tests with lnd_grpc_rust

Adds tests to:
- Open a payment channel with LND.
- Request and pay an invoice, verifying receipt.
- Generate an invoice for LND to pay, verifying receipt.
Uses lnd_grpc_rust for gRPC communication.

Closes lightningdevkit#505

Author: moisesPompilio

Cargo.toml

@@ -106,6 +106,10 @@ electrsd = { version = "0.29.0", features = ["legacy"] }
 [target.'cfg(cln_test)'.dev-dependencies]
 clightningrpc = { version = "0.3.0-beta.8", default-features = false }
 
+[target.'cfg(lnd_test)'.dev-dependencies]
+lnd_grpc_rust = { version = "2.10.0", default-features = false }
+tokio = { version = "1.37", features = ["fs"] }
+
 [build-dependencies]
 uniffi = { version = "0.27.3", features = ["build"], optional = true }
 
@@ -123,4 +127,5 @@ check-cfg = [
 	"cfg(ldk_bench)",
 	"cfg(tokio_unstable)",
 	"cfg(cln_test)",
+	"cfg(lnd_test)",
 ]

tests/common/mod.rs

@@ -5,7 +5,7 @@
 // http://opensource.org/licenses/MIT>, at your option. You may not use this file except in
 // accordance with one or both of these licenses.
 
-#![cfg(any(test, cln_test, vss_test))]
+#![cfg(any(test, cln_test, lnd_test, vss_test))]
 #![allow(dead_code)]
 
 pub(crate) mod logging;

tests/integration_tests_lnd.rs

@@ -0,0 +1,163 @@
+#![cfg(lnd_test)]
+
+mod common;
+
+use ldk_node::bitcoin::secp256k1::PublicKey;
+use ldk_node::bitcoin::Amount;
+use ldk_node::lightning::ln::msgs::SocketAddress;
+use ldk_node::{Builder, Event};
+
+use lnd_grpc_rust::lnrpc::{
+	invoice::InvoiceState::Settled, GetInfoRequest, GetInfoResponse, Invoice, ListInvoiceRequest,
+	SendRequest, SendResponse,
+};
+use lnd_grpc_rust::{connect, LndClient};
+
+use bitcoincore_rpc::Auth;
+use bitcoincore_rpc::Client as BitcoindClient;
+
+use electrum_client::Client as ElectrumClient;
+use lightning_invoice::{Bolt11InvoiceDescription, Description};
+
+use rand::distributions::Alphanumeric;
+use rand::{thread_rng, Rng};
+
+use bitcoin::hex::DisplayHex;
+
+use std::default::Default;
+use std::error::Error;
+use std::str::FromStr;
+use std::time::Duration;
+use tokio::fs;
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+async fn test_lnd() {
+	// Setup bitcoind / electrs clients
+	let bitcoind_client = BitcoindClient::new(
+		"127.0.0.1:18443",
+		Auth::UserPass("user".to_string(), "pass".to_string()),
+	)
+	.unwrap();
+	let electrs_client = ElectrumClient::new("tcp://127.0.0.1:50001").unwrap();
+
+	// Give electrs a kick.
+	common::generate_blocks_and_wait(&bitcoind_client, &electrs_client, 1);
+
+	// Setup LDK Node
+	let config = common::random_config(true);
+	let mut builder = Builder::from_config(config.node_config);
+	builder.set_chain_source_esplora("http://127.0.0.1:3002".to_string(), None);
+
+	let node = builder.build().unwrap();
+	node.start().unwrap();
+
+	// Premine some funds and distribute
+	let address = node.onchain_payment().new_address().unwrap();
+	let premine_amount = Amount::from_sat(5_000_000);
+	common::premine_and_distribute_funds(
+		&bitcoind_client,
+		&electrs_client,
+		vec![address],
+		premine_amount,
+	);
+
+	// Setup LND
+	let endpoint = "127.0.0.1:8081";
+	let cert_path = std::env::var("LND_CERT_PATH").expect("LND_CERT_PATH not set");
+	let macaroon_path = std::env::var("LND_MACAROON_PATH").expect("LND_MACAROON_PATH not set");
+	let mut lnd = TestLndClient::new(cert_path, macaroon_path, endpoint.to_string()).await.unwrap();
+
+	let lnd_node_info = lnd.get_node_info().await.unwrap();
+	let lnd_node_id = PublicKey::from_str(&lnd_node_info.identity_pubkey).unwrap();
+	let lnd_address: SocketAddress = "127.0.0.1:9735".parse().unwrap();
+
+	node.sync_wallets().unwrap();
+
+	// Open the channel
+	let funding_amount_sat = 1_000_000;
+
+	node.open_channel(lnd_node_id, lnd_address, funding_amount_sat, Some(500_000_000), None)
+		.unwrap();
+
+	let funding_txo = common::expect_channel_pending_event!(node, lnd_node_id);
+	common::wait_for_tx(&electrs_client, funding_txo.txid);
+	common::generate_blocks_and_wait(&bitcoind_client, &electrs_client, 6);
+	node.sync_wallets().unwrap();
+	let user_channel_id = common::expect_channel_ready_event!(node, lnd_node_id);
+
+	// Send a payment to LND
+	let lnd_invoice = lnd.create_invoice(100_000_000).await.unwrap();
+	let parsed_invoice = lightning_invoice::Bolt11Invoice::from_str(&lnd_invoice).unwrap();
+
+	node.bolt11_payment().send(&parsed_invoice, None).unwrap();
+	common::expect_event!(node, PaymentSuccessful);
+	let lnd_listed_invoices = lnd.list_invoices().await.unwrap();
+	assert_eq!(lnd_listed_invoices.len(), 1);
+	assert_eq!(lnd_listed_invoices.first().unwrap().state, Settled as i32);
+
+	// Sleep to process payment in LND
+	tokio::time::sleep(Duration::from_secs(1)).await;
+
+	// Send a payment to LDK
+	let mut rng = thread_rng();
+	let rand_label: String = (0..7).map(|_| rng.sample(Alphanumeric) as char).collect();
+	let invoice_description =
+		Bolt11InvoiceDescription::Direct(Description::new(rand_label).unwrap());
+	let ldk_invoice = node.bolt11_payment().receive(9_000_000, &invoice_description, 3600).unwrap();
+	lnd.pay_invoice(&ldk_invoice.to_string()).await.unwrap();
+	common::expect_event!(node, PaymentReceived);
+
+	node.close_channel(&user_channel_id, lnd_node_id).unwrap();
+	common::expect_event!(node, ChannelClosed);
+	node.stop().unwrap();
+}
+
+struct TestLndClient {
+	client: LndClient,
+}
+
+impl TestLndClient {
+	async fn new(
+		cert_path: String, macaroon_path: String, socket: String,
+	) -> Result<Self, Box<dyn Error>> {
+		// Read the contents of the file into a vector of bytes
+		let cert_bytes = fs::read(cert_path).await.expect("FailedToReadTlsCertFile");
+		let mac_bytes = fs::read(macaroon_path).await.expect("FailedToReadMacaroonFile");
+
+		// Convert the bytes to a hex string
+		let cert = cert_bytes.as_hex().to_string();
+		let macaroon = mac_bytes.as_hex().to_string();
+
+		let client = connect(cert, macaroon, socket).await?;
+		Ok(TestLndClient { client })
+	}
+
+	async fn get_node_info(&mut self) -> Result<GetInfoResponse, Box<dyn Error>> {
+		let response = self.client.lightning().get_info(GetInfoRequest {}).await?.into_inner();
+		Ok(response)
+	}
+
+	async fn create_invoice(&mut self, amount_msat: u64) -> Result<String, Box<dyn Error>> {
+		let invoice = Invoice { value_msat: amount_msat as i64, ..Default::default() };
+		let response = self.client.lightning().add_invoice(invoice).await?.into_inner();
+		Ok(response.payment_request)
+	}
+
+	async fn list_invoices(&mut self) -> Result<Vec<Invoice>, Box<dyn Error>> {
+		let response = self
+			.client
+			.lightning()
+			.list_invoices(ListInvoiceRequest { ..Default::default() })
+			.await?
+			.into_inner();
+
+		Ok(response.invoices)
+	}
+
+	async fn pay_invoice(&mut self, invoice_str: &str) -> Result<SendResponse, Box<dyn Error>> {
+		let send_req =
+			SendRequest { payment_request: invoice_str.to_string(), ..Default::default() };
+		let response = self.client.lightning().send_payment_sync(send_req).await?.into_inner();
+		Ok(response)
+	}
+}