wip

api/server/structs/block.go

@@ -540,6 +540,12 @@ 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,3 +3263,34 @@ 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,6 +188,11 @@ 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,6 +31,11 @@ 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,6 +37,7 @@ 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,6 +40,7 @@ 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"
@@ -101,6 +102,7 @@ type BeaconNode struct {
 	slashingsPool            slashings.PoolManager
 	syncCommitteePool        synccommittee.Pool
 	blsToExecPool            blstoexec.PoolManager
+	payloadAttestationPool   payloadattestation.PoolManager
 	depositCache             cache.DepositCache
 	trackedValidatorsCache   *cache.TrackedValidatorsCache
 	payloadIDCache           *cache.PayloadIDCache
@@ -155,6 +157,7 @@ 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),
@@ -972,6 +975,7 @@ 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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,201 @@
+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,6 +26,7 @@ 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,6 +217,7 @@ func (s *Service) validatorEndpoints(
 		OperationNotifier:      s.cfg.OperationNotifier,
 		TrackedValidatorsCache: s.cfg.TrackedValidatorsCache,
 		PayloadIDCache:         s.cfg.PayloadIDCache,
+		PayloadAttestationPool: s.cfg.PayloadAttestationPool,
 		CoreService:            coreService,
 		BlockRewardFetcher:     rewardFetcher,
 	}
@@ -390,6 +391,16 @@ 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},
+		},
 	}
 }
 
@@ -512,6 +523,7 @@ 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,
@@ -869,6 +881,27 @@ 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,6 +48,7 @@ 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},
 	}
 
