Merge pull request #11395 from starkware-libs/nadin/merge-main-v0.14.1-into-main-v0.14.1-committer-1767535122

Merge main-v0.14.1 into main-v0.14.1-committer

Author: Itay-Tsabary-Starkware

.github/workflows/committer_ci.yml

@@ -15,7 +15,6 @@ on:
       - "crates/starknet_api/**"
       - "crates/starknet_committer/**"
       - "crates/starknet_patricia/**"
-      - "scripts/dependencies.sh"
 
 env:
   RUSTFLAGS: "-D warnings"

.github/workflows/hybrid_system_test.yaml

@@ -18,7 +18,7 @@ env:
   overlay: hybrid.testing.node-0
   cluster_name: hybrid-system-test
   crate_triggers: "apollo_node,apollo_deployments,apollo_integration_tests"
-  path_triggers: ".github/workflows/hybrid_system_test.yaml,scripts/*.py,scripts/system_tests/**/*.py,deployments/sequencer/**,deployments/images/**"
+  path_triggers: ".github/workflows/hybrid_system_test.yaml,scripts/**,deployments/sequencer/**,deployments/images/**"
   path_triggers_exclude: "scripts/prod/**/*"
   pvc_storage_class_name: "premium-rwo"
   anvil_port: "8545"

crates/apollo_consensus/src/manager.rs

@@ -433,9 +433,7 @@ impl<ContextT: ConsensusContext> MultiHeightManager<ContextT> {
                     self.wait_until_sync_reaches_height(height, context).await;
                     RunHeightRes::Sync
                 }
