EIP-7549: p2p and sync

beacon-chain/core/helpers/attestation.go

@@ -10,6 +10,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
@@ -91,6 +92,14 @@ func IsAggregated(attestation ethpb.Att) bool {
 //
 //	return uint64((committees_since_epoch_start + committee_index) % ATTESTATION_SUBNET_COUNT)
 func ComputeSubnetForAttestation(activeValCount uint64, att ethpb.Att) uint64 {
+	if att.Version() >= version.Electra {
+		committeeIndex := 0
+		committeeIndices := att.CommitteeBitsVal().BitIndices()
+		if len(committeeIndices) > 0 {
+			committeeIndex = committeeIndices[0]
+		}
+		return ComputeSubnetFromCommitteeAndSlot(activeValCount, primitives.CommitteeIndex(committeeIndex), att.GetData().Slot)
+	}
 	return ComputeSubnetFromCommitteeAndSlot(activeValCount, att.GetData().CommitteeIndex, att.GetData().Slot)
 }
 

beacon-chain/core/helpers/attestation_test.go

@@ -73,21 +73,37 @@ func TestAttestation_ComputeSubnetForAttestation(t *testing.T) {
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	att := &ethpb.Attestation{
-		AggregationBits: []byte{'A'},
-		Data: &ethpb.AttestationData{
-			Slot:            34,
-			CommitteeIndex:  4,
-			BeaconBlockRoot: []byte{'C'},
-			Source:          nil,
-			Target:          nil,
-		},
-		Signature: []byte{'B'},
-	}
-	valCount, err := helpers.ActiveValidatorCount(context.Background(), state, slots.ToEpoch(att.Data.Slot))
+	valCount, err := helpers.ActiveValidatorCount(context.Background(), state, slots.ToEpoch(34))
 	require.NoError(t, err)
-	sub := helpers.ComputeSubnetForAttestation(valCount, att)
-	assert.Equal(t, uint64(6), sub, "Did not get correct subnet for attestation")
+
+	t.Run("Phase 0", func(t *testing.T) {
+		att := &ethpb.Attestation{
+			AggregationBits: []byte{'A'},
+			Data: &ethpb.AttestationData{
+				Slot:            34,
+				CommitteeIndex:  4,
+				BeaconBlockRoot: []byte{'C'},
+			},
+			Signature: []byte{'B'},
+		}
+		sub := helpers.ComputeSubnetForAttestation(valCount, att)
+		assert.Equal(t, uint64(6), sub, "Did not get correct subnet for attestation")
+	})
+	t.Run("Electra", func(t *testing.T) {
+		cb := primitives.NewAttestationCommitteeBits()
+		cb.SetBitAt(4, true)
+		att := &ethpb.AttestationElectra{
+			AggregationBits: []byte{'A'},
+			CommitteeBits:   cb,
+			Data: &ethpb.AttestationData{
+				Slot:            34,
+				BeaconBlockRoot: []byte{'C'},
+			},
+			Signature: []byte{'B'},
+		}
+		sub := helpers.ComputeSubnetForAttestation(valCount, att)
+		assert.Equal(t, uint64(6), sub, "Did not get correct subnet for attestation")
+	})
 }
 
 func Test_ValidateAttestationTime(t *testing.T) {

beacon-chain/p2p/gossip_topic_mappings.go

@@ -27,7 +27,8 @@ var gossipTopicMappings = map[string]proto.Message{
 // GossipTopicMappings is a function to return the assigned data type
 // versioned by epoch.
 func GossipTopicMappings(topic string, epoch primitives.Epoch) proto.Message {
-	if topic == BlockSubnetTopicFormat {
+	switch topic {
+	case BlockSubnetTopicFormat:
 		if epoch >= params.BeaconConfig().ElectraForkEpoch {
 			return &ethpb.SignedBeaconBlockElectra{}
 		}
@@ -43,8 +44,25 @@ func GossipTopicMappings(topic string, epoch primitives.Epoch) proto.Message {
 		if epoch >= params.BeaconConfig().AltairForkEpoch {
 			return &ethpb.SignedBeaconBlockAltair{}
 		}
+		return gossipTopicMappings[topic]
+	case AttestationSubnetTopicFormat:
+		if epoch >= params.BeaconConfig().ElectraForkEpoch {
+			return &ethpb.AttestationElectra{}
+		}
+		return gossipTopicMappings[topic]
+	case AttesterSlashingSubnetTopicFormat:
+		if epoch >= params.BeaconConfig().ElectraForkEpoch {
+			return &ethpb.AttesterSlashingElectra{}
+		}
+		return gossipTopicMappings[topic]
+	case AggregateAndProofSubnetTopicFormat:
+		if epoch >= params.BeaconConfig().ElectraForkEpoch {
+			return &ethpb.SignedAggregateAttestationAndProofElectra{}
+		}
+		return gossipTopicMappings[topic]
+	default:
+		return gossipTopicMappings[topic]
 	}
-	return gossipTopicMappings[topic]
 }
 
 // AllTopics returns all topics stored in our
@@ -75,4 +93,7 @@ func init() {
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockDeneb{})] = BlockSubnetTopicFormat
 	// Specially handle Electra objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockElectra{})] = BlockSubnetTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.AttestationElectra{})] = AttestationSubnetTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.AttesterSlashingElectra{})] = AttesterSlashingSubnetTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedAggregateAttestationAndProofElectra{})] = AggregateAndProofSubnetTopicFormat
 }

beacon-chain/p2p/gossip_topic_mappings_test.go

@@ -22,20 +22,20 @@ func TestMappingHasNoDuplicates(t *testing.T) {
 	}
 }
 
-func TestGossipTopicMappings_CorrectBlockType(t *testing.T) {
+func TestGossipTopicMappings_CorrectType(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	bCfg := params.BeaconConfig().Copy()
 	altairForkEpoch := primitives.Epoch(100)
-	BellatrixForkEpoch := primitives.Epoch(200)
-	CapellaForkEpoch := primitives.Epoch(300)
-	DenebForkEpoch := primitives.Epoch(400)
-	ElectraForkEpoch := primitives.Epoch(500)
+	bellatrixForkEpoch := primitives.Epoch(200)
+	capellaForkEpoch := primitives.Epoch(300)
+	denebForkEpoch := primitives.Epoch(400)
+	electraForkEpoch := primitives.Epoch(500)
 
 	bCfg.AltairForkEpoch = altairForkEpoch
-	bCfg.BellatrixForkEpoch = BellatrixForkEpoch
-	bCfg.CapellaForkEpoch = CapellaForkEpoch
-	bCfg.DenebForkEpoch = DenebForkEpoch
-	bCfg.ElectraForkEpoch = ElectraForkEpoch
+	bCfg.BellatrixForkEpoch = bellatrixForkEpoch
+	bCfg.CapellaForkEpoch = capellaForkEpoch
+	bCfg.DenebForkEpoch = denebForkEpoch
+	bCfg.ElectraForkEpoch = electraForkEpoch
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.AltairForkVersion)] = primitives.Epoch(100)
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.BellatrixForkVersion)] = primitives.Epoch(200)
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.CapellaForkVersion)] = primitives.Epoch(300)
@@ -47,29 +47,83 @@ func TestGossipTopicMappings_CorrectBlockType(t *testing.T) {
 	pMessage := GossipTopicMappings(BlockSubnetTopicFormat, 0)
 	_, ok := pMessage.(*ethpb.SignedBeaconBlock)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, 0)
