f - Allow configuring Human-Readable Name resolution

Addresses review feedback on the initial HRN configuration commit:

- Construct `HRNResolverConfig::Dns` explicitly inside the DNS arm of
  the mode match rather than relying on `HumanReadableNamesConfig`'s
  default being DNS. If LDK Node's default ever changes (e.g., to
  accommodate new resolver modes), the DNS-specific settings are still
  applied when the user explicitly selects DNS mode instead of being
  silently dropped.
- Reject configs that set `dns_server_address` or
  `enable_resolution_service` under `mode = "blip32"`, since these
  options would otherwise be silently ignored and leave users thinking
  they took effect.
- Fall back to port 53 when a DNS server address is given without an
  explicit port (e.g., `dns_server_address = "1.1.1.1"` is treated as
  `"1.1.1.1:53"`), matching the convention for DNS.

Generated with the assistance of AI (Claude).

Author: tnull

contrib/ldk-server-config.toml

@@ -109,7 +109,8 @@ poll_metrics_interval = 60       # The polling interval for metrics in seconds.
 # Resolution method: "dns" (resolve locally via a DNS server) or "blip32" (ask other
 # nodes to resolve for us via bLIP-32). Defaults to "dns".
 #mode = "dns"
-# DNS server used when `mode = "dns"`. Defaults to 8.8.8.8:53 (Google Public DNS).
+# DNS server used when `mode = "dns"`. Defaults to 8.8.8.8:53 (Google Public DNS). The
+# port defaults to 53 if omitted (e.g., "1.1.1.1" is treated as "1.1.1.1:53").
 #dns_server_address = "8.8.8.8:53"
 # When set to true (and `mode = "dns"`), also offer HRN resolution to the rest of the
 # network over Onion Messages. Requires the node to be announceable so resolution

docs/configuration.md

@@ -131,12 +131,14 @@ Human-Readable Names (e.g., `₿alice@example.com`) to Lightning payment destina
 Two resolution methods are supported via the `mode` field:
 
 - **`"dns"`** (default) - Resolve names locally using a DNS server. The server is set via
-  `dns_server_address` (default: `8.8.8.8:53`, Google Public DNS). When
-  `enable_resolution_service = true`, the node additionally offers HRN resolution to the
-  rest of the network over Onion Messages. This requires the node to be announceable so
-  resolution requests can be routed to it, and is therefore disabled by default.
+  `dns_server_address` (default: `8.8.8.8:53`, Google Public DNS). The port defaults to
+  `53` if omitted. When `enable_resolution_service = true`, the node additionally offers
+  HRN resolution to the rest of the network over Onion Messages. This requires the node
+  to be announceable so resolution requests can be routed to it, and is therefore
+  disabled by default.
 - **`"blip32"`** - Ask other nodes to resolve names on our behalf via
