Bootstrap (#501)

* Renamed fork_choice::process_attestation_from_block

* Processing attestation in fork choice

* Retrieving state from store and checking signature

* Looser check on beacon state validity.

* Cleaned up get_attestation_state

* Expanded fork choice api to provide latest validator message.

* Checking if the an attestation contains a latest message

* Correct process_attestation error handling.

* Copy paste error in comment fixed.

* Tidy ancestor iterators

* Getting attestation slot via helper method

* Refactored attestation creation in test utils

* Revert "Refactored attestation creation in test utils"

This reverts commit 4d277fe4239a7194758b18fb5c00dfe0b8231306.

* Integration tests for free attestation processing

* Implicit conflicts resolved.

* formatting

* Do first pass on Grants code

* Add another attestation processing test

* Tidy attestation processing

* Remove old code fragment

* Add non-compiling half finished changes

* Simplify, fix bugs, add tests for chain iters

* Remove attestation processing from op pool

* Fix bug with fork choice, tidy

* Fix overly restrictive check in fork choice.

* Ensure committee cache is build during attn proc

* Ignore unknown blocks at fork choice

* Various minor fixes

* Make fork choice write lock in to read lock

* Remove unused method

* Tidy comments

* Fix attestation prod. target roots change

* Fix compile error in store iters

* Reject any attestation prior to finalization

* Begin metrics refactor

* Move beacon_chain to new metrics structure.

* Make metrics not panic if already defined

* Use global prometheus gather at rest api

* Unify common metric fns into a crate

* Add heavy metering to block processing

* Remove hypen from prometheus metric name

* Add more beacon chain metrics

* Add beacon chain persistence metric

* Prune op pool on finalization

* Add extra prom beacon chain metrics

* Prefix BeaconChain metrics with "beacon_"

* Add more store metrics

* Add basic metrics to libp2p

* Add metrics to HTTP server

* Remove old `http_server` crate

* Update metrics names to be more like standard

* Fix broken beacon chain metrics, add slot clock metrics

* Add lighthouse_metrics gather fn

* Remove http args

* Fix wrong state given to op pool prune

* Make prom metric names more consistent

* Add more metrics, tidy existing metrics

* Fix store block read metrics

* Tidy attestation metrics

* Fix minor PR comments

* Fix minor PR comments

* Remove duplicated attestation finalization check

* Remove awkward `let` statement

* Add first attempts at HTTP bootstrap

* Add beacon_block methods to rest api

* Fix serde for block.body.grafitti

* Allow travis failures on beta (see desc)

There's a non-backward compatible change in `cargo fmt`. Stable and beta
do not agree.

* Add network routes to API

* Fix rustc warnings

* Add best_slot method

* Add --bootstrap arg to beacon node

* Get bootstrapper working for ENR address

* Store intermediate states during block processing

* Allow bootstrapper to scrape libp2p address

* Update bootstrapper libp2p address finding

* Add comments

* Tidy API to be more consistent with recent decisions

* Address some review comments

* Make BeaconChainTypes Send + Sync + 'static

* Add `/network/listen_port` API endpoint

* Abandon starting the node if libp2p doesn't start

* Update bootstrapper for API changes

* Remove unnecessary trait bounds

beacon_node/rest_api/Cargo.toml

@@ -7,6 +7,8 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 beacon_chain = { path = "../beacon_chain" }
+network = { path = "../network" }
+eth2-libp2p = { path = "../eth2-libp2p" }
 store = { path = "../store" }
 version = { path = "../version" }
 serde = { version = "1.0", features = ["derive"] }

beacon_node/rest_api/src/beacon.rs

@@ -2,9 +2,114 @@ use super::{success_response, ApiResult};
 use crate::{helpers::*, ApiError, UrlQuery};
 use beacon_chain::{BeaconChain, BeaconChainTypes};
 use hyper::{Body, Request};
+use serde::Serialize;
 use std::sync::Arc;
 use store::Store;
-use types::BeaconState;
+use types::{BeaconBlock, BeaconState, EthSpec, Hash256, Slot};
+
+#[derive(Serialize)]
+pub struct HeadResponse {
+    pub slot: Slot,
+    pub block_root: Hash256,
+    pub state_root: Hash256,
+}
+
+/// HTTP handler to return a `BeaconBlock` at a given `root` or `slot`.
+pub fn get_head<T: BeaconChainTypes + 'static>(req: Request<Body>) -> ApiResult {
+    let beacon_chain = req
+        .extensions()
+        .get::<Arc<BeaconChain<T>>>()
+        .ok_or_else(|| ApiError::ServerError("Beacon chain extension missing".to_string()))?;
+
+    let head = HeadResponse {
+        slot: beacon_chain.head().beacon_state.slot,
+        block_root: beacon_chain.head().beacon_block_root,
+        state_root: beacon_chain.head().beacon_state_root,
+    };
+
+    let json: String = serde_json::to_string(&head)
+        .map_err(|e| ApiError::ServerError(format!("Unable to serialize HeadResponse: {:?}", e)))?;
+
+    Ok(success_response(Body::from(json)))
+}
+
+#[derive(Serialize)]
+#[serde(bound = "T: EthSpec")]
+pub struct BlockResponse<T: EthSpec> {
+    pub root: Hash256,
+    pub beacon_block: BeaconBlock<T>,
+}
+
+/// HTTP handler to return a `BeaconBlock` at a given `root` or `slot`.
+pub fn get_block<T: BeaconChainTypes + 'static>(req: Request<Body>) -> ApiResult {
+    let beacon_chain = req
+        .extensions()
+        .get::<Arc<BeaconChain<T>>>()
+        .ok_or_else(|| ApiError::ServerError("Beacon chain extension missing".to_string()))?;
+
+    let query_params = ["root", "slot"];
+    let (key, value) = UrlQuery::from_request(&req)?.first_of(&query_params)?;
+
+    let block_root = match (key.as_ref(), value) {
+        ("slot", value) => {
+            let target = parse_slot(&value)?;
+
+            block_root_at_slot(&beacon_chain, target).ok_or_else(|| {
+                ApiError::NotFound(format!("Unable to find BeaconBlock for slot {}", target))
+            })?
+        }
+        ("root", value) => parse_root(&value)?,
+        _ => return Err(ApiError::ServerError("Unexpected query parameter".into())),
+    };
+
+    let block = beacon_chain
+        .store
+        .get::<BeaconBlock<T::EthSpec>>(&block_root)?
+        .ok_or_else(|| {
+            ApiError::NotFound(format!(
+                "Unable to find BeaconBlock for root {}",
+                block_root
+            ))
+        })?;
+
+    let response = BlockResponse {
+        root: block_root,
+        beacon_block: block,
+    };
+
+    let json: String = serde_json::to_string(&response).map_err(|e| {
+        ApiError::ServerError(format!("Unable to serialize BlockResponse: {:?}", e))
+    })?;
+
+    Ok(success_response(Body::from(json)))
+}
+
+/// HTTP handler to return a `BeaconBlock` root at a given `slot`.
+pub fn get_block_root<T: BeaconChainTypes + 'static>(req: Request<Body>) -> ApiResult {
+    let beacon_chain = req
+        .extensions()
+        .get::<Arc<BeaconChain<T>>>()
+        .ok_or_else(|| ApiError::ServerError("Beacon chain extension missing".to_string()))?;
+
+    let slot_string = UrlQuery::from_request(&req)?.only_one("slot")?;
+    let target = parse_slot(&slot_string)?;
+
+    let root = block_root_at_slot(&beacon_chain, target).ok_or_else(|| {
+        ApiError::NotFound(format!("Unable to find BeaconBlock for slot {}", target))
+    })?;
+
+    let json: String = serde_json::to_string(&root)
+        .map_err(|e| ApiError::ServerError(format!("Unable to serialize root: {:?}", e)))?;
+
+    Ok(success_response(Body::from(json)))
+}
+
+#[derive(Serialize)]
+#[serde(bound = "T: EthSpec")]
+pub struct StateResponse<T: EthSpec> {
+    pub root: Hash256,
+    pub beacon_state: BeaconState<T>,
+}
 
 /// HTTP handler to return a `BeaconState` at a given `root` or `slot`.
 ///
