fix(l1): only rebuild payload when mempool receives new transactions

crates/blockchain/mempool.rs

@@ -1,6 +1,9 @@
 use std::{
     collections::{BTreeMap, HashMap, VecDeque},
-    sync::RwLock,
+    sync::{
+        RwLock,
+        atomic::{AtomicU64, Ordering},
+    },
 };
 
 use crate::{
@@ -78,15 +81,26 @@ impl MempoolInner {
 #[derive(Debug, Default)]
 pub struct Mempool {
     inner: RwLock<MempoolInner>,
+    /// Monotonically increasing counter, bumped on every transaction insertion.
+    /// The payload builder polls this to skip rebuilds when the mempool is unchanged.
+    generation: AtomicU64,
 }
 
 impl Mempool {
     pub fn new(max_mempool_size: usize) -> Self {
         Mempool {
             inner: RwLock::new(MempoolInner::new(max_mempool_size)),
+            generation: AtomicU64::new(0),
         }
     }
 
+    /// Returns a monotonically increasing counter that increments on every
+    /// transaction insertion. Useful for detecting mempool changes without
+    /// holding any lock.
+    pub fn generation(&self) -> u64 {
+        self.generation.load(Ordering::Relaxed)
+    }
+
     fn write(&self) -> Result<std::sync::RwLockWriteGuard<'_, MempoolInner>, StoreError> {
         self.inner
             .write()
@@ -123,6 +137,7 @@ impl Mempool {
             .insert((sender, transaction.nonce()), hash);
         inner.transaction_pool.insert(hash, transaction);
         inner.broadcast_pool.insert(hash);
+        self.generation.fetch_add(1, Ordering::Relaxed);
 
         Ok(())
     }

crates/blockchain/payload.rs

@@ -389,7 +389,15 @@ impl Blockchain {
         // Attempt to rebuild the payload as many times within the given timeframe to maximize fee revenue
         // TODO(#4997): start with an empty block
         let mut res = self.build_payload(payload.clone())?;
+        let mut last_mempool_gen = self.mempool.generation().wrapping_sub(1);
         while start.elapsed() < SECONDS_PER_SLOT && !cancel_token.is_cancelled() {
+            // Only rebuild when the mempool has received new transactions
+            let current_gen = self.mempool.generation();
+            if current_gen == last_mempool_gen {
+                tokio::time::sleep(Duration::from_millis(100)).await;
+                continue;
+            }
+            last_mempool_gen = current_gen;
             let payload = payload.clone();
             let self_clone = self.clone();
             let building_task =