Merge branch 'electra_attestation_changes' of https://github.com/sigp/lighthouse into electra_op_pool

consensus/state_processing/src/common/get_attesting_indices.rs

@@ -113,11 +113,15 @@ pub mod attesting_indices_electra {
             .map(|committee| (committee.index, committee))
             .collect();
 
+        let committee_count_per_slot = committees.len() as u64;
+        let mut participant_count = 0;
         for index in committee_indices {
             if let Some(&beacon_committee) = committees_map.get(&index) {
-                if aggregation_bits.len() != beacon_committee.committee.len() {
-                    return Err(BeaconStateError::InvalidBitfield);
+                // This check is new to the spec's `process_attestation` in Electra.
+                if index >= committee_count_per_slot {
+                    return Err(BeaconStateError::InvalidCommitteeIndex(index));
                 }
+                participant_count.safe_add_assign(beacon_committee.committee.len() as u64)?;
                 let committee_attesters = beacon_committee
                     .committee
                     .iter()
@@ -136,10 +140,13 @@ pub mod attesting_indices_electra {
 
                 committee_offset.safe_add(beacon_committee.committee.len())?;
             } else {
-                return Err(Error::NoCommitteeFound);
+                return Err(Error::NoCommitteeFound(index));
             }
+        }
 
-            // TODO(electra) what should we do when theres no committee found for a given index?
+        // This check is new to the spec's `process_attestation` in Electra.
+        if participant_count as usize != aggregation_bits.len() {
+            return Err(BeaconStateError::InvalidBitfield);
         }
 
         let mut indices = output.into_iter().collect_vec();

consensus/types/src/attestation.rs

@@ -67,9 +67,9 @@ pub struct Attestation<E: EthSpec> {
     #[superstruct(only(Electra), partial_getter(rename = "aggregation_bits_electra"))]
     pub aggregation_bits: BitList<E::MaxValidatorsPerSlot>,
     pub data: AttestationData,
-    pub signature: AggregateSignature,
     #[superstruct(only(Electra))]
     pub committee_bits: BitVector<E::MaxCommitteesPerSlot>,
+    pub signature: AggregateSignature,
 }
 
 impl<E: EthSpec> Decode for Attestation<E> {
@@ -92,6 +92,7 @@ impl<E: EthSpec> Decode for Attestation<E> {
     }
 }
 
+// TODO(electra): think about how to handle fork variants here
 impl<E: EthSpec> TestRandom for Attestation<E> {
     fn random_for_test(rng: &mut impl RngCore) -> Self {
         let aggregation_bits: BitList<E::MaxValidatorsPerCommittee> = BitList::random_for_test(rng);

consensus/types/src/beacon_state.rs

@@ -159,7 +159,8 @@ pub enum Error {
     IndexNotSupported(usize),
     InvalidFlagIndex(usize),
     MerkleTreeError(merkle_proof::MerkleTreeError),
-    NoCommitteeFound,
+    NoCommitteeFound(CommitteeIndex),
+    InvalidCommitteeIndex(CommitteeIndex),
 }
 
 /// Control whether an epoch-indexed field can be indexed at the next epoch or not.

consensus/types/src/eth_spec.rs

@@ -408,6 +408,8 @@ impl EthSpec for MainnetEthSpec {
 pub struct MinimalEthSpec;
 
 impl EthSpec for MinimalEthSpec {
+    type MaxCommitteesPerSlot = U4;
+    type MaxValidatorsPerSlot = U8192;
     type SlotsPerEpoch = U8;
     type EpochsPerEth1VotingPeriod = U4;
     type SlotsPerHistoricalRoot = U64;
@@ -432,8 +434,6 @@ impl EthSpec for MinimalEthSpec {
         SubnetBitfieldLength,
         SyncCommitteeSubnetCount,
         MaxValidatorsPerCommittee,
-        MaxCommitteesPerSlot,
-        MaxValidatorsPerSlot,
         GenesisEpoch,
         HistoricalRootsLimit,
         ValidatorRegistryLimit,