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

tests/node_test_rig/src/lib.rs

@@ -1,25 +1,41 @@
-use beacon_node::{
-    beacon_chain::BeaconChainTypes, Client, ClientConfig, ClientGenesis, ProductionBeaconNode,
-    ProductionClient,
-};
+//! Provides easy ways to run a beacon node or validator client in-process.
+//!
+//! Intended to be used for testing and simulation purposes. Not for production.
+
+use beacon_node::{beacon_chain::BeaconChainTypes, Client, ProductionBeaconNode};
 use environment::RuntimeContext;
 use futures::Future;
 use remote_beacon_node::RemoteBeaconNode;
+use std::path::PathBuf;
+use std::time::{SystemTime, UNIX_EPOCH};
 use tempdir::TempDir;
 use types::EthSpec;
+use validator_client::{KeySource, ProductionValidatorClient};
 
+pub use beacon_node::{ClientConfig, ClientGenesis, ProductionClient};
 pub use environment;
+pub use validator_client::Config as ValidatorConfig;
 
-/// Provides a beacon node that is running in the current process. Useful for testing purposes.
+/// Provids a beacon node that is running in the current process on a given tokio executor (it
+/// is _local_ to this process).
+///
+/// Intended for use in testing and simulation. Not for production.
 pub struct LocalBeaconNode<T> {
     pub client: T,
     pub datadir: TempDir,
 }
 
 impl<E: EthSpec> LocalBeaconNode<ProductionClient<E>> {
-    /// Starts a new, production beacon node.
-    pub fn production(context: RuntimeContext<E>) -> Self {
-        let (client_config, datadir) = testing_client_config();
+    /// Starts a new, production beacon node on the tokio runtime in the given `context`.
+    ///
+    /// The node created is using the same types as the node we use in production.
+    pub fn production(context: RuntimeContext<E>, mut client_config: ClientConfig) -> Self {
+        // Creates a temporary directory that will be deleted once this `TempDir` is dropped.
+        let datadir = TempDir::new("lighthouse_node_test_rig")
+            .expect("should create temp directory for client datadir");
+
+        client_config.data_dir = datadir.path().into();
+        client_config.network.network_dir = PathBuf::from(datadir.path()).join("network");
 
         let client = ProductionBeaconNode::new(context, client_config)
             .wait()
@@ -34,34 +50,99 @@ impl<T: BeaconChainTypes> LocalBeaconNode<Client<T>> {
     /// Returns a `RemoteBeaconNode` that can connect to `self`. Useful for testing the node as if
     /// it were external this process.
     pub fn remote_node(&self) -> Result<RemoteBeaconNode<T::EthSpec>, String> {
-        Ok(RemoteBeaconNode::new(
-            self.client
-                .http_listen_addr()
-                .ok_or_else(|| "A remote beacon node must have a http server".to_string())?,
-        )?)
+        let socket_addr = self
+            .client
+            .http_listen_addr()
+            .ok_or_else(|| "A remote beacon node must have a http server".to_string())?;
+        Ok(RemoteBeaconNode::new(format!(
+            "http://{}:{}",
+            socket_addr.ip(),
+            socket_addr.port()
+        ))?)
     }
 }
 
-fn testing_client_config() -> (ClientConfig, TempDir) {
-    // Creates a temporary directory that will be deleted once this `TempDir` is dropped.
-    let tempdir = TempDir::new("lighthouse_node_test_rig")
-        .expect("should create temp directory for client datadir");
-
+pub fn testing_client_config() -> ClientConfig {
     let mut client_config = ClientConfig::default();
 
-    client_config.data_dir = tempdir.path().into();
-
     // Setting ports to `0` means that the OS will choose some available port.
     client_config.network.libp2p_port = 0;
     client_config.network.discovery_port = 0;
-    client_config.rpc.port = 0;
     client_config.rest_api.port = 0;
     client_config.websocket_server.port = 0;
 
+    client_config.dummy_eth1_backend = true;
+
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("should get system time")
+        .as_secs();
+
     client_config.genesis = ClientGenesis::Interop {
         validator_count: 8,
-        genesis_time: 13_371_337,
+        genesis_time: now,
     };
 
-    (client_config, tempdir)
+    client_config.dummy_eth1_backend = true;
+
+    client_config
+}
+
+/// Provids a validator client that is running in the current process on a given tokio executor (it
+/// is _local_ to this process).
+///
+/// Intended for use in testing and simulation. Not for production.
+pub struct LocalValidatorClient<T: EthSpec> {
+    pub client: ProductionValidatorClient<T>,
+    pub datadir: TempDir,
+}
+
+impl<E: EthSpec> LocalValidatorClient<E> {
+    /// Creates a validator client with insecure deterministic keypairs. The validator directories
+    /// are created in a temp dir then removed when the process exits.
+    ///
+    /// The validator created is using the same types as the node we use in production.
+    pub fn production_with_insecure_keypairs(
+        context: RuntimeContext<E>,
+        mut config: ValidatorConfig,
+        keypair_indices: &[usize],
+    ) -> impl Future<Item = Self, Error = String> {
+        // Creates a temporary directory that will be deleted once this `TempDir` is dropped.
+        let datadir = TempDir::new("lighthouse-beacon-node")
+            .expect("should create temp directory for client datadir");
+
+        config.key_source = KeySource::InsecureKeypairs(keypair_indices.to_vec());
+
+        Self::new(context, config, datadir)
+    }
+
+    /// Creates a validator client that attempts to read keys from the default data dir.
+    ///
+    /// - The validator created is using the same types as the node we use in production.
+    /// - It is recommended to use `production_with_insecure_keypairs` for testing.
+    pub fn production(
+        context: RuntimeContext<E>,
+        config: ValidatorConfig,
+    ) -> impl Future<Item = Self, Error = String> {
+        // Creates a temporary directory that will be deleted once this `TempDir` is dropped.
+        let datadir = TempDir::new("lighthouse-validator")
+            .expect("should create temp directory for client datadir");
+
+        Self::new(context, config, datadir)
+    }
+
+    fn new(
+        context: RuntimeContext<E>,
+        mut config: ValidatorConfig,
+        datadir: TempDir,
+    ) -> impl Future<Item = Self, Error = String> {
+        config.data_dir = datadir.path().into();
+
+        ProductionValidatorClient::new(context, config).map(move |mut client| {
+            client
+                .start_service()
+                .expect("should start validator services");
+            Self { client, datadir }
+        })
+    }
 }