Emit SpliceFailed event upon reload

Similarly to when a peer is disconnected, when a node is reload 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

@@ -6707,6 +6707,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.
@@ -7004,6 +7011,49 @@ where
 		splice_funding_failed
 	}
 
+	pub(super) fn maybe_splice_funding_failed(&self) -> Option<SpliceFundingFailed> {
+		if !self.should_reset_pending_splice_funding_negotiation().unwrap_or(false) {
+			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 { .. } => {
+						// FIXME Uncomment after rebase
+						//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

@@ -16092,6 +16092,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.
+		let mut splice_failed_events = Vec::new();
+		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() {
+					splice_failed_events.push((
+						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() {
@@ -16123,17 +16149,19 @@ where
 		}
 
 		let events = self.pending_events.lock().unwrap();
+		let events_iter = || events.iter().chain(splice_failed_events.iter());
+		let event_count = events.len() + splice_failed_events.len();
 		// 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.
-		let events_not_backwards_compatible = events.iter().any(|(_, action)| action.is_some());
+		let events_not_backwards_compatible = events_iter().any(|(_, action)| action.is_some());
 		if events_not_backwards_compatible {
 			// If we're gonna write a even TLV that will overwrite our events anyway we might as
 			// well save the space and not write any events here.
 			0u64.write(writer)?;
 		} else {
-			(events.len() as u64).write(writer)?;
-			for (event, _) in events.iter() {
+			(event_count as u64).write(writer)?;
+			for (event, _) in events_iter() {
 				event.write(writer)?;
 			}
 		}
@@ -16219,6 +16247,9 @@ where
 			}
 		}
 
+		let events_iter = events_not_backwards_compatible
+			.then(|| crate::util::ser::Iterable(events_iter()));
+
 		write_tlv_fields!(writer, {
 			(1, pending_outbound_payments_no_retry, required),
 			(2, pending_intercepted_htlcs, option),
@@ -16227,7 +16258,7 @@ where
 			(5, self.our_network_pubkey, required),
 			(6, monitor_update_blocked_actions_per_peer, option),
 			(7, self.fake_scid_rand_bytes, required),
-			(8, if events_not_backwards_compatible { Some(&*events) } else { None }, option),
+			(8, events_iter, option),
 			(9, htlc_purposes, required_vec),
 			(10, legacy_in_flight_monitor_updates, option),
 			(11, self.probing_cookie_secret, required),

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

@@ -430,10 +430,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_nodes(reconnect_args);
@@ -497,10 +497,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_nodes(reconnect_args);