Interop chain start strategies (#479)

* Implement more flexible beacon chain genesis

* Fix compile issues from rebase on master

* Rename CLI flag

* Adds initial documentation for TOML files

* Update docs readme

* Add first version of cli_util

* Dont write cache fields in serde

* Tidy cli_util

* Add code to load genesis YAML file

* Move serde_utils out of tests in `types`

* Update logging text

* Fix serde YAML for Fork

* Make yaml hex decoding more strict

* Update deterministic key generate for interop

* Set deposit count on testing genesis state

* Make some fixes for deposit count

* Remove code fragements

* Large restructure of docs

* Tidy docs

* Fix readme link

* Add interop docs

* Tidy README

beacon_node/client/src/beacon_chain_types.rs

@@ -1,27 +1,31 @@
+use crate::error::Result;
+use crate::{config::GenesisState, ClientConfig};
 use beacon_chain::{
     lmd_ghost::{LmdGhost, ThreadSafeReducedTree},
     slot_clock::SystemTimeSlotClock,
     store::Store,
     BeaconChain, BeaconChainTypes,
 };
-use slog::{info, Logger};
+use slog::{crit, info, Logger};
 use slot_clock::SlotClock;
+use std::fs::File;
 use std::marker::PhantomData;
 use std::sync::Arc;
+use std::time::SystemTime;
 use tree_hash::TreeHash;
-use types::{test_utils::TestingBeaconStateBuilder, BeaconBlock, ChainSpec, EthSpec, Hash256};
-
-/// The number initial validators when starting the `Minimal`.
-const TESTNET_VALIDATOR_COUNT: usize = 16;
+use types::{
+    test_utils::TestingBeaconStateBuilder, BeaconBlock, BeaconState, ChainSpec, EthSpec, Hash256,
+};
 
 /// Provides a new, initialized `BeaconChain`
 pub trait InitialiseBeaconChain<T: BeaconChainTypes> {
     fn initialise_beacon_chain(
         store: Arc<T::Store>,
+        config: &ClientConfig,
         spec: ChainSpec,
         log: Logger,
-    ) -> BeaconChain<T> {
-        maybe_load_from_store_for_testnet::<_, T::Store, T::EthSpec>(store, spec, log)
+    ) -> Result<BeaconChain<T>> {
+        maybe_load_from_store_for_testnet::<_, T::Store, T::EthSpec>(store, config, spec, log)
     }
 }
 
@@ -42,45 +46,109 @@ impl<T: Store, E: EthSpec, X: BeaconChainTypes> InitialiseBeaconChain<X> for Cli
 /// Loads a `BeaconChain` from `store`, if it exists. Otherwise, create a new chain from genesis.
 fn maybe_load_from_store_for_testnet<T, U: Store, V: EthSpec>(
     store: Arc<U>,
+    config: &ClientConfig,
     spec: ChainSpec,
     log: Logger,
-) -> BeaconChain<T>
+) -> Result<BeaconChain<T>>
 where
     T: BeaconChainTypes<Store = U, EthSpec = V>,
     T::LmdGhost: LmdGhost<U, V>,
 {
+    let genesis_state = match &config.genesis_state {
+        GenesisState::Mainnet => {
+            crit!(log, "This release does not support mainnet genesis state.");
+            return Err("Mainnet is unsupported".into());
+        }
+        GenesisState::RecentGenesis { validator_count } => {
+            generate_testnet_genesis_state(*validator_count, recent_genesis_time(), &spec)
+        }
+        GenesisState::Generated {
+            validator_count,
+            genesis_time,
+        } => generate_testnet_genesis_state(*validator_count, *genesis_time, &spec),
+        GenesisState::Yaml { file } => {
+            let file = File::open(file).map_err(|e| {
+                format!("Unable to open YAML genesis state file {:?}: {:?}", file, e)
+            })?;
+
+            serde_yaml::from_reader(file)
+                .map_err(|e| format!("Unable to parse YAML genesis state file: {:?}", e))?
+        }
+    };
+
+    let mut genesis_block = BeaconBlock::empty(&spec);
+    genesis_block.state_root = Hash256::from_slice(&genesis_state.tree_hash_root());
+    let genesis_block_root = genesis_block.canonical_root();
+
+    // Slot clock
+    let slot_clock = T::SlotClock::new(
+        spec.genesis_slot,
+        genesis_state.genesis_time,
+        spec.seconds_per_slot,
+    );
+
+    // Try load an existing `BeaconChain` from the store. If unable, create a new one.
     if let Ok(Some(beacon_chain)) =
         BeaconChain::from_store(store.clone(), spec.clone(), log.clone())
     {
-        info!(
-            log,
-            "Loaded BeaconChain from store";
-            "slot" => beacon_chain.head().beacon_state.slot,
-            "best_slot" => beacon_chain.best_slot(),
-        );
+        // Here we check to ensure that the `BeaconChain` loaded from store has the expected
+        // genesis block.
+        //
+        // Without this check, it's possible that there will be an existing DB with a `BeaconChain`
+        // that has different parameters than provided to this executable.
+        if beacon_chain.genesis_block_root == genesis_block_root {
+            info!(
+                log,
+                "Loaded BeaconChain from store";
+                "slot" => beacon_chain.head().beacon_state.slot,
+                "best_slot" => beacon_chain.best_slot(),
+            );
 
-        beacon_chain
+            Ok(beacon_chain)
+        } else {
+            crit!(
+                log,
+                "The BeaconChain loaded from disk has an incorrect genesis root. \
+                 This may be caused by an old database in located in datadir."
+            );
+            Err("Incorrect genesis root".into())
+        }
     } else {
-        info!(log, "Initializing new BeaconChain from genesis");
-        let state_builder = TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(
-            TESTNET_VALIDATOR_COUNT,
-            &spec,
-        );
-        let (genesis_state, _keypairs) = state_builder.build();
-
-        let mut genesis_block = BeaconBlock::empty(&spec);
-        genesis_block.state_root = Hash256::from_slice(&genesis_state.tree_hash_root());
-
-        // Slot clock
-        let slot_clock = T::SlotClock::new(
-            spec.genesis_slot,
-            genesis_state.genesis_time,
-            spec.seconds_per_slot,
-        );
-
-        // Genesis chain
-        //TODO: Handle error correctly
-        BeaconChain::from_genesis(store, slot_clock, genesis_state, genesis_block, spec, log)
-            .expect("Terminate if beacon chain generation fails")
+        BeaconChain::from_genesis(
+            store,
+            slot_clock,
+            genesis_state,
+            genesis_block,
+            spec,
+            log.clone(),
+        )
+        .map_err(|e| format!("Failed to initialize new beacon chain: {:?}", e).into())
     }
 }
