Light client updates by range RPC

beacon_node/beacon_processor/src/lib.rs

@@ -130,6 +130,7 @@ pub struct BeaconProcessorQueueLengths {
     lc_bootstrap_queue: usize,
     lc_optimistic_update_queue: usize,
     lc_finality_update_queue: usize,
+    lc_update_range_queue: usize,
     api_request_p0_queue: usize,
     api_request_p1_queue: usize,
 }
@@ -191,6 +192,7 @@ impl BeaconProcessorQueueLengths {
             lc_bootstrap_queue: 1024,
             lc_optimistic_update_queue: 512,
             lc_finality_update_queue: 512,
+            lc_update_range_queue: 512,
             api_request_p0_queue: 1024,
             api_request_p1_queue: 1024,
         })
@@ -611,6 +613,7 @@ pub enum Work<E: EthSpec> {
     LightClientBootstrapRequest(BlockingFn),
     LightClientOptimisticUpdateRequest(BlockingFn),
     LightClientFinalityUpdateRequest(BlockingFn),
+    LightClientUpdatesByRangeRequest(BlockingFn),
     ApiRequestP0(BlockingOrAsync),
     ApiRequestP1(BlockingOrAsync),
 }
@@ -662,6 +665,7 @@ pub enum WorkType {
     LightClientBootstrapRequest,
     LightClientOptimisticUpdateRequest,
     LightClientFinalityUpdateRequest,
+    LightClientUpdatesByRangeRequest,
     ApiRequestP0,
     ApiRequestP1,
 }
@@ -712,6 +716,7 @@ impl<E: EthSpec> Work<E> {
                 WorkType::LightClientOptimisticUpdateRequest
             }
             Work::LightClientFinalityUpdateRequest(_) => WorkType::LightClientFinalityUpdateRequest,
+            Work::LightClientUpdatesByRangeRequest(_) => WorkType::LightClientUpdatesByRangeRequest,
             Work::UnknownBlockAttestation { .. } => WorkType::UnknownBlockAttestation,
             Work::UnknownBlockAggregate { .. } => WorkType::UnknownBlockAggregate,
             Work::UnknownBlockSamplingRequest { .. } => WorkType::UnknownBlockSamplingRequest,
