Merge branch 'develop' into deflake-evaluator

**What type of PR is this?**

Feature

**What does this PR do? Why is it needed?**

This PR allows devs to test against a specific run of the nightly
reference test generator.

**Acknowledgements**

- [x] I have read
[CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md).
- [x] I have included a uniquely named [changelog fragment
file](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md#maintaining-changelogmd).
- [x] I have added a description with sufficient context for reviewers
to understand this PR.
- [x] I have tested that my changes work as expected and I added a
testing plan to the PR description (if applicable).

api/server/structs/block.go

@@ -540,12 +540,6 @@ type PayloadAttestation struct {
 	Signature       string                  `json:"signature"`
 }
 
-type PayloadAttestationMessage struct {
-	ValidatorIndex string                  `json:"validator_index"`
-	Data           *PayloadAttestationData `json:"data"`
-	Signature      string                  `json:"signature"`
-}
-
 type BeaconBlockBodyGloas struct {
 	RandaoReveal              string                        `json:"randao_reveal"`
 	Eth1Data                  *Eth1Data                     `json:"eth1_data"`

api/server/structs/conversions_block.go

@@ -3263,34 +3263,3 @@ func (d *PayloadAttestationData) ToConsensus() (*eth.PayloadAttestationData, err
 		BlobDataAvailable: d.BlobDataAvailable,
 	}, nil
 }
-
-func PayloadAttestationMessageFromConsensus(msg *eth.PayloadAttestationMessage) *PayloadAttestationMessage {
-	return &PayloadAttestationMessage{
-		ValidatorIndex: fmt.Sprintf("%d", msg.ValidatorIndex),
-		Data:           PayloadAttestationDataFromConsensus(msg.Data),
-		Signature:      hexutil.Encode(msg.Signature),
-	}
-}
-
-func (p *PayloadAttestationMessage) ToConsensus() (*eth.PayloadAttestationMessage, error) {
-	if p == nil {
-		return nil, errNilValue
-	}
-	validatorIndex, err := strconv.ParseUint(p.ValidatorIndex, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ValidatorIndex")
-	}
-	data, err := p.Data.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Data")
-	}
-	sig, err := bytesutil.DecodeHexWithLength(p.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	return &eth.PayloadAttestationMessage{
-		ValidatorIndex: primitives.ValidatorIndex(validatorIndex),
-		Data:           data,
-		Signature:      sig,
-	}, nil
-}

api/server/structs/endpoints_beacon.go

@@ -188,11 +188,6 @@ type BLSToExecutionChangesPoolResponse struct {
 	Data []*SignedBLSToExecutionChange `json:"data"`
 }
 
-type GetPoolPayloadAttestationsResponse struct {
-	Version string                `json:"version"`
-	Data    []*PayloadAttestation `json:"data"`
-}
-
 type GetAttesterSlashingsResponse struct {
 	Version string          `json:"version,omitempty"`
 	Data    json.RawMessage `json:"data"` // Accepts both `[]*AttesterSlashing` and `[]*AttesterSlashingElectra` types

api/server/structs/endpoints_validator.go

@@ -31,11 +31,6 @@ type GetAttestationDataResponse struct {
 	Data *AttestationData `json:"data"`
 }
 
-type GetPayloadAttestationDataResponse struct {
-	Version string                  `json:"version"`
-	Data    *PayloadAttestationData `json:"data"`
-}
-
 type ProduceSyncCommitteeContributionResponse struct {
 	Data *SyncCommitteeContribution `json:"data"`
 }

beacon-chain/node/BUILD.bazel

@@ -37,7 +37,6 @@ go_library(
         "//beacon-chain/node/registration:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",
-        "//beacon-chain/operations/payloadattestation:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/synccommittee:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",

beacon-chain/node/node.go

@@ -40,7 +40,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/node/registration"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/blstoexec"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/payloadattestation"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/slashings"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/synccommittee"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/voluntaryexits"
@@ -102,7 +101,6 @@ type BeaconNode struct {
 	slashingsPool            slashings.PoolManager
 	syncCommitteePool        synccommittee.Pool
 	blsToExecPool            blstoexec.PoolManager
-	payloadAttestationPool   payloadattestation.PoolManager
 	depositCache             cache.DepositCache
 	trackedValidatorsCache   *cache.TrackedValidatorsCache
 	payloadIDCache           *cache.PayloadIDCache
@@ -157,7 +155,6 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 		slashingsPool:           slashings.NewPool(),
 		syncCommitteePool:       synccommittee.NewPool(),
 		blsToExecPool:           blstoexec.NewPool(),
-		payloadAttestationPool:  payloadattestation.NewPool(),
 		trackedValidatorsCache:  cache.NewTrackedValidatorsCache(),
 		payloadIDCache:          cache.NewPayloadIDCache(),
 		slasherBlockHeadersFeed: new(event.Feed),
@@ -975,7 +972,6 @@ func (b *BeaconNode) registerRPCService(router *http.ServeMux) error {
 		SlashingsPool:             b.slashingsPool,
 		BLSChangesPool:            b.blsToExecPool,
 		SyncCommitteeObjectPool:   b.syncCommitteePool,
-		PayloadAttestationPool:    b.payloadAttestationPool,
 		ExecutionChainService:     web3Service,
 		ExecutionChainInfoFetcher: web3Service,
 		ChainStartFetcher:         chainStartFetcher,

beacon-chain/operations/payloadattestation/BUILD.bazel

@@ -1,27 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["pool.go"],
-    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/operations/payloadattestation",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/hash:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["pool_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//consensus-types/primitives:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-    ],
-)

beacon-chain/operations/payloadattestation/pool.go

@@ -1,108 +0,0 @@
-package payloadattestation
-
-import (
-	"sync"
-
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/crypto/hash"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/pkg/errors"
-	"google.golang.org/protobuf/proto"
-)
-
-// PoolManager maintains pending payload attestations.
-// This pool is used by proposers to insert payload attestations into new blocks.
-type PoolManager interface {
-	PendingPayloadAttestations(slot ...primitives.Slot) []*ethpb.PayloadAttestation
-	InsertPayloadAttestation(msg *ethpb.PayloadAttestationMessage) error
-	MarkIncluded(att *ethpb.PayloadAttestation)
-}
-
-// Pool is a concrete implementation of PoolManager.
-type Pool struct {
-	lock    sync.RWMutex
-	pending map[[32]byte]*ethpb.PayloadAttestation
-}
-
-// NewPool returns an initialized pool.
-func NewPool() *Pool {
-	return &Pool{
-		pending: make(map[[32]byte]*ethpb.PayloadAttestation),
-	}
-}
-
-// PendingPayloadAttestations returns all pending payload attestations from the pool.
-// If a slot is provided, only attestations for that slot are returned.
-func (p *Pool) PendingPayloadAttestations(slot ...primitives.Slot) []*ethpb.PayloadAttestation {
-	p.lock.RLock()
-	defer p.lock.RUnlock()
-
-	result := make([]*ethpb.PayloadAttestation, 0, len(p.pending))
-	for _, att := range p.pending {
-		if len(slot) > 0 && att.Data.Slot != slot[0] {
-			continue
-		}
-		result = append(result, att)
-	}
-	return result
-}
-
-// InsertPayloadAttestation inserts a payload attestation message into the pool.
-// The message is converted to an aggregated PayloadAttestation and merged with
-// any existing attestation that has matching PayloadAttestationData.
-func (p *Pool) InsertPayloadAttestation(msg *ethpb.PayloadAttestationMessage) error {
-	if msg == nil || msg.Data == nil {
-		return errors.New("nil payload attestation message")
-	}
-
-	key, err := dataKey(msg.Data)
-	if err != nil {
-		return errors.Wrap(err, "could not compute data key")
-	}
-
-	p.lock.Lock()
-	defer p.lock.Unlock()
-
-	existing, ok := p.pending[key]
-	if !ok {
-		// Create a new aggregated PayloadAttestation from this message.
-		p.pending[key] = &ethpb.PayloadAttestation{
-			AggregationBits: []byte{},
-			Data:            proto.Clone(msg.Data).(*ethpb.PayloadAttestationData),
-			Signature:       msg.Signature,
-		}
-		return nil
-	}
-
-	// Merge: for now just replace the signature since proper BLS aggregation
-	// requires knowing the PTC committee position. Full aggregation is a TODO.
-	_ = existing
-	return nil
-}
-
-// MarkIncluded removes the attestation with matching data from the pool.
-func (p *Pool) MarkIncluded(att *ethpb.PayloadAttestation) {
-	if att == nil || att.Data == nil {
-		return
-	}
-
-	key, err := dataKey(att.Data)
-	if err != nil {
-		return
-	}
-
-	p.lock.Lock()
-	defer p.lock.Unlock()
-
-	delete(p.pending, key)
-}
-
-// dataKey computes a deterministic key for PayloadAttestationData
-// by hashing its serialized form.
-func dataKey(data *ethpb.PayloadAttestationData) ([32]byte, error) {
-	enc, err := proto.Marshal(data)
-	if err != nil {
-		return [32]byte{}, err
-	}
-	return hash.Hash(enc), nil
-}

beacon-chain/operations/payloadattestation/pool_test.go

@@ -1,201 +0,0 @@
-package payloadattestation
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/assert"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func TestPool_PendingPayloadAttestations(t *testing.T) {
-	t.Run("empty pool", func(t *testing.T) {
-		pool := NewPool()
-		atts := pool.PendingPayloadAttestations()
-		assert.Equal(t, 0, len(atts))
-	})
-
-	t.Run("non-empty pool", func(t *testing.T) {
-		pool := NewPool()
-		msg1 := &ethpb.PayloadAttestationMessage{
-			ValidatorIndex: 0,
-			Data: &ethpb.PayloadAttestationData{
-				BeaconBlockRoot:   make([]byte, 32),
-				Slot:              1,
-				PayloadPresent:    true,
-				BlobDataAvailable: false,
-			},
-			Signature: make([]byte, 96),
-		}
-		msg2 := &ethpb.PayloadAttestationMessage{
-			ValidatorIndex: 1,
-			Data: &ethpb.PayloadAttestationData{
-				BeaconBlockRoot:   make([]byte, 32),
-				Slot:              2,
-				PayloadPresent:    false,
-				BlobDataAvailable: true,
-			},
-			Signature: make([]byte, 96),
-		}
-		require.NoError(t, pool.InsertPayloadAttestation(msg1))
-		require.NoError(t, pool.InsertPayloadAttestation(msg2))
-		atts := pool.PendingPayloadAttestations()
-		assert.Equal(t, 2, len(atts))
-	})
-
-	t.Run("filter by slot", func(t *testing.T) {
-		pool := NewPool()
-		msg1 := &ethpb.PayloadAttestationMessage{
-			ValidatorIndex: 0,
-			Data: &ethpb.PayloadAttestationData{
-				BeaconBlockRoot:   make([]byte, 32),
-				Slot:              1,
-				PayloadPresent:    true,
-				BlobDataAvailable: false,
-			},
-			Signature: make([]byte, 96),
-		}
-		msg2 := &ethpb.PayloadAttestationMessage{
-			ValidatorIndex: 1,
-			Data: &ethpb.PayloadAttestationData{
-				BeaconBlockRoot:   make([]byte, 32),
-				Slot:              2,
-				PayloadPresent:    false,
-				BlobDataAvailable: true,
-			},
-			Signature: make([]byte, 96),
-		}
-		require.NoError(t, pool.InsertPayloadAttestation(msg1))
-		require.NoError(t, pool.InsertPayloadAttestation(msg2))
-
-		atts := pool.PendingPayloadAttestations(primitives.Slot(1))
-		assert.Equal(t, 1, len(atts))
-		assert.Equal(t, primitives.Slot(1), atts[0].Data.Slot)
-
-		atts = pool.PendingPayloadAttestations(primitives.Slot(2))
-		assert.Equal(t, 1, len(atts))
-		assert.Equal(t, primitives.Slot(2), atts[0].Data.Slot)
-
-		atts = pool.PendingPayloadAttestations(primitives.Slot(99))
-		assert.Equal(t, 0, len(atts))
-	})
-}
-
-func TestPool_InsertPayloadAttestation(t *testing.T) {
-	t.Run("nil message", func(t *testing.T) {
-		pool := NewPool()
-		err := pool.InsertPayloadAttestation(nil)
-		require.ErrorContains(t, "nil payload attestation message", err)
-	})
-
-	t.Run("nil data", func(t *testing.T) {
-		pool := NewPool()
-		err := pool.InsertPayloadAttestation(&ethpb.PayloadAttestationMessage{})
-		require.ErrorContains(t, "nil payload attestation message", err)
-	})
-
-	t.Run("insert creates new entry", func(t *testing.T) {
-		pool := NewPool()
-		msg := &ethpb.PayloadAttestationMessage{
-			ValidatorIndex: 0,
-			Data: &ethpb.PayloadAttestationData{
-				BeaconBlockRoot:   make([]byte, 32),
-				Slot:              1,
-				PayloadPresent:    true,
-				BlobDataAvailable: false,
-			},
-			Signature: make([]byte, 96),
-		}
-		require.NoError(t, pool.InsertPayloadAttestation(msg))
-		atts := pool.PendingPayloadAttestations()
-		assert.Equal(t, 1, len(atts))
-	})
-
-	t.Run("duplicate data does not create second entry", func(t *testing.T) {
-		pool := NewPool()
-		msg1 := &ethpb.PayloadAttestationMessage{
-			ValidatorIndex: 0,
-			Data: &ethpb.PayloadAttestationData{
-				BeaconBlockRoot:   make([]byte, 32),
-				Slot:              1,
-				PayloadPresent:    true,
-				BlobDataAvailable: false,
-			},
-			Signature: make([]byte, 96),
-		}
-		msg2 := &ethpb.PayloadAttestationMessage{
-			ValidatorIndex: 1,
-			Data: &ethpb.PayloadAttestationData{
-				BeaconBlockRoot:   make([]byte, 32),
-				Slot:              1,
-				PayloadPresent:    true,
-				BlobDataAvailable: false,
-			},
-			Signature: make([]byte, 96),
-		}
-		require.NoError(t, pool.InsertPayloadAttestation(msg1))
-		require.NoError(t, pool.InsertPayloadAttestation(msg2))
-		atts := pool.PendingPayloadAttestations()
-		assert.Equal(t, 1, len(atts))
-	})
-}
-
-func TestPool_MarkIncluded(t *testing.T) {
-	t.Run("mark included removes from pool", func(t *testing.T) {
-		pool := NewPool()
-		msg := &ethpb.PayloadAttestationMessage{
-			ValidatorIndex: 0,
-			Data: &ethpb.PayloadAttestationData{
-				BeaconBlockRoot:   make([]byte, 32),
-				Slot:              1,
-				PayloadPresent:    true,
-				BlobDataAvailable: false,
-			},
-			Signature: make([]byte, 96),
-		}
-		require.NoError(t, pool.InsertPayloadAttestation(msg))
-		assert.Equal(t, 1, len(pool.PendingPayloadAttestations()))
-
-		pool.MarkIncluded(&ethpb.PayloadAttestation{
-			Data: &ethpb.PayloadAttestationData{
-				BeaconBlockRoot:   make([]byte, 32),
-				Slot:              1,
-				PayloadPresent:    true,
-				BlobDataAvailable: false,
-			},
-		})
-		assert.Equal(t, 0, len(pool.PendingPayloadAttestations()))
-	})
-
-	t.Run("mark included with non-matching data does nothing", func(t *testing.T) {
-		pool := NewPool()
-		msg := &ethpb.PayloadAttestationMessage{
-			ValidatorIndex: 0,
-			Data: &ethpb.PayloadAttestationData{
-				BeaconBlockRoot:   make([]byte, 32),
-				Slot:              1,
-				PayloadPresent:    true,
-				BlobDataAvailable: false,
-			},
-			Signature: make([]byte, 96),
-		}
-		require.NoError(t, pool.InsertPayloadAttestation(msg))
-
-		pool.MarkIncluded(&ethpb.PayloadAttestation{
-			Data: &ethpb.PayloadAttestationData{
-				BeaconBlockRoot:   make([]byte, 32),
-				Slot:              999,
-				PayloadPresent:    true,
-				BlobDataAvailable: false,
-			},
-		})
-		assert.Equal(t, 1, len(pool.PendingPayloadAttestations()))
-	})
-
-	t.Run("mark included with nil is safe", func(t *testing.T) {
-		pool := NewPool()
-		pool.MarkIncluded(nil)
-		pool.MarkIncluded(&ethpb.PayloadAttestation{})
-	})
-}

beacon-chain/rpc/BUILD.bazel

@@ -26,7 +26,6 @@ go_library(
         "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",
-        "//beacon-chain/operations/payloadattestation:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/synccommittee:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",

beacon-chain/rpc/endpoints.go

@@ -217,7 +217,6 @@ func (s *Service) validatorEndpoints(
 		OperationNotifier:      s.cfg.OperationNotifier,
 		TrackedValidatorsCache: s.cfg.TrackedValidatorsCache,
 		PayloadIDCache:         s.cfg.PayloadIDCache,
-		PayloadAttestationPool: s.cfg.PayloadAttestationPool,
 		CoreService:            coreService,
 		BlockRewardFetcher:     rewardFetcher,
 	}
@@ -391,16 +390,6 @@ func (s *Service) validatorEndpoints(
 			handler: server.SyncCommitteeSelections,
 			methods: []string{http.MethodPost},
 		},
-		{
-			template: "/eth/v1/validator/payload_attestation_data/{slot}",
-			name:     namespace + ".GetPayloadAttestationData",
-			middleware: []middleware.Middleware{
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType, api.OctetStreamMediaType}),
-				middleware.AcceptEncodingHeaderHandler(),
-			},
-			handler: server.GetPayloadAttestationData,
-			methods: []string{http.MethodGet},
-		},
 	}
 }
 
