Ethereum 2.0 Network Specification Upgrade (#510)

Updates lighthouse to the latest networking spec

-  Sync re-write (#496)
-  Updates to the latest eth2 networking spec (#495)
-  Libp2p updates and improvements

beacon_node/eth2-libp2p/src/rpc/methods.rs

@@ -2,7 +2,7 @@
 
 use ssz::{impl_decode_via_from, impl_encode_via_from};
 use ssz_derive::{Decode, Encode};
-use types::{BeaconBlockBody, Epoch, EthSpec, Hash256, Slot};
+use types::{Epoch, Hash256, Slot};
 
 /* Request/Response data structures for RPC methods */
 
@@ -13,23 +13,20 @@ pub type RequestId = usize;
 /// The HELLO request/response handshake message.
 #[derive(Encode, Decode, Clone, Debug)]
 pub struct HelloMessage {
-    /// The network ID of the peer.
-    pub network_id: u8,
+    /// The fork version of the chain we are broadcasting.
+    pub fork_version: [u8; 4],
 
-    /// The chain id for the HELLO request.
-    pub chain_id: u64,
+    /// Latest finalized root.
+    pub finalized_root: Hash256,
 
-    /// The peers last finalized root.
-    pub latest_finalized_root: Hash256,
+    /// Latest finalized epoch.
+    pub finalized_epoch: Epoch,
 
-    /// The peers last finalized epoch.
-    pub latest_finalized_epoch: Epoch,
+    /// The latest block root.
+    pub head_root: Hash256,
 
-    /// The peers last block root.
-    pub best_root: Hash256,
-
-    /// The peers last slot.
-    pub best_slot: Slot,
+    /// The slot associated with the latest block root.
+    pub head_slot: Slot,
 }
 
 /// The reason given for a `Goodbye` message.
@@ -74,108 +71,31 @@ impl_decode_via_from!(GoodbyeReason, u64);
 
 /// Request a number of beacon block roots from a peer.
 #[derive(Encode, Decode, Clone, Debug, PartialEq)]
-pub struct BeaconBlockRootsRequest {
-    /// The starting slot of the requested blocks.
-    pub start_slot: Slot,
+pub struct BeaconBlocksRequest {
+    /// The hash tree root of a block on the requested chain.
+    pub head_block_root: Hash256,
+
+    /// The starting slot to request blocks.
+    pub start_slot: u64,
 
     /// The number of blocks from the start slot.
-    pub count: u64, // this must be less than 32768. //TODO: Enforce this in the lower layers
-}
+    pub count: u64,
 
-/// Response containing a number of beacon block roots from a peer.
-#[derive(Encode, Decode, Clone, Debug, PartialEq)]
-pub struct BeaconBlockRootsResponse {
-    /// List of requested blocks and associated slots.
-    pub roots: Vec<BlockRootSlot>,
-}
-
-/// Contains a block root and associated slot.
-#[derive(Encode, Decode, Clone, Debug, PartialEq)]
-pub struct BlockRootSlot {
-    /// The block root.
-    pub block_root: Hash256,
-
-    /// The block slot.
-    pub slot: Slot,
-}
-
-/// The response of a beacon block roots request.
-impl BeaconBlockRootsResponse {
-    /// Returns `true` if each `self.roots.slot[i]` is higher than the preceding `i`.
-    pub fn slots_are_ascending(&self) -> bool {
-        for window in self.roots.windows(2) {
-            if window[0].slot >= window[1].slot {
-                return false;
-            }
-        }
-
-        true
-    }
-}
-
-/// Request a number of beacon block headers from a peer.
-#[derive(Encode, Decode, Clone, Debug, PartialEq)]
-pub struct BeaconBlockHeadersRequest {
-    /// The starting header hash of the requested headers.
-    pub start_root: Hash256,
-
-    /// The starting slot of the requested headers.
-    pub start_slot: Slot,
-
-    /// The maximum number of headers than can be returned.
-    pub max_headers: u64,
-
-    /// The maximum number of slots to skip between blocks.
-    pub skip_slots: u64,
-}
-
-/// Response containing requested block headers.
-#[derive(Clone, Debug, PartialEq)]
-pub struct BeaconBlockHeadersResponse {
-    /// The list of ssz-encoded requested beacon block headers.
-    pub headers: Vec<u8>,
+    /// The step increment to receive blocks.
+    ///
+    /// A value of 1 returns every block.
+    /// A value of 2 returns every second block.
+    /// A value of 3 returns every third block and so on.
+    pub step: u64,
 }
 
 /// Request a number of beacon block bodies from a peer.
 #[derive(Encode, Decode, Clone, Debug, PartialEq)]
-pub struct BeaconBlockBodiesRequest {
+pub struct RecentBeaconBlocksRequest {
     /// The list of beacon block bodies being requested.
     pub block_roots: Vec<Hash256>,
 }
 
-/// Response containing the list of requested beacon block bodies.
-#[derive(Clone, Debug, PartialEq)]
-pub struct BeaconBlockBodiesResponse {
-    /// The list of hashes that were sent in the request and match these roots response. None when
-    /// sending outbound.
-    pub block_roots: Option<Vec<Hash256>>,
-    /// The list of ssz-encoded beacon block bodies being requested.
-    pub block_bodies: Vec<u8>,
-}
-
-/// The decoded version of `BeaconBlockBodiesResponse` which is expected in `SimpleSync`.
-pub struct DecodedBeaconBlockBodiesResponse<E: EthSpec> {
-    /// The list of hashes sent in the request to get this response.
-    pub block_roots: Vec<Hash256>,
-    /// The valid decoded block bodies.
-    pub block_bodies: Vec<BeaconBlockBody<E>>,
-}
-
-/// Request values for tree hashes which yield a blocks `state_root`.
-#[derive(Encode, Decode, Clone, Debug, PartialEq)]
-pub struct BeaconChainStateRequest {
-    /// The tree hashes that a value is requested for.
-    pub hashes: Vec<Hash256>,
-}
-
-/// Request values for tree hashes which yield a blocks `state_root`.
-// Note: TBD
-#[derive(Encode, Decode, Clone, Debug, PartialEq)]
-pub struct BeaconChainStateResponse {
-    /// The values corresponding the to the requested tree hashes.
-    pub values: bool, //TBD - stubbed with encodable bool
-}
-
 /* RPC Handling and Grouping */
 // Collection of enums and structs used by the Codecs to encode/decode RPC messages
 
@@ -183,14 +103,10 @@ pub struct BeaconChainStateResponse {
 pub enum RPCResponse {
     /// A HELLO message.
     Hello(HelloMessage),
-    /// A response to a get BEACON_BLOCK_ROOTS request.
-    BeaconBlockRoots(BeaconBlockRootsResponse),
-    /// A response to a get BEACON_BLOCK_HEADERS request.
-    BeaconBlockHeaders(BeaconBlockHeadersResponse),
-    /// A response to a get BEACON_BLOCK_BODIES request.
-    BeaconBlockBodies(BeaconBlockBodiesResponse),
-    /// A response to a get BEACON_CHAIN_STATE request.
-    BeaconChainState(BeaconChainStateResponse),
+    /// A response to a get BEACON_BLOCKS request.
+    BeaconBlocks(Vec<u8>),
+    /// A response to a get RECENT_BEACON_BLOCKS request.
+    RecentBeaconBlocks(Vec<u8>),
 }
 
 #[derive(Debug)]
@@ -206,8 +122,8 @@ impl RPCErrorResponse {
     pub fn as_u8(&self) -> u8 {
         match self {
             RPCErrorResponse::Success(_) => 0,
-            RPCErrorResponse::InvalidRequest(_) => 2,
-            RPCErrorResponse::ServerError(_) => 3,
+            RPCErrorResponse::InvalidRequest(_) => 1,
+            RPCErrorResponse::ServerError(_) => 2,
             RPCErrorResponse::Unknown(_) => 255,
         }
     }
@@ -223,8 +139,8 @@ impl RPCErrorResponse {
     /// Builds an RPCErrorResponse from a response code and an ErrorMessage
     pub fn from_error(response_code: u8, err: ErrorMessage) -> Self {
         match response_code {
-            2 => RPCErrorResponse::InvalidRequest(err),
-            3 => RPCErrorResponse::ServerError(err),
+            1 => RPCErrorResponse::InvalidRequest(err),
+            2 => RPCErrorResponse::ServerError(err),
             _ => RPCErrorResponse::Unknown(err),
         }
     }