change make_onion_message to static method, return whole onion

Author: Evanfeenstra

lightning/src/ln/msgs.rs

@@ -631,7 +631,8 @@ pub struct UpdateAddHTLC {
 pub struct OnionMessage {
 	/// Used in decrypting the onion packet's payload.
 	pub blinding_point: PublicKey,
-	pub(crate) onion_routing_packet: onion_message::Packet,
+	/// The full onion packet including hop data, pubkey, and hmac
+	pub onion_routing_packet: onion_message::Packet,
 }
 
 /// An [`update_fulfill_htlc`] message to be sent to or received from a peer.

lightning/src/onion_message/messenger.rs

@@ -283,7 +283,14 @@ where
 		&self, path: OnionMessagePath, message: OnionMessageContents<T>,
 		reply_path: Option<BlindedPath>
 	) -> Result<(), SendError> {
-		let (introduction_node_id, onion_msg) = self.make_onion_message(path, message, reply_path)?;
+		let (introduction_node_id, onion_msg) = Self::make_onion_message(
+			&self.entropy_source, 
+			&self.node_signer, 
+			&self.secp_ctx, 
+			path, 
+			message, 
+			reply_path
+		)?;
 
 		let mut pending_per_peer_msgs = self.pending_messages.lock().unwrap();
 		if outbound_buffer_full(&introduction_node_id, &pending_per_peer_msgs) { return Err(SendError::BufferFull) }
@@ -296,19 +303,15 @@ where
 		}
 	}
 
-	/// Construct an onion message with contents `message` to the destination of `path`.
-	pub fn construct_onion_message<T: CustomOnionMessageContents>(
-		&self, path: OnionMessagePath, message: OnionMessageContents<T>,
-		reply_path: Option<BlindedPath>
-	) -> Result<Vec<u8>, SendError> {
-		let (_, onion_routing_packet) = self.make_onion_message(path, message, reply_path)?;
-		Ok(onion_routing_packet.onion_routing_packet.hop_data)
-	}
-
-	// returns (introduction_node_id, onion_msg)
-	fn make_onion_message<T: CustomOnionMessageContents>(
-		&self, path: OnionMessagePath, message: OnionMessageContents<T>,
-		reply_path: Option<BlindedPath>
+	/// Make an onion message with contents `message` to the destination of `path`.
+	/// Returns (introduction_node_id, onion_msg)
+	pub fn make_onion_message<T: CustomOnionMessageContents>(
+		entropy_source: &ES, 
+		node_signer: &NS,
+		secp_ctx: &Secp256k1<secp256k1::All>,
+		path: OnionMessagePath, 
+		message: OnionMessageContents<T>,
+		reply_path: Option<BlindedPath>, 
 	) -> Result<(PublicKey, msgs::OnionMessage), SendError> {
 		let OnionMessagePath { intermediate_nodes, mut destination } = path;
 		if let Destination::BlindedPath(BlindedPath { ref blinded_hops, .. }) = destination {
@@ -323,31 +326,31 @@ where
 		// advance the blinded path by 1 hop so the second hop is the new introduction node.
 		if intermediate_nodes.len() == 0 {
 			if let Destination::BlindedPath(ref mut blinded_path) = destination {
-				let our_node_id = self.node_signer.get_node_id(Recipient::Node)
+				let our_node_id = node_signer.get_node_id(Recipient::Node)
 					.map_err(|()| SendError::GetNodeIdFailed)?;
 				if blinded_path.introduction_node_id == our_node_id {
-					advance_path_by_one(blinded_path, &self.node_signer, &self.secp_ctx)
+					advance_path_by_one(blinded_path, node_signer, &secp_ctx)
 						.map_err(|()| SendError::BlindedPathAdvanceFailed)?;
 				}
 			}
 		}
 
-		let blinding_secret_bytes = self.entropy_source.get_secure_random_bytes();
+		let blinding_secret_bytes = entropy_source.get_secure_random_bytes();
 		let blinding_secret = SecretKey::from_slice(&blinding_secret_bytes[..]).expect("RNG is busted");
 		let (introduction_node_id, blinding_point) = if intermediate_nodes.len() != 0 {
-			(intermediate_nodes[0], PublicKey::from_secret_key(&self.secp_ctx, &blinding_secret))
+			(intermediate_nodes[0], PublicKey::from_secret_key(&secp_ctx, &blinding_secret))
 		} else {
 			match destination {
-				Destination::Node(pk) => (pk, PublicKey::from_secret_key(&self.secp_ctx, &blinding_secret)),
+				Destination::Node(pk) => (pk, PublicKey::from_secret_key(&secp_ctx, &blinding_secret)),
 				Destination::BlindedPath(BlindedPath { introduction_node_id, blinding_point, .. }) =>
 					(introduction_node_id, blinding_point),
 			}
 		};
 		let (packet_payloads, packet_keys) = packet_payloads_and_keys(
-			&self.secp_ctx, &intermediate_nodes, destination, message, reply_path, &blinding_secret)
+			&secp_ctx, &intermediate_nodes, destination, message, reply_path, &blinding_secret)
 			.map_err(|e| SendError::Secp256k1(e))?;
 
-		let prng_seed = self.entropy_source.get_secure_random_bytes();
+		let prng_seed = entropy_source.get_secure_random_bytes();
 		let onion_routing_packet = construct_onion_message_packet(
 			packet_payloads, packet_keys, prng_seed).map_err(|()| SendError::TooBigPacket)?;
 

lightning/src/onion_message/packet.rs

@@ -33,15 +33,15 @@ pub(super) const SMALL_PACKET_HOP_DATA_LEN: usize = 1300;
 pub(super) const BIG_PACKET_HOP_DATA_LEN: usize = 32768;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) struct Packet {
-	pub(super) version: u8,
-	pub(super) public_key: PublicKey,
+pub struct Packet {
+	pub version: u8,
+	pub public_key: PublicKey,
 	// Unlike the onion packets used for payments, onion message packets can have payloads greater
 	// than 1300 bytes.
 	// TODO: if 1300 ends up being the most common size, optimize this to be:
 	// enum { ThirteenHundred([u8; 1300]), VarLen(Vec<u8>) }
-	pub(super) hop_data: Vec<u8>,
-	pub(super) hmac: [u8; 32],
+	pub hop_data: Vec<u8>,
+	pub hmac: [u8; 32],
 }
 
 impl onion_utils::Packet for Packet {