feat(anvil): support millisecond mining with correct block.timestamp

crates/anvil/core/src/eth/mod.rs

@@ -581,7 +581,7 @@ pub enum EthRequest {
         feature = "serde",
         serde(rename = "anvil_setBlockTimestampInterval", with = "sequence")
     )]
-    EvmSetBlockTimeStampInterval(u64),
+    EvmSetBlockTimeStampInterval(f64),
 
     /// Removes a `anvil_setBlockTimestampInterval` if it exists
     #[cfg_attr(

crates/anvil/src/eth/api.rs

@@ -1845,12 +1845,17 @@ impl EthApi {
         Ok(true)
     }
 
-    /// Sets an interval for the block timestamp
+    /// Sets an interval for the block timestamp in milliseconds
     ///
     /// Handler for RPC call: `anvil_setBlockTimestampInterval`
-    pub fn evm_set_block_timestamp_interval(&self, seconds: u64) -> Result<()> {
+    pub fn evm_set_block_timestamp_interval(&self, seconds: f64) -> Result<()> {
         node_info!("anvil_setBlockTimestampInterval");
-        self.backend.time().set_block_timestamp_interval(seconds);
+        if seconds == 0.0 {
+            return Err(BlockchainError::Message("interval cannot be zero".to_string()));
+        }
+        let dur = Duration::try_from_secs_f64(seconds)
+            .map_err(|_| BlockchainError::Message("Cannot convert f64 to Duration".to_string()))?;
+        self.backend.time().set_block_timestamp_interval(dur.as_millis() as u64);
         Ok(())
     }
 

crates/anvil/src/eth/backend/mem/mod.rs

@@ -244,8 +244,10 @@ impl Backend {
             precompile_factory,
         };
 
-        if let Some(interval_block_time) = automine_block_time {
-            backend.update_interval_mine_block_time(interval_block_time);
+        if let Some(interval) = automine_block_time {
+            // Set interval in TimeManager as milliseconds.
+            backend.time.set_block_timestamp_interval((interval).as_millis().try_into().unwrap());
+            backend.update_interval_mine_block_time(interval);
         }
 
         // Note: this can only fail in forking mode, in which case we can't recover
@@ -944,7 +946,7 @@ impl Backend {
             env.block.number = env.block.number.saturating_add(U256::from(1));
             env.block.basefee = U256::from(current_base_fee);
             env.block.blob_excess_gas_and_price = current_excess_blob_gas_and_price;
-            env.block.timestamp = U256::from(self.time.next_timestamp());
+            env.block.timestamp = U256::from(self.time.next_timestamp_as_secs());
 
             let best_hash = self.blockchain.storage.read().best_hash;
 

crates/anvil/src/eth/backend/time.rs

@@ -15,14 +15,25 @@ pub fn utc_from_secs(secs: u64) -> DateTime<Utc> {
 pub struct TimeManager {
     /// tracks the overall applied timestamp offset
     offset: Arc<RwLock<i128>>,
-    /// The timestamp of the last block header
+    /// The timestamp of the last block header.
+    ///
+    /// Interpreted as seconds
     last_timestamp: Arc<RwLock<u64>>,
     /// Contains the next timestamp to use
     /// if this is set then the next time `[TimeManager::current_timestamp()]` is called this value
     /// will be taken and returned. After which the `offset` will be updated accordingly
+    ///
+    /// Interpreted as seconds
     next_exact_timestamp: Arc<RwLock<Option<u64>>>,
     /// The interval to use when determining the next block's timestamp
+    ///
+    /// Interpreted as milliseconds
     interval: Arc<RwLock<Option<u64>>>,
+    /// The wall clock timestamp with precision upto milliseconds
+    ///
+    /// This keeps track of the current timestamp in milliseconds, which is helpful for interval
+    /// mining with < 1000ms block times.
+    wall_clock_timestamp: Arc<RwLock<Option<u64>>>,
 }
 
 // === impl TimeManager ===
@@ -34,6 +45,7 @@ impl TimeManager {
             offset: Default::default(),
             next_exact_timestamp: Default::default(),
             interval: Default::default(),
+            wall_clock_timestamp: Default::default(),
         };
         time_manager.reset(start_timestamp);
         time_manager
@@ -46,6 +58,7 @@ impl TimeManager {
         *self.last_timestamp.write() = start_timestamp;
         *self.offset.write() = (start_timestamp as i128) - current;
         self.next_exact_timestamp.write().take();
+        *self.wall_clock_timestamp.write() = Some(start_timestamp.saturating_mul(1000)); // Since, wall_clock_timestamp is in milliseconds
     }
 
     pub fn offset(&self) -> i128 {
@@ -68,11 +81,11 @@ impl TimeManager {
         self.add_offset(seconds as i128)
     }
 
-    /// Sets the exact timestamp to use in the next block
+    /// Sets the exact timestamp (`next_exact_timestamp`) to use in the next block
     /// Fails if it's before (or at the same time) the last timestamp
     pub fn set_next_block_timestamp(&self, timestamp: u64) -> Result<(), BlockchainError> {
         trace!(target: "time", "override next timestamp {}", timestamp);
-        if timestamp <= *self.last_timestamp.read() {
+        if timestamp < *self.last_timestamp.read() {
             return Err(BlockchainError::TimestampError(format!(
                 "{timestamp} is lower than or equal to previous block's timestamp"
             )))
@@ -81,7 +94,7 @@ impl TimeManager {
         Ok(())
     }
 
-    /// Sets an interval to use when computing the next timestamp
+    /// Sets an interval (in milliseconds) to use when computing the next timestamp
     ///
     /// If an interval already exists, this will update the interval, otherwise a new interval will
     /// be set starting with the current timestamp.
@@ -100,30 +113,58 @@ impl TimeManager {
         }
     }
 
+    /// Updates `wall_clock_timestamp` by `interval_ms`
+    pub fn update_wall_clock_timestamp_by_interval(&self, interval_ms: u64) {
+        let current_wall_timestamp = self.wall_clock_timestamp.read().unwrap();
+        self.update_wall_clock_timestamp(current_wall_timestamp.saturating_add(interval_ms));
+    }
+
+    /// Updates `wall_clock_timestamp` to the given timestamp (milliseconds precision)
+    pub fn update_wall_clock_timestamp(&self, timestamp: u64) {
+        *self.wall_clock_timestamp.write() = Some(timestamp);
+    }
+
     /// Computes the next timestamp without updating internals
-    fn compute_next_timestamp(&self) -> (u64, Option<i128>) {
-        let current = duration_since_unix_epoch().as_secs() as i128;
+    fn compute_next_timestamp(&self, update_wall: bool) -> (u64, Option<i128>) {
+        let current = duration_since_unix_epoch().as_secs() as i128; // TODO(yash): Getting current time here as seconds.
         let last_timestamp = *self.last_timestamp.read();
 
+        let interval = *self.interval.read();
         let (mut next_timestamp, update_offset) =
             if let Some(next) = *self.next_exact_timestamp.read() {
+                if update_wall {
+                    self.update_wall_clock_timestamp(next * 1000); // Needs to be in ms
+                }
                 (next, true)
-            } else if let Some(interval) = *self.interval.read() {
-                (last_timestamp.saturating_add(interval), false)
+            } else if let Some(interval) = interval {
+                let wall_clock_timestamp = if update_wall {
+                    self.update_wall_clock_timestamp_by_interval(interval);
+                    self.wall_clock_timestamp.read().unwrap()
+                } else {
+                    let current_wall = self.wall_clock_timestamp.read().unwrap();
+                    current_wall.saturating_add(interval)
+                };
+                let next_timestamp = (wall_clock_timestamp as f64 / 1000.0).floor() as u64;
+
+                (next_timestamp, false)
             } else {
-                (current.saturating_add(self.offset()) as u64, false)
+                let next = current.saturating_add(self.offset()) as u64;
+                if update_wall {
+                    self.update_wall_clock_timestamp(next * 1000); // Needs to be in ms
+                }
+                (next, false)
             };
         // Ensures that the timestamp is always increasing
-        if next_timestamp <= last_timestamp {
+        if next_timestamp < last_timestamp {
             next_timestamp = last_timestamp + 1;
         }
         let next_offset = update_offset.then_some((next_timestamp as i128) - current);
         (next_timestamp, next_offset)
     }
 
     /// Returns the current timestamp and updates the underlying offset and interval accordingly
-    pub fn next_timestamp(&self) -> u64 {
-        let (next_timestamp, next_offset) = self.compute_next_timestamp();
+    pub fn next_timestamp_as_secs(&self) -> u64 {
+        let (next_timestamp, next_offset) = self.compute_next_timestamp(true);
         // Make sure we reset the `next_exact_timestamp`
         self.next_exact_timestamp.write().take();
         if let Some(next_offset) = next_offset {
@@ -135,7 +176,7 @@ impl TimeManager {
 
     /// Returns the current timestamp for a call that does _not_ update the value
     pub fn current_call_timestamp(&self) -> u64 {
-        let (next_timestamp, _) = self.compute_next_timestamp();
+        let (next_timestamp, _) = self.compute_next_timestamp(false);
         next_timestamp
     }
 }

crates/anvil/tests/it/anvil_api.rs

@@ -292,6 +292,9 @@ async fn test_set_next_timestamp() {
     assert_eq!(block.header.number.unwrap(), 1);
     assert_eq!(block.header.timestamp, next_timestamp.as_secs());
 
+    // Sleep for 1s
+    tokio::time::sleep(Duration::from_secs(1)).await;
+
     api.evm_mine(None).await.unwrap();
 
     let next = provider.get_block(BlockId::default(), false).await.unwrap().unwrap();
@@ -318,6 +321,11 @@ async fn test_evm_set_time() {
 
     assert!(block.header.timestamp >= timestamp.as_secs());
 
+    // Sleep for 1s
+    // This needs to be added as we removed the if condition in TimeManager wherein
+    // next_timestamp==last_timesatmp => next_timestamp + 1;
+    tokio::time::sleep(Duration::from_secs(1)).await;
+
     api.evm_mine(None).await.unwrap();
     let next = provider.get_block(BlockId::default(), false).await.unwrap().unwrap();
 
@@ -350,7 +358,7 @@ async fn test_timestamp_interval() {
     let provider = handle.http_provider();
 
     api.evm_mine(None).await.unwrap();
-    let interval = 10;
+    let interval: f64 = 1.0; // 1s
 
     for _ in 0..5 {
         let block = provider.get_block(BlockId::default(), false).await.unwrap().unwrap();
@@ -361,7 +369,7 @@ async fn test_timestamp_interval() {
 
         let new_block = provider.get_block(BlockId::default(), false).await.unwrap().unwrap();
 
-        assert_eq!(new_block.header.timestamp, block.header.timestamp + interval);
+        assert_eq!(new_block.header.timestamp, block.header.timestamp + interval as u64);
     }
 
     let block = provider.get_block(BlockId::default(), false).await.unwrap().unwrap();
@@ -377,7 +385,7 @@ async fn test_timestamp_interval() {
 
     let block = provider.get_block(BlockId::default(), false).await.unwrap().unwrap();
     // interval also works after setting the next timestamp manually
-    assert_eq!(block.header.timestamp, next_timestamp + interval);
+    assert_eq!(block.header.timestamp, next_timestamp + interval as u64);
 
     assert!(api.evm_remove_block_timestamp_interval().unwrap());
 
@@ -390,7 +398,7 @@ async fn test_timestamp_interval() {
     api.evm_mine(None).await.unwrap();
     let another_block = provider.get_block(BlockId::default(), false).await.unwrap().unwrap();
     // check interval is disabled
-    assert!(another_block.header.timestamp - new_block.header.timestamp < interval);
+    assert!(another_block.header.timestamp - new_block.header.timestamp <= interval as u64);
 }
 
 // <https://github.com/foundry-rs/foundry/issues/2341>
@@ -582,6 +590,9 @@ async fn test_fork_revert_next_block_timestamp() {
     let block = api.block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
     assert_eq!(block, latest_block);
 
+    // Sleep for 1s
+    tokio::time::sleep(Duration::from_secs(1)).await;
+
     api.mine_one().await;
     let block = api.block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
     assert!(block.header.timestamp > latest_block.header.timestamp);

crates/anvil/tests/it/fork.rs

@@ -810,7 +810,7 @@ async fn test_fork_block_timestamp() {
     api.anvil_mine(Some(U256::from(1)), None).await.unwrap();
     let latest_block = api.block_by_number(BlockNumberOrTag::Latest).await.unwrap().unwrap();
 
-    assert!(initial_block.header.timestamp < latest_block.header.timestamp);
+    assert!(initial_block.header.timestamp <= latest_block.header.timestamp);
 }
 
 #[tokio::test(flavor = "multi_thread")]