fixup! cleanup

Author: devrandom

lightning/src/chain/channelmonitor.rs

@@ -969,24 +969,23 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 
 		let secp_ctx = Secp256k1::new();
 
-		let txid = initial_holder_commitment_tx.trust_txid();
+		let txid = initial_holder_commitment_tx.untrusted_txid();
 
 		// block for Rust 1.34 compat
 		let (holder_commitment_tx, current_holder_commitment_number) = {
 			let commitment_tx = &initial_holder_commitment_tx.inner;
-			let tx_keys = &commitment_tx.keys;
-			let current_holder_commitment_number = commitment_tx.commitment_number;
+			let tx_keys = commitment_tx.untrusted_key_derivation();
 			let holder_commitment_tx = HolderSignedTx {
 				txid,
 				revocation_key: tx_keys.revocation_key,
 				a_htlc_key: tx_keys.broadcaster_htlc_key,
 				b_htlc_key: tx_keys.countersignatory_htlc_key,
 				delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 				per_commitment_point: tx_keys.per_commitment_point,
-				feerate_per_kw: commitment_tx.feerate_per_kw,
+				feerate_per_kw: commitment_tx.feerate_per_kw(),
 				htlc_outputs: Vec::new(), // There are never any HTLCs in the initial commitment transactions
 			};
-			(holder_commitment_tx, current_holder_commitment_number)
+			(holder_commitment_tx, commitment_tx.commitment_number())
 		};
 		onchain_tx_handler.provide_latest_holder_tx(initial_holder_commitment_tx);
 
@@ -1106,8 +1105,6 @@ impl<ChanSigner: ChannelKeys> ChannelMonitor<ChanSigner> {
 		}
 
 		log_trace!(logger, "Tracking new counterparty commitment transaction with txid {} at commitment number {} with {} HTLC outputs", txid, commitment_number, htlc_outputs.len());
-		// TODO do we really want to log the transaction hex?
-		// log_trace!(logger, "New potential counterparty commitment transaction: {}", encode::serialize_hex(unsigned_commitment_tx));
 		self.prev_counterparty_commitment_txid = self.current_counterparty_commitment_txid.take();
 		self.current_counterparty_commitment_txid = Some(txid);
 		self.counterparty_claimable_outpoints.insert(txid, htlc_outputs.clone());
