Remove SlotClock error from block production, tidy.

beacon_node/beacon_chain/src/block_production.rs

@@ -1,20 +1,16 @@
 use super::{BeaconChain, ClientDB, DBError, SlotClock};
 use bls::Signature;
 use log::debug;
-use slot_clock::{SystemTimeSlotClockError, TestingSlotClockError};
 use types::{
     beacon_state::{BlockProcessingError, SlotProcessingError},
-    readers::{BeaconBlockReader, BeaconStateReader},
     BeaconBlock, BeaconBlockBody, BeaconState, Eth1Data, Hash256,
 };
 
 #[derive(Debug, PartialEq)]
 pub enum Error {
     DBError(String),
-    PresentSlotIsNone,
     SlotProcessingError(SlotProcessingError),
     PerBlockProcessingError(BlockProcessingError),
-    SlotClockError(SystemTimeSlotClockError),
 }
 
 impl<T, U> BeaconChain<T, U>
@@ -22,13 +18,14 @@ where
     T: ClientDB,
     U: SlotClock,
 {
+    /// Produce a new block at the present slot.
+    ///
+    /// The produced block will not be inheriently valid, it must be signed by a block producer.
+    /// Block signing is out of the scope of this function and should be done by a separate program.
     pub fn produce_block(
         &self,
         randao_reveal: Signature,
-    ) -> Result<(BeaconBlock, BeaconState), Error>
-    where
-        Error: From<<U>::Error>,
-    {
+    ) -> Result<(BeaconBlock, BeaconState), Error> {
         debug!("Starting block production...");
 
         let mut state = self.state.read().clone();
@@ -103,15 +100,3 @@ impl From<BlockProcessingError> for Error {
         Error::PerBlockProcessingError(e)
     }
 }
-
-impl From<TestingSlotClockError> for Error {
-    fn from(_: TestingSlotClockError) -> Error {
-        unreachable!(); // Testing clock never throws an error.
-    }
-}
-
-impl From<SystemTimeSlotClockError> for Error {
-    fn from(e: SystemTimeSlotClockError) -> Error {
-        Error::SlotClockError(e)
-    }
-}

beacon_node/beacon_chain/test_harness/src/validator/beacon_node/attester.rs

@@ -1,14 +1,10 @@
 use super::BenchingBeaconNode;
 use attester::{BeaconNode as AttesterBeaconNode, BeaconNodeError as NodeError, PublishOutcome};
-use beacon_chain::block_production::Error as BlockProductionError;
 use db::ClientDB;
 use slot_clock::SlotClock;
 use types::{AttestationData, FreeAttestation};
 
-impl<T: ClientDB, U: SlotClock> AttesterBeaconNode for BenchingBeaconNode<T, U>
-where
-    BlockProductionError: From<<U>::Error>,
-{
+impl<T: ClientDB, U: SlotClock> AttesterBeaconNode for BenchingBeaconNode<T, U> {
     fn produce_attestation_data(
         &self,
         _slot: u64,

beacon_node/beacon_chain/test_harness/src/validator/beacon_node/producer.rs

@@ -1,5 +1,4 @@
 use super::BenchingBeaconNode;
-use beacon_chain::block_production::Error as BlockProductionError;
 use block_producer::{
     BeaconNode as BeaconBlockNode, BeaconNodeError as BeaconBlockNodeError, PublishOutcome,
 };
@@ -7,10 +6,7 @@ use db::ClientDB;
 use slot_clock::SlotClock;
 use types::{BeaconBlock, PublicKey, Signature};
 
-impl<T: ClientDB, U: SlotClock> BeaconBlockNode for BenchingBeaconNode<T, U>
-where
-    BlockProductionError: From<<U>::Error>,
-{
+impl<T: ClientDB, U: SlotClock> BeaconBlockNode for BenchingBeaconNode<T, U> {
     /// Requests the `proposer_nonce` from the `BeaconChain`.
     fn proposer_nonce(&self, pubkey: &PublicKey) -> Result<u64, BeaconBlockNodeError> {
         let validator_index = self

beacon_node/beacon_chain/test_harness/src/validator/direct_duties.rs

@@ -1,7 +1,7 @@
 use attester::{
     DutiesReader as AttesterDutiesReader, DutiesReaderError as AttesterDutiesReaderError,
 };
-use beacon_chain::{block_production::Error as BlockProductionError, BeaconChain};
+use beacon_chain::BeaconChain;
 use block_producer::{
     DutiesReader as ProducerDutiesReader, DutiesReaderError as ProducerDutiesReaderError,
 };
@@ -24,10 +24,7 @@ impl<T: ClientDB, U: SlotClock> DirectDuties<T, U> {
     }
 }
 
-impl<T: ClientDB, U: SlotClock> ProducerDutiesReader for DirectDuties<T, U>
-where
-    BlockProductionError: From<<U>::Error>,
-{
+impl<T: ClientDB, U: SlotClock> ProducerDutiesReader for DirectDuties<T, U> {
     fn is_block_production_slot(&self, slot: u64) -> Result<bool, ProducerDutiesReaderError> {
         let validator_index = self
             .beacon_chain
@@ -42,10 +39,7 @@ where
     }
 }
 
-impl<T: ClientDB, U: SlotClock> AttesterDutiesReader for DirectDuties<T, U>
-where
-    BlockProductionError: From<<U>::Error>,
-{
+impl<T: ClientDB, U: SlotClock> AttesterDutiesReader for DirectDuties<T, U> {
     fn validator_index(&self) -> Option<u64> {
         match self.beacon_chain.validator_index(&self.pubkey) {
             Some(index) => Some(index as u64),