WIP: checking CI

Author: martinsaposnic

lightning-background-processor/src/lib.rs

@@ -647,6 +647,7 @@ use futures_util::{dummy_waker, OptionalSelector, Selector, SelectorOutput};
 /// # use std::sync::atomic::{AtomicBool, Ordering};
 /// # use std::time::SystemTime;
 /// # use lightning_background_processor::{process_events_async, GossipSync};
+/// # use lightning_liquidity::lsps5::service::TimeProvider;
 /// # struct Logger {}
 /// # impl lightning::util::logger::Logger for Logger {
 /// #     fn log(&self, _record: lightning::util::logger::Record) {}
@@ -658,6 +659,16 @@ use futures_util::{dummy_waker, OptionalSelector, Selector, SelectorOutput};
 /// #     fn remove(&self, primary_namespace: &str, secondary_namespace: &str, key: &str, lazy: bool) -> io::Result<()> { Ok(()) }
 /// #     fn list(&self, primary_namespace: &str, secondary_namespace: &str) -> io::Result<Vec<String>> { Ok(Vec::new()) }
 /// # }
+/// 
+/// # use core::time::Duration;
+/// # struct DefaultTimeProvider;
+///
+/// # impl TimeProvider for DefaultTimeProvider {
+/// #    fn duration_since_epoch(&self) -> Duration {
+/// #        use std::time::{SystemTime, UNIX_EPOCH};
+/// #        SystemTime::now().duration_since(UNIX_EPOCH).expect("system time before Unix epoch")
+/// #    }
+/// # }
 /// # struct EventHandler {}
 /// # impl EventHandler {
 /// #     async fn handle_event(&self, _: lightning::events::Event) -> Result<(), ReplayEvent> { Ok(()) }
@@ -673,7 +684,7 @@ use futures_util::{dummy_waker, OptionalSelector, Selector, SelectorOutput};
 /// # type P2PGossipSync<UL> = lightning::routing::gossip::P2PGossipSync<Arc<NetworkGraph>, Arc<UL>, Arc<Logger>>;
 /// # type ChannelManager<B, F, FE> = lightning::ln::channelmanager::SimpleArcChannelManager<ChainMonitor<B, F, FE>, B, FE, Logger>;
 /// # type OnionMessenger<B, F, FE> = lightning::onion_message::messenger::OnionMessenger<Arc<lightning::sign::KeysManager>, Arc<lightning::sign::KeysManager>, Arc<Logger>, Arc<ChannelManager<B, F, FE>>, Arc<lightning::onion_message::messenger::DefaultMessageRouter<Arc<NetworkGraph>, Arc<Logger>, Arc<lightning::sign::KeysManager>>>, Arc<ChannelManager<B, F, FE>>, lightning::ln::peer_handler::IgnoringMessageHandler, lightning::ln::peer_handler::IgnoringMessageHandler, lightning::ln::peer_handler::IgnoringMessageHandler>;
-/// # type LiquidityManager<B, F, FE> = lightning_liquidity::LiquidityManager<Arc<lightning::sign::KeysManager>, Arc<ChannelManager<B, F, FE>>, Arc<F>>;
+/// # type LiquidityManager<B, F, FE> = lightning_liquidity::LiquidityManager<Arc<lightning::sign::KeysManager>, Arc<ChannelManager<B, F, FE>>, Arc<F>, Arc<DefaultTimeProvider>>;
 /// # type Scorer = RwLock<lightning::routing::scoring::ProbabilisticScorer<Arc<NetworkGraph>, Arc<Logger>>>;
 /// # type PeerManager<B, F, FE, UL> = lightning::ln::peer_handler::SimpleArcPeerManager<SocketDescriptor, ChainMonitor<B, F, FE>, B, FE, Arc<UL>, Logger>;
 /// #
