Refactored ForkVersionedResponse and ForkVersionDeserialize

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -6106,7 +6106,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                         payload_attributes: payload_attributes.into(),
                     },
                     metadata: Default::default(),
-                    version: Some(self.spec.fork_name_at_slot::<T::EthSpec>(prepare_slot)),
+                    version: self.spec.fork_name_at_slot::<T::EthSpec>(prepare_slot),
                 }));
             }
         }

beacon_node/builder_client/src/lib.rs

@@ -147,7 +147,7 @@ impl BuilderHttpClient {
                 self.ssz_available.store(true, Ordering::SeqCst);
                 T::from_ssz_bytes_by_fork(&response_bytes, fork_name)
                     .map(|data| ForkVersionedResponse {
-                        version: Some(fork_name),
+                        version: fork_name,
                         metadata: EmptyMetadata {},
                         data,
                     })

beacon_node/execution_layer/src/lib.rs

@@ -2116,9 +2116,9 @@ fn verify_builder_bid<E: EthSpec>(
             payload: header.block_number(),
             expected: block_number,
         }))
-    } else if bid.version != Some(current_fork) {
+    } else if bid.version != current_fork {
         Err(Box::new(InvalidBuilderPayload::Fork {
-            payload: bid.version,
+            payload: Some(bid.version),
             expected: current_fork,
         }))
     } else if !is_signature_valid {

beacon_node/execution_layer/src/test_utils/mock_builder.rs

@@ -980,7 +980,7 @@ pub fn serve<E: EthSpec>(
                         .await
                         .map_err(|e| warp::reject::custom(Custom(e)))?;
                     let resp: ForkVersionedResponse<_> = ForkVersionedResponse {
-                        version: Some(fork_name),
+                        version: fork_name,
                         metadata: Default::default(),
                         data: payload,
                     };
@@ -1040,7 +1040,7 @@ pub fn serve<E: EthSpec>(
                     ),
                     eth2::types::Accept::Json | eth2::types::Accept::Any => {
                         let resp: ForkVersionedResponse<_> = ForkVersionedResponse {
-                            version: Some(fork_name),
+                            version: fork_name,
                             metadata: Default::default(),
                             data: signed_bid,
                         };

beacon_node/http_api/src/aggregate_attestation.rs

@@ -52,7 +52,7 @@ pub fn get_aggregate_attestation<T: BeaconChainTypes>(
 
     if endpoint_version == V2 {
         let fork_versioned_response = ForkVersionedResponse {
-            version: Some(fork_name),
+            version: fork_name,
             metadata: EmptyMetadata {},
             data: aggregate_attestation,
         };

beacon_node/http_api/src/lib.rs

@@ -1698,6 +1698,13 @@ pub fn serve<T: BeaconChainTypes>(
         .and(task_spawner_filter.clone())
         .and(chain_filter.clone());
 
+    let beacon_blocks_path_v2 = eth_v2
+        .and(warp::path("beacon"))
+        .and(warp::path("blocks"))
+        .and(block_id_or_err)
+        .and(task_spawner_filter.clone())
+        .and(chain_filter.clone());
+
     let beacon_blocks_path_any = any_version
         .and(warp::path("beacon"))
         .and(warp::path("blocks"))
@@ -1706,13 +1713,12 @@ pub fn serve<T: BeaconChainTypes>(
         .and(chain_filter.clone());
 
     // GET beacon/blocks/{block_id}
-    let get_beacon_block = beacon_blocks_path_any
+    let get_beacon_block_v2 = beacon_blocks_path_v2
         .clone()
         .and(warp::path::end())
         .and(warp::header::optional::<api_types::Accept>("accept"))
         .then(
-            |endpoint_version: EndpointVersion,
-             block_id: BlockId,
+            |block_id: BlockId,
              task_spawner: TaskSpawner<T::EthSpec>,
              chain: Arc<BeaconChain<T>>,
              accept_header: Option<api_types::Accept>| {
@@ -1735,7 +1741,7 @@ pub fn serve<T: BeaconChainTypes>(
                                 ))
                             }),
                         _ => execution_optimistic_finalized_fork_versioned_response(
-                            endpoint_version,
+                            V2,
                             fork_name,
                             execution_optimistic,
                             finalized,
@@ -2020,7 +2026,7 @@ pub fn serve<T: BeaconChainTypes>(
         .and(warp::path::end())
         .and(warp::query::<api_types::AttestationPoolQuery>())
         .then(
-            |endpoint_version: EndpointVersion,
+            |_endpoint_version: EndpointVersion,
              task_spawner: TaskSpawner<T::EthSpec>,
              chain: Arc<BeaconChain<T>>,
              query: api_types::AttestationPoolQuery| {
@@ -2063,7 +2069,7 @@ pub fn serve<T: BeaconChainTypes>(
                         })
                         .collect::<Vec<_>>();
 
-                    let res = fork_versioned_response(endpoint_version, fork_name, &attestations)?;
+                    let res = fork_versioned_response(fork_name, &attestations);
                     Ok(add_consensus_version_header(
                         warp::reply::json(&res).into_response(),
                         fork_name,
@@ -2127,7 +2133,7 @@ pub fn serve<T: BeaconChainTypes>(
             .and(warp::path("attester_slashings"))
             .and(warp::path::end())
             .then(
-                |endpoint_version: EndpointVersion,
+                |_endpoint_version: EndpointVersion,
                  task_spawner: TaskSpawner<T::EthSpec>,
                  chain: Arc<BeaconChain<T>>| {
                     task_spawner.blocking_response_task(Priority::P1, move || {
@@ -2152,7 +2158,7 @@ pub fn serve<T: BeaconChainTypes>(
                             })
                             .collect::<Vec<_>>();
 
-                        let res = fork_versioned_response(endpoint_version, fork_name, &slashings)?;
+                        let res = fork_versioned_response(fork_name, &slashings);
                         Ok(add_consensus_version_header(
                             warp::reply::json(&res).into_response(),
                             fork_name,
@@ -2601,7 +2607,7 @@ pub fn serve<T: BeaconChainTypes>(
                                 ))
                             }),
                         _ => Ok(warp::reply::json(&ForkVersionedResponse {
-                            version: Some(fork_name),
+                            version: fork_name,
                             metadata: EmptyMetadata {},
                             data: update,
                         })
@@ -2650,7 +2656,7 @@ pub fn serve<T: BeaconChainTypes>(
                                 ))
                             }),
                         _ => Ok(warp::reply::json(&ForkVersionedResponse {
-                            version: Some(fork_name),
+                            version: fork_name,
                             metadata: EmptyMetadata {},
                             data: update,
                         })
@@ -3371,7 +3377,7 @@ pub fn serve<T: BeaconChainTypes>(
                     if endpoint_version == V3 {
                         produce_block_v3(accept_header, chain, slot, query).await
                     } else {
-                        produce_block_v2(endpoint_version, accept_header, chain, slot, query).await
+                        produce_block_v2(accept_header, chain, slot, query).await
                     }
                 })
             },
@@ -3401,8 +3407,7 @@ pub fn serve<T: BeaconChainTypes>(
              chain: Arc<BeaconChain<T>>| {
                 task_spawner.spawn_async_with_rejection(Priority::P0, async move {
                     not_synced_filter?;
-                    produce_blinded_block_v2(EndpointVersion(2), accept_header, chain, slot, query)
-                        .await
+                    produce_blinded_block_v2(accept_header, chain, slot, query).await
                 })
             },
         );
@@ -4604,7 +4609,7 @@ pub fn serve<T: BeaconChainTypes>(
     let post_lighthouse_block_rewards = warp::path("lighthouse")
         .and(warp::path("analysis"))
         .and(warp::path("block_rewards"))
-        .and(warp_utils::json::json())
+        .and(warp_utils::json::fork_version_json())
         .and(warp::path::end())
         .and(task_spawner_filter.clone())
         .and(chain_filter.clone())
@@ -4840,7 +4845,7 @@ pub fn serve<T: BeaconChainTypes>(
                 .uor(get_beacon_state_pending_consolidations)
                 .uor(get_beacon_headers)
                 .uor(get_beacon_headers_block_id)
-                .uor(get_beacon_block)
+                .uor(get_beacon_block_v2)
                 .uor(get_beacon_block_attestations)
                 .uor(get_beacon_blinded_block)
                 .uor(get_beacon_block_root)

beacon_node/http_api/src/light_client.rs

@@ -1,5 +1,5 @@
 use crate::version::{
-    add_consensus_version_header, add_ssz_content_type_header, fork_versioned_response, V1,
+    add_consensus_version_header, add_ssz_content_type_header, fork_versioned_response,
 };
 use beacon_chain::{BeaconChain, BeaconChainError, BeaconChainTypes};
 use eth2::types::{
@@ -52,7 +52,7 @@ pub fn get_light_client_updates<T: BeaconChainTypes>(
             let fork_versioned_response = light_client_updates
                 .iter()
                 .map(|update| map_light_client_update_to_json_response::<T>(&chain, update.clone()))
-                .collect::<Result<Vec<ForkVersionedResponse<LightClientUpdate<T::EthSpec>>>, Rejection>>()?;
+                .collect::<Vec<ForkVersionedResponse<LightClientUpdate<T::EthSpec>>>>();
             Ok(warp::reply::json(&fork_versioned_response).into_response())
         }
     }
@@ -88,10 +88,8 @@ pub fn get_light_client_bootstrap<T: BeaconChainTypes>(
                 warp_utils::reject::custom_server_error(format!("failed to create response: {}", e))
             }),
         _ => {
-            let fork_versioned_response = map_light_client_bootstrap_to_json_response::<T>(
-                fork_name,
-                light_client_bootstrap,
-            )?;
+            let fork_versioned_response =
+                map_light_client_bootstrap_to_json_response::<T>(fork_name, light_client_bootstrap);
             Ok(warp::reply::json(&fork_versioned_response).into_response())
         }
     }
@@ -177,17 +175,17 @@ fn map_light_client_update_to_ssz_chunk<T: BeaconChainTypes>(
 fn map_light_client_bootstrap_to_json_response<T: BeaconChainTypes>(
     fork_name: ForkName,
     light_client_bootstrap: LightClientBootstrap<T::EthSpec>,
-) -> Result<ForkVersionedResponse<LightClientBootstrap<T::EthSpec>>, Rejection> {
-    fork_versioned_response(V1, fork_name, light_client_bootstrap)
+) -> ForkVersionedResponse<LightClientBootstrap<T::EthSpec>> {
+    fork_versioned_response(fork_name, light_client_bootstrap)
 }
 
 fn map_light_client_update_to_json_response<T: BeaconChainTypes>(
     chain: &BeaconChain<T>,
     light_client_update: LightClientUpdate<T::EthSpec>,
-) -> Result<ForkVersionedResponse<LightClientUpdate<T::EthSpec>>, Rejection> {
+) -> ForkVersionedResponse<LightClientUpdate<T::EthSpec>> {
     let fork_name = chain
         .spec
         .fork_name_at_slot::<T::EthSpec>(*light_client_update.signature_slot());
 
-    fork_versioned_response(V1, fork_name, light_client_update)
+    fork_versioned_response(fork_name, light_client_update)
 }

beacon_node/http_api/src/produce_block.rs

@@ -9,9 +9,7 @@ use crate::{
 use beacon_chain::{
     BeaconBlockResponseWrapper, BeaconChain, BeaconChainTypes, ProduceBlockVerification,
 };
-use eth2::types::{
-    self as api_types, EndpointVersion, ProduceBlockV3Metadata, SkipRandaoVerification,
-};
+use eth2::types::{self as api_types, ProduceBlockV3Metadata, SkipRandaoVerification};
 use ssz::Encode;
 use std::sync::Arc;
 use types::{payload::BlockProductionVersion, *};
@@ -115,7 +113,7 @@ pub fn build_response_v3<T: BeaconChainTypes>(
                 warp_utils::reject::custom_server_error(format!("failed to create response: {}", e))
             }),
         _ => Ok(warp::reply::json(&ForkVersionedResponse {
-            version: Some(fork_name),
+            version: fork_name,
             metadata,
             data: block_contents,
         })
@@ -129,7 +127,6 @@ pub fn build_response_v3<T: BeaconChainTypes>(
 }
 
 pub async fn produce_blinded_block_v2<T: BeaconChainTypes>(
-    endpoint_version: EndpointVersion,
     accept_header: Option<api_types::Accept>,
     chain: Arc<BeaconChain<T>>,
     slot: Slot,
@@ -155,11 +152,10 @@ pub async fn produce_blinded_block_v2<T: BeaconChainTypes>(
         .await
         .map_err(warp_utils::reject::unhandled_error)?;
 
-    build_response_v2(chain, block_response_type, endpoint_version, accept_header)
+    build_response_v2(chain, block_response_type, accept_header)
 }
 
 pub async fn produce_block_v2<T: BeaconChainTypes>(
-    endpoint_version: EndpointVersion,
     accept_header: Option<api_types::Accept>,
     chain: Arc<BeaconChain<T>>,
     slot: Slot,
@@ -186,13 +182,12 @@ pub async fn produce_block_v2<T: BeaconChainTypes>(
         .await
         .map_err(warp_utils::reject::unhandled_error)?;
 
-    build_response_v2(chain, block_response_type, endpoint_version, accept_header)
+    build_response_v2(chain, block_response_type, accept_header)
 }
 
 pub fn build_response_v2<T: BeaconChainTypes>(
     chain: Arc<BeaconChain<T>>,
     block_response: BeaconBlockResponseWrapper<T::EthSpec>,
-    endpoint_version: EndpointVersion,
     accept_header: Option<api_types::Accept>,
 ) -> Result<Response<Body>, warp::Rejection> {
     let fork_name = block_response
@@ -210,8 +205,10 @@ pub fn build_response_v2<T: BeaconChainTypes>(
             .map_err(|e| {
                 warp_utils::reject::custom_server_error(format!("failed to create response: {}", e))
             }),
-        _ => fork_versioned_response(endpoint_version, fork_name, block_contents)
-            .map(|response| warp::reply::json(&response).into_response())
-            .map(|res| add_consensus_version_header(res, fork_name)),
+        _ => {
+            let res = warp::reply::json(&fork_versioned_response(fork_name, block_contents))
+                .into_response();
+            Ok(add_consensus_version_header(res, fork_name))
+        }
     }
 }

beacon_node/http_api/src/version.rs

@@ -17,22 +17,14 @@ pub const V2: EndpointVersion = EndpointVersion(2);
 pub const V3: EndpointVersion = EndpointVersion(3);
 
 pub fn fork_versioned_response<T: Serialize>(
-    endpoint_version: EndpointVersion,
     fork_name: ForkName,
     data: T,
-) -> Result<ForkVersionedResponse<T>, warp::reject::Rejection> {
-    let fork_name = if endpoint_version == V1 {
-        None
-    } else if endpoint_version == V2 || endpoint_version == V3 {
-        Some(fork_name)
-    } else {
-        return Err(unsupported_version_rejection(endpoint_version));
-    };
-    Ok(ForkVersionedResponse {
+) -> ForkVersionedResponse<T> {
+    ForkVersionedResponse {
         version: fork_name,
         metadata: Default::default(),
         data,
-    })
+    }
 }
 
 pub fn execution_optimistic_finalized_fork_versioned_response<T: Serialize>(
@@ -42,13 +34,10 @@ pub fn execution_optimistic_finalized_fork_versioned_response<T: Serialize>(
     finalized: bool,
     data: T,
 ) -> Result<ExecutionOptimisticFinalizedForkVersionedResponse<T>, warp::reject::Rejection> {
-    let fork_name = if endpoint_version == V1 {
-        None
-    } else if endpoint_version == V2 {
-        Some(fork_name)
-    } else {
+    if endpoint_version != V2 {
         return Err(unsupported_version_rejection(endpoint_version));
-    };
+    }
+
     Ok(ExecutionOptimisticFinalizedForkVersionedResponse {
         version: fork_name,
         metadata: ExecutionOptimisticFinalizedMetadata {