Generalize CustomOnionMessageContents trait

Rename CustomOnionMessageContents to OnionMessageContents and use it as
a trait bound on messages passed to OnionMessenger methods. This allows
using the trait in an upcoming commit as a bound on the contents of
PendingOnionMessage.

Also, make ParsedOnionMessageContent have pub(super) visibility as it no
longer needs to be exposed. It now implements OnionMessageContents so
that Payload can be bounded by OnionMessageContents directly, but used
when either reading a ParsedOnionMessageContent or writing a specific
type of OnionMessageContents (e.g., OffersMessage).

Author: jkczyz

fuzz/src/onion_message.rs

@@ -14,7 +14,7 @@ use lightning::offers::invoice_request::UnsignedInvoiceRequest;
 use lightning::util::test_channel_signer::TestChannelSigner;
 use lightning::util::logger::Logger;
 use lightning::util::ser::{Readable, Writeable, Writer};
-use lightning::onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, Destination, MessageRouter, OffersMessage, OffersMessageHandler, OnionMessagePath, OnionMessenger};
+use lightning::onion_message::{CustomOnionMessageHandler, Destination, MessageRouter, OffersMessage, OffersMessageHandler, OnionMessageContents, OnionMessagePath, OnionMessenger};
 
 use crate::utils::test_logger;
 
@@ -84,7 +84,7 @@ struct TestCustomMessage {}
 const CUSTOM_MESSAGE_TYPE: u64 = 4242;
 const CUSTOM_MESSAGE_CONTENTS: [u8; 32] = [42; 32];
 
