apollo_committer: revret block flow (#11342)

* apollo_committer: test load offset

* apollo_committer: commit state diff util

* apollo_committer: height hole errors

* apollo_committer: revert block flow

Author: yoavGrs

crates/apollo_committer/src/committer.rs

@@ -3,7 +3,12 @@ use std::error::Error;
 use std::marker::PhantomData;
 
 use apollo_committer_config::config::CommitterConfig;
-use apollo_committer_types::committer_types::{CommitBlockRequest, CommitBlockResponse};
+use apollo_committer_types::committer_types::{
+    CommitBlockRequest,
+    CommitBlockResponse,
+    RevertBlockRequest,
+    RevertBlockResponse,
+};
 use apollo_committer_types::errors::{CommitterError, CommitterResult};
 use starknet_api::block::BlockNumber;
 use starknet_api::block_hash::state_diff_hash::calculate_state_diff_hash;
@@ -123,6 +128,55 @@ impl<S: StorageConstructor, CB: CommitBlockTrait> Committer<S, CB> {
         Ok(CommitBlockResponse { state_root: global_root })
     }
 
+    /// Applies the given state diff to revert the changes of the given height.
+    pub async fn revert_block(
+        &mut self,
+        RevertBlockRequest { reversed_state_diff, height }: RevertBlockRequest,
+    ) -> CommitterResult<RevertBlockResponse> {
+        let Some(last_committed_block) = self.offset.prev() else {
+            // No committed blocks. Nothing to revert.
+            return Ok(RevertBlockResponse::Uncommitted);
+        };
+
+        if height > self.offset {
+            // Request to revert a future height. Nothing to revert.
+            return Ok(RevertBlockResponse::Uncommitted);
+        }
+
+        if height == self.offset {
+            // Request to revert the next future height.
+            // Nothing to revert, but we have the resulted state root.
+            let db_state_root = self.load_global_root(last_committed_block).await?;
+            return Ok(RevertBlockResponse::AlreadyReverted(db_state_root));
+        }
+
+        if height < last_committed_block {
+            // Request to revert an old height. Nothing to revert.
+            // Returns an error, indicating the committer has a hole in the revert series.
+            return Err(CommitterError::RevertHeightHole {
+                input_height: height,
+                last_committed_block,
+            });
+        }
+        // Sanity.
+        assert_eq!(height, last_committed_block);
+        // Happy flow. Reverts the state diff and returns the computed global root.
+        let (filled_forest, revert_global_root) =
+            self.commit_state_diff(reversed_state_diff).await?;
+
+        // Ignore entries with block number key equals to or higher than the offset.
+        let metadata = HashMap::from([(
+            ForestMetadataType::CommitmentOffset,
+            DbValue(DbBlockNumber(last_committed_block).serialize().to_vec()),
+        )]);
+        self.forest_storage
+            .write_with_metadata(&filled_forest, metadata)
+            .await
+            .map_err(|err| self.map_internal_error(err))?;
+        self.offset = last_committed_block;
+        Ok(RevertBlockResponse::RevertedTo(revert_global_root))
+    }
+
     async fn load_state_diff_commitment(
         &mut self,
         block_number: BlockNumber,

crates/apollo_committer/src/communication.rs

@@ -19,9 +19,8 @@ impl<S: StorageConstructor, CB: CommitBlockTrait>
             CommitterRequest::CommitBlock(commit_block_request) => {
                 CommitterResponse::CommitBlock(self.commit_block(commit_block_request).await)
             }
-            CommitterRequest::RevertBlock(_) => {
-                // TODO(Yoav): Call the committer.
-                unimplemented!()
+            CommitterRequest::RevertBlock(revert_block_request) => {
+                CommitterResponse::RevertBlock(self.revert_block(revert_block_request).await)
             }
         }
     }

crates/apollo_committer_types/src/committer_types.rs

@@ -19,12 +19,16 @@ pub struct CommitBlockResponse {
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct RevertBlockRequest {
     // A synthetic state diff that undoes the state diff of the given height.
-    reversed_state_diff: ThinStateDiff,
-    height: BlockNumber,
+    pub reversed_state_diff: ThinStateDiff,
+    pub height: BlockNumber,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum RevertBlockResponse {
-    Uncommitted,
+    // Nothing to revert, the committer had the resulted state root.
+    AlreadyReverted(GlobalRoot),
+    // The block was reverted, return the state root after reverting the state.
     RevertedTo(GlobalRoot),
+    // Nothing to revert. A future block that has not been committed.
+    Uncommitted,
 }