Registers the attester service to the beacon node RPC client

beacon_node/rpc/src/attestation.rs

@@ -0,0 +1,143 @@
+use crate::beacon_chain::BeaconChain;
+use futures::Future;
+use grpcio::{RpcContext, RpcStatus, RpcStatusCode, UnarySink};
+use protos::services::{
+    AttestationData as AttestationDataProto, ProduceAttestationDataRequest,
+    ProduceAttestationDataResponse, PublishAttestationRequest, PublishAttestationResponse,
+};
+use protos::services_grpc::AttestationService;
+use slog::{error, info, trace, warn, Logger};
+use ssz::{ssz_encode, Decodable};
+use std::sync::Arc;
+use types::Attestation;
+
+#[derive(Clone)]
+pub struct AttestationServiceInstance {
+    pub chain: Arc<BeaconChain>,
+    pub log: slog::Logger,
+}
+
+impl AttestationService for AttestationServiceInstance {
+    /// Produce the `AttestationData` for signing by a validator.
+    fn produce_attestation_data(
+        &mut self,
+        ctx: RpcContext,
+        req: ProduceAttestationDataRequest,
+        sink: UnarySink<ProduceAttestationDataResponse>,
+    ) {
+        warn!(
+            &self.log,
+            "Attempting to produce attestation at slot {}",
+            req.get_slot()
+        );
+
+        // verify the slot, drop lock on state afterwards
+        {
+            let slot_requested = req.get_slot();
+            let state = self.chain.get_state();
+
+            // Start by performing some checks
+            // Check that the the AttestionData is for the current slot (otherwise it will not be valid)
+            if slot_requested != state.slot.as_u64() {
+                let log_clone = self.log.clone();
+                let f = sink
+                    .fail(RpcStatus::new(
+                        RpcStatusCode::OutOfRange,
+                        Some(format!(
+                            "AttestationData request for a slot that is not the current slot."
+                        )),
+                    ))
+                    .map_err(move |e| {
+                        error!(log_clone, "Failed to reply with failure {:?}: {:?}", req, e)
+                    });
+                return ctx.spawn(f);
+            }
+        }
+
+        // Then get the AttestationData from the beacon chain
+        let shard = req.get_shard();
+        let attestation_data = match self.chain.produce_attestation_data(shard) {
+            Ok(v) => v,
+            Err(e) => {
+                // Could not produce an attestation
+                let log_clone = self.log.clone();
+                let f = sink
+                    .fail(RpcStatus::new(
+                        RpcStatusCode::Unknown,
+                        Some(format!("Could not produce an attestation: {:?}", e)),
+                    ))
+                    .map_err(move |e| warn!(log_clone, "failed to reply {:?}: {:?}", req, e));
+                return ctx.spawn(f);
+            }
+        };
+
+        let mut attestation_data_proto = AttestationDataProto::new();
+        attestation_data_proto.set_ssz(ssz_encode(&attestation_data));
+
+        let mut resp = ProduceAttestationDataResponse::new();
+        resp.set_attestation_data(attestation_data_proto);
+
+        let error_log = self.log.clone();
+        let f = sink
+            .success(resp)
+            .map_err(move |e| error!(error_log, "Failed to reply with success {:?}: {:?}", req, e));
+        ctx.spawn(f)
+    }
+
+    /// Accept some fully-formed `FreeAttestation` from the validator,
+    /// store it, and aggregate it into an `Attestation`.
+    fn publish_attestation(
+        &mut self,
+        ctx: RpcContext,
+        req: PublishAttestationRequest,
+        sink: UnarySink<PublishAttestationResponse>,
+    ) {
+        warn!(self.log, "Publishing attestation");
+
+        let mut resp = PublishAttestationResponse::new();
+        let ssz_serialized_attestation = req.get_attestation().get_ssz();
+
+        let attestation = match Attestation::ssz_decode(ssz_serialized_attestation, 0) {
+            Ok((v, _index)) => v,
+            Err(_) => {
+                let log_clone = self.log.clone();
+                let f = sink
+                    .fail(RpcStatus::new(
+                        RpcStatusCode::InvalidArgument,
+                        Some("Invalid attestation".to_string()),
+                    ))
+                    .map_err(move |_| warn!(log_clone, "failed to reply {:?}", req));
+                return ctx.spawn(f);
+            }
+        };
+
+        match self.chain.process_attestation(attestation) {
+            Ok(_) => {
+                // Attestation was successfully processed.
+                info!(
+                    self.log,
+                    "PublishAttestation";
+                    "type" => "valid_attestation",
+                );
+
+                resp.set_success(true);
+            }
+            Err(e) => {
+                // Attestation was invalid
+                warn!(
+                    self.log,
+                    "PublishAttestation";
+                    "type" => "invalid_attestation",
+                );
+                resp.set_success(false);
+                resp.set_msg(format!("InvalidAttestation: {:?}", e).as_bytes().to_vec());
+            }
+        };
+
+        let error_log = self.log.clone();
+        let f = sink
+            .success(resp)
+            .map_err(move |e| error!(error_log, "failed to reply {:?}: {:?}", req, e));
+        ctx.spawn(f)
+    }
+}