+	_, ok = pMessage.(*ethpb.Attestation)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, 0)
+	_, ok = pMessage.(*ethpb.AttesterSlashing)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, 0)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
+	assert.Equal(t, true, ok)
 
 	// Altair Fork
 	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, altairForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockAltair)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, altairForkEpoch)
+	_, ok = pMessage.(*ethpb.Attestation)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, altairForkEpoch)
+	_, ok = pMessage.(*ethpb.AttesterSlashing)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, altairForkEpoch)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
+	assert.Equal(t, true, ok)
 
 	// Bellatrix Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, BellatrixForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, bellatrixForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockBellatrix)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, bellatrixForkEpoch)
+	_, ok = pMessage.(*ethpb.Attestation)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, bellatrixForkEpoch)
+	_, ok = pMessage.(*ethpb.AttesterSlashing)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, bellatrixForkEpoch)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
+	assert.Equal(t, true, ok)
 
 	// Capella Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, CapellaForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, capellaForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockCapella)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, capellaForkEpoch)
+	_, ok = pMessage.(*ethpb.Attestation)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, capellaForkEpoch)
+	_, ok = pMessage.(*ethpb.AttesterSlashing)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, capellaForkEpoch)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
+	assert.Equal(t, true, ok)
 
 	// Deneb Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, DenebForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, denebForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockDeneb)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, denebForkEpoch)
