blockifier_reexecution: impl FetchedCompiledClass for test and offline state readers

Author: Yonatan-Starkware

Cargo.lock

@@ -32,8 +32,6 @@ 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 compiled class hash v2 for class with hash {:#064x}.", **.0)]
     MissingCompiledClassHashV2(ClassHash),
 }

crates/blockifier/src/state/errors.rs

@@ -26,7 +26,6 @@ use starknet_api::hash::StarkHash;
 use starknet_api::state::SierraContractClass;
 use starknet_core::types::{
     CompressedLegacyContractClass,
-    FlattenedSierraClass,
     LegacyContractEntryPoint,
     LegacyEntryPointsByType,
 };
@@ -76,20 +75,11 @@ pub fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
     Ok(s)
 }
 
-/// Compile a FlattenedSierraClass to a versioned ContractClass V1 (casm) using
+/// Compile a SierraContractClass to a versioned ContractClass V1 (casm) using
 /// apollo_compile_to_casm.
 pub fn sierra_to_versioned_contract_class_v1(
-    flattened_sierra: FlattenedSierraClass,
+    sierra_contract: SierraContractClass,
 ) -> StateResult<(ContractClass, SierraVersion)> {
-    let serde_value = serde_json::to_value(&flattened_sierra)
-        .unwrap_or_else(|err| panic!("Failed to serialize flattened Sierra: {err}"));
-    let sierra_contract: SierraContractClass =
-        serde_json::from_value(serde_value).unwrap_or_else(|err| {
-            panic!(
-                "Failed to deserialize SierraContractClass: {err} for flattened_sierra: \
-                 {flattened_sierra:?}"
-            );
-        });
     let sierra_version = SierraVersion::extract_from_program(&sierra_contract.sierra_program)
         .unwrap_or_else(|err| panic!("Failed to extract Sierra version: {err}"));
     let raw_class = RawClass::try_from(sierra_contract)

crates/blockifier_reexecution/src/state_reader/compile.rs

@@ -9,12 +9,14 @@ 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};
 use starknet_api::core::{ChainId, ClassHash, CompiledClassHash, ContractAddress, Nonce};
-use starknet_api::state::StorageKey;
+use starknet_api::state::{SierraContractClass, StorageKey};
 use starknet_api::transaction::{Transaction, TransactionHash};
 use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
 use starknet_core::types::ContractClass as StarknetContractClass;
