starknet_os_runner: fetch base block data

Author: AvivYossef-starkware

Cargo.lock

@@ -106,9 +106,9 @@ impl Default for RetryConfig {
 
 #[derive(Clone)]
 pub struct RpcStateReader {
-    pub(crate) rpc_state_reader: GatewayRpcStateReader,
+    pub rpc_state_reader: GatewayRpcStateReader,
     pub(crate) retry_config: RetryConfig,
-    pub(crate) chain_id: ChainId,
+    pub chain_id: ChainId,
     #[allow(dead_code)]
     pub(crate) contract_class_mapping_dumper: Arc<Mutex<Option<StarknetContractClassMapping>>>,
 }

crates/blockifier_reexecution/src/state_reader/rpc_state_reader.rs

@@ -10,6 +10,7 @@ description = "Runs transactions through the Starknet OS and returns Cairo PIE a
 cairo_native = ["blockifier/cairo_native"]
 
 [dependencies]
+apollo_gateway.workspace = true
 async-trait.workspace = true
 blockifier.workspace = true
 blockifier_reexecution.workspace = true
@@ -18,6 +19,7 @@ cairo-lang-utils.workspace = true
 cairo-vm.workspace = true
 futures.workspace = true
 indexmap.workspace = true
+serde_json.workspace = true
 shared_execution_objects.workspace = true
 starknet-rust.workspace = true
 starknet-rust-core.workspace = true

crates/starknet_os_runner/Cargo.toml

@@ -1,3 +1,4 @@
+use apollo_gateway::errors::RPCStateReaderError;
 use blockifier::state::errors::StateError;
 use blockifier_reexecution::errors::ReexecutionError;
 use starknet_api::core::ClassHash;
@@ -10,12 +11,14 @@ pub enum VirtualBlockExecutorError {
     #[error(transparent)]
     // Boxed to reduce the size of Result on the stack (ReexecutionError is >128 bytes).
     ReexecutionError(#[from] Box<ReexecutionError>),
-
     #[error("Transaction execution failed: {0}")]
     TransactionExecutionError(String),
-
     #[error("Block state unavailable after execution")]
     StateUnavailable,
+    #[error(transparent)]
+    Serde(#[from] serde_json::Error),
+    #[error(transparent)]
+    Rpc(#[from] RPCStateReaderError),
 }
 
 #[derive(Debug, Error)]

crates/starknet_os_runner/src/errors.rs

@@ -33,6 +33,7 @@ pub struct VirtualOsBlockInput {
     pub tx_execution_infos: Vec<CentralTransactionExecutionInfo>,
     pub block_info: BlockInfo,
     pub initial_reads: StateMaps,
+    pub base_block_hash: BlockHash,
     pub prev_base_block_hash: BlockHash,
     pub compiled_classes: BTreeMap<CompiledClassHash, CasmContractClass>,
 }
@@ -64,7 +65,7 @@ impl From<VirtualOsBlockInput> for StarknetOsInput {
             block_info: virtual_os_block_input.block_info,
             initial_reads: virtual_os_block_input.initial_reads,
             declared_class_hash_to_component_hashes: HashMap::new(),
-            new_block_hash: BlockHash::default(),
+            new_block_hash: virtual_os_block_input.base_block_hash,
             old_block_number_and_hash: None,
             class_hashes_to_migrate: HashMap::new(),
         };
@@ -114,7 +115,7 @@ where
         )?;
 
         // Extract chain info from block context.
-        let chain_info = execution_data.block_context.chain_info();
+        let chain_info = execution_data.base_block_info.block_context.chain_info();
         let os_chain_info = OsChainInfo {
             chain_id: chain_info.chain_id.clone(),
             strk_fee_token_address: chain_info.fee_token_addresses.strk_fee_token_address,
@@ -148,9 +149,10 @@ where
                 .classes_trie_commitment_info,
             transactions: txs,
             tx_execution_infos,
-            block_info: execution_data.block_context.block_info().clone(),
+            block_info: execution_data.base_block_info.block_context.block_info().clone(),
             initial_reads: execution_data.initial_reads,
-            prev_base_block_hash: execution_data.prev_base_block_hash,
+            base_block_hash: execution_data.base_block_info.base_block_hash,
+            prev_base_block_hash: execution_data.base_block_info.prev_base_block_hash,
             compiled_classes: classes.compiled_classes,
         };
 

crates/starknet_os_runner/src/runner.rs

@@ -11,7 +11,7 @@ use starknet_types_core::felt::Felt;
 
 use crate::storage_proofs::{RpcStorageProofsProvider, StorageProofProvider};
 use crate::test_utils::{rpc_provider, STRK_TOKEN_ADDRESS};
-use crate::virtual_block_executor::VirtualBlockExecutionData;
+use crate::virtual_block_executor::{BaseBlockInfo, VirtualBlockExecutionData};
 
 /// Fixture: Creates initial reads with the STRK contract and storage slot 0.
 #[rstest::fixture]
@@ -44,10 +44,13 @@ fn test_get_storage_proofs_from_rpc(
 
     let execution_data = VirtualBlockExecutionData {
         execution_outputs: vec![],
-        block_context: BlockContext::create_for_account_testing(),
+        base_block_info: BaseBlockInfo {
+            block_context: BlockContext::create_for_account_testing(),
+            base_block_hash: BlockHash::default(),
+            prev_base_block_hash: BlockHash::default(),
+        },
         initial_reads: state_maps,
         executed_class_hashes: HashSet::new(),
-        prev_base_block_hash: BlockHash::default(),
     };
 
     let result = runtime.block_on(async {

crates/starknet_os_runner/src/storage_proofs_test.rs

@@ -1,10 +1,17 @@
 use std::collections::HashSet;
 
+use apollo_gateway::rpc_objects::{
+    BlockHeader,
+    BlockId as GatewayBlockId,
+    GetBlockWithTxHashesParams,
+};
 use blockifier::blockifier::config::TransactionExecutorConfig;
 use blockifier::blockifier::transaction_executor::{
     TransactionExecutionOutput,
     TransactionExecutor,
 };
+use blockifier::blockifier_versioned_constants::VersionedConstants;
+use blockifier::bouncer::BouncerConfig;
 use blockifier::context::BlockContext;
 use blockifier::state::cached_state::{CachedState, StateMaps};
 use blockifier::state::contract_class_manager::ContractClassManager;
@@ -14,29 +21,64 @@ use blockifier::state::state_reader_and_contract_manager::{
 };
 use blockifier::transaction::account_transaction::ExecutionFlags;
 use blockifier::transaction::transaction_execution::Transaction as BlockifierTransaction;
-use blockifier_reexecution::state_reader::reexecution_state_reader::ReexecutionStateReader;
 use blockifier_reexecution::state_reader::rpc_state_reader::RpcStateReader;
-use starknet_api::block::{BlockHash, BlockNumber};
+use blockifier_reexecution::utils::get_chain_info;
+use starknet_api::block::{BlockHash, BlockInfo, BlockNumber};
 use starknet_api::core::{ChainId, ClassHash};
 use starknet_api::transaction::fields::Fee;
 use starknet_api::transaction::{InvokeTransaction, Transaction, TransactionHash};
+use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
 
 use crate::errors::VirtualBlockExecutorError;
 
 /// Captures execution data for a virtual block (multiple transactions).
 ///
 /// This struct contains all the execution data needed for proof generation.
+pub struct BaseBlockInfo {
+    pub(crate) block_context: BlockContext,
+    /// The block hash of the base block,
+    /// in which the virtual block is executed.
+    pub(crate) base_block_hash: BlockHash,
+    /// The block hash of the previous base block.
+    /// Used to compute the base block hash in the os.
+    pub(crate) prev_base_block_hash: BlockHash,
+}
+
+impl TryFrom<(BlockHeader, ChainId)> for BaseBlockInfo {
+    type Error = VirtualBlockExecutorError;
+
+    fn try_from((header, chain_id): (BlockHeader, ChainId)) -> Result<Self, Self::Error> {
+        let base_block_hash = header.block_hash;
+        let prev_base_block_hash = header.parent_hash;
+
+        let block_info: BlockInfo = header.try_into()?;
+        let chain_info = get_chain_info(&chain_id);
+        let versioned_constants =
+            VersionedConstants::get(&block_info.starknet_version).map_err(|e| {
+                VirtualBlockExecutorError::TransactionExecutionError(format!(
+                    "Failed to get versioned constants: {e}"
+                ))
+            })?;
+        let block_context = BlockContext::new(
+            block_info,
+            chain_info,
+            versioned_constants.clone(),
+            BouncerConfig::default(),
+        );
+
+        Ok(BaseBlockInfo { block_context, base_block_hash, prev_base_block_hash })
+    }
+}
+
 pub struct VirtualBlockExecutionData {
     /// Execution outputs for all transactions in the virtual block.
     pub execution_outputs: Vec<TransactionExecutionOutput>,
-    /// The block context in which the transactions were executed.
-    pub block_context: BlockContext,
     /// The initial state reads (accessed state) during execution.
     pub initial_reads: StateMaps,
     /// The class hashes of all contracts executed in the virtual block.
     pub executed_class_hashes: HashSet<ClassHash>,
-    /// The block hash of the state at the start of the virtual block.
-    pub prev_base_block_hash: BlockHash,
+    /// The base block info for the virtual block.
+    pub base_block_info: BaseBlockInfo,
 }
 
 /// Executes a virtual block of transactions.
@@ -85,9 +127,8 @@ pub trait VirtualBlockExecutor {
         txs: Vec<(InvokeTransaction, TransactionHash)>,
     ) -> Result<VirtualBlockExecutionData, VirtualBlockExecutorError> {
         let blockifier_txs = self.convert_invoke_txs(txs)?;
-        let block_context = self.block_context(block_number)?;
+        let base_block_info = self.base_block_info(block_number)?;
         let state_reader = self.state_reader(block_number)?;
-        let prev_base_block_hash = self.prev_base_block_hash(block_number)?;
 
         // Create state reader with contract manager.
         let state_reader_and_contract_manager =
@@ -98,7 +139,7 @@ pub trait VirtualBlockExecutor {
         // Create executor WITHOUT preprocessing (no pre_process_block call).
         let mut transaction_executor = TransactionExecutor::new(
             block_state,
-            block_context.clone(),
+            base_block_info.block_context.clone(),
             TransactionExecutorConfig::default(),
         );
 
@@ -131,10 +172,9 @@ pub trait VirtualBlockExecutor {
 
         Ok(VirtualBlockExecutionData {
             execution_outputs,
-            block_context,
+            base_block_info,
             initial_reads,
             executed_class_hashes,
-            prev_base_block_hash,
         })
     }
 
@@ -169,17 +209,12 @@ pub trait VirtualBlockExecutor {
             })
             .collect()
     }
-    /// Returns the block context for the given block number.
-    fn block_context(
-        &self,
-        block_number: BlockNumber,
-    ) -> Result<BlockContext, VirtualBlockExecutorError>;
 
-    /// Returns the block hash of the state at the start of the virtual block.
-    fn prev_base_block_hash(
+    /// Returns the base block info for the given block number.
+    fn base_block_info(
         &self,
         block_number: BlockNumber,
-    ) -> Result<BlockHash, VirtualBlockExecutorError>;
+    ) -> Result<BaseBlockInfo, VirtualBlockExecutorError>;
 
     /// Returns a state reader that implements `FetchCompiledClasses` for the given block number.
     /// Must be `Send + Sync + 'static` to be used in the transaction executor.
@@ -194,6 +229,7 @@ pub trait VirtualBlockExecutor {
 
 #[allow(dead_code)]
 pub(crate) struct RpcVirtualBlockExecutor {
+    /// The state reader for the virtual block executor.
     pub rpc_state_reader: RpcStateReader,
     /// Whether transaction validation is enabled during execution.
     pub validate_txs: bool,
@@ -219,22 +255,19 @@ impl RpcVirtualBlockExecutor {
 /// without block preprocessing. Validation and fee charging are always skipped,
 /// making it suitable for simulation and OS input generation.
 impl VirtualBlockExecutor for RpcVirtualBlockExecutor {
-    fn block_context(
-        &self,
-        _block_number: BlockNumber,
-    ) -> Result<BlockContext, VirtualBlockExecutorError> {
-        self.rpc_state_reader
-            .get_block_context()
-            .map_err(|e| VirtualBlockExecutorError::ReexecutionError(Box::new(e)))
-    }
-
-    fn prev_base_block_hash(
+    fn base_block_info(
         &self,
         block_number: BlockNumber,
-    ) -> Result<BlockHash, VirtualBlockExecutorError> {
-        self.rpc_state_reader
-            .get_old_block_hash(block_number)
-            .map_err(|e| VirtualBlockExecutorError::ReexecutionError(Box::new(e)))
+    ) -> Result<BaseBlockInfo, VirtualBlockExecutorError> {
+        let get_block_params =
+            GetBlockWithTxHashesParams { block_id: GatewayBlockId::Number(block_number) };
+        let get_block_with_tx_hashes_result = self
+            .rpc_state_reader
+            .rpc_state_reader
+            .send_rpc_request("starknet_getBlockWithTxHashes", get_block_params)?;
+        let block_header: BlockHeader = serde_json::from_value(get_block_with_tx_hashes_result)?;
+
+        BaseBlockInfo::try_from((block_header, self.rpc_state_reader.chain_id.clone()))
     }
 
     fn state_reader(

crates/starknet_os_runner/src/virtual_block_executor.rs

@@ -124,7 +124,7 @@ fn test_execute_constructed_balance_of_transaction(
 
     // Verify block context was captured.
     assert_eq!(
-        result.block_context.block_info().block_number,
+        result.base_block_info.block_context.block_info().block_number,
         BlockNumber(TEST_BLOCK_NUMBER),
         "Block context should have the correct block number"
     );