fixup! private fields in CommitmentTransaction

Author: devrandom

lightning/src/chain/channelmonitor.rs

@@ -974,18 +974,18 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 		// block for Rust 1.34 compat
 		let (holder_commitment_tx, current_holder_commitment_number) = {
 			let commitment_tx = &initial_holder_commitment_tx.inner;
-			let tx_keys = &commitment_tx.keys;
+			let tx_keys = commitment_tx.trust_key_derivation();
 			let holder_commitment_tx = HolderSignedTx {
 				txid,
 				revocation_key: tx_keys.revocation_key,
 				a_htlc_key: tx_keys.broadcaster_htlc_key,
 				b_htlc_key: tx_keys.countersignatory_htlc_key,
 				delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 				per_commitment_point: tx_keys.per_commitment_point,
-				feerate_per_kw: commitment_tx.feerate_per_kw,
+				feerate_per_kw: commitment_tx.feerate_per_kw(),
 				htlc_outputs: Vec::new(), // There are never any HTLCs in the initial commitment transactions
 			};
-			(holder_commitment_tx, commitment_tx.commitment_number)
+			(holder_commitment_tx, commitment_tx.commitment_number())
 		};
 		onchain_tx_handler.provide_latest_holder_tx(initial_holder_commitment_tx);
 
@@ -1148,16 +1148,16 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 		// block for Rust 1.34 compat
 		let mut new_holder_commitment_tx = {
 			let commitment_tx = &holder_commitment_tx.inner;
-			let tx_keys = &commitment_tx.keys;
-			self.current_holder_commitment_number = commitment_tx.commitment_number;
+			let tx_keys = &commitment_tx.trust_key_derivation();
+			self.current_holder_commitment_number = commitment_tx.commitment_number();
 			HolderSignedTx {
 				txid,
 				revocation_key: tx_keys.revocation_key,
 				a_htlc_key: tx_keys.broadcaster_htlc_key,
 				b_htlc_key: tx_keys.countersignatory_htlc_key,
 				delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 				per_commitment_point: tx_keys.per_commitment_point,
-				feerate_per_kw: commitment_tx.feerate_per_kw,
+				feerate_per_kw: commitment_tx.feerate_per_kw(),
 				htlc_outputs,
 			}
 		};

lightning/src/chain/keysinterface.rs