-impl CustomOnionMessageContents for TestCustomMessage {
+impl OnionMessageContents for TestCustomMessage {
 	fn tlv_type(&self) -> u64 {
 		CUSTOM_MESSAGE_TYPE
 	}

lightning/src/ln/peer_handler.rs

@@ -29,7 +29,7 @@ use crate::util::ser::{VecWriter, Writeable, Writer};
 use crate::ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
 use crate::ln::wire;
 use crate::ln::wire::{Encode, Type};
-use crate::onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, OffersMessage, OffersMessageHandler, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
+use crate::onion_message::{CustomOnionMessageHandler, OffersMessage, OffersMessageHandler, OnionMessageContents, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
 use crate::routing::gossip::{NetworkGraph, P2PGossipSync, NodeId, NodeAlias};
 use crate::util::atomic_counter::AtomicCounter;
 use crate::util::logger::Logger;
@@ -131,7 +131,7 @@ impl CustomOnionMessageHandler for IgnoringMessageHandler {
 	}
 }
 
-impl CustomOnionMessageContents for Infallible {
+impl OnionMessageContents for Infallible {
 	fn tlv_type(&self) -> u64 { unreachable!(); }
 }
 

lightning/src/onion_message/functional_tests.rs

@@ -15,7 +15,7 @@ use crate::ln::msgs::{self, DecodeError, OnionMessageHandler};
 use crate::sign::{NodeSigner, Recipient};
 use crate::util::ser::{FixedLengthReader, LengthReadable, Writeable, Writer};
 use crate::util::test_utils;
-use super::{CustomOnionMessageContents, CustomOnionMessageHandler, Destination, MessageRouter, OffersMessage, OffersMessageHandler, ParsedOnionMessageContents, OnionMessagePath, OnionMessenger, SendError};
+use super::{CustomOnionMessageHandler, Destination, MessageRouter, OffersMessage, OffersMessageHandler, OnionMessageContents, OnionMessagePath, OnionMessenger, SendError};
 
 use bitcoin::network::constants::Network;
 use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
@@ -77,7 +77,7 @@ const CUSTOM_RESPONSE_MESSAGE_TYPE: u64 = 4343;
 const CUSTOM_REQUEST_MESSAGE_CONTENTS: [u8; 32] = [42; 32];
 const CUSTOM_RESPONSE_MESSAGE_CONTENTS: [u8; 32] = [43; 32];
 
-impl CustomOnionMessageContents for TestCustomMessage {
+impl OnionMessageContents for TestCustomMessage {
 	fn tlv_type(&self) -> u64 {
 		match self {
 			TestCustomMessage::Request => CUSTOM_REQUEST_MESSAGE_TYPE,
@@ -196,7 +196,7 @@ fn pass_along_path(path: &Vec<MessengerNode>) {
 #[test]
 fn one_hop() {
 	let nodes = create_nodes(2);
-	let test_msg = ParsedOnionMessageContents::Custom(TestCustomMessage::Response);
+	let test_msg = TestCustomMessage::Response;
 
 	let path = OnionMessagePath {
 		intermediate_nodes: vec![],
@@ -210,7 +210,7 @@ fn one_hop() {
 #[test]
 fn two_unblinded_hops() {
 	let nodes = create_nodes(3);
-	let test_msg = ParsedOnionMessageContents::Custom(TestCustomMessage::Response);
+	let test_msg = TestCustomMessage::Response;
 
 	let path = OnionMessagePath {
 		intermediate_nodes: vec![nodes[1].get_node_pk()],
@@ -224,7 +224,7 @@ fn two_unblinded_hops() {
 #[test]
 fn two_unblinded_two_blinded() {
 	let nodes = create_nodes(5);
-	let test_msg = ParsedOnionMessageContents::Custom(TestCustomMessage::Response);
+	let test_msg = TestCustomMessage::Response;
 
 	let secp_ctx = Secp256k1::new();
 	let blinded_path = BlindedPath::new_for_message(&[nodes[3].get_node_pk(), nodes[4].get_node_pk()], &*nodes[4].keys_manager, &secp_ctx).unwrap();
@@ -241,7 +241,7 @@ fn two_unblinded_two_blinded() {
 #[test]
 fn three_blinded_hops() {
 	let nodes = create_nodes(4);
-	let test_msg = ParsedOnionMessageContents::Custom(TestCustomMessage::Response);
+	let test_msg = TestCustomMessage::Response;
 
 	let secp_ctx = Secp256k1::new();
 	let blinded_path = BlindedPath::new_for_message(&[nodes[1].get_node_pk(), nodes[2].get_node_pk(), nodes[3].get_node_pk()], &*nodes[3].keys_manager, &secp_ctx).unwrap();
@@ -259,7 +259,7 @@ fn three_blinded_hops() {
 fn too_big_packet_error() {
 	// Make sure we error as expected if a packet is too big to send.
 	let nodes = create_nodes(2);
-	let test_msg = ParsedOnionMessageContents::Custom(TestCustomMessage::Response);
+	let test_msg = TestCustomMessage::Response;
 
 	let hop_node_id = nodes[1].get_node_pk();
 	let hops = vec![hop_node_id; 400];
@@ -285,7 +285,7 @@ fn we_are_intro_node() {
 		destination: Destination::BlindedPath(blinded_path),
 	};
 
-	nodes[0].messenger.send_onion_message(path, ParsedOnionMessageContents::Custom(test_msg.clone()), None).unwrap();
+	nodes[0].messenger.send_onion_message(path, test_msg.clone(), None).unwrap();
 	nodes[2].custom_message_handler.expect_message(TestCustomMessage::Response);
 	pass_along_path(&nodes);
 
@@ -295,7 +295,7 @@ fn we_are_intro_node() {
 		intermediate_nodes: vec![],
 		destination: Destination::BlindedPath(blinded_path),
 	};
-	nodes[0].messenger.send_onion_message(path, ParsedOnionMessageContents::Custom(test_msg), None).unwrap();
+	nodes[0].messenger.send_onion_message(path, test_msg, None).unwrap();
 	nodes[1].custom_message_handler.expect_message(TestCustomMessage::Response);
 	nodes.remove(2);
 	pass_along_path(&nodes);
@@ -315,7 +315,7 @@ fn invalid_blinded_path_error() {
 		intermediate_nodes: vec![],
 		destination: Destination::BlindedPath(blinded_path),
 	};
-	let err = nodes[0].messenger.send_onion_message(path, ParsedOnionMessageContents::Custom(test_msg.clone()), None).unwrap_err();
+	let err = nodes[0].messenger.send_onion_message(path, test_msg.clone(), None).unwrap_err();
 	assert_eq!(err, SendError::TooFewBlindedHops);
 
 	// 1 hop
@@ -326,7 +326,7 @@ fn invalid_blinded_path_error() {
 		intermediate_nodes: vec![],
 		destination: Destination::BlindedPath(blinded_path),
 	};
-	let err = nodes[0].messenger.send_onion_message(path, ParsedOnionMessageContents::Custom(test_msg), None).unwrap_err();
+	let err = nodes[0].messenger.send_onion_message(path, test_msg, None).unwrap_err();
 	assert_eq!(err, SendError::TooFewBlindedHops);
 }
 
@@ -342,7 +342,7 @@ fn reply_path() {
 		destination: Destination::Node(nodes[3].get_node_pk()),
 	};
 	let reply_path = BlindedPath::new_for_message(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();
-	nodes[0].messenger.send_onion_message(path, ParsedOnionMessageContents::Custom(test_msg.clone()), Some(reply_path)).unwrap();
+	nodes[0].messenger.send_onion_message(path, test_msg.clone(), Some(reply_path)).unwrap();
 	nodes[3].custom_message_handler.expect_message(TestCustomMessage::Request);
 	pass_along_path(&nodes);
 	// Make sure the last node successfully decoded the reply path.
@@ -358,7 +358,7 @@ fn reply_path() {
 	};
 	let reply_path = BlindedPath::new_for_message(&[nodes[2].get_node_pk(), nodes[1].get_node_pk(), nodes[0].get_node_pk()], &*nodes[0].keys_manager, &secp_ctx).unwrap();
 
-	nodes[0].messenger.send_onion_message(path, ParsedOnionMessageContents::Custom(test_msg), Some(reply_path)).unwrap();
+	nodes[0].messenger.send_onion_message(path, test_msg, Some(reply_path)).unwrap();
 	nodes[3].custom_message_handler.expect_message(TestCustomMessage::Request);
 	pass_along_path(&nodes);
 
@@ -373,7 +373,7 @@ fn invalid_custom_message_type() {
 	let nodes = create_nodes(2);
 
 	struct InvalidCustomMessage{}
-	impl CustomOnionMessageContents for InvalidCustomMessage {
+	impl OnionMessageContents for InvalidCustomMessage {
 		fn tlv_type(&self) -> u64 {
 			// Onion message contents must have a TLV >= 64.
 			63
@@ -384,7 +384,7 @@ fn invalid_custom_message_type() {
 		fn write<W: Writer>(&self, _w: &mut W) -> Result<(), io::Error> { unreachable!() }
 	}
 
-	let test_msg = ParsedOnionMessageContents::Custom(InvalidCustomMessage {});
+	let test_msg = InvalidCustomMessage {};
 	let path = OnionMessagePath {
 		intermediate_nodes: vec![],
 		destination: Destination::Node(nodes[1].get_node_pk()),
@@ -402,9 +402,9 @@ fn peer_buffer_full() {
 		destination: Destination::Node(nodes[1].get_node_pk()),
 	};
 	for _ in 0..188 { // Based on MAX_PER_PEER_BUFFER_SIZE in OnionMessenger
-		nodes[0].messenger.send_onion_message(path.clone(), ParsedOnionMessageContents::Custom(test_msg.clone()), None).unwrap();
+		nodes[0].messenger.send_onion_message(path.clone(), test_msg.clone(), None).unwrap();
 	}
-	let err = nodes[0].messenger.send_onion_message(path, ParsedOnionMessageContents::Custom(test_msg), None).unwrap_err();
+	let err = nodes[0].messenger.send_onion_message(path, test_msg, None).unwrap_err();
 	assert_eq!(err, SendError::BufferFull);
 }
 
@@ -425,7 +425,7 @@ fn many_hops() {
 		intermediate_nodes,
 		destination: Destination::Node(nodes[num_nodes-1].get_node_pk()),
 	};
-	nodes[0].messenger.send_onion_message(path, ParsedOnionMessageContents::Custom(test_msg), None).unwrap();
+	nodes[0].messenger.send_onion_message(path, test_msg, None).unwrap();
 	nodes[num_nodes-1].custom_message_handler.expect_message(TestCustomMessage::Response);
 	pass_along_path(&nodes);
 }

lightning/src/onion_message/messenger.rs

@@ -23,7 +23,8 @@ use crate::ln::features::{InitFeatures, NodeFeatures};
 use crate::ln::msgs::{self, OnionMessageHandler};
 use crate::ln::onion_utils;
 use crate::ln::peer_handler::IgnoringMessageHandler;
-pub use super::packet::{CustomOnionMessageContents, ParsedOnionMessageContents};
+pub use super::packet::OnionMessageContents;
+use super::packet::ParsedOnionMessageContents;
 use super::offers::OffersMessageHandler;
 use super::packet::{BIG_PACKET_HOP_DATA_LEN, ForwardControlTlvs, Packet, Payload, ReceiveControlTlvs, SMALL_PACKET_HOP_DATA_LEN};
 use crate::util::logger::Logger;
@@ -60,7 +61,7 @@ use crate::prelude::*;
 /// # use lightning::blinded_path::BlindedPath;
 /// # use lightning::sign::KeysManager;
 /// # use lightning::ln::peer_handler::IgnoringMessageHandler;
-/// # use lightning::onion_message::{CustomOnionMessageContents, Destination, MessageRouter, ParsedOnionMessageContents, OnionMessagePath, OnionMessenger};
+/// # use lightning::onion_message::{OnionMessageContents, Destination, MessageRouter, OnionMessagePath, OnionMessenger};
 /// # use lightning::util::logger::{Logger, Record};
 /// # use lightning::util::ser::{Writeable, Writer};
 /// # use lightning::io;
@@ -101,7 +102,7 @@ use crate::prelude::*;
 /// 		// Write your custom onion message to `w`
 /// 	}
 /// }
-/// impl CustomOnionMessageContents for YourCustomMessage {
+/// impl OnionMessageContents for YourCustomMessage {
 /// 	fn tlv_type(&self) -> u64 {
 /// 		# let your_custom_message_type = 42;
 /// 		your_custom_message_type
@@ -113,8 +114,7 @@ use crate::prelude::*;
 /// 	destination: Destination::Node(destination_node_id),
 /// };
 /// let reply_path = None;
-/// # let your_custom_message = YourCustomMessage {};
-/// let message = ParsedOnionMessageContents::Custom(your_custom_message);
+/// # let message = YourCustomMessage {};
 /// onion_messenger.send_onion_message(path, message, reply_path);
 ///
 /// // Create a blinded path to yourself, for someone to send an onion message to.
@@ -128,8 +128,7 @@ use crate::prelude::*;
 /// 	destination: Destination::BlindedPath(blinded_path),
 /// };
 /// let reply_path = None;
-/// # let your_custom_message = YourCustomMessage {};
-/// let message = ParsedOnionMessageContents::Custom(your_custom_message);
+/// # let message = YourCustomMessage {};
 /// onion_messenger.send_onion_message(path, message, reply_path);
 /// ```
 ///
@@ -249,7 +248,7 @@ pub enum SendError {
 pub trait CustomOnionMessageHandler {
 	/// The message known to the handler. To support multiple message types, you may want to make this
 	/// an enum with a variant for each supported message.
-	type CustomMessage: CustomOnionMessageContents;
+	type CustomMessage: OnionMessageContents;
 
 	/// Called with the custom message that was received, returning a response to send, if any.
 	fn handle_custom_message(&self, msg: Self::CustomMessage) -> Option<Self::CustomMessage>;
@@ -292,9 +291,8 @@ where
 	/// Send an onion message with contents `message` to the destination of `path`.
 	///
 	/// See [`OnionMessenger`] for example usage.
-	pub fn send_onion_message<T: CustomOnionMessageContents>(
-		&self, path: OnionMessagePath, message: ParsedOnionMessageContents<T>,
-		reply_path: Option<BlindedPath>
+	pub fn send_onion_message<T: OnionMessageContents>(
+		&self, path: OnionMessagePath, message: T, reply_path: Option<BlindedPath>
 	) -> Result<(), SendError> {
 		let OnionMessagePath { intermediate_nodes, mut destination } = path;
 		if let Destination::BlindedPath(BlindedPath { ref blinded_hops, .. }) = destination {
@@ -348,9 +346,25 @@ where
 		}
 	}
 
-	fn find_path_and_enqueue_onion_message<T: CustomOnionMessageContents>(
-		&self, contents: ParsedOnionMessageContents<T>, destination: Destination,
-		log_suffix: fmt::Arguments
+	fn handle_onion_message_response<T: OnionMessageContents>(
+		&self, response: Option<T>, reply_path: Option<BlindedPath>, log_suffix: fmt::Arguments
+	) {
+		if let Some(response) = response {
+			match reply_path {
+				Some(reply_path) => {
+					self.find_path_and_enqueue_onion_message(
+						response, Destination::BlindedPath(reply_path), log_suffix
+					);
+				},
+				None => {
+					log_trace!(self.logger, "Missing reply path {}", log_suffix);
+				},
+			}
+		}
+	}
+
+	fn find_path_and_enqueue_onion_message<T: OnionMessageContents>(
+		&self, contents: T, destination: Destination, log_suffix: fmt::Arguments
 	) {
 		let sender = match self.node_signer.get_node_id(Recipient::Node) {
 			Ok(node_id) => node_id,
@@ -454,41 +468,32 @@ where
 			onion_decode_ss, &msg.onion_routing_packet.hop_data[..], msg.onion_routing_packet.hmac,
 			(control_tlvs_ss, &*self.custom_handler, &*self.logger)
 		) {
-			Ok((Payload::Receive::<<<CMH as Deref>::Target as CustomOnionMessageHandler>::CustomMessage> {
+			Ok((Payload::Receive::<ParsedOnionMessageContents<<<CMH as Deref>::Target as CustomOnionMessageHandler>::CustomMessage>> {
 				message, control_tlvs: ReceiveControlTlvs::Unblinded(ReceiveTlvs { path_id }), reply_path,
 			}, None)) => {
 				log_trace!(self.logger,
 					"Received an onion message with path_id {:02x?} and {} reply_path",
 						path_id, if reply_path.is_some() { "a" } else { "no" });
 
-				let response = match message {
+				match message {
 					ParsedOnionMessageContents::Offers(msg) => {
-						self.offers_handler.handle_message(msg)
-							.map(|msg| ParsedOnionMessageContents::Offers(msg))
+						let response = self.offers_handler.handle_message(msg);
+						self.handle_onion_message_response(
+							response, reply_path, format_args!(
+								"when responding to Offers onion message with path_id {:02x?}",
+								path_id
+							)
+						);
 					},
 					ParsedOnionMessageContents::Custom(msg) => {
-						self.custom_handler.handle_custom_message(msg)
-							.map(|msg| ParsedOnionMessageContents::Custom(msg))
-					},
-				};
-
-				if let Some(response) = response {
-					match reply_path {
-						Some(reply_path) => {
-							self.find_path_and_enqueue_onion_message(
-								response, Destination::BlindedPath(reply_path), format_args!(
-									"when responding to onion message with path_id {:02x?}", path_id
-								)
-							);
-						},
-						None => {
-							log_trace!(
-								self.logger,
-								"Missing reply path when responding to onion message with path_id {:02x?}",
+						let response = self.custom_handler.handle_custom_message(msg);
+						self.handle_onion_message_response(
+							response, reply_path, format_args!(
+								"when responding to Custom onion message with path_id {:02x?}",
 								path_id
-							);
-						},
-					}
+							)
+						);
+					},
 				}
 			},
 			Ok((Payload::Forward(ForwardControlTlvs::Unblinded(ForwardTlvs {
@@ -629,9 +634,9 @@ pub type SimpleRefOnionMessenger<'a, 'b, 'c, L> = OnionMessenger<
 
 /// Construct onion packet payloads and keys for sending an onion message along the given
 /// `unblinded_path` to the given `destination`.
-fn packet_payloads_and_keys<T: CustomOnionMessageContents, S: secp256k1::Signing + secp256k1::Verification>(
-	secp_ctx: &Secp256k1<S>, unblinded_path: &[PublicKey], destination: Destination,
-	message: ParsedOnionMessageContents<T>, mut reply_path: Option<BlindedPath>, session_priv: &SecretKey
+fn packet_payloads_and_keys<T: OnionMessageContents, S: secp256k1::Signing + secp256k1::Verification>(
+	secp_ctx: &Secp256k1<S>, unblinded_path: &[PublicKey], destination: Destination, message: T,
+	mut reply_path: Option<BlindedPath>, session_priv: &SecretKey
 ) -> Result<(Vec<(Payload<T>, [u8; 32])>, Vec<onion_utils::OnionKeys>), secp256k1::Error> {
 	let num_hops = unblinded_path.len() + destination.num_hops();
 	let mut payloads = Vec::with_capacity(num_hops);
@@ -707,7 +712,7 @@ fn packet_payloads_and_keys<T: CustomOnionMessageContents, S: secp256k1::Signing
 }
 
 /// Errors if the serialized payload size exceeds onion_message::BIG_PACKET_HOP_DATA_LEN
-fn construct_onion_message_packet<T: CustomOnionMessageContents>(payloads: Vec<(Payload<T>, [u8; 32])>, onion_keys: Vec<onion_utils::OnionKeys>, prng_seed: [u8; 32]) -> Result<Packet, ()> {
+fn construct_onion_message_packet<T: OnionMessageContents>(payloads: Vec<(Payload<T>, [u8; 32])>, onion_keys: Vec<onion_utils::OnionKeys>, prng_seed: [u8; 32]) -> Result<Packet, ()> {
 	// Spec rationale:
 	// "`len` allows larger messages to be sent than the standard 1300 bytes allowed for an HTLC
 	// onion, but this should be used sparingly as it is reduces anonymity set, hence the

lightning/src/onion_message/mod.rs

@@ -27,6 +27,6 @@ mod packet;
 mod functional_tests;
 
 // Re-export structs so they can be imported with just the `onion_message::` module prefix.
-pub use self::messenger::{CustomOnionMessageContents, CustomOnionMessageHandler, DefaultMessageRouter, Destination, MessageRouter, ParsedOnionMessageContents, OnionMessagePath, OnionMessenger, SendError, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
+pub use self::messenger::{CustomOnionMessageHandler, DefaultMessageRouter, Destination, MessageRouter, OnionMessageContents, OnionMessagePath, OnionMessenger, SendError, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
 pub use self::offers::{OffersMessage, OffersMessageHandler};
 pub(crate) use self::packet::{ControlTlvs, Packet};