fix test

Author: joostjager

tests/integration_tests_rust.rs

@@ -1134,46 +1134,98 @@ fn simple_bolt12_send_receive() {
 fn static_invoice_server() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
-	let (node_a, node_b) = setup_two_nodes(&chain_source, false, true, false);
 
-	let address_a = node_a.onchain_payment().new_address().unwrap();
-	let premine_amount_sat = 5_000_000;
+	let mut config_sender = random_config(true);
+	config_sender.node_config.storage_dir_path = "/tmp/node_sender".into();
+	let node_sender = setup_node(&chain_source, config_sender, None);
+
+	let mut config_sender_lsp = random_config(true);
+	config_sender_lsp.node_config.storage_dir_path = "/tmp/node_sender_lsp".into();
+	let node_sender_lsp = setup_node(&chain_source, config_sender_lsp, None);
+
+	let mut config_receiver_lsp = random_config(true);
+	config_receiver_lsp.node_config.storage_dir_path = "/tmp/node_receiver_lsp".into();
+	let node_receiver_lsp = setup_node(&chain_source, config_receiver_lsp, None);
+
+	let mut config_receiver = random_config(true);
+	config_receiver.node_config.storage_dir_path = "/tmp/node_receiver".into();
+	let node_receiver = setup_node(&chain_source, config_receiver, None);
+
+	let address_sender = node_sender.onchain_payment().new_address().unwrap();
+	let address_sender_lsp = node_sender_lsp.onchain_payment().new_address().unwrap();
+	let address_receiver_lsp = node_receiver_lsp.onchain_payment().new_address().unwrap();
+	let address_receiver = node_receiver.onchain_payment().new_address().unwrap();
+	let premine_amount_sat = 4_000_000;
 	premine_and_distribute_funds(
 		&bitcoind.client,
 		&electrsd.client,
-		vec![address_a],
+		vec![address_sender, address_sender_lsp, address_receiver_lsp, address_receiver],
 		Amount::from_sat(premine_amount_sat),
 	);
 
-	node_a.sync_wallets().unwrap();
-	open_channel(&node_a, &node_b, 4_000_000, true, &electrsd);
+	node_sender.sync_wallets().unwrap();
+	node_sender_lsp.sync_wallets().unwrap();
+	node_receiver_lsp.sync_wallets().unwrap();
+	node_receiver.sync_wallets().unwrap();
 
-	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
+	open_channel(&node_sender, &node_sender_lsp, 400_000, true, &electrsd);
+	open_channel(&node_sender_lsp, &node_receiver_lsp, 400_000, true, &electrsd);
+	open_channel(&node_receiver_lsp, &node_receiver, 400_000, true, &electrsd);
 
-	node_a.sync_wallets().unwrap();
-	node_b.sync_wallets().unwrap();
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
 
-	expect_channel_ready_event!(node_a, node_b.node_id());
-	expect_channel_ready_event!(node_b, node_a.node_id());
+	node_sender.sync_wallets().unwrap();
+	node_sender_lsp.sync_wallets().unwrap();
+	node_receiver_lsp.sync_wallets().unwrap();
+	node_receiver.sync_wallets().unwrap();
+
+	expect_channel_ready_event!(node_sender, node_sender_lsp.node_id());
+	expect_channel_ready_event!(node_sender_lsp, node_sender.node_id());
+	expect_channel_ready_event!(node_sender_lsp, node_receiver_lsp.node_id());
+	expect_channel_ready_event!(node_receiver_lsp, node_sender_lsp.node_id());
+	expect_channel_ready_event!(node_receiver_lsp, node_receiver.node_id());
+	expect_channel_ready_event!(node_receiver, node_receiver_lsp.node_id());
+
+	let has_node_announcements = |node: &ldk_node::Node| {
+		node.network_graph()
+			.list_nodes()
+			.iter()
+			.filter(|n| {
+				node.network_graph().node(n).map_or(false, |info| info.announcement_info.is_some())
+			})
+			.count() >= 4
+	};
 
-	// Sleep until we broadcasted a node announcement.
-	while node_b.status().latest_node_announcement_broadcast_timestamp.is_none() {
-		std::thread::sleep(std::time::Duration::from_millis(10));
+	// Wait for everyone to see all channels and node announcements.
+	while node_sender.network_graph().list_channels().len() < 3
+		|| node_sender_lsp.network_graph().list_channels().len() < 3
+		|| node_receiver_lsp.network_graph().list_channels().len() < 3
+		|| node_receiver.network_graph().list_channels().len() < 3
+		|| !has_node_announcements(&node_sender)
+		|| !has_node_announcements(&node_sender_lsp)
+		|| !has_node_announcements(&node_receiver_lsp)
+		|| !has_node_announcements(&node_receiver)
+	{
+		std::thread::sleep(std::time::Duration::from_millis(100));
 	}
 
-	// Sleep one more sec to make sure the node announcement propagates.
-	std::thread::sleep(std::time::Duration::from_secs(1));
-
 	let recipient_id = vec![1, 2, 3];
-	let blinded_paths = node_a.blinded_paths_for_async_recipient(recipient_id, None).unwrap();
-	node_b.set_paths_to_static_invoice_server(blinded_paths).unwrap();
+	let blinded_paths =
+		node_receiver_lsp.blinded_paths_for_async_recipient(recipient_id, None).unwrap();
+	node_receiver.set_paths_to_static_invoice_server(blinded_paths).unwrap();
 
-	// Sleep to get the cache filled.
-	std::thread::sleep(std::time::Duration::from_secs(1));
+	let offer = loop {
+		if let Ok(offer) = node_receiver.bolt12_payment().get_async_receive_offer() {
+			break offer;
+		}
+
+		std::thread::sleep(std::time::Duration::from_millis(100));
+	};
 
-	let offer = node_b.bolt12_payment().get_async_receive_offer().unwrap();
+	let payment_id =
+		node_sender.bolt12_payment().send_using_amount(&offer, 5_000, None, None).unwrap();
 
-	println!("Offer: {}", offer);
+	expect_payment_successful_event!(node_sender, Some(payment_id), None);
 }
 
 #[test]