Introduce ResponseInstruction::WithReplyPath variant.

1. Introduce a new function in OnionMessenger to create blinded paths.
2. Use it in handle_onion_message_response to create a reply_path for
   the right variant and use it in onion_message.

Author: shaavan

lightning/src/onion_message/messenger.rs

@@ -265,14 +265,23 @@ impl Responder {
 		}
 	}
 
-	/// Creates the appropriate [`ResponseInstruction`] for a given response.
+	/// Creates a [`ResponseInstruction::WithoutReplyPath`] for a given response.
 	pub fn respond<T: OnionMessageContents>(self, response: T) -> ResponseInstruction<T> {
 		ResponseInstruction::WithoutReplyPath(OnionMessageResponse {
 			message: response,
 			reply_path: self.reply_path,
 			path_id: self.path_id,
 		})
 	}
+
+	/// Creates a [`ResponseInstruction::WithReplyPath`] for a given response.
+	pub fn respond_with_reply_path<T: OnionMessageContents>(self, response: T) -> ResponseInstruction<T> {
+		ResponseInstruction::WithReplyPath(OnionMessageResponse {
+			message: response,
+			reply_path: self.reply_path,
+			path_id: self.path_id,
+		})
+	}
 }
 
 /// This struct contains the information needed to reply to a received message.
@@ -284,6 +293,9 @@ pub struct OnionMessageResponse<T: OnionMessageContents> {
 
 /// `ResponseInstruction` represents instructions for responding to received messages.
 pub enum ResponseInstruction<T: OnionMessageContents> {
+	/// Indicates that a response should be sent including a reply path for
+	/// the recipient to respond back.
+	WithReplyPath(OnionMessageResponse<T>),
 	/// Indicates that a response should be sent without including a reply path
 	/// for the recipient to respond back.
 	WithoutReplyPath(OnionMessageResponse<T>),
@@ -926,6 +938,24 @@ where
 			.map_err(|_| SendError::PathNotFound)
 	}
 
+	fn create_blinded_path(&self) -> Result<BlindedPath, SendError> {
+		let recipient = self.node_signer
+			.get_node_id(Recipient::Node)
+			.map_err(|_| SendError::GetNodeIdFailed)?;
+		let secp_ctx = &self.secp_ctx;
+
+		let peers = self.message_recipients.lock().unwrap()
+			.iter()
+			.filter(|(_, peer)| matches!(peer, OnionMessageRecipient::ConnectedPeer(_)))
+			.map(|(node_id, _)| *node_id)
+			.collect();
+
+		self.message_router
+			.create_blinded_paths(recipient, peers, secp_ctx)
+			.and_then(|paths| paths.into_iter().next().ok_or(()))
+			.map_err(|_| SendError::PathNotFound)
+	}
+
 	fn enqueue_onion_message<T: OnionMessageContents>(
 		&self, path: OnionMessagePath, contents: T, reply_path: Option<BlindedPath>,
 		log_suffix: fmt::Arguments
@@ -981,18 +1011,35 @@ where
 	/// enqueueing any response for sending.
 	pub fn handle_onion_message_response<T: OnionMessageContents>(
 		&self, response: ResponseInstruction<T>
-	) {
-		if let ResponseInstruction::WithoutReplyPath(response) = response {
-			let message_type = response.message.msg_type();
-			let _ = self.find_path_and_enqueue_onion_message(
-				response.message, Destination::BlindedPath(response.reply_path), None,
-				format_args!(
-					"when responding with {} to an onion message with path_id {:02x?}",
-					message_type,
-					response.path_id
-				)
-			);
-		}
+	) -> Result<Option<SendSuccess>, SendError> {
+		let (response, create_reply_path) = match response {
+			ResponseInstruction::WithReplyPath(response) => (response, true),
+			ResponseInstruction::WithoutReplyPath(response) => (response, false),
+			ResponseInstruction::NoResponse => return Ok(None),
+		};
+		let logger = WithContext::from(&self.logger, None, None);
+		let message_type = response.message.msg_type();
+		let log_suffix = format!(
+			"when responding with {} to an onion message with path_id {:02x?}",
+			message_type,
+			response.path_id
+		);
+
+		let reply_path = if create_reply_path {
+			let reply_path = self.create_blinded_path();
+			match reply_path.as_ref() {
+				Err(SendError::PathNotFound) => log_trace!(
+					logger, "Failed to create blinded_path {}", format_args!("{}", log_suffix)
+				),
+				_ => (),
+			}
+			Some(reply_path?)
+		} else { None };
+
+		self.find_path_and_enqueue_onion_message(
+			response.message, Destination::BlindedPath(response.reply_path), reply_path,
+			format_args!("{}", log_suffix)
+		).map(|result| Some(result))
 	}
 
 	#[cfg(test)]
@@ -1079,14 +1126,14 @@ where
 							|reply_path| Responder::new(reply_path, path_id)
 						);
 						let response_instructions = self.offers_handler.handle_message(msg, responder);
-						self.handle_onion_message_response(response_instructions);
+						let _ = self.handle_onion_message_response(response_instructions);
 					},
 					ParsedOnionMessageContents::Custom(msg) => {
 						let responder = reply_path.map(
 							|reply_path| Responder::new(reply_path, path_id)
 						);
 						let response_instructions = self.custom_handler.handle_custom_message(msg, responder);
-						self.handle_onion_message_response(response_instructions);
+						let _ = self.handle_onion_message_response(response_instructions);
 					},
 				}
 			},