update: simplified codebase

Author: heemankv

madara/crates/client/block_production/src/executor/mod.rs

@@ -34,8 +34,6 @@ pub enum ExecutorCommandError {
 pub enum ExecutorCommand {
     /// Force close the current block.
     CloseBlock(oneshot::Sender<Result<(), ExecutorCommandError>>),
-    /// Reset executor state after a reorg. This reinitializes the state adapter from the current database state.
-    ResetState(oneshot::Sender<Result<(), ExecutorCommandError>>),
 }
 
 #[derive(Debug)]
@@ -52,8 +50,6 @@ pub enum ExecutorMessage {
     },
     BatchExecuted(BatchExecutionResult),
     EndBlock(Box<BlockExecutionSummary>),
-    /// Notifies the task that executor state was reset after a reorg
-    StateReset { latest_block_n: Option<u64> },
 }
 
 #[derive(Default, Debug)]

madara/crates/client/block_production/src/executor/thread.rs

@@ -281,45 +281,6 @@ impl ExecutorThread {
                             let _ = callback.send(Ok(()));
                             Default::default()
                         }
-                        super::ExecutorCommand::ResetState(callback) => {
-                            tracing::info!("🔄 Resetting executor state after reorg");
-                            // Reinitialize the state adapter from the current database state
-                            let new_state_adaptor = match mc_exec::LayeredStateAdapter::new(self.backend.clone()) {
-                                Ok(adaptor) => adaptor,
-                                Err(e) => {
-                                    tracing::error!("Failed to reinitialize state adapter after reorg: {:#}", e);
-                                    let _ = callback.send(Err(super::ExecutorCommandError::ChannelClosed));
-                                    return Err(e.into());
-                                }
-                            };
-
-                            let latest_block_n = new_state_adaptor.previous_block_n();
-                            tracing::info!("✅ State adapter reinitialized to block_n={}", new_state_adaptor.block_n());
-
-                            // Reset the executor state to NewBlock with the fresh state adapter
-                            state = ExecutorThreadState::NewBlock(ExecutorStateNewBlock {
-                                state_adaptor: new_state_adaptor,
-                                consumed_l1_to_l2_nonces: HashSet::new(),
-                            });
-
-                            // Clear any pending transactions by clearing both fields
-                            to_exec.txs.clear();
-                            to_exec.additional_info.clear();
-
-                            // Reset block state flags
-                            block_empty = true;
-                            force_close = false;
-                            l2_gas_consumed_block = 0;
-
-                            // Notify the main task that state was reset
-                            if self.replies_sender.blocking_send(super::ExecutorMessage::StateReset { latest_block_n }).is_err() {
-                                tracing::error!("Failed to send StateReset message to block production task");
-                            }
-
-                            let _ = callback.send(Ok(()));
-                            // Continue the loop to wait for new transactions - don't return a batch
-                            continue;
-                        }
                     },
                     // Channel closed. Exit gracefully.
                     WaitTxBatchOutcome::Exit => return Ok(()),

madara/crates/client/block_production/src/handle.rs

@@ -70,15 +70,6 @@ impl BlockProductionHandle {
         recv.await.map_err(|_| ExecutorCommandError::ChannelClosed)?
     }
 
