Implement selections Beacon API endpoints to support DVT middleware

common/eth2/src/lib.rs

@@ -2664,6 +2664,22 @@ impl BeaconNodeHttpClient {
         )
         .await
     }
+
+    /// `POST validator/beacon_committee_selections`
+    pub async fn post_validator_beacon_committee_selections(
+        &self,
+        selections: &[BeaconCommitteeSelection],
+    ) -> Result<GenericResponse<Vec<SelectionProof>>, Error> {
+        let mut path = self.eth_path(V1)?;
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("validator")
+            .push("beacon_committee_selections");
+
+        self.post_with_timeout_and_response(path, &selections, self.timeouts.attester_duties)
+            .await
+    }
 }
 
 /// Returns `Ok(response)` if the response is a `200 OK` response. Otherwise, creates an

common/eth2/src/types.rs

@@ -948,6 +948,13 @@ pub struct PeerCount {
     pub disconnecting: u64,
 }
 
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct BeaconCommitteeSelection {
+    #[serde(with = "serde_utils::quoted_u64")]
+    pub validator_index: u64,
+    pub slot: Slot,
+    pub selection_proof: Signature,
+}
 // --------- Server Sent Event Types -----------
 
 #[derive(PartialEq, Debug, Serialize, Deserialize, Clone)]

consensus/types/src/selection_proof.rs

@@ -3,10 +3,12 @@ use crate::{
 };
 use ethereum_hashing::hash;
 use safe_arith::{ArithError, SafeArith};
+use serde::{Deserialize, Serialize};
 use ssz::Encode;
 use std::cmp;
 
-#[derive(arbitrary::Arbitrary, PartialEq, Debug, Clone)]
+#[derive(arbitrary::Arbitrary, PartialEq, Debug, Clone, Serialize, Deserialize)]
+#[serde(transparent)]
 pub struct SelectionProof(Signature);
 
 impl SelectionProof {

validator_client/validator_services/src/duties_service.rs

@@ -13,7 +13,8 @@ use beacon_node_fallback::{ApiTopic, BeaconNodeFallback};
 use doppelganger_service::DoppelgangerStatus;
 use environment::RuntimeContext;
 use eth2::types::{
-    AttesterData, BeaconCommitteeSubscription, DutiesResponse, ProposerData, StateId, ValidatorId,
+    AttesterData, BeaconCommitteeSelection, BeaconCommitteeSubscription, DutiesResponse,
+    ProposerData, StateId, ValidatorId,
 };
 use futures::{stream, StreamExt};
 use parking_lot::RwLock;
@@ -129,11 +130,50 @@ async fn make_selection_proof<T: SlotClock + 'static, E: EthSpec>(
     duty: &AttesterData,
     validator_store: &ValidatorStore<T, E>,
     spec: &ChainSpec,
+    distributed: bool,
+    beacon_nodes: &Arc<BeaconNodeFallback<T, E>>,
 ) -> Result<Option<SelectionProof>, Error> {
-    let selection_proof = validator_store
-        .produce_selection_proof(duty.pubkey, duty.slot)
-        .await
-        .map_err(Error::FailedToProduceSelectionProof)?;
+    let selection_proof = if distributed {
+        // Submit a partial selection proof in the data field of the POST HTTP endpoint
+        let selection = BeaconCommitteeSelection {
+            validator_index: duty.validator_index,
+            slot: duty.slot,
+            selection_proof: validator_store
+                .produce_selection_proof(duty.pubkey, duty.slot)
+                .await
+                .map_err(Error::FailedToProduceSelectionProof)?
+                .into(),
+        };
+        // Call the endpoint /eth/v1/validator/beacon_committee_selections
+        // The middleware should return a full selection proof here
+
+        let response = beacon_nodes
+            .first_success(|beacon_node| {
+                let selections = selection.clone();
+                println!("Selection proof: {:?}", selections);
+                async move {
+                    let response = beacon_node
+                        .post_validator_beacon_committee_selections(&[selections])
+                        .await;
+
+                    println!("Response from middleware {:?}", response);
+
+                    response
+                }
+            })
+            .await;
+        response
+            .map_err(|e| {
+                Error::FailedToProduceSelectionProof(ValidatorStoreError::Middleware(e.to_string()))
+            })?
+            .data[0]
+            .clone()
+    } else {
+        validator_store
+            .produce_selection_proof(duty.pubkey, duty.slot)
+            .await
+            .map_err(Error::FailedToProduceSelectionProof)?
+    };
 
     selection_proof
         .is_aggregator(duty.committee_length as usize, spec)
@@ -1101,6 +1141,8 @@ async fn fill_in_selection_proofs<T: SlotClock + 'static, E: EthSpec>(
                         &duty,
                         &duties_service.validator_store,
                         &duties_service.spec,
+                        duties_service.distributed,
+                        &duties_service.beacon_nodes,
                     )
                     .await?;
                     Ok((duty, opt_selection_proof))

validator_client/validator_store/src/lib.rs

@@ -34,6 +34,7 @@ pub enum Error {
     GreaterThanCurrentEpoch { epoch: Epoch, current_epoch: Epoch },
     UnableToSignAttestation(AttestationError),
     UnableToSign(SigningError),
+    Middleware(String),
 }
 
 impl From<SigningError> for Error {