Adopt LDK's pay_for_offer_from_hrn method

Adopt the upstream LDK change to use the dedicated
pay_for_offer_from_hrn method when initiating a payment for an offer
resolved via a Human-Readable Name (HRN). This ensures better alignment
with LDK best practices.

Author: chuksys

bindings/ldk_node.udl

@@ -216,7 +216,7 @@ interface Bolt12Payment {
 	[Throws=NodeError]
 	PaymentId send([ByRef]Offer offer, u64? quantity, string? payer_note, RouteParametersConfig? route_parameters);
 	[Throws=NodeError]
-	PaymentId send_using_amount([ByRef]Offer offer, u64 amount_msat, u64? quantity, string? payer_note, RouteParametersConfig? route_parameters);
+	PaymentId send_using_amount([ByRef]Offer offer, u64 amount_msat, u64? quantity, string? payer_note, RouteParametersConfig? route_parameters, HumanReadableName? hrn);
 	[Throws=NodeError]
 	Offer receive(u64 amount_msat, [ByRef]string description, u32? expiry_secs, u64? quantity);
 	[Throws=NodeError]
@@ -336,6 +336,7 @@ enum NodeError {
 	"LiquidityFeeTooHigh",
 	"InvalidBlindedPaths",
 	"AsyncPaymentServicesDisabled",
+	"HrnParsingFailed",
 };
 
 dictionary NodeStatus {
@@ -799,6 +800,13 @@ interface Offer {
 	PublicKey? issuer_signing_pubkey();
 };
 
+interface HumanReadableName {
+	[Throws=NodeError, Name=from_encoded]
+	constructor([ByRef] string encoded);
+	string user();
+	string domain();
+};
+
 [Traits=(Debug, Display, Eq)]
 interface Refund {
 	[Throws=NodeError, Name=from_str]

src/error.rs

@@ -127,6 +127,8 @@ pub enum Error {
 	InvalidBlindedPaths,
 	/// Asynchronous payment services are disabled.
 	AsyncPaymentServicesDisabled,
+	/// Parsing a Human-Readable Name has failed.
+	HrnParsingFailed,
 }
 
 impl fmt::Display for Error {
@@ -205,6 +207,9 @@ impl fmt::Display for Error {
 			Self::AsyncPaymentServicesDisabled => {
 				write!(f, "Asynchronous payment services are disabled.")
 			},
+			Self::HrnParsingFailed => {
+				write!(f, "Failed to parse a human-readable name.")
+			},
 		}
 	}
 }

src/ffi/types.rs

@@ -56,7 +56,7 @@ pub use crate::payment::store::{
 };
 pub use crate::payment::UnifiedPaymentResult;
 
-pub use lightning::onion_message::dns_resolution::HumanReadableName as LdkHumanReadableName;
+use lightning::onion_message::dns_resolution::HumanReadableName as LdkHumanReadableName;
 
 use crate::{hex_utils, SocketAddress, UniffiCustomTypeConverter, UserChannelId};
 
@@ -270,6 +270,72 @@ impl std::fmt::Display for Offer {
 	}
 }
 
+/// A struct containing the two parts of a BIP 353 Human-Readable Name - the user and domain parts.
+///
+/// The `user` and `domain` parts combined cannot exceed 231 bytes in length;
+/// each DNS label within them must be non-empty and no longer than 63 bytes.
+///
+/// If you intend to handle non-ASCII `user` or `domain` parts, you must handle [Homograph Attacks]
+/// and do punycode en-/de-coding yourself. This struct will always handle only plain ASCII `user`
+/// and `domain` parts.
+///
+/// This struct can also be used for LN-Address recipients.
+///
+/// [Homograph Attacks]: https://en.wikipedia.org/wiki/IDN_homograph_attack
+pub struct HumanReadableName {
+	pub(crate) inner: LdkHumanReadableName,
+}
+
+impl HumanReadableName {
+	/// Constructs a new [`HumanReadableName`] from the standard encoding - `user`@`domain`.
+	///
+	/// If `user` includes the standard BIP 353 ₿ prefix it is automatically removed as required by
+	/// BIP 353.
+	pub fn from_encoded(encoded: &str) -> Result<Self, Error> {
+		let hrn = match LdkHumanReadableName::from_encoded(encoded) {
+			Ok(hrn) => Ok(hrn),
+			Err(_) => Err(Error::HrnParsingFailed),
+		}?;
+
+		Ok(Self { inner: hrn })
+	}
+
+	/// Gets the `user` part of this Human-Readable Name
+	pub fn user(&self) -> String {
+		self.inner.user().to_string()
+	}
+
+	/// Gets the `domain` part of this Human-Readable Name
+	pub fn domain(&self) -> String {
+		self.inner.domain().to_string()
+	}
+}
+
+impl From<LdkHumanReadableName> for HumanReadableName {
+	fn from(ldk_hrn: LdkHumanReadableName) -> Self {
+		HumanReadableName { inner: ldk_hrn }
+	}
+}
+
+impl From<HumanReadableName> for LdkHumanReadableName {
+	fn from(wrapper: HumanReadableName) -> Self {
+		wrapper.inner
+	}
+}
+
+impl Deref for HumanReadableName {
+	type Target = LdkHumanReadableName;
+	fn deref(&self) -> &Self::Target {
+		&self.inner
+	}
+}
+
+impl AsRef<LdkHumanReadableName> for HumanReadableName {
+	fn as_ref(&self) -> &LdkHumanReadableName {
+		self.deref()
+	}
+}
+
 /// A `Refund` is a request to send an [`Bolt12Invoice`] without a preceding [`Offer`].
 ///
 /// Typically, after an invoice is paid, the recipient may publish a refund allowing the sender to

src/payment/bolt12.rs

@@ -15,7 +15,7 @@ use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 use lightning::blinded_path::message::BlindedMessagePath;
 use lightning::ln::channelmanager::{OptionalOfferPaymentParams, PaymentId, Retry};
-use lightning::offers::offer::{Amount, Offer as LdkOffer, Quantity};
+use lightning::offers::offer::{Amount, Offer as LdkOffer, OfferFromHrn, Quantity};
 use lightning::offers::parse::Bolt12SemanticError;
 use lightning::routing::router::RouteParametersConfig;
 #[cfg(feature = "uniffi")]
@@ -45,6 +45,11 @@ type Refund = lightning::offers::refund::Refund;
 #[cfg(feature = "uniffi")]
 type Refund = Arc<crate::ffi::Refund>;
 
+#[cfg(not(feature = "uniffi"))]
+type HumanReadableName = lightning::onion_message::dns_resolution::HumanReadableName;
+#[cfg(feature = "uniffi")]
+type HumanReadableName = Arc<crate::ffi::HumanReadableName>;
+
 /// A payment handler allowing to create and pay [BOLT 12] offers and refunds.
 ///
 /// Should be retrieved by calling [`Node::bolt12_payment`].
@@ -193,6 +198,37 @@ impl Bolt12Payment {
 	pub fn send_using_amount(
 		&self, offer: &Offer, amount_msat: u64, quantity: Option<u64>, payer_note: Option<String>,
 		route_parameters: Option<RouteParametersConfig>,
+	) -> Result<PaymentId, Error> {
+		let payment_id = self.send_using_amount_inner(
+			offer,
+			amount_msat,
+			quantity,
+			payer_note,
+			route_parameters,
+			None,
+		)?;
+		Ok(payment_id)
+	}
+
+	/// Internal helper to send a BOLT12 offer payment given an offer
+	/// and an amount in millisatoshi.
+	///
+	/// This function contains the core payment logic and is called by
+	/// [`Self::send_using_amount`] and other internal logic that resolves
+	/// payment parameters (e.g. [`crate::UnifiedPayment::send`]).
+	///
+	/// It wraps the core LDK `pay_for_offer` logic and handles necessary pre-checks,
+	/// payment ID generation, and payment details storage.
+	///
+	/// The amount validation logic ensures the provided `amount_msat` is sufficient
+	/// based on the offer's required amount.
+	///
+	/// If `hrn` is `Some`, the payment is initiated using [`ChannelManager::pay_for_offer_from_hrn`]
+	/// for offers resolved from a Human-Readable Name ([`HumanReadableName`]).
+	/// Otherwise, it falls back to the standard offer payment methods.
+	pub(crate) fn send_using_amount_inner(
+		&self, offer: &Offer, amount_msat: u64, quantity: Option<u64>, payer_note: Option<String>,
+		route_parameters: Option<RouteParametersConfig>, hrn: Option<HumanReadableName>,
 	) -> Result<PaymentId, Error> {
 		if !*self.is_running.read().unwrap() {
 			return Err(Error::NotRunning);
@@ -228,7 +264,11 @@ impl Bolt12Payment {
 			retry_strategy,
 			route_params_config: route_parameters,
 		};
-		let res = if let Some(quantity) = quantity {
+		let res = if let Some(hrn) = hrn {
+			let hrn = maybe_deref(&hrn);
+			let offer = OfferFromHrn { offer: offer.clone(), hrn: *hrn };
+			self.channel_manager.pay_for_offer_from_hrn(&offer, amount_msat, payment_id, params)
+		} else if let Some(quantity) = quantity {
 			self.channel_manager.pay_for_offer_with_quantity(
 				&offer,
 				Some(amount_msat),

src/payment/unified.rs

@@ -25,6 +25,7 @@ use std::vec::IntoIter;
 
 use lightning::ln::channelmanager::PaymentId;
 use lightning::offers::offer::Offer;
+use lightning::onion_message::dns_resolution::HumanReadableName;
 use lightning::routing::router::RouteParametersConfig;
 use lightning_invoice::{Bolt11Invoice, Bolt11InvoiceDescription, Description};
 
@@ -199,56 +200,59 @@ impl UnifiedPayment {
 			},
 		};
 
-		if let Some(PaymentMethod::LightningBolt12(offer)) =
-			resolved.methods().iter().find(|m| matches!(m, PaymentMethod::LightningBolt12(_)))
-		{
-			let offer = maybe_wrap(offer.clone());
-			let payment_result = if let Some(amount_msat) = amount_msat {
-				self.bolt12_payment.send_using_amount(&offer, amount_msat, None, None, route_parameters)
-			} else {
-				self.bolt12_payment.send(&offer, None, None, route_parameters)
-			}
-			.map_err(|e| {
-				log_error!(self.logger, "Failed to send BOLT12 offer: {:?}. This is part of a unified payment. Falling back to the BOLT11 invoice.", e);
-				e
-			});
-
-			if let Ok(payment_id) = payment_result {
-				return Ok(UnifiedPaymentResult::Bolt12 { payment_id });
-			}
-		}
+		for method in resolved.methods() {
+			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))
+					} else if let Some(amount_msat) = amount_msat {
+						self.bolt12_payment.send_using_amount(&offer, amount_msat, None, None, route_parameters)
+					} else {
+						self.bolt12_payment.send(&offer, None, None, route_parameters)
+					}
+					.map_err(|e| {
+						log_error!(self.logger, "Failed to send BOLT12 offer: {:?}. This is part of a unified payment. Falling back to the BOLT11 invoice.", e);
+						e
+					});
 
-		if let Some(PaymentMethod::LightningBolt11(invoice)) =
-			resolved.methods().iter().find(|m| matches!(m, PaymentMethod::LightningBolt11(_)))
-		{
-			let invoice = maybe_wrap(invoice.clone());
-			let payment_result = self.bolt11_invoice.send(&invoice, route_parameters)
-				.map_err(|e| {
-					log_error!(self.logger, "Failed to send BOLT11 invoice: {:?}. This is part of a unified payment. Falling back to the on-chain transaction.", e);
-					e
-				});
-
-			if let Ok(payment_id) = payment_result {
-				return Ok(UnifiedPaymentResult::Bolt11 { payment_id });
+					if let Ok(payment_id) = payment_result {
+						return Ok(UnifiedPaymentResult::Bolt12 { payment_id });
+					}
+				},
+				PaymentMethod::LightningBolt11(invoice) => {
+					let invoice = maybe_wrap(invoice.clone());
+					let payment_result = self.bolt11_invoice.send(&invoice, route_parameters)
+						.map_err(|e| {
+							log_error!(self.logger, "Failed to send BOLT11 invoice: {:?}. This is part of a unified payment. Falling back to the on-chain transaction.", e);
+							e
+						});
+
+					if let Ok(payment_id) = payment_result {
+						return Ok(UnifiedPaymentResult::Bolt11 { payment_id });
+					}
+				},
+				PaymentMethod::OnChain(address) => {
+					let amount = resolved.onchain_payment_amount().ok_or_else(|| {
+						log_error!(self.logger, "No amount specified. Aborting the payment.");
+						Error::InvalidAmount
+					})?;
+
+					let amt_sats = amount.sats().map_err(|_| {
+						log_error!(
+							self.logger,
+							"Amount in sats returned an error. Aborting the payment."
+						);
+						Error::InvalidAmount
+					})?;
+
+					let txid = self.onchain_payment.send_to_address(&address, amt_sats, None)?;
+					return Ok(UnifiedPaymentResult::Onchain { txid });
+				},
 			}
 		}
-
-		if let Some(PaymentMethod::OnChain(address)) =
-			resolved.methods().iter().find(|m| matches!(m, PaymentMethod::OnChain(_)))
-		{
-			let amount = resolved.onchain_payment_amount().ok_or_else(|| {
-				log_error!(self.logger, "No amount specified. Aborting the payment.");
-				Error::InvalidAmount
-			})?;
-
-			let amt_sats = amount.sats().map_err(|_| {
-				log_error!(self.logger, "Amount in sats returned an error. Aborting the payment.");
-				Error::InvalidAmount
-			})?;
-
-			let txid = self.onchain_payment.send_to_address(&address, amt_sats, None)?;
-			return Ok(UnifiedPaymentResult::Onchain { txid });
-		}
 		log_error!(self.logger, "Payable methods not found in URI");
 		Err(Error::PaymentSendingFailed)
 	}