Merge branch 'main' into no-std-no-send

Author: Fedeparma74

lightning/src/chain/channelmonitor.rs

@@ -3933,6 +3933,7 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 	#[rustfmt::skip]
 	fn generate_claimable_outpoints_and_watch_outputs(
 		&mut self, generate_monitor_event_with_reason: Option<ClosureReason>,
+		require_funding_seen: bool,
 	) -> (Vec<PackageTemplate>, Vec<TransactionOutputs>) {
 		let funding = get_confirmed_funding_scope!(self);
 		let holder_commitment_tx = &funding.current_holder_commitment_tx;
@@ -3960,6 +3961,13 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 		// in the claim that is queued to OnchainTxHandler. We set holder_tx_signed here to reject
 		// new channel updates.
 		self.holder_tx_signed = true;
+
+		// In manual-broadcast mode, if we have not yet observed the funding transaction on-chain,
+		// return empty vectors rather than triggering a broadcast.
+		if require_funding_seen && self.is_manual_broadcast && !self.funding_seen_onchain {
+			return (Vec::new(), Vec::new());
+		}
+
 		let mut watch_outputs = Vec::new();
 		// In CSV anchor channels, we can't broadcast our HTLC transactions while the commitment transaction is
 		// unconfirmed.
@@ -3985,13 +3993,7 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			}
 			claimable_outpoints.append(&mut new_outpoints);
 		}
-		// In manual-broadcast mode, if we have not yet observed the funding transaction on-chain,
-		// return empty vectors.
-		if self.is_manual_broadcast && !self.funding_seen_onchain {
-			return (Vec::new(), Vec::new());
-		} else {
-			(claimable_outpoints, watch_outputs)
-		}
+		(claimable_outpoints, watch_outputs)
 	}
 
 	#[rustfmt::skip]
@@ -4004,7 +4006,8 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 	///
 	/// [`ChannelMonitor::broadcast_latest_holder_commitment_txn`]: crate::chain::channelmonitor::ChannelMonitor::broadcast_latest_holder_commitment_txn
 	pub(crate) fn queue_latest_holder_commitment_txn_for_broadcast<B: Deref, F: Deref, L: Deref>(
-		&mut self, broadcaster: &B, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &WithChannelMonitor<L>, require_funding_seen: bool,
+		&mut self, broadcaster: &B, fee_estimator: &LowerBoundedFeeEstimator<F>, logger: &WithChannelMonitor<L>,
+		require_funding_seen: bool,
 	)
 	where
 		B::Target: BroadcasterInterface,
@@ -4015,7 +4018,8 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			broadcasted_latest_txn: Some(true),
 			message: "ChannelMonitor-initiated commitment transaction broadcast".to_owned(),
 		};
-		let (claimable_outpoints, _) = self.generate_claimable_outpoints_and_watch_outputs(Some(reason));
+		let (claimable_outpoints, _) =
+			self.generate_claimable_outpoints_and_watch_outputs(Some(reason), require_funding_seen);
 		// In manual-broadcast mode, if `require_funding_seen` is true and we have not yet observed
 		// the funding transaction on-chain, do not queue any transactions.
 		if require_funding_seen && self.is_manual_broadcast && !self.funding_seen_onchain {
@@ -5618,7 +5622,7 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 
 		if should_broadcast_commitment {
 			let (mut claimables, mut outputs) =
-				self.generate_claimable_outpoints_and_watch_outputs(None);
+				self.generate_claimable_outpoints_and_watch_outputs(None, false);
 			claimable_outpoints.append(&mut claimables);
 			watch_outputs.append(&mut outputs);
 		}
@@ -5660,9 +5664,13 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 			if let Some(payment_hash) = should_broadcast {
 				let reason = ClosureReason::HTLCsTimedOut { payment_hash: Some(payment_hash) };
 				let (mut new_outpoints, mut new_outputs) =
-					self.generate_claimable_outpoints_and_watch_outputs(Some(reason));
-				claimable_outpoints.append(&mut new_outpoints);
-				watch_outputs.append(&mut new_outputs);
+					self.generate_claimable_outpoints_and_watch_outputs(Some(reason), false);
+				if !self.is_manual_broadcast || self.funding_seen_onchain {
+					claimable_outpoints.append(&mut new_outpoints);
+					watch_outputs.append(&mut new_outputs);
+				} else {
+					log_info!(logger, "Not broadcasting holder commitment for manual-broadcast channel before funding appears on-chain");
+				}
 			}
 		}
 
