EIP-7688: Forward Compatible Consensus Data Structures (#9450)

## Relevant Links

- https://eips.ethereum.org/EIPS/eip-7688
- ethereum/consensus-specs#4630

## Proposed Changes

Adds the necessary types and components to support EIP-7688, along with the cargo patches to pull in the `progressive` versions of the crates in our SSZ stack.

## Testing

```yaml
participants_matrix:
  el:
    - el_type: nethermind
      el_image: ethpandaops/nethermind:master
  cl:
    - cl_type: nimbus
      cl_image: ethpandaops/nimbus-eth2:glamsterdam-devnet-7-minimal
    - cl_type: lodestar
      cl_image: ethpandaops/lodestar:glamsterdam-devnet-7
    - cl_type: lighthouse
      cl_image: ethpandaops/lighthouse:glamsterdam-devnet-7
    - cl_type: teku
      cl_image: ethpandaops/teku:glamsterdam-devnet-7

ethereum_genesis_generator_params:
  image: "ethpandaops/ethereum-genesis-generator:glamsterdam-devnet-7"
dora_params:
  image: ethpandaops/dora:glamsterdam-devnet-7

global_log_level: debug

network_params:
  preset: minimal
  gloas_fork_epoch: 1

additional_services:
  - dora
```

## Additional Info

Based on the original work by @michaelsproul in #8505

Co-authored-by: Michael Sproul <michael@sigmaprime.io>

Author: macladson

Cargo.lock

@@ -279,6 +279,13 @@ inherits = "release"
 debug = true
 
 [patch.crates-io]
+# FIXME(eip-7688): EIP-7688 development patches
+ssz_types = { git = "https://github.com/sigp/ssz_types", rev = "9203d56ad2d7bc5f12133d043e085843f81edcd6" }
+milhouse = { git = "https://github.com/sigp/milhouse", rev = "c70f128976ac0d60ea65a978dabd117a921c36ee" }
+ethereum_ssz = { git = "https://github.com/sigp/ethereum_ssz", rev = "2059c21ba52cd3a7e39a8ad537012b761812a393" }
+ethereum_ssz_derive = { git = "https://github.com/sigp/ethereum_ssz", rev = "2059c21ba52cd3a7e39a8ad537012b761812a393" }
+tree_hash = { git = "https://github.com/sigp/tree_hash", rev = "03d9fa474586c125f306dd7a00cf46284575a01f" }
+tree_hash_derive = { git = "https://github.com/sigp/tree_hash", rev = "03d9fa474586c125f306dd7a00cf46284575a01f" }
 # Temporary patch until the axum migration is complete
 warp = { git = "https://github.com/macladson/warp", rev = "6f5f21beab6a240e59470caaab56afd46d46b709" }
 

Cargo.toml

@@ -48,6 +48,7 @@ use state_processing::{
     common::{
         attesting_indices_base,
         attesting_indices_electra::{self, get_committee_indices},
+        attesting_indices_gloas,
     },
     per_block_processing::errors::{AttestationValidationError, BlockOperationError},
     signature_sets::{
@@ -688,6 +689,16 @@ impl<'a, T: BeaconChainTypes> IndexedAggregatedAttestation<'a, T> {
                         signed_aggregate.message.selection_proof.clone(),
                         signed_aggregate.message.aggregate.data.clone(),
                     ),
+                    SignedAggregateAndProof::Gloas(signed_aggregate) => (
+                        signed_aggregate
+                            .message
+                            .aggregate
+                            .committee_index()
+                            .ok_or(Error::NotExactlyOneCommitteeBitSet(0))?,
+                        signed_aggregate.message.aggregator_index,
+                        signed_aggregate.message.selection_proof.clone(),
+                        signed_aggregate.message.aggregate.data.clone(),
+                    ),
                 };
                 let slot = data.slot;
 
@@ -724,6 +735,13 @@ impl<'a, T: BeaconChainTypes> IndexedAggregatedAttestation<'a, T> {
                         )
                         .map_err(|e| BeaconChainError::from(e).into())
                     }
+                    SignedAggregateAndProof::Gloas(signed_aggregate) => {
+                        attesting_indices_gloas::get_indexed_attestation(
+                            &committees,
+                            &signed_aggregate.message.aggregate,
+                        )
+                        .map_err(|e| BeaconChainError::from(e).into())
+                    }
                 }
             };
 
@@ -1562,6 +1580,20 @@ pub fn obtain_indexed_attestation_and_committees_per_slot<T: BeaconChainTypes>(
                         }
                     })
             }
+            AttestationRef::Gloas(att) => {
+                attesting_indices_gloas::get_indexed_attestation(&committees, att)
+                    .map(|attestation| (attestation, committees_per_slot))
+                    .map_err(|e| {
+                        if let BlockOperationError::BeaconStateError(NoCommitteeFound(index)) = e {
+                            Error::NoCommitteeForSlotAndIndex {
+                                slot: att.data.slot,
+                                index,
+                            }
+                        } else {
+                            Error::Invalid(e)
+                        }
+                    })
+            }
         }
     })
 }

beacon_node/beacon_chain/src/attestation_verification.rs

@@ -263,8 +263,9 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             .safe_mul(WEIGHT_DENOMINATOR)?
             .safe_div(PROPOSER_WEIGHT)?;
 
