introduce ChannelStaticInfo

Author: devrandom

lightning/src/ln/chan_utils.rs

@@ -554,6 +554,20 @@ pub fn build_htlc_transaction(prev_hash: &Txid, feerate_per_kw: u32, contest_del
 	}
 }
 
+/// Static channel fields used to build transactions given per-commitment fields (CommitmentTransactionInfo)
+pub struct ChannelStaticInfo {
+	/// Broadcaster public keys
+	pub broadcaster_pubkeys: ChannelPublicKeys,
+	/// Counter-signatory public keys
+	pub countersignatory_pubkeys: ChannelPublicKeys,
+	/// The funding outpoint
+	pub funding_outpoint: OutPoint,
+	/// The contest delay selected by the countersignatory
+	pub contest_delay: u16,
+	/// Whether the channel is outbound from the point of view of the broadcaster
+	pub is_outbound: bool,
+}
+
 /// This class tracks the information needed to build a holder's commitment transaction and to actually
 /// build and sign.  It is used for holder transactions that we sign only when needed.
 pub struct HolderCommitmentTransactionInfo {
@@ -566,8 +580,8 @@ pub struct HolderCommitmentTransactionInfo {
 }
 
 impl HolderCommitmentTransactionInfo {
-	pub(crate) fn to_holder_commitment_tx<T: secp256k1::Signing + secp256k1::Verification>(&self, holder_pubkeys: &ChannelPublicKeys, counterparty_pubkeys: &ChannelPublicKeys, funding_outpoint: &OutPoint, contest_delay: u16, is_outbound: bool, secp_ctx: &Secp256k1<T>) -> HolderCommitmentTransaction {
-		self.info.to_holder_commitment_tx(self.counterparty_sig, self.htlcs_with_sig.clone(), holder_pubkeys, counterparty_pubkeys, funding_outpoint, contest_delay, is_outbound, secp_ctx)
+	pub(crate) fn to_holder_commitment_tx<T: secp256k1::Signing + secp256k1::Verification>(&self, channel_static_info: &ChannelStaticInfo, secp_ctx: &Secp256k1<T>) -> HolderCommitmentTransaction {
+		self.info.to_holder_commitment_tx(self.counterparty_sig, self.htlcs_with_sig.clone(), channel_static_info, secp_ctx)
 	}
 }
 
@@ -638,16 +652,12 @@ impl CommitmentTransactionInfo {
 	/// is_outbound is true if the channel is outbound from the point of view of the broadcaster
 	pub fn build<T: secp256k1::Signing + secp256k1::Verification>(
 		&self,
-		broadcaster_pubkeys: &ChannelPublicKeys,
-		countersignatory_pubkeys: &ChannelPublicKeys,
-		funding_outpoint: &OutPoint,
-		contest_delay: u16,
-		is_outbound: bool,
+		channel_static_info: &ChannelStaticInfo,
 		secp_ctx: &Secp256k1<T>,
 	) -> Result<(bitcoin::Transaction, Vec<HTLCOutputInCommitment>, Vec<Script>), ()> {
-		let (obscured_commitment_transaction_number, txins) = self.build_inputs(broadcaster_pubkeys, countersignatory_pubkeys, funding_outpoint, is_outbound);
+		let (obscured_commitment_transaction_number, txins) = self.build_inputs(channel_static_info);
 
-		let mut txouts = self.build_outputs(broadcaster_pubkeys, countersignatory_pubkeys, contest_delay, secp_ctx)?;
+		let mut txouts = self.build_outputs(channel_static_info, secp_ctx)?;
 
 		let mut outputs = Vec::with_capacity(txouts.len());
 		let mut scripts = Vec::with_capacity(txouts.len());
@@ -673,9 +683,9 @@ impl CommitmentTransactionInfo {
 		))
 	}
 
-	fn build_outputs<T: secp256k1::Signing + secp256k1::Verification>(&self, broadcaster_pubkeys: &ChannelPublicKeys, countersignatory_pubkeys: &ChannelPublicKeys, contest_delay: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<(TxOut, (Script, Option<HTLCOutputInCommitment>))>, ()> {
+	fn build_outputs<T: secp256k1::Signing + secp256k1::Verification>(&self, channel_static_info: &ChannelStaticInfo, secp_ctx: &Secp256k1<T>) -> Result<Vec<(TxOut, (Script, Option<HTLCOutputInCommitment>))>, ()> {
 		let htlcs = self.htlcs.iter().map(|h| (h.clone(), ())).collect();
-		let mut txouts = Self::do_build_outputs(&self.keys, self.to_broadcaster_value_sat, self.to_countersignatory_value_sat, &htlcs, broadcaster_pubkeys, countersignatory_pubkeys, contest_delay, secp_ctx)?;
+		let mut txouts = Self::do_build_outputs(&self.keys, self.to_broadcaster_value_sat, self.to_countersignatory_value_sat, &htlcs, &channel_static_info.broadcaster_pubkeys, &channel_static_info.countersignatory_pubkeys, channel_static_info.contest_delay, secp_ctx)?;
 		let outs = txouts.drain(..).map(|(out, (s, extra))| (out, (s, extra.map(|(p, _)| p)))).collect();
 		Ok(outs)
 	}
@@ -750,11 +760,11 @@ impl CommitmentTransactionInfo {
 		Ok(txouts)
 	}
 
-	fn build_inputs(&self, broadcaster_pubkeys: &ChannelPublicKeys, countersignatory_pubkeys: &ChannelPublicKeys, funding_outpoint: &OutPoint, is_outbound: bool) -> (u64, Vec<TxIn>) {
+	fn build_inputs(&self, channel_statc_info: &ChannelStaticInfo) -> (u64, Vec<TxIn>) {
 		let commitment_transaction_number_obscure_factor = get_commitment_transaction_number_obscure_factor(
-			&broadcaster_pubkeys.payment_point,
-			&countersignatory_pubkeys.payment_point,
-			is_outbound,
+			&channel_statc_info.broadcaster_pubkeys.payment_point,
+			&channel_statc_info.countersignatory_pubkeys.payment_point,
+			channel_statc_info.is_outbound,
 		);
 
 		let obscured_commitment_transaction_number =
@@ -763,7 +773,7 @@ impl CommitmentTransactionInfo {
 		let txins = {
 			let mut ins: Vec<TxIn> = Vec::new();
 			ins.push(TxIn {
-				previous_output: funding_outpoint.clone(),
+				previous_output: channel_statc_info.funding_outpoint.clone(),
 				script_sig: Script::new(),
 				sequence: ((0x80 as u32) << 8 * 3)
 					| ((obscured_commitment_transaction_number >> 3 * 8) as u32),
@@ -778,24 +788,24 @@ impl CommitmentTransactionInfo {
 	/// because we are about to broadcast a holder transaction.
 	///
 	/// is_outbound is true if the channel is outbound from the point of view of the broadcaster
-	pub fn get_signature<T: secp256k1::Signing + secp256k1::Verification>(&self, broadcaster_pubkeys: &ChannelPublicKeys, countersignatory_pubkeys: &ChannelPublicKeys, funding_outpoint: &OutPoint, contest_delay: u16, is_outbound: bool, funding_key: &SecretKey, funding_redeemscript: &Script, channel_value_satoshis: u64, secp_ctx: &Secp256k1<T>) -> Signature {
-		let sighash = self.get_sighash(broadcaster_pubkeys, countersignatory_pubkeys, funding_outpoint, contest_delay, is_outbound, funding_redeemscript, channel_value_satoshis, secp_ctx).0;
+	pub fn get_signature<T: secp256k1::Signing + secp256k1::Verification>(&self, channel_static_info: &ChannelStaticInfo, funding_key: &SecretKey, funding_redeemscript: &Script, channel_value_satoshis: u64, secp_ctx: &Secp256k1<T>) -> Signature {
+		let sighash = self.get_sighash(channel_static_info, funding_redeemscript, channel_value_satoshis, secp_ctx).0;
 		secp_ctx.sign(&sighash, funding_key)
 	}
 
 	/// Get the sighash and the transaction.
 	///
 	/// Builds the transaction and computes the sighash.  This can be used to verify a signature.
-	pub fn get_sighash<T: secp256k1::Signing + secp256k1::Verification>(&self, broadcaster_pubkeys: &ChannelPublicKeys, countersignatory_pubkeys: &ChannelPublicKeys, funding_outpoint: &OutPoint, contest_delay: u16, is_outbound: bool, funding_redeemscript: &Script, channel_value_satoshis: u64, secp_ctx: &Secp256k1<T>) -> (Message, Transaction) {
-		let (unsigned_tx, _, _) = self.build(broadcaster_pubkeys, countersignatory_pubkeys, funding_outpoint, contest_delay, is_outbound, secp_ctx).unwrap();
+	pub fn get_sighash<T: secp256k1::Signing + secp256k1::Verification>(&self, channel_static_info: &ChannelStaticInfo, funding_redeemscript: &Script, channel_value_satoshis: u64, secp_ctx: &Secp256k1<T>) -> (Message, Transaction) {
+		let (unsigned_tx, _, _) = self.build(channel_static_info, secp_ctx).unwrap();
 		let sighash = hash_to_message!(&bip143::SigHashCache::new(&unsigned_tx)
 			.signature_hash(0, funding_redeemscript, channel_value_satoshis, SigHashType::All)[..]);
 		(sighash, unsigned_tx)
 	}
 
-	pub(crate) fn to_holder_commitment_tx<T: secp256k1::Signing + secp256k1::Verification>(&self, counterparty_sig: Signature, htlcs_with_sig: Vec<(HTLCOutputInCommitment, Option<Signature>)>, holder_pubkeys: &ChannelPublicKeys, counterparty_pubkeys: &ChannelPublicKeys, funding_outpoint: &OutPoint, contest_delay: u16, is_outbound: bool, secp_ctx: &Secp256k1<T>) -> HolderCommitmentTransaction {
-		let (tx, _, _) = self.build(holder_pubkeys, counterparty_pubkeys, funding_outpoint, contest_delay, is_outbound, secp_ctx).unwrap();
-		HolderCommitmentTransaction::new_missing_holder_sig(tx, counterparty_sig, &holder_pubkeys.funding_pubkey, &counterparty_pubkeys.funding_pubkey, self.keys.clone(), self.feerate_per_kw, htlcs_with_sig)
+	pub(crate) fn to_holder_commitment_tx<T: secp256k1::Signing + secp256k1::Verification>(&self, counterparty_sig: Signature, htlcs_with_sig: Vec<(HTLCOutputInCommitment, Option<Signature>)>, channel_static_info: &ChannelStaticInfo, secp_ctx: &Secp256k1<T>) -> HolderCommitmentTransaction {
+		let (tx, _, _) = self.build(channel_static_info, secp_ctx).unwrap();
+		HolderCommitmentTransaction::new_missing_holder_sig(tx, counterparty_sig, &channel_static_info.broadcaster_pubkeys.funding_pubkey, &channel_static_info.countersignatory_pubkeys.funding_pubkey, self.keys.clone(), self.feerate_per_kw, htlcs_with_sig)
 	}
 }