Refactor unified.rs to support sending to BIP 21 URIs as well as BIP 353 HRNs

Author: chuksys

src/payment/unified.rs

@@ -27,8 +27,11 @@ use lightning_invoice::{Bolt11Invoice, Bolt11InvoiceDescription, Description};
 
 use bip21::de::ParamKind;
 use bip21::{DeserializationError, DeserializeParams, Param, SerializeParams};
-use bitcoin::address::{NetworkChecked, NetworkUnchecked};
+use bitcoin::address::NetworkChecked;
 use bitcoin::{Amount, Txid};
+use bitcoin_payment_instructions::{
+	amount::Amount as BPIAmount, PaymentInstructions, PaymentMethod,
+};
 
 use std::sync::Arc;
 use std::vec::IntoIter;
@@ -138,54 +141,110 @@ 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.
 	///
 	/// [BIP 21]: https://github.com/bitcoin/bips/blob/master/bip-0021.mediawiki
-	pub fn send(&self, uri_str: &str) -> Result<UnifiedPaymentResult, Error> {
-		let uri: bip21::Uri<NetworkUnchecked, Extras> =
-			uri_str.parse().map_err(|_| Error::InvalidUri)?;
-
-		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) {
-				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),
+	/// [BIP 353]: https://github.com/bitcoin/bips/blob/master/bip-0353.mediawiki
+	pub async fn send(
+		&self, uri_str: &str, amount_msat: Option<u64>,
+	) -> Result<UnifiedPaymentResult, Error> {
+		let instructions = PaymentInstructions::parse(
+			uri_str,
+			self.config.network,
+			self.hrn_resolver.as_ref(),
+			true,
+		)
+		.await
+		.map_err(|e| {
+			log_error!(self.logger, "Failed to parse payment instructions: {:?}", e);
+			Error::UriParameterParsingFailed
+		})?;
+
+		let resolved = match instructions {
+			PaymentInstructions::ConfigurableAmount(ref instr) => {
+				let amount = amount_msat.ok_or_else(|| {
+					log_error!(self.logger, "No amount specified. Aborting the payment.");
+					Error::InvalidAmount
+				})?;
+
+				let amt = BPIAmount::from_sats(amount).map_err(|e| {
+					log_error!(self.logger, "Error while converting amount : {:?}", e);
+					Error::InvalidAmount
+				})?;
+
+				instr.clone().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(ref instr) => {
+				let instr = instr.clone();
+				if let Some(user_amount) = amount_msat {
+					if instr.ln_payment_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
+			},
+		};
+
+		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)
+			} else {
+				self.bolt12_payment.send(&offer, None, None)
 			}
-		}
+			.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(invoice) = uri_network_checked.extras.bolt11_invoice {
-			let invoice = maybe_wrap(invoice);
-			match self.bolt11_invoice.send(&invoice, None) {
-				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),
+			if let Ok(payment_id) = payment_result {
+				return Ok(UnifiedPaymentResult::Bolt12 { payment_id });
 			}
 		}
 
-		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 txid = self.onchain_payment.send_to_address(
-			&uri_network_checked.address,
-			amount.to_sat(),
-			None,
-		)?;
+		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, None)
+				.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 });
+			}
+		}
 
-		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 txid =
+				self.onchain_payment.send_to_address(&address, amount.sats().unwrap(), None)?;
+			return Ok(UnifiedPaymentResult::Onchain { txid });
+		}
+		log_error!(self.logger, "Payable methods not found in URI");
+		Err(Error::PaymentSendingFailed)
 	}
 }
 
@@ -314,7 +373,7 @@ impl DeserializationError for Extras {
 mod tests {
 	use super::*;
 	use crate::payment::unified::Extras;
-	use bitcoin::{Address, Network};
+	use bitcoin::{address::NetworkUnchecked, Address, Network};
 	use std::str::FromStr;
 
 	#[test]

tests/integration_tests_rust.rs

@@ -1274,8 +1274,8 @@ fn generate_bip21_uri() {
 	assert!(uni_payment.contains("lno="));
 }
 
-#[test]
-fn unified_qr_send_receive() {
+#[tokio::test(flavor = "multi_thread")]
+async fn unified_qr_send_receive() {
 	let (bitcoind, electrsd) = setup_bitcoind_and_electrsd();
 	let chain_source = TestChainSource::Esplora(&electrsd);
 
@@ -1314,7 +1314,7 @@ 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) {
+	let offer_payment_id: PaymentId = match node_a.unified_payment().send(&uri_str, None).await {
 		Ok(UnifiedPaymentResult::Bolt12 { payment_id }) => {
 			println!("\nBolt12 payment sent successfully with PaymentID: {:?}", payment_id);
 			payment_id
@@ -1335,7 +1335,7 @@ fn unified_qr_send_receive() {
 	// 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) {
+		match node_a.unified_payment().send(uri_str_without_offer, None).await {
 			Ok(UnifiedPaymentResult::Bolt12 { payment_id: _ }) => {
 				panic!("Expected Bolt11 payment but got Bolt12");
 			},
@@ -1358,7 +1358,7 @@ 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) {
+	let txid = match node_a.unified_payment().send(&uri_str_without_lightning, None).await {
 		Ok(UnifiedPaymentResult::Bolt12 { payment_id: _ }) => {
 			panic!("Expected on-chain payment but got Bolt12")
 		},