-                e @ ConsensusError::BlockInfoConversion(_)
-                | e @ ConsensusError::InternalNetworkError(_)
-                | e @ ConsensusError::Other(_) => {
+                e @ ConsensusError::InternalNetworkError(_) => {
                     // The node is missing required components/data and cannot continue
                     // participating in the consensus. A fix and node restart are required.
                     return Err(e);
@@ -476,7 +474,7 @@ impl<ContextT: ConsensusContext> MultiHeightManager<ContextT> {
         CONSENSUS_BLOCK_NUMBER.set_lossy(height.0);
         self.cache.report_max_cached_block_number_metric(height);
 
-        if let Some(sync_result) = self.check_and_wait_for_sync(context, height).await? {
+        if let Some(sync_result) = self.check_and_wait_for_sync(context, height).await {
             return Ok(sync_result);
         }
 
@@ -503,12 +501,12 @@ impl<ContextT: ConsensusContext> MultiHeightManager<ContextT> {
     }
 
     /// Check if we need to sync and wait if necessary.
-    /// Returns Some(RunHeightRes::Sync) if sync is needed, None otherwise.
+    /// Returns Some(RunHeightRes::Sync) if sync height was learned via sync, None otherwise.
     async fn check_and_wait_for_sync(
         &mut self,
         context: &mut ContextT,
         height: BlockNumber,
-    ) -> Result<Option<RunHeightRes>, ConsensusError> {
+    ) -> Option<RunHeightRes> {
         // If we already voted for this height, do not proceed until we sync to this height.
         // Otherwise, just check if we can sync to this height, immediately. If not, proceed with
         // consensus.
@@ -524,11 +522,11 @@ impl<ContextT: ConsensusContext> MultiHeightManager<ContextT> {
                 self.last_voted_height_at_initialization.unwrap().0
             );
             self.wait_until_sync_reaches_height(height, context).await;
-            return Ok(Some(RunHeightRes::Sync));
+            return Some(RunHeightRes::Sync);
         } else if context.try_sync(height).await {
-            return Ok(Some(RunHeightRes::Sync));
+            return Some(RunHeightRes::Sync);
         }
-        Ok(None)
+        None
     }
 
     /// Initialize consensus for a height: get validators, create SHC, and set up events.

crates/apollo_consensus/src/types.rs

@@ -154,8 +154,4 @@ pub enum ConsensusError {
     // As opposed to an error between this node and peer nodes.
     #[error("{0}")]
     InternalNetworkError(String),
-    #[error("Block info conversion error: {0}")]
-    BlockInfoConversion(#[from] starknet_api::StarknetApiError),
-    #[error("{0}")]
-    Other(String),
 }

crates/apollo_consensus_orchestrator/src/build_proposal.rs

@@ -23,7 +23,8 @@ use apollo_protobuf::consensus::{
     ProposalPart,
     TransactionBatch,
 };
-use apollo_time::time::DateTime;
+use apollo_state_sync_types::communication::SharedStateSyncClient;
+use apollo_time::time::{Clock, DateTime};
 use starknet_api::block::{BlockNumber, GasPrice};
 use starknet_api::consensus_transaction::InternalConsensusTransaction;
 use starknet_api::core::ContractAddress;
@@ -64,6 +65,7 @@ pub(crate) struct ProposalBuildArguments {
     pub proposal_round: Round,
     pub retrospective_block_hash_deadline: DateTime,
     pub retrospective_block_hash_retry_interval_millis: Duration,
+    pub use_state_sync_block_timestamp: bool,
 }
 
 type BuildProposalResult<T> = Result<T, BuildProposalError>;
@@ -81,9 +83,8 @@ pub(crate) enum BuildProposalError {
     StateSyncClientError(String),
     #[error("State sync is not ready: block number {0} not found")]
     StateSyncNotReady(BlockNumber),
-    // Consensus may exit early (e.g. sync).
-    #[error("Failed to send commitment to consensus: {0}")]
-    SendError(ProposalCommitment),
+    #[error("Failed to send proposal part: {0}")]
+    SendError(String),
     #[error("EthToStrkOracle error: {0}")]
     EthToStrkOracle(#[from] EthToStrkOracleClientError),
     #[error("L1GasPriceProvider error: {0}")]
@@ -106,14 +107,13 @@ pub(crate) async fn build_proposal(
     mut args: ProposalBuildArguments,
 ) -> BuildProposalResult<ProposalCommitment> {
     let block_info = initiate_build(&args).await?;
-    args.stream_sender
-        .send(ProposalPart::Init(args.proposal_init))
-        .await
-        .expect("Failed to send proposal init");
+    args.stream_sender.send(ProposalPart::Init(args.proposal_init)).await.map_err(|e| {
+        BuildProposalError::SendError(format!("Failed to send proposal init: {e:?}"))
+    })?;
     args.stream_sender
         .send(ProposalPart::BlockInfo(block_info.clone()))
         .await
-        .expect("Failed to send block info");
+        .map_err(|e| BuildProposalError::SendError(format!("Failed to send block info: {e:?}")))?;
 
     let (proposal_commitment, content) = get_proposal_content(&mut args).await?;
 
@@ -130,8 +130,27 @@ pub(crate) async fn build_proposal(
     Ok(proposal_commitment)
 }
 
+async fn get_proposal_timestamp(
+    use_state_sync_block_timestamp: bool,
+    state_sync_client: &SharedStateSyncClient,
+    clock: &dyn Clock,
+) -> u64 {
+    if use_state_sync_block_timestamp {
+        if let Ok(Some(block_header)) = state_sync_client.get_latest_block_header().await {
+            return block_header.block_header_without_hash.timestamp.0;
+        }
+        warn!("No latest block header available from state sync, falling back to clock time");
+    }
+    clock.unix_now()
+}
+
 async fn initiate_build(args: &ProposalBuildArguments) -> BuildProposalResult<ConsensusBlockInfo> {
-    let timestamp = args.deps.clock.unix_now();
+    let timestamp = get_proposal_timestamp(
+        args.use_state_sync_block_timestamp,
+        &args.deps.state_sync_client,
+        args.deps.clock.as_ref(),
+    )
+    .await;
     let (eth_to_fri_rate, l1_prices) = get_oracle_rate_and_prices(
         args.deps.l1_gas_price_provider.clone(),
         timestamp,
@@ -225,7 +244,11 @@ async fn get_proposal_content(
                 args.stream_sender
                     .send(ProposalPart::Transactions(TransactionBatch { transactions }))
                     .await
-                    .expect("Failed to broadcast proposal content");
+                    .map_err(|e| {
+                        BuildProposalError::SendError(format!(
+                            "Failed to send transaction batch: {e:?}"
+                        ))
+                    })?;
             }
             GetProposalContent::Finished { id, final_n_executed_txs } => {
                 let proposal_commitment = ProposalCommitment(id.state_diff_commitment.0.0);
@@ -272,13 +295,16 @@ async fn get_proposal_content(
                 args.stream_sender
                     .send(ProposalPart::ExecutedTransactionCount(final_n_executed_txs_u64))
                     .await
-                    .expect("Failed to broadcast executed transaction count");
+                    .map_err(|e| {
+                        BuildProposalError::SendError(format!(
+                            "Failed to send executed transaction count: {e:?}"
+                        ))
+                    })?;
                 let fin = ProposalFin { proposal_commitment };
                 info!("Sending fin={fin:?}");
-                args.stream_sender
-                    .send(ProposalPart::Fin(fin))
-                    .await
-                    .expect("Failed to broadcast proposal fin");
+                args.stream_sender.send(ProposalPart::Fin(fin)).await.map_err(|e| {
+                    BuildProposalError::SendError(format!("Failed to send proposal fin: {e:?}"))
+                })?;
                 return Ok((proposal_commitment, content));
             }
         }

crates/apollo_consensus_orchestrator/src/build_proposal_test.rs

@@ -60,6 +60,7 @@ struct TestProposalBuildArguments {
     pub proposal_round: Round,
     pub retrospective_block_hash_deadline: DateTime,
     pub retrospective_block_hash_retry_interval_millis: Duration,
+    pub use_state_sync_block_timestamp: bool,
 }
 
 impl From<TestProposalBuildArguments> for ProposalBuildArguments {
@@ -82,6 +83,7 @@ impl From<TestProposalBuildArguments> for ProposalBuildArguments {
             retrospective_block_hash_deadline: args.retrospective_block_hash_deadline,
             retrospective_block_hash_retry_interval_millis: args
                 .retrospective_block_hash_retry_interval_millis,
+            use_state_sync_block_timestamp: args.use_state_sync_block_timestamp,
         }
     }
 }
@@ -108,7 +110,7 @@ fn create_proposal_build_arguments() -> (TestProposalBuildArguments, mpsc::Recei
     let cancel_token = CancellationToken::new();
     let previous_block_info = None;
     let proposal_round = 0;
-
+    let use_state_sync_block_timestamp = false;
     (
         TestProposalBuildArguments {
             deps,
@@ -127,6 +129,7 @@ fn create_proposal_build_arguments() -> (TestProposalBuildArguments, mpsc::Recei
             proposal_round,
             retrospective_block_hash_deadline,
             retrospective_block_hash_retry_interval_millis,
+            use_state_sync_block_timestamp,
         },
         proposal_receiver,
     )