fix

Author: bkolad

crates/full-node/sov-sequencer/src/preferred/block_executor.rs

@@ -105,6 +105,7 @@ pub struct StartBlockData<S: Spec> {
     // We pass the node state root explicitly because retrieving it is
     // fallible, so it's convenient to front-load the error-checking.
     pub node_state_root: <S::Storage as Storage>::Root,
+    pub minimum_profit_per_tx: u128,
 }
 
 #[derive(Clone)]
@@ -372,10 +373,6 @@ impl<S: Spec, Rt: Runtime<S>> RollupBlockExecutor<S, Rt> {
             sanity_check_visible_slot_number_after_increase,
             visible_increase,
             node_state_root: node_state_root.clone(),
-        };
-
-        self.start_rollup_block(
-            start_block_data,
             // When replaying batches, we wish to be deterministic and not
             // filter out previously-accepted transactions simply because
             // they're not considered profitable enough based on the current
@@ -386,9 +383,10 @@ impl<S: Spec, Rt: Runtime<S>> RollupBlockExecutor<S, Rt> {
             // cause the rest of the batch to not have a minimum profit. We
             // might want to forcibly close that batch and start a new one, or
             // send the new configuration value over a channel.
-            0,
-        )
-        .await;
+            minimum_profit_per_tx: 0,
+        };
+
+        self.start_rollup_block(start_block_data).await;
 
         trace!("Replaying txs");
     }
@@ -428,19 +426,19 @@ impl<S: Spec, Rt: Runtime<S>> RollupBlockExecutor<S, Rt> {
         }
     }
 
-    pub async fn warm_up_cache(
+    pub async fn start_rollup_block_with_provided_state_roots(
         &mut self,
         start_block_data: StartBlockData<S>,
         checkpoint: StateCheckpoint<S>,
         state_roots: BTreeMap<RollupHeight, <S::Storage as Storage>::Root>,
-        minimum_profit_per_tx: u128,
     ) {
         self.checkpoint = checkpoint;
 
         let StartBlockData {
             sanity_check_visible_slot_number_after_increase,
             visible_increase,
             node_state_root: _,
+            minimum_profit_per_tx,
         } = start_block_data;
 
         assert!(
@@ -511,15 +509,12 @@ impl<S: Spec, Rt: Runtime<S>> RollupBlockExecutor<S, Rt> {
     }
 
     #[tracing::instrument(skip_all, level = "trace")]
-    pub async fn start_rollup_block(
-        &mut self,
-        start_blcock_data: StartBlockData<S>,
-        minimum_profit_per_tx: u128,
-    ) {
+    pub async fn start_rollup_block(&mut self, start_blcock_data: StartBlockData<S>) {
         let StartBlockData {
             sanity_check_visible_slot_number_after_increase,
             visible_increase,
             node_state_root,
+            minimum_profit_per_tx,
         } = start_blcock_data;
 
         assert!(

crates/full-node/sov-sequencer/src/preferred/cache_warm_up_executor.rs

@@ -145,7 +145,11 @@ impl<S: Spec> CacheWarmupExecutor<S> {
         executor: &mut RollupBlockExecutor<S, Rt>,
     ) {
         executor
-            .warm_up_cache(notify.data, notify.checkpoint, notify.state_roots, 0)
+            .start_rollup_block_with_provided_state_roots(
+                notify.data,
+                notify.checkpoint,
+                notify.state_roots,
+            )
             .await
     }
 }

crates/full-node/sov-sequencer/src/preferred/inner.rs

@@ -267,22 +267,22 @@ where
 
         // DB operations handled by replica-aware db implementation
         let sequence_number = self.get_and_inc_next_sequence_number();
+        let min_profit_per_tx = self.seq_config.sequencer_kind_config.minimum_profit_per_tx;
 
         let start_block_data = StartBlockData {
             sanity_check_visible_slot_number_after_increase: visible_slot_number_after_increase,
             visible_increase,
             node_state_root: node_state_root.clone(),
+            minimum_profit_per_tx: min_profit_per_tx,
         };
 
-        let min_profit_per_tx = self.seq_config.sequencer_kind_config.minimum_profit_per_tx;
-
         let old_checkpoint = self
             .executor
             .checkpoint
             .clone_with_empty_witness_dropping_temp_cache();
 
         self.executor
-            .start_rollup_block(start_block_data.clone(), min_profit_per_tx)
+            .start_rollup_block(start_block_data.clone())
             .await;
 
         let state_roots = self.executor.state_roots.clone();
@@ -343,17 +343,16 @@ where
 
         let node_state_root = self.node_root_hash()?;
         let sequence_number = self.get_and_inc_next_sequence_number();
+        let min_profit_per_tx = self.seq_config.sequencer_kind_config.minimum_profit_per_tx;
 
         let start_block_data = StartBlockData {
             sanity_check_visible_slot_number_after_increase: visible_slot_number_after_increase,
             visible_increase: replica_visible_slots_to_advance,
             node_state_root: node_state_root.clone(),
+            minimum_profit_per_tx: min_profit_per_tx,
         };
 
-        let min_profit_per_tx = self.seq_config.sequencer_kind_config.minimum_profit_per_tx;
-        self.executor
-            .start_rollup_block(start_block_data, min_profit_per_tx)
-            .await;
+        self.executor.start_rollup_block(start_block_data).await;
 
         self.executor_events_sender
             .start_batch(