git rid of old const usage

beacon_node/beacon_chain/src/data_availability_checker.rs

@@ -21,7 +21,6 @@ use std::sync::Arc;
 use task_executor::TaskExecutor;
 use types::beacon_block_body::{KzgCommitmentOpts, KzgCommitments};
 use types::blob_sidecar::{BlobIdentifier, BlobSidecar, FixedBlobSidecarList};
-use types::consts::deneb::MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS;
 use types::{BlobSidecarList, ChainSpec, Epoch, EthSpec, Hash256, SignedBeaconBlock, Slot};
 
 mod availability_view;
@@ -389,7 +388,8 @@ impl<T: BeaconChainTypes> DataAvailabilityChecker<T> {
                 .map(|current_epoch| {
                     std::cmp::max(
                         fork_epoch,
-                        current_epoch.saturating_sub(MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS),
+                        current_epoch
+                            .saturating_sub(self.spec.min_epochs_for_blob_sidecars_requests),
                     )
                 })
         })
@@ -484,7 +484,8 @@ async fn availability_cache_maintenance_service<T: BeaconChainTypes>(
                 let cutoff_epoch = std::cmp::max(
                     finalized_epoch + 1,
                     std::cmp::max(
-                        current_epoch.saturating_sub(MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS),
+                        current_epoch
+                            .saturating_sub(chain.spec.min_epochs_for_blob_sidecars_requests),
                         deneb_fork_epoch,
                     ),
                 );

beacon_node/beacon_processor/src/lib.rs

@@ -60,7 +60,6 @@ use std::time::Duration;
 use task_executor::TaskExecutor;
 use tokio::sync::mpsc;
 use tokio::sync::mpsc::error::TrySendError;
-use types::consts::deneb::MAX_BLOBS_PER_BLOCK;
 use types::{Attestation, Hash256, SignedAggregateAndProof, SubnetId};
 use types::{EthSpec, Slot};
 use work_reprocessing_queue::IgnoredRpcBlock;
@@ -168,8 +167,7 @@ const MAX_BLOCKS_BY_RANGE_QUEUE_LEN: usize = 1_024;
 
 /// The maximum number of queued `BlobsByRangeRequest` objects received from the network RPC that
 /// will be stored before we start dropping them.
-const MAX_BLOBS_BY_RANGE_QUEUE_LEN: usize =
-    MAX_BLOCKS_BY_RANGE_QUEUE_LEN * MAX_BLOBS_PER_BLOCK as usize;
+const MAX_BLOBS_BY_RANGE_QUEUE_LEN: usize = 1024;
 
 /// The maximum number of queued `BlocksByRootRequest` objects received from the network RPC that
 /// will be stored before we start dropping them.

beacon_node/lighthouse_network/src/service/mod.rs

@@ -42,8 +42,7 @@ use std::{
 };
 use types::ForkName;
 use types::{
-    consts::altair::SYNC_COMMITTEE_SUBNET_COUNT, consts::deneb::BLOB_SIDECAR_SUBNET_COUNT,
-    EnrForkId, EthSpec, ForkContext, Slot, SubnetId,
+    consts::altair::SYNC_COMMITTEE_SUBNET_COUNT, EnrForkId, EthSpec, ForkContext, Slot, SubnetId,
 };
 use utils::{build_transport, strip_peer_id, Context as ServiceContext, MAX_CONNECTIONS_PER_PEER};
 
@@ -226,7 +225,7 @@ impl<AppReqId: ReqId, TSpec: EthSpec> Network<AppReqId, TSpec> {
 
             let max_topics = ctx.chain_spec.attestation_subnet_count as usize
                 + SYNC_COMMITTEE_SUBNET_COUNT as usize
-                + BLOB_SIDECAR_SUBNET_COUNT as usize
+                + ctx.chain_spec.blob_sidecar_subnet_count as usize
                 + BASE_CORE_TOPICS.len()
                 + ALTAIR_CORE_TOPICS.len()
                 + CAPELLA_CORE_TOPICS.len()
@@ -239,7 +238,7 @@ impl<AppReqId: ReqId, TSpec: EthSpec> Network<AppReqId, TSpec> {
                     possible_fork_digests,
                     ctx.chain_spec.attestation_subnet_count,
                     SYNC_COMMITTEE_SUBNET_COUNT,
-                    BLOB_SIDECAR_SUBNET_COUNT,
+                    ctx.chain_spec.blob_sidecar_subnet_count,
                 ),
                 // during a fork we subscribe to both the old and new topics
                 max_subscribed_topics: max_topics * 4,
@@ -617,7 +616,7 @@ impl<AppReqId: ReqId, TSpec: EthSpec> Network<AppReqId, TSpec> {
         }
 
         // Subscribe to core topics for the new fork
-        for kind in fork_core_topics::<TSpec>(&new_fork) {
+        for kind in fork_core_topics::<TSpec>(&new_fork, &self.fork_context.spec) {
             let topic = GossipTopic::new(kind, GossipEncoding::default(), new_fork_digest);
             self.subscribe(topic);
         }

beacon_node/lighthouse_network/src/types/topics.rs

@@ -1,8 +1,7 @@
 use libp2p::gossipsub::{IdentTopic as Topic, TopicHash};
 use serde::{Deserialize, Serialize};
 use strum::AsRefStr;
-use types::consts::deneb::BLOB_SIDECAR_SUBNET_COUNT;
-use types::{EthSpec, ForkName, SubnetId, SyncSubnetId};
+use types::{ChainSpec, EthSpec, ForkName, SubnetId, SyncSubnetId};
 
 use crate::Subnet;
 
@@ -44,7 +43,7 @@ pub const LIGHT_CLIENT_GOSSIP_TOPICS: [GossipKind; 2] = [
 pub const DENEB_CORE_TOPICS: [GossipKind; 0] = [];
 
 /// Returns the core topics associated with each fork that are new to the previous fork
-pub fn fork_core_topics<T: EthSpec>(fork_name: &ForkName) -> Vec<GossipKind> {
+pub fn fork_core_topics<T: EthSpec>(fork_name: &ForkName, spec: &ChainSpec) -> Vec<GossipKind> {
     match fork_name {
         ForkName::Base => BASE_CORE_TOPICS.to_vec(),
         ForkName::Altair => ALTAIR_CORE_TOPICS.to_vec(),
@@ -53,7 +52,7 @@ pub fn fork_core_topics<T: EthSpec>(fork_name: &ForkName) -> Vec<GossipKind> {
         ForkName::Deneb => {
             // All of deneb blob topics are core topics
             let mut deneb_blob_topics = Vec::new();
-            for i in 0..BLOB_SIDECAR_SUBNET_COUNT {
+            for i in 0..spec.blob_sidecar_subnet_count {
                 deneb_blob_topics.push(GossipKind::BlobSidecar(i));
             }
             let mut deneb_topics = DENEB_CORE_TOPICS.to_vec();
@@ -65,10 +64,13 @@ pub fn fork_core_topics<T: EthSpec>(fork_name: &ForkName) -> Vec<GossipKind> {
 
 /// Returns all the topics that we need to subscribe to for a given fork
 /// including topics from older forks and new topics for the current fork.
-pub fn core_topics_to_subscribe<T: EthSpec>(mut current_fork: ForkName) -> Vec<GossipKind> {
-    let mut topics = fork_core_topics::<T>(&current_fork);
+pub fn core_topics_to_subscribe<T: EthSpec>(
+    mut current_fork: ForkName,
+    spec: &ChainSpec,
+) -> Vec<GossipKind> {
+    let mut topics = fork_core_topics::<T>(&current_fork, spec);
     while let Some(previous_fork) = current_fork.previous_fork() {
-        let previous_fork_topics = fork_core_topics::<T>(&previous_fork);
+        let previous_fork_topics = fork_core_topics::<T>(&previous_fork, spec);
         topics.extend(previous_fork_topics);
         current_fork = previous_fork;
     }
@@ -435,14 +437,18 @@ mod tests {
     #[test]
     fn test_core_topics_to_subscribe() {
         type E = MainnetEthSpec;
+        let spec = E::default_spec();
         let mut all_topics = Vec::new();
-        let mut deneb_core_topics = fork_core_topics::<E>(&ForkName::Deneb);
+        let mut deneb_core_topics = fork_core_topics::<E>(&ForkName::Deneb, &spec);
         all_topics.append(&mut deneb_core_topics);
         all_topics.extend(CAPELLA_CORE_TOPICS);
         all_topics.extend(ALTAIR_CORE_TOPICS);
         all_topics.extend(BASE_CORE_TOPICS);
 
         let latest_fork = *ForkName::list_all().last().unwrap();
-        assert_eq!(core_topics_to_subscribe::<E>(latest_fork), all_topics);
+        assert_eq!(
+            core_topics_to_subscribe::<E>(latest_fork, &spec),
+            all_topics
+        );
     }
 }

beacon_node/network/src/service.rs

@@ -717,9 +717,10 @@ impl<T: BeaconChainTypes> NetworkService<T> {
                 }
 
                 let mut subscribed_topics: Vec<GossipTopic> = vec![];
-                for topic_kind in
-                    core_topics_to_subscribe::<T::EthSpec>(self.fork_context.current_fork())
-                {
+                for topic_kind in core_topics_to_subscribe::<T::EthSpec>(
+                    self.fork_context.current_fork(),
+                    &self.fork_context.spec,
+                ) {
                     for fork_digest in self.required_gossip_fork_digests() {
                         let topic = GossipTopic::new(
                             topic_kind.clone(),
@@ -946,7 +947,10 @@ impl<T: BeaconChainTypes> NetworkService<T> {
     }
 
     fn subscribed_core_topics(&self) -> bool {
-        let core_topics = core_topics_to_subscribe::<T::EthSpec>(self.fork_context.current_fork());
+        let core_topics = core_topics_to_subscribe::<T::EthSpec>(
+            self.fork_context.current_fork(),
+            &self.fork_context.spec,
+        );
         let core_topics: HashSet<&GossipKind> = HashSet::from_iter(&core_topics);
         let subscriptions = self.network_globals.gossipsub_subscriptions.read();
         let subscribed_topics: HashSet<&GossipKind> =

beacon_node/store/src/hot_cold_store.rs

@@ -39,7 +39,6 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::time::Duration;
 use types::blob_sidecar::BlobSidecarList;
-use types::consts::deneb::MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS;
 use types::*;
 
 /// On-disk database that stores finalized states efficiently.
@@ -2059,7 +2058,7 @@ impl<E: EthSpec, Hot: ItemStore<E>, Cold: ItemStore<E>> HotColdDB<E, Hot, Cold>
         let min_current_epoch = self.get_split_slot().epoch(E::slots_per_epoch()) + 2;
         let min_data_availability_boundary = std::cmp::max(
             deneb_fork_epoch,
-            min_current_epoch.saturating_sub(MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS),
+            min_current_epoch.saturating_sub(self.spec.min_epochs_for_blob_sidecars_requests),
         );
 
         self.try_prune_blobs(force, min_data_availability_boundary)

consensus/state_processing/src/per_block_processing/deneb.rs

@@ -1,6 +1,5 @@
 use ethereum_hashing::hash_fixed;
-use types::consts::deneb::VERSIONED_HASH_VERSION_KZG;
-use types::{KzgCommitment, VersionedHash};
+use types::{KzgCommitment, VersionedHash, VERSIONED_HASH_VERSION_KZG};
 
 pub fn kzg_commitment_to_versioned_hash(kzg_commitment: &KzgCommitment) -> VersionedHash {
     let mut hashed_commitment = hash_fixed(&kzg_commitment.0);

consensus/types/src/consts.rs

@@ -22,11 +22,3 @@ pub mod altair {
 pub mod merge {
     pub const INTERVALS_PER_SLOT: u64 = 3;
 }
-pub mod deneb {
-    use crate::Epoch;
-
-    pub const VERSIONED_HASH_VERSION_KZG: u8 = 1;
-    pub const BLOB_SIDECAR_SUBNET_COUNT: u64 = 6;
-    pub const MAX_BLOBS_PER_BLOCK: u64 = BLOB_SIDECAR_SUBNET_COUNT;
-    pub const MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS: Epoch = Epoch::new(4096);
-}

consensus/types/src/lib.rs

@@ -219,7 +219,7 @@ pub use bls::{
     Signature, SignatureBytes,
 };
 
-pub use kzg::{KzgCommitment, KzgProof};
+pub use kzg::{KzgCommitment, KzgProof, VERSIONED_HASH_VERSION_KZG};
 
 pub use sidecar::Sidecar;
 pub use ssz_types::{typenum, typenum::Unsigned, BitList, BitVector, FixedVector, VariableList};

crypto/kzg/src/lib.rs

@@ -7,7 +7,11 @@ use std::fmt::Debug;
 use std::ops::Deref;
 use std::str::FromStr;
 
-pub use crate::{kzg_commitment::KzgCommitment, kzg_proof::KzgProof, trusted_setup::TrustedSetup};
+pub use crate::{
+    kzg_commitment::{KzgCommitment, VERSIONED_HASH_VERSION_KZG},
+    kzg_proof::KzgProof,
+    trusted_setup::TrustedSetup,
+};
 pub use c_kzg::{Bytes32, Bytes48, BYTES_PER_COMMITMENT, BYTES_PER_FIELD_ELEMENT, BYTES_PER_PROOF};
 
 #[derive(Debug)]