Pass HRNResolver or DomainResolver into OnionMessenger

This commit allows us to enable our node to either be able to send HRN resolution requests or acts as a resolver for 3rd party nodes

We also pass HRNResolver as an optional parameter to Node

Author: chuksys

bindings/ldk_node.udl

@@ -312,6 +312,7 @@ enum NodeError {
 	"InsufficientFunds",
 	"LiquiditySourceUnavailable",
 	"LiquidityFeeTooHigh",
+	"HrnResolverNotConfigured",
 };
 
 dictionary NodeStatus {
@@ -348,6 +349,7 @@ enum BuildError {
 	"WalletSetupFailed",
 	"LoggerSetupFailed",
 	"NetworkMismatch",
+	"DNSResolverSetupFailed",
 };
 
 [Trait]

src/builder.rs

@@ -31,8 +31,8 @@ use crate::peer_store::PeerStore;
 use crate::runtime::Runtime;
 use crate::tx_broadcaster::TransactionBroadcaster;
 use crate::types::{
-	ChainMonitor, ChannelManager, DynStore, GossipSync, Graph, KeysManager, MessageRouter,
-	OnionMessenger, PaymentStore, PeerManager,
+	ChainMonitor, ChannelManager, DomainResolver, DynStore, GossipSync, Graph, HRNResolver,
+	KeysManager, MessageRouter, OnionMessenger, PaymentStore, PeerManager,
 };
 use crate::wallet::persist::KVStoreWalletPersister;
 use crate::wallet::Wallet;
@@ -43,6 +43,7 @@ use lightning::io::Cursor;
 use lightning::ln::channelmanager::{self, ChainParameters, ChannelManagerReadArgs};
 use lightning::ln::msgs::{RoutingMessageHandler, SocketAddress};
 use lightning::ln::peer_handler::{IgnoringMessageHandler, MessageHandler};
+use lightning::onion_message::dns_resolution::DNSResolverMessageHandler;
 use lightning::routing::gossip::NodeAlias;
 use lightning::routing::router::DefaultRouter;
 use lightning::routing::scoring::{
@@ -59,6 +60,8 @@ use lightning::util::sweep::OutputSweeper;
 
 use lightning_persister::fs_store::FilesystemStore;
 
+use lightning_dns_resolver::OMDomainResolver;
+
 use bdk_wallet::template::Bip84;
 use bdk_wallet::KeychainKind;
 use bdk_wallet::Wallet as BdkWallet;
@@ -193,6 +196,8 @@ pub enum BuildError {
 	LoggerSetupFailed,
 	/// The given network does not match the node's previously configured network.
 	NetworkMismatch,
+	/// An attempt to setup a DNS Resolver failed.
+	DNSResolverSetupFailed,
 }
 
 impl fmt::Display for BuildError {
@@ -221,12 +226,20 @@ impl fmt::Display for BuildError {
 			Self::NetworkMismatch => {
 				write!(f, "Given network does not match the node's previously configured network.")
 			},
+			Self::DNSResolverSetupFailed => {
+				write!(f, "An attempt to setup a DNS resolver has failed.")
+			},
 		}
 	}
 }
 
 impl std::error::Error for BuildError {}
 
+enum Resolver {
+	HRN(Arc<HRNResolver>),
+	DNS(Arc<DomainResolver>),
+}
+
 /// A builder for an [`Node`] instance, allowing to set some configuration and module choices from
 /// the getgo.
 ///
@@ -1456,7 +1469,22 @@ fn build_with_store_internal(
 		})?;
 	}
 
-	let hrn_resolver = Arc::new(LDKOnionMessageDNSSECHrnResolver::new(Arc::clone(&network_graph)));
+	let resolver = if config.is_hrn_resolver {
+		Resolver::DNS(Arc::new(OMDomainResolver::ignoring_incoming_proofs(
+			"8.8.8.8:53".parse().map_err(|_| BuildError::DNSResolverSetupFailed)?,
+		)))
+	} else {
+		Resolver::HRN(Arc::new(LDKOnionMessageDNSSECHrnResolver::new(Arc::clone(&network_graph))))
+	};
+
+	let om_resolver = match resolver {
+		Resolver::DNS(ref dns_resolver) => {
+			Arc::clone(dns_resolver) as Arc<dyn DNSResolverMessageHandler + Send + Sync>
+		},
+		Resolver::HRN(ref hrn_resolver) => {
+			Arc::clone(hrn_resolver) as Arc<dyn DNSResolverMessageHandler + Send + Sync>
+		},
+	};
 
 	// Initialize the PeerManager
 	let onion_messenger: Arc<OnionMessenger> = Arc::new(OnionMessenger::new(
@@ -1467,7 +1495,7 @@ fn build_with_store_internal(
 		message_router,
 		Arc::clone(&channel_manager),
 		IgnoringMessageHandler {},
-		Arc::clone(&hrn_resolver),
+		Arc::clone(&om_resolver),
 		IgnoringMessageHandler {},
 	));
 	let ephemeral_bytes: [u8; 32] = keys_manager.get_secure_random_bytes();
@@ -1595,9 +1623,15 @@ fn build_with_store_internal(
 
 	let peer_manager_clone = Arc::clone(&peer_manager);
 
-	hrn_resolver.register_post_queue_action(Box::new(move || {
-		peer_manager_clone.process_events();
-	}));
+	let hrn_resolver = match resolver {
+		Resolver::DNS(_) => None,
+		Resolver::HRN(ref hrn_resolver) => {
+			hrn_resolver.register_post_queue_action(Box::new(move || {
+				peer_manager_clone.process_events();
+			}));
+			Some(hrn_resolver)
+		},
+	};
 
 	liquidity_source.as_ref().map(|l| l.set_peer_manager(Arc::clone(&peer_manager)));
 
@@ -1706,7 +1740,7 @@ fn build_with_store_internal(
 		is_running,
 		is_listening,
 		node_metrics,
-		hrn_resolver,
+		hrn_resolver: hrn_resolver.cloned(),
 	})
 }
 

