f - Avoid an extra Vec allocation when forwarding broadcasts

Classifying a package no longer collects the transactions into a fresh
Vec; the originally-queued package is returned and the chain-source
broadcast loop iterates it directly.

No behavior change.

Generated with assistance from Claude Code.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jkczyz

src/chain/bitcoind.rs

@@ -568,16 +568,18 @@ impl BitcoindChainSource {
 		Ok(())
 	}
 
-	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
+	pub(crate) async fn process_broadcast_package(
+		&self, txs: impl IntoIterator<Item = Transaction>,
+	) {
 		// While it's a bit unclear when we'd be able to lean on Bitcoin Core >v28
 		// features, we should eventually switch to use `submitpackage` via the
 		// `rust-bitcoind-json-rpc` crate rather than just broadcasting individual
 		// transactions.
-		for tx in &package {
+		for tx in txs {
 			let txid = tx.compute_txid();
 			let timeout_fut = tokio::time::timeout(
 				Duration::from_secs(DEFAULT_TX_BROADCAST_TIMEOUT_SECS),
-				self.api_client.broadcast_transaction(tx),
+				self.api_client.broadcast_transaction(&tx),
 			);
 			match timeout_fut.await {
 				Ok(res) => match res {

src/chain/electrum.rs

@@ -275,7 +275,9 @@ impl ElectrumChainSource {
 		Ok(())
 	}
 
-	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
+	pub(crate) async fn process_broadcast_package(
+		&self, txs: impl IntoIterator<Item = Transaction>,
+	) {
 		let electrum_client: Arc<ElectrumRuntimeClient> = if let Some(client) =
 			self.electrum_runtime_status.read().expect("lock").client().as_ref()
 		{
@@ -285,7 +287,7 @@ impl ElectrumChainSource {
 			return;
 		};
 
-		for tx in package {
+		for tx in txs {
 			electrum_client.broadcast(tx).await;
 		}
 	}

src/chain/esplora.rs

@@ -352,12 +352,14 @@ impl EsploraChainSource {
 		Ok(())
 	}
 
-	pub(crate) async fn process_broadcast_package(&self, package: Vec<Transaction>) {
-		for tx in &package {
+	pub(crate) async fn process_broadcast_package(
+		&self, txs: impl IntoIterator<Item = Transaction>,
+	) {
+		for tx in txs {
 			let txid = tx.compute_txid();
 			let timeout_fut = tokio::time::timeout(
 				Duration::from_secs(self.sync_config.timeouts_config.tx_broadcast_timeout_secs),
-				self.esplora_client.broadcast(tx),
+				self.esplora_client.broadcast(&tx),
 			);
 			match timeout_fut.await {
 				Ok(res) => match res {

src/chain/mod.rs

@@ -453,8 +453,8 @@ impl ChainSource {
 					return;
 				}
 				Some(next_package) = receiver.recv() => {
-					let txs = match self.tx_broadcaster.classify_package(next_package).await {
-						Ok(txs) => txs,
+					let package = match self.tx_broadcaster.classify_package(next_package).await {
+						Ok(p) => p,
 						Err(e) => {
 							log_error!(
 								tx_bcast_logger,
@@ -464,6 +464,7 @@ impl ChainSource {
 							continue;
 						},
 					};
+					let txs = package.into_iter().map(|(tx, _)| tx);
 					match &self.kind {
 						ChainSourceKind::Esplora(esplora_chain_source) => {
 							esplora_chain_source.process_broadcast_package(txs).await

src/tx_broadcaster.rs

@@ -65,26 +65,25 @@ where
 		self.queue_receiver.lock().await
 	}
 
-	/// Classifies a queued package into payment records and returns the raw
-	/// transactions ready for the chain client. Returns `Err` if any classification
-	/// fails; callers must not broadcast the package in that case, since a crash would
-	/// leave the tx on-chain without a record.
+	/// Classifies a queued package into payment records and returns the package ready
+	/// for the chain client. Returns `Err` if any classification fails; callers must
+	/// not broadcast the package in that case, since a crash would leave the tx
+	/// on-chain without a record.
 	pub(crate) async fn classify_package(
 		&self, package: BroadcastPackage,
-	) -> Result<Vec<Transaction>, Error> {
+	) -> Result<BroadcastPackage, Error> {
 		let wallet_opt = self.wallet.lock().expect("lock").as_ref().and_then(Weak::upgrade);
 		if let Some(wallet) = wallet_opt {
-			let package = tokio::task::spawn_blocking(move || {
+			tokio::task::spawn_blocking(move || {
 				for (tx, tx_type) in &package {
 					wallet.classify_broadcast(tx, tx_type)?;
 				}
 				Ok::<_, Error>(package)
 			})
 			.await
-			.map_err(|_| Error::PersistenceFailed)??;
-			Ok(package.into_iter().map(|(tx, _)| tx).collect())
+			.map_err(|_| Error::PersistenceFailed)?
 		} else {
-			Ok(package.into_iter().map(|(tx, _)| tx).collect())
+			Ok(package)
 		}
 	}
 }