Add end-to-end test for HRN resolution

Introduce a comprehensive test case to verify the full lifecycle of a
payment initiated via a Human Readable Name (HRN).

This test ensures that the integration between HRN parsing, BIP 353
resolution, and BOLT12 offer execution is functioning correctly within
the node. By asserting that an encoded URI can be successfully resolved
to a valid offer and subsequently paid, we validate the reliability of
the resolution pipeline and ensure that recent architectural changes
to the OnionMessenger and Node configuration work in unison.

Author: chuksys

Cargo.toml

@@ -128,6 +128,7 @@ check-cfg = [
 	"cfg(cln_test)",
 	"cfg(lnd_test)",
 	"cfg(cycle_tests)",
+	"cfg(hrn_tests)",
 ]
 
 [[bench]]

src/payment/unified.rs

@@ -26,8 +26,7 @@ use bitcoin_payment_instructions::amount::Amount as BPIAmount;
 use bitcoin_payment_instructions::hrn_resolution::DummyHrnResolver;
 use bitcoin_payment_instructions::{PaymentInstructions, PaymentMethod};
 use lightning::ln::channelmanager::PaymentId;
-use lightning::offers::offer::Offer;
-use lightning::onion_message::dns_resolution::HumanReadableName;
+use lightning::offers::offer::Offer as LdkOffer;
 use lightning::routing::router::RouteParametersConfig;
 use lightning_invoice::{Bolt11Invoice, Bolt11InvoiceDescription, Description};
 
@@ -41,6 +40,16 @@ use crate::Config;
 
 type Uri<'a> = bip21::Uri<'a, NetworkChecked, Extras>;
 
