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

@@ -25,6 +25,7 @@ panic = 'abort'     # Abort on panic
 
 [features]
 default = []
+hrn_tests = []
 
 [dependencies]
 #lightning = { version = "0.2.0", features = ["std"] }

benches/payments.rs

@@ -127,6 +127,7 @@ fn payment_benchmark(c: &mut Criterion) {
 		true,
 		false,
 		common::TestStoreType::Sqlite,
+		false,
 	);
 
 	let runtime =

src/ffi/types.rs

@@ -297,6 +297,7 @@ impl std::fmt::Display for Offer {
 /// This struct can also be used for LN-Address recipients.
 ///
 /// [Homograph Attacks]: https://en.wikipedia.org/wiki/IDN_homograph_attack
+#[derive(Eq, Hash, PartialEq)]
 pub struct HumanReadableName {
 	pub(crate) inner: LdkHumanReadableName,
 }

src/lib.rs

@@ -1859,3 +1859,62 @@ pub(crate) fn total_anchor_channels_reserve_sats(
 			* anchor_channels_config.per_channel_reserve_sats
 	})
 }
+
+/// Testing utils for DNSSEC proof resolution of offers associated with the given Human-Readable Name.
+
+#[cfg(feature = "hrn_tests")]
+pub mod dnssec_testing_utils {
+	use std::collections::HashMap;
+	#[cfg(feature = "uniffi")]
+	use std::sync::Arc;
+	use std::sync::{LazyLock, Mutex};
+
+	#[cfg(not(feature = "uniffi"))]
+	type Offer = lightning::offers::offer::Offer;
+	#[cfg(feature = "uniffi")]
+	type Offer = Arc<crate::ffi::Offer>;
+
+	#[cfg(not(feature = "uniffi"))]
+	type HumanReadableName = lightning::onion_message::dns_resolution::HumanReadableName;
+	#[cfg(feature = "uniffi")]
+	type HumanReadableName = Arc<crate::ffi::HumanReadableName>;
+
+	static OFFER_OVERRIDE_MAP: LazyLock<Mutex<HashMap<HumanReadableName, Offer>>> =
+		LazyLock::new(|| Mutex::new(HashMap::new()));
+
+	/// Sets a testing override for DNSSEC proof resolution of offers associated with the given Human-Readable Name.
+	pub fn set_testing_dnssec_proof_offer_resolution_override(hrn: &str, offer: Offer) {
+		let hrn_key = {
+			#[cfg(not(feature = "uniffi"))]
+			{
+				lightning::onion_message::dns_resolution::HumanReadableName::from_encoded(hrn)
+					.unwrap()
+			}
+
+			#[cfg(feature = "uniffi")]
+			{
+				Arc::new(crate::ffi::HumanReadableName::from_encoded(hrn).unwrap())
+			}
+		};
+
+		OFFER_OVERRIDE_MAP.lock().unwrap().insert(hrn_key, offer);
+	}
+
+	/// Retrieves a testing override for DNSSEC proof resolution of offers associated with the given Human-Readable Names.
+	#[cfg(not(feature = "uniffi"))]
+	pub fn get_testing_offer_override(hrn: Option<HumanReadableName>) -> Option<Offer> {
+		OFFER_OVERRIDE_MAP.lock().unwrap().get(&hrn?).cloned()
+	}
+
+	/// Retrieves a testing override for DNSSEC proof resolution of offers associated with the given Human-Readable Names.
+	#[cfg(feature = "uniffi")]
+	pub fn get_testing_offer_override(hrn: Option<HumanReadableName>) -> Option<Offer> {
+		let offer = OFFER_OVERRIDE_MAP.lock().unwrap().get(&hrn?).cloned().unwrap();
+		Some(offer)
+	}
+
+	/// Clears all testing overrides for DNSSEC proof resolution of offers.
+	pub fn clear_testing_overrides() {
+		OFFER_OVERRIDE_MAP.lock().unwrap().clear();
+	}
+}

src/payment/bolt12.rs

@@ -234,7 +234,26 @@ impl Bolt12Payment {
 			return Err(Error::NotRunning);
 		}
 
-		let offer = maybe_deref(offer);
+		let offer = if let Some(_hrn_ref) = &hrn {
+			#[cfg(feature = "hrn_tests")]
+			{
+				crate::dnssec_testing_utils::get_testing_offer_override(Some(_hrn_ref.clone()))
+					.map(|override_offer| {
+						log_info!(self.logger, "Using test-specific Offer override.");
+						override_offer
+					})
+					.unwrap_or_else(|| offer.clone())
+			}
+
+			#[cfg(not(feature = "hrn_tests"))]
+			{
+				offer.clone()
+			}
+		} else {
+			offer.clone()
+		};
+
+		let offer = maybe_deref(&offer);
 
 		let mut random_bytes = [0u8; 32];
 		rand::rng().fill_bytes(&mut random_bytes);

src/payment/unified.rs

@@ -26,7 +26,7 @@ use bitcoin_payment_instructions::amount::Amount as BPIAmount;
 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::onion_message::dns_resolution::HumanReadableName as LdkHumanReadableName;
 use lightning::routing::router::RouteParametersConfig;
 use lightning_invoice::{Bolt11Invoice, Bolt11InvoiceDescription, Description};
 
@@ -40,6 +40,11 @@ use crate::Config;
 
 type Uri<'a> = bip21::Uri<'a, NetworkChecked, Extras>;
 