@@ -523,7 +512,6 @@ func (s *Service) beaconEndpoints(
 		SyncChecker:             s.cfg.SyncService,
 		ExecutionReconstructor:  s.cfg.ExecutionReconstructor,
 		BLSChangesPool:          s.cfg.BLSChangesPool,
-		PayloadAttestationPool:  s.cfg.PayloadAttestationPool,
 		FinalizationFetcher:     s.cfg.FinalizationFetcher,
 		ForkchoiceFetcher:       s.cfg.ForkchoiceFetcher,
 		CoreService:             coreService,
@@ -881,27 +869,6 @@ func (s *Service) beaconEndpoints(
 			handler: server.GetProposerLookahead,
 			methods: []string{http.MethodGet},
 		},
-		{
-			template: "/eth/v1/beacon/pool/payload_attestations",
-			name:     namespace + ".ListPayloadAttestations",
-			middleware: []middleware.Middleware{
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
-				middleware.AcceptEncodingHeaderHandler(),
-			},
-			handler: server.ListPayloadAttestations,
-			methods: []string{http.MethodGet},
-		},
-		{
-			template: "/eth/v1/beacon/pool/payload_attestations",
-			name:     namespace + ".SubmitPayloadAttestations",
-			middleware: []middleware.Middleware{
-				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
-				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
-				middleware.AcceptEncodingHeaderHandler(),
-			},
-			handler: server.SubmitPayloadAttestations,
-			methods: []string{http.MethodPost},
-		},
 	}
 }
 

