provide channel static fields to ChannelMonitor

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};
+use ln::chan_utils::{CounterpartyCommitmentSecrets, HTLCOutputInCommitment, HolderCommitmentTransaction, HTLCType, ChannelPublicKeys};
 use ln::channelmanager::{HTLCSource, PaymentPreimage, PaymentHash};
 use ln::onchaintx::{OnchainTxHandler, InputDescriptors};
 use chain::chaininterface::{BroadcasterInterface, FeeEstimator};
@@ -605,13 +605,15 @@ impl Readable for ChannelMonitorUpdateStep {
 pub struct ChannelMonitor<ChanSigner: ChannelKeys> {
 	latest_update_id: u64,
 	commitment_transaction_number_obscure_factor: u64,
+	is_outbound: bool,
 
 	destination_script: Script,
 	broadcasted_holder_revokable_script: Option<(Script, PublicKey, PublicKey)>,
 	counterparty_payment_script: Script,
 	shutdown_script: Script,
 
 	keys: ChanSigner,
+	counterparty_pubkeys: ChannelPublicKeys,
 	funding_info: (OutPoint, Script),
 	current_counterparty_commitment_txid: Option<Txid>,
 	prev_counterparty_commitment_txid: Option<Txid>,
@@ -756,6 +758,7 @@ impl<ChanSigner: ChannelKeys + Writeable> ChannelMonitor<ChanSigner> {
 
 		// Set in initial Channel-object creation, so should always be set by now:
 		U48(self.commitment_transaction_number_obscure_factor).write(writer)?;
+		self.is_outbound.write(writer)?;
 
 		self.destination_script.write(writer)?;
 		if let Some(ref broadcasted_holder_revokable_script) = self.broadcasted_holder_revokable_script {
@@ -771,6 +774,7 @@ impl<ChanSigner: ChannelKeys + Writeable> ChannelMonitor<ChanSigner> {
 		self.shutdown_script.write(writer)?;
 
 		self.keys.write(writer)?;
+		self.counterparty_pubkeys.write(writer)?;
 		writer.write_all(&self.funding_info.0.txid[..])?;
 		writer.write_all(&byte_utils::be16_to_array(self.funding_info.0.index))?;
 		self.funding_info.1.write(writer)?;
@@ -933,9 +937,10 @@ 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_htlc_base_key: &PublicKey, counterparty_delayed_payment_base_key: &PublicKey,
+			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> {
 
 		assert!(commitment_transaction_number_obscure_factor <= (1 << 48));
@@ -944,7 +949,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_tx_cache = CounterpartyCommitmentTransaction { counterparty_delayed_payment_base_key: *counterparty_delayed_payment_base_key, counterparty_htlc_base_key: *counterparty_htlc_base_key, on_counterparty_tx_csv, per_htlc: HashMap::new() };
+		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);
 
@@ -968,13 +975,15 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 		ChannelMonitor {
 			latest_update_id: 0,
 			commitment_transaction_number_obscure_factor,
+			is_outbound,
 
 			destination_script: destination_script.clone(),
 			broadcasted_holder_revokable_script: None,
 			counterparty_payment_script,
 			shutdown_script,
 
 			keys,
+			counterparty_pubkeys: counterparty_pubkeys.clone(),
 			funding_info,
 			current_counterparty_commitment_txid: None,
 			prev_counterparty_commitment_txid: None,
@@ -2113,6 +2122,7 @@ impl<ChanSigner: ChannelKeys + Readable> Readable for (BlockHash, ChannelMonitor
 
 		let latest_update_id: u64 = Readable::read(reader)?;
 		let commitment_transaction_number_obscure_factor = <U48 as Readable>::read(reader)?.0;
+		let is_outbound = Readable::read(reader)?;
 
 		let destination_script = Readable::read(reader)?;
 		let broadcasted_holder_revokable_script = match <u8 as Readable>::read(reader)? {
@@ -2129,6 +2139,7 @@ impl<ChanSigner: ChannelKeys + Readable> Readable for (BlockHash, ChannelMonitor
 		let shutdown_script = Readable::read(reader)?;
 
 		let keys = Readable::read(reader)?;
+		let counterparty_pubkeys = Readable::read(reader)?;
 		// Technically this can fail and serialize fail a round-trip, but only for serialization of
 		// barely-init'd ChannelMonitors that we can't do anything with.
 		let outpoint = OutPoint {
@@ -2336,13 +2347,15 @@ impl<ChanSigner: ChannelKeys + Readable> Readable for (BlockHash, ChannelMonitor
 		Ok((last_block_hash.clone(), ChannelMonitor {
 			latest_update_id,
 			commitment_transaction_number_obscure_factor,
+			is_outbound,
 
 			destination_script,
 			broadcasted_holder_revokable_script,
 			counterparty_payment_script,
 			shutdown_script,
 
 			keys,
+			counterparty_pubkeys,
 			funding_info,
 			current_counterparty_commitment_txid,
 			prev_counterparty_commitment_txid,
@@ -2399,7 +2412,7 @@ mod tests {
 	use ln::channelmanager::{PaymentPreimage, PaymentHash};
 	use ln::onchaintx::{OnchainTxHandler, InputDescriptors};
 	use ln::chan_utils;
-	use ln::chan_utils::{HTLCOutputInCommitment, HolderCommitmentTransaction};
+	use ln::chan_utils::{HTLCOutputInCommitment, HolderCommitmentTransaction, ChannelPublicKeys};
 	use util::test_utils::TestLogger;
 	use bitcoin::secp256k1::key::{SecretKey,PublicKey};
 	use bitcoin::secp256k1::Secp256k1;
@@ -2470,14 +2483,21 @@ mod tests {
 			(0, 0)
 		);
 
+		let counterparty_pubkeys = ChannelPublicKeys {
+			funding_pubkey: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[44; 32]).unwrap()),
+			revocation_basepoint: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[45; 32]).unwrap()),
+			payment_point: PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[46; 32]).unwrap()),
+			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())
+		};
 		// 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()),
-			&PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[44; 32]).unwrap()),
-			&PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&[45; 32]).unwrap()),
-			10, Script::new(), 46, 0, HolderCommitmentTransaction::dummy());
+			&counterparty_pubkeys,
+			10, Script::new(), 46, 0,
+			true, HolderCommitmentTransaction::dummy());
 
 		monitor.provide_latest_holder_commitment_tx_info(HolderCommitmentTransaction::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);

lightning/src/ln/channel.rs

@@ -1536,9 +1536,10 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 				let mut channel_monitor = ChannelMonitor::new(self.holder_keys.clone(),
 				                                              &self.shutdown_pubkey, self.holder_selected_contest_delay,
 				                                              &self.destination_script, (funding_txo, funding_txo_script.clone()),
-				                                              &counterparty_pubkeys.htlc_basepoint, &counterparty_pubkeys.delayed_payment_basepoint,
+				                                              &counterparty_pubkeys,
 				                                              self.counterparty_selected_contest_delay, funding_redeemscript.clone(), self.channel_value_satoshis,
 				                                              self.get_commitment_transaction_number_obscure_factor(),
+				                                              self.is_outbound(),
 				                                              initial_commitment_tx);
 
 				channel_monitor.provide_latest_counterparty_commitment_tx_info(&counterparty_initial_commitment_tx, Vec::new(), self.cur_counterparty_commitment_transaction_number, self.counterparty_cur_commitment_point.unwrap(), logger);
@@ -1604,9 +1605,10 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 				let mut channel_monitor = ChannelMonitor::new(self.holder_keys.clone(),
 				                                              &self.shutdown_pubkey, self.holder_selected_contest_delay,
 				                                              &self.destination_script, (funding_txo.clone(), funding_txo_script.clone()),
-				                                              &counterparty_pubkeys.htlc_basepoint, &counterparty_pubkeys.delayed_payment_basepoint,
+				                                              &counterparty_pubkeys,
 				                                              self.counterparty_selected_contest_delay, funding_redeemscript.clone(), self.channel_value_satoshis,
 				                                              self.get_commitment_transaction_number_obscure_factor(),
+				                                              self.is_outbound(),
 				                                              commitment_tx);
 
 				channel_monitor.provide_latest_counterparty_commitment_tx_info(&counterparty_initial_commitment_tx, Vec::new(), self.cur_counterparty_commitment_transaction_number, self.counterparty_cur_commitment_point.unwrap(), logger);