fix: calculate deadline after block env changes

- calculate deadline after block env changes instead of before, so that environments aren't off-by-one
- take reference to the cache after block env changes, not before, so that transactions are as fresh as possible before starting simulation

Author: dylanlott

src/tasks/block/sim.rs

@@ -9,14 +9,15 @@ use init4_bin_base::{
 };
 use signet_sim::{BlockBuild, BuiltBlock, SimCache};
 use signet_types::constants::SignetSystemConstants;
-use std::time::{Duration, Instant};
+use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use tokio::{
     sync::{
         mpsc::{self},
         watch,
     },
     task::JoinHandle,
 };
+use tracing::trace;
 use trevm::revm::{
     context::BlockEnv,
     database::{AlloyDB, WrapDatabaseAsync},
@@ -34,7 +35,6 @@ pub struct Simulator {
     pub config: BuilderConfig,
     /// A provider that cannot sign transactions, used for interacting with the rollup.
     pub ru_provider: RuProvider,
-
     /// The block configuration environment on which to simulate
     pub block_env: watch::Receiver<Option<BlockEnv>>,
 }
@@ -55,6 +55,7 @@ impl Simulator {
     ///
     /// - `config`: The configuration for the builder.
     /// - `ru_provider`: A provider for interacting with the rollup.
+    /// - `block_env`: A receiver for the block environment to simulate against.
     ///
     /// # Returns
     ///
@@ -79,6 +80,7 @@ impl Simulator {
     /// - `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.
+    /// - `block_env`: The block environment to simulate against.
     ///
     /// # Returns
     ///
@@ -88,22 +90,34 @@ impl Simulator {
         constants: SignetSystemConstants,
         sim_items: SimCache,
         finish_by: Instant,
-        block: BlockEnv,
+        block_env: BlockEnv,
     ) -> eyre::Result<BuiltBlock> {
+        debug!(
+            block_number = block_env.number,
+            deadline = ?self.instant_to_timestamp(finish_by),
+            tx_count= sim_items.len(),
+            "starting block build",
+        );
+
         let db = self.create_db().await.unwrap();
+
         let block_build: BlockBuild<_, NoOpInspector> = BlockBuild::new(
             db,
             constants,
             self.config.cfg_env(),
-            block,
+            block_env,
             finish_by,
             self.config.concurrency_limit,
             sim_items,
             self.config.rollup_block_gas_limit,
         );
 
         let built_block = block_build.build().await;
-        debug!(block_number = ?built_block.block_number(), "finished building block");
+        debug!(
+            tx_count = built_block.tx_count(),
+            block_number = ?built_block.block_number(),
+            "block simulation completed",
+        );
 
         Ok(built_block)
     }
@@ -152,19 +166,16 @@ impl Simulator {
         submit_sender: mpsc::UnboundedSender<SimResult>,
     ) {
         loop {
-            let sim_cache = cache.clone();
-            let finish_by = self.calculate_deadline();
-
             // Wait for the block environment to be set
             if self.block_env.changed().await.is_err() {
                 error!("block_env channel closed");
                 return;
             }
 
-            // If no env, skip this run
             let Some(block_env) = self.block_env.borrow_and_update().clone() else { return };
-            debug!(block_env = ?block_env, "building on block env");
 
+            let finish_by = self.calculate_deadline();
+            let sim_cache = cache.clone();
             match self.handle_build(constants, sim_cache, finish_by, block_env.clone()).await {
                 Ok(block) => {
                     debug!(block = ?block.block_number(), tx_count = block.transactions().len(), "built block");
@@ -187,17 +198,25 @@ impl Simulator {
     pub fn calculate_deadline(&self) -> Instant {
         // Get the current timepoint within the slot.
         let timepoint = self.slot_calculator().current_timepoint_within_slot();
+        trace!(timepoint, "current timepoint within slot");
 
         // We have the timepoint in seconds into the slot. To find out what's
         // remaining, we need to subtract it from the slot duration
         let remaining = self.slot_calculator().slot_duration() - timepoint;
+        trace!(remaining, "time remaining in slot");
 
         // We add a 1500 ms buffer to account for sequencer stopping signing.
-
-        let candidate =
+        let deadline =
             Instant::now() + Duration::from_secs(remaining) - Duration::from_millis(1500);
+        trace!(deadline = ?self.instant_to_timestamp(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");
 
-        candidate.max(Instant::now())
+        buffered_deadline
     }
 
     /// Creates an `AlloyDB` instance from the rollup provider.
@@ -226,4 +245,23 @@ 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)
+    }
 }