beacon-chain/rpc/endpoints_test.go

@@ -48,7 +48,6 @@ func Test_endpoints(t *testing.T) {
 		"/eth/v1/beacon/pool/sync_committees":                          {http.MethodPost},
 		"/eth/v1/beacon/pool/voluntary_exits":                          {http.MethodGet, http.MethodPost},
 		"/eth/v1/beacon/pool/bls_to_execution_changes":                 {http.MethodGet, http.MethodPost},
-		"/eth/v1/beacon/pool/payload_attestations":                     {http.MethodGet, http.MethodPost},
 		"/prysm/v1/beacon/individual_votes":                            {http.MethodPost},
 	}
 
@@ -92,23 +91,22 @@ func Test_endpoints(t *testing.T) {
 	}
 
 	validatorRoutes := map[string][]string{
-		"/eth/v1/validator/duties/attester/{epoch}":         {http.MethodPost},
-		"/eth/v1/validator/duties/proposer/{epoch}":         {http.MethodGet},
-		"/eth/v1/validator/duties/sync/{epoch}":             {http.MethodPost},
-		"/eth/v3/validator/blocks/{slot}":                   {http.MethodGet},
-		"/eth/v1/validator/attestation_data":                {http.MethodGet},
-		"/eth/v2/validator/aggregate_attestation":           {http.MethodGet},
-		"/eth/v2/validator/aggregate_and_proofs":            {http.MethodPost},
-		"/eth/v1/validator/beacon_committee_subscriptions":  {http.MethodPost},
-		"/eth/v1/validator/sync_committee_subscriptions":    {http.MethodPost},
-		"/eth/v1/validator/beacon_committee_selections":     {http.MethodPost},
-		"/eth/v1/validator/sync_committee_selections":       {http.MethodPost},
-		"/eth/v1/validator/sync_committee_contribution":     {http.MethodGet},
-		"/eth/v1/validator/contribution_and_proofs":         {http.MethodPost},
-		"/eth/v1/validator/prepare_beacon_proposer":         {http.MethodPost},
-		"/eth/v1/validator/register_validator":              {http.MethodPost},
-		"/eth/v1/validator/liveness/{epoch}":                {http.MethodPost},
-		"/eth/v1/validator/payload_attestation_data/{slot}": {http.MethodGet},
+		"/eth/v1/validator/duties/attester/{epoch}":        {http.MethodPost},
+		"/eth/v1/validator/duties/proposer/{epoch}":        {http.MethodGet},
+		"/eth/v1/validator/duties/sync/{epoch}":            {http.MethodPost},
+		"/eth/v3/validator/blocks/{slot}":                  {http.MethodGet},
+		"/eth/v1/validator/attestation_data":               {http.MethodGet},
+		"/eth/v2/validator/aggregate_attestation":          {http.MethodGet},
+		"/eth/v2/validator/aggregate_and_proofs":           {http.MethodPost},
+		"/eth/v1/validator/beacon_committee_subscriptions": {http.MethodPost},
+		"/eth/v1/validator/sync_committee_subscriptions":   {http.MethodPost},
+		"/eth/v1/validator/beacon_committee_selections":    {http.MethodPost},
+		"/eth/v1/validator/sync_committee_selections":      {http.MethodPost},
+		"/eth/v1/validator/sync_committee_contribution":    {http.MethodGet},
+		"/eth/v1/validator/contribution_and_proofs":        {http.MethodPost},
+		"/eth/v1/validator/prepare_beacon_proposer":        {http.MethodPost},
+		"/eth/v1/validator/register_validator":             {http.MethodPost},
+		"/eth/v1/validator/liveness/{epoch}":               {http.MethodPost},
 	}
 
 	prysmBeaconRoutes := map[string][]string{

beacon-chain/rpc/eth/beacon/BUILD.bazel

@@ -32,7 +32,6 @@ go_library(
         "//beacon-chain/execution:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",
-        "//beacon-chain/operations/payloadattestation:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",

beacon-chain/rpc/eth/beacon/handlers_pool.go

@@ -893,89 +893,3 @@ func (s *Server) SubmitProposerSlashing(w http.ResponseWriter, r *http.Request)
 		}
 	}
 }