+#[cfg(not(feature = "uniffi"))]
+type HumanReadableName = lightning::onion_message::dns_resolution::HumanReadableName;
+#[cfg(feature = "uniffi")]
+type HumanReadableName = crate::ffi::HumanReadableName;
+
+#[cfg(not(feature = "uniffi"))]
+type Offer = LdkOffer;
+#[cfg(feature = "uniffi")]
+type Offer = Arc<crate::ffi::Offer>;
+
 #[derive(Debug, Clone)]
 struct Extras {
 	bolt11_invoice: Option<Bolt11Invoice>,
@@ -67,6 +76,8 @@ pub struct UnifiedPayment {
 	config: Arc<Config>,
 	logger: Arc<Logger>,
 	hrn_resolver: Arc<HRNResolver>,
+	#[cfg(hrn_tests)]
+	test_offer: std::sync::Mutex<Option<Offer>>,
 }
 
 impl UnifiedPayment {
@@ -75,7 +86,16 @@ impl UnifiedPayment {
 		bolt12_payment: Arc<Bolt12Payment>, config: Arc<Config>, logger: Arc<Logger>,
 		hrn_resolver: Arc<HRNResolver>,
 	) -> Self {
-		Self { onchain_payment, bolt11_invoice, bolt12_payment, config, logger, hrn_resolver }
+		Self {
+			onchain_payment,
+			bolt11_invoice,
+			bolt12_payment,
+			config,
+			logger,
+			hrn_resolver,
+			#[cfg(hrn_tests)]
+			test_offer: std::sync::Mutex::new(None),
+		}
 	}
 }
 
@@ -116,7 +136,7 @@ impl UnifiedPayment {
 
 		let bolt12_offer =
 			match self.bolt12_payment.receive_inner(amount_msats, description, None, None) {
-				Ok(offer) => Some(offer),
+				Ok(offer) => Some(maybe_wrap(offer)),
 				Err(e) => {
 					log_error!(self.logger, "Failed to create offer: {}", e);
 					None
@@ -167,15 +187,26 @@ impl UnifiedPayment {
 		route_parameters: Option<RouteParametersConfig>,
 	) -> Result<UnifiedPaymentResult, Error> {
 		let resolver;
+		let target_network;
 
 		if let Ok(_) = HumanReadableName::from_encoded(uri_str) {
 			resolver = Arc::clone(&self.hrn_resolver);
+
+			#[cfg(hrn_tests)]
+			{
+				target_network = bitcoin::Network::Bitcoin;
+			}
+			#[cfg(not(hrn_tests))]
+			{
+				target_network = self.config.network;
+			}
 		} else {
 			resolver = Arc::new(HRNResolver::Dummy(DummyHrnResolver));
+			target_network = self.config.network;
 		}
 
 		let parse_fut =
-			PaymentInstructions::parse(uri_str, self.config.network, resolver.as_ref(), false);
+			PaymentInstructions::parse(uri_str, target_network, resolver.as_ref(), false);
 
 		let instructions =
 			tokio::time::timeout(Duration::from_secs(HRN_RESOLUTION_TIMEOUT_SECS), parse_fut)
@@ -238,9 +269,30 @@ impl UnifiedPayment {
 
 		for method in sorted_payment_methods {
 			match method {
-				PaymentMethod::LightningBolt12(offer) => {
-					let offer = maybe_wrap(offer.clone());
-					
+				PaymentMethod::LightningBolt12(_offer) => {
+					#[cfg(not(hrn_tests))]
+					let offer = maybe_wrap(_offer.clone());
+
+					#[cfg(hrn_tests)]
+					let offer = {
+						let test_offer_guard = self.test_offer.lock().map_err(|e| {
+							log_error!(
+								self.logger,
+								"Failed to lock test_offer due to poisoning: {:?}",
+								e
+							);
+							Error::PaymentSendingFailed
+						})?;
+
+						match &*test_offer_guard {
+							Some(o) => o.clone(),
+							None => {
+								log_error!(self.logger, "test_offer was None during HRN test");
+								return Err(Error::PaymentSendingFailed);
+							},
+						}
+					};
+
 					let payment_result = if let Ok(hrn) = HumanReadableName::from_encoded(uri_str) {
 						let hrn = maybe_wrap(hrn.clone());
 						self.bolt12_payment.send_using_amount_inner(&offer, amount_msat.unwrap_or(0), None, None, route_parameters, Some(hrn))
@@ -293,6 +345,16 @@ impl UnifiedPayment {
 		log_error!(self.logger, "Payable methods not found in URI");
 		Err(Error::PaymentSendingFailed)
 	}
+
+	/// Sets a test offer to be used in the `send` method when the `hrn_tests` config flag is enabled.
+	/// This is necessary to test sending Bolt12 payments via the unified payment handler in HRN tests,
+	/// as we cannot rely on the offer being present in the parsed URI.
+	#[cfg(hrn_tests)]
+	pub fn set_test_offer(&self, _offer: Offer) {
+		let _ = self.test_offer.lock().map(|mut guard| *guard = Some(_offer)).map_err(|e| {
+			log_error!(self.logger, "Failed to set test offer due to poisoned lock: {:?}", e)
+		});
+	}
 }
 
 /// Represents the result of a payment made using a [BIP 21] URI or a [BIP 353] Human-Readable Name.
@@ -400,9 +462,10 @@ impl<'a> bip21::de::DeserializationState<'a> for DeserializationState {
 			"lno" => {
 				let bolt12_value =
 					String::try_from(value).map_err(|_| Error::UriParameterParsingFailed)?;
-				let offer =
-					bolt12_value.parse::<Offer>().map_err(|_| Error::UriParameterParsingFailed)?;
-				self.bolt12_offer = Some(offer);
+				let offer = bolt12_value
+					.parse::<LdkOffer>()
+					.map_err(|_| Error::UriParameterParsingFailed)?;
+				self.bolt12_offer = Some(maybe_wrap(offer));
 				Ok(bip21::de::ParamKind::Known)
 			},
 			_ => Ok(bip21::de::ParamKind::Unknown),
@@ -425,7 +488,7 @@ mod tests {
 	use bitcoin::address::NetworkUnchecked;
 	use bitcoin::{Address, Network};
 
-	use super::{Amount, Bolt11Invoice, Extras, Offer};
+	use super::{maybe_wrap, Amount, Bolt11Invoice, Extras, LdkOffer};
 
 	#[test]
 	fn parse_uri() {
@@ -479,7 +542,7 @@ mod tests {
 		}
 
 		if let Some(offer) = parsed_uri_with_offer.extras.bolt12_offer {
-			assert_eq!(offer, Offer::from_str(expected_bolt12_offer_2).unwrap());
+			assert_eq!(offer, maybe_wrap(LdkOffer::from_str(expected_bolt12_offer_2).unwrap()));
 		} else {
 			panic!("No offer found.");
 		}

tests/common/mod.rs

@@ -27,7 +27,10 @@ use bitcoin::{
 use electrsd::corepc_node::{Client as BitcoindClient, Node as BitcoinD};
 use electrsd::{corepc_node, ElectrsD};
 use electrum_client::ElectrumApi;
-use ldk_node::config::{AsyncPaymentsRole, Config, ElectrumSyncConfig, EsploraSyncConfig};
+use ldk_node::config::{
+	AsyncPaymentsRole, Config, ElectrumSyncConfig, EsploraSyncConfig, HRNResolverConfig,
+	HumanReadableNamesConfig,
+};
 use ldk_node::entropy::{generate_entropy_mnemonic, NodeEntropy};
 use ldk_node::io::sqlite_store::SqliteStore;
 use ldk_node::payment::{PaymentDirection, PaymentKind, PaymentStatus};
@@ -400,11 +403,18 @@ pub(crate) fn setup_two_nodes_with_store(
 	println!("== Node A ==");
 	let mut config_a = random_config(anchor_channels);
 	config_a.store_type = store_type;
+
+	if cfg!(hrn_tests) {
+		config_a.node_config.hrn_config =
+			HumanReadableNamesConfig { resolution_config: HRNResolverConfig::Blip32 };
+	}
+
 	let node_a = setup_node(chain_source, config_a);
 
 	println!("\n== Node B ==");
 	let mut config_b = random_config(anchor_channels);
 	config_b.store_type = store_type;
+
 	if allow_0conf {
 		config_b.node_config.trusted_peers_0conf.push(node_a.node_id());
 	}

tests/integration_tests_hrn.rs

@@ -0,0 +1,83 @@
+// This file is Copyright its original authors, visible in version control history.
+//
+// This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// 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(hrn_tests)]
+
+mod common;
+
+use bitcoin::Amount;
+use common::{
+	expect_channel_ready_event, expect_payment_successful_event, generate_blocks_and_wait,
+	open_channel, premine_and_distribute_funds, random_chain_source, setup_bitcoind_and_electrsd,
+	setup_two_nodes, TestChainSource,
+};
+use ldk_node::payment::UnifiedPaymentResult;
+use ldk_node::Event;
+use lightning::ln::channelmanager::PaymentId;
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
+async fn unified_send_to_hrn() {
+	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
+	let chain_source = random_chain_source(&bitcoind, &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 premined_sats = 5_000_000;
+
+	premine_and_distribute_funds(
+		&bitcoind.client,
+		&electrsd.client,
+		vec![address_a],
+		Amount::from_sat(premined_sats),
+	)
+	.await;
+
+	node_a.sync_wallets().unwrap();
+	open_channel(&node_a, &node_b, 4_000_000, true, &electrsd).await;
+	generate_blocks_and_wait(&bitcoind.client, &electrsd.client, 6).await;
+
+	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());
+
+	// Wait until node_b broadcasts a node announcement
+	while node_b.status().latest_node_announcement_broadcast_timestamp.is_none() {
+		tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+	}
+
+	// Sleep to make sure the node announcement propagates
+	tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+
+	let test_offer = node_b.bolt12_payment().receive(1000000, "test offer", None, None).unwrap();
+
+	let hrn_str = "matt@mattcorallo.com";
+
+	let unified_handler = node_a.unified_payment();
+	unified_handler.set_test_offer(test_offer);
+
+	let offer_payment_id: PaymentId =
+		match unified_handler.send(&hrn_str, Some(1000000), None).await {
+			Ok(UnifiedPaymentResult::Bolt12 { payment_id }) => {
+				println!("\nBolt12 payment sent successfully with PaymentID: {:?}", payment_id);
+				payment_id
+			},
+			Ok(UnifiedPaymentResult::Bolt11 { payment_id: _ }) => {
+				panic!("Expected Bolt12 payment but got Bolt11");
+			},
+			Ok(UnifiedPaymentResult::Onchain { txid: _ }) => {
+				panic!("Expected Bolt12 payment but got On-chain transaction");
+			},
+			Err(e) => {
+				panic!("Expected Bolt12 payment but got error: {:?}", e);
+			},
+		};
+
+	expect_payment_successful_event!(node_a, Some(offer_payment_id), None);
+}