-  [bLIP-32](https://github.com/lightning/blips/blob/master/blip-0032.md).
+  [bLIP-32](https://github.com/lightning/blips/blob/master/blip-0032.md). `dns_server_address`
+  and `enable_resolution_service` only apply in `"dns"` mode and are rejected here.
 
 ## Storage Layout
 

ldk-server/src/util/config.rs

@@ -530,39 +530,80 @@ impl TryFrom<HrnTomlConfig> for HumanReadableNamesConfig {
 	type Error = io::Error;
 
 	fn try_from(value: HrnTomlConfig) -> Result<Self, Self::Error> {
-		let mut config = HumanReadableNamesConfig::default();
-
-		match value.mode.as_deref() {
-			None | Some("dns") => {},
+		let HrnTomlConfig { mode, dns_server_address, enable_resolution_service } = value;
+
+		let resolution_config = match mode.as_deref() {
+			None | Some("dns") => {
+				// Start from LDK Node's DNS defaults so we don't have to hardcode them, but fall
+				// back to explicit values if the upstream default ever stops being `Dns`.
+				let (mut dns_server_address_val, mut enable_hrn_resolution_service) =
+					if let HRNResolverConfig::Dns {
+						dns_server_address,
+						enable_hrn_resolution_service,
+					} = HumanReadableNamesConfig::default().resolution_config
+					{
+						(dns_server_address, enable_hrn_resolution_service)
+					} else {
+						(
+							SocketAddress::from_str("8.8.8.8:53")
+								.expect("`8.8.8.8:53` is a valid socket address"),
+							false,
+						)
+					};
+
+				if let Some(addr) = dns_server_address.as_deref() {
+					dns_server_address_val = parse_dns_server_address(addr)?;
+				}
+				if let Some(enable) = enable_resolution_service {
+					enable_hrn_resolution_service = enable;
+				}
+
+				HRNResolverConfig::Dns {
+					dns_server_address: dns_server_address_val,
+					enable_hrn_resolution_service,
+				}
+			},
 			Some("blip32") => {
-				config.resolution_config = HRNResolverConfig::Blip32;
+				if dns_server_address.is_some() {
+					return Err(io::Error::new(
+						io::ErrorKind::InvalidInput,
+						"`hrn.dns_server_address` only applies when `hrn.mode = \"dns\"`"
+							.to_string(),
+					));
+				}
+				if enable_resolution_service.is_some() {
+					return Err(io::Error::new(
+						io::ErrorKind::InvalidInput,
+						"`hrn.enable_resolution_service` only applies when `hrn.mode = \"dns\"`"
+							.to_string(),
+					));
+				}
+				HRNResolverConfig::Blip32
 			},
 			Some(other) => {
 				return Err(io::Error::new(
 					io::ErrorKind::InvalidInput,
 					format!("Invalid HRN mode '{}' configured; expected 'dns' or 'blip32'", other),
 				))
 			},
-		}
+		};
 
-		if let HRNResolverConfig::Dns { dns_server_address, enable_hrn_resolution_service } =
-			&mut config.resolution_config
-		{
-			if let Some(addr) = value.dns_server_address.as_deref() {
-				*dns_server_address = SocketAddress::from_str(addr).map_err(|e| {
-					io::Error::new(
-						io::ErrorKind::InvalidInput,
-						format!("Invalid HRN DNS server address configured: {}", e),
-					)
-				})?;
-			}
-			if let Some(enable) = value.enable_resolution_service {
-				*enable_hrn_resolution_service = enable;
-			}
-		}
+		Ok(HumanReadableNamesConfig { resolution_config })
+	}
+}
 
-		Ok(config)
+/// Parses a DNS server address, falling back to port 53 if the user omitted the port.
+fn parse_dns_server_address(addr: &str) -> io::Result<SocketAddress> {
+	if let Ok(sa) = SocketAddress::from_str(addr) {
+		return Ok(sa);
 	}
+	let with_default_port = format!("{}:53", addr);
+	SocketAddress::from_str(&with_default_port).map_err(|e| {
+		io::Error::new(
+			io::ErrorKind::InvalidInput,
+			format!("Invalid HRN DNS server address configured: {}", e),
+		)
+	})
 }
 
 #[derive(Deserialize, Serialize)]
@@ -1634,11 +1675,43 @@ mod tests {
 		let err = load_config(&args_config).unwrap_err();
 		assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
 
-		// Invalid DNS server address is rejected.
+		// Invalid DNS server address is rejected (contains chars disallowed in hostnames, so
+		// neither the as-is parse nor the `:53` fallback can accept it).
 		let toml_config =
-			format!("{}\n[hrn]\ndns_server_address = \"not-a-socket-address\"\n", base_config);
+			format!("{}\n[hrn]\ndns_server_address = \"invalid@address\"\n", base_config);
+		fs::write(storage_path.join(config_file_name), &toml_config).unwrap();
+		let err = load_config(&args_config).unwrap_err();
+		assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+
+		// DNS server address without an explicit port defaults to port 53.
+		let toml_config = format!("{}\n[hrn]\ndns_server_address = \"1.1.1.1\"\n", base_config);
+		fs::write(storage_path.join(config_file_name), &toml_config).unwrap();
+		let config = load_config(&args_config).unwrap();
+		match config.hrn_config.resolution_config {
+			HRNResolverConfig::Dns { dns_server_address, .. } => {
+				assert_eq!(dns_server_address, SocketAddress::from_str("1.1.1.1:53").unwrap());
+			},
+			other => panic!("unexpected HRN resolver config: {:?}", other),
+		}
+
+		// `blip32` mode combined with DNS-only settings is rejected so users aren't confused
+		// by settings that would silently have no effect.
+		let toml_config = format!(
+			"{}\n[hrn]\nmode = \"blip32\"\ndns_server_address = \"1.1.1.1:53\"\n",
+			base_config
+		);
+		fs::write(storage_path.join(config_file_name), &toml_config).unwrap();
+		let err = load_config(&args_config).unwrap_err();
+		assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+		assert!(err.to_string().contains("dns_server_address"));
+
+		let toml_config = format!(
+			"{}\n[hrn]\nmode = \"blip32\"\nenable_resolution_service = true\n",
+			base_config
+		);
 		fs::write(storage_path.join(config_file_name), &toml_config).unwrap();
 		let err = load_config(&args_config).unwrap_err();
 		assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+		assert!(err.to_string().contains("enable_resolution_service"));
 	}
 }