@@ -91,22 +92,23 @@ 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/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},
 	}
 
 	prysmBeaconRoutes := map[string][]string{

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

@@ -32,6 +32,7 @@ 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,3 +893,89 @@ 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,6 +12,7 @@ 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"
@@ -48,6 +49,7 @@ 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,6 +21,7 @@ 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,3 +1427,54 @@ 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,6 +7,7 @@ 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"
@@ -38,4 +39,5 @@ type Server struct {
 	BlockRewardFetcher     rewards.BlockRewardsFetcher
 	TrackedValidatorsCache *cache.TrackedValidatorsCache
 	PayloadIDCache         *cache.PayloadIDCache
+	PayloadAttestationPool payloadattestation.PoolManager
 }

beacon-chain/rpc/service.go

@@ -22,6 +22,7 @@ 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"
@@ -103,6 +104,7 @@ 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/jtraglia-add-specrefs-readme.md

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

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

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

changelog/syjn99_docs-ssz-ql.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- Add handy documentation for SSZ Query package (`encoding/ssz/query`).

encoding/ssz/query/doc.md

@@ -1,190 +0,0 @@
-# SSZ Query Package
-
-The `encoding/ssz/query` package provides a system for analyzing and querying SSZ ([Simple Serialize](https://github.com/ethereum/consensus-specs/blob/master/ssz/simple-serialize.md)) data structures, as well as generating Merkle proofs from them. It enables runtime analysis of SSZ-serialized Go objects with reflection, path-based queries through nested structures, generalized index calculation, and Merkle proof generation.
-
-This package is designed to be generic. It operates on arbitrary SSZ-serialized Go values at runtime, so the same query/proof machinery applies equally to any SSZ type, including the BeaconState/BeaconBlock.
-
-## Usage Example
-
-```go
-// 1. Analyze an SSZ object
-block := &ethpb.BeaconBlock{...}
-info, err := query.AnalyzeObject(block)
-
-// 2. Parse a path
-path, err := query.ParsePath(".body.attestations[0].data.slot")
-
-// 3. Get the generalized index
-gindex, err := query.GetGeneralizedIndexFromPath(info, path)
-
-// 4. Generate a Merkle proof
-proof, err := info.Prove(gindex)
-
-// 5. Get offset and length to slice the SSZ-encoded bytes
-sszBytes, _ := block.MarshalSSZ()
-_, offset, length, err := query.CalculateOffsetAndLength(info, path)
-// slotBytes contains the SSZ-encoded value at the queried path
-slotBytes := sszBytes[offset : offset+length]
-```
-
-## Exported API
-
-The main exported API consists of:
-
-```go
-// AnalyzeObject analyzes an SSZ object and returns its structural information
-func AnalyzeObject(obj SSZObject) (*SszInfo, error)
-
-// ParsePath parses a path string like ".field1.field2[0].field3"
-func ParsePath(rawPath string) (Path, error)
-
-// CalculateOffsetAndLength computes byte offset and length for a path within an SSZ object
-func CalculateOffsetAndLength(sszInfo *SszInfo, path Path) (*SszInfo, uint64, uint64, error)
-
-// GetGeneralizedIndexFromPath calculates the generalized index for a given path
-func GetGeneralizedIndexFromPath(info *SszInfo, path Path) (uint64, error)
-
-// Prove generates a Merkle proof for a target generalized index
-func (s *SszInfo) Prove(gindex uint64) (*fastssz.Proof, error)
-```
-
-## Type System
-
-### SSZ Types
-
-The package now supports [all standard SSZ types](https://github.com/ethereum/consensus-specs/blob/master/ssz/simple-serialize.md#typing) except `ProgressiveList`, `ProgressiveContainer`, `ProgressiveBitlist`, `Union`, and `CompatibleUnion`.
-
-### Core Data Structures
-
-#### `SszInfo`
-
-The `SszInfo` structure contains complete structural metadata for an SSZ type:
-
-```go
-type SszInfo struct {
-   sszType       SszType           // SSZ Type classification
-   typ           reflect.Type      // Go reflect.Type
-   source        SSZObject         // Original SSZObject reference. Mostly used for reusing SSZ methods like `HashTreeRoot`.
-   isVariable    bool              // True if contains variable-size fields
-
-   // Composite types have corresponding metadata. Other fields would be nil except for the current type.
-   containerInfo *containerInfo
-   listInfo      *listInfo
-   vectorInfo    *vectorInfo
-   bitlistInfo   *bitlistInfo
-   bitvectorInfo *bitvectorInfo
-}
-```
-
-#### `Path`
-
-The `Path` structure represents navigation paths through SSZ structures. It supports accessing a field by field name, accessing an element by index (list/vector type), and finding the length of homogenous collection types. The `ParsePath` function parses a raw string into a `Path` instance, which is commonly used in other APIs like `CalculateOffsetAndLength` and `GetGeneralizedIndexFromPath`.
-
-```go
-type Path struct {
-   Length   bool           // Flag for length queries (e.g., len(.field))
-   Elements []PathElement  // Sequence of field accesses and indices
-}
-
-type PathElement struct {
-   Name  string  // Field name
-   Index *uint64 // list/vector index (nil if not an index access)
-}
-```
-
-## Implementation Details
-
-### Type Analysis (`analyzer.go`)
-
-The `AnalyzeObject` function performs recursive type introspection using Go reflection:
-
-1. **Type Inspection** - Examines Go `reflect.Value` to determine SSZ type
-   - Basic types (`uint8`, `uint16`, `uint32`, `uint64`, `bool`): `SSZType` constants
-   - Slices: Determined from struct tags (`ssz-size` for vectors, `ssz-max` for lists). There is a related [write-up](https://hackmd.io/@junsong/H101DKnwxl) regarding struct tags.
-   - Structs: Analyzed as Containers with field ordering from JSON tags
-   - Pointers: Dereferenced automatically
-
-2. **Variable-Length Population** - Determines actual sizes at runtime
-   - For lists: Iterates elements, caches sizes for variable-element lists
-   - For containers: Recursively populates variable fields, adjusts offsets
-   - For bitlists: Decodes bit length from bitvector
-
-3. **Offset Calculation** - Computes byte positions within serialized data
-   - Fixed-size fields: Offset = sum of preceding field sizes
-   - Variable-size fields: Offset stored as 4-byte pointer entries
-
-### Path Parsing (`path.go`)
-
-The `ParsePath` function parses path strings with the following rules:
-
-- **Dot notation**: `.field1.field2` for field access
-- **Array indexing**: `[0]`, `[42]` for element access
-- **Length queries**: `len(.field)` for list/vector lengths
-- **Character set**: Only `[A-Za-z0-9._\[\]\(\)]` allowed
-
-Example:
-```go
-path, _ := ParsePath(".nested.array_field[5].inner_field")
-// Returns: Path{
-//   Elements: [
-//     PathElement{Name: "nested"},
-//     PathElement{Name: "array_field", Index: <Pointer to uint64(5)>},
-//     PathElement{Name: "inner_field"}
-//   ]
-// }
-```
-
-### Generalized Index Calculation (`generalized_index.go`)
-
-The generalized index is a tree position identifier. This package follows the [Ethereum consensus-specs](https://github.com/ethereum/consensus-specs/blob/master/ssz/merkle-proofs.md#generalized-merkle-tree-index) to calculate the generalized index.
-
-### Merkle Proof Generation (`merkle_proof.go`, `proof_collector.go`)
-
-The `Prove` method generates Merkle proofs using a single-sweep merkleization algorithm:
-
-#### Algorithm Overview
-
-**Key Terms:**
-
-- **Target gindex** (generalized index): The position of the SSZ element you want to prove, expressed as a generalized Merkle tree index. Stored in `Proof.Index`.
-  - Note: The generalized index for root is 1.
-- **Registered gindices**: The set of tree positions whose node hashes must be captured during merkleization in order to later assemble the proof.
-- **Sibling node**: The node that shares the same parent as another node.
-- **Leaf value**: The 32-byte hash of the target node (the node being proven). Stored in `Proof.Leaf`.
-
-**Phases:**
-
-1. **Registration Phase** (`addTarget`)
-> Goal: determine exactly which sibling hashes are needed for the proof.
-
-   - Record the target gindex as the proof target.
-   - Starting from the target node, walk the Merkle tree from the leaf (target gindex) to the root (gindex = 1).
-   - At each step:
-     - Compute and register the sibling gindex (`i XOR 1`) as “must collect”.
-     - Move to the parent (`i = i/2`).
-   - This produces the full set of registered gindices (the sibling nodes on the target-to-root path).
-
-2. **Merkleization Phase** (`merkleize`)
-> Goal: recursively merkleize the tree and capture the needed hashes.
-
-   - Recursively traverse the SSZ structure and compute Merkle tree node hashes from leaves to root.
-   - Whenever the traversal computes a node whose gindex is in registered gindices, store that node’s hash for later proof construction.
-
-3. **Proof Assembly Phase** (`toProof`)
-> Goal: create the final `fastssz.Proof` object in the correct format and order.
-
-```go
-// Proof represents a merkle proof against a general index.
-type Proof struct {
-	Index  int
-	Leaf   []byte
-	Hashes [][]byte
-}
-```
-
-   - Set `Proof.Index` to the target gindex.
-   - Set `Proof.Leaf` to the 32-byte hash of the target node.
-   - Build `Proof.Hashes` by walking from the target node up to (but not including) the root:
-     - At node `i`, append the stored hash for the sibling (`i XOR 1`).
-     - Move to the parent (`i = i/2`).
-   - The resulting `Proof.Hashes` is ordered from the target level upward, containing one sibling hash per tree level on the path to the root.

specrefs/README.md

@@ -1,35 +0,0 @@
-# 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/spectest/README.md

@@ -21,14 +21,10 @@ 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` 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.
+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).
 
 ```
 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,6 +1,5 @@
 # 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"):
@@ -25,7 +24,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" or version.startswith("nightly-"):
+    if version == "nightly":
         print("Downloading nightly tests")
         if not token:
             fail("Error GITHUB_TOKEN is not set")
@@ -35,22 +34,16 @@ def _impl(repository_ctx):
             "Accept": "application/vnd.github+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"
-            )
+        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),
@@ -115,8 +108,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 = "nightly-reftests.yml"),
-        "branch": attr.string(default = "master"),
+        "workflow": attr.string(default = "generate_vectors.yml"),
+        "branch": attr.string(default = "dev"),
         "release_url_template": attr.string(default = "https://github.com/ethereum/consensus-specs/releases/download/%s"),
     },
 )