xRefactor unified payment to support BIP 21 and HRNs

Restructure the payment initiation logic in unified.rs to handle both BIP 21
URIs and BIP 353 Human-Readable Names (HRNs) as input sources. This
provides a single, unified entry point for initiating payments.

Author: chuksys

bindings/ldk_node.udl

@@ -278,8 +278,8 @@ interface FeeRate {
 interface UnifiedPayment {
 	[Throws=NodeError]
 	string receive(u64 amount_sats, [ByRef]string message, u32 expiry_sec);
-	[Throws=NodeError]
-	UnifiedPaymentResult 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 {

src/payment/unified.rs

@@ -19,13 +19,17 @@ use std::vec::IntoIter;
 
 use bip21::de::ParamKind;
 use bip21::{DeserializationError, DeserializeParams, Param, SerializeParams};
-use bitcoin::address::{NetworkChecked, NetworkUnchecked};
+use bitcoin::address::NetworkChecked;
 use bitcoin::{Amount, Txid};
 use lightning::ln::channelmanager::PaymentId;
 use lightning::offers::offer::Offer;
 use lightning::routing::router::RouteParametersConfig;
 use lightning_invoice::{Bolt11Invoice, Bolt11InvoiceDescription, Description};
 
+use bitcoin_payment_instructions::{
+	amount::Amount as BPIAmount, PaymentInstructions, PaymentMethod,
+};
+
 use crate::error::Error;
 use crate::ffi::maybe_wrap;
 use crate::logger::{log_error, LdkLogger, Logger};
@@ -138,63 +142,124 @@ impl UnifiedPayment {
 		Ok(format_uri(uri))
 	}
 
-	/// Sends a payment given a [BIP 21] URI.
+	/// Sends a payment given a [BIP 21] URI or [BIP 353] HRN.
 	///
 	/// This method parses the provided URI string and attempts to send the payment. If the URI
 	/// has an offer and or invoice, it will try to pay the offer first followed by the invoice.
 	/// If they both fail, the on-chain payment will be paid.
 	///
-	/// Returns a `QrPaymentResult` indicating the outcome of the payment. If an error
+	/// Returns a `UnifiedPaymentResult` indicating the outcome of the payment. If an error
 	/// occurs, an `Error` is returned detailing the issue encountered.
 	///
 	/// If `route_parameters` are provided they will override the default as well as the
 	/// node-wide parameters configured via [`Config::route_parameters`] on a per-field basis.
 	///
 	/// [BIP 21]: https://github.com/bitcoin/bips/blob/master/bip-0021.mediawiki
-	pub fn send(
-		&self, uri_str: &str, route_parameters: Option<RouteParametersConfig>,
+	/// [BIP 353]: https://github.com/bitcoin/bips/blob/master/bip-0353.mediawiki
+	pub async fn send(
+		&self, uri_str: &str, amount_msat: Option<u64>,
+		route_parameters: Option<RouteParametersConfig>,
 	) -> Result<UnifiedPaymentResult, Error> {
-		let uri: bip21::Uri<NetworkUnchecked, Extras> =
-			uri_str.parse().map_err(|_| Error::InvalidUri)?;
-
-		let _resolver = &self.hrn_resolver;
-
-		let uri_network_checked =
-			uri.clone().require_network(self.config.network).map_err(|_| Error::InvalidNetwork)?;
-
-		if let Some(offer) = uri_network_checked.extras.bolt12_offer {
-			let offer = maybe_wrap(offer);
-
-			match self.bolt12_payment.send(&offer, None, None, route_parameters) {
-				Ok(payment_id) => return Ok(UnifiedPaymentResult::Bolt12 { payment_id }),
-				Err(e) => log_error!(self.logger, "Failed to send BOLT12 offer: {:?}. This is part of a unified QR code payment. Falling back to the BOLT11 invoice.", e),
-			}
-		}
-
-		if let Some(invoice) = uri_network_checked.extras.bolt11_invoice {
-			let invoice = maybe_wrap(invoice);
-
-			match self.bolt11_invoice.send(&invoice, route_parameters) {
-				Ok(payment_id) => return Ok(UnifiedPaymentResult::Bolt11 { payment_id }),
-				Err(e) => log_error!(self.logger, "Failed to send BOLT11 invoice: {:?}. This is part of a unified QR code payment. Falling back to the on-chain transaction.", e),
-			}
-		}
-
-		let amount = match uri_network_checked.amount {
-			Some(amount) => amount,
-			None => {
-				log_error!(self.logger, "No amount specified in the URI. Aborting the payment.");
-				return Err(Error::InvalidAmount);
+		let instructions = PaymentInstructions::parse(
+			uri_str,
+			self.config.network,
+			self.hrn_resolver.as_ref(),
+			false,
+		)
+		.await
+		.map_err(|e| {
+			log_error!(self.logger, "Failed to parse payment instructions: {:?}", e);
+			Error::UriParameterParsingFailed
+		})?;
+
+		let resolved = match instructions {
+			PaymentInstructions::ConfigurableAmount(instr) => {
+				let amount = amount_msat.ok_or_else(|| {
+					log_error!(self.logger, "No amount specified. Aborting the payment.");
+					Error::InvalidAmount
+				})?;
+
+				let amt = BPIAmount::from_milli_sats(amount).map_err(|e| {
+					log_error!(self.logger, "Error while converting amount : {:?}", e);
+					Error::InvalidAmount
+				})?;
+
+				instr.set_amount(amt, self.hrn_resolver.as_ref()).await.map_err(|e| {
+					log_error!(self.logger, "Failed to set amount: {:?}", e);
+					Error::InvalidAmount
+				})?
+			},
+			PaymentInstructions::FixedAmount(instr) => {
+				if let Some(user_amount) = amount_msat {
+					if instr.max_amount().map_or(false, |amt| user_amount < amt.milli_sats()) {
+						log_error!(self.logger, "Amount specified is less than the amount in the parsed URI. Aborting the payment.");
+						return Err(Error::InvalidAmount);
+					}
+				}
+				instr
 			},
 		};
 
-		let txid = self.onchain_payment.send_to_address(
-			&uri_network_checked.address,
-			amount.to_sat(),
-			None,
-		)?;
+		let mut sorted_payment_methods = resolved.methods().to_vec();
+		sorted_payment_methods.sort_by_key(|method| match method {
+			PaymentMethod::LightningBolt12(_) => 0,
+			PaymentMethod::LightningBolt11(_) => 1,
+			PaymentMethod::OnChain(_) => 2,
+		});
+
+		for method in sorted_payment_methods {
+			match method {
+				PaymentMethod::LightningBolt12(offer) => {
+					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 });
+					}
+				},
+				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 });
+				},
+			}
+		}
 
-		Ok(UnifiedPaymentResult::Onchain { txid })
+		log_error!(self.logger, "Payable methods not found in URI");
+		Err(Error::PaymentSendingFailed)
 	}
 }
 
