Reconstruct Payloads using Payload Bodies Methods (#4028)

## Issue Addressed

* #3895 

Co-authored-by: ethDreamer <37123614+ethDreamer@users.noreply.github.com>
Co-authored-by: Michael Sproul <michael@sigmaprime.io>

beacon_node/execution_layer/src/test_utils/execution_block_generator.rs

@@ -199,6 +199,14 @@ impl<T: EthSpec> ExecutionBlockGenerator<T> {
             .and_then(|block| block.as_execution_block_with_tx())
     }
 
+    pub fn execution_block_with_txs_by_number(
+        &self,
+        number: u64,
+    ) -> Option<ExecutionBlockWithTransactions<T>> {
+        self.block_by_number(number)
+            .and_then(|block| block.as_execution_block_with_tx())
+    }
+
     pub fn move_to_block_prior_to_terminal_block(&mut self) -> Result<(), String> {
         let target_block = self
             .terminal_block_number

beacon_node/execution_layer/src/test_utils/handle_rpc.rs

@@ -2,7 +2,7 @@ use super::Context;
 use crate::engine_api::{http::*, *};
 use crate::json_structures::*;
 use crate::test_utils::DEFAULT_MOCK_EL_PAYLOAD_VALUE_WEI;
-use serde::de::DeserializeOwned;
+use serde::{de::DeserializeOwned, Deserialize};
 use serde_json::Value as JsonValue;
 use std::sync::Arc;
 use types::{EthSpec, ForkName};
@@ -359,6 +359,61 @@ pub async fn handle_rpc<T: EthSpec>(
             let engine_capabilities = ctx.engine_capabilities.read();
             Ok(serde_json::to_value(engine_capabilities.to_response()).unwrap())
         }
+        ENGINE_GET_PAYLOAD_BODIES_BY_RANGE_V1 => {
+            #[derive(Deserialize)]
+            #[serde(transparent)]
+            struct Quantity(#[serde(with = "eth2_serde_utils::u64_hex_be")] pub u64);
+
+            let start = get_param::<Quantity>(params, 0)
+                .map_err(|s| (s, BAD_PARAMS_ERROR_CODE))?
+                .0;
+            let count = get_param::<Quantity>(params, 1)
+                .map_err(|s| (s, BAD_PARAMS_ERROR_CODE))?
+                .0;
+
+            let mut response = vec![];
+            for block_num in start..(start + count) {
+                let maybe_block = ctx
+                    .execution_block_generator
+                    .read()
+                    .execution_block_with_txs_by_number(block_num);
+
+                match maybe_block {
+                    Some(block) => {
+                        let transactions = Transactions::<T>::new(
+                            block
+                                .transactions()
+                                .iter()
+                                .map(|transaction| VariableList::new(transaction.rlp().to_vec()))
+                                .collect::<Result<_, _>>()
+                                .map_err(|e| {
+                                    (
+                                        format!("failed to deserialize transaction: {:?}", e),
+                                        GENERIC_ERROR_CODE,
+                                    )
+                                })?,
+                        )
+                        .map_err(|e| {
+                            (
+                                format!("failed to deserialize transactions: {:?}", e),
+                                GENERIC_ERROR_CODE,
+                            )
+                        })?;
+
+                        response.push(Some(JsonExecutionPayloadBodyV1::<T> {
+                            transactions,
+                            withdrawals: block
+                                .withdrawals()
+                                .ok()
+                                .map(|withdrawals| VariableList::from(withdrawals.clone())),
+                        }));
+                    }
+                    None => response.push(None),
+                }
+            }
+
+            Ok(serde_json::to_value(response).unwrap())
+        }
         other => Err((
             format!("The method {} does not exist/is not available", other),
             METHOD_NOT_FOUND_CODE,

beacon_node/execution_layer/src/test_utils/mod.rs

@@ -39,6 +39,8 @@ pub const DEFAULT_ENGINE_CAPABILITIES: EngineCapabilities = EngineCapabilities {
     new_payload_v2: true,
     forkchoice_updated_v1: true,
     forkchoice_updated_v2: true,
+    get_payload_bodies_by_hash_v1: true,
+    get_payload_bodies_by_range_v1: true,
     get_payload_v1: true,
     get_payload_v2: true,
     exchange_transition_configuration_v1: true,