beacon_node/rpc/src/beacon_attester.rs

@@ -1,131 +0,0 @@
-use crate::beacon_chain::BeaconChain;
-use futures::Future;
-use grpcio::{RpcContext, UnarySink, RpcStatus, RpcStatusCode};
-use protos::services::{
-    AttestationData as AttestationDataProto, ProduceAttestationData, ProduceAttestationDataResponse,
-    ProduceAttestationDataRequest, PublishAttestationResponse, PublishAttestationRequest,
-    PublishAttestation
-};
-use protos::services_grpc::BeaconBlockService;
-use slog::{Logger, info, warn, error, trace};
-
-#[derive(Clone)]
-pub struct AttestationServiceInstance {
-    pub chain: Arc<BeaconChain>,
-    pub log: Logger,
-}
-
-impl AttestationService for AttestationServiceInstance {
-    /// Produce the `AttestationData` for signing by a validator.
-    fn produce_attestation_data(
-        &mut self,
-        ctx: RpcContext,
-        req: ProduceAttestationDataRequest,
-        sink: UnarySink<ProduceAttestationDataResponse>,
-    ) {
-        trace!(&self.log, "Attempting to produce attestation at slot {}", req.get_slot());
-
-        // verify the slot, drop lock on state afterwards
-        {
-            let slot_requested = req.get_slot();
-            let state = self.chain.get_state();
-
-            // Start by performing some checks
-            // Check that the the AttestionData is for the current slot (otherwise it will not be valid)
-            if slot_requested != state.slot {
-                let f = sink
-                    .fail(RpcStatus::new(
-                        RpcStatusCode::OutOfRange,
-                        "AttestationData request for a slot that is not the current slot."
-                    ))
-                    .map_err(move |e| error!(&self.log, "Failed to reply with failure {:?}: {:?}", req, e));
-            }
-        }
-
-        // Then get the AttestationData from the beacon chain
-        let attestation_data = match self.chain.produce_attestation_data(req.get_shard()){
-            Ok(v) => v,
-            Err(e) => {
-                // Could not produce an attestation
-                let log_clone = self.log.clone();
-                let f = sink
-                    .fail(RpcStatus::new(
-                        RpcStatusCode::Unknown
-                        Some(format!("Could not produce an attestation: {:?}",e)),
-                    ))
-                    .map_err(move |e| warn!(log_clone, "failed to reply {:?}: {:?}", req, e));
-                return ctx.spawn(f);
-            }
-        };
-
-
-        let mut attestation_data_proto = AttestationDataProto::new();
-        attestation_data_proto.set_ssz(ssz_encode(&attestation_data));
-
-        let mut resp = ProduceAttestationDataResponse::new();
-        resp.set_attestation_data(attestation_data_proto);
-
-        let f = sink
-            .success(resp)
-            .map_err(move |e| error!("Failed to reply with success {:?}: {:?}", req, e));
-        ctx.spawn(f)
-    }
-
-    /// Accept some fully-formed `FreeAttestation` from the validator,
-    /// store it, and aggregate it into an `Attestation`.
-    fn publish_attestation(
-        &mut self,
-        ctx: RpcContext,
-        req: PublishAttestationRequest,
-        sink: UnarySink<PublishAttestationResponse>,
-    ) {
-        trace!(self.log, "Publishing attestation");
-
-        let mut resp = PublishAttestationResponse::new();
-        let ssz_serialized_attestation = req.get_attestation().get_ssz();
-
-        let attestation = match Attestation::ssz_decode(ssz_serialized_attestation, 0) {
-                Ok((v, _index)) => v,
-                Err(_) => {
-                    let log_clone = self.log.clone();
-                    let f = sink
-                        .fail(RpcStatus::new(
-                            RpcStatusCode::InvalidArgument,
-                            Some("Invalid attestation".to_string()),
-                        ))
-                        .map_err(move |e| warn!(log_clone, "failed to reply {:?}", req));
-                    return ctx.spawn(f);
-                }
-        };
-
-                match self.chain.process_attestation(attestation) {
-                    Ok(_) => {
-                            // Attestation was successfully processed.
-                            info!(
-                                self.log,
-                                "PublishAttestation";
-                                "type" => "valid_attestation",
-                            );
-
-                            resp.set_success(true);
-                            },
-                      Err(e)=> {
-                            // Attestation was invalid
-                            warn!(
-                                self.log,
-                                "PublishAttestation";
-                                "type" => "invalid_attestation",
-                            );
-                            resp.set_success(false);
-                            resp.set_msg(
-                                format!("InvalidAttestation: {:?}", e).as_bytes().to_vec(),
-                            );
-                            }
-                    };
-
-        let f = sink
-            .success(resp)
-            .map_err(move |e| println!("failed to reply {:?}: {:?}", req, e));
-        ctx.spawn(f)
-    }
-}