@@ -321,7 +386,8 @@ impl DeserializationError for Extras {
 
 #[cfg(test)]
 mod tests {
-	use super::{Amount, Bolt11Invoice, Extras, Offer};
+	use super::*;
+	use crate::payment::unified::Extras;
 	use bitcoin::{address::NetworkUnchecked, Address, Network};
 	use std::str::FromStr;
 

tests/integration_tests_rust.rs

@@ -1607,28 +1607,29 @@ async fn unified_qr_send_receive() {
 
 	let uni_payment = node_b.unified_payment().receive(expected_amount_sats, "asdf", expiry_sec);
 	let uri_str = uni_payment.clone().unwrap();
-	let offer_payment_id: PaymentId = match node_a.unified_payment().send(&uri_str, None) {
-		Ok(UnifiedPaymentResult::Bolt12 { payment_id }) => {
-			println!("\nBolt12 payment sent successfully with PaymentID: {:?}", payment_id);
-			payment_id
-		},
-		Ok(UnifiedPaymentResult::Bolt11 { payment_id: _ }) => {
-			panic!("Expected Bolt12 payment but got Bolt11");
-		},
-		Ok(UnifiedPaymentResult::Onchain { txid: _ }) => {
-			panic!("Expected Bolt12 payment but get On-chain transaction");
-		},
-		Err(e) => {
-			panic!("Expected Bolt12 payment but got error: {:?}", e);
-		},
-	};
+	let offer_payment_id: PaymentId =
+		match node_a.unified_payment().send(&uri_str, None, None).await {
+			Ok(UnifiedPaymentResult::Bolt12 { payment_id }) => {
+				println!("\nBolt12 payment sent successfully with PaymentID: {:?}", payment_id);
+				payment_id
+			},
+			Ok(UnifiedPaymentResult::Bolt11 { payment_id: _ }) => {
+				panic!("Expected Bolt12 payment but got Bolt11");
+			},
+			Ok(UnifiedPaymentResult::Onchain { txid: _ }) => {
+				panic!("Expected Bolt12 payment but get On-chain transaction");
+			},
+			Err(e) => {
+				panic!("Expected Bolt12 payment but got error: {:?}", e);
+			},
+		};
 
 	expect_payment_successful_event!(node_a, Some(offer_payment_id), None);
 
 	// Cut off the BOLT12 part to fallback to BOLT11.
 	let uri_str_without_offer = uri_str.split("&lno=").next().unwrap();
 	let invoice_payment_id: PaymentId =
-		match node_a.unified_payment().send(uri_str_without_offer, None) {
+		match node_a.unified_payment().send(uri_str_without_offer, None, None).await {
 			Ok(UnifiedPaymentResult::Bolt12 { payment_id: _ }) => {
 				panic!("Expected Bolt11 payment but got Bolt12");
 			},
@@ -1651,7 +1652,7 @@ async fn unified_qr_send_receive() {
 
 	// Cut off any lightning part to fallback to on-chain only.
 	let uri_str_without_lightning = onchain_uni_payment.split("&lightning=").next().unwrap();
-	let txid = match node_a.unified_payment().send(&uri_str_without_lightning, None) {
+	let txid = match node_a.unified_payment().send(&uri_str_without_lightning, None, None).await {
 		Ok(UnifiedPaymentResult::Bolt12 { payment_id: _ }) => {
 			panic!("Expected on-chain payment but got Bolt12")
 		},