fix(engine): Eliminates spurious warning logs in prewarm task (#19133)

Co-authored-by: Matthias Seitz <[email protected]>

Author: 0x00101010

crates/engine/tree/src/tree/payload_processor/prewarm.rs

@@ -146,7 +146,6 @@ where
             let _enter = debug_span!(target: "engine::tree::payload_processor::prewarm", parent: span, "spawn_all").entered();
 
             let (done_tx, done_rx) = mpsc::channel();
-            let mut executing = 0usize;
 
             // When transaction_count_hint is 0, it means the count is unknown. In this case, spawn
             // max workers to handle potentially many transactions in parallel rather
@@ -165,62 +164,44 @@ where
                 handles.push(ctx.spawn_worker(i, &executor, actions_tx.clone(), done_tx.clone()));
             }
 
+            // Distribute transactions to workers
             let mut tx_index = 0usize;
+            while let Ok(tx) = pending.recv() {
+                // Stop distributing if termination was requested
+                if ctx.terminate_execution.load(Ordering::Relaxed) {
+                    trace!(
+                        target: "engine::tree::payload_processor::prewarm",
+                        "Termination requested, stopping transaction distribution"
+                    );
+                    break;
+                }
+
+                let indexed_tx = IndexedTransaction { index: tx_index, tx };
+                let is_system_tx = indexed_tx.tx.tx().ty() > MAX_STANDARD_TX_TYPE;
 
-            // Handle first transaction - special case for system transactions
-            if let Ok(first_tx) = pending.recv() {
-                // Move the transaction into the indexed wrapper to avoid an extra clone
-                let indexed_tx = IndexedTransaction { index: tx_index, tx: first_tx };
-                // Compute metadata from the moved value
-                let tx_ref = indexed_tx.tx.tx();
-                let is_system_tx = tx_ref.ty() > MAX_STANDARD_TX_TYPE;
-                let first_tx_hash = tx_ref.tx_hash();
-
-                // Check if this is a system transaction (type > 4)
-                // System transactions in the first position typically set critical metadata
-                // that affects all subsequent transactions (e.g., L1 block info, fees on L2s).
-                if is_system_tx {
-                    // Broadcast system transaction to all workers to ensure they have the
-                    // critical state. This is particularly important for L2s like Optimism
-                    // where the first deposit transaction contains essential block metadata.
+                // System transactions (type > 4) in the first position set critical metadata
+                // that affects all subsequent transactions (e.g., L1 block info on L2s).
+                // Broadcast the first system transaction to all workers to ensure they have
+                // the critical state. This is particularly important for L2s like Optimism
+                // where the first deposit transaction (type 126) contains essential block metadata.
+                if tx_index == 0 && is_system_tx {
                     for handle in &handles {
-                        if let Err(err) = handle.send(indexed_tx.clone()) {
-                            warn!(
-                                target: "engine::tree::payload_processor::prewarm",
-                                tx_hash = %first_tx_hash,
-                                error = %err,
-                                "Failed to send deposit transaction to worker"
-                            );
-                        }
+                        // Ignore send errors: workers listen to terminate_execution and may
+                        // exit early when signaled. Sending to a disconnected worker is
+                        // possible and harmless and should happen at most once due to
+                        //  the terminate_execution check above.
+                        let _ = handle.send(indexed_tx.clone());
                     }
                 } else {
-                    // Not a deposit, send to first worker via round-robin
-                    if let Err(err) = handles[0].send(indexed_tx) {
-                        warn!(
-                            target: "engine::tree::payload_processor::prewarm",
-                            task_idx = 0,
-                            error = %err,
-                            "Failed to send transaction to worker"
-                        );
-                    }
+                    // Round-robin distribution for all other transactions
+                    let worker_idx = tx_index % workers_needed;
+                    // Ignore send errors: workers listen to terminate_execution and may
+                    // exit early when signaled. Sending to a disconnected worker is
+                    // possible and harmless and should happen at most once due to
+                    //  the terminate_execution check above.
+                    let _ = handles[worker_idx].send(indexed_tx);
                 }
-                executing += 1;
-                tx_index += 1;
-            }
 
-            // Process remaining transactions with round-robin distribution
-            while let Ok(executable) = pending.recv() {
-                let indexed_tx = IndexedTransaction { index: tx_index, tx: executable };
-                let task_idx = executing % workers_needed;
-                if let Err(err) = handles[task_idx].send(indexed_tx) {
-                    warn!(
-                        target: "engine::tree::payload_processor::prewarm",
-                        task_idx,
-                        error = %err,
-                        "Failed to send transaction to worker"
-                    );
-                }
-                executing += 1;
                 tx_index += 1;
             }
 
@@ -230,7 +211,7 @@ where
             while done_rx.recv().is_ok() {}
 
             let _ = actions_tx
-                .send(PrewarmTaskEvent::FinishedTxExecution { executed_transactions: executing });
+                .send(PrewarmTaskEvent::FinishedTxExecution { executed_transactions: tx_index });
         });
     }