Refactor unified_qr.rs to use bitcoin-payment-instructions

Cargo.toml

@@ -77,6 +77,8 @@ log = { version = "0.4.22", default-features = false, features = ["std"]}
 
 vss-client = { package = "vss-client-ng", version = "0.4" }
 prost = { version = "0.11.6", default-features = false}
+#bitcoin-payment-instructions = { version = "0.6" }
+bitcoin-payment-instructions = { git = "https://github.com/tnull/bitcoin-payment-instructions", branch = "2025-12-ldk-node-base" }
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3", features = ["winbase"] }

bindings/ldk_node.udl

@@ -149,7 +149,7 @@ interface Node {
 	Bolt12Payment bolt12_payment();
 	SpontaneousPayment spontaneous_payment();
 	OnchainPayment onchain_payment();
-UnifiedQrPayment unified_qr_payment();
+UnifiedPayment unified_payment();
 	LSPS1Liquidity lsps1_liquidity();
 	[Throws=NodeError]
 	void connect(PublicKey node_id, SocketAddress address, boolean persist);
@@ -275,11 +275,11 @@ interface FeeRate {
 	u64 to_sat_per_vb_ceil();
 };
 
-interface UnifiedQrPayment {
+interface UnifiedPayment {
 	[Throws=NodeError]
 	string receive(u64 amount_sats, [ByRef]string message, u32 expiry_sec);
-	[Throws=NodeError]
-QrPaymentResult send([ByRef]string uri_str, RouteParametersConfig? route_parameters);
+	[Throws=NodeError, Async]
+UnifiedPaymentResult send([ByRef]string uri_str, u64? amount_msat, RouteParametersConfig? route_parameters);
 };
 
 interface LSPS1Liquidity {
@@ -347,6 +347,7 @@ enum NodeError {
 	"LiquidityFeeTooHigh",
 	"InvalidBlindedPaths",
 	"AsyncPaymentServicesDisabled",
+	"HrnParsingFailed",
 };
 
 dictionary NodeStatus {
@@ -456,7 +457,7 @@ interface PaymentKind {
 };
 
 [Enum]
-interface QrPaymentResult {
+interface UnifiedPaymentResult {
 	Onchain(Txid txid);
 	Bolt11(PaymentId payment_id);
 	Bolt12(PaymentId payment_id);
@@ -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/builder.rs

@@ -19,6 +19,9 @@ use bitcoin::bip32::{ChildNumber, Xpriv};
 use bitcoin::key::Secp256k1;
 use bitcoin::secp256k1::PublicKey;
 use bitcoin::{BlockHash, Network};
+
+use bitcoin_payment_instructions::onion_message_resolver::LDKOnionMessageDNSSECHrnResolver;
+
 use lightning::chain::{chainmonitor, BestBlock, Watch};
 use lightning::io::Cursor;
 use lightning::ln::channelmanager::{self, ChainParameters, ChannelManagerReadArgs};
@@ -1439,6 +1442,8 @@ fn build_with_store_internal(
  })?;
 	}
 
+	let hrn_resolver = Arc::new(LDKOnionMessageDNSSECHrnResolver::new(Arc::clone(&network_graph)));
+
 	// Initialize the PeerManager
 	let onion_messenger: Arc<OnionMessenger> =
  if let Some(AsyncPaymentsRole::Server) = async_payments_role {
@@ -1450,7 +1455,7 @@ fn build_with_store_internal(
  message_router,
  Arc::clone(&channel_manager),
  Arc::clone(&channel_manager),
-IgnoringMessageHandler {},
+Arc::clone(&hrn_resolver),
  IgnoringMessageHandler {},
  ))
  } else {
@@ -1462,7 +1467,7 @@ fn build_with_store_internal(
  message_router,
  Arc::clone(&channel_manager),
  Arc::clone(&channel_manager),
-IgnoringMessageHandler {},
+Arc::clone(&hrn_resolver),
  IgnoringMessageHandler {},
  ))
  };
@@ -1594,6 +1599,12 @@ fn build_with_store_internal(
  Arc::clone(&keys_manager),
 	));
 
+	let peer_manager_clone = Arc::clone(&peer_manager);
+
+	hrn_resolver.register_post_queue_action(Box::new(move || {
+ peer_manager_clone.process_events();
+	}));
+
 	liquidity_source.as_ref().map(|l| l.set_peer_manager(Arc::clone(&peer_manager)));
 
 	gossip_source.set_gossip_verifier(
@@ -1701,6 +1712,7 @@ fn build_with_store_internal(
  node_metrics,
  om_mailbox,
  async_payments_role,
+ hrn_resolver,
 	})
 }
 

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

@@ -55,7 +55,10 @@ pub use crate::logger::{LogLevel, LogRecord, LogWriter};
 pub use crate::payment::store::{
 	ConfirmationStatus, LSPFeeLimits, PaymentDirection, PaymentKind, PaymentStatus,
 };
