Merge pull request lightningdevkit#3583 from tnull/2025-01-rename-all-liquidity-types

Rename most `lightning-liquidity` types for bindings compatibility

Author: tnull

ci/ci-tests.sh

@@ -132,3 +132,5 @@ RUSTFLAGS="--cfg=taproot" cargo test --verbose --color always -p lightning
 RUSTFLAGS="--cfg=splicing" cargo test --verbose --color always -p lightning
 [ "$CI_MINIMIZE_DISK_USAGE" != "" ] && cargo clean
 RUSTFLAGS="--cfg=async_payments" cargo test --verbose --color always -p lightning
+[ "$CI_MINIMIZE_DISK_USAGE" != "" ] && cargo clean
+RUSTFLAGS="--cfg=lsps1_service" cargo test --verbose --color always -p lightning-liquidity

lightning-liquidity/src/events.rs

@@ -28,7 +28,7 @@ use core::task::{Poll, Waker};
 pub const MAX_EVENT_QUEUE_SIZE: usize = 1000;
 
 pub(crate) struct EventQueue {
-	queue: Arc<Mutex<VecDeque<Event>>>,
+	queue: Arc<Mutex<VecDeque<LiquidityEvent>>>,
 	waker: Arc<Mutex<Option<Waker>>>,
 	#[cfg(feature = "std")]
 	condvar: crate::sync::Condvar,
@@ -47,11 +47,11 @@ impl EventQueue {
 		Self { queue, waker }
 	}
 
-	pub fn enqueue(&self, event: Event) {
+	pub fn enqueue<E: Into<LiquidityEvent>>(&self, event: E) {
 		{
 			let mut queue = self.queue.lock().unwrap();
 			if queue.len() < MAX_EVENT_QUEUE_SIZE {
-				queue.push_back(event);
+				queue.push_back(event.into());
 			} else {
 				return;
 			}
@@ -64,19 +64,21 @@ impl EventQueue {
 		self.condvar.notify_one();
 	}
 
-	pub fn next_event(&self) -> Option<Event> {
+	pub fn next_event(&self) -> Option<LiquidityEvent> {
 		self.queue.lock().unwrap().pop_front()
 	}
 
-	pub async fn next_event_async(&self) -> Event {
+	pub async fn next_event_async(&self) -> LiquidityEvent {
 		EventFuture { event_queue: Arc::clone(&self.queue), waker: Arc::clone(&self.waker) }.await
 	}
 
 	#[cfg(feature = "std")]
-	pub fn wait_next_event(&self) -> Event {
+	pub fn wait_next_event(&self) -> LiquidityEvent {
 		let mut queue = self
 			.condvar
-			.wait_while(self.queue.lock().unwrap(), |queue: &mut VecDeque<Event>| queue.is_empty())
+			.wait_while(self.queue.lock().unwrap(), |queue: &mut VecDeque<LiquidityEvent>| {
+				queue.is_empty()
+			})
 			.unwrap();
 
 		let event = queue.pop_front().expect("non-empty queue");
@@ -95,14 +97,14 @@ impl EventQueue {
 		event
 	}
 
-	pub fn get_and_clear_pending_events(&self) -> Vec<Event> {
+	pub fn get_and_clear_pending_events(&self) -> Vec<LiquidityEvent> {
 		self.queue.lock().unwrap().split_off(0).into()
 	}
 }
 
 /// An event which you should probably take some action in response to.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Event {
+pub enum LiquidityEvent {
 	/// An LSPS0 client event.
 	LSPS0Client(lsps0::event::LSPS0ClientEvent),
 	/// An LSPS1 (Channel Request) client event.
@@ -116,13 +118,44 @@ pub enum Event {
 	LSPS2Service(lsps2::event::LSPS2ServiceEvent),
 }
 
+impl From<lsps0::event::LSPS0ClientEvent> for LiquidityEvent {
+	fn from(event: lsps0::event::LSPS0ClientEvent) -> Self {
+		Self::LSPS0Client(event)
+	}
+}
+
+impl From<lsps1::event::LSPS1ClientEvent> for LiquidityEvent {
+	fn from(event: lsps1::event::LSPS1ClientEvent) -> Self {
+		Self::LSPS1Client(event)
+	}
+}
+
+#[cfg(lsps1_service)]
+impl From<lsps1::event::LSPS1ServiceEvent> for LiquidityEvent {
+	fn from(event: lsps1::event::LSPS1ServiceEvent) -> Self {
+		Self::LSPS1Service(event)
+	}
+}
+
+impl From<lsps2::event::LSPS2ClientEvent> for LiquidityEvent {
+	fn from(event: lsps2::event::LSPS2ClientEvent) -> Self {
+		Self::LSPS2Client(event)
+	}
+}
+
+impl From<lsps2::event::LSPS2ServiceEvent> for LiquidityEvent {
+	fn from(event: lsps2::event::LSPS2ServiceEvent) -> Self {
+		Self::LSPS2Service(event)
+	}
+}
+
 struct EventFuture {
-	event_queue: Arc<Mutex<VecDeque<Event>>>,
+	event_queue: Arc<Mutex<VecDeque<LiquidityEvent>>>,
 	waker: Arc<Mutex<Option<Waker>>>,
 }
 
 impl Future for EventFuture {
-	type Output = Event;
+	type Output = LiquidityEvent;
 
 	fn poll(
 		self: core::pin::Pin<&mut Self>, cx: &mut core::task::Context<'_>,
@@ -154,7 +187,7 @@ mod tests {
 		let secp_ctx = Secp256k1::new();
 		let counterparty_node_id =
 			PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap());
-		let expected_event = Event::LSPS0Client(LSPS0ClientEvent::ListProtocolsResponse {
+		let expected_event = LiquidityEvent::LSPS0Client(LSPS0ClientEvent::ListProtocolsResponse {
 			counterparty_node_id,
 			protocols: Vec::new(),
 		});

lightning-liquidity/src/lsps0/client.rs

@@ -4,12 +4,13 @@
 //! specifcation](https://github.com/lightning/blips/blob/master/blip-0050.md) for more
 //! information.
 
-use crate::events::{Event, EventQueue};
+use crate::events::EventQueue;
 use crate::lsps0::event::LSPS0ClientEvent;
 use crate::lsps0::msgs::{
-	LSPS0Message, LSPS0Request, LSPS0Response, ListProtocolsRequest, ListProtocolsResponse,
+	LSPS0ListProtocolsRequest, LSPS0ListProtocolsResponse, LSPS0Message, LSPS0Request,
+	LSPS0Response,
 };
-use crate::lsps0::ser::{ProtocolMessageHandler, ResponseError};
+use crate::lsps0::ser::{LSPSProtocolMessageHandler, LSPSResponseError};
 use crate::message_queue::MessageQueue;
 use crate::sync::Arc;
 use crate::utils;
@@ -51,7 +52,7 @@ where
 	pub fn list_protocols(&self, counterparty_node_id: &PublicKey) {
 		let msg = LSPS0Message::Request(
 			utils::generate_request_id(&self.entropy_source),
-			LSPS0Request::ListProtocols(ListProtocolsRequest {}),
+			LSPS0Request::ListProtocols(LSPS0ListProtocolsRequest {}),
 		);
 
 		self.pending_messages.enqueue(counterparty_node_id, msg.into());
@@ -61,29 +62,27 @@ where
 		&self, response: LSPS0Response, counterparty_node_id: &PublicKey,
 	) -> Result<(), LightningError> {
 		match response {
-			LSPS0Response::ListProtocols(ListProtocolsResponse { protocols }) => {
-				self.pending_events.enqueue(Event::LSPS0Client(
-					LSPS0ClientEvent::ListProtocolsResponse {
-						counterparty_node_id: *counterparty_node_id,
-						protocols,
-					},
-				));
+			LSPS0Response::ListProtocols(LSPS0ListProtocolsResponse { protocols }) => {
+				self.pending_events.enqueue(LSPS0ClientEvent::ListProtocolsResponse {
+					counterparty_node_id: *counterparty_node_id,
+					protocols,
+				});
 				Ok(())
 			},
-			LSPS0Response::ListProtocolsError(ResponseError { code, message, data, .. }) => {
-				Err(LightningError {
-					err: format!(
-						"ListProtocols error received. code = {}, message = {}, data = {:?}",
-						code, message, data
-					),
-					action: ErrorAction::IgnoreAndLog(Level::Info),
-				})
-			},
+			LSPS0Response::ListProtocolsError(LSPSResponseError {
+				code, message, data, ..
+			}) => Err(LightningError {
+				err: format!(
+					"ListProtocols error received. code = {}, message = {}, data = {:?}",
+					code, message, data
+				),
+				action: ErrorAction::IgnoreAndLog(Level::Info),
+			}),
 		}
 	}
 }
 
-impl<ES: Deref> ProtocolMessageHandler for LSPS0ClientHandler<ES>
+impl<ES: Deref> LSPSProtocolMessageHandler for LSPS0ClientHandler<ES>
 where
 	ES::Target: EntropySource,
 {
@@ -114,7 +113,7 @@ mod tests {
 	use alloc::string::ToString;
 	use alloc::sync::Arc;
 
-	use crate::lsps0::ser::{LSPSMessage, RequestId};
+	use crate::lsps0::ser::{LSPSMessage, LSPSRequestId};
 	use crate::tests::utils::{self, TestEntropy};
 
 	use super::*;
@@ -147,8 +146,8 @@ mod tests {
 		assert_eq!(
 			*message,
 			LSPSMessage::LSPS0(LSPS0Message::Request(
-				RequestId("00000000000000000000000000000000".to_string()),
-				LSPS0Request::ListProtocols(ListProtocolsRequest {})
+				LSPSRequestId("00000000000000000000000000000000".to_string()),
+				LSPS0Request::ListProtocols(LSPS0ListProtocolsRequest {})
 			))
 		);
 	}

lightning-liquidity/src/lsps0/msgs.rs

@@ -1,6 +1,6 @@
 //! Message, request, and other primitive types used to implement LSPS0.
 
-use crate::lsps0::ser::{LSPSMessage, RequestId, ResponseError};
+use crate::lsps0::ser::{LSPSMessage, LSPSRequestId, LSPSResponseError};
 use crate::prelude::Vec;
 
 use serde::{Deserialize, Serialize};
@@ -15,15 +15,15 @@ pub(crate) const LSPS0_LISTPROTOCOLS_METHOD_NAME: &str = "lsps0.list_protocols";
 /// specification](https://github.com/lightning/blips/blob/master/blip-0050.md#lsps-specification-support-query)
 /// for more information.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize, Default)]
-pub struct ListProtocolsRequest {}
+pub struct LSPS0ListProtocolsRequest {}
 
 /// A response to a `list_protocols` request.
 ///
 /// Please refer to the [bLIP-50 / LSPS0
 /// specification](https://github.com/lightning/blips/blob/master/blip-0050.md#lsps-specification-support-query)
 /// for more information.
 #[derive(Clone, Debug, PartialEq, Eq, Deserialize, Serialize)]
-pub struct ListProtocolsResponse {
+pub struct LSPS0ListProtocolsResponse {
 	/// A list of supported protocols.
 	pub protocols: Vec<u16>,
 }
@@ -36,12 +36,12 @@ pub struct ListProtocolsResponse {
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum LSPS0Request {
 	/// A request calling `list_protocols`.
-	ListProtocols(ListProtocolsRequest),
+	ListProtocols(LSPS0ListProtocolsRequest),
 }
 
 impl LSPS0Request {
 	/// Returns the method name associated with the given request variant.
-	pub fn method(&self) -> &str {
+	pub fn method(&self) -> &'static str {
 		match self {
 			LSPS0Request::ListProtocols(_) => LSPS0_LISTPROTOCOLS_METHOD_NAME,
 		}
@@ -56,9 +56,9 @@ impl LSPS0Request {
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum LSPS0Response {
 	/// A response to a `list_protocols` request.
-	ListProtocols(ListProtocolsResponse),
+	ListProtocols(LSPS0ListProtocolsResponse),
 	/// An error response to a `list_protocols` request.
-	ListProtocolsError(ResponseError),
+	ListProtocolsError(LSPSResponseError),
 }
 
 /// An bLIP-50 / LSPS0 protocol message.
@@ -69,9 +69,9 @@ pub enum LSPS0Response {
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum LSPS0Message {
 	/// A request variant.
-	Request(RequestId, LSPS0Request),
+	Request(LSPSRequestId, LSPS0Request),
 	/// A response variant.
-	Response(RequestId, LSPS0Response),
+	Response(LSPSRequestId, LSPS0Response),
 }
 
 impl TryFrom<LSPSMessage> for LSPS0Message {
@@ -117,17 +117,17 @@ mod tests {
 		assert_eq!(
 			msg,
 			LSPSMessage::LSPS0(LSPS0Message::Request(
-				RequestId("request:id:xyz123".to_string()),
-				LSPS0Request::ListProtocols(ListProtocolsRequest {})
+				LSPSRequestId("request:id:xyz123".to_string()),
+				LSPS0Request::ListProtocols(LSPS0ListProtocolsRequest {})
 			))
 		);
 	}
 
 	#[test]
 	fn serializes_request() {
 		let request = LSPSMessage::LSPS0(LSPS0Message::Request(
-			RequestId("request:id:xyz123".to_string()),
-			LSPS0Request::ListProtocols(ListProtocolsRequest {}),
+			LSPSRequestId("request:id:xyz123".to_string()),
+			LSPS0Request::ListProtocols(LSPS0ListProtocolsRequest {}),
 		));
 		let json = serde_json::to_string(&request).unwrap();
 		assert_eq!(
@@ -147,16 +147,18 @@ mod tests {
 	    }"#;
 		let mut request_id_to_method_map = new_hash_map();
 		request_id_to_method_map
-			.insert(RequestId("request:id:xyz123".to_string()), LSPSMethod::LSPS0ListProtocols);
+			.insert(LSPSRequestId("request:id:xyz123".to_string()), LSPSMethod::LSPS0ListProtocols);
 
 		let response =
 			LSPSMessage::from_str_with_id_map(json, &mut request_id_to_method_map).unwrap();
 
 		assert_eq!(
 			response,
 			LSPSMessage::LSPS0(LSPS0Message::Response(
-				RequestId("request:id:xyz123".to_string()),
-				LSPS0Response::ListProtocols(ListProtocolsResponse { protocols: vec![1, 2, 3] })
+				LSPSRequestId("request:id:xyz123".to_string()),
+				LSPS0Response::ListProtocols(LSPS0ListProtocolsResponse {
+					protocols: vec![1, 2, 3]
+				})
 			))
 		);
 	}
@@ -173,16 +175,16 @@ mod tests {
 	    }"#;
 		let mut request_id_to_method_map = new_hash_map();
 		request_id_to_method_map
-			.insert(RequestId("request:id:xyz123".to_string()), LSPSMethod::LSPS0ListProtocols);
+			.insert(LSPSRequestId("request:id:xyz123".to_string()), LSPSMethod::LSPS0ListProtocols);
 
 		let response =
 			LSPSMessage::from_str_with_id_map(json, &mut request_id_to_method_map).unwrap();
 
 		assert_eq!(
 			response,
 			LSPSMessage::LSPS0(LSPS0Message::Response(
-				RequestId("request:id:xyz123".to_string()),
-				LSPS0Response::ListProtocolsError(ResponseError {
+				LSPSRequestId("request:id:xyz123".to_string()),
+				LSPS0Response::ListProtocolsError(LSPSResponseError {
 					code: -32617,
 					message: "Unknown Error".to_string(),
 					data: None
@@ -202,7 +204,7 @@ mod tests {
 	    }"#;
 		let mut request_id_to_method_map = new_hash_map();
 		request_id_to_method_map
-			.insert(RequestId("request:id:xyz123".to_string()), LSPSMethod::LSPS0ListProtocols);
+			.insert(LSPSRequestId("request:id:xyz123".to_string()), LSPSMethod::LSPS0ListProtocols);
 
 		let response = LSPSMessage::from_str_with_id_map(json, &mut request_id_to_method_map);
 		assert!(response.is_err());
@@ -211,8 +213,8 @@ mod tests {
 	#[test]
 	fn serializes_response() {
 		let response = LSPSMessage::LSPS0(LSPS0Message::Response(
-			RequestId("request:id:xyz123".to_string()),
-			LSPS0Response::ListProtocols(ListProtocolsResponse { protocols: vec![1, 2, 3] }),
+			LSPSRequestId("request:id:xyz123".to_string()),
+			LSPS0Response::ListProtocols(LSPS0ListProtocolsResponse { protocols: vec![1, 2, 3] }),
 		));
 		let json = serde_json::to_string(&response).unwrap();
 		assert_eq!(