Report the sending peer in Event::OnionMessageIntercepted

When the OnionMessenger intercepts a message bound for an offline peer, it now
reports which peer sent us the message to forward via a new `prev_node_id`
field, so handlers can apply source-based policy when deciding whether to
forward. The existing destination field is renamed `peer_node_id` ->
`next_node_id` so the two node ids are unambiguous.

`prev_node_id` is `None` when the forward is enqueued by a message handler (the
BOLT 12 static-invoice-server flow), which isn't given the sending node;
otherwise it is the node we received the message from.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: jkczyz

lightning/src/events/mod.rs

@@ -1851,9 +1851,15 @@ pub enum Event {
 	///
 	/// [`OnionMessenger::new_with_offline_peer_interception`]: crate::onion_message::messenger::OnionMessenger::new_with_offline_peer_interception
 	OnionMessageIntercepted {
-		/// The node id of the offline peer.
-		peer_node_id: PublicKey,
-		/// The onion message intended to be forwarded to `peer_node_id`.
+		/// The node id of the peer that sent the message, if known.
+		///
+		/// This is `None` when the forward is enqueued by a message handler (e.g. the BOLT 12
+		/// static-invoice-server flow), which isn't given the sending node. Otherwise it is the
+		/// node we received the message from.
+		prev_node_id: Option<PublicKey>,
+		/// The node id of the offline peer we intended to forward the message to.
+		next_node_id: PublicKey,
+		/// The onion message intended to be forwarded to `next_node_id`.
 		message: msgs::OnionMessage,
 	},
 	/// Indicates that an onion message supporting peer has come online and any messages previously
@@ -2435,10 +2441,11 @@ impl Writeable for Event {
 				35u8.write(writer)?;
 				// Never write ConnectionNeeded events as buffered onion messages aren't serialized.
 			},
-			&Event::OnionMessageIntercepted { ref peer_node_id, ref message } => {
+			&Event::OnionMessageIntercepted { ref prev_node_id, ref next_node_id, ref message } => {
 				37u8.write(writer)?;
 				write_tlv_fields!(writer, {
-					(0, peer_node_id, required),
+					(0, next_node_id, required),
+					(1, prev_node_id, option),
 					(2, message, required),
 				});
 			},
@@ -3068,11 +3075,13 @@ impl MaybeReadable for Event {
 			37u8 => {
 				let mut f = || {
 					_init_and_read_len_prefixed_tlv_fields!(reader, {
-						(0, peer_node_id, required),
+						(0, next_node_id, required),
+						(1, prev_node_id, option),
 						(2, message, required),
 					});
 					Ok(Some(Event::OnionMessageIntercepted {
-						peer_node_id: peer_node_id.0.unwrap(),
+						prev_node_id,
+						next_node_id: next_node_id.0.unwrap(),
 						message: message.0.unwrap(),
 					}))
 				};

lightning/src/onion_message/functional_tests.rs

@@ -1144,8 +1144,9 @@ fn intercept_offline_peer_oms() {
 	let mut events = release_events(&nodes[1]);
 	assert_eq!(events.len(), 1);
 	let onion_message = match events.remove(0) {
-		Event::OnionMessageIntercepted { peer_node_id, message } => {
-			assert_eq!(peer_node_id, final_node_vec[0].node_id);
+		Event::OnionMessageIntercepted { prev_node_id, next_node_id, message } => {
+			assert_eq!(prev_node_id, Some(nodes[0].node_id));
+			assert_eq!(next_node_id, final_node_vec[0].node_id);
 			message
 		},
 		_ => panic!(),

lightning/src/onion_message/messenger.rs

@@ -1547,6 +1547,7 @@ impl<
 
 		let result = if is_forward {
 			self.enqueue_forwarded_onion_message(
+				None,
 				NextMessageHop::NodeId(first_node_id),
 				onion_message,
 				log_suffix,
@@ -1662,7 +1663,8 @@ impl<
 	}
 
 	fn enqueue_forwarded_onion_message(
-		&self, next_hop: NextMessageHop, onion_message: OnionMessage, log_suffix: fmt::Arguments,
+		&self, prev_node_id: Option<PublicKey>, next_hop: NextMessageHop,
+		onion_message: OnionMessage, log_suffix: fmt::Arguments,
 	) -> Result<(), SendError> {
 		let next_node_id = match next_hop {
 			NextMessageHop::NodeId(pubkey) => pubkey,
@@ -1712,7 +1714,8 @@ impl<
 					log_suffix
 				);
 				self.enqueue_intercepted_event(Event::OnionMessageIntercepted {
-					peer_node_id: next_node_id,
+					prev_node_id,
+					next_node_id,
 					message: onion_message,
 				});
 				Ok(())
@@ -2293,6 +2296,7 @@ impl<
 			},
 			Ok(PeeledOnion::Forward(next_hop, onion_message)) => {
 				let _ = self.enqueue_forwarded_onion_message(
+					Some(peer_node_id),
 					next_hop,
 					onion_message,
 					format_args!("when forwarding peeled onion message from {}", peer_node_id),