Pass HRNResolver or DomainResolver into OnionMessenger

Inject specialized resolution capabilities into OnionMessenger to
support outbound payments and third-party resolution services.

This change refines the previous resolution logic by allowing the node
to act as a robust BIP 353 participant. If configured as a service
provider, the node utilizes a Domain Resolver to handle requests for
other participants. Otherwise, it uses an HRN Resolver specifically for
initiating its own outbound payments. Providing these as optional
parameters in the Node constructor ensures the logic matches the
node's designated role in the ecosystem.

Author: chuksys

Cargo.toml

@@ -38,6 +38,7 @@ default = []
 #lightning-transaction-sync = { version = "0.2.0", features = ["esplora-async-https", "time", "electrum-rustls-ring"] }
 #lightning-liquidity = { version = "0.2.0", features = ["std"] }
 #lightning-macros = { version = "0.2.0" }
+#lightning-dns-resolver = { version = "0.3.0" }
 
 lightning = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "dcf0c203e166da2348bef12b2e5eff4a250cdec7", features = ["std"] }
 lightning-types = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "dcf0c203e166da2348bef12b2e5eff4a250cdec7" }
@@ -50,6 +51,7 @@ lightning-block-sync = { git = "https://github.com/lightningdevkit/rust-lightnin
 lightning-transaction-sync = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "dcf0c203e166da2348bef12b2e5eff4a250cdec7", features = ["esplora-async-https", "time", "electrum-rustls-ring"] }
 lightning-liquidity = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "dcf0c203e166da2348bef12b2e5eff4a250cdec7", features = ["std"] }
 lightning-macros = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "dcf0c203e166da2348bef12b2e5eff4a250cdec7" }
+lightning-dns-resolver = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "dcf0c203e166da2348bef12b2e5eff4a250cdec7" }
 
 bdk_chain = { version = "0.23.0", default-features = false, features = ["std"] }
 bdk_esplora = { version = "0.22.0", default-features = false, features = ["async-https-rustls", "tokio"]}
@@ -144,6 +146,7 @@ harness = false
 #lightning-transaction-sync = { path = "../rust-lightning/lightning-transaction-sync" }
 #lightning-liquidity = { path = "../rust-lightning/lightning-liquidity" }
 #lightning-macros = { path = "../rust-lightning/lightning-macros" }
+#lightning-dns-resolver = { path = "../rust-lightning/lightning-dns-resolver" }
 
 #lightning = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "main" }
 #lightning-types = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "main" }
@@ -156,6 +159,7 @@ harness = false
 #lightning-transaction-sync = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "main" }
 #lightning-liquidity = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "main" }
 #lightning-macros = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "main" }
+#lightning-dns-resolver = { git = "https://github.com/lightningdevkit/rust-lightning", branch = "main" }
 
 #lightning = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "21e9a9c0ef80021d0669f2a366f55d08ba8d9b03" }
 #lightning-types = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "21e9a9c0ef80021d0669f2a366f55d08ba8d9b03" }
@@ -168,6 +172,7 @@ harness = false
 #lightning-transaction-sync = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "21e9a9c0ef80021d0669f2a366f55d08ba8d9b03" }
 #lightning-liquidity = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "21e9a9c0ef80021d0669f2a366f55d08ba8d9b03" }
 #lightning-macros = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "21e9a9c0ef80021d0669f2a366f55d08ba8d9b03" }
+#lightning-dns-resolver = { git = "https://github.com/lightningdevkit/rust-lightning", rev = "21e9a9c0ef80021d0669f2a366f55d08ba8d9b03" }
 
 #vss-client-ng = { path = "../vss-client" }
 #vss-client-ng = { git = "https://github.com/lightningdevkit/vss-client", branch = "main" }
@@ -184,3 +189,4 @@ harness = false
 #lightning-transaction-sync = { path = "../rust-lightning/lightning-transaction-sync" }
 #lightning-liquidity = { path = "../rust-lightning/lightning-liquidity" }
 #lightning-macros = { path = "../rust-lightning/lightning-macros" }
