Add integration tests for error event handling

Add tests for the new error events:
- Test per-peer request limit rejection (GetInfoFailed)
- Test global request limit rejection (BuyRequestFailed)
- Test invalid token handling (GetInfoFailed)

These tests verify that error events are properly emitted when LSP
requests fail, ensuring the error handling behavior works end-to-end.

Author: martinsaposnic

lightning-liquidity/tests/common/mod.rs

@@ -67,7 +67,7 @@ type LockingWrapper<T> = lightning::routing::scoring::MultiThreadedLockableScore
 #[cfg(not(c_bindings))]
 type LockingWrapper<T> = std::sync::Mutex<T>;
 
-type ChannelManager = channelmanager::ChannelManager<
+pub(crate) type ChannelManager = channelmanager::ChannelManager<
 	Arc<ChainMonitor>,
 	Arc<test_utils::TestBroadcaster>,
 	Arc<KeysManager>,

lightning-liquidity/tests/lsps2_integration_tests.rs

@@ -2,32 +2,91 @@
 
 mod common;
 
-use common::{create_service_and_client_nodes, get_lsps_message, Node};
+use common::{create_service_and_client_nodes, ChannelManager};
+use common::{get_lsps_message, Node};
 
 use lightning_liquidity::events::LiquidityEvent;
 use lightning_liquidity::lsps0::ser::LSPSDateTime;
 use lightning_liquidity::lsps2::client::LSPS2ClientConfig;
-use lightning_liquidity::lsps2::event::{LSPS2ClientEvent, LSPS2ServiceEvent};
+use lightning_liquidity::lsps2::client::LSPS2ClientHandler;
+use lightning_liquidity::lsps2::event::LSPS2ClientEvent;
+use lightning_liquidity::lsps2::event::LSPS2ServiceEvent;
 use lightning_liquidity::lsps2::msgs::LSPS2RawOpeningFeeParams;
-use lightning_liquidity::lsps2::service::LSPS2ServiceConfig;
+use lightning_liquidity::lsps2::service::{LSPS2ServiceConfig, LSPS2ServiceHandler};
 use lightning_liquidity::lsps2::utils::is_valid_opening_fee_params;
-use lightning_liquidity::{LiquidityClientConfig, LiquidityServiceConfig};
 
 use lightning::ln::channelmanager::MIN_FINAL_CLTV_EXPIRY_DELTA;
 use lightning::ln::peer_handler::CustomMessageHandler;
 use lightning::log_error;
 use lightning::routing::router::{RouteHint, RouteHintHop};
+use lightning::sign::KeysManager;
 use lightning::util::logger::Logger;
 
 use lightning_invoice::{Bolt11Invoice, InvoiceBuilder, RoutingFees};
 
 use bitcoin::hashes::{sha256, Hash};
-use bitcoin::secp256k1::{PublicKey, Secp256k1};
+use bitcoin::secp256k1::{PublicKey, Secp256k1, SecretKey};
 use bitcoin::Network;
+use lightning_liquidity::LiquidityClientConfig;
+use lightning_liquidity::LiquidityServiceConfig;
 
 use std::str::FromStr;
+use std::sync::Arc;
 use std::time::Duration;
 