-        let mut current_epoch_participation = state.current_epoch_participation()?.clone();
-        let mut previous_epoch_participation = state.previous_epoch_participation()?.clone();
+        let mut current_epoch_participation = state.current_epoch_participation()?.to_owned_list();
+        let mut previous_epoch_participation =
+            state.previous_epoch_participation()?.to_owned_list();
 
         for attestation in block.body().attestations() {
             let data = attestation.data();
@@ -289,7 +290,8 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                     };
 
                     let validator_participation = epoch_participation
-                        .get_mut(index)
+                        .as_mut()
+                        .into_get_mut(index)
                         .ok_or(BeaconStateError::ParticipationOutOfBounds(index))?;
 
                     if participation_flag_indices.contains(&flag_index)

beacon_node/beacon_chain/src/beacon_block_reward.rs

@@ -1258,7 +1258,7 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
         if header_from_payload != execution_payload_header {
             for txn in execution_payload.transactions() {
                 debug!(
-                    bytes = format!("0x{}", hex::encode(&**txn)),
+                    bytes = format!("0x{}", hex::encode(txn)),
                     "Reconstructed txn"
                 );
             }
@@ -1746,12 +1746,14 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
     ) -> Result<Option<Attestation<T::EthSpec>>, Error> {
         match attestation {
             AttestationRef::Base(att) => self.get_aggregated_attestation_base(&att.data),
-            AttestationRef::Electra(att) => self.get_aggregated_attestation_electra(
-                att.data.slot,
-                &att.data.tree_hash_root(),
-                att.committee_index()
-                    .ok_or(Error::AttestationCommitteeIndexNotSet)?,
-            ),
+            AttestationRef::Electra(_) | AttestationRef::Gloas(_) => self
+                .get_aggregated_attestation_electra(
+                    attestation.data().slot,
+                    &attestation.data().tree_hash_root(),
+                    attestation
+                        .committee_index()
+                        .ok_or(Error::AttestationCommitteeIndexNotSet)?,
+                ),
         }
     }
 
@@ -5892,27 +5894,36 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
             bls_to_execution_changes,
         } = partial_beacon_block;
 
-        let (attester_slashings_base, attester_slashings_electra) =
-            attester_slashings.into_iter().fold(
-                (Vec::new(), Vec::new()),
-                |(mut base, mut electra), slashing| {
-                    match slashing {
-                        AttesterSlashing::Base(slashing) => base.push(slashing),
-                        AttesterSlashing::Electra(slashing) => electra.push(slashing),
-                    }
-                    (base, electra)
-                },
-            );
-        let (attestations_base, attestations_electra) = attestations.into_iter().fold(
-            (Vec::new(), Vec::new()),
-            |(mut base, mut electra), attestation| {
-                match attestation {
-                    Attestation::Base(attestation) => base.push(attestation),
-                    Attestation::Electra(attestation) => electra.push(attestation),
+        let mut attester_slashings_base = Vec::new();
+        let mut attester_slashings_electra = Vec::new();
+        for slashing in attester_slashings {
+            match slashing {
+                AttesterSlashing::Base(slashing) => attester_slashings_base.push(slashing),
+                AttesterSlashing::Electra(slashing) => attester_slashings_electra.push(slashing),
+                // Gloas-typed slashings cannot be included in pre-Gloas blocks, and Gloas
+                // blocks are produced via `complete_partial_beacon_block_gloas`.
+                AttesterSlashing::Gloas(_) => {
+                    return Err(BlockProductionError::InvalidBlockVariant(
+                        "Gloas attester slashing in pre-Gloas block production".to_owned(),
+                    ));
                 }
-                (base, electra)
-            },
-        );
+            }
+        }
+        let mut attestations_base = Vec::new();
+        let mut attestations_electra = Vec::new();
+        for attestation in attestations {
+            match attestation {
+                Attestation::Base(attestation) => attestations_base.push(attestation),
+                Attestation::Electra(attestation) => attestations_electra.push(attestation),
+                // Gloas-typed attestations cannot be included in pre-Gloas blocks, and Gloas
+                // blocks are produced via `complete_partial_beacon_block_gloas`.
+                Attestation::Gloas(_) => {
+                    return Err(BlockProductionError::InvalidBlockVariant(
+                        "Gloas attestation in pre-Gloas block production".to_owned(),
+                    ));
+                }
+            }
+        }
 
         let (inner_block, maybe_blobs_and_proofs, execution_payload_value) = match &state {
             BeaconState::Base(_) => (
@@ -6167,11 +6178,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                             blob_kzg_commitments: kzg_commitments
                                 .ok_or(BlockProductionError::InvalidPayloadFork)?,
                             execution_requests: maybe_requests
-                                .map(|r| ExecutionRequestsElectra {
-                                    deposits: r.deposits().clone(),
-                                    withdrawals: r.withdrawals().clone(),
-                                    consolidations: r.consolidations().clone(),
-                                })
                                 .ok_or(BlockProductionError::MissingExecutionRequests)?,
                         },
                     }),
@@ -6226,11 +6232,6 @@ impl<T: BeaconChainTypes> BeaconChain<T> {
                             blob_kzg_commitments: kzg_commitments
                                 .ok_or(BlockProductionError::InvalidPayloadFork)?,
                             execution_requests: maybe_requests
-                                .map(|r| ExecutionRequestsElectra {
-                                    deposits: r.deposits().clone(),
-                                    withdrawals: r.withdrawals().clone(),
-                                    consolidations: r.consolidations().clone(),
-                                })
                                 .ok_or(BlockProductionError::MissingExecutionRequests)?,
                         },
                     }),