Simplify ConfigAndPreset

beacon_node/http_api/src/lib.rs

@@ -2763,7 +2763,7 @@ pub fn serve<T: BeaconChainTypes>(
             move |task_spawner: TaskSpawner<T::EthSpec>, chain: Arc<BeaconChain<T>>| {
                 task_spawner.blocking_json_task(Priority::P0, move || {
                     let config_and_preset =
-                        ConfigAndPreset::from_chain_spec::<T::EthSpec>(&chain.spec, None);
+                        ConfigAndPreset::from_chain_spec::<T::EthSpec>(&chain.spec);
                     Ok(api_types::GenericResponse::from(config_and_preset))
                 })
             },

beacon_node/http_api/tests/tests.rs

@@ -2616,13 +2616,19 @@ impl ApiTester {
     }
 
     pub async fn test_get_config_spec(self) -> Self {
-        let result = self
-            .client
-            .get_config_spec::<ConfigAndPresetFulu>()
-            .await
-            .map(|res| ConfigAndPreset::Fulu(res.data))
-            .unwrap();
-        let expected = ConfigAndPreset::from_chain_spec::<E>(&self.chain.spec, None);
+        let result = if self.chain.spec.is_fulu_scheduled() {
+            self.client
+                .get_config_spec::<ConfigAndPresetFulu>()
+                .await
+                .map(|res| ConfigAndPreset::Fulu(res.data))
+        } else {
+            self.client
+                .get_config_spec::<ConfigAndPresetElectra>()
+                .await
+                .map(|res| ConfigAndPreset::Electra(res.data))
+        }
+        .unwrap();
+        let expected = ConfigAndPreset::from_chain_spec::<E>(&self.chain.spec);
 
         assert_eq!(result, expected);
 

consensus/types/src/config_and_preset.rs

@@ -1,6 +1,6 @@
 use crate::{
     consts::altair, consts::deneb, AltairPreset, BasePreset, BellatrixPreset, CapellaPreset,
-    ChainSpec, Config, DenebPreset, ElectraPreset, EthSpec, ForkName, FuluPreset,
+    ChainSpec, Config, DenebPreset, ElectraPreset, EthSpec, FuluPreset,
 };
 use maplit::hashmap;
 use serde::{Deserialize, Serialize};
@@ -43,7 +43,7 @@ pub struct ConfigAndPreset {
 }
 
 impl ConfigAndPreset {
-    pub fn from_chain_spec<E: EthSpec>(spec: &ChainSpec, fork_name: Option<ForkName>) -> Self {
+    pub fn from_chain_spec<E: EthSpec>(spec: &ChainSpec) -> Self {
         let mut config = Config::from_chain_spec::<E>(spec);
         let base_preset = BasePreset::from_chain_spec::<E>(spec);
         let altair_preset = AltairPreset::from_chain_spec::<E>(spec);
@@ -52,15 +52,7 @@ impl ConfigAndPreset {
         let deneb_preset = DenebPreset::from_chain_spec::<E>(spec);
         let extra_fields = get_extra_fields(spec);
 
-        // Remove blob schedule for backwards-compatibility.
-        if spec.fulu_fork_epoch.is_none() {
-            config.blob_schedule.set_skip_serializing();
-        }
-
-        if spec.fulu_fork_epoch.is_some()
-            || fork_name.is_none()
-            || fork_name == Some(ForkName::Fulu)
-        {
+        if spec.is_fulu_scheduled() {
             let electra_preset = ElectraPreset::from_chain_spec::<E>(spec);
             let fulu_preset = FuluPreset::from_chain_spec::<E>(spec);
 
@@ -75,10 +67,10 @@ impl ConfigAndPreset {
                 fulu_preset,
                 extra_fields,
             })
-        } else if spec.electra_fork_epoch.is_some()
-            || fork_name.is_none()
-            || fork_name == Some(ForkName::Electra)
-        {
+        } else {
+            // Remove blob schedule for backwards-compatibility.
+            config.blob_schedule.set_skip_serializing();
+
             let electra_preset = ElectraPreset::from_chain_spec::<E>(spec);
 
             ConfigAndPreset::Electra(ConfigAndPresetElectra {
@@ -91,16 +83,6 @@ impl ConfigAndPreset {
                 electra_preset,
                 extra_fields,
             })
-        } else {
-            ConfigAndPreset::Deneb(ConfigAndPresetDeneb {
-                config,
-                base_preset,
-                altair_preset,
-                bellatrix_preset,
-                capella_preset,
-                deneb_preset,
-                extra_fields,
-            })
         }
     }
 }
@@ -159,8 +141,7 @@ mod test {
         let mut mainnet_spec = ChainSpec::mainnet();
         // setting fulu_fork_epoch because we are roundtripping a fulu config
         mainnet_spec.fulu_fork_epoch = Some(Epoch::new(42));
-        let mut yamlconfig =
-            ConfigAndPreset::from_chain_spec::<MainnetEthSpec>(&mainnet_spec, None);
+        let mut yamlconfig = ConfigAndPreset::from_chain_spec::<MainnetEthSpec>(&mainnet_spec);
         let (k1, v1) = ("SAMPLE_HARDFORK_KEY1", "123456789");
         let (k2, v2) = ("SAMPLE_HARDFORK_KEY2", "987654321");
         let (k3, v3) = ("SAMPLE_HARDFORK_KEY3", 32);

testing/validator_test_rig/src/mock_beacon_node.rs

@@ -41,7 +41,7 @@ impl<E: EthSpec> MockBeaconNode<E> {
 
     pub fn mock_config_spec(&mut self, spec: &ChainSpec) {
         let path_pattern = Regex::new(r"^/eth/v1/config/spec$").unwrap();
-        let config_and_preset = ConfigAndPreset::from_chain_spec::<E>(spec, None);
+        let config_and_preset = ConfigAndPreset::from_chain_spec::<E>(spec);
         let data = GenericResponse::from(config_and_preset);
         self.server
             .mock("GET", Matcher::Regex(path_pattern.to_string()))

validator_client/http_api/src/lib.rs

@@ -315,7 +315,7 @@ pub fn serve<T: 'static + SlotClock + Clone, E: EthSpec>(
         .and(spec_filter.clone())
         .then(|spec: Arc<_>| {
             blocking_json_task(move || {
-                let config = ConfigAndPreset::from_chain_spec::<E>(&spec, None);
+                let config = ConfigAndPreset::from_chain_spec::<E>(&spec);
                 Ok(api_types::GenericResponse::from(config))
             })
         });

validator_client/http_api/src/test_utils.rs

@@ -260,7 +260,7 @@ impl ApiTester {
             .await
             .map(|res| ConfigAndPreset::Fulu(res.data))
             .unwrap();
-        let expected = ConfigAndPreset::from_chain_spec::<E>(&E::default_spec(), None);
+        let expected = ConfigAndPreset::from_chain_spec::<E>(&E::default_spec());
 
         assert_eq!(result, expected);
 

validator_client/http_api/src/tests.rs

@@ -45,6 +45,7 @@ struct ApiTester {
     validator_store: Arc<LighthouseValidatorStore<TestingSlotClock, E>>,
     url: SensitiveUrl,
     slot_clock: TestingSlotClock,
+    spec: Arc<ChainSpec>,
     _validator_dir: TempDir,
     _secrets_dir: TempDir,
     _test_runtime: TestRuntime,
@@ -117,7 +118,7 @@ impl ApiTester {
             validator_store: Some(validator_store.clone()),
             graffiti_file: None,
             graffiti_flag: Some(Graffiti::default()),
-            spec: E::default_spec().into(),
+            spec: spec.clone(),
             config: HttpConfig {
                 enabled: true,
                 listen_addr: IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
@@ -152,6 +153,7 @@ impl ApiTester {
             validator_store,
             url,
             slot_clock,
+            spec,
             _validator_dir: validator_dir,
             _secrets_dir: secrets_dir,
             _test_runtime: test_runtime,
@@ -206,13 +208,19 @@ impl ApiTester {
     }
 
     pub async fn test_get_lighthouse_spec(self) -> Self {
-        let result = self
-            .client
-            .get_lighthouse_spec::<ConfigAndPresetFulu>()
-            .await
-            .map(|res| ConfigAndPreset::Fulu(res.data))
-            .unwrap();
-        let expected = ConfigAndPreset::from_chain_spec::<E>(&E::default_spec(), None);
+        let result = if self.spec.is_fulu_scheduled() {
+            self.client
+                .get_lighthouse_spec::<ConfigAndPresetFulu>()
+                .await
+                .map(|res| ConfigAndPreset::Fulu(res.data))
+        } else {
+            self.client
+                .get_lighthouse_spec::<ConfigAndPresetElectra>()
+                .await
+                .map(|res| ConfigAndPreset::Electra(res.data))
+        }
+        .unwrap();
+        let expected = ConfigAndPreset::from_chain_spec::<E>(&self.spec);
 
         assert_eq!(result, expected);