Implement bLIP-32 resolver discovery via network graph

Adds logic to scan the network graph for nodes that support both DNS resolution and Onion Messaging.

- Iterates through the network graph to find up to 5 candidate nodes.
- Validates node features for DNS and Onion Message support.
- Adds error handling and logging for missing BIP-353 requirements.

Author: chuksys

bindings/ldk_node.udl

@@ -366,6 +366,7 @@ enum NodeError {
 	"AsyncPaymentServicesDisabled",
 	"HrnParsingFailed",
 	"HrnResolverNotConfigured",
+	"NoDnsResolvers",
 };
 
 dictionary NodeStatus {

src/error.rs

@@ -133,6 +133,8 @@ pub enum Error {
 	HrnParsingFailed,
 	/// A HRN resolver was not configured.
 	HrnResolverNotConfigured,
+	/// No nodes in the network graph support both DNS resolution and onion messaging, which are required for bLIP-32.
+	NoDnsResolvers,
 }
 
 impl fmt::Display for Error {
@@ -218,6 +220,9 @@ impl fmt::Display for Error {
 			Self::HrnResolverNotConfigured => {
 				write!(f, "A HRN resolver was not configured.")
 			},
+			Self::NoDnsResolvers => {
+				write!(f, "No nodes in the network graph support both DNS resolution and onion messaging, which are required for bLIP-32.")
+			},
 		}
 	}
 }

src/lib.rs

@@ -980,6 +980,7 @@ impl Node {
 			Arc::clone(&self.config),
 			Arc::clone(&self.logger),
 			Arc::clone(&self.hrn_resolver),
+			Arc::clone(&self.network_graph),
 		)
 	}
 
@@ -1001,6 +1002,7 @@ impl Node {
 			Arc::clone(&self.config),
 			Arc::clone(&self.logger),
 			Arc::clone(&self.hrn_resolver),
+			Arc::clone(&self.network_graph),
 		))
 	}
 

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;
@@ -34,7 +35,7 @@ use crate::error::Error;
 use crate::ffi::maybe_wrap;
 use crate::logger::{log_error, LdkLogger, Logger};
 use crate::payment::{Bolt11Payment, Bolt12Payment, OnchainPayment};
-use crate::types::HRNResolver;
+use crate::types::{Graph, HRNResolver};
 use crate::Config;
 
 type Uri<'a> = bip21::Uri<'a, NetworkChecked, Extras>;
@@ -69,15 +70,24 @@ pub struct UnifiedPayment {
 	config: Arc<Config>,
 	logger: Arc<Logger>,
 	hrn_resolver: Arc<Option<Arc<HRNResolver>>>,
+	network_graph: Arc<Graph>,
 }
 
 impl UnifiedPayment {
 	pub(crate) fn new(
 		onchain_payment: Arc<OnchainPayment>, bolt11_invoice: Arc<Bolt11Payment>,
 		bolt12_payment: Arc<Bolt12Payment>, config: Arc<Config>, logger: Arc<Logger>,
-		hrn_resolver: Arc<Option<Arc<HRNResolver>>>,
+		hrn_resolver: Arc<Option<Arc<HRNResolver>>>, network_graph: Arc<Graph>,
 	) -> Self {
-		Self { onchain_payment, bolt11_invoice, bolt12_payment, config, logger, hrn_resolver }
+		Self {
+			onchain_payment,
+			bolt11_invoice,
+			bolt12_payment,
+			config,
+			logger,
+			hrn_resolver,
+			network_graph,
+		}
 	}
 
 	/// Generates a URI with an on-chain address, [BOLT 11] invoice and [BOLT 12] offer.
@@ -165,25 +175,54 @@ impl UnifiedPayment {
 		&self, uri_str: &str, amount_msat: Option<u64>,
 		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 resolver;
 		let target_network;
 
-		target_network = if let Ok(_) = HumanReadableName::from_encoded(uri_str) {
-			#[cfg(hrn_tests)]
-			{
-				bitcoin::Network::Bitcoin
+		if let Ok(_) = HumanReadableName::from_encoded(uri_str) {
+			resolver = self.hrn_resolver.as_ref().clone().ok_or_else(|| {
+				log_error!(self.logger, "No HRN resolver configured. Cannot resolve HRNs.");
+				Error::HrnResolverNotConfigured
+			})?;
+
+			if let HRNResolver::Onion(_) = &*resolver {
+				let dns_resolvers = {
+					let mut resolvers = Vec::new();
+					let network_graph = self.network_graph.read_only();
+
+					for (node_id, node) in network_graph.nodes().unordered_iter() {
+						if let Some(info) = &node.announcement_info {
+							let supports_dns = info.features().supports_dns_resolution();
+							let supports_om = info.features().supports_onion_messages();
+							if supports_dns && supports_om {
+								resolvers.push(node_id.clone());
+							}
+						}
+						if resolvers.len() > 5 {
+							break;
+						}
+					}
+					resolvers
+				};
+
+				if dns_resolvers.is_empty() {
+					log_error!(self.logger, "No nodes in the network graph support both DNS resolution and onion messaging, which are required for bLIP-32. Please ensure you have at least one such node in your network graph before making BIP-353 payments.");
+					return Err(Error::NoDnsResolvers);
+				}
 			}
-			#[cfg(not(hrn_tests))]
-			{
-				self.config.network
+			target_network = {
+				#[cfg(hrn_tests)]
+				{
+					bitcoin::Network::Bitcoin
+				}
+				#[cfg(not(hrn_tests))]
+				{
+					self.config.network
+				}
 			}
 		} else {
-			self.config.network
-		};
+			resolver = Arc::new(HRNResolver::Dummy(DummyHrnResolver));
+			target_network = self.config.network;
+		}
 
 		let parse_fut =
 			PaymentInstructions::parse(uri_str, target_network, resolver.as_ref(), false);

src/types.rs

@@ -13,7 +13,7 @@ use std::sync::{Arc, Mutex};
 use bitcoin_payment_instructions::amount::Amount;
 use bitcoin_payment_instructions::dns_resolver::DNSHrnResolver;
 use bitcoin_payment_instructions::hrn_resolution::{
-	HrnResolutionFuture, HrnResolver, HumanReadableName, LNURLResolutionFuture,
+	DummyHrnResolver, HrnResolutionFuture, HrnResolver, HumanReadableName, LNURLResolutionFuture,
 };
 use bitcoin_payment_instructions::onion_message_resolver::LDKOnionMessageDNSSECHrnResolver;
 
@@ -304,20 +304,23 @@ pub(crate) type OnionMessenger = lightning::onion_message::messenger::OnionMesse
 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),
 		}
 	}
 
@@ -331,6 +334,9 @@ impl HrnResolver for HRNResolver {
 			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)
+			},
 		}
 	}
 }