@@ -473,9 +473,9 @@ impl ChannelKeys for InMemoryChannelKeys {
 
 		let commitment_txid = commitment_tx.trust_txid();
 
-		let mut htlc_sigs = Vec::with_capacity(commitment_tx.htlcs.len());
-		for htlc in &commitment_tx.htlcs {
-			let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, commitment_tx.feerate_per_kw, self.holder_selected_contest_delay(), htlc, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
+		let mut htlc_sigs = Vec::with_capacity(commitment_tx.htlcs().len());
+		for htlc in commitment_tx.htlcs() {
+			let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, commitment_tx.feerate_per_kw(), self.holder_selected_contest_delay(), htlc, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
 			let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &keys);
 			let htlc_sighash = hash_to_message!(&bip143::SigHashCache::new(&htlc_tx).signature_hash(0, &htlc_redeemscript, htlc.amount_msat / 1000, SigHashType::All)[..]);
 			let holder_htlc_key = match chan_utils::derive_private_key(&secp_ctx, &keys.per_commitment_point, &self.htlc_base_key) {

lightning/src/ln/chan_utils.rs

@@ -822,15 +822,15 @@ impl BuiltCommitmentTransaction {
 /// secret key.
 #[derive(Clone)]
 pub struct CommitmentTransaction {
-	pub(crate) commitment_number: u64,
-	pub(crate) to_broadcaster_value_sat: u64,
-	pub(crate) to_countersignatory_value_sat: u64,
-	pub(crate) feerate_per_kw: u32,
-	pub(crate) htlcs: Vec<HTLCOutputInCommitment>,
+	commitment_number: u64,
+	to_broadcaster_value_sat: u64,
+	to_countersignatory_value_sat: u64,
+	feerate_per_kw: u32,
+	htlcs: Vec<HTLCOutputInCommitment>,
 	// A cache of the parties' pubkeys required to construct the transaction
-	pub(crate) keys: TxCreationKeys,
+	keys: TxCreationKeys,
 	// For access to the built transaction, see doc for trust_built_transaction
-	pub(crate) built: BuiltCommitmentTransaction,
+	built: BuiltCommitmentTransaction,
 }
 
 impl PartialEq for CommitmentTransaction {

lightning/src/ln/channel.rs

@@ -1468,7 +1468,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 		let keys = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number)?;
 		let initial_commitment_tx = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &keys, true, false, self.feerate_per_kw, logger).0;
 		{
-			let initial_commitment_bitcoin_tx = &initial_commitment_tx.built;
+			let initial_commitment_bitcoin_tx = initial_commitment_tx.trust_built_transaction();
 			let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.channel_value_satoshis);
 			// They sign the holder commitment transaction...
 			log_trace!(logger, "Checking funding_created tx signature {} by key {} against tx {} (sighash {}) with redeemscript {}", log_bytes!(sig.serialize_compact()[..]), log_bytes!(self.counterparty_funding_pubkey().serialize()), encode::serialize_hex(&initial_commitment_bitcoin_tx.transaction), log_bytes!(sighash[..]), encode::serialize_hex(&funding_script));
@@ -1478,7 +1478,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 		let counterparty_keys = self.build_remote_transaction_keys()?;
 		let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, self.feerate_per_kw, logger).0;
 
-		let counterparty_initial_bitcoin_tx = &counterparty_initial_commitment_tx.built;
+		let counterparty_initial_bitcoin_tx = &counterparty_initial_commitment_tx.trust_built_transaction();
 		log_trace!(logger, "Initial counterparty ID {} tx {}", counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
 
 		let counterparty_signature = self.holder_keys.sign_counterparty_commitment(&counterparty_initial_commitment_tx, &self.secp_ctx)
@@ -1580,14 +1580,14 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 		let counterparty_keys = self.build_remote_transaction_keys()?;
 		let counterparty_initial_commitment_tx = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, self.feerate_per_kw, logger).0;
 		// TODO the txid is not integration tested
-		let counterparty_initial_bitcoin_tx = counterparty_initial_commitment_tx.built;
+		let counterparty_initial_bitcoin_tx = counterparty_initial_commitment_tx.trust_built_transaction();
 
 		log_trace!(logger, "Initial counterparty ID {} tx {}", counterparty_initial_bitcoin_tx.txid, encode::serialize_hex(&counterparty_initial_bitcoin_tx.transaction));
 
 		let holder_keys = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number)?;
 		let initial_commitment_tx = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &holder_keys, true, false, self.feerate_per_kw, logger).0;
 		{
-			let initial_commitment_bitcoin_tx = &initial_commitment_tx.built;
+			let initial_commitment_bitcoin_tx = &initial_commitment_tx.trust_built_transaction();
 			let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.channel_value_satoshis);
 			// They sign our commitment transaction, allowing us to broadcast the tx if we wish.
 			if let Err(_) = self.secp_ctx.verify(&sighash, &msg.signature, &self.get_counterparty_pubkeys().funding_pubkey) {
@@ -1982,7 +1982,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 		let (num_htlcs, mut htlcs_cloned, commitment_tx, commitment_txid) = {
 			let commitment_tx = self.build_commitment_transaction(self.cur_holder_commitment_transaction_number, &keys, true, false, feerate_per_kw, logger);
 			let commitment_txid = {
-				let initial_commitment_bitcoin_tx = &commitment_tx.0.built;
+				let initial_commitment_bitcoin_tx = &commitment_tx.0.trust_built_transaction();
 				let sighash = initial_commitment_bitcoin_tx.get_sighash_all(&funding_script, self.channel_value_satoshis);
 
 				let commitment_txid = initial_commitment_bitcoin_tx.txid;
@@ -4756,7 +4756,7 @@ mod tests {
 				let htlc_sigs = chan_keys.sign_holder_commitment_htlc_transactions(&holder_commitment_tx, &secp_ctx).unwrap();
 
 				// ((htlc, counterparty_sig), (index, holder_sig))
-				let mut htlc_sig_iter = holder_commitment_tx.inner.htlcs.iter().zip(holder_commitment_tx.counterparty_htlc_sigs).zip(htlc_sigs.iter().enumerate());
+				let mut htlc_sig_iter = holder_commitment_tx.inner.htlcs().iter().zip(holder_commitment_tx.counterparty_htlc_sigs).zip(htlc_sigs.iter().enumerate());
 
 				$({
 					let remote_signature = Signature::from_der(&hex::decode($counterparty_htlc_sig_hex).unwrap()[..]).unwrap();

lightning/src/ln/onchaintx.rs

@@ -651,7 +651,7 @@ impl<ChanSigner: ChannelKeys> OnchainTxHandler<ChanSigner> {
 						let signed_tx = self.get_fully_signed_holder_tx(funding_redeemscript).unwrap();
 						// Timer set to $NEVER given we can't bump tx without anchor outputs
 						log_trace!(logger, "Going to broadcast Holder Transaction {} claiming funding output {} from {}...", signed_tx.txid(), outp.vout, outp.txid);
-						return Some((None, self.holder_commitment.as_ref().unwrap().inner.feerate_per_kw, signed_tx));
+						return Some((None, self.holder_commitment.as_ref().unwrap().inner.feerate_per_kw(), signed_tx));
 					}
 					_ => unreachable!()
 				}
@@ -915,7 +915,7 @@ impl<ChanSigner: ChannelKeys> OnchainTxHandler<ChanSigner> {
 
 	fn extract_holder_sigs(holder_commitment: &HolderCommitmentTransaction, sigs: Vec<Signature>) -> Vec<Option<(usize, Signature)>> {
 		let mut ret = Vec::new();
-		for (htlc_idx, (holder_sig, htlc)) in sigs.iter().zip(holder_commitment.inner.htlcs.iter()).enumerate() {
+		for (htlc_idx, (holder_sig, htlc)) in sigs.iter().zip(holder_commitment.inner.htlcs().iter()).enumerate() {
 			let tx_idx = htlc.transaction_output_index.unwrap();
 			if ret.len() <= tx_idx as usize { ret.resize(tx_idx as usize + 1, None); }
 			ret[tx_idx as usize] = Some((htlc_idx, holder_sig.clone()));

lightning/src/util/enforcing_trait_impls.rs

@@ -79,12 +79,13 @@ impl ChannelKeys for EnforcingChannelKeys {
 		self.check_keys(secp_ctx, commitment_tx.trust_key_derivation());
 
 		{
-			let mut last_commitment_number = self.last_commitment_number.lock().unwrap();
-			let commitment_number = last_commitment_number.unwrap_or(commitment_tx.commitment_number);
+			let mut last_commitment_number_guard = self.last_commitment_number.lock().unwrap();
+			let actual_commitment_number = commitment_tx.commitment_number();
+			let last_commitment_number = last_commitment_number_guard.unwrap_or(actual_commitment_number);
 			// These commitment numbers are backwards counting.  We expect either the same as the previously encountered,
 			// or the next one.
-			assert!(commitment_number == commitment_tx.commitment_number || commitment_number - 1 == commitment_tx.commitment_number, "{} doesn't come after {}", commitment_tx.commitment_number, commitment_number);
-			*last_commitment_number = Some(cmp::min(commitment_number, commitment_tx.commitment_number))
+			assert!(last_commitment_number == actual_commitment_number || last_commitment_number - 1 == actual_commitment_number, "{} doesn't come after {}", actual_commitment_number, last_commitment_number);
+			*last_commitment_number_guard = Some(cmp::min(last_commitment_number, actual_commitment_number))
 		}
 
 		Ok(self.inner.sign_counterparty_commitment(commitment_tx, secp_ctx).unwrap())
@@ -106,10 +107,10 @@ impl ChannelKeys for EnforcingChannelKeys {
 		let commitment_txid = commitment_tx.trust_txid();
 		let holder_csv = self.inner.counterparty_selected_contest_delay();
 
-		for (this_htlc, sig) in commitment_tx.htlcs.iter().zip(&holder_commitment_tx.counterparty_htlc_sigs) {
+		for (this_htlc, sig) in commitment_tx.htlcs().iter().zip(&holder_commitment_tx.counterparty_htlc_sigs) {
 			assert!(this_htlc.transaction_output_index.is_some());
-			let keys = &commitment_tx.keys;
-			let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, commitment_tx.feerate_per_kw, holder_csv, &this_htlc, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
+			let keys = &commitment_tx.trust_key_derivation();
+			let htlc_tx = chan_utils::build_htlc_transaction(&commitment_txid, commitment_tx.feerate_per_kw(), holder_csv, &this_htlc, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
 
 			let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&this_htlc, &keys);