-    /// Reset the executor state after a reorg. This reinitializes the state adapter from the current database state.
-    pub async fn reset_state(&self) -> Result<(), ExecutorCommandError> {
-        let (sender, recv) = oneshot::channel();
-        self.executor_commands
-            .send(ExecutorCommand::ResetState(sender))
-            .map_err(|_| ExecutorCommandError::ChannelClosed)?;
-        recv.await.map_err(|_| ExecutorCommandError::ChannelClosed)?
-    }
-
     /// Send a transaction through the bypass channel to bypass mempool and validation.
     pub async fn send_tx_raw(&self, tx: ValidatedTransaction) -> Result<(), ExecutorCommandError> {
         self.bypass_input.send(tx).await.map_err(|_| ExecutorCommandError::ChannelClosed)

madara/crates/client/block_production/src/lib.rs

@@ -115,7 +115,6 @@ pub use handle::BlockProductionHandle;
 pub enum BlockProductionStateNotification {
     ClosedBlock,
     BatchExecuted,
-    StateReset,
 }
 
 #[derive(Debug)]
@@ -626,11 +625,6 @@ impl BlockProductionTask {
     /// Handles the state machine and its transitions.
     async fn process_reply(&mut self, reply: ExecutorMessage) -> anyhow::Result<()> {
         match reply {
-            ExecutorMessage::StateReset { latest_block_n } => {
-                tracing::info!("🔄 Resetting block production task state after reorg to latest_block_n={:?}", latest_block_n);
-                self.current_state = Some(TaskState::NotExecuting { latest_block_n });
-                self.send_state_notification(BlockProductionStateNotification::StateReset);
-            }
             ExecutorMessage::StartNewBlock { exec_ctx } => {
                 tracing::debug!("Received ExecutorMessage::StartNewBlock block_n={}", exec_ctx.block_number);
                 let current_state = self.current_state.take().context("No current state")?;

madara/crates/client/rpc/src/versions/admin/v0_1_0/methods/write.rs

@@ -11,7 +11,8 @@ use mp_rpc::v0_9_0::{
     ClassAndTxnHash, ContractAndTxnHash,
 };
 use mp_transactions::{L1HandlerTransactionResult, L1HandlerTransactionWithFee};
-use mp_utils::service::MadaraServiceId;
+use mp_utils::service::{MadaraServiceId, MadaraServiceStatus};
+use std::time::Duration;
 #[async_trait]
 impl MadaraWriteRpcApiV0_1_0Server for Starknet {
     /// Submit a new class v0 declaration transaction, bypassing mempool and all validation.
@@ -126,7 +127,26 @@ impl MadaraWriteRpcApiV0_1_0Server for Starknet {
             }
         }
 
+        // Check if block production is currently running (sequencer mode)
+        let bp_was_running = matches!(
+            self.ctx.service_status(MadaraServiceId::BlockProduction),
+            MadaraServiceStatus::On
+        );
+
+        // If running, shut down block production cleanly before reorg
+        if bp_was_running {
+            tracing::info!("🔌 Stopping block production service for reorg...");
+            self.ctx.service_remove(MadaraServiceId::BlockProduction);
+            // Allow time for clean shutdown of executor threads and channels
+            tokio::time::sleep(Duration::from_millis(100)).await;
+            tracing::info!("✅ Block production service stopped");
+        }
+
+        // Perform the blockchain reorg
+        tracing::info!("🔄 Reverting blockchain to block {}", target_block_n);
         self.backend.revert_to(&block_hash).map_err(StarknetRpcApiError::from)?;
+
+        // Update chain tip cache
         let fresh_chain_tip = self
             .backend
             .db
@@ -135,19 +155,13 @@ impl MadaraWriteRpcApiV0_1_0Server for Starknet {
             .map_err(StarknetRpcApiError::from)?;
         let backend_chain_tip = mc_db::ChainTip::from_storage(fresh_chain_tip);
         self.backend.chain_tip.send_replace(backend_chain_tip);
+        tracing::info!("✅ Blockchain reverted successfully");
 
-        // Reset block production executor state if block production is enabled
-        let bp_status = self.ctx.service_status(MadaraServiceId::BlockProduction);
-        if matches!(bp_status, mp_utils::service::MadaraServiceStatus::On) {
-          if let Some(block_prod_handle) = &self.block_prod_handle {
-              tracing::debug!("revertTo: resetting block production state");
-              block_prod_handle
-                  .reset_state()
-                  .await
-                  .context("Resetting block production executor state after reorg")
-                  .map_err(StarknetRpcApiError::from)?;
-              tracing::debug!("revertTo: block production state reset complete");
-          }
+        // Restart block production if it was running before
+        if bp_was_running {
+            tracing::info!("🔌 Restarting block production service after reorg...");
+            self.ctx.service_add(MadaraServiceId::BlockProduction);
+            tracing::info!("✅ Block production service restarted with fresh state");
         }
 
         Ok(())