+const MAX_PENDING_REQUESTS_PER_PEER: usize = 10;
+const MAX_TOTAL_PENDING_REQUESTS: usize = 1000;
+
+fn setup_lsps2_test() -> (
+	&'static LSPS2ClientHandler<Arc<KeysManager>>,
+	&'static LSPS2ServiceHandler<Arc<ChannelManager>>,
+	bitcoin::secp256k1::PublicKey,
+	bitcoin::secp256k1::PublicKey,
+	&'static Node,
+	&'static Node,
+	[u8; 32],
+) {
+	let promise_secret = [42; 32];
+	let signing_key = SecretKey::from_slice(&promise_secret).unwrap();
+	let lsps2_service_config = LSPS2ServiceConfig { promise_secret };
+	let service_config = LiquidityServiceConfig {
+		#[cfg(lsps1_service)]
+		lsps1_service_config: None,
+		lsps2_service_config: Some(lsps2_service_config),
+		advertise_service: true,
+	};
+
+	let lsps2_client_config = LSPS2ClientConfig::default();
+	let client_config = LiquidityClientConfig {
+		lsps1_client_config: None,
+		lsps2_client_config: Some(lsps2_client_config),
+	};
+
+	let (service_node, client_node) =
+		create_service_and_client_nodes("default_persist_dir", service_config, client_config);
+
+	// Leak the nodes to extend their lifetime to 'static since this is test code
+	let service_node = Box::leak(Box::new(service_node));
+	let client_node = Box::leak(Box::new(client_node));
+
+	let client_handler = client_node.liquidity_manager.lsps2_client_handler().unwrap();
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
+
+	let secp = bitcoin::secp256k1::Secp256k1::new();
+	let service_node_id = bitcoin::secp256k1::PublicKey::from_secret_key(&secp, &signing_key);
+	let client_node_id = client_node.channel_manager.get_our_node_id();
+
+	(
+		client_handler,
+		service_handler,
+		service_node_id,
+		client_node_id,
+		service_node,
+		client_node,
+		promise_secret,
+	)
+}
+
 fn create_jit_invoice(
 	node: &Node, service_node_id: PublicKey, intercept_scid: u64, cltv_expiry_delta: u32,
 	payment_size_msat: Option<u64>, description: &str, expiry_secs: u32,
@@ -82,29 +141,15 @@ fn create_jit_invoice(
 
 #[test]
 fn invoice_generation_flow() {
-	let promise_secret = [42; 32];
-	let lsps2_service_config = LSPS2ServiceConfig { promise_secret };
-	let service_config = LiquidityServiceConfig {
-		#[cfg(lsps1_service)]
-		lsps1_service_config: None,
-		lsps2_service_config: Some(lsps2_service_config),
-		advertise_service: true,
-	};
-
-	let lsps2_client_config = LSPS2ClientConfig::default();
-	let client_config = LiquidityClientConfig {
-		lsps1_client_config: None,
-		lsps2_client_config: Some(lsps2_client_config),
-	};
-
-	let (service_node, client_node) =
-		create_service_and_client_nodes("invoice_generation_flow", service_config, client_config);
-
-	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
-	let service_node_id = service_node.channel_manager.get_our_node_id();
-
-	let client_handler = client_node.liquidity_manager.lsps2_client_handler().unwrap();
-	let client_node_id = client_node.channel_manager.get_our_node_id();
+	let (
+		client_handler,
+		service_handler,
+		service_node_id,
+		client_node_id,
+		service_node,
+		client_node,
+		promise_secret,
+	) = setup_lsps2_test();
 
 	let get_info_request_id = client_handler.request_opening_params(service_node_id, None);
 	let get_info_request = get_lsps_message!(client_node, service_node_id);
@@ -239,3 +284,249 @@ fn invoice_generation_flow() {
 	)
 	.unwrap();
 }
+
+#[test]
+fn max_pending_requests_per_peer_rejected() {
+	let (client_handler, _, service_node_id, client_node_id, service_node, client_node, _) =
+		setup_lsps2_test();
+
+	for _ in 0..MAX_PENDING_REQUESTS_PER_PEER {
+		let _ = client_handler.request_opening_params(service_node_id, None);
+		let req_msg = get_lsps_message!(client_node, service_node_id);
+		let result = service_node.liquidity_manager.handle_custom_message(req_msg, client_node_id);
+		assert!(result.is_ok());
+		let event = service_node.liquidity_manager.next_event().unwrap();
+		match event {
+			LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::GetInfo { .. }) => {},
+			_ => panic!("Unexpected event"),
+		}
+	}
+
+	// Test per-peer limit: the next request should be rejected
+	let rejected_req_id = client_handler.request_opening_params(service_node_id, None);
+	let rejected_req_msg = get_lsps_message!(client_node, service_node_id);
+
+	let result =
+		service_node.liquidity_manager.handle_custom_message(rejected_req_msg, client_node_id);
+	assert!(result.is_err(), "We should have hit the per-peer limit");
+
+	let get_info_error_response = get_lsps_message!(service_node, client_node_id);
+	let result = client_node
+		.liquidity_manager
+		.handle_custom_message(get_info_error_response, service_node_id);
+	assert!(result.is_err());
+
+	let event = client_node.liquidity_manager.next_event().unwrap();
+	match event {
+		LiquidityEvent::LSPS2Client(LSPS2ClientEvent::GetInfoFailed {
+			request_id,
+			counterparty_node_id,
+			error,
+		}) => {
+			assert_eq!(request_id, rejected_req_id);
+			assert_eq!(counterparty_node_id, service_node_id);
+			assert_eq!(error.code, 1); // LSPS0_CLIENT_REJECTED_ERROR_CODE
+		},
+		_ => panic!("Expected LSPS2ClientEvent::GetInfoFailed event"),
+	}
+}
+
+#[test]
+fn max_total_requests_buy_rejected() {
+	let (client_handler, service_handler, service_node_id, _, service_node, client_node, _) =
+		setup_lsps2_test();
+	let secp = Secp256k1::new();
+
+	let special_sk_bytes = [99u8; 32];
+	let special_sk = SecretKey::from_slice(&special_sk_bytes).unwrap();
+	let special_node_id = PublicKey::from_secret_key(&secp, &special_sk);
+
+	let _ = client_handler.request_opening_params(service_node_id, None);
+	let get_info_request = get_lsps_message!(client_node, service_node_id);
+	service_node
+		.liquidity_manager
+		.handle_custom_message(get_info_request, special_node_id)
+		.unwrap();
+
+	let get_info_event = service_node.liquidity_manager.next_event().unwrap();
+	match get_info_event {
+		LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::GetInfo { request_id, .. }) => {
+			let raw_opening_params = LSPS2RawOpeningFeeParams {
+				min_fee_msat: 100,
+				proportional: 21,
+				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: 100_000_000,
+			};
+
+			service_handler
+				.opening_fee_params_generated(
+					&special_node_id,
+					request_id,
+					vec![raw_opening_params],
+				)
+				.unwrap();
+		},
+		_ => panic!("Unexpected event"),
+	}
+
+	let get_info_response = get_lsps_message!(service_node, special_node_id);
+	client_node
+		.liquidity_manager
+		.handle_custom_message(get_info_response, service_node_id)
+		.unwrap();
+
+	let opening_params_event = client_node.liquidity_manager.next_event().unwrap();
+	let opening_fee_params = match opening_params_event {
+		LiquidityEvent::LSPS2Client(LSPS2ClientEvent::OpeningParametersReady {
+			opening_fee_params_menu,
+			..
+		}) => opening_fee_params_menu.first().unwrap().clone(),
+		_ => panic!("Unexpected event"),
+	};
+
+	// Now fill up the global limit with additional GetInfo requests from other peers
+	let mut filled = 0;
+	let mut peer_idx = 0;
+
+	while filled < MAX_TOTAL_PENDING_REQUESTS {
+		let sk_bytes = [peer_idx as u8 + 1; 32];
+		let sk = SecretKey::from_slice(&sk_bytes).unwrap();
+		let peer_node_id = PublicKey::from_secret_key(&secp, &sk);
+
+		// Skip if this is our special node
+		if peer_node_id == special_node_id {
+			peer_idx += 1;
+			continue;
+		}
+
+		for _ in 0..MAX_PENDING_REQUESTS_PER_PEER {
+			if filled >= MAX_TOTAL_PENDING_REQUESTS {
+				break;
+			}
+
+			let _ = client_handler.request_opening_params(service_node_id, None);
+			let req_msg = get_lsps_message!(client_node, service_node_id);
+			let result =
+				service_node.liquidity_manager.handle_custom_message(req_msg, peer_node_id);
+			assert!(result.is_ok());
+
+			let event = service_node.liquidity_manager.next_event().unwrap();
+			match event {
+				LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::GetInfo { .. }) => {},
+				_ => panic!("Unexpected event"),
+			}
+
+			filled += 1;
+		}
+		peer_idx += 1;
+	}
+
+	// Now try to send a Buy request with our special node, which should be rejected
+	let payment_size_msat = Some(1_000_000);
+	let buy_request_id = client_handler
+		.select_opening_params(service_node_id, payment_size_msat, opening_fee_params)
+		.unwrap();
+	let buy_request = get_lsps_message!(client_node, service_node_id);
+
+	let result = service_node.liquidity_manager.handle_custom_message(buy_request, special_node_id);
+	assert!(result.is_err(), "The Buy request should have been rejected");
+
+	let buy_error_response = get_lsps_message!(service_node, special_node_id);
+	let result =
+		client_node.liquidity_manager.handle_custom_message(buy_error_response, service_node_id);
+	assert!(result.is_err());
+
+	let event = client_node.liquidity_manager.next_event().unwrap();
+	match event {
+		LiquidityEvent::LSPS2Client(LSPS2ClientEvent::BuyRequestFailed {
+			request_id,
+			counterparty_node_id,
+			error,
+		}) => {
+			assert_eq!(request_id, buy_request_id);
+			assert_eq!(counterparty_node_id, service_node_id);
+			assert_eq!(error.code, 1); // LSPS0_CLIENT_REJECTED_ERROR_CODE
+		},
+		_ => panic!("Expected LSPS2ClientEvent::BuyRequestFailed event"),
+	}
+}
+
+#[test]
+fn invalid_token_flow() {
+	let (
+		client_handler,
+		service_handler,
+		service_node_id,
+		client_node_id,
+		service_node,
+		client_node,
+		_promise_secret,
+	) = setup_lsps2_test();
+
+	let token = Some("invalid_token".to_string());
+	let get_info_request_id = client_handler.request_opening_params(service_node_id, token);
+	let get_info_request = get_lsps_message!(client_node, service_node_id);
+
+	service_node.liquidity_manager.handle_custom_message(get_info_request, client_node_id).unwrap();
+
+	let get_info_event = service_node.liquidity_manager.next_event().unwrap();
+	match get_info_event {
+		LiquidityEvent::LSPS2Service(LSPS2ServiceEvent::GetInfo {
+			request_id,
+			counterparty_node_id,
+			token,
+		}) => {
+			assert_eq!(request_id, get_info_request_id);
+			assert_eq!(counterparty_node_id, client_node_id);
+			assert_eq!(token, Some("invalid_token".to_string()));
+
+			// Service rejects the token as invalid
+			service_handler.invalid_token_provided(&client_node_id, request_id.clone()).unwrap();
+
+			// Attempt to respond to the same request again which should fail
+			// because the request has been removed from pending_requests
+			let raw_opening_params = LSPS2RawOpeningFeeParams {
+				min_fee_msat: 100,
+				proportional: 21,
+				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: 100_000_000,
+			};
+
+			let result = service_handler.opening_fee_params_generated(
+				&client_node_id,
+				request_id.clone(),
+				vec![raw_opening_params],
+			);
+
+			assert!(result.is_err(), "Request should have been removed from pending_requests");
+		},
+		_ => panic!("Unexpected event"),
+	}
+
+	let get_info_error_response = get_lsps_message!(service_node, client_node_id);
+
+	client_node
+		.liquidity_manager
+		.handle_custom_message(get_info_error_response, service_node_id)
+		.unwrap_err();
+
+	let error_event = client_node.liquidity_manager.next_event().unwrap();
+	match error_event {
+		LiquidityEvent::LSPS2Client(LSPS2ClientEvent::GetInfoFailed {
+			request_id,
+			counterparty_node_id,
+			error,
+		}) => {
+			assert_eq!(request_id, get_info_request_id);
+			assert_eq!(counterparty_node_id, service_node_id);
+			assert_eq!(error.code, 200); // LSPS2_GET_INFO_REQUEST_UNRECOGNIZED_OR_STALE_TOKEN_ERROR_CODE
+		},
+		_ => panic!("Expected LSPS2ClientEvent::GetInfoFailed event"),
+	}
+}