f - add test coverage

Author: jkczyz

lightning/src/ln/channel.rs

@@ -11795,6 +11795,32 @@ where
 		})
 	}
 
+	#[cfg(test)]
+	pub fn abandon_splice(
+		&mut self,
+	) -> Result<(msgs::TxAbort, Option<SpliceFundingFailed>), APIError> {
+		match self.should_reset_pending_splice_funding_negotiation() {
+			Some(true) => {
+				let tx_abort =
+					msgs::TxAbort { channel_id: self.context.channel_id(), data: Vec::new() };
+				let splice_funding_failed = self.reset_pending_splice_state();
+				Ok((tx_abort, splice_funding_failed))
+			},
+			Some(false) => Err(APIError::APIMisuseError {
+				err: format!(
+					"Channel {} splice cannot be abandoned; already received signatures",
+					self.context.channel_id(),
+				),
+			}),
+			None => Err(APIError::APIMisuseError {
+				err: format!(
+					"Channel {} splice cannot be abandoned; no pending splice",
+					self.context.channel_id(),
+				),
+			}),
+		}
+	}
+
 	/// Checks during handling splice_init
 	pub fn validate_splice_init(
 		&self, msg: &msgs::SpliceInit, our_funding_contribution: SignedAmount,

lightning/src/ln/channelmanager.rs

@@ -4723,6 +4723,94 @@ where
 		}
 	}
 
+	#[cfg(test)]
+	pub(crate) fn abandon_splice(
+		&self, channel_id: &ChannelId, counterparty_node_id: &PublicKey,
+	) -> Result<(), APIError> {
+		let mut res = Ok(());
+		PersistenceNotifierGuard::optionally_notify(self, || {
+			let result = self.internal_abandon_splice(channel_id, counterparty_node_id);
+			res = result;
+			match res {
+				Ok(_) => NotifyOption::SkipPersistHandleEvents,
+				Err(_) => NotifyOption::SkipPersistNoEvents,
+			}
+		});
+		res
+	}
+
+	#[cfg(test)]
+	fn internal_abandon_splice(
+		&self, channel_id: &ChannelId, counterparty_node_id: &PublicKey,
+	) -> Result<(), APIError> {
+		let per_peer_state = self.per_peer_state.read().unwrap();
+
+		let peer_state_mutex = match per_peer_state.get(counterparty_node_id).ok_or_else(|| {
+			APIError::ChannelUnavailable {
+				err: format!("Can't find a peer matching the passed counterparty node_id {counterparty_node_id}"),
+			}
+		}) {
+			Ok(p) => p,
+			Err(e) => return Err(e),
+		};
+
+		let mut peer_state_lock = peer_state_mutex.lock().unwrap();
+		let peer_state = &mut *peer_state_lock;
+
+		// Look for the channel
+		match peer_state.channel_by_id.entry(*channel_id) {
+			hash_map::Entry::Occupied(mut chan_phase_entry) => {
+				if !chan_phase_entry.get().context().is_connected() {
+					// TODO: We should probably support this, but right now `splice_channel` refuses when
+					// the peer is disconnected, so we just check it here.
+					return Err(APIError::ChannelUnavailable {
+						err: "Cannot abandon splice while peer is disconnected".to_owned(),
+					});
+				}
+
+				if let Some(chan) = chan_phase_entry.get_mut().as_funded_mut() {
+					let (tx_abort, splice_funding_failed) = chan.abandon_splice()?;
+
+					peer_state.pending_msg_events.push(MessageSendEvent::SendTxAbort {
+						node_id: *counterparty_node_id,
+						msg: tx_abort,
+					});
+
+					if let Some(splice_funding_failed) = splice_funding_failed {
+						let pending_events = &mut self.pending_events.lock().unwrap();
+						pending_events.push_back((
+							events::Event::SpliceFailed {
+								channel_id: *channel_id,
+								counterparty_node_id: *counterparty_node_id,
+								user_channel_id: chan.context.get_user_id(),
+								abandoned_funding_txo: splice_funding_failed.funding_txo,
+								channel_type: splice_funding_failed.channel_type,
+								contributed_inputs: splice_funding_failed.contributed_inputs,
+								contributed_outputs: splice_funding_failed.contributed_outputs,
+							},
+							None,
+						));
+					}
+
+					Ok(())
+				} else {
+					Err(APIError::ChannelUnavailable {
+						err: format!(
+							"Channel with id {} is not funded, cannot abandon splice",
+							channel_id
+						),
+					})
+				}
+			},
+			hash_map::Entry::Vacant(_) => Err(APIError::ChannelUnavailable {
+				err: format!(
+					"Channel with id {} not found for the passed counterparty node_id {}",
+					channel_id, counterparty_node_id,
+				),
+			}),
+		}
+	}
+
 	#[rustfmt::skip]
 	fn can_forward_htlc_to_outgoing_channel(
 		&self, chan: &mut FundedChannel<SP>, msg: &msgs::UpdateAddHTLC, next_packet: &NextPacketDetails

lightning/src/ln/splicing_tests.rs

@@ -957,3 +957,57 @@ fn fail_splice_on_interactive_tx_error() {
 	let tx_abort = get_event_msg!(acceptor, MessageSendEvent::SendTxAbort, node_id_initiator);
 	initiator.node.handle_tx_abort(node_id_acceptor, &tx_abort);
 }
+
+#[test]
+fn fail_splice_on_tx_abort() {
+	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()),
+	};
+
+	// Fail during interactive-tx construction by having the acceptor send tx_abort instead of
+	// tx_complete.
+	let _ = complete_splice_handshake(initiator, acceptor, channel_id, contribution.clone());
+
+	let tx_add_input =
+		get_event_msg!(initiator, MessageSendEvent::SendTxAddInput, node_id_acceptor);
+	acceptor.node.handle_tx_add_input(node_id_initiator, &tx_add_input);
+
+	let _tx_complete =
+		get_event_msg!(acceptor, MessageSendEvent::SendTxComplete, node_id_initiator);
+
+	acceptor.node.abandon_splice(&channel_id, &node_id_initiator).unwrap();
+	let tx_abort = get_event_msg!(acceptor, MessageSendEvent::SendTxAbort, node_id_initiator);
+	initiator.node.handle_tx_abort(node_id_acceptor, &tx_abort);
+
+	let event = get_event!(initiator, Event::SpliceFailed);
+	match event {
+		Event::SpliceFailed { contributed_inputs, .. } => {
+			assert_eq!(contributed_inputs.len(), 1);
+			assert_eq!(contributed_inputs[0], contribution.inputs()[0].outpoint());
+		},
+		_ => panic!("Expected Event::SpliceFailed"),
+	}
+
+	let tx_abort = get_event_msg!(initiator, MessageSendEvent::SendTxAbort, node_id_acceptor);
+	acceptor.node.handle_tx_abort(node_id_initiator, &tx_abort);
+}