starkware-libs · AvivYossef-starkware · Dec 13, 2025 · Dec 10, 2025
diff --git a/crates/blockifier_reexecution/src/main.rs b/crates/blockifier_reexecution/src/main.rs
@@ -13,7 +13,7 @@ use blockifier_reexecution::state_reader::cli::{
 };
 use blockifier_reexecution::state_reader::offline_state_reader::OfflineConsecutiveStateReaders;
 use blockifier_reexecution::state_reader::reexecution_state_reader::ConsecutiveReexecutionStateReaders;
-use blockifier_reexecution::state_reader::test_state_reader::ConsecutiveTestStateReaders;
+use blockifier_reexecution::state_reader::rpc_state_reader::ConsecutiveRpcStateReaders;
 use clap::Parser;
 use google_cloud_storage::client::{Client, ClientConfig};
 use google_cloud_storage::http::objects::download::Range;
@@ -68,7 +68,7 @@ async fn main() {
             // for details), so should be executed in a blocking thread.
             // TODO(Aner): make only the RPC calls blocking, not the whole function.
             tokio::task::spawn_blocking(move || {
-                ConsecutiveTestStateReaders::new(
+                ConsecutiveRpcStateReaders::new(
                     BlockNumber(block_number - 1),
                     Some(rpc_state_reader_config),
                     rpc_args.parse_chain_id(),
@@ -104,7 +104,7 @@ async fn main() {
             // for details), so should be executed in a blocking thread.
             // TODO(Aner): make only the RPC calls blocking, not the whole function.
             tokio::task::spawn_blocking(move || {
-                ConsecutiveTestStateReaders::new(
+                ConsecutiveRpcStateReaders::new(
                     BlockNumber(block_number - 1),
                     Some(rpc_state_reader_config),
                     chain_id,
@@ -139,7 +139,7 @@ async fn main() {
                 task_set.spawn(async move {
                     println!("Computing reexecution data for block {block_number}.");
                     tokio::task::spawn_blocking(move || {
-                        ConsecutiveTestStateReaders::new(
+                        ConsecutiveRpcStateReaders::new(
                             block_number.prev().expect("Should not run with block 0"),
                             Some(rpc_state_reader_config),
                             chain_id,

diff --git a/crates/blockifier_reexecution/src/state_reader.rs b/crates/blockifier_reexecution/src/state_reader.rs
@@ -9,6 +9,6 @@ pub mod reexecution_state_reader;
 pub mod reexecution_test;
 #[cfg(all(test, feature = "blockifier_regression_https_testing"))]
 pub mod rpc_https_test;
+pub mod rpc_state_reader;
 pub mod serde_utils;
-pub mod test_state_reader;
 pub mod utils;
diff --git a/crates/blockifier_reexecution/src/state_reader/offline_state_reader.rs b/crates/blockifier_reexecution/src/state_reader/offline_state_reader.rs
@@ -35,7 +35,7 @@ use crate::state_reader::reexecution_state_reader::{
     ConsecutiveReexecutionStateReaders,
     ReexecutionStateReader,
 };
-use crate::state_reader::test_state_reader::StarknetContractClassMapping;
+use crate::state_reader::rpc_state_reader::StarknetContractClassMapping;
 use crate::state_reader::utils::{get_chain_info, ReexecutionStateMaps};
 
 pub struct OfflineReexecutionData {

diff --git a/crates/blockifier_reexecution/src/state_reader/rpc_https_test.rs b/crates/blockifier_reexecution/src/state_reader/rpc_https_test.rs
@@ -13,7 +13,7 @@ use std::env;
 use std::sync::{Arc, Mutex};
 
 use apollo_gateway::rpc_objects::BlockId;
-use apollo_gateway::rpc_state_reader::RpcStateReader;
+use apollo_gateway::rpc_state_reader::RpcStateReader as GatewayRpcStateReader;
 use apollo_gateway_config::config::RpcStateReaderConfig;
 use assert_matches::assert_matches;
 use blockifier::blockifier::config::ContractClassManagerConfig;
@@ -30,12 +30,12 @@ use starknet_api::transaction::{
 };
 use starknet_core::types::ContractClass::{Legacy, Sierra};
 
-use super::test_state_reader::RetryConfig;
+use super::rpc_state_reader::RetryConfig;
 use super::utils::RPC_NODE_URL;
 use crate::state_reader::cli::guess_chain_id_from_node_url;
 use crate::state_reader::compile::legacy_to_contract_class_v0;
 use crate::state_reader::reexecution_state_reader::ReexecutionStateReader;
-use crate::state_reader::test_state_reader::{ConsecutiveTestStateReaders, TestStateReader};
+use crate::state_reader::rpc_state_reader::{ConsecutiveRpcStateReaders, RpcStateReader};
 
 const EXAMPLE_INVOKE_TX_HASH: &str =
     "0xa7c7db686c7f756ceb7ca85a759caef879d425d156da83d6a836f86851983";
@@ -95,9 +95,9 @@ pub fn get_test_rpc_config() -> RpcStateReaderConfig {
 }
 
 #[fixture]
-pub fn test_state_reader() -> TestStateReader {
-    TestStateReader {
-        rpc_state_reader: RpcStateReader {
+pub fn test_state_reader() -> RpcStateReader {
+    RpcStateReader {
+        rpc_state_reader: GatewayRpcStateReader {
             config: get_test_rpc_config(),
             block_id: get_test_block_id(),
         },
@@ -108,7 +108,7 @@ pub fn test_state_reader() -> TestStateReader {
 }
 
 #[fixture]
-pub fn test_block_number(test_state_reader: TestStateReader) -> BlockNumber {
+pub fn test_block_number(test_state_reader: RpcStateReader) -> BlockNumber {
     test_state_reader.get_block_info().unwrap().block_number
 }
 
@@ -126,8 +126,8 @@ pub fn contract_class_manager() -> ContractClassManager {
 pub fn test_state_readers_last_and_current_block(
     last_constructed_block: BlockNumber,
     contract_class_manager: ContractClassManager,
-) -> ConsecutiveTestStateReaders {
-    ConsecutiveTestStateReaders::new(
+) -> ConsecutiveRpcStateReaders {
+    ConsecutiveRpcStateReaders::new(
         last_constructed_block,
         None,
         ChainId::Mainnet,
@@ -138,17 +138,17 @@ pub fn test_state_readers_last_and_current_block(
 
 /// Test that the block info can be retrieved from the RPC server.
 #[rstest]
-pub fn test_get_block_info(test_state_reader: TestStateReader) {
+pub fn test_get_block_info(test_state_reader: RpcStateReader) {
     assert_matches!(test_state_reader.get_block_info(), Ok(BlockInfo { .. }));
 }
 
 #[rstest]
-pub fn test_get_starknet_version(test_state_reader: TestStateReader) {
+pub fn test_get_starknet_version(test_state_reader: RpcStateReader) {
     test_state_reader.get_starknet_version().unwrap();
 }
 
 #[rstest]
-pub fn test_get_contract_class(test_state_reader: TestStateReader, test_block_number: BlockNumber) {
+pub fn test_get_contract_class(test_state_reader: RpcStateReader, test_block_number: BlockNumber) {
     // An example of existing class hash in Mainnet.
     let class_hash = class_hash!(EXAMPLE_CONTACT_CLASS_HASH);
 
@@ -174,14 +174,14 @@ pub fn test_get_contract_class(test_state_reader: TestStateReader, test_block_nu
 }
 
 #[rstest]
-pub fn test_get_tx_hashes(test_state_reader: TestStateReader) {
+pub fn test_get_tx_hashes(test_state_reader: RpcStateReader) {
     test_state_reader.get_tx_hashes().unwrap_or_else(|err| {
         panic!("Error retrieving txs hash: {err}");
     });
 }
 
 #[rstest]
-pub fn test_get_invoke_tx_by_hash(test_state_reader: TestStateReader) {
+pub fn test_get_invoke_tx_by_hash(test_state_reader: RpcStateReader) {
     let actual_tx = test_state_reader.get_tx_by_hash(EXAMPLE_INVOKE_TX_HASH).unwrap();
     assert_matches!(actual_tx, Transaction::Invoke(..));
 }
@@ -203,7 +203,7 @@ pub fn test_get_deploy_account_tx_by_hash(
     #[case] version: TransactionVersion,
 ) {
     // Create StateReader with block number that contain the deploy account tx.
-    let state_reader = TestStateReader::new_for_testing(BlockNumber(block_number));
+    let state_reader = RpcStateReader::new_for_testing(BlockNumber(block_number));
     let actual_tx = state_reader.get_tx_by_hash(tx_hash).unwrap();
     if version == TransactionVersion::ONE {
         assert_matches!(actual_tx, Transaction::DeployAccount(DeployAccountTransaction::V1(..)))
@@ -224,7 +224,7 @@ pub fn test_get_declare_tx_by_hash(
     #[case] expected_version: TransactionVersion,
 ) {
     // Create StateReader with block number that contain the declare tx.
-    let state_reader = TestStateReader::new_for_testing(BlockNumber(block_number));
+    let state_reader = RpcStateReader::new_for_testing(BlockNumber(block_number));
     let actual_tx = state_reader.get_tx_by_hash(tx_hash).unwrap();
     if expected_version == TransactionVersion::ONE {
         assert_matches!(actual_tx, Transaction::Declare(DeclareTransaction::V1(..)))
@@ -241,13 +241,13 @@ pub fn test_get_declare_tx_by_hash(
 pub fn test_get_l1_handler_tx_by_hash() {
     // Create StateReader with block number that contain the l1 handler tx.
     let state_reader =
-        TestStateReader::new_for_testing(BlockNumber(EXAMPLE_L1_HANDLER_BLOCK_NUMBER));
+        RpcStateReader::new_for_testing(BlockNumber(EXAMPLE_L1_HANDLER_BLOCK_NUMBER));
     let actual_tx = state_reader.get_tx_by_hash(EXAMPLE_L1_HANDLER_TX_HASH).unwrap();
     assert_matches!(actual_tx, Transaction::L1Handler(..))
 }
 
 #[rstest]
-pub fn test_get_statediff_rpc(test_state_reader: TestStateReader) {
+pub fn test_get_statediff_rpc(test_state_reader: RpcStateReader) {
     assert!(test_state_reader.get_state_diff().is_ok());
 }
 
@@ -257,25 +257,25 @@ pub fn test_get_statediff_rpc(test_state_reader: TestStateReader) {
 #[case(EXAMPLE_DECLARE_V2_BLOCK_NUMBER)]
 #[case(EXAMPLE_DECLARE_V3_BLOCK_NUMBER)]
 pub fn test_get_all_blockifier_tx_in_block(#[case] block_number: u64) {
-    let state_reader = TestStateReader::new_for_testing(BlockNumber(block_number));
+    let state_reader = RpcStateReader::new_for_testing(BlockNumber(block_number));
     state_reader
         .api_txs_to_blockifier_txs_next_block(state_reader.get_all_txs_in_block().unwrap())
         .unwrap();
 }
 
 #[rstest]
-pub fn test_get_versioned_constants(test_state_reader: TestStateReader) {
+pub fn test_get_versioned_constants(test_state_reader: RpcStateReader) {
     test_state_reader.get_versioned_constants().unwrap();
 }
 
 #[rstest]
-pub fn test_get_block_context(test_state_reader: TestStateReader) {
+pub fn test_get_block_context(test_state_reader: RpcStateReader) {
     test_state_reader.get_block_context().unwrap();
 }
 
 #[rstest]
 pub fn test_get_old_block_hash(
-    test_state_reader: TestStateReader,
+    test_state_reader: RpcStateReader,
     last_constructed_block: BlockNumber,
 ) {
     test_state_reader.get_old_block_hash(last_constructed_block).unwrap();

diff --git a/...ion/src/state_reader/test_state_reader.rs → ...tion/src/state_reader/rpc_state_reader.rs b/...ion/src/state_reader/test_state_reader.rs → ...tion/src/state_reader/rpc_state_reader.rs
@@ -4,7 +4,7 @@ use std::sync::{Arc, Mutex};
 
 use apollo_gateway::errors::{serde_err_to_state_err, RPCStateReaderError};
 use apollo_gateway::rpc_objects::{BlockHeader, BlockId, GetBlockWithTxHashesParams};
-use apollo_gateway::rpc_state_reader::RpcStateReader;
+use apollo_gateway::rpc_state_reader::RpcStateReader as GatewayRpcStateReader;
 use apollo_gateway_config::config::RpcStateReaderConfig;
 use assert_matches::assert_matches;
 use blockifier::abi::constants;
@@ -104,26 +104,26 @@ impl Default for RetryConfig {
 }
 
 #[derive(Clone)]
-pub struct TestStateReader {
-    pub(crate) rpc_state_reader: RpcStateReader,
+pub struct RpcStateReader {
+    pub(crate) rpc_state_reader: GatewayRpcStateReader,
     pub(crate) retry_config: RetryConfig,
     pub(crate) chain_id: ChainId,
     #[allow(dead_code)]
     pub(crate) contract_class_mapping_dumper: Arc<Mutex<Option<StarknetContractClassMapping>>>,
 }
 
-impl Default for TestStateReader {
+impl Default for RpcStateReader {
     fn default() -> Self {
         Self {
-            rpc_state_reader: RpcStateReader::from_latest(&get_rpc_state_reader_config()),
+            rpc_state_reader: GatewayRpcStateReader::from_latest(&get_rpc_state_reader_config()),
             retry_config: RetryConfig::default(),
             chain_id: ChainId::Mainnet,
             contract_class_mapping_dumper: Arc::new(Mutex::new(None)),
         }
     }
 }
 
-impl StateReader for TestStateReader {
+impl StateReader for RpcStateReader {
     fn get_nonce_at(&self, contract_address: ContractAddress) -> StateResult<Nonce> {
         retry_request!(self.retry_config, || self.rpc_state_reader.get_nonce_at(contract_address))
     }
@@ -167,7 +167,7 @@ impl StateReader for TestStateReader {
     }
 }
 
-impl FetchCompiledClasses for TestStateReader {
+impl FetchCompiledClasses for RpcStateReader {
     fn get_compiled_classes(&self, class_hash: ClassHash) -> StateResult<CompiledClasses> {
         let contract_class =
             retry_request!(self.retry_config, || self.get_contract_class(&class_hash))?;
@@ -182,7 +182,7 @@ impl FetchCompiledClasses for TestStateReader {
     }
 }
 
-impl TestStateReader {
+impl RpcStateReader {
     pub fn new(
         config: &RpcStateReaderConfig,
         chain_id: ChainId,
@@ -194,15 +194,15 @@ impl TestStateReader {
             false => None,
         }));
         Self {
-            rpc_state_reader: RpcStateReader::from_number(config, block_number),
+            rpc_state_reader: GatewayRpcStateReader::from_number(config, block_number),
             retry_config: RetryConfig::default(),
             chain_id,
             contract_class_mapping_dumper,
         }
     }
 
     pub fn new_for_testing(block_number: BlockNumber) -> Self {
-        TestStateReader::new(&get_rpc_state_reader_config(), ChainId::Mainnet, block_number, false)
+        RpcStateReader::new(&get_rpc_state_reader_config(), ChainId::Mainnet, block_number, false)
     }
 
     /// Get the block info of the current block.
@@ -301,8 +301,7 @@ impl TestStateReader {
         block_context_next_block: BlockContext,
         transaction_executor_config: Option<TransactionExecutorConfig>,
         contract_class_manager: &ContractClassManager,
-    ) -> ReexecutionResult<TransactionExecutor<StateReaderAndContractManager<TestStateReader>>>
-    {
+    ) -> ReexecutionResult<TransactionExecutor<StateReaderAndContractManager<RpcStateReader>>> {
         let old_block_number = BlockNumber(
             block_context_next_block.block_info().block_number.0
                 - constants::STORED_BLOCK_HASH_BUFFER,
@@ -315,7 +314,7 @@ impl TestStateReader {
             contract_class_manager.clone(),
             class_cache_metrics,
         );
-        Ok(TransactionExecutor::<StateReaderAndContractManager<TestStateReader>>::pre_process_and_create(
+        Ok(TransactionExecutor::<StateReaderAndContractManager<RpcStateReader>>::pre_process_and_create(
             state_reader_and_contract_manager,
             block_context_next_block,
             Some(BlockHashAndNumber { number: old_block_number, hash: old_block_hash }),
@@ -377,7 +376,7 @@ impl TestStateReader {
     }
 }
 
-impl ReexecutionStateReader for TestStateReader {
+impl ReexecutionStateReader for RpcStateReader {
     fn get_contract_class(&self, class_hash: &ClassHash) -> StateResult<StarknetContractClass> {
         let params = json!({
             "block_id": self.rpc_state_reader.block_id,
@@ -412,13 +411,13 @@ impl ReexecutionStateReader for TestStateReader {
     }
 }
 
-pub struct ConsecutiveTestStateReaders {
-    pub last_block_state_reader: TestStateReader,
-    pub next_block_state_reader: TestStateReader,
+pub struct ConsecutiveRpcStateReaders {
+    pub last_block_state_reader: RpcStateReader,
+    pub next_block_state_reader: RpcStateReader,
     contract_class_manager: ContractClassManager,
 }
 
-impl ConsecutiveTestStateReaders {
+impl ConsecutiveRpcStateReaders {
     pub fn new(
         last_constructed_block_number: BlockNumber,
         config: Option<RpcStateReaderConfig>,
@@ -428,13 +427,13 @@ impl ConsecutiveTestStateReaders {
     ) -> Self {
         let config = config.unwrap_or(get_rpc_state_reader_config());
         Self {
-            last_block_state_reader: TestStateReader::new(
+            last_block_state_reader: RpcStateReader::new(
                 &config,
                 chain_id.clone(),
                 last_constructed_block_number,
                 dump_mode,
             ),
-            next_block_state_reader: TestStateReader::new(
+            next_block_state_reader: RpcStateReader::new(
                 &config,
                 chain_id,
                 last_constructed_block_number.next().expect("Overflow in block number"),
@@ -573,14 +572,13 @@ impl ConsecutiveTestStateReaders {
     }
 }
 
-impl ConsecutiveReexecutionStateReaders<StateReaderAndContractManager<TestStateReader>>
-    for ConsecutiveTestStateReaders
+impl ConsecutiveReexecutionStateReaders<StateReaderAndContractManager<RpcStateReader>>
+    for ConsecutiveRpcStateReaders
 {
     fn pre_process_and_create_executor(
         self,
         transaction_executor_config: Option<TransactionExecutorConfig>,
-    ) -> ReexecutionResult<TransactionExecutor<StateReaderAndContractManager<TestStateReader>>>
-    {
+    ) -> ReexecutionResult<TransactionExecutor<StateReaderAndContractManager<RpcStateReader>>> {
         self.last_block_state_reader.get_transaction_executor(
             self.next_block_state_reader.get_block_context()?,
             transaction_executor_config,