+#[cfg(not(feature = "uniffi"))]
+type HumanReadableName = LdkHumanReadableName;
+#[cfg(feature = "uniffi")]
+type HumanReadableName = Arc<crate::ffi::HumanReadableName>;
+
 #[derive(Debug, Clone)]
 struct Extras {
 	bolt11_invoice: Option<Bolt11Invoice>,
@@ -166,12 +171,28 @@ impl UnifiedPayment {
 			Error::HrnResolverNotConfigured
 		})?;
 
-		let parse_fut = PaymentInstructions::parse(
-			uri_str,
-			self.config.network,
-			self.hrn_resolver.as_ref(),
-			false,
-		);
+		let target_network;
+
+		target_network = if let Ok(hrn) = LdkHumanReadableName::from_encoded(uri_str) {
+			#[cfg(feature = "hrn_tests")]
+			{
+				let hrn_wrapped: HumanReadableName = maybe_wrap(hrn);
+				match crate::dnssec_testing_utils::get_testing_offer_override(Some(hrn_wrapped)) {
+					Some(_) => bitcoin::Network::Bitcoin,
+					_ => self.config.network,
+				}
+			}
+			#[cfg(not(feature = "hrn_tests"))]
+			{
+				let _ = hrn;
+				self.config.network
+			}
+		} else {
+			self.config.network
+		};
+
+		let parse_fut =
+			PaymentInstructions::parse(uri_str, target_network, resolver.as_ref(), false);
 
 		let instructions =
 			tokio::time::timeout(Duration::from_secs(HRN_RESOLUTION_TIMEOUT_SECS), parse_fut)
@@ -197,7 +218,7 @@ impl UnifiedPayment {
 					Error::InvalidAmount
 				})?;
 
-				let fut = instr.set_amount(amt, self.hrn_resolver.as_ref());
+				let fut = instr.set_amount(amt, resolver.as_ref());
 
 				tokio::time::timeout(Duration::from_secs(HRN_RESOLUTION_TIMEOUT_SECS), fut)
 					.await
@@ -237,18 +258,20 @@ impl UnifiedPayment {
 				PaymentMethod::LightningBolt12(offer) => {
 					let offer = maybe_wrap(offer.clone());
 
-					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))
-					} else if let Some(amount_msat) = amount_msat {
-						self.bolt12_payment.send_using_amount(&offer, amount_msat, None, None, route_parameters)
-					} else {
-						self.bolt12_payment.send(&offer, None, None, route_parameters)
-					}
-					.map_err(|e| {
-						log_error!(self.logger, "Failed to send BOLT12 offer: {:?}. This is part of a unified payment. Falling back to the BOLT11 invoice.", e);
-						e
-					});
+					let payment_result = {
+						if let Ok(hrn) = LdkHumanReadableName::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))
+						} else if let Some(amount_msat) = amount_msat {
+							self.bolt12_payment.send_using_amount(&offer, amount_msat, None, None, route_parameters)
+						} else {
+							self.bolt12_payment.send(&offer, None, None, route_parameters)
+						}
+						.map_err(|e| {
+							log_error!(self.logger, "Failed to send BOLT12 offer: {:?}. This is part of a unified payment. Falling back to the BOLT11 invoice.", e);
+							e
+						})
+					};
 
 					if let Ok(payment_id) = payment_result {
 						return Ok(UnifiedPaymentResult::Bolt12 { payment_id });

tests/common/mod.rs

@@ -26,7 +26,9 @@ 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, HumanReadableNamesConfig,
+};
 use ldk_node::entropy::{generate_entropy_mnemonic, NodeEntropy};
 use ldk_node::io::sqlite_store::SqliteStore;
 use ldk_node::payment::{PaymentDirection, PaymentKind, PaymentStatus};
@@ -319,20 +321,21 @@ pub(crate) use setup_builder;
 
 pub(crate) fn setup_two_nodes(
 	chain_source: &TestChainSource, allow_0conf: bool, anchor_channels: bool,
-	anchors_trusted_no_reserve: bool,
+	anchors_trusted_no_reserve: bool, second_node_is_hrn_resolver: bool,
 ) -> (TestNode, TestNode) {
 	setup_two_nodes_with_store(
 		chain_source,
 		allow_0conf,
 		anchor_channels,
 		anchors_trusted_no_reserve,
 		TestStoreType::TestSyncStore,
+		second_node_is_hrn_resolver,
 	)
 }
 
 pub(crate) fn setup_two_nodes_with_store(
 	chain_source: &TestChainSource, allow_0conf: bool, anchor_channels: bool,
-	anchors_trusted_no_reserve: bool, store_type: TestStoreType,
+	anchors_trusted_no_reserve: bool, store_type: TestStoreType, second_node_is_hrn_resolver: bool,
 ) -> (TestNode, TestNode) {
 	println!("== Node A ==");
 	let mut config_a = random_config(anchor_channels);
@@ -342,6 +345,13 @@ pub(crate) fn setup_two_nodes_with_store(
 	println!("\n== Node B ==");
 	let mut config_b = random_config(anchor_channels);
 	config_b.store_type = store_type;
+	if second_node_is_hrn_resolver {
+		config_b.node_config.hrn_config = Some(HumanReadableNamesConfig {
+			default_dns_resolvers: Vec::new(),
+			is_hrn_resolver: true,
+			dns_server_address: "8.8.8.8:53".to_string(),
+		});
+	}
 	if allow_0conf {
 		config_b.node_config.trusted_peers_0conf.push(node_a.node_id());
 	}