Enable ChainMonitor to distribute PeerStorage

To enable ChainMonitor sending peer storage to channel partners whenever a new block is added,
a new message handler, `SendingOnlyMessageHandler`, has been introduced.
This allows the `ChainMonitor` to handle the peer storage distribution.

Key changes:
 - Introduce the SendingOnlyMessageHandler trait to facilitate peer storage distribution.
 - Add SendingOnlyMessageHandler into the MessageHandler.
 - Implement SendingOnlyMessageHandler for ChainMonitor and IgnoringMessageHandler.
 - Process SendingOnlyMessageHandler events inside process_events().

Author: Aditya Sharma

lightning-background-processor/src/lib.rs

@@ -1219,6 +1219,7 @@ mod tests {
 				Arc<test_utils::TestLogger>,
 				IgnoringMessageHandler,
 				Arc<KeysManager>,
+				IgnoringMessageHandler,
 			>,
 		>,
 		chain_monitor: Arc<ChainMonitor>,
@@ -1632,6 +1633,7 @@ mod tests {
 				route_handler: Arc::new(test_utils::TestRoutingMessageHandler::new()),
 				onion_message_handler: messenger.clone(),
 				custom_message_handler: IgnoringMessageHandler {},
+				send_only_message_handler: IgnoringMessageHandler {},
 			};
 			let peer_manager = Arc::new(PeerManager::new(
 				msg_handler,

lightning-net-tokio/src/lib.rs

@@ -837,6 +837,7 @@ mod tests {
 			route_handler: Arc::clone(&a_handler),
 			onion_message_handler: Arc::new(IgnoringMessageHandler {}),
 			custom_message_handler: Arc::new(IgnoringMessageHandler {}),
+			send_only_message_handler: Arc::new(IgnoringMessageHandler {}),
 		};
 		let a_manager = Arc::new(PeerManager::new(
 			a_msg_handler,
@@ -860,6 +861,7 @@ mod tests {
 			route_handler: Arc::clone(&b_handler),
 			onion_message_handler: Arc::new(IgnoringMessageHandler {}),
 			custom_message_handler: Arc::new(IgnoringMessageHandler {}),
+			send_only_message_handler: Arc::new(IgnoringMessageHandler {}),
 		};
 		let b_manager = Arc::new(PeerManager::new(
 			b_msg_handler,
@@ -922,6 +924,7 @@ mod tests {
 			onion_message_handler: Arc::new(IgnoringMessageHandler {}),
 			route_handler: Arc::new(lightning::ln::peer_handler::IgnoringMessageHandler {}),
 			custom_message_handler: Arc::new(IgnoringMessageHandler {}),
+			send_only_message_handler: Arc::new(IgnoringMessageHandler {}),
 		};
 		let a_manager = Arc::new(PeerManager::new(
 			a_msg_handler,

lightning/src/chain/chainmonitor.rs

@@ -38,7 +38,8 @@ use crate::util::logger::{Logger, WithContext};
 use crate::util::errors::APIError;
 use crate::util::wakers::{Future, Notifier};
 use crate::ln::channel_state::ChannelDetails;
-
+use crate::ln::msgs::SendingOnlyMessageHandler;
+use crate::events::{MessageSendEvent, MessageSendEventsProvider};
 use crate::prelude::*;
 use crate::sync::{RwLock, RwLockReadGuard, Mutex, MutexGuard};
 use core::ops::Deref;
@@ -244,6 +245,7 @@ pub struct ChainMonitor<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F
 	/// A [`Notifier`] used to wake up the background processor in case we have any [`Event`]s for
 	/// it to give to users (or [`MonitorEvent`]s for `ChannelManager` to process).
 	event_notifier: Notifier,
+	pending_send_only_events: Mutex<Vec<MessageSendEvent>>,
 }
 
 impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref> ChainMonitor<ChannelSigner, C, T, F, L, P>
@@ -371,6 +373,32 @@ where C::Target: chain::Filter,
 		Ok(())
 	}
 
+impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref> MessageSendEventsProvider for ChainMonitor<ChannelSigner, C, T, F, L, P>
+where C::Target: chain::Filter,
+		T::Target: BroadcasterInterface,
+		F::Target: FeeEstimator,
+		L::Target: Logger,
+		P::Target: Persist<ChannelSigner>,
+{
+	fn get_and_clear_pending_msg_events(&self) -> Vec<MessageSendEvent> {
+		let mut pending_events = self.pending_send_only_events.lock().unwrap();
+		let mut ret = Vec::new();
+		mem::swap(&mut ret, &mut *pending_events);
+		ret	}
+}
+
+impl<ChannelSigner: EcdsaChannelSigner, C: Deref, T: Deref, F: Deref, L: Deref, P: Deref> SendingOnlyMessageHandler for ChainMonitor<ChannelSigner, C, T, F, L, P>
+where C::Target: chain::Filter,
+		T::Target: BroadcasterInterface,
+		F::Target: FeeEstimator,
+		L::Target: Logger,
+		P::Target: Persist<ChannelSigner>,
+{
+	fn send_peer_storage(&self, their_node_id: PublicKey) {
+	}
+}
+
+
 	/// Creates a new `ChainMonitor` used to watch on-chain activity pertaining to channels.
 	///
 	/// When an optional chain source implementing [`chain::Filter`] is provided, the chain monitor
@@ -389,6 +417,7 @@ where C::Target: chain::Filter,
 			pending_monitor_events: Mutex::new(Vec::new()),
 			highest_chain_height: AtomicUsize::new(0),
 			event_notifier: Notifier::new(),
+			pending_send_only_events: Mutex::new(Vec::new()),
 		}
 	}
 

lightning/src/ln/msgs.rs

@@ -1502,6 +1502,19 @@ pub struct CommitmentUpdate {
 	pub commitment_signed: CommitmentSigned,
 }
 
+/// A trait for sending messages to peers without handling any incoming messages.
+/// 
+/// This trait is designed to handle outbound-only communication, allowing implementations
+/// to send specific types of messages to connected peers identified by their public keys.
+///
+/// This trait extends [`MessageSendEventsProvider`], meaning it is capable of generating 
+/// message send events, which can be processed using
+/// [`MessageSendEventsProvider::get_and_clear_pending_msg_events`].
+pub trait SendingOnlyMessageHandler: MessageSendEventsProvider {
+	/// Send `peer_storage` message to the given peer.
+	fn send_peer_storage(&self, their_node_id: PublicKey);
+}
+
 /// A trait to describe an object which can receive channel messages.
 ///
 /// Messages MAY be called in parallel when they originate from different `their_node_ids`, however