Split out validator index gRPC call

validator_client/src/duties/grpc.rs

@@ -1,6 +1,8 @@
 use super::traits::{BeaconNode, BeaconNodeError};
 use super::EpochDuties;
-use protos::services::ValidatorAssignmentRequest;
+use protos::services::{
+    IndexResponse, ProposeBlockSlotRequest, ProposeBlockSlotResponse, PublicKey as IndexRequest,
+};
 use protos::services_grpc::ValidatorServiceClient;
 use ssz::ssz_encode;
 use types::PublicKey;
@@ -11,30 +13,33 @@ impl BeaconNode for ValidatorServiceClient {
         epoch: u64,
         public_key: &PublicKey,
     ) -> Result<Option<EpochDuties>, BeaconNodeError> {
-        let mut req = ValidatorAssignmentRequest::new();
+        // Lookup the validator index for the supplied public key.
+        let validator_index = {
+            let mut req = IndexRequest::new();
+            req.set_public_key(ssz_encode(public_key).to_vec());
+            let resp = self
+                .validator_index(&req)
+                .map_err(|err| BeaconNodeError::RemoteFailure(format!("{:?}", err)))?;
+            resp.get_index()
+        };
+
+        let mut req = ProposeBlockSlotRequest::new();
+        req.set_validator_index(validator_index);
         req.set_epoch(epoch);
-        req.set_public_key(ssz_encode(public_key).to_vec());
 
         let reply = self
-            .validator_assignment(&req)
+            .propose_block_slot(&req)
             .map_err(|err| BeaconNodeError::RemoteFailure(format!("{:?}", err)))?;
 
-        if reply.has_validator_assignment() {
-            let assignment = reply.get_validator_assignment();
-
-            let block_production_slot = if assignment.has_block_production_slot() {
-                Some(assignment.get_block_production_slot())
-            } else {
-                None
-            };
-
-            let duties = EpochDuties {
-                block_production_slot,
-            };
-
-            Ok(Some(duties))
+        let block_production_slot = if reply.has_slot() {
+            Some(reply.get_slot())
         } else {
-            Ok(None)
-        }
+            None
+        };
+
+        Ok(Some(EpochDuties {
+            validator_index,
+            block_production_slot,
+        }))
     }
 }

validator_client/src/duties/mod.rs

@@ -15,6 +15,7 @@ pub use self::service::DutiesManagerService;
 
 #[derive(Debug, PartialEq, Clone, Copy, Default)]
 pub struct EpochDuties {
+    pub validator_index: u64,
     pub block_production_slot: Option<u64>,
     // Future shard info
 }
@@ -32,10 +33,10 @@ pub type EpochDutiesMap = HashMap<u64, EpochDuties>;
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum PollOutcome {
-    NoChange,
-    NewDuties,
-    DutiesChanged,
-    UnknownValidatorOrEpoch,
+    NoChange(u64, EpochDuties),
+    NewDuties(u64, EpochDuties),
+    DutiesChanged(u64, EpochDuties),
+    UnknownValidatorOrEpoch(u64),
 }
 
 #[derive(Debug, PartialEq)]
@@ -79,17 +80,17 @@ impl<T: SlotClock, U: BeaconNode> DutiesManager<T, U> {
             // If these duties were known, check to see if they're updates or identical.
             let result = if let Some(known_duties) = map.get(&epoch) {
                 if *known_duties == duties {
-                    Ok(PollOutcome::NoChange)
+                    Ok(PollOutcome::NoChange(epoch, duties))
                 } else {
-                    Ok(PollOutcome::DutiesChanged)
+                    Ok(PollOutcome::DutiesChanged(epoch, duties))
                 }
             } else {
-                Ok(PollOutcome::NewDuties)
+                Ok(PollOutcome::NewDuties(epoch, duties))
             };
             map.insert(epoch, duties);
             result
         } else {
-            Ok(PollOutcome::UnknownValidatorOrEpoch)
+            Ok(PollOutcome::UnknownValidatorOrEpoch(epoch))
         }
     }
 }
@@ -129,6 +130,7 @@ mod tests {
 
         // Configure response from the BeaconNode.
         beacon_node.set_next_shuffling_result(Ok(Some(EpochDuties {
+            validator_index: 0,
             block_production_slot: Some(10),
         })));
 
@@ -139,6 +141,7 @@ mod tests {
 
         // Return new duties.
         beacon_node.set_next_shuffling_result(Ok(Some(EpochDuties {
+            validator_index: 0,
             block_production_slot: Some(11),
         })));
         assert_eq!(manager.poll(), Ok(PollOutcome::DutiesChanged));

validator_client/src/duties/service.rs

@@ -17,13 +17,17 @@ impl<T: SlotClock, U: BeaconNode> DutiesManagerService<T, U> {
                 Err(error) => {
                     error!(self.log, "Epoch duties poll error"; "error" => format!("{:?}", error))
                 }
-                Ok(PollOutcome::NoChange) => debug!(self.log, "No change in duties"),
-                Ok(PollOutcome::DutiesChanged) => {
-                    info!(self.log, "Duties changed (potential re-org)")
+                Ok(PollOutcome::NoChange(epoch, _)) => {
+                    debug!(self.log, "No change in duties"; "epoch" => epoch)
                 }
-                Ok(PollOutcome::NewDuties) => info!(self.log, "New duties obtained"),
-                Ok(PollOutcome::UnknownValidatorOrEpoch) => {
-                    error!(self.log, "Epoch or validator unknown")
+                Ok(PollOutcome::DutiesChanged(epoch, duties)) => {
+                    info!(self.log, "Duties changed (potential re-org)"; "epoch" => epoch, "duties" => format!("{:?}", duties))
+                }
+                Ok(PollOutcome::NewDuties(epoch, duties)) => {
+                    info!(self.log, "New duties obtained"; "epoch" => epoch, "duties" => format!("{:?}", duties))
+                }
+                Ok(PollOutcome::UnknownValidatorOrEpoch(epoch)) => {
+                    error!(self.log, "Epoch or validator unknown"; "epoch" => epoch)
                 }
             };