+#lightning-dns-resolver = { path = "../rust-lightning/lightning-dns-resolver" }

src/builder.rs

@@ -9,7 +9,7 @@ use std::collections::HashMap;
 use std::convert::TryInto;
 use std::default::Default;
 use std::path::PathBuf;
-use std::sync::{Arc, Mutex, Once, RwLock};
+use std::sync::{Arc, Mutex, Once, RwLock, Weak};
 use std::time::SystemTime;
 use std::{fmt, fs};
 
@@ -19,12 +19,13 @@ use bitcoin::bip32::{ChildNumber, Xpriv};
 use bitcoin::key::Secp256k1;
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::{BlockHash, Network};
+use bitcoin_payment_instructions::dns_resolver::DNSHrnResolver;
 use bitcoin_payment_instructions::onion_message_resolver::LDKOnionMessageDNSSECHrnResolver;
 use lightning::chain::{chainmonitor, BestBlock};
 use lightning::ln::channelmanager::{self, ChainParameters, ChannelManagerReadArgs};
 use lightning::ln::msgs::{RoutingMessageHandler, SocketAddress};
 use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler};
-use lightning::log_trace;
+use lightning::onion_message::dns_resolution::DNSResolverMessageHandler;
 use lightning::routing::gossip::NodeAlias;
 use lightning::routing::router::DefaultRouter;
 use lightning::routing::scoring::{
@@ -39,14 +40,16 @@ use lightning::util::persist::{
 };
 use lightning::util::ser::ReadableArgs;
 use lightning::util::sweep::OutputSweeper;
+use lightning::{log_trace, log_warn};
+use lightning_dns_resolver::OMDomainResolver;
 use lightning_persister::fs_store::v1::FilesystemStore;
 use vss_client::headers::VssHeaderProvider;
 
 use crate::chain::ChainSource;
 use crate::config::{
 	default_user_config, may_announce_channel, AnnounceError, AsyncPaymentsRole,
-	BitcoindRestClientConfig, Config, ElectrumSyncConfig, EsploraSyncConfig, TorConfig,
-	DEFAULT_ESPLORA_SERVER_URL, DEFAULT_LOG_FILENAME, DEFAULT_LOG_LEVEL,
+	BitcoindRestClientConfig, Config, ElectrumSyncConfig, EsploraSyncConfig, HRNResolverConfig,
+	TorConfig, DEFAULT_ESPLORA_SERVER_URL, DEFAULT_LOG_FILENAME, DEFAULT_LOG_LEVEL,
 };
 use crate::connection::ConnectionManager;
 use crate::entropy::NodeEntropy;
@@ -77,8 +80,8 @@ use crate::runtime::{Runtime, RuntimeSpawner};
 use crate::tx_broadcaster::TransactionBroadcaster;
 use crate::types::{
 	AsyncPersister, ChainMonitor, ChannelManager, DynStore, DynStoreRef, DynStoreWrapper,
-	GossipSync, Graph, KeysManager, MessageRouter, OnionMessenger, PaymentStore, PeerManager,
-	PendingPaymentStore, SyncAndAsyncKVStore,
+	GossipSync, Graph, HRNResolver, KeysManager, MessageRouter, OnionMessenger, PaymentStore,
+	PeerManager, PendingPaymentStore, SyncAndAsyncKVStore,
 };
 use crate::wallet::persist::KVStoreWalletPersister;
 use crate::wallet::Wallet;
@@ -193,6 +196,8 @@ pub enum BuildError {
 	NetworkMismatch,
 	/// The role of the node in an asynchronous payments context is not compatible with the current configuration.
 	AsyncPaymentsConfigMismatch,
+	/// An attempt to setup a DNS Resolver failed.
+	DNSResolverSetupFailed,
 }
 
 impl fmt::Display for BuildError {
@@ -226,6 +231,9 @@ impl fmt::Display for BuildError {
 					"The async payments role is not compatible with the current configuration."
 				)
 			},
+			Self::DNSResolverSetupFailed => {
+				write!(f, "An attempt to setup a DNS resolver has failed.")
+			},
 		}
 	}
 }
