Introduce new parameter in handle_custom_message.

- Add an option to direct handle_custom_message to call respond_with_reply_path.
  This expands the test suite to test the respond_with_reply_path capabilities.
- Introduce a new test for ResponseInstruction::WithReplyPath, testing
  both the success and failure of reply_path creation.

Author: shaavan

lightning/src/ln/peer_handler.rs

@@ -143,7 +143,7 @@ impl OffersMessageHandler for IgnoringMessageHandler {
 }
 impl CustomOnionMessageHandler for IgnoringMessageHandler {
 	type CustomMessage = Infallible;
-	fn handle_custom_message(&self, _message: Self::CustomMessage, _responder: Option<Responder>) -> ResponseInstruction<Self::CustomMessage> {
+	fn handle_custom_message(&self, _message: Self::CustomMessage, _responder: Option<Responder>, _add_reply_path: bool) -> ResponseInstruction<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

@@ -149,7 +149,7 @@ impl Drop for TestCustomMessageHandler {
 
 impl CustomOnionMessageHandler for TestCustomMessageHandler {
 	type CustomMessage = TestCustomMessage;
-	fn handle_custom_message(&self, msg: Self::CustomMessage, responder: Option<Responder>) -> ResponseInstruction<Self::CustomMessage> {
+	fn handle_custom_message(&self, msg: Self::CustomMessage, responder: Option<Responder>, add_reply_path: bool) -> ResponseInstruction<Self::CustomMessage> {
 		match self.expected_messages.lock().unwrap().pop_front() {
 			Some(expected_msg) => assert_eq!(expected_msg, msg),
 			None => panic!("Unexpected message: {:?}", msg),
@@ -160,12 +160,18 @@ impl CustomOnionMessageHandler for TestCustomMessageHandler {
 			TestCustomMessage::ResponseA => Some(TestCustomMessage::ResponseB),
 			TestCustomMessage::ResponseB => Some(TestCustomMessage::ResponseA),
 		};
-		if let (Some(response), Some(responder)) = (response_option, responder) {
-			responder.respond(response)
-		} else {
-			ResponseInstruction::NoResponse
+		match (response_option, responder) {
+			(Some(response), Some(responder)) => {
+				if add_reply_path {
+					responder.respond_with_reply_path(response)
+				} else {
+					responder.respond(response)
+				}
+			}
+			_ => ResponseInstruction::NoResponse,
 		}
 	}
+
 	fn read_custom_message<R: io::Read>(&self, message_type: u64, buffer: &mut R) -> Result<Option<Self::CustomMessage>, DecodeError> where Self: Sized {
 		match message_type {
 			CUSTOM_REQUEST_MESSAGE_TYPE => {
@@ -412,7 +418,7 @@ fn async_response_over_one_blinded_hop() {
 
 	// 5. Expect Alice to receive the message and create a response instruction for it.
 	alice.custom_message_handler.expect_message(message.clone());
-	let response_instruction = nodes[0].custom_message_handler.handle_custom_message(message, responder);
+	let response_instruction = nodes[0].custom_message_handler.handle_custom_message(message, responder, false);
 
 	// 6. Simulate Alice asynchronously responding back to Bob with a response.
 	assert_eq!(
@@ -425,6 +431,67 @@ fn async_response_over_one_blinded_hop() {
 	pass_along_path(&nodes);
 }
 
+fn do_test_async_response_with_reply_path_over_one_blinded_hop(reply_path_succeed: bool) {
+	// Simulate an asynchronous interaction between two nodes, Alice and Bob.
+
+	// 1. Set up the network with two nodes: Alice and Bob.
+	let mut nodes = create_nodes(2);
+	let alice = &nodes[0];
+	let bob = &nodes[1];
+
+	// 2. Define the message sent from Bob to Alice.
+	let message = TestCustomMessage::ResponseA;
+	let path_id = Some([2; 32]);
+
+	// 3. Simulate the creation of a Blinded Reply path provided by Bob.
+	let secp_ctx = Secp256k1::new();
+	let reply_path = BlindedPath::new_for_message(&[bob.node_id], &*bob.entropy_source, &secp_ctx).unwrap();
+
+	if reply_path_succeed {
+		// Add a channel so that nodes are announced to each other.
+		// This will allow creating the reply path.
+		add_channel_to_graph(alice, bob, &secp_ctx, 24);
+	}
+
+	// 4. Create a responder using the reply path for Alice.
+	let responder = Some(Responder::new(reply_path, path_id));
+
+	// 5. Expect Alice to receive the message and create a response instruction for it.
+	alice.custom_message_handler.expect_message(message.clone());
+	let response_instruction = alice.custom_message_handler.handle_custom_message(message, responder, true);
+
+	if !reply_path_succeed {
+		// 6. Simulate Alice attempting to asynchronously respond back to Bob
+		// but failing to create a reply path.
+		assert_eq!(
+			alice.messenger.handle_onion_message_response(response_instruction),
+			Err(SendError::PathNotFound),
+		);
+		return;
+	}
+
+	// 6. Simulate Alice asynchronously responding back to Bob with a response.
+	assert_eq!(
+		alice.messenger.handle_onion_message_response(response_instruction),
+		Ok(Some(SendSuccess::Buffered)),
+	);
+
+	// 7. Expect Bob to receive the response and handle it accordingly.
+	bob.custom_message_handler.expect_message(TestCustomMessage::ResponseB);
+	pass_along_path(&nodes);
+
+	// 8. Expect Alice to receive Bob's response through the created reply path and handle it.
+	alice.custom_message_handler.expect_message(TestCustomMessage::ResponseA);
+	nodes.reverse();
+	pass_along_path(&nodes);
+}
+
+#[test]
+fn async_response_with_reply_path_over_one_blinded_hop() {
+	do_test_async_response_with_reply_path_over_one_blinded_hop(true);
+	do_test_async_response_with_reply_path_over_one_blinded_hop(false);
+}
+
 #[test]
 fn too_big_packet_error() {
 	// Make sure we error as expected if a packet is too big to send.

lightning/src/onion_message/messenger.rs

@@ -613,7 +613,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(&self, message: Self::CustomMessage, responder: Option<Responder>) -> ResponseInstruction<Self::CustomMessage>;
+	fn handle_custom_message(&self, message: Self::CustomMessage, responder: Option<Responder>, add_reply_path: bool) -> ResponseInstruction<Self::CustomMessage>;
 
 	/// Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
 	/// message type is unknown.
@@ -1227,7 +1227,7 @@ where
 						let responder = reply_path.map(
 							|reply_path| Responder::new(reply_path, path_id)
 						);
-						let response_instructions = self.custom_handler.handle_custom_message(msg, responder);
+						let response_instructions = self.custom_handler.handle_custom_message(msg, responder, false);
 						let _ = self.handle_onion_message_response(response_instructions);
 					},
 				}