feat: lints and formatting

Author: greged93

bin/bridge/src/import.rs

@@ -100,12 +100,12 @@ impl RethBlockImport<reth_scroll_primitives::ScrollBlock> for BridgeBlockImport
                 Ok(BlockValidation::ValidBlock { ref block }) |
                 Ok(BlockValidation::ValidHeader { ref block }) => {
                     self.bridge_new_block_to_scroll_wire(outcome.peer, block.block.clone());
-                    return Poll::Ready(outcome)
+                    Poll::Ready(outcome)
                 }
                 Err(_) => Poll::Ready(outcome),
             }
         } else {
-            return Poll::Pending;
+            Poll::Pending
         }
     }
 }

bin/bridge/src/network.rs

@@ -59,7 +59,7 @@ where
             network_mode: NetworkMode::Work,
             block_import: Box::new(super::BridgeBlockImport::new(
                 new_block_tx,
-                self.block_import.unwrap_or_else(|| config.block_import),
+                self.block_import.unwrap_or(config.block_import),
             )),
             ..config
         };

bin/bridge/src/test.rs

@@ -1,4 +1,3 @@
-
 use alloy_primitives::B256;
 use reth_e2e_test_utils::{node::NodeTestContext, NodeHelperType};
 use reth_network::{NetworkConfigBuilder, PeersInfo};

crates/engine/Cargo.toml

@@ -17,11 +17,11 @@ alloy-rpc-types-engine.workspace = true
 
 # reth
 reth-engine-primitives = { git = "https://github.com/scroll-tech/reth.git", default-features = false, features = ["scroll"] }
-reth-primitives = { workspace = true }
+reth-primitives.workspace = true
 reth-rpc-api = { git = "https://github.com/scroll-tech/reth.git", default-features = false, features = ["client"] }
 
 # reth-scroll
-reth-scroll-primitives = { workspace = true, features = ["serde"] }
+reth-scroll-primitives = { workspace = true, features = ["serde", "scroll", "reth-codec"] }
 
 # misc
 eyre.workspace = true