@@ -891,6 +896,7 @@ impl<E: EthSpec> BeaconProcessor<E> {
         let mut lc_optimistic_update_queue =
             FifoQueue::new(queue_lengths.lc_optimistic_update_queue);
         let mut lc_finality_update_queue = FifoQueue::new(queue_lengths.lc_finality_update_queue);
+        let mut lc_update_range_queue = FifoQueue::new(queue_lengths.lc_update_range_queue);
 
         let mut api_request_p0_queue = FifoQueue::new(queue_lengths.api_request_p0_queue);
         let mut api_request_p1_queue = FifoQueue::new(queue_lengths.api_request_p1_queue);
@@ -1368,6 +1374,9 @@ impl<E: EthSpec> BeaconProcessor<E> {
                             Work::LightClientFinalityUpdateRequest { .. } => {
                                 lc_finality_update_queue.push(work, work_id, &self.log)
                             }
+                            Work::LightClientUpdatesByRangeRequest { .. } => {
+                                lc_update_range_queue.push(work, work_id, &self.log)
+                            }
                             Work::UnknownBlockAttestation { .. } => {
                                 unknown_block_attestation_queue.push(work)
                             }
@@ -1459,6 +1468,7 @@ impl<E: EthSpec> BeaconProcessor<E> {
                         WorkType::LightClientFinalityUpdateRequest => {
                             lc_finality_update_queue.len()
                         }
+                        WorkType::LightClientUpdatesByRangeRequest => lc_update_range_queue.len(),
                         WorkType::ApiRequestP0 => api_request_p0_queue.len(),
                         WorkType::ApiRequestP1 => api_request_p1_queue.len(),
                     };
@@ -1611,7 +1621,8 @@ impl<E: EthSpec> BeaconProcessor<E> {
             | Work::GossipBlsToExecutionChange(process_fn)
             | Work::LightClientBootstrapRequest(process_fn)
             | Work::LightClientOptimisticUpdateRequest(process_fn)
-            | Work::LightClientFinalityUpdateRequest(process_fn) => {
+            | Work::LightClientFinalityUpdateRequest(process_fn)
+            | Work::LightClientUpdatesByRangeRequest(process_fn) => {
                 task_spawner.spawn_blocking(process_fn)
             }
         };

beacon_node/lighthouse_network/src/peer_manager/mod.rs

@@ -572,6 +572,7 @@ impl<E: EthSpec> PeerManager<E> {
                     Protocol::LightClientBootstrap => return,
                     Protocol::LightClientOptimisticUpdate => return,
                     Protocol::LightClientFinalityUpdate => return,
+                    Protocol::LightClientUpdatesByRange => return,
                     Protocol::BlobsByRoot => PeerAction::MidToleranceError,
                     Protocol::DataColumnsByRoot => PeerAction::MidToleranceError,
                     Protocol::DataColumnsByRange => PeerAction::MidToleranceError,
@@ -599,6 +600,7 @@ impl<E: EthSpec> PeerManager<E> {
                     Protocol::LightClientBootstrap => return,
                     Protocol::LightClientOptimisticUpdate => return,
                     Protocol::LightClientFinalityUpdate => return,
+                    Protocol::LightClientUpdatesByRange => return,
                     Protocol::MetaData => PeerAction::Fatal,
                     Protocol::Status => PeerAction::Fatal,
                 }
@@ -620,6 +622,7 @@ impl<E: EthSpec> PeerManager<E> {
                     Protocol::LightClientBootstrap => return,
                     Protocol::LightClientOptimisticUpdate => return,
                     Protocol::LightClientFinalityUpdate => return,
+                    Protocol::LightClientUpdatesByRange => return,
                     Protocol::Goodbye => return,
                     Protocol::MetaData => return,
                     Protocol::Status => return,

beacon_node/lighthouse_network/src/rpc/codec.rs

@@ -18,9 +18,9 @@ use tokio_util::codec::{Decoder, Encoder};
 use types::{
     BlobSidecar, ChainSpec, DataColumnSidecar, EthSpec, ForkContext, ForkName, Hash256,
     LightClientBootstrap, LightClientFinalityUpdate, LightClientOptimisticUpdate,
-    RuntimeVariableList, SignedBeaconBlock, SignedBeaconBlockAltair, SignedBeaconBlockBase,
-    SignedBeaconBlockBellatrix, SignedBeaconBlockCapella, SignedBeaconBlockDeneb,
-    SignedBeaconBlockElectra,
+    LightClientUpdate, RuntimeVariableList, SignedBeaconBlock, SignedBeaconBlockAltair,
+    SignedBeaconBlockBase, SignedBeaconBlockBellatrix, SignedBeaconBlockCapella,
+    SignedBeaconBlockDeneb, SignedBeaconBlockElectra,
 };
 use unsigned_varint::codec::Uvi;
 
@@ -76,6 +76,7 @@ impl<E: EthSpec> SSZSnappyInboundCodec<E> {
                 RPCResponse::LightClientBootstrap(res) => res.as_ssz_bytes(),
                 RPCResponse::LightClientOptimisticUpdate(res) => res.as_ssz_bytes(),
                 RPCResponse::LightClientFinalityUpdate(res) => res.as_ssz_bytes(),
+                RPCResponse::LightClientUpdatesByRange(res) => res.as_ssz_bytes(),
                 RPCResponse::Pong(res) => res.data.as_ssz_bytes(),
                 RPCResponse::MetaData(res) =>
                 // Encode the correct version of the MetaData response based on the negotiated version.
@@ -494,6 +495,10 @@ fn context_bytes<E: EthSpec>(
                     return lc_finality_update
                         .map_with_fork_name(|fork_name| fork_context.to_context_bytes(fork_name));
                 }
+                RPCResponse::LightClientUpdatesByRange(lc_update) => {
+                    return lc_update
+                        .map_with_fork_name(|fork_name| fork_context.to_context_bytes(fork_name));
+                }
                 // These will not pass the has_context_bytes() check
                 RPCResponse::Status(_) | RPCResponse::Pong(_) | RPCResponse::MetaData(_) => {
                     return None;
@@ -602,6 +607,11 @@ fn handle_rpc_request<E: EthSpec>(
         SupportedProtocol::LightClientFinalityUpdateV1 => {
             Ok(Some(InboundRequest::LightClientFinalityUpdate))
         }
+        SupportedProtocol::LightClientUpdatesByRangeV1 => {
+            Ok(Some(InboundRequest::LightClientUpdatesByRange(
+                LightClientUpdatesByRangeRequest::from_ssz_bytes(decoded_buffer)?,
+            )))
+        }
         // MetaData requests return early from InboundUpgrade and do not reach the decoder.
         // Handle this case just for completeness.
         SupportedProtocol::MetaDataV3 => {
@@ -776,6 +786,18 @@ fn handle_rpc_response<E: EthSpec>(
                 ),
             )),
         },
+        SupportedProtocol::LightClientUpdatesByRangeV1 => match fork_name {
+            Some(fork_name) => Ok(Some(RPCResponse::LightClientUpdatesByRange(Arc::new(
+                LightClientUpdate::from_ssz_bytes(decoded_buffer, &fork_name)?,
+            )))),
+            None => Err(RPCError::ErrorResponse(
+                RPCResponseErrorCode::InvalidRequest,
+                format!(
+                    "No context bytes provided for {:?} response",
+                    versioned_protocol
+                ),
+            )),
+        },
         // MetaData V2/V3 responses have no context bytes, so behave similarly to V1 responses
         SupportedProtocol::MetaDataV3 => Ok(Some(RPCResponse::MetaData(MetaData::V3(
             MetaDataV3::from_ssz_bytes(decoded_buffer)?,

beacon_node/lighthouse_network/src/rpc/config.rs

@@ -96,6 +96,7 @@ pub struct RateLimiterConfig {
     pub(super) light_client_bootstrap_quota: Quota,
     pub(super) light_client_optimistic_update_quota: Quota,
     pub(super) light_client_finality_update_quota: Quota,
+    pub(super) light_client_updates_by_range_quota: Quota,
 }
 
 impl RateLimiterConfig {
@@ -121,6 +122,7 @@ impl RateLimiterConfig {
     pub const DEFAULT_LIGHT_CLIENT_BOOTSTRAP_QUOTA: Quota = Quota::one_every(10);
     pub const DEFAULT_LIGHT_CLIENT_OPTIMISTIC_UPDATE_QUOTA: Quota = Quota::one_every(10);
     pub const DEFAULT_LIGHT_CLIENT_FINALITY_UPDATE_QUOTA: Quota = Quota::one_every(10);
+    pub const DEFAULT_LIGHT_CLIENT_UPDATES_BY_RANGE_QUOTA: Quota = Quota::one_every(10);
 }
 
 impl Default for RateLimiterConfig {
@@ -140,6 +142,7 @@ impl Default for RateLimiterConfig {
             light_client_optimistic_update_quota:
                 Self::DEFAULT_LIGHT_CLIENT_OPTIMISTIC_UPDATE_QUOTA,
             light_client_finality_update_quota: Self::DEFAULT_LIGHT_CLIENT_FINALITY_UPDATE_QUOTA,
+            light_client_updates_by_range_quota: Self::DEFAULT_LIGHT_CLIENT_UPDATES_BY_RANGE_QUOTA,
         }
     }
 }
@@ -198,6 +201,7 @@ impl FromStr for RateLimiterConfig {
         let mut light_client_bootstrap_quota = None;
         let mut light_client_optimistic_update_quota = None;
         let mut light_client_finality_update_quota = None;
+        let mut light_client_updates_by_range_quota = None;
 
         for proto_def in s.split(';') {
             let ProtocolQuota { protocol, quota } = proto_def.parse()?;
@@ -228,6 +232,10 @@ impl FromStr for RateLimiterConfig {
                     light_client_finality_update_quota =
                         light_client_finality_update_quota.or(quota)
                 }
+                Protocol::LightClientUpdatesByRange => {
+                    light_client_updates_by_range_quota =
+                        light_client_updates_by_range_quota.or(quota)
+                }
             }
         }
         Ok(RateLimiterConfig {
@@ -252,6 +260,8 @@ impl FromStr for RateLimiterConfig {
                 .unwrap_or(Self::DEFAULT_LIGHT_CLIENT_OPTIMISTIC_UPDATE_QUOTA),
             light_client_finality_update_quota: light_client_finality_update_quota
                 .unwrap_or(Self::DEFAULT_LIGHT_CLIENT_FINALITY_UPDATE_QUOTA),
+            light_client_updates_by_range_quota: light_client_updates_by_range_quota
+                .unwrap_or(Self::DEFAULT_LIGHT_CLIENT_UPDATES_BY_RANGE_QUOTA),
         })
     }
 }

beacon_node/lighthouse_network/src/rpc/methods.rs

@@ -14,6 +14,7 @@ use std::sync::Arc;
 use strum::IntoStaticStr;
 use superstruct::superstruct;
 use types::blob_sidecar::BlobIdentifier;
+use types::LightClientUpdate;
 use types::{
     blob_sidecar::BlobSidecar, ChainSpec, ColumnIndex, DataColumnIdentifier, DataColumnSidecar,
     Epoch, EthSpec, Hash256, LightClientBootstrap, LightClientFinalityUpdate,
@@ -24,6 +25,10 @@ use types::{
 pub type MaxErrorLen = U256;
 pub const MAX_ERROR_LEN: u64 = 256;
 
+// Max light client updates by range request limits
+// spec: https://github.com/ethereum/consensus-specs/blob/dev/specs/altair/light-client/p2p-interface.md#configuration
+pub const MAX_REQUEST_LIGHT_CLIENT_UPDATES: u64 = 128;
+
 /// Wrapper over SSZ List to represent error message in rpc responses.
 #[derive(Debug, Clone)]
 pub struct ErrorType(pub VariableList<u8, MaxErrorLen>);
@@ -477,6 +482,39 @@ impl DataColumnsByRootRequest {
     }
 }
 
+/// Request a number of beacon data columns from a peer.
+#[derive(Encode, Decode, Clone, Debug, PartialEq)]
+pub struct LightClientUpdatesByRangeRequest {
+    /// The starting period to request light client updates.
+    pub start_period: u64,
+    /// The number of periods from `start_period`.
+    pub count: u64,
+}
+
+impl LightClientUpdatesByRangeRequest {
+    pub fn max_requested<E: EthSpec>(&self) -> u64 {
+        MAX_REQUEST_LIGHT_CLIENT_UPDATES
+    }
+
+    pub fn ssz_min_len() -> usize {
+        LightClientUpdatesByRangeRequest {
+            start_period: 0,
+            count: 0,
+        }
+        .as_ssz_bytes()
+        .len()
+    }
+
+    pub fn ssz_max_len() -> usize {
+        LightClientUpdatesByRangeRequest {
+            start_period: 0,
+            count: 0,
+        }
+        .as_ssz_bytes()
+        .len()
+    }
+}
+
 /* RPC Handling and Grouping */
 // Collection of enums and structs used by the Codecs to encode/decode RPC messages
 
@@ -504,6 +542,9 @@ pub enum RPCResponse<E: EthSpec> {
     /// A response to a get LIGHT_CLIENT_FINALITY_UPDATE request.
     LightClientFinalityUpdate(Arc<LightClientFinalityUpdate<E>>),
 
+    /// A response to a get LIGHT_CLIENT_UPDATES_BY_RANGE request.
+    LightClientUpdatesByRange(Arc<LightClientUpdate<E>>),
+
     /// A response to a get BLOBS_BY_ROOT request.
     BlobsByRoot(Arc<BlobSidecar<E>>),
 
@@ -540,6 +581,9 @@ pub enum ResponseTermination {
 
     /// Data column sidecars by range stream termination.
     DataColumnsByRange,
+
+    /// Light client updates by range stream termination.
+    LightClientUpdatesByRange,
 }
 
 /// The structured response containing a result/code indicating success or failure
@@ -637,6 +681,7 @@ impl<E: EthSpec> RPCResponse<E> {
             RPCResponse::LightClientBootstrap(_) => Protocol::LightClientBootstrap,
             RPCResponse::LightClientOptimisticUpdate(_) => Protocol::LightClientOptimisticUpdate,
             RPCResponse::LightClientFinalityUpdate(_) => Protocol::LightClientFinalityUpdate,
+            RPCResponse::LightClientUpdatesByRange(_) => Protocol::LightClientUpdatesByRange,
         }
     }
 }
@@ -706,6 +751,13 @@ impl<E: EthSpec> std::fmt::Display for RPCResponse<E> {
                     update.signature_slot()
                 )
             }
+            RPCResponse::LightClientUpdatesByRange(update) => {
+                write!(
+                    f,
+                    "LightClientUpdatesByRange Slot: {}",
+                    update.signature_slot(),
+                )
+            }
         }
     }
 }

beacon_node/lighthouse_network/src/rpc/mod.rs

@@ -479,6 +479,9 @@ where
                             ResponseTermination::BlobsByRoot => Protocol::BlobsByRoot,
                             ResponseTermination::DataColumnsByRoot => Protocol::DataColumnsByRoot,
                             ResponseTermination::DataColumnsByRange => Protocol::DataColumnsByRange,
+                            ResponseTermination::LightClientUpdatesByRange => {
+                                Protocol::LightClientUpdatesByRange
+                            }
                         },
                     ),
                 };