f

Author: tnull

src/payment/bolt11.rs

@@ -22,8 +22,7 @@ use crate::peer_store::{PeerInfo, PeerStore};
 use crate::types::ChannelManager;
 
 use lightning::ln::channelmanager::{
-	Bolt11InvoiceParameters, Bolt11PaymentError, PaymentId, RecipientOnionFields, Retry,
-	RetryableSendFailure,
+	Bolt11InvoiceParameters, Bolt11PaymentError, PaymentId, Retry, RetryableSendFailure,
 };
 use lightning::routing::router::{PaymentParameters, RouteParameters, RouteParametersConfig};
 
@@ -187,8 +186,14 @@ impl Bolt11Payment {
 			},
 			Err(Bolt11PaymentError::InvalidAmount) => {
 				log_error!(self.logger,
-                    "Failed to send payment due to the given invoice being \"zero-amount\". Please use send_using_amount instead."
-                );
+					"Failed to send payment due to the given invoice being \"zero-amount\". Please use send_using_amount instead."
+				);
+				return Err(Error::InvalidInvoice);
+			},
+			Err(Bolt11PaymentError::InvalidInvoice) => {
+				log_error!(self.logger,
+					"Failed to send payment due to the given invoice being invalid or incompatible."
+				);
 				return Err(Error::InvalidInvoice);
 			},
 			Err(Bolt11PaymentError::SendingFailed(e)) => {
@@ -303,6 +308,12 @@ impl Bolt11Payment {
 				);
 				return Err(Error::InvalidInvoice);
 			},
+			Err(Bolt11PaymentError::InvalidInvoice) => {
+				log_error!(self.logger,
+					"Failed to send payment due to the given invoice being invalid or incompatible."
+				);
+				return Err(Error::InvalidInvoice);
+			},
 			Err(Bolt11PaymentError::SendingFailed(e)) => {
 				log_error!(self.logger, "Failed to send payment: {:?}", e);
 				match e {
@@ -714,18 +725,42 @@ impl Bolt11Payment {
 	/// payment. To mitigate this issue, channels with available liquidity less than the required
 	/// amount times [`Config::probing_liquidity_limit_multiplier`] won't be used to send
 	/// pre-flight probes.
-	pub fn send_probes(&self, invoice: &Bolt11Invoice) -> Result<(), Error> {
+	pub fn send_probes(
+		&self, invoice: &Bolt11Invoice, route_parameters: Option<RouteParametersConfig>,
+	) -> Result<(), Error> {
 		let invoice = maybe_convert_invoice(invoice);
 		let rt_lock = self.runtime.read().unwrap();
 		if rt_lock.is_none() {
 			return Err(Error::NotRunning);
 		}
 
-		let (_payment_hash, _recipient_onion, route_params) = bolt11_payment::payment_parameters_from_invoice(&invoice).map_err(|_| {
+		let payment_params = PaymentParameters::from_bolt11_invoice(invoice).map_err(|e| {
+			log_error!(self.logger, "Failed to send payment probes: {:?}", e);
+			Error::InvalidInvoice
+		})?;
+
+		let amount_msat = invoice.amount_milli_satoshis().ok_or_else(|| {
 			log_error!(self.logger, "Failed to send probes due to the given invoice being \"zero-amount\". Please use send_probes_using_amount instead.");
 			Error::InvalidInvoice
 		})?;
 
+		let mut route_params =
+			RouteParameters::from_payment_params_and_value(payment_params, amount_msat);
+
+		if let Some(RouteParametersConfig {
+			max_total_routing_fee_msat,
+			max_total_cltv_expiry_delta,
+			max_path_count,
+			max_channel_saturation_power_of_half,
+		}) = route_parameters.as_ref().or(self.config.route_parameters.as_ref())
+		{
+			route_params.max_total_routing_fee_msat = *max_total_routing_fee_msat;
+			route_params.payment_params.max_total_cltv_expiry_delta = *max_total_cltv_expiry_delta;
+			route_params.payment_params.max_path_count = *max_path_count;
+			route_params.payment_params.max_channel_saturation_power_of_half =
+				*max_channel_saturation_power_of_half;
+		}
+
 		let liquidity_limit_multiplier = Some(self.config.probing_liquidity_limit_multiplier);
 
 		self.channel_manager
@@ -747,33 +782,47 @@ impl Bolt11Payment {
 	/// See [`Self::send_probes`] for more information.
 	pub fn send_probes_using_amount(
 		&self, invoice: &Bolt11Invoice, amount_msat: u64,
+		route_parameters: Option<RouteParametersConfig>,
 	) -> Result<(), Error> {
 		let invoice = maybe_convert_invoice(invoice);
 		let rt_lock = self.runtime.read().unwrap();
 		if rt_lock.is_none() {
 			return Err(Error::NotRunning);
 		}
 
-		let (_payment_hash, _recipient_onion, route_params) = if let Some(invoice_amount_msat) =
-			invoice.amount_milli_satoshis()
-		{
+		let payment_params = PaymentParameters::from_bolt11_invoice(invoice).map_err(|e| {
+			log_error!(self.logger, "Failed to send payment probes: {:?}", e);
+			Error::InvalidInvoice
+		})?;
+
+		if let Some(invoice_amount_msat) = invoice.amount_milli_satoshis() {
 			if amount_msat < invoice_amount_msat {
 				log_error!(
 					self.logger,
-					"Failed to send probes as the given amount needs to be at least the invoice amount: required {}msat, gave {}msat.", invoice_amount_msat, amount_msat);
+					"Failed to send probes as the given amount needs to be at least the invoice amount: required {}msat, gave {}msat.",
+					invoice_amount_msat,
+					amount_msat
+				);
 				return Err(Error::InvalidAmount);
 			}
+		}
 
-			bolt11_payment::payment_parameters_from_invoice(&invoice).map_err(|_| {
-				log_error!(self.logger, "Failed to send probes due to the given invoice unexpectedly being \"zero-amount\".");
-				Error::InvalidInvoice
-			})?
-		} else {
-			bolt11_payment::payment_parameters_from_variable_amount_invoice(&invoice, amount_msat).map_err(|_| {
-				log_error!(self.logger, "Failed to send probes due to the given invoice unexpectedly being not \"zero-amount\".");
-				Error::InvalidInvoice
-			})?
-		};
+		let mut route_params =
+			RouteParameters::from_payment_params_and_value(payment_params, amount_msat);
+
+		if let Some(RouteParametersConfig {
+			max_total_routing_fee_msat,
+			max_total_cltv_expiry_delta,
+			max_path_count,
+			max_channel_saturation_power_of_half,
+		}) = route_parameters.as_ref().or(self.config.route_parameters.as_ref())
+		{
+			route_params.max_total_routing_fee_msat = *max_total_routing_fee_msat;
+			route_params.payment_params.max_total_cltv_expiry_delta = *max_total_cltv_expiry_delta;
+			route_params.payment_params.max_path_count = *max_path_count;
+			route_params.payment_params.max_channel_saturation_power_of_half =
+				*max_channel_saturation_power_of_half;
+		}
 
 		let liquidity_limit_multiplier = Some(self.config.probing_liquidity_limit_multiplier);