src/error.rs

@@ -120,6 +120,8 @@ pub enum Error {
 	LiquiditySourceUnavailable,
 	/// The given operation failed due to the LSP's required opening fee being too high.
 	LiquidityFeeTooHigh,
+	/// A HRN resolver was not configured
+	HrnResolverNotConfigured,
 }
 
 impl fmt::Display for Error {
@@ -193,6 +195,9 @@ impl fmt::Display for Error {
 			Self::LiquidityFeeTooHigh => {
 				write!(f, "The given operation failed due to the LSP's required opening fee being too high.")
 			},
+			Self::HrnResolverNotConfigured => {
+				write!(f, "A HRN resolver was not configured.")
+			},
 		}
 	}
 }

src/lib.rs

@@ -206,7 +206,7 @@ pub struct Node {
 	is_running: Arc<RwLock<bool>>,
 	is_listening: Arc<AtomicBool>,
 	node_metrics: Arc<RwLock<NodeMetrics>>,
-	hrn_resolver: Arc<HRNResolver>,
+	hrn_resolver: Option<Arc<HRNResolver>>,
 }
 
 impl Node {
@@ -901,7 +901,7 @@ impl Node {
 			self.bolt12_payment().into(),
 			Arc::clone(&self.config),
 			Arc::clone(&self.logger),
-			Arc::clone(&self.hrn_resolver),
+			Arc::new(self.hrn_resolver.clone()),
 		)
 	}
 
@@ -922,7 +922,7 @@ impl Node {
 			self.bolt12_payment(),
 			Arc::clone(&self.config),
 			Arc::clone(&self.logger),
-			Arc::clone(&self.hrn_resolver),
+			Arc::new(self.hrn_resolver.clone()),
 		))
 	}
 

src/payment/unified.rs

@@ -62,14 +62,14 @@ pub struct UnifiedPayment {
 	bolt12_payment: Arc<Bolt12Payment>,
 	config: Arc<Config>,
 	logger: Arc<Logger>,
-	hrn_resolver: Arc<HRNResolver>,
+	hrn_resolver: Arc<Option<Arc<HRNResolver>>>,
 }
 
 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<HRNResolver>,
+		hrn_resolver: Arc<Option<Arc<HRNResolver>>>,
 	) -> Self {
 		Self { onchain_payment, bolt11_invoice, bolt12_payment, config, logger, hrn_resolver }
 	}
@@ -155,18 +155,24 @@ impl UnifiedPayment {
 	pub async fn send(
 		&self, uri_str: &str, amount_msat: Option<u64>,
 	) -> Result<UnifiedPaymentResult, Error> {
-		let instructions = PaymentInstructions::parse(
-			uri_str,
-			self.config.network,
-			self.hrn_resolver.as_ref(),
-			false,
-		)
-		.await
-		.map_err(|e| {
-			log_error!(self.logger, "Failed to parse payment instructions: {:?}", e);
-			Error::UriParameterParsingFailed
+		let resolver = self.hrn_resolver.as_ref().clone().ok_or_else(|| {
+			log_error!(self.logger, "No HRN resolver configured. Cannot resolve HRNs.");
+			Error::HrnResolverNotConfigured
 		})?;
 
+		println!("Parsing instructions...");
+
+		let instructions =
+			PaymentInstructions::parse(uri_str, self.config.network, resolver.as_ref(), false)
+				.await
+				.map_err(|e| {
+					log_error!(self.logger, "Failed to parse payment instructions: {:?}", e);
+					println!("Failed to parse payment instructions: {:?}", e);
+					Error::UriParameterParsingFailed
+				})?;
+
+		println!("Sending...");
+
 		let resolved = match instructions {
 			PaymentInstructions::ConfigurableAmount(instr) => {
 				let amount = amount_msat.ok_or_else(|| {
@@ -179,7 +185,7 @@ impl UnifiedPayment {
 					Error::InvalidAmount
 				})?;
 
-				instr.set_amount(amt, self.hrn_resolver.as_ref()).await.map_err(|e| {
+				instr.set_amount(amt, resolver.as_ref()).await.map_err(|e| {
 					log_error!(self.logger, "Failed to set amount: {:?}", e);
 					Error::InvalidAmount
 				})?

src/types.rs

@@ -21,6 +21,7 @@ use lightning::ln::msgs::RoutingMessageHandler;
 use lightning::ln::msgs::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::{ProbabilisticScorer, ProbabilisticScoringFeeParameters};
@@ -33,6 +34,8 @@ use lightning_block_sync::gossip::{GossipVerifier, UtxoSource};
 
 use lightning_net_tokio::SocketDescriptor;
 
+use lightning_dns_resolver::OMDomainResolver;
+
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::OutPoint;
 
@@ -119,11 +122,12 @@ pub(crate) type OnionMessenger = lightning::onion_message::messenger::OnionMesse
 	Arc<MessageRouter>,
 	Arc<ChannelManager>,
 	IgnoringMessageHandler,
-	Arc<HRNResolver>,
+	Arc<dyn DNSResolverMessageHandler + Sync + Send>,
 	IgnoringMessageHandler,
 >;
 
 pub(crate) type HRNResolver = LDKOnionMessageDNSSECHrnResolver<Arc<Graph>, Arc<Logger>>;
+pub(crate) type DomainResolver = OMDomainResolver<IgnoringMessageHandler>;
 
 pub(crate) type MessageRouter = lightning::onion_message::messenger::DefaultMessageRouter<
 	Arc<Graph>,