feat(starknet_gateway): state_reader_get_compiled_classes_from_class_manager

Author: noamsp-starkware

crates/starknet_gateway/Cargo.toml

@@ -48,6 +48,7 @@ papyrus_network_types = { workspace = true, features = ["testing"] }
 papyrus_test_utils.workspace = true
 pretty_assertions.workspace = true
 rstest.workspace = true
+starknet_class_manager_types = { workspace = true, features = ["testing"] }
 starknet_mempool.workspace = true
 starknet_mempool_types = { workspace = true, features = ["testing"] }
 starknet_state_sync_types = { workspace = true, features = ["testing"] }

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,12 @@ 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::{
+    ClassManagerClientError,
+    ClassManagerError,
+    ClassStorageError,
+    SharedClassManagerClient,
+};
 use starknet_state_sync_types::communication::{
     SharedStateSyncClient,
     StateSyncClientError,
@@ -20,14 +26,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 +107,19 @@ 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 res = block_on(self.class_manager_client.get_executable(class_hash));
+
+        let contract_class = match res {
+            Ok(value) => value,
+            // TODO(noamsp): Remove this once the class manager component is ready.
+            Err(ClassManagerClientError::ClassManagerError(
+                ClassManagerError::ClassStorageError(ClassStorageError::ClassNotFound { .. }),
+            )) => block_on(
+                self.state_sync_client.get_compiled_class_deprecated(self.block_number, class_hash),
+            )
+            .map_err(|e| StateError::StateReadError(e.to_string()))?,
+            Err(e) => return Err(StateError::StateReadError(e.to_string())),
+        };
 
         match contract_class {
             ContractClass::V1(casm_contract_class) => {
@@ -134,6 +151,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 +164,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!(