feat: improve naming

Author: yiweichi

crates/network/src/manager.rs

@@ -20,7 +20,7 @@ use reth_tokio_util::{EventSender, EventStream};
 use rollup_node_primitives::{sig_encode_hash, BlockInfo};
 use scroll_alloy_hardforks::ScrollHardforks;
 use scroll_wire::{
-    NewBlock, PeerState, ScrollMessage, ScrollWireConfig, ScrollWireEvent, ScrollWireManager,
+    NewBlock, ScrollMessage, ScrollWireConfig, ScrollWireEvent, ScrollWireManager,
     ScrollWireProtocolHandler, LRU_CACHE_SIZE,
 };
 use std::sync::Arc;
@@ -262,7 +262,7 @@ impl<
                 .scroll_wire
                 .peer_state()
                 .get(&peer.remote_id)
-                .is_some_and(|state| state.has_seen(&hash))
+                .is_some_and(|state| state.contains(&hash))
             {
                 continue;
             }
@@ -274,7 +274,7 @@ impl<
                 .any(|cap| cap == &ScrollMessage::capability())
             {
                 trace!(target: "scroll::network::manager", peer_id = %peer.remote_id, block_number = %block.block.header.number, block_hash = %hash, "Announcing new block to peer via scroll-wire");
-                self.scroll_wire.announce_block(peer.remote_id, &block, hash);
+                self.scroll_wire.announce_block(peer.remote_id, &block);
             } else {
                 if should_announce_eth_wire {
                     trace!(target: "scroll::network::manager", peer_id = %peer.remote_id, block_number = %block.block.header.number, block_hash = %hash, "Announcing new block to peer via eth-wire");
@@ -304,9 +304,9 @@ impl<
                     .scroll_wire
                     .peer_state_mut()
                     .entry(peer_id)
-                    .or_insert_with(|| PeerState::new(LRU_CACHE_SIZE));
+                    .or_insert_with(|| LruCache::new(LRU_CACHE_SIZE));
 
-                if state.has_received(&block_hash) {
+                if state.contains(&block_hash) {
                     tracing::warn!(target: "scroll::network::manager", peer_id = ?peer_id, block = ?block_hash, "Peer sent duplicate block via scroll-wire, penalizing");
                     self.inner_network_handle.reputation_change(
                         peer_id,
@@ -315,7 +315,7 @@ impl<
                     return None;
                 }
                 // Update the state that the peer has received this block
-                state.insert_received(block_hash);
+                state.insert(block_hash);
 
                 if self.blocks_seen.contains(&(block_hash, signature)) {
                     None
@@ -422,16 +422,16 @@ impl<
                 .scroll_wire
                 .peer_state_mut()
                 .entry(peer_id)
-                .or_insert_with(|| PeerState::new(LRU_CACHE_SIZE));
+                .or_insert_with(|| LruCache::new(LRU_CACHE_SIZE));
 
-            if state.has_received(&block_hash) {
+            if state.contains(&block_hash) {
                 tracing::warn!(target: "scroll::bridge::import", peer_id = ?peer_id, block = ?block_hash, "Peer sent duplicate block via eth-wire, penalizing");
                 self.inner_network_handle
                     .reputation_change(peer_id, reth_network_api::ReputationChangeKind::BadBlock);
                 return None;
             }
             // Update the state that the peer has received this block
-            state.insert_received(block_hash);
+            state.insert(block_hash);
 
             if self.blocks_seen.contains(&(block_hash, signature)) {
                 None

crates/node/tests/e2e.rs

@@ -2217,59 +2217,57 @@ where
 //     Ok(())
 // }
 
-// /// Tests that peers are penalized for sending duplicate blocks via the same protocol
-// /// (eth-wire).
-// ///
-// /// This test verifies the DoS protection mechanism that detects when a peer sends
-// /// the same block multiple times through the eth-wire protocol.
-// ///
-// /// Test flow:
-// /// 1. Node0 sends a block to node1 via eth-wire
-// /// 2. Node0 sends the SAME block again via eth-wire
-// /// 3. Verify that node0's reputation decreases (duplicate detected)
-// #[tokio::test]
-// async fn can_penalize_peer_for_duplicate_block_via_eth_wire() -> eyre::Result<()> {
-//     reth_tracing::init_test_tracing();
+/// Tests that peers are penalized for sending duplicate blocks
+///
+/// This test verifies the DoS protection mechanism that detects when a peer sends
+/// the same block multiple times through the eth-wire protocol.
+///
+/// Test flow:
+/// 1. Node0 sends a block to node1 via eth-wire
+/// 2. Node0 sends the SAME block again via eth-wire
+/// 3. Verify that node0's reputation decreases (duplicate detected)
+#[tokio::test]
+async fn can_penalize_peer_for_duplicate_block_via_eth_wire() -> eyre::Result<()> {
+    reth_tracing::init_test_tracing();
 
-//     // Create 2 nodes with eth-scroll bridge enabled (for eth-wire)
-//     let mut fixture = TestFixture::builder()
-//         .sequencer()
-//         .followers(1)
-//         .block_time(0)
-//         .allow_empty_blocks(true)
-//         .with_eth_scroll_bridge(true)
-//         .payload_building_duration(1000)
-//         .build()
-//         .await?;
+    // Create 2 nodes with eth-scroll bridge enabled (for eth-wire)
+    let mut fixture = TestFixture::builder()
+        .sequencer()
+        .followers(1)
+        .block_time(0)
+        .allow_empty_blocks(true)
+        .payload_building_duration(1000)
+        .build()
+        .await?;
 
-//     // Set the L1 to synced on the sequencer node
-//     fixture.l1().for_node(0).sync().await?;
-//     fixture.expect_event_on(0).l1_synced().await?;
+    // Set the L1 to synced on the sequencer node
+    fixture.l1().for_node(0).sync().await?;
+    fixture.expect_event_on(0).l1_synced().await?;
 
-//     // Build a block
-//     let block = fixture.build_block().expect_tx_count(0).build_and_await_block().await?;
+    // Build a block
+    let block = fixture.build_block().expect_tx_count(0).build_and_await_block().await?;
 
-//     // Wait for node1 to receive the block via eth-wire
-//     fixture.expect_event_on(1).new_block_received().await?;
+    // Wait for node1 to receive the block
+    fixture.expect_event_on(1).new_block_received().await?;
 
-//     // Check initial reputation of node 0 from node 1's perspective
-//     fixture.check_reputation_on(1).of_node(0).await?.equals(0).await?;
+    // Check initial reputation of node 0 from node 1's perspective
+    fixture.check_reputation_on(1).of_node(0).await?.equals(0).await?;
 
-//     // Send the same block again via eth-wire (duplicate)
-//     fixture
-//         .network_on(0)
-//         .announce_block(block.clone(), Signature::new(U256::from(1), U256::from(1), false))
-//         .await?;
+    // Send the same block again (duplicate)
+    fixture
+        .network_on(0)
+        .announce_block(block.clone(), Signature::new(U256::from(1), U256::from(1), false))
+        .await?;
 
-//     // Wait for reputation to decrease due to duplicate block detection
-//     fixture
-//         .check_reputation_on(1)
-//         .of_node(0)
-//         .await?
-//         .with_timeout(Duration::from_secs(5))
-//         .with_poll_interval(Duration::from_millis(10))
-//         .eventually_less_than(0)
-//         .await?;
+    // Wait for reputation to decrease due to duplicate block detection
+    fixture
+        .check_reputation_on(1)
+        .of_node(0)
+        .await?
+        .with_timeout(Duration::from_secs(5))
+        .with_poll_interval(Duration::from_millis(10))
+        .eventually_less_than(0)
+        .await?;
 
-//     Ok(())
-// }
+    Ok(())
+}

crates/scroll-wire/src/lib.rs

@@ -5,7 +5,7 @@ pub use config::ScrollWireConfig;
 
 mod connection;
 mod manager;
-pub use manager::{PeerState, ScrollWireManager, LRU_CACHE_SIZE};
+pub use manager::{ScrollWireManager, LRU_CACHE_SIZE};
 
 mod protocol;
 pub use protocol::{NewBlock, ScrollMessage, ScrollWireEvent, ScrollWireProtocolHandler};

crates/scroll-wire/src/manager.rs

@@ -16,51 +16,15 @@ use tracing::trace;
 /// The size of the LRU cache used to track blocks that have been seen by peers.
 pub const LRU_CACHE_SIZE: u32 = 100;
 
-/// Tracks block announced and received state for a peer.
-#[derive(Debug)]
-pub struct PeerState {
-    /// blocks announced to the peer
-    announced: LruCache<B256>,
-    /// blocks received, this is used to penalize peers that send duplicate blocks.
-    received: LruCache<B256>,
-}
-
-impl PeerState {
-    /// Creates a new `PeerBlockState` with the specified LRU cache capacity.
-    pub fn new(capacity: u32) -> Self {
-        Self { announced: LruCache::new(capacity), received: LruCache::new(capacity) }
-    }
-
-    /// Check if peer knows about this block (either received or announced).
-    pub fn has_seen(&self, hash: &B256) -> bool {
-        self.announced.contains(hash) || self.received.contains(hash)
-    }
-
-    /// Check if peer has received this block.
-    pub fn has_received(&self, hash: &B256) -> bool {
-        self.received.contains(hash)
-    }
-
-    /// Record that this peer has announced this block.
-    pub fn insert_announced(&mut self, hash: B256) {
-        self.announced.insert(hash);
-    }
-
-    /// Record that this peer has received this block.
-    pub fn insert_received(&mut self, hash: B256) {
-        self.received.insert(hash); // Track for duplicate detection
-    }
-}
-
 /// A manager for the `ScrollWire` protocol.
 #[derive(Debug)]
 pub struct ScrollWireManager {
     /// A stream of [`ScrollWireEvent`]s produced by the scroll wire protocol.
     events: UnboundedReceiverStream<ScrollWireEvent>,
     /// A map of connections to peers.
     connections: HashMap<PeerId, UnboundedSender<ScrollMessage>>,
-    /// Unified state tracking block state and blocks received from each peer via both protocols.
-    peer_state: HashMap<PeerId, PeerState>,
+    /// Tracks block hashes received from each peer for duplicate detection.
+    peer_state: HashMap<PeerId, LruCache<B256>>,
 }
 
 impl ScrollWireManager {
@@ -71,7 +35,7 @@ impl ScrollWireManager {
     }
 
     /// Announces a new block to the specified peer.
-    pub fn announce_block(&mut self, peer_id: PeerId, block: &NewBlock, hash: B256) {
+    pub fn announce_block(&mut self, peer_id: PeerId, block: &NewBlock) {
         if let Entry::Occupied(to_connection) = self.connections.entry(peer_id) {
             // We send the block to the peer. If we receive an error we remove the peer from the
             // connections map and peer_block_state as the connection is no longer valid.
@@ -81,11 +45,6 @@ impl ScrollWireManager {
                 to_connection.remove();
             } else {
                 trace!(target: "scroll::wire::manager", peer_id = %peer_id, "Announced block to peer");
-                // Record that we announced this block to the peer
-                self.peer_state
-                    .entry(peer_id)
-                    .or_insert_with(|| PeerState::new(LRU_CACHE_SIZE))
-                    .insert_announced(hash);
             }
         }
     }
@@ -96,12 +55,12 @@ impl ScrollWireManager {
     }
 
     /// Returns a reference to the peer state map.
-    pub const fn peer_state(&self) -> &HashMap<PeerId, PeerState> {
+    pub const fn peer_state(&self) -> &HashMap<PeerId, LruCache<B256>> {
         &self.peer_state
     }
 
     /// Returns a mutable reference to the peer state map.
-    pub const fn peer_state_mut(&mut self) -> &mut HashMap<PeerId, PeerState> {
+    pub const fn peer_state_mut(&mut self) -> &mut HashMap<PeerId, LruCache<B256>> {
         &mut self.peer_state
     }
 }