Fix CI problems

Author: martinsaposnic

lightning-liquidity/src/lsps5/client.rs

@@ -28,7 +28,7 @@ use core::ops::Deref;
 use crate::prelude::{new_hash_map, HashMap, String};
 
 use super::msgs::{Lsps5AppName, Lsps5WebhookUrl};
-use super::service::{DefaultTimeProvider, TimeProvider};
+use super::service::{from_rfc3339, DefaultTimeProvider, TimeProvider};
 use super::url_utils::Url;
 use core::time::Duration;
 use lightning::sign::EntropySource;
@@ -88,14 +88,15 @@ impl PeerState {
 		let now = time_provider.now();
 
 		// Only run cleanup once per minute to avoid excessive processing
-		if now.abs_diff(self.last_cleanup) < Duration::from_secs(60) {
+		if now.checked_sub(self.last_cleanup).unwrap() < Duration::from_secs(60) {
 			return;
 		}
 
 		self.last_cleanup = now.clone();
 
 		// Calculate the cutoff time for expired requests
-		let cutoff = now.abs_diff(Duration::from_secs(max_age_secs.try_into().unwrap()));
+		let cutoff =
+			now.checked_sub(Duration::from_secs(max_age_secs.try_into().unwrap())).unwrap();
 
 		// Remove expired set_webhook requests
 		self.pending_set_webhook_requests.retain(|_, (_, _, timestamp)| *timestamp > cutoff);
@@ -517,14 +518,19 @@ where
 	/// * On error: LightningError with error description
 	pub fn verify_notification_signature(
 		counterparty_node_id: PublicKey, timestamp: &str, signature: &str,
-		notification: &WebhookNotification, time_provider: Arc<dyn TimeProvider>,
+		notification: &WebhookNotification, time_provider: &Arc<dyn TimeProvider>,
 	) -> Result<bool, LightningError> {
 		// Check timestamp format
-		match time_provider.from_rfc3339(timestamp) {
+		match from_rfc3339(timestamp) {
 			Ok(timestamp_dt) => {
 				// Check timestamp is within 10 minutes of current time
 				let now = time_provider.now();
-				let diff = now.abs_diff(timestamp_dt);
+				let diff;
+				if now > timestamp_dt {
+					diff = now.checked_sub(timestamp_dt).unwrap();
+				} else {
+					diff = timestamp_dt.checked_sub(now).unwrap();
+				}
 				if diff > Duration::from_secs(600) {
 					// 10 minutes
 					return Err(LightningError {
@@ -587,7 +593,7 @@ where
 	/// * On error: LightningError with error description
 	pub fn parse_webhook_notification(
 		counterparty_node_id: PublicKey, timestamp: &str, signature: &str, notification_json: &str,
-		time_provider: Arc<dyn TimeProvider>,
+		time_provider: &Arc<dyn TimeProvider>,
 	) -> Result<WebhookNotification, LightningError> {
 		// Parse the notification JSON
 		let notification: WebhookNotification = match serde_json::from_str(notification_json) {
@@ -605,7 +611,7 @@ where
 			timestamp,
 			signature,
 			&notification,
-			time_provider,
+			&time_provider,
 		) {
 			Ok(_) => Ok(notification),
 			Err(e) => Err(e),
@@ -770,7 +776,7 @@ mod tests {
 	fn test_cleanup_expired_responses() {
 		// use DefaultTimeProvider
 		let (client, _, _, _, _) = setup_test_client();
-		let time_provider = client.time_provider;
+		let time_provider = &client.time_provider;
 		const OLD_APP_NAME: &str = "test-app-old";
 		const NEW_APP_NAME: &str = "test-app-new";
 		const WEBHOOK_URL: &str = "https://example.com/hook";
@@ -781,7 +787,7 @@ mod tests {
 		let now = time_provider.now();
 		// Create a mock PeerState with a very old cleanup time
 		let mut peer_state = PeerState::new();
-		peer_state.last_cleanup = now.abs_diff(Duration::from_secs(120));
+		peer_state.last_cleanup = now.checked_sub(Duration::from_secs(120)).unwrap();
 
 		// Add some test requests with different timestamps
 		let old_request_id = LSPSRequestId("test:request:old".to_string());
@@ -793,14 +799,18 @@ mod tests {
 			(
 				lsps5_old_app_name,
 				lsps5_webhook_url.clone(),
-				now.abs_diff(Duration::from_secs(7200)),
+				now.checked_sub(Duration::from_secs(7200)).unwrap(),
 			), // 2 hours old
 		);
 
 		// Add a recent request (should be kept)
 		peer_state.pending_set_webhook_requests.insert(
 			new_request_id.clone(),
-			(lsps5_new_app_name, lsps5_webhook_url, now.abs_diff(Duration::from_secs(600))), // 10 minutes old
+			(
+				lsps5_new_app_name,
+				lsps5_webhook_url,
+				now.checked_sub(Duration::from_secs(600)).unwrap(),
+			), // 10 minutes old
 		);
 
 		// Run cleanup with 30 minutes (1800 seconds) max age
@@ -811,7 +821,7 @@ mod tests {
 		assert!(peer_state.pending_set_webhook_requests.contains_key(&new_request_id));
 
 		// Verify last_cleanup was updated within the last 10 seconds
-		let cleanup_age = time_provider.clone().now().abs_diff(peer_state.last_cleanup);
+		let cleanup_age = time_provider.now().checked_sub(peer_state.last_cleanup).unwrap();
 		assert!(cleanup_age < Duration::from_secs(10));
 	}
 

lightning-liquidity/src/lsps5/service.rs

@@ -148,14 +148,11 @@ pub trait HttpClient: Send + Sync + 'static {
 pub trait TimeProvider: Send + Sync + 'static {
 	/// Get the current time as a duration since the Unix epoch
 	fn now(&self) -> Duration;
-	/// Convert an RFC3339 formatted string to a duration since the Unix epoch
-	fn from_rfc3339(&self, _rfc3339: &str) -> Result<Duration, String>;
-	/// Convert a duration since the Unix epoch to an RFC3339 formatted string
-	fn to_rfc3339(&self, duration: Duration) -> String;
 }
 
 /// Default time provider using the system clock
 #[derive(Clone, Debug)]
+#[cfg(feature = "std")]
 pub struct DefaultTimeProvider;
 
 #[cfg(feature = "std")]
@@ -166,19 +163,21 @@ impl TimeProvider for DefaultTimeProvider {
 			SystemTime::now().duration_since(UNIX_EPOCH).expect("system time before Unix epoch");
 		Duration::from_secs(now.as_secs())
 	}
+}
 
-	fn from_rfc3339(&self, s: &str) -> Result<Duration, String> {
-		use chrono::DateTime;
-		let dt = DateTime::parse_from_rfc3339(s).map_err(|e| e.to_string())?;
-		let now = dt.timestamp();
-		Ok(Duration::from_secs(now as u64))
-	}
+/// Convert an RFC3339 timestamp string to a Duration
+pub fn from_rfc3339(s: &str) -> Result<Duration, String> {
+	use chrono::DateTime;
+	let dt = DateTime::parse_from_rfc3339(s).map_err(|e| e.to_string())?;
+	let now = dt.timestamp();
+	Ok(Duration::from_secs(now as u64))
+}
 
-	fn to_rfc3339(&self, duration: Duration) -> String {
-		use chrono::DateTime;
-		(DateTime::from_timestamp(duration.as_secs() as i64, duration.subsec_nanos()).unwrap())
-			.to_rfc3339()
-	}
+/// Convert a Duration to an RFC3339 timestamp string
+pub fn to_rfc3339(duration: Duration) -> String {
+	use chrono::DateTime;
+	(DateTime::from_timestamp(duration.as_secs() as i64, duration.subsec_nanos()).unwrap())
+		.to_rfc3339()
 }
 
 /// Configuration for LSPS5 service
@@ -618,7 +617,7 @@ impl LSPS5ServiceHandler {
 		for (app_name, webhook) in client_webhooks.iter_mut() {
 			// Check if this notification type was recently sent (cooldown period)
 			if let Some(last_sent) = webhook.last_notification_sent.get(&method) {
-				let duration = now.clone().abs_diff(*last_sent);
+				let duration = now.checked_sub(*last_sent).unwrap();
 				// Skip if notification was sent less than cooldown_hours ago
 				// According to spec: "This timeout must be measurable in hours or days."
 				if duration.as_secs() < self.config.notification_cooldown_hours * 3600 {
@@ -650,7 +649,7 @@ impl LSPS5ServiceHandler {
 		notification: WebhookNotification, method: WebhookNotificationMethod,
 	) -> Result<(), LightningError> {
 		// Create timestamp in ISO8601 format using chrono
-		let timestamp = self.time_provider.to_rfc3339(self.time_provider.now());
+		let timestamp = to_rfc3339(self.time_provider.now());
 
 		// Serialize the notification
 		let notification_json =
@@ -770,7 +769,7 @@ impl LSPS5ServiceHandler {
 			if client_channel_counts.get(client_id).copied().unwrap_or(0) == 0 {
 				// Filter out webhooks that haven't been used in at least MIN_WEBHOOK_RETENTION_DAYS
 				client_webhooks.retain(|_, webhook| {
-					let duration = now.abs_diff(webhook.last_used);
+					let duration = now.checked_sub(webhook.last_used).unwrap();
 					if duration.as_secs() < (MIN_WEBHOOK_RETENTION_DAYS * 24 * 60 * 60).into() {
 						// Keep webhook - not stale yet
 						true

lightning-liquidity/tests/lsps5_integration_tests.rs

@@ -9,7 +9,9 @@ use lightning_liquidity::events::LiquidityEvent;
 use lightning_liquidity::lsps5::client::{LSPS5ClientConfig, LSPS5ClientHandler};
 use lightning_liquidity::lsps5::event::{LSPS5ClientEvent, LSPS5ServiceEvent};
 use lightning_liquidity::lsps5::msgs::{Lsps5AppName, Lsps5WebhookUrl, WebhookNotificationMethod};
-use lightning_liquidity::lsps5::service::{DefaultTimeProvider, HttpClient, LSPS5ServiceConfig};
+use lightning_liquidity::lsps5::service::{
+	DefaultTimeProvider, HttpClient, LSPS5ServiceConfig, TimeProvider,
+};
 use lightning_liquidity::{LiquidityClientConfig, LiquidityServiceConfig};
 
 use bitcoin::secp256k1::SecretKey;
@@ -524,7 +526,7 @@ fn webhook_error_handling_test() {
 fn webhook_notification_delivery_test() {
 	let mock_client = Arc::new(MockHttpClient::new(true));
 	let mock_client_for_verification = mock_client.clone();
-	let time_provider = Arc::new(DefaultTimeProvider);
+	let time_provider: Arc<(dyn TimeProvider + 'static)> = Arc::new(DefaultTimeProvider);
 
 	let signing_key = SecretKey::from_slice(&[42; 32]).unwrap();
 
@@ -627,7 +629,7 @@ fn webhook_notification_delivery_test() {
 		&timestamp_value,
 		&signature_value,
 		&first_call.2,
-		time_provider.clone(),
+		&time_provider,
 	);
 	assert!(
 		result.is_ok(),
@@ -667,13 +669,13 @@ fn webhook_notification_delivery_test() {
 		.find(|(name, _)| name == "x-lsps5-signature")
 		.map(|(_, value)| value.clone())
 		.expect("Signature header should be present");
-	let time_provider_cloned = time_provider.clone();
+
 	let result = LSPS5ClientHandler::<Arc<dyn EntropySource>>::parse_webhook_notification(
 		derived_pubkey,
 		&timestamp_header,
 		&signature_header,
 		&payment_call.2,
-		time_provider_cloned,
+		&time_provider,
 	);
 	assert!(
 		result.is_ok(),
@@ -874,14 +876,14 @@ fn multiple_webhooks_notification_test() {
 			.find(|(name, _)| name == "x-lsps5-signature")
 			.map(|(_, value)| value.clone())
 			.expect("Signature header should be present");
-		let time_provider = Arc::new(DefaultTimeProvider);
+		let time_provider: Arc<(dyn TimeProvider + 'static)> = Arc::new(DefaultTimeProvider);
 		// Verify the signature using the derived pubkey
 		let result = LSPS5ClientHandler::<Arc<dyn EntropySource>>::parse_webhook_notification(
 			derived_pubkey,
 			&timestamp_header,
 			&signature_header,
 			&call.2,
-			time_provider,
+			&time_provider,
 		);
 		assert!(result.is_ok(), "Signature verification should succeed for all notifications");
 	}
@@ -1176,14 +1178,14 @@ fn replay_prevention_test() {
 	// Extract the timestamp and signature
 	let (timestamp, signature) = extract_timestamp_and_signature(payment_call);
 	let body = payment_call.2.clone();
-	let time_provider = Arc::new(DefaultTimeProvider);
+	let time_provider: Arc<(dyn TimeProvider + 'static)> = Arc::new(DefaultTimeProvider);
 	// First verification should succeed
 	let result = LSPS5ClientHandler::<Arc<dyn EntropySource>>::parse_webhook_notification(
 		derived_pubkey,
 		&timestamp,
 		&signature,
 		&body,
-		time_provider.clone(),
+		&time_provider,
 	);
 	assert!(result.is_ok(), "First verification should succeed");
 
@@ -1193,7 +1195,7 @@ fn replay_prevention_test() {
 		&timestamp,
 		&signature,
 		&body,
-		time_provider,
+		&time_provider,
 	);
 
 	assert!(