Add tests for LSPS5 client and service.

Author: martinsaposnic

lightning-background-processor/Cargo.toml

@@ -14,9 +14,10 @@ all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
+default = ["std", "time"]
 std = ["lightning/std", "lightning-liquidity/std", "bitcoin-io/std", "bitcoin_hashes/std"]
+time = ["std", "lightning-liquidity/time"]
 
-default = ["std"]
 
 [dependencies]
 bitcoin = { version = "0.32.2", default-features = false }

lightning-background-processor/src/lib.rs

@@ -650,6 +650,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) {}
@@ -661,6 +662,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(()) }
@@ -676,7 +687,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, F, Store>;
 /// #
@@ -1153,7 +1164,7 @@ impl Drop for BackgroundProcessor {
 	}
 }
 
-#[cfg(all(feature = "std", test))]
+#[cfg(all(feature = "std", feature = "time", test))]
 mod tests {
 	use super::{BackgroundProcessor, GossipSync, FRESHNESS_TIMER};
 	use bitcoin::constants::{genesis_block, ChainHash};
@@ -1198,7 +1209,8 @@ mod tests {
 	use lightning::util::sweep::{OutputSpendStatus, OutputSweeperSync, PRUNE_DELAY_BLOCKS};
 	use lightning::util::test_utils;
 	use lightning::{get_event, get_event_msg};
-	use lightning_liquidity::lsps5::service::TimeProvider;
+	#[cfg(feature = "time")]
+	use lightning_liquidity::lsps5::service::DefaultTimeProvider;
 	use lightning_liquidity::LiquidityManager;
 	use lightning_persister::fs_store::FilesystemStore;
 	use lightning_rapid_gossip_sync::RapidGossipSync;
@@ -1642,16 +1654,6 @@ mod tests {
 		path.to_str().unwrap().to_string()
 	}
 
-	pub struct DefaultTimeProvider;
-
-	#[cfg(feature = "std")]
-	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")
-		}
-	}
-
 	fn create_nodes(num_nodes: usize, persist_dir: &str) -> (String, Vec<Node>) {
 		let persist_temp_path = env::temp_dir().join(persist_dir);
 		let persist_dir = persist_temp_path.to_string_lossy().to_string();
@@ -1753,16 +1755,14 @@ mod tests {
 				Arc::clone(&logger),
 				Arc::clone(&keys_manager),
 			));
