fixup clippy and fmt

Author: dylanlott

bin/builder.rs

@@ -52,8 +52,7 @@ async fn main() -> eyre::Result<()> {
     let (submit_channel, submit_jh) = submit.spawn();
 
     let sim_items = SimCache::new();
-
-    let slot_calculator = SlotCalculator::pecorino();
+    let slot_calculator = SlotCalculator::new(config.start_timestamp, config.chain_offset, config.target_slot_time);
     let builder = Arc::new(BlockBuilder::new(&config, ru_provider.clone(), slot_calculator));
 
     let sim_cache_jh =

src/config.rs

@@ -259,7 +259,7 @@ impl BuilderConfig {
     }
 
     /// Loads the Signet system constants for Pecorino.
-    pub fn load_pecorino_constants(&self) -> SignetSystemConstants {
+    pub const fn load_pecorino_constants(&self) -> SignetSystemConstants {
         let host = HostConfig::new(
             self.host_chain_id,
             149984,

src/tasks/block.rs

@@ -24,23 +24,30 @@ use trevm::{
     },
 };
 
-/// Pecorino Chain ID
+/// Pecorino Chain ID used for the Pecorino network.
 pub const PECORINO_CHAIN_ID: u64 = 14174;
 
-/// BlockBuilder is a task that periodically builds a block then sends it for
-/// signing and submission.
+/// `BlockBuilder` is responsible for periodically building blocks and submitting them for signing and inclusion in the blockchain.
 #[derive(Debug)]
 pub struct BlockBuilder {
-    /// Configuration.
+    /// Configuration for the builder.
     pub config: BuilderConfig,
-    /// A provider that cannot sign transactions.
+    /// A provider that cannot sign transactions, used for interacting with the rollup.
     pub ru_provider: WalletlessProvider,
-    /// The slot calculator for waking up and sleeping the builder correctly
+    /// The slot calculator for determining when to wake up and build blocks.
     pub slot_calculator: SlotCalculator,
 }
 
 impl BlockBuilder {
-    /// Creates a new block builder that builds blocks based on the given provider.
+    /// Creates a new `BlockBuilder` instance.
+    ///
+    /// # Arguments
+    /// - `config`: The configuration for the builder.
+    /// - `ru_provider`: A provider for interacting with the rollup.
+    /// - `slot_calculator`: A slot calculator for managing block timing.
+    ///
+    /// # Returns
+    /// A new `BlockBuilder` instance.
     pub fn new(
         config: &BuilderConfig,
         ru_provider: WalletlessProvider,
@@ -50,6 +57,14 @@ impl BlockBuilder {
     }
 
     /// Handles building a single block.
+    ///
+    /// # Arguments
+    /// - `constants`: The system constants for the rollup.
+    /// - `sim_items`: The simulation cache containing transactions and bundles.
+    /// - `finish_by`: The deadline by which the block must be built.
+    ///
+    /// # Returns
+    /// A `Result` containing the built block or an error.
     pub async fn handle_build(
         &self,
         constants: SignetSystemConstants,
@@ -74,14 +89,22 @@ impl BlockBuilder {
         Ok(block)
     }
 
-    /// Scans the tx and bundle receivers for new items and adds them to the cache.
+    /// Spawns a task to handle incoming transactions and bundles, adding them to the simulation cache.
+    ///
+    /// # Arguments
+    /// - `tx_receiver`: A channel receiver for incoming transactions.
+    /// - `bundle_receiver`: A channel receiver for incoming bundles.
+    /// - `cache`: The simulation cache to store the received items.
+    ///
+    /// # Returns
+    /// A `JoinHandle` for the spawned task.
     pub fn spawn_cache_handler(
         self: Arc<Self>,
         mut tx_receiver: mpsc::UnboundedReceiver<TxEnvelope>,
         mut bundle_receiver: mpsc::UnboundedReceiver<Bundle>,
         cache: SimCache,
     ) -> JoinHandle<()> {
-        let jh = tokio::spawn(async move {
+        tokio::spawn(async move {
             loop {
                 select! {
                     maybe_tx = tx_receiver.recv() => {
@@ -96,18 +119,25 @@ impl BlockBuilder {
                     }
                 }
             }
-        });
-        jh
+        })
     }
 
     /// Spawns the block building task.
+    ///
+    /// # Arguments
+    /// - `constants`: The system constants for the rollup.
+    /// - `cache`: The simulation cache containing transactions and bundles.
+    /// - `submit_sender`: A channel sender for submitting built blocks.
+    ///
+    /// # Returns
+    /// A `JoinHandle` for the spawned task.
     pub fn spawn_builder_task(
         self: Arc<Self>,
         constants: SignetSystemConstants,
         cache: SimCache,
         submit_sender: mpsc::UnboundedSender<BuiltBlock>,
     ) -> JoinHandle<()> {
-        let jh = tokio::spawn(async move {
+        tokio::spawn(async move {
             loop {
                 let sim_cache = cache.clone();
 
@@ -126,19 +156,24 @@ impl BlockBuilder {
                     }
                 }
             }
-        });
-        jh
+        })
     }
 
-    /// Returns the instant at which simulation must stop.
+    /// Calculates the deadline for the current block simulation.
+    ///
+    /// # Returns
+    /// An `Instant` representing the deadline.
     pub fn calculate_deadline(&self) -> Instant {
         let now = SystemTime::now();
         let unix_seconds = now.duration_since(UNIX_EPOCH).expect("Time went backwards").as_secs();
 
         Instant::now().checked_add(Duration::from_secs(unix_seconds)).unwrap()
     }
 
-    /// Creates an AlloyDB from a rollup provider
+    /// Creates an `AlloyDB` instance from the rollup provider.
+    ///
+    /// # Returns
+    /// An `Option` containing the wrapped database or `None` if an error occurs.
     async fn create_db(&self) -> Option<WrapAlloyDatabaseAsync> {
         let latest = match self.ru_provider.get_block_number().await {
             Ok(block_number) => block_number,
@@ -155,7 +190,7 @@ impl BlockBuilder {
     }
 }
 
-/// The wrapped alloy database type that is compatible with Db + DatabaseRef
+/// The wrapped alloy database type that is compatible with `Db` and `DatabaseRef`.
 type WrapAlloyDatabaseAsync = WrapDatabaseAsync<
     AlloyDB<
         alloy::network::Ethereum,
@@ -178,13 +213,17 @@ type WrapAlloyDatabaseAsync = WrapDatabaseAsync<
     >,
 >;
 
-/// Configuration struct for Pecorino network values
+/// Configuration struct for Pecorino network values.
 #[derive(Debug, Clone)]
 pub struct PecorinoCfg {}
 
 impl Copy for PecorinoCfg {}
 
 impl trevm::Cfg for PecorinoCfg {
+    /// Fills the configuration environment with Pecorino-specific values.
+    ///
+    /// # Arguments
+    /// - `cfg_env`: The configuration environment to be filled.
     fn fill_cfg_env(&self, cfg_env: &mut CfgEnv) {
         let CfgEnv { chain_id, spec, .. } = cfg_env;
 

tests/block_builder_test.rs

@@ -1,3 +1,4 @@
+//! Tests for the block building task.
 #[cfg(test)]
 mod tests {
     use alloy::{
@@ -17,6 +18,11 @@ mod tests {
     };
     use tokio::{sync::mpsc::unbounded_channel, time::timeout};
 
+    /// Tests the `handle_build` method of the `BlockBuilder`.
+    ///
+    /// This test sets up a simulated environment using Anvil, creates a block builder,
+    /// and verifies that the block builder can successfully build a block containing
+    /// transactions from multiple senders.
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_handle_build() {
         setup_logging();
@@ -65,7 +71,11 @@ mod tests {
         assert!(got.unwrap().tx_count() == 2);
     }
 
-    /// Tests the full block builder loop
+    /// Tests the full block builder loop, including transaction ingestion and block simulation.
+    ///
+    /// This test sets up a simulated environment using Anvil, creates a block builder,
+    /// and verifies that the builder can process incoming transactions and produce a block
+    /// within a specified timeout.
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_spawn() {
         setup_logging();
@@ -96,16 +106,18 @@ mod tests {
             config.chain_offset,
             config.target_slot_time,
         );
-        let sim_cache = SimCache::new();
         let builder = Arc::new(BlockBuilder::new(&config, ru_provider.clone(), slot_calculator));
 
+        // Create a shared sim cache
+        let sim_cache = SimCache::new();
+
         // Create a sim cache and start filling it with items
-        let _ =
-            builder.clone().spawn_cache_handler(tx_receiver, bundle_receiver, sim_cache.clone());
+        builder.clone().spawn_cache_handler(tx_receiver, bundle_receiver, sim_cache.clone());
 
         // Finally, Kick off the block builder task.
-        let _ = builder.clone().spawn_builder_task(constants, sim_cache.clone(), block_sender);
+        builder.clone().spawn_builder_task(constants, sim_cache.clone(), block_sender);
 
+        // Feed in transactions to the tx_sender and wait for the block to be simulated
         let tx_1 = new_signed_tx(&test_key_0, 0, U256::from(1_f64), 11_000).unwrap();
         let tx_2 = new_signed_tx(&test_key_1, 0, U256::from(2_f64), 10_000).unwrap();
         tx_sender.send(tx_1).unwrap();
@@ -114,8 +126,9 @@ mod tests {
         // Wait for a block with timeout
         let result = timeout(Duration::from_secs(5), block_receiver.recv()).await;
         assert!(result.is_ok(), "Did not receive block within 5 seconds");
+
+        // Assert on the block
         let block = result.unwrap();
-        dbg!(&block);
         assert!(block.is_some(), "Block channel closed without receiving a block");
         assert!(block.unwrap().tx_count() == 2); // TODO: Why is this failing? I'm seeing EVM errors but haven't tracked them down yet. 
     }