lsps2: Track channel creation time via created_at field

Add a `created_at: LSPSDateTime` field to `OutboundJITChannel` to
record when each JIT channel was created (i.e., when the buy request
was accepted by the LSP). This timestamp is needed to implement
time-based bulk pruning of completed channel state.

The field is persisted as TLV type 10 with a `default_value` of
Unix epoch, ensuring old serialized data (without TLV 10) is read
back successfully with the epoch sentinel rather than failing
deserialization.

Author: f3r10

lightning-liquidity/src/lsps2/service.rs

@@ -19,13 +19,15 @@ use core::ops::Deref;
 use core::pin::pin;
 use core::sync::atomic::{AtomicUsize, Ordering};
 use core::task;
+use core::time::Duration;
 
 use crate::events::EventQueue;
 use crate::lsps0::ser::{
-	LSPSMessage, LSPSProtocolMessageHandler, LSPSRequestId, LSPSResponseError,
+	LSPSDateTime, LSPSMessage, LSPSProtocolMessageHandler, LSPSRequestId, LSPSResponseError,
 	JSONRPC_INTERNAL_ERROR_ERROR_CODE, JSONRPC_INTERNAL_ERROR_ERROR_MESSAGE,
 	LSPS0_CLIENT_REJECTED_ERROR_CODE,
 };
+use crate::utils::time::TimeProvider;
 use crate::lsps2::event::LSPS2ServiceEvent;
 use crate::lsps2::payment_queue::{InterceptedHTLC, PaymentQueue};
 use crate::lsps2::utils::{
@@ -497,6 +499,8 @@ struct OutboundJITChannel {
 	opening_fee_params: LSPS2OpeningFeeParams,
 	payment_size_msat: Option<u64>,
 	trust_model: TrustModel,
+	/// The time at which the JIT channel was created (i.e., the buy request was accepted).
+	created_at: LSPSDateTime,
 }
 
 impl_writeable_tlv_based!(OutboundJITChannel, {
@@ -505,19 +509,21 @@ impl_writeable_tlv_based!(OutboundJITChannel, {
 	(4, opening_fee_params, required),
 	(6, payment_size_msat, option),
 	(8, trust_model, required),
+	(10, created_at, (default_value, LSPSDateTime::new_from_duration_since_epoch(Duration::ZERO))),
 });
 
 impl OutboundJITChannel {
 	fn new(
 		payment_size_msat: Option<u64>, opening_fee_params: LSPS2OpeningFeeParams,
-		user_channel_id: u128, client_trusts_lsp: bool,
+		user_channel_id: u128, client_trusts_lsp: bool, created_at: LSPSDateTime,
 	) -> Self {
 		Self {
 			user_channel_id,
 			state: OutboundJITChannelState::new(),
 			opening_fee_params,
 			payment_size_msat,
 			trust_model: TrustModel::new(client_trusts_lsp),
+			created_at,
 		}
 	}
 
@@ -702,9 +708,10 @@ macro_rules! get_or_insert_peer_state_entry {
 }
 
 /// The main object allowing to send and receive bLIP-52 / LSPS2 messages.
-pub struct LSPS2ServiceHandler<CM: Deref, K: KVStore + Clone, T: BroadcasterInterface>
+pub struct LSPS2ServiceHandler<CM: Deref, K: KVStore + Clone, T: BroadcasterInterface, TP: Deref + Clone>
 where
 	CM::Target: AChannelManager,
+	TP::Target: TimeProvider,
 {
 	channel_manager: CM,
 	kv_store: K,
@@ -717,17 +724,20 @@ where
 	total_pending_requests: AtomicUsize,
 	config: LSPS2ServiceConfig,
 	persistence_in_flight: AtomicUsize,
+	time_provider: TP,
 }
 
-impl<CM: Deref, K: KVStore + Clone, T: BroadcasterInterface + Clone> LSPS2ServiceHandler<CM, K, T>
+impl<CM: Deref, K: KVStore + Clone, T: BroadcasterInterface + Clone, TP: Deref + Clone>
+	LSPS2ServiceHandler<CM, K, T, TP>
 where
 	CM::Target: AChannelManager,
+	TP::Target: TimeProvider,
 {
 	/// Constructs a `LSPS2ServiceHandler`.
 	pub(crate) fn new(
 		per_peer_state: HashMap<PublicKey, Mutex<PeerState>>, pending_messages: Arc<MessageQueue>,
 		pending_events: Arc<EventQueue<K>>, channel_manager: CM, kv_store: K, tx_broadcaster: T,
-		config: LSPS2ServiceConfig,
+		config: LSPS2ServiceConfig, time_provider: TP,
 	) -> Result<Self, lightning::io::Error> {
 		let mut peer_by_intercept_scid = new_hash_map();
 		let mut peer_by_channel_id = new_hash_map();
@@ -768,6 +778,7 @@ where
 			kv_store,
 			tx_broadcaster,
 			config,
+			time_provider,
 		})
 	}
 
@@ -921,11 +932,15 @@ where
 							peer_by_intercept_scid.insert(intercept_scid, *counterparty_node_id);
 						}
 
+						let created_at = LSPSDateTime::new_from_duration_since_epoch(
+							self.time_provider.duration_since_epoch(),
+						);
 						let outbound_jit_channel = OutboundJITChannel::new(
 							buy_request.payment_size_msat,
 							buy_request.opening_fee_params,
 							user_channel_id,
 							client_trusts_lsp,
+							created_at,
 						);
 
 						peer_state_lock
@@ -2050,10 +2065,11 @@ where
 	}
 }
 