@@ -19,26 +124,34 @@ pub fn get_state<T: BeaconChainTypes + 'static>(req: Request<Body>) -> ApiResult
     let query_params = ["root", "slot"];
     let (key, value) = UrlQuery::from_request(&req)?.first_of(&query_params)?;
 
-    let state: BeaconState<T::EthSpec> = match (key.as_ref(), value) {
+    let (root, state): (Hash256, BeaconState<T::EthSpec>) = match (key.as_ref(), value) {
         ("slot", value) => state_at_slot(&beacon_chain, parse_slot(&value)?)?,
         ("root", value) => {
             let root = &parse_root(&value)?;
 
-            beacon_chain
+            let state = beacon_chain
                 .store
                 .get(root)?
-                .ok_or_else(|| ApiError::NotFound(format!("No state for root: {}", root)))?
+                .ok_or_else(|| ApiError::NotFound(format!("No state for root: {}", root)))?;
+
+            (*root, state)
         }
-        _ => unreachable!("Guarded by UrlQuery::from_request()"),
+        _ => return Err(ApiError::ServerError("Unexpected query parameter".into())),
     };
 
-    let json: String = serde_json::to_string(&state)
-        .map_err(|e| ApiError::ServerError(format!("Unable to serialize BeaconState: {:?}", e)))?;
+    let response = StateResponse {
+        root,
+        beacon_state: state,
+    };
+
+    let json: String = serde_json::to_string(&response).map_err(|e| {
+        ApiError::ServerError(format!("Unable to serialize StateResponse: {:?}", e))
+    })?;
 
     Ok(success_response(Body::from(json)))
 }
 
