Introduce retry_tick_occurred function.

We need to retry InvoiceRequest messages in a smaller time duration
than timer_tick_occurred. This function provides the base for doing
the retry, by getting the InvoiceRequest for PendingOutboundPayments
and using a new reply_path to create and enqueue InvoiceRequest messages.

Author: shaavan

lightning/src/ln/channelmanager.rs

@@ -76,6 +76,8 @@ use crate::util::string::UntrustedString;
 use crate::util::ser::{BigSize, FixedLengthReader, Readable, ReadableArgs, MaybeReadable, Writeable, Writer, VecWriter};
 use crate::util::logger::{Level, Logger, WithContext};
 use crate::util::errors::APIError;
+use super::onion_utils::construct_invoice_request_message;
+
 #[cfg(not(c_bindings))]
 use {
 	crate::offers::offer::DerivedMetadata,
@@ -6010,6 +6012,20 @@ where
 		});
 	}
 
+	pub fn retry_tick_occurred(&self) {
+		let invoice_requests = self.pending_outbound_payments.get_invoice_request_awaiting_invoice();
+
+		if invoice_requests.is_empty() { return; }
+
+		if let Ok(reply_path) = self.create_blinded_path() {
+			let mut pending_offers_messages = self.pending_offers_messages.lock().unwrap();
+
+			for invoice_request in invoice_requests {
+				pending_offers_messages.extend(construct_invoice_request_message(invoice_request, reply_path.clone()));
+			}
+		}
+	}
+
 	/// Indicates that the preimage for payment_hash is unknown or the received amount is incorrect
 	/// after a PaymentClaimable event, failing the HTLC back to its origin and freeing resources
 	/// along the path (including in our own channel on which we received it).
@@ -8745,27 +8761,7 @@ where
 			.map_err(|_| Bolt12SemanticError::DuplicatePaymentId)?;
 
 		let mut pending_offers_messages = self.pending_offers_messages.lock().unwrap();
-		if offer.paths().is_empty() {
-			let message = new_pending_onion_message(
-				OffersMessage::InvoiceRequest(invoice_request),
-				Destination::Node(offer.signing_pubkey()),
-				Some(reply_path),
-			);
-			pending_offers_messages.push(message);
-		} else {
-			// Send as many invoice requests as there are paths in the offer (with an upper bound).
-			// Using only one path could result in a failure if the path no longer exists. But only
-			// one invoice for a given payment id will be paid, even if more than one is received.
-			const REQUEST_LIMIT: usize = 10;
-			for path in offer.paths().into_iter().take(REQUEST_LIMIT) {
-				let message = new_pending_onion_message(
-					OffersMessage::InvoiceRequest(invoice_request.clone()),
-					Destination::BlindedPath(path.clone()),
-					Some(reply_path.clone()),
-				);
-				pending_offers_messages.push(message);
-			}
-		}
+		pending_offers_messages.extend(construct_invoice_request_message(invoice_request, reply_path));
 
 		Ok(())
 	}

lightning/src/ln/onion_utils.rs

@@ -7,12 +7,16 @@
 // You may not use this file except in accordance with one or both of these
 // licenses.
 
+use crate::blinded_path::BlindedPath;
 use crate::crypto::chacha20::ChaCha20;
 use crate::crypto::streams::ChaChaReader;
 use crate::ln::channelmanager::{HTLCSource, RecipientOnionFields};
 use crate::ln::msgs;
 use crate::ln::wire::Encode;
 use crate::ln::{PaymentHash, PaymentPreimage};
+use crate::offers::invoice_request::InvoiceRequest;
+use crate::onion_message::messenger::{new_pending_onion_message, Destination, PendingOnionMessage};
+use crate::onion_message::offers::OffersMessage;
 use crate::routing::gossip::NetworkUpdate;
 use crate::routing::router::{BlindedTail, Path, RouteHop};
 use crate::sign::NodeSigner;
@@ -1235,6 +1239,32 @@ fn decode_next_hop<T, R: ReadableArgs<T>, N: NextPacketBytes>(
 	}
 }
 
+pub fn construct_invoice_request_message(invoice_request: InvoiceRequest, reply_path: BlindedPath) -> Vec<PendingOnionMessage<OffersMessage>> {
+	let mut messages = vec![];
+	if invoice_request.paths().is_empty() {
+		let message = new_pending_onion_message(
+			OffersMessage::InvoiceRequest(invoice_request.clone()),
+			Destination::Node(invoice_request.signing_pubkey()),
+			Some(reply_path),
+		);
+		messages.push(message);
+	} else {
+		// Send as many invoice requests as there are paths in the offer (with an upper bound).
+		// Using only one path could result in a failure if the path no longer exists. But only
+		// one invoice for a given payment id will be paid, even if more than one is received.
+		const REQUEST_LIMIT: usize = 10;
+		for path in invoice_request.paths().into_iter().take(REQUEST_LIMIT) {
+			let message = new_pending_onion_message(
+				OffersMessage::InvoiceRequest(invoice_request.clone()),
+				Destination::BlindedPath(path.clone()),
+				Some(reply_path.clone()),
+			);
+			messages.push(message);
+		}
+	}
+	messages
+}
+
 #[cfg(test)]
 mod tests {
 	use crate::io;