-impl<CM: Deref, K: KVStore + Clone, T: BroadcasterInterface + Clone> LSPSProtocolMessageHandler
-	for LSPS2ServiceHandler<CM, K, T>
+impl<CM: Deref, K: KVStore + Clone, T: BroadcasterInterface + Clone, TP: Deref + Clone>
+	LSPSProtocolMessageHandler for LSPS2ServiceHandler<CM, K, T, TP>
 where
 	CM::Target: AChannelManager,
+	TP::Target: TimeProvider,
 {
 	type ProtocolMessage = LSPS2Message;
 	const PROTOCOL_NUMBER: Option<u16> = Some(2);
@@ -2128,18 +2144,21 @@ pub struct LSPS2ServiceHandlerSync<
 	CM: Deref,
 	K: KVStore + Clone,
 	T: BroadcasterInterface + Clone,
+	TP: Deref + Clone,
 > where
 	CM::Target: AChannelManager,
+	TP::Target: TimeProvider,
 {
-	inner: &'a LSPS2ServiceHandler<CM, K, T>,
+	inner: &'a LSPS2ServiceHandler<CM, K, T, TP>,
 }
 
-impl<'a, CM: Deref, K: KVStore + Clone, T: BroadcasterInterface + Clone>
-	LSPS2ServiceHandlerSync<'a, CM, K, T>
+impl<'a, CM: Deref, K: KVStore + Clone, T: BroadcasterInterface + Clone, TP: Deref + Clone>
+	LSPS2ServiceHandlerSync<'a, CM, K, T, TP>
 where
 	CM::Target: AChannelManager,
+	TP::Target: TimeProvider,
 {
-	pub(crate) fn from_inner(inner: &'a LSPS2ServiceHandler<CM, K, T>) -> Self {
+	pub(crate) fn from_inner(inner: &'a LSPS2ServiceHandler<CM, K, T, TP>) -> Self {
 		Self { inner }
 	}
 
@@ -2785,6 +2804,7 @@ mod tests {
 			opening_fee_params.clone(),
 			user_channel_id,
 			true,
+			LSPSDateTime::from_str("2024-01-01T00:00:00Z").unwrap(),
 		);
 
 		let opening_payment_hash = PaymentHash([42; 32]);
@@ -2864,4 +2884,47 @@ mod tests {
 			"Broadcast was not allowed even though all the skimmed fees were collected"
 		);
 	}
+
+	#[test]
+	fn test_outbound_jit_channel_created_at_stored() {
+		let opening_fee_params = LSPS2OpeningFeeParams {
+			min_fee_msat: 1_000,
+			proportional: 0,
+			valid_until: LSPSDateTime::from_str("2035-05-20T08:30:45Z").unwrap(),
+			min_lifetime: 144,
+			max_client_to_self_delay: 128,
+			min_payment_size_msat: 1,
+			max_payment_size_msat: 10_000_000_000,
+			promise: "ignore".to_string(),
+		};
+		let created_at = LSPSDateTime::from_str("2024-06-15T12:00:00Z").unwrap();
+		let channel =
+			OutboundJITChannel::new(Some(1_000_000), opening_fee_params, 1u128, true, created_at);
+		assert_eq!(channel.created_at, created_at);
+	}
+
+	#[test]
+	fn test_outbound_jit_channel_created_at_round_trips() {
+		use lightning::util::ser::{Readable, Writeable};
+
+		let opening_fee_params = LSPS2OpeningFeeParams {
+			min_fee_msat: 1_000,
+			proportional: 0,
+			valid_until: LSPSDateTime::from_str("2035-05-20T08:30:45Z").unwrap(),
+			min_lifetime: 144,
+			max_client_to_self_delay: 128,
+			min_payment_size_msat: 1,
+			max_payment_size_msat: 10_000_000_000,
+			promise: "ignore".to_string(),
+		};
+		let created_at = LSPSDateTime::from_str("2024-06-15T12:00:00Z").unwrap();
+		let channel =
+			OutboundJITChannel::new(Some(1_000_000), opening_fee_params, 1u128, true, created_at);
+
+		let mut buf = Vec::new();
+		channel.write(&mut buf).unwrap();
+
+		let decoded = <OutboundJITChannel as Readable>::read(&mut &buf[..]).unwrap();
+		assert_eq!(decoded.created_at, created_at);
+	}
 }

lightning-liquidity/src/manager.rs

@@ -283,7 +283,7 @@ pub struct LiquidityManager<
 	lsps0_service_handler: Option<LSPS0ServiceHandler>,
 	lsps1_service_handler: Option<LSPS1ServiceHandler<ES, CM, K, TP>>,
 	lsps1_client_handler: Option<LSPS1ClientHandler<ES, K>>,
-	lsps2_service_handler: Option<LSPS2ServiceHandler<CM, K, T>>,
+	lsps2_service_handler: Option<LSPS2ServiceHandler<CM, K, T, TP>>,
 	lsps2_client_handler: Option<LSPS2ClientHandler<ES, K>>,
 	lsps5_service_handler: Option<LSPS5ServiceHandler<CM, NS, K, TP>>,
 	lsps5_client_handler: Option<LSPS5ClientHandler<ES, K>>,
@@ -377,7 +377,7 @@ where
 		let lsps2_service_handler = if let Some(service_config) = service_config.as_ref() {
 			if let Some(lsps2_service_config) = service_config.lsps2_service_config.as_ref() {
 				if let Some(number) =
-					<LSPS2ServiceHandler<CM, K, T> as LSPSProtocolMessageHandler>::PROTOCOL_NUMBER
+					<LSPS2ServiceHandler<CM, K, T, TP> as LSPSProtocolMessageHandler>::PROTOCOL_NUMBER
 				{
 					supported_protocols.push(number);
 				}
@@ -391,6 +391,7 @@ where
 					kv_store.clone(),
 					transaction_broadcaster.clone(),
 					lsps2_service_config.clone(),
+					time_provider.clone(),
 				)?)
 			} else {
 				None
@@ -540,7 +541,7 @@ where
 	/// Returns a reference to the LSPS2 server-side handler.
 	///
 	/// The returned hendler allows to initiate the LSPS2 service-side flow.
-	pub fn lsps2_service_handler(&self) -> Option<&LSPS2ServiceHandler<CM, K, T>> {
+	pub fn lsps2_service_handler(&self) -> Option<&LSPS2ServiceHandler<CM, K, T, TP>> {
 		self.lsps2_service_handler.as_ref()
 	}
 
@@ -1053,7 +1054,7 @@ where
 	/// Wraps [`LiquidityManager::lsps2_service_handler`].
 	pub fn lsps2_service_handler<'a>(
 		&'a self,
-	) -> Option<LSPS2ServiceHandlerSync<'a, CM, KVStoreSyncWrapper<KS>, T>> {
+	) -> Option<LSPS2ServiceHandlerSync<'a, CM, KVStoreSyncWrapper<KS>, T, TP>> {
 		self.inner.lsps2_service_handler.as_ref().map(|r| LSPS2ServiceHandlerSync::from_inner(r))
 	}