Refactor beacon chain start code

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -114,7 +114,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     /// Instantiate a new Beacon Chain, from genesis.
     pub fn from_genesis(
         store: Arc<T::Store>,
-        slot_clock: T::SlotClock,
         mut genesis_state: BeaconState<T::EthSpec>,
         mut genesis_block: BeaconBlock<T::EthSpec>,
         spec: ChainSpec,
@@ -147,6 +146,13 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
               "genesis_block_root" => format!("{}", genesis_block_root),
         );
 
+        // Slot clock
+        let slot_clock = T::SlotClock::new(
+            spec.genesis_slot,
+            genesis_state.genesis_time,
+            spec.seconds_per_slot,
+        );
+
         Ok(Self {
             spec,
             slot_clock,

beacon_node/beacon_chain/src/beacon_chain_builder.rs

@@ -1,49 +1,115 @@
-use crate::BeaconChainTypes;
+use super::bootstrapper::Bootstrapper;
+use crate::{BeaconChain, BeaconChainTypes};
+use slog::Logger;
 use std::fs::File;
 use std::path::PathBuf;
+use std::sync::Arc;
 use std::time::SystemTime;
-use types::{
-    test_utils::TestingBeaconStateBuilder, BeaconBlock, BeaconState, ChainSpec, EthSpec, Hash256,
-};
+use types::{test_utils::TestingBeaconStateBuilder, BeaconBlock, BeaconState, ChainSpec, EthSpec};
+
+enum BuildStrategy<T: BeaconChainTypes> {
+    FromGenesis {
+        genesis_state: Box<BeaconState<T::EthSpec>>,
+        genesis_block: Box<BeaconBlock<T::EthSpec>>,
+    },
+    LoadFromStore,
+}
 
 pub struct BeaconChainBuilder<T: BeaconChainTypes> {
-    genesis_state: BeaconState<T::EthSpec>,
-    genesis_block: BeaconBlock<T::EthSpec>,
+    build_strategy: BuildStrategy<T>,
     spec: ChainSpec,
+    log: Logger,
 }
 
 impl<T: BeaconChainTypes> BeaconChainBuilder<T> {
-    pub fn recent_genesis(validator_count: usize, spec: ChainSpec) -> Self {
-        Self::quick_start(recent_genesis_time(), validator_count, spec)
+    pub fn recent_genesis(validator_count: usize, spec: ChainSpec, log: Logger) -> Self {
+        Self::quick_start(recent_genesis_time(), validator_count, spec, log)
     }
 
-    pub fn quick_start(genesis_time: u64, validator_count: usize, spec: ChainSpec) -> Self {
+    pub fn quick_start(
+        genesis_time: u64,
+        validator_count: usize,
+        spec: ChainSpec,
+        log: Logger,
+    ) -> Self {
         let (mut genesis_state, _keypairs) =
             TestingBeaconStateBuilder::from_default_keypairs_file_if_exists(validator_count, &spec)
                 .build();
 
         genesis_state.genesis_time = genesis_time;
 
-        Self::from_genesis_state(genesis_state, spec)
+        Self::from_genesis_state(genesis_state, spec, log)
     }
 
-    pub fn yaml_state(file: PathBuf, spec: ChainSpec) -> Result<Self, String> {
+    pub fn yaml_state(file: &PathBuf, spec: ChainSpec, log: Logger) -> Result<Self, String> {
         let file = File::open(file.clone())
             .map_err(|e| format!("Unable to open YAML genesis state file {:?}: {:?}", file, e))?;
 
         let genesis_state = serde_yaml::from_reader(file)
             .map_err(|e| format!("Unable to parse YAML genesis state file: {:?}", e))?;
 
-        Ok(Self::from_genesis_state(genesis_state, spec))
+        Ok(Self::from_genesis_state(genesis_state, spec, log))
     }
 
-    pub fn from_genesis_state(genesis_state: BeaconState<T::EthSpec>, spec: ChainSpec) -> Self {
-        Self {
-            genesis_block: genesis_block(&genesis_state, &spec),
-            genesis_state,
+    pub fn http_bootstrap(server: &str, spec: ChainSpec, log: Logger) -> Result<Self, String> {
+        let bootstrapper = Bootstrapper::from_server_string(server.to_string())
+            .map_err(|e| format!("Failed to initialize bootstrap client: {}", e))?;
+
+        let (genesis_state, genesis_block) = bootstrapper
+            .genesis()
+            .map_err(|e| format!("Failed to bootstrap genesis state: {}", e))?;
+
+        Ok(Self {
+            build_strategy: BuildStrategy::FromGenesis {
+                genesis_block: Box::new(genesis_block),
+                genesis_state: Box::new(genesis_state),
+            },
             spec,
+            log,
+        })
+    }
+
+    fn from_genesis_state(
+        genesis_state: BeaconState<T::EthSpec>,
+        spec: ChainSpec,
+        log: Logger,
+    ) -> Self {
+        Self {
+            build_strategy: BuildStrategy::FromGenesis {
+                genesis_block: Box::new(genesis_block(&genesis_state, &spec)),
+                genesis_state: Box::new(genesis_state),
+            },
+            spec,
+            log,
         }
     }
+
+    pub fn from_store(spec: ChainSpec, log: Logger) -> Self {
+        Self {
+            build_strategy: BuildStrategy::LoadFromStore,
+            spec,
+            log,
+        }
+    }
+
+    pub fn build(self, store: Arc<T::Store>) -> Result<BeaconChain<T>, String> {
+        Ok(match self.build_strategy {
+            BuildStrategy::LoadFromStore => BeaconChain::from_store(store, self.spec, self.log)
+                .map_err(|e| format!("Error loading BeaconChain from database: {:?}", e))?
+                .ok_or_else(|| format!("Unable to find exising BeaconChain in database."))?,
+            BuildStrategy::FromGenesis {
+                genesis_block,
+                genesis_state,
+            } => BeaconChain::from_genesis(
+                store,
+                genesis_state.as_ref().clone(),
+                genesis_block.as_ref().clone(),
+                self.spec,
+                self.log,
+            )
+            .map_err(|e| format!("Failed to initialize new beacon chain: {:?}", e))?,
+        })
+    }
 }
 
 fn genesis_block<T: EthSpec>(genesis_state: &BeaconState<T>, spec: &ChainSpec) -> BeaconBlock<T> {

beacon_node/beacon_chain/src/bootstrapper.rs

@@ -0,0 +1,214 @@
+use eth2_libp2p::{
+    multiaddr::{Multiaddr, Protocol},
+    Enr,
+};
+use reqwest::{Error as HttpError, Url};
+use serde::Deserialize;
+use std::borrow::Cow;
+use std::net::Ipv4Addr;
+use types::{BeaconBlock, BeaconState, Checkpoint, EthSpec, Hash256, Slot};
+use url::Host;
+
+#[derive(Debug)]
+enum Error {
+    InvalidUrl,
+    HttpError(HttpError),
+}
+
+impl From<HttpError> for Error {
+    fn from(e: HttpError) -> Error {
+        Error::HttpError(e)
+    }
+}
+
+/// Used to load "bootstrap" information from the HTTP API of another Lighthouse beacon node.
+///
+/// Bootstrapping information includes things like genesis and finalized states and blocks, and
+/// libp2p connection details.
+pub struct Bootstrapper {
+    url: Url,
+}
+
+impl Bootstrapper {
+    /// Parses the given `server` as a URL, instantiating `Self`.
+    pub fn from_server_string(server: String) -> Result<Self, String> {
+        Ok(Self {
+            url: Url::parse(&server).map_err(|e| format!("Invalid bootstrap server url: {}", e))?,
+        })
+    }
+
+    /// Build a multiaddr using the HTTP server URL that is not guaranteed to be correct.
+    ///
+    /// The address is created by querying the HTTP server for its listening libp2p addresses.
+    /// Then, we find the first TCP port in those addresses and combine the port with the URL of
+    /// the server.
+    ///
+    /// For example, the server `http://192.168.0.1` might end up with a `best_effort_multiaddr` of
+    /// `/ipv4/192.168.0.1/tcp/9000` if the server advertises a listening address of
+    /// `/ipv4/172.0.0.1/tcp/9000`.
+    pub fn best_effort_multiaddr(&self, port: Option<u16>) -> Option<Multiaddr> {
+        let tcp_port = if let Some(port) = port {
+            port
+        } else {
+            self.listen_port().ok()?
+        };
+
+        let mut multiaddr = Multiaddr::with_capacity(2);
+
+        match self.url.host()? {
+            Host::Ipv4(addr) => multiaddr.push(Protocol::Ip4(addr)),
+            Host::Domain(s) => multiaddr.push(Protocol::Dns4(Cow::Borrowed(s))),
+            _ => return None,
+        };
+
+        multiaddr.push(Protocol::Tcp(tcp_port));
+
+        Some(multiaddr)
+    }
+
+    /// Returns the IPv4 address of the server URL, unless it contains a FQDN.
+    pub fn server_ipv4_addr(&self) -> Option<Ipv4Addr> {
+        match self.url.host()? {
+            Host::Ipv4(addr) => Some(addr),
+            _ => None,
+        }
+    }
+
+    /// Returns the servers ENR address.
+    pub fn enr(&self) -> Result<Enr, String> {
+        get_enr(self.url.clone()).map_err(|e| format!("Unable to get ENR: {:?}", e))
+    }
+
+    /// Returns the servers listening libp2p addresses.
+    pub fn listen_port(&self) -> Result<u16, String> {
+        get_listen_port(self.url.clone()).map_err(|e| format!("Unable to get listen port: {:?}", e))
+    }
+
+    /// Returns the genesis block and state.
+    pub fn genesis<T: EthSpec>(&self) -> Result<(BeaconState<T>, BeaconBlock<T>), String> {
+        let genesis_slot = Slot::new(0);
+
+        let block = get_block(self.url.clone(), genesis_slot)
+            .map_err(|e| format!("Unable to get genesis block: {:?}", e))?
+            .beacon_block;
+        let state = get_state(self.url.clone(), genesis_slot)
+            .map_err(|e| format!("Unable to get genesis state: {:?}", e))?
+            .beacon_state;
+
+        Ok((state, block))
+    }
+
+    /// Returns the most recent finalized state and block.
+    pub fn finalized<T: EthSpec>(&self) -> Result<(BeaconState<T>, BeaconBlock<T>), String> {
+        let slots_per_epoch = get_slots_per_epoch(self.url.clone())
+            .map_err(|e| format!("Unable to get slots per epoch: {:?}", e))?;
+        let finalized_slot = get_finalized_slot(self.url.clone(), slots_per_epoch.as_u64())
+            .map_err(|e| format!("Unable to get finalized slot: {:?}", e))?;
+
+        let block = get_block(self.url.clone(), finalized_slot)
+            .map_err(|e| format!("Unable to get finalized block: {:?}", e))?
+            .beacon_block;
+        let state = get_state(self.url.clone(), finalized_slot)
+            .map_err(|e| format!("Unable to get finalized state: {:?}", e))?
+            .beacon_state;
+
+        Ok((state, block))
+    }
+}
+
+fn get_slots_per_epoch(mut url: Url) -> Result<Slot, Error> {
+    url.path_segments_mut()
+        .map(|mut url| {
+            url.push("spec").push("slots_per_epoch");
+        })
+        .map_err(|_| Error::InvalidUrl)?;
+
+    reqwest::get(url)?
+        .error_for_status()?
+        .json()
+        .map_err(Into::into)
+}
+
+fn get_finalized_slot(mut url: Url, slots_per_epoch: u64) -> Result<Slot, Error> {
+    url.path_segments_mut()
+        .map(|mut url| {
+            url.push("beacon").push("latest_finalized_checkpoint");
+        })
+        .map_err(|_| Error::InvalidUrl)?;
+
+    let checkpoint: Checkpoint = reqwest::get(url)?.error_for_status()?.json()?;
+
+    Ok(checkpoint.epoch.start_slot(slots_per_epoch))
+}
+
+#[derive(Deserialize)]
+#[serde(bound = "T: EthSpec")]
+pub struct StateResponse<T: EthSpec> {
+    pub root: Hash256,
+    pub beacon_state: BeaconState<T>,
+}
+
+fn get_state<T: EthSpec>(mut url: Url, slot: Slot) -> Result<StateResponse<T>, Error> {
+    url.path_segments_mut()
+        .map(|mut url| {
+            url.push("beacon").push("state");
+        })
+        .map_err(|_| Error::InvalidUrl)?;
+
+    url.query_pairs_mut()
+        .append_pair("slot", &format!("{}", slot.as_u64()));
+
+    reqwest::get(url)?
+        .error_for_status()?
+        .json()
+        .map_err(Into::into)
+}
+
+#[derive(Deserialize)]
+#[serde(bound = "T: EthSpec")]
+pub struct BlockResponse<T: EthSpec> {
+    pub root: Hash256,
+    pub beacon_block: BeaconBlock<T>,
+}
+
+fn get_block<T: EthSpec>(mut url: Url, slot: Slot) -> Result<BlockResponse<T>, Error> {
+    url.path_segments_mut()
+        .map(|mut url| {
+            url.push("beacon").push("block");
+        })
+        .map_err(|_| Error::InvalidUrl)?;
+
+    url.query_pairs_mut()
+        .append_pair("slot", &format!("{}", slot.as_u64()));
+
+    reqwest::get(url)?
+        .error_for_status()?
+        .json()
+        .map_err(Into::into)
+}
+
+fn get_enr(mut url: Url) -> Result<Enr, Error> {
+    url.path_segments_mut()
+        .map(|mut url| {
+            url.push("network").push("enr");
+        })
+        .map_err(|_| Error::InvalidUrl)?;
+
+    reqwest::get(url)?
+        .error_for_status()?
+        .json()
+        .map_err(Into::into)
+}
+
+fn get_listen_port(mut url: Url) -> Result<u16, Error> {
+    url.path_segments_mut()
+        .map(|mut url| {
+            url.push("network").push("listen_port");
+        })
+        .map_err(|_| Error::InvalidUrl)?;
+
+    reqwest::get(url)?
+        .error_for_status()?
+        .json()
+        .map_err(Into::into)
+}

beacon_node/beacon_chain/src/lib.rs

@@ -4,6 +4,7 @@ extern crate lazy_static;
 
 mod beacon_chain;
 mod beacon_chain_builder;
+mod bootstrapper;
 mod checkpoint;
 mod errors;
 mod fork_choice;
@@ -18,6 +19,7 @@ pub use self::beacon_chain::{
 pub use self::checkpoint::CheckPoint;
 pub use self::errors::{BeaconChainError, BlockProductionError};
 pub use beacon_chain_builder::BeaconChainBuilder;
+pub use bootstrapper::Bootstrapper;
 pub use lmd_ghost;
 pub use metrics::scrape_for_metrics;
 pub use parking_lot;

beacon_node/beacon_chain/src/test_utils.rs

@@ -1,7 +1,6 @@
 use crate::{BeaconChain, BeaconChainTypes, BlockProcessingOutcome};
 use lmd_ghost::LmdGhost;
 use sloggers::{null::NullLoggerBuilder, Build};
-use slot_clock::SlotClock;
 use slot_clock::TestingSlotClock;
 use state_processing::per_slot_processing;
 use std::marker::PhantomData;
@@ -114,22 +113,9 @@ where
         let builder = NullLoggerBuilder;
         let log = builder.build().expect("logger should build");
 
-        // Slot clock
-        let slot_clock = TestingSlotClock::new(
-            spec.genesis_slot,
-            genesis_state.genesis_time,
-            spec.seconds_per_slot,
-        );
-
-        let chain = BeaconChain::from_genesis(
-            store,
-            slot_clock,
-            genesis_state,
-            genesis_block,
-            spec.clone(),
-            log,
-        )
-        .expect("Terminate if beacon chain generation fails");
+        let chain =
+            BeaconChain::from_genesis(store, genesis_state, genesis_block, spec.clone(), log)
+                .expect("Terminate if beacon chain generation fails");
 
         Self {
             chain,