Fix all compile errors from new Slot/Epoch types

validator_client/src/block_producer_service/beacon_block_grpc_client.rs

@@ -5,7 +5,7 @@ use protos::services::{
 use protos::services_grpc::BeaconBlockServiceClient;
 use ssz::{ssz_encode, Decodable};
 use std::sync::Arc;
-use types::{BeaconBlock, BeaconBlockBody, Eth1Data, Hash256, PublicKey, Signature};
+use types::{BeaconBlock, BeaconBlockBody, Eth1Data, Hash256, PublicKey, Signature, Slot};
 
 /// A newtype designed to wrap the gRPC-generated service so the `BeaconNode` trait may be
 /// implemented upon it.
@@ -32,11 +32,11 @@ impl BeaconNode for BeaconBlockGrpcClient {
     /// BN is unable to find a parent block.
     fn produce_beacon_block(
         &self,
-        slot: u64,
+        slot: Slot,
         randao_reveal: &Signature,
     ) -> Result<Option<BeaconBlock>, BeaconNodeError> {
         let mut req = ProduceBeaconBlockRequest::new();
-        req.set_slot(slot);
+        req.set_slot(slot.as_u64());
 
         let reply = self
             .client
@@ -54,7 +54,7 @@ impl BeaconNode for BeaconBlockGrpcClient {
 
             // TODO: this conversion is incomplete; fix it.
             Ok(Some(BeaconBlock {
-                slot: block.get_slot(),
+                slot: Slot::new(block.get_slot()),
                 parent_root: Hash256::zero(),
                 state_root: Hash256::zero(),
                 randao_reveal,
@@ -88,7 +88,7 @@ impl BeaconNode for BeaconBlockGrpcClient {
 
         // TODO: this conversion is incomplete; fix it.
         let mut grpc_block = GrpcBeaconBlock::new();
-        grpc_block.set_slot(block.slot);
+        grpc_block.set_slot(block.slot.as_u64());
         grpc_block.set_block_root(vec![0]);
         grpc_block.set_randao_reveal(ssz_encode(&block.randao_reveal));
         grpc_block.set_signature(ssz_encode(&block.signature));

validator_client/src/duties/epoch_duties.rs

@@ -1,6 +1,7 @@
 use block_producer::{DutiesReader, DutiesReaderError};
 use std::collections::HashMap;
 use std::sync::RwLock;
+use types::{Epoch, Slot};
 
 /// The information required for a validator to propose and attest during some epoch.
 ///
@@ -10,14 +11,14 @@ use std::sync::RwLock;
 #[derive(Debug, PartialEq, Clone, Copy, Default)]
 pub struct EpochDuties {
     pub validator_index: u64,
-    pub block_production_slot: Option<u64>,
+    pub block_production_slot: Option<Slot>,
     // Future shard info
 }
 
 impl EpochDuties {
     /// Returns `true` if the supplied `slot` is a slot in which the validator should produce a
     /// block.
-    pub fn is_block_production_slot(&self, slot: u64) -> bool {
+    pub fn is_block_production_slot(&self, slot: Slot) -> bool {
         match self.block_production_slot {
             Some(s) if s == slot => true,
             _ => false,
@@ -32,7 +33,7 @@ pub enum EpochDutiesMapError {
 /// Maps an `epoch` to some `EpochDuties` for a single validator.
 pub struct EpochDutiesMap {
     pub epoch_length: u64,
-    pub map: RwLock<HashMap<u64, EpochDuties>>,
+    pub map: RwLock<HashMap<Epoch, EpochDuties>>,
 }
 
 impl EpochDutiesMap {
@@ -43,7 +44,7 @@ impl EpochDutiesMap {
         }
     }
 
-    pub fn get(&self, epoch: u64) -> Result<Option<EpochDuties>, EpochDutiesMapError> {
+    pub fn get(&self, epoch: Epoch) -> Result<Option<EpochDuties>, EpochDutiesMapError> {
         let map = self.map.read().map_err(|_| EpochDutiesMapError::Poisoned)?;
         match map.get(&epoch) {
             Some(duties) => Ok(Some(duties.clone())),
@@ -53,7 +54,7 @@ impl EpochDutiesMap {
 
     pub fn insert(
         &self,
-        epoch: u64,
+        epoch: Epoch,
         epoch_duties: EpochDuties,
     ) -> Result<Option<EpochDuties>, EpochDutiesMapError> {
         let mut map = self
@@ -65,10 +66,8 @@ impl EpochDutiesMap {
 }
 
 impl DutiesReader for EpochDutiesMap {
-    fn is_block_production_slot(&self, slot: u64) -> Result<bool, DutiesReaderError> {
-        let epoch = slot
-            .checked_div(self.epoch_length)
-            .ok_or_else(|| DutiesReaderError::EpochLengthIsZero)?;
+    fn is_block_production_slot(&self, slot: Slot) -> Result<bool, DutiesReaderError> {
+        let epoch = slot.epoch(self.epoch_length);
 
         let map = self.map.read().map_err(|_| DutiesReaderError::Poisoned)?;
         let duties = map

validator_client/src/duties/grpc.rs

@@ -3,7 +3,7 @@ use super::EpochDuties;
 use protos::services::{ProposeBlockSlotRequest, PublicKey as IndexRequest};
 use protos::services_grpc::ValidatorServiceClient;
 use ssz::ssz_encode;
-use types::PublicKey;
+use types::{Epoch, PublicKey, Slot};
 
 impl BeaconNode for ValidatorServiceClient {
     /// Request the shuffling from the Beacon Node (BN).
@@ -14,7 +14,7 @@ impl BeaconNode for ValidatorServiceClient {
     /// Note: presently only block production information is returned.
     fn request_shuffling(
         &self,
-        epoch: u64,
+        epoch: Epoch,
         public_key: &PublicKey,
     ) -> Result<Option<EpochDuties>, BeaconNodeError> {
         // Lookup the validator index for the supplied public key.
@@ -29,7 +29,7 @@ impl BeaconNode for ValidatorServiceClient {
 
         let mut req = ProposeBlockSlotRequest::new();
         req.set_validator_index(validator_index);
-        req.set_epoch(epoch);
+        req.set_epoch(epoch.as_u64());
 
         let reply = self
             .propose_block_slot(&req)
@@ -41,6 +41,11 @@ impl BeaconNode for ValidatorServiceClient {
             None
         };
 
+        let block_production_slot = match block_production_slot {
+            Some(slot) => Some(Slot::new(slot)),
+            None => None,
+        };
+
         Ok(Some(EpochDuties {
             validator_index,
             block_production_slot,

validator_client/src/duties/mod.rs

@@ -12,20 +12,20 @@ use self::traits::{BeaconNode, BeaconNodeError};
 use bls::PublicKey;
 use slot_clock::SlotClock;
 use std::sync::Arc;
-use types::ChainSpec;
+use types::{ChainSpec, Epoch, Slot};
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum PollOutcome {
     /// The `EpochDuties` were not updated during this poll.
-    NoChange(u64),
+    NoChange(Epoch),
     /// The `EpochDuties` for the `epoch` were previously unknown, but obtained in the poll.
-    NewDuties(u64, EpochDuties),
+    NewDuties(Epoch, EpochDuties),
     /// New `EpochDuties` were obtained, different to those which were previously known. This is
     /// likely to be the result of chain re-organisation.
-    DutiesChanged(u64, EpochDuties),
+    DutiesChanged(Epoch, EpochDuties),
     /// The Beacon Node was unable to return the duties as the validator is unknown, or the
     /// shuffling for the epoch is unknown.
-    UnknownValidatorOrEpoch(u64),
+    UnknownValidatorOrEpoch(Epoch),
 }
 
 #[derive(Debug, PartialEq)]
@@ -62,9 +62,7 @@ impl<T: SlotClock, U: BeaconNode> DutiesManager<T, U> {
             .map_err(|_| Error::SlotClockError)?
             .ok_or(Error::SlotUnknowable)?;
 
-        let epoch = slot
-            .checked_div(self.spec.epoch_length)
-            .ok_or(Error::EpochLengthIsZero)?;
+        let epoch = slot.epoch(self.spec.epoch_length);
 
         if let Some(duties) = self.beacon_node.request_shuffling(epoch, &self.pubkey)? {
             // If these duties were known, check to see if they're updates or identical.
@@ -130,25 +128,34 @@ mod tests {
         // Configure response from the BeaconNode.
         let duties = EpochDuties {
             validator_index: 0,
-            block_production_slot: Some(10),
+            block_production_slot: Some(Slot::new(10)),
         };
         beacon_node.set_next_shuffling_result(Ok(Some(duties)));
 
         // Get the duties for the first time...
-        assert_eq!(manager.poll(), Ok(PollOutcome::NewDuties(0, duties)));
+        assert_eq!(
+            manager.poll(),
+            Ok(PollOutcome::NewDuties(Epoch::new(0), duties))
+        );
         // Get the same duties again...
-        assert_eq!(manager.poll(), Ok(PollOutcome::NoChange(0)));
+        assert_eq!(manager.poll(), Ok(PollOutcome::NoChange(Epoch::new(0))));
 
         // Return new duties.
         let duties = EpochDuties {
             validator_index: 0,
-            block_production_slot: Some(11),
+            block_production_slot: Some(Slot::new(11)),
         };
         beacon_node.set_next_shuffling_result(Ok(Some(duties)));
-        assert_eq!(manager.poll(), Ok(PollOutcome::DutiesChanged(0, duties)));
+        assert_eq!(
+            manager.poll(),
+            Ok(PollOutcome::DutiesChanged(Epoch::new(0), duties))
+        );
 
         // Return no duties.
         beacon_node.set_next_shuffling_result(Ok(None));
-        assert_eq!(manager.poll(), Ok(PollOutcome::UnknownValidatorOrEpoch(0)));
+        assert_eq!(
+            manager.poll(),
+            Ok(PollOutcome::UnknownValidatorOrEpoch(Epoch::new(0)))
+        );
     }
 }

validator_client/src/duties/test_node.rs

@@ -2,13 +2,14 @@ use super::traits::{BeaconNode, BeaconNodeError};
 use super::EpochDuties;
 use bls::PublicKey;
 use std::sync::RwLock;
+use types::Epoch;
 
 type ShufflingResult = Result<Option<EpochDuties>, BeaconNodeError>;
 
 /// A test-only struct used to simulate a Beacon Node.
 #[derive(Default)]
 pub struct TestBeaconNode {
-    pub request_shuffling_input: RwLock<Option<(u64, PublicKey)>>,
+    pub request_shuffling_input: RwLock<Option<(Epoch, PublicKey)>>,
     pub request_shuffling_result: RwLock<Option<ShufflingResult>>,
 }
 
@@ -21,7 +22,7 @@ impl TestBeaconNode {
 
 impl BeaconNode for TestBeaconNode {
     /// Returns the value specified by the `set_next_shuffling_result`.
-    fn request_shuffling(&self, epoch: u64, public_key: &PublicKey) -> ShufflingResult {
+    fn request_shuffling(&self, epoch: Epoch, public_key: &PublicKey) -> ShufflingResult {
         *self.request_shuffling_input.write().unwrap() = Some((epoch, public_key.clone()));
         match *self.request_shuffling_result.read().unwrap() {
             Some(ref r) => r.clone(),

validator_client/src/duties/traits.rs

@@ -1,5 +1,6 @@
 use super::EpochDuties;
 use bls::PublicKey;
+use types::Epoch;
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum BeaconNodeError {
@@ -13,7 +14,7 @@ pub trait BeaconNode: Send + Sync {
     /// Returns Ok(None) if the public key is unknown, or the shuffling for that epoch is unknown.
     fn request_shuffling(
         &self,
-        epoch: u64,
+        epoch: Epoch,
         public_key: &PublicKey,
     ) -> Result<Option<EpochDuties>, BeaconNodeError>;
 }