Revert to 0.14.0 3 (#10504)

* Revert "apollo_infra: apply tcp_nodelay on remote connections (#10237)"

This reverts commit 3a5aacd.

* Revert "apollo_gateway: Add gatewaye cache ratio panel (#10189)"

This reverts commit e961954.

* Revert "apollo_gateway: Add cache metrics (#10191)"

This reverts commit 4f46288.

* Revert "apollo_gateway: make class cache configurable (#10188)"

This reverts commit 4ced915.

* Revert "apollo_gateway: Add naive class cache (#10190)"

This reverts commit cfb096e.

Author: dan-starkware

crates/apollo_dashboard/resources/dev_grafana.json

@@ -630,17 +630,6 @@
             "histogram_quantile(0.95, sum by (le) (rate(gateway_validate_stateful_tx_storage_operations_bucket{cluster=~\"$cluster\", namespace=~\"$namespace\"}[5m])))"
           ],
           "extra_params": {}
-        },
-        {
-          "title": "gateway_class_cache_miss_ratio",
-          "description": "The ratio of cache misses when requesting compiled classes from the Gateway State Reader",
-          "type": "timeseries",
-          "exprs": [
-            "(increase(gateway_class_cache_misses{cluster=~\"$cluster\", namespace=~\"$namespace\"}[5m]) / (increase(gateway_class_cache_misses{cluster=~\"$cluster\", namespace=~\"$namespace\"}[5m]) + increase(gateway_class_cache_hits{cluster=~\"$cluster\", namespace=~\"$namespace\"}[5m])))"
-          ],
-          "extra_params": {
-            "unit": "percentunit"
-          }
         }
       ],
       "collapsed": true

crates/apollo_dashboard/src/panels/gateway.rs

@@ -1,9 +1,6 @@
 use apollo_gateway::metrics::{
     GATEWAY_ADD_TX_FAILURE,
     GATEWAY_ADD_TX_LATENCY,
-    GATEWAY_CLASS_CACHE_HITS,
-    GATEWAY_CLASS_CACHE_MISSES,
-    GATEWAY_METRIC_RATE_DURATION,
     GATEWAY_TRANSACTIONS_FAILED,
     GATEWAY_TRANSACTIONS_RECEIVED,
     GATEWAY_TRANSACTIONS_SENT_TO_MEMPOOL,
@@ -135,17 +132,6 @@ fn get_panel_gateway_validate_stateful_tx_storage_operations() -> Panel {
     )
 }
 
-// TODO(MatanL/Shahak): use clamp_min(X, 1) on denom to avoid division by zero.
-fn get_panel_gateway_class_cache_miss_ratio() -> Panel {
-    Panel::ratio_time_series(
-        "gateway_class_cache_miss_ratio",
-        "The ratio of cache misses when requesting compiled classes from the Gateway State Reader",
-        &GATEWAY_CLASS_CACHE_MISSES,
-        &[&GATEWAY_CLASS_CACHE_MISSES, &GATEWAY_CLASS_CACHE_HITS],
-        GATEWAY_METRIC_RATE_DURATION,
-    )
-}
-
 pub(crate) fn get_gateway_row() -> Row {
     Row::new(
         "Gateway",
@@ -160,7 +146,6 @@ pub(crate) fn get_gateway_row() -> Row {
             get_panel_gateway_transactions_sent_to_mempool(),
             get_panel_gateway_validate_stateful_tx_storage_time(),
             get_panel_gateway_validate_stateful_tx_storage_operations(),
-            get_panel_gateway_class_cache_miss_ratio(),
         ],
     )
 }

crates/apollo_deployments/resources/app_configs/gateway_config.json

@@ -2,7 +2,6 @@
   "gateway_config.authorized_declarer_accounts": "",
   "gateway_config.authorized_declarer_accounts.#is_none": true,
   "gateway_config.block_declare": false,
-  "gateway_config.class_cache_size": 250,
   "gateway_config.stateful_tx_validator_config.max_allowed_nonce_gap": 200,
   "gateway_config.stateful_tx_validator_config.max_nonce_for_validation_skip": "0x1",
   "gateway_config.stateful_tx_validator_config.min_gas_price_percentage": 100,
@@ -19,4 +18,4 @@
   "gateway_config.stateless_tx_validator_config.min_sierra_version.major": 1,
   "gateway_config.stateless_tx_validator_config.min_sierra_version.minor": 1,
   "gateway_config.stateless_tx_validator_config.min_sierra_version.patch": 0
-}
+}

crates/apollo_gateway/src/config.rs

