f - add test coverage

Author: jkczyz

lightning/src/ln/channelmanager.rs

@@ -4515,7 +4515,6 @@ where
 				last_local_balance_msat: Some(shutdown_res.last_local_balance_msat),
 			}, None));
 
-			// Emit SpliceFailed event immediately after ChannelClosed if there was an active splice negotiation
 			if let Some(splice_funding_failed) = shutdown_res.splice_funding_failed.take() {
 				pending_events.push_back((events::Event::SpliceFailed {
 					channel_id: shutdown_res.channel_id,

lightning/src/ln/functional_test_utils.rs

@@ -2128,6 +2128,7 @@ pub struct ExpectedCloseEvent {
 	pub channel_id: Option<ChannelId>,
 	pub counterparty_node_id: Option<PublicKey>,
 	pub discard_funding: bool,
+	pub splice_failed: bool,
 	pub reason: Option<ClosureReason>,
 	pub channel_funding_txo: Option<OutPoint>,
 	pub user_channel_id: Option<u128>,
@@ -2142,6 +2143,7 @@ impl ExpectedCloseEvent {
 			channel_id: Some(channel_id),
 			counterparty_node_id: None,
 			discard_funding,
+			splice_failed: false,
 			reason: Some(reason),
 			channel_funding_txo: None,
 			user_channel_id: None,
@@ -2153,8 +2155,14 @@ impl ExpectedCloseEvent {
 pub fn check_closed_events(node: &Node, expected_close_events: &[ExpectedCloseEvent]) {
 	let closed_events_count = expected_close_events.len();
 	let discard_events_count = expected_close_events.iter().filter(|e| e.discard_funding).count();
+	let splice_events_count = expected_close_events.iter().filter(|e| e.splice_failed).count();
 	let events = node.node.get_and_clear_pending_events();
-	assert_eq!(events.len(), closed_events_count + discard_events_count, "{:?}", events);
+	assert_eq!(
+		events.len(),
+		closed_events_count + discard_events_count + splice_events_count,
+		"{:?}",
+		events
+	);
 	for expected_event in expected_close_events {
 		assert!(events.iter().any(|e| matches!(
 			e,
@@ -2184,6 +2192,10 @@ pub fn check_closed_events(node: &Node, expected_close_events: &[ExpectedCloseEv
 		events.iter().filter(|e| matches!(e, Event::DiscardFunding { .. },)).count(),
 		discard_events_count
 	);
+	assert_eq!(
+		events.iter().filter(|e| matches!(e, Event::SpliceFailed { .. },)).count(),
+		splice_events_count
+	);
 }
 
 /// Check that a channel's closing channel events has been issued
@@ -2205,6 +2217,7 @@ pub fn check_closed_event(
 			channel_id: None,
 			counterparty_node_id: Some(*node_id),
 			discard_funding: is_check_discard_funding,
+			splice_failed: false,
 			reason: Some(expected_reason.clone()),
 			channel_funding_txo: None,
 			user_channel_id: None,

lightning/src/ln/monitor_tests.rs

@@ -1467,6 +1467,7 @@ fn do_test_revoked_counterparty_commitment_balances(keyed_anchors: bool, p2a_anc
 		channel_id: Some(chan_id),
 		counterparty_node_id: Some(nodes[0].node.get_our_node_id()),
 		discard_funding: false,
+		splice_failed: false,
 		reason: None, // Could be due to any HTLC timing out, so don't bother checking
 		channel_funding_txo: None,
 		user_channel_id: None,

lightning/src/ln/reorg_tests.rs

@@ -503,6 +503,7 @@ fn test_set_outpoints_partial_claiming() {
 		channel_id: Some(chan.2),
 		counterparty_node_id: Some(nodes[0].node.get_our_node_id()),
 		discard_funding: false,
+		splice_failed: false,
 		reason: None, // Could be due to either HTLC timing out, so don't bother checking
 		channel_funding_txo: None,
 		user_channel_id: None,

lightning/src/ln/shutdown_tests.rs

@@ -636,6 +636,7 @@ fn do_htlc_fail_async_shutdown(blinded_recipient: bool) {
 		channel_id: None,
 		counterparty_node_id: Some(node_a_id),
 		discard_funding: false,
+		splice_failed: false,
 		reason: Some(ClosureReason::LocallyInitiatedCooperativeClosure),
 		channel_funding_txo: None,
 		user_channel_id: None,
@@ -645,6 +646,7 @@ fn do_htlc_fail_async_shutdown(blinded_recipient: bool) {
 		channel_id: None,
 		counterparty_node_id: Some(node_c_id),
 		discard_funding: false,
+		splice_failed: false,
 		reason: Some(ClosureReason::CounterpartyInitiatedCooperativeClosure),
 		channel_funding_txo: None,
 		user_channel_id: None,

lightning/src/ln/splicing_tests.rs

@@ -1011,3 +1011,114 @@ fn fail_splice_on_tx_abort() {
 	let tx_abort = get_event_msg!(initiator, MessageSendEvent::SendTxAbort, node_id_acceptor);
 	acceptor.node.handle_tx_abort(node_id_initiator, &tx_abort);
 }
+
+#[test]
+fn fail_splice_on_channel_close() {
+	let chanmon_cfgs = create_chanmon_cfgs(2);
+	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let config = test_default_anchors_channel_config();
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(config.clone()), Some(config)]);
+	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+	let initiator = &nodes[0];
+	let acceptor = &nodes[1];
+
+	let _node_id_initiator = initiator.node.get_our_node_id();
+	let node_id_acceptor = acceptor.node.get_our_node_id();
+
+	let initial_channel_capacity = 100_000;
+	let (_, _, channel_id, _) =
+		create_announced_chan_between_nodes_with_value(&nodes, 0, 1, initial_channel_capacity, 0);
+
+	let coinbase_tx = provide_anchor_reserves(&nodes);
+	let splice_in_amount = initial_channel_capacity / 2;
+	let contribution = SpliceContribution::SpliceIn {
+		value: Amount::from_sat(splice_in_amount),
+		inputs: vec![FundingTxInput::new_p2wpkh(coinbase_tx, 0).unwrap()],
+		change_script: Some(nodes[0].wallet_source.get_change_script().unwrap()),
+	};
+
+	// Close the channel before completion of interactive-tx construction.
+	let _ = complete_splice_handshake(initiator, acceptor, channel_id, contribution.clone());
+	let _tx_add_input =
+		get_event_msg!(initiator, MessageSendEvent::SendTxAddInput, node_id_acceptor);
+
+	initiator
+		.node
+		.force_close_broadcasting_latest_txn(&channel_id, &node_id_acceptor, "test".to_owned())
+		.unwrap();
+	handle_bump_events(initiator, true, 0);
+	check_closed_events(
+		&nodes[0],
+		&[ExpectedCloseEvent {
+			channel_id: Some(channel_id),
+			discard_funding: false,
+			splice_failed: true,
+			channel_funding_txo: None,
+			user_channel_id: Some(42),
+			..Default::default()
+		}],
+	);
+	check_closed_broadcast(&nodes[0], 1, true);
+	check_added_monitors(&nodes[0], 1);
+}
+
+#[test]
+fn fail_quiescent_action_on_channel_close() {
+	let chanmon_cfgs = create_chanmon_cfgs(2);
+	let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
+	let config = test_default_anchors_channel_config();
+	let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(config.clone()), Some(config)]);
+	let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
+
+	let initiator = &nodes[0];
+	let acceptor = &nodes[1];
+
+	let _node_id_initiator = initiator.node.get_our_node_id();
+	let node_id_acceptor = acceptor.node.get_our_node_id();
+
+	let initial_channel_capacity = 100_000;
+	let (_, _, channel_id, _) =
+		create_announced_chan_between_nodes_with_value(&nodes, 0, 1, initial_channel_capacity, 0);
+
+	let coinbase_tx = provide_anchor_reserves(&nodes);
+	let splice_in_amount = initial_channel_capacity / 2;
+	let contribution = SpliceContribution::SpliceIn {
+		value: Amount::from_sat(splice_in_amount),
+		inputs: vec![FundingTxInput::new_p2wpkh(coinbase_tx, 0).unwrap()],
+		change_script: Some(nodes[0].wallet_source.get_change_script().unwrap()),
+	};
+
+	// Close the channel before completion of STFU handshake.
+	initiator
+		.node
+		.splice_channel(
+			&channel_id,
+			&node_id_acceptor,
+			contribution,
+			FEERATE_FLOOR_SATS_PER_KW,
+			None,
+		)
+		.unwrap();
+
+	let _stfu_init = get_event_msg!(initiator, MessageSendEvent::SendStfu, node_id_acceptor);
+
+	initiator
+		.node
+		.force_close_broadcasting_latest_txn(&channel_id, &node_id_acceptor, "test".to_owned())
+		.unwrap();
+	handle_bump_events(initiator, true, 0);
+	check_closed_events(
+		&nodes[0],
+		&[ExpectedCloseEvent {
+			channel_id: Some(channel_id),
+			discard_funding: false,
+			splice_failed: true,
+			channel_funding_txo: None,
+			user_channel_id: Some(42),
+			..Default::default()
+		}],
+	);
+	check_closed_broadcast(&nodes[0], 1, true);
+	check_added_monitors(&nodes[0], 1);
+}