@@ -5969,7 +5977,7 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitorImpl<Signer> {
 	/// Filters a block's `txdata` for transactions spending watched outputs or for any child
 	/// transactions thereof.
 	#[rustfmt::skip]
-	fn filter_block<'a>(&mut self, txdata: &TransactionData<'a>) -> Vec<&'a Transaction> {
+	fn filter_block<'a>(&self, txdata: &TransactionData<'a>) -> Vec<&'a Transaction> {
 		let mut matched_txn = new_hash_set();
 		txdata.iter().filter(|&&(_, tx)| {
 			let mut matches = self.spends_watched_output(tx);

lightning/src/chain/mod.rs

@@ -12,6 +12,8 @@
 use bitcoin::block::{Block, Header};
 use bitcoin::constants::genesis_block;
 use bitcoin::hash_types::{BlockHash, Txid};
+use bitcoin::hashes::sha256::Hash as Sha256;
+use bitcoin::hashes::{Hash, HashEngine};
 use bitcoin::network::Network;
 use bitcoin::script::{Script, ScriptBuf};
 use bitcoin::secp256k1::PublicKey;
@@ -21,6 +23,7 @@ use crate::chain::transaction::{OutPoint, TransactionData};
 use crate::impl_writeable_tlv_based;
 use crate::ln::types::ChannelId;
 use crate::sign::ecdsa::EcdsaChannelSigner;
+use crate::sign::HTLCDescriptor;
 
 #[allow(unused_imports)]
 use crate::prelude::*;
@@ -442,3 +445,20 @@ where
 /// This is not exported to bindings users as we just use [u8; 32] directly.
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
 pub struct ClaimId(pub [u8; 32]);
+
+impl ClaimId {
+	pub(crate) fn from_htlcs(htlcs: &[HTLCDescriptor]) -> ClaimId {
+		let mut engine = Sha256::engine();
+		for htlc in htlcs {
+			engine.input(&htlc.commitment_txid.to_byte_array());
+			engine.input(&htlc.htlc.transaction_output_index.unwrap().to_be_bytes());
+		}
+		ClaimId(Sha256::from_engine(engine).to_byte_array())
+	}
+	pub(crate) fn step_with_bytes(&self, bytes: &[u8]) -> ClaimId {
+		let mut engine = Sha256::engine();
+		engine.input(&self.0);
+		engine.input(bytes);
+		ClaimId(Sha256::from_engine(engine).to_byte_array())
+	}
+}

lightning/src/chain/onchaintx.rs

@@ -14,8 +14,7 @@
 
 use bitcoin::amount::Amount;
 use bitcoin::hash_types::{BlockHash, Txid};
-use bitcoin::hashes::sha256::Hash as Sha256;
-use bitcoin::hashes::{Hash, HashEngine};
+use bitcoin::hashes::Hash;
 use bitcoin::locktime::absolute::LockTime;
 use bitcoin::script::{Script, ScriptBuf};
 use bitcoin::secp256k1;
@@ -882,12 +881,7 @@ impl<ChannelSigner: EcdsaChannelSigner> OnchainTxHandler<ChannelSigner> {
 								// claim, which will always be unique per request. Once a claim ID
 								// is generated, it is assigned and remains unchanged, even if the
 								// underlying set of HTLCs changes.
-								let mut engine = Sha256::engine();
-								for htlc in htlcs {
-									engine.input(&htlc.commitment_txid.to_byte_array());
-									engine.input(&htlc.htlc.transaction_output_index.unwrap().to_be_bytes());
-								}
-								ClaimId(Sha256::from_engine(engine).to_byte_array())
+								ClaimId::from_htlcs(htlcs)
 							},
 						};
 						debug_assert!(self.pending_claim_requests.get(&claim_id).is_none());