Start heavy refactor of validator client

- Block production is working

eth2/utils/remote_beacon_node/Cargo.toml

@@ -16,3 +16,4 @@ rest_api = { path = "../../../beacon_node/rest_api" }
 hex = "0.3"
 eth2_ssz = { path = "../../../eth2/utils/ssz" }
 serde_json = "^1.0"
+eth2_config = { path = "../../../eth2/utils/eth2_config" }

eth2/utils/remote_beacon_node/src/lib.rs

@@ -3,6 +3,7 @@
 //!
 //! Presently, this is only used for testing but it _could_ become a user-facing library.
 
+use eth2_config::Eth2Config;
 use futures::{future, Future, IntoFuture};
 use reqwest::{
     r#async::{Client, ClientBuilder, Response},
@@ -14,8 +15,8 @@ use std::marker::PhantomData;
 use std::net::SocketAddr;
 use std::time::Duration;
 use types::{
-    Attestation, BeaconBlock, BeaconState, CommitteeIndex, Epoch, EthSpec, Hash256, PublicKey,
-    Signature, Slot,
+    Attestation, BeaconBlock, BeaconState, CommitteeIndex, Epoch, EthSpec, Fork, Hash256,
+    PublicKey, Signature, Slot,
 };
 use url::Url;
 
@@ -23,6 +24,7 @@ pub use rest_api::{HeadResponse, ValidatorDuty};
 
 pub const REQUEST_TIMEOUT_SECONDS: u64 = 5;
 
+#[derive(Clone)]
 /// Connects to a remote Lighthouse (or compatible) node via HTTP.
 pub struct RemoteBeaconNode<E: EthSpec> {
     pub http: HttpClient<E>,
@@ -81,6 +83,10 @@ impl<E: EthSpec> HttpClient<E> {
         Validator(self.clone())
     }
 
+    pub fn spec(&self) -> Spec<E> {
+        Spec(self.clone())
+    }
+
     fn url(&self, path: &str) -> Result<Url, Error> {
         self.url.join(path).map_err(|e| e.into())
     }
@@ -284,6 +290,20 @@ impl<E: EthSpec> Beacon<E> {
             .map_err(Into::into)
     }
 
+    pub fn get_genesis_time(&self) -> impl Future<Item = u64, Error = Error> {
+        let client = self.0.clone();
+        self.url("genesis_time")
+            .into_future()
+            .and_then(move |url| client.json_get(url, vec![]))
+    }
+
+    pub fn get_fork(&self) -> impl Future<Item = Fork, Error = Error> {
+        let client = self.0.clone();
+        self.url("fork")
+            .into_future()
+            .and_then(move |url| client.json_get(url, vec![]))
+    }
+
     pub fn get_head(&self) -> impl Future<Item = HeadResponse, Error = Error> {
         let client = self.0.clone();
         self.url("head")
@@ -354,6 +374,26 @@ impl<E: EthSpec> Beacon<E> {
     }
 }
 
+/// Provides the functions on the `/spec` endpoint of the node.
+#[derive(Clone)]
+pub struct Spec<E>(HttpClient<E>);
+
+impl<E: EthSpec> Spec<E> {
+    fn url(&self, path: &str) -> Result<Url, Error> {
+        self.0
+            .url("spec/")
+            .and_then(move |url| url.join(path).map_err(Error::from))
+            .map_err(Into::into)
+    }
+
+    pub fn get_eth2_config(&self) -> impl Future<Item = Eth2Config, Error = Error> {
+        let client = self.0.clone();
+        self.url("eth2_config")
+            .into_future()
+            .and_then(move |url| client.json_get(url, vec![]))
+    }
+}
+
 #[derive(Deserialize)]
 #[serde(bound = "T: EthSpec")]
 pub struct BlockResponse<T: EthSpec> {

eth2/utils/slot_clock/src/lib.rs

@@ -28,4 +28,7 @@ pub trait SlotClock: Send + Sync + Sized {
 
     /// Returns the duration until the next slot.
     fn duration_to_next_slot(&self) -> Option<Duration>;
+
+    /// Returns the duration until the first slot of the next epoch.
+    fn duration_to_next_epoch(&self, slots_per_epoch: u64) -> Option<Duration>;
 }

eth2/utils/slot_clock/src/system_time_slot_clock.rs

@@ -65,6 +65,35 @@ impl SlotClock for SystemTimeSlotClock {
         }
     }
 
+    fn duration_to_next_epoch(&self, slots_per_epoch: u64) -> Option<Duration> {
+        let now = SystemTime::now().duration_since(UNIX_EPOCH).ok()?;
+        let genesis = self.genesis_duration;
+
+        let slot_start = |slot: Slot| -> Duration {
+            let slot = slot.as_u64() as u32;
+            genesis + slot * self.slot_duration
+        };
+
+        let slot = self
+            .now()
+            .map(|slot| slot.epoch(slots_per_epoch))
+            .map(|epoch| (epoch + 1).start_slot(slots_per_epoch))?;
+
+        if now >= genesis {
+            Some(
+                slot_start(self.now()? + 1)
+                    .checked_sub(now)
+                    .expect("The next epoch cannot start before now"),
+            )
+        } else {
+            Some(
+                genesis
+                    .checked_sub(now)
+                    .expect("Control flow ensures genesis is greater than or equal to now"),
+            )
+        }
+    }
+
     fn slot_duration(&self) -> Duration {
         self.slot_duration
     }

eth2/utils/slot_clock/src/testing_slot_clock.rs

@@ -37,6 +37,11 @@ impl SlotClock for TestingSlotClock {
         Some(Duration::from_secs(1))
     }
 
+    /// Always returns a duration of `1 * slots_per_epoch` second.
+    fn duration_to_next_epoch(&self, slots_per_epoch: u64) -> Option<Duration> {
+        Some(Duration::from_secs(1 + slots_per_epoch))
+    }
+
     /// Always returns a slot duration of 0 seconds.
     fn slot_duration(&self) -> Duration {
         Duration::from_secs(0)