@@ -1717,7 +1725,75 @@ fn build_with_store_internal(
 		})?;
 	}
 
-	let hrn_resolver = Arc::new(LDKOnionMessageDNSSECHrnResolver::new(Arc::clone(&network_graph)));
+	// This hook resolves a circular dependency:
+	// 1. PeerManager requires OnionMessenger (via MessageHandler).
+	// 2. OnionMessenger (via HRN resolver) needs to call PeerManager::process_events.
+	//
+	// We provide the resolver with a Weak pointer via this Mutex-protected "hook."
+	// This allows us to initialize the resolver before the PeerManager exists,
+	// and prevents a reference cycle (memory leak).
+	let peer_manager_hook: Arc<Mutex<Option<Weak<PeerManager>>>> = Arc::new(Mutex::new(None));
+	let hrn_resolver;
+
+	let runtime_handle = runtime.handle();
+
+	let om_resolver: Arc<dyn DNSResolverMessageHandler + Send + Sync> = match &config
+		.hrn_config
+		.resolution_config
+	{
+		HRNResolverConfig::Blip32 => {
+			let hrn_res =
+				Arc::new(LDKOnionMessageDNSSECHrnResolver::new(Arc::clone(&network_graph)));
+			hrn_resolver = HRNResolver::Onion(Arc::clone(&hrn_res));
+
+			// We clone the hook because it's moved into a Send + Sync closure that outlives this scope.
+			let pm_hook_clone = Arc::clone(&peer_manager_hook);
+			hrn_res.register_post_queue_action(Box::new(move || {
+				if let Ok(guard) = pm_hook_clone.lock() {
+					if let Some(pm) = guard.as_ref().and_then(|weak| weak.upgrade()) {
+						pm.process_events();
+					}
+				}
+			}));
+			hrn_res as Arc<dyn DNSResolverMessageHandler + Send + Sync>
+		},
+		HRNResolverConfig::Dns { dns_server_address, enable_hrn_resolution_service, .. } => {
+			let addr = dns_server_address.parse().map_err(|_| {
+				log_error!(logger, "Failed to parse DNS server address: {}", dns_server_address);
+				BuildError::DNSResolverSetupFailed
+			})?;
+
+			if *enable_hrn_resolution_service && may_announce_channel(&config).is_ok() {
+				let hrn_res = Arc::new(DNSHrnResolver(addr));
+				hrn_resolver = HRNResolver::Local(hrn_res);
+
+				Arc::new(OMDomainResolver::<IgnoringMessageHandler>::with_runtime(
+					addr,
+					None,
+					Some(runtime_handle.clone()),
+				)) as Arc<dyn DNSResolverMessageHandler + Send + Sync>
+			} else {
+				if *enable_hrn_resolution_service {
+					log_warn!(logger, "Unable to act as an HRN resolution service. To act as an HRN resolution service, the node must be configured to announce channels.");
+				}
+
+				// Fallback/Default: Onion resolver
+				let hrn_res =
+					Arc::new(LDKOnionMessageDNSSECHrnResolver::new(Arc::clone(&network_graph)));
+				hrn_resolver = HRNResolver::Onion(Arc::clone(&hrn_res));
+
+				let pm_hook_clone = Arc::clone(&peer_manager_hook);
+				hrn_res.register_post_queue_action(Box::new(move || {
+					if let Ok(guard) = pm_hook_clone.lock() {
+						if let Some(pm) = guard.as_ref().and_then(|weak| weak.upgrade()) {
+							pm.process_events();
+						}
+					}
+				}));
+				hrn_res as Arc<dyn DNSResolverMessageHandler + Send + Sync>
+			}
+		},
+	};
 
 	// Initialize the PeerManager
 	let onion_messenger: Arc<OnionMessenger> =
