lambdaclass
diff --git a/‎Cargo.lock‎
Lines changed: 1 addition & 0 deletions b/‎Cargo.lock‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎crates/blockchain/Cargo.toml‎
Lines changed: 1 addition & 0 deletions b/‎crates/blockchain/Cargo.toml‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎crates/blockchain/blockchain.rs‎
Lines changed: 106 additions & 0 deletions b/‎crates/blockchain/blockchain.rs‎
Lines changed: 106 additions & 0 deletions
@@ -36,6 +36,7 @@ tokio-util.workspace = true
 [dev-dependencies]
 tokio = { workspace = true, features = ["full"] }
 ethrex-levm.workspace = true
+tempfile.workspace = true
 
 [lib]
 path = "./blockchain.rs"
 
@@ -219,6 +219,12 @@ pub struct Blockchain {
     /// Set to true after initial sync completes, never reset to false.
     /// Does not reflect whether an ongoing sync is in progress.
     is_synced: AtomicBool,
+    /// Set while a deep-reorg apply pass is in flight (issue #6685). Concurrent
+    /// FCUs from the engine API short-circuit to SYNCING while this is set,
+    /// and journal pruning in `forkchoice_update_inner` defers until the apply
+    /// pass clears it. Managed via [`enter_reorg`](Self::enter_reorg) which
+    /// returns a [`ReorgGuard`] RAII that clears the flag on drop.
+    reorg_in_progress: AtomicBool,
     /// Configuration options for blockchain behavior.
     pub options: BlockchainOptions,
     /// Cache of recently built payloads.
@@ -268,6 +274,21 @@ impl std::fmt::Debug for PrewarmedCache {
     }
 }
 
+/// RAII guard that clears [`Blockchain::reorg_in_progress`] on drop. Returned by
+/// [`Blockchain::enter_reorg`]. Ensures the flag is reset on every exit path of
+/// the apply pass, including panics that unwind through the guard.
+pub struct ReorgGuard<'a> {
+    blockchain: &'a Blockchain,
+}
+
+impl Drop for ReorgGuard<'_> {
+    fn drop(&mut self) {
+        self.blockchain
+            .reorg_in_progress
+            .store(false, Ordering::Release);
+    }
+}
+
 /// Configuration options for the blockchain.
 #[derive(Debug, Clone)]
 pub struct BlockchainOptions {
@@ -433,6 +454,7 @@ impl Blockchain {
             storage: store,
             mempool: Mempool::new(blockchain_opts.max_mempool_size),
             is_synced: AtomicBool::new(false),
+            reorg_in_progress: AtomicBool::new(false),
             payloads: Arc::new(TokioMutex::new(Vec::new())),
             options: blockchain_opts,
             merkle_pool: Self::build_merkle_pool(),
@@ -454,6 +476,7 @@ impl Blockchain {
             storage: store,
             mempool: Mempool::new(MAX_MEMPOOL_SIZE_DEFAULT),
             is_synced: AtomicBool::new(false),
+            reorg_in_progress: AtomicBool::new(false),
             payloads: Arc::new(TokioMutex::new(Vec::new())),
             options: BlockchainOptions::default(),
             merkle_pool: pool,
@@ -466,6 +489,7 @@ impl Blockchain {
             storage: store,
             mempool: Mempool::new(MAX_MEMPOOL_SIZE_DEFAULT),
             is_synced: AtomicBool::new(false),
+            reorg_in_progress: AtomicBool::new(false),
             payloads: Arc::new(TokioMutex::new(Vec::new())),
             options: BlockchainOptions::default(),
             merkle_pool: Self::build_merkle_pool(),
@@ -493,6 +517,33 @@ impl Blockchain {
         Ok(())
     }
 
+    /// Returns a reference to the underlying [`Store`]. Used by the deep-reorg
+    /// orchestrator to drive the storage-side primitives.
+    pub fn store(&self) -> &Store {
+        &self.storage
+    }
+
+    /// Returns `true` while a deep-reorg apply pass is in flight. Set by
+    /// [`enter_reorg`](Self::enter_reorg); the engine API's FCU handler should
+    /// short-circuit to SYNCING when this is `true`.
+    pub fn is_reorg_in_progress(&self) -> bool {
+        self.reorg_in_progress.load(Ordering::Acquire)
+    }
+
+    /// Attempts to mark the start of a deep-reorg apply pass. Returns a RAII
+    /// guard that clears the flag on drop (success, error, or panic) if no other
+    /// pass is in flight, or `None` if one already is. This is a test-and-set:
+    /// the flag transition `false -> true` is atomic, so two concurrent FCUs
+    /// that both reach the deep path can never both acquire the guard. The loser
+    /// short-circuits to SYNCING and the CL retries. At most one apply pass runs
+    /// at a time.
+    pub fn enter_reorg(&self) -> Option<ReorgGuard<'_>> {
+        self.reorg_in_progress
+            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+            .is_ok()
+            .then_some(ReorgGuard { blockchain: self })
+    }
+
     /// Executes a block withing a new vm instance and state
     fn execute_block(
         &self,
@@ -4541,3 +4592,58 @@ pub fn compute_sharded_storage_root(
 
     Ok((root_hash.finalize(&NativeCrypto), nodes))
 }
+
+#[cfg(test)]
+mod reorg_guard_tests {
+    use super::*;
+    use ethrex_storage::{EngineType, Store};
+
+    fn make_blockchain() -> Blockchain {
+        let dir = tempfile::tempdir().unwrap();
+        let store = Store::new(dir.path(), EngineType::InMemory).unwrap();
+        Blockchain::default_with_store(store)
+    }
+
+    /// `enter_reorg` SHALL set the flag; the returned guard SHALL clear it on drop.
+    #[test]
+    fn reorg_guard_sets_and_clears_flag() {
+        let blockchain = make_blockchain();
+        assert!(!blockchain.is_reorg_in_progress(), "flag starts false");
+
+        {
+            let guard = blockchain.enter_reorg();
+            assert!(guard.is_some(), "first enter_reorg must acquire the guard");
+            assert!(
+                blockchain.is_reorg_in_progress(),
+                "flag must be set while guard is alive"
+            );
+            // A second attempt while the first guard is alive must fail the
+            // test-and-set and return None.
+            assert!(
+                blockchain.enter_reorg().is_none(),
+                "concurrent enter_reorg must not acquire a second guard"
+            );
+        }
+        assert!(
+            !blockchain.is_reorg_in_progress(),
+            "flag must clear when guard drops"
+        );
+    }
+
+    /// The guard SHALL clear the flag even when its scope ends via panic unwinding.
+    #[test]
+    fn reorg_guard_clears_flag_on_panic() {
+        let blockchain = make_blockchain();
+        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            let _guard = blockchain.enter_reorg();
+            assert!(blockchain.is_reorg_in_progress());
+            panic!("simulated apply failure");
+        }));
+        // guard is dropped by the unwind; flag must be clear below.
+        assert!(result.is_err(), "panic must propagate out of the scope");
+        assert!(
+            !blockchain.is_reorg_in_progress(),
+            "flag must be cleared after a panicking guard scope"
+        );
+    }
+}