@@ -38,10 +38,10 @@ reth-testing-utils = { git = "https://github.com/scroll-tech/reth.git" }
 
 [features]
 arbitrary = [
-	"alloy-primitives/arbitrary",
-	"reth-primitives/arbitrary",
-	"alloy-eips/arbitrary",
-	"reth-scroll-primitives/arbitrary"
+    "alloy-primitives/arbitrary",
+    "reth-primitives/arbitrary",
+    "alloy-eips/arbitrary",
+    "reth-scroll-primitives/arbitrary"
 ]
 test_utils = [
     "arbitrary",

crates/network/Cargo.toml

@@ -13,25 +13,20 @@ alloy-primitives = { workspace = true, features = [
 ] }
 
 # reth
-reth-discv5 = { git = "https://github.com/scroll-tech/reth.git" }
-reth-eth-wire-types.workspace = true
 reth-network.workspace = true
 reth-network-api.workspace = true
-reth-network-types = { git = "https://github.com/scroll-tech/reth.git" }
 reth-network-peers.workspace = true
 reth-primitives.workspace = true
 reth-storage-api = { git = "https://github.com/scroll-tech/reth.git" }
-reth-tasks.workspace = true
 
 # scroll
 reth-scroll-chainspec.workspace = true
-reth-scroll-node = { workspace = true, features = ["skip-state-root-validation"] }
+reth-scroll-node = { workspace = true, features = ["skip-state-root-validation", "scroll"] }
 reth-scroll-primitives.workspace = true
 scroll-wire.workspace = true
 
 # misc
 futures.workspace = true
-parking_lot = "0.12"
 secp256k1 = { workspace = true, features = ["global-context", "rand-std", "recovery"] }
 tokio = { workspace = true, features = ["full"] }
 tokio-stream.workspace = true

crates/network/src/handle.rs

@@ -6,7 +6,7 @@ use secp256k1::{ecdsa::Signature, SecretKey};
 use std::sync::Arc;
 use tokio::sync::{mpsc::UnboundedSender, oneshot};
 
-/// A handle used to communicate with the [`NetworkManager`].
+/// A handle used to communicate with the [`super::NetworkManager`].
 #[derive(Debug, Clone)]
 pub struct NetworkHandle {
     /// A reference to the inner network handle.
@@ -28,7 +28,7 @@ impl NetworkHandle {
 /// The inner state of the [`NetworkHandle`].
 #[derive(Debug)]
 pub struct NetworkInner {
-    /// The sender half of the channel set up between this type and the [`NetworkManager`].
+    /// The sender half of the channel set up between this type and the [`super::NetworkManager`].
     pub(crate) to_manager_tx: UnboundedSender<NetworkHandleMessage>,
     /// Inner network handle which is used to communicate with the inner network.
     pub inner_network_handle: RethNetworkHandle<ScrollNetworkPrimitives>,

crates/network/src/lib.rs

@@ -2,7 +2,7 @@ mod import;
 pub use import::{BlockImport, BlockImportOutcome, BlockValidation, NoopBlockImport};
 
 mod handle;
-use handle::{NetworkHandle, NetworkHandleMessage};
+pub use handle::{NetworkHandle, NetworkHandleMessage};
 
 mod manager;
 pub use manager::NetworkManager;

crates/scroll-wire/Cargo.toml

@@ -20,15 +20,11 @@ alloy-rlp = { version = "0.3.10", default-features = false }
 reth-eth-wire = { git = "https://github.com/scroll-tech/reth.git" }
 reth-network.workspace = true
 reth-network-api.workspace = true
-reth-primitives.workspace = true
-reth-provider = { workspace = true, features = ["test-utils"] }
 
 # scroll
-reth-scroll-chainspec.workspace = true
-reth-scroll-primitives.workspace = true
+reth-scroll-primitives = { workspace = true, features = ["serde"] }
 
 # misc
-eyre.workspace = true
 futures.workspace = true
 secp256k1 = { workspace = true, features = [
     "global-context",

crates/scroll-wire/src/protocol/handler.rs

@@ -4,10 +4,10 @@ use reth_network::protocol::ProtocolHandler as ProtocolHandlerTrait;
 use reth_network_api::PeerId;
 use tokio::sync::mpsc;
 
-/// A Receiver for `ScrollWireEvents`.
+/// A Receiver for [`Event`].
 pub(super) type ScrollWireEventReceiver = mpsc::UnboundedReceiver<Event>;
 
-/// A Sender for `ScrollWireEvents`.
+/// A Sender for [`Event`].
 pub(super) type ScrollWireEventSender = mpsc::UnboundedSender<Event>;
 
 /// The state of the protocol.
@@ -20,15 +20,15 @@ pub struct ProtocolState {
 }
 
 impl ProtocolState {
-    /// Returns a reference to the sender for emitting [`ScrollWireEvent`]s.
+    /// Returns a reference to the sender for emitting [`Event`]s.
     pub const fn event_sender(&self) -> &ScrollWireEventSender {
         &self.event_sender
     }
 }
 
 /// A handler for the `ScrollWire` protocol.
 ///
-/// This handler contains the state of the protocol ([`ProtocolState`]) and protocol configuration.
+/// This handler contains the state of the protocol and protocol configuration.
 /// This type is responsible for handling incoming and outgoing connections. It would typically be
 /// used for protocol negotiation, but currently we do not have any.
 #[derive(Debug)]
@@ -38,8 +38,8 @@ pub struct ProtocolHandler {
 }
 
 impl ProtocolHandler {
-    /// Creates a tuple of ([`ProtocolHandler`], [`ScrollWireEventReceiver`]) from the provided
-    /// configuration.
+    /// Creates a tuple of ([`ProtocolHandler`], [`mpsc::UnboundedReceiver<Event>`]) from the
+    /// provided configuration.
     pub fn new(config: ScrollWireConfig) -> (Self, ScrollWireEventReceiver) {
         let (events_tx, events_rx) = mpsc::unbounded_channel();
         let state = ProtocolState { event_sender: events_tx };