Introduce CounterpartyChannelTransactionParameters

also, eliminate ChannelStaticData in favor of ChannelTransactionParameters

Author: devrandom

lightning/src/chain/channelmonitor.rs

@@ -960,8 +960,9 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 		let payment_key_hash = WPubkeyHash::hash(&keys.pubkeys().payment_point.serialize());
 		let counterparty_payment_script = Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&payment_key_hash[..]).into_script();
 
-		let counterparty_delayed_payment_base_key = channel_parameters.counterparty_pubkeys.delayed_payment_basepoint;
-		let counterparty_htlc_base_key = channel_parameters.counterparty_pubkeys.htlc_basepoint;
+		let counterparty_channel_parameters = channel_parameters.counterparty_parameters.as_ref().unwrap();
+		let counterparty_delayed_payment_base_key = counterparty_channel_parameters.pubkeys.delayed_payment_basepoint;
+		let counterparty_htlc_base_key = counterparty_channel_parameters.pubkeys.htlc_basepoint;
 		let counterparty_tx_cache = CounterpartyCommitmentTransaction { counterparty_delayed_payment_base_key, counterparty_htlc_base_key, on_counterparty_tx_csv, per_htlc: HashMap::new() };
 
 		let mut onchain_tx_handler = OnchainTxHandler::new(destination_script.clone(), keys.clone(), channel_parameters.clone());
@@ -1012,7 +1013,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 			channel_value_satoshis,
 			their_cur_revocation_points: None,
 
-			on_holder_tx_csv: channel_parameters.counterparty_selected_contest_delay,
+			on_holder_tx_csv: counterparty_channel_parameters.selected_contest_delay,
 
 			commitment_secrets: CounterpartyCommitmentSecrets::new(),
 			counterparty_claimable_outpoints: HashMap::new(),
@@ -2605,7 +2606,7 @@ mod tests {
 	use ln::channelmanager::{PaymentPreimage, PaymentHash};
 	use ln::onchaintx::{OnchainTxHandler, InputDescriptors};
 	use ln::chan_utils;
-	use ln::chan_utils::{HTLCOutputInCommitment, ChannelPublicKeys, ChannelTransactionParameters, HolderCommitmentTransaction};
+	use ln::chan_utils::{HTLCOutputInCommitment, ChannelPublicKeys, ChannelTransactionParameters, HolderCommitmentTransaction, CounterpartyChannelTransactionParameters};
 	use util::test_utils::{TestLogger, TestBroadcaster, TestFeeEstimator};
 	use bitcoin::secp256k1::key::{SecretKey,PublicKey};
 	use bitcoin::secp256k1::Secp256k1;
@@ -2685,13 +2686,16 @@ mod tests {
 			delayed_payment_basepoint: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[47; 32]).unwrap()),
 			htlc_basepoint: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[48; 32]).unwrap())
 		};
+		let funding_outpoint = OutPoint { txid: Default::default(), index: u16::max_value() };
 		let channel_parameters = ChannelTransactionParameters {
 			holder_pubkeys: keys.holder_channel_pubkeys.clone(),
-			counterparty_pubkeys,
 			holder_selected_contest_delay: 66,
-			counterparty_selected_contest_delay: 67,
-			funding_outpoint: Default::default(),
-			is_outbound_from_holder: true
+			is_outbound_from_holder: true,
+			counterparty_parameters: Some(CounterpartyChannelTransactionParameters {
+				pubkeys: counterparty_pubkeys,
+				selected_contest_delay: 67,
+			}),
+			funding_outpoint: Some(funding_outpoint),
 		};
 		// Prune with one old state and a holder commitment tx holding a few overlaps with the
 		// old state.

lightning/src/chain/keysinterface.rs

@@ -33,7 +33,7 @@ use util::ser::{Writeable, Writer, Readable};
 
 use chain::transaction::OutPoint;
 use ln::chan_utils;
