Support LightClientFinalityUpdate and LightClientOptimisticUpdate rpcs

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

@@ -16,12 +16,10 @@ use std::marker::PhantomData;
 use std::sync::Arc;
 use tokio_util::codec::{Decoder, Encoder};
 use types::{
-    BlobSidecar, EthSpec, ForkContext, ForkName, Hash256, RuntimeVariableList, SignedBeaconBlock,
+    BlobSidecar, ChainSpec, EthSpec, ForkContext, ForkName, Hash256, LightClientBootstrap,
+    LightClientFinalityUpdate, LightClientOptimisticUpdate, RuntimeVariableList, SignedBeaconBlock,
     SignedBeaconBlockAltair, SignedBeaconBlockBase, SignedBeaconBlockCapella,
-    SignedBeaconBlockDeneb, SignedBeaconBlockMerge,
-};
-use types::{
-    ChainSpec, LightClientBootstrap, LightClientFinalityUpdate, LightClientOptimisticUpdate,
+    SignedBeaconBlockDeneb, SignedBeaconBlockElectra, SignedBeaconBlockMerge,
 };
 use unsigned_varint::codec::Uvi;
 
@@ -396,6 +394,9 @@ fn context_bytes<E: EthSpec>(
                     return match **ref_box_block {
                         // NOTE: If you are adding another fork type here, be sure to modify the
                         //       `fork_context.to_context_bytes()` function to support it as well!
+                        SignedBeaconBlock::Electra { .. } => {
+                            fork_context.to_context_bytes(ForkName::Electra)
+                        }
                         SignedBeaconBlock::Deneb { .. } => {
                             fork_context.to_context_bytes(ForkName::Deneb)
                         }

beacon_node/lighthouse_network/src/rpc/methods.rs

@@ -392,10 +392,10 @@ pub enum RPCResponse<E: EthSpec> {
     LightClientBootstrap(Arc<LightClientBootstrap<E>>),
 
     /// A response to a get LIGHT_CLIENT_OPTIMISTIC_UPDATE request.
-    LightClientOptimisticUpdate(Arc<LightClientOptimisticUpdate<T>>),
+    LightClientOptimisticUpdate(Arc<LightClientOptimisticUpdate<E>>),
 
     /// A response to a get LIGHT_CLIENT_FINALITY_UPDATE request.
-    LightClientFinalityUpdate(Arc<LightClientFinalityUpdate<T>>),
+    LightClientFinalityUpdate(Arc<LightClientFinalityUpdate<E>>),
 
     /// A response to a get BLOBS_BY_ROOT request.
     BlobsByRoot(Arc<BlobSidecar<E>>),

beacon_node/lighthouse_network/src/rpc/protocol.rs

@@ -17,9 +17,10 @@ use tokio_util::{
     compat::{Compat, FuturesAsyncReadCompatExt},
 };
 use types::{
-    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockCapella, BeaconBlockMerge,
-    BlobSidecar, ChainSpec, EmptyBlock, EthSpec, ForkContext, ForkName, LightClientBootstrap,
-    LightClientFinalityUpdate, LightClientFinalityUpdateAltair, LightClientOptimisticUpdate,
+    BeaconBlock, BeaconBlockAltair, BeaconBlockBase, BeaconBlockCapella, BeaconBlockElectra,
+    BeaconBlockMerge, BlobSidecar, ChainSpec, EmptyBlock, EthSpec, ForkContext, ForkName,
+    LightClientBootstrap, LightClientBootstrapAltair, LightClientFinalityUpdate,
+    LightClientFinalityUpdateAltair, LightClientOptimisticUpdate,
     LightClientOptimisticUpdateAltair, MainnetEthSpec, Signature, SignedBeaconBlock,
 };
 
@@ -169,6 +170,24 @@ pub fn rpc_block_limits_by_fork(current_fork: ForkName) -> RpcLimits {
     }
 }
 
+#[test]
+fn test_limits() {
+    for fork in ForkName::list_all() {
+        println!(
+            "rpc_light_client_finality_update_limits_by_fork: {:?}",
+            rpc_light_client_finality_update_limits_by_fork(fork)
+        );
+        println!(
+            "rpc_light_client_optimistic_update_limits_by_fork: {:?}",
+            rpc_light_client_optimistic_update_limits_by_fork(fork)
+        );
+        println!(
+            "rpc_light_client_bootstrap_limits_by_fork: {:?}",
+            rpc_light_client_bootstrap_limits_by_fork(fork)
+        );
+    }
+}
+
 fn rpc_light_client_finality_update_limits_by_fork(current_fork: ForkName) -> RpcLimits {
     let altair_fixed_len = LightClientFinalityUpdateAltair::<MainnetEthSpec>::ssz_fixed_len();
 
@@ -181,6 +200,9 @@ fn rpc_light_client_finality_update_limits_by_fork(current_fork: ForkName) -> Rp
         ForkName::Deneb => {
             RpcLimits::new(altair_fixed_len, *LIGHT_CLIENT_FINALITY_UPDATE_DENEB_MAX)
         }
+        ForkName::Electra => {
+            unimplemented!("Electra not implemented")
+        }
     }
 }
 
@@ -197,17 +219,23 @@ fn rpc_light_client_optimistic_update_limits_by_fork(current_fork: ForkName) ->
         ForkName::Deneb => {
             RpcLimits::new(altair_fixed_len, *LIGHT_CLIENT_OPTIMISTIC_UPDATE_DENEB_MAX)
         }
+        ForkName::Electra => {
+            unimplemented!("Electra not implemented")
+        }
     }
 }
 
 fn rpc_light_client_bootstrap_limits_by_fork(current_fork: ForkName) -> RpcLimits {
-    let altair_fixed_len = LightClientBootstrap::<MainnetEthSpec>::ssz_fixed_len();
+    let altair_fixed_len = LightClientBootstrapAltair::<MainnetEthSpec>::ssz_fixed_len();
 
     match &current_fork {
         ForkName::Base => RpcLimits::new(0, 0),
         ForkName::Altair | ForkName::Merge => RpcLimits::new(altair_fixed_len, altair_fixed_len),
         ForkName::Capella => RpcLimits::new(altair_fixed_len, *LIGHT_CLIENT_BOOTSTRAP_CAPELLA_MAX),
         ForkName::Deneb => RpcLimits::new(altair_fixed_len, *LIGHT_CLIENT_BOOTSTRAP_DENEB_MAX),
+        ForkName::Electra => {
+            unimplemented!("Electra not implemented")
+        }
     }
 }
 

