do not expose list protocols

Author: johncantrell97

src/events.rs

@@ -19,7 +19,6 @@
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 
 mod channel_request;
-pub mod events;
 mod jit_channel;
 mod transport;
 mod utils;

src/lib.rs

@@ -1,4 +1,3 @@
-use crate::events::Event;
 use crate::transport::msgs::{LSPSMessage, RawLSPSMessage, LSPS_MESSAGE_TYPE};
 use crate::transport::protocol::LSPS0MessageHandler;
 
@@ -43,7 +42,6 @@ where
 	ES::Target: EntropySource,
 {
 	pending_messages: Arc<Mutex<Vec<(PublicKey, LSPSMessage)>>>,
-	pending_events: Arc<Mutex<Vec<Event>>>,
 	request_id_to_method_map: Mutex<HashMap<String, String>>,
 	lsps0_message_handler: LSPS0MessageHandler<ES>,
 	config: LSPConfig,
@@ -58,36 +56,18 @@ where
 	/// Sets up all required protocol message handlers based on configuration passed in
 	pub fn new(entropy_source: ES, config: LSPConfig) -> Self {
 		let pending_messages = Arc::new(Mutex::new(vec![]));
-		let pending_events = Arc::new(Mutex::new(vec![]));
 
-		let lsps0_message_handler = LSPS0MessageHandler::new(
-			entropy_source,
-			vec![],
-			Arc::clone(&pending_messages),
-			Arc::clone(&pending_events),
-		);
+		let lsps0_message_handler =
+			LSPS0MessageHandler::new(entropy_source, vec![], Arc::clone(&pending_messages));
 
 		Self {
 			pending_messages,
-			pending_events,
 			request_id_to_method_map: Mutex::new(HashMap::new()),
 			lsps0_message_handler,
 			config,
 		}
 	}
 
-	/// List the LSP protocols a node supports
-	///
-	/// Will receive the response via a ListProtocols event
-	pub fn list_protocols(&self, counterparty_node_id: PublicKey) {
-		self.lsps0_message_handler.list_protocols(counterparty_node_id)
-	}
-
-	/// Needs to be polled regularly to surface events generated by the various message handlers
-	pub fn get_and_clear_pending_events(&self) -> Vec<Event> {
-		self.pending_events.lock().unwrap().drain(..).collect()
-	}
-
 	fn handle_lsps_message(
 		&self, msg: LSPSMessage, sender_node_id: &PublicKey,
 	) -> Result<(), lightning::ln::msgs::LightningError> {

src/transport/message_handler.rs

@@ -5,7 +5,6 @@ use lightning::util::logger::Level;
 use std::ops::Deref;
 use std::sync::{Arc, Mutex};
 
-use crate::events::Event;
 use crate::transport::message_handler::ProtocolMessageHandler;
 use crate::transport::msgs::{
 	LSPS0Message, LSPS0Request, LSPS0Response, LSPSMessage, ListProtocolsRequest,
@@ -19,7 +18,6 @@ where
 {
 	entropy_source: ES,
 	pending_messages: Arc<Mutex<Vec<(PublicKey, LSPSMessage)>>>,
-	pending_events: Arc<Mutex<Vec<Event>>>,
 	protocols: Vec<u16>,
 }
 
@@ -30,9 +28,8 @@ where
 	pub fn new(
 		entropy_source: ES, protocols: Vec<u16>,
 		pending_messages: Arc<Mutex<Vec<(PublicKey, LSPSMessage)>>>,
-		pending_events: Arc<Mutex<Vec<Event>>>,
 	) -> Self {
-		Self { entropy_source, protocols, pending_messages, pending_events }
+		Self { entropy_source, protocols, pending_messages }
 	}
 
 	pub fn list_protocols(&self, counterparty_node_id: PublicKey) {
@@ -48,11 +45,6 @@ where
 		self.pending_messages.lock().unwrap().push((counterparty_node_id, message.into()));
 	}
 
-	fn enqueue_event(&self, event: Event) {
-		let mut pending_events = self.pending_events.lock().unwrap();
-		pending_events.push(event);
-	}
-
 	fn handle_request(
 		&self, request_id: RequestId, request: LSPS0Request, counterparty_node_id: &PublicKey,
 	) -> Result<(), lightning::ln::msgs::LightningError> {
@@ -74,13 +66,7 @@ where
 		&self, response: LSPS0Response, counterparty_node_id: &PublicKey,
 	) -> Result<(), LightningError> {
 		match response {
-			LSPS0Response::ListProtocols(ListProtocolsResponse { protocols }) => {
-				self.enqueue_event(Event::ListProtocols {
-					counterparty_node_id: *counterparty_node_id,
-					protocols,
-				});
-				Ok(())
-			}
+			LSPS0Response::ListProtocols(ListProtocolsResponse { protocols }) => Ok(()),
 			LSPS0Response::ListProtocolsError(ResponseError { code, message, data, .. }) => {
 				Err(LightningError {
 					err: format!(
@@ -134,14 +120,9 @@ mod tests {
 		let entropy = Arc::new(TestEntropy {});
 		let protocols: Vec<u16> = vec![];
 		let pending_messages = Arc::new(Mutex::new(vec![]));
-		let pending_events = Arc::new(Mutex::new(vec![]));
 
-		let lsps0_handler = Arc::new(LSPS0MessageHandler::new(
-			entropy,
-			protocols,
-			pending_messages.clone(),
-			pending_events,
-		));
+		let lsps0_handler =
+			Arc::new(LSPS0MessageHandler::new(entropy, protocols, pending_messages.clone()));
 
 		let list_protocols_request = LSPS0Message::Request(
 			RequestId("xyz123".to_string()),
@@ -172,13 +153,11 @@ mod tests {
 	#[test]
 	fn test_list_protocols() {
 		let pending_messages = Arc::new(Mutex::new(vec![]));
-		let pending_events = Arc::new(Mutex::new(vec![]));
 
 		let lsps0_handler = Arc::new(LSPS0MessageHandler::new(
 			Arc::new(TestEntropy {}),
 			vec![1, 2, 3],
 			pending_messages.clone(),
-			pending_events,
 		));
 
 		let counterparty_node_id = utils::parse_pubkey(
@@ -202,36 +181,4 @@ mod tests {
 			))
 		);
 	}
-
-	#[test]
-	fn test_handle_list_protocols_response() {
-		let pending_messages = Arc::new(Mutex::new(vec![]));
-		let pending_events = Arc::new(Mutex::new(vec![]));
-		let protocols = vec![1, 2, 3];
-
-		let lsps0_handler = Arc::new(LSPS0MessageHandler::new(
-			Arc::new(TestEntropy {}),
-			protocols,
-			pending_messages,
-			pending_events.clone(),
-		));
-
-		let list_protocols_response = LSPS0Message::Response(
-			RequestId("00000000000000000000000000000000".to_string()),
-			LSPS0Response::ListProtocols(ListProtocolsResponse { protocols: vec![1, 2, 3] }),
-		);
-		let counterparty_node_id = utils::parse_pubkey(
-			"027100442c3b79f606f80f322d98d499eefcb060599efc5d4ecb00209c2cb54190",
-		)
-		.unwrap();
-
-		lsps0_handler.handle_message(list_protocols_response, &counterparty_node_id).unwrap();
-		let pending_events = pending_events.lock().unwrap();
-
-		assert_eq!(pending_events.len(), 1);
-		assert_eq!(
-			pending_events[0],
-			Event::ListProtocols { counterparty_node_id, protocols: vec![1, 2, 3] }
-		);
-	}
 }