Merge branch 'starkware-libs:main' into main

Author: FrancoGiachetta

Cargo.lock

@@ -159,6 +159,11 @@
     "pointer_target": "chain_id",
     "privacy": "Public"
   },
+  "context.constant_l2_gas_price": {
+    "description": "If true, sets STRK gas price to its minimum price from the versioned constants.",
+    "privacy": "Public",
+    "value": false
+  },
   "context.l1_da_mode": {
     "description": "The data availability mode, true: Blob, false: Calldata.",
     "privacy": "Public",

config/papyrus/default_config.json

@@ -67,6 +67,7 @@ use crate::metrics::{
     LAST_SYNCED_BLOCK,
     REJECTED_TRANSACTIONS,
     REVERTED_BLOCKS,
+    REVERTED_TRANSACTIONS,
     STORAGE_HEIGHT,
     SYNCED_TRANSACTIONS,
 };
@@ -572,6 +573,15 @@ impl Batcher {
         let n_rejected_txs =
             u64::try_from(block_execution_artifacts.execution_data.rejected_tx_hashes.len())
                 .expect("Number of rejected transactions should fit in u64");
+        let n_reverted_count = u64::try_from(
+            block_execution_artifacts
+                .execution_data
+                .execution_infos
+                .values()
+                .filter(|info| info.revert_error.is_some())
+                .count(),
+        )
+        .expect("Number of reverted transactions should fit in u64");
         self.commit_proposal_and_block(
             height,
             state_diff.clone(),
@@ -585,6 +595,7 @@ impl Batcher {
         LAST_BATCHED_BLOCK.set_lossy(height.0);
         BATCHED_TRANSACTIONS.increment(n_txs);
         REJECTED_TRANSACTIONS.increment(n_rejected_txs);
+        REVERTED_TRANSACTIONS.increment(n_reverted_count);
 
         Ok(DecisionReachedResponse {
             state_diff,

crates/apollo_batcher/src/batcher.rs

@@ -64,6 +64,7 @@ use crate::metrics::{
     PROPOSAL_SUCCEEDED,
     REJECTED_TRANSACTIONS,
     REVERTED_BLOCKS,
+    REVERTED_TRANSACTIONS,
     STORAGE_HEIGHT,
     SYNCED_TRANSACTIONS,
 };
@@ -525,10 +526,10 @@ async fn send_content_to_unknown_proposal(#[case] content: SendProposalContent)
 }
 
 #[rstest]
-#[case::send_txs(SendProposalContent::Txs(test_txs(0..1)), ProposalStatus::InvalidProposal)]
+#[case::send_txs(SendProposalContent::Txs(test_txs(0..1)), ProposalStatus::InvalidProposal("Block is full".to_string()))]
 #[case::send_finish(
     SendProposalContent::Finish(DUMMY_FINAL_N_EXECUTED_TXS),
-    ProposalStatus::InvalidProposal
+    ProposalStatus::InvalidProposal("Block is full".to_string())
 )]
 #[case::send_abort(SendProposalContent::Abort, ProposalStatus::Aborted)]
 #[tokio::test]
@@ -1046,6 +1047,17 @@ async fn decision_reached() {
         REJECTED_TRANSACTIONS.parse_numeric_metric::<usize>(&metrics),
         Some(expected_artifacts.execution_data.rejected_tx_hashes.len())
     );
+    assert_eq!(
+        REVERTED_TRANSACTIONS.parse_numeric_metric::<usize>(&metrics),
+        Some(
+            expected_artifacts
+                .execution_data
+                .execution_infos
+                .values()
+                .filter(|info| info.revert_error.is_some())
+                .count(),
+        )
+    );
 }
 
 #[rstest]

crates/apollo_batcher/src/batcher_test.rs

@@ -365,6 +365,7 @@ impl BlockBuilder {
             Err(e @ TransactionProviderError::L1HandlerTransactionValidationFailed { .. })
                 if self.execution_params.is_validator =>
             {
+                warn!("Failed to validate L1 Handler transaction: {:?}", e);
                 return Err(BlockBuilderError::FailOnError(L1HandlerTransactionValidationFailed(
                     e,
                 )));

crates/apollo_batcher/src/block_builder.rs

@@ -17,6 +17,7 @@ define_metrics!(
         // Transactions
         MetricCounter { BATCHED_TRANSACTIONS, "batcher_batched_transactions", "Counter of batched transactions across all forks", init = 0 },
         MetricCounter { REJECTED_TRANSACTIONS, "batcher_rejected_transactions", "Counter of rejected transactions", init = 0 },
+        MetricCounter { REVERTED_TRANSACTIONS, "batcher_reverted_transactions", "Counter of reverted transactions across all forks", init = 0 },
         MetricCounter { SYNCED_TRANSACTIONS, "batcher_synced_transactions", "Counter of synced transactions", init = 0 },
 
         MetricCounter { FULL_BLOCKS, "batcher_full_blocks", "Counter of blocks closed on full capacity", init = 0 },
@@ -39,6 +40,7 @@ pub fn register_metrics(storage_height: BlockNumber) {
 
     BATCHED_TRANSACTIONS.register();
     REJECTED_TRANSACTIONS.register();
+    REVERTED_TRANSACTIONS.register();
     SYNCED_TRANSACTIONS.register();
 
     FULL_BLOCKS.register();

crates/apollo_batcher/src/metrics.rs

@@ -13,12 +13,13 @@ use indexmap::map::Entry;
 use indexmap::IndexMap;
 #[cfg(test)]
 use mockall::automock;
+use reqwest::StatusCode;
 use serde::{Deserialize, Serialize};
 use starknet_api::block::BlockNumber;
 use starknet_api::consensus_transaction::InternalConsensusTransaction;
 use starknet_api::transaction::TransactionHash;
 use thiserror::Error;
-use tracing::info;
+use tracing::{error, info};
 
 use crate::cende_client_types::{
     CendeBlockMetadata,
@@ -146,7 +147,7 @@ impl PreconfirmedBlockWriterTrait for PreconfirmedBlockWriter {
         // We initially mark that we have pending changes so that the client will write to the
         // Cende recorder that a new proposal round has started.
         let mut pending_changes = true;
-        let mut write_iteration: u64 = 0;
+        let mut next_write_iteration = 0;
 
         loop {
             tokio::select! {
@@ -156,15 +157,22 @@ impl PreconfirmedBlockWriterTrait for PreconfirmedBlockWriter {
                         // TODO(noamsp): Extract to a function.
                         let pre_confirmed_block = self.create_pre_confirmed_block(
                             &transactions_map,
-                            write_iteration,
+                            next_write_iteration,
                         );
                         pending_tasks.push(self.cende_client.write_pre_confirmed_block(pre_confirmed_block));
-                        write_iteration += 1;
+                        next_write_iteration += 1;
                         pending_changes = false;
                     }
                 }
-                // TODO(noamsp): Handle height/round mismatch by immediately exiting the loop; All the other writes will be rejected as well.
-                Some(_) = pending_tasks.next() => {}
+
+                Some(result) = pending_tasks.next() => {
+                    if let Err(error) = result {
+                        if is_round_mismatch_error(&error, next_write_iteration) {
+                            pending_tasks.clear();
+                            return Err(error.into());
+                        }
+                    }
+                }
                 msg = self.pre_confirmed_tx_receiver.recv() => {
                     match msg {
                         Some((tx, tx_receipt, tx_state_diff)) => {
@@ -205,19 +213,53 @@ impl PreconfirmedBlockWriterTrait for PreconfirmedBlockWriter {
 
         if pending_changes {
             let pre_confirmed_block =
-                self.create_pre_confirmed_block(&transactions_map, write_iteration);
+                self.create_pre_confirmed_block(&transactions_map, next_write_iteration);
             self.cende_client.write_pre_confirmed_block(pre_confirmed_block).await?
         }
 
         // Wait for all pending tasks to complete gracefully.
-        // TODO(noamsp): Add error handling and timeout.
-        while pending_tasks.next().await.is_some() {}
+        // TODO(noamsp): Add timeout.
+        while let Some(result) = pending_tasks.next().await {
+            if let Err(error) = result {
+                if is_round_mismatch_error(&error, next_write_iteration) {
+                    pending_tasks.clear();
+                    return Err(error.into());
+                }
+            }
+        }
         info!("Pre confirmed block writer finished");
 
         Ok(())
     }
 }
 
+fn is_round_mismatch_error(
+    error: &PreconfirmedCendeClientError,
+    next_write_iteration: u64,
+) -> bool {
+    let PreconfirmedCendeClientError::CendeRecorderError {
+        block_number,
+        round,
+        write_iteration,
+        status_code,
+    } = error
+    else {
+        return false;
+    };
+
+    // A bad request status indicates a round or write iteration mismatch. The latest request can
+    // receive a bad request status only if it is due to a round mismatch.
+    if *status_code == StatusCode::BAD_REQUEST && *write_iteration == next_write_iteration - 1 {
+        error!(
+            "A higher round was detected for block_number: {}. rejected round: {}. Stopping \
+             pre-confirmed block writer.",
+            block_number, round,
+        );
+        return true;
+    }
+    false
+}
+
 #[derive(Serialize, Deserialize, Clone, PartialEq, Debug, Copy)]
 pub struct PreconfirmedBlockWriterConfig {
     pub channel_buffer_capacity: usize,

crates/apollo_batcher/src/pre_confirmed_block_writer.rs

@@ -4,7 +4,7 @@ use apollo_batcher_types::batcher_types::Round;
 use apollo_config::dumping::{ser_param, SerializeConfig};
 use apollo_config::{ParamPath, ParamPrivacyInput, SerializedParam};
 use async_trait::async_trait;
-use reqwest::Client;
+use reqwest::{Client, StatusCode};
 use serde::{Deserialize, Serialize};
 use starknet_api::block::BlockNumber;
 use thiserror::Error;
@@ -15,12 +15,19 @@ use crate::cende_client_types::CendePreconfirmedBlock;
 use crate::metrics::PRECONFIRMED_BLOCK_WRITTEN;
 
 #[derive(Debug, Error)]
-// TODO(noamsp): add block number/round mismatch and handle it in the client implementation.
 pub enum PreconfirmedCendeClientError {
     #[error(transparent)]
     RequestError(#[from] reqwest::Error),
-    #[error("CendeRecorder returned an error: {0}")]
-    CendeRecorderError(String),
+    #[error(
+        "Cende recorder returned an error. block_number: {block_number}, round: {round}, \
+         write_iteration: {write_iteration}, status_code: {status_code}."
+    )]
+    CendeRecorderError {
+        block_number: BlockNumber,
+        round: Round,
+        write_iteration: u64,
+        status_code: StatusCode,
+    },
 }
 
 pub type PreconfirmedCendeClientResult<T> = Result<T, PreconfirmedCendeClientError>;
@@ -101,13 +108,15 @@ impl PreconfirmedCendeClientTrait for PreconfirmedCendeClient {
         let block_number = pre_confirmed_block.block_number;
         let round = pre_confirmed_block.round;
         let write_iteration = pre_confirmed_block.write_iteration;
+        let number_of_txs = pre_confirmed_block.pre_confirmed_block.transactions.len();
 
         let request_builder =
             self.client.post(self.write_pre_confirmed_block_url.clone()).json(&pre_confirmed_block);
 
         trace!(
             "Sending write_pre_confirmed_block request to Cende recorder. \
-             block_number={block_number}, round={round}, write_iteration={write_iteration}",
+             block_number={block_number}, round={round}, write_iteration={write_iteration}. The \
+             block contains {number_of_txs} transactions.",
         );
 
         let response = request_builder.send().await?;
@@ -121,12 +130,17 @@ impl PreconfirmedCendeClientTrait for PreconfirmedCendeClient {
             PRECONFIRMED_BLOCK_WRITTEN.increment(1);
             Ok(())
         } else {
-            let error_msg = format!(
+            warn!(
                 "write_pre_confirmed_block request failed. block_number={block_number}, \
                  round={round}, write_iteration={write_iteration}, status={response_status}",
             );
-            warn!("{error_msg}");
-            Err(PreconfirmedCendeClientError::CendeRecorderError(error_msg))
+
+            return Err(PreconfirmedCendeClientError::CendeRecorderError {
+                block_number,
+                round,
+                write_iteration,
+                status_code: response_status,
+            });
         }
     }
 }