Add FundingNeeded event for splicing

Rather than requiring the user to pass FundingTxInputs when initiating a
splice, generate a FundingNeeded event once the channel has become
quiescent. This simplifies error handling and UTXO / change address
clean-up by consolidating it in SpliceFailed event handling.

Later, this event will be used for opportunistic contributions (i.e.,
when the counterparty wins quiescence or initiates), dual-funding, and
RBF.

Author: jkczyz

fuzz/src/chanmon_consistency.rs

@@ -52,7 +52,7 @@ use lightning::ln::channelmanager::{
 	RecipientOnionFields,
 };
 use lightning::ln::functional_test_utils::*;
-use lightning::ln::funding::{FundingTxInput, SpliceContribution};
+use lightning::ln::funding::SpliceContribution;
 use lightning::ln::inbound_payment::ExpandedKey;
 use lightning::ln::msgs::{
 	BaseMessageHandler, ChannelMessageHandler, CommitmentUpdate, Init, MessageSendEvent,
@@ -1859,16 +1859,11 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 			},
 
 			0xa0 => {
-				let input = FundingTxInput::new_p2wpkh(coinbase_tx.clone(), 0).unwrap();
-				let contribution =
-					SpliceContribution::splice_in(Amount::from_sat(10_000), vec![input], None);
-				let funding_feerate_sat_per_kw = fee_est_a.ret_val.load(atomic::Ordering::Acquire);
+				let contribution = SpliceContribution::splice_in(Amount::from_sat(10_000), None);
 				if let Err(e) = nodes[0].splice_channel(
 					&chan_a_id,
 					&nodes[1].get_our_node_id(),
 					contribution,
-					funding_feerate_sat_per_kw,
-					None,
 				) {
 					assert!(
 						matches!(e, APIError::APIMisuseError { ref err } if err.contains("splice pending")),
@@ -1878,16 +1873,11 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 				}
 			},
 			0xa1 => {
-				let input = FundingTxInput::new_p2wpkh(coinbase_tx.clone(), 1).unwrap();
-				let contribution =
-					SpliceContribution::splice_in(Amount::from_sat(10_000), vec![input], None);
-				let funding_feerate_sat_per_kw = fee_est_b.ret_val.load(atomic::Ordering::Acquire);
+				let contribution = SpliceContribution::splice_in(Amount::from_sat(10_000), None);
 				if let Err(e) = nodes[1].splice_channel(
 					&chan_a_id,
 					&nodes[0].get_our_node_id(),
 					contribution,
-					funding_feerate_sat_per_kw,
-					None,
 				) {
 					assert!(
 						matches!(e, APIError::APIMisuseError { ref err } if err.contains("splice pending")),
@@ -1897,16 +1887,11 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 				}
 			},
 			0xa2 => {
-				let input = FundingTxInput::new_p2wpkh(coinbase_tx.clone(), 0).unwrap();
-				let contribution =
-					SpliceContribution::splice_in(Amount::from_sat(10_000), vec![input], None);
-				let funding_feerate_sat_per_kw = fee_est_b.ret_val.load(atomic::Ordering::Acquire);
+				let contribution = SpliceContribution::splice_in(Amount::from_sat(10_000), None);
 				if let Err(e) = nodes[1].splice_channel(
 					&chan_b_id,
 					&nodes[2].get_our_node_id(),
 					contribution,
-					funding_feerate_sat_per_kw,
-					None,
 				) {
 					assert!(
 						matches!(e, APIError::APIMisuseError { ref err } if err.contains("splice pending")),
@@ -1916,16 +1901,11 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 				}
 			},
 			0xa3 => {
-				let input = FundingTxInput::new_p2wpkh(coinbase_tx.clone(), 1).unwrap();
-				let contribution =
-					SpliceContribution::splice_in(Amount::from_sat(10_000), vec![input], None);
-				let funding_feerate_sat_per_kw = fee_est_c.ret_val.load(atomic::Ordering::Acquire);
+				let contribution = SpliceContribution::splice_in(Amount::from_sat(10_000), None);
 				if let Err(e) = nodes[2].splice_channel(
 					&chan_b_id,
 					&nodes[1].get_our_node_id(),
 					contribution,
-					funding_feerate_sat_per_kw,
-					None,
 				) {
 					assert!(
 						matches!(e, APIError::APIMisuseError { ref err } if err.contains("splice pending")),
@@ -1950,14 +1930,10 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 						value: Amount::from_sat(MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS),
 						script_pubkey: coinbase_tx.output[0].script_pubkey.clone(),
 					}]);
-					let funding_feerate_sat_per_kw =
-						fee_est_a.ret_val.load(atomic::Ordering::Acquire);
 					if let Err(e) = nodes[0].splice_channel(
 						&chan_a_id,
 						&nodes[1].get_our_node_id(),
 						contribution,
-						funding_feerate_sat_per_kw,
-						None,
 					) {
 						assert!(
 							matches!(e, APIError::APIMisuseError { ref err } if err.contains("splice pending")),
@@ -1979,14 +1955,10 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 						value: Amount::from_sat(MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS),
 						script_pubkey: coinbase_tx.output[1].script_pubkey.clone(),
 					}]);
-					let funding_feerate_sat_per_kw =
-						fee_est_b.ret_val.load(atomic::Ordering::Acquire);
 					if let Err(e) = nodes[1].splice_channel(
 						&chan_a_id,
 						&nodes[0].get_our_node_id(),
 						contribution,
-						funding_feerate_sat_per_kw,
-						None,
 					) {
 						assert!(
 							matches!(e, APIError::APIMisuseError { ref err } if err.contains("splice pending")),
@@ -2008,14 +1980,10 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 						value: Amount::from_sat(MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS),
 						script_pubkey: coinbase_tx.output[1].script_pubkey.clone(),
 					}]);
-					let funding_feerate_sat_per_kw =
-						fee_est_b.ret_val.load(atomic::Ordering::Acquire);
 					if let Err(e) = nodes[1].splice_channel(
 						&chan_b_id,
 						&nodes[2].get_our_node_id(),
 						contribution,
-						funding_feerate_sat_per_kw,
-						None,
 					) {
 						assert!(
 							matches!(e, APIError::APIMisuseError { ref err } if err.contains("splice pending")),
@@ -2037,14 +2005,10 @@ pub fn do_test<Out: Output>(data: &[u8], underlying_out: Out, anchors: bool) {
 						value: Amount::from_sat(MAX_STD_OUTPUT_DUST_LIMIT_SATOSHIS),
 						script_pubkey: coinbase_tx.output[2].script_pubkey.clone(),
 					}]);
-					let funding_feerate_sat_per_kw =
-						fee_est_c.ret_val.load(atomic::Ordering::Acquire);
 					if let Err(e) = nodes[2].splice_channel(
 						&chan_b_id,
 						&nodes[1].get_our_node_id(),
 						contribution,
-						funding_feerate_sat_per_kw,
-						None,
 					) {
 						assert!(
 							matches!(e, APIError::APIMisuseError { ref err } if err.contains("splice pending")),

lightning/src/events/bump_transaction/mod.rs

@@ -271,6 +271,12 @@ pub struct Input {
 	pub satisfaction_weight: u64,
 }
 
+impl_writeable_tlv_based!(Input, {
+	(1, outpoint, required),
+	(3, previous_utxo, required),
+	(5, satisfaction_weight, required),
+});
+
 /// An unspent transaction output that is available to spend resulting from a successful
 /// [`CoinSelection`] attempt.
 #[derive(Clone, Debug, Hash, PartialOrd, Ord, PartialEq, Eq)]

lightning/src/events/mod.rs

@@ -25,6 +25,7 @@ use crate::blinded_path::payment::{
 use crate::chain::transaction;
 use crate::ln::channel::FUNDING_CONF_DEADLINE_BLOCKS;
 use crate::ln::channelmanager::{InterceptId, PaymentId, RecipientOnionFields};
+use crate::ln::funding::FundingTemplate;
 use crate::ln::msgs;
 use crate::ln::onion_utils::LocalHTLCFailureReason;
 use crate::ln::types::ChannelId;
@@ -1817,6 +1818,36 @@ pub enum Event {
 		/// [`ChannelManager::respond_to_static_invoice_request`]: crate::ln::channelmanager::ChannelManager::respond_to_static_invoice_request
 		invoice_request: InvoiceRequest,
 	},
+	/// Indicates that funding is needed for a channel splice or a dual-funded channel open.
+	///
+	/// The client should build a [`FundingContribution`] from the provided [`FundingTemplate`] and
+	/// pass it to [`ChannelManager::funding_contributed`].
+	///
+	/// [`FundingContribution`]: crate::ln::funding::FundingContribution
+	/// [`ChannelManager::funding_contributed`]: crate::ln::channelmanager::ChannelManager::funding_contributed
+	FundingNeeded {
+		/// The `channel_id` of the channel which you'll need to pass back into
+		/// [`ChannelManager::funding_contributed`].
+		///
+		/// [`ChannelManager::funding_contributed`]: crate::ln::channelmanager::ChannelManager::funding_contributed
+		channel_id: ChannelId,
+		/// The counterparty's `node_id`, which you'll need to pass back into
+		/// [`ChannelManager::funding_contributed`].
+		///
+		/// [`ChannelManager::funding_contributed`]: crate::ln::channelmanager::ChannelManager::funding_contributed
+		counterparty_node_id: PublicKey,
+		/// The `user_channel_id` value passed in for outbound channels, or for inbound channels if
+		/// [`UserConfig::manually_accept_inbound_channels`] config flag is set to true. Otherwise
+		/// `user_channel_id` will be randomized for inbound channels.
+		///
+		/// [`UserConfig::manually_accept_inbound_channels`]: crate::util::config::UserConfig::manually_accept_inbound_channels
+		user_channel_id: u128,
+		/// A template for constructing a [`FundingContribution`], which contains information when
+		/// the funding was initiated.
+		///
+		/// [`FundingContribution`]: crate::ln::funding::FundingContribution
+		funding_template: FundingTemplate,
+	},
 	/// Indicates that a channel funding transaction constructed interactively is ready to be
 	/// signed. This event will only be triggered if at least one input was contributed.
 	///
@@ -2348,6 +2379,20 @@ impl Writeable for Event {
 					(13, *contributed_outputs, optional_vec),
 				});
 			},
+			&Event::FundingNeeded {
+				ref channel_id,
+				ref user_channel_id,
+				ref counterparty_node_id,
+				ref funding_template,
+			} => {
+				54u8.write(writer)?;
+				write_tlv_fields!(writer, {
+					(1, channel_id, required),
+					(3, user_channel_id, required),
+					(5, counterparty_node_id, required),
+					(7, funding_template, required),
+				});
+			},
 			// Note that, going forward, all new events must only write data inside of
 			// `write_tlv_fields`. Versions 0.0.101+ will ignore odd-numbered events that write
 			// data via `write_tlv_fields`.
@@ -2979,6 +3024,24 @@ impl MaybeReadable for Event {
 				};
 				f()
 			},
+			54u8 => {
+				let mut f = || {
+					_init_and_read_len_prefixed_tlv_fields!(reader, {
+						(1, channel_id, required),
+						(3, user_channel_id, required),
+						(5, counterparty_node_id, required),
+						(7, funding_template, required),
+					});
+
+					Ok(Some(Event::FundingNeeded {
+						channel_id: channel_id.0.unwrap(),
+						user_channel_id: user_channel_id.0.unwrap(),
+						counterparty_node_id: counterparty_node_id.0.unwrap(),
+						funding_template: funding_template.0.unwrap(),
+					}))
+				};
+				f()
+			},
 			// Versions prior to 0.0.100 did not ignore odd types, instead returning InvalidValue.
 			// Version 0.0.100 failed to properly ignore odd types, possibly resulting in corrupt
 			// reads.