Validator client refactor (#618)

* Update to spec v0.9.0

* Update to v0.9.1

* Bump spec tags for v0.9.1

* Formatting, fix CI failures

* Resolve accidental KeyPair merge conflict

* Document new BeaconState functions

* Add `validator` changes from `validator-to-rest`

* Add initial (failing) REST api tests

* Fix signature parsing

* Add more tests

* Refactor http router

* Add working tests for publish beacon block

* Add validator duties tests

* Move account_manager under `lighthouse` binary

* Unify logfile handling in `environment` crate.

* Fix incorrect cache drops in `advance_caches`

* Update fork choice for v0.9.1

* Add `deposit_contract` crate

* Add progress on validator onboarding

* Add unfinished attesation code

* Update account manager CLI

* Write eth1 data file as hex string

* Integrate ValidatorDirectory with validator_client

* Move ValidatorDirectory into validator_client

* Clean up some FIXMEs

* Add beacon_chain_sim

* Fix a few docs/logs

* Expand `beacon_chain_sim`

* Fix spec for `beacon_chain_sim

* More testing for api

* Start work on attestation endpoint

* Reject empty attestations

* Allow attestations to genesis block

* Add working tests for `rest_api` validator endpoint

* Remove grpc from beacon_node

* Start heavy refactor of validator client

- Block production is working

* Prune old validator client files

* Start works on attestation service

* Add attestation service to validator client

* Use full pubkey for validator directories

* Add validator duties post endpoint

* Use par_iter for keypair generation

* Use bulk duties request in validator client

* Add version http endpoint tests

* Add interop keys and startup wait

* Ensure a prompt exit

* Add duties pruning

* Fix compile error in beacon node tests

* Add github workflow

* Modify rust.yaml

* Modify gitlab actions

* Add to CI file

* Add sudo to CI npm install

* Move cargo fmt to own job in tests

* Fix cargo fmt in CI

* Add rustup update before cargo fmt

* Change name of CI job

* Make other CI jobs require cargo fmt

* Add CI badge

* Remove gitlab and travis files

* Add different http timeout for debug

* Update docker file, use makefile in CI

* Use make in the dockerfile, skip the test

* Use the makefile for debug GI test

* Update book

* Tidy grpc and misc things

* Apply discv5 fixes

* Address other minor issues

* Fix warnings

* Attempt fix for addr parsing

* Tidy validator config, CLIs

* Tidy comments

* Tidy signing, reduce ForkService duplication

* Fail if skipping too many slots

* Set default recent genesis time to 0

* Add custom http timeout to validator

* Fix compile bug in node_test_rig

* Remove old bootstrap flag from val CLI

* Update docs

* Tidy val client

* Change val client log levels

* Add comments, more validity checks

* Fix compile error, add comments

* Undo changes to eth2-libp2p/src

* Reduce duplication of keypair generation

* Add more logging for validator duties

* Fix beacon_chain_sim, nitpicks

* Fix compile error, minor nits

* Address Michael's comments

beacon_node/rest_api/src/helpers.rs

@@ -10,13 +10,16 @@ use http::header;
 use hyper::{Body, Request};
 use network::NetworkMessage;
 use parking_lot::RwLock;
-use ssz::Encode;
+use ssz::{Decode, Encode};
 use std::sync::Arc;
 use store::{iter::AncestorIter, Store};
 use tokio::sync::mpsc;
-use types::{Attestation, BeaconBlock, BeaconState, EthSpec, Hash256, RelativeEpoch, Slot};
+use types::{
+    Attestation, BeaconBlock, BeaconState, CommitteeIndex, Epoch, EthSpec, Hash256, RelativeEpoch,
+    Signature, Slot,
+};
 
-/// Parse a slot from a `0x` preixed string.
+/// Parse a slot.
 ///
 /// E.g., `"1234"`
 pub fn parse_slot(string: &str) -> Result<Slot, ApiError> {
@@ -26,6 +29,25 @@ pub fn parse_slot(string: &str) -> Result<Slot, ApiError> {
         .map_err(|e| ApiError::BadRequest(format!("Unable to parse slot: {:?}", e)))
 }
 
+/// Parse an epoch.
+///
+/// E.g., `"13"`
+pub fn parse_epoch(string: &str) -> Result<Epoch, ApiError> {
+    string
+        .parse::<u64>()
+        .map(Epoch::from)
+        .map_err(|e| ApiError::BadRequest(format!("Unable to parse epoch: {:?}", e)))
+}
+
+/// Parse a CommitteeIndex.
+///
+/// E.g., `"18"`
+pub fn parse_committee_index(string: &str) -> Result<CommitteeIndex, ApiError> {
+    string
+        .parse::<CommitteeIndex>()
+        .map_err(|e| ApiError::BadRequest(format!("Unable to parse committee index: {:?}", e)))
+}
+
 /// Checks the provided request to ensure that the `content-type` header.
 ///
 /// The content-type header should either be omitted, in which case JSON is assumed, or it should
@@ -41,6 +63,23 @@ pub fn check_content_type_for_json(req: &Request<Body>) -> Result<(), ApiError>
     }
 }
 
+/// Parse a signature from a `0x` preixed string.
+pub fn parse_signature(string: &str) -> Result<Signature, ApiError> {
+    const PREFIX: &str = "0x";
+
+    if string.starts_with(PREFIX) {
+        let trimmed = string.trim_start_matches(PREFIX);
+        let bytes = hex::decode(trimmed)
+            .map_err(|e| ApiError::BadRequest(format!("Unable to parse signature hex: {:?}", e)))?;
+        Signature::from_ssz_bytes(&bytes)
+            .map_err(|e| ApiError::BadRequest(format!("Unable to parse signature bytes: {:?}", e)))
+    } else {
+        Err(ApiError::BadRequest(
+            "Signature must have a 0x prefix".to_string(),
+        ))
+    }
+}
+
 /// Parse a root from a `0x` preixed string.
 ///
 /// E.g., `"0x0000000000000000000000000000000000000000000000000000000000000000"`
@@ -54,7 +93,7 @@ pub fn parse_root(string: &str) -> Result<Hash256, ApiError> {
             .map_err(|e| ApiError::BadRequest(format!("Unable to parse root: {:?}", e)))
     } else {
         Err(ApiError::BadRequest(
-            "Root must have a  '0x' prefix".to_string(),
+            "Root must have a 0x prefix".to_string(),
         ))
     }
 }
@@ -71,7 +110,7 @@ pub fn parse_pubkey(string: &str) -> Result<PublicKey, ApiError> {
         Ok(pubkey)
     } else {
         Err(ApiError::BadRequest(
-            "Public key must have a  '0x' prefix".to_string(),
+            "Public key must have a 0x prefix".to_string(),
         ))
     }
 }
@@ -194,26 +233,6 @@ pub fn implementation_pending_response(_req: Request<Body>) -> ApiResult {
     ))
 }
 
-pub fn get_beacon_chain_from_request<T: BeaconChainTypes + 'static>(
-    req: &Request<Body>,
-) -> Result<(Arc<BeaconChain<T>>), ApiError> {
-    // Get beacon state
-    let beacon_chain = req
-        .extensions()
-        .get::<Arc<BeaconChain<T>>>()
-        .ok_or_else(|| ApiError::ServerError("Beacon chain extension missing".into()))?;
-
-    Ok(beacon_chain.clone())
-}
-
-pub fn get_logger_from_request(req: &Request<Body>) -> slog::Logger {
-    let log = req
-        .extensions()
-        .get::<slog::Logger>()
-        .expect("Should always get the logger from the request, since we put it in there.");
-    log.to_owned()
-}
-
 pub fn publish_beacon_block_to_network<T: BeaconChainTypes + 'static>(
     chan: Arc<RwLock<mpsc::UnboundedSender<NetworkMessage>>>,
     block: BeaconBlock<T::EthSpec>,