Remove InputDescriptors by named constants

Author: Antoine Riard

lightning/src/chain/channelmonitor.rs

@@ -44,7 +44,7 @@ use chain::chaininterface::{BroadcasterInterface, FeeEstimator};
 use chain::transaction::{OutPoint, TransactionData};
 use chain::keysinterface::{SpendableOutputDescriptor, StaticPaymentOutputDescriptor, DelayedPaymentOutputDescriptor, Sign, KeysInterface};
 use chain::onchaintx::OnchainTxHandler;
-use chain::onchain_utils::{CounterpartyHTLCOutput, HolderFundingOutput, HolderHTLCOutput, InputDescriptors, PackageMalleability, PackageSolvingData, PackageTemplate, RevokedOutput};
+use chain::onchain_utils::{CounterpartyHTLCOutput, HolderFundingOutput, HolderHTLCOutput, PackageMalleability, PackageSolvingData, PackageTemplate, RevokedOutput, WEIGHT_REVOKED_OUTPUT, WEIGHT_REVOKED_RECEIVED_HTLC, WEIGHT_REVOKED_OFFERED_HTLC};
 use chain::Filter;
 use util::logger::Logger;
 use util::ser::{Readable, ReadableArgs, MaybeReadable, Writer, Writeable, U48};
@@ -1571,7 +1571,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 			// First, process non-htlc outputs (to_holder & to_counterparty)
 			for (idx, outp) in tx.output.iter().enumerate() {
 				if outp.script_pubkey == revokeable_p2wsh {
-					let revk_outp = RevokedOutput::build(per_commitment_point, per_commitment_key, self.counterparty_tx_cache.counterparty_delayed_payment_base_key, self.counterparty_tx_cache.counterparty_htlc_base_key, InputDescriptors::RevokedOutput, outp.value, None, self.counterparty_tx_cache.on_counterparty_tx_csv);
+					let revk_outp = RevokedOutput::build(per_commitment_point, per_commitment_key, self.counterparty_tx_cache.counterparty_delayed_payment_base_key, self.counterparty_tx_cache.counterparty_htlc_base_key, WEIGHT_REVOKED_OUTPUT, outp.value, None, self.counterparty_tx_cache.on_counterparty_tx_csv);
 					let justice_package = PackageTemplate::build_package(commitment_txid, idx as u32, PackageSolvingData::RevokedOutput(revk_outp), PackageMalleability::Malleable, height + self.counterparty_tx_cache.on_counterparty_tx_csv as u32, true, 0, None, height);
 					claimable_outpoints.push(justice_package);
 				}
@@ -1585,7 +1585,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 								tx.output[transaction_output_index as usize].value != htlc.amount_msat / 1000 {
 							return (claimable_outpoints, (commitment_txid, watch_outputs)); // Corrupted per_commitment_data, fuck this user
 						}
-						let revk_outp = RevokedOutput::build(per_commitment_point, per_commitment_key, self.counterparty_tx_cache.counterparty_delayed_payment_base_key, self.counterparty_tx_cache.counterparty_htlc_base_key, if htlc.offered { InputDescriptors::RevokedOfferedHTLC } else { InputDescriptors::RevokedReceivedHTLC }, htlc.amount_msat / 1000, Some(htlc.clone()), self.counterparty_tx_cache.on_counterparty_tx_csv);
+						let revk_outp = RevokedOutput::build(per_commitment_point, per_commitment_key, self.counterparty_tx_cache.counterparty_delayed_payment_base_key, self.counterparty_tx_cache.counterparty_htlc_base_key, if htlc.offered { WEIGHT_REVOKED_OFFERED_HTLC } else { WEIGHT_REVOKED_RECEIVED_HTLC }, htlc.amount_msat / 1000, Some(htlc.clone()), self.counterparty_tx_cache.on_counterparty_tx_csv);
 						let justice_package = PackageTemplate::build_package(commitment_txid, transaction_output_index, PackageSolvingData::RevokedOutput(revk_outp), PackageMalleability::Malleable, htlc.cltv_expiry, true, 0, None, height);
 						claimable_outpoints.push(justice_package);
 					}
@@ -1767,7 +1767,7 @@ impl<Signer: Sign> ChannelMonitorImpl<Signer> {
 		let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key);
 
 		log_trace!(logger, "Counterparty HTLC broadcast {}:{}", htlc_txid, 0);