+	_, ok = pMessage.(*ethpb.Attestation)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, denebForkEpoch)
+	_, ok = pMessage.(*ethpb.AttesterSlashing)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, denebForkEpoch)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
+	assert.Equal(t, true, ok)
 
 	// Electra Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, ElectraForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, electraForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockElectra)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, electraForkEpoch)
+	_, ok = pMessage.(*ethpb.AttestationElectra)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, electraForkEpoch)
+	_, ok = pMessage.(*ethpb.AttesterSlashingElectra)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, electraForkEpoch)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProofElectra)
+	assert.Equal(t, true, ok)
 }

beacon-chain/p2p/types/BUILD.bazel

@@ -43,6 +43,7 @@ go_test(
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",

beacon-chain/p2p/types/object_mapping.go

@@ -26,7 +26,13 @@ var (
 	BlockMap map[[4]byte]func() (interfaces.ReadOnlySignedBeaconBlock, error)
 	// MetaDataMap maps the fork-version to the underlying data type for that
 	// particular fork period.
-	MetaDataMap map[[4]byte]func() metadata.Metadata
+	MetaDataMap map[[4]byte]func() (metadata.Metadata, error)
+	// AttestationMap maps the fork-version to the underlying data type for that
+	// particular fork period.
+	AttestationMap map[[4]byte]func() (ethpb.Att, error)
+	// AggregateAttestationMap maps the fork-version to the underlying data type for that
+	// particular fork period.
+	AggregateAttestationMap map[[4]byte]func() (ethpb.SignedAggregateAttAndProof, error)
 )
 
 // InitializeDataMaps initializes all the relevant object maps. This function is called to
@@ -67,24 +73,68 @@ func InitializeDataMaps() {
 	}
 
 	// Reset our metadata map.
-	MetaDataMap = map[[4]byte]func() metadata.Metadata{
-		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV0(&ethpb.MetaDataV0{})
+	MetaDataMap = map[[4]byte]func() (metadata.Metadata, error){
+		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV0(&ethpb.MetaDataV0{}), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
+		},
+	}
+
+	// Reset our attestation map.
+	AttestationMap = map[[4]byte]func() (ethpb.Att, error){
+		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.Attestation{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.Attestation{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.Attestation{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.Attestation{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.Attestation{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.AttestationElectra{}, nil
+		},
+	}
+
+	// Reset our aggregate attestation map.
+	AggregateAttestationMap = map[[4]byte]func() (ethpb.SignedAggregateAttAndProof, error){
+		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProof{}, nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
+		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProof{}, nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
+		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProof{}, nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
+		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProof{}, nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
+		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProof{}, nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
+		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProofElectra{}, nil
 		},
 	}
 }

beacon-chain/p2p/types/object_mapping_test.go

@@ -5,7 +5,9 @@ import (
 
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
 
 func TestInitializeDataMaps(t *testing.T) {
@@ -44,8 +46,36 @@ func TestInitializeDataMaps(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			tt.action()
-			_, ok := BlockMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+			bFunc, ok := BlockMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
 			assert.Equal(t, tt.exists, ok)
+			if tt.exists {
+				b, err := bFunc()
+				require.NoError(t, err)
+				generic, err := b.PbGenericBlock()
+				require.NoError(t, err)
+				assert.NotNil(t, generic.GetPhase0())
+			}
+			mdFunc, ok := MetaDataMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+			if tt.exists {
+				md, err := mdFunc()
+				require.NoError(t, err)
+				assert.NotNil(t, md.MetadataObjV0())
+			}
+			assert.Equal(t, tt.exists, ok)
+			attFunc, ok := AttestationMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+			if tt.exists {
+				att, err := attFunc()
+				require.NoError(t, err)
+				assert.Equal(t, version.Phase0, att.Version())
+			}
+			assert.Equal(t, tt.exists, ok)
+			aggFunc, ok := AggregateAttestationMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+			assert.Equal(t, tt.exists, ok)
+			if tt.exists {
+				agg, err := aggFunc()
+				require.NoError(t, err)
+				assert.Equal(t, version.Phase0, agg.Version())
+			}
 		})
 	}
 }