-/// HTTP handler to return a `BeaconState` root at a given or `slot`.
+/// HTTP handler to return a `BeaconState` root at a given `slot`.
 ///
 /// Will not return a state if the request slot is in the future. Will return states higher than
 /// the current head by skipping slots.
@@ -58,3 +171,24 @@ pub fn get_state_root<T: BeaconChainTypes + 'static>(req: Request<Body>) -> ApiR
 
     Ok(success_response(Body::from(json)))
 }
+
+/// HTTP handler to return the highest finalized slot.
+pub fn get_latest_finalized_checkpoint<T: BeaconChainTypes + 'static>(
+    req: Request<Body>,
+) -> ApiResult {
+    let beacon_chain = req
+        .extensions()
+        .get::<Arc<BeaconChain<T>>>()
+        .ok_or_else(|| ApiError::ServerError("Beacon chain extension missing".to_string()))?;
+
+    let checkpoint = beacon_chain
+        .head()
+        .beacon_state
+        .finalized_checkpoint
+        .clone();
+
+    let json: String = serde_json::to_string(&checkpoint)
+        .map_err(|e| ApiError::ServerError(format!("Unable to serialize checkpoint: {:?}", e)))?;
+
+    Ok(success_response(Body::from(json)))
+}

beacon_node/rest_api/src/helpers.rs

@@ -31,22 +31,40 @@ pub fn parse_root(string: &str) -> Result<Hash256, ApiError> {
     }
 }
 
