NDEV-3112. Optimize getting of deactivated features

evm_loader/lib/Cargo.toml

@@ -53,6 +53,7 @@ lazy_static = "1.5.0"
 elsa = "1.10.0"
 arrayref = "0.3.8"
 futures = "0.3.30"
+once_cell = "1.19.0"
 
 [dev-dependencies]
 hex-literal = "0.4.1"

evm_loader/lib/src/rpc/db_call_client.rs

@@ -1,4 +1,5 @@
 use super::{e, Rpc, SliceConfig};
+use crate::types::deactivated_features::get_deactivated_features;
 use crate::types::{TracerDb, TracerDbTrait};
 use crate::NeonError;
 use crate::NeonError::RocksDb;
@@ -88,6 +89,6 @@ impl Rpc for CallDbClient {
     }
 
     async fn get_deactivated_solana_features(&self) -> ClientResult<Vec<Pubkey>> {
-        Ok(vec![]) // TODO
+        get_deactivated_features(self, Some(self.slot)).await
     }
 }

evm_loader/lib/src/rpc/validator_client.rs

@@ -1,4 +1,4 @@
-use crate::{config::APIOptions, Config};
+use crate::{config::APIOptions, types::deactivated_features::get_deactivated_features, Config};
 
 use super::{Rpc, SliceConfig};
 use async_trait::async_trait;
@@ -179,52 +179,6 @@ impl Rpc for CloneRpcClient {
     }
 
     async fn get_deactivated_solana_features(&self) -> ClientResult<Vec<Pubkey>> {
-        use std::time::{Duration, Instant};
-        use tokio::sync::Mutex;
-
-        struct Cache {
-            data: Vec<Pubkey>,
-            timestamp: Instant,
-        }
-
-        static CACHE: Mutex<Option<Cache>> = Mutex::const_new(None);
-        let mut cache = CACHE.lock().await;
-
-        if let Some(cache) = cache.as_ref() {
-            if cache.timestamp.elapsed() < Duration::from_secs(24 * 60 * 60) {
-                return Ok(cache.data.clone());
-            }
-        }
-
-        let feature_keys: Vec<Pubkey> = solana_sdk::feature_set::FEATURE_NAMES
-            .keys()
-            .copied()
-            .collect();
-
-        let features = Rpc::get_multiple_accounts(self, &feature_keys).await?;
-
-        let mut result = Vec::with_capacity(feature_keys.len());
-        for (pubkey, feature) in feature_keys.iter().zip(features) {
-            let is_activated = feature
-                .and_then(|a| solana_sdk::feature::from_account(&a))
-                .and_then(|f| f.activated_at)
-                .is_some();
-
-            if !is_activated {
-                result.push(*pubkey);
-            }
-        }
-
-        for feature in &result {
-            debug!("Deactivated feature: {}", feature);
-        }
-
-        cache.replace(Cache {
-            data: result.clone(),
-            timestamp: Instant::now(),
-        });
-        drop(cache);
-
-        Ok(result)
+        get_deactivated_features(self, None).await
     }
 }

evm_loader/lib/src/types/deactivated_features.rs

@@ -0,0 +1,82 @@
+// use crate::tracing::tracers::state_diff::Account;
+use crate::rpc::Rpc;
+use once_cell::sync::Lazy;
+use solana_client::client_error::Result as ClientResult;
+use solana_sdk::pubkey::Pubkey;
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+static DEACTIVATED_FEATURES_UPDATE_SLOTS: u64 = 24 * 60 * 60; // approximately each 12h
+
+#[derive(Debug, Eq, PartialEq, Clone, Default)]
+struct DeactivatedFeaturesCache {
+    // feature to slot when activated, if not then None
+    pub data: HashMap<Pubkey, Option<u64>>,
+    pub last_slot: u64,
+}
+
+impl DeactivatedFeaturesCache {
+    fn should_update(&self, slot: u64) -> bool {
+        self.last_slot >= DEACTIVATED_FEATURES_UPDATE_SLOTS + slot
+    }
+}
+
+static DEACTIVATED_FEATURES: Lazy<Arc<Mutex<DeactivatedFeaturesCache>>> =
+    Lazy::new(|| Arc::new(Mutex::new(DeactivatedFeaturesCache::default())));
+
+async fn get_multiple_features(rpc: &dyn Rpc) -> ClientResult<HashMap<Pubkey, Option<u64>>> {
+    let feature_keys: Vec<Pubkey> = solana_sdk::feature_set::FEATURE_NAMES
+        .keys()
+        .copied()
+        .collect();
+
+    let features = Rpc::get_multiple_accounts(rpc, &feature_keys).await?;
+
+    let mut result = HashMap::<Pubkey, Option<u64>>::new();
+    for (pubkey, feature) in feature_keys.iter().zip(features) {
+        let slot = feature
+            .and_then(|a| solana_sdk::feature::from_account(&a))
+            .and_then(|f| f.activated_at);
+
+        result.insert(*pubkey, slot);
+    }
+
+    Ok(result)
+}
+
+async fn deactivated_features_get_instance(
+    rpc: &dyn Rpc,
+) -> ClientResult<DeactivatedFeaturesCache> {
+    let mut cache = DEACTIVATED_FEATURES.lock().await;
+
+    let rpc_slot = rpc.get_slot().await?;
+    if cache.should_update(rpc_slot) {
+        cache.last_slot = rpc_slot;
+        cache.data = get_multiple_features(rpc).await?;
+    }
+
+    Ok((*cache).clone())
+}
+
+pub async fn get_deactivated_features(
+    rpc: &dyn Rpc,
+    slot: Option<u64>,
+) -> ClientResult<Vec<Pubkey>> {
+    let features = deactivated_features_get_instance(rpc).await?;
+
+    Ok(features
+        .data
+        .into_iter()
+        .filter_map(|(pubkey, activated_at)| match (slot, activated_at) {
+            (_, None) => Some(pubkey),
+            (Some(slot), Some(activated_at)) => {
+                if activated_at > slot {
+                    return Some(pubkey);
+                }
+                None
+            }
+            (None, Some(_)) => None,
+        })
+        .collect())
+}

evm_loader/lib/src/types/mod.rs

@@ -1,6 +1,6 @@
-pub mod tracer_ch_common;
-
+pub mod deactivated_features;
 pub mod programs_cache;
+pub mod tracer_ch_common;
 pub(crate) mod tracer_ch_db;
 pub mod tracer_rocks_db;