Merge pull request #3682 from tankyleo/commitment-stats-less-duplication

Add `ChannelContext::get_commitment_stats`

Author: wpaulino

lightning/src/chain/channelmonitor.rs

@@ -317,7 +317,7 @@ impl HolderCommitment {
 		let delayed_payment_key = &tx_keys.broadcaster_delayed_payment_key;
 		let per_commitment_point = &tx_keys.per_commitment_point;
 
-		let mut nondust_htlcs = self.tx.htlcs().iter().zip(self.tx.counterparty_htlc_sigs.iter());
+		let mut nondust_htlcs = self.tx.nondust_htlcs().iter().zip(self.tx.counterparty_htlc_sigs.iter());
 		let mut sources = self.nondust_htlc_sources.iter();
 
 		// Use an iterator to write `htlc_outputs` to avoid allocations.
@@ -937,7 +937,7 @@ impl TryFrom<(HolderCommitmentTransaction, HolderSignedTx)> for HolderCommitment
 		// HTLC sources, separately. All offered, non-dust HTLCs must have a source available.
 
 		let mut missing_nondust_source = false;
-		let mut nondust_htlc_sources = Vec::with_capacity(holder_commitment_tx.htlcs().len());
+		let mut nondust_htlc_sources = Vec::with_capacity(holder_commitment_tx.nondust_htlcs().len());
 		let dust_htlcs = holder_signed_tx.htlc_outputs.into_iter().filter_map(|(htlc, _, source)| {
 			// Filter our non-dust HTLCs, while at the same time pushing their sources into
 			// `nondust_htlc_sources`.
@@ -967,16 +967,16 @@ impl TryFrom<(HolderCommitmentTransaction, HolderSignedTx)> for HolderCommitment
 
 impl HolderCommitment {
 	fn has_htlcs(&self) -> bool {
-		self.tx.htlcs().len() > 0 || self.dust_htlcs.len() > 0
+		self.tx.nondust_htlcs().len() > 0 || self.dust_htlcs.len() > 0
 	}
 
 	fn htlcs(&self) -> impl Iterator<Item = &HTLCOutputInCommitment> {
-		self.tx.htlcs().iter().chain(self.dust_htlcs.iter().map(|(htlc, _)| htlc))
+		self.tx.nondust_htlcs().iter().chain(self.dust_htlcs.iter().map(|(htlc, _)| htlc))
 	}
 
 	fn htlcs_with_sources(&self) -> impl Iterator<Item = (&HTLCOutputInCommitment, Option<&HTLCSource>)> {
 		let mut sources = self.nondust_htlc_sources.iter();
-		let nondust_htlcs = self.tx.htlcs().iter().map(move |htlc| {
+		let nondust_htlcs = self.tx.nondust_htlcs().iter().map(move |htlc| {
 			let mut source = None;
 			if htlc.offered && htlc.transaction_output_index.is_some() {
 				source = sources.next();
@@ -3098,8 +3098,8 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			// If we have non-dust HTLCs in htlc_outputs, ensure they match the HTLCs in the
 			// `holder_commitment_tx`. In the future, we'll no longer provide the redundant data
 			// and just pass in source data via `nondust_htlc_sources`.
-			debug_assert_eq!(htlc_outputs.iter().filter(|(_, s, _)| s.is_some()).count(), holder_commitment_tx.trust().htlcs().len());
-			for (a, b) in htlc_outputs.iter().filter(|(_, s, _)| s.is_some()).map(|(h, _, _)| h).zip(holder_commitment_tx.trust().htlcs().iter()) {
+			debug_assert_eq!(htlc_outputs.iter().filter(|(_, s, _)| s.is_some()).count(), holder_commitment_tx.trust().nondust_htlcs().len());
+			for (a, b) in htlc_outputs.iter().filter(|(_, s, _)| s.is_some()).map(|(h, _, _)| h).zip(holder_commitment_tx.trust().nondust_htlcs().iter()) {
 				debug_assert_eq!(a, b);
 			}
 			debug_assert_eq!(htlc_outputs.iter().filter(|(_, s, _)| s.is_some()).count(), holder_commitment_tx.counterparty_htlc_sigs.len());
@@ -3109,7 +3109,7 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 
 			// Backfill the non-dust HTLC sources.
 			debug_assert!(nondust_htlc_sources.is_empty());
-			nondust_htlc_sources.reserve_exact(holder_commitment_tx.htlcs().len());
+			nondust_htlc_sources.reserve_exact(holder_commitment_tx.nondust_htlcs().len());
 			let dust_htlcs = htlc_outputs.into_iter().filter_map(|(htlc, _, source)| {
 				// Filter our non-dust HTLCs, while at the same time pushing their sources into
 				// `nondust_htlc_sources`.
@@ -3129,18 +3129,18 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			// `nondust_htlc_sources` and the `holder_commitment_tx`
 			{
 				let mut prev = -1;
-				for htlc in holder_commitment_tx.trust().htlcs().iter() {
+				for htlc in holder_commitment_tx.trust().nondust_htlcs().iter() {
 					assert!(htlc.transaction_output_index.unwrap() as i32 > prev);
 					prev = htlc.transaction_output_index.unwrap() as i32;
 				}
 			}
 
 			debug_assert!(htlc_outputs.iter().all(|(htlc, _, _)| htlc.transaction_output_index.is_none()));
 			debug_assert!(htlc_outputs.iter().all(|(_, sig_opt, _)| sig_opt.is_none()));
-			debug_assert_eq!(holder_commitment_tx.trust().htlcs().len(), holder_commitment_tx.counterparty_htlc_sigs.len());
+			debug_assert_eq!(holder_commitment_tx.trust().nondust_htlcs().len(), holder_commitment_tx.counterparty_htlc_sigs.len());
 
 			let mut sources = nondust_htlc_sources.iter();
-			for htlc in holder_commitment_tx.trust().htlcs().iter() {
+			for htlc in holder_commitment_tx.trust().nondust_htlcs().iter() {
 				if htlc.offered {
 					let source = sources.next().expect("Non-dust HTLC sources didn't match commitment tx");
 					assert!(source.possibly_matches_output(htlc));
@@ -3955,9 +3955,9 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 		&self, holder_tx: &HolderCommitmentTransaction,
 	) -> Vec<HTLCDescriptor> {
 		let tx = holder_tx.trust();
-		let mut htlcs = Vec::with_capacity(holder_tx.htlcs().len());
-		debug_assert_eq!(holder_tx.htlcs().len(), holder_tx.counterparty_htlc_sigs.len());
-		for (htlc, counterparty_sig) in holder_tx.htlcs().iter().zip(holder_tx.counterparty_htlc_sigs.iter()) {
+		let mut htlcs = Vec::with_capacity(holder_tx.nondust_htlcs().len());
+		debug_assert_eq!(holder_tx.nondust_htlcs().len(), holder_tx.counterparty_htlc_sigs.len());
+		for (htlc, counterparty_sig) in holder_tx.nondust_htlcs().iter().zip(holder_tx.counterparty_htlc_sigs.iter()) {
 			assert!(htlc.transaction_output_index.is_some(), "Expected transaction output index for non-dust HTLC");
 
 			let preimage = if htlc.offered {
@@ -4026,9 +4026,9 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 
 	// Returns holder HTLC outputs to watch and react to in case of spending.
 	fn get_broadcasted_holder_watch_outputs(&self, holder_tx: &HolderCommitmentTransaction) -> Vec<(u32, TxOut)> {
-		let mut watch_outputs = Vec::with_capacity(holder_tx.htlcs().len());
+		let mut watch_outputs = Vec::with_capacity(holder_tx.nondust_htlcs().len());
 		let tx = holder_tx.trust();
-		for htlc in holder_tx.htlcs() {
+		for htlc in holder_tx.nondust_htlcs() {
 			if let Some(transaction_output_index) = htlc.transaction_output_index {
 				watch_outputs.push((
 					transaction_output_index,
@@ -4121,7 +4121,7 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			let txid = self.funding.current_holder_commitment.tx.trust().txid();
 			log_trace!(logger, "Canceling claims for previously broadcast holder commitment {}", txid);
 			let mut outpoint = BitcoinOutPoint { txid, vout: 0 };
-			for htlc in self.funding.current_holder_commitment.tx.htlcs() {
+			for htlc in self.funding.current_holder_commitment.tx.nondust_htlcs() {
 				if let Some(vout) = htlc.transaction_output_index {
 					outpoint.vout = vout;
 					self.onchain_tx_handler.abandon_claim(&outpoint);
@@ -4135,7 +4135,7 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			if txid != *confirmed_commitment_txid {
 				log_trace!(logger, "Canceling claims for previously broadcast holder commitment {}", txid);
 				let mut outpoint = BitcoinOutPoint { txid, vout: 0 };
-				for htlc in prev_holder_commitment.tx.htlcs() {
+				for htlc in prev_holder_commitment.tx.nondust_htlcs() {
 					if let Some(vout) = htlc.transaction_output_index {
 						outpoint.vout = vout;
 						self.onchain_tx_handler.abandon_claim(&outpoint);

lightning/src/chain/onchaintx.rs

@@ -688,7 +688,7 @@ impl<ChannelSigner: EcdsaChannelSigner> OnchainTxHandler<ChannelSigner> {
 								OnchainClaim::Event(ClaimEvent::BumpCommitment {
 									package_target_feerate_sat_per_1000_weight,
 									commitment_tx: tx,
-									pending_nondust_htlcs: holder_commitment.htlcs().to_vec(),
+									pending_nondust_htlcs: holder_commitment.nondust_htlcs().to_vec(),
 									commitment_tx_fee_satoshis: fee_sat,
 									anchor_output_idx: idx,
 									channel_parameters: channel_parameters.clone(),
@@ -1339,7 +1339,7 @@ mod tests {
 		let holder_commit = tx_handler.current_holder_commitment_tx();
 		let holder_commit_txid = holder_commit.trust().txid();
 		let mut requests = Vec::new();
-		for (htlc, counterparty_sig) in holder_commit.htlcs().iter().zip(holder_commit.counterparty_htlc_sigs.iter()) {
+		for (htlc, counterparty_sig) in holder_commit.nondust_htlcs().iter().zip(holder_commit.counterparty_htlc_sigs.iter()) {
 			requests.push(PackageTemplate::build_package(
 				holder_commit_txid,
 				htlc.transaction_output_index.unwrap(),

lightning/src/chain/package.rs

@@ -472,7 +472,7 @@ impl HolderHTLCOutput {
 			}
 
 			let (htlc, counterparty_sig) =
-				trusted_tx.htlcs().iter().zip(holder_commitment.counterparty_htlc_sigs.iter())
+				trusted_tx.nondust_htlcs().iter().zip(holder_commitment.counterparty_htlc_sigs.iter())
 					.find(|(htlc, _)| htlc.transaction_output_index.unwrap() == outp.vout)
 					.unwrap();
 

lightning/src/ln/chan_utils.rs

@@ -1430,7 +1430,7 @@ pub struct CommitmentTransaction {
 	feerate_per_kw: u32,
 	// The set of non-dust HTLCs included in the commitment. They must be sorted in increasing
 	// output index order.
-	htlcs: Vec<HTLCOutputInCommitment>,
+	nondust_htlcs: Vec<HTLCOutputInCommitment>,
 	// Note that on upgrades, some features of existing outputs may be missed.
 	channel_type_features: ChannelTypeFeatures,
 	// A cache of the parties' pubkeys required to construct the transaction, see doc for trust()
@@ -1446,7 +1446,7 @@ impl PartialEq for CommitmentTransaction {
 			self.to_broadcaster_value_sat == o.to_broadcaster_value_sat &&
 			self.to_countersignatory_value_sat == o.to_countersignatory_value_sat &&
 			self.feerate_per_kw == o.feerate_per_kw &&
-			self.htlcs == o.htlcs &&
+			self.nondust_htlcs == o.nondust_htlcs &&
 			self.channel_type_features == o.channel_type_features &&
 			self.keys == o.keys;
 		if eq {
@@ -1468,7 +1468,7 @@ impl Writeable for CommitmentTransaction {
 			(6, self.feerate_per_kw, required),
 			(8, self.keys, required),
 			(10, self.built, required),
-			(12, self.htlcs, required_vec),
+			(12, self.nondust_htlcs, required_vec),
 			(14, legacy_deserialization_prevention_marker, option),
 			(15, self.channel_type_features, required),
 		});
@@ -1486,7 +1486,7 @@ impl Readable for CommitmentTransaction {
 			(6, feerate_per_kw, required),
 			(8, keys, required),
 			(10, built, required),
-			(12, htlcs, required_vec),
+			(12, nondust_htlcs, required_vec),
 			(14, _legacy_deserialization_prevention_marker, (option, explicit_type: ())),
 			(15, channel_type_features, option),
 		});
@@ -1503,7 +1503,7 @@ impl Readable for CommitmentTransaction {
 			feerate_per_kw: feerate_per_kw.0.unwrap(),
 			keys: keys.0.unwrap(),
 			built: built.0.unwrap(),
-			htlcs,
+			nondust_htlcs,
 			channel_type_features: channel_type_features.unwrap_or(ChannelTypeFeatures::only_static_remote_key())
 		})
 	}
@@ -1526,7 +1526,7 @@ impl CommitmentTransaction {
 		let keys = TxCreationKeys::from_channel_static_keys(per_commitment_point, channel_parameters.broadcaster_pubkeys(), channel_parameters.countersignatory_pubkeys(), secp_ctx);
 
 		// Sort outputs and populate output indices while keeping track of the auxiliary data
-		let (outputs, htlcs) = Self::internal_build_outputs(&keys, to_broadcaster_value_sat, to_countersignatory_value_sat, htlcs_with_aux, channel_parameters);
+		let (outputs, nondust_htlcs) = Self::internal_build_outputs(&keys, to_broadcaster_value_sat, to_countersignatory_value_sat, htlcs_with_aux, channel_parameters);
 
 		let (obscured_commitment_transaction_number, txins) = Self::internal_build_inputs(commitment_number, channel_parameters);
 		let transaction = Self::make_transaction(obscured_commitment_transaction_number, txins, outputs);
@@ -1537,7 +1537,7 @@ impl CommitmentTransaction {
 			to_countersignatory_value_sat,
 			to_broadcaster_delay: Some(channel_parameters.contest_delay()),
 			feerate_per_kw,
-			htlcs,
+			nondust_htlcs,
 			channel_type_features: channel_parameters.channel_type_features().clone(),
 			keys,
 			built: BuiltCommitmentTransaction {
@@ -1558,7 +1558,7 @@ impl CommitmentTransaction {
 	fn internal_rebuild_transaction(&self, keys: &TxCreationKeys, channel_parameters: &DirectedChannelTransactionParameters) -> BuiltCommitmentTransaction {
 		let (obscured_commitment_transaction_number, txins) = Self::internal_build_inputs(self.commitment_number, channel_parameters);
 
-		let mut htlcs_with_aux = self.htlcs.iter().map(|h| (h.clone(), ())).collect();
+		let mut htlcs_with_aux = self.nondust_htlcs.iter().map(|h| (h.clone(), ())).collect();
 		let (outputs, _) = Self::internal_build_outputs(keys, self.to_broadcaster_value_sat, self.to_countersignatory_value_sat, &mut htlcs_with_aux, channel_parameters);
 
 		let transaction = Self::make_transaction(obscured_commitment_transaction_number, txins, outputs);
@@ -1653,7 +1653,7 @@ impl CommitmentTransaction {
 			}
 		}
 
-		let mut htlcs = Vec::with_capacity(htlcs_with_aux.len());
+		let mut nondust_htlcs = Vec::with_capacity(htlcs_with_aux.len());
 		for (htlc, _) in htlcs_with_aux {
 			let script = get_htlc_redeemscript(htlc, channel_type, keys);
 			let txout = TxOut {
@@ -1683,11 +1683,11 @@ impl CommitmentTransaction {
 		for (idx, out) in txouts.drain(..).enumerate() {
 			if let Some(htlc) = out.1 {
 				htlc.transaction_output_index = Some(idx as u32);
-				htlcs.push(htlc.clone());
+				nondust_htlcs.push(htlc.clone());
 			}
 			outputs.push(out.0);
 		}
-		(outputs, htlcs)
+		(outputs, nondust_htlcs)
 	}
 
 	fn internal_build_inputs(commitment_number: u64, channel_parameters: &DirectedChannelTransactionParameters) -> (u64, Vec<TxIn>) {
@@ -1746,8 +1746,8 @@ impl CommitmentTransaction {
 	///
 	/// This is not exported to bindings users as we cannot currently convert Vec references to/from C, though we should
 	/// expose a less effecient version which creates a Vec of references in the future.
-	pub fn htlcs(&self) -> &Vec<HTLCOutputInCommitment> {
-		&self.htlcs
+	pub fn nondust_htlcs(&self) -> &Vec<HTLCOutputInCommitment> {
+		&self.nondust_htlcs
 	}
 
 	/// Trust our pre-built transaction and derived transaction creation public keys.
@@ -1831,10 +1831,10 @@ impl<'a> TrustedCommitmentTransaction<'a> {
 		let inner = self.inner;
 		let keys = &inner.keys;
 		let txid = inner.built.txid;
-		let mut ret = Vec::with_capacity(inner.htlcs.len());
+		let mut ret = Vec::with_capacity(inner.nondust_htlcs.len());
 		let holder_htlc_key = derive_private_key(secp_ctx, &inner.keys.per_commitment_point, htlc_base_key);
 
-		for this_htlc in inner.htlcs.iter() {
+		for this_htlc in inner.nondust_htlcs.iter() {
 			assert!(this_htlc.transaction_output_index.is_some());
 			let htlc_tx = build_htlc_transaction(&txid, inner.feerate_per_kw, channel_parameters.contest_delay(), &this_htlc, &self.channel_type_features, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);