blockifier_reexecution: impl FetchedCompiledClass for test and offline state readers

Author: Yonatan-Starkware

Cargo.lock

@@ -32,8 +32,8 @@ pub enum StateError {
     /// Represents all unexpected errors that may occur while reading from state.
     #[error("Failed to read from state: {0}.")]
     StateReadError(String),
-    #[error("Missing Sierra class for CASM class with hash {:#066x}.", **.0)]
-    MissingSierra(ClassHash),
+    #[error("Missing Sierra class.")]
+    MissingSierra(),
     #[error("Missing compiled class hash v2 for class with hash {:#064x}.", **.0)]
     MissingCompiledClassHashV2(ClassHash),
 }

crates/blockifier/src/state/errors.rs

@@ -1,11 +1,13 @@
 use std::sync::Arc;
 
 use starknet_api::class_cache::GlobalContractCache;
+use starknet_api::contract_class::ContractClass;
 use starknet_api::state::SierraContractClass;
 
 use crate::execution::contract_class::{CompiledClassV0, CompiledClassV1, RunnableCompiledClass};
 #[cfg(feature = "cairo_native")]
 use crate::execution::native::contract_class::NativeCompiledClassV1;
+use crate::state::state_api::StateResult;
 
 pub const GLOBAL_CONTRACT_CACHE_SIZE_FOR_TEST: usize = 600;
 
@@ -36,6 +38,30 @@ impl CompiledClasses {
             },
         }
     }
+
+    /// Converts a [`starknet_api::contract_class::ContractClass`] into the corresponding
+    /// [`CompiledClasses`].
+    ///
+    /// For `V1` (Cairo 1) classes, a matching `SierraContractClass` must be provided.
+    /// For `V0` classes, this argument should be `None`.
+    pub fn from_contract_class(
+        contract_class: &ContractClass,
+        sierra_contract_class: Option<SierraContractClass>,
+    ) -> StateResult<CompiledClasses> {
+        match contract_class {
+            ContractClass::V0(deprecated_class) => {
+                Ok(CompiledClasses::V0(CompiledClassV0::try_from(deprecated_class.clone())?))
+            }
+            ContractClass::V1(versioned_casm) => {
+                let sierra_contract_class =
+                    sierra_contract_class.expect("V1 contract class requires Sierra class");
+                Ok(CompiledClasses::V1(
+                    CompiledClassV1::try_from(versioned_casm.clone())?,
+                    Arc::new(sierra_contract_class.clone()),
+                ))
+            }
+        }
+    }
 }
 
 pub type RawClassCache = GlobalContractCache<CompiledClasses>;

crates/blockifier/src/state/global_cache.rs

@@ -9,7 +9,9 @@ use blockifier::context::BlockContext;
 use blockifier::execution::contract_class::RunnableCompiledClass;
 use blockifier::state::cached_state::{CommitmentStateDiff, StateMaps};
 use blockifier::state::errors::StateError;
+use blockifier::state::global_cache::CompiledClasses;
 use blockifier::state::state_api::{StateReader, StateResult};
+use blockifier::state::state_reader_and_contract_manager::FetchCompiledClasses;
 use blockifier::transaction::transaction_execution::Transaction as BlockifierTransaction;
 use serde::{Deserialize, Serialize};
 use starknet_api::block::{BlockHash, BlockHashAndNumber, BlockInfo, BlockNumber, StarknetVersion};
@@ -191,6 +193,17 @@ impl ReexecutionStateReader for OfflineStateReader {
     }
 }
 
