change InboundUpgrade function to use new rpcs. fmt. add test for LightClientFinalityUpdate

Author: GeemoCandama

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

@@ -16,9 +16,9 @@ use std::marker::PhantomData;
 use std::sync::Arc;
 use tokio_util::codec::{Decoder, Encoder};
 use types::{
-    LightClientBootstrap, EthSpec, ForkContext, ForkName, Hash256,
-    LightClientFinalityUpdate, LightClientOptimisticUpdate, SignedBeaconBlock,
-    SignedBeaconBlockAltair, SignedBeaconBlockBase, SignedBeaconBlockMerge, SignedBeaconBlockCapella,
+    EthSpec, ForkContext, ForkName, Hash256, LightClientBootstrap, LightClientFinalityUpdate,
+    LightClientOptimisticUpdate, SignedBeaconBlock, SignedBeaconBlockAltair, SignedBeaconBlockBase,
+    SignedBeaconBlockCapella, SignedBeaconBlockMerge,
 };
 use unsigned_varint::codec::Uvi;
 
@@ -488,12 +488,10 @@ fn handle_v1_request<T: EthSpec>(
                 root: Hash256::from_ssz_bytes(decoded_buffer)?,
             },
         ))),
-        Protocol::LightClientOptimisticUpdate => Ok(Some(
-            InboundRequest::LightClientOptimisticUpdate,
-        )),
-        Protocol::LightClientFinalityUpdate => Ok(Some(
-                InboundRequest::LightClientFinalityUpdate,
-        )),
+        Protocol::LightClientOptimisticUpdate => {
+            Ok(Some(InboundRequest::LightClientOptimisticUpdate))
+        }
+        Protocol::LightClientFinalityUpdate => Ok(Some(InboundRequest::LightClientFinalityUpdate)),
         // MetaData requests return early from InboundUpgrade and do not reach the decoder.
         // Handle this case just for completeness.
         Protocol::MetaData => {

beacon_node/lighthouse_network/src/rpc/config.rs

@@ -141,7 +141,11 @@ impl FromStr for OutboundRateLimiterConfig {
                 Protocol::MetaData => meta_data_quota = meta_data_quota.or(quota),
                 Protocol::LightClientBootstrap
                 | Protocol::LightClientOptimisticUpdate
-                | Protocol::LightClientFinalityUpdate => return Err("Lighthouse does not send LightClient requests. Quota should not be set."),
+                | Protocol::LightClientFinalityUpdate => {
+                    return Err(
+                        "Lighthouse does not send LightClient requests. Quota should not be set.",
+                    )
+                }
             }
         }
         Ok(OutboundRateLimiterConfig {

beacon_node/lighthouse_network/src/rpc/methods.rs

@@ -13,8 +13,8 @@ use std::sync::Arc;
 use strum::IntoStaticStr;
 use superstruct::superstruct;
 use types::{
-    LightClientBootstrap, Epoch, EthSpec, Hash256,
-    LightClientFinalityUpdate, LightClientOptimisticUpdate, SignedBeaconBlock, Slot,
+    Epoch, EthSpec, Hash256, LightClientBootstrap, LightClientFinalityUpdate,
+    LightClientOptimisticUpdate, SignedBeaconBlock, Slot,
 };
 
 /// Maximum number of blocks in a single request.

beacon_node/lighthouse_network/src/rpc/mod.rs

@@ -24,18 +24,16 @@ pub(crate) use protocol::InboundRequest;
 
 pub use codec::{BaseOutboundCodec, OutboundCodec, SSZSnappyOutboundCodec};
 pub use handler::{
-    HandlerErr, HandlerEvent, HandlerState,
-    OutboundInfo, OutboundSubstreamState, RPCHandler, SubstreamId,
+    HandlerErr, HandlerEvent, HandlerState, OutboundInfo, OutboundSubstreamState, RPCHandler,
+    SubstreamId,
 };
 pub use methods::{
-    BlocksByRangeRequest, BlocksByRootRequest, GoodbyeReason, LightClientBootstrapRequest, MaxRequestBlocks,
-    RPCResponseErrorCode, ResponseTermination, StatusMessage, MAX_REQUEST_BLOCKS,
+    BlocksByRangeRequest, BlocksByRootRequest, GoodbyeReason, LightClientBootstrapRequest,
+    MaxRequestBlocks, RPCResponseErrorCode, ResponseTermination, StatusMessage, MAX_REQUEST_BLOCKS,
 };
 pub use outbound::OutboundFramed;
 pub use outbound::OutboundRequest;
-pub use protocol::{
-    max_rpc_size, Encoding, Protocol, ProtocolId, RPCError, RPCProtocol, Version,
-};
+pub use protocol::{max_rpc_size, Encoding, Protocol, ProtocolId, RPCError, RPCProtocol, Version};
 
 use self::config::OutboundRateLimiterConfig;
 use self::self_limiter::SelfRateLimiter;

beacon_node/lighthouse_network/src/rpc/outbound.rs

@@ -122,9 +122,7 @@ impl<TSpec: EthSpec> OutboundRequest<TSpec> {
             OutboundRequest::Ping(_) => Protocol::Ping,
             OutboundRequest::MetaData(_) => Protocol::MetaData,
             OutboundRequest::LightClientBootstrap(_) => Protocol::LightClientBootstrap,
-            OutboundRequest::LightClientOptimisticUpdate => {
-                Protocol::LightClientOptimisticUpdate
-            }
+            OutboundRequest::LightClientOptimisticUpdate => Protocol::LightClientOptimisticUpdate,
             OutboundRequest::LightClientFinalityUpdate => Protocol::LightClientFinalityUpdate,
         }
     }

beacon_node/lighthouse_network/src/rpc/protocol.rs

@@ -22,8 +22,9 @@ use tokio_util::{
 };
 use types::{
     BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockCapella, BeaconBlockMerge,
-    EmptyBlock, EthSpec, ForkContext, ForkName, Hash256, MainnetEthSpec, Signature,
-    SignedBeaconBlock, LightClientFinalityUpdate, LightClientOptimisticUpdate, LightClientBootstrap,
+    EmptyBlock, EthSpec, ForkContext, ForkName, Hash256, LightClientBootstrap,
+    LightClientFinalityUpdate, LightClientOptimisticUpdate, MainnetEthSpec, Signature,
+    SignedBeaconBlock,
 };
 
 lazy_static! {
@@ -444,6 +445,12 @@ where
             // MetaData requests should be empty, return the stream
             match protocol_name {
                 Protocol::MetaData => Ok((InboundRequest::MetaData(PhantomData), socket)),
+                Protocol::LightClientOptimisticUpdate => {
+                    Ok((InboundRequest::LightClientOptimisticUpdate, socket))
+                }
+                Protocol::LightClientFinalityUpdate => {
+                    Ok((InboundRequest::LightClientFinalityUpdate, socket))
+                }
                 _ => {
                     match tokio::time::timeout(
                         Duration::from_secs(REQUEST_TIMEOUT),

beacon_node/lighthouse_network/src/rpc/self_limiter.rs

@@ -73,7 +73,10 @@ impl<Id: ReqId, TSpec: EthSpec> SelfRateLimiter<Id, TSpec> {
             // inbound and outbound requests, and the LightClientBootstrap is an only inbound
             // protocol.
             .one_every(Protocol::LightClientBootstrap, Duration::from_secs(10))
-            .one_every(Protocol::LightClientOptimisticUpdate, Duration::from_secs(10))
+            .one_every(
+                Protocol::LightClientOptimisticUpdate,
+                Duration::from_secs(10),
+            )
             .one_every(Protocol::LightClientFinalityUpdate, Duration::from_secs(10))
             .build()?;
 

beacon_node/lighthouse_network/src/service/api_types.rs

@@ -2,8 +2,8 @@ use std::sync::Arc;
 
 use libp2p::core::connection::ConnectionId;
 use types::{
-    LightClientBootstrap, EthSpec, LightClientFinalityUpdate,
-    LightClientOptimisticUpdate, SignedBeaconBlock,
+    EthSpec, LightClientBootstrap, LightClientFinalityUpdate, LightClientOptimisticUpdate,
+    SignedBeaconBlock,
 };
 
 use crate::rpc::{
@@ -57,12 +57,8 @@ impl<TSpec: EthSpec> std::convert::From<Request> for OutboundRequest<TSpec> {
                 })
             }
             Request::LightClientBootstrap(b) => OutboundRequest::LightClientBootstrap(b),
-            Request::LightClientOptimisticUpdate => {
-                OutboundRequest::LightClientOptimisticUpdate
-            }
-            Request::LightClientFinalityUpdate => {
-                OutboundRequest::LightClientFinalityUpdate
-            }
+            Request::LightClientOptimisticUpdate => OutboundRequest::LightClientOptimisticUpdate,
+            Request::LightClientFinalityUpdate => OutboundRequest::LightClientFinalityUpdate,
             Request::Status(s) => OutboundRequest::Status(s),
         }
     }

beacon_node/lighthouse_network/tests/common/mock_light_client.rs

@@ -4,7 +4,7 @@ use futures::future::BoxFuture;
 use futures::prelude::*;
 use libp2p::core::connection::ConnectionId;
 use libp2p::core::upgrade::{NegotiationError, ProtocolError};
-use libp2p::core::{UpgradeError, UpgradeInfo, PeerId};
+use libp2p::core::{PeerId, UpgradeError, UpgradeInfo};
 use libp2p::multiaddr::{Multiaddr, Protocol as MProtocol};
 use libp2p::swarm::handler::SubstreamProtocol;
 use libp2p::swarm::{
@@ -15,13 +15,12 @@ use libp2p::swarm::{NotifyHandler, PollParameters, SwarmBuilder, SwarmEvent};
 use libp2p::OutboundUpgrade;
 use lighthouse_network::rpc::methods::RPCCodedResponse;
 use lighthouse_network::rpc::{
-    max_rpc_size, BaseOutboundCodec, Encoding, GoodbyeReason,
-    HandlerErr, HandlerEvent, HandlerState,
-    OutboundCodec, OutboundFramed, OutboundInfo, OutboundRequest, OutboundSubstreamState, Protocol,
-    ProtocolId, RPCError, RPCMessage, RPCProtocol, RPCReceived, RPCSend,
-    ReqId, SSZSnappyOutboundCodec, SubstreamId, Version,
+    max_rpc_size, BaseOutboundCodec, Encoding, GoodbyeReason, HandlerErr, HandlerEvent,
+    HandlerState, OutboundCodec, OutboundFramed, OutboundInfo, OutboundRequest,
+    OutboundSubstreamState, Protocol, ProtocolId, RPCError, RPCMessage, RPCProtocol, RPCReceived,
+    RPCSend, ReqId, SSZSnappyOutboundCodec, SubstreamId, Version,
 };
-use lighthouse_network::{error, Request, NetworkConfig};
+use lighthouse_network::{error, NetworkConfig, Request};
 use slog::{crit, debug, o, trace};
 use smallvec::SmallVec;
 use std::collections::hash_map::Entry;
@@ -35,7 +34,7 @@ use tokio::time::Instant as TInstant;
 use tokio_util::{codec::Framed, compat::FuturesAsyncReadCompatExt, time::DelayQueue};
 use types::{EthSpec, ForkContext};
 
-use lighthouse_network::{build_transport, Context as ServiceContext, };
+use lighthouse_network::{build_transport, Context as ServiceContext};
 
 /// The time (in seconds) before a substream that is awaiting a response from the user times out.
 pub const RESPONSE_TIMEOUT: u64 = 10;
@@ -470,7 +469,7 @@ where
         match rpc_event {
             RPCSend::Request(id, req) => self.send_request(id, req),
             RPCSend::Shutdown(id, reason) => self.shutdown(Some((id, reason))),
-            _ => {},
+            _ => {}
         }
         // In any case, we need the handler to process the event.
         if let Some(waker) = &self.waker {