feat: configure DNS resolver

Author: rustaceanrob

src/core/builder.rs

@@ -1,3 +1,4 @@
+use std::net::SocketAddr;
 use std::{path::PathBuf, time::Duration};
 
 use bitcoin::Network;
@@ -9,6 +10,7 @@ use super::{client::Client, config::NodeConfig, node::Node, FilterSyncPolicy};
 use crate::db::error::SqlInitializationError;
 #[cfg(feature = "database")]
 use crate::db::sqlite::{headers::SqliteHeaderDb, peers::SqlitePeerDb};
+use crate::network::dns::DnsResolver;
 use crate::{
     chain::checkpoints::HeaderCheckpoint,
     db::traits::{HeaderStore, PeerStore},
@@ -176,6 +178,14 @@ impl NodeBuilder {
         self
     }
 
+    /// Configure the DNS resolver to use when querying DNS seeds.
+    /// Default is `1.1.1.1:53`.
+    pub fn use_dns_resolver(mut self, resolver: impl Into<SocketAddr>) -> Self {
+        let socket_addr = resolver.into();
+        self.config.dns_resolver = DnsResolver { socket_addr };
+        self
+    }
+
     /// Stop the node from downloading and checking compact block filters until an explicit command by the client is made.
     /// This is only useful if the scripts to check for may not be known do to some expensive computation, like in a silent
     /// payments context.

src/core/config.rs

@@ -3,7 +3,8 @@ use std::{collections::HashSet, path::PathBuf, time::Duration};
 use bitcoin::ScriptBuf;
 
 use crate::{
-    chain::checkpoints::HeaderCheckpoint, ConnectionType, PeerStoreSizeConfig, TrustedPeer,
+    chain::checkpoints::HeaderCheckpoint, network::dns::DnsResolver, ConnectionType,
+    PeerStoreSizeConfig, TrustedPeer,
 };
 
 use super::FilterSyncPolicy;
@@ -16,6 +17,7 @@ const TWO_HOUR: u64 = 60 * 60 * 2;
 pub(crate) struct NodeConfig {
     pub required_peers: u8,
     pub white_list: Vec<TrustedPeer>,
+    pub dns_resolver: DnsResolver,
     pub addresses: HashSet<ScriptBuf>,
     pub data_path: Option<PathBuf>,
     pub header_checkpoint: Option<HeaderCheckpoint>,
@@ -31,6 +33,7 @@ impl Default for NodeConfig {
         Self {
             required_peers: REQUIRED_PEERS,
             white_list: Default::default(),
+            dns_resolver: DnsResolver::default(),
             addresses: Default::default(),
             data_path: Default::default(),
             header_checkpoint: Default::default(),

src/core/node.rs

@@ -25,6 +25,7 @@ use crate::{
     core::{error::FetchHeaderError, peer_map::PeerMap},
     db::traits::{HeaderStore, PeerStore},
     filters::{cfheader_chain::AppendAttempt, error::CFilterSyncError},
+    network::dns::DnsResolver,
     ConnectionType, PeerStoreSizeConfig, RejectPayload, TrustedPeer, TxBroadcastPolicy,
 };
 
@@ -82,6 +83,7 @@ impl<H: HeaderStore, P: PeerStore> Node<H, P> {
     pub(crate) fn new(
         network: Network,
         white_list: Whitelist,
+        dns_resolver: DnsResolver,
         scripts: HashSet<ScriptBuf>,
         header_checkpoint: Option<HeaderCheckpoint>,
         required_peers: PeerRequirement,
@@ -115,6 +117,7 @@ impl<H: HeaderStore, P: PeerStore> Node<H, P> {
             target_peer_size,
             timeout_config,
             Arc::clone(&height_monitor),
+            dns_resolver,
         )));
         // Set up the transaction broadcaster
         let tx_broadcaster = Arc::new(Mutex::new(Broadcaster::new()));
@@ -161,6 +164,7 @@ impl<H: HeaderStore, P: PeerStore> Node<H, P> {
         Node::new(
             network,
             config.white_list,
+            config.dns_resolver,
             config.addresses,
             config.header_checkpoint,
             config.required_peers as PeerRequirement,

src/core/peer_map.rs

@@ -23,6 +23,7 @@ use crate::{
     chain::HeightMonitor,
     db::{traits::PeerStore, PeerStatus, PersistedPeer},
     network::{
+        dns::DnsResolver,
         error::PeerError,
         peer::Peer,
         traits::{ClearNetConnection, NetworkConnector},
@@ -71,6 +72,7 @@ pub(crate) struct PeerMap<P: PeerStore> {
     target_db_size: PeerStoreSizeConfig,
     net_groups: HashSet<String>,
     timeout_config: PeerTimeoutConfig,
+    dns_resolver: DnsResolver,
 }
 
 #[allow(dead_code)]
@@ -86,6 +88,7 @@ impl<P: PeerStore> PeerMap<P> {
         target_db_size: PeerStoreSizeConfig,
         timeout_config: PeerTimeoutConfig,
         height_monitor: Arc<Mutex<HeightMonitor>>,
+        dns_resolver: DnsResolver,
     ) -> Self {
         let connector: Arc<Mutex<dyn NetworkConnector + Send + Sync>> = match connection_type {
             ConnectionType::ClearNet => Arc::new(Mutex::new(ClearNetConnection::new())),
@@ -108,6 +111,7 @@ impl<P: PeerStore> PeerMap<P> {
             target_db_size,
             net_groups: HashSet::new(),
             timeout_config,
+            dns_resolver,
         }
     }
 
@@ -392,7 +396,7 @@ impl<P: PeerStore> PeerMap<P> {
         use std::net::IpAddr;
         self.dialog.send_dialog("Bootstraping peers with DNS").await;
         let mut db_lock = self.db.lock().await;
-        let new_peers = Dns::new(self.network)
+        let new_peers = Dns::new(self.network, self.dns_resolver)
             .bootstrap()
             .await
             .map_err(|_| PeerManagerError::Dns)?

src/network/dns.rs

@@ -6,7 +6,7 @@ use bitcoin::{
 };
 use std::{
     io::Read,
-    net::{IpAddr, Ipv4Addr},
+    net::{IpAddr, Ipv4Addr, SocketAddr},
 };
 use tokio::net::UdpSocket;
 
@@ -35,7 +35,6 @@ const MAINNET_SEEDS: &[&str; 9] = &[
     "seed.bitcoin.wiz.biz",
 ];
 
-const RESOLVER: &str = "1.1.1.1:53";
 const LOCAL_HOST: &str = "0.0.0.0:0";
 
 const HEADER_BYTES: usize = 12;
@@ -59,12 +58,31 @@ const A_RECORD: u16 = 0x01;
 const A_CLASS: u16 = 0x01;
 const EXPECTED_RDATA_LEN: u16 = 0x04;
 
+#[derive(Debug, Clone, Copy)]
+pub(crate) struct DnsResolver {
+    pub(crate) socket_addr: SocketAddr,
+}
+
+impl Default for DnsResolver {
+    fn default() -> Self {
+        let socket_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(1, 1, 1, 1)), 53);
+        Self { socket_addr }
+    }
+}
+
+impl From<DnsResolver> for SocketAddr {
+    fn from(value: DnsResolver) -> Self {
+        value.socket_addr
+    }
+}
+
 pub(crate) struct Dns<'a> {
     seeds: Vec<&'a str>,
+    dns_resolver: DnsResolver,
 }
 
 impl Dns<'_> {
-    pub fn new(network: Network) -> Self {
+    pub fn new(network: Network, dns_resolver: DnsResolver) -> Self {
         let seeds = match network {
             Network::Bitcoin => MAINNET_SEEDS.to_vec(),
             Network::Testnet => TESTNET_SEEDS.to_vec(),
@@ -73,14 +91,17 @@ impl Dns<'_> {
             Network::Testnet4 => Vec::with_capacity(0),
             _ => unreachable!(),
         };
-        Self { seeds }
+        Self {
+            seeds,
+            dns_resolver,
+        }
     }
 
     pub async fn bootstrap(&self) -> Result<Vec<IpAddr>, DnsBootstrapError> {
         let mut ip_addrs: Vec<IpAddr> = vec![];
 
         for host in &self.seeds {
-            match DNSQuery::new(host).lookup().await {
+            match DNSQuery::new(host).lookup(self.dns_resolver.into()).await {
                 Ok(addrs) => ip_addrs.extend(addrs),
                 Err(e) => eprintln!("{e}"),
             }
@@ -122,11 +143,11 @@ impl DNSQuery {
         }
     }
 
-    async fn lookup(&self) -> Result<Vec<IpAddr>, DNSQueryError> {
+    async fn lookup(&self, dns_resolver: SocketAddr) -> Result<Vec<IpAddr>, DNSQueryError> {
         let sock = UdpSocket::bind(LOCAL_HOST)
             .await
             .map_err(|_| DNSQueryError::ConnectionDenied)?;
-        sock.connect(RESOLVER)
+        sock.connect(dns_resolver)
             .await
             .map_err(|_| DNSQueryError::Udp)?;
         sock.send(&self.message)
@@ -229,15 +250,21 @@ impl DNSQuery {
 
 #[cfg(test)]
 mod test {
-    use super::Dns;
+    use std::net::SocketAddr;
+
+    use super::*;
 
     #[tokio::test]
     #[ignore = "dns works"]
     async fn dns_responds() {
-        let addrs = Dns::new(bitcoin::network::Network::Signet)
-            .bootstrap()
-            .await
-            .unwrap();
+        let socket_addr = "1.1.1.1:53".parse::<SocketAddr>().unwrap();
+        let addrs = Dns::new(
+            bitcoin::network::Network::Signet,
+            DnsResolver { socket_addr },
+        )
+        .bootstrap()
+        .await
+        .unwrap();
         assert!(addrs.len() > 1);
     }
 }