Retry htlcs in process_pending_htlc_forwards

Author: valentinewallace

lightning/src/ln/channelmanager.rs

@@ -2410,6 +2410,16 @@ where
 	pub fn retry_payment(&self, route: &Route, payment_id: PaymentId) -> Result<(), PaymentSendFailure> {
 		let best_block_height = self.best_block.read().unwrap().height();
 		self.pending_outbound_payments.retry_payment_with_route(route, payment_id, &self.keys_manager, best_block_height,
+			&|path, payment_params, payment_hash, payment_secret, total_value, cur_height, payment_id, keysend_preimage, session_priv|
+			self.send_payment_along_path(path, payment_params, payment_hash, payment_secret, total_value, cur_height, payment_id, keysend_preimage, session_priv))
+	}
+
+	/// Similar to [`ChannelManager::retry_payment`], but will automatically find a route based on
+	/// `route_params`. If paths fail then additional retries may be attempted, based on the retry
+	/// strategy that was specified on initial send.
+	fn retry_payment_auto_route(&self, payment_id: PaymentId, route_params: RouteParameters) -> Result<(), PaymentSendFailure> {
+		let best_block_height = self.best_block.read().unwrap().height();
+		self.pending_outbound_payments.retry_payment(payment_id, route_params, &self.router, self.list_usable_channels(), self.compute_inflight_htlcs(), &self.keys_manager, best_block_height,
 			|path, payment_params, payment_hash, payment_secret, total_value, cur_height, payment_id, keysend_preimage, session_priv|
 			self.send_payment_along_path(path, payment_params, payment_hash, payment_secret, total_value, cur_height, payment_id, keysend_preimage, session_priv))
 	}
@@ -3163,6 +3173,17 @@ where
 				}
 			}
 		}
+		{
+			let mut retryable_htlcs = Vec::new();
+			mem::swap(&mut retryable_htlcs, &mut self.pending_outbound_payments.retryable_htlcs.lock().unwrap());
+			for (payment_id, params) in retryable_htlcs {
+				// TODO: do we need to generate a PendingHTLCsForwardable event?
+				if let Err(e) = self.retry_payment_auto_route(payment_id, params) {
+					log_trace!(self.logger, "Errored retrying payment, marking as abandoned: {:?}", e);
+					self.abandon_payment(payment_id);
+				}
+			}
+		}
 
 		for (htlc_source, payment_hash, failure_reason, destination) in failed_forwards.drain(..) {
 			self.fail_htlc_backwards_internal(&htlc_source, &payment_hash, &failure_reason, destination);

lightning/src/ln/outbound_payment.rs

@@ -15,10 +15,10 @@ use bitcoin::secp256k1::{self, Secp256k1, SecretKey};
 
 use crate::chain::keysinterface::{EntropySource, KeysInterface, NodeSigner, Recipient};
 use crate::ln::{PaymentHash, PaymentPreimage, PaymentSecret};
-use crate::ln::channelmanager::{HTLCSource, IDEMPOTENCY_TIMEOUT_TICKS, MIN_HTLC_RELAY_HOLDING_CELL_MILLIS, PaymentId};
+use crate::ln::channelmanager::{ChannelDetails, HTLCSource, IDEMPOTENCY_TIMEOUT_TICKS, MIN_HTLC_RELAY_HOLDING_CELL_MILLIS, PaymentId};
 use crate::ln::msgs::DecodeError;
 use crate::ln::onion_utils::HTLCFailReason;
-use crate::routing::router::{PaymentParameters, Route, RouteHop, RouteParameters, RoutePath};
+use crate::routing::router::{InFlightHtlcs, PaymentParameters, Route, RouteHop, RouteParameters, RoutePath, Router};
 use crate::util::errors::APIError;
 use crate::util::events;
 use crate::util::logger::Logger;
@@ -233,6 +233,16 @@ impl Retry {
 	}
 }
 
+#[cfg(feature = "std")]
+pub(crate) fn has_expired(route_params: &RouteParameters) -> bool {
+	if let Some(expiry_time) = route_params.payment_params.expiry_time {
+		if let Ok(elapsed) = std::time::SystemTime::UNIX_EPOCH.elapsed() {
+			return elapsed > core::time::Duration::from_secs(expiry_time)
+		}
+	}
+	false
+}
+
 pub(crate) type PaymentAttempts = PaymentAttemptsUsingTime<ConfiguredTime>;
 
 /// Storing minimal payment attempts information required for determining if a outbound payment can
@@ -412,9 +422,55 @@ impl OutboundPayments {
 		}
 	}
 
+	pub(super) fn retry_payment<R: Deref, K: Deref, F>(&self, payment_id: PaymentId,
+		route_params: RouteParameters, router: &R, first_hops: Vec<ChannelDetails>,
+		inflight_htlcs: InFlightHtlcs, keys_manager: &K, best_block_height: u32,
+		send_payment_along_path: F) -> Result<(), PaymentSendFailure>
+	where
+		R::Target: Router,
+		K::Target: KeysInterface,
+		F: Fn(&Vec<RouteHop>, &Option<PaymentParameters>, &PaymentHash, &Option<PaymentSecret>, u64,
+		   u32, PaymentId, &Option<PaymentPreimage>, [u8; 32]) -> Result<(), APIError>
+	{
+		#[cfg(feature = "std")] {
+			if has_expired(&route_params) {
+				return Err(PaymentSendFailure::ParameterError(APIError::APIMisuseError {
+					err: format!("Invoice expired for payment id {}; not retrying", log_bytes!(payment_id.0)),
+				}))
+			}
+		}
+
+		self.pending_outbound_payments.lock().unwrap().get_mut(&payment_id).map(|pmt| pmt.increment_attempts());
+		if !self.pending_outbound_payments.lock().unwrap().get(&payment_id)
+			.map_or(false, |payment| payment.is_retryable())
+		{
+			return Err(PaymentSendFailure::ParameterError(APIError::APIMisuseError {
+				err: format!("Payment {} is not retryable", log_bytes!(payment_id.0)),
+			}))
+		}
+
+		let route = router.find_route(
+			&keys_manager.get_node_id(Recipient::Node).unwrap(), &route_params,
+			Some(&first_hops.iter().collect::<Vec<_>>()), &inflight_htlcs
+		).map_err(|e| PaymentSendFailure::ParameterError(APIError::APIMisuseError {
+			err: format!("Failed to find a route for payment {}: {:?}", log_bytes!(payment_id.0), e), // TODO: add APIError::RouteNotFound
+		}))?;
+
+		match self.retry_payment_with_route(&route, payment_id, keys_manager, best_block_height, &send_payment_along_path) {
+			Err(PaymentSendFailure::AllFailedResendSafe(_)) => {
+				self.retry_payment(payment_id, route_params, router, first_hops, inflight_htlcs, keys_manager, best_block_height, send_payment_along_path)
+			},
+			Err(PaymentSendFailure::PartialFailure { failed_paths_retry: Some(retry), .. }) => {
+				let _ = self.retry_payment(payment_id, retry, router, first_hops, inflight_htlcs, keys_manager, best_block_height, send_payment_along_path);
+				Ok(())
+			},
+			res => res,
+		}
+	}
+
 	pub(super) fn retry_payment_with_route<K: Deref, F>(
 		&self, route: &Route, payment_id: PaymentId, keys_manager: &K, best_block_height: u32,
-		send_payment_along_path: F
+		send_payment_along_path: &F
 	) -> Result<(), PaymentSendFailure>
 	where
 		K::Target: KeysInterface,