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 #505

Author: moisesPompilio

Cargo.toml

@@ -106,6 +106,9 @@ 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 = "2.10.0"
+
 [build-dependencies]
 uniffi = { version = "0.27.3", features = ["build"], optional = true }
 
@@ -123,4 +126,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,181 @@
+#![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 std::{fs, thread};
+
+#[test]
+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 = "./data_lnd/tls.cert".to_string();
+	let macaroon_path = "./data_lnd/data/chain/bitcoin/regtest/admin.macaroon".to_string();
+	let mut lnd = ClientLnd::new(cert_path, macaroon_path, endpoint.to_string()).unwrap();
+
+	let info = lnd.get_node_info().unwrap();
+	let lnd_node_pubkey = info.identity_pubkey;
+	let lnd_node_id = PublicKey::from_str(&lnd_node_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 mut rng = thread_rng();
+	let rand_label: String = (0..7).map(|_| rng.sample(Alphanumeric) as char).collect();
+	let lnd_invoice = lnd.create_invoice(100_000_000, rand_label).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);
+	lnd.check_invoice_paid(&lnd_invoice).unwrap();
+
+	// Sleep to process payment in LND
+	thread::sleep(Duration::from_secs(1));
+
+	// Send a payment to LDK
+	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()).unwrap();
+	common::expect_event!(node, PaymentReceived);
+
+	node.close_channel(&user_channel_id, lnd_node_id).unwrap();
+	common::expect_event!(node, ChannelClosed);
+	node.stop().unwrap();
+}
+
+macro_rules! async_block {
+	($expr:expr) => {{
+		let rt = tokio::runtime::Runtime::new().expect("Failed to create Tokio runtime");
+		rt.block_on($expr)
+	}};
+}
+
+pub struct ClientLnd {
+	client: LndClient,
+}
+
+impl ClientLnd {
+	pub fn new(cert: String, macaroon: 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).expect("FailedToReadTlsCertFile");
+		let mac_bytes = fs::read(macaroon).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 = async_block!(connect(cert, macaroon, socket))?;
+		Ok(ClientLnd { client })
+	}
+
+	pub fn get_node_info(&mut self) -> Result<GetInfoResponse, Box<dyn Error>> {
+		let response =
+			async_block!(self.client.lightning().get_info(GetInfoRequest {}))?.into_inner();
+		Ok(response)
+	}
+
+	pub fn create_invoice(
+		&mut self, amount_msat: u64, memo: String,
+	) -> Result<String, Box<dyn Error>> {
+		let invoice = Invoice { value_msat: amount_msat as i64, memo, ..Default::default() };
+		let response = async_block!(self.client.lightning().add_invoice(invoice))?.into_inner();
+		Ok(response.payment_request)
+	}
+
+	pub fn check_invoice_paid(&mut self, payment_request: &str) -> Result<(), Box<dyn Error>> {
+		let response = async_block!(self
+			.client
+			.lightning()
+			.list_invoices(ListInvoiceRequest { pending_only: false, ..Default::default() }))?
+		.into_inner();
+
+		if let Some(invoice) =
+			response.invoices.iter().find(|inv| inv.payment_request == payment_request)
+		{
+			if invoice.state == Settled as i32 {
+				Ok(())
+			} else {
+				panic!("InvoiceNotPaid");
+			}
+		} else {
+			panic!("InvoiceNotFound");
+		}
+	}
+
+	pub 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 =
+			async_block!(self.client.lightning().send_payment_sync(send_req))?.into_inner();
+		Ok(response)
+	}
+}