+impl FetchCompiledClasses for OfflineStateReader {
+    fn get_compiled_classes(&self, class_hash: ClassHash) -> StateResult<CompiledClasses> {
+        let contract_class = self.get_contract_class(&class_hash)?;
+        self.starknet_core_contract_class_to_compiled_classes(&contract_class)
+    }
+
+    fn is_declared(&self, class_hash: ClassHash) -> StateResult<bool> {
+        self.is_contract_class_declared(class_hash)
+    }
+}
+
 impl OfflineStateReader {
     pub fn get_transaction_executor(
         self,

crates/blockifier_reexecution/src/state_reader/offline_state_reader.rs

@@ -2,12 +2,15 @@ use apollo_rpc_execution::DEPRECATED_CONTRACT_SIERRA_SIZE;
 use blockifier::blockifier::config::TransactionExecutorConfig;
 use blockifier::blockifier::transaction_executor::TransactionExecutor;
 use blockifier::state::cached_state::CommitmentStateDiff;
+use blockifier::state::errors::StateError;
+use blockifier::state::global_cache::CompiledClasses;
 use blockifier::state::state_api::{StateReader, StateResult};
 use blockifier::transaction::account_transaction::ExecutionFlags;
 use blockifier::transaction::transaction_execution::Transaction as BlockifierTransaction;
 use starknet_api::block::{BlockHash, BlockNumber};
 use starknet_api::contract_class::{ClassInfo, SierraVersion};
 use starknet_api::core::ClassHash;
+use starknet_api::state::SierraContractClass;
 use starknet_api::test_utils::MAX_FEE;
 use starknet_api::transaction::{Transaction, TransactionHash};
 use starknet_core::types::ContractClass as StarknetContractClass;
@@ -92,6 +95,34 @@ pub trait ReexecutionStateReader {
     }
 
     fn get_old_block_hash(&self, old_block_number: BlockNumber) -> ReexecutionResult<BlockHash>;
+
+    fn is_contract_class_declared(&self, class_hash: ClassHash) -> StateResult<bool> {
+        match self.get_contract_class(&class_hash) {
+            Err(StateError::UndeclaredClassHash(_)) => Ok(false),
+            Err(err) => Err(err),
+            Ok(contract_class) => Ok(matches!(contract_class, StarknetContractClass::Sierra(_))),
+        }
+    }
+
+    /// Converts a `starknet_core::types::ContractClass` to `CompiledClasses`.
+    fn starknet_core_contract_class_to_compiled_classes(
+        &self,
+        contract_class: &StarknetContractClass,
+    ) -> StateResult<CompiledClasses> {
+        match contract_class {
+            StarknetContractClass::Sierra(flat_sierra) => {
+                let (class_v1, _) = sierra_to_versioned_contract_class_v1(flat_sierra.clone())?;
+                let sierra = SierraContractClass::from(flat_sierra.clone());
+
+                Ok(CompiledClasses::from_contract_class(&class_v1, Some(sierra))?)
+            }
+            StarknetContractClass::Legacy(legacy) => {
+                let class_v0 = legacy_to_contract_class_v0(legacy.clone())?;
+
+                Ok(CompiledClasses::from_contract_class(&class_v0, None)?)
+            }
+        }
+    }
 }
 
 /// Trait of the functions \ queries required for reexecution.

crates/blockifier_reexecution/src/state_reader/reexecution_state_reader.rs

@@ -15,7 +15,9 @@ use blockifier::context::BlockContext;
 use blockifier::execution::contract_class::RunnableCompiledClass;
 use blockifier::state::cached_state::CommitmentStateDiff;
 use blockifier::state::errors::StateError;
+use blockifier::state::global_cache::CompiledClasses;
 use blockifier::state::state_api::{StateReader, StateResult};
+use blockifier::state::state_reader_and_contract_manager::FetchCompiledClasses;
 use blockifier::transaction::transaction_execution::Transaction as BlockifierTransaction;
 use serde::Serialize;
 use serde_json::{json, to_value};
@@ -152,6 +154,19 @@ impl StateReader for TestStateReader {
     }
 }
 
