Support generating events when an OM for an offline peer is received.

Docs will be added in upcoming commits.

Author: valentinewallace

lightning/src/events/mod.rs

@@ -1036,6 +1036,13 @@ pub enum Event {
 	///
 	/// [`ChannelHandshakeConfig::negotiate_anchors_zero_fee_htlc_tx`]: crate::util::config::ChannelHandshakeConfig::negotiate_anchors_zero_fee_htlc_tx
 	BumpTransaction(BumpTransactionEvent),
+	///
+	OnionMessageForOfflinePeer {
+		/// The node id of the offline peer.
+		peer_node_id: PublicKey,
+		/// The onion message intended to be forwarded to `peer_node_id`.
+		message: msgs::OnionMessage,
+	},
 }
 
 impl Writeable for Event {
@@ -1281,6 +1288,13 @@ impl Writeable for Event {
 				35u8.write(writer)?;
 				// Never write ConnectionNeeded events as buffered onion messages aren't serialized.
 			},
+			&Event::OnionMessageForOfflinePeer { ref peer_node_id, ref message } => {
+				37u8.write(writer)?;
+				write_tlv_fields!(writer, {
+					(0, peer_node_id, required),
+					(2, message, required),
+				});
+			}
 			// Note that, going forward, all new events must only write data inside of
 			// `write_tlv_fields`. Versions 0.0.101+ will ignore odd-numbered events that write
 			// data via `write_tlv_fields`.
@@ -1692,6 +1706,18 @@ impl MaybeReadable for Event {
 			},
 			// Note that we do not write a length-prefixed TLV for ConnectionNeeded events.
 			35u8 => Ok(None),
+			37u8 => {
+				let f = || {
+					_init_and_read_len_prefixed_tlv_fields!(reader, {
+						(0, peer_node_id, required),
+						(2, message, required),
+					});
+					Ok(Some(Event::OnionMessageForOfflinePeer {
+						peer_node_id: peer_node_id.0.unwrap(), message: message.0.unwrap()
+					}))
+				};
+				f()
+			},
 			// Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue.
 			// Version 0.0.100 failed to properly ignore odd types, possibly resulting in corrupt
 			// reads.

lightning/src/onion_message/messenger.rs

@@ -172,6 +172,8 @@ where
 	message_router: MR,
 	offers_handler: OMH,
 	custom_handler: CMH,
+	intercept_oms_for_offline_peers: bool,
+	pending_events: Mutex<Vec<Event>>,
 }
 
 /// [`OnionMessage`]s buffered to be sent.
@@ -713,6 +715,27 @@ where
 	pub fn new(
 		entropy_source: ES, node_signer: NS, logger: L, message_router: MR, offers_handler: OMH,
 		custom_handler: CMH
+	) -> Self {
+		Self::new_inner(
+			entropy_source, node_signer, logger, message_router, offers_handler,
+			custom_handler, false
+		)
+	}
+
+	///
+	pub fn new_with_offline_peer_interception(
+		entropy_source: ES, node_signer: NS, logger: L, message_router: MR, offers_handler: OMH,
+		custom_handler: CMH
+	) -> Self {
+		Self::new_inner(
+			entropy_source, node_signer, logger, message_router, offers_handler,
+			custom_handler, true
+		)
+	}
+
+	fn new_inner(
+		entropy_source: ES, node_signer: NS, logger: L, message_router: MR, offers_handler: OMH,
+		custom_handler: CMH, intercept_oms_for_offline_peers: bool
 	) -> Self {
 		let mut secp_ctx = Secp256k1::new();
 		secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
@@ -725,6 +748,8 @@ where
 			message_router,
 			offers_handler,
 			custom_handler,
+			intercept_oms_for_offline_peers,
+			pending_events: Mutex::new(Vec::new()),
 		}
 	}
 
@@ -918,6 +943,11 @@ where
 				}
 			}
 		}
+		let mut events = Vec::new();
+		core::mem::swap(&mut *self.pending_events.lock().unwrap(), &mut events);
+		for ev in events {
+			handler.handle_event(ev);
+		}
 	}
 }
 
@@ -983,6 +1013,13 @@ where
 						e.get_mut().enqueue_message(onion_message);
 						log_trace!(logger, "Forwarding an onion message to peer {}", next_node_id);
 					},
+					_ if self.intercept_oms_for_offline_peers => {
+						self.pending_events.lock().unwrap().push(
+							Event::OnionMessageForOfflinePeer {
+								peer_node_id: next_node_id, message: onion_message
+							}
+						);
+					},
 					_ => {
 						log_trace!(
 							logger,