Refactor BroadcastType with channel context

We add the `ChannelId` as context to the just-added `BroadcastType`
enum.

Co-Authored-By: HAL 9000

Signed-off-by: Elias Rohrer <dev@tnull.de>

Author: tnull

lightning-liquidity/src/lsps2/service.rs

@@ -2023,23 +2023,24 @@ where
 		// (for example when a forwarded HTLC nears expiry). Broadcasting funding after a
 		// close could then confirm the commitment and trigger unintended on‑chain handling.
 		// To avoid this, we check ChannelManager’s view (`is_channel_ready`) before broadcasting.
-		let channel_id_opt = jit_channel.get_channel_id();
-		if let Some(ch_id) = channel_id_opt {
+		if let Some(ch_id) = jit_channel.get_channel_id() {
 			let is_channel_ready = self
 				.channel_manager
 				.get_cm()
 				.list_channels()
 				.into_iter()
 				.any(|cd| cd.channel_id == ch_id && cd.is_channel_ready);
+
 			if !is_channel_ready {
 				return;
 			}
-		} else {
-			return;
-		}
 
-		if let Some(funding_tx) = jit_channel.get_funding_tx() {
-			self.tx_broadcaster.broadcast_transactions(&[(funding_tx, BroadcastType::Funding)]);
+			if let Some(funding_tx) = jit_channel.get_funding_tx() {
+				self.tx_broadcaster.broadcast_transactions(&[(
+					funding_tx,
+					BroadcastType::Funding { channel_ids: vec![ch_id] },
+				)]);
+			}
 		}
 	}
 }

lightning/src/chain/chaininterface.rs

@@ -15,6 +15,7 @@
 
 use core::{cmp, ops::Deref};
 
+use crate::ln::types::ChannelId;
 use crate::prelude::*;
 
 use bitcoin::transaction::Transaction;
@@ -23,22 +24,47 @@ use bitcoin::transaction::Transaction;
 ///
 /// This is used to provide context about the type of transaction being broadcast, which may be
 /// useful for logging, filtering, or prioritization purposes.
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub enum BroadcastType {
 	/// A funding transaction establishing a new channel.
-	Funding,
+	Funding {
+		/// The IDs of the channels being funded.
+		///
+		/// A single funding transaction may establish multiple channels when using batch funding.
+		channel_ids: Vec<ChannelId>,
+	},
 	/// A cooperative close transaction mutually agreed upon by both parties.
-	CooperativeClose,
+	CooperativeClose {
+		/// The ID of the channel being closed.
+		channel_id: ChannelId,
+	},
 	/// A commitment transaction being broadcast to force-close the channel.
-	Commitment,
+	Commitment {
+		/// The ID of the channel being force-closed.
+		channel_id: ChannelId,
+	},
 	/// An anchor transaction used for CPFP fee-bumping a commitment transaction.
-	Anchor,
+	Anchor {
+		/// The ID of the channel whose commitment transaction is being fee-bumped.
+		channel_id: ChannelId,
+	},
 	/// A transaction claiming outputs from a commitment transaction (HTLC claims, penalty/justice).
-	Claim,
+	Claim {
+		/// The ID of the channel from which outputs are being claimed.
+		channel_id: ChannelId,
+	},
 	/// An HTLC resolution transaction (HTLC-timeout or HTLC-success) for anchor channels.
-	HtlcResolution,
+	HtlcResolution {
+		/// The ID of the channel whose HTLCs are being resolved.
+		channel_id: ChannelId,
+	},
 	/// A transaction sweeping spendable outputs to the user's wallet.
-	Sweep,
+	Sweep {
+		/// The IDs of the channels from which outputs are being swept, if known.
+		///
+		/// A single sweep transaction may aggregate outputs from multiple channels.
+		channel_ids: Vec<ChannelId>,
+	},
 }
 
 // TODO: Define typed abstraction over feerates to handle their conversions.

lightning/src/chain/channelmonitor.rs

