fixup: add test to check what happens to service if client does not claim on time

Author: martinsaposnic

lightning-liquidity/tests/lsps2_integration_tests.rs

@@ -1612,6 +1612,197 @@ fn late_payment_forwarded_and_safe_after_force_close_does_not_broadcast() {
 	}
 }
 
+#[test]
+fn htlc_timeout_before_client_claim_results_in_handling_failed() {
+	let chanmon_cfgs = create_chanmon_cfgs(3);
+	let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
+	let mut service_node_config = test_default_channel_config();
+	service_node_config.accept_intercept_htlcs = true;
+
+	let mut client_node_config = test_default_channel_config();
+	client_node_config.manually_accept_inbound_channels = true;
+	client_node_config.channel_config.accept_underpaying_htlcs = true;
+
+	let node_chanmgrs = create_node_chanmgrs(
+		3,
+		&node_cfgs,
+		&[Some(service_node_config), Some(client_node_config), None],
+	);
+	let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
+	let (lsps_nodes, promise_secret) = setup_test_lsps2_nodes_with_payer(nodes);
+	let LSPSNodesWithPayer { ref service_node, ref client_node, ref payer_node } = lsps_nodes;
+
+	let payer_node_id = payer_node.node.get_our_node_id();
+	let service_node_id = service_node.inner.node.get_our_node_id();
+	let client_node_id = client_node.inner.node.get_our_node_id();
+
+	let service_handler = service_node.liquidity_manager.lsps2_service_handler().unwrap();
+
+	create_chan_between_nodes_with_value(&payer_node, &service_node.inner, 2_000_000, 100_000);
+
+	let intercept_scid = service_node.node.get_intercept_scid();
+	let user_channel_id = 44u128;
+	let cltv_expiry_delta: u32 = 144;
+	let payment_size_msat = Some(1_000_000);
+	let fee_base_msat: u64 = 10_000;
+
+	execute_lsps2_dance(
+		&lsps_nodes,
+		intercept_scid,
+		user_channel_id,
+		cltv_expiry_delta,
+		promise_secret,
+		payment_size_msat,
+		fee_base_msat,
+	);
+
+	let invoice = create_jit_invoice(
+		&client_node,
+		service_node_id,
+		intercept_scid,
+		cltv_expiry_delta,
+		payment_size_msat,
+		"timeout-before-claim",
+		3600,
+	)
+	.unwrap();
+
+	payer_node
+		.node
+		.pay_for_bolt11_invoice(
+			&invoice,
+			PaymentId(invoice.payment_hash().to_byte_array()),
+			None,
+			Default::default(),
+			Retry::Attempts(3),
+		)
+		.unwrap();
+
+	check_added_monitors!(payer_node, 1);
+	let events = payer_node.node.get_and_clear_pending_msg_events();
+	let ev = SendEvent::from_event(events[0].clone());
+	service_node.inner.node.handle_update_add_htlc(payer_node_id, &ev.msgs[0]);
+	do_commitment_signed_dance(&service_node.inner, &payer_node, &ev.commitment_msg, false, true);
+	service_node.inner.node.process_pending_htlc_forwards();
+
+	let events = service_node.inner.node.get_and_clear_pending_events();
+	assert_eq!(events.len(), 1);
+	match &events[0] {
+		Event::HTLCIntercepted {
+			intercept_id,
+			requested_next_hop_scid,
+			payment_hash: _,
+			expected_outbound_amount_msat,
+			..
+		} => {
+			assert_eq!(*requested_next_hop_scid, intercept_scid);
+			service_handler
+				.htlc_intercepted(
+					*requested_next_hop_scid,
+					*intercept_id,
+					*expected_outbound_amount_msat,
+					PaymentHash(invoice.payment_hash().to_byte_array()),
+				)
+				.unwrap();
+		},
+		other => panic!("Expected HTLCIntercepted, got {:?}", other),
+	}
+
+	// Create and mark broadcast safe so the channel is fully ready
+	let expected_outbound_amount_msat = payment_size_msat.unwrap() - fee_base_msat;
+	let (channel_id, _funding_tx) = create_channel_with_manual_broadcast(
+		&service_node_id,
+		&client_node_id,
+		&service_node,
+		&client_node,
+		user_channel_id,
+		&expected_outbound_amount_msat,
+		true,
+	);
+
+	service_handler.channel_ready(user_channel_id, &channel_id, &client_node_id).unwrap();
+	service_node.inner.node.process_pending_htlc_forwards();
+
+	// Forward to client, but do not claim yet
+	let pay_event = {
+		{
+			let mut added_monitors =
+				service_node.inner.chain_monitor.added_monitors.lock().unwrap();
+			assert_eq!(added_monitors.len(), 1);
+			added_monitors.clear();
+		}
+		let mut msg_events = service_node.inner.node.get_and_clear_pending_msg_events();
+		assert_eq!(msg_events.len(), 1);
+		SendEvent::from_event(msg_events.remove(0))
+	};
+
+	client_node.inner.node.handle_update_add_htlc(service_node_id, &pay_event.msgs[0]);
+	do_commitment_signed_dance(
+		&client_node.inner,
+		&service_node.inner,
+		&pay_event.commitment_msg,
+		false,
+		true,
+	);
+	client_node.inner.node.process_pending_htlc_forwards();
+
+	let client_events = client_node.inner.node.get_and_clear_pending_events();
+	assert_eq!(client_events.len(), 1);
+	let preimage = match &client_events[0] {
+		Event::PaymentClaimable { purpose, .. } => purpose.preimage().unwrap(),
+		other => panic!("Expected PaymentClaimable, got {:?}", other),
+	};
+
+	// Advance blocks past CLTV expiry before the client attempts to claim
+	const SOME_EXTRA_BLOCKS: u32 = 3;
+	let client_htlc_cltv_expiry = pay_event.msgs[0].cltv_expiry;
+	let target_height = client_htlc_cltv_expiry.saturating_add(SOME_EXTRA_BLOCKS);
+	let cur_height = service_node.inner.best_block_info().1;
+	let d = target_height - cur_height;
+	connect_blocks(&service_node.inner, d);
+	connect_blocks(&client_node.inner, d);
+	connect_blocks(&payer_node, d);
+
+	service_node.inner.node.process_pending_htlc_forwards();
+	client_node.inner.node.process_pending_htlc_forwards();
+
+	// Service->client channel should close due to HTLC timeout
+	let svc_events = service_node.inner.node.get_and_clear_pending_events();
+	let closed_on_service = svc_events.iter().any(|ev| {
+		matches!(ev, Event::ChannelClosed { reason: ClosureReason::HTLCsTimedOut { .. }, .. })
+	});
+	assert!(closed_on_service, "Expected service->client channel to close due to HTLC timeout");
+
+	// Client tries to claim but should fail since HTLC timed out
+	client_node.inner.node.claim_funds(preimage);
+	let client_events = client_node.inner.node.get_and_clear_pending_events();
+	assert_eq!(client_events.len(), 1);
+	match &client_events[0] {
+		Event::HTLCHandlingFailed { failure_type, .. } => match failure_type {
+			lightning::events::HTLCHandlingFailureType::Receive { payment_hash } => {
+				assert_eq!(*payment_hash, PaymentHash(invoice.payment_hash().to_byte_array()));
+			},
+			_ => panic!("Unexpected failure_type: {:?}", failure_type),
+		},
+		other => panic!("Expected HTLCHandlingFailed after timeout, got {:?}", other),
+	}
+
+	// Payer->service channel should remain open
+	{
+		let chans = service_node.inner.node.list_channels();
+		assert!(chans
+			.iter()
+			.any(|cd| cd.counterparty.node_id == payer_node_id && cd.is_channel_ready));
+	}
+
+	service_node.inner.node.get_and_clear_pending_msg_events();
+	client_node.inner.node.get_and_clear_pending_msg_events();
+	payer_node.node.get_and_clear_pending_msg_events();
+	service_node.inner.chain_monitor.added_monitors.lock().unwrap().clear();
+	client_node.inner.chain_monitor.added_monitors.lock().unwrap().clear();
+	payer_node.chain_monitor.added_monitors.lock().unwrap().clear();
+}
+
 fn claim_and_assert_forwarded_only<'a, 'b, 'c>(
 	payer_node: &lightning::ln::functional_test_utils::Node<'a, 'b, 'c>,
 	service_node: &lightning::ln::functional_test_utils::Node<'a, 'b, 'c>,