-			let time_provider = Arc::new(DefaultTimeProvider);
-			let liquidity_manager = Arc::new(LiquidityManager::new_with_custom_time_provider(
+			let liquidity_manager = Arc::new(LiquidityManager::new(
 				Arc::clone(&keys_manager),
 				Arc::clone(&keys_manager),
 				Arc::clone(&manager),
 				None,
 				None,
 				None,
 				None,
-				time_provider,
 			));
 			let node = Node {
 				node: manager,

lightning-liquidity/tests/common/mod.rs

@@ -2,6 +2,7 @@
 
 use bitcoin::Network;
 use lightning::ln::channelmanager::ChainParameters;
+use lightning_liquidity::lsps5::service::TimeProvider;
 use lightning_liquidity::{LiquidityClientConfig, LiquidityManager, LiquidityServiceConfig};
 
 use lightning::chain::{BestBlock, Filter};
@@ -19,28 +20,32 @@ pub(crate) struct LSPSNodes<'a, 'b, 'c> {
 
 pub(crate) fn create_service_and_client_nodes<'a, 'b, 'c>(
 	nodes: Vec<Node<'a, 'b, 'c>>, service_config: LiquidityServiceConfig,
-	client_config: LiquidityClientConfig,
+	client_config: LiquidityClientConfig, time_provider: Arc<dyn TimeProvider + Send + Sync>,
 ) -> LSPSNodes<'a, 'b, 'c> {
 	let chain_params = ChainParameters {
 		network: Network::Testnet,
 		best_block: BestBlock::from_network(Network::Testnet),
 	};
-	let service_lm = LiquidityManager::new(
+	let service_lm = LiquidityManager::new_with_custom_time_provider(
+		nodes[0].keys_manager,
 		nodes[0].keys_manager,
 		nodes[0].node,
 		None::<Arc<dyn Filter + Send + Sync>>,
 		Some(chain_params.clone()),
 		Some(service_config),
 		None,
+		Arc::clone(&time_provider),
 	);
 
-	let client_lm = LiquidityManager::new(
+	let client_lm = LiquidityManager::new_with_custom_time_provider(
+		nodes[1].keys_manager,
 		nodes[1].keys_manager,
 		nodes[1].node,
 		None::<Arc<dyn Filter + Send + Sync>>,
 		Some(chain_params),
 		None,
 		Some(client_config),
+		time_provider,
 	);
 
 	let mut iter = nodes.into_iter();
@@ -53,19 +58,23 @@ pub(crate) fn create_service_and_client_nodes<'a, 'b, 'c>(
 pub(crate) struct LiquidityNode<'a, 'b, 'c> {
 	pub inner: Node<'a, 'b, 'c>,
 	pub liquidity_manager: LiquidityManager<
+		&'c TestKeysInterface,
 		&'c TestKeysInterface,
 		&'a TestChannelManager<'b, 'c>,
 		Arc<dyn Filter + Send + Sync>,
+		Arc<dyn TimeProvider + Send + Sync>,
 	>,
 }
 
 impl<'a, 'b, 'c> LiquidityNode<'a, 'b, 'c> {
 	pub fn new(
 		node: Node<'a, 'b, 'c>,
 		liquidity_manager: LiquidityManager<
+			&'c TestKeysInterface,
 			&'c TestKeysInterface,
 			&'a TestChannelManager<'b, 'c>,
 			Arc<dyn Filter + Send + Sync>,
+			Arc<dyn TimeProvider + Send + Sync>,
 		>,
 	) -> Self {
 		Self { inner: node, liquidity_manager }

lightning-liquidity/tests/lsps0_integration_tests.rs

@@ -1,4 +1,4 @@
-#![cfg(all(test, feature = "std"))]
+#![cfg(all(test, feature = "time"))]
 
 mod common;
 
@@ -12,13 +12,18 @@ use lightning_liquidity::lsps1::client::LSPS1ClientConfig;
 use lightning_liquidity::lsps1::service::LSPS1ServiceConfig;
 use lightning_liquidity::lsps2::client::LSPS2ClientConfig;
 use lightning_liquidity::lsps2::service::LSPS2ServiceConfig;
+use lightning_liquidity::lsps5::client::LSPS5ClientConfig;
+use lightning_liquidity::lsps5::service::{DefaultTimeProvider, LSPS5ServiceConfig};
 use lightning_liquidity::{LiquidityClientConfig, LiquidityServiceConfig};
 
 use lightning::ln::functional_test_utils::{
 	create_chanmon_cfgs, create_network, create_node_cfgs, create_node_chanmgrs,
 };
 use lightning::ln::peer_handler::CustomMessageHandler;
 
+use std::sync::Arc;
+use std::time::Duration;
+
 #[test]
 fn list_protocols_integration_test() {
 	let chanmon_cfgs = create_chanmon_cfgs(2);
@@ -30,29 +35,40 @@ fn list_protocols_integration_test() {
 	let lsps2_service_config = LSPS2ServiceConfig { promise_secret };
 	#[cfg(lsps1_service)]
 	let lsps1_service_config = LSPS1ServiceConfig { supported_options: None, token: None };
+	let lsps5_service_config = LSPS5ServiceConfig {
+		max_webhooks_per_client: 10,
+		notification_cooldown_hours: Duration::from_secs(3600),
+	};
 	let service_config = LiquidityServiceConfig {
 		#[cfg(lsps1_service)]
 		lsps1_service_config: Some(lsps1_service_config),
 		lsps2_service_config: Some(lsps2_service_config),
+		lsps5_service_config: Some(lsps5_service_config),
 		advertise_service: true,
 	};
 
 	let lsps2_client_config = LSPS2ClientConfig::default();
 	#[cfg(lsps1_service)]
 	let lsps1_client_config: LSPS1ClientConfig = LSPS1ClientConfig { max_channel_fees_msat: None };
+	let lsps5_client_config = LSPS5ClientConfig::default();
 	let client_config = LiquidityClientConfig {
 		#[cfg(lsps1_service)]
 		lsps1_client_config: Some(lsps1_client_config),
 		#[cfg(not(lsps1_service))]
 		lsps1_client_config: None,
 		lsps2_client_config: Some(lsps2_client_config),
+		lsps5_client_config: Some(lsps5_client_config),
 	};
 
 	let service_node_id = nodes[0].node.get_our_node_id();
 	let client_node_id = nodes[1].node.get_our_node_id();
 
-	let LSPSNodes { service_node, client_node } =
-		create_service_and_client_nodes(nodes, service_config, client_config);
+	let LSPSNodes { service_node, client_node } = create_service_and_client_nodes(
+		nodes,
+		service_config,
+		client_config,
+		Arc::new(DefaultTimeProvider),
+	);
 
 	let client_handler = client_node.liquidity_manager.lsps0_client_handler();
 
@@ -82,11 +98,12 @@ fn list_protocols_integration_test() {
 			{
 				assert!(protocols.contains(&1));
 				assert!(protocols.contains(&2));
-				assert_eq!(protocols.len(), 2);
+				assert!(protocols.contains(&5));
+				assert_eq!(protocols.len(), 3);
 			}
 
 			#[cfg(not(lsps1_service))]
-			assert_eq!(protocols, vec![2]);
+			assert_eq!(protocols, vec![2, 5]);
 		},
 		_ => panic!("Unexpected event"),
 	}

lightning-liquidity/tests/lsps2_integration_tests.rs

@@ -1,4 +1,4 @@
-#![cfg(all(test, feature = "std"))]
+#![cfg(all(test, feature = "std", feature = "time"))]
 
 mod common;
 
@@ -12,6 +12,7 @@ use lightning_liquidity::lsps2::event::LSPS2ServiceEvent;
 use lightning_liquidity::lsps2::msgs::LSPS2RawOpeningFeeParams;
 use lightning_liquidity::lsps2::service::LSPS2ServiceConfig;
 use lightning_liquidity::lsps2::utils::is_valid_opening_fee_params;
+use lightning_liquidity::lsps5::service::DefaultTimeProvider;
 use lightning_liquidity::{LiquidityClientConfig, LiquidityServiceConfig};
 
 use lightning::ln::channelmanager::{InterceptId, MIN_FINAL_CLTV_EXPIRY_DELTA};
@@ -35,6 +36,7 @@ use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
 use bitcoin::Network;
 
 use std::str::FromStr;
+use std::sync::Arc;
 use std::time::Duration;
 
 const MAX_PENDING_REQUESTS_PER_PEER: usize = 10;
@@ -49,15 +51,22 @@ fn setup_test_lsps2_nodes<'a, 'b, 'c>(
 		#[cfg(lsps1_service)]
 		lsps1_service_config: None,
 		lsps2_service_config: Some(lsps2_service_config),
+		lsps5_service_config: None,
 		advertise_service: true,
 	};
 
 	let lsps2_client_config = LSPS2ClientConfig::default();
 	let client_config = LiquidityClientConfig {
 		lsps1_client_config: None,
 		lsps2_client_config: Some(lsps2_client_config),
+		lsps5_client_config: None,
 	};
-	let lsps_nodes = create_service_and_client_nodes(nodes, service_config, client_config);
+	let lsps_nodes = create_service_and_client_nodes(
+		nodes,
+		service_config,
+		client_config,
+		Arc::new(DefaultTimeProvider),
+	);
 
 	(lsps_nodes, promise_secret)
 }