diff --git a/Cargo.lock b/Cargo.lock
index 48d48bf40e5..8cb0a2d9c5d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -8033,6 +8033,7 @@ version = "0.0.0"
 dependencies = [
  "assert_matches",
  "blockifier",
+ "cairo-lang-starknet-classes",
  "indexmap 2.7.0",
  "papyrus_storage",
  "rstest",
diff --git a/crates/papyrus_state_reader/Cargo.toml b/crates/papyrus_state_reader/Cargo.toml
index ec39ffb16e9..aaf0067263b 100644
--- a/crates/papyrus_state_reader/Cargo.toml
+++ b/crates/papyrus_state_reader/Cargo.toml
@@ -13,6 +13,7 @@ workspace = true
 
 [dependencies]
 blockifier.workspace = true
+cairo-lang-starknet-classes.workspace = true
 papyrus_storage.workspace = true
 starknet-types-core.workspace = true
 starknet_api.workspace = true
diff --git a/crates/papyrus_state_reader/src/papyrus_state.rs b/crates/papyrus_state_reader/src/papyrus_state.rs
index 39203d0a64c..49c65d95b06 100644
--- a/crates/papyrus_state_reader/src/papyrus_state.rs
+++ b/crates/papyrus_state_reader/src/papyrus_state.rs
@@ -11,6 +11,7 @@ use blockifier::state::errors::{couple_casm_and_sierra, StateError};
 use blockifier::state::global_cache::CachedCairoNative;
 use blockifier::state::global_cache::CachedCasm;
 use blockifier::state::state_api::{StateReader, StateResult};
+use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
 use papyrus_storage::compiled_class::CasmStorageReader;
 use papyrus_storage::db::RO;
 use papyrus_storage::state::StateStorageReader;
@@ -18,7 +19,8 @@ use papyrus_storage::StorageReader;
 use starknet_api::block::BlockNumber;
 use starknet_api::contract_class::SierraVersion;
 use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce};
-use starknet_api::state::{StateNumber, StorageKey};
+use starknet_api::deprecated_contract_class::ContractClass as DeprecatedClass;
+use starknet_api::state::{SierraContractClass, StateNumber, StorageKey};
 use starknet_class_manager_types::{EmptyClassManagerClient, SharedClassManagerClient};
 use starknet_types_core::felt::Felt;
 
@@ -65,15 +67,7 @@ impl PapyrusReader {
                         Some(block_number) if block_number <= state_number.0);
 
         if class_is_declared {
-            let (option_casm, option_sierra) = self
-                .reader()?
-                .get_casm_and_sierra(&class_hash)
-                .map_err(|err| StateError::StateReadError(err.to_string()))?;
-            let (casm_compiled_class, sierra) =
-                couple_casm_and_sierra(class_hash, option_casm, option_sierra)?.expect(
-                    "Should be able to fetch a Casm and Sierra class if its definition exists, \
-                     database is inconsistent.",
-                );
+            let (casm_compiled_class, sierra) = self.read_casm_and_sierra(class_hash)?;
             let sierra_version = SierraVersion::extract_from_program(&sierra.sierra_program)?;
             let runnable_casm = RunnableCompiledClass::V1(CompiledClassV1::try_from((
                 casm_compiled_class,
@@ -92,12 +86,7 @@ impl PapyrusReader {
             return Ok(cached_casm);
         }
 
-        let v0_compiled_class = self
-            .reader()?
-            .get_state_reader()
-            .and_then(|sr| sr.get_deprecated_class_definition_at(state_number, &class_hash))
-            .map_err(|err| StateError::StateReadError(err.to_string()))?;
-
+        let v0_compiled_class = self.read_deprecated_casm(class_hash)?;
         match v0_compiled_class {
             Some(starknet_api_contract_class) => {
                 let runnable_casm = RunnableCompiledClass::V0(CompiledClassV0::try_from(
@@ -150,6 +139,34 @@ impl PapyrusReader {
             CachedCairoNative::CompilationFailed => casm,
         }
     }
+
+    fn read_casm_and_sierra(
+        &self,
+        class_hash: ClassHash,
+    ) -> StateResult<(CasmContractClass, SierraContractClass)> {
+        let (option_casm, option_sierra) = self
+            .reader()?
+            .get_casm_and_sierra(&class_hash)
+            .map_err(|err| StateError::StateReadError(err.to_string()))?;
+        let (casm, sierra) = couple_casm_and_sierra(class_hash, option_casm, option_sierra)?
+            .expect(
+                "Should be able to fetch a Casm and Sierra class if its definition exists,
+                database is inconsistent.",
+            );
+
+        Ok((casm, sierra))
+    }
+
+    fn read_deprecated_casm(&self, class_hash: ClassHash) -> StateResult<Option<DeprecatedClass>> {
+        let state_number = StateNumber(self.latest_block);
+        let option_casm = self
+            .reader()?
+            .get_state_reader()
+            .and_then(|sr| sr.get_deprecated_class_definition_at(state_number, &class_hash))
+            .map_err(|err| StateError::StateReadError(err.to_string()))?;
+
+        Ok(option_casm)
+    }
 }
 
 // Currently unused - will soon replace the same `impl` for `PapyrusStateReader`.