apollo_consensus_orchestrator: send CommitmentParts in Fin

Author: asmaastarkware

Cargo.lock

@@ -17,6 +17,7 @@ use apollo_consensus::types::{ProposalCommitment, Round};
 use apollo_l1_gas_price_types::errors::{EthToStrkOracleClientError, L1GasPriceClientError};
 use apollo_protobuf::consensus::{
     BuildParam,
+    CommitmentParts,
     ProposalFin,
     ProposalInit,
     ProposalPart,
@@ -308,11 +309,11 @@ async fn get_proposal_content(
                     .final_n_executed_txs
                     .try_into()
                     .expect("Number of executed transactions should fit in u64");
-                // TODO(Asmaa): Pass the commitment parts.
+                let commitment_parts = CommitmentParts::from(&info);
                 let fin = ProposalFin {
                     proposal_commitment,
                     executed_transaction_count,
-                    commitment_parts: None,
+                    commitment_parts: Some(commitment_parts),
                 };
                 info!("Sending fin={fin:?}");
                 args.stream_sender.send(ProposalPart::Fin(fin)).await.map_err(|e| {

crates/apollo_consensus_orchestrator/src/build_proposal.rs

@@ -25,6 +25,7 @@ use apollo_l1_gas_price_types::L1GasPriceProviderClient;
 use apollo_network::network_manager::{BroadcastTopicClient, BroadcastTopicClientTrait};
 use apollo_protobuf::consensus::{
     BuildParam,
+    CommitmentParts,
     HeightAndRound,
     ProposalFin,
     ProposalInit,
@@ -623,7 +624,7 @@ impl ConsensusContext for SequencerConsensusContext {
     async fn repropose(&mut self, id: ProposalCommitment, build_param: BuildParam) {
         info!(?id, ?build_param, "Reproposing.");
         let height = build_param.height;
-        let (init, txs, _, _) = self
+        let (init, txs, _, finished_info) = self
             .valid_proposals
             .lock()
             .expect("Lock on active proposals was poisoned due to a previous panic")
@@ -635,8 +636,15 @@ impl ConsensusContext for SequencerConsensusContext {
             self.start_stream(HeightAndRound(height.0, build_param.round)).await;
         let handle = tokio::spawn(
             async move {
-                let res =
-                    send_reproposal(id, init, txs, &mut stream_sender, transaction_converter).await;
+                let res = send_reproposal(
+                    id,
+                    init,
+                    txs,
+                    finished_info,
+                    &mut stream_sender,
+                    transaction_converter,
+                )
+                .await;
                 match res {
                     Ok(()) => {
                         info!(?id, ?build_param, "Reproposal succeeded.");
@@ -923,11 +931,11 @@ async fn send_reproposal(
     id: ProposalCommitment,
     init: ProposalInit,
     txs: Vec<Vec<InternalConsensusTransaction>>,
+    finished_info: FinishedProposalInfo,
     stream_sender: &mut StreamSender,
     transaction_converter: Arc<dyn TransactionConverterTrait>,
 ) -> Result<(), ReproposeError> {
     stream_sender.send(ProposalPart::Init(init)).await?;
-    let mut n_executed_txs: usize = 0;
     for batch in txs.iter() {
         let transactions = futures::future::join_all(batch.iter().map(|tx| {
             // transaction_converter is an external dependency (class manager) and so
@@ -938,12 +946,17 @@ async fn send_reproposal(
         .into_iter()
         .collect::<Result<Vec<_>, _>>()?;
         stream_sender.send(ProposalPart::Transactions(TransactionBatch { transactions })).await?;
-        n_executed_txs += batch.len();
     }
-    let executed_transaction_count: u64 =
-        n_executed_txs.try_into().expect("Number of executed transactions should fit in u64");
-    let fin =
-        ProposalFin { proposal_commitment: id, executed_transaction_count, commitment_parts: None };
+    let executed_transaction_count: u64 = finished_info
+        .final_n_executed_txs
+        .try_into()
+        .expect("Number of executed transactions should fit in u64");
+    let commitment_parts = CommitmentParts::from(&finished_info);
+    let fin = ProposalFin {
+        proposal_commitment: id,
+        executed_transaction_count,
+        commitment_parts: Some(commitment_parts),
+    };
     stream_sender.send(ProposalPart::Fin(fin)).await?;
 
     Ok(())

crates/apollo_consensus_orchestrator/src/sequencer_consensus_context.rs

@@ -29,6 +29,7 @@ use apollo_l1_gas_price_types::errors::{
 use apollo_l1_gas_price_types::{MockL1GasPriceProviderClient, PriceInfo};
 use apollo_protobuf::consensus::{
     BuildParam,
+    CommitmentParts,
     ProposalCommitment,
     ProposalFin,
     ProposalPart,
@@ -136,7 +137,7 @@ async fn validate_then_repropose(#[case] execute_all_txs: bool) {
     let fin = ProposalPart::Fin(ProposalFin {
         proposal_commitment: ProposalCommitment(STATE_DIFF_COMMITMENT.0.0),
         executed_transaction_count: n_executed_txs_count.try_into().unwrap(),
-        commitment_parts: None,
+        commitment_parts: Some(CommitmentParts::default()),
     });
     content_sender.send(fin.clone()).await.unwrap();
     let fin_receiver = context.validate_proposal(init.clone(), TIMEOUT, content_receiver).await;
@@ -170,7 +171,7 @@ async fn proposals_from_different_rounds() {
     let prop_part_fin = ProposalPart::Fin(ProposalFin {
         proposal_commitment: ProposalCommitment(STATE_DIFF_COMMITMENT.0.0),
         executed_transaction_count: INTERNAL_TX_BATCH.len().try_into().unwrap(),
-        commitment_parts: None,
+        commitment_parts: Some(CommitmentParts::default()),
     });
 
     // The proposal from the past round is ignored.
@@ -293,7 +294,7 @@ async fn build_proposal() {
         ProposalPart::Fin(ProposalFin {
             proposal_commitment: ProposalCommitment(STATE_DIFF_COMMITMENT.0.0),
             executed_transaction_count: INTERNAL_TX_BATCH.len().try_into().unwrap(),
-            commitment_parts: None,
+            commitment_parts: Some(CommitmentParts::default()),
         })
     );
     assert!(receiver.next().await.is_none());
@@ -729,7 +730,7 @@ async fn oracle_fails_on_startup(#[case] l1_oracle_failure: bool) {
         ProposalPart::Fin(ProposalFin {
             proposal_commitment: ProposalCommitment(STATE_DIFF_COMMITMENT.0.0),
             executed_transaction_count: INTERNAL_TX_BATCH.len().try_into().unwrap(),
-            commitment_parts: None,
+            commitment_parts: Some(CommitmentParts::default()),
         })
     );
     assert!(receiver.next().await.is_none());
@@ -850,7 +851,7 @@ async fn oracle_fails_on_second_block(#[case] l1_oracle_failure: bool) {
         ProposalPart::Fin(ProposalFin {
             proposal_commitment: ProposalCommitment(STATE_DIFF_COMMITMENT.0.0),
             executed_transaction_count: INTERNAL_TX_BATCH.len().try_into().unwrap(),
-            commitment_parts: None,
+            commitment_parts: Some(CommitmentParts::default()),
         })
     );
     assert!(receiver.next().await.is_none());

crates/apollo_consensus_orchestrator/src/sequencer_consensus_context_test.rs

@@ -16,6 +16,7 @@ path = "src/bin/generate_protoc_output.rs"
 required-features = ["bin-deps"]
 
 [dependencies]
+apollo_batcher_types.workspace = true
 apollo_test_utils = { workspace = true, optional = true }
 asynchronous-codec.workspace = true
 bytes.workspace = true

crates/apollo_protobuf/Cargo.toml

@@ -168,7 +168,7 @@ pub struct TransactionBatch {
 
 /// Optional parts of a commitment carried in ProposalFin.
 // TODO(Asmaa): Send next_l2_gas_price_fri and l2_gas_used in a separate optional message.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, Default, PartialEq)]
 pub struct CommitmentParts {
     pub concatenated_counts: Felt,
     // None for the first block

crates/apollo_protobuf/src/consensus.rs

@@ -4,6 +4,7 @@ mod consensus_test;
 
 use std::convert::{TryFrom, TryInto};
 
+use apollo_batcher_types::batcher_types::FinishedProposalInfo;
 use prost::Message;
 use starknet_api::block::{BlockNumber, GasPrice, StarknetVersion};
 use starknet_api::consensus_transaction::ConsensusTransaction;
@@ -320,6 +321,22 @@ impl From<CommitmentParts> for protobuf::CommitmentParts {
     }
 }
 
+impl From<&FinishedProposalInfo> for CommitmentParts {
+    fn from(info: &FinishedProposalInfo) -> Self {
+        let commitments = &info.block_header_commitments;
+        CommitmentParts {
+            concatenated_counts: commitments.concatenated_counts,
+            parent_commitment: info
+                .parent_proposal_commitment
+                .as_ref()
+                .map(|p| ProposalCommitment(p.state_diff_commitment.0.0)),
+            transaction_commitment: commitments.transaction_commitment.0,
+            event_commitment: commitments.event_commitment.0,
+            receipt_commitment: commitments.receipt_commitment.0,
+        }
+    }
+}
+
 impl TryFrom<protobuf::ProposalFin> for ProposalFin {
     type Error = ProtobufConversionError;
     fn try_from(value: protobuf::ProposalFin) -> Result<Self, Self::Error> {