Altair networking (#2300)

## Issue Addressed

Resolves #2278 

## Proposed Changes

Implements the networking components for the Altair hard fork https://github.com/ethereum/eth2.0-specs/blob/dev/specs/altair/p2p-interface.md

## Additional Info

This PR acts as the base branch for networking changes and tracks https://github.com/sigp/lighthouse/pull/2279 . Changes to gossip, rpc and discovery can be separate PRs to be merged here for ease of review.

Co-authored-by: realbigsean <seananderson33@gmail.com>

beacon_node/eth2_libp2p/src/rpc/codec/base.rs

@@ -181,16 +181,18 @@ where
 mod tests {
     use super::super::ssz_snappy::*;
     use super::*;
-    use crate::rpc::methods::StatusMessage;
     use crate::rpc::protocol::*;
-    use snap::write::FrameEncoder;
-    use ssz::Encode;
-    use std::io::Write;
-    use types::{Epoch, Hash256, Slot};
+
+    use std::sync::Arc;
+    use types::{ForkContext, Hash256};
     use unsigned_varint::codec::Uvi;
 
     type Spec = types::MainnetEthSpec;
 
+    fn fork_context() -> ForkContext {
+        ForkContext::new::<Spec>(types::Slot::new(0), Hash256::zero(), &Spec::default_spec())
+    }
+
     #[test]
     fn test_decode_status_message() {
         let message = hex::decode("0054ff060000734e615070590032000006e71e7b54989925efd6c9cbcb8ceb9b5f71216f5137282bf6a1e3b50f64e42d6c7fb347abe07eb0db8200000005029e2800").unwrap();
@@ -200,8 +202,9 @@ mod tests {
         let snappy_protocol_id =
             ProtocolId::new(Protocol::Status, Version::V1, Encoding::SSZSnappy);
 
+        let fork_context = Arc::new(fork_context());
         let mut snappy_outbound_codec =
-            SSZSnappyOutboundCodec::<Spec>::new(snappy_protocol_id, 1_048_576);
+            SSZSnappyOutboundCodec::<Spec>::new(snappy_protocol_id, 1_048_576, fork_context);
 
         // remove response code
         let mut snappy_buf = buf.clone();
@@ -233,8 +236,10 @@ mod tests {
 
         let snappy_protocol_id =
             ProtocolId::new(Protocol::Status, Version::V1, Encoding::SSZSnappy);
+
+        let fork_context = Arc::new(fork_context());
         let mut snappy_outbound_codec =
-            SSZSnappyOutboundCodec::<Spec>::new(snappy_protocol_id, 1_048_576);
+            SSZSnappyOutboundCodec::<Spec>::new(snappy_protocol_id, 1_048_576, fork_context);
 
         let snappy_decoded_message = snappy_outbound_codec.decode(&mut dst).unwrap_err();
 
@@ -260,80 +265,34 @@ mod tests {
         // Response limits
         let limit = protocol_id.rpc_response_limits::<Spec>();
         let mut max = encode_len(limit.max + 1);
-        let mut codec = SSZSnappyOutboundCodec::<Spec>::new(protocol_id.clone(), 1_048_576);
+        let fork_context = Arc::new(fork_context());
+        let mut codec = SSZSnappyOutboundCodec::<Spec>::new(
+            protocol_id.clone(),
+            1_048_576,
+            fork_context.clone(),
+        );
         assert_eq!(codec.decode(&mut max).unwrap_err(), RPCError::InvalidData);
 
         let mut min = encode_len(limit.min - 1);
-        let mut codec = SSZSnappyOutboundCodec::<Spec>::new(protocol_id.clone(), 1_048_576);
+        let mut codec = SSZSnappyOutboundCodec::<Spec>::new(
+            protocol_id.clone(),
+            1_048_576,
+            fork_context.clone(),
+        );
         assert_eq!(codec.decode(&mut min).unwrap_err(), RPCError::InvalidData);
 
         // Request limits
         let limit = protocol_id.rpc_request_limits();
         let mut max = encode_len(limit.max + 1);
-        let mut codec = SSZSnappyOutboundCodec::<Spec>::new(protocol_id.clone(), 1_048_576);
+        let mut codec = SSZSnappyOutboundCodec::<Spec>::new(
+            protocol_id.clone(),
+            1_048_576,
+            fork_context.clone(),
+        );
         assert_eq!(codec.decode(&mut max).unwrap_err(), RPCError::InvalidData);
 
         let mut min = encode_len(limit.min - 1);
-        let mut codec = SSZSnappyOutboundCodec::<Spec>::new(protocol_id, 1_048_576);
+        let mut codec = SSZSnappyOutboundCodec::<Spec>::new(protocol_id, 1_048_576, fork_context);
         assert_eq!(codec.decode(&mut min).unwrap_err(), RPCError::InvalidData);
     }
-
-    #[test]
-    fn test_decode_malicious_status_message() {
-        // 10 byte snappy stream identifier
-        let stream_identifier: &'static [u8] = b"\xFF\x06\x00\x00sNaPpY";
-
-        assert_eq!(stream_identifier.len(), 10);
-
-        // byte 0(0xFE) is padding chunk type identifier for snappy messages
-        // byte 1,2,3 are chunk length (little endian)
-        let malicious_padding: &'static [u8] = b"\xFE\x00\x00\x00";
-
-        // Status message is 84 bytes uncompressed. `max_compressed_len` is 32 + 84 + 84/6 = 130.
-        let status_message_bytes = StatusMessage {
-            fork_digest: [0; 4],
-            finalized_root: Hash256::from_low_u64_be(0),
-            finalized_epoch: Epoch::new(1),
-            head_root: Hash256::from_low_u64_be(0),
-            head_slot: Slot::new(1),
-        }
-        .as_ssz_bytes();
-
-        assert_eq!(status_message_bytes.len(), 84);
-        assert_eq!(snap::raw::max_compress_len(status_message_bytes.len()), 130);
-
-        let mut uvi_codec: Uvi<usize> = Uvi::default();
-        let mut dst = BytesMut::with_capacity(1024);
-
-        // Insert length-prefix
-        uvi_codec
-            .encode(status_message_bytes.len(), &mut dst)
-            .unwrap();
-
-        // Insert snappy stream identifier
-        dst.extend_from_slice(stream_identifier);
-
-        // Insert malicious padding of 80 bytes.
-        for _ in 0..20 {
-            dst.extend_from_slice(malicious_padding);
-        }
-
-        // Insert payload (42 bytes compressed)
-        let mut writer = FrameEncoder::new(Vec::new());
-        writer.write_all(&status_message_bytes).unwrap();
-        writer.flush().unwrap();
-        assert_eq!(writer.get_ref().len(), 42);
-        dst.extend_from_slice(writer.get_ref());
-
-        // 10 (for stream identifier) + 80 + 42 = 132 > `max_compressed_len`. Hence, decoding should fail with `InvalidData`.
-
-        let snappy_protocol_id =
-            ProtocolId::new(Protocol::Status, Version::V1, Encoding::SSZSnappy);
-
-        let mut snappy_outbound_codec =
-            SSZSnappyOutboundCodec::<Spec>::new(snappy_protocol_id, 1_048_576);
-
-        let snappy_decoded_message = snappy_outbound_codec.decode(&mut dst).unwrap_err();
-        assert_eq!(snappy_decoded_message, RPCError::InvalidData);
-    }
 }

beacon_node/eth2_libp2p/src/rpc/handler.rs

@@ -4,6 +4,7 @@
 use super::methods::{
     GoodbyeReason, RPCCodedResponse, RPCResponseErrorCode, RequestId, ResponseTermination,
 };
+use super::outbound::OutboundRequestContainer;
 use super::protocol::{InboundRequest, Protocol, RPCError, RPCProtocol};
 use super::{RPCReceived, RPCSend};
 use crate::rpc::outbound::{OutboundFramed, OutboundRequest};
@@ -23,12 +24,13 @@ use smallvec::SmallVec;
 use std::{
     collections::hash_map::Entry,
     pin::Pin,
+    sync::Arc,
     task::{Context, Poll},
     time::Duration,
 };
 use tokio::time::{sleep_until, Instant as TInstant, Sleep};
 use tokio_util::time::{delay_queue, DelayQueue};
-use types::EthSpec;
+use types::{EthSpec, ForkContext};
 
 /// The time (in seconds) before a substream that is awaiting a response from the user times out.
 pub const RESPONSE_TIMEOUT: u64 = 10;
@@ -126,6 +128,9 @@ where
     /// This keeps track of the number of attempts.
     outbound_io_error_retries: u8,
 
+    /// Fork specific info.
+    fork_context: Arc<ForkContext>,
+
     /// Logger for handling RPC streams
     log: slog::Logger,
 }
@@ -203,6 +208,7 @@ where
 {
     pub fn new(
         listen_protocol: SubstreamProtocol<RPCProtocol<TSpec>, ()>,
+        fork_context: Arc<ForkContext>,
         log: &slog::Logger,
     ) -> Self {
         RPCHandler {
@@ -219,6 +225,7 @@ where
             state: HandlerState::Active,
             max_dial_negotiated: 8,
             outbound_io_error_retries: 0,
+            fork_context,
             log: log.clone(),
         }
     }
@@ -308,7 +315,7 @@ where
     type OutEvent = HandlerEvent<TSpec>;
     type Error = RPCError;
     type InboundProtocol = RPCProtocol<TSpec>;
-    type OutboundProtocol = OutboundRequest<TSpec>;
+    type OutboundProtocol = OutboundRequestContainer<TSpec>;
     type OutboundOpenInfo = (RequestId, OutboundRequest<TSpec>); // Keep track of the id and the request
     type InboundOpenInfo = ();
 
@@ -874,7 +881,14 @@ where
             let (id, req) = self.dial_queue.remove(0);
             self.dial_queue.shrink_to_fit();
             return Poll::Ready(ProtocolsHandlerEvent::OutboundSubstreamRequest {
-                protocol: SubstreamProtocol::new(req.clone(), ()).map_info(|()| (id, req)),
+                protocol: SubstreamProtocol::new(
+                    OutboundRequestContainer {
+                        req: req.clone(),
+                        fork_context: self.fork_context.clone(),
+                    },
+                    (),
+                )
+                .map_info(|()| (id, req)),
             });
         }
 

beacon_node/eth2_libp2p/src/rpc/methods.rs

@@ -1,6 +1,6 @@
 //! Available RPC methods types and ids.
 
-use crate::types::EnrBitfield;
+use crate::types::{EnrAttestationBitfield, EnrSyncCommitteeBitfield};
 use regex::bytes::Regex;
 use serde::Serialize;
 use ssz_derive::{Decode, Encode};
@@ -10,6 +10,7 @@ use ssz_types::{
 };
 use std::ops::Deref;
 use strum::AsStaticStr;
+use superstruct::superstruct;
 use types::{Epoch, EthSpec, Hash256, SignedBeaconBlock, Slot};
 
 /// Maximum number of blocks in a single request.
@@ -93,13 +94,23 @@ pub struct Ping {
 }
 
 /// The METADATA response structure.
-#[derive(Encode, Decode, Clone, Debug, PartialEq, Serialize)]
+#[superstruct(
+    variants(V1, V2),
+    variant_attributes(
+        derive(Encode, Decode, Clone, Debug, PartialEq, Serialize),
+        serde(bound = "T: EthSpec", deny_unknown_fields),
+    )
+)]
+#[derive(Clone, Debug, PartialEq, Serialize, Encode)]
 #[serde(bound = "T: EthSpec")]
 pub struct MetaData<T: EthSpec> {
     /// A sequential counter indicating when data gets modified.
     pub seq_number: u64,
-    /// The persistent subnet bitfield.
-    pub attnets: EnrBitfield<T>,
+    /// The persistent attestation subnet bitfield.
+    pub attnets: EnrAttestationBitfield<T>,
+    /// The persistent sync committee bitfield.
+    #[superstruct(only(V2))]
+    pub syncnets: EnrSyncCommitteeBitfield<T>,
 }
 
 /// The reason given for a `Goodbye` message.
@@ -360,7 +371,7 @@ impl<T: EthSpec> std::fmt::Display for RPCResponse<T> {
                 write!(f, "BlocksByRoot: Block slot: {}", block.slot())
             }
             RPCResponse::Pong(ping) => write!(f, "Pong: {}", ping.data),
-            RPCResponse::MetaData(metadata) => write!(f, "Metadata: {}", metadata.seq_number),
+            RPCResponse::MetaData(metadata) => write!(f, "Metadata: {}", metadata.seq_number()),
         }
     }
 }

