Add pending funding scopes to FundedChannel

Once a channel is funded, it may be spliced to add or remove funds. The
new funding transaction is pending until confirmed on chain and thus
needs to be tracked. Additionally, it may be replaced by another
transaction using RBF with a higher fee. Hence, there may be more than
one pending FundingScope to track for a splice.

This commit adds support for tracking pending funding scopes. The
following commits will account for any pending scopes where applicable
(e.g., when handling commitment_signed).

Author: jkczyz

lightning/src/chain/onchaintx.rs

@@ -368,7 +368,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 		let prev_holder_commitment = Readable::read(reader)?;
 		let _prev_holder_htlc_sigs: Option<Vec<Option<(usize, Signature)>>> = Readable::read(reader)?;
 
-		let channel_parameters = ReadableArgs::<u64>::read(reader, channel_value_satoshis)?;
+		let channel_parameters = ReadableArgs::<Option<u64>>::read(reader, Some(channel_value_satoshis))?;
 
 		// Read the serialized signer bytes, but don't deserialize them, as we'll obtain our signer
 		// by re-deriving the private key material.

lightning/src/ln/chan_utils.rs

@@ -1034,8 +1034,8 @@ impl Writeable for ChannelTransactionParameters {
 	}
 }
 
-impl ReadableArgs<u64> for ChannelTransactionParameters {
-	fn read<R: io::Read>(reader: &mut R, read_args: u64) -> Result<Self, DecodeError> {
+impl ReadableArgs<Option<u64>> for ChannelTransactionParameters {
+	fn read<R: io::Read>(reader: &mut R, read_args: Option<u64>) -> Result<Self, DecodeError> {
 		let mut holder_pubkeys = RequiredWrapper(None);
 		let mut holder_selected_contest_delay = RequiredWrapper(None);
 		let mut is_outbound_from_holder = RequiredWrapper(None);
@@ -1058,10 +1058,17 @@ impl ReadableArgs<u64> for ChannelTransactionParameters {
 			(13, channel_value_satoshis, option),
 		});
 
-		let channel_value_satoshis = channel_value_satoshis.unwrap_or(read_args);
-		if channel_value_satoshis != read_args {
-			return Err(DecodeError::InvalidValue);
-		}
+		let channel_value_satoshis = match read_args {
+			None => channel_value_satoshis.ok_or(DecodeError::InvalidValue)?,
+			Some(expected_value) => {
+				let channel_value_satoshis = channel_value_satoshis.unwrap_or(expected_value);
+				if channel_value_satoshis == expected_value {
+					channel_value_satoshis
+				} else {
+					return Err(DecodeError::InvalidValue);
+				}
+			},
+		};
 
 		let mut additional_features = ChannelTypeFeatures::empty();
 		additional_features.set_anchors_nonzero_fee_htlc_tx_required();

lightning/src/ln/channel.rs

@@ -60,7 +60,7 @@ use crate::sign::{EntropySource, ChannelSigner, SignerProvider, NodeSigner, Reci
 use crate::events::{ClosureReason, Event};
 use crate::events::bump_transaction::BASE_INPUT_WEIGHT;
 use crate::routing::gossip::NodeId;
-use crate::util::ser::{Readable, ReadableArgs, TransactionU16LenLimited, Writeable, Writer};
+use crate::util::ser::{Readable, ReadableArgs, RequiredWrapper, TransactionU16LenLimited, Writeable, Writer};
 use crate::util::logger::{Logger, Record, WithContext};
 use crate::util::errors::APIError;
 use crate::util::config::{UserConfig, ChannelConfig, LegacyChannelConfig, ChannelHandshakeConfig, ChannelHandshakeLimits, MaxDustHTLCExposure};
@@ -1514,6 +1514,7 @@ impl<SP: Deref> Channel<SP> where
 				};
 				let mut funded_channel = FundedChannel {
 					funding: chan.funding,
+					pending_funding: vec![],
 					context: chan.context,
 					interactive_tx_signing_session: chan.interactive_tx_signing_session,
 					holder_commitment_point,
@@ -1660,6 +1661,63 @@ pub(super) struct FundingScope {
 	funding_transaction: Option<Transaction>,
 }
 
+impl Writeable for FundingScope {
+	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
+		#[cfg(any(test, fuzzing))]
+		self.next_local_commitment_tx_fee_info_cached.write(writer)?;
+		#[cfg(any(test, fuzzing))]
+		self.next_remote_commitment_tx_fee_info_cached.write(writer)?;
+
+		write_tlv_fields!(writer, {
+			(0, self.value_to_self_msat, required),
+			(1, self.counterparty_selected_channel_reserve_satoshis, option),
+			(2, self.holder_selected_channel_reserve_satoshis, required),
+			(3, self.channel_transaction_parameters, (required: ReadableArgs, None)),
+			(4, self.funding_transaction, option),
+		});
+		Ok(())
+	}
+}
+
+impl Readable for FundingScope {
+	fn read<R: io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+		let mut value_to_self_msat = RequiredWrapper(None);
+		let mut counterparty_selected_channel_reserve_satoshis = None;
+		let mut holder_selected_channel_reserve_satoshis = RequiredWrapper(None);
+		let mut channel_transaction_parameters = RequiredWrapper(None);
+		let mut funding_transaction = None;
+
+		#[cfg(any(test, fuzzing))]
+		let next_local_commitment_tx_fee_info_cached = Readable::read(reader)?;
+		#[cfg(any(test, fuzzing))]
+		let next_remote_commitment_tx_fee_info_cached = Readable::read(reader)?;
+
+		read_tlv_fields!(reader, {
+			(0, value_to_self_msat, required),
+			(1, counterparty_selected_channel_reserve_satoshis, option),
+			(2, holder_selected_channel_reserve_satoshis, required),
+			(3, channel_transaction_parameters, (required: ReadableArgs, None)),
+			(4, funding_transaction, option),
+		});
+
+		Ok(Self {
+			value_to_self_msat: value_to_self_msat.0.unwrap(),
+			counterparty_selected_channel_reserve_satoshis,
+			holder_selected_channel_reserve_satoshis: holder_selected_channel_reserve_satoshis.0.unwrap(),
+			#[cfg(debug_assertions)]
+			holder_max_commitment_tx_output: Mutex::new((0, 0)),
+			#[cfg(debug_assertions)]
+			counterparty_max_commitment_tx_output: Mutex::new((0, 0)),
+			channel_transaction_parameters: channel_transaction_parameters.0.unwrap(),
+			funding_transaction,
+			#[cfg(any(test, fuzzing))]
+			next_local_commitment_tx_fee_info_cached,
+			#[cfg(any(test, fuzzing))]
+			next_remote_commitment_tx_fee_info_cached,
+		})
+	}
+}
+
 impl FundingScope {
 	pub fn get_value_satoshis(&self) -> u64 {
 		self.channel_transaction_parameters.channel_value_satoshis
@@ -3522,7 +3580,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 				if let Some(info) = projected_commit_tx_info {
 					let total_pending_htlcs = self.pending_inbound_htlcs.len() + self.pending_outbound_htlcs.len()
 						+ self.holding_cell_htlc_updates.len();
-					if info.total_pending_htlcs == total_pending_htlcs
+					if info.total_pending_htlcs == total_pending_htlcs as u64
 						&& info.next_holder_htlc_id == self.next_holder_htlc_id
 						&& info.next_counterparty_htlc_id == self.next_counterparty_htlc_id
 						&& info.feerate == self.feerate_per_kw {
@@ -4342,7 +4400,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 				+ context.holding_cell_htlc_updates.len();
 			let commitment_tx_info = CommitmentTxInfoCached {
 				fee,
-				total_pending_htlcs,
+				total_pending_htlcs: total_pending_htlcs as u64,
 				next_holder_htlc_id: match htlc.origin {
 					HTLCInitiator::LocalOffered => context.next_holder_htlc_id + 1,
 					HTLCInitiator::RemoteOffered => context.next_holder_htlc_id,
@@ -4438,7 +4496,7 @@ impl<SP: Deref> ChannelContext<SP> where SP::Target: SignerProvider {
 			let total_pending_htlcs = context.pending_inbound_htlcs.len() + context.pending_outbound_htlcs.len();
 			let commitment_tx_info = CommitmentTxInfoCached {
 				fee,
-				total_pending_htlcs,
+				total_pending_htlcs: total_pending_htlcs as u64,
 				next_holder_htlc_id: match htlc.origin {
 					HTLCInitiator::LocalOffered => context.next_holder_htlc_id + 1,
 					HTLCInitiator::RemoteOffered => context.next_holder_htlc_id,
@@ -4890,6 +4948,7 @@ pub(super) struct DualFundingChannelContext {
 // Counterparty designates channel data owned by the another channel participant entity.
 pub(super) struct FundedChannel<SP: Deref> where SP::Target: SignerProvider {
 	pub funding: FundingScope,
+	pending_funding: Vec<FundingScope>,
 	pub context: ChannelContext<SP>,
 	pub interactive_tx_signing_session: Option<InteractiveTxSigningSession>,
 	holder_commitment_point: HolderCommitmentPoint,
@@ -4904,12 +4963,21 @@ pub(super) struct FundedChannel<SP: Deref> where SP::Target: SignerProvider {
 #[cfg(any(test, fuzzing))]
 struct CommitmentTxInfoCached {
 	fee: u64,
-	total_pending_htlcs: usize,
+	total_pending_htlcs: u64,
 	next_holder_htlc_id: u64,
 	next_counterparty_htlc_id: u64,
 	feerate: u32,
 }
 
+#[cfg(any(test, fuzzing))]
+impl_writeable_tlv_based!(CommitmentTxInfoCached, {
+	(0, fee, required),
+	(1, total_pending_htlcs, required),
+	(2, next_holder_htlc_id, required),
+	(3, next_counterparty_htlc_id, required),
+	(4, feerate, required),
+});
+
 /// Partial data from ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo used to simplify the
 /// return type of `ChannelContext::validate_commitment_signed`.
 struct LatestHolderCommitmentTXInfo {
@@ -8770,7 +8838,7 @@ impl<SP: Deref> FundedChannel<SP> where
 				*self.funding.next_local_commitment_tx_fee_info_cached.lock().unwrap() = None;
 				if let Some(info) = projected_commit_tx_info {
 					let total_pending_htlcs = self.context.pending_inbound_htlcs.len() + self.context.pending_outbound_htlcs.len();
-					if info.total_pending_htlcs == total_pending_htlcs
+					if info.total_pending_htlcs == total_pending_htlcs as u64
 						&& info.next_holder_htlc_id == self.context.next_holder_htlc_id
 						&& info.next_counterparty_htlc_id == self.context.next_counterparty_htlc_id
 						&& info.feerate == self.context.feerate_per_kw {
@@ -9472,6 +9540,7 @@ impl<SP: Deref> OutboundV1Channel<SP> where SP::Target: SignerProvider {
 
 		let mut channel = FundedChannel {
 			funding: self.funding,
+			pending_funding: vec![],
 			context: self.context,
 			interactive_tx_signing_session: None,
 			is_v2_established: false,
@@ -9748,6 +9817,7 @@ impl<SP: Deref> InboundV1Channel<SP> where SP::Target: SignerProvider {
 		// `ChannelMonitor`.
 		let mut channel = FundedChannel {
 			funding: self.funding,
+			pending_funding: vec![],
 			context: self.context,
 			interactive_tx_signing_session: None,
 			is_v2_established: false,
@@ -10542,6 +10612,7 @@ impl<SP: Deref> Writeable for FundedChannel<SP> where SP::Target: SignerProvider
 			(49, self.context.local_initiated_shutdown, option), // Added in 0.0.122
 			(51, is_manual_broadcast, option), // Added in 0.0.124
 			(53, funding_tx_broadcast_safe_event_emitted, option), // Added in 0.0.124
+			(55, self.pending_funding, optional_vec), // Added in 0.2
 		});
 
 		Ok(())
@@ -10766,7 +10837,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 			_ => return Err(DecodeError::InvalidValue),
 		};
 
-		let mut channel_parameters: ChannelTransactionParameters = ReadableArgs::<u64>::read(reader, channel_value_satoshis)?;
+		let mut channel_parameters: ChannelTransactionParameters = ReadableArgs::<Option<u64>>::read(reader, Some(channel_value_satoshis))?;
 		let funding_transaction: Option<Transaction> = Readable::read(reader)?;
 
 		let counterparty_cur_commitment_point = Readable::read(reader)?;
@@ -10833,6 +10904,8 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 		let mut next_holder_commitment_point_opt: Option<PublicKey> = None;
 		let mut is_manual_broadcast = None;
 
+		let mut pending_funding = Some(Vec::new());
+
 		read_tlv_fields!(reader, {
 			(0, announcement_sigs, option),
 			(1, minimum_depth, option),
@@ -10868,6 +10941,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 			(49, local_initiated_shutdown, option),
 			(51, is_manual_broadcast, option),
 			(53, funding_tx_broadcast_safe_event_emitted, option),
+			(55, pending_funding, optional_vec), // Added in 0.2
 		});
 
 		let holder_signer = signer_provider.derive_channel_signer(channel_keys_id);
@@ -11009,6 +11083,7 @@ impl<'a, 'b, 'c, ES: Deref, SP: Deref> ReadableArgs<(&'a ES, &'b SP, &'c Channel
 				channel_transaction_parameters: channel_parameters,
 				funding_transaction,
 			},
+			pending_funding: pending_funding.unwrap(),
 			context: ChannelContext {
 				user_id,
 

lightning/src/sign/mod.rs

@@ -124,7 +124,7 @@ impl_writeable_tlv_based!(DelayedPaymentOutputDescriptor, {
 	(8, revocation_pubkey, required),
 	(10, channel_keys_id, required),
 	(12, channel_value_satoshis, required),
-	(13, channel_transaction_parameters, (option: ReadableArgs, channel_value_satoshis.0.unwrap())),
+	(13, channel_transaction_parameters, (option: ReadableArgs, channel_value_satoshis.0)),
 });
 
 pub(crate) const P2WPKH_WITNESS_WEIGHT: u64 = 1 /* num stack items */ +
@@ -199,7 +199,7 @@ impl_writeable_tlv_based!(StaticPaymentOutputDescriptor, {
 	(2, output, required),
 	(4, channel_keys_id, required),
 	(6, channel_value_satoshis, required),
-	(7, channel_transaction_parameters, (option: ReadableArgs, channel_value_satoshis.0.unwrap())),
+	(7, channel_transaction_parameters, (option: ReadableArgs, channel_value_satoshis.0)),
 });
 
 /// Describes the necessary information to spend a spendable output.
@@ -559,7 +559,7 @@ pub struct ChannelDerivationParameters {
 impl_writeable_tlv_based!(ChannelDerivationParameters, {
 	(0, value_satoshis, required),
 	(2, keys_id, required),
-	(4, transaction_parameters, (required: ReadableArgs, value_satoshis.0.unwrap())),
+	(4, transaction_parameters, (required: ReadableArgs, value_satoshis.0)),
 });
 
 /// A descriptor used to sign for a commitment transaction's HTLC output.