refactor: block-miner automine checks

src/config.rs

@@ -246,14 +246,7 @@ impl ExecutorConfig {
             .expect("spawning evm threads should not fail");
         }
 
-        let auto_mine_enabled = if miner.block_time.is_none() {
-            tracing::info!("enabling auto mining");
-            true
-        } else {
-            false
-        };
-
-        let executor = Executor::new(storage, miner, auto_mine_enabled, relayer, evm_tx, self.num_evms);
+        let executor = Executor::new(storage, miner, relayer, evm_tx, self.num_evms);
         Arc::new(executor)
     }
 }
@@ -271,12 +264,11 @@ pub struct MinerConfig {
 impl MinerConfig {
     pub fn init(&self, storage: Arc<StratusStorage>) -> Arc<BlockMiner> {
         tracing::info!(config = ?self, "starting block miner");
-        let miner = Arc::new(BlockMiner::new(storage, self.block_time));
 
-        if let Some(block_time) = self.block_time {
-            Arc::clone(&miner).spawn_interval_miner(block_time);
+        let miner = Arc::new(BlockMiner::new(storage, self.block_time));
+        if miner.is_interval_miner_mode() {
+            Arc::clone(&miner).spawn_interval_miner();
         }
-
         miner
     }
 }

src/eth/block_miner.rs

@@ -46,14 +46,30 @@ impl BlockMiner {
         }
     }
 
-    pub fn spawn_interval_miner(self: Arc<Self>, block_time: Duration) {
+    /// Spawns a new thread that keep mining blocks in the specified interval.
+    pub fn spawn_interval_miner(self: Arc<Self>) {
+        let Some(block_time) = self.block_time else {
+            tracing::error!("cannot spawn interval miner because it does not have a block time defined");
+            return;
+        };
+
         tracing::info!(block_time = %humantime::Duration::from(block_time), "spawning interval miner");
 
         let t = thread::Builder::new().name("interval-miner".into());
         t.spawn(move || interval_miner(self, block_time))
             .expect("spawning interval miner should not fail");
     }
 
+    /// Checks if miner should run in interval miner mode.
+    pub fn is_interval_miner_mode(&self) -> bool {
+        self.block_time.is_some()
+    }
+
+    /// Checks if miner should run in automine mode.
+    pub fn is_automine_mode(&self) -> bool {
+        not(self.is_interval_miner_mode())
+    }
+
     /// Mines external block and external transactions.
     ///
     /// Local transactions are not allowed to be part of the block.

src/eth/executor.rs

@@ -51,7 +51,7 @@ pub struct Executor {
     miner: Mutex<Arc<BlockMiner>>,
 
     /// Bool indicating whether to enable auto mining or not.
-    auto_mine_enabled: bool,
+    automine: bool,
 
     /// Provider for sending rpc calls to substrate
     relayer: Option<Arc<TransactionRelayer>>,
@@ -65,17 +65,18 @@ impl Executor {
     pub fn new(
         storage: Arc<StratusStorage>,
         miner: Arc<BlockMiner>,
-        auto_mine_enabled: bool,
         relayer: Option<Arc<TransactionRelayer>>,
         evm_tx: crossbeam_channel::Sender<EvmTask>,
         num_evms: usize,
     ) -> Self {
-        tracing::info!(%num_evms, "starting executor");
+        let automine = miner.is_automine_mode();
+        tracing::info!(%num_evms, %automine, "starting executor");
+
         Self {
             evm_tx,
             num_evms,
             miner: Mutex::new(miner),
-            auto_mine_enabled,
+            automine,
             storage,
             relayer,
         }
@@ -285,7 +286,7 @@ impl Executor {
                     }
 
                     // auto mine needed for e2e contract tests
-                    if self.auto_mine_enabled {
+                    if self.automine {
                         let miner = self.miner.lock().await;
                         miner.mine_local_and_commit().await?;
                     }