Electra: Remaining Consensus Data Structures (#5712)

* Attestation superstruct changes for EIP 7549 (#5644)

* update

* experiment

* superstruct changes

* revert

* superstruct changes

* fix tests

* indexed attestation

* indexed attestation superstruct

* updated TODOs

* `superstruct` the `AttesterSlashing` (#5636)

* `superstruct` Attester Fork Variants

* Push a little further

* Deal with Encode / Decode of AttesterSlashing

* not so sure about this..

* Stop Encode/Decode Bounds from Propagating Out

* Tons of Changes..

* More Conversions to AttestationRef

* Add AsReference trait (#15)

* Add AsReference trait

* Fix some snafus

* Got it Compiling! :D

* Got Tests Building

* Get beacon chain tests compiling

---------

Co-authored-by: Michael Sproul <micsproul@gmail.com>

* Merge remote-tracking branch 'upstream/unstable' into electra_attestation_changes

* Make EF Tests Fork-Agnostic (#5713)

* Finish EF Test Fork Agnostic (#5714)

* Superstruct `AggregateAndProof` (#5715)

* Upgrade `superstruct` to `0.8.0`

* superstruct `AggregateAndProof`

* Merge remote-tracking branch 'sigp/unstable' into electra_attestation_changes

* cargo fmt

* Merge pull request #5726 from realbigsean/electra_attestation_changes

Merge unstable into Electra attestation changes

* EIP7549 `get_attestation_indices` (#5657)

* get attesting indices electra impl

* fmt

* get tests to pass

* fmt

* fix some beacon chain tests

* fmt

* fix slasher test

* fmt got me again

* fix more tests

* fix tests

* Some small changes (#5739)

* cargo fmt (#5740)

* Sketch op pool changes

* fix get attesting indices (#5742)

* fix get attesting indices

* better errors

* fix compile

* only get committee index once

* Ef test fixes (#5753)

* attestation related ef test fixes

* delete commented out stuff

* Fix Aggregation Pool for Electra (#5754)

* Fix Aggregation Pool for Electra

* Remove Outdated Interface

* fix ssz (#5755)

* Get `electra_op_pool` up to date (#5756)

* fix get attesting indices (#5742)

* fix get attesting indices

* better errors

* fix compile

* only get committee index once

* Ef test fixes (#5753)

* attestation related ef test fixes

* delete commented out stuff

* Fix Aggregation Pool for Electra (#5754)

* Fix Aggregation Pool for Electra

* Remove Outdated Interface

* fix ssz (#5755)

---------

Co-authored-by: realbigsean <sean@sigmaprime.io>

* Revert "Get `electra_op_pool` up to date (#5756)" (#5757)

This reverts commit ab9e58aa3d.

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

* Compute on chain aggregate impl (#5752)

* add compute_on_chain_agg impl to op pool changes

* fmt

* get op pool tests to pass

* update the naive agg pool interface (#5760)

* Fix bugs in cross-committee aggregation

* Add comment to max cover optimisation

* Fix assert

* Merge pull request #5749 from sigp/electra_op_pool

Optimise Electra op pool aggregation

* update committee offset

* Fix Electra Fork Choice Tests (#5764)

* Subscribe to the correct subnets for electra attestations (#5782)

* subscribe to the correct att subnets for electra

* subscribe to the correct att subnets for electra

* cargo fmt

* fix slashing handling

* Merge remote-tracking branch 'upstream/unstable'

* Send unagg attestation based on fork

* Publish all aggregates

* just one more check bro plz..

* Merge pull request #5832 from ethDreamer/electra_attestation_changes_merge_unstable

Merge `unstable` into `electra_attestation_changes`

* Merge pull request #5835 from realbigsean/fix-validator-logic

Fix validator logic

* Merge pull request #5816 from realbigsean/electra-attestation-slashing-handling

Electra slashing handling

* Electra attestation changes rm decode impl (#5856)

* Remove Crappy Decode impl for Attestation

* Remove Inefficient Attestation Decode impl

* Implement Schema Upgrade / Downgrade

* Update beacon_node/beacon_chain/src/schema_change/migration_schema_v20.rs

Co-authored-by: Michael Sproul <micsproul@gmail.com>

---------

Co-authored-by: Michael Sproul <micsproul@gmail.com>

* Fix failing attestation tests and misc electra attestation cleanup (#5810)

* - get attestation related beacon chain tests to pass
- observed attestations are now keyed off of data + committee index
- rename op pool attestationref to compactattestationref
- remove unwraps in agg pool and use options instead
- cherry pick some changes from ef-tests-electra

* cargo fmt

* fix failing test

* Revert dockerfile changes

* make committee_index return option

* function args shouldnt be a ref to attestation ref

* fmt

* fix dup imports

---------

Co-authored-by: realbigsean <seananderson33@GMAIL.com>

* fix some todos (#5817)

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

* add consolidations to merkle calc for inclusion proof

* Remove Duplicate KZG Commitment Merkle Proof Code (#5874)

* Remove Duplicate KZG Commitment Merkle Proof Code

* s/tree_lists/fields/

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

* fix compile

* Fix slasher tests (#5906)

* Fix electra tests

* Add electra attestations to double vote tests

* Update superstruct to 0.8

* Merge remote-tracking branch 'origin/unstable' into electra_attestation_changes

* Small cleanup in slasher tests

* Clean up Electra observed aggregates (#5929)

* Use consistent key in observed_attestations

* Remove unwraps from observed aggregates

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

* De-dup attestation constructor logic

* Remove unwraps in Attestation construction

* Dedup match_attestation_data

* Remove outdated TODO

* Use ForkName Ord in fork-choice tests

* Use ForkName Ord in BeaconBlockBody

* Make to_electra not fallible

* Remove TestRandom impl for IndexedAttestation

* Remove IndexedAttestation faulty Decode impl

* Drop TestRandom impl

* Add PendingAttestationInElectra

* Indexed att on disk (#35)

* indexed att on disk

* fix lints

* Update slasher/src/migrate.rs

Co-authored-by: ethDreamer <37123614+ethDreamer@users.noreply.github.com>

---------

Co-authored-by: Lion - dapplion <35266934+dapplion@users.noreply.github.com>
Co-authored-by: ethDreamer <37123614+ethDreamer@users.noreply.github.com>

* add electra fork enabled fn to ForkName impl (#36)

* add electra fork enabled fn to ForkName impl

* remove inadvertent file

* Update common/eth2/src/types.rs

Co-authored-by: ethDreamer <37123614+ethDreamer@users.noreply.github.com>

* Dedup attestation constructor logic in attester cache

* Use if let Ok for committee_bits

* Dedup Attestation constructor code

* Diff reduction in tests

* Fix beacon_chain tests

* Diff reduction

* Use Ord for ForkName in pubsub

* Resolve into_attestation_and_indices todo

* Remove stale TODO

* Fix beacon_chain tests

* Test spec invariant

* Use electra_enabled in pubsub

* Remove get_indexed_attestation_from_signed_aggregate

* Use ok_or instead of if let else

* committees are sorted

* remove dup method `get_indexed_attestation_from_committees`

* Merge pull request #5940 from dapplion/electra_attestation_changes_lionreview

Electra attestations #5712 review

* update default persisted op pool deserialization

* ensure aggregate and proof uses serde untagged on ref

* Fork aware ssz static attestation tests

* Electra attestation changes from Lions review (#5971)

* dedup/cleanup and remove unneeded hashset use

* remove irrelevant TODOs

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

* Electra attestation changes sean review (#5972)

* instantiate empty bitlist in unreachable code

* clean up error conversion

* fork enabled bool cleanup

* remove a couple todos

* return bools instead of options in `aggregate` and use the result

* delete commented out code

* use map macros in simple transformations

* remove signers_disjoint_from

* get ef tests compiling

* get ef tests compiling

* update intentionally excluded files

* Avoid changing slasher schema for Electra

* Delete slasher schema v4

* Fix clippy

* Fix compilation of beacon_chain tests

* Update database.rs

* Add electra lightclient types

* Update slasher/src/database.rs

* fix imports

* Merge pull request #5980 from dapplion/electra-lightclient

Add electra lightclient types

* Merge pull request #5975 from michaelsproul/electra-slasher-no-migration

Avoid changing slasher schema for Electra

* Update beacon_node/beacon_chain/src/attestation_verification.rs

* Update beacon_node/beacon_chain/src/attestation_verification.rs

beacon_node/operation_pool/src/attestation_storage.rs

@@ -1,9 +1,10 @@
 use crate::AttestationStats;
 use itertools::Itertools;
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use types::{
-    AggregateSignature, Attestation, AttestationData, BeaconState, BitList, Checkpoint, Epoch,
-    EthSpec, Hash256, Slot,
+    attestation::{AttestationBase, AttestationElectra},
+    superstruct, AggregateSignature, Attestation, AttestationData, BeaconState, BitList, BitVector,
+    Checkpoint, Epoch, EthSpec, Hash256, Slot, Unsigned,
 };
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone, Copy)]
@@ -20,11 +21,17 @@ pub struct CompactAttestationData {
     pub target_root: Hash256,
 }
 
+#[superstruct(variants(Base, Electra), variant_attributes(derive(Debug, PartialEq,)))]
 #[derive(Debug, PartialEq)]
 pub struct CompactIndexedAttestation<E: EthSpec> {
     pub attesting_indices: Vec<u64>,
+    #[superstruct(only(Base), partial_getter(rename = "aggregation_bits_base"))]
     pub aggregation_bits: BitList<E::MaxValidatorsPerCommittee>,
+    #[superstruct(only(Electra), partial_getter(rename = "aggregation_bits_electra"))]
+    pub aggregation_bits: BitList<E::MaxValidatorsPerSlot>,
     pub signature: AggregateSignature,
+    #[superstruct(only(Electra))]
+    pub committee_bits: BitVector<E::MaxCommitteesPerSlot>,
 }
 
 #[derive(Debug)]
@@ -35,7 +42,7 @@ pub struct SplitAttestation<E: EthSpec> {
 }
 
 #[derive(Debug, Clone)]
-pub struct AttestationRef<'a, E: EthSpec> {
+pub struct CompactAttestationRef<'a, E: EthSpec> {
     pub checkpoint: &'a CheckpointKey,
     pub data: &'a CompactAttestationData,
     pub indexed: &'a CompactIndexedAttestation<E>,
@@ -54,20 +61,34 @@ pub struct AttestationDataMap<E: EthSpec> {
 impl<E: EthSpec> SplitAttestation<E> {
     pub fn new(attestation: Attestation<E>, attesting_indices: Vec<u64>) -> Self {
         let checkpoint = CheckpointKey {
-            source: attestation.data.source,
-            target_epoch: attestation.data.target.epoch,
+            source: attestation.data().source,
+            target_epoch: attestation.data().target.epoch,
         };
         let data = CompactAttestationData {
-            slot: attestation.data.slot,
-            index: attestation.data.index,
-            beacon_block_root: attestation.data.beacon_block_root,
-            target_root: attestation.data.target.root,
+            slot: attestation.data().slot,
+            index: attestation.data().index,
+            beacon_block_root: attestation.data().beacon_block_root,
+            target_root: attestation.data().target.root,
         };
-        let indexed = CompactIndexedAttestation {
-            attesting_indices,
-            aggregation_bits: attestation.aggregation_bits,
-            signature: attestation.signature,
+
+        let indexed = match attestation.clone() {
+            Attestation::Base(attn) => {
+                CompactIndexedAttestation::Base(CompactIndexedAttestationBase {
+                    attesting_indices,
+                    aggregation_bits: attn.aggregation_bits,
+                    signature: attestation.signature().clone(),
+                })
+            }
+            Attestation::Electra(attn) => {
+                CompactIndexedAttestation::Electra(CompactIndexedAttestationElectra {
+                    attesting_indices,
+                    aggregation_bits: attn.aggregation_bits,
+                    signature: attestation.signature().clone(),
+                    committee_bits: attn.committee_bits,
+                })
+            }
         };
+
         Self {
             checkpoint,
             data,
@@ -75,8 +96,8 @@ impl<E: EthSpec> SplitAttestation<E> {
         }
     }
 
-    pub fn as_ref(&self) -> AttestationRef<E> {
-        AttestationRef {
+    pub fn as_ref(&self) -> CompactAttestationRef<E> {
+        CompactAttestationRef {
             checkpoint: &self.checkpoint,
             data: &self.data,
             indexed: &self.indexed,
@@ -84,7 +105,7 @@ impl<E: EthSpec> SplitAttestation<E> {
     }
 }
 
-impl<'a, E: EthSpec> AttestationRef<'a, E> {
+impl<'a, E: EthSpec> CompactAttestationRef<'a, E> {
     pub fn attestation_data(&self) -> AttestationData {
         AttestationData {
             slot: self.data.slot,
@@ -99,10 +120,20 @@ impl<'a, E: EthSpec> AttestationRef<'a, E> {
     }
 
     pub fn clone_as_attestation(&self) -> Attestation<E> {
-        Attestation {
-            aggregation_bits: self.indexed.aggregation_bits.clone(),
-            data: self.attestation_data(),
-            signature: self.indexed.signature.clone(),
+        match self.indexed {
+            CompactIndexedAttestation::Base(indexed_att) => Attestation::Base(AttestationBase {
+                aggregation_bits: indexed_att.aggregation_bits.clone(),
+                data: self.attestation_data(),
+                signature: indexed_att.signature.clone(),
+            }),
+            CompactIndexedAttestation::Electra(indexed_att) => {
+                Attestation::Electra(AttestationElectra {
+                    aggregation_bits: indexed_att.aggregation_bits.clone(),
+                    data: self.attestation_data(),
+                    signature: indexed_att.signature.clone(),
+                    committee_bits: indexed_att.committee_bits.clone(),
+                })
+            }
         }
     }
 }
@@ -125,7 +156,37 @@ impl CheckpointKey {
 }
 
 impl<E: EthSpec> CompactIndexedAttestation<E> {
-    pub fn signers_disjoint_from(&self, other: &Self) -> bool {
+    pub fn should_aggregate(&self, other: &Self) -> bool {
+        match (self, other) {
+            (CompactIndexedAttestation::Base(this), CompactIndexedAttestation::Base(other)) => {
+                this.should_aggregate(other)
+            }
+            (
+                CompactIndexedAttestation::Electra(this),
+                CompactIndexedAttestation::Electra(other),
+            ) => this.should_aggregate(other),
+            _ => false,
+        }
+    }
+
+    /// Returns `true` if aggregated, otherwise `false`.
+    pub fn aggregate(&mut self, other: &Self) -> bool {
+        match (self, other) {
+            (CompactIndexedAttestation::Base(this), CompactIndexedAttestation::Base(other)) => {
+                this.aggregate(other);
+                true
+            }
+            (
+                CompactIndexedAttestation::Electra(this),
+                CompactIndexedAttestation::Electra(other),
+            ) => this.aggregate_same_committee(other),
+            _ => false,
+        }
+    }
+}
+
+impl<E: EthSpec> CompactIndexedAttestationBase<E> {
+    pub fn should_aggregate(&self, other: &Self) -> bool {
         self.aggregation_bits
             .intersection(&other.aggregation_bits)
             .is_zero()
@@ -143,13 +204,108 @@ impl<E: EthSpec> CompactIndexedAttestation<E> {
     }
 }
 
+impl<E: EthSpec> CompactIndexedAttestationElectra<E> {
+    pub fn should_aggregate(&self, other: &Self) -> bool {
+        // For Electra, only aggregate attestations in the same committee.
+        self.committee_bits == other.committee_bits
+            && self
+                .aggregation_bits
+                .intersection(&other.aggregation_bits)
+                .is_zero()
+    }
+
+    /// Returns `true` if aggregated, otherwise `false`.
+    pub fn aggregate_same_committee(&mut self, other: &Self) -> bool {
+        if self.committee_bits != other.committee_bits {
+            return false;
+        }
+        self.aggregation_bits = self.aggregation_bits.union(&other.aggregation_bits);
+        self.attesting_indices = self
+            .attesting_indices
+            .drain(..)
+            .merge(other.attesting_indices.iter().copied())
+            .dedup()
+            .collect();
+        self.signature.add_assign_aggregate(&other.signature);
+        true
+    }
+
+    pub fn aggregate_with_disjoint_committees(&mut self, other: &Self) -> Option<()> {
+        if !self
+            .committee_bits
+            .intersection(&other.committee_bits)
+            .is_zero()
+        {
+            return None;
+        }
+        // The attestation being aggregated in must only have 1 committee bit set.
+        if other.committee_bits.num_set_bits() != 1 {
+            return None;
+        }
+
+        // Check we are aggregating in increasing committee index order (so we can append
+        // aggregation bits).
+        if self.committee_bits.highest_set_bit() >= other.committee_bits.highest_set_bit() {
+            return None;
+        }
+
+        self.committee_bits = self.committee_bits.union(&other.committee_bits);
+        if let Some(agg_bits) = bitlist_extend(&self.aggregation_bits, &other.aggregation_bits) {
+            self.aggregation_bits = agg_bits;
+
+            self.attesting_indices = self
+                .attesting_indices
+                .drain(..)
+                .merge(other.attesting_indices.iter().copied())
+                .dedup()
+                .collect();
+            self.signature.add_assign_aggregate(&other.signature);
+
+            return Some(());
+        }
+
+        None
+    }
+
+    pub fn committee_index(&self) -> Option<u64> {
+        self.get_committee_indices().first().copied()
+    }
+
+    pub fn get_committee_indices(&self) -> Vec<u64> {
+        self.committee_bits
+            .iter()
+            .enumerate()
+            .filter_map(|(index, bit)| if bit { Some(index as u64) } else { None })
+            .collect()
+    }
+}
+
+// TODO(electra): upstream this or a more efficient implementation
+fn bitlist_extend<N: Unsigned>(list1: &BitList<N>, list2: &BitList<N>) -> Option<BitList<N>> {
+    let new_length = list1.len() + list2.len();
+    let mut list = BitList::<N>::with_capacity(new_length).ok()?;
+
+    // Copy bits from list1.
+    for (i, bit) in list1.iter().enumerate() {
+        list.set(i, bit).ok()?;
+    }
+
+    // Copy bits from list2, starting from the end of list1.
+    let offset = list1.len();
+    for (i, bit) in list2.iter().enumerate() {
+        list.set(offset + i, bit).ok()?;
+    }
+
+    Some(list)
+}
+
 impl<E: EthSpec> AttestationMap<E> {
     pub fn insert(&mut self, attestation: Attestation<E>, attesting_indices: Vec<u64>) {
         let SplitAttestation {
             checkpoint,
             data,
             indexed,
-        } = SplitAttestation::new(attestation, attesting_indices);
+        } = SplitAttestation::new(attestation.clone(), attesting_indices);
 
         let attestation_map = self.checkpoint_map.entry(checkpoint).or_default();
         let attestations = attestation_map.attestations.entry(data).or_default();
@@ -158,10 +314,10 @@ impl<E: EthSpec> AttestationMap<E> {
         // NOTE: this is sub-optimal and in future we will remove this in favour of max-clique
         // aggregation.
         let mut aggregated = false;
+
         for existing_attestation in attestations.iter_mut() {
-            if existing_attestation.signers_disjoint_from(&indexed) {
-                existing_attestation.aggregate(&indexed);
-                aggregated = true;
+            if existing_attestation.should_aggregate(&indexed) {
+                aggregated = existing_attestation.aggregate(&indexed);
             } else if *existing_attestation == indexed {
                 aggregated = true;
             }
@@ -172,11 +328,93 @@ impl<E: EthSpec> AttestationMap<E> {
         }
     }
 
+    /// Aggregate Electra attestations for the same attestation data signed by different
+    /// committees.
+    ///
+    /// Non-Electra attestations are left as-is.
+    pub fn aggregate_across_committees(&mut self, checkpoint_key: CheckpointKey) {
+        let Some(attestation_map) = self.checkpoint_map.get_mut(&checkpoint_key) else {
+            return;
+        };
+        for compact_indexed_attestations in attestation_map.attestations.values_mut() {
+            let unaggregated_attestations = std::mem::take(compact_indexed_attestations);
+            let mut aggregated_attestations: Vec<CompactIndexedAttestation<E>> = vec![];
+
+            // Aggregate the best attestations for each committee and leave the rest.
+            let mut best_attestations_by_committee: BTreeMap<
+                u64,
+                CompactIndexedAttestationElectra<E>,
+            > = BTreeMap::new();
+
+            for committee_attestation in unaggregated_attestations {
+                let mut electra_attestation = match committee_attestation {
+                    CompactIndexedAttestation::Electra(att)
+                        if att.committee_bits.num_set_bits() == 1 =>
+                    {
+                        att
+                    }
+                    CompactIndexedAttestation::Electra(att) => {
+                        // Aggregate already covers multiple committees, leave it as-is.
+                        aggregated_attestations.push(CompactIndexedAttestation::Electra(att));
+                        continue;
+                    }
+                    CompactIndexedAttestation::Base(att) => {
+                        // Leave as-is.
+                        aggregated_attestations.push(CompactIndexedAttestation::Base(att));
+                        continue;
+                    }
+                };
+                if let Some(committee_index) = electra_attestation.committee_index() {
+                    if let Some(existing_attestation) =
+                        best_attestations_by_committee.get_mut(&committee_index)
+                    {
+                        // Search for the best (most aggregation bits) attestation for this committee
+                        // index.
+                        if electra_attestation.aggregation_bits.num_set_bits()
+                            > existing_attestation.aggregation_bits.num_set_bits()
+                        {
+                            // New attestation is better than the previously known one for this
+                            // committee. Replace it.
+                            std::mem::swap(existing_attestation, &mut electra_attestation);
+                        }
+                        // Put the inferior attestation into the list of aggregated attestations
+                        // without performing any cross-committee aggregation.
+                        aggregated_attestations
+                            .push(CompactIndexedAttestation::Electra(electra_attestation));
+                    } else {
+                        // First attestation seen for this committee. Place it in the map
+                        // provisionally.
+                        best_attestations_by_committee.insert(committee_index, electra_attestation);
+                    }
+                }
+            }
+
+            if let Some(on_chain_aggregate) =
+                Self::compute_on_chain_aggregate(best_attestations_by_committee)
+            {
+                aggregated_attestations
+                    .push(CompactIndexedAttestation::Electra(on_chain_aggregate));
+            }
+
+            *compact_indexed_attestations = aggregated_attestations;
+        }
+    }
+
+    pub fn compute_on_chain_aggregate(
+        mut attestations_by_committee: BTreeMap<u64, CompactIndexedAttestationElectra<E>>,
+    ) -> Option<CompactIndexedAttestationElectra<E>> {
+        let (_, mut on_chain_aggregate) = attestations_by_committee.pop_first()?;
+        for (_, attestation) in attestations_by_committee {
+            on_chain_aggregate.aggregate_with_disjoint_committees(&attestation);
+        }
+        Some(on_chain_aggregate)
+    }
+
     /// Iterate all attestations matching the given `checkpoint_key`.
     pub fn get_attestations<'a>(
         &'a self,
         checkpoint_key: &'a CheckpointKey,
-    ) -> impl Iterator<Item = AttestationRef<'a, E>> + 'a {
+    ) -> impl Iterator<Item = CompactAttestationRef<'a, E>> + 'a {
         self.checkpoint_map
             .get(checkpoint_key)
             .into_iter()
@@ -184,7 +422,7 @@ impl<E: EthSpec> AttestationMap<E> {
     }
 
     /// Iterate all attestations in the map.
-    pub fn iter(&self) -> impl Iterator<Item = AttestationRef<E>> {
+    pub fn iter(&self) -> impl Iterator<Item = CompactAttestationRef<E>> {
         self.checkpoint_map
             .iter()
             .flat_map(|(checkpoint_key, attestation_map)| attestation_map.iter(checkpoint_key))
@@ -215,9 +453,9 @@ impl<E: EthSpec> AttestationDataMap<E> {
     pub fn iter<'a>(
         &'a self,
         checkpoint_key: &'a CheckpointKey,
-    ) -> impl Iterator<Item = AttestationRef<'a, E>> + 'a {
+    ) -> impl Iterator<Item = CompactAttestationRef<'a, E>> + 'a {
         self.attestations.iter().flat_map(|(data, vec_indexed)| {
-            vec_indexed.iter().map(|indexed| AttestationRef {
+            vec_indexed.iter().map(|indexed| CompactAttestationRef {
                 checkpoint: checkpoint_key,
                 data,
                 indexed,