Fix merge rpc length limits (#3133)

## Issue Addressed

N/A

## Proposed Changes

Fix the upper bound for blocks by root responses to be equal to the max merge block size instead of altair.
Further make the rpc response limits fork aware.

beacon_node/lighthouse_network/src/rpc/protocol.rs

@@ -63,7 +63,13 @@ lazy_static! {
 
     /// The `BeaconBlockMerge` block has an `ExecutionPayload` field which has a max size ~16 GiB for future proofing.
     /// We calculate the value from its fields instead of constructing the block and checking the length.
-    pub static ref SIGNED_BEACON_BLOCK_MERGE_MAX: usize = types::ExecutionPayload::<MainnetEthSpec>::max_execution_payload_size();
+    /// Note: This is only the theoretical upper bound. We further bound the max size we receive over the network
+    /// with `MAX_RPC_SIZE_POST_MERGE`.
+    pub static ref SIGNED_BEACON_BLOCK_MERGE_MAX: usize =
+    // Size of a full altair block
+    *SIGNED_BEACON_BLOCK_ALTAIR_MAX
+    + types::ExecutionPayload::<MainnetEthSpec>::max_execution_payload_size() // adding max size of execution payload (~16gb)
+    + ssz::BYTES_PER_LENGTH_OFFSET; // Adding the additional ssz offset for the `ExecutionPayload` field
 
     pub static ref BLOCKS_BY_ROOT_REQUEST_MIN: usize =
         VariableList::<Hash256, MaxRequestBlocks>::from(Vec::<Hash256>::new())
@@ -106,10 +112,9 @@ const REQUEST_TIMEOUT: u64 = 15;
 
 /// Returns the maximum bytes that can be sent across the RPC.
 pub fn max_rpc_size(fork_context: &ForkContext) -> usize {
-    if fork_context.fork_exists(ForkName::Merge) {
-        MAX_RPC_SIZE_POST_MERGE
-    } else {
-        MAX_RPC_SIZE
+    match fork_context.current_fork() {
+        ForkName::Merge => MAX_RPC_SIZE_POST_MERGE,
+        ForkName::Altair | ForkName::Base => MAX_RPC_SIZE,
     }
 }
 
@@ -269,39 +274,39 @@ impl ProtocolId {
     }
 
     /// Returns min and max size for messages of given protocol id responses.
-    pub fn rpc_response_limits<T: EthSpec>(&self) -> RpcLimits {
+    pub fn rpc_response_limits<T: EthSpec>(&self, fork_context: &ForkContext) -> RpcLimits {
         match self.message_name {
             Protocol::Status => RpcLimits::new(
                 <StatusMessage as Encode>::ssz_fixed_len(),
                 <StatusMessage as Encode>::ssz_fixed_len(),
             ),
             Protocol::Goodbye => RpcLimits::new(0, 0), // Goodbye request has no response
-            Protocol::BlocksByRange => RpcLimits::new(
-                std::cmp::min(
-                    std::cmp::min(
-                        *SIGNED_BEACON_BLOCK_ALTAIR_MIN,
-                        *SIGNED_BEACON_BLOCK_BASE_MIN,
-                    ),
-                    *SIGNED_BEACON_BLOCK_MERGE_MIN,
+            Protocol::BlocksByRange => match fork_context.current_fork() {
+                ForkName::Base => {
+                    RpcLimits::new(*SIGNED_BEACON_BLOCK_BASE_MIN, *SIGNED_BEACON_BLOCK_BASE_MAX)
+                }
+                ForkName::Altair => RpcLimits::new(
+                    *SIGNED_BEACON_BLOCK_ALTAIR_MIN,
+                    *SIGNED_BEACON_BLOCK_ALTAIR_MAX,
                 ),
-                std::cmp::max(
-                    std::cmp::max(
-                        *SIGNED_BEACON_BLOCK_ALTAIR_MAX,
-                        *SIGNED_BEACON_BLOCK_BASE_MAX,
-                    ),
+                ForkName::Merge => RpcLimits::new(
+                    *SIGNED_BEACON_BLOCK_MERGE_MIN,
                     *SIGNED_BEACON_BLOCK_MERGE_MAX,
                 ),
-            ),
-            Protocol::BlocksByRoot => RpcLimits::new(
-                std::cmp::min(
+            },
+            Protocol::BlocksByRoot => match fork_context.current_fork() {
+                ForkName::Base => {
+                    RpcLimits::new(*SIGNED_BEACON_BLOCK_BASE_MIN, *SIGNED_BEACON_BLOCK_BASE_MAX)
+                }
+                ForkName::Altair => RpcLimits::new(
                     *SIGNED_BEACON_BLOCK_ALTAIR_MIN,
-                    *SIGNED_BEACON_BLOCK_BASE_MIN,
-                ),
-                std::cmp::max(
                     *SIGNED_BEACON_BLOCK_ALTAIR_MAX,
-                    *SIGNED_BEACON_BLOCK_BASE_MAX,
                 ),
-            ),
+                ForkName::Merge => RpcLimits::new(
+                    *SIGNED_BEACON_BLOCK_MERGE_MIN,
+                    *SIGNED_BEACON_BLOCK_MERGE_MAX,
+                ),
+            },
 
             Protocol::Ping => RpcLimits::new(
                 <Ping as Encode>::ssz_fixed_len(),
@@ -528,7 +533,7 @@ pub enum RPCError {
     /// Stream ended unexpectedly.
     IncompleteStream,
     /// Peer sent invalid data.
-    InvalidData,
+    InvalidData(String),
     /// An error occurred due to internal reasons. Ex: timer failure.
     InternalError(&'static str),
     /// Negotiation with this peer timed out.
@@ -562,7 +567,7 @@ impl std::fmt::Display for RPCError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match *self {
             RPCError::SSZDecodeError(ref err) => write!(f, "Error while decoding ssz: {:?}", err),
-            RPCError::InvalidData => write!(f, "Peer sent unexpected data"),
+            RPCError::InvalidData(ref err) => write!(f, "Peer sent unexpected data: {}", err),
             RPCError::IoError(ref err) => write!(f, "IO Error: {}", err),
             RPCError::ErrorResponse(ref code, ref reason) => write!(
                 f,
@@ -589,7 +594,7 @@ impl std::error::Error for RPCError {
             RPCError::StreamTimeout => None,
             RPCError::UnsupportedProtocol => None,
             RPCError::IncompleteStream => None,
-            RPCError::InvalidData => None,
+            RPCError::InvalidData(_) => None,
             RPCError::InternalError(_) => None,
             RPCError::ErrorResponse(_, _) => None,
             RPCError::NegotiationTimeout => None,