-use ln::chan_utils::{HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, HolderCommitmentTransaction, ChannelTransactionParameters, CommitmentTransaction};
+use ln::chan_utils::{HTLCOutputInCommitment, make_funding_redeemscript, ChannelPublicKeys, HolderCommitmentTransaction, ChannelTransactionParameters, CommitmentTransaction, CounterpartyChannelTransactionParameters};
 use ln::msgs::UnsignedChannelAnnouncement;
 
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -327,7 +327,7 @@ pub trait ChannelKeys : Send+Clone {
 	/// We bind holder_selected_contest_delay late here for API convenience.
 	///
 	/// Will be called before any signatures are applied.
-	fn ready_channel(&mut self, channel_points: &ChannelPublicKeys, counterparty_selected_contest_delay: u16, holder_selected_contest_delay: u16, is_outbound: bool, funding_outpoint: &OutPoint);
+	fn ready_channel(&mut self, channel_parameters: &ChannelTransactionParameters);
 }
 
 /// A trait to describe an object which can get user secrets and key material.
@@ -389,9 +389,7 @@ pub struct InMemoryChannelKeys {
 	/// Holder public keys and basepoints
 	pub(crate) holder_channel_pubkeys: ChannelPublicKeys,
 	/// Counterparty public keys and counterparty/holder selected_contest_delay, populated on channel acceptance
-	accepted_channel_data: Option<StaticChannelData>,
-	/// Funding outpoint, populated on channel funding creation
-	funding_outpoint: Option<OutPoint>,
+	channel_parameters: Option<ChannelTransactionParameters>,
 	/// The total value of this channel
 	channel_value_satoshis: u64,
 	/// Key derivation parameters
@@ -423,8 +421,7 @@ impl InMemoryChannelKeys {
 			commitment_seed,
 			channel_value_satoshis,
 			holder_channel_pubkeys,
-			accepted_channel_data: None,
-			funding_outpoint: None,
+			channel_parameters: None,
 			key_derivation_params,
 		}
 	}
@@ -447,27 +444,27 @@ impl InMemoryChannelKeys {
 
 	/// Counterparty pubkeys.
 	/// Will panic if ready_channel wasn't called.
-	pub fn counterparty_pubkeys(&self) -> &ChannelPublicKeys { &self.accepted_channel_data.as_ref().unwrap().counterparty_channel_pubkeys }
+	pub fn counterparty_pubkeys(&self) -> &ChannelPublicKeys { &self.channel_parameters.as_ref().unwrap().counterparty_parameters.as_ref().unwrap().pubkeys }
 
 	/// The contest_delay value specified by our counterparty and applied on holder-broadcastable
 	/// transactions, ie the amount of time that we have to wait to recover our funds if we
 	/// broadcast a transaction. You'll likely want to pass this to the
 	/// ln::chan_utils::build*_transaction functions when signing holder's transactions.
 	/// Will panic if ready_channel wasn't called.
-	pub fn counterparty_selected_contest_delay(&self) -> u16 { self.accepted_channel_data.as_ref().unwrap().counterparty_selected_contest_delay }
+	pub fn counterparty_selected_contest_delay(&self) -> u16 { self.channel_parameters.as_ref().unwrap().counterparty_parameters.as_ref().unwrap().selected_contest_delay }
 
 	/// The contest_delay value specified by us and applied on transactions broadcastable
 	/// by our counterparty, ie the amount of time that they have to wait to recover their funds
 	/// if they broadcast a transaction.
 	/// Will panic if ready_channel wasn't called.
-	pub fn holder_selected_contest_delay(&self) -> u16 { self.accepted_channel_data.as_ref().unwrap().holder_selected_contest_delay }
+	pub fn holder_selected_contest_delay(&self) -> u16 { self.channel_parameters.as_ref().unwrap().holder_selected_contest_delay }
 
 	/// Whether the holder is the initiator
-	pub fn is_outbound(&self) -> bool { self.accepted_channel_data.as_ref().unwrap().is_outbound }
+	pub fn is_outbound(&self) -> bool { self.channel_parameters.as_ref().unwrap().is_outbound_from_holder }
 
 	/// Funding outpoint
 	/// Will panic if ready_channel wasn't called.
-	pub fn funding_outpoint(&self) -> &OutPoint { self.funding_outpoint.as_ref().unwrap() }
+	pub fn funding_outpoint(&self) -> &OutPoint { self.channel_parameters.as_ref().unwrap().funding_outpoint.as_ref().unwrap() }
 }
 
 impl ChannelKeys for InMemoryChannelKeys {
@@ -487,8 +484,7 @@ impl ChannelKeys for InMemoryChannelKeys {
 		let keys = commitment_tx.trust_key_derivation();
 
 		let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
-		let accepted_data = self.accepted_channel_data.as_ref().expect("must accept before signing");
-		let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &accepted_data.counterparty_channel_pubkeys.funding_pubkey);
+		let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &self.counterparty_pubkeys().funding_pubkey);
 
 		let channel_parameters = self.make_channel_parameters();
 		let directed_channel_parameters = channel_parameters.to_directed(false);