@@ -160,7 +162,8 @@ impl StateReader for OfflineStateReader {
     fn get_compiled_class(&self, class_hash: ClassHash) -> StateResult<RunnableCompiledClass> {
         match self.get_contract_class(&class_hash)? {
             StarknetContractClass::Sierra(sierra) => {
-                let (casm, _) = sierra_to_versioned_contract_class_v1(sierra).unwrap();
+                let sierra_contract = SierraContractClass::from(sierra);
+                let (casm, _) = sierra_to_versioned_contract_class_v1(sierra_contract).unwrap();
                 Ok(casm.try_into().unwrap())
             }
             StarknetContractClass::Legacy(legacy) => {
@@ -192,6 +195,19 @@ 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_class(contract_class)
+    }
+
+    /// This check is no needed in the reexecution context.
+    /// We assume that all the classes returned successfuly by the OfflineStateReader are declared.
+    fn is_declared(&self, _class_hash: ClassHash) -> StateResult<bool> {
+        Ok(true)
+    }
+}
+
 impl OfflineStateReader {
     pub fn get_transaction_executor(
         self,

crates/blockifier_reexecution/src/state_reader/offline_state_reader.rs

@@ -2,12 +2,14 @@ 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::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;
@@ -17,6 +19,7 @@ use crate::state_reader::compile::{
     sierra_to_versioned_contract_class_v1,
 };
 use crate::state_reader::errors::ReexecutionResult;
+use crate::state_reader::utils::contract_class_to_compiled_classes;
 
 pub trait ReexecutionStateReader {
     fn get_contract_class(&self, class_hash: &ClassHash) -> StateResult<StarknetContractClass>;
@@ -27,8 +30,9 @@ pub trait ReexecutionStateReader {
                 let abi_length = sierra.abi.len();
                 let sierra_length = sierra.sierra_program.len();
 
+                let sierra_contract = SierraContractClass::from(sierra);
                 let (contract_class, sierra_version) =
-                    sierra_to_versioned_contract_class_v1(sierra)?;
+                    sierra_to_versioned_contract_class_v1(sierra_contract)?;
 
                 Ok(ClassInfo::new(&contract_class, sierra_length, abi_length, sierra_version)?)
             }
@@ -92,6 +96,26 @@ pub trait ReexecutionStateReader {
     }
 
     fn get_old_block_hash(&self, old_block_number: BlockNumber) -> ReexecutionResult<BlockHash>;
+
+    /// Converts a `starknet_core::types::ContractClass` to `CompiledClasses`.
+    fn starknet_core_contract_class_to_compiled_class(
+        &self,
+        contract_class: StarknetContractClass,
+    ) -> StateResult<CompiledClasses> {
+        match contract_class {
+            StarknetContractClass::Sierra(flat_sierra) => {
+                let sierra = SierraContractClass::from(flat_sierra);
+                let (class_v1, _) = sierra_to_versioned_contract_class_v1(sierra.clone())?;
+
+                Ok(contract_class_to_compiled_classes(class_v1, Some(sierra))?)
+            }
+            StarknetContractClass::Legacy(legacy) => {
+                let class_v0 = legacy_to_contract_class_v0(legacy)?;
+
+                Ok(contract_class_to_compiled_classes(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};
@@ -28,7 +30,7 @@ use starknet_api::block::{
     StarknetVersion,
 };
 use starknet_api::core::{ChainId, ClassHash, CompiledClassHash, ContractAddress, Nonce};
-use starknet_api::state::StorageKey;
+use starknet_api::state::{SierraContractClass, StorageKey};
 use starknet_api::transaction::{Transaction, TransactionHash};
 use starknet_api::versioned_constants_logic::VersionedConstantsTrait;
 use starknet_core::types::ContractClass as StarknetContractClass;
@@ -139,7 +141,8 @@ impl StateReader for TestStateReader {
 
         match contract_class {
             StarknetContractClass::Sierra(sierra) => {
-                let (casm, _) = sierra_to_versioned_contract_class_v1(sierra).unwrap();
+                let sierra_contract = SierraContractClass::from(sierra);
+                let (casm, _) = sierra_to_versioned_contract_class_v1(sierra_contract).unwrap();
                 Ok(RunnableCompiledClass::try_from(casm).unwrap())
             }
             StarknetContractClass::Legacy(legacy) => {
@@ -153,6 +156,21 @@ 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_class(contract_class)
+    }
+
+    /// This check is no needed in the reexecution context.
+    /// We assume that all the classes returned successfuly by the rpc-provider are declared.
+    fn is_declared(&self, _class_hash: ClassHash) -> StateResult<bool> {
+        Ok(true)
+    }
+}
+
 impl TestStateReader {
     pub fn new(
         config: &RpcStateReaderConfig,

crates/blockifier_reexecution/src/state_reader/test_state_reader.rs

@@ -1,21 +1,24 @@
 use std::collections::{BTreeMap, HashMap};
 use std::env;
 use std::fs::read_to_string;
-use std::sync::LazyLock;
+use std::sync::{Arc, LazyLock};
 
 use apollo_gateway_config::config::RpcStateReaderConfig;
 use apollo_rpc_execution::{ETH_FEE_CONTRACT_ADDRESS, STRK_FEE_CONTRACT_ADDRESS};
 use assert_matches::assert_matches;
 use blockifier::context::{ChainInfo, FeeTokenAddresses};
+use blockifier::execution::contract_class::{CompiledClassV0, CompiledClassV1};
 use blockifier::state::cached_state::{CachedState, CommitmentStateDiff, StateMaps};
-use blockifier::state::state_api::StateReader;
+use blockifier::state::global_cache::CompiledClasses;
+use blockifier::state::state_api::{StateReader, StateResult};
 use indexmap::IndexMap;
 use pretty_assertions::assert_eq;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use starknet_api::block::BlockNumber;
+use starknet_api::contract_class::ContractClass;
 use starknet_api::core::{ChainId, ClassHash, CompiledClassHash, ContractAddress, Nonce};
-use starknet_api::state::StorageKey;
+use starknet_api::state::{SierraContractClass, StorageKey};
 use starknet_api::transaction::TransactionHash;
 use starknet_types_core::felt::Felt;
 
@@ -39,6 +42,30 @@ pub static RPC_NODE_URL: LazyLock<String> = LazyLock::new(|| {
         .unwrap_or_else(|_| "https://free-rpc.nethermind.io/mainnet-juno/".to_string())
 });
 
+/// 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 contract_class_to_compiled_classes(
+    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)?))
+        }
+        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)?,
+                Arc::new(sierra_contract_class),
+            ))
+        }
+    }
+}
+
 /// Returns the fee token addresses of mainnet.
 pub fn get_fee_token_addresses(chain_id: &ChainId) -> FeeTokenAddresses {
     match chain_id {

crates/blockifier_reexecution/src/state_reader/utils.rs

@@ -34,6 +34,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 {
     pub 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,
 )]