Complete initial testing of new RPC

beacon_node/eth2-libp2p/src/discovery.rs

@@ -68,6 +68,7 @@ impl<TSubstream> Discovery<TSubstream> {
 
         info!(log, "Local ENR: {}", local_enr.to_base64());
         debug!(log, "Local Node Id: {}", local_enr.node_id());
+        debug!(log, "Local ENR seq: {}", local_enr.seq());
 
         let mut discovery = Discv5::new(local_enr, local_key.clone(), config.listen_address)
             .map_err(|e| format!("Discv5 service failed: {:?}", e))?;

beacon_node/eth2-libp2p/src/rpc/codec/base.rs

@@ -113,11 +113,6 @@ where
                 resp_code_byte.copy_from_slice(&resp_byte);
 
                 let resp_code = u8::from_be_bytes(resp_code_byte);
-
-                if let Some(response) = RPCErrorResponse::internal_data(resp_code) {
-                    self.response_code = None;
-                    return Ok(Some(response));
-                }
                 self.response_code = Some(resp_code);
                 resp_code
             }

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, BeaconBlockHeader, Epoch, Hash256, Slot};
+use types::{BeaconBlockBody, Epoch, Hash256, Slot};
 
 /* Request/Response data structures for RPC methods */
 
@@ -136,11 +136,6 @@ pub struct BeaconBlockHeadersResponse {
     pub headers: Vec<u8>,
 }
 
-#[derive(Encode, Decode, Debug)]
-pub struct EncodeableBeaconBlockHeadersResponse {
-    pub headers: Vec<BeaconBlockHeader>,
-}
-
 /// Request a number of beacon block bodies from a peer.
 #[derive(Encode, Decode, Clone, Debug, PartialEq)]
 pub struct BeaconBlockBodiesRequest {
@@ -208,16 +203,6 @@ pub enum RPCErrorResponse {
 }
 
 impl RPCErrorResponse {
-    /// If a response has no payload, returns the variant corresponding to the code.
-    pub fn internal_data(response_code: u8) -> Option<RPCErrorResponse> {
-        match response_code {
-            // EncodingError
-            1 => Some(RPCErrorResponse::EncodingError),
-            // All others require further data
-            _ => None,
-        }
-    }
-
     /// Used to encode the response.
     pub fn as_u8(&self) -> u8 {
         match self {

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

@@ -20,7 +20,7 @@ use tokio::util::FutureExt;
 /// The maximum bytes that can be sent across the RPC.
 const MAX_RPC_SIZE: usize = 4_194_304; // 4M
 /// The protocol prefix the RPC protocol id.
-const PROTOCOL_PREFIX: &str = "/eth/serenity/rpc/";
+const PROTOCOL_PREFIX: &str = "/eth2/beacon_node/rpc";
 /// The number of seconds to wait for a request once a protocol has been established before the stream is terminated.
 const REQUEST_TIMEOUT: u64 = 3;
 
@@ -72,16 +72,16 @@ impl ProtocolId {
     pub fn from_bytes(bytes: &[u8]) -> Result<Self, RPCError> {
         let protocol_string = String::from_utf8(bytes.to_vec())
             .map_err(|_| RPCError::InvalidProtocol("Invalid protocol Id"))?;
-        let protocol_list: Vec<&str> = protocol_string.as_str().split('/').take(5).collect();
+        let protocol_list: Vec<&str> = protocol_string.as_str().split('/').take(7).collect();
 
-        if protocol_list.len() != 5 {
+        if protocol_list.len() != 7 {
             return Err(RPCError::InvalidProtocol("Not enough '/'"));
         }
 
         Ok(ProtocolId {
-            message_name: protocol_list[3].into(),
-            version: protocol_list[4].into(),
-            encoding: protocol_list[5].into(),
+            message_name: protocol_list[4].into(),
+            version: protocol_list[5].into(),
+            encoding: protocol_list[6].into(),
         })
     }
 }