-		let revk_outp = RevokedOutput::build(per_commitment_point, per_commitment_key, self.counterparty_tx_cache.counterparty_delayed_payment_base_key, self.counterparty_tx_cache.counterparty_htlc_base_key, InputDescriptors::RevokedOutput, tx.output[0].value, None, self.counterparty_tx_cache.on_counterparty_tx_csv);
+		let revk_outp = RevokedOutput::build(per_commitment_point, per_commitment_key, self.counterparty_tx_cache.counterparty_delayed_payment_base_key, self.counterparty_tx_cache.counterparty_htlc_base_key, WEIGHT_REVOKED_OUTPUT, tx.output[0].value, None, self.counterparty_tx_cache.on_counterparty_tx_csv);
 		let justice_package = PackageTemplate::build_package(htlc_txid, 0, PackageSolvingData::RevokedOutput(revk_outp), PackageMalleability::Malleable, height + self.counterparty_tx_cache.on_counterparty_tx_csv as u32, true, 0, None, height);
 		let claimable_outpoints = vec!(justice_package);
 		let outputs = vec![(0, tx.output[0].clone())];
@@ -2902,8 +2902,7 @@ mod tests {
 	use bitcoin::network::constants::Network;
 	use hex;
 	use chain::channelmonitor::ChannelMonitor;
-	use chain::onchain_utils;
-	use chain::onchain_utils::InputDescriptors;
+	use chain::onchain_utils::{WEIGHT_OFFERED_HTLC, WEIGHT_RECEIVED_HTLC, WEIGHT_REVOKED_OFFERED_HTLC, WEIGHT_REVOKED_RECEIVED_HTLC, WEIGHT_REVOKED_OUTPUT};
 	use chain::transaction::OutPoint;
 	use ln::{PaymentPreimage, PaymentHash};
 	use ln::channelmanager::BestBlock;
@@ -3062,25 +3061,25 @@ mod tests {
 		let mut sum_actual_sigs = 0;
 
 		macro_rules! sign_input {
-			($sighash_parts: expr, $idx: expr, $amount: expr, $input_type: expr, $sum_actual_sigs: expr) => {
+			($sighash_parts: expr, $idx: expr, $amount: expr, $weight: expr, $sum_actual_sigs: expr) => {
 				let htlc = HTLCOutputInCommitment {
-					offered: if *$input_type == InputDescriptors::RevokedOfferedHTLC || *$input_type == InputDescriptors::OfferedHTLC { true } else { false },
+					offered: if *$weight == WEIGHT_REVOKED_OFFERED_HTLC || *$weight == WEIGHT_OFFERED_HTLC { true } else { false },
 					amount_msat: 0,
 					cltv_expiry: 2 << 16,
 					payment_hash: PaymentHash([1; 32]),
 					transaction_output_index: Some($idx as u32),
 				};
-				let redeem_script = if *$input_type == InputDescriptors::RevokedOutput { chan_utils::get_revokeable_redeemscript(&pubkey, 256, &pubkey) } else { chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, &pubkey, &pubkey, &pubkey) };
+				let redeem_script = if *$weight == WEIGHT_REVOKED_OUTPUT { chan_utils::get_revokeable_redeemscript(&pubkey, 256, &pubkey) } else { chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, &pubkey, &pubkey, &pubkey) };
 				let sighash = hash_to_message!(&$sighash_parts.signature_hash($idx, &redeem_script, $amount, SigHashType::All)[..]);
 				let sig = secp_ctx.sign(&sighash, &privkey);
 				$sighash_parts.access_witness($idx).push(sig.serialize_der().to_vec());
 				$sighash_parts.access_witness($idx)[0].push(SigHashType::All as u8);
 				sum_actual_sigs += $sighash_parts.access_witness($idx)[0].len();
-				if *$input_type == InputDescriptors::RevokedOutput {
+				if *$weight == WEIGHT_REVOKED_OUTPUT {
 					$sighash_parts.access_witness($idx).push(vec!(1));
-				} else if *$input_type == InputDescriptors::RevokedOfferedHTLC || *$input_type == InputDescriptors::RevokedReceivedHTLC {
+				} else if *$weight == WEIGHT_REVOKED_OFFERED_HTLC || *$weight == WEIGHT_REVOKED_RECEIVED_HTLC {
 					$sighash_parts.access_witness($idx).push(pubkey.clone().serialize().to_vec());
-				} else if *$input_type == InputDescriptors::ReceivedHTLC {
+				} else if *$weight == WEIGHT_RECEIVED_HTLC {
 					$sighash_parts.access_witness($idx).push(vec![0]);
 				} else {
 					$sighash_parts.access_witness($idx).push(PaymentPreimage([1; 32]).0.to_vec());
@@ -3113,14 +3112,16 @@ mod tests {
 			value: 0,
 		});
 		let base_weight = claim_tx.get_weight();
-		let inputs_des = vec![InputDescriptors::RevokedOutput, InputDescriptors::RevokedOfferedHTLC, InputDescriptors::RevokedOfferedHTLC, InputDescriptors::RevokedReceivedHTLC];
+		let inputs_weight = vec![WEIGHT_REVOKED_OUTPUT, WEIGHT_REVOKED_OFFERED_HTLC, WEIGHT_REVOKED_OFFERED_HTLC, WEIGHT_REVOKED_RECEIVED_HTLC];
+		let mut inputs_total_weight = 2; // count segwit flags
 		{
 			let mut sighash_parts = bip143::SigHashCache::new(&mut claim_tx);
-			for (idx, inp) in inputs_des.iter().enumerate() {
+			for (idx, inp) in inputs_weight.iter().enumerate() {
 				sign_input!(sighash_parts, idx, 0, inp, sum_actual_sigs);
+				inputs_total_weight += inp;
 			}
 		}
-		assert_eq!(base_weight + onchain_utils::get_witnesses_weight(&inputs_des[..]),  claim_tx.get_weight() + /* max_length_sig */ (73 * inputs_des.len() - sum_actual_sigs));
+		assert_eq!(base_weight + inputs_total_weight as usize,  claim_tx.get_weight() + /* max_length_sig */ (73 * inputs_weight.len() - sum_actual_sigs));
 
 		// Claim tx with 1 offered HTLCs, 3 received HTLCs
 		claim_tx.input.clear();
@@ -3137,14 +3138,16 @@ mod tests {
 			});
 		}
 		let base_weight = claim_tx.get_weight();
-		let inputs_des = vec![InputDescriptors::OfferedHTLC, InputDescriptors::ReceivedHTLC, InputDescriptors::ReceivedHTLC, InputDescriptors::ReceivedHTLC];
+		let inputs_weight = vec![WEIGHT_OFFERED_HTLC, WEIGHT_RECEIVED_HTLC, WEIGHT_RECEIVED_HTLC, WEIGHT_RECEIVED_HTLC];
+		let mut inputs_total_weight = 2; // count segwit flags
 		{
 			let mut sighash_parts = bip143::SigHashCache::new(&mut claim_tx);
-			for (idx, inp) in inputs_des.iter().enumerate() {
+			for (idx, inp) in inputs_weight.iter().enumerate() {
 				sign_input!(sighash_parts, idx, 0, inp, sum_actual_sigs);
+				inputs_total_weight += inp;
 			}
 		}
-		assert_eq!(base_weight + onchain_utils::get_witnesses_weight(&inputs_des[..]),  claim_tx.get_weight() + /* max_length_sig */ (73 * inputs_des.len() - sum_actual_sigs));
+		assert_eq!(base_weight + inputs_total_weight as usize,  claim_tx.get_weight() + /* max_length_sig */ (73 * inputs_weight.len() - sum_actual_sigs));
 
 		// Justice tx with 1 revoked HTLC-Success tx output
 		claim_tx.input.clear();
@@ -3159,14 +3162,16 @@ mod tests {
 			witness: Vec::new(),
 		});
 		let base_weight = claim_tx.get_weight();
-		let inputs_des = vec![InputDescriptors::RevokedOutput];
+		let inputs_weight = vec![WEIGHT_REVOKED_OUTPUT];
+		let mut inputs_total_weight = 2; // count segwit flags
 		{
 			let mut sighash_parts = bip143::SigHashCache::new(&mut claim_tx);
-			for (idx, inp) in inputs_des.iter().enumerate() {
+			for (idx, inp) in inputs_weight.iter().enumerate() {
 				sign_input!(sighash_parts, idx, 0, inp, sum_actual_sigs);
+				inputs_total_weight += inp;
 			}
 		}
-		assert_eq!(base_weight + onchain_utils::get_witnesses_weight(&inputs_des[..]), claim_tx.get_weight() + /* max_length_isg */ (73 * inputs_des.len() - sum_actual_sigs));
+		assert_eq!(base_weight + inputs_total_weight as usize, claim_tx.get_weight() + /* max_length_isg */ (73 * inputs_weight.len() - sum_actual_sigs));
 	}
 
 	// Further testing is done in the ChannelManager integration tests.

lightning/src/chain/onchain_utils.rs

@@ -36,94 +36,16 @@ use std::ops::Deref;
 const MAX_ALLOC_SIZE: usize = 64*1024;
 
 
-/// witnessScript markers used to compute the expected witness weight.
-#[derive(PartialEq, Clone, Copy)]
-pub(crate) enum InputDescriptors {
-	RevokedOfferedHTLC,
-	RevokedReceivedHTLC,
-	OfferedHTLC,
-	ReceivedHTLC,
-	RevokedOutput, // either a revoked to_holder output on commitment tx, a revoked HTLC-Timeout output or a revoked HTLC-Success output
-}
-
-impl Writeable for InputDescriptors {
-	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
-		match self {
-			&InputDescriptors::RevokedOfferedHTLC => {
-				writer.write_all(&[0; 1])?;
-			},
-			&InputDescriptors::RevokedReceivedHTLC => {
-				writer.write_all(&[1; 1])?;
-			},
-			&InputDescriptors::OfferedHTLC => {
-				writer.write_all(&[2; 1])?;
-			},
-			&InputDescriptors::ReceivedHTLC => {
-				writer.write_all(&[3; 1])?;
-			}
-			&InputDescriptors::RevokedOutput => {
-				writer.write_all(&[4; 1])?;
-			}
-		}
-		Ok(())
-	}
-}
-
-impl Readable for InputDescriptors {
-	fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
-		let input_descriptor = match <u8 as Readable>::read(reader)? {
-			0 => {
-				InputDescriptors::RevokedOfferedHTLC
-			},
-			1 => {
-				InputDescriptors::RevokedReceivedHTLC
-			},
-			2 => {
-				InputDescriptors::OfferedHTLC
-			},
-			3 => {
-				InputDescriptors::ReceivedHTLC
-			},
-			4 => {
-				InputDescriptors::RevokedOutput
-			}
-			_ => return Err(DecodeError::InvalidValue),
-		};
-		Ok(input_descriptor)
-	}
-}
-
-/// Sum up witnesses weight of a set of given inputs. Inputs might belong to differing descriptors.
-/// Weights should be compliant with BOLT 3 Appendix A.
-pub(crate) fn get_witnesses_weight(inputs: &[InputDescriptors]) -> usize {
-	let mut tx_weight = 2; // count segwit flags
-	for inp in inputs {
-		// We use expected weight (and not actual) as signatures and time lock delays may vary
-		tx_weight +=  match inp {
-			// number_of_witness_elements + sig_length + revocation_sig + pubkey_length + revocationpubkey + witness_script_length + witness_script
-			&InputDescriptors::RevokedOfferedHTLC => {
-				1 + 1 + 73 + 1 + 33 + 1 + 133
-			},
-			// number_of_witness_elements + sig_length + revocation_sig + pubkey_length + revocationpubkey + witness_script_length + witness_script
-			&InputDescriptors::RevokedReceivedHTLC => {
-				1 + 1 + 73 + 1 + 33 + 1 + 139
-			},
-			// number_of_witness_elements + sig_length + counterpartyhtlc_sig  + preimage_length + preimage + witness_script_length + witness_script
-			&InputDescriptors::OfferedHTLC => {
-				1 + 1 + 73 + 1 + 32 + 1 + 133
-			},
-			// number_of_witness_elements + sig_length + revocation_sig + pubkey_length + revocationpubkey + witness_script_length + witness_script
-			&InputDescriptors::ReceivedHTLC => {
-				1 + 1 + 73 + 1 + 1 + 1 + 139
-			},
-			// number_of_witness_elements + sig_length + revocation_sig + true_length + op_true + witness_script_length + witness_script
-			&InputDescriptors::RevokedOutput => {
-				1 + 1 + 73 + 1 + 1 + 1 + 77
-			},
-		};
-	}
-	tx_weight
-}
+// number_of_witness_elements + sig_length + revocation_sig + pubkey_length + revocationpubkey + witness_script_length + witness_script
+pub(crate) const WEIGHT_REVOKED_OFFERED_HTLC: u64 = 1 + 1 + 73 + 1 + 33 + 1 + 133;
+// number_of_witness_elements + sig_length + revocation_sig + pubkey_length + revocationpubkey + witness_script_length + witness_script
+pub(crate) const WEIGHT_REVOKED_RECEIVED_HTLC: u64 = 1 + 1 + 73 + 1 + 33 + 1 +  139;
+// number_of_witness_elements + sig_length + counterpartyhtlc_sig  + preimage_length + preimage + witness_script_length + witness_script
+pub(crate) const WEIGHT_OFFERED_HTLC: u64 = 1 + 1 + 73 + 1 + 32 + 1 + 133;
+// number_of_witness_elements + sig_length + revocation_sig + pubkey_length + revocationpubkey + witness_script_length + witness_script
+pub(crate) const WEIGHT_RECEIVED_HTLC: u64 = 1 + 1 + 73 + 1 + 1 + 1 + 139;
+// number_of_witness_elements + sig_length + revocation_sig + true_length + op_true + witness_script_length + witness_script
+pub(crate) const WEIGHT_REVOKED_OUTPUT: u64 = 1 + 1 + 73 + 1 + 1 + 1 + 77;
 
 /// A struct to describe a revoked output and corresponding informations to generate a solving
 /// witness.
@@ -141,20 +63,20 @@ pub(crate) struct RevokedOutput {
 	counterparty_delayed_payment_base_key: PublicKey,
 	counterparty_htlc_base_key: PublicKey,
 	per_commitment_key: SecretKey,
-	input_descriptor: InputDescriptors,
+	weight: u64,
 	amount: u64,
 	htlc: Option<HTLCOutputInCommitment>,
 	on_counterparty_tx_csv: u16,
 }
 
 impl RevokedOutput {
-	pub(crate) fn build(per_commitment_point: PublicKey, per_commitment_key: SecretKey, counterparty_delayed_payment_base_key: PublicKey, counterparty_htlc_base_key: PublicKey, input_descriptor: InputDescriptors, amount: u64, htlc: Option<HTLCOutputInCommitment>, on_counterparty_tx_csv: u16) -> Self {
+	pub(crate) fn build(per_commitment_point: PublicKey, per_commitment_key: SecretKey, counterparty_delayed_payment_base_key: PublicKey, counterparty_htlc_base_key: PublicKey, weight: u64, amount: u64, htlc: Option<HTLCOutputInCommitment>, on_counterparty_tx_csv: u16) -> Self {
 		RevokedOutput {
 			per_commitment_point,
 			counterparty_delayed_payment_base_key,
 			counterparty_htlc_base_key,
 			per_commitment_key,
-			input_descriptor,
+			weight,
 			amount,
 			htlc,
 			on_counterparty_tx_csv
@@ -168,7 +90,7 @@ impl Writeable for RevokedOutput {
 		self.counterparty_delayed_payment_base_key.write(writer)?;
 		self.counterparty_htlc_base_key.write(writer)?;
 		writer.write_all(&self.per_commitment_key[..])?;
-		self.input_descriptor.write(writer)?;
+		writer.write_all(&byte_utils::be64_to_array(self.weight))?;
 		writer.write_all(&byte_utils::be64_to_array(self.amount))?;
 		self.htlc.write(writer)?;
 		self.on_counterparty_tx_csv.write(writer)?;
@@ -182,7 +104,7 @@ impl Readable for RevokedOutput {
 		let counterparty_delayed_payment_base_key = Readable::read(reader)?;
 		let counterparty_htlc_base_key = Readable::read(reader)?;
 		let per_commitment_key = Readable::read(reader)?;
-		let input_descriptor = Readable::read(reader)?;
+		let weight = Readable::read(reader)?;
 		let amount = Readable::read(reader)?;
 		let htlc = Readable::read(reader)?;
 		let on_counterparty_tx_csv = Readable::read(reader)?;
@@ -191,7 +113,7 @@ impl Readable for RevokedOutput {
 			counterparty_delayed_payment_base_key,
 			counterparty_htlc_base_key,
 			per_commitment_key,
-			input_descriptor,
+			weight,
 			amount,
 			htlc,
 			on_counterparty_tx_csv
@@ -360,8 +282,8 @@ impl PackageSolvingData {
 	}
 	fn weight(&self) -> usize {
 		let weight = match self {
-			PackageSolvingData::RevokedOutput(ref outp) => { get_witnesses_weight(&[outp.input_descriptor]) },
-			PackageSolvingData::CounterpartyHTLCOutput(ref outp) => { get_witnesses_weight(if outp.preimage.is_some() { &[InputDescriptors::OfferedHTLC] } else { &[InputDescriptors::ReceivedHTLC]}) },
+			PackageSolvingData::RevokedOutput(ref outp) => { outp.weight as usize },
+			PackageSolvingData::CounterpartyHTLCOutput(ref outp) => { if outp.preimage.is_some() { WEIGHT_OFFERED_HTLC as usize } else { WEIGHT_RECEIVED_HTLC as usize } },
 			// Note: Currently, weights of holder outputs spending witnesses aren't used
 			// as we can't malleate spending package to increase their feerate. This
 			// should change with the remaining anchor output patchset.
@@ -663,7 +585,7 @@ impl PackageTemplate {
 	}
 	pub(crate) fn package_weight(&self, destination_script: &Script) -> usize {
 		let mut input = Vec::new();
-		let mut witnesses_weight = 0;
+		let mut witnesses_weight = 2; // count segwit flags
 		for (outpoint, outp) in self.inputs.iter() {
 			input.push(TxIn {
 				previous_output: *outpoint,