add client updates and test updates

common/eth2/src/lib.rs

@@ -346,6 +346,19 @@ impl BeaconNodeHttpClient {
         Ok(())
     }
 
+    /// Perform a HTTP POST request with a custom timeout.
+    async fn post_with_timeout_and_consensus_header<T: Serialize, U: IntoUrl>(
+        &self,
+        url: U,
+        body: &T,
+        timeout: Duration,
+        fork_name: ForkName,
+    ) -> Result<(), Error> {
+        self.post_generic_with_consensus_version(url, body, Some(timeout), fork_name)
+            .await?;
+        Ok(())
+    }
+
     /// Perform a HTTP POST request with a custom timeout, returning a JSON response.
     async fn post_with_timeout_and_response<T: DeserializeOwned, U: IntoUrl, V: Serialize>(
         &self,
@@ -395,6 +408,33 @@ impl BeaconNodeHttpClient {
         ok_or_error(response).await
     }
 
+    /// Generic POST function supporting arbitrary responses and timeouts.
+    /// Does not include Content-Type application/json in the request header.
+    async fn post_generic_json_without_content_type_header_but_with_consensus_header<
+        T: Serialize,
+        U: IntoUrl,
+    >(
+        &self,
+        url: U,
+        body: &T,
+        timeout: Option<Duration>,
+        fork: ForkName,
+    ) -> Result<Response, Error> {
+        let mut builder = self.client.post(url);
+        if let Some(timeout) = timeout {
+            builder = builder.timeout(timeout);
+        }
+
+        let serialized_body = serde_json::to_vec(body).map_err(Error::InvalidJson)?;
+
+        let response = builder
+            .header(CONSENSUS_VERSION_HEADER, fork.to_string())
+            .body(serialized_body)
+            .send()
+            .await?;
+        ok_or_error(response).await
+    }
+
     /// Generic POST function supporting arbitrary responses and timeouts.
     async fn post_generic_with_consensus_version<T: Serialize, U: IntoUrl>(
         &self,
@@ -1191,10 +1231,10 @@ impl BeaconNodeHttpClient {
         self.get_opt(path).await
     }
 
-    /// `GET beacon/blocks/{block_id}/attestations`
+    /// `GET v1/beacon/blocks/{block_id}/attestations`
     ///
     /// Returns `Ok(None)` on a 404 error.
-    pub async fn get_beacon_blocks_attestations<E: EthSpec>(
+    pub async fn get_beacon_blocks_attestations_v1<E: EthSpec>(
         &self,
         block_id: BlockId,
     ) -> Result<Option<ExecutionOptimisticFinalizedResponse<Vec<Attestation<E>>>>, Error> {
@@ -1210,8 +1250,28 @@ impl BeaconNodeHttpClient {
         self.get_opt(path).await
     }
 
-    /// `POST beacon/pool/attestations`
-    pub async fn post_beacon_pool_attestations<E: EthSpec>(
+    /// `GET v2/beacon/blocks/{block_id}/attestations`
+    ///
+    /// Returns `Ok(None)` on a 404 error.
+    pub async fn get_beacon_blocks_attestations_v2<E: EthSpec>(
+        &self,
+        block_id: BlockId,
+    ) -> Result<Option<ExecutionOptimisticFinalizedForkVersionedResponse<Vec<Attestation<E>>>>, Error>
+    {
+        let mut path = self.eth_path(V2)?;
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("beacon")
+            .push("blocks")
+            .push(&block_id.to_string())
+            .push("attestations");
+
+        self.get_opt(path).await
+    }
+
+    /// `POST v1/beacon/pool/attestations`
+    pub async fn post_beacon_pool_attestations_v1<E: EthSpec>(
         &self,
         attestations: &[Attestation<E>],
     ) -> Result<(), Error> {
@@ -1229,8 +1289,33 @@ impl BeaconNodeHttpClient {
         Ok(())
     }
 
-    /// `GET beacon/pool/attestations?slot,committee_index`
-    pub async fn get_beacon_pool_attestations<E: EthSpec>(
+    /// `POST v2/beacon/pool/attestations`
+    pub async fn post_beacon_pool_attestations_v2<E: EthSpec>(
+        &self,
+        attestations: &[Attestation<E>],
+        fork_name: ForkName,
+    ) -> Result<(), Error> {
+        let mut path = self.eth_path(V2)?;
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("beacon")
+            .push("pool")
+            .push("attestations");
+
+        self.post_with_timeout_and_consensus_header(
+            path,
+            &attestations,
+            self.timeouts.attestation,
+            fork_name,
+        )
+        .await?;
+
+        Ok(())
+    }
+
+    /// `GET v1/beacon/pool/attestations?slot,committee_index`
+    pub async fn get_beacon_pool_attestations_v1<E: EthSpec>(
         &self,
         slot: Option<Slot>,
         committee_index: Option<u64>,
@@ -1256,8 +1341,35 @@ impl BeaconNodeHttpClient {
         self.get(path).await
     }
 
-    /// `POST beacon/pool/attester_slashings`
-    pub async fn post_beacon_pool_attester_slashings<E: EthSpec>(
+    /// `GET v2/beacon/pool/attestations?slot,committee_index`
+    pub async fn get_beacon_pool_attestations_v2<E: EthSpec>(
+        &self,
+        slot: Option<Slot>,
+        committee_index: Option<u64>,
+    ) -> Result<ForkVersionedResponse<Vec<Attestation<E>>>, Error> {
+        let mut path = self.eth_path(V2)?;
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("beacon")
+            .push("pool")
+            .push("attestations");
+
+        if let Some(slot) = slot {
+            path.query_pairs_mut()
+                .append_pair("slot", &slot.to_string());
+        }
+
+        if let Some(index) = committee_index {
+            path.query_pairs_mut()
+                .append_pair("committee_index", &index.to_string());
+        }
+
+        self.get(path).await
+    }
+
+    /// `POST v1/beacon/pool/attester_slashings`
+    pub async fn post_beacon_pool_attester_slashings_v1<E: EthSpec>(
         &self,
         slashing: &AttesterSlashing<E>,
     ) -> Result<(), Error> {
@@ -1275,8 +1387,30 @@ impl BeaconNodeHttpClient {
         Ok(())
     }
 
-    /// `GET beacon/pool/attester_slashings`
-    pub async fn get_beacon_pool_attester_slashings<E: EthSpec>(
+    /// `POST v2/beacon/pool/attester_slashings`
+    pub async fn post_beacon_pool_attester_slashings_v2<E: EthSpec>(
+        &self,
+        slashing: &AttesterSlashing<E>,
+        fork_name: ForkName,
+    ) -> Result<(), Error> {
+        let mut path = self.eth_path(V2)?;
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("beacon")
+            .push("pool")
+            .push("attester_slashings");
+
+        self.post_generic_json_without_content_type_header_but_with_consensus_header(
+            path, slashing, None, fork_name,
+        )
+        .await?;
+
+        Ok(())
+    }
+
+    /// `GET v1/beacon/pool/attester_slashings`
+    pub async fn get_beacon_pool_attester_slashings_v1<E: EthSpec>(
         &self,
     ) -> Result<GenericResponse<Vec<AttesterSlashing<E>>>, Error> {
         let mut path = self.eth_path(V1)?;
@@ -1290,6 +1424,21 @@ impl BeaconNodeHttpClient {
         self.get(path).await
     }
 
+    /// `GET v2/beacon/pool/attester_slashings`
+    pub async fn get_beacon_pool_attester_slashings_v2<E: EthSpec>(
+        &self,
+    ) -> Result<ForkVersionedResponse<Vec<AttesterSlashing<E>>>, Error> {
+        let mut path = self.eth_path(V2)?;
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("beacon")
+            .push("pool")
+            .push("attester_slashings");
+
+        self.get(path).await
+    }
+
     /// `POST beacon/pool/proposer_slashings`
     pub async fn post_beacon_pool_proposer_slashings(
         &self,
@@ -2324,8 +2473,8 @@ impl BeaconNodeHttpClient {
         .await
     }
 
-    /// `POST validator/aggregate_and_proofs`
-    pub async fn post_validator_aggregate_and_proof<E: EthSpec>(
+    /// `POST v1/validator/aggregate_and_proofs`
+    pub async fn post_validator_aggregate_and_proof_v1<E: EthSpec>(
         &self,
         aggregates: &[SignedAggregateAndProof<E>],
     ) -> Result<(), Error> {
@@ -2342,6 +2491,30 @@ impl BeaconNodeHttpClient {
         Ok(())
     }
 
+    /// `POST v2/validator/aggregate_and_proofs`
+    pub async fn post_validator_aggregate_and_proof_v2<E: EthSpec>(
+        &self,
+        aggregates: &[SignedAggregateAndProof<E>],
+        fork_name: ForkName,
+    ) -> Result<(), Error> {
+        let mut path = self.eth_path(V2)?;
+
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("validator")
+            .push("aggregate_and_proofs");
+
+        self.post_with_timeout_and_consensus_header(
+            path,
+            &aggregates,
+            self.timeouts.attestation,
+            fork_name,
+        )
+        .await?;
+
+        Ok(())
+    }
+
     /// `POST validator/beacon_committee_subscriptions`
     pub async fn post_validator_beacon_committee_subscriptions(
         &self,