Introduce the Fn Trait for Message Responders:

1. Enables using custom handler functions tailored to specific cases.
2. Enhances further generalisation by removing the constraint of bounding responders based on the `OnionMessageHandler` trait.
3. Also, separate `path_id` from Responder to induce symmetry between `ReceivedOnionMessage` variants.

Author: shaavan

fuzz/src/onion_message.rs

@@ -96,7 +96,7 @@ impl MessageRouter for TestMessageRouter {
 struct TestOffersMessageHandler {}
 
 impl OffersMessageHandler for TestOffersMessageHandler {
-	fn handle_message<OMH: OnionMessageHandler>(&self, _message: &ReceivedOnionMessage<OMH, OffersMessage>) {}
+	fn handle_message<F: Fn(OffersMessage, BlindedPath)>(&self, _message: &ReceivedOnionMessage<OMH, OffersMessage>) {}
 }
 
 #[derive(Debug)]
@@ -121,7 +121,7 @@ struct TestCustomMessageHandler {}
 
 impl CustomOnionMessageHandler for TestCustomMessageHandler {
 	type CustomMessage = TestCustomMessage;
-	fn handle_custom_message<OMH: OnionMessageHandler, T: OnionMessageContents>(&self, message: &ReceivedOnionMessage<OMH, T>) {
+	fn handle_custom_message<F: Fn(Self::CustomMessage, BlindedPath), T: OnionMessageContents>(&self, message: &ReceivedOnionMessage<F, T>) {
 		if let ReceivedOnionMessage::WithReplyPath({_, responder}) = message {
 			responder.respond(TestCustomMessage {})
 		}

lightning/src/ln/channelmanager.rs

@@ -75,7 +75,6 @@ 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::msgs::OnionMessageHandler;
 
 #[cfg(not(c_bindings))]
 use {
@@ -9263,23 +9262,23 @@ where
 	}
 }
 
-impl<M: Deref, BI: Deref, ES: Deref, NS: Deref, SP: Deref, F: Deref, R: Deref, L: Deref>
-OffersMessageHandler for ChannelManager<M, BI, ES, NS, SP, F, R, L>
+impl<M: Deref, BI: Deref, ES: Deref, NS: Deref, SP: Deref, FE: Deref, R: Deref, L: Deref>
+OffersMessageHandler for ChannelManager<M, BI, ES, NS, SP, FE, R, L>
 where
 	M::Target: chain::Watch<<SP::Target as SignerProvider>::EcdsaSigner>,
 	BI::Target: BroadcasterInterface,
 	ES::Target: EntropySource,
 	NS::Target: NodeSigner,
 	SP::Target: SignerProvider,
-	F::Target: FeeEstimator,
+	FE::Target: FeeEstimator,
 	R::Target: Router,
 	L::Target: Logger,
 {
-	fn handle_message<OMH: OnionMessageHandler>(&self, message: &ReceivedOnionMessage<OMH, OffersMessage>) {
+	fn handle_message<F: Fn(OffersMessage, BlindedPath)>(&self, message: &ReceivedOnionMessage<F, OffersMessage>) {
 		let secp_ctx = &self.secp_ctx;
 		let expanded_key = &self.inbound_payment_key;
 
-		if let ReceivedOnionMessage::WithReplyPath{message, responder} = message {
+		if let ReceivedOnionMessage::WithReplyPath{responder, message, path_id: _} = message {
 			let response_option = match &message {
 				OffersMessage::InvoiceRequest(invoice_request) => {
 					let amount_msats = match InvoiceBuilder::<DerivedSigningPubkey>::amount_msats(

lightning/src/ln/peer_handler.rs

@@ -136,11 +136,11 @@ impl OnionMessageHandler for IgnoringMessageHandler {
 }
 
 impl OffersMessageHandler for IgnoringMessageHandler {
-	fn handle_message<OMH: OnionMessageHandler>(&self, _message: &ReceivedOnionMessage<OMH, OffersMessage>) {}
+	fn handle_message<F: Fn(OffersMessage, BlindedPath)>(&self, _message: &ReceivedOnionMessage<F, OffersMessage>) {}
 }
 impl CustomOnionMessageHandler for IgnoringMessageHandler {
 	type CustomMessage = Infallible;
-	fn handle_custom_message<OMH: OnionMessageHandler>(&self, _message: &ReceivedOnionMessage<OMH, Self::CustomMessage>) {
+	fn handle_custom_message<F: Fn(Self::CustomMessage, BlindedPath)>(&self, _message: &ReceivedOnionMessage<F, Self::CustomMessage>) {
 		// Since we always return `None` in the read the handle method should never be called.
 		unreachable!();
 	}

lightning/src/onion_message/functional_tests.rs

@@ -70,7 +70,7 @@ impl MessageRouter for TestMessageRouter {
 struct TestOffersMessageHandler {}
 
 impl OffersMessageHandler for TestOffersMessageHandler {
-	fn handle_message<OMH: OnionMessageHandler>(&self, _message: &ReceivedOnionMessage<OMH, OffersMessage>) {}
+	fn handle_message<F: Fn(OffersMessage, BlindedPath)>(&self, _message: &ReceivedOnionMessage<F, OffersMessage>) {}
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -132,8 +132,8 @@ impl Drop for TestCustomMessageHandler {
 
 impl CustomOnionMessageHandler for TestCustomMessageHandler {
 	type CustomMessage = TestCustomMessage;
-	fn handle_custom_message<OMH: OnionMessageHandler>(&self, message: &ReceivedOnionMessage<OMH, Self::CustomMessage>) {
-		if let ReceivedOnionMessage::WithReplyPath{message, responder} = message {
+	fn handle_custom_message<F: Fn(Self::CustomMessage, BlindedPath)>(&self, message: &ReceivedOnionMessage<F, Self::CustomMessage>) {
+		if let ReceivedOnionMessage::WithReplyPath{responder, message, path_id: _} = message {
 			match self.expected_messages.lock().unwrap().pop_front() {
 				Some(expected_msg) => assert_eq!(expected_msg, *message),
 				None => panic!("Unexpected message: {:?}", message),

lightning/src/onion_message/messenger.rs

@@ -32,6 +32,7 @@ use crate::util::logger::Logger;
 use crate::util::ser::Writeable;
 
 use core::fmt;
+use core::marker::PhantomData;
 use core::ops::Deref;
 use crate::io;
 use crate::sync::Mutex;
@@ -243,56 +244,79 @@ impl OnionMessageRecipient {
 	}
 }
 
+pub trait RespondFunction<T: OnionMessageContents>{
+	fn respond(&self, response: T, reply_path: BlindedPath);
+}
+
+impl<F, T> RespondFunction<T> for F
+where
+T: OnionMessageContents,
+F: Fn(T, BlindedPath)
+{
+	fn respond(&self, response: T, reply_path: BlindedPath) {
+		self(response, reply_path)
+	}
+}
+
 /// A struct handling response to an [`OnionMessage`]
-pub struct Responder<'a, OMH: OnionMessageHandler, T: OnionMessageContents> {
-	messenger: &'a OMH,
+pub struct Responder<R, T>
+where
+R: RespondFunction<T>,
+T: OnionMessageContents
+{
+	messenger_function: R,
 	pub reply_path: BlindedPath,
-	pub path_id: Option<[u8; 32]>,
 	// This phantom Data is used to ensure that we use T in the struct definition
 	// This allow us to ensure at compile time that the received message type and response type will be same
-	_phantom: core::marker::PhantomData<T>
+	_phantom: PhantomData<T>
 }
 
-impl<'a, OMH: OnionMessageHandler, T: OnionMessageContents> Responder<'a, OMH, T> {
+impl<R, T> Responder<R, T>
+where
+R: RespondFunction<T>,
+T: OnionMessageContents
+{
     pub fn respond(&self, response: T) {
 		// Utilising the fact that we ensure at compile time that
 		// received message type, and response type will be same
-		let message_type = T::msg_type(&response);
-		self.messenger.handle_onion_message_response(
-			response, self.reply_path.clone(), format_args!(
-				"when responding to {} onion message with path_id {:02x?}",
-				message_type,
-				self.path_id
-			)
-		);
-    }
+		self.messenger_function.respond(response, self.reply_path.clone())
+	}
 }
 
 /// A enum to handle received [`OnionMessage`]
-pub enum ReceivedOnionMessage<'a, OMH: OnionMessageHandler, T: OnionMessageContents> {
+pub enum ReceivedOnionMessage<R, T>
+where
+R: RespondFunction<T>,
+T: OnionMessageContents
+{
 	WithReplyPath {
+		responder: Responder<R, T>,
 		message: T,
-		responder: Responder<'a, OMH, T>,
+		path_id: Option<[u8; 32]>
 	},
 	WithoutReplyPath {
 		message: T,
 		path_id: Option<[u8; 32]>,
 	},
 }
 
-impl<'a, OMH: OnionMessageHandler, T: OnionMessageContents> ReceivedOnionMessage<'a, OMH, T> {
-	fn new(messenger: &'a OMH, message: T, reply_path_option: Option<BlindedPath>, path_id: Option<[u8; 32]> ) -> Self {
+impl<R, T> ReceivedOnionMessage<R, T>
+where
+R: RespondFunction<T>,
+T: OnionMessageContents
+{
+	fn new(messenger_function: R, message: T, reply_path_option: Option<BlindedPath>, path_id: Option<[u8; 32]> ) -> Self {
 		match reply_path_option {
 			Some(reply_path) => {
 				let responder = Responder {
-					messenger,
+					messenger_function,
 					reply_path,
-					path_id,
-					_phantom: std::marker::PhantomData
+					_phantom: PhantomData
 				};
 				ReceivedOnionMessage::WithReplyPath {
+					responder,
 					message,
-					responder
+					path_id
 				}
 			}
 			None => ReceivedOnionMessage::WithoutReplyPath {
@@ -560,7 +584,7 @@ pub trait CustomOnionMessageHandler {
 	/// Called with the custom message that was received, returning a response to send, if any.
 	///
 	/// The returned [`Self::CustomMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
-	fn handle_custom_message<OMH: OnionMessageHandler>(&self, message: &ReceivedOnionMessage<OMH, Self::CustomMessage>);
+	fn handle_custom_message<F: Fn(Self::CustomMessage, BlindedPath)>(&self, message: &ReceivedOnionMessage<F, Self::CustomMessage>);
 
 	/// Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
 	/// message type is unknown.
@@ -965,11 +989,35 @@ where
 
 				match message {
 					ParsedOnionMessageContents::Offers(msg) => {
-						let message = ReceivedOnionMessage::new(self, msg, reply_path, path_id);
+						// message_type is defined outside of closure to avoid burrowing
+						// issues when using msg for creating ReceivedOnionMessage::New()
+						let message_type = msg.msg_type();
+						let closure = |response, reply_path: BlindedPath| {
+							self.handle_onion_message_response(
+								response, reply_path, format_args!(
+									"when responding to {} onion message with path_id {:02x?}",
+									message_type,
+									path_id
+								)
+							);
+						};
+						let message = ReceivedOnionMessage::new(closure, msg, reply_path, path_id);
 						self.offers_handler.handle_message(&message);
 					},
 					ParsedOnionMessageContents::Custom(msg) => {
-						let message = ReceivedOnionMessage::new(self, msg, reply_path, path_id);
+						// message_type is defined outside of closure to avoid burrowing
+						// issues when using msg for creating ReceivedOnionMessage::New()
+						let message_type = msg.msg_type();
+						let closure = |response, reply_path: BlindedPath| {
+							self.handle_onion_message_response(
+								response, reply_path, format_args!(
+									"when responding to {} onion message with path_id {:02x?}",
+									message_type,
+									path_id
+								)
+							);
+						};
+						let message = ReceivedOnionMessage::new(closure, msg, reply_path, path_id);
 						self.custom_handler.handle_custom_message(&message);
 					},
 				}

lightning/src/onion_message/offers.rs

@@ -11,6 +11,7 @@
 
 use core::convert::TryFrom;
 use core::fmt;
+use crate::blinded_path::BlindedPath;
 use crate::io::{self, Read};
 use crate::ln::msgs::{DecodeError, OnionMessageHandler};
 use crate::offers::invoice_error::InvoiceError;
@@ -42,7 +43,7 @@ pub trait OffersMessageHandler {
 	/// The returned [`OffersMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
 	///
 	/// [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
-	fn handle_message<OMH: OnionMessageHandler>(&self, message: &ReceivedOnionMessage<OMH, OffersMessage>);
+	fn handle_message<F: Fn(OffersMessage, BlindedPath)>(&self, message: &ReceivedOnionMessage<F, OffersMessage>);
 
 	/// Releases any [`OffersMessage`]s that need to be sent.
 	///