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

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

src/ffi/types.rs

@@ -298,6 +298,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/payment/unified.rs

@@ -26,7 +26,6 @@ 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::routing::router::RouteParametersConfig;
 use lightning_invoice::{Bolt11Invoice, Bolt11InvoiceDescription, Description};
 
@@ -40,6 +39,11 @@ 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;
+
 #[derive(Debug, Clone)]
 struct Extras {
 	bolt11_invoice: Option<Bolt11Invoice>,
@@ -159,15 +163,30 @@ impl UnifiedPayment {
 	/// [BIP 353]: https://github.com/bitcoin/bips/blob/master/bip-0353.mediawiki
 	pub async fn send(
 		&self, uri_str: &str, amount_msat: Option<u64>,
-		route_parameters: Option<RouteParametersConfig>,
+		route_parameters: Option<RouteParametersConfig>, #[cfg(hrn_tests)] test_offer: &Offer,
 	) -> Result<UnifiedPaymentResult, Error> {
 		let resolver = self.hrn_resolver.as_ref().clone().ok_or_else(|| {
 			log_error!(self.logger, "No HRN resolver configured. Cannot resolve HRNs.");
 			Error::HrnResolverNotConfigured
 		})?;
 
+		let target_network;
+
+		target_network = if let Ok(_) = HumanReadableName::from_encoded(uri_str) {
+			#[cfg(hrn_tests)]
+			{
+				bitcoin::Network::Bitcoin
+			}
+			#[cfg(not(hrn_tests))]
+			{
+				self.config.network
+			}
+		} else {
+			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)
@@ -230,21 +249,27 @@ impl UnifiedPayment {
 
 		for method in sorted_payment_methods {
 			match method {
-				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
-					});
+				PaymentMethod::LightningBolt12(_offer) => {
+					#[cfg(not(hrn_tests))]
+					let offer = maybe_wrap(_offer);
+
+					#[cfg(hrn_tests)]
+					let offer = maybe_wrap(test_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
+						})
+					};
 
 					if let Ok(payment_id) = payment_result {
 						return Ok(UnifiedPaymentResult::Bolt12 { payment_id });

tests/common/mod.rs

@@ -26,7 +26,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};
@@ -401,11 +404,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 =
+			Some(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,80 @@
+// 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, 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 = 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 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());
+
+	// Sleep until we broadcast a node announcement.
+	while node_b.status().latest_node_announcement_broadcast_timestamp.is_none() {
+		std::thread::sleep(std::time::Duration::from_millis(10));
+	}
+
+	let test_offer = node_b.bolt12_payment().receive(1000000, "test offer", None, None).unwrap();
+
+	// Sleep one more sec to make sure the node announcement propagates.
+	std::thread::sleep(std::time::Duration::from_secs(1));
+
+	let hrn_str = "matt@mattcorallo.com";
+
+	let offer_payment_id: PaymentId =
+		match node_a.unified_payment().send(&hrn_str, Some(1000000), None, &test_offer).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);
+}

tests/integration_tests_rust.rs

@@ -33,6 +33,7 @@ use ldk_node::payment::{
 	ConfirmationStatus, PaymentDetails, PaymentDirection, PaymentKind, PaymentStatus,
 	UnifiedPaymentResult,
 };
+
 use ldk_node::{Builder, Event, NodeError};
 use lightning::ln::channelmanager::PaymentId;
 use lightning::routing::gossip::{NodeAlias, NodeId};