starknet_api: cache virtual_os_config_hash in OsConfigHash (#13310)

Author: meship-starkware

crates/blockifier/src/context.rs

@@ -1,5 +1,5 @@
 use std::collections::BTreeMap;
-use std::sync::Arc;
+use std::sync::{Arc, OnceLock};
 
 use apollo_config::dumping::{prepend_sub_config_name, ser_param, SerializeConfig};
 use apollo_config::{ParamPath, ParamPrivacyInput, SerializedParam};
@@ -14,6 +14,7 @@ use starknet_api::transaction::fields::{
     Tip,
     ValidResourceBounds,
 };
+use starknet_types_core::felt::Felt;
 
 use crate::blockifier_versioned_constants::VersionedConstants;
 use crate::bouncer::BouncerConfig;
@@ -121,6 +122,9 @@ pub struct BlockContext {
     pub(crate) chain_info: ChainInfo,
     pub(crate) versioned_constants: VersionedConstants,
     pub bouncer_config: BouncerConfig,
+    /// Cached on first access; derived from `chain_info`. Fixed for the lifetime of a block
+    /// context.
+    virtual_os_config_hash: OnceLock<Felt>,
 }
 
 impl BlockContext {
@@ -130,7 +134,13 @@ impl BlockContext {
         versioned_constants: VersionedConstants,
         bouncer_config: BouncerConfig,
     ) -> Self {
-        BlockContext { block_info, chain_info, versioned_constants, bouncer_config }
+        BlockContext {
+            block_info,
+            chain_info,
+            versioned_constants,
+            bouncer_config,
+            virtual_os_config_hash: OnceLock::new(),
+        }
     }
 
     pub fn block_info(&self) -> &BlockInfo {
@@ -145,6 +155,15 @@ impl BlockContext {
         &self.versioned_constants
     }
 
+    /// Returns the virtual OS config hash, computing and caching it on first access.
+    pub(crate) fn virtual_os_config_hash(&self) -> Felt {
+        *self.virtual_os_config_hash.get_or_init(|| {
+            OsChainInfo::from(&self.chain_info)
+                .compute_virtual_os_config_hash()
+                .expect("Failed to compute OS config hash")
+        })
+    }
+
     pub fn to_tx_context(
         &self,
         tx_info_creator: &impl TransactionInfoCreator,
@@ -179,6 +198,12 @@ impl BlockContext {
         }
     }
 
+    /// Returns a new context with the given chain info, resetting the cached config hash.
+    #[cfg(any(test, feature = "testing"))]
+    pub fn with_chain_info(self, chain_info: ChainInfo) -> Self {
+        Self::new(self.block_info, chain_info, self.versioned_constants, self.bouncer_config)
+    }
+
     /// Test util to allow overriding block gas limits.
     #[cfg(any(test, feature = "testing"))]
     pub fn set_sierra_gas_limits(

crates/blockifier/src/execution/deprecated_syscalls/deprecated_syscalls_test.rs

@@ -727,8 +727,7 @@ fn test_send_message_to_l1_invalid_address(#[values(true, false)] is_l3: bool) {
         ..trivial_external_entry_point_new(test_contract)
     };
 
-    let block_context =
-        BlockContext { chain_info: chain_info.clone(), ..BlockContext::create_for_testing() };
+    let block_context = BlockContext::create_for_testing().with_chain_info(chain_info.clone());
     let result = entry_point_call.execute_directly_given_block_context(&mut state, block_context);
 
     if is_l3 {

crates/blockifier/src/execution/syscalls/syscall_tests/send_message_to_l1.rs

@@ -114,8 +114,7 @@ fn test_send_message_to_l1_invalid_address(
         calldata,
         ..trivial_external_entry_point_new(test_contract)
     };
-    let block_context =
-        BlockContext { chain_info: chain_info.clone(), ..BlockContext::create_for_testing() };
+    let block_context = BlockContext::create_for_testing().with_chain_info(chain_info.clone());
     let result = entry_point_call.execute_directly_given_block_context(&mut state, block_context);
 
     if is_l3 {

crates/blockifier/src/test_utils/struct_impls.rs

@@ -193,41 +193,39 @@ impl ChainInfo {
 
 impl BlockContext {
     pub fn create_for_testing() -> Self {
-        Self {
-            block_info: BlockInfo::create_for_testing(),
-            chain_info: ChainInfo::create_for_testing(),
-            versioned_constants: VersionedConstants::create_for_testing(),
-            bouncer_config: BouncerConfig::max(),
-        }
+        Self::new(
+            BlockInfo::create_for_testing(),
+            ChainInfo::create_for_testing(),
+            VersionedConstants::create_for_testing(),
+            BouncerConfig::max(),
+        )
     }
 
     pub fn create_for_account_testing() -> Self {
-        Self {
-            block_info: BlockInfo::create_for_testing(),
-            chain_info: ChainInfo::create_for_testing(),
-            versioned_constants: VersionedConstants::create_for_account_testing(),
-            bouncer_config: BouncerConfig::max(),
-        }
+        Self::new(
+            BlockInfo::create_for_testing(),
+            ChainInfo::create_for_testing(),
+            VersionedConstants::create_for_account_testing(),
+            BouncerConfig::max(),
+        )
     }
 
     pub fn create_for_bouncer_testing(max_n_events_in_block: usize) -> Self {
-        Self {
-            bouncer_config: BouncerConfig {
-                block_max_capacity: BouncerWeights {
-                    n_events: max_n_events_in_block,
-                    ..BouncerWeights::max()
-                },
-                ..BouncerConfig::max()
+        let mut context = Self::create_for_account_testing();
+        context.bouncer_config = BouncerConfig {
+            block_max_capacity: BouncerWeights {
+                n_events: max_n_events_in_block,
+                ..BouncerWeights::max()
             },
-            ..Self::create_for_account_testing()
-        }
+            ..BouncerConfig::max()
+        };
+        context
     }
 
     pub fn create_for_account_testing_with_kzg(use_kzg_da: bool) -> Self {
-        Self {
-            block_info: BlockInfo::create_for_testing_with_kzg(use_kzg_da),
-            ..Self::create_for_account_testing()
-        }
+        let mut context = Self::create_for_account_testing();
+        context.block_info = BlockInfo::create_for_testing_with_kzg(use_kzg_da);
+        context
     }
 
     /// Returns a BlockContext for the given block index based on the base context.

crates/blockifier/src/test_utils/transfers_generator.rs

@@ -100,10 +100,8 @@ pub enum ExecutorWrapper {
 impl TransfersGenerator {
     pub fn new(config: TransfersGeneratorConfig) -> Self {
         let account_contract = FeatureContract::AccountWithoutValidations(config.cairo_version);
-        let block_context = BlockContext {
-            block_info: BlockInfo::create_for_testing_with_kzg(true),
-            ..BlockContext::create_for_account_testing()
-        };
+        let mut block_context = BlockContext::create_for_account_testing();
+        block_context.block_info = BlockInfo::create_for_testing_with_kzg(true);
         let resource_bounds = ValidResourceBounds::all_bounds_from_vectors(
             &GasVector {
                 l1_gas: 0_u32.into(),

crates/blockifier/src/transaction/account_transaction.rs

@@ -4,7 +4,7 @@ use starknet_api::abi::abi_utils::selector_from_name;
 use starknet_api::block::{BlockNumber, GasPriceVector};
 use starknet_api::calldata;
 use starknet_api::contract_class::EntryPointType;
-use starknet_api::core::{ContractAddress, EntryPointSelector, Nonce, OsChainInfo};
+use starknet_api::core::{ContractAddress, EntryPointSelector, Nonce};
 use starknet_api::data_availability::DataAvailabilityMode;
 use starknet_api::executable_transaction::{AccountTransaction as Transaction, TransactionType};
 use starknet_api::execution_resources::GasAmount;
@@ -330,11 +330,7 @@ impl AccountTransaction {
         Self::validate_proof_block_hash(proof_block_hash, proof_block_number, os_constants, state)?;
 
         // Validate the config hash.
-        let chain_info = &block_context.chain_info;
-        // TODO(Meshi): Cache this computation as part of the chain context.
-        let virtual_os_config_hash = OsChainInfo::from(chain_info)
-            .compute_virtual_os_config_hash()
-            .expect("Failed to compute OS config hash");
+        let virtual_os_config_hash = block_context.virtual_os_config_hash();
         let proof_config_hash = snos_proof_facts.config_hash;
         if virtual_os_config_hash != proof_config_hash {
             return Err(TransactionPreValidationError::InvalidProofFacts(format!(