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);
-    }
 }