@@ -1146,21 +1143,21 @@ 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(&mut self, holder_commitment_tx: HolderCommitmentTransaction, htlc_outputs: Vec<(HTLCOutputInCommitment, Option<Signature>, Option<HTLCSource>)>) -> Result<(), MonitorUpdateError> {
-		let txid = holder_commitment_tx.trust_txid();
+		let txid = holder_commitment_tx.untrusted_txid();
 
 		// block for Rust 1.34 compat
 		let mut new_holder_commitment_tx = {
 			let commitment_tx = &holder_commitment_tx.inner;
-			let tx_keys = &commitment_tx.keys;
-			self.current_holder_commitment_number = commitment_tx.commitment_number;
+			let tx_keys = &commitment_tx.untrusted_key_derivation();
+			self.current_holder_commitment_number = commitment_tx.commitment_number();
 			HolderSignedTx {
 				txid,
 				revocation_key: tx_keys.revocation_key,
 				a_htlc_key: tx_keys.broadcaster_htlc_key,
 				b_htlc_key: tx_keys.countersignatory_htlc_key,
 				delayed_payment_key: tx_keys.broadcaster_delayed_payment_key,
 				per_commitment_point: tx_keys.per_commitment_point,
-				feerate_per_kw: commitment_tx.feerate_per_kw,
+				feerate_per_kw: commitment_tx.feerate_per_kw(),
 				htlc_outputs,
 			}
 		};

lightning/src/chain/keysinterface.rs

@@ -350,29 +350,11 @@ pub trait KeysInterface: Send + Sync {
 	fn get_secure_random_bytes(&self) -> [u8; 32];
 }
 
-#[derive(Clone)]
-/// Holds late-bound static channel data.
-/// This data is available after the channel is readied, either
-/// when receiving an funding_created for an inbound channel or when
-/// creating a funding transaction for an outbound channel.
-struct StaticChannelData {
-	/// Counterparty public keys and base points
-	counterparty_channel_pubkeys: ChannelPublicKeys,
-	/// 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.
-	counterparty_selected_contest_delay: u16,
-	/// 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.
-	holder_selected_contest_delay: u16,
-	/// Whether the holder is the initiator of this channel
-	is_outbound: bool,
-}
-
 #[derive(Clone)]
 /// A simple implementation of ChannelKeys that just keeps the private keys in memory.
+///
+/// This implementation performs no policy checks and is insufficient by itself as
+/// a secure external signer.
 pub struct InMemoryChannelKeys {
 	/// Private key of anchor tx
 	pub funding_key: SecretKey,
@@ -481,26 +463,26 @@ impl ChannelKeys for InMemoryChannelKeys {
 	fn key_derivation_params(&self) -> (u64, u64) { self.key_derivation_params }
 
 	fn sign_counterparty_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, commitment_tx: &CommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<(Signature, Vec<Signature>), ()> {
-		let keys = commitment_tx.trust_key_derivation();
+		let keys = commitment_tx.untrusted_key_derivation();
 
 		let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 		let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &self.counterparty_pubkeys().funding_pubkey);
 
-		let built_tx = &commitment_tx.built;
-		let commitment_sig = built_tx.get_signature(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
+		let built_tx = commitment_tx.untrusted_built_transaction();
+		let commitment_sig = built_tx.sign(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx);
 
-		let commitment_txid = commitment_tx.trust_txid();
+		let commitment_txid = commitment_tx.untrusted_txid();
 
-		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, self.holder_selected_contest_delay(), htlc, &keys.broadcaster_delayed_payment_key, &keys.revocation_key);
+		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(), 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) {
+			let holder_htlc_key = match chan_utils::derive_private_key(&secp_ctx, &keys.per_commitment_point, &self.htlc_base_key) {
 				Ok(s) => s,
 				Err(_) => return Err(()),
 			};
-			htlc_sigs.push(secp_ctx.sign(&htlc_sighash, &our_htlc_key));
+			htlc_sigs.push(secp_ctx.sign(&htlc_sighash, &holder_htlc_key));
 		}
 
 		Ok((commitment_sig, htlc_sigs))
@@ -510,8 +492,8 @@ impl ChannelKeys for InMemoryChannelKeys {
 		let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 		let funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &self.counterparty_pubkeys().funding_pubkey);
 
-		let built_tx = &commitment_tx.inner.built;
-		let sig = built_tx.get_signature(&self.funding_key, &funding_redeemscript, self.channel_value_satoshis, secp_ctx);
+		let built_tx = commitment_tx.inner.untrusted_built_transaction();
+		let sig = built_tx.sign(&self.funding_key, &funding_redeemscript, self.channel_value_satoshis, secp_ctx);
 		let htlc_sigs_o = self.sign_holder_commitment_htlc_transactions(&commitment_tx, secp_ctx)?;
 		let htlc_sigs = htlc_sigs_o.iter().map(|o| o.unwrap()).collect();
 
@@ -523,13 +505,13 @@ impl ChannelKeys for InMemoryChannelKeys {
 		let funding_pubkey = PublicKey::from_secret_key(secp_ctx, &self.funding_key);
 		let channel_funding_redeemscript = make_funding_redeemscript(&funding_pubkey, &self.counterparty_pubkeys().funding_pubkey);
 
-		let built_tx = &holder_commitment_tx.inner.built;
-		Ok(built_tx.get_signature(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
+		let built_tx = holder_commitment_tx.inner.untrusted_built_transaction();
+		Ok(built_tx.sign(&self.funding_key, &channel_funding_redeemscript, self.channel_value_satoshis, secp_ctx))
 	}
 
 	fn sign_holder_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, commitment_tx: &HolderCommitmentTransaction, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()> {
 		let channel_parameters = self.make_channel_parameters();
-		let channel_parameters = channel_parameters.to_directed(true);
+		let channel_parameters = channel_parameters.as_holder_broadcastable();
 		commitment_tx.inner.get_htlc_sigs(&self.htlc_base_key, &channel_parameters, secp_ctx)
 	}