apollo_batcher: commitment manager output uses apollo committer types

Author: yoavGrs

crates/apollo_batcher/src/commitment_manager/commitment_manager_impl.rs

@@ -3,6 +3,7 @@
 use std::sync::Arc;
 
 use apollo_batcher_config::config::BatcherConfig;
+use apollo_committer_types::committer_types::CommitBlockResponse;
 use apollo_committer_types::communication::SharedCommitterClient;
 use starknet_api::block::BlockNumber;
 use starknet_api::block_hash::block_hash_calculator::{
@@ -21,6 +22,7 @@ use crate::commitment_manager::state_committer::{StateCommitter, StateCommitterT
 use crate::commitment_manager::types::{
     CommitmentTaskInput,
     CommitmentTaskOutput,
+    CommitterTaskOutput,
     FinalBlockCommitment,
 };
 
@@ -53,7 +55,7 @@ impl Default for CommitmentManagerConfig {
 /// Encapsulates the block hash calculation logic.
 pub(crate) struct CommitmentManager<S: StateCommitterTrait> {
     pub(crate) tasks_sender: Sender<CommitmentTaskInput>,
-    pub(crate) results_receiver: Receiver<CommitmentTaskOutput>,
+    pub(crate) results_receiver: Receiver<CommitterTaskOutput>,
     pub(crate) config: CommitmentManagerConfig,
     pub(crate) commitment_task_offset: BlockNumber,
     pub(crate) state_committer: S,
@@ -142,12 +144,13 @@ impl<S: StateCommitterTrait> CommitmentManager<S> {
         }
     }
 
-    /// Fetches all ready commitment results from the state committer.
+    /// Fetches all ready commitment results from the state committer. Panics if any task is a
+    /// revert.
     pub(crate) async fn get_commitment_results(&mut self) -> Vec<CommitmentTaskOutput> {
         let mut results = Vec::new();
         loop {
             match self.results_receiver.try_recv() {
-                Ok(result) => results.push(result),
+                Ok(result) => results.push(result.expect_commitment()),
                 Err(TryRecvError::Empty) => break,
                 Err(err) => {
                     panic!("Failed to receive commitment result from state committer. error: {err}")
@@ -262,7 +265,7 @@ impl<S: StateCommitterTrait> CommitmentManager<S> {
     // TODO(Rotem): Test this function.
     pub(crate) fn final_commitment_output<R: BatcherStorageReader + ?Sized>(
         storage_reader: Arc<R>,
-        CommitmentTaskOutput { height, global_root }: CommitmentTaskOutput,
+        CommitmentTaskOutput { response: CommitBlockResponse { state_root: global_root }, height }: CommitmentTaskOutput,
         should_finalize_block_hash: bool,
     ) -> CommitmentManagerResult<FinalBlockCommitment> {
         match should_finalize_block_hash {

crates/apollo_batcher/src/commitment_manager/commitment_manager_test.rs

@@ -149,7 +149,7 @@ async fn test_create_commitment_manager_with_missing_tasks(
     assert_eq!(get_number_of_tasks_in_sender(&commitment_manager.tasks_sender), 1,);
     commitment_manager.state_committer.pop_task_and_insert_result().await;
     let results = await_results(&mut commitment_manager.results_receiver, 1).await;
-    let result = results.first().unwrap();
+    let result = (results.first().unwrap()).clone().expect_commitment();
     assert_eq!(result.height, global_root_height);
 }
 
@@ -285,8 +285,8 @@ async fn test_get_commitment_results(mut mock_dependencies: MockDependencies) {
     commitment_manager.state_committer.pop_task_and_insert_result().await;
 
     let results = await_results(&mut commitment_manager.results_receiver, 2).await;
-    let first_result = results.first().unwrap();
-    let second_result = results.get(1).unwrap();
+    let first_result = results.first().unwrap().clone().expect_commitment();
+    let second_result = results.get(1).unwrap().clone().expect_commitment();
     assert_eq!(first_result.height, INITIAL_HEIGHT,);
     assert_eq!(second_result.height, INITIAL_HEIGHT.next().unwrap(),);
 }

crates/apollo_batcher/src/commitment_manager/state_committer.rs

@@ -4,14 +4,14 @@ use apollo_committer_types::communication::SharedCommitterClient;
 use tokio::sync::mpsc::{Receiver, Sender};
 use tokio::task::JoinHandle;
 
-use crate::commitment_manager::types::{CommitmentTaskInput, CommitmentTaskOutput};
+use crate::commitment_manager::types::{CommitmentTaskInput, CommitterTaskOutput};
 
 /// Commits state changes by calling the committer.
 pub(crate) trait StateCommitterTrait {
     /// Creates a new instance and starts thread which performs commitment tasks.
     fn create(
         tasks_receiver: Receiver<CommitmentTaskInput>,
-        results_sender: Sender<CommitmentTaskOutput>,
+        results_sender: Sender<CommitterTaskOutput>,
         committer_client: SharedCommitterClient,
     ) -> Self;
     /// Returns a handle to the thread performing commitment tasks.
@@ -25,7 +25,7 @@ pub(crate) struct StateCommitter {
 impl StateCommitterTrait for StateCommitter {
     fn create(
         tasks_receiver: Receiver<CommitmentTaskInput>,
-        results_sender: Sender<CommitmentTaskOutput>,
+        results_sender: Sender<CommitterTaskOutput>,
         committer_client: SharedCommitterClient,
     ) -> Self {
         let handle = tokio::spawn(async move {
@@ -41,7 +41,7 @@ impl StateCommitterTrait for StateCommitter {
 impl StateCommitter {
     pub(crate) async fn perform_commitment_tasks(
         mut tasks_receiver: Receiver<CommitmentTaskInput>,
-        mut results_sender: Sender<CommitmentTaskOutput>,
+        mut results_sender: Sender<CommitterTaskOutput>,
         committer_client: SharedCommitterClient,
     ) {
         // Placeholder: simply drain the receiver and do nothing.

crates/apollo_batcher/src/commitment_manager/types.rs

@@ -1,4 +1,6 @@
 #![allow(dead_code)]
+
+use apollo_committer_types::committer_types::{CommitBlockResponse, RevertBlockResponse};
 use starknet_api::block::{BlockHash, BlockNumber};
 use starknet_api::core::{GlobalRoot, StateDiffCommitment};
 use starknet_api::state::ThinStateDiff;
@@ -11,13 +13,33 @@ pub(crate) struct CommitmentTaskInput {
     pub(crate) state_diff_commitment: Option<StateDiffCommitment>,
 }
 
-/// Output of commitment tasks.
-#[cfg_attr(test, derive(Default))]
+#[derive(Clone)]
 pub(crate) struct CommitmentTaskOutput {
-    pub(crate) global_root: GlobalRoot,
+    pub(crate) response: CommitBlockResponse,
+    pub(crate) height: BlockNumber,
+}
+
+#[derive(Clone)]
+pub(crate) struct RevertTaskOutput {
+    pub(crate) response: RevertBlockResponse,
     pub(crate) height: BlockNumber,
 }
 
+#[derive(Clone)]
+pub(crate) enum CommitterTaskOutput {
+    Commit(CommitmentTaskOutput),
+    Revert(RevertTaskOutput),
+}
+
+impl CommitterTaskOutput {
+    pub(crate) fn expect_commitment(self) -> CommitmentTaskOutput {
+        match self {
+            Self::Commit(commitment_task_output) => commitment_task_output,
+            Self::Revert(_) => panic!("Got revert output."),
+        }
+    }
+}
+
 pub(crate) struct FinalBlockCommitment {
     pub(crate) height: BlockNumber,
     // Field is optional because for old blocks there are no component hashes, so the block hash

crates/apollo_batcher/src/test_utils.rs

@@ -5,6 +5,7 @@ use std::sync::Arc;
 use apollo_batcher_config::config::{BatcherConfig, FirstBlockWithPartialBlockHash};
 use apollo_batcher_types::batcher_types::{ProposalId, ProposeBlockInput};
 use apollo_class_manager_types::{EmptyClassManagerClient, SharedClassManagerClient};
+use apollo_committer_types::committer_types::CommitBlockResponse;
 use apollo_committer_types::communication::{MockCommitterClient, SharedCommitterClient};
 use apollo_l1_provider_types::MockL1ProviderClient;
 use apollo_mempool_types::communication::MockMempoolClient;
@@ -41,7 +42,11 @@ use crate::block_builder::{
     MockBlockBuilderFactoryTrait,
 };
 use crate::commitment_manager::state_committer::StateCommitterTrait;
-use crate::commitment_manager::types::{CommitmentTaskInput, CommitmentTaskOutput};
+use crate::commitment_manager::types::{
+    CommitmentTaskInput,
+    CommitmentTaskOutput,
+    CommitterTaskOutput,
+};
 use crate::pre_confirmed_block_writer::{
     MockPreconfirmedBlockWriterFactoryTrait,
     MockPreconfirmedBlockWriterTrait,
@@ -316,7 +321,7 @@ pub(crate) struct MockStateCommitter {
 impl StateCommitterTrait for MockStateCommitter {
     fn create(
         tasks_receiver: Receiver<CommitmentTaskInput>,
-        results_sender: Sender<CommitmentTaskOutput>,
+        results_sender: Sender<CommitterTaskOutput>,
         _committer_client: SharedCommitterClient,
     ) -> Self {
         let (mock_task_sender, mock_task_receiver) = channel(10);
@@ -335,13 +340,15 @@ impl MockStateCommitter {
     /// from the task receiver and sends a result to the results sender.
     pub(crate) async fn wait_for_mock_tasks(
         mut tasks_receiver: Receiver<CommitmentTaskInput>,
-        results_sender: Sender<CommitmentTaskOutput>,
+        results_sender: Sender<CommitterTaskOutput>,
         mut mock_task_receiver: Receiver<()>,
     ) {
         while mock_task_receiver.recv().await.is_some() {
             let task = tasks_receiver.try_recv().unwrap();
-            let result =
-                CommitmentTaskOutput { global_root: GlobalRoot::default(), height: task.height };
+            let result = CommitterTaskOutput::Commit(CommitmentTaskOutput {
+                response: CommitBlockResponse { state_root: GlobalRoot::default() },
+                height: task.height,
+            });
             results_sender.try_send(result).unwrap();
         }
     }

crates/apollo_committer_types/src/committer_types.rs

@@ -13,6 +13,7 @@ pub struct CommitBlockRequest {
 
 #[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
 pub struct CommitBlockResponse {
+    // TODO(Yoav): Rename to global_root.
     pub state_root: GlobalRoot,
 }