beacon_node/rpc/src/beacon_block.rs

@@ -36,8 +36,8 @@ impl BeaconBlockService for BeaconBlockServiceInstance {
         // decode the request
         // TODO: requested slot currently unused, see: https://github.com/sigp/lighthouse/issues/336
         let _requested_slot = Slot::from(req.get_slot());
-        let (randao_reveal, _index) = match Signature::ssz_decode(req.get_randao_reveal(), 0) {
-            Ok(v) => v,
+        let randao_reveal = match Signature::ssz_decode(req.get_randao_reveal(), 0) {
+            Ok((reveal, _index)) => reveal,
             Err(_) => {
                 // decode error, incorrect signature
                 let log_clone = self.log.clone();
@@ -86,6 +86,8 @@ impl BeaconBlockService for BeaconBlockServiceInstance {
         req: PublishBeaconBlockRequest,
         sink: UnarySink<PublishBeaconBlockResponse>,
     ) {
+        trace!(&self.log, "Attempting to publish a block");
+
         let mut resp = PublishBeaconBlockResponse::new();
 
         let ssz_serialized_block = req.get_block().get_ssz();

beacon_node/rpc/src/beacon_chain.rs

@@ -5,10 +5,10 @@ use beacon_chain::{
     parking_lot::RwLockReadGuard,
     slot_clock::SlotClock,
     types::{BeaconState, ChainSpec, Signature},
-    BlockProductionError,
+    AttestationValidationError, BlockProductionError,
 };
 pub use beacon_chain::{BeaconChainError, BlockProcessingOutcome};
-use types::BeaconBlock;
+use types::{Attestation, AttestationData, BeaconBlock};
 
 /// The RPC's API to the beacon chain.
 pub trait BeaconChain: Send + Sync {
@@ -23,6 +23,13 @@ pub trait BeaconChain: Send + Sync {
         &self,
         randao_reveal: Signature,
     ) -> Result<(BeaconBlock, BeaconState), BlockProductionError>;
+
+    fn produce_attestation_data(&self, shard: u64) -> Result<AttestationData, BeaconChainError>;
+
+    fn process_attestation(
+        &self,
+        attestation: Attestation,
+    ) -> Result<(), AttestationValidationError>;
 }
 
 impl<T, U, F> BeaconChain for RawBeaconChain<T, U, F>
@@ -52,4 +59,15 @@ where
     ) -> Result<(BeaconBlock, BeaconState), BlockProductionError> {
         self.produce_block(randao_reveal)
     }
+
+    fn produce_attestation_data(&self, shard: u64) -> Result<AttestationData, BeaconChainError> {
+        self.produce_attestation_data(shard)
+    }
+
+    fn process_attestation(
+        &self,
+        attestation: Attestation,
+    ) -> Result<(), AttestationValidationError> {
+        self.process_attestation(attestation)
+    }
 }

beacon_node/rpc/src/lib.rs

@@ -1,19 +1,22 @@
+mod attestation;
 mod beacon_block;
 pub mod beacon_chain;
 mod beacon_node;
 pub mod config;
 mod validator;
 
+use self::attestation::AttestationServiceInstance;
 use self::beacon_block::BeaconBlockServiceInstance;
 use self::beacon_chain::BeaconChain;
 use self::beacon_node::BeaconNodeServiceInstance;
 use self::validator::ValidatorServiceInstance;
 pub use config::Config as RPCConfig;
-use futures::{future, Future};
-use grpcio::{Environment, Server, ServerBuilder};
+use futures::Future;
+use grpcio::{Environment, ServerBuilder};
 use network::NetworkMessage;
 use protos::services_grpc::{
-    create_beacon_block_service, create_beacon_node_service, create_validator_service,
+    create_attestation_service, create_beacon_block_service, create_beacon_node_service,
+    create_validator_service,
 };
 use slog::{info, o, warn};
 use std::sync::Arc;
@@ -56,11 +59,19 @@ pub fn start_server(
         };
         create_validator_service(instance)
     };
+    let attestation_service = {
+        let instance = AttestationServiceInstance {
+            chain: beacon_chain.clone(),
+            log: log.clone(),
+        };
+        create_attestation_service(instance)
+    };
 
     let mut server = ServerBuilder::new(env)
         .register_service(beacon_block_service)
         .register_service(validator_service)
         .register_service(beacon_node_service)
+        .register_service(attestation_service)
         .bind(config.listen_address.to_string(), config.port)
         .build()
         .unwrap();