+impl FetchCompiledClasses for TestStateReader {
+    fn get_compiled_classes(&self, class_hash: ClassHash) -> StateResult<CompiledClasses> {
+        let contract_class =
+            retry_request!(self.retry_config, || self.get_contract_class(&class_hash))?;
+
+        self.starknet_core_contract_class_to_compiled_classes(&contract_class)
+    }
+
+    fn is_declared(&self, class_hash: ClassHash) -> StateResult<bool> {
+        self.is_contract_class_declared(class_hash)
+    }
+}
+
 impl TestStateReader {
     pub fn new(
         config: &RpcStateReaderConfig,

crates/blockifier_reexecution/src/state_reader/test_state_reader.rs

@@ -32,6 +32,7 @@ semver.workspace = true
 serde = { workspace = true, features = ["derive", "rc"] }
 serde_json.workspace = true
 sha3.workspace = true
+starknet-core.workspace = true
 starknet-crypto.workspace = true
 starknet-types-core = { workspace = true, features = ["hash"] }
 strum = { workspace = true, features = ["derive"] }

crates/starknet_api/Cargo.toml

@@ -7,6 +7,7 @@ use std::collections::HashMap;
 use apollo_sizeof::SizeOf;
 use cairo_lang_starknet_classes::contract_class::ContractEntryPoints as CairoLangContractEntryPoints;
 use serde::{Deserialize, Serialize};
+use starknet_core::types::EntryPointsByType as StarknetCoreEntryPointsByType;
 use strum::EnumVariantNames;
 use strum_macros::{EnumDiscriminants, EnumIter, IntoStaticStr};
 
@@ -680,6 +681,16 @@ impl From<CairoLangContractEntryPoints> for EntryPointByType {
     }
 }
 
+impl From<StarknetCoreEntryPointsByType> for EntryPointByType {
+    fn from(value: StarknetCoreEntryPointsByType) -> Self {
+        Self {
+            constructor: value.constructor.into_iter().map(EntryPoint::from).collect(),
+            external: value.external.into_iter().map(EntryPoint::from).collect(),
+            l1handler: value.l1_handler.into_iter().map(EntryPoint::from).collect(),
+        }
+    }
+}
+
 impl EntryPointByType {
     pub fn from_hash_map(entry_points_by_type: HashMap<EntryPointType, Vec<EntryPoint>>) -> Self {
         macro_rules! get_entrypoint_by_type {

crates/starknet_api/src/rpc_transaction.rs

@@ -9,6 +9,7 @@ use cairo_lang_starknet_classes::contract_class::ContractEntryPoint as CairoLang
 use indexmap::IndexMap;
 use serde::{Deserialize, Serialize};
 use sha3::Digest;
+use starknet_core::types::{FlattenedSierraClass, SierraEntryPoint};
 use starknet_types_core::felt::Felt;
 use starknet_types_core::hash::{Poseidon, StarkHash as SNTypsCoreStarkHash};
 
@@ -270,6 +271,17 @@ impl SierraContractClass {
     }
 }
 
+impl From<FlattenedSierraClass> for SierraContractClass {
+    fn from(flattened_sierra: FlattenedSierraClass) -> Self {
+        Self {
+            sierra_program: flattened_sierra.sierra_program,
+            contract_class_version: flattened_sierra.contract_class_version,
+            entry_points_by_type: flattened_sierra.entry_points_by_type.into(),
+            abi: flattened_sierra.abi,
+        }
+    }
+}
+
 #[derive(Clone, Debug, Deserialize)]
 pub struct ContractClassComponentHashes {
     contract_class_version: Felt,
@@ -327,6 +339,18 @@ impl From<CairoLangContractEntryPoint> for EntryPoint {
     }
 }
 
+impl From<SierraEntryPoint> for EntryPoint {
+    fn from(entry_point: SierraEntryPoint) -> Self {
+        Self {
+            function_idx: FunctionIndex(
+                usize::try_from(entry_point.function_idx)
+                    .expect("Function index should fit in a usize"),
+            ),
+            selector: EntryPointSelector(entry_point.selector),
+        }
+    }
+}
+
 #[derive(
     Debug, Copy, Clone, Default, Eq, PartialEq, Hash, Deserialize, Serialize, PartialOrd, Ord,
 )]