@@ -1285,8 +1296,12 @@ mod tests {
 		IgnoringMessageHandler,
 	>;
 
-	type LM =
-		LiquidityManager<Arc<KeysManager>, Arc<ChannelManager>, Arc<dyn Filter + Sync + Send>>;
+	type LM = LiquidityManager<
+		Arc<KeysManager>,
+		Arc<ChannelManager>,
+		Arc<dyn Filter + Sync + Send>,
+		Arc<DefaultTimeProvider>,
+	>;
 
 	struct Node {
 		node: Arc<ChannelManager>,

lightning-liquidity/src/lsps0/ser.rs

@@ -35,7 +35,7 @@ use lightning::util::ser::{LengthLimitedRead, LengthReadable, WithoutLength};
 use bitcoin::secp256k1::PublicKey;
 
 use core::time::Duration;
-#[cfg(feature = "std")]
+#[cfg(feature = "time")]
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use serde::de::{self, MapAccess, Visitor};
@@ -229,7 +229,7 @@ impl LSPSDateTime {
 	}
 
 	/// Returns if the given time is in the past.
-	#[cfg(feature = "std")]
+	#[cfg(feature = "time")]
 	pub fn is_past(&self) -> bool {
 		let now_seconds_since_epoch = SystemTime::now()
 			.duration_since(UNIX_EPOCH)

lightning-liquidity/src/lsps2/utils.rs

@@ -28,13 +28,13 @@ pub fn is_valid_opening_fee_params(
 }
 
 /// Determines if the given parameters are expired, or still valid.
-#[cfg_attr(not(feature = "std"), allow(unused_variables))]
+#[cfg_attr(not(feature = "time"), allow(unused_variables))]
 pub fn is_expired_opening_fee_params(fee_params: &LSPS2OpeningFeeParams) -> bool {
-	#[cfg(feature = "std")]
+	#[cfg(feature = "time")]
 	{
 		fee_params.valid_until.is_past()
 	}
-	#[cfg(not(feature = "std"))]
+	#[cfg(not(feature = "time"))]
 	{
 		// TODO: We need to find a way to check expiry times in no-std builds.
 		false

lightning-liquidity/src/lsps5/client.rs

@@ -83,18 +83,24 @@ impl Default for LSPS5ClientConfig {
 	}
 }
 
-struct PeerState {
+struct PeerState<TP: Deref>
+where
+	TP::Target: TimeProvider,
+{
 	pending_set_webhook_requests:
 		HashMap<LSPSRequestId, (LSPS5AppName, LSPS5WebhookUrl, LSPSDateTime)>,
 	pending_list_webhooks_requests: HashMap<LSPSRequestId, LSPSDateTime>,
 	pending_remove_webhook_requests: HashMap<LSPSRequestId, (LSPS5AppName, LSPSDateTime)>,
 	last_cleanup: Option<LSPSDateTime>,
 	max_age_secs: Duration,
-	time_provider: Arc<dyn TimeProvider>,
+	time_provider: TP,
 }
 
-impl PeerState {
-	fn new(max_age_secs: Duration, time_provider: Arc<dyn TimeProvider>) -> Self {
+impl<TP: Deref> PeerState<TP>
+where
+	TP::Target: TimeProvider,
+{
+	fn new(max_age_secs: Duration, time_provider: TP) -> Self {
 		Self {
 			pending_set_webhook_requests: new_hash_map(),
 			pending_list_webhooks_requests: new_hash_map(),
@@ -109,27 +115,29 @@ impl PeerState {
 		let now =
 			LSPSDateTime::new_from_duration_since_epoch(self.time_provider.duration_since_epoch());
 		// Only run cleanup once per minute to avoid excessive processing
-		let minute = 60;
+		const CLEANUP_INTERVAL: Duration = Duration::from_secs(60);
 		if let Some(last_cleanup) = &self.last_cleanup {
-			if now.abs_diff(last_cleanup.clone()) < minute {
+			let time_since_last_cleanup = Duration::from_secs(now.abs_diff(last_cleanup.clone()));
+			if time_since_last_cleanup < CLEANUP_INTERVAL {
 				return;
 			}
 		}
 
 		self.last_cleanup = Some(now.clone());
 
 		self.pending_set_webhook_requests.retain(|_, (_, _, timestamp)| {
-			timestamp.abs_diff(now.clone()) < self.max_age_secs.as_secs()
+			Duration::from_secs(timestamp.abs_diff(now.clone())) < self.max_age_secs
+		});
+		self.pending_list_webhooks_requests.retain(|_, timestamp| {
+			Duration::from_secs(timestamp.abs_diff(now.clone())) < self.max_age_secs
 		});
-		self.pending_list_webhooks_requests
-			.retain(|_, timestamp| timestamp.abs_diff(now.clone()) < self.max_age_secs.as_secs());
 		self.pending_remove_webhook_requests.retain(|_, (_, timestamp)| {
-			timestamp.abs_diff(now.clone()) < self.max_age_secs.as_secs()
+			Duration::from_secs(timestamp.abs_diff(now.clone())) < self.max_age_secs
 		});
 	}
 }
 
-/// Client‐side handler for the LSPS5 (bLIP-55) webhook registration protocol.
+/// Client-side handler for the LSPS5 (bLIP-55) webhook registration protocol.
 ///
 /// `LSPS5ClientHandler` is the primary interface for LSP clients
 /// to register, list, and remove webhook endpoints with an LSP, and to parse
@@ -146,27 +154,29 @@ impl PeerState {
 /// [`lsps5.set_webhook`]: super::msgs::LSPS5Request::SetWebhook
 /// [`lsps5.list_webhooks`]: super::msgs::LSPS5Request::ListWebhooks
 /// [`lsps5.remove_webhook`]: super::msgs::LSPS5Request::RemoveWebhook
-pub struct LSPS5ClientHandler<ES: Deref>
+pub struct LSPS5ClientHandler<ES: Deref, TP: Deref + Clone>
 where
 	ES::Target: EntropySource,
+	TP::Target: TimeProvider,
 {
 	pending_messages: Arc<MessageQueue>,
 	pending_events: Arc<EventQueue>,
 	entropy_source: ES,
-	per_peer_state: RwLock<HashMap<PublicKey, Mutex<PeerState>>>,
+	per_peer_state: RwLock<HashMap<PublicKey, Mutex<PeerState<TP>>>>,
 	config: LSPS5ClientConfig,
-	time_provider: Arc<dyn TimeProvider>,
+	time_provider: TP,
 	recent_signatures: Mutex<VecDeque<(String, LSPSDateTime)>>,
 }
 
-impl<ES: Deref> LSPS5ClientHandler<ES>
+impl<ES: Deref, TP: Deref + Clone> LSPS5ClientHandler<ES, TP>
 where
 	ES::Target: EntropySource,
+	TP::Target: TimeProvider,
 {
 	/// Constructs an `LSPS5ClientHandler`.
 	pub(crate) fn new(
 		entropy_source: ES, pending_messages: Arc<MessageQueue>, pending_events: Arc<EventQueue>,
-		config: LSPS5ClientConfig, time_provider: Arc<dyn TimeProvider>,
+		config: LSPS5ClientConfig, time_provider: TP,
 	) -> Self {
 		let max_signatures = config.signature_config.max_signatures.clone();
 		Self {
@@ -182,11 +192,11 @@ where
 
 	fn with_peer_state<F, R>(&self, counterparty_node_id: PublicKey, f: F) -> R
 	where
-		F: FnOnce(&mut PeerState) -> R,
+		F: FnOnce(&mut PeerState<TP>) -> R,
 	{
 		let mut outer_state_lock = self.per_peer_state.write().unwrap();
 		let inner_state_lock = outer_state_lock.entry(counterparty_node_id).or_insert(Mutex::new(
-			PeerState::new(self.config.response_max_age_secs, Arc::clone(&self.time_provider)),
+			PeerState::new(self.config.response_max_age_secs, self.time_provider.clone()),
 		));
 		let mut peer_state_lock = inner_state_lock.lock().unwrap();
 
@@ -347,7 +357,7 @@ where
 			action: ErrorAction::IgnoreAndLog(Level::Error),
 		});
 		let event_queue_notifier = self.pending_events.notifier();
-		let handle_response = |peer_state: &mut PeerState| {
+		let handle_response = |peer_state: &mut PeerState<TP>| {
 			if let Some((app_name, webhook_url, _)) =
 				peer_state.pending_set_webhook_requests.remove(&request_id)
 			{
@@ -449,13 +459,13 @@ where
 	fn verify_notification_signature(
 		&self, counterparty_node_id: PublicKey, signature_timestamp: &LSPSDateTime,
 		signature: &str, notification: &WebhookNotification,
-	) -> Result<bool, LSPS5ClientError> {
+	) -> Result<(), LSPS5ClientError> {
 		let now =
 			LSPSDateTime::new_from_duration_since_epoch(self.time_provider.duration_since_epoch());
 		let diff = signature_timestamp.abs_diff(now);
-		let ten_minutes = 600;
-		if diff > ten_minutes {
-			return Err(LSPS5ClientError::InvalidTimestamp(signature_timestamp.to_rfc3339()));
+		const MAX_TIMESTAMP_DRIFT_SECS: u64 = 600;
+		if diff > MAX_TIMESTAMP_DRIFT_SECS {
+			return Err(LSPS5ClientError::InvalidTimestamp);
 		}
 
 		let message = format!(
@@ -465,7 +475,7 @@ where
 		);
 
 		if message_signing::verify(message.as_bytes(), signature, &counterparty_node_id) {
-			Ok(true)
+			Ok(())
 		} else {
 			Err(LSPS5ClientError::InvalidSignature)
 		}
@@ -490,17 +500,10 @@ where
 
 		recent_signatures.push_back((signature, now.clone()));
 
-		let retention_duration = self.config.signature_config.retention_minutes * 60;
-		while let Some((_, time)) = recent_signatures.front() {
-			if now.abs_diff(time.clone()) > retention_duration.as_secs() {
-				recent_signatures.pop_front();
-			} else {
-				break;
-			}
-		}
-
-		while recent_signatures.len() > self.config.signature_config.max_signatures {
-			recent_signatures.pop_front();
+		let retention_secs = self.config.signature_config.retention_minutes.as_secs();
+		recent_signatures.retain(|(_, ts)| now.abs_diff(ts.clone()) <= retention_secs);
+		if recent_signatures.len() > self.config.signature_config.max_signatures {
+			recent_signatures.truncate(self.config.signature_config.max_signatures);
 		}
 	}
 
@@ -513,15 +516,15 @@ where
 	///    configured retention window.
 	/// 4. Reconstructs the exact string
 	///    `"LSPS5: DO NOT SIGN THIS MESSAGE MANUALLY: LSP: At {timestamp} I notify {body}"`
-	///    and verifies the zbase32 LN-style signature against the LSP’s node ID.
+	///    and verifies the zbase32 LN-style signature against the LSP's node ID.
 	///
 	/// # Parameters
-	/// - `counterparty_node_id`: the LSP’s public key, used to verify the signature.
+	/// - `counterparty_node_id`: the LSP's public key, used to verify the signature.
 	/// - `timestamp`: ISO8601 time when the LSP created the notification.
 	/// - `signature`: the zbase32-encoded LN signature over timestamp+body.
 	/// - `notification`: the [`WebhookNotification`] received from the LSP.
 	///
-	/// On success, emits [`LSPS5ClientEvent::WebhookNotificationReceived`].
+	/// On success, returns the received [`WebhookNotification`].
 	///
 	/// Failure reasons include:
 	/// - Timestamp too old (drift > 10 minutes)
@@ -532,42 +535,31 @@ where
 	/// event, before taking action on the notification. This guarantees that only authentic,
 	/// non-replayed notifications reach your application.
 	///
-	/// [`LSPS5ClientEvent::WebhookNotificationReceived`]: super::event::LSPS5ClientEvent::WebhookNotificationReceived
 	/// [`LSPS5ServiceEvent::SendWebhookNotification`]: super::event::LSPS5ServiceEvent::SendWebhookNotification
 	/// [`WebhookNotification`]: super::msgs::WebhookNotification
 	pub fn parse_webhook_notification(
 		&self, counterparty_node_id: PublicKey, timestamp: &LSPSDateTime, signature: &str,
 		notification: &WebhookNotification,
-	) -> Result<(), LSPS5ClientError> {
-		match self.verify_notification_signature(
+	) -> Result<WebhookNotification, LSPS5ClientError> {
+		self.verify_notification_signature(
 			counterparty_node_id,
 			timestamp,
 			signature,
 			&notification,
-		) {
-			Ok(signature_valid) => {
-				let event_queue_notifier = self.pending_events.notifier();
+		)?;
 
-				self.check_signature_exists(signature)?;
+		self.check_signature_exists(signature)?;
 
-				self.store_signature(signature.to_string());
+		self.store_signature(signature.to_string());
 
-				event_queue_notifier.enqueue(LSPS5ClientEvent::WebhookNotificationReceived {
-					counterparty_node_id,
-					notification: notification.clone(),
-					timestamp: timestamp.clone(),
-					signature_valid,
-				});
-				Ok(())
-			},
-			Err(e) => Err(e),
-		}
+		Ok(notification.clone())
 	}
 }
 
-impl<ES: Deref> LSPSProtocolMessageHandler for LSPS5ClientHandler<ES>
+impl<ES: Deref, TP: Deref + Clone> LSPSProtocolMessageHandler for LSPS5ClientHandler<ES, TP>
 where
 	ES::Target: EntropySource,
+	TP::Target: TimeProvider,
 {
 	type ProtocolMessage = LSPS5Message;
 	const PROTOCOL_NUMBER: Option<u16> = Some(5);
@@ -592,8 +584,10 @@ mod tests {
 	};
 	use bitcoin::{key::Secp256k1, secp256k1::SecretKey};
 
-	fn setup_test_client() -> (
-		LSPS5ClientHandler<Arc<TestEntropy>>,
+	fn setup_test_client(
+		time_provider: Arc<dyn TimeProvider>,
+	) -> (
+		LSPS5ClientHandler<Arc<TestEntropy>, Arc<dyn TimeProvider>>,
 		Arc<MessageQueue>,
 		Arc<EventQueue>,
 		PublicKey,
@@ -602,7 +596,6 @@ mod tests {
 		let test_entropy_source = Arc::new(TestEntropy {});
 		let message_queue = Arc::new(MessageQueue::new());
 		let event_queue = Arc::new(EventQueue::new());
-		let time_provider = Arc::new(DefaultTimeProvider);
 		let client = LSPS5ClientHandler::new(
 			test_entropy_source,
 			message_queue.clone(),
@@ -622,7 +615,7 @@ mod tests {
 
 	#[test]
 	fn test_per_peer_state_isolation() {
-		let (client, _, _, peer_1, peer_2) = setup_test_client();
+		let (client, _, _, peer_1, peer_2) = setup_test_client(Arc::new(DefaultTimeProvider));
 
 		let req_id_1 = client
 			.set_webhook(peer_1, "test-app-1".to_string(), "https://example.com/hook1".to_string())
@@ -644,7 +637,7 @@ mod tests {
 
 	#[test]
 	fn test_pending_request_tracking() {
-		let (client, _, _, peer, _) = setup_test_client();
+		let (client, _, _, peer, _) = setup_test_client(Arc::new(DefaultTimeProvider));
 		const APP_NAME: &str = "test-app";
 		const WEBHOOK_URL: &str = "https://example.com/hook";
 		let lsps5_app_name = LSPS5AppName::from_string(APP_NAME.to_string()).unwrap();
@@ -677,7 +670,7 @@ mod tests {
 
 	#[test]
 	fn test_handle_response_clears_pending_state() {
-		let (client, _, _, peer, _) = setup_test_client();
+		let (client, _, _, peer, _) = setup_test_client(Arc::new(DefaultTimeProvider));
 
 		let req_id = client
 			.set_webhook(peer, "test-app".to_string(), "https://example.com/hook".to_string())
@@ -707,7 +700,7 @@ mod tests {
 
 	#[test]
 	fn test_cleanup_expired_responses() {
-		let (client, _, _, _, _) = setup_test_client();
+		let (client, _, _, _, _) = setup_test_client(Arc::new(DefaultTimeProvider));
 		let time_provider = &client.time_provider;
 		const OLD_APP_NAME: &str = "test-app-old";
 		const NEW_APP_NAME: &str = "test-app-new";
@@ -764,7 +757,7 @@ mod tests {
 
 	#[test]
 	fn test_unknown_request_id_handling() {
-		let (client, _message_queue, _, peer, _) = setup_test_client();
+		let (client, _message_queue, _, peer, _) = setup_test_client(Arc::new(DefaultTimeProvider));
 
 		let _valid_req = client
 			.set_webhook(peer, "test-app".to_string(), "https://example.com/hook".to_string())