Revert "Merge pull request #200 from sigp/new-structure"

This reverts commit d7a3545be1, reversing
changes made to 1da06c156c.

validator_client/src/block_producer_service/beacon_block_grpc_client.rs

@@ -0,0 +1,102 @@
+use block_producer::{BeaconNode, BeaconNodeError, PublishOutcome};
+use protos::services::{
+    BeaconBlock as GrpcBeaconBlock, ProduceBeaconBlockRequest, PublishBeaconBlockRequest,
+};
+use protos::services_grpc::BeaconBlockServiceClient;
+use ssz::{ssz_encode, Decodable};
+use std::sync::Arc;
+use types::{BeaconBlock, BeaconBlockBody, Eth1Data, Hash256, Signature, Slot};
+
+/// A newtype designed to wrap the gRPC-generated service so the `BeaconNode` trait may be
+/// implemented upon it.
+pub struct BeaconBlockGrpcClient {
+    client: Arc<BeaconBlockServiceClient>,
+}
+
+impl BeaconBlockGrpcClient {
+    pub fn new(client: Arc<BeaconBlockServiceClient>) -> Self {
+        Self { client }
+    }
+}
+
+impl BeaconNode for BeaconBlockGrpcClient {
+    /// Request a Beacon Node (BN) to produce a new block at the supplied slot.
+    ///
+    /// Returns `None` if it is not possible to produce at the supplied slot. For example, if the
+    /// BN is unable to find a parent block.
+    fn produce_beacon_block(
+        &self,
+        slot: Slot,
+        // TODO: use randao_reveal, when proto APIs have been updated.
+        _randao_reveal: &Signature,
+    ) -> Result<Option<BeaconBlock>, BeaconNodeError> {
+        let mut req = ProduceBeaconBlockRequest::new();
+        req.set_slot(slot.as_u64());
+
+        let reply = self
+            .client
+            .produce_beacon_block(&req)
+            .map_err(|err| BeaconNodeError::RemoteFailure(format!("{:?}", err)))?;
+
+        if reply.has_block() {
+            let block = reply.get_block();
+
+            let (signature, _) = Signature::ssz_decode(block.get_signature(), 0)
+                .map_err(|_| BeaconNodeError::DecodeFailure)?;
+
+            let (randao_reveal, _) = Signature::ssz_decode(block.get_randao_reveal(), 0)
+                .map_err(|_| BeaconNodeError::DecodeFailure)?;
+
+            // TODO: this conversion is incomplete; fix it.
+            Ok(Some(BeaconBlock {
+                slot: Slot::new(block.get_slot()),
+                parent_root: Hash256::zero(),
+                state_root: Hash256::zero(),
+                randao_reveal,
+                eth1_data: Eth1Data {
+                    deposit_root: Hash256::zero(),
+                    block_hash: Hash256::zero(),
+                },
+                signature,
+                body: BeaconBlockBody {
+                    proposer_slashings: vec![],
+                    attester_slashings: vec![],
+                    attestations: vec![],
+                    deposits: vec![],
+                    exits: vec![],
+                },
+            }))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Request a Beacon Node (BN) to publish a block.
+    ///
+    /// Generally, this will be called after a `produce_beacon_block` call with a block that has
+    /// been completed (signed) by the validator client.
+    fn publish_beacon_block(&self, block: BeaconBlock) -> Result<PublishOutcome, BeaconNodeError> {
+        let mut req = PublishBeaconBlockRequest::new();
+
+        // TODO: this conversion is incomplete; fix it.
+        let mut grpc_block = GrpcBeaconBlock::new();
+        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));
+
+        req.set_block(grpc_block);
+
+        let reply = self
+            .client
+            .publish_beacon_block(&req)
+            .map_err(|err| BeaconNodeError::RemoteFailure(format!("{:?}", err)))?;
+
+        if reply.get_success() {
+            Ok(PublishOutcome::ValidBlock)
+        } else {
+            // TODO: distinguish between different errors
+            Ok(PublishOutcome::InvalidBlock("Publish failed".to_string()))
+        }
+    }
+}

validator_client/src/block_producer_service/mod.rs

@@ -0,0 +1,58 @@
+mod beacon_block_grpc_client;
+// mod block_producer_service;
+
+use block_producer::{
+    BeaconNode, BlockProducer, DutiesReader, PollOutcome as BlockProducerPollOutcome, Signer,
+};
+use slog::{error, info, warn, Logger};
+use slot_clock::SlotClock;
+use std::time::Duration;
+
+pub use self::beacon_block_grpc_client::BeaconBlockGrpcClient;
+
+pub struct BlockProducerService<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> {
+    pub block_producer: BlockProducer<T, U, V, W>,
+    pub poll_interval_millis: u64,
+    pub log: Logger,
+}
+
+impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> BlockProducerService<T, U, V, W> {
+    /// Run a loop which polls the block producer each `poll_interval_millis` millseconds.
+    ///
+    /// Logs the results of the polls.
+    pub fn run(&mut self) {
+        loop {
+            match self.block_producer.poll() {
+                Err(error) => {
+                    error!(self.log, "Block producer poll error"; "error" => format!("{:?}", error))
+                }
+                Ok(BlockProducerPollOutcome::BlockProduced(slot)) => {
+                    info!(self.log, "Produced block"; "slot" => slot)
+                }
+                Ok(BlockProducerPollOutcome::SlashableBlockNotProduced(slot)) => {
+                    warn!(self.log, "Slashable block was not signed"; "slot" => slot)
+                }
+                Ok(BlockProducerPollOutcome::BlockProductionNotRequired(slot)) => {
+                    info!(self.log, "Block production not required"; "slot" => slot)
+                }
+                Ok(BlockProducerPollOutcome::ProducerDutiesUnknown(slot)) => {
+                    error!(self.log, "Block production duties unknown"; "slot" => slot)
+                }
+                Ok(BlockProducerPollOutcome::SlotAlreadyProcessed(slot)) => {
+                    warn!(self.log, "Attempted to re-process slot"; "slot" => slot)
+                }
+                Ok(BlockProducerPollOutcome::BeaconNodeUnableToProduceBlock(slot)) => {
+                    error!(self.log, "Beacon node unable to produce block"; "slot" => slot)
+                }
+                Ok(BlockProducerPollOutcome::SignerRejection(slot)) => {
+                    error!(self.log, "The cryptographic signer refused to sign the block"; "slot" => slot)
+                }
+                Ok(BlockProducerPollOutcome::ValidatorIsUnknown(slot)) => {
+                    error!(self.log, "The Beacon Node does not recognise the validator"; "slot" => slot)
+                }
+            };
+
+            std::thread::sleep(Duration::from_millis(self.poll_interval_millis));
+        }
+    }
+}