@@ -1730,7 +1806,7 @@ fn build_with_store_internal(
 				message_router,
 				Arc::clone(&channel_manager),
 				Arc::clone(&channel_manager),
-				Arc::clone(&hrn_resolver),
+				Arc::clone(&om_resolver),
 				IgnoringMessageHandler {},
 			))
 		} else {
@@ -1742,7 +1818,7 @@ fn build_with_store_internal(
 				message_router,
 				Arc::clone(&channel_manager),
 				Arc::clone(&channel_manager),
-				Arc::clone(&hrn_resolver),
+				Arc::clone(&om_resolver),
 				IgnoringMessageHandler {},
 			))
 		};
@@ -1873,12 +1949,7 @@ fn build_with_store_internal(
 		Arc::clone(&keys_manager),
 	));
 
-	let peer_manager_clone = Arc::downgrade(&peer_manager);
-	hrn_resolver.register_post_queue_action(Box::new(move || {
-		if let Some(upgraded_pointer) = peer_manager_clone.upgrade() {
-			upgraded_pointer.process_events();
-		}
-	}));
+	*peer_manager_hook.lock().unwrap() = Some(Arc::downgrade(&peer_manager));
 
 	liquidity_source.as_ref().map(|l| l.set_peer_manager(Arc::downgrade(&peer_manager)));
 
@@ -1992,7 +2063,7 @@ fn build_with_store_internal(
 		node_metrics,
 		om_mailbox,
 		async_payments_role,
-		hrn_resolver,
+		hrn_resolver: Arc::new(hrn_resolver),
 		#[cfg(cycle_tests)]
 		_leak_checker,
 	})

src/payment/unified.rs

@@ -23,6 +23,7 @@ use bip21::{DeserializationError, DeserializeParams, Param, SerializeParams};
 use bitcoin::address::NetworkChecked;
 use bitcoin::{Amount, Txid};
 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;
@@ -165,12 +166,16 @@ impl UnifiedPayment {
 		&self, uri_str: &str, amount_msat: Option<u64>,
 		route_parameters: Option<RouteParametersConfig>,
 	) -> Result<UnifiedPaymentResult, Error> {
-		let parse_fut = PaymentInstructions::parse(
-			uri_str,
-			self.config.network,
-			self.hrn_resolver.as_ref(),
-			false,
-		);
+		let resolver;
+
+		if let Ok(_) = HumanReadableName::from_encoded(uri_str) {
+			resolver = Arc::clone(&self.hrn_resolver);
+		} else {
+			resolver = Arc::new(HRNResolver::Dummy(DummyHrnResolver));
+		}
+
+		let parse_fut =
+			PaymentInstructions::parse(uri_str, self.config.network, resolver.as_ref(), false);
 
 		let instructions =
 			tokio::time::timeout(Duration::from_secs(HRN_RESOLUTION_TIMEOUT_SECS), parse_fut)
@@ -196,7 +201,7 @@ impl UnifiedPayment {
 					Error::InvalidAmount
 				})?;
 
-				let fut = instr.set_amount(amt, self.hrn_resolver.as_ref());
+				let fut = instr.set_amount(amt, &*resolver);
 
 				tokio::time::timeout(Duration::from_secs(HRN_RESOLUTION_TIMEOUT_SECS), fut)
 					.await
@@ -235,7 +240,6 @@ impl UnifiedPayment {
 			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))

src/runtime.rs

@@ -208,7 +208,7 @@ impl Runtime {
 		);
 	}
 
