Use pay_for_offer_from_hrn in unified API

Integrate the LDK upstream pay_for_offer_from_hrn method into the
unified payment flow.

Previously, sending to a Human Readable Name (HRN) did not utilize the
specialized upstream logic required for these offers. By switching to
this method, we ensure compatibility with LDK's intended handling of
HRN-based payments, providing a more robust resolution
path for unified API users.

Author: chuksys

bindings/ldk_node.udl

@@ -347,6 +347,7 @@ enum NodeError {
 	"LiquidityFeeTooHigh",
 	"InvalidBlindedPaths",
 	"AsyncPaymentServicesDisabled",
+	"HrnParsingFailed",
 };
 
 dictionary NodeStatus {
@@ -809,6 +810,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

@@ -129,6 +129,8 @@ pub enum Error {
 	InvalidBlindedPaths,
 	/// Asynchronous payment services are disabled.
 	AsyncPaymentServicesDisabled,
+	/// Parsing a Human-Readable Name has failed.
+	HrnParsingFailed,
 }
 
 impl fmt::Display for Error {
@@ -208,6 +210,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

@@ -57,7 +57,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};
 
@@ -287,6 +287,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

@@ -23,6 +23,7 @@ use bitcoin::address::NetworkChecked;
 use bitcoin::{Amount, Txid};
 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};
 
@@ -212,7 +213,10 @@ impl UnifiedPayment {
 				PaymentMethod::LightningBolt12(offer) => {
 					let offer = maybe_wrap(offer.clone());
 
-					let payment_result = if let Some(amount_msat) = amount_msat {
+					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)
@@ -229,10 +233,10 @@ impl UnifiedPayment {
 				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
-							});
+						.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 });
@@ -262,9 +266,6 @@ impl UnifiedPayment {
 		Err(Error::PaymentSendingFailed)
 	}
 }
-
-/// Represents the result of a payment made using a [BIP 21] QR code.
-///
 /// After a successful on-chain transaction, the transaction ID ([`Txid`]) is returned.
 /// For BOLT11 and BOLT12 payments, the corresponding [`PaymentId`] is returned.
 ///