replace HolderCommitmentTransaction with HolderCommitmentTransactionInfo, except for signing API

Author: devrandom

lightning/src/chain/channelmonitor.rs

@@ -39,7 +39,7 @@ use bitcoin::secp256k1;
 
 use ln::msgs::DecodeError;
 use ln::chan_utils;
-use ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HolderCommitmentTransaction, HTLCType, ChannelPublicKeys};
+use ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HTLCType, ChannelStaticInfo, HolderCommitmentTransactionInfo};
 use ln::channelmanager::{HTLCSource, PaymentPreimage, PaymentHash};
 use ln::onchaintx::{OnchainTxHandler, InputDescriptors};
 use chain::chaininterface::{BroadcasterInterface, FeeEstimator};
@@ -474,7 +474,7 @@ const MIN_SERIALIZATION_VERSION: u8 = 1;
 #[derive(Clone)]
 pub(crate) enum ChannelMonitorUpdateStep {
 	LatestHolderCommitmentTXInfo {
-		commitment_tx: HolderCommitmentTransaction,
+		commitment_info: HolderCommitmentTransactionInfo,
 		htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>,
 	},
 	LatestCounterpartyCommitmentTXInfo {
@@ -502,7 +502,7 @@ pub(crate) enum ChannelMonitorUpdateStep {
 impl Writeable for ChannelMonitorUpdateStep {
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		match self {
-			&ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { ref commitment_tx, ref htlc_outputs } => {
+			&ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_info: ref commitment_tx, ref htlc_outputs } => {
 				0u8.write(w)?;
 				commitment_tx.write(w)?;
 				(htlc_outputs.len() as u64).write(w)?;
@@ -545,7 +545,7 @@ impl Readable for ChannelMonitorUpdateStep {
 		match Readable::read(r)? {
 			0u8 => {
 				Ok(ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo {
-					commitment_tx: Readable::read(r)?,
+					commitment_info: Readable::read(r)?,
 					htlc_outputs: {
 						let len: u64 = Readable::read(r)?;
 						let mut res = Vec::new();
@@ -934,46 +934,48 @@ impl<ChanSigner: ChannelKeys + Writeable> ChannelMonitor<ChanSigner> {
 
 impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 	pub(crate) fn new(keys: ChanSigner, shutdown_pubkey: &PublicKey,
-			on_counterparty_tx_csv: u16, destination_script: &Script, funding_info: (OutPoint, Script),
-			counterparty_pubkeys: &ChannelPublicKeys,
-			on_holder_tx_csv: u16, funding_redeemscript: Script, channel_value_satoshis: u64,
-			commitment_transaction_number_obscure_factor: u64,
-			is_outbound: bool,
-			initial_holder_commitment_tx: HolderCommitmentTransaction) -> ChannelMonitor<ChanSigner> {
+	                  on_counterparty_tx_csv: u16, destination_script: &Script, funding_info: (OutPoint, Script),
+	                  channel_static_info: &ChannelStaticInfo,
+	                  funding_redeemscript: Script, channel_value_satoshis: u64,
+	                  commitment_transaction_number_obscure_factor: u64,
+	                  initial_holder_commitment_info: HolderCommitmentTransactionInfo) -> ChannelMonitor<ChanSigner> {
 
 		assert!(commitment_transaction_number_obscure_factor <= (1 << 48));
 		let our_channel_close_key_hash = WPubkeyHash::hash(&shutdown_pubkey.serialize());
 		let shutdown_script = Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0).push_slice(&our_channel_close_key_hash[..]).into_script();
 		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_pubkeys = &channel_static_info.counterparty_pubkeys;
 		let counterparty_delayed_payment_base_key = counterparty_pubkeys.delayed_payment_basepoint;
 		let counterparty_htlc_base_key = counterparty_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(), on_holder_tx_csv);
+		let mut onchain_tx_handler = OnchainTxHandler::new(destination_script.clone(), keys.clone(), channel_static_info.clone());
 
-		let holder_tx_sequence = initial_holder_commitment_tx.unsigned_tx.input[0].sequence as u64;
-		let holder_tx_locktime = initial_holder_commitment_tx.unsigned_tx.lock_time as u64;
+		let current_holder_commitment_number = initial_holder_commitment_info.info.commitment_number;
+		let secp_ctx = Secp256k1::new();
+
+		let txid = initial_holder_commitment_info.txid(channel_static_info, &secp_ctx);
 		let holder_commitment_tx = HolderSignedTx {
-			txid: initial_holder_commitment_tx.txid(),
-			revocation_key: initial_holder_commitment_tx.keys.revocation_key,
-			a_htlc_key: initial_holder_commitment_tx.keys.broadcaster_htlc_key,
-			b_htlc_key: initial_holder_commitment_tx.keys.countersignatory_htlc_key,
-			delayed_payment_key: initial_holder_commitment_tx.keys.broadcaster_delayed_payment_key,
-			per_commitment_point: initial_holder_commitment_tx.keys.per_commitment_point,
-			feerate_per_kw: initial_holder_commitment_tx.feerate_per_kw,
+			txid,
+			revocation_key: initial_holder_commitment_info.info.keys.revocation_key,
+			a_htlc_key: initial_holder_commitment_info.info.keys.broadcaster_htlc_key,
+			b_htlc_key: initial_holder_commitment_info.info.keys.countersignatory_htlc_key,
+			delayed_payment_key: initial_holder_commitment_info.info.keys.broadcaster_delayed_payment_key,
+			per_commitment_point: initial_holder_commitment_info.info.keys.per_commitment_point,
+			feerate_per_kw: initial_holder_commitment_info.info.feerate_per_kw,
 			htlc_outputs: Vec::new(), // There are never any HTLCs in the initial commitment transactions
 		};
-		onchain_tx_handler.provide_latest_holder_tx(initial_holder_commitment_tx);
+		onchain_tx_handler.provide_latest_holder_tx(initial_holder_commitment_info);
 
 		let mut outputs_to_watch = HashMap::new();
 		outputs_to_watch.insert(funding_info.0.txid, vec![funding_info.1.clone()]);
 
 		ChannelMonitor {
 			latest_update_id: 0,
 			commitment_transaction_number_obscure_factor,
-			is_outbound,
+			is_outbound: channel_static_info.is_outbound_from_holder,
 
 			destination_script: destination_script.clone(),
 			broadcasted_holder_revokable_script: None,
@@ -990,7 +992,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 			channel_value_satoshis,
 			their_cur_revocation_points: None,
 
-			on_holder_tx_csv,
+			on_holder_tx_csv: channel_static_info.counterparty_selected_contest_delay,
 
 			commitment_secrets: CounterpartyCommitmentSecrets::new(),
 			counterparty_claimable_outpoints: HashMap::new(),
@@ -1000,7 +1002,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 			prev_holder_signed_commitment_tx: None,
 			current_holder_commitment_tx: holder_commitment_tx,
 			current_counterparty_commitment_number: 1 << 48,
-			current_holder_commitment_number: 0xffff_ffff_ffff - ((((holder_tx_sequence & 0xffffff) << 3*8) | (holder_tx_locktime as u64 & 0xffffff)) ^ commitment_transaction_number_obscure_factor),
+			current_holder_commitment_number,
 
 			payment_preimages: HashMap::new(),
 			pending_monitor_events: Vec::new(),
@@ -1015,7 +1017,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 			holder_tx_signed: false,
 
 			last_block_hash: Default::default(),
-			secp_ctx: Secp256k1::new(),
+			secp_ctx: secp_ctx,
 		}
 	}
 
@@ -1123,22 +1125,20 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 	/// is important that any clones of this channel monitor (including remote clones) by kept
 	/// 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_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>) -> Result<(), MonitorUpdateError> {
-		let txid = commitment_tx.txid();
-		let sequence = commitment_tx.unsigned_tx.input[0].sequence as u64;
-		let locktime = commitment_tx.unsigned_tx.lock_time as u64;
+	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 mut new_holder_commitment_tx = HolderSignedTx {
 			txid,
-			revocation_key: commitment_tx.keys.revocation_key,
-			a_htlc_key: commitment_tx.keys.broadcaster_htlc_key,
-			b_htlc_key: commitment_tx.keys.countersignatory_htlc_key,
-			delayed_payment_key: commitment_tx.keys.broadcaster_delayed_payment_key,
-			per_commitment_point: commitment_tx.keys.per_commitment_point,
-			feerate_per_kw: commitment_tx.feerate_per_kw,
+			revocation_key: commitment_info.info.keys.revocation_key,
+			a_htlc_key: commitment_info.info.keys.broadcaster_htlc_key,
+			b_htlc_key: commitment_info.info.keys.countersignatory_htlc_key,
+			delayed_payment_key: commitment_info.info.keys.broadcaster_delayed_payment_key,
+			per_commitment_point: commitment_info.info.keys.per_commitment_point,
+			feerate_per_kw: commitment_info.info.feerate_per_kw,
 			htlc_outputs,
 		};
-		self.onchain_tx_handler.provide_latest_holder_tx(commitment_tx);
-		self.current_holder_commitment_number = 0xffff_ffff_ffff - ((((sequence & 0xffffff) << 3*8) | (locktime as u64 & 0xffffff)) ^ self.commitment_transaction_number_obscure_factor);
+		self.current_holder_commitment_number = commitment_info.info.commitment_number;
+		self.onchain_tx_handler.provide_latest_holder_tx(commitment_info);
 		mem::swap(&mut new_holder_commitment_tx, &mut self.current_holder_commitment_tx);
 		self.prev_holder_signed_commitment_tx = Some(new_holder_commitment_tx);
 		if self.holder_tx_signed {
@@ -1176,7 +1176,7 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 		}
 		for update in updates.updates.drain(..) {
 			match update {
-				ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_tx, htlc_outputs } => {
+				ChannelMonitorUpdateStep::LatestHolderCommitmentTXInfo { commitment_info: commitment_tx, htlc_outputs } => {
 					if self.lockdown_from_offchain { panic!(); }
 					self.provide_latest_holder_commitment_tx_info(commitment_tx, htlc_outputs)?
 				},
@@ -2407,7 +2407,7 @@ mod tests {
 	use ln::channelmanager::{PaymentPreimage, PaymentHash};
 	use ln::onchaintx::{OnchainTxHandler, InputDescriptors};
 	use ln::chan_utils;
-	use ln::chan_utils::{HTLCOutputInCommitment, HolderCommitmentTransaction, ChannelPublicKeys};
+	use ln::chan_utils::{HTLCOutputInCommitment, ChannelPublicKeys, ChannelStaticInfo, HolderCommitmentTransactionInfo};
 	use util::test_utils::TestLogger;
 	use bitcoin::secp256k1::key::{SecretKey,PublicKey};
 	use bitcoin::secp256k1::Secp256k1;
@@ -2485,16 +2485,24 @@ 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 channel_static_info = ChannelStaticInfo {
+			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
+		};
 		// Prune with one old state and a holder commitment tx holding a few overlaps with the
 		// old state.
 		let mut monitor = ChannelMonitor::new(keys,
 			&PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[42; 32]).unwrap()), 0, &Script::new(),
 			(OutPoint { txid: Txid::from_slice(&[43; 32]).unwrap(), index: 0 }, Script::new()),
-			&counterparty_pubkeys,
-			10, Script::new(), 46, 0,
-			true, HolderCommitmentTransaction::dummy());
+			&channel_static_info,
+			Script::new(), 46, 0,
+			HolderCommitmentTransactionInfo::dummy());
 
-		monitor.provide_latest_holder_commitment_tx_info(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
+		monitor.provide_latest_holder_commitment_tx_info(HolderCommitmentTransactionInfo::dummy(), preimages_to_holder_htlcs!(preimages[0..10])).unwrap();
 		monitor.provide_latest_counterparty_commitment_tx_info(&dummy_tx, preimages_slice_to_htlc_outputs!(preimages[5..15]), 281474976710655, dummy_key, &logger);
 		monitor.provide_latest_counterparty_commitment_tx_info(&dummy_tx, preimages_slice_to_htlc_outputs!(preimages[15..20]), 281474976710654, dummy_key, &logger);
 		monitor.provide_latest_counterparty_commitment_tx_info(&dummy_tx, preimages_slice_to_htlc_outputs!(preimages[17..20]), 281474976710653, dummy_key, &logger);
@@ -2520,15 +2528,15 @@ mod tests {
 
 		// Now update holder commitment tx info, pruning only element 18 as we still care about the
 		// previous commitment tx's preimages too
-		monitor.provide_latest_holder_commitment_tx_info(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..5])).unwrap();
+		monitor.provide_latest_holder_commitment_tx_info(HolderCommitmentTransactionInfo::dummy(), preimages_to_holder_htlcs!(preimages[0..5])).unwrap();
 		secret[0..32].clone_from_slice(&hex::decode("2273e227a5b7449b6e70f1fb4652864038b1cbf9cd7c043a7d6456b7fc275ad8").unwrap());
 		monitor.provide_secret(281474976710653, secret.clone()).unwrap();
 		assert_eq!(monitor.payment_preimages.len(), 12);
 		test_preimages_exist!(&preimages[0..10], monitor);
 		test_preimages_exist!(&preimages[18..20], monitor);
 
 		// But if we do it again, we'll prune 5-10
-		monitor.provide_latest_holder_commitment_tx_info(HolderCommitmentTransaction::dummy(), preimages_to_holder_htlcs!(preimages[0..3])).unwrap();
+		monitor.provide_latest_holder_commitment_tx_info(HolderCommitmentTransactionInfo::dummy(), preimages_to_holder_htlcs!(preimages[0..3])).unwrap();
 		secret[0..32].clone_from_slice(&hex::decode("27cddaa5624534cb6cb9d7da077cf2b22ab21e9b506fd4998a51d54502e99116").unwrap());
 		monitor.provide_secret(281474976710652, secret.clone()).unwrap();
 		assert_eq!(monitor.payment_preimages.len(), 5);