Add Capella & Deneb light client support

beacon_node/beacon_chain/src/beacon_chain.rs

@@ -1353,6 +1353,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     ) -> Result<(), Error> {
         self.light_client_server_cache.recompute_and_cache_updates(
             &self.log,
+            &self.spec,
             self.store.clone(),
             &parent_root,
             slot,
@@ -6631,13 +6632,14 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         &self,
         block_root: &Hash256,
     ) -> Result<Option<(LightClientBootstrap<T::EthSpec>, ForkName)>, Error> {
-        let Some((state_root, slot)) = self
-            .get_blinded_block(block_root)?
-            .map(|block| (block.state_root(), block.slot()))
-        else {
+        let runtime = tokio::runtime::Runtime::new().map_err(|_| Error::RuntimeShutdown)?;
+
+        let Some(block) = runtime.block_on(async { self.get_block(block_root).await })? else {
             return Ok(None);
         };
 
+        let (state_root, slot) = (block.state_root(), block.slot());
+
         let Some(mut state) = self.get_state(&state_root, Some(slot))? else {
             return Ok(None);
         };
@@ -6647,12 +6649,12 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .map_err(Error::InconsistentFork)?;
 
         match fork_name {
-            ForkName::Altair | ForkName::Merge => {
-                LightClientBootstrap::from_beacon_state(&mut state)
+            ForkName::Altair | ForkName::Merge | ForkName::Capella | ForkName::Deneb => {
+                LightClientBootstrap::from_beacon_state(&self.spec, &mut state, &block)
                     .map(|bootstrap| Some((bootstrap, fork_name)))
                     .map_err(Error::LightClientError)
             }
-            ForkName::Base | ForkName::Capella | ForkName::Deneb => Err(Error::UnsupportedFork),
+            ForkName::Base => Err(Error::UnsupportedFork),
         }
     }
 }

beacon_node/beacon_chain/src/errors.rs

@@ -250,6 +250,7 @@ easy_from_to!(StateAdvanceError, BeaconChainError);
 easy_from_to!(BlockReplayError, BeaconChainError);
 easy_from_to!(InconsistentFork, BeaconChainError);
 easy_from_to!(AvailabilityCheckError, BeaconChainError);
+easy_from_to!(LightClientError, BeaconChainError);
 
 #[derive(Debug)]
 pub enum BlockProductionError {

beacon_node/beacon_chain/src/light_client_optimistic_update_verification.rs

@@ -67,7 +67,7 @@ impl<T: BeaconChainTypes> VerifiedLightClientOptimisticUpdate<T> {
         // otherwise queue
         let canonical_root = rcv_optimistic_update
             .attested_header
-            .beacon
+            .beacon()
             .canonical_root();
 
         if canonical_root != head_block.message().parent_root() {
@@ -84,7 +84,7 @@ impl<T: BeaconChainTypes> VerifiedLightClientOptimisticUpdate<T> {
             return Err(Error::InvalidLightClientOptimisticUpdate);
         }
 
-        let parent_root = rcv_optimistic_update.attested_header.beacon.parent_root;
+        let parent_root = rcv_optimistic_update.attested_header.beacon().parent_root;
         Ok(Self {
             light_client_optimistic_update: rcv_optimistic_update,
             parent_root,

beacon_node/beacon_chain/src/light_client_server_cache.rs

@@ -4,11 +4,15 @@ use parking_lot::{Mutex, RwLock};
 use slog::{debug, Logger};
 use ssz_types::FixedVector;
 use std::num::NonZeroUsize;
+use types::light_client_header::{
+    LightClientHeaderAltair, LightClientHeaderCapella, LightClientHeaderDeneb,
+};
 use types::light_client_update::{FinalizedRootProofLen, FINALIZED_ROOT_INDEX};
 use types::non_zero_usize::new_non_zero_usize;
 use types::{
-    BeaconBlockRef, BeaconState, ChainSpec, EthSpec, ForkName, Hash256, LightClientFinalityUpdate,
-    LightClientHeader, LightClientOptimisticUpdate, Slot, SyncAggregate,
+    light_client_update::Error as LightClientError, BeaconBlockRef, BeaconState, ChainSpec,
+    EthSpec, ForkName, Hash256, LightClientFinalityUpdate, LightClientHeader,
+    LightClientOptimisticUpdate, SignedBeaconBlock, Slot, SyncAggregate,
 };
 
 /// A prev block cache miss requires to re-generate the state of the post-parent block. Items in the
@@ -72,6 +76,7 @@ impl<T: BeaconChainTypes> LightClientServerCache<T> {
     pub fn recompute_and_cache_updates(
         &self,
         log: &Logger,
+        chain_spec: &ChainSpec,
         store: BeaconStore<T>,
         block_parent_root: &Hash256,
         block_slot: Slot,
@@ -83,12 +88,13 @@ impl<T: BeaconChainTypes> LightClientServerCache<T> {
         let signature_slot = block_slot;
         let attested_block_root = block_parent_root;
 
-        let attested_block = store.get_blinded_block(attested_block_root)?.ok_or(
-            BeaconChainError::DBInconsistent(format!(
-                "Block not available {:?}",
-                attested_block_root
-            )),
-        )?;
+        let attested_block =
+            store
+                .get_full_block(attested_block_root)?
+                .ok_or(BeaconChainError::DBInconsistent(format!(
+                    "Block not available {:?}",
+                    attested_block_root
+                )))?;
 
         let cached_parts = self.get_or_compute_prev_block_cache(
             store.clone(),
@@ -99,6 +105,9 @@ impl<T: BeaconChainTypes> LightClientServerCache<T> {
 
         let attested_slot = attested_block.slot();
 
+        let fork_name =
+            chain_spec.fork_name_at_epoch(attested_slot.epoch(T::EthSpec::slots_per_epoch()));
+
         // Spec: Full nodes SHOULD provide the LightClientOptimisticUpdate with the highest
         // attested_header.beacon.slot (if multiple, highest signature_slot) as selected by fork choice
         let is_latest_optimistic = match &self.latest_optimistic_update.read().clone() {
@@ -110,7 +119,7 @@ impl<T: BeaconChainTypes> LightClientServerCache<T> {
         if is_latest_optimistic {
             // can create an optimistic update, that is more recent
             *self.latest_optimistic_update.write() = Some(LightClientOptimisticUpdate {
-                attested_header: block_to_light_client_header(attested_block.message()),
+                attested_header: block_to_light_client_header(fork_name, &attested_block)?,
                 sync_aggregate: sync_aggregate.clone(),
                 signature_slot,
             });
@@ -127,13 +136,13 @@ impl<T: BeaconChainTypes> LightClientServerCache<T> {
         if is_latest_finality & !cached_parts.finalized_block_root.is_zero() {
             // Immediately after checkpoint sync the finalized block may not be available yet.
             if let Some(finalized_block) =
-                store.get_blinded_block(&cached_parts.finalized_block_root)?
+                store.get_full_block(&cached_parts.finalized_block_root)?
             {
                 *self.latest_finality_update.write() = Some(LightClientFinalityUpdate {
                     // TODO: may want to cache this result from latest_optimistic_update if producing a
                     // light_client header becomes expensive
-                    attested_header: block_to_light_client_header(attested_block.message()),
-                    finalized_header: block_to_light_client_header(finalized_block.message()),
+                    attested_header: block_to_light_client_header(fork_name, &attested_block)?,
+                    finalized_header: block_to_light_client_header(fork_name, &finalized_block)?,
                     finality_branch: cached_parts.finality_branch.clone(),
                     sync_aggregate: sync_aggregate.clone(),
                     signature_slot,
@@ -214,7 +223,7 @@ impl LightClientCachedData {
     }
 }
 
-// Implements spec priorization rules:
+// Implements spec prioritization rules:
 // > Full nodes SHOULD provide the LightClientFinalityUpdate with the highest attested_header.beacon.slot (if multiple, highest signature_slot)
 //
 // ref: https://github.com/ethereum/consensus-specs/blob/113c58f9bf9c08867f6f5f633c4d98e0364d612a/specs/altair/light-client/full-node.md#create_light_client_finality_update
@@ -223,14 +232,14 @@ fn is_latest_finality_update<T: EthSpec>(
     attested_slot: Slot,
     signature_slot: Slot,
 ) -> bool {
-    if attested_slot > prev.attested_header.beacon.slot {
+    if attested_slot > prev.attested_header.beacon().slot {
         true
     } else {
-        attested_slot == prev.attested_header.beacon.slot && signature_slot > prev.signature_slot
+        attested_slot == prev.attested_header.beacon().slot && signature_slot > prev.signature_slot
     }
 }
 
-// Implements spec priorization rules:
+// Implements spec prioritization rules:
 // > Full nodes SHOULD provide the LightClientOptimisticUpdate with the highest attested_header.beacon.slot (if multiple, highest signature_slot)
 //
 // ref: https://github.com/ethereum/consensus-specs/blob/113c58f9bf9c08867f6f5f633c4d98e0364d612a/specs/altair/light-client/full-node.md#create_light_client_optimistic_update
@@ -239,18 +248,25 @@ fn is_latest_optimistic_update<T: EthSpec>(
     attested_slot: Slot,
     signature_slot: Slot,
 ) -> bool {
-    if attested_slot > prev.attested_header.beacon.slot {
+    if attested_slot > prev.attested_header.beacon().slot {
         true
     } else {
-        attested_slot == prev.attested_header.beacon.slot && signature_slot > prev.signature_slot
+        attested_slot == prev.attested_header.beacon().slot && signature_slot > prev.signature_slot
     }
 }
 
 fn block_to_light_client_header<T: EthSpec>(
-    block: BeaconBlockRef<T, types::BlindedPayload<T>>,
-) -> LightClientHeader {
-    // TODO: make fork aware
-    LightClientHeader {
-        beacon: block.block_header(),
-    }
+    fork_name: ForkName,
+    block: &SignedBeaconBlock<T>,
+) -> Result<LightClientHeader<T>, BeaconChainError> {
+    let light_client_header = match fork_name {
+        ForkName::Base => return Err(LightClientError::AltairForkNotActive.into()),
+        ForkName::Merge | ForkName::Altair => {
+            LightClientHeaderAltair::block_to_light_client_header(block)?.into()
+        }
+        ForkName::Capella => LightClientHeaderCapella::block_to_light_client_header(block)?.into(),
+        ForkName::Deneb => LightClientHeaderDeneb::block_to_light_client_header(block)?.into(),
+    };
+
+    Ok(light_client_header)
 }

beacon_node/http_api/tests/tests.rs

@@ -1715,7 +1715,7 @@ impl ApiTester {
         };
 
         let expected = block.slot();
-        assert_eq!(result.header.beacon.slot, expected);
+        assert_eq!(result.header.beacon().slot, expected);
 
         self
     }

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

@@ -591,7 +591,7 @@ fn handle_rpc_response<T: EthSpec>(
             MetaDataV1::from_ssz_bytes(decoded_buffer)?,
         )))),
         SupportedProtocol::LightClientBootstrapV1 => Ok(Some(RPCResponse::LightClientBootstrap(
-            LightClientBootstrap::from_ssz_bytes(decoded_buffer)?,
+            Arc::new(LightClientBootstrap::from_ssz_bytes(decoded_buffer)?),
         ))),
         // MetaData V2 responses have no context bytes, so behave similarly to V1 responses
         SupportedProtocol::MetaDataV2 => Ok(Some(RPCResponse::MetaData(MetaData::V2(

beacon_node/lighthouse_network/src/rpc/methods.rs

@@ -385,7 +385,7 @@ pub enum RPCResponse<T: EthSpec> {
     BlobsByRange(Arc<BlobSidecar<T>>),
 
     /// A response to a get LIGHT_CLIENT_BOOTSTRAP request.
-    LightClientBootstrap(LightClientBootstrap<T>),
+    LightClientBootstrap(Arc<LightClientBootstrap<T>>),
 
     /// A response to a get BLOBS_BY_ROOT request.
     BlobsByRoot(Arc<BlobSidecar<T>>),
@@ -569,7 +569,7 @@ impl<T: EthSpec> std::fmt::Display for RPCResponse<T> {
                 write!(
                     f,
                     "LightClientBootstrap Slot: {}",
-                    bootstrap.header.beacon.slot
+                    bootstrap.header.beacon().slot
                 )
             }
         }

beacon_node/lighthouse_network/src/service/api_types.rs

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

beacon_node/network/src/network_beacon_processor/rpc_methods.rs

@@ -305,7 +305,7 @@ impl<T: BeaconChainTypes> NetworkBeaconProcessor<T> {
         match self.chain.get_light_client_bootstrap(&block_root) {
             Ok(Some((bootstrap, _))) => self.send_response(
                 peer_id,
-                Response::LightClientBootstrap(bootstrap),
+                Response::LightClientBootstrap(Arc::new(bootstrap)),
                 request_id,
             ),
             Ok(None) => self.send_error_response(

consensus/types/src/beacon_block_body.rs

@@ -16,6 +16,13 @@ pub type KzgCommitments<T> =
 pub type KzgCommitmentOpts<T> =
     FixedVector<Option<KzgCommitment>, <T as EthSpec>::MaxBlobsPerBlock>;
 
+/// The number of leaves (including padding) on the `BeaconBlockBody` Merkle tree.
+///
+/// ## Note
+///
+/// This constant is set with the assumption that there are `> 8` and `<= 16` fields on the
+/// `BeaconBlockBody`. **Tree hashing will fail if this value is set incorrectly.**
+pub const NUM_BEACON_BLOCK_BODY_HASH_TREE_ROOT_LEAVES: usize = 16;
 /// Index of the `blob_kzg_commitments` leaf in the `BeaconBlockBody` tree post-deneb.
 pub const BLOB_KZG_COMMITMENTS_INDEX: usize = 11;
 
@@ -47,11 +54,12 @@ pub const BLOB_KZG_COMMITMENTS_INDEX: usize = 11;
     cast_error(ty = "Error", expr = "Error::IncorrectStateVariant"),
     partial_getter_error(ty = "Error", expr = "Error::IncorrectStateVariant")
 )]
-#[derive(Debug, Clone, Serialize, Deserialize, Derivative, arbitrary::Arbitrary)]
+#[derive(Debug, Clone, Serialize, Deserialize, Derivative, TreeHash, arbitrary::Arbitrary)]
 #[derivative(PartialEq, Hash(bound = "T: EthSpec"))]
 #[serde(untagged)]
 #[serde(bound = "T: EthSpec, Payload: AbstractExecPayload<T>")]
 #[arbitrary(bound = "T: EthSpec, Payload: AbstractExecPayload<T>")]
+#[tree_hash(enum_behaviour = "transparent")]
 pub struct BeaconBlockBody<T: EthSpec, Payload: AbstractExecPayload<T> = FullPayload<T>> {
     pub randao_reveal: Signature,
     pub eth1_data: Eth1Data,
@@ -586,6 +594,59 @@ impl<E: EthSpec> From<BeaconBlockBody<E, FullPayload<E>>>
     }
 }
 
+impl<T: EthSpec> BeaconBlockBody<T> {
+    pub fn block_body_merkle_proof(
+        &mut self,
+        generalized_index: usize,
+    ) -> Result<Vec<Hash256>, Error> {
+        let field_index = match generalized_index {
+            light_client_update::EXECUTION_PAYLOAD_INDEX => {
+                // Execution payload is a top-level field, subtract off the generalized indices
+                // for the internal nodes. Result should be 9, the field offset of the execution
+                // payload in the `BeaconBlockBody`:
+                // https://github.com/ethereum/consensus-specs/blob/dev/specs/deneb/beacon-chain.md#beaconblockbody
+                generalized_index
+                    .checked_sub(NUM_BEACON_BLOCK_BODY_HASH_TREE_ROOT_LEAVES)
+                    .ok_or(Error::IndexNotSupported(generalized_index))?
+            }
+            _ => return Err(Error::IndexNotSupported(generalized_index)),
+        };
+
+        let mut leaves = vec![
+            self.randao_reveal().tree_hash_root(),
+            self.eth1_data().tree_hash_root(),
+            self.graffiti().tree_hash_root(),
+            self.proposer_slashings().tree_hash_root(),
+            self.attester_slashings().tree_hash_root(),
+            self.attestations().tree_hash_root(),
+            self.deposits().tree_hash_root(),
+            self.voluntary_exits().tree_hash_root(),
+        ];
+
+        if let Ok(sync_aggregate) = self.sync_aggregate() {
+            leaves.push(sync_aggregate.tree_hash_root())
+        }
+
+        if let Ok(execution_payload) = self.execution_payload() {
+            leaves.push(execution_payload.tree_hash_root())
+        }
+
+        if let Ok(bls_to_execution_changes) = self.bls_to_execution_changes() {
+            leaves.push(bls_to_execution_changes.tree_hash_root())
+        }
+
+        if let Ok(blob_kzg_commitments) = self.blob_kzg_commitments() {
+            leaves.push(blob_kzg_commitments.tree_hash_root())
+        }
+
+        let depth = light_client_update::EXECUTION_PAYLOAD_PROOF_LEN;
+        let tree = merkle_proof::MerkleTree::create(&leaves, depth);
+        let (_, proof) = tree.generate_proof(field_index, depth)?;
+
+        Ok(proof)
+    }
+}
+
 /// Util method helpful for logging.
 pub fn format_kzg_commitments(commitments: &[KzgCommitment]) -> String {
     let commitment_strings: Vec<String> = commitments.iter().map(|x| x.to_string()).collect();

consensus/types/src/beacon_block_header.rs

@@ -13,6 +13,7 @@ use tree_hash_derive::TreeHash;
 #[derive(
     arbitrary::Arbitrary,
     Debug,
+    Default,
     PartialEq,
     Eq,
     Hash,