-
-// SubmitPayloadAttestations submits payload attestation messages to the node's pool.
-func (s *Server) SubmitPayloadAttestations(w http.ResponseWriter, r *http.Request) {
-	ctx, span := trace.StartSpan(r.Context(), "beacon.SubmitPayloadAttestations")
-	defer span.End()
-
-	if shared.IsSyncing(ctx, w, s.SyncChecker, s.HeadFetcher, s.TimeFetcher, s.OptimisticModeFetcher) {
-		return
-	}
-
-	versionHeader := r.Header.Get(api.VersionHeader)
-	if versionHeader == "" {
-		httputil.HandleError(w, api.VersionHeader+" header is required", http.StatusBadRequest)
-		return
-	}
-
-	var msgs []*structs.PayloadAttestationMessage
-	if err := json.NewDecoder(r.Body).Decode(&msgs); err != nil {
-		httputil.HandleError(w, "Could not decode request body: "+err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	var failures []*server.IndexedError
-	for i, msg := range msgs {
-		consensusMsg, err := msg.ToConsensus()
-		if err != nil {
-			failures = append(failures, &server.IndexedError{
-				Index:   i,
-				Message: "Could not convert message: " + err.Error(),
-			})
-			continue
-		}
-
-		// TODO: Add full gossip validation (BLS signatures, PTC membership).
-		if err := s.PayloadAttestationPool.InsertPayloadAttestation(consensusMsg); err != nil {
-			failures = append(failures, &server.IndexedError{
-				Index:   i,
-				Message: "Could not insert payload attestation: " + err.Error(),
-			})
-			continue
-		}
-
-		if err := s.Broadcaster.Broadcast(ctx, consensusMsg); err != nil {
-			log.WithError(err).Error("Could not broadcast payload attestation message")
-		}
-	}
-
-	if len(failures) > 0 {
-		failuresErr := &server.IndexedErrorContainer{
-			Code:     http.StatusBadRequest,
-			Message:  server.ErrIndexedValidationFail,
-			Failures: failures,
-		}
-		httputil.WriteError(w, failuresErr)
-		return
-	}
-}
-
-// ListPayloadAttestations retrieves payload attestations from the pool.
-func (s *Server) ListPayloadAttestations(w http.ResponseWriter, r *http.Request) {
-	_, span := trace.StartSpan(r.Context(), "beacon.ListPayloadAttestations")
-	defer span.End()
-
-	rawSlot, slot, ok := shared.UintFromQuery(w, r, "slot", false)
-	if !ok {
-		return
-	}
-
-	var atts []*eth.PayloadAttestation
-	if rawSlot != "" {
-		atts = s.PayloadAttestationPool.PendingPayloadAttestations(primitives.Slot(slot))
-	} else {
-		atts = s.PayloadAttestationPool.PendingPayloadAttestations()
-	}
-
-	data := make([]*structs.PayloadAttestation, len(atts))
-	for i, att := range atts {
-		data[i] = structs.PayloadAttestationFromConsensus(att)
-	}
-
-	w.Header().Set(api.VersionHeader, version.String(version.Gloas))
-	httputil.WriteJson(w, &structs.GetPoolPayloadAttestationsResponse{
-		Version: version.String(version.Gloas),
-		Data:    data,
-	})
-}

beacon-chain/rpc/eth/beacon/server.go

@@ -12,7 +12,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/execution"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/blstoexec"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/payloadattestation"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/slashings"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/voluntaryexits"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
@@ -49,7 +48,6 @@ type Server struct {
 	ExecutionReconstructor  execution.Reconstructor
 	FinalizationFetcher     blockchain.FinalizationFetcher
 	BLSChangesPool          blstoexec.PoolManager
-	PayloadAttestationPool  payloadattestation.PoolManager
 	ForkchoiceFetcher       blockchain.ForkchoiceFetcher
 	CoreService             *core.Service
 	AttestationStateFetcher blockchain.AttestationStateFetcher

beacon-chain/rpc/eth/validator/BUILD.bazel

@@ -21,7 +21,6 @@ go_library(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
-        "//beacon-chain/operations/payloadattestation:go_default_library",
         "//beacon-chain/operations/synccommittee:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",

beacon-chain/rpc/eth/validator/handlers.go

@@ -1427,54 +1427,3 @@ func sortProposerDuties(duties []*structs.ProposerDuty) error {
 	})
 	return err
 }
-
-// GetPayloadAttestationData produces payload attestation data for the requested slot.
-func (s *Server) GetPayloadAttestationData(w http.ResponseWriter, r *http.Request) {
-	ctx, span := trace.StartSpan(r.Context(), "validator.GetPayloadAttestationData")
-	defer span.End()
-
-	if shared.IsSyncing(ctx, w, s.SyncChecker, s.HeadFetcher, s.TimeFetcher, s.OptimisticModeFetcher) {
-		return
-	}
-
-	_, slot, ok := shared.UintFromRoute(w, r, "slot")
-	if !ok {
-		return
-	}
-
-	headRoot, err := s.HeadFetcher.HeadRoot(ctx)
-	if err != nil {
-		httputil.HandleError(w, "Could not get head root: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-
-	// TODO: Determine payload_present and blob_data_available from the SignedExecutionPayloadEnvelope
-	// once that handling is implemented. For now, stub with false.
-	payloadPresent := false
-	blobDataAvailable := false
-
-	data := &ethpbalpha.PayloadAttestationData{
-		BeaconBlockRoot:   headRoot,
-		Slot:              primitives.Slot(slot),
-		PayloadPresent:    payloadPresent,
-		BlobDataAvailable: blobDataAvailable,
-	}
-
-	if httputil.RespondWithSsz(r) {
-		sszData, err := data.MarshalSSZ()
-		if err != nil {
-			httputil.HandleError(w, "Could not marshal payload attestation data: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		w.Header().Set(api.VersionHeader, version.String(version.Gloas))
-		httputil.WriteSsz(w, sszData)
-		return
-	}
-
-	response := &structs.GetPayloadAttestationDataResponse{
-		Version: version.String(version.Gloas),
-		Data:    structs.PayloadAttestationDataFromConsensus(data),
-	}
-	w.Header().Set(api.VersionHeader, version.String(version.Gloas))
-	httputil.WriteJson(w, response)
-}

beacon-chain/rpc/eth/validator/server.go

@@ -7,7 +7,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/operation"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/attestations"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/payloadattestation"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/synccommittee"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/p2p"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/rpc/core"
@@ -39,5 +38,4 @@ type Server struct {
 	BlockRewardFetcher     rewards.BlockRewardsFetcher
 	TrackedValidatorsCache *cache.TrackedValidatorsCache
 	PayloadIDCache         *cache.PayloadIDCache
-	PayloadAttestationPool payloadattestation.PoolManager
 }

beacon-chain/rpc/service.go

@@ -22,7 +22,6 @@ import (
 	lightClient "github.com/OffchainLabs/prysm/v7/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/blstoexec"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/payloadattestation"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/slashings"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/synccommittee"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/operations/voluntaryexits"
@@ -104,7 +103,6 @@ type Config struct {
 	SlashingsPool             slashings.PoolManager
 	SyncCommitteeObjectPool   synccommittee.Pool
 	BLSChangesPool            blstoexec.PoolManager
-	PayloadAttestationPool    payloadattestation.PoolManager
 	SyncService               chainSync.Checker
 	Broadcaster               p2p.Broadcaster
 	PeersFetcher              p2p.PeersProvider

changelog/james-prysm_deflake-evaluator.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- adding some short retries for some end to end evaluators in an attempt to deflake tests.

changelog/jtraglia-add-specrefs-readme.md

@@ -0,0 +1,3 @@
+### Added
+
+- Added README for maintaining specrefs.

changelog/jtraglia-nightly-reftests-with-run-id.md

@@ -0,0 +1,3 @@
+### Added
+
+- The ability to download the nightly reference tests from a specific day.

specrefs/README.md

@@ -0,0 +1,35 @@
+# Specification References
+
+This directory contains specification reference tracking files managed by
+[ethspecify](https://github.com/jtraglia/ethspecify).
+
+## Installation
+
+Install `ethspecify` with the following command:
+
+```bash
+pipx install ethspecify
+```
+
+> [!NOTE]
+> You can run `ethspecify <cmd>` in the `specrefs` directory or
+> `ethspecify <cmd> --path=specrefs` from the project's root directory.
+
+## Maintenance
+
+When adding support for a new specification version, follow these steps:
+
+0. Change directory into the `specrefs` directory.
+1. Update the version in `.ethspecify.yml` configuration.
+2. Run `ethspecify process` to update/populate specrefs.
+3. Run `ethspecify check` to check specrefs.
+4. If there are errors, use the error message as a guide to fix the issue. If
+   there are new specrefs with empty sources, implement/locate each item and
+   update each specref source list. If you choose not to implement an item,
+   add an exception to the appropriate section the the `.ethspecify.yml`
+   configuration.
+5. Repeat steps 3 and 4 until `ethspecify check` passes.
+6. Run `git diff` to view updated specrefs. If an object/function/etc has
+   changed, make the necessary updates to the implementation.
+7. Lastly, in the project's root directory, run `act -j check-specrefs` to
+   ensure everything is correct.

testing/endtoend/components/eth1/transactions.go

@@ -40,6 +40,7 @@ type TransactionGenerator struct {
 	cancel        context.CancelFunc
 	paused        bool
 	useLargeBlobs bool // Use large blob transactions (6 blobs per tx) for BPO testing
+	blobTxCount   int  // Number of blob transactions per slot (0 means default of 5)
 }
 
 func (t *TransactionGenerator) UnderlyingProcess() *os.Process {
@@ -48,8 +49,8 @@ func (t *TransactionGenerator) UnderlyingProcess() *os.Process {
 	return &os.Process{}
 }
 
-func NewTransactionGenerator(keystore string, seed int64, useLargeBlobs bool) *TransactionGenerator {
-	return &TransactionGenerator{keystore: keystore, seed: seed, useLargeBlobs: useLargeBlobs}
+func NewTransactionGenerator(keystore string, seed int64, useLargeBlobs bool, blobTxCount int) *TransactionGenerator {
+	return &TransactionGenerator{keystore: keystore, seed: seed, useLargeBlobs: useLargeBlobs, blobTxCount: blobTxCount}
 }
 
 func (t *TransactionGenerator) Start(ctx context.Context) error {
@@ -114,7 +115,7 @@ func (t *TransactionGenerator) Start(ctx context.Context) error {
 				continue
 			}
 			backend := ethclient.NewClient(client)
-			err = SendTransaction(client, mineKey.PrivateKey, gasPrice, mineKey.Address.String(), txCount, backend, false, t.useLargeBlobs)
+			err = SendTransaction(client, mineKey.PrivateKey, gasPrice, mineKey.Address.String(), txCount, backend, false, t.useLargeBlobs, t.blobTxCount)
 			if err != nil {
 				return err
 			}
@@ -128,7 +129,7 @@ func (s *TransactionGenerator) Started() <-chan struct{} {
 	return s.started
 }
 
-func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.Int, addr string, txCount uint64, backend *ethclient.Client, al bool, useLargeBlobs bool) error {
+func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.Int, addr string, txCount uint64, backend *ethclient.Client, al bool, useLargeBlobs bool, blobTxCount int) error {
 	sender := common.HexToAddress(addr)
 	nonce, err := backend.PendingNonceAt(context.Background(), fundedAccount.Address)
 	if err != nil {
@@ -150,14 +151,19 @@ func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.In
 	clock := startup.NewClock(e2e.TestParams.CLGenesisTime, [32]byte{})
 	isPostFulu := clock.CurrentEpoch() >= params.BeaconConfig().FuluForkEpoch
 
+	// Default to 5 blob transactions per slot if not configured.
+	numBlobTxs := blobTxCount
+	if numBlobTxs <= 0 {
+		numBlobTxs = 5
+	}
+
 	g, _ := errgroup.WithContext(context.Background())
-	txs := make([]*types.Transaction, 10)
+	txs := make([]*types.Transaction, numBlobTxs)
 
 	// Send blob transactions - use different versions pre/post Fulu
 	if isPostFulu {
 		logrus.Info("Sending blob transactions with cell proofs")
-		// Reduced from 10 to 5 to reduce load and prevent builder/EL timeouts
-		for index := range uint64(5) {
+		for index := range uint64(numBlobTxs) {
 
 			g.Go(func() error {
 				tx, err := RandomBlobCellTx(client, fundedAccount.Address, nonce+index, gasPrice, chainid, al, useLargeBlobs)
@@ -176,8 +182,7 @@ func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, gasPrice *big.In
 		}
 	} else {
 		logrus.Info("Sending blob transactions with sidecars")
-		// Reduced from 10 to 5 to reduce load and prevent builder/EL timeouts
-		for index := range uint64(5) {
+		for index := range uint64(numBlobTxs) {
 
 			g.Go(func() error {
 				tx, err := RandomBlobTx(client, fundedAccount.Address, nonce+index, gasPrice, chainid, al, useLargeBlobs)

testing/endtoend/endtoend_test.go

@@ -225,9 +225,9 @@ func (r *testRunner) testDepositsAndTx(ctx context.Context, g *errgroup.Group,
 		if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{r.depositor}); err != nil {
 			return errors.Wrap(err, "testDepositsAndTx unable to run, depositor did not Start")
 		}
-        go func() {
-            if r.config.TestDeposits {
-                log.Info("Running deposit tests")
+		go func() {
+			if r.config.TestDeposits {
+				log.Info("Running deposit tests")
 				// The validators with an index < minGenesisActiveCount all have deposits already from the chain start.
 				// Skip all of those chain start validators by seeking to minGenesisActiveCount in the validator list
 				// for further deposit testing.
@@ -238,12 +238,12 @@ func (r *testRunner) testDepositsAndTx(ctx context.Context, g *errgroup.Group,
 						r.t.Error(errors.Wrap(err, "depositor.SendAndMine failed"))
 					}
 				}
-            }
-            // Only generate background transactions when relevant for the test.
-            if r.config.TestDeposits || r.config.TestFeature || r.config.UseBuilder {
-                r.testTxGeneration(ctx, g, keystorePath, []e2etypes.ComponentRunner{})
-            }
-        }()
+			}
+			// Only generate background transactions when relevant for the test.
+			if r.config.TestDeposits || r.config.TestFeature || r.config.UseBuilder {
+				r.testTxGeneration(ctx, g, keystorePath, []e2etypes.ComponentRunner{})
+			}
+		}()
 		if r.config.TestDeposits {
 			return depositCheckValidator.Start(ctx)
 		}
@@ -252,7 +252,7 @@ func (r *testRunner) testDepositsAndTx(ctx context.Context, g *errgroup.Group,
 }
 
 func (r *testRunner) testTxGeneration(ctx context.Context, g *errgroup.Group, keystorePath string, requiredNodes []e2etypes.ComponentRunner) {
-	txGenerator := eth1.NewTransactionGenerator(keystorePath, r.config.Seed, r.config.UseLargeBlobs)
+	txGenerator := eth1.NewTransactionGenerator(keystorePath, r.config.Seed, r.config.UseLargeBlobs, r.config.BlobTxCount)
 	r.comHandler.txGen = txGenerator
 	g.Go(func() error {
 		if err := helpers.ComponentsStarted(ctx, requiredNodes); err != nil {

testing/endtoend/evaluators/node.go

@@ -156,19 +156,9 @@ func waitForMidEpoch(conn *grpc.ClientConn) error {
 	}
 }
 
-func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) error {
-	// Wait until we're at least halfway into the epoch to avoid race conditions
-	// at epoch boundaries where nodes may report different epochs.
-	if err := waitForMidEpoch(conns[0]); err != nil {
-		return errors.Wrap(err, "failed waiting for mid-epoch")
-	}
-
-	headEpochs := make([]primitives.Epoch, len(conns))
-	headBlockRoots := make([][]byte, len(conns))
-	justifiedRoots := make([][]byte, len(conns))
-	prevJustifiedRoots := make([][]byte, len(conns))
-	finalizedRoots := make([][]byte, len(conns))
-	chainHeads := make([]*eth.ChainHead, len(conns))
+// getHeadEpochs fetches the head epoch from all beacon nodes concurrently.
+func getHeadEpochs(conns []*grpc.ClientConn) ([]primitives.Epoch, error) {
+	epochs := make([]primitives.Epoch, len(conns))
 	g, _ := errgroup.WithContext(context.Background())
 
 	for i, conn := range conns {
@@ -180,63 +170,145 @@ func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientCo
 			if err != nil {
 				return errors.Wrapf(err, "connection number=%d", conIdx)
 			}
-			headEpochs[conIdx] = chainHead.HeadEpoch
-			headBlockRoots[conIdx] = chainHead.HeadBlockRoot
-			justifiedRoots[conIdx] = chainHead.JustifiedBlockRoot
-			prevJustifiedRoots[conIdx] = chainHead.PreviousJustifiedBlockRoot
-			finalizedRoots[conIdx] = chainHead.FinalizedBlockRoot
-			chainHeads[conIdx] = chainHead
+			epochs[conIdx] = chainHead.HeadEpoch
 			return nil
 		})
 	}
 	if err := g.Wait(); err != nil {
-		return err
+		return nil, err
 	}
-
-	for i := range conns {
-		if headEpochs[0] != headEpochs[i] {
-			return fmt.Errorf(
-				"received conflicting head epochs on node %d, expected %d, received %d",
-				i,
-				headEpochs[0],
-				headEpochs[i],
-			)
-		}
-		if !bytes.Equal(headBlockRoots[0], headBlockRoots[i]) {
-			return fmt.Errorf(
-				"received conflicting head block roots on node %d, expected %#x, received %#x",
-				i,
-				headBlockRoots[0],
-				headBlockRoots[i],
-			)
-		}
-		if !bytes.Equal(justifiedRoots[0], justifiedRoots[i]) {
-			return fmt.Errorf(
-				"received conflicting justified block roots on node %d, expected %#x, received %#x: %s and %s",
-				i,
-				justifiedRoots[0],
-				justifiedRoots[i],
-				chainHeads[0].String(),
-				chainHeads[i].String(),
-			)
-		}
-		if !bytes.Equal(prevJustifiedRoots[0], prevJustifiedRoots[i]) {
-			return fmt.Errorf(
-				"received conflicting previous justified block roots on node %d, expected %#x, received %#x",
-				i,
-				prevJustifiedRoots[0],
-				prevJustifiedRoots[i],
-			)
-		}
-		if !bytes.Equal(finalizedRoots[0], finalizedRoots[i]) {
-			return fmt.Errorf(
-				"received conflicting finalized epoch roots on node %d, expected %#x, received %#x",
-				i,
-				finalizedRoots[0],
-				finalizedRoots[i],
-			)
-		}
-	}
-
-	return nil
+	return epochs, nil
+}
+
+func allNodesHaveSameHead(_ *e2etypes.EvaluationContext, conns ...*grpc.ClientConn) error {
+	// Wait until we're at least halfway into the epoch to avoid race conditions
+	// at epoch boundaries where nodes may report different epochs.
+	if err := waitForMidEpoch(conns[0]); err != nil {
+		return errors.Wrap(err, "failed waiting for mid-epoch")
+	}
+
+	// First, wait for all nodes to reach the same epoch. Sync nodes may be
+	// behind and need time to catch up. We poll every 2 seconds with a
+	// 60 second timeout - this adapts to actual sync progress rather than
+	// using fixed delays.
+	const epochTimeout = 60 * time.Second
+	const epochPollInterval = 2 * time.Second
+	epochDeadline := time.Now().Add(epochTimeout)
+
+	for time.Now().Before(epochDeadline) {
+		epochs, err := getHeadEpochs(conns)
+		if err != nil {
+			return err
+		}
+		allSame := true
+		for i := 1; i < len(epochs); i++ {
+			if epochs[0] != epochs[i] {
+				allSame = false
+				break
+			}
+		}
+		if allSame {
+			break
+		}
+		time.Sleep(epochPollInterval)
+	}
+
+	// Now that epochs match (or timeout reached), do detailed head comparison
+	// with a few retries to handle block propagation delays.
+	const maxRetries = 5
+	const retryDelay = 1 * time.Second
+	var lastErr error
+
+	for attempt := range maxRetries {
+		if attempt > 0 {
+			time.Sleep(retryDelay)
+		}
+
+		headEpochs := make([]primitives.Epoch, len(conns))
+		headBlockRoots := make([][]byte, len(conns))
+		justifiedRoots := make([][]byte, len(conns))
+		prevJustifiedRoots := make([][]byte, len(conns))
+		finalizedRoots := make([][]byte, len(conns))
+		chainHeads := make([]*eth.ChainHead, len(conns))
+		g, _ := errgroup.WithContext(context.Background())
+
+		for i, conn := range conns {
+			conIdx := i
+			currConn := conn
+			g.Go(func() error {
+				beaconClient := eth.NewBeaconChainClient(currConn)
+				chainHead, err := beaconClient.GetChainHead(context.Background(), &emptypb.Empty{})
+				if err != nil {
+					return errors.Wrapf(err, "connection number=%d", conIdx)
+				}
+				headEpochs[conIdx] = chainHead.HeadEpoch
+				headBlockRoots[conIdx] = chainHead.HeadBlockRoot
+				justifiedRoots[conIdx] = chainHead.JustifiedBlockRoot
+				prevJustifiedRoots[conIdx] = chainHead.PreviousJustifiedBlockRoot
+				finalizedRoots[conIdx] = chainHead.FinalizedBlockRoot
+				chainHeads[conIdx] = chainHead
+				return nil
+			})
+		}
+		if err := g.Wait(); err != nil {
+			return err
+		}
+
+		lastErr = nil
+		for i := range conns {
+			if headEpochs[0] != headEpochs[i] {
+				lastErr = fmt.Errorf(
+					"received conflicting head epochs on node %d, expected %d, received %d",
+					i,
+					headEpochs[0],
+					headEpochs[i],
+				)
+				break
+			}
+			if !bytes.Equal(headBlockRoots[0], headBlockRoots[i]) {
+				lastErr = fmt.Errorf(
+					"received conflicting head block roots on node %d, expected %#x, received %#x",
+					i,
+					headBlockRoots[0],
+					headBlockRoots[i],
+				)
+				break
+			}
+			if !bytes.Equal(justifiedRoots[0], justifiedRoots[i]) {
+				lastErr = fmt.Errorf(
+					"received conflicting justified block roots on node %d, expected %#x, received %#x: %s and %s",
+					i,
+					justifiedRoots[0],
+					justifiedRoots[i],
+					chainHeads[0].String(),
+					chainHeads[i].String(),
+				)
+				break
+			}
+			if !bytes.Equal(prevJustifiedRoots[0], prevJustifiedRoots[i]) {
+				lastErr = fmt.Errorf(
+					"received conflicting previous justified block roots on node %d, expected %#x, received %#x",
+					i,
+					prevJustifiedRoots[0],
+					prevJustifiedRoots[i],
+				)
+				break
+			}
+			if !bytes.Equal(finalizedRoots[0], finalizedRoots[i]) {
+				lastErr = fmt.Errorf(
+					"received conflicting finalized epoch roots on node %d, expected %#x, received %#x",
+					i,
+					finalizedRoots[0],
+					finalizedRoots[i],
+				)
+				break
+			}
+		}
+
+		if lastErr == nil {
+			return nil
+		}
+	}
+
+	return lastErr
 }

testing/endtoend/evaluators/validator.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"net/http"
 	"strconv"
+	"time"
 
 	"github.com/OffchainLabs/prysm/v7/api/server/structs"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/altair"
@@ -123,6 +124,25 @@ func validatorsAreActive(ec *types.EvaluationContext, conns ...*grpc.ClientConn)
 
 // validatorsParticipating ensures the validators have an acceptable participation rate.
 func validatorsParticipating(_ *types.EvaluationContext, conns ...*grpc.ClientConn) error {
+	// Retry up to 3 times with 2 second delays to handle timing flakes where
+	// attestations haven't been fully processed yet due to block propagation delays.
+	const maxRetries = 3
+	const retryDelay = 2 * time.Second
+	var lastErr error
+
+	for attempt := range maxRetries {
+		if attempt > 0 {
+			time.Sleep(retryDelay)
+		}
+		lastErr = checkValidatorsParticipating(conns)
+		if lastErr == nil {
+			return nil
+		}
+	}
+	return lastErr
+}
+
+func checkValidatorsParticipating(conns []*grpc.ClientConn) error {
 	conn := conns[0]
 	client := ethpb.NewBeaconChainClient(conn)
 	validatorRequest := &ethpb.GetValidatorParticipationRequest{}
@@ -234,6 +254,25 @@ func validatorsParticipating(_ *types.EvaluationContext, conns ...*grpc.ClientCo
 // validatorsSyncParticipation ensures the validators have an acceptable participation rate for
 // sync committee assignments.
 func validatorsSyncParticipation(_ *types.EvaluationContext, conns ...*grpc.ClientConn) error {
+	// Retry up to 3 times with 2 second delays to handle timing flakes where
+	// sync committee messages haven't fully propagated yet.
+	const maxRetries = 3
+	const retryDelay = 2 * time.Second
+	var lastErr error
+
+	for attempt := range maxRetries {
+		if attempt > 0 {
+			time.Sleep(retryDelay)
+		}
+		lastErr = checkSyncParticipation(conns)
+		if lastErr == nil {
+			return nil
+		}
+	}
+	return lastErr
+}
+
+func checkSyncParticipation(conns []*grpc.ClientConn) error {
 	conn := conns[0]
 	client := ethpb.NewNodeClient(conn)
 	altairClient := ethpb.NewBeaconChainClient(conn)
@@ -272,9 +311,9 @@ func validatorsSyncParticipation(_ *types.EvaluationContext, conns ...*grpc.Clie
 			// Skip fork slot.
 			continue
 		}
-		// Skip slots 1-2 at genesis - validators need time to ramp up after chain start
+		// Skip early slots at genesis - validators need time to ramp up after chain start
 		// due to doppelganger protection. This is a startup timing issue, not a fork transition issue.
-		if b.Block().Slot() < 3 {
+		if b.Block().Slot() < 5 {
 			continue
 		}
 		expectedParticipation := expectedSyncParticipation
@@ -289,6 +328,11 @@ func validatorsSyncParticipation(_ *types.EvaluationContext, conns ...*grpc.Clie
 		if err != nil {
 			return err
 		}
+		// Skip blocks with zero sync bits - these are typically empty/anomalous blocks
+		// where the proposer didn't receive sync committee contributions in time.
+		if syncAgg.SyncCommitteeBits.Count() == 0 {
+			continue
+		}
 		threshold := uint64(float64(syncAgg.SyncCommitteeBits.Len()) * expectedParticipation)
 		if syncAgg.SyncCommitteeBits.Count() < threshold {
 			return errors.Errorf("In block of slot %d ,the aggregate bitvector with length of %d only got a count of %d", b.Block().Slot(), threshold, syncAgg.SyncCommitteeBits.Count())
@@ -343,6 +387,11 @@ func validatorsSyncParticipation(_ *types.EvaluationContext, conns ...*grpc.Clie
 		if err != nil {
 			return err
 		}
+		// Skip blocks with zero sync bits - these are typically empty/anomalous blocks
+		// where the proposer didn't receive sync committee contributions in time.
+		if syncAgg.SyncCommitteeBits.Count() == 0 {
+			continue
+		}
 		threshold := uint64(float64(syncAgg.SyncCommitteeBits.Len()) * expectedSyncParticipation)
 		if syncAgg.SyncCommitteeBits.Count() < threshold {
 			return errors.Errorf("In block of slot %d ,the aggregate bitvector with length of %d only got a count of %d", b.Block().Slot(), threshold, syncAgg.SyncCommitteeBits.Count())

testing/endtoend/minimal_builder_e2e_test.go

@@ -9,11 +9,11 @@ import (
 )
 
 func TestEndToEnd_MinimalConfig_WithBuilder(t *testing.T) {
-	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder())
+	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder(), types.WithBlobTxCount(2))
 	r.run()
 }
 
 func TestEndToEnd_MinimalConfig_WithBuilder_ValidatorRESTApi(t *testing.T) {
-	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder(), types.WithValidatorRESTApi())
+	r := e2eMinimal(t, types.InitForkCfg(version.Bellatrix, version.Electra, params.E2ETestConfig()), types.WithCheckpointSync(), types.WithBuilder(), types.WithValidatorRESTApi(), types.WithBlobTxCount(2))
 	r.run()
 }

testing/endtoend/types/types.go

@@ -68,6 +68,14 @@ func WithLargeBlobs() E2EConfigOpt {
 	}
 }
 
+// WithBlobTxCount sets the number of blob transactions sent per slot.
+// Default is 5 when not specified.
+func WithBlobTxCount(n int) E2EConfigOpt {
+	return func(cfg *E2EConfig) {
+		cfg.BlobTxCount = n
+	}
+}
+
 func WithSSZOnly() E2EConfigOpt {
 	return func(cfg *E2EConfig) {
 		if err := os.Setenv(params.EnvNameOverrideAccept, api.OctetStreamMediaType); err != nil {
@@ -108,6 +116,7 @@ type E2EConfig struct {
 	UseBeaconRestApi        bool
 	UseBuilder              bool
 	UseLargeBlobs           bool // Use large blob transactions (6 blobs per tx) for BPO testing
+	BlobTxCount             int  // Number of blob transactions per slot (0 means default of 5)
 	EpochsToRun             uint64
 	ExitEpoch               primitives.Epoch // Custom epoch for voluntary exit submission (0 means use default)
 	Seed                    int64

testing/spectest/README.md

@@ -21,10 +21,14 @@ There are tests for mainnet and minimal config, so for each config we will add a
 
 ## Running nightly spectests
 
-Since [PR 15312](https://github.com/OffchainLabs/prysm/pull/15312), Prysm has support to download "nightly" spectests from github via a starlark rule configuration by environment variable. 
-Set `--repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly` when running spectest to download the "nightly" spectests. 
-Note: A GITHUB_TOKEN environment variable is required to be set. The github token must be a [fine grained token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-fine-grained-personal-access-token).
+Since [PR 15312](https://github.com/OffchainLabs/prysm/pull/15312), Prysm has support to download "nightly" spectests from github via a starlark rule configuration by environment variable.
+Set `--repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly` or `--repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly-<run_id>` when running spectest to download the "nightly" spectests.
+Note: A GITHUB_TOKEN environment variable is required to be set. The github token does not need to be associated with your main account; it can be from a "burner account". And the token does not need to be a fine-grained token; it can be a classic token.
 
 ```
 bazel test //... --test_tag_filters=spectest --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly
 ```
+
+```
+bazel test //... --test_tag_filters=spectest --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly-21422848633
+```

tools/download_spectests.bzl

@@ -1,5 +1,6 @@
 # bazel build @consensus_spec_tests//:test_data
 # bazel build @consensus_spec_tests//:test_data --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly
+# bazel build @consensus_spec_tests//:test_data --repo_env=CONSENSUS_SPEC_TESTS_VERSION=nightly-<run_id>
 
 def _get_redirected_url(repository_ctx, url, headers):
     if not repository_ctx.which("curl"):
@@ -24,7 +25,7 @@ def _impl(repository_ctx):
     version = repository_ctx.getenv("CONSENSUS_SPEC_TESTS_VERSION") or repository_ctx.attr.version
     token = repository_ctx.getenv("GITHUB_TOKEN") or ""
 
-    if version == "nightly":
+    if version == "nightly" or version.startswith("nightly-"):
         print("Downloading nightly tests")
         if not token:
             fail("Error GITHUB_TOKEN is not set")
@@ -34,16 +35,22 @@ def _impl(repository_ctx):
             "Accept": "application/vnd.github+json",
         }
 
-        repository_ctx.download(
-            "https://api.github.com/repos/%s/actions/workflows/%s/runs?branch=%s&status=success&per_page=1"
-                % (repository_ctx.attr.repo, repository_ctx.attr.workflow, repository_ctx.attr.branch),
-            headers = headers,
-            output = "runs.json"
-        )
+        if version.startswith("nightly-"):
+            run_id = version.split("nightly-", 1)[1]
+            if not run_id:
+                fail("Error invalid run id")
+        else:
+            repository_ctx.download(
+                "https://api.github.com/repos/%s/actions/workflows/%s/runs?branch=%s&status=success&per_page=1"
+                    % (repository_ctx.attr.repo, repository_ctx.attr.workflow, repository_ctx.attr.branch),
+                headers = headers,
+                output = "runs.json"
+            )
 
-        run_id = json.decode(repository_ctx.read("runs.json"))["workflow_runs"][0]["id"]
-        repository_ctx.delete("runs.json")
+            run_id = json.decode(repository_ctx.read("runs.json"))["workflow_runs"][0]["id"]
+            repository_ctx.delete("runs.json")
 
+        print("Run id:", run_id)
         repository_ctx.download(
             "https://api.github.com/repos/%s/actions/runs/%s/artifacts"
                 % (repository_ctx.attr.repo, run_id),
@@ -108,8 +115,8 @@ consensus_spec_tests = repository_rule(
         "version": attr.string(mandatory = True),
         "flavors": attr.string_dict(mandatory = True),
         "repo": attr.string(default = "ethereum/consensus-specs"),
-        "workflow": attr.string(default = "generate_vectors.yml"),
-        "branch": attr.string(default = "dev"),
+        "workflow": attr.string(default = "nightly-reftests.yml"),
+        "branch": attr.string(default = "master"),
         "release_url_template": attr.string(default = "https://github.com/ethereum/consensus-specs/releases/download/%s"),
     },
 )