@@ -498,7 +494,7 @@ impl ChannelKeys for InMemoryChannelKeys {
 
 		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, accepted_data.holder_selected_contest_delay, htlc, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
+			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 our_htlc_key = match chan_utils::derive_private_key(&secp_ctx, &keys.per_commitment_point, &self.htlc_base_key) {
@@ -527,8 +523,7 @@ impl ChannelKeys for InMemoryChannelKeys {
 	#[cfg(any(test,feature = "unsafe_revoked_tx_signing"))]
 	fn unsafe_sign_holder_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, holder_commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
 		let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
-		let counterparty_channel_pubkeys = &self.accepted_channel_data.as_ref().expect("must accept before signing").counterparty_channel_pubkeys;
-		let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &counterparty_channel_pubkeys.funding_pubkey);
+		let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &self.counterparty_pubkeys().funding_pubkey);
 		let channel_parameters = self.make_channel_parameters();
 		let channel_parameters = channel_parameters.to_directed(true);
 
@@ -595,8 +590,7 @@ impl ChannelKeys for InMemoryChannelKeys {
 		if closing_tx.output.len() > 2 { return Err(()); }
 
 		let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
-		let counterparty_channel_data = self.accepted_channel_data.as_ref().expect("must accept before signing");
-		let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &counterparty_channel_data.counterparty_channel_pubkeys.funding_pubkey);
+		let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &self.counterparty_pubkeys().funding_pubkey);
 
 		let sighash = hash_to_message!(&bip143::SigHashCache::new(closing_tx)
 			.signature_hash(0, &channel_funding_redeemscript, self.channel_value_satoshis, SigHashType::All)[..]);
@@ -608,23 +602,13 @@ impl ChannelKeys for InMemoryChannelKeys {
 		Ok(secp_ctx.sign(&msghash, &self.funding_key))
 	}
 
-	fn ready_channel(&mut self, channel_pubkeys: &ChannelPublicKeys, counterparty_selected_contest_delay: u16, holder_selected_contest_delay: u16, is_outbound: bool, funding_outpoint: &OutPoint) {
-		assert!(self.accepted_channel_data.is_none(), "Acceptance already noted");
-		self.accepted_channel_data = Some(StaticChannelData {
-			counterparty_channel_pubkeys: channel_pubkeys.clone(),
-			counterparty_selected_contest_delay,
-			holder_selected_contest_delay,
-			is_outbound,
-		});
-		assert!(self.funding_outpoint.is_none(), "Funding creation already noted");
-		self.funding_outpoint = Some(funding_outpoint.clone());
+	fn ready_channel(&mut self, channel_parameters: &ChannelTransactionParameters) {
+		assert!(self.channel_parameters.is_none(), "Acceptance already noted");
+		assert!(channel_parameters.is_populated(), "Channel parameters must be fully populated");
+		self.channel_parameters = Some(channel_parameters.clone());
 	}
 }
 
