test wip

Author: joostjager

src/lib.rs

@@ -1466,10 +1466,18 @@ impl Node {
 	/// Sets the [`BlindedMessagePath`]s that we will use as an async recipient to interactively build [`Offer`]s with a
 	/// static invoice server, so the server can serve [`StaticInvoice`]s to payers on our behalf when we're offline.
 	pub fn set_paths_to_static_invoice_server(
-		&mut self, paths: Vec<BlindedMessagePath>,
+		&self, paths: Vec<BlindedMessagePath>,
 	) -> Result<(), ()> {
 		self.channel_manager.set_paths_to_static_invoice_server(paths)
 	}
+
+	/// [`BlindedMessagePath`]s for an async recipient to communicate with this node and interactively
+	/// build [`Offer`]s and [`StaticInvoice`]s for receiving async payments.
+	pub fn blinded_paths_for_async_recipient(
+		&self, recipient_id: Vec<u8>, relative_expiry: Option<Duration>,
+	) -> Result<Vec<BlindedMessagePath>, ()> {
+		self.channel_manager.blinded_paths_for_async_recipient(recipient_id, relative_expiry)
+	}
 }
 
 impl Drop for Node {

tests/common/mod.rs

@@ -288,10 +288,13 @@ pub(crate) fn setup_two_nodes(
 ) -> (TestNode, TestNode) {
 	println!("== Node A ==");
 	let config_a = random_config(anchor_channels);
+	println!("Node A storage path: {}", config_a.node_config.storage_dir_path.clone());
+
 	let node_a = setup_node(chain_source, config_a, None);
 
 	println!("\n== Node B ==");
 	let mut config_b = random_config(anchor_channels);
+	println!("Node B storage path: {}", config_b.node_config.storage_dir_path.clone());
 	if allow_0conf {
 		config_b.node_config.trusted_peers_0conf.push(node_a.node_id());
 	}

tests/integration_tests_rust.rs

@@ -1130,6 +1130,58 @@ fn simple_bolt12_send_receive() {
 	assert_eq!(node_a_payments.first().unwrap().amount_msat, Some(overpaid_amount));
 }
 
+#[test]
+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;
+	premine_and_distribute_funds(
+		&bitcoind.client,
+		&electrsd.client,
+		vec![address_a],
+		Amount::from_sat(premine_amount_sat),
+	);
+
+	node_a.sync_wallets().unwrap();
+	open_channel(&node_a, &node_b, 4_000_000, true, &electrsd);
+
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6);
+
+	node_a.sync_wallets().unwrap();
+	node_b.sync_wallets().unwrap();
+
+	expect_channel_ready_event!(node_a, node_b.node_id());
+	expect_channel_ready_event!(node_b, node_a.node_id());
+
+	// 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));
+	}
+
+	// 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();
+
+	// Sleep to get the cache filled.
+	std::thread::sleep(std::time::Duration::from_secs(1));
+
+	let mut iter = 0;
+	while node_b.bolt12_payment().get_async_receive_offer().is_err() {
+		std::thread::sleep(std::time::Duration::from_millis(1000));
+
+		iter += 1;
+		if iter > 10 {
+			assert!(false, "Failed to fetch static invoice offer");
+		}
+	}
+}
+
 #[test]
 fn test_node_announcement_propagation() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();