f Cleanup client-trusts-LSP/LSP-trusts-client test cases somewhat

Author: tnull

tests/integration_tests_rust.rs

@@ -1912,6 +1912,7 @@ async fn lsps2_client_trusts_lsp() {
 	client_builder.set_liquidity_source_lsps2(service_node_id, service_addr.clone(), None);
 	let client_node = client_builder.build().unwrap();
 	client_node.start().unwrap();
+	let client_node_id = client_node.node_id();
 
 	let payer_config = random_config(true);
 	setup_builder!(payer_builder, payer_config.node_config);
@@ -1945,8 +1946,6 @@ async fn lsps2_client_trusts_lsp() {
 	expect_channel_ready_event!(payer_node, service_node.node_id());
 	expect_channel_ready_event!(service_node, payer_node.node_id());
 
-	let initial_mempool_size = bitcoind.client.get_raw_mempool().unwrap().0.len();
-
 	let invoice_description =
 		Bolt11InvoiceDescription::Direct(Description::new(String::from("asdf")).unwrap());
 	let jit_amount_msat = 100_000_000;
@@ -1969,21 +1968,41 @@ async fn lsps2_client_trusts_lsp() {
 	println!("Paying JIT invoice!");
 	let payment_id = payer_node.bolt11_payment().send(&res, None).unwrap();
 	println!("Payment ID: {:?}", payment_id);
-	expect_channel_pending_event!(service_node, client_node.node_id());
+	let funding_txo = expect_channel_pending_event!(service_node, client_node.node_id());
 	expect_channel_ready_event!(service_node, client_node.node_id());
 	expect_channel_pending_event!(client_node, service_node.node_id());
 	expect_channel_ready_event!(client_node, service_node.node_id());
+
+	// Check the fundign transaction hasn't broadcasted yet and nodes aren't seeing it.
 	println!("Try to find funding tx... It won't be found yet, as the client has not claimed it.");
-	let mut funding_tx_found = false;
-	for _ in 0..50 {
-		std::thread::sleep(std::time::Duration::from_millis(100));
-		let current_mempool = bitcoind.client.get_raw_mempool().unwrap();
-		if current_mempool.0.len() > initial_mempool_size {
-			funding_tx_found = true;
-			break;
-		}
+	for _ in 0..30 {
+		tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+		let mempool = bitcoind.client.get_raw_mempool().unwrap().into_model().unwrap();
+		let funding_tx_found = mempool.0.iter().any(|txid| *txid == funding_txo.txid);
+		assert!(!funding_tx_found, "Funding transaction should NOT be broadcast yet");
 	}
-	assert!(!funding_tx_found, "Funding transaction should NOT be broadcast yet");
+	service_node.sync_wallets().unwrap();
+	client_node.sync_wallets().unwrap();
+	assert_eq!(
+		client_node
+			.list_channels()
+			.iter()
+			.find(|c| c.counterparty_node_id == service_node_id)
+			.unwrap()
+			.confirmations,
+		Some(0)
+	);
+	assert_eq!(
+		service_node
+			.list_channels()
+			.iter()
+			.find(|c| c.counterparty_node_id == client_node_id)
+			.unwrap()
+			.confirmations,
+		Some(0)
+	);
+
+	// No claim the JIT payment, which should release the funding transaction
 	let service_fee_msat = (jit_amount_msat * channel_opening_fee_ppm as u64) / 1_000_000;
 	let expected_received_amount_msat = jit_amount_msat - service_fee_msat;
 
@@ -2003,18 +2022,29 @@ async fn lsps2_client_trusts_lsp() {
 
 	let _ = expect_payment_received_event!(client_node, expected_received_amount_msat).unwrap();
 
-	println!("Waiting for funding transaction to be broadcast...");
-	let mut funding_tx_found = false;
-	for _ in 0..500 {
-		std::thread::sleep(std::time::Duration::from_millis(100));
-		let current_mempool = bitcoind.client.get_raw_mempool().unwrap();
-		if current_mempool.0.len() > initial_mempool_size {
-			funding_tx_found = true;
-			break;
-		}
-	}
-
-	assert!(funding_tx_found, "Funding transaction should be broadcast after the client claims it");
+	// Check the nodes pick up on the confirmed funding tx now.
+	wait_for_tx(&electrsd.client, funding_txo.txid).await;
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
+	service_node.sync_wallets().unwrap();
+	client_node.sync_wallets().unwrap();
+	assert_eq!(
+		client_node
+			.list_channels()
+			.iter()
+			.find(|c| c.counterparty_node_id == service_node_id)
+			.unwrap()
+			.confirmations,
+		Some(6)
+	);
+	assert_eq!(
+		service_node
+			.list_channels()
+			.iter()
+			.find(|c| c.counterparty_node_id == client_node_id)
+			.unwrap()
+			.confirmations,
+		Some(6)
+	);
 }
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
@@ -2058,6 +2088,8 @@ async fn lsps2_lsp_trusts_client_but_client_does_not_claim() {
 	let client_node = client_builder.build().unwrap();
 	client_node.start().unwrap();
 
+	let client_node_id = client_node.node_id();
+
 	let payer_config = random_config(true);
 	setup_builder!(payer_builder, payer_config.node_config);
 	payer_builder.set_chain_source_esplora(esplora_url.clone(), Some(sync_config));
@@ -2090,8 +2122,6 @@ async fn lsps2_lsp_trusts_client_but_client_does_not_claim() {
 	expect_channel_ready_event!(payer_node, service_node.node_id());
 	expect_channel_ready_event!(service_node, payer_node.node_id());
 
-	let initial_mempool_size = bitcoind.client.get_raw_mempool().unwrap().0.len();
-
 	let invoice_description =
 		Bolt11InvoiceDescription::Direct(Description::new(String::from("asdf")).unwrap());
 	let jit_amount_msat = 100_000_000;
@@ -2113,19 +2143,33 @@ async fn lsps2_lsp_trusts_client_but_client_does_not_claim() {
 	// Have the payer_node pay the invoice, therby triggering channel open service_node -> client_node.
 	println!("Paying JIT invoice!");
 	let _payment_id = payer_node.bolt11_payment().send(&res, None).unwrap();
-	expect_channel_pending_event!(service_node, client_node.node_id());
+	let funding_txo = expect_channel_pending_event!(service_node, client_node.node_id());
 	expect_channel_ready_event!(service_node, client_node.node_id());
 	expect_channel_pending_event!(client_node, service_node.node_id());
 	expect_channel_ready_event!(client_node, service_node.node_id());
-	println!("Waiting for funding transaction to be broadcast... It will be there because LSP trusts the client, even though the client has not claimed it yet.");
-	let mut funding_tx_found = false;
-	for _ in 0..500 {
-		std::thread::sleep(std::time::Duration::from_millis(100));
-		let current_mempool = bitcoind.client.get_raw_mempool().unwrap();
-		if current_mempool.0.len() > initial_mempool_size {
-			funding_tx_found = true;
-			break;
-		}
-	}
-	assert!(funding_tx_found, "Funding transaction should be broadcast");
+	println!("Waiting for funding transaction to be broadcast...");
+
+	// Check the nodes pick up on the confirmed funding tx now.
+	wait_for_tx(&electrsd.client, funding_txo.txid).await;
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
+	service_node.sync_wallets().unwrap();
+	client_node.sync_wallets().unwrap();
+	assert_eq!(
+		client_node
+			.list_channels()
+			.iter()
+			.find(|c| c.counterparty_node_id == service_node_id)
+			.unwrap()
+			.confirmations,
+		Some(6)
+	);
+	assert_eq!(
+		service_node
+			.list_channels()
+			.iter()
+			.find(|c| c.counterparty_node_id == client_node_id)
+			.unwrap()
+			.confirmations,
+		Some(6)
+	);
 }