-/// Returns a `BeaconState` in the canonical chain of `beacon_chain` at the given `slot`, if
-/// possible.
+/// Returns the root of the `BeaconBlock` in the canonical chain of `beacon_chain` at the given
+/// `slot`, if possible.
+///
+/// May return a root for a previous slot, in the case of skip slots.
+pub fn block_root_at_slot<T: BeaconChainTypes>(
+    beacon_chain: &BeaconChain<T>,
+    target: Slot,
+) -> Option<Hash256> {
+    beacon_chain
+        .rev_iter_block_roots()
+        .take_while(|(_root, slot)| *slot >= target)
+        .find(|(_root, slot)| *slot == target)
+        .map(|(root, _slot)| root)
+}
+
+/// Returns a `BeaconState` and it's root in the canonical chain of `beacon_chain` at the given
+/// `slot`, if possible.
 ///
 /// Will not return a state if the request slot is in the future. Will return states higher than
 /// the current head by skipping slots.
 pub fn state_at_slot<T: BeaconChainTypes>(
     beacon_chain: &BeaconChain<T>,
     slot: Slot,
-) -> Result<BeaconState<T::EthSpec>, ApiError> {
+) -> Result<(Hash256, BeaconState<T::EthSpec>), ApiError> {
     let head_state = &beacon_chain.head().beacon_state;
 
     if head_state.slot == slot {
         // The request slot is the same as the best block (head) slot.
 
         // I'm not sure if this `.clone()` will be optimized out. If not, it seems unnecessary.
-        Ok(beacon_chain.head().beacon_state.clone())
+        Ok((
+            beacon_chain.head().beacon_state_root,
+            beacon_chain.head().beacon_state.clone(),
+        ))
     } else {
         let root = state_root_at_slot(beacon_chain, slot)?;
 
@@ -55,7 +73,7 @@ pub fn state_at_slot<T: BeaconChainTypes>(
             .get(&root)?
             .ok_or_else(|| ApiError::NotFound(format!("Unable to find state at root {}", root)))?;
 
-        Ok(state)
+        Ok((root, state))
     }
 }
 

beacon_node/rest_api/src/lib.rs

@@ -1,15 +1,18 @@
 #[macro_use]
 extern crate lazy_static;
+extern crate network as client_network;
 
 mod beacon;
 mod config;
 mod helpers;
 mod metrics;
+mod network;
 mod node;
+mod spec;
 mod url_query;
 
 use beacon_chain::{BeaconChain, BeaconChainTypes};
-pub use config::Config as ApiConfig;
+use client_network::Service as NetworkService;
 use hyper::rt::Future;
 use hyper::service::service_fn_ok;
 use hyper::{Body, Method, Response, Server, StatusCode};
@@ -20,6 +23,9 @@ use std::sync::Arc;
 use tokio::runtime::TaskExecutor;
 use url_query::UrlQuery;
 
+pub use beacon::{BlockResponse, HeadResponse, StateResponse};
+pub use config::Config as ApiConfig;
+
 #[derive(PartialEq, Debug)]
 pub enum ApiError {
     MethodNotAllowed(String),
@@ -67,10 +73,11 @@ impl From<state_processing::per_slot_processing::Error> for ApiError {
     }
 }
 
-pub fn start_server<T: BeaconChainTypes + Clone + 'static>(
+pub fn start_server<T: BeaconChainTypes>(
     config: &ApiConfig,
     executor: &TaskExecutor,
     beacon_chain: Arc<BeaconChain<T>>,
+    network_service: Arc<NetworkService<T>>,
     db_path: PathBuf,
     log: &slog::Logger,
 ) -> Result<exit_future::Signal, hyper::Error> {
@@ -98,6 +105,7 @@ pub fn start_server<T: BeaconChainTypes + Clone + 'static>(
         let log = server_log.clone();
         let beacon_chain = server_bc.clone();
         let db_path = db_path.clone();
+        let network_service = network_service.clone();
 
         // Create a simple handler for the router, inject our stateful objects into the request.
         service_fn_ok(move |mut req| {
@@ -108,16 +116,34 @@ pub fn start_server<T: BeaconChainTypes + Clone + 'static>(
             req.extensions_mut()
                 .insert::<Arc<BeaconChain<T>>>(beacon_chain.clone());
             req.extensions_mut().insert::<DBPath>(db_path.clone());
+            req.extensions_mut()
+                .insert::<Arc<NetworkService<T>>>(network_service.clone());
 
             let path = req.uri().path().to_string();
 
             // Route the request to the correct handler.
             let result = match (req.method(), path.as_ref()) {
+                (&Method::GET, "/beacon/head") => beacon::get_head::<T>(req),
+                (&Method::GET, "/beacon/block") => beacon::get_block::<T>(req),
+                (&Method::GET, "/beacon/block_root") => beacon::get_block_root::<T>(req),
+                (&Method::GET, "/beacon/latest_finalized_checkpoint") => {
+                    beacon::get_latest_finalized_checkpoint::<T>(req)
+                }
                 (&Method::GET, "/beacon/state") => beacon::get_state::<T>(req),
                 (&Method::GET, "/beacon/state_root") => beacon::get_state_root::<T>(req),
                 (&Method::GET, "/metrics") => metrics::get_prometheus::<T>(req),
+                (&Method::GET, "/network/enr") => network::get_enr::<T>(req),
+                (&Method::GET, "/network/peer_count") => network::get_peer_count::<T>(req),
+                (&Method::GET, "/network/peer_id") => network::get_peer_id::<T>(req),
+                (&Method::GET, "/network/peers") => network::get_peer_list::<T>(req),
+                (&Method::GET, "/network/listen_port") => network::get_listen_port::<T>(req),
+                (&Method::GET, "/network/listen_addresses") => {
+                    network::get_listen_addresses::<T>(req)
+                }
                 (&Method::GET, "/node/version") => node::get_version(req),
                 (&Method::GET, "/node/genesis_time") => node::get_genesis_time::<T>(req),
+                (&Method::GET, "/spec") => spec::get_spec::<T>(req),
+                (&Method::GET, "/spec/slots_per_epoch") => spec::get_slots_per_epoch::<T>(req),
                 _ => Err(ApiError::MethodNotAllowed(path.clone())),
             };
 

beacon_node/rest_api/src/network.rs

@@ -0,0 +1,108 @@
+use crate::{success_response, ApiError, ApiResult, NetworkService};
+use beacon_chain::BeaconChainTypes;
+use eth2_libp2p::{Enr, Multiaddr, PeerId};
+use hyper::{Body, Request};
+use std::sync::Arc;
+
+/// HTTP handle to return the list of libp2p multiaddr the client is listening on.
+///
+/// Returns a list of `Multiaddr`, serialized according to their `serde` impl.
+pub fn get_listen_addresses<T: BeaconChainTypes>(req: Request<Body>) -> ApiResult {
+    let network = req
+        .extensions()
+        .get::<Arc<NetworkService<T>>>()
+        .ok_or_else(|| ApiError::ServerError("NetworkService extension missing".to_string()))?;
+
+    let multiaddresses: Vec<Multiaddr> = network.listen_multiaddrs();
+
+    Ok(success_response(Body::from(
+        serde_json::to_string(&multiaddresses)
+            .map_err(|e| ApiError::ServerError(format!("Unable to serialize Enr: {:?}", e)))?,
+    )))
+}
+
+/// HTTP handle to return the list of libp2p multiaddr the client is listening on.
+///
+/// Returns a list of `Multiaddr`, serialized according to their `serde` impl.
+pub fn get_listen_port<T: BeaconChainTypes>(req: Request<Body>) -> ApiResult {
+    let network = req
+        .extensions()
+        .get::<Arc<NetworkService<T>>>()
+        .ok_or_else(|| ApiError::ServerError("NetworkService extension missing".to_string()))?;
+
+    Ok(success_response(Body::from(
+        serde_json::to_string(&network.listen_port())
+            .map_err(|e| ApiError::ServerError(format!("Unable to serialize port: {:?}", e)))?,
+    )))
+}
+
+/// HTTP handle to return the Discv5 ENR from the client's libp2p service.
+///
+/// ENR is encoded as base64 string.
+pub fn get_enr<T: BeaconChainTypes>(req: Request<Body>) -> ApiResult {
+    let network = req
+        .extensions()
+        .get::<Arc<NetworkService<T>>>()
+        .ok_or_else(|| ApiError::ServerError("NetworkService extension missing".to_string()))?;
+
+    let enr: Enr = network.local_enr();
+
+    Ok(success_response(Body::from(
+        serde_json::to_string(&enr.to_base64())
+            .map_err(|e| ApiError::ServerError(format!("Unable to serialize Enr: {:?}", e)))?,
+    )))
+}
+
+/// HTTP handle to return the `PeerId` from the client's libp2p service.
+///
+/// PeerId is encoded as base58 string.
+pub fn get_peer_id<T: BeaconChainTypes>(req: Request<Body>) -> ApiResult {
+    let network = req
+        .extensions()
+        .get::<Arc<NetworkService<T>>>()
+        .ok_or_else(|| ApiError::ServerError("NetworkService extension missing".to_string()))?;
+
+    let peer_id: PeerId = network.local_peer_id();
+
+    Ok(success_response(Body::from(
+        serde_json::to_string(&peer_id.to_base58())
+            .map_err(|e| ApiError::ServerError(format!("Unable to serialize Enr: {:?}", e)))?,
+    )))
+}
+
+/// HTTP handle to return the number of peers connected in the client's libp2p service.
+pub fn get_peer_count<T: BeaconChainTypes>(req: Request<Body>) -> ApiResult {
+    let network = req
+        .extensions()
+        .get::<Arc<NetworkService<T>>>()
+        .ok_or_else(|| ApiError::ServerError("NetworkService extension missing".to_string()))?;
+
+    let connected_peers: usize = network.connected_peers();
+
+    Ok(success_response(Body::from(
+        serde_json::to_string(&connected_peers)
+            .map_err(|e| ApiError::ServerError(format!("Unable to serialize Enr: {:?}", e)))?,
+    )))
+}
+
+/// HTTP handle to return the list of peers connected to the client's libp2p service.
+///
+/// Peers are presented as a list of `PeerId::to_string()`.
+pub fn get_peer_list<T: BeaconChainTypes>(req: Request<Body>) -> ApiResult {
+    let network = req
+        .extensions()
+        .get::<Arc<NetworkService<T>>>()
+        .ok_or_else(|| ApiError::ServerError("NetworkService extension missing".to_string()))?;
+
+    let connected_peers: Vec<String> = network
+        .connected_peer_set()
+        .iter()
+        .map(PeerId::to_string)
+        .collect();
+
+    Ok(success_response(Body::from(
+        serde_json::to_string(&connected_peers).map_err(|e| {
+            ApiError::ServerError(format!("Unable to serialize Vec<PeerId>: {:?}", e))
+        })?,
+    )))
+}

beacon_node/rest_api/src/spec.rs

@@ -0,0 +1,27 @@
+use super::{success_response, ApiResult};
+use crate::ApiError;
+use beacon_chain::{BeaconChain, BeaconChainTypes};
+use hyper::{Body, Request};
+use std::sync::Arc;
+use types::EthSpec;
+
+/// HTTP handler to return the full spec object.
+pub fn get_spec<T: BeaconChainTypes + 'static>(req: Request<Body>) -> ApiResult {
+    let beacon_chain = req
+        .extensions()
+        .get::<Arc<BeaconChain<T>>>()
+        .ok_or_else(|| ApiError::ServerError("Beacon chain extension missing".to_string()))?;
+
+    let json: String = serde_json::to_string(&beacon_chain.spec)
+        .map_err(|e| ApiError::ServerError(format!("Unable to serialize spec: {:?}", e)))?;
+
+    Ok(success_response(Body::from(json)))
+}
+
+/// HTTP handler to return the full spec object.
+pub fn get_slots_per_epoch<T: BeaconChainTypes + 'static>(_req: Request<Body>) -> ApiResult {
+    let json: String = serde_json::to_string(&T::EthSpec::slots_per_epoch())
+        .map_err(|e| ApiError::ServerError(format!("Unable to serialize epoch: {:?}", e)))?;
+
+    Ok(success_response(Body::from(json)))
+}