Add test for external node opening channel with LDK

Introduce `do_external_node_opens_channel_simple_transactions_with_ldk` to test external nodes initiating channel opening and performing simple transactions with LDK. Extend ExternalLightningNode trait with `open_channel` and `create_new_address` methods for better support in integration tests.

Author: moisesPompilio

tests/common/external_node.rs

@@ -42,6 +42,10 @@ pub trait ExternalLightningNode {
 	fn check_receive_payment(&mut self, invoice: Bolt11Invoice);
 
 	fn close_channel(&mut self, channel_id: OutPoint, node_id: PublicKey, force: bool);
+
+	fn create_new_address(&mut self) -> String;
+
+	fn open_channel(&mut self, node_id: PublicKey, funding_amount_sat: u64);
 }
 
 static BITCOIND_CLIENT: OnceLock<BitcoindClient> = OnceLock::new();
@@ -249,3 +253,59 @@ pub(crate) fn do_ldk_opens_channel_full_cycle_with_external_node<E: ExternalLigh
 
 	node.stop().unwrap();
 }
+
+pub(crate) fn do_external_node_opens_channel_simple_transactions_with_ldk<
+	E: ExternalLightningNode,
+>(
+	external_node: &mut E,
+) {
+	// Initialize LDK node and clients
+	let (node, bitcoind_client, electrs_client) = setup_test_node(false);
+
+	// setup external node info
+	let (external_node_id, external_node_address) = external_node.get_node_info();
+
+	let addr_string = external_node.create_new_address();
+	let addr = bitcoin::Address::from_str(&addr_string)
+		.unwrap()
+		.require_network(bitcoin::Network::Regtest)
+		.unwrap();
+	let amount = Amount::from_sat(5_000_000);
+	distribute_funds_unconfirmed(bitcoind_client, &electrs_client, vec![addr], amount);
+	generate_blocks_and_wait(bitcoind_client, &electrs_client, 6);
+
+	node.connect(external_node_id, external_node_address.clone(), true).unwrap();
+
+	// Open the channel
+	external_node.open_channel(node.node_id(), 2_000_000);
+	let funding_txo = expect_channel_pending_event!(node, external_node_id);
+	wait_for_tx(&electrs_client, funding_txo.txid);
+	generate_blocks_and_wait(bitcoind_client, &electrs_client, 6);
+	node.sync_wallets().unwrap();
+	let user_channel_id = expect_channel_ready_event!(node, external_node_id);
+
+	// Send a payment to LDK
+	let amount_msat = 100_000_000;
+	receive_payment_from_external_node(&node, external_node, amount_msat);
+	node.sync_wallets().unwrap();
+
+	// Send a payment to the external node
+	let invoice_amount_sat = node.list_channels().first().unwrap().next_outbound_htlc_limit_msat;
+	let invoice: Bolt11Invoice =
+		send_payment_to_external_node(&node, external_node, invoice_amount_sat);
+	check_send_payment_succeeds(&node, external_node, invoice);
+
+	// Close the channel
+	close_channel(
+		&bitcoind_client,
+		&electrs_client,
+		external_node,
+		&node,
+		funding_txo,
+		external_node_id,
+		&user_channel_id,
+		None,
+	);
+
+	node.stop().unwrap();
+}

tests/integration_tests_cln.rs

@@ -21,7 +21,9 @@ use std::default::Default;
 use std::str::FromStr;
 
 use crate::common::external_node::{
-	do_ldk_opens_channel_full_cycle_with_external_node, init_bitcoind_client, ExternalLightningNode,
+	do_external_node_opens_channel_simple_transactions_with_ldk,
+	do_ldk_opens_channel_full_cycle_with_external_node, init_bitcoind_client,
+	ExternalLightningNode,
 };
 
 #[test]
@@ -45,6 +47,13 @@ fn test_cln_initiates_force_channel_close() {
 	do_ldk_opens_channel_full_cycle_with_external_node(&mut client, None);
 }
 
+#[test]
+fn test_cln_opens_channel_with_ldk() {
+	init_bitcoind_client();
+	let mut client = ClnClient::new();
+	do_external_node_opens_channel_simple_transactions_with_ldk(&mut client);
+}
+
 struct ClnClient {
 	pub client: LightningRPC,
 	pub rng: rand::rngs::ThreadRng,
@@ -139,4 +148,18 @@ impl ExternalLightningNode for ClnClient {
 			assert_eq!(response.type_, "mutual");
 		}
 	}
+	fn create_new_address(&mut self) -> String {
+		let address_info = self.client.newaddr(None).unwrap();
+		address_info.bech32.unwrap()
+	}
+
+	fn open_channel(&mut self, node_id: PublicKey, funding_amount_sat: u64) {
+		self.client
+			.fundchannel(
+				&node_id.to_string(),
+				clightningrpc::requests::AmountOrAll::Amount(funding_amount_sat),
+				None,
+			)
+			.unwrap();
+	}
 }

tests/integration_tests_lnd.rs

@@ -184,4 +184,33 @@ impl ExternalLightningNode for LndClient {
 			.block_on(self.client.lightning().close_channel(request))
 			.expect("Failed to initiate close channel on LND");
 	}
+
+	fn create_new_address(&mut self) -> String {
+		let address = self
+			.runtime
+			.block_on(self.client.lightning().new_address(
+				lnd_grpc_rust::lnrpc::NewAddressRequest {
+					r#type: 0, // 0 = WITNESS_PUBKEY_HASH (bech32)
+					account: "".to_string(),
+				},
+			))
+			.expect("Failed to create new address")
+			.into_inner();
+
+		address.address
+	}
+
+	fn open_channel(&mut self, node_id: PublicKey, funding_amount_sat: u64) {
+		let open_channel_request = lnd_grpc_rust::lnrpc::OpenChannelRequest {
+			node_pubkey: node_id.to_public_key().to_bytes().to_vec(),
+			local_funding_amount: funding_amount_sat as i64,
+			sat_per_vbyte: 1,
+			..Default::default()
+		};
+
+		let _stream = self
+			.runtime
+			.block_on(self.client.lightning().open_channel_sync(open_channel_request))
+			.expect("Failed to open channel on LND");
+	}
 }