-	fn handle(&self) -> &tokio::runtime::Handle {
+	pub(crate) fn handle(&self) -> &tokio::runtime::Handle {
 		match &self.mode {
 			RuntimeMode::Owned(rt) => rt.handle(),
 			RuntimeMode::Handle(handle) => handle,

src/types.rs

@@ -10,15 +10,23 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::{Arc, Mutex};
 
+use bitcoin_payment_instructions::amount::Amount;
+use bitcoin_payment_instructions::dns_resolver::DNSHrnResolver;
+use bitcoin_payment_instructions::hrn_resolution::{
+	DummyHrnResolver, HrnResolutionFuture, HrnResolver, HumanReadableName, LNURLResolutionFuture,
+};
+use bitcoin_payment_instructions::onion_message_resolver::LDKOnionMessageDNSSECHrnResolver;
+
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::{OutPoint, ScriptBuf};
-use bitcoin_payment_instructions::onion_message_resolver::LDKOnionMessageDNSSECHrnResolver;
+
 use lightning::chain::chainmonitor;
 use lightning::impl_writeable_tlv_based;
 use lightning::ln::channel_state::{ChannelDetails as LdkChannelDetails, ChannelShutdownState};
 use lightning::ln::msgs::{RoutingMessageHandler, SocketAddress};
 use lightning::ln::peer_handler::IgnoringMessageHandler;
 use lightning::ln::types::ChannelId;
+use lightning::onion_message::dns_resolution::DNSResolverMessageHandler;
 use lightning::routing::gossip;
 use lightning::routing::router::DefaultRouter;
 use lightning::routing::scoring::{CombinedScorer, ProbabilisticScoringFeeParameters};
@@ -318,11 +326,49 @@ pub(crate) type OnionMessenger = lightning::onion_message::messenger::OnionMesse
 	Arc<MessageRouter>,
 	Arc<ChannelManager>,
 	Arc<ChannelManager>,
-	Arc<HRNResolver>,
+	Arc<dyn DNSResolverMessageHandler + Sync + Send>,
 	IgnoringMessageHandler,
 >;
 
-pub(crate) type HRNResolver = LDKOnionMessageDNSSECHrnResolver<Arc<Graph>, Arc<Logger>>;
+pub enum HRNResolver {
+	Onion(Arc<LDKOnionMessageDNSSECHrnResolver<Arc<Graph>, Arc<Logger>>>),
+	Local(Arc<DNSHrnResolver>),
+	Dummy(DummyHrnResolver),
+}
+
+impl HrnResolver for HRNResolver {
+	fn resolve_hrn<'a>(&'a self, hrn: &'a HumanReadableName) -> HrnResolutionFuture<'a> {
+		match self {
+			HRNResolver::Onion(inner) => inner.resolve_hrn(hrn),
+			HRNResolver::Local(inner) => inner.resolve_hrn(hrn),
+			HRNResolver::Dummy(inner) => inner.resolve_hrn(hrn),
+		}
+	}
+
+	fn resolve_lnurl<'a>(&'a self, url: &'a str) -> HrnResolutionFuture<'a> {
+		match self {
+			HRNResolver::Onion(inner) => inner.resolve_lnurl(url),
+			HRNResolver::Local(inner) => inner.resolve_lnurl(url),
+			HRNResolver::Dummy(inner) => inner.resolve_lnurl(url),
+		}
+	}
+
+	fn resolve_lnurl_to_invoice<'a>(
+		&'a self, callback_url: String, amount: Amount, expected_description_hash: [u8; 32],
+	) -> LNURLResolutionFuture<'a> {
+		match self {
+			HRNResolver::Onion(inner) => {
+				inner.resolve_lnurl_to_invoice(callback_url, amount, expected_description_hash)
+			},
+			HRNResolver::Local(inner) => {
+				inner.resolve_lnurl_to_invoice(callback_url, amount, expected_description_hash)
+			},
+			HRNResolver::Dummy(inner) => {
+				inner.resolve_lnurl_to_invoice(callback_url, amount, expected_description_hash)
+			},
+		}
+	}
+}
 
 pub(crate) type MessageRouter = lightning::onion_message::messenger::DefaultMessageRouter<
 	Arc<Graph>,