+
+fn generate_testnet_genesis_state<E: EthSpec>(
+    validator_count: usize,
+    genesis_time: u64,
+    spec: &ChainSpec,
+) -> BeaconState<E> {
+    let (mut genesis_state, _keypairs) =
+        TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(validator_count, spec)
+            .build();
+
+    genesis_state.genesis_time = genesis_time;
+
+    genesis_state
+}
+
+/// Returns the system time, mod 30 minutes.
+///
+/// Used for easily creating testnets.
+fn recent_genesis_time() -> u64 {
+    let now = SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+    let secs_after_last_period = now.checked_rem(30 * 60).unwrap_or(0);
+    // genesis is now the last 30 minute block.
+    now - secs_after_last_period
+}

beacon_node/client/src/config.rs

@@ -7,6 +7,12 @@ use std::fs::{self, OpenOptions};
 use std::path::PathBuf;
 use std::sync::Mutex;
 
+/// The number initial validators when starting the `Minimal`.
+const TESTNET_VALIDATOR_COUNT: usize = 16;
+
+/// The number initial validators when starting the `Minimal`.
+const TESTNET_SPEC_CONSTANTS: &str = "minimal";
+
 /// The core configuration of a Lighthouse beacon node.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Config {
@@ -14,12 +20,35 @@ pub struct Config {
     pub db_type: String,
     db_name: String,
     pub log_file: PathBuf,
+    pub spec_constants: String,
+    pub genesis_state: GenesisState,
     pub network: network::NetworkConfig,
     pub rpc: rpc::RPCConfig,
     pub http: HttpServerConfig,
     pub rest_api: rest_api::APIConfig,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type")]
+pub enum GenesisState {
+    /// Use the mainnet genesis state.
+    ///
+    /// Mainnet genesis state is not presently known, so this is a place-holder.
+    Mainnet,
+    /// Generate a state with `validator_count` validators, all with well-known secret keys.
+    ///
+    /// Set the genesis time to be the start of the previous 30-minute window.
+    RecentGenesis { validator_count: usize },
+    /// Generate a state with `genesis_time` and `validator_count` validators, all with well-known
+    /// secret keys.
+    Generated {
+        validator_count: usize,
+        genesis_time: u64,
+    },
+    /// Load a YAML-encoded genesis state from a file.
+    Yaml { file: PathBuf },
+}
+
 impl Default for Config {
     fn default() -> Self {
         Self {
@@ -33,6 +62,10 @@ impl Default for Config {
             rpc: rpc::RPCConfig::default(),
             http: HttpServerConfig::default(),
             rest_api: rest_api::APIConfig::default(),
+            spec_constants: TESTNET_SPEC_CONSTANTS.into(),
+            genesis_state: GenesisState::RecentGenesis {
+                validator_count: TESTNET_VALIDATOR_COUNT,
+            },
         }
     }
 }

beacon_node/client/src/lib.rs

@@ -67,9 +67,10 @@ where
         // Load a `BeaconChain` from the store, or create a new one if it does not exist.
         let beacon_chain = Arc::new(T::initialise_beacon_chain(
             store,
+            &client_config,
             eth2_config.spec.clone(),
             log.clone(),
-        ));
+        )?);
         // Registry all beacon chain metrics with the global registry.
         beacon_chain
             .metrics
@@ -90,7 +91,7 @@ where
             let slots_since_genesis = beacon_chain.slots_since_genesis().unwrap();
             info!(
                 log,
-                "Initializing state";
+                "BeaconState cache init";
                 "state_slot" => state_slot,
                 "wall_clock_slot" => wall_clock_slot,
                 "slots_since_genesis" => slots_since_genesis,
@@ -98,12 +99,6 @@ where
             );
         }
         do_state_catchup(&beacon_chain, &log);
-        info!(
-            log,
-            "State initialized";
-            "state_slot" => beacon_chain.head().beacon_state.slot,
-            "wall_clock_slot" => beacon_chain.read_slot_clock().unwrap(),
-        );
 
         // Start the network service, libp2p and syncing threads
         // TODO: Add beacon_chain reference to network parameters