Restrict network limits based on merge fork epoch (#2839)

beacon_node/lighthouse_network/src/rpc/codec/ssz_snappy.rs

@@ -697,9 +697,9 @@ mod tests {
         version: Version,
         message: &mut BytesMut,
     ) -> Result<Option<RPCResponse<Spec>>, RPCError> {
-        let max_packet_size = 1_048_576;
         let snappy_protocol_id = ProtocolId::new(protocol, version, Encoding::SSZSnappy);
         let fork_context = Arc::new(fork_context());
+        let max_packet_size = max_rpc_size(&fork_context);
         let mut snappy_outbound_codec =
             SSZSnappyOutboundCodec::<Spec>::new(snappy_protocol_id, max_packet_size, fork_context);
         // decode message just as snappy message
@@ -1124,7 +1124,7 @@ mod tests {
         );
     }
 
-    /// Test sending a message with encoded length prefix > MAX_RPC_SIZE.
+    /// Test sending a message with encoded length prefix > max_rpc_size.
     #[test]
     fn test_decode_invalid_length() {
         // 10 byte snappy stream identifier

beacon_node/lighthouse_network/src/rpc/handler.rs

@@ -5,7 +5,7 @@ use super::methods::{
     GoodbyeReason, RPCCodedResponse, RPCResponseErrorCode, RequestId, ResponseTermination,
 };
 use super::outbound::OutboundRequestContainer;
-use super::protocol::{InboundRequest, Protocol, RPCError, RPCProtocol};
+use super::protocol::{max_rpc_size, InboundRequest, Protocol, RPCError, RPCProtocol};
 use super::{RPCReceived, RPCSend};
 use crate::rpc::outbound::{OutboundFramed, OutboundRequest};
 use crate::rpc::protocol::InboundFramed;
@@ -951,6 +951,7 @@ where
                     OutboundRequestContainer {
                         req: req.clone(),
                         fork_context: self.fork_context.clone(),
+                        max_rpc_size: max_rpc_size(&self.fork_context),
                     },
                     (),
                 )

beacon_node/lighthouse_network/src/rpc/mod.rs

@@ -30,7 +30,7 @@ pub use methods::{
     RPCResponseErrorCode, RequestId, ResponseTermination, StatusMessage, MAX_REQUEST_BLOCKS,
 };
 pub(crate) use outbound::OutboundRequest;
-pub use protocol::{Protocol, RPCError, MAX_RPC_SIZE};
+pub use protocol::{max_rpc_size, Protocol, RPCError};
 
 pub(crate) mod codec;
 mod handler;
@@ -186,6 +186,7 @@ where
             SubstreamProtocol::new(
                 RPCProtocol {
                     fork_context: self.fork_context.clone(),
+                    max_rpc_size: max_rpc_size(&self.fork_context),
                     phantom: PhantomData,
                 },
                 (),

beacon_node/lighthouse_network/src/rpc/outbound.rs

@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 
 use super::methods::*;
 use super::protocol::Protocol;
-use super::protocol::{ProtocolId, MAX_RPC_SIZE};
+use super::protocol::ProtocolId;
 use super::RPCError;
 use crate::rpc::protocol::Encoding;
 use crate::rpc::protocol::Version;
@@ -29,6 +29,7 @@ use types::{EthSpec, ForkContext};
 pub struct OutboundRequestContainer<TSpec: EthSpec> {
     pub req: OutboundRequest<TSpec>,
     pub fork_context: Arc<ForkContext>,
+    pub max_rpc_size: usize,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -150,7 +151,7 @@ where
             Encoding::SSZSnappy => {
                 let ssz_snappy_codec = BaseOutboundCodec::new(SSZSnappyOutboundCodec::new(
                     protocol,
-                    MAX_RPC_SIZE,
+                    self.max_rpc_size,
                     self.fork_context.clone(),
                 ));
                 OutboundCodec::SSZSnappy(ssz_snappy_codec)

beacon_node/lighthouse_network/src/rpc/protocol.rs

@@ -22,7 +22,7 @@ use tokio_util::{
 };
 use types::{
     BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockMerge, EthSpec, ForkContext,
-    Hash256, MainnetEthSpec, Signature, SignedBeaconBlock,
+    ForkName, Hash256, MainnetEthSpec, Signature, SignedBeaconBlock,
 };
 
 lazy_static! {
@@ -92,8 +92,10 @@ lazy_static! {
 
 }
 
-/// The maximum bytes that can be sent across the RPC.
-pub const MAX_RPC_SIZE: usize = 10 * 1_048_576; // 10M
+/// The maximum bytes that can be sent across the RPC pre-merge.
+pub(crate) const MAX_RPC_SIZE: usize = 1_048_576; // 1M
+/// The maximum bytes that can be sent across the RPC post-merge.
+pub(crate) const MAX_RPC_SIZE_POST_MERGE: usize = 10 * 1_048_576; // 10M
 /// The protocol prefix the RPC protocol id.
 const PROTOCOL_PREFIX: &str = "/eth2/beacon_chain/req";
 /// Time allowed for the first byte of a request to arrive before we time out (Time To First Byte).
@@ -102,6 +104,15 @@ const TTFB_TIMEOUT: u64 = 5;
 /// established before the stream is terminated.
 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
+    }
+}
+
 /// Protocol names to be used.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Protocol {
@@ -170,6 +181,7 @@ impl std::fmt::Display for Version {
 #[derive(Debug, Clone)]
 pub struct RPCProtocol<TSpec: EthSpec> {
     pub fork_context: Arc<ForkContext>,
+    pub max_rpc_size: usize,
     pub phantom: PhantomData<TSpec>,
 }
 
@@ -206,7 +218,7 @@ impl RpcLimits {
         Self { min, max }
     }
 
-    /// Returns true if the given length is greater than `MAX_RPC_SIZE` or out of
+    /// Returns true if the given length is greater than `max_rpc_size` or out of
     /// bounds for the given ssz type, returns false otherwise.
     pub fn is_out_of_bounds(&self, length: usize, max_rpc_size: usize) -> bool {
         length > std::cmp::min(self.max, max_rpc_size) || length < self.min
@@ -365,7 +377,7 @@ where
                 Encoding::SSZSnappy => {
                     let ssz_snappy_codec = BaseInboundCodec::new(SSZSnappyInboundCodec::new(
                         protocol,
-                        MAX_RPC_SIZE,
+                        self.max_rpc_size,
                         self.fork_context.clone(),
                     ));
                     InboundCodec::SSZSnappy(ssz_snappy_codec)