feat(starknet_gateway): state reader get compiled classes from class manager

This commit also includes the removal of deprecated_get_compiled_class from state
sync component which was blocked until the changes in this commit were introduced.

Author: noamsp-starkware

crates/starknet_gateway/src/gateway.rs

@@ -171,7 +171,10 @@ pub fn create_gateway(
     mempool_client: SharedMempoolClient,
     class_manager_client: SharedClassManagerClient,
 ) -> Gateway {
-    let state_reader_factory = Arc::new(SyncStateReaderFactory { shared_state_sync_client });
+    let state_reader_factory = Arc::new(SyncStateReaderFactory {
+        shared_state_sync_client,
+        class_manager_client: class_manager_client.clone(),
+    });
 
     let transaction_converter =
         TransactionConverter::new(class_manager_client, config.chain_info.chain_id.clone());

crates/starknet_gateway/src/sync_state_reader.rs

@@ -7,6 +7,7 @@ use starknet_api::contract_class::ContractClass;
 use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce};
 use starknet_api::data_availability::L1DataAvailabilityMode;
 use starknet_api::state::StorageKey;
+use starknet_class_manager_types::SharedClassManagerClient;
 use starknet_state_sync_types::communication::{
     SharedStateSyncClient,
     StateSyncClientError,
@@ -20,14 +21,16 @@ use crate::state_reader::{MempoolStateReader, StateReaderFactory};
 pub(crate) struct SyncStateReader {
     block_number: BlockNumber,
     state_sync_client: SharedStateSyncClient,
+    class_manager_client: SharedClassManagerClient,
 }
 
 impl SyncStateReader {
     pub fn from_number(
         state_sync_client: SharedStateSyncClient,
+        class_manager_client: SharedClassManagerClient,
         block_number: BlockNumber,
     ) -> Self {
-        Self { block_number, state_sync_client }
+        Self { block_number, state_sync_client, class_manager_client }
     }
 }
 
@@ -99,10 +102,8 @@ impl BlockifierStateReader for SyncStateReader {
     }
 
     fn get_compiled_class(&self, class_hash: ClassHash) -> StateResult<RunnableCompiledClass> {
-        let contract_class = block_on(
-            self.state_sync_client.get_compiled_class_deprecated(self.block_number, class_hash),
-        )
-        .map_err(|e| StateError::StateReadError(e.to_string()))?;
+        let contract_class = block_on(self.class_manager_client.get_executable(class_hash))
+            .map_err(|e| StateError::StateReadError(e.to_string()))?;
 
         match contract_class {
             ContractClass::V1(casm_contract_class) => {
@@ -134,6 +135,7 @@ impl BlockifierStateReader for SyncStateReader {
 
 pub struct SyncStateReaderFactory {
     pub shared_state_sync_client: SharedStateSyncClient,
+    pub class_manager_client: SharedClassManagerClient,
 }
 
 impl StateReaderFactory for SyncStateReaderFactory {
@@ -146,11 +148,16 @@ impl StateReaderFactory for SyncStateReaderFactory {
 
         Ok(Box::new(SyncStateReader::from_number(
             self.shared_state_sync_client.clone(),
+            self.class_manager_client.clone(),
             latest_block_number,
         )))
     }
 
     fn get_state_reader(&self, block_number: BlockNumber) -> Box<dyn MempoolStateReader> {
-        Box::new(SyncStateReader::from_number(self.shared_state_sync_client.clone(), block_number))
+        Box::new(SyncStateReader::from_number(
+            self.shared_state_sync_client.clone(),
+            self.class_manager_client.clone(),
+            block_number,
+        ))
     }
 }

crates/starknet_gateway/src/sync_state_reader_test.rs

@@ -19,6 +19,7 @@ use starknet_api::contract_class::{ContractClass, SierraVersion};
 use starknet_api::core::SequencerContractAddress;
 use starknet_api::data_availability::L1DataAvailabilityMode;
 use starknet_api::{class_hash, contract_address, felt, nonce, storage_key};
+use starknet_class_manager_types::MockClassManagerClient;
 use starknet_state_sync_types::communication::MockStateSyncClient;
 use starknet_state_sync_types::state_sync_types::SyncBlock;
 
@@ -27,6 +28,7 @@ use crate::sync_state_reader::SyncStateReader;
 #[tokio::test]
 async fn test_get_block_info() {
     let mut mock_state_sync_client = MockStateSyncClient::new();
+    let mock_class_manager_client = MockClassManagerClient::new();
     let block_number = BlockNumber(1);
     let block_timestamp = BlockTimestamp(2);
     let sequencer_address = contract_address!("0x3");
@@ -55,8 +57,11 @@ async fn test_get_block_info() {
         },
     );
 
-    let state_sync_reader =
-        SyncStateReader::from_number(Arc::new(mock_state_sync_client), block_number);
+    let state_sync_reader = SyncStateReader::from_number(
+        Arc::new(mock_state_sync_client),
+        Arc::new(mock_class_manager_client),
+        block_number,
+    );
     let result = state_sync_reader.get_block_info().unwrap();
 
     assert_eq!(
@@ -92,6 +97,7 @@ async fn test_get_block_info() {
 #[tokio::test]
 async fn test_get_storage_at() {
     let mut mock_state_sync_client = MockStateSyncClient::new();
+    let mock_class_manager_client = MockClassManagerClient::new();
     let block_number = BlockNumber(1);
     let contract_address = contract_address!("0x2");
     let storage_key = storage_key!("0x3");
@@ -106,8 +112,11 @@ async fn test_get_storage_at() {
         )
         .returning(move |_, _, _| Ok(value));
 
-    let state_sync_reader =
-        SyncStateReader::from_number(Arc::new(mock_state_sync_client), block_number);
+    let state_sync_reader = SyncStateReader::from_number(
+        Arc::new(mock_state_sync_client),
+        Arc::new(mock_class_manager_client),
+        block_number,
+    );
 
     let result = state_sync_reader.get_storage_at(contract_address, storage_key).unwrap();
     assert_eq!(result, value);
@@ -116,6 +125,7 @@ async fn test_get_storage_at() {
 #[tokio::test]
 async fn test_get_nonce_at() {
     let mut mock_state_sync_client = MockStateSyncClient::new();
+    let mock_class_manager_client = MockClassManagerClient::new();
     let block_number = BlockNumber(1);
     let contract_address = contract_address!("0x2");
     let expected_result = nonce!(0x3);
@@ -126,8 +136,11 @@ async fn test_get_nonce_at() {
         .with(predicate::eq(block_number), predicate::eq(contract_address))
         .returning(move |_, _| Ok(expected_result));
 
-    let state_sync_reader =
-        SyncStateReader::from_number(Arc::new(mock_state_sync_client), block_number);
+    let state_sync_reader = SyncStateReader::from_number(
+        Arc::new(mock_state_sync_client),
+        Arc::new(mock_class_manager_client),
+        block_number,
+    );
 
     let result = state_sync_reader.get_nonce_at(contract_address).unwrap();
     assert_eq!(result, expected_result);
@@ -136,6 +149,7 @@ async fn test_get_nonce_at() {
 #[tokio::test]
 async fn test_get_class_hash_at() {
     let mut mock_state_sync_client = MockStateSyncClient::new();
+    let mock_class_manager_client = MockClassManagerClient::new();
     let block_number = BlockNumber(1);
     let contract_address = contract_address!("0x2");
     let expected_result = class_hash!("0x3");
@@ -146,16 +160,20 @@ async fn test_get_class_hash_at() {
         .with(predicate::eq(block_number), predicate::eq(contract_address))
         .returning(move |_, _| Ok(expected_result));
 
-    let state_sync_reader =
-        SyncStateReader::from_number(Arc::new(mock_state_sync_client), block_number);
+    let state_sync_reader = SyncStateReader::from_number(
+        Arc::new(mock_state_sync_client),
+        Arc::new(mock_class_manager_client),
+        block_number,
+    );
 
     let result = state_sync_reader.get_class_hash_at(contract_address).unwrap();
     assert_eq!(result, expected_result);
 }
 
 #[tokio::test]
 async fn test_get_compiled_class() {
-    let mut mock_state_sync_client = MockStateSyncClient::new();
+    let mock_state_sync_client = MockStateSyncClient::new();
+    let mut mock_class_manager_client = MockClassManagerClient::new();
     let block_number = BlockNumber(1);
     let class_hash = class_hash!("0x2");
     let casm_contract_class = CasmContractClass {
@@ -169,16 +187,19 @@ async fn test_get_compiled_class() {
     };
     let expected_result = casm_contract_class.clone();
 
-    mock_state_sync_client
-        .expect_get_compiled_class_deprecated()
+    mock_class_manager_client
+        .expect_get_executable()
         .times(1)
-        .with(predicate::eq(block_number), predicate::eq(class_hash))
-        .returning(move |_, _| {
+        .with(predicate::eq(class_hash))
+        .returning(move |_| {
             Ok(ContractClass::V1((casm_contract_class.clone(), SierraVersion::default())))
         });
 
-    let state_sync_reader =
-        SyncStateReader::from_number(Arc::new(mock_state_sync_client), block_number);
+    let state_sync_reader = SyncStateReader::from_number(
+        Arc::new(mock_state_sync_client),
+        Arc::new(mock_class_manager_client),
+        block_number,
+    );
 
     let result = state_sync_reader.get_compiled_class(class_hash).unwrap();
     assert_eq!(

crates/starknet_state_sync/src/lib.rs

@@ -9,13 +9,11 @@ use async_trait::async_trait;
 use futures::channel::mpsc::{channel, Sender};
 use futures::SinkExt;
 use papyrus_storage::body::BodyStorageReader;
-use papyrus_storage::compiled_class::CasmStorageReader;
 use papyrus_storage::db::TransactionKind;
 use papyrus_storage::header::HeaderStorageReader;
 use papyrus_storage::state::{StateReader, StateStorageReader};
 use papyrus_storage::{StorageReader, StorageTxn};
 use starknet_api::block::BlockNumber;
-use starknet_api::contract_class::{ContractClass, SierraVersion};
 use starknet_api::core::{ClassHash, ContractAddress, Nonce, BLOCK_HASH_TABLE_ADDRESS};
 use starknet_api::state::{StateNumber, StorageKey};
 use starknet_class_manager_types::SharedClassManagerClient;
@@ -73,11 +71,6 @@ impl ComponentRequestHandler<StateSyncRequest, StateSyncResponse> for StateSync
                     self.get_class_hash_at(block_number, contract_address),
                 )
             }
-            StateSyncRequest::GetCompiledClassDeprecated(block_number, class_hash) => {
-                StateSyncResponse::GetCompiledClassDeprecated(
-                    self.get_compiled_class_deprecated(block_number, class_hash),
-                )
-            }
             StateSyncRequest::GetLatestBlockNumber() => {
                 StateSyncResponse::GetLatestBlockNumber(self.get_latest_block_number())
             }
@@ -160,42 +153,6 @@ impl StateSync {
         Ok(class_hash)
     }
 
-    fn get_compiled_class_deprecated(
-        &self,
-        block_number: BlockNumber,
-        class_hash: ClassHash,
-    ) -> StateSyncResult<ContractClass> {
-        let txn = self.storage_reader.begin_ro_txn()?;
-        verify_synced_up_to(&txn, block_number)?;
-
-        let state_reader = txn.get_state_reader()?;
-
-        // Check if this class exists in the Cairo1 classes table.
-        if let Some(class_definition_block_number) =
-            state_reader.get_class_definition_block_number(&class_hash)?
-        {
-            if class_definition_block_number > block_number {
-                return Err(StateSyncError::ClassNotFound(class_hash));
-            }
-
-            let (option_casm, option_sierra) = txn.get_casm_and_sierra(&class_hash)?;
-
-            // Check if both options are `Some`. If not, since we verified the block number is
-            // smaller than the casm marker, we return that the class doesnt exist.
-            let (casm, sierra) =
-                option_casm.zip(option_sierra).ok_or(StateSyncError::ClassNotFound(class_hash))?;
-            let sierra_version = SierraVersion::extract_from_program(&sierra.sierra_program)?;
-            return Ok(ContractClass::V1((casm, sierra_version)));
-        }
-
-        // Check if this class exists in the Cairo0 classes table.
-        let state_number = StateNumber::unchecked_right_after_block(block_number);
-        let deprecated_compiled_contract_class = state_reader
-            .get_deprecated_class_definition_at(state_number, &class_hash)?
-            .ok_or(StateSyncError::ClassNotFound(class_hash))?;
-        Ok(ContractClass::V0(deprecated_compiled_contract_class))
-    }
-
     fn get_latest_block_number(&self) -> StateSyncResult<Option<BlockNumber>> {
         let txn = self.storage_reader.begin_ro_txn()?;
         let latest_block_number = latest_synced_block(&txn)?;

crates/starknet_state_sync/src/test.rs

@@ -1,20 +1,15 @@
-use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
 use futures::channel::mpsc::channel;
 use indexmap::IndexMap;
 use papyrus_storage::body::BodyStorageWriter;
-use papyrus_storage::class::ClassStorageWriter;
-use papyrus_storage::compiled_class::CasmStorageWriter;
 use papyrus_storage::header::HeaderStorageWriter;
 use papyrus_storage::state::StateStorageWriter;
 use papyrus_storage::test_utils::get_test_storage;
 use papyrus_storage::StorageWriter;
 use papyrus_test_utils::{get_rng, get_test_block, get_test_state_diff, GetTestInstance};
 use rand_chacha::rand_core::RngCore;
 use starknet_api::block::{Block, BlockHeader, BlockNumber};
-use starknet_api::contract_class::{ContractClass, SierraVersion};
-use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce};
-use starknet_api::deprecated_contract_class::ContractClass as DeprecatedContractClass;
-use starknet_api::state::{SierraContractClass, StorageKey, ThinStateDiff};
+use starknet_api::core::{ClassHash, ContractAddress, Nonce};
+use starknet_api::state::{StorageKey, ThinStateDiff};
 use starknet_sequencer_infra::component_definitions::ComponentRequestHandler;
 use starknet_state_sync_types::communication::{StateSyncRequest, StateSyncResponse};
 use starknet_state_sync_types::errors::StateSyncError;
@@ -188,63 +183,6 @@ async fn get_class_hash_at() {
     assert_eq!(class_hash, expected_class_hash);
 }
 
-#[tokio::test]
-async fn test_get_compiled_class_deprecated() {
-    let (state_sync, mut storage_writer) = setup();
-
-    let mut rng = get_rng();
-    let cairo1_class_hash = ClassHash(Felt::from(rng.next_u64()));
-    let cairo1_contract_class = CasmContractClass::get_test_instance(&mut rng);
-    let sierra_contract_class = SierraContractClass::default();
-    let cairo0_class_hash = ClassHash(Felt::from(rng.next_u64()));
-    let cairo0_contract_class = DeprecatedContractClass::get_test_instance(&mut get_rng());
-    let block_number = BlockNumber(0);
-
-    storage_writer
-        .begin_rw_txn()
-        .unwrap()
-        .append_state_diff(
-            block_number,
-            starknet_api::state::ThinStateDiff {
-                declared_classes: IndexMap::from([(
-                    cairo1_class_hash,
-                    CompiledClassHash::default(),
-                )]),
-                deprecated_declared_classes: vec![cairo0_class_hash],
-                ..Default::default()
-            },
-        )
-        .unwrap()
-        .append_casm(&cairo1_class_hash, &cairo1_contract_class)
-        .unwrap()
-        .append_classes(
-            block_number,
-            &[(cairo1_class_hash, &sierra_contract_class)],
-            &[(cairo0_class_hash, &cairo0_contract_class)],
-        )
-        .unwrap()
-        .append_body(block_number, Default::default())
-        .unwrap()
-        .commit()
-        .unwrap();
-
-    // Verify the cairo1 class was written and is returned correctly.
-    let contract_class_v1 =
-        state_sync.get_compiled_class_deprecated(block_number, cairo1_class_hash).unwrap();
-    let sierra_version =
-        SierraVersion::extract_from_program(&sierra_contract_class.sierra_program).unwrap();
-    assert_eq!(contract_class_v1, ContractClass::V1((cairo1_contract_class, sierra_version)));
-
-    // Verify the cairo0 class was written and is returned correctly.
-    let contract_class_v0 =
-        state_sync.get_compiled_class_deprecated(block_number, cairo0_class_hash).unwrap();
-    assert_eq!(contract_class_v0, ContractClass::V0(cairo0_contract_class));
-
-    let other_class_hash = ClassHash::get_test_instance(&mut rng);
-    let result = state_sync.get_compiled_class_deprecated(block_number, other_class_hash);
-    assert_eq!(result, Err(StateSyncError::ClassNotFound(other_class_hash)));
-}
-
 // Verify we get None/BlockNotFound when trying to call read methods with a block number that does
 // not exist.
 #[tokio::test]
@@ -299,21 +237,6 @@ async fn test_block_not_found() {
         get_class_hash_at_result,
         Err(StateSyncError::BlockNotFound(non_existing_block_number))
     );
-
-    let response = state_sync
-        .handle_request(StateSyncRequest::GetCompiledClassDeprecated(
-            non_existing_block_number,
-            Default::default(),
-        ))
-        .await;
-    let StateSyncResponse::GetCompiledClassDeprecated(get_compiled_class_result) = response else {
-        panic!("Expected StateSyncResponse::GetCompiledClassDeprecated(_), but got {:?}", response);
-    };
-
-    assert_eq!(
-        get_compiled_class_result,
-        Err(StateSyncError::BlockNotFound(non_existing_block_number))
-    );
 }
 
 #[tokio::test]