feat(starknet_state_sync): implement sync state reader get class hash at

starkware-libs · Dec 22, 2024 · f7ff380 · f7ff380
1 parent 9b1350a
commit f7ff380
Show file tree

Hide file tree

Showing 3 changed files with 67 additions and 5 deletions.
diff --git a/crates/starknet_gateway/src/sync_state_reader.rs b/crates/starknet_gateway/src/sync_state_reader.rs
@@ -59,8 +59,12 @@ impl BlockifierStateReader for SyncStateReader {
         todo!()
     }
 
-    fn get_class_hash_at(&self, _contract_address: ContractAddress) -> StateResult<ClassHash> {
-        todo!()
+    fn get_class_hash_at(&self, contract_address: ContractAddress) -> StateResult<ClassHash> {
+        let res =
+            block_on(self.state_sync_client.get_class_hash_at(self.block_number, contract_address))
+                .map_err(|e| StateError::StateReadError(e.to_string()))?;
+
+        Ok(res)
     }
 
     fn get_compiled_class_hash(&self, _class_hash: ClassHash) -> StateResult<CompiledClassHash> {

diff --git a/crates/starknet_state_sync/src/lib.rs b/crates/starknet_state_sync/src/lib.rs
@@ -7,7 +7,7 @@ use papyrus_storage::db::TransactionKind;
 use papyrus_storage::state::StateStorageReader;
 use papyrus_storage::{StorageReader, StorageTxn};
 use starknet_api::block::BlockNumber;
-use starknet_api::core::{ContractAddress, Nonce, BLOCK_HASH_TABLE_ADDRESS};
+use starknet_api::core::{ClassHash, ContractAddress, Nonce, BLOCK_HASH_TABLE_ADDRESS};
 use starknet_api::state::{StateNumber, StorageKey};
 use starknet_sequencer_infra::component_definitions::{ComponentRequestHandler, ComponentStarter};
 use starknet_sequencer_infra::component_server::{LocalComponentServer, RemoteComponentServer};
@@ -50,6 +50,11 @@ impl ComponentRequestHandler<StateSyncRequest, StateSyncResponse> for StateSync
             StateSyncRequest::GetNonceAt(block_number, contract_address) => {
                 StateSyncResponse::GetNonceAt(self.get_nonce_at(block_number, contract_address))
             }
+            StateSyncRequest::GetClassHashAt(block_number, contract_address) => {
+                StateSyncResponse::GetClassHashAt(
+                    self.get_class_hash_at(block_number, contract_address),
+                )
+            }
         }
     }
 }
@@ -113,6 +118,22 @@ impl StateSync {
 
         Ok(res)
     }
+
+    fn get_class_hash_at(
+        &self,
+        block_number: BlockNumber,
+        contract_address: ContractAddress,
+    ) -> StateSyncResult<ClassHash> {
+        let txn = self.storage_reader.begin_ro_txn()?;
+        verify_synced_up_to(&txn, block_number)?;
+
+        let state_number = StateNumber::unchecked_right_after_block(block_number);
+        let state_reader = txn.get_state_reader()?;
+        let class_hash = state_reader
+            .get_class_hash_at(state_number, &contract_address)?
+            .ok_or(StateSyncError::ContractNotFound(contract_address))?;
+        Ok(class_hash)
+    }
 }
 
 fn verify_synced_up_to<Mode: TransactionKind>(

diff --git a/crates/starknet_state_sync_types/src/communication.rs b/crates/starknet_state_sync_types/src/communication.rs
@@ -4,7 +4,7 @@ use async_trait::async_trait;
 use papyrus_proc_macros::handle_response_variants;
 use serde::{Deserialize, Serialize};
 use starknet_api::block::BlockNumber;
-use starknet_api::core::{ContractAddress, Nonce};
+use starknet_api::core::{ClassHash, ContractAddress, Nonce};
 use starknet_api::state::StorageKey;
 use starknet_sequencer_infra::component_client::{
     ClientError,
@@ -50,8 +50,13 @@ pub trait StateSyncClient: Send + Sync {
         contract_address: ContractAddress,
     ) -> StateSyncClientResult<Nonce>;
 
+    async fn get_class_hash_at(
+        &self,
+        block_number: BlockNumber,
+        contract_address: ContractAddress,
+    ) -> StateSyncClientResult<ClassHash>;
+
     // TODO: Add get_compiled_class for StateSyncReader
-    // TODO: Add get_class_hash_at for StateSyncReader
     // TODO: Add get_compiled_class_hash for StateSyncReader
     // TODO: Add get_block_info for StateSyncReader
 }
@@ -77,6 +82,7 @@ pub enum StateSyncRequest {
     AddNewBlock(BlockNumber, SyncBlock),
     GetStorageAt(BlockNumber, ContractAddress, StorageKey),
     GetNonceAt(BlockNumber, ContractAddress),
+    GetClassHashAt(BlockNumber, ContractAddress),
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -85,6 +91,7 @@ pub enum StateSyncResponse {
     AddNewBlock(StateSyncResult<()>),
     GetStorageAt(StateSyncResult<Felt>),
     GetNonceAt(StateSyncResult<Nonce>),
+    GetClassHashAt(StateSyncResult<ClassHash>),
 }
 
 #[async_trait]
@@ -143,6 +150,21 @@ impl StateSyncClient for LocalStateSyncClient {
             StateSyncError
         )
     }
+
+    async fn get_class_hash_at(
+        &self,
+        block_number: BlockNumber,
+        contract_address: ContractAddress,
+    ) -> StateSyncClientResult<ClassHash> {
+        let request = StateSyncRequest::GetClassHashAt(block_number, contract_address);
+        let response = self.send(request).await;
+        handle_response_variants!(
+            StateSyncResponse,
+            GetClassHashAt,
+            StateSyncClientError,
+            StateSyncError
+        )
+    }
 }
 
 #[async_trait]
@@ -201,4 +223,19 @@ impl StateSyncClient for RemoteStateSyncClient {
             StateSyncError
         )
     }
+
+    async fn get_class_hash_at(
+        &self,
+        block_number: BlockNumber,
+        contract_address: ContractAddress,
+    ) -> StateSyncClientResult<ClassHash> {
+        let request = StateSyncRequest::GetClassHashAt(block_number, contract_address);
+        let response = self.send(request).await;
+        handle_response_variants!(
+            StateSyncResponse,
+            GetClassHashAt,
+            StateSyncClientError,
+            StateSyncError
+        )
+    }
 }