blockifier_reexecution: move rpc_state_reader from apollo_gateway into

Author: lev-starkware

Cargo.lock

@@ -30,20 +30,16 @@ apollo_metrics.workspace = true
 apollo_network_types.workspace = true
 apollo_proc_macros.workspace = true
 apollo_proof_manager_types.workspace = true
-apollo_rpc.workspace = true
 apollo_state_sync_types.workspace = true
 async-trait.workspace = true
 axum.workspace = true
 blockifier.workspace = true
 blockifier_test_utils = { workspace = true, optional = true }
-cairo-lang-starknet-classes.workspace = true
 clap.workspace = true
 google-cloud-storage.workspace = true
 mempool_test_utils.workspace = true
 mockall.workspace = true
 num-rational.workspace = true
-reqwest.workspace = true
-serde.workspace = true
 serde_json.workspace = true
 starknet-types-core.workspace = true
 starknet_api.workspace = true

crates/apollo_gateway/Cargo.toml

@@ -10,9 +10,6 @@ use apollo_gateway_types::errors::GatewaySpecError;
 use apollo_gateway_types::gateway_types::SUPPORTED_TRANSACTION_VERSIONS;
 use apollo_mempool_types::communication::{MempoolClientError, MempoolClientResult};
 use apollo_mempool_types::errors::MempoolError;
-use blockifier::state::errors::StateError;
-use reqwest::StatusCode;
-use serde_json::{Error as SerdeError, Value};
 use starknet_api::block::GasPrice;
 use starknet_api::executable_transaction::ValidateCompiledClassHashError;
 use starknet_api::execution_resources::GasAmount;
@@ -21,8 +18,6 @@ use starknet_api::StarknetApiError;
 use thiserror::Error;
 use tracing::{debug, error, warn};
 
-use crate::rpc_objects::{RpcErrorCode, RpcErrorResponse};
-
 pub type GatewayResult<T> = Result<T, StarknetError>;
 
 #[derive(Debug, Error)]
@@ -301,49 +296,6 @@ pub type StatelessTransactionValidatorResult<T> = Result<T, StatelessTransaction
 
 pub type StatefulTransactionValidatorResult<T> = Result<T, StarknetError>;
 