-pub use crate::payment::QrPaymentResult;
+pub use crate::payment::UnifiedPaymentResult;
+
+use lightning::onion_message::dns_resolution::HumanReadableName as LdkHumanReadableName;
+
 use crate::{hex_utils, SocketAddress, UniffiCustomTypeConverter, UserChannelId};
 
 impl UniffiCustomTypeConverter for PublicKey {
@@ -284,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/lib.rs

@@ -152,14 +152,15 @@ use payment::asynchronous::om_mailbox::OnionMessageMailbox;
 use payment::asynchronous::static_invoice_store::StaticInvoiceStore;
 use payment::{
 	Bolt11Payment, Bolt12Payment, OnchainPayment, PaymentDetails, SpontaneousPayment,
-UnifiedQrPayment,
+UnifiedPayment,
 };
 use peer_store::{PeerInfo, PeerStore};
 use rand::Rng;
 use runtime::Runtime;
 use types::{
 	Broadcaster, BumpTransactionEventHandler, ChainMonitor, ChannelManager, DynStore, Graph,
-	KeysManager, OnionMessenger, PaymentStore, PeerManager, Router, Scorer, Sweeper, Wallet,
+	HRNResolver, KeysManager, OnionMessenger, PaymentStore, PeerManager, Router, Scorer, Sweeper,
+	Wallet,
 };
 pub use types::{ChannelDetails, CustomTlvRecord, PeerDetails, SyncAndAsyncKVStore, UserChannelId};
 pub use {
@@ -206,6 +207,7 @@ pub struct Node {
 	node_metrics: Arc<RwLock<NodeMetrics>>,
 	om_mailbox: Option<Arc<OnionMessageMailbox>>,
 	async_payments_role: Option<AsyncPaymentsRole>,
+	hrn_resolver: Arc<HRNResolver>,
 }
 
 impl Node {
@@ -945,34 +947,42 @@ impl Node {
 	/// Returns a payment handler allowing to create [BIP 21] URIs with an on-chain, [BOLT 11],
 	/// and [BOLT 12] payment options.
 	///
+	/// This handler allows you to send payments to these URIs as well as [BIP 353] HRNs.
+	///
 	/// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md
 	/// [BOLT 12]: https://github.com/lightning/bolts/blob/master/12-offer-encoding.md
 	/// [BIP 21]: https://github.com/bitcoin/bips/blob/master/bip-0021.mediawiki
+	/// [BIP 353]: https://github.com/bitcoin/bips/blob/master/bip-0353.mediawiki
 	#[cfg(not(feature = "uniffi"))]
-	pub fn unified_qr_payment(&self) -> UnifiedQrPayment {
-UnifiedQrPayment::new(
+	pub fn unified_payment(&self) -> UnifiedPayment {
+UnifiedPayment::new(
  self.onchain_payment().into(),
  self.bolt11_payment().into(),
  self.bolt12_payment().into(),
  Arc::clone(&self.config),
  Arc::clone(&self.logger),
+ Arc::clone(&self.hrn_resolver),
  )
 	}
 
 	/// Returns a payment handler allowing to create [BIP 21] URIs with an on-chain, [BOLT 11],
 	/// and [BOLT 12] payment options.
 	///
+	/// This handler allows you to send payments to these URIs as well as [BIP 353] HRNs.
+	///
 	/// [BOLT 11]: https://github.com/lightning/bolts/blob/master/11-payment-encoding.md
 	/// [BOLT 12]: https://github.com/lightning/bolts/blob/master/12-offer-encoding.md
 	/// [BIP 21]: https://github.com/bitcoin/bips/blob/master/bip-0021.mediawiki
+	/// [BIP 353]: https://github.com/bitcoin/bips/blob/master/bip-0353.mediawiki
 	#[cfg(feature = "uniffi")]
-	pub fn unified_qr_payment(&self) -> Arc<UnifiedQrPayment> {
- Arc::new(UnifiedQrPayment::new(
+	pub fn unified_payment(&self) -> Arc<UnifiedPayment> {
+ Arc::new(UnifiedPayment::new(
  self.onchain_payment(),
  self.bolt11_payment(),
  self.bolt12_payment(),
  Arc::clone(&self.config),
  Arc::clone(&self.logger),
+ Arc::clone(&self.hrn_resolver),
  ))
 	}
 

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/mod.rs

@@ -13,7 +13,7 @@ mod bolt12;
 mod onchain;
 mod spontaneous;
 pub(crate) mod store;
-mod unified_qr;
+mod unified;
 
 pub use bolt11::Bolt11Payment;
 pub use bolt12::Bolt12Payment;
@@ -22,4 +22,4 @@ pub use spontaneous::SpontaneousPayment;
 pub use store::{
 	ConfirmationStatus, LSPFeeLimits, PaymentDetails, PaymentDirection, PaymentKind, PaymentStatus,
 };
-pub use unified_qr::{QrPaymentResult, UnifiedQrPayment};
+pub use unified::{UnifiedPayment, UnifiedPaymentResult};