cleanup

Author: dylanlott

src/tasks/block/sim.rs

@@ -9,7 +9,7 @@ use init4_bin_base::{
 };
 use signet_sim::{BlockBuild, BuiltBlock, SimCache};
 use signet_types::constants::SignetSystemConstants;
-use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
+use std::time::{Duration, Instant};
 use tokio::{
     sync::{
         mpsc::{self},
@@ -94,7 +94,7 @@ impl Simulator {
     ) -> eyre::Result<BuiltBlock> {
         debug!(
             block_number = block_env.number,
-            deadline = ?self.instant_to_timestamp(finish_by),
+            ?finish_by,
             tx_count= sim_items.len(),
             "starting block build",
         );
@@ -208,14 +208,11 @@ impl Simulator {
         // We add a 1500 ms buffer to account for sequencer stopping signing.
         let deadline =
             Instant::now() + Duration::from_secs(remaining) - Duration::from_millis(1500);
-        trace!(deadline = ?self.instant_to_timestamp(deadline), "calculated deadline for block simulation");
+        trace!(?deadline, "calculated deadline for block simulation");
 
         let buffered_deadline = deadline.max(Instant::now());
         trace!(?buffered_deadline, "final deadline for block simulation");
 
-        let timestamp = self.instant_to_timestamp(buffered_deadline);
-        trace!(?timestamp, "deadline converted to timestamp");
-
         buffered_deadline
     }
 
@@ -245,23 +242,4 @@ impl Simulator {
         let wrapped_db: AlloyDatabaseProvider = WrapDatabaseAsync::new(alloy_db).unwrap();
         Some(wrapped_db)
     }
-
-    /// Converts an `Instant` to a UNIX timestamp in seconds and milliseconds.
-    pub fn instant_to_timestamp(&self, instant: Instant) -> (u64, u128) {
-        let now_instant = Instant::now();
-        let now_system = SystemTime::now();
-
-        let duration_from_now = now_instant.duration_since(instant);
-
-        // Subtract that duration from the system time
-        let target_system_time = now_system - duration_from_now;
-
-        let duration_since_epoch =
-            target_system_time.duration_since(UNIX_EPOCH).expect("Time went backwards");
-
-        let seconds = duration_since_epoch.as_secs();
-        let milliseconds = duration_since_epoch.as_millis();
-
-        (seconds, milliseconds)
-    }
 }

src/tasks/submit.rs

@@ -509,9 +509,6 @@ impl SubmitTask {
     /// NB: This task assumes that the simulator will only send it blocks for
     /// slots that it's assigned.
     async fn task_future(self, mut inbound: mpsc::UnboundedReceiver<SimResult>) {
-        // Holds a reference to the last block we attempted to submit
-        let mut last_block_attempted: u64 = 0;
-
         loop {
             // Wait to receive a new block
             let Some(result) = inbound.recv().await else {
@@ -520,23 +517,10 @@ impl SubmitTask {
             };
             debug!(block_number = result.block.block_number(), "submit channel received block");
 
-            // Only attempt each block number once
-            if result.block.block_number() == last_block_attempted {
-                debug!(
-                    block_number = result.block.block_number(),
-                    "block number is unchanged from last attempt - skipping"
-                );
-                continue;
+            if let Err(e) = self.retrying_handle_inbound(&result.block, &result.env, 3).await {
+                error!(error = %e, "error handling inbound block");
+                continue;   
             }
-
-            // This means we have encountered a new block, so reset the last block attempted
-            last_block_attempted = result.block.block_number();
-            debug!(last_block_attempted, "resetting last block attempted");
-
-            if self.retrying_handle_inbound(&result.block, &result.env, 3).await.is_err() {
-                debug!("error handling inbound block");
-                continue;
-            };
         }
     }