Committee-aware attestation packing

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_attestations.go

@@ -11,6 +11,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -112,18 +113,12 @@ func (vs *Server) packAttestations(ctx context.Context, latestState state.Beacon
 	if err != nil {
 		return nil, err
 	}
-	sorted, err := deduped.sortByProfitability()
+	sorted, err := deduped.sort()
 	if err != nil {
 		return nil, err
 	}
 	atts = sorted.limitToMaxAttestations()
-
-	atts, err = vs.filterAttestationBySignature(ctx, atts, latestState)
-	if err != nil {
-		return nil, err
-	}
-
-	return atts, nil
+	return vs.filterAttestationBySignature(ctx, atts, latestState)
 }
 
 // filter separates attestation list into two groups: valid and invalid attestations.
@@ -143,14 +138,6 @@ func (a proposerAtts) filter(ctx context.Context, st state.BeaconState) (propose
 	return validAtts, invalidAtts
 }
 
-// sortByProfitability orders attestations by highest slot and by highest aggregation bit count.
-func (a proposerAtts) sortByProfitability() (proposerAtts, error) {
-	if len(a) < 2 {
-		return a, nil
-	}
-	return a.sortByProfitabilityUsingMaxCover()
-}
-
 // sortByProfitabilityUsingMaxCover orders attestations by highest slot and by highest aggregation bit count.
 // Duplicate bits are counted only once, using max-cover algorithm.
 func (a proposerAtts) sortByProfitabilityUsingMaxCover() (proposerAtts, error) {
@@ -218,6 +205,143 @@ func (a proposerAtts) sortByProfitabilityUsingMaxCover() (proposerAtts, error) {
 	return sortedAtts, nil
 }
 
+// sort attestations as follows:
+//
+//   - all attestations selected by max-cover are taken, leftover attestations are discarded
+//     (with current parameters all bits of a leftover attestation are already covered by selected attestations)
+//   - selected attestations are ordered by slot, with higher slot coming first
+//   - within a slot, all top attestations (one per committee) are ordered before any second-best attestations, second-best before third-best etc.
+//   - within top/second-best/etc. attestations (one per committee), attestations are ordered by bit count, with higher bit count coming first
+func (a proposerAtts) sort() (proposerAtts, error) {
+	if len(a) < 2 {
+		return a, nil
+	}
+
+	if features.Get().EnableCommitteeAwarePacking {
+		return a.sortBySlotAndCommittee()
+	}
+	return a.sortByProfitabilityUsingMaxCover()
+}
+
+// Separate attestations by slot, as slot number takes higher precedence when sorting.
+// Also separate by committee index because maxcover will prefer attestations for the same
+// committee with disjoint bits over attestations for different committees with overlapping
+// bits, even though same bits for different committees are separate votes.
+func (a proposerAtts) sortBySlotAndCommittee() (proposerAtts, error) {
+	type slotAtts struct {
+		candidates map[primitives.CommitteeIndex]proposerAtts
+		selected   map[primitives.CommitteeIndex]proposerAtts
+		leftover   map[primitives.CommitteeIndex]proposerAtts
+	}
+
+	var slots []primitives.Slot
+	attsBySlot := map[primitives.Slot]*slotAtts{}
+	for _, att := range a {
+		slot := att.GetData().Slot
+		ci := att.GetData().CommitteeIndex
+		if _, ok := attsBySlot[slot]; !ok {
+			attsBySlot[slot] = &slotAtts{}
+			attsBySlot[slot].candidates = make(map[primitives.CommitteeIndex]proposerAtts)
+			slots = append(slots, slot)
+		}
+		attsBySlot[slot].candidates[ci] = append(attsBySlot[slot].candidates[ci], att)
+	}
+
+	var err error
+	for _, sa := range attsBySlot {
+		sa.selected = make(map[primitives.CommitteeIndex]proposerAtts)
+		sa.leftover = make(map[primitives.CommitteeIndex]proposerAtts)
+		for ci, committeeAtts := range sa.candidates {
+			sa.selected[ci], err = committeeAtts.sortByProfitabilityUsingMaxCover_committeeAwarePacking()
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	var sortedAtts proposerAtts
+	sort.Slice(slots, func(i, j int) bool {
+		return slots[i] > slots[j]
+	})
+	for _, slot := range slots {
+		sortedAtts = append(sortedAtts, sortSlotAttestations(attsBySlot[slot].selected)...)
+	}
+	for _, slot := range slots {
+		sortedAtts = append(sortedAtts, sortSlotAttestations(attsBySlot[slot].leftover)...)
+	}
+
+	return sortedAtts, nil
+}
+
+// sortByProfitabilityUsingMaxCover orders attestations by highest aggregation bit count.
+// Duplicate bits are counted only once, using max-cover algorithm.
+func (a proposerAtts) sortByProfitabilityUsingMaxCover_committeeAwarePacking() (proposerAtts, error) {
+	if len(a) < 2 {
+		return a, nil
+	}
+	candidates := make([]*bitfield.Bitlist64, len(a))
+	for i := 0; i < len(a); i++ {
+		var err error
+		candidates[i], err = a[i].GetAggregationBits().ToBitlist64()
+		if err != nil {
+			return nil, err
+		}
+	}
+	// Add selected candidates on top, those that are not selected - append at bottom.
+	selectedKeys, _, err := aggregation.MaxCover(candidates, len(candidates), true /* allowOverlaps */)
+	if err != nil {
+		log.WithError(err).Debug("MaxCover aggregation failed")
+		return a, nil
+	}
+
+	// Pick selected attestations first, leftover attestations will be appended at the end.
+	// Both lists will be sorted by number of bits set.
+	selected := make(proposerAtts, selectedKeys.Count())
+	for i, key := range selectedKeys.BitIndices() {
+		selected[i] = a[key]
+	}
+	sort.Slice(selected, func(i, j int) bool {
+		return selected[i].GetAggregationBits().Count() > selected[j].GetAggregationBits().Count()
+	})
+	return selected, nil
+}
+
+// sortSlotAttestations assumes each proposerAtts value in the map is ordered by profitability.
+// The function takes the first attestation from each value, orders these attestations by bit count
+// and places them at the start of the resulting slice. It then takes the second attestation for each value,
+// orders these attestations by bit count and appends them to the end.
+// It continues this pattern until all attestations are processed.
+func sortSlotAttestations(slotAtts map[primitives.CommitteeIndex]proposerAtts) proposerAtts {
+	attCount := 0
+	for _, committeeAtts := range slotAtts {
+		attCount += len(committeeAtts)
+	}
+
+	sorted := make([]ethpb.Att, 0, attCount)
+
+	processedCount := 0
+	index := 0
+	for processedCount < attCount {
+		var atts []ethpb.Att
+
+		for _, committeeAtts := range slotAtts {
+			if len(committeeAtts) > index {
+				atts = append(atts, committeeAtts[index])
+			}
+		}
+
+		sort.Slice(atts, func(i, j int) bool {
+			return atts[i].GetAggregationBits().Count() > atts[j].GetAggregationBits().Count()
+		})
+		sorted = append(sorted, atts...)
+
+		processedCount += len(atts)
+		index++
+	}
+
+	return sorted
+}
+
 // limitToMaxAttestations limits attestations to maximum attestations per block.
 func (a proposerAtts) limitToMaxAttestations() proposerAtts {
 	if len(a) == 0 {