-#[derive(Debug, Error)]
-pub enum RPCStateReaderError {
-    #[error("Block not found for request {0}")]
-    BlockNotFound(Value),
-    #[error("Class hash not found for request {0}")]
-    ClassHashNotFound(Value),
-    #[error("Contract address not found for request {0}")]
-    ContractAddressNotFound(Value),
-    #[error("Failed to parse gas price {:?}", 0)]
-    GasPriceParsingFailure(GasPrice),
-    #[error("Invalid params: {0:?}")]
-    InvalidParams(Box<RpcErrorResponse>),
-    #[error("RPC error: {0}")]
-    RPCError(StatusCode),
-    #[error(transparent)]
-    ReqwestError(#[from] reqwest::Error),
-    #[error("Unexpected error code: {0}")]
-    UnexpectedErrorCode(RpcErrorCode),
-    #[error(transparent)]
-    StarknetApi(#[from] StarknetApiError),
-}
-
-pub type RPCStateReaderResult<T> = Result<T, RPCStateReaderError>;
-
-impl From<RPCStateReaderError> for StateError {
-    fn from(err: RPCStateReaderError) -> Self {
-        match err {
-            RPCStateReaderError::ClassHashNotFound(request) => {
-                match serde_json::from_value(request["params"]["class_hash"].clone()) {
-                    Ok(class_hash) => StateError::UndeclaredClassHash(class_hash),
-                    Err(e) => serde_err_to_state_err(e),
-                }
-            }
-            _ => StateError::StateReadError(err.to_string()),
-        }
-    }
-}
-
-// Converts a serde error to the error type of the state reader.
-pub fn serde_err_to_state_err(err: SerdeError) -> StateError {
-    StateError::StateReadError(format!("Failed to parse rpc result {:?}", err.to_string()))
-}
-
 pub fn transaction_converter_err_to_deprecated_gw_err(
     tx_signature: &TransactionSignature,
     err: TransactionConverterError,

crates/apollo_gateway/src/errors.rs

@@ -4,10 +4,6 @@ pub mod gateway;
 pub mod gateway_fixed_block_state_reader;
 pub mod metrics;
 pub mod proof_archive_writer;
-pub mod rpc_objects;
-pub mod rpc_state_reader;
-#[cfg(test)]
-mod rpc_state_reader_test;
 mod state_reader;
 #[cfg(any(feature = "testing", test))]
 mod state_reader_test_utils;

crates/apollo_gateway/src/lib.rs

@@ -1,3 +1,2 @@
 pub mod compiler_version;
 pub mod config;
-pub mod rpc_state_reader_config;

crates/apollo_gateway_config/src/lib.rs

@@ -13,8 +13,8 @@ cairo_native = ["blockifier/cairo_native"]
 [dependencies]
 apollo_compile_to_casm.workspace = true
 apollo_compile_to_casm_types.workspace = true
-apollo_gateway.workspace = true
-apollo_gateway_config.workspace = true
+apollo_config.workspace = true
+apollo_rpc.workspace = true
 apollo_rpc_execution.workspace = true
 apollo_sierra_compilation_config.workspace = true
 assert_matches.workspace = true
@@ -24,6 +24,7 @@ flate2.workspace = true
 google-cloud-storage.workspace = true
 indexmap = { workspace = true, features = ["serde"] }
 pretty_assertions.workspace = true
+reqwest = { workspace = true, features = ["blocking", "json"] }
 retry.workspace = true
 serde.workspace = true
 serde_json.workspace = true
@@ -32,9 +33,13 @@ starknet-types-core.workspace = true
 starknet_api.workspace = true
 thiserror.workspace = true
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+validator.workspace = true
 
 [dev-dependencies]
+cairo-lang-starknet-classes.workspace = true
+mockito.workspace = true
 rstest.workspace = true
+starknet_api = { workspace = true, features = ["testing"] }
 
 [lints]
 workspace = true

crates/blockifier_reexecution/Cargo.toml

@@ -1,12 +1,60 @@
-use apollo_gateway::errors::RPCStateReaderError;
 use blockifier::blockifier::transaction_executor::TransactionExecutorError;
 use blockifier::blockifier_versioned_constants::VersionedConstantsError;
 use blockifier::state::errors::StateError;
 use blockifier::transaction::errors::TransactionExecutionError;
-use serde_json::Error as SerdeError;
+use reqwest::StatusCode;
+use serde_json::{Error as SerdeError, Value};
+use starknet_api::block::GasPrice;
 use starknet_api::StarknetApiError;
 use thiserror::Error;
 
+use crate::rpc_state_reader::rpc_objects::{RpcErrorCode, RpcErrorResponse};
+
+#[derive(Debug, Error)]
+pub enum RPCStateReaderError {
+    #[error("Block not found for request {0}")]
+    BlockNotFound(Value),
+    #[error("Class hash not found for request {0}")]
+    ClassHashNotFound(Value),
+    #[error("Contract address not found for request {0}")]
+    ContractAddressNotFound(Value),
+    #[error("Failed to parse gas price {:?}", 0)]
+    GasPriceParsingFailure(GasPrice),
+    #[error("Invalid params: {0:?}")]
+    InvalidParams(Box<RpcErrorResponse>),
+    #[error("RPC error: {0}")]
+    RPCError(StatusCode),
+    #[error(transparent)]
+    ReqwestError(#[from] reqwest::Error),
+    #[error("Unexpected error code: {0}")]
+    UnexpectedErrorCode(RpcErrorCode),
+    #[error(transparent)]
+    StarknetApi(#[from] StarknetApiError),
+    #[error("Internal error: {0}")]
+    InternalError(String),
+}
+
+pub type RPCStateReaderResult<T> = Result<T, RPCStateReaderError>;
+
+impl From<RPCStateReaderError> for StateError {
+    fn from(err: RPCStateReaderError) -> Self {
+        match err {
+            RPCStateReaderError::ClassHashNotFound(request) => {
+                match serde_json::from_value(request["params"]["class_hash"].clone()) {
+                    Ok(class_hash) => StateError::UndeclaredClassHash(class_hash),
+                    Err(e) => serde_err_to_state_err(e),
+                }
+            }
+            _ => StateError::StateReadError(err.to_string()),
+        }
+    }
+}
+
+// Converts a serde error to the error type of the state reader.
+pub fn serde_err_to_state_err(err: SerdeError) -> StateError {
+    StateError::StateReadError(format!("Failed to parse rpc result {:?}", err.to_string()))
+}
+
 #[derive(Debug, Error)]
 #[allow(clippy::enum_variant_names)]
 pub enum ReexecutionError {

crates/blockifier_reexecution/src/errors.rs

@@ -1,17 +1,18 @@
 pub mod cli;
 pub mod compile;
 pub mod errors;
+pub mod rpc_state_reader;
 pub mod serde_utils;
 pub mod state_reader;
 pub mod utils;
 
-use apollo_gateway_config::rpc_state_reader_config::RpcStateReaderConfig;
 use blockifier::blockifier::config::ContractClassManagerConfig;
 use blockifier::blockifier::transaction_executor::TransactionExecutionOutput;
 use blockifier::context::BlockContext;
 use blockifier::state::cached_state::StateMaps;
 use blockifier::state::contract_class_manager::ContractClassManager;
 use errors::ReexecutionResult;
+use rpc_state_reader::config::RpcStateReaderConfig;
 use starknet_api::block::BlockNumber;
 use starknet_api::core::ChainId;
 use starknet_api::transaction::Transaction;

crates/blockifier_reexecution/src/lib.rs

@@ -1,7 +1,6 @@
 use std::fs;
 use std::path::Path;
 
-use apollo_gateway_config::rpc_state_reader_config::RpcStateReaderConfig;
 use blockifier::blockifier::config::ContractClassManagerConfig;
 use blockifier::state::contract_class_manager::ContractClassManager;
 use blockifier_reexecution::cli::{
@@ -11,6 +10,7 @@ use blockifier_reexecution::cli::{
     TransactionInput,
     FULL_RESOURCES_DIR,
 };
+use blockifier_reexecution::rpc_state_reader::config::RpcStateReaderConfig;
 use blockifier_reexecution::state_reader::offline_state_reader::OfflineConsecutiveStateReaders;
 use blockifier_reexecution::state_reader::reexecution_state_reader::ConsecutiveReexecutionStateReaders;
 use blockifier_reexecution::state_reader::rpc_state_reader::ConsecutiveRpcStateReaders;

crates/blockifier_reexecution/src/main.rs

@@ -25,7 +25,7 @@ impl Default for RpcStateReaderConfig {
     }
 }
 
-#[cfg(any(feature = "testing", test))]
+#[cfg(test)]
 impl RpcStateReaderConfig {
     pub fn create_for_testing() -> Self {
         Self::from_url("http://localhost:8080".to_string())