feat(consensus): add try_sync to context, and implement it in sequencer

crates/sequencing/papyrus_consensus/src/test_utils.rs

@@ -90,6 +90,8 @@ mock! {
             precommits: Vec<Vote>,
         ) -> Result<(), ConsensusError>;
 
+        async fn try_sync(&mut self, height: BlockNumber) -> bool;
+
         async fn set_height_and_round(&mut self, height: BlockNumber, round: Round);
     }
 }

crates/sequencing/papyrus_consensus/src/types.rs

@@ -112,6 +112,10 @@ pub trait ConsensusContext {
         precommits: Vec<Vote>,
     ) -> Result<(), ConsensusError>;
 
+    /// Attempt to learn of a decision from the sync protocol.
+    /// Returns true if a decision was learned so consensus can proceed.
+    async fn try_sync(&mut self, height: BlockNumber) -> bool;
+
     /// Update the context with the current height and round.
     /// Must be called at the beginning of each height.
     async fn set_height_and_round(&mut self, height: BlockNumber, round: Round);

crates/sequencing/papyrus_consensus_orchestrator/Cargo.toml

@@ -20,6 +20,7 @@ serde.workspace = true
 starknet-types-core.workspace = true
 starknet_api.workspace = true
 starknet_batcher_types = { workspace = true, features = ["testing"] }
+starknet_state_sync_types = { workspace = true, features = ["testing"] }
 tokio = { workspace = true, features = ["full"] }
 tokio-util.workspace = true
 tracing.workspace = true

crates/sequencing/papyrus_consensus_orchestrator/src/papyrus_consensus_context.rs

@@ -302,6 +302,11 @@ impl ConsensusContext for PapyrusConsensusContext {
         Ok(())
     }
 
+    async fn try_sync(&mut self, _height: BlockNumber) -> bool {
+        // TODO(Asmaa): Implement this.
+        false
+    }
+
     async fn set_height_and_round(&mut self, _height: BlockNumber, _round: Round) {
         // No-op
     }

crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context.rs

@@ -55,6 +55,7 @@ use starknet_batcher_types::batcher_types::{
     ValidateBlockInput,
 };
 use starknet_batcher_types::communication::BatcherClient;
+use starknet_state_sync_types::communication::SharedStateSyncClient;
 use tokio::task::JoinHandle;
 use tokio_util::sync::CancellationToken;
 use tracing::{debug, debug_span, info, instrument, trace, warn, Instrument};
@@ -97,6 +98,7 @@ enum HandledProposalPart {
 const BUILD_PROPOSAL_MARGIN: Duration = Duration::from_millis(1000);
 
 pub struct SequencerConsensusContext {
+    state_sync_client: SharedStateSyncClient,
     batcher: Arc<dyn BatcherClient>,
     validators: Vec<ValidatorId>,
     // Proposal building/validating returns immediately, leaving the actual processing to a spawned
@@ -127,6 +129,7 @@ pub struct SequencerConsensusContext {
 
 impl SequencerConsensusContext {
     pub fn new(
+        state_sync_client: SharedStateSyncClient,
         batcher: Arc<dyn BatcherClient>,
         outbound_proposal_sender: mpsc::Sender<(u64, mpsc::Receiver<ProposalPart>)>,
         vote_broadcast_client: BroadcastTopicClient<ConsensusMessage>,
@@ -135,6 +138,7 @@ impl SequencerConsensusContext {
         cende_ambassador: Arc<dyn CendeContext>,
     ) -> Self {
         Self {
+            state_sync_client,
             batcher,
             outbound_proposal_sender,
             vote_broadcast_client,
@@ -340,6 +344,15 @@ impl ConsensusContext for SequencerConsensusContext {
         Ok(())
     }
 
+    async fn try_sync(&mut self, height: BlockNumber) -> bool {
+        let sync_block = self.state_sync_client.get_block(height).await;
+        if let Ok(Some(sync_block)) = sync_block {
+            self.batcher.add_sync_block(sync_block).await.unwrap();
+            return true;
+        }
+        false
+    }
+
     async fn set_height_and_round(&mut self, height: BlockNumber, round: Round) {
         if self.current_height.map(|h| height > h).unwrap_or(true) {
             self.current_height = Some(height);

crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context_test.rs

@@ -41,6 +41,7 @@ use starknet_batcher_types::batcher_types::{
     ValidateBlockInput,
 };
 use starknet_batcher_types::communication::MockBatcherClient;
+use starknet_state_sync_types::communication::MockStateSyncClient;
 use starknet_types_core::felt::Felt;
 
 use crate::cende::MockCendeContext;
@@ -88,8 +89,10 @@ fn setup(
         mock_register_broadcast_topic().expect("Failed to create mock network");
     let BroadcastTopicChannels { broadcast_topic_client: votes_topic_client, .. } =
         subscriber_channels;
+    let state_sync_client = MockStateSyncClient::new();
 
     let context = SequencerConsensusContext::new(
+        Arc::new(state_sync_client),
         Arc::new(batcher),
         outbound_proposal_stream_sender,
         votes_topic_client,

crates/starknet_consensus_manager/src/consensus_manager.rs

@@ -81,6 +81,7 @@ impl ConsensusManager {
         };
 
         let context = SequencerConsensusContext::new(
+            Arc::clone(&self.state_sync_client),
             Arc::clone(&self.batcher_client),
             outbound_internal_sender,
             votes_broadcast_channels.broadcast_topic_client.clone(),

crates/starknet_state_sync_types/Cargo.toml

@@ -5,16 +5,24 @@ edition.workspace = true
 license.workspace = true
 repository.workspace = true
 
+[features]
+testing = ["mockall"]
+
 [lints]
 workspace = true
 
 [dependencies]
 async-trait.workspace = true
 futures.workspace = true
+mockall = { workspace = true, optional = true }
 papyrus_proc_macros.workspace = true
 papyrus_storage.workspace = true
 serde = { workspace = true, features = ["derive"] }
 starknet-types-core.workspace = true
 starknet_api.workspace = true
 starknet_sequencer_infra.workspace = true
 thiserror.workspace = true
+
+[dev-dependencies]
+# Enable self with "testing" feature in tests.
+starknet_state_sync_types = { workspace = true, features = ["testing"] }

crates/starknet_state_sync_types/src/communication.rs

@@ -1,6 +1,8 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
+#[cfg(any(feature = "testing", test))]
+use mockall::automock;
 use papyrus_proc_macros::handle_response_variants;
 use serde::{Deserialize, Serialize};
 use starknet_api::block::BlockNumber;
@@ -22,6 +24,7 @@ use thiserror::Error;
 use crate::errors::StateSyncError;
 use crate::state_sync_types::{StateSyncResult, SyncBlock};
 
+#[cfg_attr(any(test, feature = "testing"), automock)]
 #[async_trait]
 pub trait StateSyncClient: Send + Sync {
     /// Request for a block at a specific height.