-
-impl_writeable!(StaticChannelData, 0,
- { counterparty_channel_pubkeys, counterparty_selected_contest_delay, holder_selected_contest_delay, is_outbound });
-
 impl Writeable for InMemoryChannelKeys {
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
 		self.funding_key.write(writer)?;
@@ -633,8 +617,7 @@ impl Writeable for InMemoryChannelKeys {
 		self.delayed_payment_base_key.write(writer)?;
 		self.htlc_base_key.write(writer)?;
 		self.commitment_seed.write(writer)?;
-		self.accepted_channel_data.write(writer)?;
-		self.funding_outpoint.write(writer)?;
+		self.channel_parameters.write(writer)?;
 		self.channel_value_satoshis.write(writer)?;
 		self.key_derivation_params.0.write(writer)?;
 		self.key_derivation_params.1.write(writer)?;
@@ -652,7 +635,6 @@ impl Readable for InMemoryChannelKeys {
 		let htlc_base_key = Readable::read(reader)?;
 		let commitment_seed = Readable::read(reader)?;
 		let counterparty_channel_data = Readable::read(reader)?;
-		let funding_outpoint = Readable::read(reader)?;
 		let channel_value_satoshis = Readable::read(reader)?;
 		let secp_ctx = Secp256k1::signing_only();
 		let holder_channel_pubkeys =
@@ -671,8 +653,7 @@ impl Readable for InMemoryChannelKeys {
 			commitment_seed,
 			channel_value_satoshis,
 			holder_channel_pubkeys,
-			accepted_channel_data: counterparty_channel_data,
-			funding_outpoint,
+			channel_parameters: counterparty_channel_data,
 			key_derivation_params: (params_1, params_2),
 		})
 	}
@@ -858,11 +839,13 @@ impl InMemoryChannelKeys {
 	pub(crate) fn make_channel_parameters(&self) -> ChannelTransactionParameters {
 		ChannelTransactionParameters {
 			holder_pubkeys: self.pubkeys().clone(),
-			counterparty_pubkeys: self.counterparty_pubkeys().clone(),
 			holder_selected_contest_delay: self.holder_selected_contest_delay(),
-			counterparty_selected_contest_delay: self.counterparty_selected_contest_delay(),
-			funding_outpoint: self.funding_outpoint().into_bitcoin_outpoint(),
-			is_outbound_from_holder: self.is_outbound()
+			is_outbound_from_holder: self.is_outbound(),
+			counterparty_parameters: Some(CounterpartyChannelTransactionParameters {
+				pubkeys: self.counterparty_pubkeys().clone(),
+				selected_contest_delay: self.counterparty_selected_contest_delay(),
+			}),
+			funding_outpoint: Some(self.funding_outpoint().clone()),
 		}
 	}
 }

lightning/src/ln/chan_utils.rs

@@ -37,6 +37,7 @@ use ln::chan_utils;
 use util::transaction_utils::sort_outputs;
 use ln::channel::INITIAL_COMMITMENT_NUMBER;
 use std::io::Read;
+use chain;
 
 const HTLC_OUTPUT_IN_COMMITMENT_SIZE: usize = 1 + 8 + 4 + 32 + 5;
 
@@ -543,6 +544,17 @@ pub fn build_htlc_transaction(prev_hash: &Txid, feerate_per_kw: u32, contest_del
 	}
 }
 
+/// Late-bound per-channel data used to build transactions.
+///
+/// This is a sub-structure of ChannelTransactionParameters.
+#[derive(Clone)]
+pub struct CounterpartyChannelTransactionParameters {
+	/// Counter-party public keys
+	pub pubkeys: ChannelPublicKeys,
+	/// The contest delay selected by the counterparty, which applies to holder-broadcast transactions
+	pub selected_contest_delay: u16,
+}
+
 /// Per-channel data used to build transactions in conjunction with the per-commitment data (CommitmentTransaction).
 ///
 /// Normally, this is converted to the owner-independent DirectedChannelTransactionParameters
