Block v3 endpoint (#4629)

## Issue Addressed

#4582

## Proposed Changes

Add a new v3 block fetching flow that can decide to return a Full OR Blinded payload

## Additional Info



Co-authored-by: Michael Sproul <micsproul@gmail.com>

common/eth2/src/lib.rs

@@ -38,8 +38,12 @@ use store::fork_versioned_response::ExecutionOptimisticFinalizedForkVersionedRes
 
 pub const V1: EndpointVersion = EndpointVersion(1);
 pub const V2: EndpointVersion = EndpointVersion(2);
+pub const V3: EndpointVersion = EndpointVersion(3);
 
 pub const CONSENSUS_VERSION_HEADER: &str = "Eth-Consensus-Version";
+pub const EXECUTION_PAYLOAD_BLINDED_HEADER: &str = "Eth-Execution-Payload-Blinded";
+pub const EXECUTION_PAYLOAD_VALUE_HEADER: &str = "Eth-Execution-Payload-Value";
+pub const CONSENSUS_BLOCK_VALUE_HEADER: &str = "Eth-Consensus-Block-Value";
 
 #[derive(Debug)]
 pub enum Error {
@@ -1628,6 +1632,26 @@ impl BeaconNodeHttpClient {
             .await
     }
 
+    /// `GET v2/validator/blocks/{slot}`
+    pub async fn get_validator_blocks_modular<T: EthSpec, Payload: AbstractExecPayload<T>>(
+        &self,
+        slot: Slot,
+        randao_reveal: &SignatureBytes,
+        graffiti: Option<&Graffiti>,
+        skip_randao_verification: SkipRandaoVerification,
+    ) -> Result<ForkVersionedResponse<BlockContents<T, Payload>>, Error> {
+        let path = self
+            .get_validator_blocks_path::<T, Payload>(
+                slot,
+                randao_reveal,
+                graffiti,
+                skip_randao_verification,
+            )
+            .await?;
+
+        self.get(path).await
+    }
+
     /// returns `GET v2/validator/blocks/{slot}` URL path
     pub async fn get_validator_blocks_path<T: EthSpec, Payload: AbstractExecPayload<T>>(
         &self,
@@ -1660,24 +1684,70 @@ impl BeaconNodeHttpClient {
         Ok(path)
     }
 
-    /// `GET v2/validator/blocks/{slot}`
-    pub async fn get_validator_blocks_modular<T: EthSpec, Payload: AbstractExecPayload<T>>(
+    /// `GET v3/validator/blocks/{slot}`
+    pub async fn get_validator_blocks_v3<T: EthSpec>(
+        &self,
+        slot: Slot,
+        randao_reveal: &SignatureBytes,
+        graffiti: Option<&Graffiti>,
+    ) -> Result<ForkVersionedBeaconBlockType<T>, Error> {
+        self.get_validator_blocks_v3_modular(
+            slot,
+            randao_reveal,
+            graffiti,
+            SkipRandaoVerification::No,
+        )
+        .await
+    }
+
+    /// `GET v3/validator/blocks/{slot}`
+    pub async fn get_validator_blocks_v3_modular<T: EthSpec>(
         &self,
         slot: Slot,
         randao_reveal: &SignatureBytes,
         graffiti: Option<&Graffiti>,
         skip_randao_verification: SkipRandaoVerification,
-    ) -> Result<ForkVersionedResponse<BlockContents<T, Payload>>, Error> {
-        let path = self
-            .get_validator_blocks_path::<T, Payload>(
-                slot,
-                randao_reveal,
-                graffiti,
-                skip_randao_verification,
-            )
-            .await?;
+    ) -> Result<ForkVersionedBeaconBlockType<T>, Error> {
+        let mut path = self.eth_path(V3)?;
 
-        self.get(path).await
+        path.path_segments_mut()
+            .map_err(|()| Error::InvalidUrl(self.server.clone()))?
+            .push("validator")
+            .push("blocks")
+            .push(&slot.to_string());
+
+        path.query_pairs_mut()
+            .append_pair("randao_reveal", &randao_reveal.to_string());
+
+        if let Some(graffiti) = graffiti {
+            path.query_pairs_mut()
+                .append_pair("graffiti", &graffiti.to_string());
+        }
+
+        if skip_randao_verification == SkipRandaoVerification::Yes {
+            path.query_pairs_mut()
+                .append_pair("skip_randao_verification", "");
+        }
+
+        let response = self.get_response(path, |b| b).await?;
+
+        let is_blinded_payload = response
+            .headers()
+            .get(EXECUTION_PAYLOAD_BLINDED_HEADER)
+            .map(|value| value.to_str().unwrap_or_default().to_lowercase() == "true")
+            .unwrap_or(false);
+
+        if is_blinded_payload {
+            let blinded_payload = response
+                .json::<ForkVersionedResponse<BlockContents<T, BlindedPayload<T>>>>()
+                .await?;
+            Ok(ForkVersionedBeaconBlockType::Blinded(blinded_payload))
+        } else {
+            let full_payload = response
+                .json::<ForkVersionedResponse<BlockContents<T, FullPayload<T>>>>()
+                .await?;
+            Ok(ForkVersionedBeaconBlockType::Full(full_payload))
+        }
     }
 
     /// `GET v2/validator/blocks/{slot}` in ssz format

common/eth2/src/types.rs

@@ -1384,6 +1384,11 @@ pub mod serde_status_code {
     }
 }
 
+pub enum ForkVersionedBeaconBlockType<T: EthSpec> {
+    Full(ForkVersionedResponse<BlockContents<T, FullPayload<T>>>),
+    Blinded(ForkVersionedResponse<BlockContents<T, BlindedPayload<T>>>),
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;