beacon_node/lighthouse_network/src/service/api_types.rs

@@ -102,11 +102,11 @@ pub enum Response<E: EthSpec> {
     /// A response to a get BLOBS_BY_ROOT request.
     BlobsByRoot(Option<Arc<BlobSidecar<E>>>),
     /// A response to a LightClientUpdate request.
-    LightClientBootstrap(Arc<LightClientBootstrap<TSpec>>),
+    LightClientBootstrap(Arc<LightClientBootstrap<E>>),
     /// A response to a LightClientOptimisticUpdate request.
-    LightClientOptimisticUpdate(Arc<LightClientOptimisticUpdate<TSpec>>),
+    LightClientOptimisticUpdate(Arc<LightClientOptimisticUpdate<E>>),
     /// A response to a LightClientFinalityUpdate request.
-    LightClientFinalityUpdate(Arc<LightClientFinalityUpdate<TSpec>>),
+    LightClientFinalityUpdate(Arc<LightClientFinalityUpdate<E>>),
 }
 
 impl<E: EthSpec> std::convert::From<Response<E>> for RPCCodedResponse<E> {

consensus/state_processing/src/per_epoch_processing/registry_updates.rs

@@ -56,8 +56,8 @@ pub fn process_registry_updates<E: EthSpec>(
     Ok(())
 }
 
-pub fn process_registry_updates_slow<T: EthSpec>(
-    state: &mut BeaconState<T>,
+pub fn process_registry_updates_slow<E: EthSpec>(
+    state: &mut BeaconState<E>,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     process_epoch_single_pass(

consensus/state_processing/src/per_epoch_processing/slashings.rs

@@ -47,8 +47,8 @@ pub fn process_slashings<E: EthSpec>(
     Ok(())
 }
 
-pub fn process_slashings_slow<T: EthSpec>(
-    state: &mut BeaconState<T>,
+pub fn process_slashings_slow<E: EthSpec>(
+    state: &mut BeaconState<E>,
     spec: &ChainSpec,
 ) -> Result<(), Error> {
     process_epoch_single_pass(

consensus/types/src/execution_payload_header.rs

@@ -120,7 +120,10 @@ impl<E: EthSpec> ExecutionPayloadHeader<E> {
             | ForkName::Capella
             | ForkName::Deneb => {
                 // Max size of variable length `extra_data` field
-                T::max_extra_data_bytes() * <u8 as Encode>::ssz_fixed_len()
+                E::max_extra_data_bytes() * <u8 as Encode>::ssz_fixed_len()
+            }
+            ForkName::Electra => {
+                unimplemented!("Electra not implemented")
             }
         }
     }

consensus/types/src/light_client_bootstrap.rs

@@ -101,9 +101,12 @@ impl<E: EthSpec> LightClientBootstrap<E> {
         match fork_name {
             ForkName::Base => 0,
             ForkName::Altair | ForkName::Merge | ForkName::Capella | ForkName::Deneb => {
-                <Self as Encode>::ssz_fixed_len()
+                <LightClientBootstrapAltair<E> as Encode>::ssz_fixed_len()
                     + LightClientHeader::<E>::ssz_max_var_len_for_fork(fork_name)
             }
+            ForkName::Electra => {
+                unimplemented!("Electra not implemented")
+            }
         }
     }
 

consensus/types/src/light_client_finality_update.rs

@@ -170,9 +170,12 @@ impl<E: EthSpec> LightClientFinalityUpdate<E> {
         match fork_name {
             ForkName::Base => 0,
             ForkName::Altair | ForkName::Merge | ForkName::Capella | ForkName::Deneb => {
-                <Self as Encode>::ssz_fixed_len()
+                <LightClientFinalityUpdateAltair<E> as Encode>::ssz_fixed_len()
                     + 2 * LightClientHeader::<E>::ssz_max_var_len_for_fork(fork_name)
             }
+            ForkName::Electra => {
+                unimplemented!("Electra not implemented")
+            }
         }
     }
 }

consensus/types/src/light_client_header.rs

@@ -123,6 +123,9 @@ impl<E: EthSpec> LightClientHeader<E> {
             ForkName::Capella | ForkName::Deneb => {
                 ExecutionPayloadHeader::<E>::ssz_max_var_len_for_fork(fork_name)
             }
+            ForkName::Electra => {
+                unimplemented!("Electra not implemented")
+            }
         }
     }
 }

consensus/types/src/light_client_optimistic_update.rs

@@ -155,9 +155,12 @@ impl<E: EthSpec> LightClientOptimisticUpdate<E> {
         match fork_name {
             ForkName::Base => 0,
             ForkName::Altair | ForkName::Merge | ForkName::Capella | ForkName::Deneb => {
-                <Self as Encode>::ssz_fixed_len()
+                <LightClientOptimisticUpdateAltair<E> as Encode>::ssz_fixed_len()
                     + LightClientHeader::<E>::ssz_max_var_len_for_fork(fork_name)
             }
+            ForkName::Electra => {
+                unimplemented!("Electra not implemented")
+            }
         }
     }
 }