From b445c223b39ea8330e0b20b9b1c16d2bcfe6741e Mon Sep 17 00:00:00 2001 From: Aviv Greenburg Date: Mon, 20 Jan 2025 19:31:17 +0200 Subject: [PATCH] chore(blockifier): fn execute_txs_sequentially return state_diff + change privacy pub fn to fn --- .../src/blockifier/transaction_executor.rs | 30 ++++++++++++------- .../blockifier/transaction_executor_test.rs | 2 +- crates/blockifier/src/state/cached_state.rs | 10 +++++++ .../src/py_block_executor.rs | 2 +- 4 files changed, 31 insertions(+), 13 deletions(-) diff --git a/crates/blockifier/src/blockifier/transaction_executor.rs b/crates/blockifier/src/blockifier/transaction_executor.rs index 5ee21ac558a..0dce93805a6 100644 --- a/crates/blockifier/src/blockifier/transaction_executor.rs +++ b/crates/blockifier/src/blockifier/transaction_executor.rs @@ -11,7 +11,7 @@ use crate::blockifier::config::TransactionExecutorConfig; use crate::bouncer::{Bouncer, BouncerWeights}; use crate::concurrency::worker_logic::WorkerExecutor; use crate::context::BlockContext; -use crate::state::cached_state::{CachedState, CommitmentStateDiff, TransactionalState}; +use crate::state::cached_state::{CachedState, CommitmentStateDiff, StateMaps, TransactionalState}; use crate::state::errors::StateError; use crate::state::state_api::{StateReader, StateResult}; use crate::state::stateful_compression::{allocate_aliases_in_storage, compress, CompressionError}; @@ -27,6 +27,8 @@ pub mod transaction_executor_test; pub const BLOCK_STATE_ACCESS_ERR: &str = "Error: The block state should be `Some`."; pub const DEFAULT_STACK_SIZE: usize = 60 * 1024 * 1024; +pub type TransactionExecutionOutput = (TransactionExecutionInfo, StateMaps); + #[derive(Debug, Error)] pub enum TransactionExecutorError { #[error("Transaction cannot be added to the current block, block capacity reached.")] @@ -103,7 +105,7 @@ impl TransactionExecutor { pub fn execute( &mut self, tx: &Transaction, - ) -> TransactionExecutorResult { + ) -> TransactionExecutorResult { let mut transactional_state = TransactionalState::create_transactional( self.block_state.as_mut().expect(BLOCK_STATE_ACCESS_ERR), ); @@ -114,8 +116,8 @@ impl TransactionExecutor { tx.execute_raw(&mut transactional_state, &self.block_context, concurrency_mode); match tx_execution_result { Ok(tx_execution_info) => { - let tx_state_changes_keys = - transactional_state.get_actual_state_changes()?.state_maps.into_keys(); + let state_diff = transactional_state.to_state_diff()?.state_maps; + let tx_state_changes_keys = state_diff.keys(); self.bouncer.try_update( &transactional_state, &tx_state_changes_keys, @@ -123,7 +125,8 @@ impl TransactionExecutor { &tx_execution_info.receipt.resources, )?; transactional_state.commit(); - Ok(tx_execution_info) + + Ok((tx_execution_info, state_diff)) } Err(error) => { transactional_state.abort(); @@ -132,14 +135,16 @@ impl TransactionExecutor { } } - pub fn execute_txs_sequentially_inner( + fn execute_txs_sequentially_inner( &mut self, txs: &[Transaction], - ) -> Vec> { + ) -> Vec> { let mut results = Vec::new(); for tx in txs { match self.execute(tx) { - Ok(tx_execution_info) => results.push(Ok(tx_execution_info)), + Ok((tx_execution_info, state_diff)) => { + results.push(Ok((tx_execution_info, state_diff))) + } Err(TransactionExecutorError::BlockFull) => break, Err(error) => results.push(Err(error)), } @@ -196,6 +201,9 @@ impl TransactionExecutor { if !self.config.concurrency_config.enabled { log::debug!("Executing transactions sequentially."); self.execute_txs_sequentially(txs) + .into_iter() + .map(|res| res.map(|(tx_execution_info, _state_diff)| tx_execution_info)) + .collect() } else { log::debug!("Executing transactions concurrently."); let chunk_size = self.config.concurrency_config.chunk_size; @@ -228,10 +236,10 @@ impl TransactionExecutor { } } - pub fn execute_txs_sequentially( + fn execute_txs_sequentially( &mut self, txs: &[Transaction], - ) -> Vec> { + ) -> Vec> { #[cfg(not(feature = "cairo_native"))] return self.execute_txs_sequentially_inner(txs); #[cfg(feature = "cairo_native")] @@ -261,7 +269,7 @@ impl TransactionExecutor { } } - pub fn execute_chunk( + fn execute_chunk( &mut self, chunk: &[Transaction], ) -> Vec> { diff --git a/crates/blockifier/src/blockifier/transaction_executor_test.rs b/crates/blockifier/src/blockifier/transaction_executor_test.rs index 276d79ec7ef..f5b9309ec3f 100644 --- a/crates/blockifier/src/blockifier/transaction_executor_test.rs +++ b/crates/blockifier/src/blockifier/transaction_executor_test.rs @@ -59,7 +59,7 @@ fn tx_executor_test_body( // TODO(Arni, 30/03/2024): Consider adding a test for the transaction execution info. If A test // should not be added, rename the test to `test_bouncer_info`. // TODO(Arni, 30/03/2024): Test all bouncer weights. - let _tx_execution_info = tx_executor.execute(&tx).unwrap(); + let _tx_execution_output = tx_executor.execute(&tx).unwrap(); let bouncer_weights = tx_executor.bouncer.get_accumulated_weights(); assert_eq!(bouncer_weights.state_diff_size, expected_bouncer_weights.state_diff_size); assert_eq!( diff --git a/crates/blockifier/src/state/cached_state.rs b/crates/blockifier/src/state/cached_state.rs index 5fc582edc47..2cbee140b28 100644 --- a/crates/blockifier/src/state/cached_state.rs +++ b/crates/blockifier/src/state/cached_state.rs @@ -364,6 +364,16 @@ impl StateMaps { compiled_class_hash_keys: self.compiled_class_hashes.into_keys().collect(), } } + + pub fn keys(&self) -> StateChangesKeys { + StateChangesKeys { + modified_contracts: self.get_contract_addresses(), + nonce_keys: self.nonces.keys().cloned().collect(), + class_hash_keys: self.class_hashes.keys().cloned().collect(), + storage_keys: self.storage.keys().cloned().collect(), + compiled_class_hash_keys: self.compiled_class_hashes.keys().cloned().collect(), + } + } } /// Caches read and write requests. /// The tracked changes are needed for block state commitment. diff --git a/crates/native_blockifier/src/py_block_executor.rs b/crates/native_blockifier/src/py_block_executor.rs index 9b50a8480d6..3e2ae4e40df 100644 --- a/crates/native_blockifier/src/py_block_executor.rs +++ b/crates/native_blockifier/src/py_block_executor.rs @@ -197,7 +197,7 @@ impl PyBlockExecutor { optional_py_class_info: Option, ) -> NativeBlockifierResult> { let tx: Transaction = py_tx(tx, optional_py_class_info).expect(PY_TX_PARSING_ERR); - let tx_execution_info = self.tx_executor().execute(&tx)?; + let (tx_execution_info, _state_diff) = self.tx_executor().execute(&tx)?; let thin_tx_execution_info = ThinTransactionExecutionInfo::from_tx_execution_info(tx_execution_info);