fix(starknet_batcher): change block full condition in block builder

crates/starknet_batcher/src/block_builder.rs

@@ -232,6 +232,22 @@ async fn collect_execution_results_and_stream_txs(
     output_content_sender: &Option<tokio::sync::mpsc::UnboundedSender<Transaction>>,
     fail_on_err: bool,
 ) -> BlockBuilderResult<bool> {
+    assert!(
+        results.len() <= tx_chunk.len(),
+        "The number of results should be less than or equal to the number of transactions."
+    );
+    let mut block_is_full = false;
+    // If the block is full, we won't get an error from the executor. We will just get only the
+    // results of the transactions that were executed before the block was full.
+    // see [TransactionExecutor::execute_txs].
+    if results.len() < tx_chunk.len() {
+        info!("Block is full.");
+        if fail_on_err {
+            return Err(BlockBuilderError::FailOnError(FailOnErrorCause::BlockFull));
+        } else {
+            block_is_full = true;
+        }
+    }
     for (input_tx, result) in tx_chunk.into_iter().zip(results.into_iter()) {
         match result {
             Ok(tx_execution_info) => {
@@ -245,13 +261,6 @@ async fn collect_execution_results_and_stream_txs(
             }
             // TODO(yael 18/9/2024): add timeout error handling here once this
             // feature is added.
-            Err(BlockifierTransactionExecutorError::BlockFull) => {
-                info!("Block is full");
-                if fail_on_err {
-                    return Err(BlockBuilderError::FailOnError(FailOnErrorCause::BlockFull));
-                }
-                return Ok(true);
-            }
             Err(err) => {
                 debug!("Transaction {:?} failed with error: {}.", input_tx, err);
                 if fail_on_err {
@@ -263,7 +272,7 @@ async fn collect_execution_results_and_stream_txs(
             }
         }
     }
-    Ok(false)
+    Ok(block_is_full)
 }
 
 pub struct BlockMetadata {

crates/starknet_batcher/src/block_builder_test.rs

@@ -167,11 +167,14 @@ fn empty_block_test_expectations() -> TestExpectations {
 fn mock_transaction_executor_block_full(input_txs: &[Transaction]) -> MockTransactionExecutorTrait {
     let input_txs_cloned = input_txs.to_vec();
     let mut mock_transaction_executor = MockTransactionExecutorTrait::new();
+    let execution_results = vec![Ok(execution_info())];
+    // When the block is full, the executor will return less results than the number of input txs.
+    assert!(input_txs.len() > execution_results.len());
     mock_transaction_executor
         .expect_add_txs_to_block()
         .times(1)
         .withf(move |blockifier_input| compare_tx_hashes(&input_txs_cloned, blockifier_input))
-        .return_once(move |_| vec![Ok(execution_info()), Err(TransactionExecutorError::BlockFull)]);
+        .return_once(move |_| execution_results);
     mock_transaction_executor
 }