@@ -19,46 +19,24 @@ use crate::compiler_version::VersionId;
 
 const JSON_RPC_VERSION: &str = "2.0";
 
-#[derive(Clone, Debug, Serialize, Deserialize, Validate, PartialEq)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize, Validate, PartialEq)]
 pub struct GatewayConfig {
     pub stateless_tx_validator_config: StatelessTransactionValidatorConfig,
     pub stateful_tx_validator_config: StatefulTransactionValidatorConfig,
     pub chain_info: ChainInfo,
     pub block_declare: bool,
     #[serde(default, deserialize_with = "deserialize_optional_contract_addresses")]
     pub authorized_declarer_accounts: Option<Vec<ContractAddress>>,
-    pub class_cache_size: usize,
-}
-
-impl Default for GatewayConfig {
-    fn default() -> Self {
-        Self {
-            stateless_tx_validator_config: StatelessTransactionValidatorConfig::default(),
-            stateful_tx_validator_config: StatefulTransactionValidatorConfig::default(),
-            chain_info: ChainInfo::default(),
-            block_declare: false,
-            authorized_declarer_accounts: None,
-            class_cache_size: 250,
-        }
-    }
 }
 
 impl SerializeConfig for GatewayConfig {
     fn dump(&self) -> BTreeMap<ParamPath, SerializedParam> {
-        let mut dump = BTreeMap::from_iter([
-            ser_param(
-                "block_declare",
-                &self.block_declare,
-                "If true, the gateway will block declare transactions.",
-                ParamPrivacyInput::Public,
-            ),
-            ser_param(
-                "class_cache_size",
-                &self.class_cache_size,
-                "Maximum number of compiled contract classes to cache in memory.",
-                ParamPrivacyInput::Public,
-            ),
-        ]);
+        let mut dump = BTreeMap::from_iter([ser_param(
+            "block_declare",
+            &self.block_declare,
+            "If true, the gateway will block declare transactions.",
+            ParamPrivacyInput::Public,
+        )]);
         dump.extend(prepend_sub_config_name(
             self.stateless_tx_validator_config.dump(),
             "stateless_tx_validator_config",

crates/apollo_gateway/src/gateway.rs

@@ -25,7 +25,6 @@ use apollo_proc_macros::sequencer_latency_histogram;
 use apollo_state_sync_types::communication::SharedStateSyncClient;
 use axum::async_trait;
 use blockifier::context::ChainInfo;
-use starknet_api::class_cache::GlobalContractCache;
 use starknet_api::rpc_transaction::{
     InternalRpcTransaction,
     InternalRpcTransactionWithoutTxHash,
@@ -280,12 +279,9 @@ pub fn create_gateway(
     class_manager_client: SharedClassManagerClient,
     runtime: tokio::runtime::Handle,
 ) -> Gateway {
-    let class_cache = GlobalContractCache::new(config.class_cache_size);
-
     let state_reader_factory = Arc::new(SyncStateReaderFactory {
         shared_state_sync_client,
         class_manager_client: class_manager_client.clone(),
-        class_cache,
         runtime,
     });
     let transaction_converter =

crates/apollo_gateway/src/gateway_test.rs

@@ -92,7 +92,6 @@ fn config() -> GatewayConfig {
         chain_info: ChainInfo::create_for_testing(),
         block_declare: false,
         authorized_declarer_accounts: None,
-        class_cache_size: 1,
     }
 }
 

crates/apollo_gateway/src/metrics.rs

@@ -47,8 +47,6 @@ define_metrics!(
         MetricHistogram { GATEWAY_VALIDATE_TX_LATENCY, "gateway_validate_tx_latency", "Latency of gateway validate function in secs" },
         MetricHistogram { GATEWAY_VALIDATE_STATEFUL_TX_STORAGE_TIME, "gateway_validate_stateful_tx_storage_time", "Total time spent in storage operations in secs during stateful tx validation" },
         MetricHistogram { GATEWAY_VALIDATE_STATEFUL_TX_STORAGE_OPERATIONS, "gateway_validate_stateful_tx_storage_operations", "Total number of storage operations during stateful tx validation"},
-        MetricCounter { GATEWAY_CLASS_CACHE_HITS, "gateway_class_cache_hits", "Counter of class cache hits", init=0 },
-        MetricCounter { GATEWAY_CLASS_CACHE_MISSES, "gateway_class_cache_misses", "Counter of class cache misses", init=0 },
     },
 );
 
@@ -245,8 +243,6 @@ impl Drop for GatewayMetricHandle {
     }
 }
 
-pub const GATEWAY_METRIC_RATE_DURATION: &str = "5m";
-
 pub(crate) fn register_metrics() {
     GATEWAY_TRANSACTIONS_RECEIVED.register();
     GATEWAY_TRANSACTIONS_FAILED.register();
@@ -256,6 +252,4 @@ pub(crate) fn register_metrics() {
     GATEWAY_VALIDATE_TX_LATENCY.register();
     GATEWAY_VALIDATE_STATEFUL_TX_STORAGE_TIME.register();
     GATEWAY_VALIDATE_STATEFUL_TX_STORAGE_OPERATIONS.register();
-    GATEWAY_CLASS_CACHE_HITS.register();
-    GATEWAY_CLASS_CACHE_MISSES.register();
 }

crates/apollo_gateway/src/sync_state_reader.rs

@@ -19,7 +19,6 @@ use blockifier::state::state_api::{StateReader as BlockifierStateReader, StateRe
 use futures::executor::block_on;
 use lazy_static::lazy_static;
 use starknet_api::block::{BlockHash, BlockInfo, BlockNumber, GasPriceVector, GasPrices};
-use starknet_api::class_cache::GlobalContractCache;
 use starknet_api::contract_class::ContractClass;
 use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce};
 use starknet_api::data_availability::L1DataAvailabilityMode;
@@ -28,8 +27,6 @@ use starknet_api::state::StorageKey;
 use starknet_types_core::felt::Felt;
 
 use crate::metrics::{
-    GATEWAY_CLASS_CACHE_HITS,
-    GATEWAY_CLASS_CACHE_MISSES,
     GATEWAY_VALIDATE_STATEFUL_TX_STORAGE_OPERATIONS,
     GATEWAY_VALIDATE_STATEFUL_TX_STORAGE_TIME,
 };
@@ -41,23 +38,20 @@ pub(crate) struct SyncStateReader {
     block_number: BlockNumber,
     state_sync_client: SharedStateSyncClientMetricWrapper,
     class_manager_client: SharedClassManagerClient,
-    class_cache: GlobalContractCache<RunnableCompiledClass>,
     runtime: tokio::runtime::Handle,
 }
 
 impl SyncStateReader {
     pub fn from_number(
         state_sync_client: SharedStateSyncClient,
         class_manager_client: SharedClassManagerClient,
-        class_cache: GlobalContractCache<RunnableCompiledClass>,
         block_number: BlockNumber,
         runtime: tokio::runtime::Handle,
     ) -> Self {
         Self {
             block_number,
             state_sync_client: SharedStateSyncClientMetricWrapper::new(state_sync_client),
             class_manager_client,
-            class_cache,
             runtime,
         }
     }
@@ -131,19 +125,6 @@ impl BlockifierStateReader for SyncStateReader {
     }
 
     fn get_compiled_class(&self, class_hash: ClassHash) -> StateResult<RunnableCompiledClass> {
-        // Check cache first.
-        // Note: GlobalContractCache uses std::sync::Mutex which blocks the thread.
-        // This is safe here because get_compiled_class() is always called from
-        // spawn_blocking contexts (see ProcessTxBlockingTask in gateway.rs), not
-        // directly from async code. Cache operations are very fast (hash map lookups),
-        // so the blocking time is minimal (microseconds).
-        if let Some(cached_class) = self.class_cache.get(&class_hash) {
-            GATEWAY_CLASS_CACHE_HITS.increment(1);
-            return Ok(cached_class);
-        }
-
-        GATEWAY_CLASS_CACHE_MISSES.increment(1);
-
         let mut is_class_declared = self
             .runtime
             .block_on(self.state_sync_client.is_class_declared_at(self.block_number, class_hash))
@@ -167,18 +148,14 @@ impl BlockifierStateReader for SyncStateReader {
                  was declared",
             );
 
-        let runnable_class = match contract_class {
+        match contract_class {
             ContractClass::V1(casm_contract_class) => {
-                RunnableCompiledClass::V1(casm_contract_class.try_into()?)
+                Ok(RunnableCompiledClass::V1(casm_contract_class.try_into()?))
             }
             ContractClass::V0(deprecated_contract_class) => {
-                RunnableCompiledClass::V0(deprecated_contract_class.try_into()?)
+                Ok(RunnableCompiledClass::V0(deprecated_contract_class.try_into()?))
             }
-        };
-
-        // Cache the compiled class before returning
-        self.class_cache.set(class_hash, runnable_class.clone());
-        Ok(runnable_class)
+        }
     }
 
     fn get_class_hash_at(&self, contract_address: ContractAddress) -> StateResult<ClassHash> {
@@ -304,16 +281,9 @@ impl Drop for SharedStateSyncClientMetricWrapper {
     }
 }
 
-/// Factory for creating SyncStateReader instances with a shared class cache.
-///
-/// The class cache is shared across all state readers created by this factory,
-/// maximizing cache hit rates across transaction validations. The cache uses
-/// std::sync::Mutex internally, which is safe because state reader operations
-/// are always executed in spawn_blocking contexts (see ProcessTxBlockingTask).
 pub(crate) struct SyncStateReaderFactory {
     pub shared_state_sync_client: SharedStateSyncClient,
     pub class_manager_client: SharedClassManagerClient,
-    pub class_cache: GlobalContractCache<RunnableCompiledClass>,
     pub runtime: tokio::runtime::Handle,
 }
 
@@ -331,7 +301,6 @@ impl StateReaderFactory for SyncStateReaderFactory {
         Ok(Box::new(SyncStateReader::from_number(
             self.shared_state_sync_client.clone(),
             self.class_manager_client.clone(),
-            self.class_cache.clone(),
             latest_block_number,
             self.runtime.clone(),
         )))

crates/apollo_gateway/src/sync_state_reader_test.rs

@@ -25,18 +25,13 @@ use starknet_api::block::{
     GasPrices,
     NonzeroGasPrice,
 };
-use starknet_api::class_cache::GlobalContractCache;
 use starknet_api::contract_class::{ContractClass, SierraVersion};
 use starknet_api::core::{ClassHash, SequencerContractAddress};
 use starknet_api::data_availability::L1DataAvailabilityMode;
 use starknet_api::{class_hash, contract_address, felt, nonce, storage_key};
 
 use crate::state_reader::MempoolStateReader;
 use crate::sync_state_reader::{SyncStateReader, OLD_DEPLOY_CLASS_HASH_WHITELIST};
-
-fn create_test_class_cache() -> GlobalContractCache<RunnableCompiledClass> {
-    GlobalContractCache::new(1)
-}
 #[tokio::test]
 async fn test_get_block_info() {
     let mut mock_state_sync_client = MockStateSyncClient::new();
@@ -73,7 +68,6 @@ async fn test_get_block_info() {
     let state_sync_reader = SyncStateReader::from_number(
         Arc::new(mock_state_sync_client),
         Arc::new(mock_class_manager_client),
-        create_test_class_cache(),
         block_number,
         tokio::runtime::Handle::current(),
     );
@@ -130,7 +124,6 @@ async fn test_get_storage_at() {
     let state_sync_reader = SyncStateReader::from_number(
         Arc::new(mock_state_sync_client),
         Arc::new(mock_class_manager_client),
-        create_test_class_cache(),
         block_number,
         tokio::runtime::Handle::current(),
     );
@@ -161,7 +154,6 @@ async fn test_get_nonce_at() {
     let state_sync_reader = SyncStateReader::from_number(
         Arc::new(mock_state_sync_client),
         Arc::new(mock_class_manager_client),
-        create_test_class_cache(),
         block_number,
         tokio::runtime::Handle::current(),
     );
@@ -191,7 +183,6 @@ async fn test_get_class_hash_at() {
     let state_sync_reader = SyncStateReader::from_number(
         Arc::new(mock_state_sync_client),
         Arc::new(mock_class_manager_client),
-        create_test_class_cache(),
         block_number,
         tokio::runtime::Handle::current(),
     );
@@ -286,7 +277,6 @@ async fn test_get_compiled_class(
     let state_sync_reader = SyncStateReader::from_number(
         Arc::new(mock_state_sync_client),
         Arc::new(mock_class_manager_client),
-        create_test_class_cache(),
         block_number,
         tokio::runtime::Handle::current(),
     );

crates/apollo_infra/src/component_client/remote_component_client.rs

@@ -130,16 +130,12 @@ where
         metrics: &'static RemoteClientMetrics,
     ) -> Self {
         let uri = format!("http://{url}:{port}/").parse().unwrap();
-        let mut connector = hyper::client::connect::HttpConnector::new();
-        connector.set_nodelay(true);
         let client = Client::builder()
             .http2_only(true)
             .pool_max_idle_per_host(config.idle_connections)
             .pool_idle_timeout(Duration::from_millis(config.idle_timeout_ms))
-            .build(connector);
-
+            .build_http();
         debug!("RemoteComponentClient created with URI: {uri:?}");
-
         Self { uri, client, config, metrics, _req: PhantomData, _res: PhantomData }
     }