Rename ResponseInstruction -> MessageSendInstructions

In a coming commit we'll start using `ResponseInstruction` for all
messages, so it no longer makes sense to continue calling it
`Response`.

Author: TheBlueMatt

lightning/src/ln/channelmanager.rs

@@ -71,7 +71,7 @@ use crate::offers::parse::Bolt12SemanticError;
 use crate::offers::refund::{Refund, RefundBuilder};
 use crate::offers::signer;
 use crate::onion_message::async_payments::{AsyncPaymentsMessage, HeldHtlcAvailable, ReleaseHeldHtlc, AsyncPaymentsMessageHandler};
-use crate::onion_message::messenger::{new_pending_onion_message, Destination, MessageRouter, PendingOnionMessage, Responder, ResponseInstruction};
+use crate::onion_message::messenger::{new_pending_onion_message, Destination, MessageRouter, PendingOnionMessage, Responder, MessageSendInstructions};
 use crate::onion_message::offers::{OffersMessage, OffersMessageHandler};
 use crate::sign::{EntropySource, NodeSigner, Recipient, SignerProvider};
 use crate::sign::ecdsa::EcdsaChannelSigner;
@@ -10749,7 +10749,7 @@ where
 {
 	fn handle_message(
 		&self, message: OffersMessage, context: Option<OffersContext>, responder: Option<Responder>,
-	) -> Option<(OffersMessage, ResponseInstruction)> {
+	) -> Option<(OffersMessage, MessageSendInstructions)> {
 		let secp_ctx = &self.secp_ctx;
 		let expanded_key = &self.inbound_payment_key;
 
@@ -10956,7 +10956,7 @@ where
 {
 	fn held_htlc_available(
 		&self, _message: HeldHtlcAvailable, _responder: Option<Responder>
-	) -> Option<(ReleaseHeldHtlc, ResponseInstruction)> {
+	) -> Option<(ReleaseHeldHtlc, MessageSendInstructions)> {
 		None
 	}
 

lightning/src/ln/peer_handler.rs

@@ -30,7 +30,7 @@ use crate::ln::peer_channel_encryptor::{PeerChannelEncryptor, NextNoiseStep, Mes
 use crate::ln::wire;
 use crate::ln::wire::{Encode, Type};
 use crate::onion_message::async_payments::{AsyncPaymentsMessageHandler, HeldHtlcAvailable, ReleaseHeldHtlc};
-use crate::onion_message::messenger::{CustomOnionMessageHandler, PendingOnionMessage, Responder, ResponseInstruction};
+use crate::onion_message::messenger::{CustomOnionMessageHandler, PendingOnionMessage, Responder, MessageSendInstructions};
 use crate::onion_message::offers::{OffersMessage, OffersMessageHandler};
 use crate::onion_message::packet::OnionMessageContents;
 use crate::routing::gossip::{NodeId, NodeAlias};
@@ -144,21 +144,21 @@ impl OnionMessageHandler for IgnoringMessageHandler {
 }
 
 impl OffersMessageHandler for IgnoringMessageHandler {
-	fn handle_message(&self, _message: OffersMessage, _context: Option<OffersContext>, _responder: Option<Responder>) -> Option<(OffersMessage, ResponseInstruction)> {
+	fn handle_message(&self, _message: OffersMessage, _context: Option<OffersContext>, _responder: Option<Responder>) -> Option<(OffersMessage, MessageSendInstructions)> {
 		None
 	}
 }
 impl AsyncPaymentsMessageHandler for IgnoringMessageHandler {
 	fn held_htlc_available(
 		&self, _message: HeldHtlcAvailable, _responder: Option<Responder>,
-	) -> Option<(ReleaseHeldHtlc, ResponseInstruction)> {
+	) -> Option<(ReleaseHeldHtlc, MessageSendInstructions)> {
 		None
 	}
 	fn release_held_htlc(&self, _message: ReleaseHeldHtlc) {}
 }
 impl CustomOnionMessageHandler for IgnoringMessageHandler {
 	type CustomMessage = Infallible;
-	fn handle_custom_message(&self, _message: Self::CustomMessage, _context: Option<Vec<u8>>, _responder: Option<Responder>) -> Option<(Infallible, ResponseInstruction)> {
+	fn handle_custom_message(&self, _message: Self::CustomMessage, _context: Option<Vec<u8>>, _responder: Option<Responder>) -> Option<(Infallible, MessageSendInstructions)> {
 		// Since we always return `None` in the read the handle method should never be called.
 		unreachable!();
 	}

lightning/src/onion_message/async_payments.rs

@@ -13,7 +13,7 @@ use crate::io;
 use crate::ln::msgs::DecodeError;
 #[cfg(not(c_bindings))]
 use crate::onion_message::messenger::PendingOnionMessage;
-use crate::onion_message::messenger::{Responder, ResponseInstruction};
+use crate::onion_message::messenger::{Responder, MessageSendInstructions};
 use crate::onion_message::packet::OnionMessageContents;
 use crate::prelude::*;
 use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer};
@@ -30,7 +30,7 @@ pub trait AsyncPaymentsMessageHandler {
 	/// the held funds.
 	fn held_htlc_available(
 		&self, message: HeldHtlcAvailable, responder: Option<Responder>,
-	) -> Option<(ReleaseHeldHtlc, ResponseInstruction)>;
+	) -> Option<(ReleaseHeldHtlc, MessageSendInstructions)>;
 
 	/// Handle a [`ReleaseHeldHtlc`] message. If authentication of the message succeeds, an HTLC
 	/// should be released to the corresponding payee.

lightning/src/onion_message/functional_tests.rs

@@ -20,7 +20,7 @@ use crate::sign::{NodeSigner, Recipient};
 use crate::util::ser::{FixedLengthReader, LengthReadable, Writeable, Writer};
 use crate::util::test_utils;
 use super::async_payments::{AsyncPaymentsMessageHandler, HeldHtlcAvailable, ReleaseHeldHtlc};
-use super::messenger::{CustomOnionMessageHandler, DefaultMessageRouter, Destination, OnionMessagePath, OnionMessenger, PendingOnionMessage, Responder, ResponseInstruction, SendError, SendSuccess};
+use super::messenger::{CustomOnionMessageHandler, DefaultMessageRouter, Destination, OnionMessagePath, OnionMessenger, PendingOnionMessage, Responder, MessageSendInstructions, SendError, SendSuccess};
 use super::offers::{OffersMessage, OffersMessageHandler};
 use super::packet::{OnionMessageContents, Packet};
 
@@ -76,7 +76,7 @@ impl Drop for MessengerNode {
 struct TestOffersMessageHandler {}
 
 impl OffersMessageHandler for TestOffersMessageHandler {
-	fn handle_message(&self, _message: OffersMessage, _context: Option<OffersContext>, _responder: Option<Responder>) -> Option<(OffersMessage, ResponseInstruction)> {
+	fn handle_message(&self, _message: OffersMessage, _context: Option<OffersContext>, _responder: Option<Responder>) -> Option<(OffersMessage, MessageSendInstructions)> {
 		None
 	}
 }
@@ -86,7 +86,7 @@ struct TestAsyncPaymentsMessageHandler {}
 impl AsyncPaymentsMessageHandler for TestAsyncPaymentsMessageHandler {
 	fn held_htlc_available(
 		&self, _message: HeldHtlcAvailable, _responder: Option<Responder>,
-	) -> Option<(ReleaseHeldHtlc, ResponseInstruction)> {
+	) -> Option<(ReleaseHeldHtlc, MessageSendInstructions)> {
 		None
 	}
 	fn release_held_htlc(&self, _message: ReleaseHeldHtlc) {}
@@ -174,7 +174,7 @@ impl Drop for TestCustomMessageHandler {
 
 impl CustomOnionMessageHandler for TestCustomMessageHandler {
 	type CustomMessage = TestCustomMessage;
-	fn handle_custom_message(&self, msg: Self::CustomMessage, context: Option<Vec<u8>>, responder: Option<Responder>) -> Option<(Self::CustomMessage, ResponseInstruction)> {
+	fn handle_custom_message(&self, msg: Self::CustomMessage, context: Option<Vec<u8>>, responder: Option<Responder>) -> Option<(Self::CustomMessage, MessageSendInstructions)> {
 		let expectation = self.get_next_expectation();
 		assert_eq!(msg, expectation.expect);
 

lightning/src/onion_message/messenger.rs

@@ -342,7 +342,7 @@ impl OnionMessageRecipient {
 }
 
 
-/// The `Responder` struct creates an appropriate [`ResponseInstruction`]
+/// The `Responder` struct creates an appropriate [`MessageSendInstructions`]
 /// for responding to a message.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Responder {
@@ -362,42 +362,42 @@ impl Responder {
 		}
 	}
 
-	/// Creates a [`ResponseInstruction::WithoutReplyPath`] for a given response.
+	/// Creates a [`MessageSendInstructions::WithoutReplyPath`] for a given response.
 	///
 	/// Use when the recipient doesn't need to send back a reply to us.
-	pub fn respond<T: OnionMessageContents>(self, response: T) -> Option<(T, ResponseInstruction)> {
-		Some((response, ResponseInstruction::WithoutReplyPath {
+	pub fn respond<T: OnionMessageContents>(self, response: T) -> Option<(T, MessageSendInstructions)> {
+		Some((response, MessageSendInstructions::WithoutReplyPath {
 			send_path: self.reply_path,
 		}))
 	}
 
-	/// Creates a [`ResponseInstruction::WithReplyPath`] for a given response.
+	/// Creates a [`MessageSendInstructions::WithReplyPath`] for a given response.
 	///
 	/// Use when the recipient needs to send back a reply to us.
-	pub fn respond_with_reply_path<T: OnionMessageContents>(self, response: T, context: MessageContext) -> Option<(T, ResponseInstruction)> {
-		Some((response, ResponseInstruction::WithReplyPath {
+	pub fn respond_with_reply_path<T: OnionMessageContents>(self, response: T, context: MessageContext) -> Option<(T, MessageSendInstructions)> {
+		Some((response, MessageSendInstructions::WithReplyPath {
 			send_path: self.reply_path,
 			context: context,
 		}))
 	}
 }
 
-/// `ResponseInstruction` represents instructions for responding to received messages.
+/// Instructions for how and where to send a message.
 #[derive(Clone)]
-pub enum ResponseInstruction {
-	/// Indicates that a response should be sent including a reply path for
-	/// the recipient to respond back.
+pub enum MessageSendInstructions {
+	/// Indicates that a message should be sent including a reply path for the recipient to
+	/// respond.
 	WithReplyPath {
-		/// The path over which we'll send our reply.
+		/// The desination where we need to send our message.
 		send_path: BlindedMessagePath,
 		/// The context to include in the reply path we'll give the recipient so they can respond
 		/// to us.
 		context: MessageContext,
 	},
-	/// Indicates that a response should be sent without including a reply path
-	/// for the recipient to respond back.
+	/// Indicates that a emssage should be sent without including a reply path, preventing the
+	/// recipient from responding.
 	WithoutReplyPath {
-		/// The path over which we'll send our reply.
+		/// The desination where we need to send our message.
 		send_path: BlindedMessagePath,
 	}
 }
@@ -802,7 +802,7 @@ pub trait CustomOnionMessageHandler {
 	/// The returned [`Self::CustomMessage`], if any, is enqueued to be sent by [`OnionMessenger`].
 	fn handle_custom_message(
 		&self, message: Self::CustomMessage, context: Option<Vec<u8>>, responder: Option<Responder>
-	) -> Option<(Self::CustomMessage, ResponseInstruction)>;
+	) -> Option<(Self::CustomMessage, MessageSendInstructions)>;
 
 	/// Read a custom message of type `message_type` from `buffer`, returning `Ok(None)` if the
 	/// message type is unknown.
@@ -1313,7 +1313,7 @@ where
 		)
 	}
 
-	/// Handles the response to an [`OnionMessage`] based on its [`ResponseInstruction`],
+	/// Handles the response to an [`OnionMessage`] based on its [`MessageSendInstructions`],
 	/// enqueueing any response for sending.
 	///
 	/// This function is useful for asynchronous handling of [`OnionMessage`]s.
@@ -1322,11 +1322,11 @@ where
 	/// generating the response asynchronously. Subsequently, when the response is prepared and
 	/// ready for sending, that task can invoke this method to enqueue the response for delivery.
 	pub fn handle_onion_message_response<T: OnionMessageContents>(
-		&self, response_message: T, response: ResponseInstruction,
+		&self, response_message: T, response: MessageSendInstructions,
 	) -> Result<Option<SendSuccess>, SendError> {
 		let (response_path, context) = match response {
-			ResponseInstruction::WithReplyPath { send_path, context } => (send_path, Some(context)),
-			ResponseInstruction::WithoutReplyPath { send_path } => (send_path, None),
+			MessageSendInstructions::WithReplyPath { send_path, context } => (send_path, Some(context)),
+			MessageSendInstructions::WithoutReplyPath { send_path } => (send_path, None),
 		};
 
 		let message_type = response_message.msg_type();

lightning/src/onion_message/offers.rs

@@ -22,7 +22,7 @@ use crate::offers::static_invoice::StaticInvoice;
 use crate::onion_message::packet::OnionMessageContents;
 use crate::util::logger::Logger;
 use crate::util::ser::{Readable, ReadableArgs, Writeable, Writer};
-use crate::onion_message::messenger::{ResponseInstruction, Responder};
+use crate::onion_message::messenger::{MessageSendInstructions, Responder};
 #[cfg(not(c_bindings))]
 use crate::onion_message::messenger::PendingOnionMessage;
 
@@ -47,7 +47,7 @@ pub trait OffersMessageHandler {
 	/// [`OnionMessenger`]: crate::onion_message::messenger::OnionMessenger
 	fn handle_message(
 		&self, message: OffersMessage, context: Option<OffersContext>, responder: Option<Responder>,
-	) -> Option<(OffersMessage, ResponseInstruction)>;
+	) -> Option<(OffersMessage, MessageSendInstructions)>;
 
 	/// Releases any [`OffersMessage`]s that need to be sent.
 	///