Unify EthSpecs in Mainnet and Minimal

eth2/fork_choice/benches/benches.rs

@@ -3,10 +3,10 @@ use criterion::{criterion_group, criterion_main, Benchmark};
 use fork_choice::{test_utils::TestingForkChoiceBuilder, ForkChoice, OptimizedLMDGhost};
 use std::sync::Arc;
 use store::MemoryStore;
-use types::{ChainSpec, EthSpec, FoundationEthSpec};
+use types::{ChainSpec, EthSpec, MainnetEthSpec};
 
 pub type TestedForkChoice<T, U> = OptimizedLMDGhost<T, U>;
-pub type TestedEthSpec = FoundationEthSpec;
+pub type TestedEthSpec = MainnetEthSpec;
 
 /// Helper function to setup a builder and spec.
 fn setup(

eth2/fork_choice/examples/example.rs

@@ -1,7 +1,7 @@
 use fork_choice::{test_utils::TestingForkChoiceBuilder, ForkChoice, OptimizedLMDGhost};
 use std::sync::Arc;
 use store::{MemoryStore, Store};
-use types::{BeaconBlock, ChainSpec, EthSpec, FoundationEthSpec, Hash256};
+use types::{BeaconBlock, ChainSpec, EthSpec, Hash256, MainnetEthSpec};
 
 fn main() {
     let validator_count = 16;
@@ -9,15 +9,15 @@ fn main() {
     let repetitions = 50;
 
     let store = MemoryStore::open();
-    let builder: TestingForkChoiceBuilder<MemoryStore, FoundationEthSpec> =
+    let builder: TestingForkChoiceBuilder<MemoryStore, MainnetEthSpec> =
         TestingForkChoiceBuilder::new(validator_count, chain_length, Arc::new(store));
 
-    let fork_choosers: Vec<OptimizedLMDGhost<MemoryStore, FoundationEthSpec>> = (0..repetitions)
+    let fork_choosers: Vec<OptimizedLMDGhost<MemoryStore, MainnetEthSpec>> = (0..repetitions)
         .into_iter()
         .map(|_| builder.build())
         .collect();
 
-    let spec = &FoundationEthSpec::default_spec();
+    let spec = &MainnetEthSpec::default_spec();
 
     println!("Running {} times...", repetitions);
     for fc in fork_choosers {

eth2/fork_choice/src/test_utils.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 use store::Store;
 use types::{
     test_utils::{SeedableRng, TestRandom, TestingBeaconStateBuilder, XorShiftRng},
-    BeaconBlock, BeaconState, EthSpec, FoundationEthSpec, Hash256, Keypair,
+    BeaconBlock, BeaconState, EthSpec, Hash256, Keypair, MainnetEthSpec,
 };
 
 /// Creates a chain of blocks and produces `ForkChoice` instances with pre-filled stores.
@@ -16,11 +16,8 @@ pub struct TestingForkChoiceBuilder<S, E> {
 
 impl<S: Store, E: EthSpec> TestingForkChoiceBuilder<S, E> {
     pub fn new(validator_count: usize, chain_length: usize, store: Arc<S>) -> Self {
-        let chain = get_chain_of_blocks::<FoundationEthSpec, S>(
-            chain_length,
-            validator_count,
-            store.clone(),
-        );
+        let chain =
+            get_chain_of_blocks::<MainnetEthSpec, S>(chain_length, validator_count, store.clone());
 
         Self {
             store,

eth2/fork_choice/tests/tests.rs

@@ -11,7 +11,7 @@ use std::sync::Arc;
 use std::{fs::File, io::prelude::*, path::PathBuf};
 use types::test_utils::TestingBeaconStateBuilder;
 use types::{
-    BeaconBlock, BeaconBlockBody, Eth1Data, EthSpec, FoundationEthSpec, Hash256, Keypair, Slot,
+    BeaconBlock, BeaconBlockBody, Eth1Data, EthSpec, Hash256, Keypair, MainnetEthSpec, Slot,
 };
 use yaml_rust::yaml;
 
@@ -22,7 +22,7 @@ fn test_optimized_lmd_ghost() {
     // set up logging
     // Builder::from_env(Env::default().default_filter_or("trace")).init();
 
-    test_yaml_vectors::<OptimizedLMDGhost<MemoryStore, FoundationEthSpec>>(
+    test_yaml_vectors::<OptimizedLMDGhost<MemoryStore, MainnetEthSpec>>(
         "tests/lmd_ghost_test_vectors.yaml",
         100,
     );
@@ -33,7 +33,7 @@ fn test_bitwise_lmd_ghost() {
     // set up logging
     //Builder::from_env(Env::default().default_filter_or("trace")).init();
 
-    test_yaml_vectors::<BitwiseLMDGhost<MemoryStore, FoundationEthSpec>>(
+    test_yaml_vectors::<BitwiseLMDGhost<MemoryStore, MainnetEthSpec>>(
         "tests/bitwise_lmd_ghost_test_vectors.yaml",
         100,
     );
@@ -41,7 +41,7 @@ fn test_bitwise_lmd_ghost() {
 
 #[test]
 fn test_slow_lmd_ghost() {
-    test_yaml_vectors::<SlowLMDGhost<MemoryStore, FoundationEthSpec>>(
+    test_yaml_vectors::<SlowLMDGhost<MemoryStore, MainnetEthSpec>>(
         "tests/lmd_ghost_test_vectors.yaml",
         100,
     );
@@ -61,7 +61,7 @@ fn test_yaml_vectors<T: ForkChoice<MemoryStore>>(
     let test_cases = load_test_cases_from_yaml(yaml_file_path);
 
     // default vars
-    let spec = FoundationEthSpec::default_spec();
+    let spec = MainnetEthSpec::default_spec();
     let zero_hash = Hash256::zero();
     let eth1_data = Eth1Data {
         deposit_count: 0,
@@ -204,9 +204,9 @@ where
     let store = Arc::new(MemoryStore::open());
 
     let fork_choice = ForkChoice::new(store.clone());
-    let spec = FoundationEthSpec::default_spec();
+    let spec = MainnetEthSpec::default_spec();
 
-    let mut state_builder: TestingBeaconStateBuilder<FoundationEthSpec> =
+    let mut state_builder: TestingBeaconStateBuilder<MainnetEthSpec> =
         TestingBeaconStateBuilder::from_single_keypair(num_validators, &Keypair::random(), &spec);
     state_builder.build_caches(&spec).unwrap();
     let (state, _keypairs) = state_builder.build();

eth2/operation_pool/src/lib.rs

@@ -675,12 +675,12 @@ mod tests {
             .collect()
     }
 
-    fn test_state(rng: &mut XorShiftRng) -> (ChainSpec, BeaconState<FoundationEthSpec>) {
-        let spec = FoundationEthSpec::default_spec();
+    fn test_state(rng: &mut XorShiftRng) -> (ChainSpec, BeaconState<MainnetEthSpec>) {
+        let spec = MainnetEthSpec::default_spec();
 
         let mut state = BeaconState::random_for_test(rng);
 
-        state.fork = Fork::genesis(FoundationEthSpec::genesis_epoch());
+        state.fork = Fork::genesis(MainnetEthSpec::genesis_epoch());
 
         (spec, state)
     }
@@ -735,13 +735,13 @@ mod tests {
             state_builder.build_caches(&spec).unwrap();
             let (state, keypairs) = state_builder.build();
 
-            (state, keypairs, FoundationEthSpec::default_spec())
+            (state, keypairs, MainnetEthSpec::default_spec())
         }
 
         #[test]
         fn test_attestation_score() {
             let (ref mut state, ref keypairs, ref spec) =
-                attestation_test_state::<FoundationEthSpec>(1);
+                attestation_test_state::<MainnetEthSpec>(1);
 
             let slot = state.slot - 1;
             let committees = state
@@ -793,7 +793,7 @@ mod tests {
         #[test]
         fn attestation_aggregation_insert_get_prune() {
             let (ref mut state, ref keypairs, ref spec) =
-                attestation_test_state::<FoundationEthSpec>(1);
+                attestation_test_state::<MainnetEthSpec>(1);
 
             let op_pool = OperationPool::new();
 
@@ -861,7 +861,7 @@ mod tests {
         #[test]
         fn attestation_duplicate() {
             let (ref mut state, ref keypairs, ref spec) =
-                attestation_test_state::<FoundationEthSpec>(1);
+                attestation_test_state::<MainnetEthSpec>(1);
 
             let op_pool = OperationPool::new();
 
@@ -898,7 +898,7 @@ mod tests {
         #[test]
         fn attestation_pairwise_overlapping() {
             let (ref mut state, ref keypairs, ref spec) =
-                attestation_test_state::<FoundationEthSpec>(1);
+                attestation_test_state::<MainnetEthSpec>(1);
 
             let op_pool = OperationPool::new();
 
@@ -946,7 +946,7 @@ mod tests {
             let big_step_size = 4;
 
             let (ref mut state, ref keypairs, ref spec) =
-                attestation_test_state::<FoundationEthSpec>(big_step_size);
+                attestation_test_state::<MainnetEthSpec>(big_step_size);
 
             let op_pool = OperationPool::new();
 

eth2/state_processing/benches/bench_epoch_processing.rs

@@ -17,7 +17,7 @@ pub const SMALL_BENCHING_SAMPLE_SIZE: usize = 10;
 
 /// Run the benchmarking suite on a foundation spec with 16,384 validators.
 pub fn bench_epoch_processing_n_validators(c: &mut Criterion, validator_count: usize) {
-    let spec = ChainSpec::foundation();
+    let spec = ChainSpec::mainnet();
 
     let mut builder =
         TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(validator_count, &spec);

eth2/state_processing/benches/benches.rs

@@ -25,7 +25,7 @@ pub fn block_processing_worst_case(c: &mut Criterion) {
     );
 
     // Use the specifications from the Eth2.0 spec.
-    let spec = ChainSpec::foundation();
+    let spec = ChainSpec::mainnet();
 
     // Create a builder for configuring the block and state for benching.
     let mut bench_builder = BlockBenchingBuilder::new(VALIDATOR_COUNT, &spec);
@@ -59,7 +59,7 @@ pub fn block_processing_reasonable_case(c: &mut Criterion) {
     );
 
     // Use the specifications from the Eth2.0 spec.
-    let spec = ChainSpec::foundation();
+    let spec = ChainSpec::mainnet();
 
     // Create a builder for configuring the block and state for benching.
     let mut bench_builder = BlockBenchingBuilder::new(VALIDATOR_COUNT, &spec);

eth2/state_processing/src/per_block_processing/tests.rs

@@ -9,7 +9,7 @@ pub const VALIDATOR_COUNT: usize = 10;
 
 #[test]
 fn valid_block_ok() {
-    let spec = FoundationEthSpec::default_spec();
+    let spec = MainnetEthSpec::default_spec();
     let builder = get_builder(&spec);
     let (block, mut state) = builder.build(None, None, &spec);
 
@@ -20,7 +20,7 @@ fn valid_block_ok() {
 
 #[test]
 fn invalid_block_header_state_slot() {
-    let spec = FoundationEthSpec::default_spec();
+    let spec = MainnetEthSpec::default_spec();
     let builder = get_builder(&spec);
     let (mut block, mut state) = builder.build(None, None, &spec);
 
@@ -39,7 +39,7 @@ fn invalid_block_header_state_slot() {
 
 #[test]
 fn invalid_parent_block_root() {
-    let spec = FoundationEthSpec::default_spec();
+    let spec = MainnetEthSpec::default_spec();
     let builder = get_builder(&spec);
     let invalid_parent_root = Hash256::from([0xAA; 32]);
     let (block, mut state) = builder.build(None, Some(invalid_parent_root), &spec);
@@ -59,14 +59,14 @@ fn invalid_parent_block_root() {
 
 #[test]
 fn invalid_block_signature() {
-    let spec = FoundationEthSpec::default_spec();
+    let spec = MainnetEthSpec::default_spec();
     let builder = get_builder(&spec);
     let (mut block, mut state) = builder.build(None, None, &spec);
 
     // sign the block with a keypair that is not the expected proposer
     let keypair = Keypair::random();
     let message = block.signed_root();
-    let epoch = block.slot.epoch(FoundationEthSpec::slots_per_epoch());
+    let epoch = block.slot.epoch(MainnetEthSpec::slots_per_epoch());
     let domain = spec.get_domain(epoch, Domain::BeaconProposer, &state.fork);
     block.signature = Signature::new(&message, domain, &keypair.sk);
 
@@ -82,7 +82,7 @@ fn invalid_block_signature() {
 
 #[test]
 fn invalid_randao_reveal_signature() {
-    let spec = FoundationEthSpec::default_spec();
+    let spec = MainnetEthSpec::default_spec();
     let builder = get_builder(&spec);
 
     // sign randao reveal with random keypair
@@ -100,12 +100,12 @@ fn invalid_randao_reveal_signature() {
     );
 }
 
-fn get_builder(spec: &ChainSpec) -> (BlockProcessingBuilder<FoundationEthSpec>) {
+fn get_builder(spec: &ChainSpec) -> (BlockProcessingBuilder<MainnetEthSpec>) {
     let mut builder = BlockProcessingBuilder::new(VALIDATOR_COUNT, &spec);
 
     // Set the state and block to be in the last slot of the 4th epoch.
     let last_slot_of_epoch =
-        (FoundationEthSpec::genesis_epoch() + 4).end_slot(FoundationEthSpec::slots_per_epoch());
+        (MainnetEthSpec::genesis_epoch() + 4).end_slot(MainnetEthSpec::slots_per_epoch());
     builder.set_slot(last_slot_of_epoch, &spec);
     builder.build_caches(&spec);
 

eth2/state_processing/src/per_epoch_processing/tests.rs

@@ -8,13 +8,13 @@ use types::*;
 fn runs_without_error() {
     Builder::from_env(Env::default().default_filter_or("error")).init();
 
-    let spec = FewValidatorsEthSpec::default_spec();
+    let spec = MinimalEthSpec::default_spec();
 
-    let mut builder: TestingBeaconStateBuilder<FewValidatorsEthSpec> =
+    let mut builder: TestingBeaconStateBuilder<MinimalEthSpec> =
         TestingBeaconStateBuilder::from_deterministic_keypairs(8, &spec);
 
-    let target_slot = (FewValidatorsEthSpec::genesis_epoch() + 4)
-        .end_slot(FewValidatorsEthSpec::slots_per_epoch());
+    let target_slot =
+        (MinimalEthSpec::genesis_epoch() + 4).end_slot(MinimalEthSpec::slots_per_epoch());
     builder.teleport_to_slot(target_slot, &spec);
 
     let (mut state, _keypairs) = builder.build();

eth2/types/src/beacon_state/beacon_state_types.rs

@@ -95,9 +95,9 @@ pub trait EthSpec: 'static + Default + Sync + Send + Clone + Debug + PartialEq {
 ///
 /// Spec v0.6.1
 #[derive(Clone, PartialEq, Debug, Default, Serialize, Deserialize)]
-pub struct FoundationEthSpec;
+pub struct MainnetEthSpec;
 
-impl EthSpec for FoundationEthSpec {
+impl EthSpec for MainnetEthSpec {
     type ShardCount = U1024;
     type SlotsPerHistoricalRoot = U8192;
     type LatestRandaoMixesLength = U8192;
@@ -107,17 +107,17 @@ impl EthSpec for FoundationEthSpec {
     type GenesisEpoch = U0;
 
     fn default_spec() -> ChainSpec {
-        ChainSpec::foundation()
+        ChainSpec::mainnet()
     }
 }
 
-pub type FoundationBeaconState = BeaconState<FoundationEthSpec>;
+pub type FoundationBeaconState = BeaconState<MainnetEthSpec>;
 
 /// Ethereum Foundation specifications, modified to be suitable for < 1000 validators.
 #[derive(Clone, PartialEq, Debug, Default, Serialize, Deserialize)]
-pub struct FewValidatorsEthSpec;
+pub struct MinimalEthSpec;
 
-impl EthSpec for FewValidatorsEthSpec {
+impl EthSpec for MinimalEthSpec {
     type ShardCount = U8;
     type SlotsPerHistoricalRoot = U8192;
     type LatestRandaoMixesLength = U8192;
@@ -127,28 +127,8 @@ impl EthSpec for FewValidatorsEthSpec {
     type GenesisEpoch = U0;
 
     fn default_spec() -> ChainSpec {
-        ChainSpec::few_validators()
+        ChainSpec::minimal()
     }
 }
 
-pub type FewValidatorsBeaconState = BeaconState<FewValidatorsEthSpec>;
-
-/// Specifications suitable for a small-scale (< 1000 validators) lighthouse testnet.
-#[derive(Clone, PartialEq, Debug, Default, Serialize, Deserialize)]
-pub struct LighthouseTestnetEthSpec;
-
-impl EthSpec for LighthouseTestnetEthSpec {
-    type ShardCount = U8;
-    type SlotsPerHistoricalRoot = U8192;
-    type LatestRandaoMixesLength = U8192;
-    type LatestActiveIndexRootsLength = U8192;
-    type LatestSlashedExitLength = U8192;
-    type SlotsPerEpoch = U8;
-    type GenesisEpoch = U0;
-
-    fn default_spec() -> ChainSpec {
-        ChainSpec::lighthouse_testnet()
-    }
-}
-
-pub type LighthouseTestnetBeaconState = BeaconState<LighthouseTestnetEthSpec>;
+pub type MinimalBeaconState = BeaconState<MinimalEthSpec>;

eth2/types/src/beacon_state/committee_cache/tests.rs

@@ -34,8 +34,8 @@ fn new_state<T: EthSpec>(validator_count: usize, slot: Slot) -> BeaconState<T> {
 
 #[test]
 fn fails_without_validators() {
-    let state = new_state::<FewValidatorsEthSpec>(0, Slot::new(0));
-    let spec = &FewValidatorsEthSpec::default_spec();
+    let state = new_state::<MinimalEthSpec>(0, Slot::new(0));
+    let spec = &MinimalEthSpec::default_spec();
 
     assert_eq!(
         CommitteeCache::initialized(&state, state.current_epoch(), &spec),
@@ -45,8 +45,8 @@ fn fails_without_validators() {
 
 #[test]
 fn initializes_with_the_right_epoch() {
-    let state = new_state::<FewValidatorsEthSpec>(16, Slot::new(0));
-    let spec = &FewValidatorsEthSpec::default_spec();
+    let state = new_state::<MinimalEthSpec>(16, Slot::new(0));
+    let spec = &MinimalEthSpec::default_spec();
 
     let cache = CommitteeCache::default();
     assert_eq!(cache.initialized_epoch, None);
@@ -63,14 +63,14 @@ fn initializes_with_the_right_epoch() {
 
 #[test]
 fn shuffles_for_the_right_epoch() {
-    let num_validators = FewValidatorsEthSpec::minimum_validator_count() * 2;
+    let num_validators = MinimalEthSpec::minimum_validator_count() * 2;
     let epoch = Epoch::new(100_000_000);
-    let slot = epoch.start_slot(FewValidatorsEthSpec::slots_per_epoch());
+    let slot = epoch.start_slot(MinimalEthSpec::slots_per_epoch());
 
-    let mut state = new_state::<FewValidatorsEthSpec>(num_validators, slot);
-    let spec = &FewValidatorsEthSpec::default_spec();
+    let mut state = new_state::<MinimalEthSpec>(num_validators, slot);
+    let spec = &MinimalEthSpec::default_spec();
 
-    let distinct_hashes: Vec<Hash256> = (0..FewValidatorsEthSpec::latest_randao_mixes_length())
+    let distinct_hashes: Vec<Hash256> = (0..MinimalEthSpec::latest_randao_mixes_length())
         .into_iter()
         .map(|i| Hash256::from(i as u64))
         .collect();
@@ -118,14 +118,14 @@ fn shuffles_for_the_right_epoch() {
 
 #[test]
 fn can_start_on_any_shard() {
-    let num_validators = FewValidatorsEthSpec::minimum_validator_count() * 2;
+    let num_validators = MinimalEthSpec::minimum_validator_count() * 2;
     let epoch = Epoch::new(100_000_000);
-    let slot = epoch.start_slot(FewValidatorsEthSpec::slots_per_epoch());
+    let slot = epoch.start_slot(MinimalEthSpec::slots_per_epoch());
 
-    let mut state = new_state::<FewValidatorsEthSpec>(num_validators, slot);
-    let spec = &FewValidatorsEthSpec::default_spec();
+    let mut state = new_state::<MinimalEthSpec>(num_validators, slot);
+    let spec = &MinimalEthSpec::default_spec();
 
-    for i in 0..FewValidatorsEthSpec::shard_count() as u64 {
+    for i in 0..MinimalEthSpec::shard_count() as u64 {
         state.latest_start_shard = i;
 
         let cache = CommitteeCache::initialized(&state, state.current_epoch(), spec).unwrap();
@@ -154,7 +154,7 @@ impl EthSpec for ExcessShardsEthSpec {
     type GenesisEpoch = U0;
 
     fn default_spec() -> ChainSpec {
-        ChainSpec::few_validators()
+        ChainSpec::minimal()
     }
 }
 

eth2/types/src/beacon_state/tests.rs

@@ -53,7 +53,7 @@ fn test_beacon_proposer_index<T: EthSpec>() {
 
 #[test]
 fn beacon_proposer_index() {
-    test_beacon_proposer_index::<FewValidatorsEthSpec>();
+    test_beacon_proposer_index::<MinimalEthSpec>();
 }
 
 /// Should produce (note the set notation brackets):
@@ -115,11 +115,11 @@ fn test_active_index<T: EthSpec>(state_slot: Slot) {
 
 #[test]
 fn get_active_index_root_index() {
-    test_active_index::<FoundationEthSpec>(Slot::new(0));
+    test_active_index::<MainnetEthSpec>(Slot::new(0));
 
-    let epoch = Epoch::from(FoundationEthSpec::latest_active_index_roots() * 4);
-    let slot = epoch.start_slot(FoundationEthSpec::slots_per_epoch());
-    test_active_index::<FoundationEthSpec>(slot);
+    let epoch = Epoch::from(MainnetEthSpec::latest_active_index_roots() * 4);
+    let slot = epoch.start_slot(MainnetEthSpec::slots_per_epoch());
+    test_active_index::<MainnetEthSpec>(slot);
 }
 
 /// Test that
@@ -166,14 +166,14 @@ fn test_cache_initialization<'a, T: EthSpec>(
 
 #[test]
 fn cache_initialization() {
-    let spec = FewValidatorsEthSpec::default_spec();
+    let spec = MinimalEthSpec::default_spec();
 
-    let builder: TestingBeaconStateBuilder<FewValidatorsEthSpec> =
+    let builder: TestingBeaconStateBuilder<MinimalEthSpec> =
         TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(16, &spec);
     let (mut state, _keypairs) = builder.build();
 
-    state.slot = (FewValidatorsEthSpec::genesis_epoch() + 1)
-        .start_slot(FewValidatorsEthSpec::slots_per_epoch());
+    state.slot =
+        (MinimalEthSpec::genesis_epoch() + 1).start_slot(MinimalEthSpec::slots_per_epoch());
 
     test_cache_initialization(&mut state, RelativeEpoch::Previous, &spec);
     test_cache_initialization(&mut state, RelativeEpoch::Current, &spec);
@@ -203,7 +203,7 @@ fn tree_hash_cache() {
 #[cfg(test)]
 mod committees {
     use super::*;
-    use crate::beacon_state::FewValidatorsEthSpec;
+    use crate::beacon_state::MinimalEthSpec;
     use swap_or_not_shuffle::shuffle_list;
 
     fn execute_committee_consistency_test<T: EthSpec>(
@@ -347,16 +347,16 @@ mod committees {
 
     #[test]
     fn current_epoch_committee_consistency() {
-        committee_consistency_test_suite::<FewValidatorsEthSpec>(RelativeEpoch::Current);
+        committee_consistency_test_suite::<MinimalEthSpec>(RelativeEpoch::Current);
     }
 
     #[test]
     fn previous_epoch_committee_consistency() {
-        committee_consistency_test_suite::<FewValidatorsEthSpec>(RelativeEpoch::Previous);
+        committee_consistency_test_suite::<MinimalEthSpec>(RelativeEpoch::Previous);
     }
 
     #[test]
     fn next_epoch_committee_consistency() {
-        committee_consistency_test_suite::<FewValidatorsEthSpec>(RelativeEpoch::Next);
+        committee_consistency_test_suite::<MinimalEthSpec>(RelativeEpoch::Next);
     }
 }

eth2/types/src/chain_spec.rs

@@ -136,7 +136,7 @@ impl ChainSpec {
     /// Returns a `ChainSpec` compatible with the Ethereum Foundation specification.
     ///
     /// Spec v0.6.1
-    pub fn foundation() -> Self {
+    pub fn mainnet() -> Self {
         Self {
             /*
              * Misc
@@ -217,43 +217,35 @@ impl ChainSpec {
              * Boot nodes
              */
             boot_nodes: vec![],
-            chain_id: 1, // foundation chain id
+            chain_id: 1, // mainnet chain id
         }
     }
 
-    /// Returns a `ChainSpec` compatible with the Lighthouse testnet specification.
-    ///
-    /// Spec v0.4.0
-    pub fn lighthouse_testnet() -> Self {
-        /*
-         * Lighthouse testnet bootnodes
-         */
+    /// Returns a `ChainSpec` compatible with the specification suitable for 8 validators.
+    pub fn minimal() -> Self {
+        let genesis_slot = Slot::new(0);
+
+        // Note: these bootnodes are placeholders.
+        //
+        // Should be updated once static bootnodes exist.
         let boot_nodes = vec!["/ip4/127.0.0.1/tcp/9000"
             .parse()
             .expect("correct multiaddr")];
 
         Self {
             boot_nodes,
-            chain_id: 2, // lighthouse testnet chain id
-            ..ChainSpec::few_validators()
-        }
-    }
-
-    /// Returns a `ChainSpec` compatible with the specification suitable for 8 validators.
-    pub fn few_validators() -> Self {
-        let genesis_slot = Slot::new(0);
-
-        Self {
             target_committee_size: 1,
+            chain_id: 2, // lighthouse testnet chain id
             genesis_slot,
-            ..ChainSpec::foundation()
+            shuffle_round_count: 10,
+            ..ChainSpec::mainnet()
         }
     }
 }
 
 impl Default for ChainSpec {
     fn default() -> Self {
-        Self::foundation()
+        Self::mainnet()
     }
 }
 
@@ -263,8 +255,8 @@ mod tests {
     use int_to_bytes::int_to_bytes8;
 
     #[test]
-    fn test_foundation_spec_can_be_constructed() {
-        let _ = ChainSpec::foundation();
+    fn test_mainnet_spec_can_be_constructed() {
+        let _ = ChainSpec::mainnet();
     }
 
     fn test_domain(domain_type: Domain, raw_domain: u32, spec: &ChainSpec) {
@@ -281,7 +273,7 @@ mod tests {
 
     #[test]
     fn test_get_domain() {
-        let spec = ChainSpec::foundation();
+        let spec = ChainSpec::mainnet();
 
         test_domain(Domain::BeaconProposer, spec.domain_beacon_proposer, &spec);
         test_domain(Domain::Randao, spec.domain_randao, &spec);

eth2/types/src/fork.rs

@@ -63,7 +63,7 @@ mod tests {
     cached_tree_hash_tests!(Fork);
 
     fn test_genesis(epoch: Epoch) {
-        let mut spec = ChainSpec::foundation();
+        let mut spec = ChainSpec::mainnet();
 
         let fork = Fork::genesis(epoch);
 

eth2/types/src/historical_batch.rs

@@ -31,7 +31,7 @@ pub struct HistoricalBatch<T: EthSpec> {
 mod tests {
     use super::*;
 
-    pub type FoundationHistoricalBatch = HistoricalBatch<FoundationEthSpec>;
+    pub type FoundationHistoricalBatch = HistoricalBatch<MainnetEthSpec>;
 
     ssz_tests!(FoundationHistoricalBatch);
     cached_tree_hash_tests!(FoundationHistoricalBatch);