@@ -551,36 +563,47 @@ pub fn build_htlc_transaction(prev_hash: &Txid, feerate_per_kw: u32, contest_del
 pub struct ChannelTransactionParameters {
 	/// Holder public keys
 	pub holder_pubkeys: ChannelPublicKeys,
-	/// Counter-party public keys
-	pub counterparty_pubkeys: ChannelPublicKeys,
 	/// The contest delay selected by the holder, which applies to counterparty-broadcast transactions
 	pub holder_selected_contest_delay: u16,
-	/// The contest delay selected by the counterparty, which applies to holder-broadcast transactions
-	pub counterparty_selected_contest_delay: u16,
-	/// The funding outpoint
-	pub funding_outpoint: OutPoint,
 	/// Whether the holder is the initiator of this channel.
 	/// This is an input to the commitment number obscure factor computation.
 	pub is_outbound_from_holder: bool,
+	/// The late-bound counterparty channel transaction parameters.
+	/// These parameters are populated at the point in the protocol where the counterparty provides them.
+	pub counterparty_parameters: Option<CounterpartyChannelTransactionParameters>,
+	/// The late-bound funding outpoint
+	pub funding_outpoint: Option<chain::transaction::OutPoint>,
 }
 
 impl ChannelTransactionParameters {
-	/// Convert the owner specific parameters to owner independent parameters
+	/// Whether the late bound parameters are populated.
+	pub fn is_populated(&self) -> bool {
+		self.counterparty_parameters.is_some() && self.funding_outpoint.is_some()
+	}
+
+	/// Convert the owner specific parameters to owner independent parameters.
+	///
+	/// self.is_populated() must be true before calling this function.
 	pub fn to_directed(&self, broadcaster_is_holder: bool) -> DirectedChannelTransactionParameters {
+		assert!(self.is_populated(), "self.late_parameters must be set before using to_directed");
 		DirectedChannelTransactionParameters {
 			inner: self,
 			broadcaster_is_holder
 		}
 	}
 }
 
+impl_writeable!(CounterpartyChannelTransactionParameters, 0, {
+	pubkeys,
+	selected_contest_delay
+});
+
 impl_writeable!(ChannelTransactionParameters, 0, {
 	holder_pubkeys,
-	counterparty_pubkeys,
 	holder_selected_contest_delay,
-	counterparty_selected_contest_delay,
-	funding_outpoint,
-	is_outbound_from_holder
+	is_outbound_from_holder,
+	counterparty_parameters,
+	funding_outpoint
 });
 
 /// Static channel fields used to build transactions given per-commitment fields (CommitmentTransaction).
@@ -602,30 +625,32 @@ pub struct DirectedChannelTransactionParameters<'a> {
 impl<'a> DirectedChannelTransactionParameters<'a> {
 	/// Get the pubkeys for the broadcaster and countersignatory
 	pub fn pubkeys(&self) -> (&ChannelPublicKeys, &ChannelPublicKeys) {
+		let counterparty_parameters = self.inner.counterparty_parameters.as_ref().unwrap();
 		if self.broadcaster_is_holder {
-			(&self.inner.holder_pubkeys, &self.inner.counterparty_pubkeys)
+			(&self.inner.holder_pubkeys, &counterparty_parameters.pubkeys)
 		} else {
-			(&self.inner.counterparty_pubkeys, &self.inner.holder_pubkeys)
+			(&counterparty_parameters.pubkeys, &self.inner.holder_pubkeys)
 		}
 	}
 
 	/// 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.inner.counterparty_selected_contest_delay } else { self.inner.holder_selected_contest_delay }
+		let counterparty_parameters = self.inner.counterparty_parameters.as_ref().unwrap();
+		if self.broadcaster_is_holder { counterparty_parameters.selected_contest_delay } else { self.inner.holder_selected_contest_delay }
 	}
 
 	/// Whether the channel is outbound from the broadcaster.
 	///
 	/// The boolean representing the side that initiated the channel is
 	/// an input to the commitment number obscure factor computation.
 	pub fn is_outbound(&self) -> bool {
-		return if self.broadcaster_is_holder { self.inner.is_outbound_from_holder } else { !self.inner.is_outbound_from_holder };
+		if self.broadcaster_is_holder { self.inner.is_outbound_from_holder } else { !self.inner.is_outbound_from_holder }
 	}
 
 	/// The funding outpoint
 	pub fn funding_outpoint(&self) -> OutPoint {
-		self.inner.funding_outpoint
+		self.inner.funding_outpoint.unwrap().into_bitcoin_outpoint()
 	}
 }
 
@@ -642,7 +667,7 @@ pub struct HolderCommitmentTransaction {
 	/// All non-dust counterparty HTLC signatures, in the order they appear in the transaction
 	pub counterparty_htlc_sigs: Vec<Signature>,
 	// Which order the signatures should go in when constructing the final commitment tx witness.
-	// The user should be able to reconstruc this themselves, so we don't bother to expose it.
+	// The user should be able to reconstruct this themselves, so we don't bother to expose it.
 	holder_sig_first: bool,
 }