@@ -1904,8 +1904,9 @@ impl<Signer: EcdsaChannelSigner> ChannelMonitor<Signer> {
 			initial_holder_commitment_tx.trust().commitment_number();
 
 		let onchain_tx_handler = OnchainTxHandler::new(
-			channel_parameters.channel_value_satoshis, channel_keys_id, destination_script.into(),
-			keys, channel_parameters.clone(), initial_holder_commitment_tx.clone(), secp_ctx
+			channel_id, channel_parameters.channel_value_satoshis, channel_keys_id,
+			destination_script.into(), keys, channel_parameters.clone(),
+			initial_holder_commitment_tx.clone(), secp_ctx,
 		);
 
 		let funding_outpoint = channel_parameters.funding_outpoint

lightning/src/chain/onchaintx.rs

@@ -35,6 +35,7 @@ use crate::ln::chan_utils::{
 	HTLCOutputInCommitment, HolderCommitmentTransaction,
 };
 use crate::ln::msgs::DecodeError;
+use crate::ln::types::ChannelId;
 use crate::sign::{ecdsa::EcdsaChannelSigner, EntropySource, HTLCDescriptor, SignerProvider};
 use crate::util::logger::Logger;
 use crate::util::ser::{
@@ -223,6 +224,7 @@ pub(crate) enum FeerateStrategy {
 /// do RBF bumping if possible.
 #[derive(Clone)]
 pub struct OnchainTxHandler<ChannelSigner: EcdsaChannelSigner> {
+	channel_id: ChannelId,
 	channel_value_satoshis: u64,   // Deprecated as of 0.2.
 	channel_keys_id: [u8; 32],     // Deprecated as of 0.2.
 	destination_script: ScriptBuf, // Deprecated as of 0.2.
@@ -285,7 +287,8 @@ impl<ChannelSigner: EcdsaChannelSigner> PartialEq for OnchainTxHandler<ChannelSi
 	#[rustfmt::skip]
 	fn eq(&self, other: &Self) -> bool {
 		// `signer`, `secp_ctx`, and `pending_claim_events` are excluded on purpose.
-		self.channel_value_satoshis == other.channel_value_satoshis &&
+		self.channel_id == other.channel_id &&
+			self.channel_value_satoshis == other.channel_value_satoshis &&
 			self.channel_keys_id == other.channel_keys_id &&
 			self.destination_script == other.destination_script &&
 			self.holder_commitment == other.holder_commitment &&
@@ -345,7 +348,9 @@ impl<ChannelSigner: EcdsaChannelSigner> OnchainTxHandler<ChannelSigner> {
 			entry.write(writer)?;
 		}
 
-		write_tlv_fields!(writer, {});
+		write_tlv_fields!(writer, {
+			(1, self.channel_id, required),
+		});
 		Ok(())
 	}
 }
@@ -369,7 +374,7 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 		let prev_holder_commitment = Readable::read(reader)?;
 		let _prev_holder_htlc_sigs: Option<Vec<Option<(usize, Signature)>>> = Readable::read(reader)?;
 
-		let channel_parameters = ReadableArgs::<Option<u64>>::read(reader, Some(channel_value_satoshis))?;
+		let channel_parameters: ChannelTransactionParameters = ReadableArgs::<Option<u64>>::read(reader, Some(channel_value_satoshis))?;
 
 		// Read the serialized signer bytes, but don't deserialize them, as we'll obtain our signer
 		// by re-deriving the private key material.
@@ -421,12 +426,24 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 			}
 		}
 
-		read_tlv_fields!(reader, {});
+		let mut channel_id = None;
+		read_tlv_fields!(reader, {
+			(1, channel_id, option),
+		});
+
+		// For backwards compatibility with monitors serialized before channel_id was added,
+		// we derive a channel_id from the funding outpoint if not present.
+		let channel_id = channel_id.or_else(|| {
+			channel_parameters.funding_outpoint
+				.map(|op| ChannelId::v1_from_funding_outpoint(op))
+		}) // funding_outpoint must be known during intialization.
+		.ok_or(DecodeError::InvalidValue)?;
 
 		let mut secp_ctx = Secp256k1::new();
 		secp_ctx.seeded_randomize(&entropy_source.get_secure_random_bytes());
 
 		Ok(OnchainTxHandler {
+			channel_id,
 			channel_value_satoshis,
 			channel_keys_id,
 			destination_script,
@@ -446,11 +463,13 @@ impl<'a, 'b, ES: EntropySource, SP: SignerProvider> ReadableArgs<(&'a ES, &'b SP
 
 impl<ChannelSigner: EcdsaChannelSigner> OnchainTxHandler<ChannelSigner> {
 	pub(crate) fn new(
-		channel_value_satoshis: u64, channel_keys_id: [u8; 32], destination_script: ScriptBuf,
-		signer: ChannelSigner, channel_parameters: ChannelTransactionParameters,
+		channel_id: ChannelId, channel_value_satoshis: u64, channel_keys_id: [u8; 32],
+		destination_script: ScriptBuf, signer: ChannelSigner,
+		channel_parameters: ChannelTransactionParameters,
 		holder_commitment: HolderCommitmentTransaction, secp_ctx: Secp256k1<secp256k1::All>,
 	) -> Self {
 		OnchainTxHandler {
+			channel_id,
 			channel_value_satoshis,
 			channel_keys_id,
 			destination_script,
@@ -518,7 +537,7 @@ impl<ChannelSigner: EcdsaChannelSigner> OnchainTxHandler<ChannelSigner> {
 							if tx.is_fully_signed() {
 								let log_start = if feerate_was_bumped { "Broadcasting RBF-bumped" } else { "Rebroadcasting" };
 								log_info!(logger, "{} onchain {}", log_start, log_tx!(tx.0));
-								broadcaster.broadcast_transactions(&[(&tx.0, BroadcastType::Claim)]);
+								broadcaster.broadcast_transactions(&[(&tx.0, BroadcastType::Claim { channel_id: self.channel_id })]);
 							} else {
 								log_info!(logger, "Waiting for signature of unsigned onchain transaction {}", tx.0.compute_txid());
 							}
@@ -865,7 +884,7 @@ impl<ChannelSigner: EcdsaChannelSigner> OnchainTxHandler<ChannelSigner> {
 					OnchainClaim::Tx(tx) => {
 						if tx.is_fully_signed() {
 							log_info!(logger, "Broadcasting onchain {}", log_tx!(tx.0));
-							broadcaster.broadcast_transactions(&[(&tx.0, BroadcastType::Claim)]);
+							broadcaster.broadcast_transactions(&[(&tx.0, BroadcastType::Claim { channel_id: self.channel_id })]);
 						} else {
 							log_info!(logger, "Waiting for signature of unsigned onchain transaction {}", tx.0.compute_txid());
 						}
@@ -1086,7 +1105,7 @@ impl<ChannelSigner: EcdsaChannelSigner> OnchainTxHandler<ChannelSigner> {
 					OnchainClaim::Tx(bump_tx) => {
 						if bump_tx.is_fully_signed() {
 							log_info!(logger, "Broadcasting RBF-bumped onchain {}", log_tx!(bump_tx.0));
-							broadcaster.broadcast_transactions(&[(&bump_tx.0, BroadcastType::Claim)]);
+							broadcaster.broadcast_transactions(&[(&bump_tx.0, BroadcastType::Claim { channel_id: self.channel_id })]);
 						} else {
 							log_info!(logger, "Waiting for signature of RBF-bumped unsigned onchain transaction {}",
 								bump_tx.0.compute_txid());
@@ -1189,7 +1208,7 @@ impl<ChannelSigner: EcdsaChannelSigner> OnchainTxHandler<ChannelSigner> {
 					OnchainClaim::Tx(bump_tx) => {
 						if bump_tx.is_fully_signed() {
 							log_info!(logger, "Broadcasting onchain {}", log_tx!(bump_tx.0));
-							broadcaster.broadcast_transactions(&[(&bump_tx.0, BroadcastType::Claim)]);
+							broadcaster.broadcast_transactions(&[(&bump_tx.0, BroadcastType::Claim { channel_id: self.channel_id })]);
 						} else {
 							log_info!(logger, "Waiting for signature of unsigned onchain transaction {}", bump_tx.0.compute_txid());
 						}
@@ -1283,6 +1302,7 @@ mod tests {
 	};
 	use crate::ln::channel_keys::{DelayedPaymentBasepoint, HtlcBasepoint, RevocationBasepoint};
 	use crate::ln::functional_test_utils::create_dummy_block;
+	use crate::ln::types::ChannelId;
 	use crate::sign::{ChannelDerivationParameters, ChannelSigner, HTLCDescriptor, InMemorySigner};
 	use crate::types::payment::{PaymentHash, PaymentPreimage};
 	use crate::util::test_utils::{TestBroadcaster, TestFeeEstimator, TestLogger};
@@ -1367,6 +1387,7 @@ mod tests {
 		let holder_commit = HolderCommitmentTransaction::dummy(1000000, funding_outpoint, nondust_htlcs);
 		let destination_script = ScriptBuf::new();
 		let mut tx_handler = OnchainTxHandler::new(
+			ChannelId::from_bytes([0; 32]),
 			1000000,
 			[0; 32],
 			destination_script.clone(),

lightning/src/events/bump_transaction/mod.rs

@@ -765,9 +765,9 @@ where
 	/// transaction spending an anchor output of the commitment transaction to bump its fee and
 	/// broadcasts them to the network as a package.
 	async fn handle_channel_close(
-		&self, claim_id: ClaimId, package_target_feerate_sat_per_1000_weight: u32,
-		commitment_tx: &Transaction, commitment_tx_fee_sat: u64,
-		anchor_descriptor: &AnchorDescriptor,
+		&self, channel_id: ChannelId, claim_id: ClaimId,
+		package_target_feerate_sat_per_1000_weight: u32, commitment_tx: &Transaction,
+		commitment_tx_fee_sat: u64, anchor_descriptor: &AnchorDescriptor,
 	) -> Result<(), ()> {
 		let channel_type = &anchor_descriptor
 			.channel_derivation_parameters
@@ -788,7 +788,10 @@ where
 			log_debug!(self.logger, "Pre-signed commitment {} already has feerate {} sat/kW above required {} sat/kW, broadcasting.",
 				commitment_tx.compute_txid(), commitment_tx_feerate_sat_per_1000_weight,
 				package_target_feerate_sat_per_1000_weight);
-			self.broadcaster.broadcast_transactions(&[(&commitment_tx, BroadcastType::Commitment)]);
+			self.broadcaster.broadcast_transactions(&[(
+				&commitment_tx,
+				BroadcastType::Commitment { channel_id },
+			)]);
 			return Ok(());
 		}
 
@@ -956,8 +959,8 @@ where
 				commitment_tx.compute_txid()
 			);
 			self.broadcaster.broadcast_transactions(&[
-				(&commitment_tx, BroadcastType::Commitment),
-				(&anchor_tx, BroadcastType::Anchor),
+				(&commitment_tx, BroadcastType::Commitment { channel_id }),
+				(&anchor_tx, BroadcastType::Anchor { channel_id }),
 			]);
 			return Ok(());
 		}
@@ -966,7 +969,7 @@ where
 	/// Handles a [`BumpTransactionEvent::HTLCResolution`] event variant by producing a
 	/// fully-signed, fee-bumped HTLC transaction that is broadcast to the network.
 	async fn handle_htlc_resolution(
-		&self, claim_id: ClaimId, target_feerate_sat_per_1000_weight: u32,
+		&self, channel_id: ChannelId, claim_id: ClaimId, target_feerate_sat_per_1000_weight: u32,
 		htlc_descriptors: &[HTLCDescriptor], tx_lock_time: LockTime,
 	) -> Result<(), ()> {
 		let channel_type = &htlc_descriptors[0]
@@ -1191,7 +1194,10 @@ where
 			}
 
 			log_info!(self.logger, "Broadcasting {}", log_tx!(htlc_tx));
-			self.broadcaster.broadcast_transactions(&[(&htlc_tx, BroadcastType::HtlcResolution)]);
+			self.broadcaster.broadcast_transactions(&[(
+				&htlc_tx,
+				BroadcastType::HtlcResolution { channel_id },
+			)]);
 		}
 
 		Ok(())
@@ -1201,6 +1207,7 @@ where
 	pub async fn handle_event(&self, event: &BumpTransactionEvent) {
 		match event {
 			BumpTransactionEvent::ChannelClose {
+				channel_id,
 				claim_id,
 				package_target_feerate_sat_per_1000_weight,
 				commitment_tx,
@@ -1215,6 +1222,7 @@ where
 					commitment_tx.compute_txid()
 				);
 				self.handle_channel_close(
+					*channel_id,
 					*claim_id,
 					*package_target_feerate_sat_per_1000_weight,
 					commitment_tx,
@@ -1231,6 +1239,7 @@ where
 				});
 			},
 			BumpTransactionEvent::HTLCResolution {
+				channel_id,
 				claim_id,
 				target_feerate_sat_per_1000_weight,
 				htlc_descriptors,
@@ -1244,6 +1253,7 @@ where
 					log_iter!(htlc_descriptors.iter().map(|d| d.outpoint()))
 				);
 				self.handle_htlc_resolution(
+					*channel_id,
 					*claim_id,
 					*target_feerate_sat_per_1000_weight,
 					htlc_descriptors,