Merge branch 'validator_client' of github.com:sigp/lighthouse into validator_client

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -280,8 +280,8 @@ where
     }
 
     /// Produce an `AttestationData` that is valid for the present `slot` and given `shard`.
-    pub fn produce_attestation_data(&self, shard: u64) -> Result<AttestationData, Error> {
+    pub fn produce_attestation(&self, shard: u64) -> Result<AttestationData, Error> {
-        trace!("BeaconChain::produce_attestation_data: shard: {}", shard);
+        trace!("BeaconChain::produce_attestation: shard: {}", shard);
         let source_epoch = self.state.read().current_justified_epoch;
         let source_root = *self.state.read().get_block_root(
             source_epoch.start_slot(self.spec.slots_per_epoch),

beacon_node/beacon_chain/test_harness/src/validator_harness/direct_beacon_node.rs

@@ -50,18 +50,18 @@ impl<T: ClientDB, U: SlotClock, F: ForkChoice> DirectBeaconNode<T, U, F> {
 }
 
 impl<T: ClientDB, U: SlotClock, F: ForkChoice> AttesterBeaconNode for DirectBeaconNode<T, U, F> {
-    fn produce_attestation_data(
+    fn produce_attestation(
         &self,
         _slot: Slot,
         shard: u64,
     ) -> Result<Option<AttestationData>, NodeError> {
-        match self.beacon_chain.produce_attestation_data(shard) {
+        match self.beacon_chain.produce_attestation(shard) {
             Ok(attestation_data) => Ok(Some(attestation_data)),
             Err(e) => Err(NodeError::RemoteFailure(format!("{:?}", e))),
         }
     }
 
-    fn publish_attestation_data(
+    fn publish_attestation(
         &self,
         free_attestation: FreeAttestation,
     ) -> Result<AttestationPublishOutcome, NodeError> {

beacon_node/rpc/src/beacon_attester.rs

@@ -0,0 +1,61 @@
+use futures::Future;
+use grpcio::{RpcContext, UnarySink};
+use protos::services::{
+    Attestation as AttestationProto, ProduceAttestation, ProduceAttestationResponse,
+    ProduceAttestationRequest, PublishAttestationResponse, PublishAttestationRequest,
+    PublishAttestation
+};
+use protos::services_grpc::BeaconBlockService;
+use slog::Logger;
+
+#[derive(Clone)]
+pub struct AttestationServiceInstance {
+    pub log: Logger,
+}
+
+impl AttestationService for AttestationServiceInstance {
+    /// Produce a `BeaconBlock` for signing by a validator.
+    fn produce_attestation(
+        &mut self,
+        ctx: RpcContext,
+        req: ProduceAttestationRequest,
+        sink: UnarySink<ProduceAttestationResponse>,
+    ) {
+        println!("producing attestation at slot {}", req.get_slot());
+
+        // TODO: build a legit block.
+        let mut attestation = AttestationProto::new();
+        attestation.set_slot(req.get_slot());
+        // TODO Set the shard to something legit.
+        attestation.set_shard(0);
+        attestation.set_block_root(b"cats".to_vec());
+
+        let mut resp = ProduceAttestationResponse::new();
+        resp.set_attestation_data(attestation);
+
+        let f = sink
+            .success(resp)
+            .map_err(move |e| println!("failed to reply {:?}: {:?}", req, e));
+        ctx.spawn(f)
+    }
+
+    /// Accept some fully-formed `BeaconBlock`, process and publish it.
+    fn publish_attestation(
+        &mut self,
+        ctx: RpcContext,
+        req: PublishAttestationRequest,
+        sink: UnarySink<PublishAttestationResponse>,
+    ) {
+        println!("publishing attestation {:?}", req.get_block());
+
+        // TODO: actually process the block.
+        let mut resp = PublishAttestationResponse::new();
+
+        resp.set_success(true);
+
+        let f = sink
+            .success(resp)
+            .map_err(move |e| println!("failed to reply {:?}: {:?}", req, e));
+        ctx.spawn(f)
+    }
+}

eth2/attester/src/lib.rs

@@ -94,7 +94,7 @@ impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> Attester<T, U, V,
     }
 
     fn produce_attestation(&mut self, slot: Slot, shard: u64) -> Result<PollOutcome, Error> {
-        let attestation_data = match self.beacon_node.produce_attestation_data(slot, shard)? {
+        let attestation_data = match self.beacon_node.produce_attestation(slot, shard)? {
             Some(attestation_data) => attestation_data,
             None => return Ok(PollOutcome::BeaconNodeUnableToProduceAttestation(slot)),
         };
@@ -120,7 +120,7 @@ impl<T: SlotClock, U: BeaconNode, V: DutiesReader, W: Signer> Attester<T, U, V,
         };
 
         self.beacon_node
-            .publish_attestation_data(free_attestation)?;
+            .publish_attestation(free_attestation)?;
         Ok(PollOutcome::AttestationProduced(slot))
     }
 

eth2/attester/src/test_utils/simulated_beacon_node.rs

@@ -26,7 +26,7 @@ impl SimulatedBeaconNode {
 }
 
 impl BeaconNode for SimulatedBeaconNode {
-    fn produce_attestation_data(&self, slot: Slot, shard: u64) -> ProduceResult {
+    fn produce_attestation(&self, slot: Slot, shard: u64) -> ProduceResult {
         *self.produce_input.write().unwrap() = Some((slot, shard));
         match *self.produce_result.read().unwrap() {
             Some(ref r) => r.clone(),
@@ -34,7 +34,7 @@ impl BeaconNode for SimulatedBeaconNode {
         }
     }
 
-    fn publish_attestation_data(&self, free_attestation: FreeAttestation) -> PublishResult {
+    fn publish_attestation(&self, free_attestation: FreeAttestation) -> PublishResult {
         *self.publish_input.write().unwrap() = Some(free_attestation.clone());
         match *self.publish_result.read().unwrap() {
             Some(ref r) => r.clone(),

eth2/attester/src/traits.rs

@@ -14,13 +14,13 @@ pub enum PublishOutcome {
 
 /// Defines the methods required to produce and publish blocks on a Beacon Node.
 pub trait BeaconNode: Send + Sync {
-    fn produce_attestation_data(
+    fn produce_attestation(
         &self,
         slot: Slot,
         shard: u64,
     ) -> Result<Option<AttestationData>, BeaconNodeError>;
 
-    fn publish_attestation_data(
+    fn publish_attestation(
         &self,
         free_attestation: FreeAttestation,
     ) -> Result<PublishOutcome, BeaconNodeError>;

protos/src/services.proto

@@ -33,8 +33,8 @@ service ValidatorService {
 
 /// Service that handles validator attestations
 service AttestationService {
-	rpc ProduceAttestationData (ProduceAttestationDataRequest) returns (ProduceAttestationDataResponse);
+	rpc ProduceAttestation(ProduceAttestationRequest) returns (ProduceAttestationResponse);
-	rpc PublishAttestationData (PublishAttestationDataRequest) returns (PublishAttestationDataResponse);
+	rpc PublishAttestation(PublishAttestationRequest) returns (PublishAttestationResponse);
 }
 
 /*
@@ -138,20 +138,20 @@ message ProposeBlockSlotResponse {
  * Attestation Service Messages
  */
 
-message ProduceAttestationDataRequest {
+message ProduceAttestationRequest {
 	uint64 slot = 1;
 	uint64 shard = 2;
 }
 
-message ProduceAttestationDataResponse {
+message ProduceAttestationResponse {
-	AttestationData attestation_data = 1;
+	Attestation attestation_data = 1;
 }
 
-message PublishAttestationDataRequest {
+message PublishAttestationRequest {
 	FreeAttestation free_attestation = 1;
 }
 
-message PublishAttestationDataResponse {
+message PublishAttestationResponse {
 	bool success = 1;
 	bytes msg = 2;
 }
@@ -162,7 +162,7 @@ message Crosslink {
 
 }
 
-message AttestationData {
+message Attestation {
 	uint64 slot = 1;
 	uint64 shard = 2;
 	bytes beacon_block_root = 3;
@@ -175,7 +175,7 @@ message AttestationData {
 }
 
 message FreeAttestation {
-	AttestationData attestation_data = 1;
+	Attestation attestation_data = 1;
 	bytes signature = 2;
 	uint64 validator_index = 3;
 }

validator_client/src/attester_service/attestation_grpc_client.rs

@@ -2,7 +2,7 @@ use protos::services_grpc::AttestationServiceClient;
 use std::sync::Arc;
 
 use attester::{BeaconNode, BeaconNodeError, PublishOutcome};
-use protos::services::ProduceAttestationDataRequest;
+use protos::services::ProduceAttestationRequest;
 use types::{AttestationData, FreeAttestation, Slot};
 
 pub struct AttestationGrpcClient {
@@ -16,25 +16,25 @@ impl AttestationGrpcClient {
 }
 
 impl BeaconNode for AttestationGrpcClient {
-    fn produce_attestation_data(
+    fn produce_attestation(
         &self,
         slot: Slot,
         shard: u64,
     ) -> Result<Option<AttestationData>, BeaconNodeError> {
-        let mut req = ProduceAttestationDataRequest::new();
+        let mut req = ProduceAttestationRequest::new();
         req.set_slot(slot.as_u64());
         req.set_shard(shard);
 
         let reply = self
             .client
-            .produce_attestation_data(&req)
+            .produce_attestation(&req)
             .map_err(|err| BeaconNodeError::RemoteFailure(format!("{:?}", err)))?;
 
-        // TODO: return correct AttestationData
+        // TODO: return correct Attestation
         Err(BeaconNodeError::DecodeFailure)
     }
 
-    fn publish_attestation_data(
+    fn publish_attestation(
         &self,
         free_attestation: FreeAttestation,
     ) -> Result<PublishOutcome, BeaconNodeError> {