Fix all compile errors from new Slot/Epoch types

eth2/block_producer/src/lib.rs

@@ -4,7 +4,7 @@ mod traits;
 use slot_clock::SlotClock;
 use ssz::ssz_encode;
 use std::sync::Arc;
-use types::{BeaconBlock, ChainSpec, PublicKey};
+use types::{BeaconBlock, ChainSpec, PublicKey, Slot};
 
 pub use self::traits::{
     BeaconNode, BeaconNodeError, DutiesReader, DutiesReaderError, PublishOutcome, Signer,
@@ -13,21 +13,21 @@ pub use self::traits::{
 #[derive(Debug, PartialEq)]
 pub enum PollOutcome {
     /// A new block was produced.
-    BlockProduced(u64),
+    BlockProduced(Slot),
     /// A block was not produced as it would have been slashable.
-    SlashableBlockNotProduced(u64),
+    SlashableBlockNotProduced(Slot),
     /// The validator duties did not require a block to be produced.
-    BlockProductionNotRequired(u64),
+    BlockProductionNotRequired(Slot),
     /// The duties for the present epoch were not found.
-    ProducerDutiesUnknown(u64),
+    ProducerDutiesUnknown(Slot),
     /// The slot has already been processed, execution was skipped.
-    SlotAlreadyProcessed(u64),
+    SlotAlreadyProcessed(Slot),
     /// The Beacon Node was unable to produce a block at that slot.
-    BeaconNodeUnableToProduceBlock(u64),
+    BeaconNodeUnableToProduceBlock(Slot),
     /// The signer failed to sign the message.
-    SignerRejection(u64),
+    SignerRejection(Slot),
     /// The public key for this validator is not an active validator.
-    ValidatorIsUnknown(u64),
+    ValidatorIsUnknown(Slot),
 }
 
 #[derive(Debug, PartialEq)]
@@ -47,7 +47,7 @@ pub enum Error {
 ///
 /// Relies upon an external service to keep the `EpochDutiesMap` updated.
 pub struct BlockProducer<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> {
-    pub last_processed_slot: Option<u64>,
+    pub last_processed_slot: Option<Slot>,
     pubkey: PublicKey,
     spec: Arc<ChainSpec>,
     epoch_map: Arc<V>,
@@ -115,7 +115,7 @@ impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> BlockProducer<T, U
         }
     }
 
-    fn is_processed_slot(&self, slot: u64) -> bool {
+    fn is_processed_slot(&self, slot: Slot) -> bool {
         match self.last_processed_slot {
             Some(processed_slot) if processed_slot >= slot => true,
             _ => false,
@@ -132,7 +132,7 @@ impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> BlockProducer<T, U
     ///
     /// The slash-protection code is not yet implemented. There is zero protection against
     /// slashing.
-    fn produce_block(&mut self, slot: u64) -> Result<PollOutcome, Error> {
+    fn produce_block(&mut self, slot: Slot) -> Result<PollOutcome, Error> {
         let randao_reveal = {
             let producer_nonce = self.beacon_node.proposer_nonce(&self.pubkey)?;
 
@@ -236,8 +236,8 @@ mod tests {
         let signer = Arc::new(LocalSigner::new(Keypair::random()));
 
         let mut epoch_map = EpochMap::new(spec.epoch_length);
-        let produce_slot = 100;
-        let produce_epoch = produce_slot / spec.epoch_length;
+        let produce_slot = Slot::new(100);
+        let produce_epoch = produce_slot.epoch(spec.epoch_length);
         epoch_map.map.insert(produce_epoch, produce_slot);
         let epoch_map = Arc::new(epoch_map);
         let keypair = Keypair::random();
@@ -257,39 +257,39 @@ mod tests {
         beacon_node.set_next_nonce_result(Ok(0));
 
         // One slot before production slot...
-        slot_clock.set_slot(produce_slot - 1);
+        slot_clock.set_slot(produce_slot.as_u64() - 1);
         assert_eq!(
             block_producer.poll(),
             Ok(PollOutcome::BlockProductionNotRequired(produce_slot - 1))
         );
 
         // On the produce slot...
-        slot_clock.set_slot(produce_slot);
+        slot_clock.set_slot(produce_slot.as_u64());
         assert_eq!(
             block_producer.poll(),
-            Ok(PollOutcome::BlockProduced(produce_slot))
+            Ok(PollOutcome::BlockProduced(produce_slot.into()))
         );
 
         // Trying the same produce slot again...
-        slot_clock.set_slot(produce_slot);
+        slot_clock.set_slot(produce_slot.as_u64());
         assert_eq!(
             block_producer.poll(),
             Ok(PollOutcome::SlotAlreadyProcessed(produce_slot))
         );
 
         // One slot after the produce slot...
-        slot_clock.set_slot(produce_slot + 1);
+        slot_clock.set_slot(produce_slot.as_u64() + 1);
         assert_eq!(
             block_producer.poll(),
             Ok(PollOutcome::BlockProductionNotRequired(produce_slot + 1))
         );
 
         // In an epoch without known duties...
-        let slot = (produce_epoch + 1) * spec.epoch_length;
+        let slot = (produce_epoch.as_u64() + 1) * spec.epoch_length;
         slot_clock.set_slot(slot);
         assert_eq!(
             block_producer.poll(),
-            Ok(PollOutcome::ProducerDutiesUnknown(slot))
+            Ok(PollOutcome::ProducerDutiesUnknown(Slot::new(slot)))
         );
     }
 }

eth2/block_producer/src/test_utils/epoch_map.rs

@@ -1,9 +1,10 @@
 use crate::{DutiesReader, DutiesReaderError};
 use std::collections::HashMap;
+use types::{Epoch, Slot};
 
 pub struct EpochMap {
     epoch_length: u64,
-    pub map: HashMap<u64, u64>,
+    pub map: HashMap<Epoch, Slot>,
 }
 
 impl EpochMap {
@@ -16,8 +17,8 @@ impl EpochMap {
 }
 
 impl DutiesReader for EpochMap {
-    fn is_block_production_slot(&self, slot: u64) -> Result<bool, DutiesReaderError> {
-        let epoch = slot / self.epoch_length;
+    fn is_block_production_slot(&self, slot: Slot) -> Result<bool, DutiesReaderError> {
+        let epoch = slot.epoch(self.epoch_length);
         match self.map.get(&epoch) {
             Some(s) if *s == slot => Ok(true),
             Some(s) if *s != slot => Ok(false),

eth2/block_producer/src/test_utils/simulated_beacon_node.rs

@@ -1,6 +1,6 @@
 use crate::traits::{BeaconNode, BeaconNodeError, PublishOutcome};
 use std::sync::RwLock;
-use types::{BeaconBlock, PublicKey, Signature};
+use types::{BeaconBlock, PublicKey, Signature, Slot};
 
 type NonceResult = Result<u64, BeaconNodeError>;
 type ProduceResult = Result<Option<BeaconBlock>, BeaconNodeError>;
@@ -12,7 +12,7 @@ pub struct SimulatedBeaconNode {
     pub nonce_input: RwLock<Option<PublicKey>>,
     pub nonce_result: RwLock<Option<NonceResult>>,
 
-    pub produce_input: RwLock<Option<(u64, Signature)>>,
+    pub produce_input: RwLock<Option<(Slot, Signature)>>,
     pub produce_result: RwLock<Option<ProduceResult>>,
 
     pub publish_input: RwLock<Option<BeaconBlock>>,
@@ -46,7 +46,7 @@ impl BeaconNode for SimulatedBeaconNode {
     }
 
     /// Returns the value specified by the `set_next_produce_result`.
-    fn produce_beacon_block(&self, slot: u64, randao_reveal: &Signature) -> ProduceResult {
+    fn produce_beacon_block(&self, slot: Slot, randao_reveal: &Signature) -> ProduceResult {
         *self.produce_input.write().unwrap() = Some((slot, randao_reveal.clone()));
         match *self.produce_result.read().unwrap() {
             Some(ref r) => r.clone(),

eth2/block_producer/src/traits.rs

@@ -1,4 +1,4 @@
-use types::{BeaconBlock, PublicKey, Signature};
+use types::{BeaconBlock, PublicKey, Signature, Slot};
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum BeaconNodeError {
@@ -22,7 +22,7 @@ pub trait BeaconNode: Send + Sync {
     /// Returns Ok(None) if the Beacon Node is unable to produce at the given slot.
     fn produce_beacon_block(
         &self,
-        slot: u64,
+        slot: Slot,
         randao_reveal: &Signature,
     ) -> Result<Option<BeaconBlock>, BeaconNodeError>;
 
@@ -42,7 +42,7 @@ pub enum DutiesReaderError {
 
 /// Informs a validator of their duties (e.g., block production).
 pub trait DutiesReader: Send + Sync {
-    fn is_block_production_slot(&self, slot: u64) -> Result<bool, DutiesReaderError>;
+    fn is_block_production_slot(&self, slot: Slot) -> Result<bool, DutiesReaderError>;
 }
 
 /// Signs message using an internally-maintained private key.