Introduce DirectedChannelStaticInfo

This allows Bitcoin transaction building without knowing if the transaction is for holder or counterparty.

Author: devrandom

lightning/src/chain/channelmonitor.rs

@@ -955,7 +955,8 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 
 		let secp_ctx = Secp256k1::new();
 
-		let txid = initial_holder_commitment_info.txid(channel_static_info, &secp_ctx);
+		let directed_channel_static_info = channel_static_info.to_directed(true);
+		let txid = initial_holder_commitment_info.txid(&directed_channel_static_info, &secp_ctx);
 
 		// block for Rust 1.34 compat
 		let (holder_commitment_tx, current_holder_commitment_number) = {
@@ -1133,7 +1134,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 	/// up-to-date as our holder commitment transaction is updated.
 	/// Panics if set_on_holder_tx_csv has never been called.
 	fn provide_latest_holder_commitment_tx_info(&mut self, commitment_info: HolderCommitmentTransactionInfo, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>) -> Result<(), MonitorUpdateError> {
-		let txid = commitment_info.txid(&self.onchain_tx_handler.channel_static_info, &self.secp_ctx);
+		let txid = commitment_info.txid(&self.onchain_tx_handler.channel_static_info.to_directed(true), &self.secp_ctx);
 
 		// block for Rust 1.34 compat
 		let mut new_holder_commitment_tx = {

lightning/src/ln/chan_utils.rs

@@ -556,21 +556,30 @@ 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)
+// Static channel fields used to build transactions given per-commitment fields (CommitmentTransactionInfo)
 #[derive(Clone)]
-pub struct ChannelStaticInfo {
-	/// Holder public keys
-	pub holder_pubkeys: ChannelPublicKeys,
-	/// Counter-party public keys
-	pub counterparty_pubkeys: ChannelPublicKeys,
-	/// The contest delay selected by the holder
-	pub holder_selected_contest_delay: u16,
-	/// The contest delay selected by the counterparty
-	pub counterparty_selected_contest_delay: u16,
-	/// The funding outpoint
-	pub funding_outpoint: OutPoint,
-	/// Whether the channel is outbound from the point of view of the holder
-	pub is_outbound_from_holder: bool,
+pub(crate) struct ChannelStaticInfo {
+	// Holder public keys
+	pub(crate) holder_pubkeys: ChannelPublicKeys,
+	// Counter-party public keys
+	pub(crate) counterparty_pubkeys: ChannelPublicKeys,
+	// The contest delay selected by the holder
+	pub(crate) holder_selected_contest_delay: u16,
+	// The contest delay selected by the counterparty
+	pub(crate) counterparty_selected_contest_delay: u16,
+	// The funding outpoint
+	pub(crate) funding_outpoint: OutPoint,
+	// Whether the channel is outbound from the point of view of the holder
+	pub(crate) is_outbound_from_holder: bool,
+}
+
+impl ChannelStaticInfo {
+	pub(crate) fn to_directed(&self, holder: bool) -> DirectedChannelStaticInfo {
+		DirectedChannelStaticInfo {
+			info: self,
+			broadcaster_is_holder: holder
+		}
+	}
 }
 
 impl_writeable!(ChannelStaticInfo, 0, {
@@ -582,25 +591,38 @@ impl_writeable!(ChannelStaticInfo, 0, {
 	is_outbound_from_holder
 });
 
-impl ChannelStaticInfo {
-	/// Get the pubkeys for the selected side and the opposing side
-	pub fn pubkeys(&self, holder: bool) -> (&ChannelPublicKeys, &ChannelPublicKeys) {
-		if holder {
-			(&self.holder_pubkeys, &self.counterparty_pubkeys)
+/// Static channel fields used to build transactions given per-commitment fields (CommitmentTransactionInfo)
+pub struct DirectedChannelStaticInfo<'a> {
+	/// The holder's channel static info
+	info: &'a ChannelStaticInfo,
+	/// Whether the holder is the broadcaster
+	broadcaster_is_holder: bool,
+}
+
+impl<'a> DirectedChannelStaticInfo<'a> {
+	/// Get the pubkeys for the broadcaster and countersignatory
+	pub fn pubkeys(&self) -> (&ChannelPublicKeys, &ChannelPublicKeys) {
+		if self.broadcaster_is_holder {
+			(&self.info.holder_pubkeys, &self.info.counterparty_pubkeys)
 		} else {
-			(&self.counterparty_pubkeys, &self.holder_pubkeys)
+			(&self.info.counterparty_pubkeys, &self.info.holder_pubkeys)
 		}
 	}
 
-	/// Get the contest delay applicable to the selected side's transactions.
-	/// Note that the contest delay was selected by the opposite party.
-	pub fn contest_delay(&self, holder: bool) -> u16 {
-		if holder { self.counterparty_selected_contest_delay } else { self.holder_selected_contest_delay }
+	/// Get the contest delay applicable to the transactions.
+	/// Note that the contest delay was selected by the countersignatory.
+	pub fn contest_delay(&self) -> u16 {
+		if self.broadcaster_is_holder { self.info.counterparty_selected_contest_delay } else { self.info.holder_selected_contest_delay }
 	}
 
-	/// Whether the channel is outbound from the perspective of the selected party
-	pub fn is_outbound(&self, holder: bool) -> bool {
-		return if holder { self.is_outbound_from_holder } else { !self.is_outbound_from_holder };
+	/// Whether the channel is outbound from the broadcaster
+	pub fn is_outbound(&self) -> bool {
+		return if self.broadcaster_is_holder { self.info.is_outbound_from_holder } else { !self.info.is_outbound_from_holder };
+	}
+
+	/// The funding outpoint
+	pub fn funding_outpoint(&self) -> OutPoint {
+		self.info.funding_outpoint
 	}
 }
 
@@ -654,8 +676,8 @@ impl HolderCommitmentTransactionInfo {
 			counterparty_htlc_sigs: Vec::new()
 		}
 	}
-	pub(crate) fn txid<T: secp256k1::Signing + secp256k1::Verification>(&self, channel_static_info: &ChannelStaticInfo, secp_ctx: &Secp256k1<T>) -> Txid {
-		self.info.txid(true, channel_static_info, secp_ctx)
+	pub(crate) fn txid<T: secp256k1::Signing + secp256k1::Verification>(&self, channel_static_info: &DirectedChannelStaticInfo, secp_ctx: &Secp256k1<T>) -> Txid {
+		self.info.txid(channel_static_info, secp_ctx)
 	}
 }
 
@@ -664,7 +686,7 @@ impl HolderCommitmentTransactionInfo {
 		let opt_sigs: Vec<Option<Signature>> = self.counterparty_htlc_sigs.iter().map(|s| Some(s.clone())).collect();
 		let mut htlcs = self.info.htlcs.clone();
 		let htlcs_with_sig = htlcs.drain(..).zip(opt_sigs).collect();
-		self.info.to_holder_commitment_tx(self.counterparty_sig, htlcs_with_sig, channel_static_info, secp_ctx)
+		self.info.to_holder_commitment_tx(self.counterparty_sig, htlcs_with_sig, &channel_static_info.to_directed(true), secp_ctx)
 	}
 }
 
@@ -735,9 +757,9 @@ impl CommitmentTransactionInfo {
 	/// Also keeps track of auxiliary HTLC data and returns it along with the mutated and sorted HTLCs.
 	/// This allows the caller to match the HTLC output index with the auxiliary data.
 	/// This auxiliary data is not stored in this object.
-	pub fn new_with_auxiliary_htlc_data<T: Copy>(commitment_number: u64, to_broadcaster_value_sat: u64, to_countersignatory_value_sat: u64, keys: TxCreationKeys, feerate_per_kw: u32, htlcs_with_aux: Vec<(HTLCOutputInCommitment, T)>, holder: bool, channel_static_info: &ChannelStaticInfo, secp_ctx: &Secp256k1<secp256k1::All>) -> (CommitmentTransactionInfo, Vec<(HTLCOutputInCommitment, T)>) {
+	pub fn new_with_auxiliary_htlc_data<T: Copy>(commitment_number: u64, to_broadcaster_value_sat: u64, to_countersignatory_value_sat: u64, keys: TxCreationKeys, feerate_per_kw: u32, htlcs_with_aux: Vec<(HTLCOutputInCommitment, T)>, channel_static_info: &DirectedChannelStaticInfo, secp_ctx: &Secp256k1<secp256k1::All>) -> (CommitmentTransactionInfo, Vec<(HTLCOutputInCommitment, T)>) {
 		// Sort outputs and populate output indices while keeping track of the auxiliary data
-		let mut txouts = Self::do_build_outputs(&keys, to_broadcaster_value_sat, to_countersignatory_value_sat, &htlcs_with_aux, holder, channel_static_info, &secp_ctx).unwrap();
+		let mut txouts = Self::do_build_outputs(&keys, to_broadcaster_value_sat, to_countersignatory_value_sat, &htlcs_with_aux,channel_static_info, &secp_ctx).unwrap();
 		let mut result_htlcs_with_aux = Vec::new();
 		let mut htlcs = Vec::new();
 		for (idx, mut out) in txouts.drain(..).enumerate() {
@@ -759,16 +781,16 @@ impl CommitmentTransactionInfo {
 		(info, result_htlcs_with_aux)
 	}
 
-	pub(crate) fn txid<T: secp256k1::Signing + secp256k1::Verification>(&self, holder: bool, channel_static_info: &ChannelStaticInfo, secp_ctx: &Secp256k1<T>) -> Txid {
-		let tx = self.build(holder, channel_static_info, secp_ctx).unwrap().0;
+	pub(crate) fn txid<T: secp256k1::Signing + secp256k1::Verification>(&self, channel_static_info: &DirectedChannelStaticInfo, secp_ctx: &Secp256k1<T>) -> Txid {
+		let tx = self.build(channel_static_info, secp_ctx).unwrap().0;
 		tx.txid()
 	}
 
 	/// Build the Bitcoin transaction
-	pub fn build<T: secp256k1::Signing + secp256k1::Verification>(&self, holder: 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(holder, channel_static_info);
+	pub fn build<T: secp256k1::Signing + secp256k1::Verification>(&self, channel_static_info: &DirectedChannelStaticInfo, secp_ctx: &Secp256k1<T>) -> Result<(bitcoin::Transaction, Vec<HTLCOutputInCommitment>, Vec<Script>), ()> {
+		let (obscured_commitment_transaction_number, txins) = self.build_inputs(channel_static_info);
 
-		let mut txouts = self.build_outputs(holder, channel_static_info, 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());
@@ -794,16 +816,16 @@ impl CommitmentTransactionInfo {
 		))
 	}
 
-	fn build_outputs<T: secp256k1::Signing + secp256k1::Verification>(&self, holder: bool, channel_static_info: &ChannelStaticInfo, secp_ctx: &Secp256k1<T>) -> Result<Vec<(TxOut, (Script, Option<HTLCOutputInCommitment>))>, ()> {
+	fn build_outputs<T: secp256k1::Signing + secp256k1::Verification>(&self, channel_static_info: &DirectedChannelStaticInfo, 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, holder, channel_static_info, 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, secp_ctx)?;
 		let outs = txouts.drain(..).map(|(out, (s, extra))| (out, (s, extra.map(|(p, _)| p)))).collect();
 		Ok(outs)
 	}
 
-	fn do_build_outputs<T: Copy, S: secp256k1::Signing + secp256k1::Verification>(keys: &TxCreationKeys, to_broadcaster_value_sat: u64, to_countersignatory_value_sat: u64, htlcs: &Vec<(HTLCOutputInCommitment, T)>, 		holder: bool, channel_static_info: &ChannelStaticInfo, secp_ctx: &Secp256k1<S>) -> Result<Vec<(TxOut, (Script, Option<(HTLCOutputInCommitment, T)>))>, ()> {
-		let (broadcaster_pubkeys, countersignatory_pubkeys) = channel_static_info.pubkeys(holder);
-		let contest_delay = channel_static_info.contest_delay(holder);
+	fn do_build_outputs<T: Copy, S: secp256k1::Signing + secp256k1::Verification>(keys: &TxCreationKeys, to_broadcaster_value_sat: u64, to_countersignatory_value_sat: u64, htlcs: &Vec<(HTLCOutputInCommitment, T)>, channel_static_info: &DirectedChannelStaticInfo, secp_ctx: &Secp256k1<S>) -> Result<Vec<(TxOut, (Script, Option<(HTLCOutputInCommitment, T)>))>, ()> {
+		let (broadcaster_pubkeys, countersignatory_pubkeys) = channel_static_info.pubkeys();
+		let contest_delay = channel_static_info.contest_delay();
 
 		let per_commitment_point = &keys.per_commitment_point;
 		let to_broadcaster_delayed_pubkey = derive_public_key(
@@ -871,12 +893,12 @@ impl CommitmentTransactionInfo {
 		Ok(txouts)
 	}
 
-	fn build_inputs(&self, holder: bool, channel_static_info: &ChannelStaticInfo) -> (u64, Vec<TxIn>) {
-		let (broadcaster_pubkeys, countersignatory_pubkeys) = channel_static_info.pubkeys(holder);
+	fn build_inputs(&self, channel_static_info: &DirectedChannelStaticInfo) -> (u64, Vec<TxIn>) {
+		let (broadcaster_pubkeys, countersignatory_pubkeys) = channel_static_info.pubkeys();
 		let commitment_transaction_number_obscure_factor = get_commitment_transaction_number_obscure_factor(
 			&broadcaster_pubkeys.payment_point,
 			&countersignatory_pubkeys.payment_point,
-			channel_static_info.is_outbound(holder),
+			channel_static_info.is_outbound(),
 		);
 
 		let obscured_commitment_transaction_number =
@@ -885,7 +907,7 @@ impl CommitmentTransactionInfo {
 		let txins = {
 			let mut ins: Vec<TxIn> = Vec::new();
 			ins.push(TxIn {
-				previous_output: channel_static_info.funding_outpoint.clone(),
+				previous_output: channel_static_info.funding_outpoint(),
 				script_sig: Script::new(),
 				sequence: ((0x80 as u32) << 8 * 3)
 					| ((obscured_commitment_transaction_number >> 3 * 8) as u32),
@@ -898,25 +920,25 @@ impl CommitmentTransactionInfo {
 
 	/// Sign a transaction, either because we are counter-signing the counterparty's transaction or
 	/// because we are about to broadcast a holder transaction.
-	pub fn get_signature<T: secp256k1::Signing + secp256k1::Verification>(&self, holder: bool, channel_static_info: &ChannelStaticInfo, funding_key: &SecretKey, funding_redeemscript: &Script, channel_value_satoshis: u64, secp_ctx: &Secp256k1<T>) -> Signature {
-		let sighash = self.get_sighash(holder, channel_static_info, funding_redeemscript, channel_value_satoshis, secp_ctx).0;
+	pub fn get_signature<T: secp256k1::Signing + secp256k1::Verification>(&self, channel_static_info: &DirectedChannelStaticInfo, 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_ALL sighash value 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, holder: bool, channel_static_info: &ChannelStaticInfo, funding_redeemscript: &Script, channel_value_satoshis: u64, secp_ctx: &Secp256k1<T>) -> (Message, Transaction) {
-		let (unsigned_tx, _, _) = self.build(holder, channel_static_info, secp_ctx).unwrap();
+	pub fn get_sighash<T: secp256k1::Signing + secp256k1::Verification>(&self, channel_static_info: &DirectedChannelStaticInfo, 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)
 	}
 
 	// TODO(devrandom): remove this and subsume the HolderCommitmentTransaction signing functionality
-	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 (broadcaster_pubkeys, countersignatory_pubkeys) = channel_static_info.pubkeys(true);
-		let (tx, _, _) = self.build(true, channel_static_info, secp_ctx).unwrap();
+	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: &DirectedChannelStaticInfo, secp_ctx: &Secp256k1<T>) -> HolderCommitmentTransaction {
+		let (broadcaster_pubkeys, countersignatory_pubkeys) = channel_static_info.pubkeys();
+		let (tx, _, _) = self.build(channel_static_info, secp_ctx).unwrap();
 		HolderCommitmentTransaction::new_missing_holder_sig(tx, counterparty_sig, &broadcaster_pubkeys.funding_pubkey, &countersignatory_pubkeys.funding_pubkey, self.keys.clone(), self.feerate_per_kw, htlcs_with_sig)
 	}
 }