beacon_node/eth2_libp2p/src/rpc/mod.rs

@@ -15,12 +15,13 @@ use libp2p::{Multiaddr, PeerId};
 use rate_limiter::{RPCRateLimiter as RateLimiter, RPCRateLimiterBuilder, RateLimitedErr};
 use slog::{crit, debug, o};
 use std::marker::PhantomData;
+use std::sync::Arc;
 use std::task::{Context, Poll};
 use std::time::Duration;
-use types::EthSpec;
+use types::{EthSpec, ForkContext};
 
 pub(crate) use handler::HandlerErr;
-pub(crate) use methods::{MetaData, Ping, RPCCodedResponse, RPCResponse};
+pub(crate) use methods::{MetaData, MetaDataV1, MetaDataV2, Ping, RPCCodedResponse, RPCResponse};
 pub(crate) use protocol::{InboundRequest, RPCProtocol};
 
 pub use handler::SubstreamId;
@@ -101,12 +102,13 @@ pub struct RPC<TSpec: EthSpec> {
     limiter: RateLimiter,
     /// Queue of events to be processed.
     events: Vec<NetworkBehaviourAction<RPCSend<TSpec>, RPCMessage<TSpec>>>,
+    fork_context: Arc<ForkContext>,
     /// Slog logger for RPC behaviour.
     log: slog::Logger,
 }
 
 impl<TSpec: EthSpec> RPC<TSpec> {
-    pub fn new(log: slog::Logger) -> Self {
+    pub fn new(fork_context: Arc<ForkContext>, log: slog::Logger) -> Self {
         let log = log.new(o!("service" => "libp2p_rpc"));
         let limiter = RPCRateLimiterBuilder::new()
             .n_every(Protocol::MetaData, 2, Duration::from_secs(5))
@@ -124,6 +126,7 @@ impl<TSpec: EthSpec> RPC<TSpec> {
         RPC {
             limiter,
             events: Vec::new(),
+            fork_context,
             log,
         }
     }
@@ -182,10 +185,12 @@ where
         RPCHandler::new(
             SubstreamProtocol::new(
                 RPCProtocol {
+                    fork_context: self.fork_context.clone(),
                     phantom: PhantomData,
                 },
                 (),
             ),
+            self.fork_context.clone(),
             &self.log,
         )
     }

beacon_node/eth2_libp2p/src/rpc/outbound.rs

@@ -14,16 +14,23 @@ use futures::future::BoxFuture;
 use futures::prelude::{AsyncRead, AsyncWrite};
 use futures::{FutureExt, SinkExt};
 use libp2p::core::{OutboundUpgrade, UpgradeInfo};
+use std::sync::Arc;
 use tokio_util::{
     codec::Framed,
     compat::{Compat, FuturesAsyncReadCompatExt},
 };
-use types::EthSpec;
+use types::{EthSpec, ForkContext};
 /* Outbound request */
 
 // Combines all the RPC requests into a single enum to implement `UpgradeInfo` and
 // `OutboundUpgrade`
 
+#[derive(Debug, Clone)]
+pub struct OutboundRequestContainer<TSpec: EthSpec> {
+    pub req: OutboundRequest<TSpec>,
+    pub fork_context: Arc<ForkContext>,
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum OutboundRequest<TSpec: EthSpec> {
     Status(StatusMessage),
@@ -34,13 +41,13 @@ pub enum OutboundRequest<TSpec: EthSpec> {
     MetaData(PhantomData<TSpec>),
 }
 
-impl<TSpec: EthSpec> UpgradeInfo for OutboundRequest<TSpec> {
+impl<TSpec: EthSpec> UpgradeInfo for OutboundRequestContainer<TSpec> {
     type Info = ProtocolId;
     type InfoIter = Vec<Self::Info>;
 
     // add further protocols as we support more encodings/versions
     fn protocol_info(&self) -> Self::InfoIter {
-        self.supported_protocols()
+        self.req.supported_protocols()
     }
 }
 
@@ -59,26 +66,23 @@ impl<TSpec: EthSpec> OutboundRequest<TSpec> {
                 Version::V1,
                 Encoding::SSZSnappy,
             )],
-            OutboundRequest::BlocksByRange(_) => vec![ProtocolId::new(
-                Protocol::BlocksByRange,
-                Version::V1,
-                Encoding::SSZSnappy,
-            )],
-            OutboundRequest::BlocksByRoot(_) => vec![ProtocolId::new(
-                Protocol::BlocksByRoot,
-                Version::V1,
-                Encoding::SSZSnappy,
-            )],
+            OutboundRequest::BlocksByRange(_) => vec![
+                ProtocolId::new(Protocol::BlocksByRange, Version::V2, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::BlocksByRange, Version::V1, Encoding::SSZSnappy),
+            ],
+            OutboundRequest::BlocksByRoot(_) => vec![
+                ProtocolId::new(Protocol::BlocksByRoot, Version::V2, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::BlocksByRoot, Version::V1, Encoding::SSZSnappy),
+            ],
             OutboundRequest::Ping(_) => vec![ProtocolId::new(
                 Protocol::Ping,
                 Version::V1,
                 Encoding::SSZSnappy,
             )],
-            OutboundRequest::MetaData(_) => vec![ProtocolId::new(
-                Protocol::MetaData,
-                Version::V1,
-                Encoding::SSZSnappy,
-            )],
+            OutboundRequest::MetaData(_) => vec![
+                ProtocolId::new(Protocol::MetaData, Version::V2, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::MetaData, Version::V1, Encoding::SSZSnappy),
+            ],
         }
     }
 
@@ -130,7 +134,7 @@ impl<TSpec: EthSpec> OutboundRequest<TSpec> {
 
 pub type OutboundFramed<TSocket, TSpec> = Framed<Compat<TSocket>, OutboundCodec<TSpec>>;
 
-impl<TSocket, TSpec> OutboundUpgrade<TSocket> for OutboundRequest<TSpec>
+impl<TSocket, TSpec> OutboundUpgrade<TSocket> for OutboundRequestContainer<TSpec>
 where
     TSpec: EthSpec + Send + 'static,
     TSocket: AsyncRead + AsyncWrite + Unpin + Send + 'static,
@@ -147,6 +151,7 @@ where
                 let ssz_snappy_codec = BaseOutboundCodec::new(SSZSnappyOutboundCodec::new(
                     protocol,
                     usize::max_value(),
+                    self.fork_context.clone(),
                 ));
                 OutboundCodec::SSZSnappy(ssz_snappy_codec)
             }
@@ -155,7 +160,7 @@ where
         let mut socket = Framed::new(socket, codec);
 
         async {
-            socket.send(self).await?;
+            socket.send(self.req).await?;
             socket.close().await?;
             Ok(socket)
         }

beacon_node/eth2_libp2p/src/rpc/protocol.rs

@@ -12,6 +12,7 @@ use ssz::Encode;
 use ssz_types::VariableList;
 use std::io;
 use std::marker::PhantomData;
+use std::sync::Arc;
 use std::time::Duration;
 use strum::{AsStaticRef, AsStaticStr};
 use tokio_io_timeout::TimeoutStream;
@@ -19,19 +20,35 @@ use tokio_util::{
     codec::Framed,
     compat::{Compat, FuturesAsyncReadCompatExt},
 };
-use types::{BeaconBlock, EthSpec, Hash256, MainnetEthSpec, Signature, SignedBeaconBlock};
+use types::{
+    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, EthSpec, ForkContext, Hash256, MainnetEthSpec,
+    Signature, SignedBeaconBlock,
+};
 
 lazy_static! {
     // Note: Hardcoding the `EthSpec` type for `SignedBeaconBlock` as min/max values is
     // same across different `EthSpec` implementations.
-    pub static ref SIGNED_BEACON_BLOCK_MIN: usize = SignedBeaconBlock::<MainnetEthSpec>::from_block(
-        BeaconBlock::empty(&MainnetEthSpec::default_spec()),
+    pub static ref SIGNED_BEACON_BLOCK_BASE_MIN: usize = SignedBeaconBlock::<MainnetEthSpec>::from_block(
+        BeaconBlock::Base(BeaconBlockBase::<MainnetEthSpec>::empty(&MainnetEthSpec::default_spec())),
         Signature::empty(),
     )
     .as_ssz_bytes()
     .len();
-    pub static ref SIGNED_BEACON_BLOCK_MAX: usize = SignedBeaconBlock::<MainnetEthSpec>::from_block(
-        BeaconBlock::full(&MainnetEthSpec::default_spec()),
+    pub static ref SIGNED_BEACON_BLOCK_BASE_MAX: usize = SignedBeaconBlock::<MainnetEthSpec>::from_block(
+        BeaconBlock::Base(BeaconBlockBase::full(&MainnetEthSpec::default_spec())),
+        Signature::empty(),
+    )
+    .as_ssz_bytes()
+    .len();
+
+    pub static ref SIGNED_BEACON_BLOCK_ALTAIR_MIN: usize = SignedBeaconBlock::<MainnetEthSpec>::from_block(
+        BeaconBlock::Altair(BeaconBlockAltair::<MainnetEthSpec>::empty(&MainnetEthSpec::default_spec())),
+        Signature::empty(),
+    )
+    .as_ssz_bytes()
+    .len();
+    pub static ref SIGNED_BEACON_BLOCK_ALTAIR_MAX: usize = SignedBeaconBlock::<MainnetEthSpec>::from_block(
+        BeaconBlock::Altair(BeaconBlockAltair::full(&MainnetEthSpec::default_spec())),
         Signature::empty(),
     )
     .as_ssz_bytes()
@@ -95,6 +112,8 @@ pub enum Protocol {
 pub enum Version {
     /// Version 1 of RPC
     V1,
+    /// Version 2 of RPC
+    V2,
 }
 
 /// RPC Encondings supported.
@@ -130,6 +149,7 @@ impl std::fmt::Display for Version {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let repr = match self {
             Version::V1 => "1",
+            Version::V2 => "2",
         };
         f.write_str(repr)
     }
@@ -137,6 +157,7 @@ impl std::fmt::Display for Version {
 
 #[derive(Debug, Clone)]
 pub struct RPCProtocol<TSpec: EthSpec> {
+    pub fork_context: Arc<ForkContext>,
     pub phantom: PhantomData<TSpec>,
 }
 
@@ -149,9 +170,13 @@ impl<TSpec: EthSpec> UpgradeInfo for RPCProtocol<TSpec> {
         vec![
             ProtocolId::new(Protocol::Status, Version::V1, Encoding::SSZSnappy),
             ProtocolId::new(Protocol::Goodbye, Version::V1, Encoding::SSZSnappy),
+            // V2 variants have higher preference then V1
+            ProtocolId::new(Protocol::BlocksByRange, Version::V2, Encoding::SSZSnappy),
             ProtocolId::new(Protocol::BlocksByRange, Version::V1, Encoding::SSZSnappy),
+            ProtocolId::new(Protocol::BlocksByRoot, Version::V2, Encoding::SSZSnappy),
             ProtocolId::new(Protocol::BlocksByRoot, Version::V1, Encoding::SSZSnappy),
             ProtocolId::new(Protocol::Ping, Version::V1, Encoding::SSZSnappy),
+            ProtocolId::new(Protocol::MetaData, Version::V2, Encoding::SSZSnappy),
             ProtocolId::new(Protocol::MetaData, Version::V1, Encoding::SSZSnappy),
         ]
     }
@@ -226,22 +251,49 @@ impl ProtocolId {
                 <StatusMessage as Encode>::ssz_fixed_len(),
             ),
             Protocol::Goodbye => RpcLimits::new(0, 0), // Goodbye request has no response
-            Protocol::BlocksByRange => {
-                RpcLimits::new(*SIGNED_BEACON_BLOCK_MIN, *SIGNED_BEACON_BLOCK_MAX)
-            }
-            Protocol::BlocksByRoot => {
-                RpcLimits::new(*SIGNED_BEACON_BLOCK_MIN, *SIGNED_BEACON_BLOCK_MAX)
-            }
+            Protocol::BlocksByRange => RpcLimits::new(
+                std::cmp::min(
+                    *SIGNED_BEACON_BLOCK_ALTAIR_MIN,
+                    *SIGNED_BEACON_BLOCK_BASE_MIN,
+                ),
+                std::cmp::max(
+                    *SIGNED_BEACON_BLOCK_ALTAIR_MAX,
+                    *SIGNED_BEACON_BLOCK_BASE_MAX,
+                ),
+            ),
+            Protocol::BlocksByRoot => RpcLimits::new(
+                std::cmp::min(
+                    *SIGNED_BEACON_BLOCK_ALTAIR_MIN,
+                    *SIGNED_BEACON_BLOCK_BASE_MIN,
+                ),
+                std::cmp::max(
+                    *SIGNED_BEACON_BLOCK_ALTAIR_MAX,
+                    *SIGNED_BEACON_BLOCK_BASE_MAX,
+                ),
+            ),
+
             Protocol::Ping => RpcLimits::new(
                 <Ping as Encode>::ssz_fixed_len(),
                 <Ping as Encode>::ssz_fixed_len(),
             ),
             Protocol::MetaData => RpcLimits::new(
-                <MetaData<T> as Encode>::ssz_fixed_len(),
-                <MetaData<T> as Encode>::ssz_fixed_len(),
+                <MetaDataV1<T> as Encode>::ssz_fixed_len(),
+                <MetaDataV2<T> as Encode>::ssz_fixed_len(),
             ),
         }
     }
+
+    /// Returns `true` if the given `ProtocolId` should expect `context_bytes` in the
+    /// beginning of the stream, else returns `false`.
+    pub fn has_context_bytes(&self) -> bool {
+        if self.version == Version::V2 {
+            match self.message_name {
+                Protocol::BlocksByRange | Protocol::BlocksByRoot => return true,
+                _ => return false,
+            }
+        }
+        false
+    }
 }
 
 /// An RPC protocol ID.
@@ -292,8 +344,11 @@ where
             let socket = socket.compat();
             let codec = match protocol.encoding {
                 Encoding::SSZSnappy => {
-                    let ssz_snappy_codec =
-                        BaseInboundCodec::new(SSZSnappyInboundCodec::new(protocol, MAX_RPC_SIZE));
+                    let ssz_snappy_codec = BaseInboundCodec::new(SSZSnappyInboundCodec::new(
+                        protocol,
+                        MAX_RPC_SIZE,
+                        self.fork_context.clone(),
+                    ));
                     InboundCodec::SSZSnappy(ssz_snappy_codec)
                 }
             };
@@ -359,26 +414,25 @@ impl<TSpec: EthSpec> InboundRequest<TSpec> {
                 Version::V1,
                 Encoding::SSZSnappy,
             )],
-            InboundRequest::BlocksByRange(_) => vec![ProtocolId::new(
-                Protocol::BlocksByRange,
-                Version::V1,
-                Encoding::SSZSnappy,
-            )],
-            InboundRequest::BlocksByRoot(_) => vec![ProtocolId::new(
-                Protocol::BlocksByRoot,
-                Version::V1,
-                Encoding::SSZSnappy,
-            )],
+            InboundRequest::BlocksByRange(_) => vec![
+                // V2 has higher preference when negotiating a stream
+                ProtocolId::new(Protocol::BlocksByRange, Version::V2, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::BlocksByRange, Version::V1, Encoding::SSZSnappy),
+            ],
+            InboundRequest::BlocksByRoot(_) => vec![
+                // V2 has higher preference when negotiating a stream
+                ProtocolId::new(Protocol::BlocksByRoot, Version::V2, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::BlocksByRoot, Version::V1, Encoding::SSZSnappy),
+            ],
             InboundRequest::Ping(_) => vec![ProtocolId::new(
                 Protocol::Ping,
                 Version::V1,
                 Encoding::SSZSnappy,
             )],
-            InboundRequest::MetaData(_) => vec![ProtocolId::new(
-                Protocol::MetaData,
-                Version::V1,
-                Encoding::SSZSnappy,
-            )],
+            InboundRequest::MetaData(_) => vec![
+                ProtocolId::new(Protocol::MetaData, Version::V2, Encoding::SSZSnappy),
+                ProtocolId::new(Protocol::MetaData, Version::V1, Encoding::SSZSnappy),
+            ],
         }
     }
 
@@ -424,8 +478,6 @@ impl<TSpec: EthSpec> InboundRequest<TSpec> {
     }
 }
 
-/* RPC Response type - used for outbound upgrades */
-
 /// Error in RPC Encoding/Decoding.
 #[derive(Debug, Clone, PartialEq, AsStaticStr)]
 #[strum(serialize_all = "snake_case")]