info out of funding_created_signature

Author: devrandom

lightning/src/ln/chan_utils.rs

@@ -775,6 +775,11 @@ impl CommitmentTransactionInfo {
 			.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)
+	}
 }
 
 /// Get the transaction number obscure factor

lightning/src/ln/channel.rs

@@ -1456,7 +1456,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 		Ok(())
 	}
 
-	fn funding_created_signature<L: Deref>(&mut self, sig: &Signature, logger: &L) -> Result<(Transaction, HolderCommitmentTransaction, Signature), ChannelError> where L::Target: Logger {
+	fn funding_created_signature<L: Deref>(&mut self, sig: &Signature, logger: &L) -> Result<(Transaction, CommitmentTransactionInfo, Signature), ChannelError> where L::Target: Logger {
 		let funding_script = self.get_funding_redeemscript();
 
 		let keys = self.build_holder_transaction_keys(self.cur_holder_commitment_transaction_number)?;
@@ -1467,8 +1467,6 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 		log_trace!(logger, "Checking funding_created tx signature {} by key {} against tx {} (sighash {}) with redeemscript {}", log_bytes!(sig.serialize_compact()[..]), log_bytes!(self.counterparty_funding_pubkey().serialize()), encode::serialize_hex(&initial_commitment_tx), log_bytes!(sighash[..]), encode::serialize_hex(&funding_script));
 		secp_check!(self.secp_ctx.verify(&sighash, &sig, self.counterparty_funding_pubkey()), "Invalid funding_created signature from peer".to_owned());
 
-		let tx = HolderCommitmentTransaction::new_missing_holder_sig(initial_commitment_tx, sig.clone(), &self.holder_keys.pubkeys().funding_pubkey, self.counterparty_funding_pubkey(), keys, self.feerate_per_kw, Vec::new());
-
 		let counterparty_keys = self.build_remote_transaction_keys()?;
 		let counterparty_initial_commitment_info = self.build_commitment_transaction(self.cur_counterparty_commitment_transaction_number, &counterparty_keys, false, false, self.feerate_per_kw, logger);
 		let counterparty_initial_commitment_tx = counterparty_initial_commitment_info.0.build(self.counterparty_pubkeys.as_ref().unwrap(), self.holder_keys.pubkeys(), &self.funding_txo.unwrap().into_bitcoin_outpoint(), self.holder_selected_contest_delay,!self.is_outbound(), &self.secp_ctx).unwrap().0;
@@ -1477,7 +1475,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 				.map_err(|_| ChannelError::Close("Failed to get signatures for new commitment_signed".to_owned()))?.0;
 
 		// We sign "counterparty" commitment transaction, allowing them to broadcast the tx if they wish.
-		Ok((counterparty_initial_commitment_tx, tx, counterparty_signature))
+		Ok((counterparty_initial_commitment_tx, initial_commitment_info.0, counterparty_signature))
 	}
 
 	fn counterparty_funding_pubkey(&self) -> &PublicKey {
@@ -1503,14 +1501,27 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 		let funding_txo = OutPoint{ txid: msg.funding_txid, index: msg.funding_output_index };
 		self.funding_txo = Some(funding_txo.clone());
 
-		let (counterparty_initial_commitment_tx, initial_commitment_tx, signature) = match self.funding_created_signature(&msg.signature, logger) {
+		let (counterparty_initial_commitment_tx, initial_commitment_info, signature) = match self.funding_created_signature(&msg.signature, logger) {
 			Ok(res) => res,
 			Err(e) => {
 				self.funding_txo = None;
 				return Err(e);
 			}
 		};
 
+		// TODO some of the needed fields are already passed into ChannelMonitor, but some still need
+		// to be passed in if we are to replace HolderCommitmentTransaction with CommitmentTransactionInfo
+		let initial_commitment_tx = initial_commitment_info.to_holder_commitment_tx(
+			msg.signature, // provide in a wrapper named HolderCommitmentTransactionInfo?
+			Vec::new(),  // provide in a wrapper named HolderCommitmentTransactionInfo?
+			&self.holder_keys.pubkeys(), // DONE
+			self.counterparty_pubkeys.as_ref().unwrap(), // partially
+			&self.funding_txo.unwrap().into_bitcoin_outpoint(), // DONE
+			self.counterparty_selected_contest_delay, // DONE
+			self.is_outbound(), // provide
+			&self.secp_ctx, // not needed
+		);
+
 		// Now that we're past error-generating stuff, update our local state:
 
 		let counterparty_pubkeys = self.counterparty_pubkeys.as_ref().unwrap();
@@ -1524,7 +1535,7 @@ impl<ChanSigner: ChannelKeys> Channel<ChanSigner> {
 				                                              &counterparty_pubkeys.htlc_basepoint, &counterparty_pubkeys.delayed_payment_basepoint,
 				                                              self.counterparty_selected_contest_delay, funding_redeemscript.clone(), self.channel_value_satoshis,
 				                                              self.get_commitment_transaction_number_obscure_factor(),
-				                                              initial_commitment_tx.clone());
+				                                              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);
 				channel_monitor