Emit SpliceFailed event upon reload

Similarly to when a peer is disconnected, when a node is reloaded any
splice that hasn't reaching FundingNegotiation::AwaitingSignatures will
be reset. This should produce a SpliceFailed event. However, since other
FundingNegotiation variants are not persisted, the data to produced the
SpliceFailed event upon reload is lost. Therefore, opportunistically
persist a SpliceFailed event for these cases such that it is available
upon reload.

Author: jkczyz

lightning/src/ln/channel.rs

@@ -6732,6 +6732,13 @@ impl FundingNegotiationContext {
 		let contributed_outputs = self.our_funding_outputs;
 		(contributed_inputs, contributed_outputs)
 	}
+
+	fn to_contributed_inputs_and_outputs(&self) -> (Vec<bitcoin::OutPoint>, Vec<TxOut>) {
+		let contributed_inputs =
+			self.our_funding_inputs.iter().map(|input| input.utxo.outpoint).collect();
+		let contributed_outputs = self.our_funding_outputs.clone();
+		(contributed_inputs, contributed_outputs)
+	}
 }
 
 // Holder designates channel data owned for the benefit of the user client.
@@ -7021,6 +7028,48 @@ where
 		splice_funding_failed
 	}
 
+	pub(super) fn maybe_splice_funding_failed(&self) -> Option<SpliceFundingFailed> {
+		if !self.should_reset_pending_splice_state() {
+			return None;
+		}
+
+		self.pending_splice
+			.as_ref()
+			.and_then(|pending_splice| pending_splice.funding_negotiation.as_ref())
+			.filter(|funding_negotiation| funding_negotiation.is_initiator())
+			.map(|funding_negotiation| {
+				let funding_txo = funding_negotiation
+					.as_funding()
+					.and_then(|funding| funding.get_funding_txo())
+					.map(|txo| txo.into_bitcoin_outpoint());
+
+				let channel_type = funding_negotiation
+					.as_funding()
+					.map(|funding| funding.get_channel_type().clone());
+
+				let (contributed_inputs, contributed_outputs) = match funding_negotiation {
+					FundingNegotiation::AwaitingAck { context } => {
+						context.to_contributed_inputs_and_outputs()
+					},
+					FundingNegotiation::ConstructingTransaction {
+						interactive_tx_constructor,
+						..
+					} => interactive_tx_constructor.to_contributed_inputs_and_outputs(),
+					FundingNegotiation::AwaitingSignatures { .. } => {
+						debug_assert!(false);
+						(Vec::new(), Vec::new())
+					},
+				};
+
+				SpliceFundingFailed {
+					funding_txo,
+					channel_type,
+					contributed_inputs,
+					contributed_outputs,
+				}
+			})
+	}
+
 	#[rustfmt::skip]
 	fn check_remote_fee<F: Deref, L: Deref>(
 		channel_type: &ChannelTypeFeatures, fee_estimator: &LowerBoundedFeeEstimator<F>,

lightning/src/ln/channelmanager.rs

@@ -16098,6 +16098,32 @@ where
 			htlc_onion_fields.push(&payment.onion_fields);
 		}
 
+		// Since some FundingNegotiation variants are not persisted, any splice in such state must
+		// be failed upon reload. However, as the necessary information for the SpliceFailed event
+		// is not persisted, the event itself needs to be persisted even though it hasn't been
+		// emitted yet. These are removed after the events are written.
+		let event_count = self.pending_events.lock().unwrap().len();
+		for (_, peer_state_mutex) in per_peer_state.iter() {
+			let mut peer_state_lock = peer_state_mutex.lock().unwrap();
+			let peer_state = &mut *peer_state_lock;
+			for chan in peer_state.channel_by_id.values().filter_map(Channel::as_funded) {
+				if let Some(splice_funding_failed) = chan.maybe_splice_funding_failed() {
+					self.pending_events.lock().unwrap().push_back((
+						events::Event::SpliceFailed {
+							channel_id: chan.context.channel_id(),
+							counterparty_node_id: chan.context.get_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,
+					));
+				}
+			}
+		}
+
 		let mut monitor_update_blocked_actions_per_peer = None;
 		let mut peer_states = Vec::new();
 		for (_, peer_state_mutex) in per_peer_state.iter() {
@@ -16128,7 +16154,7 @@ where
 			}
 		}
 
-		let events = self.pending_events.lock().unwrap();
+		let mut events = self.pending_events.lock().unwrap();
 		// LDK versions prior to 0.0.115 don't support post-event actions, thus if there's no
 		// actions at all, skip writing the required TLV. Otherwise, pre-0.0.115 versions will
 		// refuse to read the new ChannelManager.
@@ -16245,6 +16271,9 @@ where
 			(21, WithoutLength(&self.flow.writeable_async_receive_offer_cache()), required),
 		});
 
+		// Remove the SpliceFailed events added earlier.
+		events.truncate(event_count);
+
 		Ok(())
 	}
 }

lightning/src/ln/interactivetxs.rs

@@ -2100,6 +2100,22 @@ impl InteractiveTxConstructor {
 		(contributed_inputs, contributed_outputs)
 	}
 
+	pub(super) fn to_contributed_inputs_and_outputs(&self) -> (Vec<BitcoinOutPoint>, Vec<TxOut>) {
+		let contributed_inputs = self
+			.inputs_to_contribute
+			.iter()
+			.filter(|(_, input)| !input.is_shared())
+			.map(|(_, input)| input.tx_in().previous_output)
+			.collect();
+		let contributed_outputs = self
+			.outputs_to_contribute
+			.iter()
+			.filter(|(_, output)| !output.is_shared())
+			.map(|(_, output)| output.tx_out().clone())
+			.collect();
+		(contributed_inputs, contributed_outputs)
+	}
+
 	pub fn is_initiator(&self) -> bool {
 		self.is_initiator
 	}

lightning/src/ln/splicing_tests.rs

@@ -431,10 +431,10 @@ fn do_test_splice_state_reset_on_disconnect(reload: bool) {
 	} else {
 		nodes[0].node.peer_disconnected(node_id_1);
 		nodes[1].node.peer_disconnected(node_id_0);
-
-		let _event = get_event!(nodes[0], Event::SpliceFailed);
 	}
 
+	let _event = get_event!(nodes[0], Event::SpliceFailed);
+
 	let mut reconnect_args = ReconnectArgs::new(&nodes[0], &nodes[1]);
 	reconnect_args.send_channel_ready = (true, true);
 	reconnect_args.send_announcement_sigs = (true, true);
@@ -490,10 +490,10 @@ fn do_test_splice_state_reset_on_disconnect(reload: bool) {
 	} else {
 		nodes[0].node.peer_disconnected(node_id_1);
 		nodes[1].node.peer_disconnected(node_id_0);
-
-		let _event = get_event!(nodes[0], Event::SpliceFailed);
 	}
 
+	let _event = get_event!(nodes[0], Event::SpliceFailed);
+
 	let mut reconnect_args = ReconnectArgs::new(&nodes[0], &nodes[1]);
 	reconnect_args.send_channel_ready = (true, true);
 	reconnect_args.send_announcement_sigs = (true, true);